]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 */ | |
1da177e4 LT |
20 | #include <linux/syscalls.h> |
21 | #include <linux/unistd.h> | |
22 | #include <linux/security.h> | |
3158e941 | 23 | #include <linux/timex.h> |
6e5fdeed | 24 | #include <linux/export.h> |
1b2db9fb | 25 | #include <linux/migrate.h> |
1711ef38 | 26 | #include <linux/posix-timers.h> |
f06febc9 | 27 | #include <linux/times.h> |
e3d5a27d | 28 | #include <linux/ptrace.h> |
5a0e3ad6 | 29 | #include <linux/gfp.h> |
1da177e4 | 30 | |
7c0f6ba6 | 31 | #include <linux/uaccess.h> |
1da177e4 | 32 | |
3a4d44b6 AV |
33 | int compat_get_timex(struct timex *txc, const struct compat_timex __user *utp) |
34 | { | |
35 | struct compat_timex tx32; | |
36 | ||
0a0b9873 | 37 | memset(txc, 0, sizeof(struct timex)); |
3a4d44b6 | 38 | if (copy_from_user(&tx32, utp, sizeof(struct compat_timex))) |
65f5d80b RC |
39 | return -EFAULT; |
40 | ||
3a4d44b6 AV |
41 | txc->modes = tx32.modes; |
42 | txc->offset = tx32.offset; | |
43 | txc->freq = tx32.freq; | |
44 | txc->maxerror = tx32.maxerror; | |
45 | txc->esterror = tx32.esterror; | |
46 | txc->status = tx32.status; | |
47 | txc->constant = tx32.constant; | |
48 | txc->precision = tx32.precision; | |
49 | txc->tolerance = tx32.tolerance; | |
50 | txc->time.tv_sec = tx32.time.tv_sec; | |
51 | txc->time.tv_usec = tx32.time.tv_usec; | |
52 | txc->tick = tx32.tick; | |
53 | txc->ppsfreq = tx32.ppsfreq; | |
54 | txc->jitter = tx32.jitter; | |
55 | txc->shift = tx32.shift; | |
56 | txc->stabil = tx32.stabil; | |
57 | txc->jitcnt = tx32.jitcnt; | |
58 | txc->calcnt = tx32.calcnt; | |
59 | txc->errcnt = tx32.errcnt; | |
60 | txc->stbcnt = tx32.stbcnt; | |
61 | ||
65f5d80b RC |
62 | return 0; |
63 | } | |
64 | ||
3a4d44b6 AV |
65 | int compat_put_timex(struct compat_timex __user *utp, const struct timex *txc) |
66 | { | |
67 | struct compat_timex tx32; | |
68 | ||
69 | memset(&tx32, 0, sizeof(struct compat_timex)); | |
70 | tx32.modes = txc->modes; | |
71 | tx32.offset = txc->offset; | |
72 | tx32.freq = txc->freq; | |
73 | tx32.maxerror = txc->maxerror; | |
74 | tx32.esterror = txc->esterror; | |
75 | tx32.status = txc->status; | |
76 | tx32.constant = txc->constant; | |
77 | tx32.precision = txc->precision; | |
78 | tx32.tolerance = txc->tolerance; | |
79 | tx32.time.tv_sec = txc->time.tv_sec; | |
80 | tx32.time.tv_usec = txc->time.tv_usec; | |
81 | tx32.tick = txc->tick; | |
82 | tx32.ppsfreq = txc->ppsfreq; | |
83 | tx32.jitter = txc->jitter; | |
84 | tx32.shift = txc->shift; | |
85 | tx32.stabil = txc->stabil; | |
86 | tx32.jitcnt = txc->jitcnt; | |
87 | tx32.calcnt = txc->calcnt; | |
88 | tx32.errcnt = txc->errcnt; | |
89 | tx32.stbcnt = txc->stbcnt; | |
90 | tx32.tai = txc->tai; | |
91 | if (copy_to_user(utp, &tx32, sizeof(struct compat_timex))) | |
65f5d80b RC |
92 | return -EFAULT; |
93 | return 0; | |
94 | } | |
95 | ||
9afc5eee | 96 | static int __compat_get_timeval(struct timeval *tv, const struct old_timeval32 __user *ctv) |
6684ba20 PA |
97 | { |
98 | return (!access_ok(VERIFY_READ, ctv, sizeof(*ctv)) || | |
99 | __get_user(tv->tv_sec, &ctv->tv_sec) || | |
100 | __get_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0; | |
101 | } | |
6684ba20 | 102 | |
9afc5eee | 103 | static int __compat_put_timeval(const struct timeval *tv, struct old_timeval32 __user *ctv) |
6684ba20 PA |
104 | { |
105 | return (!access_ok(VERIFY_WRITE, ctv, sizeof(*ctv)) || | |
106 | __put_user(tv->tv_sec, &ctv->tv_sec) || | |
107 | __put_user(tv->tv_usec, &ctv->tv_usec)) ? -EFAULT : 0; | |
108 | } | |
6684ba20 | 109 | |
9afc5eee | 110 | static int __compat_get_timespec(struct timespec *ts, const struct old_timespec32 __user *cts) |
1da177e4 LT |
111 | { |
112 | return (!access_ok(VERIFY_READ, cts, sizeof(*cts)) || | |
113 | __get_user(ts->tv_sec, &cts->tv_sec) || | |
114 | __get_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0; | |
115 | } | |
116 | ||
9afc5eee | 117 | static int __compat_put_timespec(const struct timespec *ts, struct old_timespec32 __user *cts) |
1da177e4 LT |
118 | { |
119 | return (!access_ok(VERIFY_WRITE, cts, sizeof(*cts)) || | |
120 | __put_user(ts->tv_sec, &cts->tv_sec) || | |
121 | __put_user(ts->tv_nsec, &cts->tv_nsec)) ? -EFAULT : 0; | |
122 | } | |
123 | ||
6684ba20 PA |
124 | int compat_get_timeval(struct timeval *tv, const void __user *utv) |
125 | { | |
126 | if (COMPAT_USE_64BIT_TIME) | |
6516a466 | 127 | return copy_from_user(tv, utv, sizeof(*tv)) ? -EFAULT : 0; |
6684ba20 | 128 | else |
81993e81 | 129 | return __compat_get_timeval(tv, utv); |
6684ba20 PA |
130 | } |
131 | EXPORT_SYMBOL_GPL(compat_get_timeval); | |
132 | ||
133 | int compat_put_timeval(const struct timeval *tv, void __user *utv) | |
134 | { | |
135 | if (COMPAT_USE_64BIT_TIME) | |
6516a466 | 136 | return copy_to_user(utv, tv, sizeof(*tv)) ? -EFAULT : 0; |
6684ba20 | 137 | else |
81993e81 | 138 | return __compat_put_timeval(tv, utv); |
6684ba20 PA |
139 | } |
140 | EXPORT_SYMBOL_GPL(compat_put_timeval); | |
141 | ||
142 | int compat_get_timespec(struct timespec *ts, const void __user *uts) | |
143 | { | |
144 | if (COMPAT_USE_64BIT_TIME) | |
6516a466 | 145 | return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0; |
6684ba20 | 146 | else |
81993e81 | 147 | return __compat_get_timespec(ts, uts); |
6684ba20 PA |
148 | } |
149 | EXPORT_SYMBOL_GPL(compat_get_timespec); | |
150 | ||
151 | int compat_put_timespec(const struct timespec *ts, void __user *uts) | |
152 | { | |
153 | if (COMPAT_USE_64BIT_TIME) | |
6516a466 | 154 | return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0; |
6684ba20 | 155 | else |
81993e81 | 156 | return __compat_put_timespec(ts, uts); |
6684ba20 PA |
157 | } |
158 | EXPORT_SYMBOL_GPL(compat_put_timespec); | |
159 | ||
54ad9c46 | 160 | int get_compat_itimerval(struct itimerval *o, const struct compat_itimerval __user *i) |
1da177e4 | 161 | { |
54ad9c46 | 162 | struct compat_itimerval v32; |
baa73d9e | 163 | |
54ad9c46 AV |
164 | if (copy_from_user(&v32, i, sizeof(struct compat_itimerval))) |
165 | return -EFAULT; | |
166 | o->it_interval.tv_sec = v32.it_interval.tv_sec; | |
167 | o->it_interval.tv_usec = v32.it_interval.tv_usec; | |
168 | o->it_value.tv_sec = v32.it_value.tv_sec; | |
169 | o->it_value.tv_usec = v32.it_value.tv_usec; | |
170 | return 0; | |
1da177e4 LT |
171 | } |
172 | ||
54ad9c46 | 173 | int put_compat_itimerval(struct compat_itimerval __user *o, const struct itimerval *i) |
1da177e4 | 174 | { |
54ad9c46 | 175 | struct compat_itimerval v32; |
1da177e4 | 176 | |
54ad9c46 AV |
177 | v32.it_interval.tv_sec = i->it_interval.tv_sec; |
178 | v32.it_interval.tv_usec = i->it_interval.tv_usec; | |
179 | v32.it_value.tv_sec = i->it_value.tv_sec; | |
180 | v32.it_value.tv_usec = i->it_value.tv_usec; | |
181 | return copy_to_user(o, &v32, sizeof(struct compat_itimerval)) ? -EFAULT : 0; | |
1da177e4 LT |
182 | } |
183 | ||
be84cb43 CM |
184 | #ifdef __ARCH_WANT_SYS_SIGPROCMASK |
185 | ||
b7dafa0e JK |
186 | /* |
187 | * sys_sigprocmask SIG_SETMASK sets the first (compat) word of the | |
188 | * blocked set of signals to the supplied signal set | |
189 | */ | |
190 | static inline void compat_sig_setmask(sigset_t *blocked, compat_sigset_word set) | |
1da177e4 | 191 | { |
b7dafa0e JK |
192 | memcpy(blocked->sig, &set, sizeof(set)); |
193 | } | |
1da177e4 | 194 | |
5cf22100 AV |
195 | COMPAT_SYSCALL_DEFINE3(sigprocmask, int, how, |
196 | compat_old_sigset_t __user *, nset, | |
197 | compat_old_sigset_t __user *, oset) | |
b7dafa0e JK |
198 | { |
199 | old_sigset_t old_set, new_set; | |
200 | sigset_t new_blocked; | |
201 | ||
202 | old_set = current->blocked.sig[0]; | |
203 | ||
204 | if (nset) { | |
205 | if (get_user(new_set, nset)) | |
206 | return -EFAULT; | |
207 | new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP)); | |
208 | ||
209 | new_blocked = current->blocked; | |
210 | ||
211 | switch (how) { | |
212 | case SIG_BLOCK: | |
213 | sigaddsetmask(&new_blocked, new_set); | |
214 | break; | |
215 | case SIG_UNBLOCK: | |
216 | sigdelsetmask(&new_blocked, new_set); | |
217 | break; | |
218 | case SIG_SETMASK: | |
219 | compat_sig_setmask(&new_blocked, new_set); | |
220 | break; | |
221 | default: | |
222 | return -EINVAL; | |
223 | } | |
224 | ||
225 | set_current_blocked(&new_blocked); | |
226 | } | |
227 | ||
228 | if (oset) { | |
229 | if (put_user(old_set, oset)) | |
230 | return -EFAULT; | |
231 | } | |
232 | ||
233 | return 0; | |
1da177e4 LT |
234 | } |
235 | ||
be84cb43 CM |
236 | #endif |
237 | ||
1da177e4 LT |
238 | int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru) |
239 | { | |
7668b679 AV |
240 | struct compat_rusage r32; |
241 | memset(&r32, 0, sizeof(r32)); | |
242 | r32.ru_utime.tv_sec = r->ru_utime.tv_sec; | |
243 | r32.ru_utime.tv_usec = r->ru_utime.tv_usec; | |
244 | r32.ru_stime.tv_sec = r->ru_stime.tv_sec; | |
245 | r32.ru_stime.tv_usec = r->ru_stime.tv_usec; | |
246 | r32.ru_maxrss = r->ru_maxrss; | |
247 | r32.ru_ixrss = r->ru_ixrss; | |
248 | r32.ru_idrss = r->ru_idrss; | |
249 | r32.ru_isrss = r->ru_isrss; | |
250 | r32.ru_minflt = r->ru_minflt; | |
251 | r32.ru_majflt = r->ru_majflt; | |
252 | r32.ru_nswap = r->ru_nswap; | |
253 | r32.ru_inblock = r->ru_inblock; | |
254 | r32.ru_oublock = r->ru_oublock; | |
255 | r32.ru_msgsnd = r->ru_msgsnd; | |
256 | r32.ru_msgrcv = r->ru_msgrcv; | |
257 | r32.ru_nsignals = r->ru_nsignals; | |
258 | r32.ru_nvcsw = r->ru_nvcsw; | |
259 | r32.ru_nivcsw = r->ru_nivcsw; | |
260 | if (copy_to_user(ru, &r32, sizeof(r32))) | |
1da177e4 LT |
261 | return -EFAULT; |
262 | return 0; | |
263 | } | |
264 | ||
1da177e4 | 265 | static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr, |
a45185d2 | 266 | unsigned len, struct cpumask *new_mask) |
1da177e4 LT |
267 | { |
268 | unsigned long *k; | |
269 | ||
a45185d2 RR |
270 | if (len < cpumask_size()) |
271 | memset(new_mask, 0, cpumask_size()); | |
272 | else if (len > cpumask_size()) | |
273 | len = cpumask_size(); | |
1da177e4 | 274 | |
a45185d2 | 275 | k = cpumask_bits(new_mask); |
1da177e4 LT |
276 | return compat_get_bitmap(k, user_mask_ptr, len * 8); |
277 | } | |
278 | ||
62a6fa97 HC |
279 | COMPAT_SYSCALL_DEFINE3(sched_setaffinity, compat_pid_t, pid, |
280 | unsigned int, len, | |
281 | compat_ulong_t __user *, user_mask_ptr) | |
1da177e4 | 282 | { |
a45185d2 | 283 | cpumask_var_t new_mask; |
1da177e4 LT |
284 | int retval; |
285 | ||
a45185d2 RR |
286 | if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) |
287 | return -ENOMEM; | |
288 | ||
289 | retval = compat_get_user_cpu_mask(user_mask_ptr, len, new_mask); | |
1da177e4 | 290 | if (retval) |
a45185d2 | 291 | goto out; |
1da177e4 | 292 | |
a45185d2 RR |
293 | retval = sched_setaffinity(pid, new_mask); |
294 | out: | |
295 | free_cpumask_var(new_mask); | |
296 | return retval; | |
1da177e4 LT |
297 | } |
298 | ||
62a6fa97 HC |
299 | COMPAT_SYSCALL_DEFINE3(sched_getaffinity, compat_pid_t, pid, unsigned int, len, |
300 | compat_ulong_t __user *, user_mask_ptr) | |
1da177e4 LT |
301 | { |
302 | int ret; | |
a45185d2 | 303 | cpumask_var_t mask; |
1da177e4 | 304 | |
fa9dc265 KM |
305 | if ((len * BITS_PER_BYTE) < nr_cpu_ids) |
306 | return -EINVAL; | |
307 | if (len & (sizeof(compat_ulong_t)-1)) | |
1da177e4 LT |
308 | return -EINVAL; |
309 | ||
a45185d2 RR |
310 | if (!alloc_cpumask_var(&mask, GFP_KERNEL)) |
311 | return -ENOMEM; | |
312 | ||
313 | ret = sched_getaffinity(pid, mask); | |
fa9dc265 | 314 | if (ret == 0) { |
4de373a1 | 315 | unsigned int retlen = min(len, cpumask_size()); |
1da177e4 | 316 | |
fa9dc265 KM |
317 | if (compat_put_bitmap(user_mask_ptr, cpumask_bits(mask), retlen * 8)) |
318 | ret = -EFAULT; | |
319 | else | |
320 | ret = retlen; | |
321 | } | |
a45185d2 | 322 | free_cpumask_var(mask); |
fa9dc265 | 323 | |
a45185d2 | 324 | return ret; |
1da177e4 LT |
325 | } |
326 | ||
1da177e4 LT |
327 | /* |
328 | * We currently only need the following fields from the sigevent | |
329 | * structure: sigev_value, sigev_signo, sig_notify and (sometimes | |
330 | * sigev_notify_thread_id). The others are handled in user mode. | |
331 | * We also assume that copying sigev_value.sival_int is sufficient | |
332 | * to keep all the bits of sigev_value.sival_ptr intact. | |
333 | */ | |
334 | int get_compat_sigevent(struct sigevent *event, | |
335 | const struct compat_sigevent __user *u_event) | |
336 | { | |
51410d3c | 337 | memset(event, 0, sizeof(*event)); |
1da177e4 LT |
338 | return (!access_ok(VERIFY_READ, u_event, sizeof(*u_event)) || |
339 | __get_user(event->sigev_value.sival_int, | |
340 | &u_event->sigev_value.sival_int) || | |
341 | __get_user(event->sigev_signo, &u_event->sigev_signo) || | |
342 | __get_user(event->sigev_notify, &u_event->sigev_notify) || | |
343 | __get_user(event->sigev_notify_thread_id, | |
344 | &u_event->sigev_notify_thread_id)) | |
345 | ? -EFAULT : 0; | |
346 | } | |
347 | ||
5fa3839a | 348 | long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask, |
1da177e4 LT |
349 | unsigned long bitmap_size) |
350 | { | |
1da177e4 LT |
351 | unsigned long nr_compat_longs; |
352 | ||
353 | /* align bitmap up to nearest compat_long_t boundary */ | |
354 | bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG); | |
1e1fc133 | 355 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); |
1da177e4 LT |
356 | |
357 | if (!access_ok(VERIFY_READ, umask, bitmap_size / 8)) | |
358 | return -EFAULT; | |
359 | ||
1e1fc133 AV |
360 | user_access_begin(); |
361 | while (nr_compat_longs > 1) { | |
362 | compat_ulong_t l1, l2; | |
363 | unsafe_get_user(l1, umask++, Efault); | |
364 | unsafe_get_user(l2, umask++, Efault); | |
365 | *mask++ = ((unsigned long)l2 << BITS_PER_COMPAT_LONG) | l1; | |
366 | nr_compat_longs -= 2; | |
1da177e4 | 367 | } |
1e1fc133 AV |
368 | if (nr_compat_longs) |
369 | unsafe_get_user(*mask, umask++, Efault); | |
370 | user_access_end(); | |
1da177e4 | 371 | return 0; |
1e1fc133 AV |
372 | |
373 | Efault: | |
374 | user_access_end(); | |
375 | return -EFAULT; | |
1da177e4 LT |
376 | } |
377 | ||
378 | long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask, | |
379 | unsigned long bitmap_size) | |
380 | { | |
1da177e4 LT |
381 | unsigned long nr_compat_longs; |
382 | ||
383 | /* align bitmap up to nearest compat_long_t boundary */ | |
384 | bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG); | |
1e1fc133 | 385 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); |
1da177e4 LT |
386 | |
387 | if (!access_ok(VERIFY_WRITE, umask, bitmap_size / 8)) | |
388 | return -EFAULT; | |
389 | ||
1e1fc133 AV |
390 | user_access_begin(); |
391 | while (nr_compat_longs > 1) { | |
392 | unsigned long m = *mask++; | |
393 | unsafe_put_user((compat_ulong_t)m, umask++, Efault); | |
394 | unsafe_put_user(m >> BITS_PER_COMPAT_LONG, umask++, Efault); | |
395 | nr_compat_longs -= 2; | |
1da177e4 | 396 | } |
1e1fc133 AV |
397 | if (nr_compat_longs) |
398 | unsafe_put_user((compat_ulong_t)*mask, umask++, Efault); | |
399 | user_access_end(); | |
1da177e4 | 400 | return 0; |
1e1fc133 AV |
401 | Efault: |
402 | user_access_end(); | |
403 | return -EFAULT; | |
1da177e4 LT |
404 | } |
405 | ||
3968cf62 AV |
406 | int |
407 | get_compat_sigset(sigset_t *set, const compat_sigset_t __user *compat) | |
1da177e4 | 408 | { |
3968cf62 AV |
409 | #ifdef __BIG_ENDIAN |
410 | compat_sigset_t v; | |
411 | if (copy_from_user(&v, compat, sizeof(compat_sigset_t))) | |
412 | return -EFAULT; | |
1da177e4 | 413 | switch (_NSIG_WORDS) { |
3968cf62 AV |
414 | case 4: set->sig[3] = v.sig[6] | (((long)v.sig[7]) << 32 ); |
415 | case 3: set->sig[2] = v.sig[4] | (((long)v.sig[5]) << 32 ); | |
416 | case 2: set->sig[1] = v.sig[2] | (((long)v.sig[3]) << 32 ); | |
417 | case 1: set->sig[0] = v.sig[0] | (((long)v.sig[1]) << 32 ); | |
1da177e4 | 418 | } |
3968cf62 AV |
419 | #else |
420 | if (copy_from_user(set, compat, sizeof(compat_sigset_t))) | |
421 | return -EFAULT; | |
422 | #endif | |
423 | return 0; | |
1da177e4 | 424 | } |
3968cf62 | 425 | EXPORT_SYMBOL_GPL(get_compat_sigset); |
1da177e4 | 426 | |
c41d68a5 PA |
427 | /* |
428 | * Allocate user-space memory for the duration of a single system call, | |
429 | * in order to marshall parameters inside a compat thunk. | |
430 | */ | |
431 | void __user *compat_alloc_user_space(unsigned long len) | |
432 | { | |
433 | void __user *ptr; | |
434 | ||
435 | /* If len would occupy more than half of the entire compat space... */ | |
436 | if (unlikely(len > (((compat_uptr_t)~0) >> 1))) | |
437 | return NULL; | |
438 | ||
439 | ptr = arch_compat_alloc_user_space(len); | |
440 | ||
441 | if (unlikely(!access_ok(VERIFY_WRITE, ptr, len))) | |
442 | return NULL; | |
443 | ||
444 | return ptr; | |
445 | } | |
446 | EXPORT_SYMBOL_GPL(compat_alloc_user_space); |