| 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>
|
| 20 | #include <linux/futex.h>
|
| 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 |
|
| 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 |
|
| 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 = ¤t_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 |
|
| 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 |
|
| 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 |
|
| 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(¤t->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(¤t->blocked, ¤t->blocked, &s);
|
| 792 |
|
| 793 | recalc_sigpending();
|
| 794 | spin_unlock_irq(¤t->sighand->siglock);
|
| 795 |
|
| 796 | timeout = schedule_timeout_interruptible(timeout);
|
| 797 |
|
| 798 | spin_lock_irq(¤t->sighand->siglock);
|
| 799 | sig = dequeue_signal(current, &s, &info);
|
| 800 | current->blocked = current->real_blocked;
|
| 801 | siginitset(¤t->real_blocked, 0);
|
| 802 | recalc_sigpending();
|
| 803 | }
|
| 804 | }
|
| 805 | spin_unlock_irq(¤t->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 |
|
| 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
|