]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * linux/kernel/compat.c | |
3 | * | |
4 | * Kernel compatibililty routines for e.g. 32 bit syscall support | |
5 | * on 64 bit kernels. | |
6 | * | |
7 | * Copyright (C) 2002-2003 Stephen Rothwell, IBM Corporation | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License version 2 as | |
11 | * published by the Free Software Foundation. | |
12 | */ | |
13 | ||
14 | #include <linux/linkage.h> | |
15 | #include <linux/compat.h> | |
16 | #include <linux/errno.h> | |
17 | #include <linux/time.h> | |
18 | #include <linux/signal.h> | |
19 | #include <linux/sched.h> /* for MAX_SCHEDULE_TIMEOUT */ | |
20 | #include <linux/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> | |
30 | ||
31 | #include <linux/uaccess.h> | |
32 | ||
33 | int compat_get_timex(struct timex *txc, const struct compat_timex __user *utp) | |
34 | { | |
35 | struct compat_timex tx32; | |
36 | ||
37 | memset(txc, 0, sizeof(struct timex)); | |
38 | if (copy_from_user(&tx32, utp, sizeof(struct compat_timex))) | |
39 | return -EFAULT; | |
40 | ||
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 | ||
62 | return 0; | |
63 | } | |
64 | ||
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))) | |
92 | return -EFAULT; | |
93 | return 0; | |
94 | } | |
95 | ||
96 | static int __compat_get_timeval(struct timeval *tv, const struct compat_timeval __user *ctv) | |
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 | } | |
102 | ||
103 | static int __compat_put_timeval(const struct timeval *tv, struct compat_timeval __user *ctv) | |
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 | } | |
109 | ||
110 | static int __compat_get_timespec(struct timespec *ts, const struct compat_timespec __user *cts) | |
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 | ||
117 | static int __compat_put_timespec(const struct timespec *ts, struct compat_timespec __user *cts) | |
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 | ||
124 | static int __compat_get_timespec64(struct timespec64 *ts64, | |
125 | const struct compat_timespec __user *cts) | |
126 | { | |
127 | struct compat_timespec ts; | |
128 | int ret; | |
129 | ||
130 | ret = copy_from_user(&ts, cts, sizeof(ts)); | |
131 | if (ret) | |
132 | return -EFAULT; | |
133 | ||
134 | ts64->tv_sec = ts.tv_sec; | |
135 | ts64->tv_nsec = ts.tv_nsec; | |
136 | ||
137 | return 0; | |
138 | } | |
139 | ||
140 | static int __compat_put_timespec64(const struct timespec64 *ts64, | |
141 | struct compat_timespec __user *cts) | |
142 | { | |
143 | struct compat_timespec ts = { | |
144 | .tv_sec = ts64->tv_sec, | |
145 | .tv_nsec = ts64->tv_nsec | |
146 | }; | |
147 | return copy_to_user(cts, &ts, sizeof(ts)) ? -EFAULT : 0; | |
148 | } | |
149 | ||
150 | int compat_get_timespec64(struct timespec64 *ts, const void __user *uts) | |
151 | { | |
152 | if (COMPAT_USE_64BIT_TIME) | |
153 | return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0; | |
154 | else | |
155 | return __compat_get_timespec64(ts, uts); | |
156 | } | |
157 | EXPORT_SYMBOL_GPL(compat_get_timespec64); | |
158 | ||
159 | int compat_put_timespec64(const struct timespec64 *ts, void __user *uts) | |
160 | { | |
161 | if (COMPAT_USE_64BIT_TIME) | |
162 | return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0; | |
163 | else | |
164 | return __compat_put_timespec64(ts, uts); | |
165 | } | |
166 | EXPORT_SYMBOL_GPL(compat_put_timespec64); | |
167 | ||
168 | int compat_get_timeval(struct timeval *tv, const void __user *utv) | |
169 | { | |
170 | if (COMPAT_USE_64BIT_TIME) | |
171 | return copy_from_user(tv, utv, sizeof(*tv)) ? -EFAULT : 0; | |
172 | else | |
173 | return __compat_get_timeval(tv, utv); | |
174 | } | |
175 | EXPORT_SYMBOL_GPL(compat_get_timeval); | |
176 | ||
177 | int compat_put_timeval(const struct timeval *tv, void __user *utv) | |
178 | { | |
179 | if (COMPAT_USE_64BIT_TIME) | |
180 | return copy_to_user(utv, tv, sizeof(*tv)) ? -EFAULT : 0; | |
181 | else | |
182 | return __compat_put_timeval(tv, utv); | |
183 | } | |
184 | EXPORT_SYMBOL_GPL(compat_put_timeval); | |
185 | ||
186 | int compat_get_timespec(struct timespec *ts, const void __user *uts) | |
187 | { | |
188 | if (COMPAT_USE_64BIT_TIME) | |
189 | return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0; | |
190 | else | |
191 | return __compat_get_timespec(ts, uts); | |
192 | } | |
193 | EXPORT_SYMBOL_GPL(compat_get_timespec); | |
194 | ||
195 | int compat_put_timespec(const struct timespec *ts, void __user *uts) | |
196 | { | |
197 | if (COMPAT_USE_64BIT_TIME) | |
198 | return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0; | |
199 | else | |
200 | return __compat_put_timespec(ts, uts); | |
201 | } | |
202 | EXPORT_SYMBOL_GPL(compat_put_timespec); | |
203 | ||
204 | int get_compat_itimerval(struct itimerval *o, const struct compat_itimerval __user *i) | |
205 | { | |
206 | struct compat_itimerval v32; | |
207 | ||
208 | if (copy_from_user(&v32, i, sizeof(struct compat_itimerval))) | |
209 | return -EFAULT; | |
210 | o->it_interval.tv_sec = v32.it_interval.tv_sec; | |
211 | o->it_interval.tv_usec = v32.it_interval.tv_usec; | |
212 | o->it_value.tv_sec = v32.it_value.tv_sec; | |
213 | o->it_value.tv_usec = v32.it_value.tv_usec; | |
214 | return 0; | |
215 | } | |
216 | ||
217 | int put_compat_itimerval(struct compat_itimerval __user *o, const struct itimerval *i) | |
218 | { | |
219 | struct compat_itimerval v32; | |
220 | ||
221 | v32.it_interval.tv_sec = i->it_interval.tv_sec; | |
222 | v32.it_interval.tv_usec = i->it_interval.tv_usec; | |
223 | v32.it_value.tv_sec = i->it_value.tv_sec; | |
224 | v32.it_value.tv_usec = i->it_value.tv_usec; | |
225 | return copy_to_user(o, &v32, sizeof(struct compat_itimerval)) ? -EFAULT : 0; | |
226 | } | |
227 | ||
228 | #ifdef __ARCH_WANT_SYS_SIGPROCMASK | |
229 | ||
230 | /* | |
231 | * sys_sigprocmask SIG_SETMASK sets the first (compat) word of the | |
232 | * blocked set of signals to the supplied signal set | |
233 | */ | |
234 | static inline void compat_sig_setmask(sigset_t *blocked, compat_sigset_word set) | |
235 | { | |
236 | memcpy(blocked->sig, &set, sizeof(set)); | |
237 | } | |
238 | ||
239 | COMPAT_SYSCALL_DEFINE3(sigprocmask, int, how, | |
240 | compat_old_sigset_t __user *, nset, | |
241 | compat_old_sigset_t __user *, oset) | |
242 | { | |
243 | old_sigset_t old_set, new_set; | |
244 | sigset_t new_blocked; | |
245 | ||
246 | old_set = current->blocked.sig[0]; | |
247 | ||
248 | if (nset) { | |
249 | if (get_user(new_set, nset)) | |
250 | return -EFAULT; | |
251 | new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP)); | |
252 | ||
253 | new_blocked = current->blocked; | |
254 | ||
255 | switch (how) { | |
256 | case SIG_BLOCK: | |
257 | sigaddsetmask(&new_blocked, new_set); | |
258 | break; | |
259 | case SIG_UNBLOCK: | |
260 | sigdelsetmask(&new_blocked, new_set); | |
261 | break; | |
262 | case SIG_SETMASK: | |
263 | compat_sig_setmask(&new_blocked, new_set); | |
264 | break; | |
265 | default: | |
266 | return -EINVAL; | |
267 | } | |
268 | ||
269 | set_current_blocked(&new_blocked); | |
270 | } | |
271 | ||
272 | if (oset) { | |
273 | if (put_user(old_set, oset)) | |
274 | return -EFAULT; | |
275 | } | |
276 | ||
277 | return 0; | |
278 | } | |
279 | ||
280 | #endif | |
281 | ||
282 | int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru) | |
283 | { | |
284 | struct compat_rusage r32; | |
285 | memset(&r32, 0, sizeof(r32)); | |
286 | r32.ru_utime.tv_sec = r->ru_utime.tv_sec; | |
287 | r32.ru_utime.tv_usec = r->ru_utime.tv_usec; | |
288 | r32.ru_stime.tv_sec = r->ru_stime.tv_sec; | |
289 | r32.ru_stime.tv_usec = r->ru_stime.tv_usec; | |
290 | r32.ru_maxrss = r->ru_maxrss; | |
291 | r32.ru_ixrss = r->ru_ixrss; | |
292 | r32.ru_idrss = r->ru_idrss; | |
293 | r32.ru_isrss = r->ru_isrss; | |
294 | r32.ru_minflt = r->ru_minflt; | |
295 | r32.ru_majflt = r->ru_majflt; | |
296 | r32.ru_nswap = r->ru_nswap; | |
297 | r32.ru_inblock = r->ru_inblock; | |
298 | r32.ru_oublock = r->ru_oublock; | |
299 | r32.ru_msgsnd = r->ru_msgsnd; | |
300 | r32.ru_msgrcv = r->ru_msgrcv; | |
301 | r32.ru_nsignals = r->ru_nsignals; | |
302 | r32.ru_nvcsw = r->ru_nvcsw; | |
303 | r32.ru_nivcsw = r->ru_nivcsw; | |
304 | if (copy_to_user(ru, &r32, sizeof(r32))) | |
305 | return -EFAULT; | |
306 | return 0; | |
307 | } | |
308 | ||
309 | static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr, | |
310 | unsigned len, struct cpumask *new_mask) | |
311 | { | |
312 | unsigned long *k; | |
313 | ||
314 | if (len < cpumask_size()) | |
315 | memset(new_mask, 0, cpumask_size()); | |
316 | else if (len > cpumask_size()) | |
317 | len = cpumask_size(); | |
318 | ||
319 | k = cpumask_bits(new_mask); | |
320 | return compat_get_bitmap(k, user_mask_ptr, len * 8); | |
321 | } | |
322 | ||
323 | COMPAT_SYSCALL_DEFINE3(sched_setaffinity, compat_pid_t, pid, | |
324 | unsigned int, len, | |
325 | compat_ulong_t __user *, user_mask_ptr) | |
326 | { | |
327 | cpumask_var_t new_mask; | |
328 | int retval; | |
329 | ||
330 | if (!alloc_cpumask_var(&new_mask, GFP_KERNEL)) | |
331 | return -ENOMEM; | |
332 | ||
333 | retval = compat_get_user_cpu_mask(user_mask_ptr, len, new_mask); | |
334 | if (retval) | |
335 | goto out; | |
336 | ||
337 | retval = sched_setaffinity(pid, new_mask); | |
338 | out: | |
339 | free_cpumask_var(new_mask); | |
340 | return retval; | |
341 | } | |
342 | ||
343 | COMPAT_SYSCALL_DEFINE3(sched_getaffinity, compat_pid_t, pid, unsigned int, len, | |
344 | compat_ulong_t __user *, user_mask_ptr) | |
345 | { | |
346 | int ret; | |
347 | cpumask_var_t mask; | |
348 | ||
349 | if ((len * BITS_PER_BYTE) < nr_cpu_ids) | |
350 | return -EINVAL; | |
351 | if (len & (sizeof(compat_ulong_t)-1)) | |
352 | return -EINVAL; | |
353 | ||
354 | if (!alloc_cpumask_var(&mask, GFP_KERNEL)) | |
355 | return -ENOMEM; | |
356 | ||
357 | ret = sched_getaffinity(pid, mask); | |
358 | if (ret == 0) { | |
359 | size_t retlen = min_t(size_t, len, cpumask_size()); | |
360 | ||
361 | if (compat_put_bitmap(user_mask_ptr, cpumask_bits(mask), retlen * 8)) | |
362 | ret = -EFAULT; | |
363 | else | |
364 | ret = retlen; | |
365 | } | |
366 | free_cpumask_var(mask); | |
367 | ||
368 | return ret; | |
369 | } | |
370 | ||
371 | int get_compat_itimerspec64(struct itimerspec64 *its, | |
372 | const struct compat_itimerspec __user *uits) | |
373 | { | |
374 | ||
375 | if (__compat_get_timespec64(&its->it_interval, &uits->it_interval) || | |
376 | __compat_get_timespec64(&its->it_value, &uits->it_value)) | |
377 | return -EFAULT; | |
378 | return 0; | |
379 | } | |
380 | EXPORT_SYMBOL_GPL(get_compat_itimerspec64); | |
381 | ||
382 | int put_compat_itimerspec64(const struct itimerspec64 *its, | |
383 | struct compat_itimerspec __user *uits) | |
384 | { | |
385 | if (__compat_put_timespec64(&its->it_interval, &uits->it_interval) || | |
386 | __compat_put_timespec64(&its->it_value, &uits->it_value)) | |
387 | return -EFAULT; | |
388 | return 0; | |
389 | } | |
390 | EXPORT_SYMBOL_GPL(put_compat_itimerspec64); | |
391 | ||
392 | /* | |
393 | * We currently only need the following fields from the sigevent | |
394 | * structure: sigev_value, sigev_signo, sig_notify and (sometimes | |
395 | * sigev_notify_thread_id). The others are handled in user mode. | |
396 | * We also assume that copying sigev_value.sival_int is sufficient | |
397 | * to keep all the bits of sigev_value.sival_ptr intact. | |
398 | */ | |
399 | int get_compat_sigevent(struct sigevent *event, | |
400 | const struct compat_sigevent __user *u_event) | |
401 | { | |
402 | memset(event, 0, sizeof(*event)); | |
403 | return (!access_ok(VERIFY_READ, u_event, sizeof(*u_event)) || | |
404 | __get_user(event->sigev_value.sival_int, | |
405 | &u_event->sigev_value.sival_int) || | |
406 | __get_user(event->sigev_signo, &u_event->sigev_signo) || | |
407 | __get_user(event->sigev_notify, &u_event->sigev_notify) || | |
408 | __get_user(event->sigev_notify_thread_id, | |
409 | &u_event->sigev_notify_thread_id)) | |
410 | ? -EFAULT : 0; | |
411 | } | |
412 | ||
413 | long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask, | |
414 | unsigned long bitmap_size) | |
415 | { | |
416 | unsigned long nr_compat_longs; | |
417 | ||
418 | /* align bitmap up to nearest compat_long_t boundary */ | |
419 | bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG); | |
420 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); | |
421 | ||
422 | if (!access_ok(VERIFY_READ, umask, bitmap_size / 8)) | |
423 | return -EFAULT; | |
424 | ||
425 | user_access_begin(); | |
426 | while (nr_compat_longs > 1) { | |
427 | compat_ulong_t l1, l2; | |
428 | unsafe_get_user(l1, umask++, Efault); | |
429 | unsafe_get_user(l2, umask++, Efault); | |
430 | *mask++ = ((unsigned long)l2 << BITS_PER_COMPAT_LONG) | l1; | |
431 | nr_compat_longs -= 2; | |
432 | } | |
433 | if (nr_compat_longs) | |
434 | unsafe_get_user(*mask, umask++, Efault); | |
435 | user_access_end(); | |
436 | return 0; | |
437 | ||
438 | Efault: | |
439 | user_access_end(); | |
440 | return -EFAULT; | |
441 | } | |
442 | ||
443 | long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask, | |
444 | unsigned long bitmap_size) | |
445 | { | |
446 | unsigned long nr_compat_longs; | |
447 | ||
448 | /* align bitmap up to nearest compat_long_t boundary */ | |
449 | bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG); | |
450 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); | |
451 | ||
452 | if (!access_ok(VERIFY_WRITE, umask, bitmap_size / 8)) | |
453 | return -EFAULT; | |
454 | ||
455 | user_access_begin(); | |
456 | while (nr_compat_longs > 1) { | |
457 | unsigned long m = *mask++; | |
458 | unsafe_put_user((compat_ulong_t)m, umask++, Efault); | |
459 | unsafe_put_user(m >> BITS_PER_COMPAT_LONG, umask++, Efault); | |
460 | nr_compat_longs -= 2; | |
461 | } | |
462 | if (nr_compat_longs) | |
463 | unsafe_put_user((compat_ulong_t)*mask, umask++, Efault); | |
464 | user_access_end(); | |
465 | return 0; | |
466 | Efault: | |
467 | user_access_end(); | |
468 | return -EFAULT; | |
469 | } | |
470 | ||
471 | int | |
472 | get_compat_sigset(sigset_t *set, const compat_sigset_t __user *compat) | |
473 | { | |
474 | #ifdef __BIG_ENDIAN | |
475 | compat_sigset_t v; | |
476 | if (copy_from_user(&v, compat, sizeof(compat_sigset_t))) | |
477 | return -EFAULT; | |
478 | switch (_NSIG_WORDS) { | |
479 | case 4: set->sig[3] = v.sig[6] | (((long)v.sig[7]) << 32 ); | |
480 | case 3: set->sig[2] = v.sig[4] | (((long)v.sig[5]) << 32 ); | |
481 | case 2: set->sig[1] = v.sig[2] | (((long)v.sig[3]) << 32 ); | |
482 | case 1: set->sig[0] = v.sig[0] | (((long)v.sig[1]) << 32 ); | |
483 | } | |
484 | #else | |
485 | if (copy_from_user(set, compat, sizeof(compat_sigset_t))) | |
486 | return -EFAULT; | |
487 | #endif | |
488 | return 0; | |
489 | } | |
490 | EXPORT_SYMBOL_GPL(get_compat_sigset); | |
491 | ||
492 | int | |
493 | put_compat_sigset(compat_sigset_t __user *compat, const sigset_t *set, | |
494 | unsigned int size) | |
495 | { | |
496 | /* size <= sizeof(compat_sigset_t) <= sizeof(sigset_t) */ | |
497 | #ifdef __BIG_ENDIAN | |
498 | compat_sigset_t v; | |
499 | switch (_NSIG_WORDS) { | |
500 | case 4: v.sig[7] = (set->sig[3] >> 32); v.sig[6] = set->sig[3]; | |
501 | case 3: v.sig[5] = (set->sig[2] >> 32); v.sig[4] = set->sig[2]; | |
502 | case 2: v.sig[3] = (set->sig[1] >> 32); v.sig[2] = set->sig[1]; | |
503 | case 1: v.sig[1] = (set->sig[0] >> 32); v.sig[0] = set->sig[0]; | |
504 | } | |
505 | return copy_to_user(compat, &v, size) ? -EFAULT : 0; | |
506 | #else | |
507 | return copy_to_user(compat, set, size) ? -EFAULT : 0; | |
508 | #endif | |
509 | } | |
510 | ||
511 | #ifdef CONFIG_NUMA | |
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) | |
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 | ||
525 | if (get_user(p, pages32 + i) || | |
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 | } | |
531 | ||
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) | |
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 | } | |
564 | #endif | |
565 | ||
566 | /* | |
567 | * Allocate user-space memory for the duration of a single system call, | |
568 | * in order to marshall parameters inside a compat thunk. | |
569 | */ | |
570 | void __user *compat_alloc_user_space(unsigned long len) | |
571 | { | |
572 | void __user *ptr; | |
573 | ||
574 | /* If len would occupy more than half of the entire compat space... */ | |
575 | if (unlikely(len > (((compat_uptr_t)~0) >> 1))) | |
576 | return NULL; | |
577 | ||
578 | ptr = arch_compat_alloc_user_space(len); | |
579 | ||
580 | if (unlikely(!access_ok(VERIFY_WRITE, ptr, len))) | |
581 | return NULL; | |
582 | ||
583 | return ptr; | |
584 | } | |
585 | EXPORT_SYMBOL_GPL(compat_alloc_user_space); |