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