Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/syscalls.h> |
| 21 | #include <linux/unistd.h> |
| 22 | #include <linux/security.h> |
Stephen Rothwell | 3158e94 | 2006-03-26 01:37:29 -0800 | [diff] [blame] | 23 | #include <linux/timex.h> |
Paul Gortmaker | 6e5fdee | 2011-05-26 16:00:52 -0400 | [diff] [blame] | 24 | #include <linux/export.h> |
Christoph Lameter | 1b2db9f | 2006-06-23 02:03:56 -0700 | [diff] [blame] | 25 | #include <linux/migrate.h> |
Toyo Abe | 1711ef38 | 2006-09-29 02:00:28 -0700 | [diff] [blame] | 26 | #include <linux/posix-timers.h> |
Frank Mayhar | f06febc | 2008-09-12 09:54:39 -0700 | [diff] [blame] | 27 | #include <linux/times.h> |
Paul Mackerras | e3d5a27 | 2009-01-06 14:41:02 -0800 | [diff] [blame] | 28 | #include <linux/ptrace.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 29 | #include <linux/gfp.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | |
Linus Torvalds | 7c0f6ba | 2016-12-24 11:46:01 -0800 | [diff] [blame] | 31 | #include <linux/uaccess.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 32 | |
Al Viro | 3a4d44b | 2017-06-07 09:42:34 +0100 | [diff] [blame] | 33 | int compat_get_timex(struct timex *txc, const struct compat_timex __user *utp) |
Richard Cochran | 65f5d80 | 2011-02-01 13:52:23 +0000 | [diff] [blame] | 34 | { |
Al Viro | 3a4d44b | 2017-06-07 09:42:34 +0100 | [diff] [blame] | 35 | struct compat_timex tx32; |
Richard Cochran | 65f5d80 | 2011-02-01 13:52:23 +0000 | [diff] [blame] | 36 | |
Al Viro | 3a4d44b | 2017-06-07 09:42:34 +0100 | [diff] [blame] | 37 | if (copy_from_user(&tx32, utp, sizeof(struct compat_timex))) |
Richard Cochran | 65f5d80 | 2011-02-01 13:52:23 +0000 | [diff] [blame] | 38 | return -EFAULT; |
| 39 | |
Al Viro | 3a4d44b | 2017-06-07 09:42:34 +0100 | [diff] [blame] | 40 | txc->modes = tx32.modes; |
| 41 | txc->offset = tx32.offset; |
| 42 | txc->freq = tx32.freq; |
| 43 | txc->maxerror = tx32.maxerror; |
| 44 | txc->esterror = tx32.esterror; |
| 45 | txc->status = tx32.status; |
| 46 | txc->constant = tx32.constant; |
| 47 | txc->precision = tx32.precision; |
| 48 | txc->tolerance = tx32.tolerance; |
| 49 | txc->time.tv_sec = tx32.time.tv_sec; |
| 50 | txc->time.tv_usec = tx32.time.tv_usec; |
| 51 | txc->tick = tx32.tick; |
| 52 | txc->ppsfreq = tx32.ppsfreq; |
| 53 | txc->jitter = tx32.jitter; |
| 54 | txc->shift = tx32.shift; |
| 55 | txc->stabil = tx32.stabil; |
| 56 | txc->jitcnt = tx32.jitcnt; |
| 57 | txc->calcnt = tx32.calcnt; |
| 58 | txc->errcnt = tx32.errcnt; |
| 59 | txc->stbcnt = tx32.stbcnt; |
| 60 | |
Richard Cochran | 65f5d80 | 2011-02-01 13:52:23 +0000 | [diff] [blame] | 61 | return 0; |
| 62 | } |
| 63 | |
Al Viro | 3a4d44b | 2017-06-07 09:42:34 +0100 | [diff] [blame] | 64 | int compat_put_timex(struct compat_timex __user *utp, const struct timex *txc) |
Richard Cochran | 65f5d80 | 2011-02-01 13:52:23 +0000 | [diff] [blame] | 65 | { |
Al Viro | 3a4d44b | 2017-06-07 09:42:34 +0100 | [diff] [blame] | 66 | struct compat_timex tx32; |
| 67 | |
| 68 | memset(&tx32, 0, sizeof(struct compat_timex)); |
| 69 | tx32.modes = txc->modes; |
| 70 | tx32.offset = txc->offset; |
| 71 | tx32.freq = txc->freq; |
| 72 | tx32.maxerror = txc->maxerror; |
| 73 | tx32.esterror = txc->esterror; |
| 74 | tx32.status = txc->status; |
| 75 | tx32.constant = txc->constant; |
| 76 | tx32.precision = txc->precision; |
| 77 | tx32.tolerance = txc->tolerance; |
| 78 | tx32.time.tv_sec = txc->time.tv_sec; |
| 79 | tx32.time.tv_usec = txc->time.tv_usec; |
| 80 | tx32.tick = txc->tick; |
| 81 | tx32.ppsfreq = txc->ppsfreq; |
| 82 | tx32.jitter = txc->jitter; |
| 83 | tx32.shift = txc->shift; |
| 84 | tx32.stabil = txc->stabil; |
| 85 | tx32.jitcnt = txc->jitcnt; |
| 86 | tx32.calcnt = txc->calcnt; |
| 87 | tx32.errcnt = txc->errcnt; |
| 88 | tx32.stbcnt = txc->stbcnt; |
| 89 | tx32.tai = txc->tai; |
| 90 | if (copy_to_user(utp, &tx32, sizeof(struct compat_timex))) |
Richard Cochran | 65f5d80 | 2011-02-01 13:52:23 +0000 | [diff] [blame] | 91 | return -EFAULT; |
| 92 | return 0; |
| 93 | } |
| 94 | |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 95 | static int __compat_get_timeval(struct timeval *tv, const struct compat_timeval __user *ctv) |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 96 | { |
| 97 | return (!access_ok(VERIFY_READ, ctv, sizeof(*ctv)) || |
| 98 | __get_user(tv->tv_sec, &ctv->tv_sec) || |
| 99 | __get_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0; |
| 100 | } |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 101 | |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 102 | static int __compat_put_timeval(const struct timeval *tv, struct compat_timeval __user *ctv) |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 103 | { |
| 104 | return (!access_ok(VERIFY_WRITE, ctv, sizeof(*ctv)) || |
| 105 | __put_user(tv->tv_sec, &ctv->tv_sec) || |
| 106 | __put_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0; |
| 107 | } |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 108 | |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 109 | static int __compat_get_timespec(struct timespec *ts, const struct compat_timespec __user *cts) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | { |
| 111 | return (!access_ok(VERIFY_READ, cts, sizeof(*cts)) || |
| 112 | __get_user(ts->tv_sec, &cts->tv_sec) || |
| 113 | __get_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0; |
| 114 | } |
| 115 | |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 116 | static int __compat_put_timespec(const struct timespec *ts, struct compat_timespec __user *cts) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | { |
| 118 | return (!access_ok(VERIFY_WRITE, cts, sizeof(*cts)) || |
| 119 | __put_user(ts->tv_sec, &cts->tv_sec) || |
| 120 | __put_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0; |
| 121 | } |
| 122 | |
Deepa Dinamani | f59dd9c | 2017-06-24 11:45:02 -0700 | [diff] [blame] | 123 | static int __compat_get_timespec64(struct timespec64 *ts64, |
| 124 | const struct compat_timespec __user *cts) |
| 125 | { |
| 126 | struct compat_timespec ts; |
| 127 | int ret; |
| 128 | |
| 129 | ret = copy_from_user(&ts, cts, sizeof(ts)); |
| 130 | if (ret) |
| 131 | return -EFAULT; |
| 132 | |
| 133 | ts64->tv_sec = ts.tv_sec; |
| 134 | ts64->tv_nsec = ts.tv_nsec; |
| 135 | |
| 136 | return 0; |
| 137 | } |
| 138 | |
| 139 | static int __compat_put_timespec64(const struct timespec64 *ts64, |
| 140 | struct compat_timespec __user *cts) |
| 141 | { |
| 142 | struct compat_timespec ts = { |
| 143 | .tv_sec = ts64->tv_sec, |
| 144 | .tv_nsec = ts64->tv_nsec |
| 145 | }; |
| 146 | return copy_to_user(cts, &ts, sizeof(ts)) ? -EFAULT : 0; |
| 147 | } |
| 148 | |
| 149 | int compat_get_timespec64(struct timespec64 *ts, const void __user *uts) |
| 150 | { |
| 151 | if (COMPAT_USE_64BIT_TIME) |
| 152 | return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0; |
| 153 | else |
| 154 | return __compat_get_timespec64(ts, uts); |
| 155 | } |
| 156 | EXPORT_SYMBOL_GPL(compat_get_timespec64); |
| 157 | |
| 158 | int compat_put_timespec64(const struct timespec64 *ts, void __user *uts) |
| 159 | { |
| 160 | if (COMPAT_USE_64BIT_TIME) |
| 161 | return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0; |
| 162 | else |
| 163 | return __compat_put_timespec64(ts, uts); |
| 164 | } |
| 165 | EXPORT_SYMBOL_GPL(compat_put_timespec64); |
| 166 | |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 167 | int compat_get_timeval(struct timeval *tv, const void __user *utv) |
| 168 | { |
| 169 | if (COMPAT_USE_64BIT_TIME) |
Fabian Frederick | 6516a46 | 2014-06-04 16:12:02 -0700 | [diff] [blame] | 170 | return copy_from_user(tv, utv, sizeof(*tv)) ? -EFAULT : 0; |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 171 | else |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 172 | return __compat_get_timeval(tv, utv); |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 173 | } |
| 174 | EXPORT_SYMBOL_GPL(compat_get_timeval); |
| 175 | |
| 176 | int compat_put_timeval(const struct timeval *tv, void __user *utv) |
| 177 | { |
| 178 | if (COMPAT_USE_64BIT_TIME) |
Fabian Frederick | 6516a46 | 2014-06-04 16:12:02 -0700 | [diff] [blame] | 179 | return copy_to_user(utv, tv, sizeof(*tv)) ? -EFAULT : 0; |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 180 | else |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 181 | return __compat_put_timeval(tv, utv); |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 182 | } |
| 183 | EXPORT_SYMBOL_GPL(compat_put_timeval); |
| 184 | |
| 185 | int compat_get_timespec(struct timespec *ts, const void __user *uts) |
| 186 | { |
| 187 | if (COMPAT_USE_64BIT_TIME) |
Fabian Frederick | 6516a46 | 2014-06-04 16:12:02 -0700 | [diff] [blame] | 188 | return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0; |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 189 | else |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 190 | return __compat_get_timespec(ts, uts); |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 191 | } |
| 192 | EXPORT_SYMBOL_GPL(compat_get_timespec); |
| 193 | |
| 194 | int compat_put_timespec(const struct timespec *ts, void __user *uts) |
| 195 | { |
| 196 | if (COMPAT_USE_64BIT_TIME) |
Fabian Frederick | 6516a46 | 2014-06-04 16:12:02 -0700 | [diff] [blame] | 197 | return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0; |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 198 | else |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 199 | return __compat_put_timespec(ts, uts); |
H. Peter Anvin | 6684ba2 | 2012-02-19 17:38:00 -0800 | [diff] [blame] | 200 | } |
| 201 | EXPORT_SYMBOL_GPL(compat_put_timespec); |
| 202 | |
Al Viro | 54ad9c4 | 2017-06-07 09:42:37 +0100 | [diff] [blame] | 203 | int get_compat_itimerval(struct itimerval *o, const struct compat_itimerval __user *i) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 204 | { |
Al Viro | 54ad9c4 | 2017-06-07 09:42:37 +0100 | [diff] [blame] | 205 | struct compat_itimerval v32; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | |
Al Viro | 54ad9c4 | 2017-06-07 09:42:37 +0100 | [diff] [blame] | 207 | if (copy_from_user(&v32, i, sizeof(struct compat_itimerval))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 208 | return -EFAULT; |
Al Viro | 54ad9c4 | 2017-06-07 09:42:37 +0100 | [diff] [blame] | 209 | o->it_interval.tv_sec = v32.it_interval.tv_sec; |
| 210 | o->it_interval.tv_usec = v32.it_interval.tv_usec; |
| 211 | o->it_value.tv_sec = v32.it_value.tv_sec; |
| 212 | o->it_value.tv_usec = v32.it_value.tv_usec; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 213 | return 0; |
| 214 | } |
| 215 | |
Al Viro | 54ad9c4 | 2017-06-07 09:42:37 +0100 | [diff] [blame] | 216 | int put_compat_itimerval(struct compat_itimerval __user *o, const struct itimerval *i) |
| 217 | { |
| 218 | struct compat_itimerval v32; |
| 219 | |
| 220 | v32.it_interval.tv_sec = i->it_interval.tv_sec; |
| 221 | v32.it_interval.tv_usec = i->it_interval.tv_usec; |
| 222 | v32.it_value.tv_sec = i->it_value.tv_sec; |
| 223 | v32.it_value.tv_usec = i->it_value.tv_usec; |
| 224 | return copy_to_user(o, &v32, sizeof(struct compat_itimerval)) ? -EFAULT : 0; |
| 225 | } |
| 226 | |
Chris Metcalf | be84cb4 | 2011-05-09 13:12:30 -0400 | [diff] [blame] | 227 | #ifdef __ARCH_WANT_SYS_SIGPROCMASK |
| 228 | |
Jan Kiszka | b7dafa0 | 2012-05-10 10:04:36 -0300 | [diff] [blame] | 229 | /* |
| 230 | * sys_sigprocmask SIG_SETMASK sets the first (compat) word of the |
| 231 | * blocked set of signals to the supplied signal set |
| 232 | */ |
| 233 | static inline void compat_sig_setmask(sigset_t *blocked, compat_sigset_word set) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | { |
Jan Kiszka | b7dafa0 | 2012-05-10 10:04:36 -0300 | [diff] [blame] | 235 | memcpy(blocked->sig, &set, sizeof(set)); |
| 236 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 237 | |
Al Viro | 5cf2210 | 2012-11-25 19:41:01 -0500 | [diff] [blame] | 238 | COMPAT_SYSCALL_DEFINE3(sigprocmask, int, how, |
| 239 | compat_old_sigset_t __user *, nset, |
| 240 | compat_old_sigset_t __user *, oset) |
Jan Kiszka | b7dafa0 | 2012-05-10 10:04:36 -0300 | [diff] [blame] | 241 | { |
| 242 | old_sigset_t old_set, new_set; |
| 243 | sigset_t new_blocked; |
| 244 | |
| 245 | old_set = current->blocked.sig[0]; |
| 246 | |
| 247 | if (nset) { |
| 248 | if (get_user(new_set, nset)) |
| 249 | return -EFAULT; |
| 250 | new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP)); |
| 251 | |
| 252 | new_blocked = current->blocked; |
| 253 | |
| 254 | switch (how) { |
| 255 | case SIG_BLOCK: |
| 256 | sigaddsetmask(&new_blocked, new_set); |
| 257 | break; |
| 258 | case SIG_UNBLOCK: |
| 259 | sigdelsetmask(&new_blocked, new_set); |
| 260 | break; |
| 261 | case SIG_SETMASK: |
| 262 | compat_sig_setmask(&new_blocked, new_set); |
| 263 | break; |
| 264 | default: |
| 265 | return -EINVAL; |
| 266 | } |
| 267 | |
| 268 | set_current_blocked(&new_blocked); |
| 269 | } |
| 270 | |
| 271 | if (oset) { |
| 272 | if (put_user(old_set, oset)) |
| 273 | return -EFAULT; |
| 274 | } |
| 275 | |
| 276 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | } |
| 278 | |
Chris Metcalf | be84cb4 | 2011-05-09 13:12:30 -0400 | [diff] [blame] | 279 | #endif |
| 280 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 281 | int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru) |
| 282 | { |
Al Viro | 7668b67 | 2017-05-31 06:39:31 -0400 | [diff] [blame] | 283 | struct compat_rusage r32; |
| 284 | memset(&r32, 0, sizeof(r32)); |
| 285 | r32.ru_utime.tv_sec = r->ru_utime.tv_sec; |
| 286 | r32.ru_utime.tv_usec = r->ru_utime.tv_usec; |
| 287 | r32.ru_stime.tv_sec = r->ru_stime.tv_sec; |
| 288 | r32.ru_stime.tv_usec = r->ru_stime.tv_usec; |
| 289 | r32.ru_maxrss = r->ru_maxrss; |
| 290 | r32.ru_ixrss = r->ru_ixrss; |
| 291 | r32.ru_idrss = r->ru_idrss; |
| 292 | r32.ru_isrss = r->ru_isrss; |
| 293 | r32.ru_minflt = r->ru_minflt; |
| 294 | r32.ru_majflt = r->ru_majflt; |
| 295 | r32.ru_nswap = r->ru_nswap; |
| 296 | r32.ru_inblock = r->ru_inblock; |
| 297 | r32.ru_oublock = r->ru_oublock; |
| 298 | r32.ru_msgsnd = r->ru_msgsnd; |
| 299 | r32.ru_msgrcv = r->ru_msgrcv; |
| 300 | r32.ru_nsignals = r->ru_nsignals; |
| 301 | r32.ru_nvcsw = r->ru_nvcsw; |
| 302 | r32.ru_nivcsw = r->ru_nivcsw; |
| 303 | if (copy_to_user(ru, &r32, sizeof(r32))) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 304 | return -EFAULT; |
| 305 | return 0; |
| 306 | } |
| 307 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 308 | static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr, |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 309 | unsigned len, struct cpumask *new_mask) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 310 | { |
| 311 | unsigned long *k; |
| 312 | |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 313 | if (len < cpumask_size()) |
| 314 | memset(new_mask, 0, cpumask_size()); |
| 315 | else if (len > cpumask_size()) |
| 316 | len = cpumask_size(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 317 | |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 318 | k = cpumask_bits(new_mask); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | return compat_get_bitmap(k, user_mask_ptr, len * 8); |
| 320 | } |
| 321 | |
Heiko Carstens | 62a6fa97 | 2014-03-03 16:11:13 +0100 | [diff] [blame] | 322 | COMPAT_SYSCALL_DEFINE3(sched_setaffinity, compat_pid_t, pid, |
| 323 | unsigned int, len, |
| 324 | compat_ulong_t __user *, user_mask_ptr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 325 | { |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 326 | cpumask_var_t new_mask; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 327 | int retval; |
| 328 | |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 329 | if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) |
| 330 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 331 | |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 332 | retval = compat_get_user_cpu_mask(user_mask_ptr, len, new_mask); |
| 333 | if (retval) |
| 334 | goto out; |
| 335 | |
| 336 | retval = sched_setaffinity(pid, new_mask); |
| 337 | out: |
| 338 | free_cpumask_var(new_mask); |
| 339 | return retval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | } |
| 341 | |
Heiko Carstens | 62a6fa97 | 2014-03-03 16:11:13 +0100 | [diff] [blame] | 342 | COMPAT_SYSCALL_DEFINE3(sched_getaffinity, compat_pid_t, pid, unsigned int, len, |
| 343 | compat_ulong_t __user *, user_mask_ptr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | { |
| 345 | int ret; |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 346 | cpumask_var_t mask; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 347 | |
KOSAKI Motohiro | fa9dc26 | 2010-05-19 09:37:41 +0900 | [diff] [blame] | 348 | if ((len * BITS_PER_BYTE) < nr_cpu_ids) |
| 349 | return -EINVAL; |
| 350 | if (len & (sizeof(compat_ulong_t)-1)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | return -EINVAL; |
| 352 | |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 353 | if (!alloc_cpumask_var(&mask, GFP_KERNEL)) |
| 354 | return -ENOMEM; |
| 355 | |
| 356 | ret = sched_getaffinity(pid, mask); |
KOSAKI Motohiro | fa9dc26 | 2010-05-19 09:37:41 +0900 | [diff] [blame] | 357 | if (ret == 0) { |
| 358 | size_t retlen = min_t(size_t, len, cpumask_size()); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 359 | |
KOSAKI Motohiro | fa9dc26 | 2010-05-19 09:37:41 +0900 | [diff] [blame] | 360 | if (compat_put_bitmap(user_mask_ptr, cpumask_bits(mask), retlen * 8)) |
| 361 | ret = -EFAULT; |
| 362 | else |
| 363 | ret = retlen; |
| 364 | } |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 365 | free_cpumask_var(mask); |
KOSAKI Motohiro | fa9dc26 | 2010-05-19 09:37:41 +0900 | [diff] [blame] | 366 | |
Rusty Russell | a45185d | 2009-01-01 10:12:24 +1030 | [diff] [blame] | 367 | return ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 368 | } |
| 369 | |
Davide Libenzi | 83f5d12 | 2007-05-10 22:23:18 -0700 | [diff] [blame] | 370 | int get_compat_itimerspec(struct itimerspec *dst, |
| 371 | const struct compat_itimerspec __user *src) |
Daniel Walker | bd3a849 | 2007-10-18 03:06:09 -0700 | [diff] [blame] | 372 | { |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 373 | if (__compat_get_timespec(&dst->it_interval, &src->it_interval) || |
| 374 | __compat_get_timespec(&dst->it_value, &src->it_value)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 375 | return -EFAULT; |
| 376 | return 0; |
Daniel Walker | bd3a849 | 2007-10-18 03:06:09 -0700 | [diff] [blame] | 377 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 378 | |
Davide Libenzi | 83f5d12 | 2007-05-10 22:23:18 -0700 | [diff] [blame] | 379 | int put_compat_itimerspec(struct compat_itimerspec __user *dst, |
| 380 | const struct itimerspec *src) |
Daniel Walker | bd3a849 | 2007-10-18 03:06:09 -0700 | [diff] [blame] | 381 | { |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 382 | if (__compat_put_timespec(&src->it_interval, &dst->it_interval) || |
| 383 | __compat_put_timespec(&src->it_value, &dst->it_value)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 384 | return -EFAULT; |
| 385 | return 0; |
Daniel Walker | bd3a849 | 2007-10-18 03:06:09 -0700 | [diff] [blame] | 386 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 387 | |
Deepa Dinamani | d5b7ffb | 2017-06-24 11:45:03 -0700 | [diff] [blame] | 388 | int get_compat_itimerspec64(struct itimerspec64 *its, |
| 389 | const struct compat_itimerspec __user *uits) |
| 390 | { |
| 391 | |
| 392 | if (__compat_get_timespec64(&its->it_interval, &uits->it_interval) || |
| 393 | __compat_get_timespec64(&its->it_value, &uits->it_value)) |
| 394 | return -EFAULT; |
| 395 | return 0; |
| 396 | } |
| 397 | EXPORT_SYMBOL_GPL(get_compat_itimerspec64); |
| 398 | |
| 399 | int put_compat_itimerspec64(const struct itimerspec64 *its, |
| 400 | struct compat_itimerspec __user *uits) |
| 401 | { |
| 402 | if (__compat_put_timespec64(&its->it_interval, &uits->it_interval) || |
| 403 | __compat_put_timespec64(&its->it_value, &uits->it_value)) |
| 404 | return -EFAULT; |
| 405 | return 0; |
| 406 | } |
| 407 | EXPORT_SYMBOL_GPL(put_compat_itimerspec64); |
| 408 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 409 | /* |
| 410 | * We currently only need the following fields from the sigevent |
| 411 | * structure: sigev_value, sigev_signo, sig_notify and (sometimes |
| 412 | * sigev_notify_thread_id). The others are handled in user mode. |
| 413 | * We also assume that copying sigev_value.sival_int is sufficient |
| 414 | * to keep all the bits of sigev_value.sival_ptr intact. |
| 415 | */ |
| 416 | int get_compat_sigevent(struct sigevent *event, |
| 417 | const struct compat_sigevent __user *u_event) |
| 418 | { |
David S. Miller | 51410d3 | 2005-04-16 15:24:01 -0700 | [diff] [blame] | 419 | memset(event, 0, sizeof(*event)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 420 | return (!access_ok(VERIFY_READ, u_event, sizeof(*u_event)) || |
| 421 | __get_user(event->sigev_value.sival_int, |
| 422 | &u_event->sigev_value.sival_int) || |
| 423 | __get_user(event->sigev_signo, &u_event->sigev_signo) || |
| 424 | __get_user(event->sigev_notify, &u_event->sigev_notify) || |
| 425 | __get_user(event->sigev_notify_thread_id, |
| 426 | &u_event->sigev_notify_thread_id)) |
| 427 | ? -EFAULT : 0; |
| 428 | } |
| 429 | |
Stephen Rothwell | 5fa3839 | 2006-10-28 10:38:46 -0700 | [diff] [blame] | 430 | long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 431 | unsigned long bitmap_size) |
| 432 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | unsigned long nr_compat_longs; |
| 434 | |
| 435 | /* align bitmap up to nearest compat_long_t boundary */ |
| 436 | bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG); |
Al Viro | 1e1fc13 | 2017-05-30 00:29:38 -0400 | [diff] [blame] | 437 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 438 | |
| 439 | if (!access_ok(VERIFY_READ, umask, bitmap_size / 8)) |
| 440 | return -EFAULT; |
| 441 | |
Al Viro | 1e1fc13 | 2017-05-30 00:29:38 -0400 | [diff] [blame] | 442 | user_access_begin(); |
| 443 | while (nr_compat_longs > 1) { |
| 444 | compat_ulong_t l1, l2; |
| 445 | unsafe_get_user(l1, umask++, Efault); |
| 446 | unsafe_get_user(l2, umask++, Efault); |
| 447 | *mask++ = ((unsigned long)l2 << BITS_PER_COMPAT_LONG) | l1; |
| 448 | nr_compat_longs -= 2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 449 | } |
Al Viro | 1e1fc13 | 2017-05-30 00:29:38 -0400 | [diff] [blame] | 450 | if (nr_compat_longs) |
| 451 | unsafe_get_user(*mask, umask++, Efault); |
| 452 | user_access_end(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 453 | return 0; |
Al Viro | 1e1fc13 | 2017-05-30 00:29:38 -0400 | [diff] [blame] | 454 | |
| 455 | Efault: |
| 456 | user_access_end(); |
| 457 | return -EFAULT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 458 | } |
| 459 | |
| 460 | long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask, |
| 461 | unsigned long bitmap_size) |
| 462 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 463 | unsigned long nr_compat_longs; |
| 464 | |
| 465 | /* align bitmap up to nearest compat_long_t boundary */ |
| 466 | bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG); |
Al Viro | 1e1fc13 | 2017-05-30 00:29:38 -0400 | [diff] [blame] | 467 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | |
| 469 | if (!access_ok(VERIFY_WRITE, umask, bitmap_size / 8)) |
| 470 | return -EFAULT; |
| 471 | |
Al Viro | 1e1fc13 | 2017-05-30 00:29:38 -0400 | [diff] [blame] | 472 | user_access_begin(); |
| 473 | while (nr_compat_longs > 1) { |
| 474 | unsigned long m = *mask++; |
| 475 | unsafe_put_user((compat_ulong_t)m, umask++, Efault); |
| 476 | unsafe_put_user(m >> BITS_PER_COMPAT_LONG, umask++, Efault); |
| 477 | nr_compat_longs -= 2; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 478 | } |
Al Viro | 1e1fc13 | 2017-05-30 00:29:38 -0400 | [diff] [blame] | 479 | if (nr_compat_longs) |
| 480 | unsafe_put_user((compat_ulong_t)*mask, umask++, Efault); |
| 481 | user_access_end(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 482 | return 0; |
Al Viro | 1e1fc13 | 2017-05-30 00:29:38 -0400 | [diff] [blame] | 483 | Efault: |
| 484 | user_access_end(); |
| 485 | return -EFAULT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 486 | } |
| 487 | |
| 488 | void |
Al Viro | 322a56c | 2012-12-25 13:32:58 -0500 | [diff] [blame] | 489 | sigset_from_compat(sigset_t *set, const compat_sigset_t *compat) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 490 | { |
| 491 | switch (_NSIG_WORDS) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 492 | case 4: set->sig[3] = compat->sig[6] | (((long)compat->sig[7]) << 32 ); |
| 493 | case 3: set->sig[2] = compat->sig[4] | (((long)compat->sig[5]) << 32 ); |
| 494 | case 2: set->sig[1] = compat->sig[2] | (((long)compat->sig[3]) << 32 ); |
| 495 | case 1: set->sig[0] = compat->sig[0] | (((long)compat->sig[1]) << 32 ); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 496 | } |
| 497 | } |
Alexander Graf | 1dda606 | 2011-06-08 02:45:37 +0200 | [diff] [blame] | 498 | EXPORT_SYMBOL_GPL(sigset_from_compat); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 499 | |
Al Viro | 322a56c | 2012-12-25 13:32:58 -0500 | [diff] [blame] | 500 | void |
| 501 | sigset_to_compat(compat_sigset_t *compat, const sigset_t *set) |
| 502 | { |
| 503 | switch (_NSIG_WORDS) { |
| 504 | case 4: compat->sig[7] = (set->sig[3] >> 32); compat->sig[6] = set->sig[3]; |
| 505 | case 3: compat->sig[5] = (set->sig[2] >> 32); compat->sig[4] = set->sig[2]; |
| 506 | case 2: compat->sig[3] = (set->sig[1] >> 32); compat->sig[2] = set->sig[1]; |
| 507 | case 1: compat->sig[1] = (set->sig[0] >> 32); compat->sig[0] = set->sig[0]; |
| 508 | } |
| 509 | } |
| 510 | |
Christoph Lameter | 1b2db9f | 2006-06-23 02:03:56 -0700 | [diff] [blame] | 511 | #ifdef CONFIG_NUMA |
Heiko Carstens | 2f2728f | 2014-03-04 17:18:23 +0100 | [diff] [blame] | 512 | COMPAT_SYSCALL_DEFINE6(move_pages, pid_t, pid, compat_ulong_t, nr_pages, |
| 513 | compat_uptr_t __user *, pages32, |
| 514 | const int __user *, nodes, |
| 515 | int __user *, status, |
| 516 | int, flags) |
Christoph Lameter | 1b2db9f | 2006-06-23 02:03:56 -0700 | [diff] [blame] | 517 | { |
| 518 | const void __user * __user *pages; |
| 519 | int i; |
| 520 | |
| 521 | pages = compat_alloc_user_space(nr_pages * sizeof(void *)); |
| 522 | for (i = 0; i < nr_pages; i++) { |
| 523 | compat_uptr_t p; |
| 524 | |
Christoph Lameter | 9216dfa | 2006-06-23 02:03:57 -0700 | [diff] [blame] | 525 | if (get_user(p, pages32 + i) || |
Christoph Lameter | 1b2db9f | 2006-06-23 02:03:56 -0700 | [diff] [blame] | 526 | put_user(compat_ptr(p), pages + i)) |
| 527 | return -EFAULT; |
| 528 | } |
| 529 | return sys_move_pages(pid, nr_pages, pages, nodes, status, flags); |
| 530 | } |
Stephen Rothwell | 3fd5939 | 2006-11-02 22:07:24 -0800 | [diff] [blame] | 531 | |
Heiko Carstens | 62a6fa97 | 2014-03-03 16:11:13 +0100 | [diff] [blame] | 532 | COMPAT_SYSCALL_DEFINE4(migrate_pages, compat_pid_t, pid, |
| 533 | compat_ulong_t, maxnode, |
| 534 | const compat_ulong_t __user *, old_nodes, |
| 535 | const compat_ulong_t __user *, new_nodes) |
Stephen Rothwell | 3fd5939 | 2006-11-02 22:07:24 -0800 | [diff] [blame] | 536 | { |
| 537 | unsigned long __user *old = NULL; |
| 538 | unsigned long __user *new = NULL; |
| 539 | nodemask_t tmp_mask; |
| 540 | unsigned long nr_bits; |
| 541 | unsigned long size; |
| 542 | |
| 543 | nr_bits = min_t(unsigned long, maxnode - 1, MAX_NUMNODES); |
| 544 | size = ALIGN(nr_bits, BITS_PER_LONG) / 8; |
| 545 | if (old_nodes) { |
| 546 | if (compat_get_bitmap(nodes_addr(tmp_mask), old_nodes, nr_bits)) |
| 547 | return -EFAULT; |
| 548 | old = compat_alloc_user_space(new_nodes ? size * 2 : size); |
| 549 | if (new_nodes) |
| 550 | new = old + size / sizeof(unsigned long); |
| 551 | if (copy_to_user(old, nodes_addr(tmp_mask), size)) |
| 552 | return -EFAULT; |
| 553 | } |
| 554 | if (new_nodes) { |
| 555 | if (compat_get_bitmap(nodes_addr(tmp_mask), new_nodes, nr_bits)) |
| 556 | return -EFAULT; |
| 557 | if (new == NULL) |
| 558 | new = compat_alloc_user_space(size); |
| 559 | if (copy_to_user(new, nodes_addr(tmp_mask), size)) |
| 560 | return -EFAULT; |
| 561 | } |
| 562 | return sys_migrate_pages(pid, nr_bits + 1, old, new); |
| 563 | } |
Christoph Lameter | 1b2db9f | 2006-06-23 02:03:56 -0700 | [diff] [blame] | 564 | #endif |
Kyle McMartin | d4d23ad | 2007-02-10 01:46:00 -0800 | [diff] [blame] | 565 | |
Al Viro | 6883da8 | 2012-12-25 16:59:28 -0500 | [diff] [blame] | 566 | COMPAT_SYSCALL_DEFINE2(sched_rr_get_interval, |
| 567 | compat_pid_t, pid, |
| 568 | struct compat_timespec __user *, interval) |
Catalin Marinas | 0ad50c3 | 2012-12-17 16:01:45 -0800 | [diff] [blame] | 569 | { |
| 570 | struct timespec t; |
| 571 | int ret; |
| 572 | mm_segment_t old_fs = get_fs(); |
| 573 | |
| 574 | set_fs(KERNEL_DS); |
| 575 | ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t); |
| 576 | set_fs(old_fs); |
H. Peter Anvin | 81993e8 | 2014-02-01 18:54:11 -0800 | [diff] [blame] | 577 | if (compat_put_timespec(&t, interval)) |
Catalin Marinas | 0ad50c3 | 2012-12-17 16:01:45 -0800 | [diff] [blame] | 578 | return -EFAULT; |
| 579 | return ret; |
| 580 | } |
Catalin Marinas | 0ad50c3 | 2012-12-17 16:01:45 -0800 | [diff] [blame] | 581 | |
H. Peter Anvin | c41d68a | 2010-09-07 16:16:18 -0700 | [diff] [blame] | 582 | /* |
| 583 | * Allocate user-space memory for the duration of a single system call, |
| 584 | * in order to marshall parameters inside a compat thunk. |
| 585 | */ |
| 586 | void __user *compat_alloc_user_space(unsigned long len) |
| 587 | { |
| 588 | void __user *ptr; |
| 589 | |
| 590 | /* If len would occupy more than half of the entire compat space... */ |
| 591 | if (unlikely(len > (((compat_uptr_t)~0) >> 1))) |
| 592 | return NULL; |
| 593 | |
| 594 | ptr = arch_compat_alloc_user_space(len); |
| 595 | |
| 596 | if (unlikely(!access_ok(VERIFY_WRITE, ptr, len))) |
| 597 | return NULL; |
| 598 | |
| 599 | return ptr; |
| 600 | } |
| 601 | EXPORT_SYMBOL_GPL(compat_alloc_user_space); |