1 | // SPDX-License-Identifier: GPL-2.0-only |
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 |
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 */ |
17 | #include <linux/syscalls.h> |
18 | #include <linux/unistd.h> |
19 | #include <linux/security.h> |
20 | #include <linux/export.h> |
21 | #include <linux/migrate.h> |
22 | #include <linux/posix-timers.h> |
23 | #include <linux/times.h> |
24 | #include <linux/ptrace.h> |
25 | #include <linux/gfp.h> |
26 | |
27 | #include <linux/uaccess.h> |
28 | |
29 | #ifdef __ARCH_WANT_SYS_SIGPROCMASK |
30 | |
31 | /* |
32 | * sys_sigprocmask SIG_SETMASK sets the first (compat) word of the |
33 | * blocked set of signals to the supplied signal set |
34 | */ |
35 | static inline void compat_sig_setmask(sigset_t *blocked, compat_sigset_word set) |
36 | { |
37 | memcpy(blocked->sig, &set, sizeof(set)); |
38 | } |
39 | |
40 | COMPAT_SYSCALL_DEFINE3(sigprocmask, int, how, |
41 | compat_old_sigset_t __user *, nset, |
42 | compat_old_sigset_t __user *, oset) |
43 | { |
44 | old_sigset_t old_set, new_set; |
45 | sigset_t new_blocked; |
46 | |
47 | old_set = current->blocked.sig[0]; |
48 | |
49 | if (nset) { |
50 | if (get_user(new_set, nset)) |
51 | return -EFAULT; |
52 | new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP)); |
53 | |
54 | new_blocked = current->blocked; |
55 | |
56 | switch (how) { |
57 | case SIG_BLOCK: |
58 | sigaddsetmask(set: &new_blocked, mask: new_set); |
59 | break; |
60 | case SIG_UNBLOCK: |
61 | sigdelsetmask(set: &new_blocked, mask: new_set); |
62 | break; |
63 | case SIG_SETMASK: |
64 | compat_sig_setmask(blocked: &new_blocked, set: new_set); |
65 | break; |
66 | default: |
67 | return -EINVAL; |
68 | } |
69 | |
70 | set_current_blocked(&new_blocked); |
71 | } |
72 | |
73 | if (oset) { |
74 | if (put_user(old_set, oset)) |
75 | return -EFAULT; |
76 | } |
77 | |
78 | return 0; |
79 | } |
80 | |
81 | #endif |
82 | |
83 | int put_compat_rusage(const struct rusage *r, struct compat_rusage __user *ru) |
84 | { |
85 | struct compat_rusage r32; |
86 | memset(&r32, 0, sizeof(r32)); |
87 | r32.ru_utime.tv_sec = r->ru_utime.tv_sec; |
88 | r32.ru_utime.tv_usec = r->ru_utime.tv_usec; |
89 | r32.ru_stime.tv_sec = r->ru_stime.tv_sec; |
90 | r32.ru_stime.tv_usec = r->ru_stime.tv_usec; |
91 | r32.ru_maxrss = r->ru_maxrss; |
92 | r32.ru_ixrss = r->ru_ixrss; |
93 | r32.ru_idrss = r->ru_idrss; |
94 | r32.ru_isrss = r->ru_isrss; |
95 | r32.ru_minflt = r->ru_minflt; |
96 | r32.ru_majflt = r->ru_majflt; |
97 | r32.ru_nswap = r->ru_nswap; |
98 | r32.ru_inblock = r->ru_inblock; |
99 | r32.ru_oublock = r->ru_oublock; |
100 | r32.ru_msgsnd = r->ru_msgsnd; |
101 | r32.ru_msgrcv = r->ru_msgrcv; |
102 | r32.ru_nsignals = r->ru_nsignals; |
103 | r32.ru_nvcsw = r->ru_nvcsw; |
104 | r32.ru_nivcsw = r->ru_nivcsw; |
105 | if (copy_to_user(to: ru, from: &r32, n: sizeof(r32))) |
106 | return -EFAULT; |
107 | return 0; |
108 | } |
109 | |
110 | static int compat_get_user_cpu_mask(compat_ulong_t __user *user_mask_ptr, |
111 | unsigned len, struct cpumask *new_mask) |
112 | { |
113 | unsigned long *k; |
114 | |
115 | if (len < cpumask_size()) |
116 | memset(new_mask, 0, cpumask_size()); |
117 | else if (len > cpumask_size()) |
118 | len = cpumask_size(); |
119 | |
120 | k = cpumask_bits(new_mask); |
121 | return compat_get_bitmap(mask: k, umask: user_mask_ptr, bitmap_size: len * 8); |
122 | } |
123 | |
124 | COMPAT_SYSCALL_DEFINE3(sched_setaffinity, compat_pid_t, pid, |
125 | unsigned int, len, |
126 | compat_ulong_t __user *, user_mask_ptr) |
127 | { |
128 | cpumask_var_t new_mask; |
129 | int retval; |
130 | |
131 | if (!alloc_cpumask_var(mask: &new_mask, GFP_KERNEL)) |
132 | return -ENOMEM; |
133 | |
134 | retval = compat_get_user_cpu_mask(user_mask_ptr, len, new_mask); |
135 | if (retval) |
136 | goto out; |
137 | |
138 | retval = sched_setaffinity(pid, new_mask); |
139 | out: |
140 | free_cpumask_var(mask: new_mask); |
141 | return retval; |
142 | } |
143 | |
144 | COMPAT_SYSCALL_DEFINE3(sched_getaffinity, compat_pid_t, pid, unsigned int, len, |
145 | compat_ulong_t __user *, user_mask_ptr) |
146 | { |
147 | int ret; |
148 | cpumask_var_t mask; |
149 | |
150 | if ((len * BITS_PER_BYTE) < nr_cpu_ids) |
151 | return -EINVAL; |
152 | if (len & (sizeof(compat_ulong_t)-1)) |
153 | return -EINVAL; |
154 | |
155 | if (!zalloc_cpumask_var(mask: &mask, GFP_KERNEL)) |
156 | return -ENOMEM; |
157 | |
158 | ret = sched_getaffinity(pid, mask); |
159 | if (ret == 0) { |
160 | unsigned int retlen = min(len, cpumask_size()); |
161 | |
162 | if (compat_put_bitmap(umask: user_mask_ptr, cpumask_bits(mask), bitmap_size: retlen * 8)) |
163 | ret = -EFAULT; |
164 | else |
165 | ret = retlen; |
166 | } |
167 | free_cpumask_var(mask); |
168 | |
169 | return ret; |
170 | } |
171 | |
172 | /* |
173 | * We currently only need the following fields from the sigevent |
174 | * structure: sigev_value, sigev_signo, sig_notify and (sometimes |
175 | * sigev_notify_thread_id). The others are handled in user mode. |
176 | * We also assume that copying sigev_value.sival_int is sufficient |
177 | * to keep all the bits of sigev_value.sival_ptr intact. |
178 | */ |
179 | int get_compat_sigevent(struct sigevent *event, |
180 | const struct compat_sigevent __user *u_event) |
181 | { |
182 | memset(event, 0, sizeof(*event)); |
183 | return (!access_ok(u_event, sizeof(*u_event)) || |
184 | __get_user(event->sigev_value.sival_int, |
185 | &u_event->sigev_value.sival_int) || |
186 | __get_user(event->sigev_signo, &u_event->sigev_signo) || |
187 | __get_user(event->sigev_notify, &u_event->sigev_notify) || |
188 | __get_user(event->sigev_notify_thread_id, |
189 | &u_event->sigev_notify_thread_id)) |
190 | ? -EFAULT : 0; |
191 | } |
192 | |
193 | long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask, |
194 | unsigned long bitmap_size) |
195 | { |
196 | unsigned long nr_compat_longs; |
197 | |
198 | /* align bitmap up to nearest compat_long_t boundary */ |
199 | bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG); |
200 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); |
201 | |
202 | if (!user_read_access_begin(umask, bitmap_size / 8)) |
203 | return -EFAULT; |
204 | |
205 | while (nr_compat_longs > 1) { |
206 | compat_ulong_t l1, l2; |
207 | unsafe_get_user(l1, umask++, Efault); |
208 | unsafe_get_user(l2, umask++, Efault); |
209 | *mask++ = ((unsigned long)l2 << BITS_PER_COMPAT_LONG) | l1; |
210 | nr_compat_longs -= 2; |
211 | } |
212 | if (nr_compat_longs) |
213 | unsafe_get_user(*mask, umask++, Efault); |
214 | user_read_access_end(); |
215 | return 0; |
216 | |
217 | Efault: |
218 | user_read_access_end(); |
219 | return -EFAULT; |
220 | } |
221 | |
222 | long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask, |
223 | unsigned long bitmap_size) |
224 | { |
225 | unsigned long nr_compat_longs; |
226 | |
227 | /* align bitmap up to nearest compat_long_t boundary */ |
228 | bitmap_size = ALIGN(bitmap_size, BITS_PER_COMPAT_LONG); |
229 | nr_compat_longs = BITS_TO_COMPAT_LONGS(bitmap_size); |
230 | |
231 | if (!user_write_access_begin(umask, bitmap_size / 8)) |
232 | return -EFAULT; |
233 | |
234 | while (nr_compat_longs > 1) { |
235 | unsigned long m = *mask++; |
236 | unsafe_put_user((compat_ulong_t)m, umask++, Efault); |
237 | unsafe_put_user(m >> BITS_PER_COMPAT_LONG, umask++, Efault); |
238 | nr_compat_longs -= 2; |
239 | } |
240 | if (nr_compat_longs) |
241 | unsafe_put_user((compat_ulong_t)*mask, umask++, Efault); |
242 | user_write_access_end(); |
243 | return 0; |
244 | Efault: |
245 | user_write_access_end(); |
246 | return -EFAULT; |
247 | } |
248 | |
249 | int |
250 | get_compat_sigset(sigset_t *set, const compat_sigset_t __user *compat) |
251 | { |
252 | #ifdef __BIG_ENDIAN |
253 | compat_sigset_t v; |
254 | if (copy_from_user(&v, compat, sizeof(compat_sigset_t))) |
255 | return -EFAULT; |
256 | switch (_NSIG_WORDS) { |
257 | case 4: set->sig[3] = v.sig[6] | (((long)v.sig[7]) << 32 ); |
258 | fallthrough; |
259 | case 3: set->sig[2] = v.sig[4] | (((long)v.sig[5]) << 32 ); |
260 | fallthrough; |
261 | case 2: set->sig[1] = v.sig[2] | (((long)v.sig[3]) << 32 ); |
262 | fallthrough; |
263 | case 1: set->sig[0] = v.sig[0] | (((long)v.sig[1]) << 32 ); |
264 | } |
265 | #else |
266 | if (copy_from_user(to: set, from: compat, n: sizeof(compat_sigset_t))) |
267 | return -EFAULT; |
268 | #endif |
269 | return 0; |
270 | } |
271 | EXPORT_SYMBOL_GPL(get_compat_sigset); |
272 | |