1 /*
2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
4 * for more details.
5 *
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 * Copyright (C) 1994 - 2000, 2006 Ralf Baechle
8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
9 */
10 #include <linux/cache.h>
11 #include <linux/compat.h>
12 #include <linux/sched.h>
13 #include <linux/mm.h>
14 #include <linux/smp.h>
15 #include <linux/kernel.h>
16 #include <linux/signal.h>
17 #include <linux/syscalls.h>
18 #include <linux/errno.h>
19 #include <linux/wait.h>
20 #include <linux/ptrace.h>
21 #include <linux/suspend.h>
22 #include <linux/compiler.h>
23 #include <linux/uaccess.h>
24
25 #include <asm/abi.h>
26 #include <asm/asm.h>
27 #include <asm/compat-signal.h>
28 #include <linux/bitops.h>
29 #include <asm/cacheflush.h>
30 #include <asm/sim.h>
31 #include <asm/ucontext.h>
32 #include <asm/system.h>
33 #include <asm/fpu.h>
34 #include <asm/war.h>
35
36 #include "signal-common.h"
37
38 /*
39 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
40 */
41 #define __NR_O32_sigreturn 4119
42 #define __NR_O32_rt_sigreturn 4193
43 #define __NR_O32_restart_syscall 4253
44
45 /* 32-bit compatibility types */
46
47 typedef unsigned int __sighandler32_t;
48 typedef void (*vfptr_t)(void);
49
50 struct sigaction32 {
51 unsigned int sa_flags;
52 __sighandler32_t sa_handler;
53 compat_sigset_t sa_mask;
54 };
55
56 /* IRIX compatible stack_t */
57 typedef struct sigaltstack32 {
58 s32 ss_sp;
59 compat_size_t ss_size;
60 int ss_flags;
61 } stack32_t;
62
63 struct ucontext32 {
64 u32 uc_flags;
65 s32 uc_link;
66 stack32_t uc_stack;
67 struct sigcontext32 uc_mcontext;
68 compat_sigset_t uc_sigmask; /* mask last for extensibility */
69 };
70
71 /*
72 * Horribly complicated - with the bloody RM9000 workarounds enabled
73 * the signal trampolines is moving to the end of the structure so we can
74 * increase the alignment without breaking software compatibility.
75 */
76 #if ICACHE_REFILLS_WORKAROUND_WAR == 0
77
78 struct sigframe32 {
79 u32 sf_ass[4]; /* argument save space for o32 */
80 u32 sf_code[2]; /* signal trampoline */
81 struct sigcontext32 sf_sc;
82 compat_sigset_t sf_mask;
83 };
84
85 struct rt_sigframe32 {
86 u32 rs_ass[4]; /* argument save space for o32 */
87 u32 rs_code[2]; /* signal trampoline */
88 compat_siginfo_t rs_info;
89 struct ucontext32 rs_uc;
90 };
91
92 #else /* ICACHE_REFILLS_WORKAROUND_WAR */
93
94 struct sigframe32 {
95 u32 sf_ass[4]; /* argument save space for o32 */
96 u32 sf_pad[2];
97 struct sigcontext32 sf_sc; /* hw context */
98 compat_sigset_t sf_mask;
99 u32 sf_code[8] ____cacheline_aligned; /* signal trampoline */
100 };
101
102 struct rt_sigframe32 {
103 u32 rs_ass[4]; /* argument save space for o32 */
104 u32 rs_pad[2];
105 compat_siginfo_t rs_info;
106 struct ucontext32 rs_uc;
107 u32 rs_code[8] __attribute__((aligned(32))); /* signal trampoline */
108 };
109
110 #endif /* !ICACHE_REFILLS_WORKAROUND_WAR */
111
112 /*
113 * sigcontext handlers
114 */
protected_save_fp_context32(struct sigcontext32 __user * sc)115 static int protected_save_fp_context32(struct sigcontext32 __user *sc)
116 {
117 int err;
118 while (1) {
119 lock_fpu_owner();
120 own_fpu_inatomic(1);
121 err = save_fp_context32(sc); /* this might fail */
122 unlock_fpu_owner();
123 if (likely(!err))
124 break;
125 /* touch the sigcontext and try again */
126 err = __put_user(0, &sc->sc_fpregs[0]) |
127 __put_user(0, &sc->sc_fpregs[31]) |
128 __put_user(0, &sc->sc_fpc_csr);
129 if (err)
130 break; /* really bad sigcontext */
131 }
132 return err;
133 }
134
protected_restore_fp_context32(struct sigcontext32 __user * sc)135 static int protected_restore_fp_context32(struct sigcontext32 __user *sc)
136 {
137 int err, tmp;
138 while (1) {
139 lock_fpu_owner();
140 own_fpu_inatomic(0);
141 err = restore_fp_context32(sc); /* this might fail */
142 unlock_fpu_owner();
143 if (likely(!err))
144 break;
145 /* touch the sigcontext and try again */
146 err = __get_user(tmp, &sc->sc_fpregs[0]) |
147 __get_user(tmp, &sc->sc_fpregs[31]) |
148 __get_user(tmp, &sc->sc_fpc_csr);
149 if (err)
150 break; /* really bad sigcontext */
151 }
152 return err;
153 }
154
setup_sigcontext32(struct pt_regs * regs,struct sigcontext32 __user * sc)155 static int setup_sigcontext32(struct pt_regs *regs,
156 struct sigcontext32 __user *sc)
157 {
158 int err = 0;
159 int i;
160 u32 used_math;
161
162 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
163
164 err |= __put_user(0, &sc->sc_regs[0]);
165 for (i = 1; i < 32; i++)
166 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
167
168 err |= __put_user(regs->hi, &sc->sc_mdhi);
169 err |= __put_user(regs->lo, &sc->sc_mdlo);
170 if (cpu_has_dsp) {
171 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
172 err |= __put_user(mfhi1(), &sc->sc_hi1);
173 err |= __put_user(mflo1(), &sc->sc_lo1);
174 err |= __put_user(mfhi2(), &sc->sc_hi2);
175 err |= __put_user(mflo2(), &sc->sc_lo2);
176 err |= __put_user(mfhi3(), &sc->sc_hi3);
177 err |= __put_user(mflo3(), &sc->sc_lo3);
178 }
179
180 used_math = !!used_math();
181 err |= __put_user(used_math, &sc->sc_used_math);
182
183 if (used_math) {
184 /*
185 * Save FPU state to signal context. Signal handler
186 * will "inherit" current FPU state.
187 */
188 err |= protected_save_fp_context32(sc);
189 }
190 return err;
191 }
192
193 static int
check_and_restore_fp_context32(struct sigcontext32 __user * sc)194 check_and_restore_fp_context32(struct sigcontext32 __user *sc)
195 {
196 int err, sig;
197
198 err = sig = fpcsr_pending(&sc->sc_fpc_csr);
199 if (err > 0)
200 err = 0;
201 err |= protected_restore_fp_context32(sc);
202 return err ?: sig;
203 }
204
restore_sigcontext32(struct pt_regs * regs,struct sigcontext32 __user * sc)205 static int restore_sigcontext32(struct pt_regs *regs,
206 struct sigcontext32 __user *sc)
207 {
208 u32 used_math;
209 int err = 0;
210 s32 treg;
211 int i;
212
213 /* Always make any pending restarted system calls return -EINTR */
214 current_thread_info()->restart_block.fn = do_no_restart_syscall;
215
216 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
217 err |= __get_user(regs->hi, &sc->sc_mdhi);
218 err |= __get_user(regs->lo, &sc->sc_mdlo);
219 if (cpu_has_dsp) {
220 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
221 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
222 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
223 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
224 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
225 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
226 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
227 }
228
229 for (i = 1; i < 32; i++)
230 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
231
232 err |= __get_user(used_math, &sc->sc_used_math);
233 conditional_used_math(used_math);
234
235 if (used_math) {
236 /* restore fpu context if we have used it before */
237 if (!err)
238 err = check_and_restore_fp_context32(sc);
239 } else {
240 /* signal handler may have used FPU. Give it up. */
241 lose_fpu(0);
242 }
243
244 return err;
245 }
246
247 /*
248 *
249 */
250 extern void __put_sigset_unknown_nsig(void);
251 extern void __get_sigset_unknown_nsig(void);
252
put_sigset(const sigset_t * kbuf,compat_sigset_t __user * ubuf)253 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
254 {
255 int err = 0;
256
257 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
258 return -EFAULT;
259
260 switch (_NSIG_WORDS) {
261 default:
262 __put_sigset_unknown_nsig();
263 case 2:
264 err |= __put_user(kbuf->sig[1] >> 32, &ubuf->sig[3]);
265 err |= __put_user(kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
266 case 1:
267 err |= __put_user(kbuf->sig[0] >> 32, &ubuf->sig[1]);
268 err |= __put_user(kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
269 }
270
271 return err;
272 }
273
get_sigset(sigset_t * kbuf,const compat_sigset_t __user * ubuf)274 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf)
275 {
276 int err = 0;
277 unsigned long sig[4];
278
279 if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
280 return -EFAULT;
281
282 switch (_NSIG_WORDS) {
283 default:
284 __get_sigset_unknown_nsig();
285 case 2:
286 err |= __get_user(sig[3], &ubuf->sig[3]);
287 err |= __get_user(sig[2], &ubuf->sig[2]);
288 kbuf->sig[1] = sig[2] | (sig[3] << 32);
289 case 1:
290 err |= __get_user(sig[1], &ubuf->sig[1]);
291 err |= __get_user(sig[0], &ubuf->sig[0]);
292 kbuf->sig[0] = sig[0] | (sig[1] << 32);
293 }
294
295 return err;
296 }
297
298 /*
299 * Atomically swap in the new signal mask, and wait for a signal.
300 */
301
sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)302 asmlinkage int sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
303 {
304 compat_sigset_t __user *uset;
305 sigset_t newset;
306
307 uset = (compat_sigset_t __user *) regs.regs[4];
308 if (get_sigset(&newset, uset))
309 return -EFAULT;
310 sigdelsetmask(&newset, ~_BLOCKABLE);
311
312 spin_lock_irq(¤t->sighand->siglock);
313 current->saved_sigmask = current->blocked;
314 current->blocked = newset;
315 recalc_sigpending();
316 spin_unlock_irq(¤t->sighand->siglock);
317
318 current->state = TASK_INTERRUPTIBLE;
319 schedule();
320 set_thread_flag(TIF_RESTORE_SIGMASK);
321 return -ERESTARTNOHAND;
322 }
323
sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)324 asmlinkage int sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
325 {
326 compat_sigset_t __user *uset;
327 sigset_t newset;
328 size_t sigsetsize;
329
330 /* XXX Don't preclude handling different sized sigset_t's. */
331 sigsetsize = regs.regs[5];
332 if (sigsetsize != sizeof(compat_sigset_t))
333 return -EINVAL;
334
335 uset = (compat_sigset_t __user *) regs.regs[4];
336 if (get_sigset(&newset, uset))
337 return -EFAULT;
338 sigdelsetmask(&newset, ~_BLOCKABLE);
339
340 spin_lock_irq(¤t->sighand->siglock);
341 current->saved_sigmask = current->blocked;
342 current->blocked = newset;
343 recalc_sigpending();
344 spin_unlock_irq(¤t->sighand->siglock);
345
346 current->state = TASK_INTERRUPTIBLE;
347 schedule();
348 set_thread_flag(TIF_RESTORE_SIGMASK);
349 return -ERESTARTNOHAND;
350 }
351
352 SYSCALL_DEFINE3(32_sigaction, long, sig, const struct sigaction32 __user *, act,
353 struct sigaction32 __user *, oact)
354 {
355 struct k_sigaction new_ka, old_ka;
356 int ret;
357 int err = 0;
358
359 if (act) {
360 old_sigset_t mask;
361 s32 handler;
362
363 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
364 return -EFAULT;
365 err |= __get_user(handler, &act->sa_handler);
366 new_ka.sa.sa_handler = (void __user *)(s64)handler;
367 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
368 err |= __get_user(mask, &act->sa_mask.sig[0]);
369 if (err)
370 return -EFAULT;
371
372 siginitset(&new_ka.sa.sa_mask, mask);
373 }
374
375 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
376
377 if (!ret && oact) {
378 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
379 return -EFAULT;
380 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
381 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
382 &oact->sa_handler);
383 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
384 err |= __put_user(0, &oact->sa_mask.sig[1]);
385 err |= __put_user(0, &oact->sa_mask.sig[2]);
386 err |= __put_user(0, &oact->sa_mask.sig[3]);
387 if (err)
388 return -EFAULT;
389 }
390
391 return ret;
392 }
393
sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)394 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
395 {
396 const stack32_t __user *uss = (const stack32_t __user *) regs.regs[4];
397 stack32_t __user *uoss = (stack32_t __user *) regs.regs[5];
398 unsigned long usp = regs.regs[29];
399 stack_t kss, koss;
400 int ret, err = 0;
401 mm_segment_t old_fs = get_fs();
402 s32 sp;
403
404 if (uss) {
405 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
406 return -EFAULT;
407 err |= __get_user(sp, &uss->ss_sp);
408 kss.ss_sp = (void __user *) (long) sp;
409 err |= __get_user(kss.ss_size, &uss->ss_size);
410 err |= __get_user(kss.ss_flags, &uss->ss_flags);
411 if (err)
412 return -EFAULT;
413 }
414
415 set_fs(KERNEL_DS);
416 ret = do_sigaltstack(uss ? (stack_t __user *)&kss : NULL,
417 uoss ? (stack_t __user *)&koss : NULL, usp);
418 set_fs(old_fs);
419
420 if (!ret && uoss) {
421 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
422 return -EFAULT;
423 sp = (int) (unsigned long) koss.ss_sp;
424 err |= __put_user(sp, &uoss->ss_sp);
425 err |= __put_user(koss.ss_size, &uoss->ss_size);
426 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
427 if (err)
428 return -EFAULT;
429 }
430 return ret;
431 }
432
copy_siginfo_to_user32(compat_siginfo_t __user * to,siginfo_t * from)433 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
434 {
435 int err;
436
437 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
438 return -EFAULT;
439
440 /* If you change siginfo_t structure, please be sure
441 this code is fixed accordingly.
442 It should never copy any pad contained in the structure
443 to avoid security leaks, but must copy the generic
444 3 ints plus the relevant union member.
445 This routine must convert siginfo from 64bit to 32bit as well
446 at the same time. */
447 err = __put_user(from->si_signo, &to->si_signo);
448 err |= __put_user(from->si_errno, &to->si_errno);
449 err |= __put_user((short)from->si_code, &to->si_code);
450 if (from->si_code < 0)
451 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
452 else {
453 switch (from->si_code >> 16) {
454 case __SI_TIMER >> 16:
455 err |= __put_user(from->si_tid, &to->si_tid);
456 err |= __put_user(from->si_overrun, &to->si_overrun);
457 err |= __put_user(from->si_int, &to->si_int);
458 break;
459 case __SI_CHLD >> 16:
460 err |= __put_user(from->si_utime, &to->si_utime);
461 err |= __put_user(from->si_stime, &to->si_stime);
462 err |= __put_user(from->si_status, &to->si_status);
463 default:
464 err |= __put_user(from->si_pid, &to->si_pid);
465 err |= __put_user(from->si_uid, &to->si_uid);
466 break;
467 case __SI_FAULT >> 16:
468 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
469 break;
470 case __SI_POLL >> 16:
471 err |= __put_user(from->si_band, &to->si_band);
472 err |= __put_user(from->si_fd, &to->si_fd);
473 break;
474 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
475 case __SI_MESGQ >> 16:
476 err |= __put_user(from->si_pid, &to->si_pid);
477 err |= __put_user(from->si_uid, &to->si_uid);
478 err |= __put_user(from->si_int, &to->si_int);
479 break;
480 }
481 }
482 return err;
483 }
484
copy_siginfo_from_user32(siginfo_t * to,compat_siginfo_t __user * from)485 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
486 {
487 memset(to, 0, sizeof *to);
488
489 if (copy_from_user(to, from, 3*sizeof(int)) ||
490 copy_from_user(to->_sifields._pad,
491 from->_sifields._pad, SI_PAD_SIZE32))
492 return -EFAULT;
493
494 return 0;
495 }
496
sys32_sigreturn(nabi_no_regargs struct pt_regs regs)497 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
498 {
499 struct sigframe32 __user *frame;
500 sigset_t blocked;
501 int sig;
502
503 frame = (struct sigframe32 __user *) regs.regs[29];
504 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
505 goto badframe;
506 if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
507 goto badframe;
508
509 sigdelsetmask(&blocked, ~_BLOCKABLE);
510 spin_lock_irq(¤t->sighand->siglock);
511 current->blocked = blocked;
512 recalc_sigpending();
513 spin_unlock_irq(¤t->sighand->siglock);
514
515 sig = restore_sigcontext32(®s, &frame->sf_sc);
516 if (sig < 0)
517 goto badframe;
518 else if (sig)
519 force_sig(sig, current);
520
521 /*
522 * Don't let your children do this ...
523 */
524 __asm__ __volatile__(
525 "move\t$29, %0\n\t"
526 "j\tsyscall_exit"
527 :/* no outputs */
528 :"r" (®s));
529 /* Unreached */
530
531 badframe:
532 force_sig(SIGSEGV, current);
533 }
534
sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)535 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
536 {
537 struct rt_sigframe32 __user *frame;
538 mm_segment_t old_fs;
539 sigset_t set;
540 stack_t st;
541 s32 sp;
542 int sig;
543
544 frame = (struct rt_sigframe32 __user *) regs.regs[29];
545 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
546 goto badframe;
547 if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
548 goto badframe;
549
550 sigdelsetmask(&set, ~_BLOCKABLE);
551 spin_lock_irq(¤t->sighand->siglock);
552 current->blocked = set;
553 recalc_sigpending();
554 spin_unlock_irq(¤t->sighand->siglock);
555
556 sig = restore_sigcontext32(®s, &frame->rs_uc.uc_mcontext);
557 if (sig < 0)
558 goto badframe;
559 else if (sig)
560 force_sig(sig, current);
561
562 /* The ucontext contains a stack32_t, so we must convert! */
563 if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
564 goto badframe;
565 st.ss_sp = (void __user *)(long) sp;
566 if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
567 goto badframe;
568 if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
569 goto badframe;
570
571 /* It is more difficult to avoid calling this function than to
572 call it and ignore errors. */
573 old_fs = get_fs();
574 set_fs(KERNEL_DS);
575 do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
576 set_fs(old_fs);
577
578 /*
579 * Don't let your children do this ...
580 */
581 __asm__ __volatile__(
582 "move\t$29, %0\n\t"
583 "j\tsyscall_exit"
584 :/* no outputs */
585 :"r" (®s));
586 /* Unreached */
587
588 badframe:
589 force_sig(SIGSEGV, current);
590 }
591
setup_frame_32(struct k_sigaction * ka,struct pt_regs * regs,int signr,sigset_t * set)592 static int setup_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
593 int signr, sigset_t *set)
594 {
595 struct sigframe32 __user *frame;
596 int err = 0;
597
598 frame = get_sigframe(ka, regs, sizeof(*frame));
599 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
600 goto give_sigsegv;
601
602 err |= install_sigtramp(frame->sf_code, __NR_O32_sigreturn);
603
604 err |= setup_sigcontext32(regs, &frame->sf_sc);
605 err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
606
607 if (err)
608 goto give_sigsegv;
609
610 /*
611 * Arguments to signal handler:
612 *
613 * a0 = signal number
614 * a1 = 0 (should be cause)
615 * a2 = pointer to struct sigcontext
616 *
617 * $25 and c0_epc point to the signal handler, $29 points to the
618 * struct sigframe.
619 */
620 regs->regs[ 4] = signr;
621 regs->regs[ 5] = 0;
622 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
623 regs->regs[29] = (unsigned long) frame;
624 regs->regs[31] = (unsigned long) frame->sf_code;
625 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
626
627 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
628 current->comm, current->pid,
629 frame, regs->cp0_epc, regs->regs[31]);
630
631 return 0;
632
633 give_sigsegv:
634 force_sigsegv(signr, current);
635 return -EFAULT;
636 }
637
setup_rt_frame_32(struct k_sigaction * ka,struct pt_regs * regs,int signr,sigset_t * set,siginfo_t * info)638 static int setup_rt_frame_32(struct k_sigaction * ka, struct pt_regs *regs,
639 int signr, sigset_t *set, siginfo_t *info)
640 {
641 struct rt_sigframe32 __user *frame;
642 int err = 0;
643 s32 sp;
644
645 frame = get_sigframe(ka, regs, sizeof(*frame));
646 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
647 goto give_sigsegv;
648
649 err |= install_sigtramp(frame->rs_code, __NR_O32_rt_sigreturn);
650
651 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
652 err |= copy_siginfo_to_user32(&frame->rs_info, info);
653
654 /* Create the ucontext. */
655 err |= __put_user(0, &frame->rs_uc.uc_flags);
656 err |= __put_user(0, &frame->rs_uc.uc_link);
657 sp = (int) (long) current->sas_ss_sp;
658 err |= __put_user(sp,
659 &frame->rs_uc.uc_stack.ss_sp);
660 err |= __put_user(sas_ss_flags(regs->regs[29]),
661 &frame->rs_uc.uc_stack.ss_flags);
662 err |= __put_user(current->sas_ss_size,
663 &frame->rs_uc.uc_stack.ss_size);
664 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
665 err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
666
667 if (err)
668 goto give_sigsegv;
669
670 /*
671 * Arguments to signal handler:
672 *
673 * a0 = signal number
674 * a1 = 0 (should be cause)
675 * a2 = pointer to ucontext
676 *
677 * $25 and c0_epc point to the signal handler, $29 points to
678 * the struct rt_sigframe32.
679 */
680 regs->regs[ 4] = signr;
681 regs->regs[ 5] = (unsigned long) &frame->rs_info;
682 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
683 regs->regs[29] = (unsigned long) frame;
684 regs->regs[31] = (unsigned long) frame->rs_code;
685 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
686
687 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
688 current->comm, current->pid,
689 frame, regs->cp0_epc, regs->regs[31]);
690
691 return 0;
692
693 give_sigsegv:
694 force_sigsegv(signr, current);
695 return -EFAULT;
696 }
697
698 /*
699 * o32 compatibility on 64-bit kernels, without DSP ASE
700 */
701 struct mips_abi mips_abi_32 = {
702 .setup_frame = setup_frame_32,
703 .setup_rt_frame = setup_rt_frame_32,
704 .restart = __NR_O32_restart_syscall
705 };
706
707 SYSCALL_DEFINE4(32_rt_sigaction, int, sig,
708 const struct sigaction32 __user *, act,
709 struct sigaction32 __user *, oact, unsigned int, sigsetsize)
710 {
711 struct k_sigaction new_sa, old_sa;
712 int ret = -EINVAL;
713
714 /* XXX: Don't preclude handling different sized sigset_t's. */
715 if (sigsetsize != sizeof(sigset_t))
716 goto out;
717
718 if (act) {
719 s32 handler;
720 int err = 0;
721
722 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
723 return -EFAULT;
724 err |= __get_user(handler, &act->sa_handler);
725 new_sa.sa.sa_handler = (void __user *)(s64)handler;
726 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
727 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
728 if (err)
729 return -EFAULT;
730 }
731
732 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
733
734 if (!ret && oact) {
735 int err = 0;
736
737 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
738 return -EFAULT;
739
740 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
741 &oact->sa_handler);
742 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
743 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
744 if (err)
745 return -EFAULT;
746 }
747 out:
748 return ret;
749 }
750
751 SYSCALL_DEFINE4(32_rt_sigprocmask, int, how, compat_sigset_t __user *, set,
752 compat_sigset_t __user *, oset, unsigned int, sigsetsize)
753 {
754 sigset_t old_set, new_set;
755 int ret;
756 mm_segment_t old_fs = get_fs();
757
758 if (set && get_sigset(&new_set, set))
759 return -EFAULT;
760
761 set_fs(KERNEL_DS);
762 ret = sys_rt_sigprocmask(how, set ? (sigset_t __user *)&new_set : NULL,
763 oset ? (sigset_t __user *)&old_set : NULL,
764 sigsetsize);
765 set_fs(old_fs);
766
767 if (!ret && oset && put_sigset(&old_set, oset))
768 return -EFAULT;
769
770 return ret;
771 }
772
773 SYSCALL_DEFINE2(32_rt_sigpending, compat_sigset_t __user *, uset,
774 unsigned int, sigsetsize)
775 {
776 int ret;
777 sigset_t set;
778 mm_segment_t old_fs = get_fs();
779
780 set_fs(KERNEL_DS);
781 ret = sys_rt_sigpending((sigset_t __user *)&set, sigsetsize);
782 set_fs(old_fs);
783
784 if (!ret && put_sigset(&set, uset))
785 return -EFAULT;
786
787 return ret;
788 }
789
790 SYSCALL_DEFINE3(32_rt_sigqueueinfo, int, pid, int, sig,
791 compat_siginfo_t __user *, uinfo)
792 {
793 siginfo_t info;
794 int ret;
795 mm_segment_t old_fs = get_fs();
796
797 if (copy_from_user(&info, uinfo, 3*sizeof(int)) ||
798 copy_from_user(info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
799 return -EFAULT;
800 set_fs(KERNEL_DS);
801 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
802 set_fs(old_fs);
803 return ret;
804 }
805
806 SYSCALL_DEFINE5(32_waitid, int, which, compat_pid_t, pid,
807 compat_siginfo_t __user *, uinfo, int, options,
808 struct compat_rusage __user *, uru)
809 {
810 siginfo_t info;
811 struct rusage ru;
812 long ret;
813 mm_segment_t old_fs = get_fs();
814
815 info.si_signo = 0;
816 set_fs(KERNEL_DS);
817 ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options,
818 uru ? (struct rusage __user *) &ru : NULL);
819 set_fs(old_fs);
820
821 if (ret < 0 || info.si_signo == 0)
822 return ret;
823
824 if (uru && (ret = put_compat_rusage(&ru, uru)))
825 return ret;
826
827 BUG_ON(info.si_code & __SI_MASK);
828 info.si_code |= __SI_CHLD;
829 return copy_siginfo_to_user32(uinfo, &info);
830 }
831