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 | ||
81993e81 | 96 | static int __compat_get_timeval(struct timeval *tv, const struct compat_timeval __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 | |
81993e81 | 103 | static int __compat_put_timeval(const struct timeval *tv, struct compat_timeval __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 | |
81993e81 | 110 | static int __compat_get_timespec(struct timespec *ts, const struct compat_timespec __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 | ||
81993e81 | 117 | static int __compat_put_timespec(const struct timespec *ts, struct compat_timespec __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 | ||
f59dd9c8 DD |
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 | ||
6684ba20 PA |
168 | int compat_get_timeval(struct timeval *tv, const void __user *utv) |
169 | { | |
170 | if (COMPAT_USE_64BIT_TIME) | |
6516a466 | 171 | return copy_from_user(tv, utv, sizeof(*tv)) ? -EFAULT : 0; |
6684ba20 | 172 | else |
81993e81 | 173 | return __compat_get_timeval(tv, utv); |
6684ba20 PA |
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) | |
6516a466 | 180 | return copy_to_user(utv, tv, sizeof(*tv)) ? -EFAULT : 0; |
6684ba20 | 181 | else |
81993e81 | 182 | return __compat_put_timeval(tv, utv); |
6684ba20 PA |
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) | |
6516a466 | 189 | return copy_from_user(ts, uts, sizeof(*ts)) ? -EFAULT : 0; |
6684ba20 | 190 | else |
81993e81 | 191 | return __compat_get_timespec(ts, uts); |
6684ba20 PA |
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) | |
6516a466 | 198 | return copy_to_user(uts, ts, sizeof(*ts)) ? -EFAULT : 0; |
6684ba20 | 199 | else |
81993e81 | 200 | return __compat_put_timespec(ts, uts); |
6684ba20 PA |
201 | } |
202 | EXPORT_SYMBOL_GPL(compat_put_timespec); | |
203 | ||
54ad9c46 | 204 | int get_compat_itimerval(struct itimerval *o, const struct compat_itimerval __user *i) |
1da177e4 | 205 | { |
54ad9c46 | 206 | struct compat_itimerval v32; |
baa73d9e | 207 | |
54ad9c46 AV |
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; | |
1da177e4 LT |
215 | } |
216 | ||
54ad9c46 | 217 | int put_compat_itimerval(struct compat_itimerval __user *o, const struct itimerval *i) |
1da177e4 | 218 | { |
54ad9c46 | 219 | struct compat_itimerval v32; |
1da177e4 | 220 | |
54ad9c46 AV |
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; | |
1da177e4 LT |
226 | } |
227 | ||
be84cb43 CM |
228 | #ifdef __ARCH_WANT_SYS_SIGPROCMASK |
229 | ||
b7dafa0e JK |
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) | |
1da177e4 | 235 | { |
b7dafa0e JK |
236 | memcpy(blocked->sig, &set, sizeof(set)); |
237 | } | |
1da177e4 | 238 | |
5cf22100 AV |
239 | COMPAT_SYSCALL_DEFINE3(sigprocmask, int, how, |
240 | compat_old_sigset_t __user *, nset, | |
241 | compat_old_sigset_t __user *, oset) | |
b7dafa0e JK |
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; | |
1da177e4 LT |
278 | } |
279 | ||
be84cb43 CM |
280 | #endif |
281 | ||
1da177e4 LT |
282 | int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru) |
283 | { | |
7668b679 AV |
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))) | |
1da177e4 LT |
305 | return -EFAULT; |
306 | return 0; | |
307 | } | |
308 | ||
1da177e4 | 309 | static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr, |
a45185d2 | 310 | unsigned len, struct cpumask *new_mask) |
1da177e4 LT |
311 | { |
312 | unsigned long *k; | |
313 | ||
a45185d2 RR |
314 | if (len < cpumask_size()) |
315 | memset(new_mask, 0, cpumask_size()); | |
316 | else if (len > cpumask_size()) | |
317 | len = cpumask_size(); | |
1da177e4 | 318 | |
a45185d2 | 319 | k = cpumask_bits(new_mask); |
1da177e4 LT |
320 | return compat_get_bitmap(k, user_mask_ptr, len * 8); |
321 | } | |
322 | ||
62a6fa97 HC |
323 | COMPAT_SYSCALL_DEFINE3(sched_setaffinity, compat_pid_t, pid, |
324 | unsigned int, len, | |
325 | compat_ulong_t __user *, user_mask_ptr) | |
1da177e4 | 326 | { |
a45185d2 | 327 | cpumask_var_t new_mask; |
1da177e4 LT |
328 | int retval; |
329 | ||
a45185d2 RR |
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); | |
1da177e4 | 334 | if (retval) |
a45185d2 | 335 | goto out; |
1da177e4 | 336 | |
a45185d2 RR |
337 | retval = sched_setaffinity(pid, new_mask); |
338 | out: | |
339 | free_cpumask_var(new_mask); | |
340 | return retval; | |
1da177e4 LT |
341 | } |
342 | ||
62a6fa97 HC |
343 | COMPAT_SYSCALL_DEFINE3(sched_getaffinity, compat_pid_t, pid, unsigned int, len, |
344 | compat_ulong_t __user *, user_mask_ptr) | |
1da177e4 LT |
345 | { |
346 | int ret; | |
a45185d2 | 347 | cpumask_var_t mask; |
1da177e4 | 348 | |
fa9dc265 KM |
349 | if ((len * BITS_PER_BYTE) < nr_cpu_ids) |
350 | return -EINVAL; | |
351 | if (len & (sizeof(compat_ulong_t)-1)) | |
1da177e4 LT |
352 | return -EINVAL; |
353 | ||
a45185d2 RR |
354 | if (!alloc_cpumask_var(&mask, GFP_KERNEL)) |
355 | return -ENOMEM; | |
356 | ||
357 | ret = sched_getaffinity(pid, mask); | |
fa9dc265 | 358 | if (ret == 0) { |
4de373a1 | 359 | unsigned int retlen = min(len, cpumask_size()); |
1da177e4 | 360 | |
fa9dc265 KM |
361 | if (compat_put_bitmap(user_mask_ptr, cpumask_bits(mask), retlen * 8)) |
362 | ret = -EFAULT; | |
363 | else | |
364 | ret = retlen; | |
365 | } | |
a45185d2 | 366 | free_cpumask_var(mask); |
fa9dc265 | 367 | |
a45185d2 | 368 | return ret; |
1da177e4 LT |
369 | } |
370 | ||
d5b7ffbf DD |
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 | ||
1da177e4 LT |
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 | { | |
51410d3c | 402 | memset(event, 0, sizeof(*event)); |
1da177e4 LT |
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 | ||
5fa3839a | 413 | long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask, |
1da177e4 LT |
414 | unsigned long bitmap_size) |
415 | { | |
1da177e4 LT |
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); | |
1e1fc133 | 420 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); |
1da177e4 LT |
421 | |
422 | if (!access_ok(VERIFY_READ, umask, bitmap_size / 8)) | |
423 | return -EFAULT; | |
424 | ||
1e1fc133 AV |
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; | |
1da177e4 | 432 | } |
1e1fc133 AV |
433 | if (nr_compat_longs) |
434 | unsafe_get_user(*mask, umask++, Efault); | |
435 | user_access_end(); | |
1da177e4 | 436 | return 0; |
1e1fc133 AV |
437 | |
438 | Efault: | |
439 | user_access_end(); | |
440 | return -EFAULT; | |
1da177e4 LT |
441 | } |
442 | ||
443 | long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask, | |
444 | unsigned long bitmap_size) | |
445 | { | |
1da177e4 LT |
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); | |
1e1fc133 | 450 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); |
1da177e4 LT |
451 | |
452 | if (!access_ok(VERIFY_WRITE, umask, bitmap_size / 8)) | |
453 | return -EFAULT; | |
454 | ||
1e1fc133 AV |
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; | |
1da177e4 | 461 | } |
1e1fc133 AV |
462 | if (nr_compat_longs) |
463 | unsafe_put_user((compat_ulong_t)*mask, umask++, Efault); | |
464 | user_access_end(); | |
1da177e4 | 465 | return 0; |
1e1fc133 AV |
466 | Efault: |
467 | user_access_end(); | |
468 | return -EFAULT; | |
1da177e4 LT |
469 | } |
470 | ||
3968cf62 AV |
471 | int |
472 | get_compat_sigset(sigset_t *set, const compat_sigset_t __user *compat) | |
1da177e4 | 473 | { |
3968cf62 AV |
474 | #ifdef __BIG_ENDIAN |
475 | compat_sigset_t v; | |
476 | if (copy_from_user(&v, compat, sizeof(compat_sigset_t))) | |
477 | return -EFAULT; | |
1da177e4 | 478 | switch (_NSIG_WORDS) { |
3968cf62 AV |
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 ); | |
1da177e4 | 483 | } |
3968cf62 AV |
484 | #else |
485 | if (copy_from_user(set, compat, sizeof(compat_sigset_t))) | |
486 | return -EFAULT; | |
487 | #endif | |
488 | return 0; | |
1da177e4 | 489 | } |
3968cf62 | 490 | EXPORT_SYMBOL_GPL(get_compat_sigset); |
1da177e4 | 491 | |
c41d68a5 PA |
492 | /* |
493 | * Allocate user-space memory for the duration of a single system call, | |
494 | * in order to marshall parameters inside a compat thunk. | |
495 | */ | |
496 | void __user *compat_alloc_user_space(unsigned long len) | |
497 | { | |
498 | void __user *ptr; | |
499 | ||
500 | /* If len would occupy more than half of the entire compat space... */ | |
501 | if (unlikely(len > (((compat_uptr_t)~0) >> 1))) | |
502 | return NULL; | |
503 | ||
504 | ptr = arch_compat_alloc_user_space(len); | |
505 | ||
506 | if (unlikely(!access_ok(VERIFY_WRITE, ptr, len))) | |
507 | return NULL; | |
508 | ||
509 | return ptr; | |
510 | } | |
511 | EXPORT_SYMBOL_GPL(compat_alloc_user_space); |