xref: /openbmc/linux/kernel/compat.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  *  linux/kernel/compat.c
3  *
4  *  Kernel compatibililty routines for e.g. 32 bit syscall support
5  *  on 64 bit kernels.
6  *
7  *  Copyright (C) 2002-2003 Stephen Rothwell, IBM Corporation
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License version 2 as
11  *  published by the Free Software Foundation.
12  */
13 
14 #include <linux/linkage.h>
15 #include <linux/compat.h>
16 #include <linux/errno.h>
17 #include <linux/time.h>
18 #include <linux/signal.h>
19 #include <linux/sched.h>	/* for MAX_SCHEDULE_TIMEOUT */
20 #include <linux/futex.h>	/* for FUTEX_WAIT */
21 #include <linux/syscalls.h>
22 #include <linux/unistd.h>
23 #include <linux/security.h>
24 
25 #include <asm/uaccess.h>
26 #include <asm/bug.h>
27 
28 int get_compat_timespec(struct timespec *ts, const struct compat_timespec __user *cts)
29 {
30 	return (!access_ok(VERIFY_READ, cts, sizeof(*cts)) ||
31 			__get_user(ts->tv_sec, &cts->tv_sec) ||
32 			__get_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0;
33 }
34 
35 int put_compat_timespec(const struct timespec *ts, struct compat_timespec __user *cts)
36 {
37 	return (!access_ok(VERIFY_WRITE, cts, sizeof(*cts)) ||
38 			__put_user(ts->tv_sec, &cts->tv_sec) ||
39 			__put_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0;
40 }
41 
42 static long compat_nanosleep_restart(struct restart_block *restart)
43 {
44 	unsigned long expire = restart->arg0, now = jiffies;
45 	struct compat_timespec __user *rmtp;
46 
47 	/* Did it expire while we handled signals? */
48 	if (!time_after(expire, now))
49 		return 0;
50 
51 	expire = schedule_timeout_interruptible(expire - now);
52 	if (expire == 0)
53 		return 0;
54 
55 	rmtp = (struct compat_timespec __user *)restart->arg1;
56 	if (rmtp) {
57 		struct compat_timespec ct;
58 		struct timespec t;
59 
60 		jiffies_to_timespec(expire, &t);
61 		ct.tv_sec = t.tv_sec;
62 		ct.tv_nsec = t.tv_nsec;
63 		if (copy_to_user(rmtp, &ct, sizeof(ct)))
64 			return -EFAULT;
65 	}
66 	/* The 'restart' block is already filled in */
67 	return -ERESTART_RESTARTBLOCK;
68 }
69 
70 asmlinkage long compat_sys_nanosleep(struct compat_timespec __user *rqtp,
71 		struct compat_timespec __user *rmtp)
72 {
73 	struct timespec t;
74 	struct restart_block *restart;
75 	unsigned long expire;
76 
77 	if (get_compat_timespec(&t, rqtp))
78 		return -EFAULT;
79 
80 	if ((t.tv_nsec >= 1000000000L) || (t.tv_nsec < 0) || (t.tv_sec < 0))
81 		return -EINVAL;
82 
83 	expire = timespec_to_jiffies(&t) + (t.tv_sec || t.tv_nsec);
84 	expire = schedule_timeout_interruptible(expire);
85 	if (expire == 0)
86 		return 0;
87 
88 	if (rmtp) {
89 		jiffies_to_timespec(expire, &t);
90 		if (put_compat_timespec(&t, rmtp))
91 			return -EFAULT;
92 	}
93 	restart = &current_thread_info()->restart_block;
94 	restart->fn = compat_nanosleep_restart;
95 	restart->arg0 = jiffies + expire;
96 	restart->arg1 = (unsigned long) rmtp;
97 	return -ERESTART_RESTARTBLOCK;
98 }
99 
100 static inline long get_compat_itimerval(struct itimerval *o,
101 		struct compat_itimerval __user *i)
102 {
103 	return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
104 		(__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
105 		 __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
106 		 __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
107 		 __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
108 }
109 
110 static inline long put_compat_itimerval(struct compat_itimerval __user *o,
111 		struct itimerval *i)
112 {
113 	return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
114 		(__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
115 		 __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
116 		 __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
117 		 __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
118 }
119 
120 asmlinkage long compat_sys_getitimer(int which,
121 		struct compat_itimerval __user *it)
122 {
123 	struct itimerval kit;
124 	int error;
125 
126 	error = do_getitimer(which, &kit);
127 	if (!error && put_compat_itimerval(it, &kit))
128 		error = -EFAULT;
129 	return error;
130 }
131 
132 asmlinkage long compat_sys_setitimer(int which,
133 		struct compat_itimerval __user *in,
134 		struct compat_itimerval __user *out)
135 {
136 	struct itimerval kin, kout;
137 	int error;
138 
139 	if (in) {
140 		if (get_compat_itimerval(&kin, in))
141 			return -EFAULT;
142 	} else
143 		memset(&kin, 0, sizeof(kin));
144 
145 	error = do_setitimer(which, &kin, out ? &kout : NULL);
146 	if (error || !out)
147 		return error;
148 	if (put_compat_itimerval(out, &kout))
149 		return -EFAULT;
150 	return 0;
151 }
152 
153 asmlinkage long compat_sys_times(struct compat_tms __user *tbuf)
154 {
155 	/*
156 	 *	In the SMP world we might just be unlucky and have one of
157 	 *	the times increment as we use it. Since the value is an
158 	 *	atomically safe type this is just fine. Conceptually its
159 	 *	as if the syscall took an instant longer to occur.
160 	 */
161 	if (tbuf) {
162 		struct compat_tms tmp;
163 		struct task_struct *tsk = current;
164 		struct task_struct *t;
165 		cputime_t utime, stime, cutime, cstime;
166 
167 		read_lock(&tasklist_lock);
168 		utime = tsk->signal->utime;
169 		stime = tsk->signal->stime;
170 		t = tsk;
171 		do {
172 			utime = cputime_add(utime, t->utime);
173 			stime = cputime_add(stime, t->stime);
174 			t = next_thread(t);
175 		} while (t != tsk);
176 
177 		/*
178 		 * While we have tasklist_lock read-locked, no dying thread
179 		 * can be updating current->signal->[us]time.  Instead,
180 		 * we got their counts included in the live thread loop.
181 		 * However, another thread can come in right now and
182 		 * do a wait call that updates current->signal->c[us]time.
183 		 * To make sure we always see that pair updated atomically,
184 		 * we take the siglock around fetching them.
185 		 */
186 		spin_lock_irq(&tsk->sighand->siglock);
187 		cutime = tsk->signal->cutime;
188 		cstime = tsk->signal->cstime;
189 		spin_unlock_irq(&tsk->sighand->siglock);
190 		read_unlock(&tasklist_lock);
191 
192 		tmp.tms_utime = compat_jiffies_to_clock_t(cputime_to_jiffies(utime));
193 		tmp.tms_stime = compat_jiffies_to_clock_t(cputime_to_jiffies(stime));
194 		tmp.tms_cutime = compat_jiffies_to_clock_t(cputime_to_jiffies(cutime));
195 		tmp.tms_cstime = compat_jiffies_to_clock_t(cputime_to_jiffies(cstime));
196 		if (copy_to_user(tbuf, &tmp, sizeof(tmp)))
197 			return -EFAULT;
198 	}
199 	return compat_jiffies_to_clock_t(jiffies);
200 }
201 
202 /*
203  * Assumption: old_sigset_t and compat_old_sigset_t are both
204  * types that can be passed to put_user()/get_user().
205  */
206 
207 asmlinkage long compat_sys_sigpending(compat_old_sigset_t __user *set)
208 {
209 	old_sigset_t s;
210 	long ret;
211 	mm_segment_t old_fs = get_fs();
212 
213 	set_fs(KERNEL_DS);
214 	ret = sys_sigpending((old_sigset_t __user *) &s);
215 	set_fs(old_fs);
216 	if (ret == 0)
217 		ret = put_user(s, set);
218 	return ret;
219 }
220 
221 asmlinkage long compat_sys_sigprocmask(int how, compat_old_sigset_t __user *set,
222 		compat_old_sigset_t __user *oset)
223 {
224 	old_sigset_t s;
225 	long ret;
226 	mm_segment_t old_fs;
227 
228 	if (set && get_user(s, set))
229 		return -EFAULT;
230 	old_fs = get_fs();
231 	set_fs(KERNEL_DS);
232 	ret = sys_sigprocmask(how,
233 			      set ? (old_sigset_t __user *) &s : NULL,
234 			      oset ? (old_sigset_t __user *) &s : NULL);
235 	set_fs(old_fs);
236 	if (ret == 0)
237 		if (oset)
238 			ret = put_user(s, oset);
239 	return ret;
240 }
241 
242 #ifdef CONFIG_FUTEX
243 asmlinkage long compat_sys_futex(u32 __user *uaddr, int op, int val,
244 		struct compat_timespec __user *utime, u32 __user *uaddr2,
245 		int val3)
246 {
247 	struct timespec t;
248 	unsigned long timeout = MAX_SCHEDULE_TIMEOUT;
249 	int val2 = 0;
250 
251 	if ((op == FUTEX_WAIT) && utime) {
252 		if (get_compat_timespec(&t, utime))
253 			return -EFAULT;
254 		timeout = timespec_to_jiffies(&t) + 1;
255 	}
256 	if (op >= FUTEX_REQUEUE)
257 		val2 = (int) (unsigned long) utime;
258 
259 	return do_futex((unsigned long)uaddr, op, val, timeout,
260 			(unsigned long)uaddr2, val2, val3);
261 }
262 #endif
263 
264 asmlinkage long compat_sys_setrlimit(unsigned int resource,
265 		struct compat_rlimit __user *rlim)
266 {
267 	struct rlimit r;
268 	int ret;
269 	mm_segment_t old_fs = get_fs ();
270 
271 	if (resource >= RLIM_NLIMITS)
272 		return -EINVAL;
273 
274 	if (!access_ok(VERIFY_READ, rlim, sizeof(*rlim)) ||
275 	    __get_user(r.rlim_cur, &rlim->rlim_cur) ||
276 	    __get_user(r.rlim_max, &rlim->rlim_max))
277 		return -EFAULT;
278 
279 	if (r.rlim_cur == COMPAT_RLIM_INFINITY)
280 		r.rlim_cur = RLIM_INFINITY;
281 	if (r.rlim_max == COMPAT_RLIM_INFINITY)
282 		r.rlim_max = RLIM_INFINITY;
283 	set_fs(KERNEL_DS);
284 	ret = sys_setrlimit(resource, (struct rlimit __user *) &r);
285 	set_fs(old_fs);
286 	return ret;
287 }
288 
289 #ifdef COMPAT_RLIM_OLD_INFINITY
290 
291 asmlinkage long compat_sys_old_getrlimit(unsigned int resource,
292 		struct compat_rlimit __user *rlim)
293 {
294 	struct rlimit r;
295 	int ret;
296 	mm_segment_t old_fs = get_fs();
297 
298 	set_fs(KERNEL_DS);
299 	ret = sys_old_getrlimit(resource, &r);
300 	set_fs(old_fs);
301 
302 	if (!ret) {
303 		if (r.rlim_cur > COMPAT_RLIM_OLD_INFINITY)
304 			r.rlim_cur = COMPAT_RLIM_INFINITY;
305 		if (r.rlim_max > COMPAT_RLIM_OLD_INFINITY)
306 			r.rlim_max = COMPAT_RLIM_INFINITY;
307 
308 		if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
309 		    __put_user(r.rlim_cur, &rlim->rlim_cur) ||
310 		    __put_user(r.rlim_max, &rlim->rlim_max))
311 			return -EFAULT;
312 	}
313 	return ret;
314 }
315 
316 #endif
317 
318 asmlinkage long compat_sys_getrlimit (unsigned int resource,
319 		struct compat_rlimit __user *rlim)
320 {
321 	struct rlimit r;
322 	int ret;
323 	mm_segment_t old_fs = get_fs();
324 
325 	set_fs(KERNEL_DS);
326 	ret = sys_getrlimit(resource, (struct rlimit __user *) &r);
327 	set_fs(old_fs);
328 	if (!ret) {
329 		if (r.rlim_cur > COMPAT_RLIM_INFINITY)
330 			r.rlim_cur = COMPAT_RLIM_INFINITY;
331 		if (r.rlim_max > COMPAT_RLIM_INFINITY)
332 			r.rlim_max = COMPAT_RLIM_INFINITY;
333 
334 		if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
335 		    __put_user(r.rlim_cur, &rlim->rlim_cur) ||
336 		    __put_user(r.rlim_max, &rlim->rlim_max))
337 			return -EFAULT;
338 	}
339 	return ret;
340 }
341 
342 int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru)
343 {
344 	if (!access_ok(VERIFY_WRITE, ru, sizeof(*ru)) ||
345 	    __put_user(r->ru_utime.tv_sec, &ru->ru_utime.tv_sec) ||
346 	    __put_user(r->ru_utime.tv_usec, &ru->ru_utime.tv_usec) ||
347 	    __put_user(r->ru_stime.tv_sec, &ru->ru_stime.tv_sec) ||
348 	    __put_user(r->ru_stime.tv_usec, &ru->ru_stime.tv_usec) ||
349 	    __put_user(r->ru_maxrss, &ru->ru_maxrss) ||
350 	    __put_user(r->ru_ixrss, &ru->ru_ixrss) ||
351 	    __put_user(r->ru_idrss, &ru->ru_idrss) ||
352 	    __put_user(r->ru_isrss, &ru->ru_isrss) ||
353 	    __put_user(r->ru_minflt, &ru->ru_minflt) ||
354 	    __put_user(r->ru_majflt, &ru->ru_majflt) ||
355 	    __put_user(r->ru_nswap, &ru->ru_nswap) ||
356 	    __put_user(r->ru_inblock, &ru->ru_inblock) ||
357 	    __put_user(r->ru_oublock, &ru->ru_oublock) ||
358 	    __put_user(r->ru_msgsnd, &ru->ru_msgsnd) ||
359 	    __put_user(r->ru_msgrcv, &ru->ru_msgrcv) ||
360 	    __put_user(r->ru_nsignals, &ru->ru_nsignals) ||
361 	    __put_user(r->ru_nvcsw, &ru->ru_nvcsw) ||
362 	    __put_user(r->ru_nivcsw, &ru->ru_nivcsw))
363 		return -EFAULT;
364 	return 0;
365 }
366 
367 asmlinkage long compat_sys_getrusage(int who, struct compat_rusage __user *ru)
368 {
369 	struct rusage r;
370 	int ret;
371 	mm_segment_t old_fs = get_fs();
372 
373 	set_fs(KERNEL_DS);
374 	ret = sys_getrusage(who, (struct rusage __user *) &r);
375 	set_fs(old_fs);
376 
377 	if (ret)
378 		return ret;
379 
380 	if (put_compat_rusage(&r, ru))
381 		return -EFAULT;
382 
383 	return 0;
384 }
385 
386 asmlinkage long
387 compat_sys_wait4(compat_pid_t pid, compat_uint_t __user *stat_addr, int options,
388 	struct compat_rusage __user *ru)
389 {
390 	if (!ru) {
391 		return sys_wait4(pid, stat_addr, options, NULL);
392 	} else {
393 		struct rusage r;
394 		int ret;
395 		unsigned int status;
396 		mm_segment_t old_fs = get_fs();
397 
398 		set_fs (KERNEL_DS);
399 		ret = sys_wait4(pid,
400 				(stat_addr ?
401 				 (unsigned int __user *) &status : NULL),
402 				options, (struct rusage __user *) &r);
403 		set_fs (old_fs);
404 
405 		if (ret > 0) {
406 			if (put_compat_rusage(&r, ru))
407 				return -EFAULT;
408 			if (stat_addr && put_user(status, stat_addr))
409 				return -EFAULT;
410 		}
411 		return ret;
412 	}
413 }
414 
415 asmlinkage long compat_sys_waitid(int which, compat_pid_t pid,
416 		struct compat_siginfo __user *uinfo, int options,
417 		struct compat_rusage __user *uru)
418 {
419 	siginfo_t info;
420 	struct rusage ru;
421 	long ret;
422 	mm_segment_t old_fs = get_fs();
423 
424 	memset(&info, 0, sizeof(info));
425 
426 	set_fs(KERNEL_DS);
427 	ret = sys_waitid(which, pid, (siginfo_t __user *)&info, options,
428 			 uru ? (struct rusage __user *)&ru : NULL);
429 	set_fs(old_fs);
430 
431 	if ((ret < 0) || (info.si_signo == 0))
432 		return ret;
433 
434 	if (uru) {
435 		ret = put_compat_rusage(&ru, uru);
436 		if (ret)
437 			return ret;
438 	}
439 
440 	BUG_ON(info.si_code & __SI_MASK);
441 	info.si_code |= __SI_CHLD;
442 	return copy_siginfo_to_user32(uinfo, &info);
443 }
444 
445 static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr,
446 				    unsigned len, cpumask_t *new_mask)
447 {
448 	unsigned long *k;
449 
450 	if (len < sizeof(cpumask_t))
451 		memset(new_mask, 0, sizeof(cpumask_t));
452 	else if (len > sizeof(cpumask_t))
453 		len = sizeof(cpumask_t);
454 
455 	k = cpus_addr(*new_mask);
456 	return compat_get_bitmap(k, user_mask_ptr, len * 8);
457 }
458 
459 asmlinkage long compat_sys_sched_setaffinity(compat_pid_t pid,
460 					     unsigned int len,
461 					     compat_ulong_t __user *user_mask_ptr)
462 {
463 	cpumask_t new_mask;
464 	int retval;
465 
466 	retval = compat_get_user_cpu_mask(user_mask_ptr, len, &new_mask);
467 	if (retval)
468 		return retval;
469 
470 	return sched_setaffinity(pid, new_mask);
471 }
472 
473 asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid, unsigned int len,
474 					     compat_ulong_t __user *user_mask_ptr)
475 {
476 	int ret;
477 	cpumask_t mask;
478 	unsigned long *k;
479 	unsigned int min_length = sizeof(cpumask_t);
480 
481 	if (NR_CPUS <= BITS_PER_COMPAT_LONG)
482 		min_length = sizeof(compat_ulong_t);
483 
484 	if (len < min_length)
485 		return -EINVAL;
486 
487 	ret = sched_getaffinity(pid, &mask);
488 	if (ret < 0)
489 		return ret;
490 
491 	k = cpus_addr(mask);
492 	ret = compat_put_bitmap(user_mask_ptr, k, min_length * 8);
493 	if (ret)
494 		return ret;
495 
496 	return min_length;
497 }
498 
499 static int get_compat_itimerspec(struct itimerspec *dst,
500 				 struct compat_itimerspec __user *src)
501 {
502 	if (get_compat_timespec(&dst->it_interval, &src->it_interval) ||
503 	    get_compat_timespec(&dst->it_value, &src->it_value))
504 		return -EFAULT;
505 	return 0;
506 }
507 
508 static int put_compat_itimerspec(struct compat_itimerspec __user *dst,
509 				 struct itimerspec *src)
510 {
511 	if (put_compat_timespec(&src->it_interval, &dst->it_interval) ||
512 	    put_compat_timespec(&src->it_value, &dst->it_value))
513 		return -EFAULT;
514 	return 0;
515 }
516 
517 long compat_sys_timer_settime(timer_t timer_id, int flags,
518 			  struct compat_itimerspec __user *new,
519 			  struct compat_itimerspec __user *old)
520 {
521 	long err;
522 	mm_segment_t oldfs;
523 	struct itimerspec newts, oldts;
524 
525 	if (!new)
526 		return -EINVAL;
527 	if (get_compat_itimerspec(&newts, new))
528 		return -EFAULT;
529 	oldfs = get_fs();
530 	set_fs(KERNEL_DS);
531 	err = sys_timer_settime(timer_id, flags,
532 				(struct itimerspec __user *) &newts,
533 				(struct itimerspec __user *) &oldts);
534 	set_fs(oldfs);
535 	if (!err && old && put_compat_itimerspec(old, &oldts))
536 		return -EFAULT;
537 	return err;
538 }
539 
540 long compat_sys_timer_gettime(timer_t timer_id,
541 		struct compat_itimerspec __user *setting)
542 {
543 	long err;
544 	mm_segment_t oldfs;
545 	struct itimerspec ts;
546 
547 	oldfs = get_fs();
548 	set_fs(KERNEL_DS);
549 	err = sys_timer_gettime(timer_id,
550 				(struct itimerspec __user *) &ts);
551 	set_fs(oldfs);
552 	if (!err && put_compat_itimerspec(setting, &ts))
553 		return -EFAULT;
554 	return err;
555 }
556 
557 long compat_sys_clock_settime(clockid_t which_clock,
558 		struct compat_timespec __user *tp)
559 {
560 	long err;
561 	mm_segment_t oldfs;
562 	struct timespec ts;
563 
564 	if (get_compat_timespec(&ts, tp))
565 		return -EFAULT;
566 	oldfs = get_fs();
567 	set_fs(KERNEL_DS);
568 	err = sys_clock_settime(which_clock,
569 				(struct timespec __user *) &ts);
570 	set_fs(oldfs);
571 	return err;
572 }
573 
574 long compat_sys_clock_gettime(clockid_t which_clock,
575 		struct compat_timespec __user *tp)
576 {
577 	long err;
578 	mm_segment_t oldfs;
579 	struct timespec ts;
580 
581 	oldfs = get_fs();
582 	set_fs(KERNEL_DS);
583 	err = sys_clock_gettime(which_clock,
584 				(struct timespec __user *) &ts);
585 	set_fs(oldfs);
586 	if (!err && put_compat_timespec(&ts, tp))
587 		return -EFAULT;
588 	return err;
589 }
590 
591 long compat_sys_clock_getres(clockid_t which_clock,
592 		struct compat_timespec __user *tp)
593 {
594 	long err;
595 	mm_segment_t oldfs;
596 	struct timespec ts;
597 
598 	oldfs = get_fs();
599 	set_fs(KERNEL_DS);
600 	err = sys_clock_getres(which_clock,
601 			       (struct timespec __user *) &ts);
602 	set_fs(oldfs);
603 	if (!err && tp && put_compat_timespec(&ts, tp))
604 		return -EFAULT;
605 	return err;
606 }
607 
608 long compat_sys_clock_nanosleep(clockid_t which_clock, int flags,
609 			    struct compat_timespec __user *rqtp,
610 			    struct compat_timespec __user *rmtp)
611 {
612 	long err;
613 	mm_segment_t oldfs;
614 	struct timespec in, out;
615 
616 	if (get_compat_timespec(&in, rqtp))
617 		return -EFAULT;
618 
619 	oldfs = get_fs();
620 	set_fs(KERNEL_DS);
621 	err = sys_clock_nanosleep(which_clock, flags,
622 				  (struct timespec __user *) &in,
623 				  (struct timespec __user *) &out);
624 	set_fs(oldfs);
625 	if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
626 	    put_compat_timespec(&out, rmtp))
627 		return -EFAULT;
628 	return err;
629 }
630 
631 /*
632  * We currently only need the following fields from the sigevent
633  * structure: sigev_value, sigev_signo, sig_notify and (sometimes
634  * sigev_notify_thread_id).  The others are handled in user mode.
635  * We also assume that copying sigev_value.sival_int is sufficient
636  * to keep all the bits of sigev_value.sival_ptr intact.
637  */
638 int get_compat_sigevent(struct sigevent *event,
639 		const struct compat_sigevent __user *u_event)
640 {
641 	memset(event, 0, sizeof(*event));
642 	return (!access_ok(VERIFY_READ, u_event, sizeof(*u_event)) ||
643 		__get_user(event->sigev_value.sival_int,
644 			&u_event->sigev_value.sival_int) ||
645 		__get_user(event->sigev_signo, &u_event->sigev_signo) ||
646 		__get_user(event->sigev_notify, &u_event->sigev_notify) ||
647 		__get_user(event->sigev_notify_thread_id,
648 			&u_event->sigev_notify_thread_id))
649 		? -EFAULT : 0;
650 }
651 
652 /* timer_create is architecture specific because it needs sigevent conversion */
653 
654 long compat_get_bitmap(unsigned long *mask, compat_ulong_t __user *umask,
655 		       unsigned long bitmap_size)
656 {
657 	int i, j;
658 	unsigned long m;
659 	compat_ulong_t um;
660 	unsigned long nr_compat_longs;
661 
662 	/* align bitmap up to nearest compat_long_t boundary */
663 	bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
664 
665 	if (!access_ok(VERIFY_READ, umask, bitmap_size / 8))
666 		return -EFAULT;
667 
668 	nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
669 
670 	for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
671 		m = 0;
672 
673 		for (j = 0; j < sizeof(m)/sizeof(um); j++) {
674 			/*
675 			 * We dont want to read past the end of the userspace
676 			 * bitmap. We must however ensure the end of the
677 			 * kernel bitmap is zeroed.
678 			 */
679 			if (nr_compat_longs-- > 0) {
680 				if (__get_user(um, umask))
681 					return -EFAULT;
682 			} else {
683 				um = 0;
684 			}
685 
686 			umask++;
687 			m |= (long)um << (j * BITS_PER_COMPAT_LONG);
688 		}
689 		*mask++ = m;
690 	}
691 
692 	return 0;
693 }
694 
695 long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
696 		       unsigned long bitmap_size)
697 {
698 	int i, j;
699 	unsigned long m;
700 	compat_ulong_t um;
701 	unsigned long nr_compat_longs;
702 
703 	/* align bitmap up to nearest compat_long_t boundary */
704 	bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
705 
706 	if (!access_ok(VERIFY_WRITE, umask, bitmap_size / 8))
707 		return -EFAULT;
708 
709 	nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
710 
711 	for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
712 		m = *mask++;
713 
714 		for (j = 0; j < sizeof(m)/sizeof(um); j++) {
715 			um = m;
716 
717 			/*
718 			 * We dont want to write past the end of the userspace
719 			 * bitmap.
720 			 */
721 			if (nr_compat_longs-- > 0) {
722 				if (__put_user(um, umask))
723 					return -EFAULT;
724 			}
725 
726 			umask++;
727 			m >>= 4*sizeof(um);
728 			m >>= 4*sizeof(um);
729 		}
730 	}
731 
732 	return 0;
733 }
734 
735 void
736 sigset_from_compat (sigset_t *set, compat_sigset_t *compat)
737 {
738 	switch (_NSIG_WORDS) {
739 #if defined (__COMPAT_ENDIAN_SWAP__)
740 	case 4: set->sig[3] = compat->sig[7] | (((long)compat->sig[6]) << 32 );
741 	case 3: set->sig[2] = compat->sig[5] | (((long)compat->sig[4]) << 32 );
742 	case 2: set->sig[1] = compat->sig[3] | (((long)compat->sig[2]) << 32 );
743 	case 1: set->sig[0] = compat->sig[1] | (((long)compat->sig[0]) << 32 );
744 #else
745 	case 4: set->sig[3] = compat->sig[6] | (((long)compat->sig[7]) << 32 );
746 	case 3: set->sig[2] = compat->sig[4] | (((long)compat->sig[5]) << 32 );
747 	case 2: set->sig[1] = compat->sig[2] | (((long)compat->sig[3]) << 32 );
748 	case 1: set->sig[0] = compat->sig[0] | (((long)compat->sig[1]) << 32 );
749 #endif
750 	}
751 }
752 
753 asmlinkage long
754 compat_sys_rt_sigtimedwait (compat_sigset_t __user *uthese,
755 		struct compat_siginfo __user *uinfo,
756 		struct compat_timespec __user *uts, compat_size_t sigsetsize)
757 {
758 	compat_sigset_t s32;
759 	sigset_t s;
760 	int sig;
761 	struct timespec t;
762 	siginfo_t info;
763 	long ret, timeout = 0;
764 
765 	if (sigsetsize != sizeof(sigset_t))
766 		return -EINVAL;
767 
768 	if (copy_from_user(&s32, uthese, sizeof(compat_sigset_t)))
769 		return -EFAULT;
770 	sigset_from_compat(&s, &s32);
771 	sigdelsetmask(&s,sigmask(SIGKILL)|sigmask(SIGSTOP));
772 	signotset(&s);
773 
774 	if (uts) {
775 		if (get_compat_timespec (&t, uts))
776 			return -EFAULT;
777 		if (t.tv_nsec >= 1000000000L || t.tv_nsec < 0
778 				|| t.tv_sec < 0)
779 			return -EINVAL;
780 	}
781 
782 	spin_lock_irq(&current->sighand->siglock);
783 	sig = dequeue_signal(current, &s, &info);
784 	if (!sig) {
785 		timeout = MAX_SCHEDULE_TIMEOUT;
786 		if (uts)
787 			timeout = timespec_to_jiffies(&t)
788 				+(t.tv_sec || t.tv_nsec);
789 		if (timeout) {
790 			current->real_blocked = current->blocked;
791 			sigandsets(&current->blocked, &current->blocked, &s);
792 
793 			recalc_sigpending();
794 			spin_unlock_irq(&current->sighand->siglock);
795 
796 			timeout = schedule_timeout_interruptible(timeout);
797 
798 			spin_lock_irq(&current->sighand->siglock);
799 			sig = dequeue_signal(current, &s, &info);
800 			current->blocked = current->real_blocked;
801 			siginitset(&current->real_blocked, 0);
802 			recalc_sigpending();
803 		}
804 	}
805 	spin_unlock_irq(&current->sighand->siglock);
806 
807 	if (sig) {
808 		ret = sig;
809 		if (uinfo) {
810 			if (copy_siginfo_to_user32(uinfo, &info))
811 				ret = -EFAULT;
812 		}
813 	}else {
814 		ret = timeout?-EINTR:-EAGAIN;
815 	}
816 	return ret;
817 
818 }
819 
820 #ifdef __ARCH_WANT_COMPAT_SYS_TIME
821 
822 /* compat_time_t is a 32 bit "long" and needs to get converted. */
823 
824 asmlinkage long compat_sys_time(compat_time_t __user * tloc)
825 {
826 	compat_time_t i;
827 	struct timeval tv;
828 
829 	do_gettimeofday(&tv);
830 	i = tv.tv_sec;
831 
832 	if (tloc) {
833 		if (put_user(i,tloc))
834 			i = -EFAULT;
835 	}
836 	return i;
837 }
838 
839 asmlinkage long compat_sys_stime(compat_time_t __user *tptr)
840 {
841 	struct timespec tv;
842 	int err;
843 
844 	if (get_user(tv.tv_sec, tptr))
845 		return -EFAULT;
846 
847 	tv.tv_nsec = 0;
848 
849 	err = security_settime(&tv, NULL);
850 	if (err)
851 		return err;
852 
853 	do_settimeofday(&tv);
854 	return 0;
855 }
856 
857 #endif /* __ARCH_WANT_COMPAT_SYS_TIME */
858