2 * linux/kernel/compat.c
4 * Kernel compatibililty routines for e.g. 32 bit syscall support
7 * Copyright (C) 2002-2003 Stephen Rothwell, IBM Corporation
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.
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/syscalls.h>
21 #include <linux/unistd.h>
22 #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>
31 #include <asm/uaccess.h>
34 * Get/set struct timeval with struct timespec on the native side
36 static int compat_get_timeval_convert(struct timespec *o,
37 struct compat_timeval __user *i)
41 if (get_user(o->tv_sec, &i->tv_sec) ||
42 get_user(usec, &i->tv_usec))
44 o->tv_nsec = usec * 1000;
48 static int compat_put_timeval_convert(struct compat_timeval __user *o,
51 return (put_user(i->tv_sec, &o->tv_sec) ||
52 put_user(i->tv_usec, &o->tv_usec)) ? -EFAULT : 0;
55 static int compat_get_timex(struct timex *txc, struct compat_timex __user *utp)
57 memset(txc, 0, sizeof(struct timex));
59 if (!access_ok(VERIFY_READ, utp, sizeof(struct compat_timex)) ||
60 __get_user(txc->modes, &utp->modes) ||
61 __get_user(txc->offset, &utp->offset) ||
62 __get_user(txc->freq, &utp->freq) ||
63 __get_user(txc->maxerror, &utp->maxerror) ||
64 __get_user(txc->esterror, &utp->esterror) ||
65 __get_user(txc->status, &utp->status) ||
66 __get_user(txc->constant, &utp->constant) ||
67 __get_user(txc->precision, &utp->precision) ||
68 __get_user(txc->tolerance, &utp->tolerance) ||
69 __get_user(txc->time.tv_sec, &utp->time.tv_sec) ||
70 __get_user(txc->time.tv_usec, &utp->time.tv_usec) ||
71 __get_user(txc->tick, &utp->tick) ||
72 __get_user(txc->ppsfreq, &utp->ppsfreq) ||
73 __get_user(txc->jitter, &utp->jitter) ||
74 __get_user(txc->shift, &utp->shift) ||
75 __get_user(txc->stabil, &utp->stabil) ||
76 __get_user(txc->jitcnt, &utp->jitcnt) ||
77 __get_user(txc->calcnt, &utp->calcnt) ||
78 __get_user(txc->errcnt, &utp->errcnt) ||
79 __get_user(txc->stbcnt, &utp->stbcnt))
85 static int compat_put_timex(struct compat_timex __user *utp, struct timex *txc)
87 if (!access_ok(VERIFY_WRITE, utp, sizeof(struct compat_timex)) ||
88 __put_user(txc->modes, &utp->modes) ||
89 __put_user(txc->offset, &utp->offset) ||
90 __put_user(txc->freq, &utp->freq) ||
91 __put_user(txc->maxerror, &utp->maxerror) ||
92 __put_user(txc->esterror, &utp->esterror) ||
93 __put_user(txc->status, &utp->status) ||
94 __put_user(txc->constant, &utp->constant) ||
95 __put_user(txc->precision, &utp->precision) ||
96 __put_user(txc->tolerance, &utp->tolerance) ||
97 __put_user(txc->time.tv_sec, &utp->time.tv_sec) ||
98 __put_user(txc->time.tv_usec, &utp->time.tv_usec) ||
99 __put_user(txc->tick, &utp->tick) ||
100 __put_user(txc->ppsfreq, &utp->ppsfreq) ||
101 __put_user(txc->jitter, &utp->jitter) ||
102 __put_user(txc->shift, &utp->shift) ||
103 __put_user(txc->stabil, &utp->stabil) ||
104 __put_user(txc->jitcnt, &utp->jitcnt) ||
105 __put_user(txc->calcnt, &utp->calcnt) ||
106 __put_user(txc->errcnt, &utp->errcnt) ||
107 __put_user(txc->stbcnt, &utp->stbcnt) ||
108 __put_user(txc->tai, &utp->tai))
113 asmlinkage long compat_sys_gettimeofday(struct compat_timeval __user *tv,
114 struct timezone __user *tz)
118 do_gettimeofday(&ktv);
119 if (compat_put_timeval_convert(tv, &ktv))
123 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
130 asmlinkage long compat_sys_settimeofday(struct compat_timeval __user *tv,
131 struct timezone __user *tz)
137 if (compat_get_timeval_convert(&kts, tv))
141 if (copy_from_user(&ktz, tz, sizeof(ktz)))
145 return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL);
148 int get_compat_timeval(struct timeval *tv, const struct compat_timeval __user *ctv)
150 return (!access_ok(VERIFY_READ, ctv, sizeof(*ctv)) ||
151 __get_user(tv->tv_sec, &ctv->tv_sec) ||
152 __get_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0;
154 EXPORT_SYMBOL_GPL(get_compat_timeval);
156 int put_compat_timeval(const struct timeval *tv, struct compat_timeval __user *ctv)
158 return (!access_ok(VERIFY_WRITE, ctv, sizeof(*ctv)) ||
159 __put_user(tv->tv_sec, &ctv->tv_sec) ||
160 __put_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0;
162 EXPORT_SYMBOL_GPL(put_compat_timeval);
164 int get_compat_timespec(struct timespec *ts, const struct compat_timespec __user *cts)
166 return (!access_ok(VERIFY_READ, cts, sizeof(*cts)) ||
167 __get_user(ts->tv_sec, &cts->tv_sec) ||
168 __get_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0;
170 EXPORT_SYMBOL_GPL(get_compat_timespec);
172 int put_compat_timespec(const struct timespec *ts, struct compat_timespec __user *cts)
174 return (!access_ok(VERIFY_WRITE, cts, sizeof(*cts)) ||
175 __put_user(ts->tv_sec, &cts->tv_sec) ||
176 __put_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0;
178 EXPORT_SYMBOL_GPL(put_compat_timespec);
180 int compat_get_timeval(struct timeval *tv, const void __user *utv)
182 if (COMPAT_USE_64BIT_TIME)
183 return copy_from_user(tv, utv, sizeof *tv) ? -EFAULT : 0;
185 return get_compat_timeval(tv, utv);
187 EXPORT_SYMBOL_GPL(compat_get_timeval);
189 int compat_put_timeval(const struct timeval *tv, void __user *utv)
191 if (COMPAT_USE_64BIT_TIME)
192 return copy_to_user(utv, tv, sizeof *tv) ? -EFAULT : 0;
194 return put_compat_timeval(tv, utv);
196 EXPORT_SYMBOL_GPL(compat_put_timeval);
198 int compat_get_timespec(struct timespec *ts, const void __user *uts)
200 if (COMPAT_USE_64BIT_TIME)
201 return copy_from_user(ts, uts, sizeof *ts) ? -EFAULT : 0;
203 return get_compat_timespec(ts, uts);
205 EXPORT_SYMBOL_GPL(compat_get_timespec);
207 int compat_put_timespec(const struct timespec *ts, void __user *uts)
209 if (COMPAT_USE_64BIT_TIME)
210 return copy_to_user(uts, ts, sizeof *ts) ? -EFAULT : 0;
212 return put_compat_timespec(ts, uts);
214 EXPORT_SYMBOL_GPL(compat_put_timespec);
216 static long compat_nanosleep_restart(struct restart_block *restart)
218 struct compat_timespec __user *rmtp;
223 restart->nanosleep.rmtp = (struct timespec __user *) &rmt;
226 ret = hrtimer_nanosleep_restart(restart);
230 rmtp = restart->nanosleep.compat_rmtp;
232 if (rmtp && put_compat_timespec(&rmt, rmtp))
239 asmlinkage long compat_sys_nanosleep(struct compat_timespec __user *rqtp,
240 struct compat_timespec __user *rmtp)
242 struct timespec tu, rmt;
246 if (get_compat_timespec(&tu, rqtp))
249 if (!timespec_valid(&tu))
254 ret = hrtimer_nanosleep(&tu,
255 rmtp ? (struct timespec __user *)&rmt : NULL,
256 HRTIMER_MODE_REL, CLOCK_MONOTONIC);
260 struct restart_block *restart
261 = ¤t_thread_info()->restart_block;
263 restart->fn = compat_nanosleep_restart;
264 restart->nanosleep.compat_rmtp = rmtp;
266 if (rmtp && put_compat_timespec(&rmt, rmtp))
273 static inline long get_compat_itimerval(struct itimerval *o,
274 struct compat_itimerval __user *i)
276 return (!access_ok(VERIFY_READ, i, sizeof(*i)) ||
277 (__get_user(o->it_interval.tv_sec, &i->it_interval.tv_sec) |
278 __get_user(o->it_interval.tv_usec, &i->it_interval.tv_usec) |
279 __get_user(o->it_value.tv_sec, &i->it_value.tv_sec) |
280 __get_user(o->it_value.tv_usec, &i->it_value.tv_usec)));
283 static inline long put_compat_itimerval(struct compat_itimerval __user *o,
286 return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) ||
287 (__put_user(i->it_interval.tv_sec, &o->it_interval.tv_sec) |
288 __put_user(i->it_interval.tv_usec, &o->it_interval.tv_usec) |
289 __put_user(i->it_value.tv_sec, &o->it_value.tv_sec) |
290 __put_user(i->it_value.tv_usec, &o->it_value.tv_usec)));
293 asmlinkage long compat_sys_getitimer(int which,
294 struct compat_itimerval __user *it)
296 struct itimerval kit;
299 error = do_getitimer(which, &kit);
300 if (!error && put_compat_itimerval(it, &kit))
305 asmlinkage long compat_sys_setitimer(int which,
306 struct compat_itimerval __user *in,
307 struct compat_itimerval __user *out)
309 struct itimerval kin, kout;
313 if (get_compat_itimerval(&kin, in))
316 memset(&kin, 0, sizeof(kin));
318 error = do_setitimer(which, &kin, out ? &kout : NULL);
321 if (put_compat_itimerval(out, &kout))
326 static compat_clock_t clock_t_to_compat_clock_t(clock_t x)
328 return compat_jiffies_to_clock_t(clock_t_to_jiffies(x));
331 asmlinkage long compat_sys_times(struct compat_tms __user *tbuf)
335 struct compat_tms tmp;
338 /* Convert our struct tms to the compat version. */
339 tmp.tms_utime = clock_t_to_compat_clock_t(tms.tms_utime);
340 tmp.tms_stime = clock_t_to_compat_clock_t(tms.tms_stime);
341 tmp.tms_cutime = clock_t_to_compat_clock_t(tms.tms_cutime);
342 tmp.tms_cstime = clock_t_to_compat_clock_t(tms.tms_cstime);
343 if (copy_to_user(tbuf, &tmp, sizeof(tmp)))
346 force_successful_syscall_return();
347 return compat_jiffies_to_clock_t(jiffies);
350 #ifdef __ARCH_WANT_SYS_SIGPENDING
353 * Assumption: old_sigset_t and compat_old_sigset_t are both
354 * types that can be passed to put_user()/get_user().
357 asmlinkage long compat_sys_sigpending(compat_old_sigset_t __user *set)
361 mm_segment_t old_fs = get_fs();
364 ret = sys_sigpending((old_sigset_t __user *) &s);
367 ret = put_user(s, set);
373 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
376 * sys_sigprocmask SIG_SETMASK sets the first (compat) word of the
377 * blocked set of signals to the supplied signal set
379 static inline void compat_sig_setmask(sigset_t *blocked, compat_sigset_word set)
381 memcpy(blocked->sig, &set, sizeof(set));
384 asmlinkage long compat_sys_sigprocmask(int how,
385 compat_old_sigset_t __user *nset,
386 compat_old_sigset_t __user *oset)
388 old_sigset_t old_set, new_set;
389 sigset_t new_blocked;
391 old_set = current->blocked.sig[0];
394 if (get_user(new_set, nset))
396 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
398 new_blocked = current->blocked;
402 sigaddsetmask(&new_blocked, new_set);
405 sigdelsetmask(&new_blocked, new_set);
408 compat_sig_setmask(&new_blocked, new_set);
414 set_current_blocked(&new_blocked);
418 if (put_user(old_set, oset))
427 asmlinkage long compat_sys_setrlimit(unsigned int resource,
428 struct compat_rlimit __user *rlim)
432 if (!access_ok(VERIFY_READ, rlim, sizeof(*rlim)) ||
433 __get_user(r.rlim_cur, &rlim->rlim_cur) ||
434 __get_user(r.rlim_max, &rlim->rlim_max))
437 if (r.rlim_cur == COMPAT_RLIM_INFINITY)
438 r.rlim_cur = RLIM_INFINITY;
439 if (r.rlim_max == COMPAT_RLIM_INFINITY)
440 r.rlim_max = RLIM_INFINITY;
441 return do_prlimit(current, resource, &r, NULL);
444 #ifdef COMPAT_RLIM_OLD_INFINITY
446 asmlinkage long compat_sys_old_getrlimit(unsigned int resource,
447 struct compat_rlimit __user *rlim)
451 mm_segment_t old_fs = get_fs();
454 ret = sys_old_getrlimit(resource, &r);
458 if (r.rlim_cur > COMPAT_RLIM_OLD_INFINITY)
459 r.rlim_cur = COMPAT_RLIM_INFINITY;
460 if (r.rlim_max > COMPAT_RLIM_OLD_INFINITY)
461 r.rlim_max = COMPAT_RLIM_INFINITY;
463 if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
464 __put_user(r.rlim_cur, &rlim->rlim_cur) ||
465 __put_user(r.rlim_max, &rlim->rlim_max))
473 asmlinkage long compat_sys_getrlimit(unsigned int resource,
474 struct compat_rlimit __user *rlim)
479 ret = do_prlimit(current, resource, NULL, &r);
481 if (r.rlim_cur > COMPAT_RLIM_INFINITY)
482 r.rlim_cur = COMPAT_RLIM_INFINITY;
483 if (r.rlim_max > COMPAT_RLIM_INFINITY)
484 r.rlim_max = COMPAT_RLIM_INFINITY;
486 if (!access_ok(VERIFY_WRITE, rlim, sizeof(*rlim)) ||
487 __put_user(r.rlim_cur, &rlim->rlim_cur) ||
488 __put_user(r.rlim_max, &rlim->rlim_max))
494 int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru)
496 if (!access_ok(VERIFY_WRITE, ru, sizeof(*ru)) ||
497 __put_user(r->ru_utime.tv_sec, &ru->ru_utime.tv_sec) ||
498 __put_user(r->ru_utime.tv_usec, &ru->ru_utime.tv_usec) ||
499 __put_user(r->ru_stime.tv_sec, &ru->ru_stime.tv_sec) ||
500 __put_user(r->ru_stime.tv_usec, &ru->ru_stime.tv_usec) ||
501 __put_user(r->ru_maxrss, &ru->ru_maxrss) ||
502 __put_user(r->ru_ixrss, &ru->ru_ixrss) ||
503 __put_user(r->ru_idrss, &ru->ru_idrss) ||
504 __put_user(r->ru_isrss, &ru->ru_isrss) ||
505 __put_user(r->ru_minflt, &ru->ru_minflt) ||
506 __put_user(r->ru_majflt, &ru->ru_majflt) ||
507 __put_user(r->ru_nswap, &ru->ru_nswap) ||
508 __put_user(r->ru_inblock, &ru->ru_inblock) ||
509 __put_user(r->ru_oublock, &ru->ru_oublock) ||
510 __put_user(r->ru_msgsnd, &ru->ru_msgsnd) ||
511 __put_user(r->ru_msgrcv, &ru->ru_msgrcv) ||
512 __put_user(r->ru_nsignals, &ru->ru_nsignals) ||
513 __put_user(r->ru_nvcsw, &ru->ru_nvcsw) ||
514 __put_user(r->ru_nivcsw, &ru->ru_nivcsw))
519 asmlinkage long compat_sys_getrusage(int who, struct compat_rusage __user *ru)
523 mm_segment_t old_fs = get_fs();
526 ret = sys_getrusage(who, (struct rusage __user *) &r);
532 if (put_compat_rusage(&r, ru))
538 COMPAT_SYSCALL_DEFINE4(wait4,
540 compat_uint_t __user *, stat_addr,
542 struct compat_rusage __user *, ru)
545 return sys_wait4(pid, stat_addr, options, NULL);
550 mm_segment_t old_fs = get_fs();
555 (unsigned int __user *) &status : NULL),
556 options, (struct rusage __user *) &r);
560 if (put_compat_rusage(&r, ru))
562 if (stat_addr && put_user(status, stat_addr))
569 COMPAT_SYSCALL_DEFINE5(waitid,
570 int, which, compat_pid_t, pid,
571 struct compat_siginfo __user *, uinfo, int, options,
572 struct compat_rusage __user *, uru)
577 mm_segment_t old_fs = get_fs();
579 memset(&info, 0, sizeof(info));
582 ret = sys_waitid(which, pid, (siginfo_t __user *)&info, options,
583 uru ? (struct rusage __user *)&ru : NULL);
586 if ((ret < 0) || (info.si_signo == 0))
590 ret = put_compat_rusage(&ru, uru);
595 BUG_ON(info.si_code & __SI_MASK);
596 info.si_code |= __SI_CHLD;
597 return copy_siginfo_to_user32(uinfo, &info);
600 static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr,
601 unsigned len, struct cpumask *new_mask)
605 if (len < cpumask_size())
606 memset(new_mask, 0, cpumask_size());
607 else if (len > cpumask_size())
608 len = cpumask_size();
610 k = cpumask_bits(new_mask);
611 return compat_get_bitmap(k, user_mask_ptr, len * 8);
614 asmlinkage long compat_sys_sched_setaffinity(compat_pid_t pid,
616 compat_ulong_t __user *user_mask_ptr)
618 cpumask_var_t new_mask;
621 if (!alloc_cpumask_var(&new_mask, GFP_KERNEL))
624 retval = compat_get_user_cpu_mask(user_mask_ptr, len, new_mask);
628 retval = sched_setaffinity(pid, new_mask);
630 free_cpumask_var(new_mask);
634 asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid, unsigned int len,
635 compat_ulong_t __user *user_mask_ptr)
640 if ((len * BITS_PER_BYTE) < nr_cpu_ids)
642 if (len & (sizeof(compat_ulong_t)-1))
645 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
648 ret = sched_getaffinity(pid, mask);
650 size_t retlen = min_t(size_t, len, cpumask_size());
652 if (compat_put_bitmap(user_mask_ptr, cpumask_bits(mask), retlen * 8))
657 free_cpumask_var(mask);
662 int get_compat_itimerspec(struct itimerspec *dst,
663 const struct compat_itimerspec __user *src)
665 if (get_compat_timespec(&dst->it_interval, &src->it_interval) ||
666 get_compat_timespec(&dst->it_value, &src->it_value))
671 int put_compat_itimerspec(struct compat_itimerspec __user *dst,
672 const struct itimerspec *src)
674 if (put_compat_timespec(&src->it_interval, &dst->it_interval) ||
675 put_compat_timespec(&src->it_value, &dst->it_value))
680 long compat_sys_timer_create(clockid_t which_clock,
681 struct compat_sigevent __user *timer_event_spec,
682 timer_t __user *created_timer_id)
684 struct sigevent __user *event = NULL;
686 if (timer_event_spec) {
687 struct sigevent kevent;
689 event = compat_alloc_user_space(sizeof(*event));
690 if (get_compat_sigevent(&kevent, timer_event_spec) ||
691 copy_to_user(event, &kevent, sizeof(*event)))
695 return sys_timer_create(which_clock, event, created_timer_id);
698 long compat_sys_timer_settime(timer_t timer_id, int flags,
699 struct compat_itimerspec __user *new,
700 struct compat_itimerspec __user *old)
704 struct itimerspec newts, oldts;
708 if (get_compat_itimerspec(&newts, new))
712 err = sys_timer_settime(timer_id, flags,
713 (struct itimerspec __user *) &newts,
714 (struct itimerspec __user *) &oldts);
716 if (!err && old && put_compat_itimerspec(old, &oldts))
721 long compat_sys_timer_gettime(timer_t timer_id,
722 struct compat_itimerspec __user *setting)
726 struct itimerspec ts;
730 err = sys_timer_gettime(timer_id,
731 (struct itimerspec __user *) &ts);
733 if (!err && put_compat_itimerspec(setting, &ts))
738 long compat_sys_clock_settime(clockid_t which_clock,
739 struct compat_timespec __user *tp)
745 if (get_compat_timespec(&ts, tp))
749 err = sys_clock_settime(which_clock,
750 (struct timespec __user *) &ts);
755 long compat_sys_clock_gettime(clockid_t which_clock,
756 struct compat_timespec __user *tp)
764 err = sys_clock_gettime(which_clock,
765 (struct timespec __user *) &ts);
767 if (!err && put_compat_timespec(&ts, tp))
772 long compat_sys_clock_adjtime(clockid_t which_clock,
773 struct compat_timex __user *utp)
779 err = compat_get_timex(&txc, utp);
785 ret = sys_clock_adjtime(which_clock, (struct timex __user *) &txc);
788 err = compat_put_timex(utp, &txc);
795 long compat_sys_clock_getres(clockid_t which_clock,
796 struct compat_timespec __user *tp)
804 err = sys_clock_getres(which_clock,
805 (struct timespec __user *) &ts);
807 if (!err && tp && put_compat_timespec(&ts, tp))
812 static long compat_clock_nanosleep_restart(struct restart_block *restart)
817 struct compat_timespec *rmtp = restart->nanosleep.compat_rmtp;
819 restart->nanosleep.rmtp = (struct timespec __user *) &tu;
822 err = clock_nanosleep_restart(restart);
825 if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
826 put_compat_timespec(&tu, rmtp))
829 if (err == -ERESTART_RESTARTBLOCK) {
830 restart->fn = compat_clock_nanosleep_restart;
831 restart->nanosleep.compat_rmtp = rmtp;
836 long compat_sys_clock_nanosleep(clockid_t which_clock, int flags,
837 struct compat_timespec __user *rqtp,
838 struct compat_timespec __user *rmtp)
842 struct timespec in, out;
843 struct restart_block *restart;
845 if (get_compat_timespec(&in, rqtp))
850 err = sys_clock_nanosleep(which_clock, flags,
851 (struct timespec __user *) &in,
852 (struct timespec __user *) &out);
855 if ((err == -ERESTART_RESTARTBLOCK) && rmtp &&
856 put_compat_timespec(&out, rmtp))
859 if (err == -ERESTART_RESTARTBLOCK) {
860 restart = ¤t_thread_info()->restart_block;
861 restart->fn = compat_clock_nanosleep_restart;
862 restart->nanosleep.compat_rmtp = rmtp;
868 * We currently only need the following fields from the sigevent
869 * structure: sigev_value, sigev_signo, sig_notify and (sometimes
870 * sigev_notify_thread_id). The others are handled in user mode.
871 * We also assume that copying sigev_value.sival_int is sufficient
872 * to keep all the bits of sigev_value.sival_ptr intact.
874 int get_compat_sigevent(struct sigevent *event,
875 const struct compat_sigevent __user *u_event)
877 memset(event, 0, sizeof(*event));
878 return (!access_ok(VERIFY_READ, u_event, sizeof(*u_event)) ||
879 __get_user(event->sigev_value.sival_int,
880 &u_event->sigev_value.sival_int) ||
881 __get_user(event->sigev_signo, &u_event->sigev_signo) ||
882 __get_user(event->sigev_notify, &u_event->sigev_notify) ||
883 __get_user(event->sigev_notify_thread_id,
884 &u_event->sigev_notify_thread_id))
888 long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
889 unsigned long bitmap_size)
894 unsigned long nr_compat_longs;
896 /* align bitmap up to nearest compat_long_t boundary */
897 bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
899 if (!access_ok(VERIFY_READ, umask, bitmap_size / 8))
902 nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
904 for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
907 for (j = 0; j < sizeof(m)/sizeof(um); j++) {
909 * We dont want to read past the end of the userspace
910 * bitmap. We must however ensure the end of the
911 * kernel bitmap is zeroed.
913 if (nr_compat_longs-- > 0) {
914 if (__get_user(um, umask))
921 m |= (long)um << (j * BITS_PER_COMPAT_LONG);
929 long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
930 unsigned long bitmap_size)
935 unsigned long nr_compat_longs;
937 /* align bitmap up to nearest compat_long_t boundary */
938 bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG);
940 if (!access_ok(VERIFY_WRITE, umask, bitmap_size / 8))
943 nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size);
945 for (i = 0; i < BITS_TO_LONGS(bitmap_size); i++) {
948 for (j = 0; j < sizeof(m)/sizeof(um); j++) {
952 * We dont want to write past the end of the userspace
955 if (nr_compat_longs-- > 0) {
956 if (__put_user(um, umask))
970 sigset_from_compat (sigset_t *set, compat_sigset_t *compat)
972 switch (_NSIG_WORDS) {
973 case 4: set->sig[3] = compat->sig[6] | (((long)compat->sig[7]) << 32 );
974 case 3: set->sig[2] = compat->sig[4] | (((long)compat->sig[5]) << 32 );
975 case 2: set->sig[1] = compat->sig[2] | (((long)compat->sig[3]) << 32 );
976 case 1: set->sig[0] = compat->sig[0] | (((long)compat->sig[1]) << 32 );
979 EXPORT_SYMBOL_GPL(sigset_from_compat);
982 compat_sys_rt_sigtimedwait (compat_sigset_t __user *uthese,
983 struct compat_siginfo __user *uinfo,
984 struct compat_timespec __user *uts, compat_size_t sigsetsize)
992 if (sigsetsize != sizeof(sigset_t))
995 if (copy_from_user(&s32, uthese, sizeof(compat_sigset_t)))
997 sigset_from_compat(&s, &s32);
1000 if (get_compat_timespec(&t, uts))
1004 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
1006 if (ret > 0 && uinfo) {
1007 if (copy_siginfo_to_user32(uinfo, &info))
1016 compat_sys_rt_tgsigqueueinfo(compat_pid_t tgid, compat_pid_t pid, int sig,
1017 struct compat_siginfo __user *uinfo)
1021 if (copy_siginfo_from_user32(&info, uinfo))
1023 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
1026 #ifdef __ARCH_WANT_COMPAT_SYS_TIME
1028 /* compat_time_t is a 32 bit "long" and needs to get converted. */
1030 asmlinkage long compat_sys_time(compat_time_t __user * tloc)
1035 do_gettimeofday(&tv);
1039 if (put_user(i,tloc))
1042 force_successful_syscall_return();
1046 asmlinkage long compat_sys_stime(compat_time_t __user *tptr)
1051 if (get_user(tv.tv_sec, tptr))
1056 err = security_settime(&tv, NULL);
1060 do_settimeofday(&tv);
1064 #endif /* __ARCH_WANT_COMPAT_SYS_TIME */
1066 #ifdef __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND
1067 asmlinkage long compat_sys_rt_sigsuspend(compat_sigset_t __user *unewset, compat_size_t sigsetsize)
1070 compat_sigset_t newset32;
1072 /* XXX: Don't preclude handling different sized sigset_t's. */
1073 if (sigsetsize != sizeof(sigset_t))
1076 if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
1078 sigset_from_compat(&newset, &newset32);
1079 return sigsuspend(&newset);
1081 #endif /* __ARCH_WANT_COMPAT_SYS_RT_SIGSUSPEND */
1083 asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp)
1088 err = compat_get_timex(&txc, utp);
1092 ret = do_adjtimex(&txc);
1094 err = compat_put_timex(utp, &txc);
1102 asmlinkage long compat_sys_move_pages(pid_t pid, unsigned long nr_pages,
1103 compat_uptr_t __user *pages32,
1104 const int __user *nodes,
1108 const void __user * __user *pages;
1111 pages = compat_alloc_user_space(nr_pages * sizeof(void *));
1112 for (i = 0; i < nr_pages; i++) {
1115 if (get_user(p, pages32 + i) ||
1116 put_user(compat_ptr(p), pages + i))
1119 return sys_move_pages(pid, nr_pages, pages, nodes, status, flags);
1122 asmlinkage long compat_sys_migrate_pages(compat_pid_t pid,
1123 compat_ulong_t maxnode,
1124 const compat_ulong_t __user *old_nodes,
1125 const compat_ulong_t __user *new_nodes)
1127 unsigned long __user *old = NULL;
1128 unsigned long __user *new = NULL;
1129 nodemask_t tmp_mask;
1130 unsigned long nr_bits;
1133 nr_bits = min_t(unsigned long, maxnode - 1, MAX_NUMNODES);
1134 size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
1136 if (compat_get_bitmap(nodes_addr(tmp_mask), old_nodes, nr_bits))
1138 old = compat_alloc_user_space(new_nodes ? size * 2 : size);
1140 new = old + size / sizeof(unsigned long);
1141 if (copy_to_user(old, nodes_addr(tmp_mask), size))
1145 if (compat_get_bitmap(nodes_addr(tmp_mask), new_nodes, nr_bits))
1148 new = compat_alloc_user_space(size);
1149 if (copy_to_user(new, nodes_addr(tmp_mask), size))
1152 return sys_migrate_pages(pid, nr_bits + 1, old, new);
1156 struct compat_sysinfo {
1170 char _f[20-2*sizeof(u32)-sizeof(int)];
1174 compat_sys_sysinfo(struct compat_sysinfo __user *info)
1180 /* Check to see if any memory value is too large for 32-bit and scale
1183 if ((s.totalram >> 32) || (s.totalswap >> 32)) {
1186 while (s.mem_unit < PAGE_SIZE) {
1191 s.totalram >>= bitcount;
1192 s.freeram >>= bitcount;
1193 s.sharedram >>= bitcount;
1194 s.bufferram >>= bitcount;
1195 s.totalswap >>= bitcount;
1196 s.freeswap >>= bitcount;
1197 s.totalhigh >>= bitcount;
1198 s.freehigh >>= bitcount;
1201 if (!access_ok(VERIFY_WRITE, info, sizeof(struct compat_sysinfo)) ||
1202 __put_user (s.uptime, &info->uptime) ||
1203 __put_user (s.loads[0], &info->loads[0]) ||
1204 __put_user (s.loads[1], &info->loads[1]) ||
1205 __put_user (s.loads[2], &info->loads[2]) ||
1206 __put_user (s.totalram, &info->totalram) ||
1207 __put_user (s.freeram, &info->freeram) ||
1208 __put_user (s.sharedram, &info->sharedram) ||
1209 __put_user (s.bufferram, &info->bufferram) ||
1210 __put_user (s.totalswap, &info->totalswap) ||
1211 __put_user (s.freeswap, &info->freeswap) ||
1212 __put_user (s.procs, &info->procs) ||
1213 __put_user (s.totalhigh, &info->totalhigh) ||
1214 __put_user (s.freehigh, &info->freehigh) ||
1215 __put_user (s.mem_unit, &info->mem_unit))
1221 #ifdef __ARCH_WANT_COMPAT_SYS_SCHED_RR_GET_INTERVAL
1222 asmlinkage long compat_sys_sched_rr_get_interval(compat_pid_t pid,
1223 struct compat_timespec __user *interval)
1227 mm_segment_t old_fs = get_fs();
1230 ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t);
1232 if (put_compat_timespec(&t, interval))
1236 #endif /* __ARCH_WANT_COMPAT_SYS_SCHED_RR_GET_INTERVAL */
1239 * Allocate user-space memory for the duration of a single system call,
1240 * in order to marshall parameters inside a compat thunk.
1242 void __user *compat_alloc_user_space(unsigned long len)
1246 /* If len would occupy more than half of the entire compat space... */
1247 if (unlikely(len > (((compat_uptr_t)~0) >> 1)))
1250 ptr = arch_compat_alloc_user_space(len);
1252 if (unlikely(!access_ok(VERIFY_WRITE, ptr, len)))
1257 EXPORT_SYMBOL_GPL(compat_alloc_user_space);