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 Ralf Baechle
8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc.
10 #include <linux/sched.h>
12 #include <linux/smp.h>
13 #include <linux/smp_lock.h>
14 #include <linux/kernel.h>
15 #include <linux/signal.h>
16 #include <linux/syscalls.h>
17 #include <linux/errno.h>
18 #include <linux/wait.h>
19 #include <linux/ptrace.h>
20 #include <linux/compat.h>
21 #include <linux/suspend.h>
22 #include <linux/compiler.h>
25 #include <linux/bitops.h>
26 #include <asm/cacheflush.h>
28 #include <asm/uaccess.h>
29 #include <asm/ucontext.h>
30 #include <asm/system.h>
33 #define SI_PAD_SIZE32 ((SI_MAX_SIZE/sizeof(int)) - 3)
35 typedef struct compat_siginfo {
41 int _pad[SI_PAD_SIZE32];
45 compat_pid_t _pid; /* sender's pid */
46 compat_uid_t _uid; /* sender's uid */
51 compat_pid_t _pid; /* which child */
52 compat_uid_t _uid; /* sender's uid */
53 int _status; /* exit code */
54 compat_clock_t _utime;
55 compat_clock_t _stime;
60 compat_pid_t _pid; /* which child */
61 compat_clock_t _utime;
62 int _status; /* exit code */
63 compat_clock_t _stime;
66 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
68 s32 _addr; /* faulting insn/memory ref. */
71 /* SIGPOLL, SIGXFSZ (To do ...) */
73 int _band; /* POLL_IN, POLL_OUT, POLL_MSG */
79 timer_t _tid; /* timer id */
80 int _overrun; /* overrun count */
81 compat_sigval_t _sigval;/* same as below */
82 int _sys_private; /* not to be passed to user */
85 /* POSIX.1b signals */
87 compat_pid_t _pid; /* sender's pid */
88 compat_uid_t _uid; /* sender's uid */
89 compat_sigval_t _sigval;
96 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
98 #define __NR_O32_sigreturn 4119
99 #define __NR_O32_rt_sigreturn 4193
100 #define __NR_O32_restart_syscall 4253
104 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
106 extern int do_signal32(sigset_t *oldset, struct pt_regs *regs);
108 /* 32-bit compatibility types */
110 #define _NSIG_BPW32 32
111 #define _NSIG_WORDS32 (_NSIG / _NSIG_BPW32)
114 unsigned int sig[_NSIG_WORDS32];
117 typedef unsigned int __sighandler32_t;
118 typedef void (*vfptr_t)(void);
121 unsigned int sa_flags;
122 __sighandler32_t sa_handler;
123 compat_sigset_t sa_mask;
126 /* IRIX compatible stack_t */
127 typedef struct sigaltstack32 {
129 compat_size_t ss_size;
137 struct sigcontext32 uc_mcontext;
138 sigset_t32 uc_sigmask; /* mask last for extensibility */
141 extern void __put_sigset_unknown_nsig(void);
142 extern void __get_sigset_unknown_nsig(void);
144 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t *ubuf)
148 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
151 switch (_NSIG_WORDS) {
153 __put_sigset_unknown_nsig();
155 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]);
156 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
158 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]);
159 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
165 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t *ubuf)
168 unsigned long sig[4];
170 if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
173 switch (_NSIG_WORDS) {
175 __get_sigset_unknown_nsig();
177 err |= __get_user (sig[3], &ubuf->sig[3]);
178 err |= __get_user (sig[2], &ubuf->sig[2]);
179 kbuf->sig[1] = sig[2] | (sig[3] << 32);
181 err |= __get_user (sig[1], &ubuf->sig[1]);
182 err |= __get_user (sig[0], &ubuf->sig[0]);
183 kbuf->sig[0] = sig[0] | (sig[1] << 32);
190 * Atomically swap in the new signal mask, and wait for a signal.
193 save_static_function(sys32_sigsuspend);
194 __attribute_used__ noinline static int
195 _sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
197 compat_sigset_t *uset;
198 sigset_t newset, saveset;
200 uset = (compat_sigset_t *) regs.regs[4];
201 if (get_sigset(&newset, uset))
203 sigdelsetmask(&newset, ~_BLOCKABLE);
205 spin_lock_irq(¤t->sighand->siglock);
206 saveset = current->blocked;
207 current->blocked = newset;
209 spin_unlock_irq(¤t->sighand->siglock);
211 regs.regs[2] = EINTR;
214 current->state = TASK_INTERRUPTIBLE;
216 if (do_signal32(&saveset, ®s))
221 save_static_function(sys32_rt_sigsuspend);
222 __attribute_used__ noinline static int
223 _sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
225 compat_sigset_t *uset;
226 sigset_t newset, saveset;
229 /* XXX Don't preclude handling different sized sigset_t's. */
230 sigsetsize = regs.regs[5];
231 if (sigsetsize != sizeof(compat_sigset_t))
234 uset = (compat_sigset_t *) regs.regs[4];
235 if (get_sigset(&newset, uset))
237 sigdelsetmask(&newset, ~_BLOCKABLE);
239 spin_lock_irq(¤t->sighand->siglock);
240 saveset = current->blocked;
241 current->blocked = newset;
243 spin_unlock_irq(¤t->sighand->siglock);
245 regs.regs[2] = EINTR;
248 current->state = TASK_INTERRUPTIBLE;
250 if (do_signal32(&saveset, ®s))
255 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 *act,
256 struct sigaction32 *oact)
258 struct k_sigaction new_ka, old_ka;
266 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
268 err |= __get_user(handler, &act->sa_handler);
269 new_ka.sa.sa_handler = (void*)(s64)handler;
270 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
271 err |= __get_user(mask, &act->sa_mask.sig[0]);
275 siginitset(&new_ka.sa.sa_mask, mask);
278 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
281 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
283 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
284 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
286 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
287 err |= __put_user(0, &oact->sa_mask.sig[1]);
288 err |= __put_user(0, &oact->sa_mask.sig[2]);
289 err |= __put_user(0, &oact->sa_mask.sig[3]);
297 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
299 const stack32_t *uss = (const stack32_t *) regs.regs[4];
300 stack32_t *uoss = (stack32_t *) regs.regs[5];
301 unsigned long usp = regs.regs[29];
304 mm_segment_t old_fs = get_fs();
308 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
310 err |= __get_user(sp, &uss->ss_sp);
311 kss.ss_sp = (void *) (long) sp;
312 err |= __get_user(kss.ss_size, &uss->ss_size);
313 err |= __get_user(kss.ss_flags, &uss->ss_flags);
319 ret = do_sigaltstack(uss ? &kss : NULL , uoss ? &koss : NULL, usp);
323 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
325 sp = (int) (long) koss.ss_sp;
326 err |= __put_user(sp, &uoss->ss_sp);
327 err |= __put_user(koss.ss_size, &uoss->ss_size);
328 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
335 static int restore_sigcontext32(struct pt_regs *regs, struct sigcontext32 *sc)
340 /* Always make any pending restarted system calls return -EINTR */
341 current_thread_info()->restart_block.fn = do_no_restart_syscall;
343 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
344 err |= __get_user(regs->hi, &sc->sc_mdhi);
345 err |= __get_user(regs->lo, &sc->sc_mdlo);
347 #define restore_gp_reg(i) do { \
348 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); \
350 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
351 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
352 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
353 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
354 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
355 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
356 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
357 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
358 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
359 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
361 #undef restore_gp_reg
363 err |= __get_user(used_math, &sc->sc_used_math);
364 conditional_used_math(used_math);
369 /* restore fpu context if we have used it before */
371 err |= restore_fp_context32(sc);
373 /* signal handler may have used FPU. Give it up. */
383 u32 sf_ass[4]; /* argument save space for o32 */
384 u32 sf_code[2]; /* signal trampoline */
385 struct sigcontext32 sf_sc;
389 struct rt_sigframe32 {
390 u32 rs_ass[4]; /* argument save space for o32 */
391 u32 rs_code[2]; /* signal trampoline */
392 compat_siginfo_t rs_info;
393 struct ucontext32 rs_uc;
396 int copy_siginfo_to_user32(compat_siginfo_t *to, siginfo_t *from)
400 if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
403 /* If you change siginfo_t structure, please be sure
404 this code is fixed accordingly.
405 It should never copy any pad contained in the structure
406 to avoid security leaks, but must copy the generic
407 3 ints plus the relevant union member.
408 This routine must convert siginfo from 64bit to 32bit as well
410 err = __put_user(from->si_signo, &to->si_signo);
411 err |= __put_user(from->si_errno, &to->si_errno);
412 err |= __put_user((short)from->si_code, &to->si_code);
413 if (from->si_code < 0)
414 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
416 switch (from->si_code >> 16) {
417 case __SI_TIMER >> 16:
418 err |= __put_user(from->si_tid, &to->si_tid);
419 err |= __put_user(from->si_overrun, &to->si_overrun);
420 err |= __put_user(from->si_int, &to->si_int);
422 case __SI_CHLD >> 16:
423 err |= __put_user(from->si_utime, &to->si_utime);
424 err |= __put_user(from->si_stime, &to->si_stime);
425 err |= __put_user(from->si_status, &to->si_status);
427 err |= __put_user(from->si_pid, &to->si_pid);
428 err |= __put_user(from->si_uid, &to->si_uid);
430 case __SI_FAULT >> 16:
431 err |= __put_user((long)from->si_addr, &to->si_addr);
433 case __SI_POLL >> 16:
434 err |= __put_user(from->si_band, &to->si_band);
435 err |= __put_user(from->si_fd, &to->si_fd);
437 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
438 case __SI_MESGQ >> 16:
439 err |= __put_user(from->si_pid, &to->si_pid);
440 err |= __put_user(from->si_uid, &to->si_uid);
441 err |= __put_user(from->si_int, &to->si_int);
448 save_static_function(sys32_sigreturn);
449 __attribute_used__ noinline static void
450 _sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
452 struct sigframe *frame;
455 frame = (struct sigframe *) regs.regs[29];
456 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
458 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
461 sigdelsetmask(&blocked, ~_BLOCKABLE);
462 spin_lock_irq(¤t->sighand->siglock);
463 current->blocked = blocked;
465 spin_unlock_irq(¤t->sighand->siglock);
467 if (restore_sigcontext32(®s, &frame->sf_sc))
471 * Don't let your children do this ...
473 if (current_thread_info()->flags & TIF_SYSCALL_TRACE)
474 do_syscall_trace(®s, 1);
475 __asm__ __volatile__(
483 force_sig(SIGSEGV, current);
486 save_static_function(sys32_rt_sigreturn);
487 __attribute_used__ noinline static void
488 _sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
490 struct rt_sigframe32 *frame;
496 frame = (struct rt_sigframe32 *) regs.regs[29];
497 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
499 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
502 sigdelsetmask(&set, ~_BLOCKABLE);
503 spin_lock_irq(¤t->sighand->siglock);
504 current->blocked = set;
506 spin_unlock_irq(¤t->sighand->siglock);
508 if (restore_sigcontext32(®s, &frame->rs_uc.uc_mcontext))
511 /* The ucontext contains a stack32_t, so we must convert! */
512 if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
514 st.ss_size = (long) sp;
515 if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
517 if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
520 /* It is more difficult to avoid calling this function than to
521 call it and ignore errors. */
524 do_sigaltstack(&st, NULL, regs.regs[29]);
528 * Don't let your children do this ...
530 __asm__ __volatile__(
538 force_sig(SIGSEGV, current);
541 static inline int setup_sigcontext32(struct pt_regs *regs,
542 struct sigcontext32 *sc)
546 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
547 err |= __put_user(regs->cp0_status, &sc->sc_status);
549 #define save_gp_reg(i) { \
550 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); \
552 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
553 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
554 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
555 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
556 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
557 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
558 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
559 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
563 err |= __put_user(regs->hi, &sc->sc_mdhi);
564 err |= __put_user(regs->lo, &sc->sc_mdlo);
565 err |= __put_user(regs->cp0_cause, &sc->sc_cause);
566 err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
568 err |= __put_user(!!used_math(), &sc->sc_used_math);
574 * Save FPU state to signal context. Signal handler will "inherit"
579 if (!is_fpu_owner()) {
583 err |= save_fp_context32(sc);
592 * Determine which stack to use..
594 static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
599 /* Default to using normal stack */
603 * FPU emulator may have it's own trampoline active just
604 * above the user stack, 16-bytes before the next lowest
605 * 16 byte boundary. Try to avoid trashing it.
609 /* This is the X/Open sanctioned signal stack switching. */
610 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
611 sp = current->sas_ss_sp + current->sas_ss_size;
613 return (void *)((sp - frame_size) & ALMASK);
616 static inline void setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
617 int signr, sigset_t *set)
619 struct sigframe *frame;
622 frame = get_sigframe(ka, regs, sizeof(*frame));
623 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
627 * Set up the return code ...
629 * li v0, __NR_O32_sigreturn
632 err |= __put_user(0x24020000 + __NR_O32_sigreturn, frame->sf_code + 0);
633 err |= __put_user(0x0000000c , frame->sf_code + 1);
634 flush_cache_sigtramp((unsigned long) frame->sf_code);
636 err |= setup_sigcontext32(regs, &frame->sf_sc);
637 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
642 * Arguments to signal handler:
645 * a1 = 0 (should be cause)
646 * a2 = pointer to struct sigcontext
648 * $25 and c0_epc point to the signal handler, $29 points to the
651 regs->regs[ 4] = signr;
653 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
654 regs->regs[29] = (unsigned long) frame;
655 regs->regs[31] = (unsigned long) frame->sf_code;
656 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
659 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
660 current->comm, current->pid,
661 frame, regs->cp0_epc, frame->sf_code);
666 force_sigsegv(signr, current);
669 static inline void setup_rt_frame(struct k_sigaction * ka,
670 struct pt_regs *regs, int signr,
671 sigset_t *set, siginfo_t *info)
673 struct rt_sigframe32 *frame;
677 frame = get_sigframe(ka, regs, sizeof(*frame));
678 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
681 /* Set up to return from userspace. If provided, use a stub already
684 * Set up the return code ...
686 * li v0, __NR_O32_rt_sigreturn
689 err |= __put_user(0x24020000 + __NR_O32_rt_sigreturn, frame->rs_code + 0);
690 err |= __put_user(0x0000000c , frame->rs_code + 1);
691 flush_cache_sigtramp((unsigned long) frame->rs_code);
693 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
694 err |= copy_siginfo_to_user32(&frame->rs_info, info);
696 /* Create the ucontext. */
697 err |= __put_user(0, &frame->rs_uc.uc_flags);
698 err |= __put_user(0, &frame->rs_uc.uc_link);
699 sp = (int) (long) current->sas_ss_sp;
700 err |= __put_user(sp,
701 &frame->rs_uc.uc_stack.ss_sp);
702 err |= __put_user(sas_ss_flags(regs->regs[29]),
703 &frame->rs_uc.uc_stack.ss_flags);
704 err |= __put_user(current->sas_ss_size,
705 &frame->rs_uc.uc_stack.ss_size);
706 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
707 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
713 * Arguments to signal handler:
716 * a1 = 0 (should be cause)
717 * a2 = pointer to ucontext
719 * $25 and c0_epc point to the signal handler, $29 points to
720 * the struct rt_sigframe32.
722 regs->regs[ 4] = signr;
723 regs->regs[ 5] = (unsigned long) &frame->rs_info;
724 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
725 regs->regs[29] = (unsigned long) frame;
726 regs->regs[31] = (unsigned long) frame->rs_code;
727 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
730 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
731 current->comm, current->pid,
732 frame, regs->cp0_epc, frame->rs_code);
737 force_sigsegv(signr, current);
740 static inline void handle_signal(unsigned long sig, siginfo_t *info,
741 struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs)
743 switch (regs->regs[0]) {
744 case ERESTART_RESTARTBLOCK:
746 regs->regs[2] = EINTR;
749 if(!(ka->sa.sa_flags & SA_RESTART)) {
750 regs->regs[2] = EINTR;
754 case ERESTARTNOINTR: /* Userland will reload $v0. */
755 regs->regs[7] = regs->regs[26];
759 regs->regs[0] = 0; /* Don't deal with this again. */
761 if (ka->sa.sa_flags & SA_SIGINFO)
762 setup_rt_frame(ka, regs, sig, oldset, info);
764 setup_frame(ka, regs, sig, oldset);
766 spin_lock_irq(¤t->sighand->siglock);
767 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
768 if (!(ka->sa.sa_flags & SA_NODEFER))
769 sigaddset(¤t->blocked,sig);
771 spin_unlock_irq(¤t->sighand->siglock);
774 int do_signal32(sigset_t *oldset, struct pt_regs *regs)
776 struct k_sigaction ka;
781 * We want the common case to go fast, which is why we may in certain
782 * cases get here from kernel mode. Just return without doing anything
785 if (!user_mode(regs))
792 oldset = ¤t->blocked;
794 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
796 handle_signal(signr, &info, &ka, oldset, regs);
802 * Who's code doesn't conform to the restartable syscall convention
803 * dies here!!! The li instruction, a single machine instruction,
804 * must directly be followed by the syscall instruction.
807 if (regs->regs[2] == ERESTARTNOHAND ||
808 regs->regs[2] == ERESTARTSYS ||
809 regs->regs[2] == ERESTARTNOINTR) {
810 regs->regs[7] = regs->regs[26];
813 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
814 regs->regs[2] = __NR_O32_restart_syscall;
815 regs->regs[7] = regs->regs[26];
822 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
823 struct sigaction32 *oact,
824 unsigned int sigsetsize)
826 struct k_sigaction new_sa, old_sa;
829 /* XXX: Don't preclude handling different sized sigset_t's. */
830 if (sigsetsize != sizeof(sigset_t))
837 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
839 err |= __get_user(handler, &act->sa_handler);
840 new_sa.sa.sa_handler = (void*)(s64)handler;
841 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
842 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
847 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
852 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
855 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
857 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
858 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
866 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
867 compat_sigset_t *oset, unsigned int sigsetsize)
869 sigset_t old_set, new_set;
871 mm_segment_t old_fs = get_fs();
873 if (set && get_sigset(&new_set, set))
877 ret = sys_rt_sigprocmask(how, set ? &new_set : NULL,
878 oset ? &old_set : NULL, sigsetsize);
881 if (!ret && oset && put_sigset(&old_set, oset))
887 asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
888 unsigned int sigsetsize)
892 mm_segment_t old_fs = get_fs();
895 ret = sys_rt_sigpending(&set, sigsetsize);
898 if (!ret && put_sigset(&set, uset))
904 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t *uinfo)
908 mm_segment_t old_fs = get_fs();
910 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
911 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
914 ret = sys_rt_sigqueueinfo(pid, sig, &info);
920 sys32_waitid(int which, compat_pid_t pid,
921 compat_siginfo_t __user *uinfo, int options,
922 struct compat_rusage __user *uru)
927 mm_segment_t old_fs = get_fs();
931 ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options,
932 uru ? (struct rusage __user *) &ru : NULL);
935 if (ret < 0 || info.si_signo == 0)
938 if (uru && (ret = put_compat_rusage(&ru, uru)))
941 BUG_ON(info.si_code & __SI_MASK);
942 info.si_code |= __SI_CHLD;
943 return copy_siginfo_to_user32(uinfo, &info);