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 sigval_t32 _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;
495 frame = (struct rt_sigframe32 *) regs.regs[29];
496 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
498 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
501 sigdelsetmask(&set, ~_BLOCKABLE);
502 spin_lock_irq(¤t->sighand->siglock);
503 current->blocked = set;
505 spin_unlock_irq(¤t->sighand->siglock);
507 if (restore_sigcontext32(®s, &frame->rs_uc.uc_mcontext))
510 /* The ucontext contains a stack32_t, so we must convert! */
511 if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
513 st.ss_size = (long) sp;
514 if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
516 if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
519 /* It is more difficult to avoid calling this function than to
520 call it and ignore errors. */
521 do_sigaltstack(&st, NULL, regs.regs[29]);
524 * Don't let your children do this ...
526 __asm__ __volatile__(
534 force_sig(SIGSEGV, current);
537 static inline int setup_sigcontext32(struct pt_regs *regs,
538 struct sigcontext32 *sc)
542 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
543 err |= __put_user(regs->cp0_status, &sc->sc_status);
545 #define save_gp_reg(i) { \
546 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); \
548 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
549 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
550 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
551 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
552 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
553 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
554 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
555 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
559 err |= __put_user(regs->hi, &sc->sc_mdhi);
560 err |= __put_user(regs->lo, &sc->sc_mdlo);
561 err |= __put_user(regs->cp0_cause, &sc->sc_cause);
562 err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
564 err |= __put_user(!!used_math(), &sc->sc_used_math);
570 * Save FPU state to signal context. Signal handler will "inherit"
575 if (!is_fpu_owner()) {
579 err |= save_fp_context32(sc);
588 * Determine which stack to use..
590 static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
595 /* Default to using normal stack */
599 * FPU emulator may have it's own trampoline active just
600 * above the user stack, 16-bytes before the next lowest
601 * 16 byte boundary. Try to avoid trashing it.
605 /* This is the X/Open sanctioned signal stack switching. */
606 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
607 sp = current->sas_ss_sp + current->sas_ss_size;
609 return (void *)((sp - frame_size) & ALMASK);
612 static inline void setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
613 int signr, sigset_t *set)
615 struct sigframe *frame;
618 frame = get_sigframe(ka, regs, sizeof(*frame));
619 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
623 * Set up the return code ...
625 * li v0, __NR_O32_sigreturn
628 err |= __put_user(0x24020000 + __NR_O32_sigreturn, frame->sf_code + 0);
629 err |= __put_user(0x0000000c , frame->sf_code + 1);
630 flush_cache_sigtramp((unsigned long) frame->sf_code);
632 err |= setup_sigcontext32(regs, &frame->sf_sc);
633 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
638 * Arguments to signal handler:
641 * a1 = 0 (should be cause)
642 * a2 = pointer to struct sigcontext
644 * $25 and c0_epc point to the signal handler, $29 points to the
647 regs->regs[ 4] = signr;
649 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
650 regs->regs[29] = (unsigned long) frame;
651 regs->regs[31] = (unsigned long) frame->sf_code;
652 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
655 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
656 current->comm, current->pid,
657 frame, regs->cp0_epc, frame->sf_code);
662 force_sigsegv(signr, current);
665 static inline void setup_rt_frame(struct k_sigaction * ka,
666 struct pt_regs *regs, int signr,
667 sigset_t *set, siginfo_t *info)
669 struct rt_sigframe32 *frame;
673 frame = get_sigframe(ka, regs, sizeof(*frame));
674 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
677 /* Set up to return from userspace. If provided, use a stub already
680 * Set up the return code ...
682 * li v0, __NR_O32_rt_sigreturn
685 err |= __put_user(0x24020000 + __NR_O32_rt_sigreturn, frame->rs_code + 0);
686 err |= __put_user(0x0000000c , frame->rs_code + 1);
687 flush_cache_sigtramp((unsigned long) frame->rs_code);
689 /* Convert (siginfo_t -> compat_siginfo_t) and copy to user. */
690 err |= copy_siginfo_to_user32(&frame->rs_info, info);
692 /* Create the ucontext. */
693 err |= __put_user(0, &frame->rs_uc.uc_flags);
694 err |= __put_user(0, &frame->rs_uc.uc_link);
695 sp = (int) (long) current->sas_ss_sp;
696 err |= __put_user(sp,
697 &frame->rs_uc.uc_stack.ss_sp);
698 err |= __put_user(sas_ss_flags(regs->regs[29]),
699 &frame->rs_uc.uc_stack.ss_flags);
700 err |= __put_user(current->sas_ss_size,
701 &frame->rs_uc.uc_stack.ss_size);
702 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
703 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
709 * Arguments to signal handler:
712 * a1 = 0 (should be cause)
713 * a2 = pointer to ucontext
715 * $25 and c0_epc point to the signal handler, $29 points to
716 * the struct rt_sigframe32.
718 regs->regs[ 4] = signr;
719 regs->regs[ 5] = (unsigned long) &frame->rs_info;
720 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
721 regs->regs[29] = (unsigned long) frame;
722 regs->regs[31] = (unsigned long) frame->rs_code;
723 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
726 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
727 current->comm, current->pid,
728 frame, regs->cp0_epc, frame->rs_code);
733 force_sigsegv(signr, current);
736 static inline void handle_signal(unsigned long sig, siginfo_t *info,
737 struct k_sigaction *ka, sigset_t *oldset, struct pt_regs * regs)
739 switch (regs->regs[0]) {
740 case ERESTART_RESTARTBLOCK:
742 regs->regs[2] = EINTR;
745 if(!(ka->sa.sa_flags & SA_RESTART)) {
746 regs->regs[2] = EINTR;
750 case ERESTARTNOINTR: /* Userland will reload $v0. */
751 regs->regs[7] = regs->regs[26];
755 regs->regs[0] = 0; /* Don't deal with this again. */
757 if (ka->sa.sa_flags & SA_SIGINFO)
758 setup_rt_frame(ka, regs, sig, oldset, info);
760 setup_frame(ka, regs, sig, oldset);
762 spin_lock_irq(¤t->sighand->siglock);
763 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
764 if (!(ka->sa.sa_flags & SA_NODEFER))
765 sigaddset(¤t->blocked,sig);
767 spin_unlock_irq(¤t->sighand->siglock);
770 int do_signal32(sigset_t *oldset, struct pt_regs *regs)
772 struct k_sigaction ka;
777 * We want the common case to go fast, which is why we may in certain
778 * cases get here from kernel mode. Just return without doing anything
781 if (!user_mode(regs))
788 oldset = ¤t->blocked;
790 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
792 handle_signal(signr, &info, &ka, oldset, regs);
798 * Who's code doesn't conform to the restartable syscall convention
799 * dies here!!! The li instruction, a single machine instruction,
800 * must directly be followed by the syscall instruction.
803 if (regs->regs[2] == ERESTARTNOHAND ||
804 regs->regs[2] == ERESTARTSYS ||
805 regs->regs[2] == ERESTARTNOINTR) {
806 regs->regs[7] = regs->regs[26];
809 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
810 regs->regs[2] = __NR_O32_restart_syscall;
811 regs->regs[7] = regs->regs[26];
818 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
819 struct sigaction32 *oact,
820 unsigned int sigsetsize)
822 struct k_sigaction new_sa, old_sa;
825 /* XXX: Don't preclude handling different sized sigset_t's. */
826 if (sigsetsize != sizeof(sigset_t))
833 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
835 err |= __get_user(handler, &act->sa_handler);
836 new_sa.sa.sa_handler = (void*)(s64)handler;
837 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
838 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
843 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
848 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
851 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
853 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
854 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
862 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
863 compat_sigset_t *oset, unsigned int sigsetsize)
865 sigset_t old_set, new_set;
867 mm_segment_t old_fs = get_fs();
869 if (set && get_sigset(&new_set, set))
873 ret = sys_rt_sigprocmask(how, set ? &new_set : NULL,
874 oset ? &old_set : NULL, sigsetsize);
877 if (!ret && oset && put_sigset(&old_set, oset))
883 asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
884 unsigned int sigsetsize)
888 mm_segment_t old_fs = get_fs();
891 ret = sys_rt_sigpending(&set, sigsetsize);
894 if (!ret && put_sigset(&set, uset))
900 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t *uinfo)
904 mm_segment_t old_fs = get_fs();
906 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
907 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
910 ret = sys_rt_sigqueueinfo(pid, sig, &info);
916 sys32_waitid(int which, compat_pid_t pid,
917 compat_siginfo_t __user *uinfo, int options,
918 struct compat_rusage __user *uru)
923 mm_segment_t old_fs = get_fs();
927 ret = sys_waitid(which, pid, (siginfo_t __user *) &info, options,
928 uru ? (struct rusage __user *) &ru : NULL);
931 if (ret < 0 || info.si_signo == 0)
934 if (uru && (ret = put_compat_rusage(&ru, uru)))
937 BUG_ON(info.si_code & __SI_MASK);
938 info.si_code |= __SI_CHLD;
939 return copy_siginfo_to_user32(uinfo, &info);