compat.c 29.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 *  linux/kernel/compat.c
 *
 *  Kernel compatibililty routines for e.g. 32 bit syscall support
 *  on 64 bit kernels.
 *
 *  Copyright (C) 2002-2003 Stephen Rothwell, IBM Corporation
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 */

#include <linux/linkage.h>
#include <linux/compat.h>
#include <linux/errno.h>
#include <linux/time.h>
#include <linux/signal.h>
#include <linux/sched.h>	/* for MAX_SCHEDULE_TIMEOUT */
#include <linux/syscalls.h>
#include <linux/unistd.h>
#include <linux/security.h>
23
#include <linux/timex.h>
24
#include <linux/export.h>
25
#include <linux/migrate.h>
26
#include <linux/posix-timers.h>
27
#include <linux/times.h>
28
#include <linux/ptrace.h>
29
#include <linux/gfp.h>
L
Linus Torvalds 已提交
30 31 32

#include <asm/uaccess.h>

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
static int compat_get_timex(struct timex *txc, struct compat_timex __user *utp)
{
	memset(txc, 0, sizeof(struct timex));

	if (!access_ok(VERIFY_READ, utp, sizeof(struct compat_timex)) ||
			__get_user(txc->modes, &utp->modes) ||
			__get_user(txc->offset, &utp->offset) ||
			__get_user(txc->freq, &utp->freq) ||
			__get_user(txc->maxerror, &utp->maxerror) ||
			__get_user(txc->esterror, &utp->esterror) ||
			__get_user(txc->status, &utp->status) ||
			__get_user(txc->constant, &utp->constant) ||
			__get_user(txc->precision, &utp->precision) ||
			__get_user(txc->tolerance, &utp->tolerance) ||
			__get_user(txc->time.tv_sec, &utp->time.tv_sec) ||
			__get_user(txc->time.tv_usec, &utp->time.tv_usec) ||
			__get_user(txc->tick, &utp->tick) ||
			__get_user(txc->ppsfreq, &utp->ppsfreq) ||
			__get_user(txc->jitter, &utp->jitter) ||
			__get_user(txc->shift, &utp->shift) ||
			__get_user(txc->stabil, &utp->stabil) ||
			__get_user(txc->jitcnt, &utp->jitcnt) ||
			__get_user(txc->calcnt, &utp->calcnt) ||
			__get_user(txc->errcnt, &utp->errcnt) ||
			__get_user(txc->stbcnt, &utp->stbcnt))
		return -EFAULT;

	return 0;
}

static int compat_put_timex(struct compat_timex __user *utp, struct timex *txc)
{
	if (!access_ok(VERIFY_WRITE, utp, sizeof(struct compat_timex)) ||
			__put_user(txc->modes, &utp->modes) ||
			__put_user(txc->offset, &utp->offset) ||
			__put_user(txc->freq, &utp->freq) ||
			__put_user(txc->maxerror, &utp->maxerror) ||
			__put_user(txc->esterror, &utp->esterror) ||
			__put_user(txc->status, &utp->status) ||
			__put_user(txc->constant, &utp->constant) ||
			__put_user(txc->precision, &utp->precision) ||
			__put_user(txc->tolerance, &utp->tolerance) ||
			__put_user(txc->time.tv_sec, &utp->time.tv_sec) ||
			__put_user(txc->time.tv_usec, &utp->time.tv_usec) ||
			__put_user(txc->tick, &utp->tick) ||
			__put_user(txc->ppsfreq, &utp->ppsfreq) ||
			__put_user(txc->jitter, &utp->jitter) ||
			__put_user(txc->shift, &utp->shift) ||
			__put_user(txc->stabil, &utp->stabil) ||
			__put_user(txc->jitcnt, &utp->jitcnt) ||
			__put_user(txc->calcnt, &utp->calcnt) ||
			__put_user(txc->errcnt, &utp->errcnt) ||
			__put_user(txc->stbcnt, &utp->stbcnt) ||
			__put_user(txc->tai, &utp->tai))
		return -EFAULT;
	return 0;
}

91 92
COMPAT_SYSCALL_DEFINE2(gettimeofday, struct compat_timeval __user *, tv,
		       struct timezone __user *, tz)
93 94 95 96
{
	if (tv) {
		struct timeval ktv;
		do_gettimeofday(&ktv);
97
		if (compat_put_timeval(&ktv, tv))
98 99 100 101 102 103 104 105 106 107
			return -EFAULT;
	}
	if (tz) {
		if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
			return -EFAULT;
	}

	return 0;
}

108 109
COMPAT_SYSCALL_DEFINE2(settimeofday, struct compat_timeval __user *, tv,
		       struct timezone __user *, tz)
110
{
111 112 113
	struct timeval user_tv;
	struct timespec	new_ts;
	struct timezone new_tz;
114 115

	if (tv) {
116
		if (compat_get_timeval(&user_tv, tv))
117
			return -EFAULT;
118 119
		new_ts.tv_sec = user_tv.tv_sec;
		new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
120 121
	}
	if (tz) {
122
		if (copy_from_user(&new_tz, tz, sizeof(*tz)))
123 124 125
			return -EFAULT;
	}

126
	return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
127 128
}

129
static int __compat_get_timeval(struct timeval *tv, const struct compat_timeval __user *ctv)
130 131 132 133 134 135
{
	return (!access_ok(VERIFY_READ, ctv, sizeof(*ctv)) ||
			__get_user(tv->tv_sec, &ctv->tv_sec) ||
			__get_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0;
}

136
static int __compat_put_timeval(const struct timeval *tv, struct compat_timeval __user *ctv)
137 138 139 140 141 142
{
	return (!access_ok(VERIFY_WRITE, ctv, sizeof(*ctv)) ||
			__put_user(tv->tv_sec, &ctv->tv_sec) ||
			__put_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0;
}

143
static int __compat_get_timespec(struct timespec *ts, const struct compat_timespec __user *cts)
L
Linus Torvalds 已提交
144 145 146 147 148 149
{
	return (!access_ok(VERIFY_READ, cts, sizeof(*cts)) ||
			__get_user(ts->tv_sec, &cts->tv_sec) ||
			__get_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0;
}

150
static int __compat_put_timespec(const struct timespec *ts, struct compat_timespec __user *cts)
L
Linus Torvalds 已提交
151 152 153 154 155 156
{
	return (!access_ok(VERIFY_WRITE, cts, sizeof(*cts)) ||
			__put_user(ts->tv_sec, &cts->tv_sec) ||
			__put_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0;
}

157 158 159
int compat_get_timeval(struct timeval *tv, const void __user *utv)
{
	if (COMPAT_USE_64BIT_TIME)
160
		return copy_from_user(tv, utv, sizeof(*tv)) ? -EFAULT : 0;
161
	else
162
		return __compat_get_timeval(tv, utv);
163 164 165 166 167 168
}
EXPORT_SYMBOL_GPL(compat_get_timeval);

int compat_put_timeval(const struct timeval *tv, void __user *utv)
{
	if (COMPAT_USE_64BIT_TIME)
169
		return copy_to_user(utv, tv, sizeof(*tv)) ? -EFAULT : 0;
170
	else
171
		return __compat_put_timeval(tv, utv);
172 173 174 175 176 177
}
EXPORT_SYMBOL_GPL(compat_put_timeval);

int compat_get_timespec(struct timespec *ts, const void __user *uts)
{
	if (COMPAT_USE_64BIT_TIME)
178
		return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0;
179
	else
180
		return __compat_get_timespec(ts, uts);
181 182 183 184 185 186
}
EXPORT_SYMBOL_GPL(compat_get_timespec);

int compat_put_timespec(const struct timespec *ts, void __user *uts)
{
	if (COMPAT_USE_64BIT_TIME)
187
		return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0;
188
	else
189
		return __compat_put_timespec(ts, uts);
190 191 192
}
EXPORT_SYMBOL_GPL(compat_put_timespec);

193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
int compat_convert_timespec(struct timespec __user **kts,
			    const void __user *cts)
{
	struct timespec ts;
	struct timespec __user *uts;

	if (!cts || COMPAT_USE_64BIT_TIME) {
		*kts = (struct timespec __user *)cts;
		return 0;
	}

	uts = compat_alloc_user_space(sizeof(ts));
	if (!uts)
		return -EFAULT;
	if (compat_get_timespec(&ts, cts))
		return -EFAULT;
	if (copy_to_user(uts, &ts, sizeof(ts)))
		return -EFAULT;

	*kts = uts;
	return 0;
}

216 217 218 219 220 221 222
static long compat_nanosleep_restart(struct restart_block *restart)
{
	struct compat_timespec __user *rmtp;
	struct timespec rmt;
	mm_segment_t oldfs;
	long ret;

223
	restart->nanosleep.rmtp = (struct timespec __user *) &rmt;
224 225 226 227 228
	oldfs = get_fs();
	set_fs(KERNEL_DS);
	ret = hrtimer_nanosleep_restart(restart);
	set_fs(oldfs);

229
	if (ret == -ERESTART_RESTARTBLOCK) {
230
		rmtp = restart->nanosleep.compat_rmtp;
231

232
		if (rmtp && compat_put_timespec(&rmt, rmtp))
233 234 235 236 237 238
			return -EFAULT;
	}

	return ret;
}

239 240
COMPAT_SYSCALL_DEFINE2(nanosleep, struct compat_timespec __user *, rqtp,
		       struct compat_timespec __user *, rmtp)
L
Linus Torvalds 已提交
241
{
242
	struct timespec tu, rmt;
243
	mm_segment_t oldfs;
244
	long ret;
L
Linus Torvalds 已提交
245

246
	if (compat_get_timespec(&tu, rqtp))
L
Linus Torvalds 已提交
247 248
		return -EFAULT;

249
	if (!timespec_valid(&tu))
L
Linus Torvalds 已提交
250 251
		return -EINVAL;

252 253 254 255 256 257 258
	oldfs = get_fs();
	set_fs(KERNEL_DS);
	ret = hrtimer_nanosleep(&tu,
				rmtp ? (struct timespec __user *)&rmt : NULL,
				HRTIMER_MODE_REL, CLOCK_MONOTONIC);
	set_fs(oldfs);

259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
	/*
	 * hrtimer_nanosleep() can only return 0 or
	 * -ERESTART_RESTARTBLOCK here because:
	 *
	 * - we call it with HRTIMER_MODE_REL and therefor exclude the
	 *   -ERESTARTNOHAND return path.
	 *
	 * - we supply the rmtp argument from the task stack (due to
	 *   the necessary compat conversion. So the update cannot
	 *   fail, which excludes the -EFAULT return path as well. If
	 *   it fails nevertheless we have a bigger problem and wont
	 *   reach this place anymore.
	 *
	 * - if the return value is 0, we do not have to update rmtp
	 *    because there is no remaining time.
	 *
	 * We check for -ERESTART_RESTARTBLOCK nevertheless if the
	 * core implementation decides to return random nonsense.
	 */
	if (ret == -ERESTART_RESTARTBLOCK) {
279 280 281 282
		struct restart_block *restart
			= &current_thread_info()->restart_block;

		restart->fn = compat_nanosleep_restart;
283
		restart->nanosleep.compat_rmtp = rmtp;
L
Linus Torvalds 已提交
284

285
		if (rmtp && compat_put_timespec(&rmt, rmtp))
L
Linus Torvalds 已提交
286 287
			return -EFAULT;
	}
288
	return ret;
L
Linus Torvalds 已提交
289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
}

static inline long get_compat_itimerval(struct itimerval *o,
		struct compat_itimerval __user *i)
{
	return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
		(__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
		 __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
		 __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
		 __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
}

static inline long put_compat_itimerval(struct compat_itimerval __user *o,
		struct itimerval *i)
{
	return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
		(__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
		 __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
		 __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
		 __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
}

311 312
COMPAT_SYSCALL_DEFINE2(getitimer, int, which,
		struct compat_itimerval __user *, it)
L
Linus Torvalds 已提交
313 314 315 316 317 318 319 320 321 322
{
	struct itimerval kit;
	int error;

	error = do_getitimer(which, &kit);
	if (!error && put_compat_itimerval(it, &kit))
		error = -EFAULT;
	return error;
}

323 324 325
COMPAT_SYSCALL_DEFINE3(setitimer, int, which,
		struct compat_itimerval __user *, in,
		struct compat_itimerval __user *, out)
L
Linus Torvalds 已提交
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
{
	struct itimerval kin, kout;
	int error;

	if (in) {
		if (get_compat_itimerval(&kin, in))
			return -EFAULT;
	} else
		memset(&kin, 0, sizeof(kin));

	error = do_setitimer(which, &kin, out ? &kout : NULL);
	if (error || !out)
		return error;
	if (put_compat_itimerval(out, &kout))
		return -EFAULT;
	return 0;
}

344 345 346 347 348
static compat_clock_t clock_t_to_compat_clock_t(clock_t x)
{
	return compat_jiffies_to_clock_t(clock_t_to_jiffies(x));
}

349
COMPAT_SYSCALL_DEFINE1(times, struct compat_tms __user *, tbuf)
L
Linus Torvalds 已提交
350 351
{
	if (tbuf) {
352
		struct tms tms;
L
Linus Torvalds 已提交
353
		struct compat_tms tmp;
354 355 356 357 358 359 360

		do_sys_times(&tms);
		/* Convert our struct tms to the compat version. */
		tmp.tms_utime = clock_t_to_compat_clock_t(tms.tms_utime);
		tmp.tms_stime = clock_t_to_compat_clock_t(tms.tms_stime);
		tmp.tms_cutime = clock_t_to_compat_clock_t(tms.tms_cutime);
		tmp.tms_cstime = clock_t_to_compat_clock_t(tms.tms_cstime);
L
Linus Torvalds 已提交
361 362 363
		if (copy_to_user(tbuf, &tmp, sizeof(tmp)))
			return -EFAULT;
	}
364
	force_successful_syscall_return();
L
Linus Torvalds 已提交
365 366 367
	return compat_jiffies_to_clock_t(jiffies);
}

368 369
#ifdef __ARCH_WANT_SYS_SIGPENDING

L
Linus Torvalds 已提交
370 371 372 373 374
/*
 * Assumption: old_sigset_t and compat_old_sigset_t are both
 * types that can be passed to put_user()/get_user().
 */

375
COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set)
L
Linus Torvalds 已提交
376 377 378 379 380 381 382 383 384 385 386 387 388
{
	old_sigset_t s;
	long ret;
	mm_segment_t old_fs = get_fs();

	set_fs(KERNEL_DS);
	ret = sys_sigpending((old_sigset_t __user *) &s);
	set_fs(old_fs);
	if (ret == 0)
		ret = put_user(s, set);
	return ret;
}

389 390 391 392
#endif

#ifdef __ARCH_WANT_SYS_SIGPROCMASK

393 394 395 396 397
/*
 * sys_sigprocmask SIG_SETMASK sets the first (compat) word of the
 * blocked set of signals to the supplied signal set
 */
static inline void compat_sig_setmask(sigset_t *blocked, compat_sigset_word set)
L
Linus Torvalds 已提交
398
{
399 400
	memcpy(blocked->sig, &set, sizeof(set));
}
L
Linus Torvalds 已提交
401

402 403 404
COMPAT_SYSCALL_DEFINE3(sigprocmask, int, how,
		       compat_old_sigset_t __user *, nset,
		       compat_old_sigset_t __user *, oset)
405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440
{
	old_sigset_t old_set, new_set;
	sigset_t new_blocked;

	old_set = current->blocked.sig[0];

	if (nset) {
		if (get_user(new_set, nset))
			return -EFAULT;
		new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));

		new_blocked = current->blocked;

		switch (how) {
		case SIG_BLOCK:
			sigaddsetmask(&new_blocked, new_set);
			break;
		case SIG_UNBLOCK:
			sigdelsetmask(&new_blocked, new_set);
			break;
		case SIG_SETMASK:
			compat_sig_setmask(&new_blocked, new_set);
			break;
		default:
			return -EINVAL;
		}

		set_current_blocked(&new_blocked);
	}

	if (oset) {
		if (put_user(old_set, oset))
			return -EFAULT;
	}

	return 0;
L
Linus Torvalds 已提交
441 442
}

443 444
#endif

445 446
COMPAT_SYSCALL_DEFINE2(setrlimit, unsigned int, resource,
		       struct compat_rlimit __user *, rlim)
L
Linus Torvalds 已提交
447 448 449 450 451 452 453 454 455 456 457 458
{
	struct rlimit r;

	if (!access_ok(VERIFY_READ, rlim, sizeof(*rlim)) ||
	    __get_user(r.rlim_cur, &rlim->rlim_cur) ||
	    __get_user(r.rlim_max, &rlim->rlim_max))
		return -EFAULT;

	if (r.rlim_cur == COMPAT_RLIM_INFINITY)
		r.rlim_cur = RLIM_INFINITY;
	if (r.rlim_max == COMPAT_RLIM_INFINITY)
		r.rlim_max = RLIM_INFINITY;
459
	return do_prlimit(current, resource, &r, NULL);
L
Linus Torvalds 已提交
460 461 462 463
}

#ifdef COMPAT_RLIM_OLD_INFINITY

464 465
COMPAT_SYSCALL_DEFINE2(old_getrlimit, unsigned int, resource,
		       struct compat_rlimit __user *, rlim)
L
Linus Torvalds 已提交
466 467 468 469 470 471
{
	struct rlimit r;
	int ret;
	mm_segment_t old_fs = get_fs();

	set_fs(KERNEL_DS);
472
	ret = sys_old_getrlimit(resource, (struct rlimit __user *)&r);
L
Linus Torvalds 已提交
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
	set_fs(old_fs);

	if (!ret) {
		if (r.rlim_cur > COMPAT_RLIM_OLD_INFINITY)
			r.rlim_cur = COMPAT_RLIM_INFINITY;
		if (r.rlim_max > COMPAT_RLIM_OLD_INFINITY)
			r.rlim_max = COMPAT_RLIM_INFINITY;

		if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
		    __put_user(r.rlim_cur, &rlim->rlim_cur) ||
		    __put_user(r.rlim_max, &rlim->rlim_max))
			return -EFAULT;
	}
	return ret;
}

#endif

491 492
COMPAT_SYSCALL_DEFINE2(getrlimit, unsigned int, resource,
		       struct compat_rlimit __user *, rlim)
L
Linus Torvalds 已提交
493 494 495 496
{
	struct rlimit r;
	int ret;

497
	ret = do_prlimit(current, resource, NULL, &r);
L
Linus Torvalds 已提交
498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
	if (!ret) {
		if (r.rlim_cur > COMPAT_RLIM_INFINITY)
			r.rlim_cur = COMPAT_RLIM_INFINITY;
		if (r.rlim_max > COMPAT_RLIM_INFINITY)
			r.rlim_max = COMPAT_RLIM_INFINITY;

		if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
		    __put_user(r.rlim_cur, &rlim->rlim_cur) ||
		    __put_user(r.rlim_max, &rlim->rlim_max))
			return -EFAULT;
	}
	return ret;
}

int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru)
{
	if (!access_ok(VERIFY_WRITE, ru, sizeof(*ru)) ||
	    __put_user(r->ru_utime.tv_sec, &ru->ru_utime.tv_sec) ||
	    __put_user(r->ru_utime.tv_usec, &ru->ru_utime.tv_usec) ||
	    __put_user(r->ru_stime.tv_sec, &ru->ru_stime.tv_sec) ||
	    __put_user(r->ru_stime.tv_usec, &ru->ru_stime.tv_usec) ||
	    __put_user(r->ru_maxrss, &ru->ru_maxrss) ||
	    __put_user(r->ru_ixrss, &ru->ru_ixrss) ||
	    __put_user(r->ru_idrss, &ru->ru_idrss) ||
	    __put_user(r->ru_isrss, &ru->ru_isrss) ||
	    __put_user(r->ru_minflt, &ru->ru_minflt) ||
	    __put_user(r->ru_majflt, &ru->ru_majflt) ||
	    __put_user(r->ru_nswap, &ru->ru_nswap) ||
	    __put_user(r->ru_inblock, &ru->ru_inblock) ||
	    __put_user(r->ru_oublock, &ru->ru_oublock) ||
	    __put_user(r->ru_msgsnd, &ru->ru_msgsnd) ||
	    __put_user(r->ru_msgrcv, &ru->ru_msgrcv) ||
	    __put_user(r->ru_nsignals, &ru->ru_nsignals) ||
	    __put_user(r->ru_nvcsw, &ru->ru_nvcsw) ||
	    __put_user(r->ru_nivcsw, &ru->ru_nivcsw))
		return -EFAULT;
	return 0;
}

537 538 539 540 541
COMPAT_SYSCALL_DEFINE4(wait4,
	compat_pid_t, pid,
	compat_uint_t __user *, stat_addr,
	int, options,
	struct compat_rusage __user *, ru)
L
Linus Torvalds 已提交
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567
{
	if (!ru) {
		return sys_wait4(pid, stat_addr, options, NULL);
	} else {
		struct rusage r;
		int ret;
		unsigned int status;
		mm_segment_t old_fs = get_fs();

		set_fs (KERNEL_DS);
		ret = sys_wait4(pid,
				(stat_addr ?
				 (unsigned int __user *) &status : NULL),
				options, (struct rusage __user *) &r);
		set_fs (old_fs);

		if (ret > 0) {
			if (put_compat_rusage(&r, ru))
				return -EFAULT;
			if (stat_addr && put_user(status, stat_addr))
				return -EFAULT;
		}
		return ret;
	}
}

568 569 570 571
COMPAT_SYSCALL_DEFINE5(waitid,
		int, which, compat_pid_t, pid,
		struct compat_siginfo __user *, uinfo, int, options,
		struct compat_rusage __user *, uru)
L
Linus Torvalds 已提交
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588
{
	siginfo_t info;
	struct rusage ru;
	long ret;
	mm_segment_t old_fs = get_fs();

	memset(&info, 0, sizeof(info));

	set_fs(KERNEL_DS);
	ret = sys_waitid(which, pid, (siginfo_t __user *)&info, options,
			 uru ? (struct rusage __user *)&ru : NULL);
	set_fs(old_fs);

	if ((ret < 0) || (info.si_signo == 0))
		return ret;

	if (uru) {
A
Al Viro 已提交
589 590 591 592 593
		/* sys_waitid() overwrites everything in ru */
		if (COMPAT_USE_64BIT_TIME)
			ret = copy_to_user(uru, &ru, sizeof(ru));
		else
			ret = put_compat_rusage(&ru, uru);
L
Linus Torvalds 已提交
594
		if (ret)
595
			return -EFAULT;
L
Linus Torvalds 已提交
596 597 598 599 600 601 602 603
	}

	BUG_ON(info.si_code & __SI_MASK);
	info.si_code |= __SI_CHLD;
	return copy_siginfo_to_user32(uinfo, &info);
}

static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr,
R
Rusty Russell 已提交
604
				    unsigned len, struct cpumask *new_mask)
L
Linus Torvalds 已提交
605 606 607
{
	unsigned long *k;

R
Rusty Russell 已提交
608 609 610 611
	if (len < cpumask_size())
		memset(new_mask, 0, cpumask_size());
	else if (len > cpumask_size())
		len = cpumask_size();
L
Linus Torvalds 已提交
612

R
Rusty Russell 已提交
613
	k = cpumask_bits(new_mask);
L
Linus Torvalds 已提交
614 615 616
	return compat_get_bitmap(k, user_mask_ptr, len * 8);
}

617 618 619
COMPAT_SYSCALL_DEFINE3(sched_setaffinity, compat_pid_t, pid,
		       unsigned int, len,
		       compat_ulong_t __user *, user_mask_ptr)
L
Linus Torvalds 已提交
620
{
R
Rusty Russell 已提交
621
	cpumask_var_t new_mask;
L
Linus Torvalds 已提交
622 623
	int retval;

R
Rusty Russell 已提交
624 625 626 627
	if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
		return -ENOMEM;

	retval = compat_get_user_cpu_mask(user_mask_ptr, len, new_mask);
L
Linus Torvalds 已提交
628
	if (retval)
R
Rusty Russell 已提交
629
		goto out;
L
Linus Torvalds 已提交
630

R
Rusty Russell 已提交
631 632 633 634
	retval = sched_setaffinity(pid, new_mask);
out:
	free_cpumask_var(new_mask);
	return retval;
L
Linus Torvalds 已提交
635 636
}

637 638
COMPAT_SYSCALL_DEFINE3(sched_getaffinity, compat_pid_t,  pid, unsigned int, len,
		       compat_ulong_t __user *, user_mask_ptr)
L
Linus Torvalds 已提交
639 640
{
	int ret;
R
Rusty Russell 已提交
641
	cpumask_var_t mask;
L
Linus Torvalds 已提交
642

643 644 645
	if ((len * BITS_PER_BYTE) < nr_cpu_ids)
		return -EINVAL;
	if (len & (sizeof(compat_ulong_t)-1))
L
Linus Torvalds 已提交
646 647
		return -EINVAL;

R
Rusty Russell 已提交
648 649 650 651
	if (!alloc_cpumask_var(&mask, GFP_KERNEL))
		return -ENOMEM;

	ret = sched_getaffinity(pid, mask);
652 653
	if (ret == 0) {
		size_t retlen = min_t(size_t, len, cpumask_size());
L
Linus Torvalds 已提交
654

655 656 657 658 659
		if (compat_put_bitmap(user_mask_ptr, cpumask_bits(mask), retlen * 8))
			ret = -EFAULT;
		else
			ret = retlen;
	}
R
Rusty Russell 已提交
660
	free_cpumask_var(mask);
661

R
Rusty Russell 已提交
662
	return ret;
L
Linus Torvalds 已提交
663 664
}

665 666
int get_compat_itimerspec(struct itimerspec *dst,
			  const struct compat_itimerspec __user *src)
D
Daniel Walker 已提交
667
{
668 669
	if (__compat_get_timespec(&dst->it_interval, &src->it_interval) ||
	    __compat_get_timespec(&dst->it_value, &src->it_value))
L
Linus Torvalds 已提交
670 671
		return -EFAULT;
	return 0;
D
Daniel Walker 已提交
672
}
L
Linus Torvalds 已提交
673

674 675
int put_compat_itimerspec(struct compat_itimerspec __user *dst,
			  const struct itimerspec *src)
D
Daniel Walker 已提交
676
{
677 678
	if (__compat_put_timespec(&src->it_interval, &dst->it_interval) ||
	    __compat_put_timespec(&src->it_value, &dst->it_value))
L
Linus Torvalds 已提交
679 680
		return -EFAULT;
	return 0;
D
Daniel Walker 已提交
681
}
L
Linus Torvalds 已提交
682

683 684 685
COMPAT_SYSCALL_DEFINE3(timer_create, clockid_t, which_clock,
		       struct compat_sigevent __user *, timer_event_spec,
		       timer_t __user *, created_timer_id)
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
{
	struct sigevent __user *event = NULL;

	if (timer_event_spec) {
		struct sigevent kevent;

		event = compat_alloc_user_space(sizeof(*event));
		if (get_compat_sigevent(&kevent, timer_event_spec) ||
		    copy_to_user(event, &kevent, sizeof(*event)))
			return -EFAULT;
	}

	return sys_timer_create(which_clock, event, created_timer_id);
}

701 702 703
COMPAT_SYSCALL_DEFINE4(timer_settime, timer_t, timer_id, int, flags,
		       struct compat_itimerspec __user *, new,
		       struct compat_itimerspec __user *, old)
D
Daniel Walker 已提交
704
{
L
Linus Torvalds 已提交
705 706 707 708 709 710 711
	long err;
	mm_segment_t oldfs;
	struct itimerspec newts, oldts;

	if (!new)
		return -EINVAL;
	if (get_compat_itimerspec(&newts, new))
D
Daniel Walker 已提交
712
		return -EFAULT;
L
Linus Torvalds 已提交
713 714 715 716 717
	oldfs = get_fs();
	set_fs(KERNEL_DS);
	err = sys_timer_settime(timer_id, flags,
				(struct itimerspec __user *) &newts,
				(struct itimerspec __user *) &oldts);
D
Daniel Walker 已提交
718
	set_fs(oldfs);
L
Linus Torvalds 已提交
719 720 721
	if (!err && old && put_compat_itimerspec(old, &oldts))
		return -EFAULT;
	return err;
D
Daniel Walker 已提交
722
}
L
Linus Torvalds 已提交
723

724 725
COMPAT_SYSCALL_DEFINE2(timer_gettime, timer_t, timer_id,
		       struct compat_itimerspec __user *, setting)
D
Daniel Walker 已提交
726
{
L
Linus Torvalds 已提交
727 728
	long err;
	mm_segment_t oldfs;
D
Daniel Walker 已提交
729
	struct itimerspec ts;
L
Linus Torvalds 已提交
730 731 732 733

	oldfs = get_fs();
	set_fs(KERNEL_DS);
	err = sys_timer_gettime(timer_id,
D
Daniel Walker 已提交
734 735
				(struct itimerspec __user *) &ts);
	set_fs(oldfs);
L
Linus Torvalds 已提交
736 737 738
	if (!err && put_compat_itimerspec(setting, &ts))
		return -EFAULT;
	return err;
D
Daniel Walker 已提交
739
}
L
Linus Torvalds 已提交
740

741 742
COMPAT_SYSCALL_DEFINE2(clock_settime, clockid_t, which_clock,
		       struct compat_timespec __user *, tp)
L
Linus Torvalds 已提交
743 744 745
{
	long err;
	mm_segment_t oldfs;
D
Daniel Walker 已提交
746
	struct timespec ts;
L
Linus Torvalds 已提交
747

748
	if (compat_get_timespec(&ts, tp))
D
Daniel Walker 已提交
749
		return -EFAULT;
L
Linus Torvalds 已提交
750
	oldfs = get_fs();
D
Daniel Walker 已提交
751
	set_fs(KERNEL_DS);
L
Linus Torvalds 已提交
752 753 754 755
	err = sys_clock_settime(which_clock,
				(struct timespec __user *) &ts);
	set_fs(oldfs);
	return err;
D
Daniel Walker 已提交
756
}
L
Linus Torvalds 已提交
757

758 759
COMPAT_SYSCALL_DEFINE2(clock_gettime, clockid_t, which_clock,
		       struct compat_timespec __user *, tp)
L
Linus Torvalds 已提交
760 761 762
{
	long err;
	mm_segment_t oldfs;
D
Daniel Walker 已提交
763
	struct timespec ts;
L
Linus Torvalds 已提交
764 765 766 767 768 769

	oldfs = get_fs();
	set_fs(KERNEL_DS);
	err = sys_clock_gettime(which_clock,
				(struct timespec __user *) &ts);
	set_fs(oldfs);
770
	if (!err && compat_put_timespec(&ts, tp))
D
Daniel Walker 已提交
771
		return -EFAULT;
L
Linus Torvalds 已提交
772
	return err;
D
Daniel Walker 已提交
773
}
L
Linus Torvalds 已提交
774

775 776
COMPAT_SYSCALL_DEFINE2(clock_adjtime, clockid_t, which_clock,
		       struct compat_timex __user *, utp)
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
{
	struct timex txc;
	mm_segment_t oldfs;
	int err, ret;

	err = compat_get_timex(&txc, utp);
	if (err)
		return err;

	oldfs = get_fs();
	set_fs(KERNEL_DS);
	ret = sys_clock_adjtime(which_clock, (struct timex __user *) &txc);
	set_fs(oldfs);

	err = compat_put_timex(utp, &txc);
	if (err)
		return err;

	return ret;
}

798 799
COMPAT_SYSCALL_DEFINE2(clock_getres, clockid_t, which_clock,
		       struct compat_timespec __user *, tp)
L
Linus Torvalds 已提交
800 801 802
{
	long err;
	mm_segment_t oldfs;
D
Daniel Walker 已提交
803
	struct timespec ts;
L
Linus Torvalds 已提交
804 805 806 807 808 809

	oldfs = get_fs();
	set_fs(KERNEL_DS);
	err = sys_clock_getres(which_clock,
			       (struct timespec __user *) &ts);
	set_fs(oldfs);
810
	if (!err && tp && compat_put_timespec(&ts, tp))
D
Daniel Walker 已提交
811
		return -EFAULT;
L
Linus Torvalds 已提交
812
	return err;
D
Daniel Walker 已提交
813
}
L
Linus Torvalds 已提交
814

815 816 817 818 819
static long compat_clock_nanosleep_restart(struct restart_block *restart)
{
	long err;
	mm_segment_t oldfs;
	struct timespec tu;
820
	struct compat_timespec __user *rmtp = restart->nanosleep.compat_rmtp;
821

822
	restart->nanosleep.rmtp = (struct timespec __user *) &tu;
823 824 825 826 827 828
	oldfs = get_fs();
	set_fs(KERNEL_DS);
	err = clock_nanosleep_restart(restart);
	set_fs(oldfs);

	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
829
	    compat_put_timespec(&tu, rmtp))
830 831 832 833
		return -EFAULT;

	if (err == -ERESTART_RESTARTBLOCK) {
		restart->fn = compat_clock_nanosleep_restart;
834
		restart->nanosleep.compat_rmtp = rmtp;
835 836 837 838
	}
	return err;
}

839 840 841
COMPAT_SYSCALL_DEFINE4(clock_nanosleep, clockid_t, which_clock, int, flags,
		       struct compat_timespec __user *, rqtp,
		       struct compat_timespec __user *, rmtp)
L
Linus Torvalds 已提交
842 843 844
{
	long err;
	mm_segment_t oldfs;
D
Daniel Walker 已提交
845
	struct timespec in, out;
846
	struct restart_block *restart;
L
Linus Torvalds 已提交
847

848
	if (compat_get_timespec(&in, rqtp))
L
Linus Torvalds 已提交
849 850 851 852 853 854 855 856
		return -EFAULT;

	oldfs = get_fs();
	set_fs(KERNEL_DS);
	err = sys_clock_nanosleep(which_clock, flags,
				  (struct timespec __user *) &in,
				  (struct timespec __user *) &out);
	set_fs(oldfs);
857

L
Linus Torvalds 已提交
858
	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
859
	    compat_put_timespec(&out, rmtp))
L
Linus Torvalds 已提交
860
		return -EFAULT;
861 862 863 864

	if (err == -ERESTART_RESTARTBLOCK) {
		restart = &current_thread_info()->restart_block;
		restart->fn = compat_clock_nanosleep_restart;
865
		restart->nanosleep.compat_rmtp = rmtp;
866
	}
D
Daniel Walker 已提交
867 868
	return err;
}
L
Linus Torvalds 已提交
869 870 871 872 873 874 875 876 877 878 879

/*
 * We currently only need the following fields from the sigevent
 * structure: sigev_value, sigev_signo, sig_notify and (sometimes
 * sigev_notify_thread_id).  The others are handled in user mode.
 * We also assume that copying sigev_value.sival_int is sufficient
 * to keep all the bits of sigev_value.sival_ptr intact.
 */
int get_compat_sigevent(struct sigevent *event,
		const struct compat_sigevent __user *u_event)
{
880
	memset(event, 0, sizeof(*event));
L
Linus Torvalds 已提交
881 882 883 884 885 886 887 888 889 890
	return (!access_ok(VERIFY_READ, u_event, sizeof(*u_event)) ||
		__get_user(event->sigev_value.sival_int,
			&u_event->sigev_value.sival_int) ||
		__get_user(event->sigev_signo, &u_event->sigev_signo) ||
		__get_user(event->sigev_notify, &u_event->sigev_notify) ||
		__get_user(event->sigev_notify_thread_id,
			&u_event->sigev_notify_thread_id))
		? -EFAULT : 0;
}

891
long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
L
Linus Torvalds 已提交
892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972
		       unsigned long bitmap_size)
{
	int i, j;
	unsigned long m;
	compat_ulong_t um;
	unsigned long nr_compat_longs;

	/* align bitmap up to nearest compat_long_t boundary */
	bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);

	if (!access_ok(VERIFY_READ, umask, bitmap_size / 8))
		return -EFAULT;

	nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);

	for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
		m = 0;

		for (j = 0; j < sizeof(m)/sizeof(um); j++) {
			/*
			 * We dont want to read past the end of the userspace
			 * bitmap. We must however ensure the end of the
			 * kernel bitmap is zeroed.
			 */
			if (nr_compat_longs-- > 0) {
				if (__get_user(um, umask))
					return -EFAULT;
			} else {
				um = 0;
			}

			umask++;
			m |= (long)um << (j * BITS_PER_COMPAT_LONG);
		}
		*mask++ = m;
	}

	return 0;
}

long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
		       unsigned long bitmap_size)
{
	int i, j;
	unsigned long m;
	compat_ulong_t um;
	unsigned long nr_compat_longs;

	/* align bitmap up to nearest compat_long_t boundary */
	bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);

	if (!access_ok(VERIFY_WRITE, umask, bitmap_size / 8))
		return -EFAULT;

	nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);

	for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
		m = *mask++;

		for (j = 0; j < sizeof(m)/sizeof(um); j++) {
			um = m;

			/*
			 * We dont want to write past the end of the userspace
			 * bitmap.
			 */
			if (nr_compat_longs-- > 0) {
				if (__put_user(um, umask))
					return -EFAULT;
			}

			umask++;
			m >>= 4*sizeof(um);
			m >>= 4*sizeof(um);
		}
	}

	return 0;
}

void
A
Al Viro 已提交
973
sigset_from_compat(sigset_t *set, const compat_sigset_t *compat)
L
Linus Torvalds 已提交
974 975 976 977 978 979 980 981
{
	switch (_NSIG_WORDS) {
	case 4: set->sig[3] = compat->sig[6] | (((long)compat->sig[7]) << 32 );
	case 3: set->sig[2] = compat->sig[4] | (((long)compat->sig[5]) << 32 );
	case 2: set->sig[1] = compat->sig[2] | (((long)compat->sig[3]) << 32 );
	case 1: set->sig[0] = compat->sig[0] | (((long)compat->sig[1]) << 32 );
	}
}
982
EXPORT_SYMBOL_GPL(sigset_from_compat);
L
Linus Torvalds 已提交
983

A
Al Viro 已提交
984 985 986 987 988 989 990 991 992 993 994
void
sigset_to_compat(compat_sigset_t *compat, const sigset_t *set)
{
	switch (_NSIG_WORDS) {
	case 4: compat->sig[7] = (set->sig[3] >> 32); compat->sig[6] = set->sig[3];
	case 3: compat->sig[5] = (set->sig[2] >> 32); compat->sig[4] = set->sig[2];
	case 2: compat->sig[3] = (set->sig[1] >> 32); compat->sig[2] = set->sig[1];
	case 1: compat->sig[1] = (set->sig[0] >> 32); compat->sig[0] = set->sig[0];
	}
}

995 996 997
COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
		struct compat_siginfo __user *, uinfo,
		struct compat_timespec __user *, uts, compat_size_t, sigsetsize)
L
Linus Torvalds 已提交
998 999 1000 1001 1002
{
	compat_sigset_t s32;
	sigset_t s;
	struct timespec t;
	siginfo_t info;
1003
	long ret;
L
Linus Torvalds 已提交
1004 1005 1006 1007 1008 1009 1010 1011 1012

	if (sigsetsize != sizeof(sigset_t))
		return -EINVAL;

	if (copy_from_user(&s32, uthese, sizeof(compat_sigset_t)))
		return -EFAULT;
	sigset_from_compat(&s, &s32);

	if (uts) {
A
Al Viro 已提交
1013
		if (compat_get_timespec(&t, uts))
L
Linus Torvalds 已提交
1014 1015 1016
			return -EFAULT;
	}

1017
	ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
L
Linus Torvalds 已提交
1018

1019 1020 1021
	if (ret > 0 && uinfo) {
		if (copy_siginfo_to_user32(uinfo, &info))
			ret = -EFAULT;
L
Linus Torvalds 已提交
1022
	}
1023

L
Linus Torvalds 已提交
1024
	return ret;
1025 1026
}

L
Linus Torvalds 已提交
1027 1028 1029 1030
#ifdef __ARCH_WANT_COMPAT_SYS_TIME

/* compat_time_t is a 32 bit "long" and needs to get converted. */

1031
COMPAT_SYSCALL_DEFINE1(time, compat_time_t __user *, tloc)
L
Linus Torvalds 已提交
1032 1033 1034 1035 1036 1037 1038 1039 1040
{
	compat_time_t i;
	struct timeval tv;

	do_gettimeofday(&tv);
	i = tv.tv_sec;

	if (tloc) {
		if (put_user(i,tloc))
1041
			return -EFAULT;
L
Linus Torvalds 已提交
1042
	}
1043
	force_successful_syscall_return();
L
Linus Torvalds 已提交
1044 1045 1046
	return i;
}

1047
COMPAT_SYSCALL_DEFINE1(stime, compat_time_t __user *, tptr)
L
Linus Torvalds 已提交
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
{
	struct timespec tv;
	int err;

	if (get_user(tv.tv_sec, tptr))
		return -EFAULT;

	tv.tv_nsec = 0;

	err = security_settime(&tv, NULL);
	if (err)
		return err;

	do_settimeofday(&tv);
	return 0;
}

#endif /* __ARCH_WANT_COMPAT_SYS_TIME */
1066

1067
COMPAT_SYSCALL_DEFINE1(adjtimex, struct compat_timex __user *, utp)
1068 1069
{
	struct timex txc;
1070
	int err, ret;
1071

1072 1073 1074
	err = compat_get_timex(&txc, utp);
	if (err)
		return err;
1075 1076 1077

	ret = do_adjtimex(&txc);

1078 1079 1080
	err = compat_put_timex(utp, &txc);
	if (err)
		return err;
1081 1082 1083

	return ret;
}
1084 1085

#ifdef CONFIG_NUMA
1086 1087 1088 1089 1090
COMPAT_SYSCALL_DEFINE6(move_pages, pid_t, pid, compat_ulong_t, nr_pages,
		       compat_uptr_t __user *, pages32,
		       const int __user *, nodes,
		       int __user *, status,
		       int, flags)
1091 1092 1093 1094 1095 1096 1097 1098
{
	const void __user * __user *pages;
	int i;

	pages = compat_alloc_user_space(nr_pages * sizeof(void *));
	for (i = 0; i < nr_pages; i++) {
		compat_uptr_t p;

1099
		if (get_user(p, pages32 + i) ||
1100 1101 1102 1103 1104
			put_user(compat_ptr(p), pages + i))
			return -EFAULT;
	}
	return sys_move_pages(pid, nr_pages, pages, nodes, status, flags);
}
1105

1106 1107 1108 1109
COMPAT_SYSCALL_DEFINE4(migrate_pages, compat_pid_t, pid,
		       compat_ulong_t, maxnode,
		       const compat_ulong_t __user *, old_nodes,
		       const compat_ulong_t __user *, new_nodes)
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
{
	unsigned long __user *old = NULL;
	unsigned long __user *new = NULL;
	nodemask_t tmp_mask;
	unsigned long nr_bits;
	unsigned long size;

	nr_bits = min_t(unsigned long, maxnode - 1, MAX_NUMNODES);
	size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
	if (old_nodes) {
		if (compat_get_bitmap(nodes_addr(tmp_mask), old_nodes, nr_bits))
			return -EFAULT;
		old = compat_alloc_user_space(new_nodes ? size * 2 : size);
		if (new_nodes)
			new = old + size / sizeof(unsigned long);
		if (copy_to_user(old, nodes_addr(tmp_mask), size))
			return -EFAULT;
	}
	if (new_nodes) {
		if (compat_get_bitmap(nodes_addr(tmp_mask), new_nodes, nr_bits))
			return -EFAULT;
		if (new == NULL)
			new = compat_alloc_user_space(size);
		if (copy_to_user(new, nodes_addr(tmp_mask), size))
			return -EFAULT;
	}
	return sys_migrate_pages(pid, nr_bits + 1, old, new);
}
1138
#endif
1139

1140 1141 1142
COMPAT_SYSCALL_DEFINE2(sched_rr_get_interval,
		       compat_pid_t, pid,
		       struct compat_timespec __user *, interval)
1143 1144 1145 1146 1147 1148 1149 1150
{
	struct timespec t;
	int ret;
	mm_segment_t old_fs = get_fs();

	set_fs(KERNEL_DS);
	ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);
	set_fs(old_fs);
1151
	if (compat_put_timespec(&t, interval))
1152 1153 1154 1155
		return -EFAULT;
	return ret;
}

1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
/*
 * Allocate user-space memory for the duration of a single system call,
 * in order to marshall parameters inside a compat thunk.
 */
void __user *compat_alloc_user_space(unsigned long len)
{
	void __user *ptr;

	/* If len would occupy more than half of the entire compat space... */
	if (unlikely(len > (((compat_uptr_t)~0) >> 1)))
		return NULL;

	ptr = arch_compat_alloc_user_space(len);

	if (unlikely(!access_ok(VERIFY_WRITE, ptr, len)))
		return NULL;

	return ptr;
}
EXPORT_SYMBOL_GPL(compat_alloc_user_space);