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/errno.h>
17 #include <linux/wait.h>
18 #include <linux/ptrace.h>
19 #include <linux/unistd.h>
20 #include <linux/compat.h>
23 #include <asm/bitops.h>
24 #include <asm/pgalloc.h>
25 #include <asm/stackframe.h>
26 #include <asm/uaccess.h>
27 #include <asm/ucontext.h>
28 #include <asm/system.h>
33 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
35 extern asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs *regs);
37 extern asmlinkage void do_syscall_trace(void);
39 /* 32-bit compatibility types */
41 #define _NSIG_BPW32 32
42 #define _NSIG_WORDS32 (_NSIG / _NSIG_BPW32)
44 typedef unsigned int __sighandler32_t;
45 typedef void (*vfptr_t)(void);
48 unsigned int sa_flags;
49 __sighandler32_t sa_handler;
50 compat_sigset_t sa_mask;
53 /* IRIX compatible stack_t */
54 typedef struct sigaltstack32 {
56 compat_size_t ss_size;
60 extern void __put_sigset_unknown_nsig(void);
61 extern void __get_sigset_unknown_nsig(void);
63 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t *ubuf)
67 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
70 switch (_NSIG_WORDS) {
72 __put_sigset_unknown_nsig();
74 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]);
75 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
77 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]);
78 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
84 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t *ubuf)
89 if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
92 switch (_NSIG_WORDS) {
94 __get_sigset_unknown_nsig();
96 err |= __get_user (sig[3], &ubuf->sig[3]);
97 err |= __get_user (sig[2], &ubuf->sig[2]);
98 kbuf->sig[1] = sig[2] | (sig[3] << 32);
100 err |= __get_user (sig[1], &ubuf->sig[1]);
101 err |= __get_user (sig[0], &ubuf->sig[0]);
102 kbuf->sig[0] = sig[0] | (sig[1] << 32);
109 * Atomically swap in the new signal mask, and wait for a signal.
111 asmlinkage inline int sys32_sigsuspend(abi64_no_regargs, struct pt_regs regs)
113 compat_sigset_t *uset;
114 sigset_t newset, saveset;
117 uset = (compat_sigset_t *) regs.regs[4];
118 if (get_sigset(&newset, uset))
120 sigdelsetmask(&newset, ~_BLOCKABLE);
122 spin_lock_irq(¤t->sighand->siglock);
123 saveset = current->blocked;
124 current->blocked = newset;
126 spin_unlock_irq(¤t->sighand->siglock);
128 regs.regs[2] = EINTR;
131 current->state = TASK_INTERRUPTIBLE;
133 if (do_signal32(&saveset, ®s))
138 asmlinkage int sys32_rt_sigsuspend(abi64_no_regargs, struct pt_regs regs)
140 compat_sigset_t *uset;
141 sigset_t newset, saveset;
145 /* XXX Don't preclude handling different sized sigset_t's. */
146 sigsetsize = regs.regs[5];
147 if (sigsetsize != sizeof(compat_sigset_t))
150 uset = (compat_sigset_t *) regs.regs[4];
151 if (get_sigset(&newset, uset))
153 sigdelsetmask(&newset, ~_BLOCKABLE);
155 spin_lock_irq(¤t->sighand->siglock);
156 saveset = current->blocked;
157 current->blocked = newset;
159 spin_unlock_irq(¤t->sighand->siglock);
161 regs.regs[2] = EINTR;
164 current->state = TASK_INTERRUPTIBLE;
166 if (do_signal32(&saveset, ®s))
171 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 *act,
172 struct sigaction32 *oact)
174 struct k_sigaction new_ka, old_ka;
181 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
183 err |= __get_user((u32)(u64)new_ka.sa.sa_handler,
185 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
186 err |= __get_user(mask, &act->sa_mask.sig[0]);
190 siginitset(&new_ka.sa.sa_mask, mask);
193 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
196 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
198 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
199 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
201 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
202 err |= __put_user(0, &oact->sa_mask.sig[1]);
203 err |= __put_user(0, &oact->sa_mask.sig[2]);
204 err |= __put_user(0, &oact->sa_mask.sig[3]);
212 asmlinkage int sys32_sigaltstack(abi64_no_regargs, struct pt_regs regs)
214 const stack32_t *uss = (const stack32_t *) regs.regs[4];
215 stack32_t *uoss = (stack32_t *) regs.regs[5];
216 unsigned long usp = regs.regs[29];
219 mm_segment_t old_fs = get_fs();
223 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
225 err |= __get_user(sp, &uss->ss_sp);
226 kss.ss_size = (long) sp;
227 err |= __get_user(kss.ss_size, &uss->ss_size);
228 err |= __get_user(kss.ss_flags, &uss->ss_flags);
234 ret = do_sigaltstack(uss ? &kss : NULL , uoss ? &koss : NULL, usp);
238 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
240 sp = (int) (long) koss.ss_sp;
241 err |= __put_user(sp, &uoss->ss_sp);
242 err |= __put_user(koss.ss_size, &uoss->ss_size);
243 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
250 static asmlinkage int restore_sigcontext(struct pt_regs *regs,
251 struct sigcontext *sc)
255 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
256 err |= __get_user(regs->hi, &sc->sc_mdhi);
257 err |= __get_user(regs->lo, &sc->sc_mdlo);
259 #define restore_gp_reg(i) do { \
260 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); \
262 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
263 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
264 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
265 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
266 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
267 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
268 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
269 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
270 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
271 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
273 #undef restore_gp_reg
275 err |= __get_user(current->used_math, &sc->sc_used_math);
277 if (current->used_math) {
278 /* restore fpu context if we have used it before */
280 err |= restore_fp_context(sc);
282 /* signal handler may have used FPU. Give it up. */
290 u32 sf_ass[4]; /* argument save space for o32 */
291 u32 sf_code[2]; /* signal trampoline */
292 struct sigcontext sf_sc;
296 struct rt_sigframe32 {
297 u32 rs_ass[4]; /* argument save space for o32 */
298 u32 rs_code[2]; /* signal trampoline */
299 struct siginfo32 rs_info;
300 struct ucontext rs_uc;
303 static int copy_siginfo_to_user32(siginfo_t32 *to, siginfo_t *from)
307 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
310 /* If you change siginfo_t structure, please be sure
311 this code is fixed accordingly.
312 It should never copy any pad contained in the structure
313 to avoid security leaks, but must copy the generic
314 3 ints plus the relevant union member.
315 This routine must convert siginfo from 64bit to 32bit as well
317 err = __put_user(from->si_signo, &to->si_signo);
318 err |= __put_user(from->si_errno, &to->si_errno);
319 err |= __put_user((short)from->si_code, &to->si_code);
320 if (from->si_code < 0)
321 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
323 switch (from->si_code >> 16) {
324 case __SI_CHLD >> 16:
325 err |= __put_user(from->si_utime, &to->si_utime);
326 err |= __put_user(from->si_stime, &to->si_stime);
327 err |= __put_user(from->si_status, &to->si_status);
329 err |= __put_user(from->si_pid, &to->si_pid);
330 err |= __put_user(from->si_uid, &to->si_uid);
332 case __SI_FAULT >> 16:
333 err |= __put_user((long)from->si_addr, &to->si_addr);
335 case __SI_POLL >> 16:
336 err |= __put_user(from->si_band, &to->si_band);
337 err |= __put_user(from->si_fd, &to->si_fd);
339 /* case __SI_RT: This is not generated by the kernel as of now. */
345 asmlinkage void sys32_sigreturn(abi64_no_regargs, struct pt_regs regs)
347 struct sigframe *frame;
350 frame = (struct sigframe *) regs.regs[29];
351 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
353 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
356 sigdelsetmask(&blocked, ~_BLOCKABLE);
357 spin_lock_irq(¤t->sighand->siglock);
358 current->blocked = blocked;
360 spin_unlock_irq(¤t->sighand->siglock);
362 if (restore_sigcontext(®s, &frame->sf_sc))
366 * Don't let your children do this ...
368 if (current_thread_info()->flags & TIF_SYSCALL_TRACE)
370 __asm__ __volatile__(
378 force_sig(SIGSEGV, current);
381 asmlinkage void sys32_rt_sigreturn(abi64_no_regargs, struct pt_regs regs)
383 struct rt_sigframe32 *frame;
387 frame = (struct rt_sigframe32 *) regs.regs[29];
388 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
390 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
393 sigdelsetmask(&set, ~_BLOCKABLE);
394 spin_lock_irq(¤t->sighand->siglock);
395 current->blocked = set;
397 spin_unlock_irq(¤t->sighand->siglock);
399 if (restore_sigcontext(®s, &frame->rs_uc.uc_mcontext))
402 if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st)))
404 /* It is more difficult to avoid calling this function than to
405 call it and ignore errors. */
406 do_sigaltstack(&st, NULL, regs.regs[29]);
409 * Don't let your children do this ...
411 __asm__ __volatile__(
419 force_sig(SIGSEGV, current);
422 static inline int setup_sigcontext(struct pt_regs *regs,
423 struct sigcontext *sc)
427 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
428 err |= __put_user(regs->cp0_status, &sc->sc_status);
430 #define save_gp_reg(i) { \
431 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); \
433 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
434 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
435 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
436 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
437 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
438 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
439 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
440 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
444 err |= __put_user(regs->hi, &sc->sc_mdhi);
445 err |= __put_user(regs->lo, &sc->sc_mdlo);
446 err |= __put_user(regs->cp0_cause, &sc->sc_cause);
447 err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
449 err |= __put_user(current->used_math, &sc->sc_used_math);
451 if (!current->used_math)
455 * Save FPU state to signal context. Signal handler will "inherit"
458 if (!is_fpu_owner()) {
462 err |= save_fp_context(sc);
469 * Determine which stack to use..
471 static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
476 /* Default to using normal stack */
480 * FPU emulator may have it's own trampoline active just
481 * above the user stack, 16-bytes before the next lowest
482 * 16 byte boundary. Try to avoid trashing it.
486 /* This is the X/Open sanctioned signal stack switching. */
487 if ((ka->sa.sa_flags & SA_ONSTACK) && ! on_sig_stack(sp))
488 sp = current->sas_ss_sp + current->sas_ss_size;
490 return (void *)((sp - frame_size) & ALMASK);
493 static inline void setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
494 int signr, sigset_t *set)
496 struct sigframe *frame;
499 frame = get_sigframe(ka, regs, sizeof(*frame));
500 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
504 * Set up the return code ...
506 * li v0, __NR_O32_sigreturn
509 err |= __put_user(0x24020000 + __NR_O32_sigreturn, frame->sf_code + 0);
510 err |= __put_user(0x0000000c , frame->sf_code + 1);
511 flush_cache_sigtramp((unsigned long) frame->sf_code);
513 err |= setup_sigcontext(regs, &frame->sf_sc);
514 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
519 * Arguments to signal handler:
522 * a1 = 0 (should be cause)
523 * a2 = pointer to struct sigcontext
525 * $25 and c0_epc point to the signal handler, $29 points to the
528 regs->regs[ 4] = signr;
530 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
531 regs->regs[29] = (unsigned long) frame;
532 regs->regs[31] = (unsigned long) frame->sf_code;
533 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
536 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
537 current->comm, current->pid,
538 frame, regs->cp0_epc, frame->sf_code);
543 if (signr == SIGSEGV)
544 ka->sa.sa_handler = SIG_DFL;
545 force_sig(SIGSEGV, current);
548 static inline void setup_rt_frame(struct k_sigaction * ka,
549 struct pt_regs *regs, int signr,
550 sigset_t *set, siginfo_t *info)
552 struct rt_sigframe32 *frame;
555 frame = get_sigframe(ka, regs, sizeof(*frame));
556 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
559 /* Set up to return from userspace. If provided, use a stub already
562 * Set up the return code ...
564 * li v0, __NR_O32_rt_sigreturn
567 err |= __put_user(0x24020000 + __NR_O32_rt_sigreturn, frame->rs_code + 0);
568 err |= __put_user(0x0000000c , frame->rs_code + 1);
569 flush_cache_sigtramp((unsigned long) frame->rs_code);
571 /* Convert (siginfo_t -> siginfo_t32) and copy to user. */
572 err |= copy_siginfo_to_user32(&frame->rs_info, info);
574 /* Create the ucontext. */
575 err |= __put_user(0, &frame->rs_uc.uc_flags);
576 err |= __put_user(0, &frame->rs_uc.uc_link);
577 err |= __put_user((void *)current->sas_ss_sp,
578 &frame->rs_uc.uc_stack.ss_sp);
579 err |= __put_user(sas_ss_flags(regs->regs[29]),
580 &frame->rs_uc.uc_stack.ss_flags);
581 err |= __put_user(current->sas_ss_size,
582 &frame->rs_uc.uc_stack.ss_size);
583 err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext);
584 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
590 * Arguments to signal handler:
593 * a1 = 0 (should be cause)
594 * a2 = pointer to ucontext
596 * $25 and c0_epc point to the signal handler, $29 points to
597 * the struct rt_sigframe32.
599 regs->regs[ 4] = signr;
600 regs->regs[ 5] = (unsigned long) &frame->rs_info;
601 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
602 regs->regs[29] = (unsigned long) frame;
603 regs->regs[31] = (unsigned long) frame->rs_code;
604 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
607 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
608 current->comm, current->pid,
609 frame, regs->cp0_epc, frame->rs_code);
614 if (signr == SIGSEGV)
615 ka->sa.sa_handler = SIG_DFL;
616 force_sig(SIGSEGV, current);
619 static inline void handle_signal(unsigned long sig, siginfo_t *info,
620 sigset_t *oldset, struct pt_regs * regs)
622 struct k_sigaction *ka = ¤t->sighand->action[sig-1];
624 switch (regs->regs[0]) {
626 regs->regs[2] = EINTR;
629 if(!(ka->sa.sa_flags & SA_RESTART)) {
630 regs->regs[2] = EINTR;
634 case ERESTARTNOINTR: /* Userland will reload $v0. */
635 regs->regs[7] = regs->regs[26];
639 regs->regs[0] = 0; /* Don't deal with this again. */
641 if (ka->sa.sa_flags & SA_SIGINFO)
642 setup_rt_frame(ka, regs, sig, oldset, info);
644 setup_frame(ka, regs, sig, oldset);
646 if (ka->sa.sa_flags & SA_ONESHOT)
647 ka->sa.sa_handler = SIG_DFL;
648 if (!(ka->sa.sa_flags & SA_NODEFER)) {
649 spin_lock_irq(¤t->sighand->siglock);
650 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
651 sigaddset(¤t->blocked,sig);
653 spin_unlock_irq(¤t->sighand->siglock);
657 asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs *regs)
663 oldset = ¤t->blocked;
665 signr = get_signal_to_deliver(&info, regs, NULL);
667 handle_signal(signr, &info, oldset, regs);
672 * Who's code doesn't conform to the restartable syscall convention
673 * dies here!!! The li instruction, a single machine instruction,
674 * must directly be followed by the syscall instruction.
677 if (regs->regs[2] == ERESTARTNOHAND ||
678 regs->regs[2] == ERESTARTSYS ||
679 regs->regs[2] == ERESTARTNOINTR) {
680 regs->regs[7] = regs->regs[26];
687 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
688 struct sigaction32 *oact,
689 unsigned int sigsetsize)
691 struct k_sigaction new_sa, old_sa;
694 /* XXX: Don't preclude handling different sized sigset_t's. */
695 if (sigsetsize != sizeof(sigset_t))
701 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
703 err |= __get_user((u32)(u64)new_sa.sa.sa_handler,
705 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
706 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
711 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
716 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
719 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
721 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
722 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
730 asmlinkage long sys_rt_sigprocmask(int how, sigset_t *set, sigset_t *oset,
733 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
734 compat_sigset_t *oset, unsigned int sigsetsize)
736 sigset_t old_set, new_set;
738 mm_segment_t old_fs = get_fs();
740 if (set && get_sigset(&new_set, set))
744 ret = sys_rt_sigprocmask(how, set ? &new_set : NULL,
745 oset ? &old_set : NULL, sigsetsize);
748 if (!ret && oset && put_sigset(&old_set, oset))
754 asmlinkage long sys_rt_sigpending(sigset_t *set, size_t sigsetsize);
756 asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
757 unsigned int sigsetsize)
761 mm_segment_t old_fs = get_fs();
764 ret = sys_rt_sigpending(&set, sigsetsize);
767 if (!ret && put_sigset(&set, uset))
773 asmlinkage int sys32_rt_sigtimedwait(compat_sigset_t *uthese,
774 siginfo_t32 *uinfo, struct compat_timespec *uts,
775 compat_time_t sigsetsize)
779 compat_sigset_t these32;
785 * As the result of a brainfarting competition a few years ago the
786 * size of sigset_t for the 32-bit kernel was choosen to be 128 bits
787 * but nothing so far is actually using that many, 64 are enough. So
788 * for now we just drop the high bits.
790 if (copy_from_user (&these32, uthese, sizeof(compat_old_sigset_t)))
793 switch (_NSIG_WORDS) {
795 case 4: these.sig[3] = these32.sig[6] | (((long)these32.sig[7]) << 32);
796 case 3: these.sig[2] = these32.sig[4] | (((long)these32.sig[5]) << 32);
797 case 2: these.sig[1] = these32.sig[2] | (((long)these32.sig[3]) << 32);
798 case 1: these.sig[0] = these32.sig[0] | (((long)these32.sig[1]) << 32);
801 case 4: these.sig[3] = these32.sig[7] | (((long)these32.sig[6]) << 32);
802 case 3: these.sig[2] = these32.sig[5] | (((long)these32.sig[4]) << 32);
803 case 2: these.sig[1] = these32.sig[3] | (((long)these32.sig[2]) << 32);
804 case 1: these.sig[0] = these32.sig[1] | (((long)these32.sig[0]) << 32);
809 * Invert the set of allowed signals to get those we
812 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
816 if (get_user (ts.tv_sec, &uts->tv_sec) ||
817 get_user (ts.tv_nsec, &uts->tv_nsec))
819 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
824 spin_lock_irq(¤t->sighand->siglock);
825 sig = dequeue_signal(current, &these, &info);
827 /* None ready -- temporarily unblock those we're interested
828 in so that we'll be awakened when they arrive. */
829 sigset_t oldblocked = current->blocked;
830 sigandsets(¤t->blocked, ¤t->blocked, &these);
832 spin_unlock_irq(¤t->sighand->siglock);
834 timeout = MAX_SCHEDULE_TIMEOUT;
836 timeout = (timespec_to_jiffies(&ts)
837 + (ts.tv_sec || ts.tv_nsec));
839 current->state = TASK_INTERRUPTIBLE;
840 timeout = schedule_timeout(timeout);
842 spin_lock_irq(¤t->sighand->siglock);
843 sig = dequeue_signal(current, &these, &info);
844 current->blocked = oldblocked;
847 spin_unlock_irq(¤t->sighand->siglock);
852 if (copy_siginfo_to_user32(uinfo, &info))
864 extern asmlinkage int sys_rt_sigqueueinfo(int pid, int sig, siginfo_t *uinfo);
866 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, siginfo_t32 *uinfo)
870 mm_segment_t old_fs = get_fs();
872 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
873 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
876 ret = sys_rt_sigqueueinfo(pid, sig, &info);