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
6 * Copyright (C) 1991, 1992 Linus Torvalds
7 * Copyright (C) 1994 - 2000, 2006 Ralf Baechle
8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
10 #include <linux/cache.h>
11 #include <linux/compat.h>
12 #include <linux/sched.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>
27 #include <asm/compat-signal.h>
28 #include <linux/bitops.h>
29 #include <asm/cacheflush.h>
31 #include <asm/ucontext.h>
37 #include "signal-common.h"
39 static int (*save_fp_context32)(struct sigcontext32 __user *sc);
40 static int (*restore_fp_context32)(struct sigcontext32 __user *sc);
42 extern asmlinkage int _save_fp_context32(struct sigcontext32 __user *sc);
43 extern asmlinkage int _restore_fp_context32(struct sigcontext32 __user *sc);
45 extern asmlinkage int fpu_emulator_save_context32(struct sigcontext32 __user *sc);
46 extern asmlinkage int fpu_emulator_restore_context32(struct sigcontext32 __user *sc);
49 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
51 #define __NR_O32_restart_syscall 4253
53 /* 32-bit compatibility types */
55 typedef unsigned int __sighandler32_t;
56 typedef void (*vfptr_t)(void);
59 unsigned int sa_flags;
60 __sighandler32_t sa_handler;
61 compat_sigset_t sa_mask;
64 /* IRIX compatible stack_t */
65 typedef struct sigaltstack32 {
67 compat_size_t ss_size;
75 struct sigcontext32 uc_mcontext;
76 compat_sigset_t uc_sigmask; /* mask last for extensibility */
80 u32 sf_ass[4]; /* argument save space for o32 */
81 u32 sf_pad[2]; /* Was: signal trampoline */
82 struct sigcontext32 sf_sc;
83 compat_sigset_t sf_mask;
86 struct rt_sigframe32 {
87 u32 rs_ass[4]; /* argument save space for o32 */
88 u32 rs_pad[2]; /* Was: signal trampoline */
89 compat_siginfo_t rs_info;
90 struct ucontext32 rs_uc;
96 static int protected_save_fp_context32(struct sigcontext32 __user *sc)
102 err = save_fp_context32(sc); /* this might fail */
106 /* touch the sigcontext and try again */
107 err = __put_user(0, &sc->sc_fpregs[0]) |
108 __put_user(0, &sc->sc_fpregs[31]) |
109 __put_user(0, &sc->sc_fpc_csr);
111 break; /* really bad sigcontext */
116 static int protected_restore_fp_context32(struct sigcontext32 __user *sc)
118 int err, tmp __maybe_unused;
122 err = restore_fp_context32(sc); /* this might fail */
126 /* touch the sigcontext and try again */
127 err = __get_user(tmp, &sc->sc_fpregs[0]) |
128 __get_user(tmp, &sc->sc_fpregs[31]) |
129 __get_user(tmp, &sc->sc_fpc_csr);
131 break; /* really bad sigcontext */
136 static int setup_sigcontext32(struct pt_regs *regs,
137 struct sigcontext32 __user *sc)
143 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
145 err |= __put_user(0, &sc->sc_regs[0]);
146 for (i = 1; i < 32; i++)
147 err |= __put_user(regs->regs[i], &sc->sc_regs[i]);
149 err |= __put_user(regs->hi, &sc->sc_mdhi);
150 err |= __put_user(regs->lo, &sc->sc_mdlo);
152 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp);
153 err |= __put_user(mfhi1(), &sc->sc_hi1);
154 err |= __put_user(mflo1(), &sc->sc_lo1);
155 err |= __put_user(mfhi2(), &sc->sc_hi2);
156 err |= __put_user(mflo2(), &sc->sc_lo2);
157 err |= __put_user(mfhi3(), &sc->sc_hi3);
158 err |= __put_user(mflo3(), &sc->sc_lo3);
161 used_math = !!used_math();
162 err |= __put_user(used_math, &sc->sc_used_math);
166 * Save FPU state to signal context. Signal handler
167 * will "inherit" current FPU state.
169 err |= protected_save_fp_context32(sc);
175 check_and_restore_fp_context32(struct sigcontext32 __user *sc)
179 err = sig = fpcsr_pending(&sc->sc_fpc_csr);
182 err |= protected_restore_fp_context32(sc);
186 static int restore_sigcontext32(struct pt_regs *regs,
187 struct sigcontext32 __user *sc)
194 /* Always make any pending restarted system calls return -EINTR */
195 current_thread_info()->restart_block.fn = do_no_restart_syscall;
197 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
198 err |= __get_user(regs->hi, &sc->sc_mdhi);
199 err |= __get_user(regs->lo, &sc->sc_mdlo);
201 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg);
202 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg);
203 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg);
204 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg);
205 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg);
206 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg);
207 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK);
210 for (i = 1; i < 32; i++)
211 err |= __get_user(regs->regs[i], &sc->sc_regs[i]);
213 err |= __get_user(used_math, &sc->sc_used_math);
214 conditional_used_math(used_math);
217 /* restore fpu context if we have used it before */
219 err = check_and_restore_fp_context32(sc);
221 /* signal handler may have used FPU. Give it up. */
231 extern void __put_sigset_unknown_nsig(void);
232 extern void __get_sigset_unknown_nsig(void);
234 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t __user *ubuf)
238 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
241 switch (_NSIG_WORDS) {
243 __put_sigset_unknown_nsig();
245 err |= __put_user(kbuf->sig[1] >> 32, &ubuf->sig[3]);
246 err |= __put_user(kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
248 err |= __put_user(kbuf->sig[0] >> 32, &ubuf->sig[1]);
249 err |= __put_user(kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
255 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t __user *ubuf)
258 unsigned long sig[4];
260 if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
263 switch (_NSIG_WORDS) {
265 __get_sigset_unknown_nsig();
267 err |= __get_user(sig[3], &ubuf->sig[3]);
268 err |= __get_user(sig[2], &ubuf->sig[2]);
269 kbuf->sig[1] = sig[2] | (sig[3] << 32);
271 err |= __get_user(sig[1], &ubuf->sig[1]);
272 err |= __get_user(sig[0], &ubuf->sig[0]);
273 kbuf->sig[0] = sig[0] | (sig[1] << 32);
280 * Atomically swap in the new signal mask, and wait for a signal.
283 asmlinkage int sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
285 compat_sigset_t __user *uset;
288 uset = (compat_sigset_t __user *) regs.regs[4];
289 if (get_sigset(&newset, uset))
291 return sigsuspend(&newset);
294 asmlinkage int sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
296 compat_sigset_t __user *uset;
300 /* XXX Don't preclude handling different sized sigset_t's. */
301 sigsetsize = regs.regs[5];
302 if (sigsetsize != sizeof(compat_sigset_t))
305 uset = (compat_sigset_t __user *) regs.regs[4];
306 if (get_sigset(&newset, uset))
308 return sigsuspend(&newset);
311 SYSCALL_DEFINE3(32_sigaction, long, sig, const struct sigaction32 __user *, act,
312 struct sigaction32 __user *, oact)
314 struct k_sigaction new_ka, old_ka;
322 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
324 err |= __get_user(handler, &act->sa_handler);
325 new_ka.sa.sa_handler = (void __user *)(s64)handler;
326 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
327 err |= __get_user(mask, &act->sa_mask.sig[0]);
331 siginitset(&new_ka.sa.sa_mask, mask);
334 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
337 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
339 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
340 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
342 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
343 err |= __put_user(0, &oact->sa_mask.sig[1]);
344 err |= __put_user(0, &oact->sa_mask.sig[2]);
345 err |= __put_user(0, &oact->sa_mask.sig[3]);
353 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
355 const stack32_t __user *uss = (const stack32_t __user *) regs.regs[4];
356 stack32_t __user *uoss = (stack32_t __user *) regs.regs[5];
357 unsigned long usp = regs.regs[29];
360 mm_segment_t old_fs = get_fs();
364 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
366 err |= __get_user(sp, &uss->ss_sp);
367 kss.ss_sp = (void __user *) (long) sp;
368 err |= __get_user(kss.ss_size, &uss->ss_size);
369 err |= __get_user(kss.ss_flags, &uss->ss_flags);
375 ret = do_sigaltstack(uss ? (stack_t __user *)&kss : NULL,
376 uoss ? (stack_t __user *)&koss : NULL, usp);
380 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
382 sp = (int) (unsigned long) koss.ss_sp;
383 err |= __put_user(sp, &uoss->ss_sp);
384 err |= __put_user(koss.ss_size, &uoss->ss_size);
385 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
392 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
396 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
399 /* If you change siginfo_t structure, please be sure
400 this code is fixed accordingly.
401 It should never copy any pad contained in the structure
402 to avoid security leaks, but must copy the generic
403 3 ints plus the relevant union member.
404 This routine must convert siginfo from 64bit to 32bit as well
406 err = __put_user(from->si_signo, &to->si_signo);
407 err |= __put_user(from->si_errno, &to->si_errno);
408 err |= __put_user((short)from->si_code, &to->si_code);
409 if (from->si_code < 0)
410 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
412 switch (from->si_code >> 16) {
413 case __SI_TIMER >> 16:
414 err |= __put_user(from->si_tid, &to->si_tid);
415 err |= __put_user(from->si_overrun, &to->si_overrun);
416 err |= __put_user(from->si_int, &to->si_int);
418 case __SI_CHLD >> 16:
419 err |= __put_user(from->si_utime, &to->si_utime);
420 err |= __put_user(from->si_stime, &to->si_stime);
421 err |= __put_user(from->si_status, &to->si_status);
423 err |= __put_user(from->si_pid, &to->si_pid);
424 err |= __put_user(from->si_uid, &to->si_uid);
426 case __SI_FAULT >> 16:
427 err |= __put_user((unsigned long)from->si_addr, &to->si_addr);
429 case __SI_POLL >> 16:
430 err |= __put_user(from->si_band, &to->si_band);
431 err |= __put_user(from->si_fd, &to->si_fd);
433 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
434 case __SI_MESGQ >> 16:
435 err |= __put_user(from->si_pid, &to->si_pid);
436 err |= __put_user(from->si_uid, &to->si_uid);
437 err |= __put_user(from->si_int, &to->si_int);
444 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
446 memset(to, 0, sizeof *to);
448 if (copy_from_user(to, from, 3*sizeof(int)) ||
449 copy_from_user(to->_sifields._pad,
450 from->_sifields._pad, SI_PAD_SIZE32))
456 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
458 struct sigframe32 __user *frame;
462 frame = (struct sigframe32 __user *) regs.regs[29];
463 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
465 if (__copy_conv_sigset_from_user(&blocked, &frame->sf_mask))
468 sigdelsetmask(&blocked, ~_BLOCKABLE);
469 set_current_blocked(&blocked);
471 sig = restore_sigcontext32(®s, &frame->sf_sc);
475 force_sig(sig, current);
478 * Don't let your children do this ...
480 __asm__ __volatile__(
488 force_sig(SIGSEGV, current);
491 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
493 struct rt_sigframe32 __user *frame;
500 frame = (struct rt_sigframe32 __user *) regs.regs[29];
501 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
503 if (__copy_conv_sigset_from_user(&set, &frame->rs_uc.uc_sigmask))
506 sigdelsetmask(&set, ~_BLOCKABLE);
507 set_current_blocked(&set);
509 sig = restore_sigcontext32(®s, &frame->rs_uc.uc_mcontext);
513 force_sig(sig, current);
515 /* The ucontext contains a stack32_t, so we must convert! */
516 if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
518 st.ss_sp = (void __user *)(long) sp;
519 if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
521 if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
524 /* It is more difficult to avoid calling this function than to
525 call it and ignore errors. */
528 do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]);
532 * Don't let your children do this ...
534 __asm__ __volatile__(
542 force_sig(SIGSEGV, current);
545 static int setup_frame_32(void *sig_return, struct k_sigaction *ka,
546 struct pt_regs *regs, int signr, sigset_t *set)
548 struct sigframe32 __user *frame;
551 frame = get_sigframe(ka, regs, sizeof(*frame));
552 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
555 err |= setup_sigcontext32(regs, &frame->sf_sc);
556 err |= __copy_conv_sigset_to_user(&frame->sf_mask, set);
562 * Arguments to signal handler:
565 * a1 = 0 (should be cause)
566 * a2 = pointer to struct sigcontext
568 * $25 and c0_epc point to the signal handler, $29 points to the
571 regs->regs[ 4] = signr;
573 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
574 regs->regs[29] = (unsigned long) frame;
575 regs->regs[31] = (unsigned long) sig_return;
576 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
578 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
579 current->comm, current->pid,
580 frame, regs->cp0_epc, regs->regs[31]);
585 force_sigsegv(signr, current);
589 static int setup_rt_frame_32(void *sig_return, struct k_sigaction *ka,
590 struct pt_regs *regs, int signr, sigset_t *set,
593 struct rt_sigframe32 __user *frame;
597 frame = get_sigframe(ka, regs, sizeof(*frame));
598 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
601 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
602 err |= copy_siginfo_to_user32(&frame->rs_info, info);
604 /* Create the ucontext. */
605 err |= __put_user(0, &frame->rs_uc.uc_flags);
606 err |= __put_user(0, &frame->rs_uc.uc_link);
607 sp = (int) (long) current->sas_ss_sp;
608 err |= __put_user(sp,
609 &frame->rs_uc.uc_stack.ss_sp);
610 err |= __put_user(sas_ss_flags(regs->regs[29]),
611 &frame->rs_uc.uc_stack.ss_flags);
612 err |= __put_user(current->sas_ss_size,
613 &frame->rs_uc.uc_stack.ss_size);
614 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
615 err |= __copy_conv_sigset_to_user(&frame->rs_uc.uc_sigmask, set);
621 * Arguments to signal handler:
624 * a1 = 0 (should be cause)
625 * a2 = pointer to ucontext
627 * $25 and c0_epc point to the signal handler, $29 points to
628 * the struct rt_sigframe32.
630 regs->regs[ 4] = signr;
631 regs->regs[ 5] = (unsigned long) &frame->rs_info;
632 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
633 regs->regs[29] = (unsigned long) frame;
634 regs->regs[31] = (unsigned long) sig_return;
635 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
637 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n",
638 current->comm, current->pid,
639 frame, regs->cp0_epc, regs->regs[31]);
644 force_sigsegv(signr, current);
649 * o32 compatibility on 64-bit kernels, without DSP ASE
651 struct mips_abi mips_abi_32 = {
652 .setup_frame = setup_frame_32,
653 .signal_return_offset =
654 offsetof(struct mips_vdso, o32_signal_trampoline),
655 .setup_rt_frame = setup_rt_frame_32,
656 .rt_signal_return_offset =
657 offsetof(struct mips_vdso, o32_rt_signal_trampoline),
658 .restart = __NR_O32_restart_syscall
661 SYSCALL_DEFINE4(32_rt_sigaction, int, sig,
662 const struct sigaction32 __user *, act,
663 struct sigaction32 __user *, oact, unsigned int, sigsetsize)
665 struct k_sigaction new_sa, old_sa;
668 /* XXX: Don't preclude handling different sized sigset_t's. */
669 if (sigsetsize != sizeof(sigset_t))
676 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
678 err |= __get_user(handler, &act->sa_handler);
679 new_sa.sa.sa_handler = (void __user *)(s64)handler;
680 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
681 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
686 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
691 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
694 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
696 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
697 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
705 SYSCALL_DEFINE4(32_rt_sigprocmask, int, how, compat_sigset_t __user *, set,
706 compat_sigset_t __user *, oset, unsigned int, sigsetsize)
708 sigset_t old_set, new_set;
710 mm_segment_t old_fs = get_fs();
712 if (set && get_sigset(&new_set, set))
716 ret = sys_rt_sigprocmask(how, set ? (sigset_t __user *)&new_set : NULL,
717 oset ? (sigset_t __user *)&old_set : NULL,
721 if (!ret && oset && put_sigset(&old_set, oset))
727 SYSCALL_DEFINE2(32_rt_sigpending, compat_sigset_t __user *, uset,
728 unsigned int, sigsetsize)
732 mm_segment_t old_fs = get_fs();
735 ret = sys_rt_sigpending((sigset_t __user *)&set, sigsetsize);
738 if (!ret && put_sigset(&set, uset))
744 SYSCALL_DEFINE3(32_rt_sigqueueinfo, int, pid, int, sig,
745 compat_siginfo_t __user *, uinfo)
749 mm_segment_t old_fs = get_fs();
751 if (copy_from_user(&info, uinfo, 3*sizeof(int)) ||
752 copy_from_user(info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
755 ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __user *)&info);
760 SYSCALL_DEFINE5(32_waitid, int, which, compat_pid_t, pid,
761 compat_siginfo_t __user *, uinfo, int, options,
762 struct compat_rusage __user *, uru)
767 mm_segment_t old_fs = get_fs();
771 ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options,
772 uru ? (struct rusage __user *) &ru : NULL);
775 if (ret < 0 || info.si_signo == 0)
778 if (uru && (ret = put_compat_rusage(&ru, uru)))
781 BUG_ON(info.si_code & __SI_MASK);
782 info.si_code |= __SI_CHLD;
783 return copy_siginfo_to_user32(uinfo, &info);
786 static int signal32_init(void)
789 save_fp_context32 = _save_fp_context32;
790 restore_fp_context32 = _restore_fp_context32;
792 save_fp_context32 = fpu_emulator_save_context32;
793 restore_fp_context32 = fpu_emulator_restore_context32;
799 arch_initcall(signal32_init);