1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/compat.h>
26#include <linux/slab.h>
27#include <linux/module.h>
28#include <linux/unistd.h>
29#include <linux/init.h>
30#include <linux/sched.h>
31#include <linux/syscalls.h>
32#include <linux/types.h>
33#include <linux/errno.h>
34
35#include <asm/uaccess.h>
36
37#include "signal32.h"
38#include "sys32.h"
39
40#define DEBUG_COMPAT_SIG 0
41#define DEBUG_COMPAT_SIG_LEVEL 2
42
43#if DEBUG_COMPAT_SIG
44#define DBG(LEVEL, ...) \
45 ((DEBUG_COMPAT_SIG_LEVEL >= LEVEL) \
46 ? printk(__VA_ARGS__) : (void) 0)
47#else
48#define DBG(LEVEL, ...)
49#endif
50
51#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
52
53inline void
54sigset_32to64(sigset_t *s64, compat_sigset_t *s32)
55{
56 s64->sig[0] = s32->sig[0] | ((unsigned long)s32->sig[1] << 32);
57}
58
59inline void
60sigset_64to32(compat_sigset_t *s32, sigset_t *s64)
61{
62 s32->sig[0] = s64->sig[0] & 0xffffffffUL;
63 s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL;
64}
65
66static int
67put_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
68{
69 compat_sigset_t s;
70
71 if (sz != sizeof *set) panic("put_sigset32()");
72 sigset_64to32(&s, set);
73
74 return copy_to_user(up, &s, sizeof s);
75}
76
77static int
78get_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz)
79{
80 compat_sigset_t s;
81 int r;
82
83 if (sz != sizeof *set) panic("put_sigset32()");
84
85 if ((r = copy_from_user(&s, up, sz)) == 0) {
86 sigset_32to64(set, &s);
87 }
88
89 return r;
90}
91
92int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset,
93 unsigned int sigsetsize)
94{
95 sigset_t old_set, new_set;
96 int ret;
97
98 if (set && get_sigset32(set, &new_set, sigsetsize))
99 return -EFAULT;
100
101 KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? (sigset_t __user *)&new_set : NULL,
102 oset ? (sigset_t __user *)&old_set : NULL, sigsetsize);
103
104 if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize))
105 return -EFAULT;
106
107 return ret;
108}
109
110
111int sys32_rt_sigpending(compat_sigset_t __user *uset, unsigned int sigsetsize)
112{
113 int ret;
114 sigset_t set;
115
116 KERNEL_SYSCALL(ret, sys_rt_sigpending, (sigset_t __user *)&set, sigsetsize);
117
118 if (!ret && put_sigset32(uset, &set, sigsetsize))
119 return -EFAULT;
120
121 return ret;
122}
123
124long
125sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, struct sigaction32 __user *oact,
126 size_t sigsetsize)
127{
128 struct k_sigaction32 new_sa32, old_sa32;
129 struct k_sigaction new_sa, old_sa;
130 int ret = -EINVAL;
131
132 if (act) {
133 if (copy_from_user(&new_sa32.sa, act, sizeof new_sa32.sa))
134 return -EFAULT;
135 new_sa.sa.sa_handler = (__sighandler_t)(unsigned long)new_sa32.sa.sa_handler;
136 new_sa.sa.sa_flags = new_sa32.sa.sa_flags;
137 sigset_32to64(&new_sa.sa.sa_mask, &new_sa32.sa.sa_mask);
138 }
139
140 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
141
142 if (!ret && oact) {
143 sigset_64to32(&old_sa32.sa.sa_mask, &old_sa.sa.sa_mask);
144 old_sa32.sa.sa_flags = old_sa.sa.sa_flags;
145 old_sa32.sa.sa_handler = (__sighandler_t32)(unsigned long)old_sa.sa.sa_handler;
146 if (copy_to_user(oact, &old_sa32.sa, sizeof old_sa32.sa))
147 return -EFAULT;
148 }
149 return ret;
150}
151
152int
153do_sigaltstack32 (const compat_stack_t __user *uss32, compat_stack_t __user *uoss32, unsigned long sp)
154{
155 compat_stack_t ss32, oss32;
156 stack_t ss, oss;
157 stack_t *ssp = NULL, *ossp = NULL;
158 int ret;
159
160 if (uss32) {
161 if (copy_from_user(&ss32, uss32, sizeof ss32))
162 return -EFAULT;
163
164 ss.ss_sp = (void __user *)(unsigned long)ss32.ss_sp;
165 ss.ss_flags = ss32.ss_flags;
166 ss.ss_size = ss32.ss_size;
167
168 ssp = &ss;
169 }
170
171 if (uoss32)
172 ossp = &oss;
173
174 KERNEL_SYSCALL(ret, do_sigaltstack, (const stack_t __user *)ssp, (stack_t __user *)ossp, sp);
175
176 if (!ret && uoss32) {
177 oss32.ss_sp = (unsigned int)(unsigned long)oss.ss_sp;
178 oss32.ss_flags = oss.ss_flags;
179 oss32.ss_size = oss.ss_size;
180 if (copy_to_user(uoss32, &oss32, sizeof *uoss32))
181 return -EFAULT;
182 }
183
184 return ret;
185}
186
187long
188restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,
189 struct pt_regs *regs)
190{
191 long err = 0;
192 compat_uint_t compat_reg;
193 compat_uint_t compat_regt;
194 int regn;
195
196
197
198 DBG(2,"restore_sigcontext32: PER_LINUX32 process\n");
199 DBG(2,"restore_sigcontext32: sc = 0x%p, rf = 0x%p, regs = 0x%p\n", sc, rf, regs);
200 DBG(2,"restore_sigcontext32: compat_sigcontext is %#lx bytes\n", sizeof(*sc));
201 for(regn=0; regn < 32; regn++){
202 err |= __get_user(compat_reg,&sc->sc_gr[regn]);
203 regs->gr[regn] = compat_reg;
204
205 err |= __get_user(compat_regt,&rf->rf_gr[regn]);
206 regs->gr[regn] = ((u64)compat_regt << 32) | (u64)compat_reg;
207 DBG(3,"restore_sigcontext32: gr%02d = %#lx (%#x / %#x)\n",
208 regn, regs->gr[regn], compat_regt, compat_reg);
209 }
210 DBG(2,"restore_sigcontext32: sc->sc_fr = 0x%p (%#lx)\n",sc->sc_fr, sizeof(sc->sc_fr));
211
212 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
213
214
215
216
217 err |= __get_user(compat_reg, &sc->sc_iaoq[0]);
218
219 err |= __get_user(compat_regt, &rf->rf_iaoq[0]);
220 regs->iaoq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
221 DBG(2,"restore_sigcontext32: upper half of iaoq[0] = %#lx\n", compat_regt);
222 DBG(2,"restore_sigcontext32: sc->sc_iaoq[0] = %p => %#x\n",
223 &sc->sc_iaoq[0], compat_reg);
224
225 err |= __get_user(compat_reg, &sc->sc_iaoq[1]);
226
227 err |= __get_user(compat_regt, &rf->rf_iaoq[1]);
228 regs->iaoq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
229 DBG(2,"restore_sigcontext32: upper half of iaoq[1] = %#lx\n", compat_regt);
230 DBG(2,"restore_sigcontext32: sc->sc_iaoq[1] = %p => %#x\n",
231 &sc->sc_iaoq[1],compat_reg);
232 DBG(2,"restore_sigcontext32: iaoq is %#lx / %#lx\n",
233 regs->iaoq[0],regs->iaoq[1]);
234
235 err |= __get_user(compat_reg, &sc->sc_iasq[0]);
236
237 err |= __get_user(compat_regt, &rf->rf_iasq[0]);
238 regs->iasq[0] = ((u64)compat_regt << 32) | (u64)compat_reg;
239 DBG(2,"restore_sigcontext32: upper half of iasq[0] = %#lx\n", compat_regt);
240
241 err |= __get_user(compat_reg, &sc->sc_iasq[1]);
242
243 err |= __get_user(compat_regt, &rf->rf_iasq[1]);
244 regs->iasq[1] = ((u64)compat_regt << 32) | (u64)compat_reg;
245 DBG(2,"restore_sigcontext32: upper half of iasq[1] = %#lx\n", compat_regt);
246 DBG(2,"restore_sigcontext32: iasq is %#lx / %#lx\n",
247 regs->iasq[0],regs->iasq[1]);
248
249 err |= __get_user(compat_reg, &sc->sc_sar);
250
251 err |= __get_user(compat_regt, &rf->rf_sar);
252 regs->sar = ((u64)compat_regt << 32) | (u64)compat_reg;
253 DBG(2,"restore_sigcontext32: upper_half & sar = %#lx\n", compat_regt);
254 DBG(2,"restore_sigcontext32: sar is %#lx\n", regs->sar);
255 DBG(2,"restore_sigcontext32: r28 is %ld\n", regs->gr[28]);
256
257 return err;
258}
259
260
261
262
263
264
265
266long
267setup_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf,
268 struct pt_regs *regs, int in_syscall)
269{
270 compat_int_t flags = 0;
271 long err = 0;
272 compat_uint_t compat_reg;
273 compat_uint_t compat_regb;
274 int regn;
275
276 if (on_sig_stack((unsigned long) sc))
277 flags |= PARISC_SC_FLAG_ONSTACK;
278
279 if (in_syscall) {
280
281 DBG(1,"setup_sigcontext32: in_syscall\n");
282
283 flags |= PARISC_SC_FLAG_IN_SYSCALL;
284
285 compat_reg = (compat_uint_t)(regs->gr[31]);
286
287 err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
288 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
289 &sc->sc_iaoq[0], compat_reg);
290
291
292 compat_reg = (compat_uint_t)(regs->gr[31] >> 32);
293 err |= __put_user(compat_reg, &rf->rf_iaoq[0]);
294 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
295
296
297 compat_reg = (compat_uint_t)(regs->gr[31]+4);
298 err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
299 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
300 &sc->sc_iaoq[1], compat_reg);
301
302 compat_reg = (compat_uint_t)((regs->gr[31]+4) >> 32);
303 err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
304 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
305
306
307 compat_reg = (compat_uint_t)(regs->sr[3]);
308 err |= __put_user(compat_reg, &sc->sc_iasq[0]);
309 err |= __put_user(compat_reg, &sc->sc_iasq[1]);
310
311
312 compat_reg = (compat_uint_t)(regs->sr[3] >> 32);
313 err |= __put_user(compat_reg, &rf->rf_iasq[0]);
314 err |= __put_user(compat_reg, &rf->rf_iasq[1]);
315
316 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
317 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);
318 DBG(1,"setup_sigcontext32: iaoq %#lx / %#lx\n",
319 regs->gr[31], regs->gr[31]+4);
320
321 } else {
322
323 compat_reg = (compat_uint_t)(regs->iaoq[0]);
324 err |= __put_user(compat_reg, &sc->sc_iaoq[0]);
325 DBG(2,"setup_sigcontext32: sc->sc_iaoq[0] = %p <= %#x\n",
326 &sc->sc_iaoq[0], compat_reg);
327
328 compat_reg = (compat_uint_t)(regs->iaoq[0] >> 32);
329 err |= __put_user(compat_reg, &rf->rf_iaoq[0]);
330 DBG(2,"setup_sigcontext32: upper half iaoq[0] = %#x\n", compat_reg);
331
332 compat_reg = (compat_uint_t)(regs->iaoq[1]);
333 err |= __put_user(compat_reg, &sc->sc_iaoq[1]);
334 DBG(2,"setup_sigcontext32: sc->sc_iaoq[1] = %p <= %#x\n",
335 &sc->sc_iaoq[1], compat_reg);
336
337 compat_reg = (compat_uint_t)(regs->iaoq[1] >> 32);
338 err |= __put_user(compat_reg, &rf->rf_iaoq[1]);
339 DBG(2,"setup_sigcontext32: upper half iaoq[1] = %#x\n", compat_reg);
340
341
342 compat_reg = (compat_uint_t)(regs->iasq[0]);
343 err |= __put_user(compat_reg, &sc->sc_iasq[0]);
344 DBG(2,"setup_sigcontext32: sc->sc_iasq[0] = %p <= %#x\n",
345 &sc->sc_iasq[0], compat_reg);
346
347 compat_reg = (compat_uint_t)(regs->iasq[0] >> 32);
348 err |= __put_user(compat_reg, &rf->rf_iasq[0]);
349 DBG(2,"setup_sigcontext32: upper half iasq[0] = %#x\n", compat_reg);
350
351
352 compat_reg = (compat_uint_t)(regs->iasq[1]);
353 err |= __put_user(compat_reg, &sc->sc_iasq[1]);
354 DBG(2,"setup_sigcontext32: sc->sc_iasq[1] = %p <= %#x\n",
355 &sc->sc_iasq[1], compat_reg);
356
357 compat_reg = (compat_uint_t)(regs->iasq[1] >> 32);
358 err |= __put_user(compat_reg, &rf->rf_iasq[1]);
359 DBG(2,"setup_sigcontext32: upper half iasq[1] = %#x\n", compat_reg);
360
361
362 DBG(1,"setup_sigcontext32: ia0q %#lx / %#lx\n",
363 regs->iaoq[0], regs->iaoq[1]);
364 }
365
366 err |= __put_user(flags, &sc->sc_flags);
367
368 DBG(1,"setup_sigcontext32: Truncating general registers.\n");
369
370 for(regn=0; regn < 32; regn++){
371
372 compat_reg = (compat_uint_t)(regs->gr[regn]);
373 err |= __put_user(compat_reg, &sc->sc_gr[regn]);
374
375 compat_regb = (compat_uint_t)(regs->gr[regn] >> 32);
376 err |= __put_user(compat_regb, &rf->rf_gr[regn]);
377
378
379 DBG(2,"setup_sigcontext32: gr%02d = %#x / %#x\n", regn,
380 compat_regb, compat_reg);
381 }
382
383
384
385 DBG(1,"setup_sigcontext32: Copying from regs to sc, "
386 "sc->sc_fr size = %#lx, regs->fr size = %#lx\n",
387 sizeof(regs->fr), sizeof(sc->sc_fr));
388 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
389
390 compat_reg = (compat_uint_t)(regs->sar);
391 err |= __put_user(compat_reg, &sc->sc_sar);
392 DBG(2,"setup_sigcontext32: sar is %#x\n", compat_reg);
393
394 compat_reg = (compat_uint_t)(regs->sar >> 32);
395 err |= __put_user(compat_reg, &rf->rf_sar);
396 DBG(2,"setup_sigcontext32: upper half sar = %#x\n", compat_reg);
397 DBG(1,"setup_sigcontext32: r28 is %ld\n", regs->gr[28]);
398
399 return err;
400}
401
402int
403copy_siginfo_from_user32 (siginfo_t *to, compat_siginfo_t __user *from)
404{
405 compat_uptr_t addr;
406 int err;
407
408 if (!access_ok(VERIFY_READ, from, sizeof(compat_siginfo_t)))
409 return -EFAULT;
410
411 err = __get_user(to->si_signo, &from->si_signo);
412 err |= __get_user(to->si_errno, &from->si_errno);
413 err |= __get_user(to->si_code, &from->si_code);
414
415 if (to->si_code < 0)
416 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
417 else {
418 switch (to->si_code >> 16) {
419 case __SI_CHLD >> 16:
420 err |= __get_user(to->si_utime, &from->si_utime);
421 err |= __get_user(to->si_stime, &from->si_stime);
422 err |= __get_user(to->si_status, &from->si_status);
423 default:
424 err |= __get_user(to->si_pid, &from->si_pid);
425 err |= __get_user(to->si_uid, &from->si_uid);
426 break;
427 case __SI_FAULT >> 16:
428 err |= __get_user(addr, &from->si_addr);
429 to->si_addr = compat_ptr(addr);
430 break;
431 case __SI_POLL >> 16:
432 err |= __get_user(to->si_band, &from->si_band);
433 err |= __get_user(to->si_fd, &from->si_fd);
434 break;
435 case __SI_RT >> 16:
436 case __SI_MESGQ >> 16:
437 err |= __get_user(to->si_pid, &from->si_pid);
438 err |= __get_user(to->si_uid, &from->si_uid);
439 err |= __get_user(to->si_int, &from->si_int);
440 break;
441 }
442 }
443 return err;
444}
445
446int
447copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from)
448{
449 compat_uptr_t addr;
450 compat_int_t val;
451 int err;
452
453 if (!access_ok(VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
454 return -EFAULT;
455
456
457
458
459
460
461
462
463 err = __put_user(from->si_signo, &to->si_signo);
464 err |= __put_user(from->si_errno, &to->si_errno);
465 err |= __put_user((short)from->si_code, &to->si_code);
466 if (from->si_code < 0)
467 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
468 else {
469 switch (from->si_code >> 16) {
470 case __SI_CHLD >> 16:
471 err |= __put_user(from->si_utime, &to->si_utime);
472 err |= __put_user(from->si_stime, &to->si_stime);
473 err |= __put_user(from->si_status, &to->si_status);
474 default:
475 err |= __put_user(from->si_pid, &to->si_pid);
476 err |= __put_user(from->si_uid, &to->si_uid);
477 break;
478 case __SI_FAULT >> 16:
479 addr = ptr_to_compat(from->si_addr);
480 err |= __put_user(addr, &to->si_addr);
481 break;
482 case __SI_POLL >> 16:
483 err |= __put_user(from->si_band, &to->si_band);
484 err |= __put_user(from->si_fd, &to->si_fd);
485 break;
486 case __SI_TIMER >> 16:
487 err |= __put_user(from->si_tid, &to->si_tid);
488 err |= __put_user(from->si_overrun, &to->si_overrun);
489 val = (compat_int_t)from->si_int;
490 err |= __put_user(val, &to->si_int);
491 break;
492 case __SI_RT >> 16:
493 case __SI_MESGQ >> 16:
494 err |= __put_user(from->si_uid, &to->si_uid);
495 err |= __put_user(from->si_pid, &to->si_pid);
496 val = (compat_int_t)from->si_int;
497 err |= __put_user(val, &to->si_int);
498 break;
499 }
500 }
501 return err;
502}
503
504asmlinkage long compat_sys_rt_sigqueueinfo(int pid, int sig,
505 struct compat_siginfo __user *uinfo)
506{
507 siginfo_t info;
508
509 if (copy_siginfo_from_user32(&info, uinfo))
510 return -EFAULT;
511
512
513
514 if (info.si_code >= 0)
515 return -EPERM;
516 info.si_signo = sig;
517
518
519 return kill_proc_info(sig, &info, pid);
520}
521
522