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>
23 #include <asm/bitops.h>
25 #include <asm/uaccess.h>
26 #include <asm/ucontext.h>
27 #include <asm/system.h>
31 * Including <asm/unistd.h> would give use the 64-bit syscall numbers ...
33 #define __NR_O32_sigreturn 4119
34 #define __NR_O32_rt_sigreturn 4193
35 #define __NR_O32_restart_syscall 4253
39 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
41 extern asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs *regs);
43 extern asmlinkage void do_syscall_trace(void);
45 /* 32-bit compatibility types */
47 #define _NSIG_BPW32 32
48 #define _NSIG_WORDS32 (_NSIG / _NSIG_BPW32)
51 unsigned int sig[_NSIG_WORDS32];
54 typedef unsigned int __sighandler32_t;
55 typedef void (*vfptr_t)(void);
58 unsigned int sa_flags;
59 __sighandler32_t sa_handler;
60 compat_sigset_t sa_mask;
63 /* IRIX compatible stack_t */
64 typedef struct sigaltstack32 {
66 compat_size_t ss_size;
74 struct sigcontext32 uc_mcontext;
75 sigset_t32 uc_sigmask; /* mask last for extensibility */
78 extern void __put_sigset_unknown_nsig(void);
79 extern void __get_sigset_unknown_nsig(void);
81 static inline int put_sigset(const sigset_t *kbuf, compat_sigset_t *ubuf)
85 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)))
88 switch (_NSIG_WORDS) {
90 __put_sigset_unknown_nsig();
92 err |= __put_user (kbuf->sig[1] >> 32, &ubuf->sig[3]);
93 err |= __put_user (kbuf->sig[1] & 0xffffffff, &ubuf->sig[2]);
95 err |= __put_user (kbuf->sig[0] >> 32, &ubuf->sig[1]);
96 err |= __put_user (kbuf->sig[0] & 0xffffffff, &ubuf->sig[0]);
102 static inline int get_sigset(sigset_t *kbuf, const compat_sigset_t *ubuf)
105 unsigned long sig[4];
107 if (!access_ok(VERIFY_READ, ubuf, sizeof(*ubuf)))
110 switch (_NSIG_WORDS) {
112 __get_sigset_unknown_nsig();
114 err |= __get_user (sig[3], &ubuf->sig[3]);
115 err |= __get_user (sig[2], &ubuf->sig[2]);
116 kbuf->sig[1] = sig[2] | (sig[3] << 32);
118 err |= __get_user (sig[1], &ubuf->sig[1]);
119 err |= __get_user (sig[0], &ubuf->sig[0]);
120 kbuf->sig[0] = sig[0] | (sig[1] << 32);
127 * Atomically swap in the new signal mask, and wait for a signal.
129 save_static_function(sys32_sigsuspend);
130 static_unused int _sys32_sigsuspend(nabi_no_regargs struct pt_regs regs)
132 compat_sigset_t *uset;
133 sigset_t newset, saveset;
135 uset = (compat_sigset_t *) regs.regs[4];
136 if (get_sigset(&newset, uset))
138 sigdelsetmask(&newset, ~_BLOCKABLE);
140 spin_lock_irq(¤t->sighand->siglock);
141 saveset = current->blocked;
142 current->blocked = newset;
144 spin_unlock_irq(¤t->sighand->siglock);
146 regs.regs[2] = EINTR;
149 current->state = TASK_INTERRUPTIBLE;
151 if (do_signal32(&saveset, ®s))
156 save_static_function(sys32_rt_sigsuspend);
157 static_unused int _sys32_rt_sigsuspend(nabi_no_regargs struct pt_regs regs)
159 compat_sigset_t *uset;
160 sigset_t newset, saveset;
163 /* XXX Don't preclude handling different sized sigset_t's. */
164 sigsetsize = regs.regs[5];
165 if (sigsetsize != sizeof(compat_sigset_t))
168 uset = (compat_sigset_t *) regs.regs[4];
169 if (get_sigset(&newset, uset))
171 sigdelsetmask(&newset, ~_BLOCKABLE);
173 spin_lock_irq(¤t->sighand->siglock);
174 saveset = current->blocked;
175 current->blocked = newset;
177 spin_unlock_irq(¤t->sighand->siglock);
179 regs.regs[2] = EINTR;
182 current->state = TASK_INTERRUPTIBLE;
184 if (do_signal32(&saveset, ®s))
189 asmlinkage int sys32_sigaction(int sig, const struct sigaction32 *act,
190 struct sigaction32 *oact)
192 struct k_sigaction new_ka, old_ka;
199 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
201 err |= __get_user((u32)(u64)new_ka.sa.sa_handler,
203 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
204 err |= __get_user(mask, &act->sa_mask.sig[0]);
208 siginitset(&new_ka.sa.sa_mask, mask);
211 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
214 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
216 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
217 err |= __put_user((u32)(u64)old_ka.sa.sa_handler,
219 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig);
220 err |= __put_user(0, &oact->sa_mask.sig[1]);
221 err |= __put_user(0, &oact->sa_mask.sig[2]);
222 err |= __put_user(0, &oact->sa_mask.sig[3]);
230 asmlinkage int sys32_sigaltstack(nabi_no_regargs struct pt_regs regs)
232 const stack32_t *uss = (const stack32_t *) regs.regs[4];
233 stack32_t *uoss = (stack32_t *) regs.regs[5];
234 unsigned long usp = regs.regs[29];
237 mm_segment_t old_fs = get_fs();
241 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
243 err |= __get_user(sp, &uss->ss_sp);
244 kss.ss_sp = (void *) (long) sp;
245 err |= __get_user(kss.ss_size, &uss->ss_size);
246 err |= __get_user(kss.ss_flags, &uss->ss_flags);
252 ret = do_sigaltstack(uss ? &kss : NULL , uoss ? &koss : NULL, usp);
256 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
258 sp = (int) (long) koss.ss_sp;
259 err |= __put_user(sp, &uoss->ss_sp);
260 err |= __put_user(koss.ss_size, &uoss->ss_size);
261 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
268 static asmlinkage int restore_sigcontext32(struct pt_regs *regs,
269 struct sigcontext32 *sc)
273 /* Always make any pending restarted system calls return -EINTR */
274 current_thread_info()->restart_block.fn = do_no_restart_syscall;
276 err |= __get_user(regs->cp0_epc, &sc->sc_pc);
277 err |= __get_user(regs->hi, &sc->sc_mdhi);
278 err |= __get_user(regs->lo, &sc->sc_mdlo);
280 #define restore_gp_reg(i) do { \
281 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); \
283 restore_gp_reg( 1); restore_gp_reg( 2); restore_gp_reg( 3);
284 restore_gp_reg( 4); restore_gp_reg( 5); restore_gp_reg( 6);
285 restore_gp_reg( 7); restore_gp_reg( 8); restore_gp_reg( 9);
286 restore_gp_reg(10); restore_gp_reg(11); restore_gp_reg(12);
287 restore_gp_reg(13); restore_gp_reg(14); restore_gp_reg(15);
288 restore_gp_reg(16); restore_gp_reg(17); restore_gp_reg(18);
289 restore_gp_reg(19); restore_gp_reg(20); restore_gp_reg(21);
290 restore_gp_reg(22); restore_gp_reg(23); restore_gp_reg(24);
291 restore_gp_reg(25); restore_gp_reg(26); restore_gp_reg(27);
292 restore_gp_reg(28); restore_gp_reg(29); restore_gp_reg(30);
294 #undef restore_gp_reg
296 err |= __get_user(current->used_math, &sc->sc_used_math);
298 if (current->used_math) {
299 /* restore fpu context if we have used it before */
301 err |= restore_fp_context32(sc);
303 /* signal handler may have used FPU. Give it up. */
311 u32 sf_ass[4]; /* argument save space for o32 */
312 u32 sf_code[2]; /* signal trampoline */
313 struct sigcontext32 sf_sc;
317 struct rt_sigframe32 {
318 u32 rs_ass[4]; /* argument save space for o32 */
319 u32 rs_code[2]; /* signal trampoline */
320 struct siginfo32 rs_info;
321 struct ucontext32 rs_uc;
324 static int copy_siginfo_to_user32(siginfo_t32 *to, siginfo_t *from)
328 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
331 /* If you change siginfo_t structure, please be sure
332 this code is fixed accordingly.
333 It should never copy any pad contained in the structure
334 to avoid security leaks, but must copy the generic
335 3 ints plus the relevant union member.
336 This routine must convert siginfo from 64bit to 32bit as well
338 err = __put_user(from->si_signo, &to->si_signo);
339 err |= __put_user(from->si_errno, &to->si_errno);
340 err |= __put_user((short)from->si_code, &to->si_code);
341 if (from->si_code < 0)
342 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
344 switch (from->si_code >> 16) {
345 case __SI_CHLD >> 16:
346 err |= __put_user(from->si_utime, &to->si_utime);
347 err |= __put_user(from->si_stime, &to->si_stime);
348 err |= __put_user(from->si_status, &to->si_status);
350 err |= __put_user(from->si_pid, &to->si_pid);
351 err |= __put_user(from->si_uid, &to->si_uid);
353 case __SI_FAULT >> 16:
354 err |= __put_user((long)from->si_addr, &to->si_addr);
356 case __SI_POLL >> 16:
357 err |= __put_user(from->si_band, &to->si_band);
358 err |= __put_user(from->si_fd, &to->si_fd);
360 case __SI_RT >> 16: /* This is not generated by the kernel as of now. */
361 case __SI_MESGQ >> 16:
362 err |= __put_user(from->si_pid, &to->si_pid);
363 err |= __put_user(from->si_uid, &to->si_uid);
364 err |= __put_user(from->si_int, &to->si_int);
371 asmlinkage void sys32_sigreturn(nabi_no_regargs struct pt_regs regs)
373 struct sigframe *frame;
376 frame = (struct sigframe *) regs.regs[29];
377 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
379 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked)))
382 sigdelsetmask(&blocked, ~_BLOCKABLE);
383 spin_lock_irq(¤t->sighand->siglock);
384 current->blocked = blocked;
386 spin_unlock_irq(¤t->sighand->siglock);
388 if (restore_sigcontext32(®s, &frame->sf_sc))
392 * Don't let your children do this ...
394 if (current_thread_info()->flags & TIF_SYSCALL_TRACE)
396 __asm__ __volatile__(
404 force_sig(SIGSEGV, current);
407 asmlinkage void sys32_rt_sigreturn(nabi_no_regargs struct pt_regs regs)
409 struct rt_sigframe32 *frame;
414 frame = (struct rt_sigframe32 *) regs.regs[29];
415 if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
417 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set)))
420 sigdelsetmask(&set, ~_BLOCKABLE);
421 spin_lock_irq(¤t->sighand->siglock);
422 current->blocked = set;
424 spin_unlock_irq(¤t->sighand->siglock);
426 if (restore_sigcontext32(®s, &frame->rs_uc.uc_mcontext))
429 /* The ucontext contains a stack32_t, so we must convert! */
430 if (__get_user(sp, &frame->rs_uc.uc_stack.ss_sp))
432 st.ss_size = (long) sp;
433 if (__get_user(st.ss_size, &frame->rs_uc.uc_stack.ss_size))
435 if (__get_user(st.ss_flags, &frame->rs_uc.uc_stack.ss_flags))
438 /* It is more difficult to avoid calling this function than to
439 call it and ignore errors. */
440 do_sigaltstack(&st, NULL, regs.regs[29]);
443 * Don't let your children do this ...
445 __asm__ __volatile__(
453 force_sig(SIGSEGV, current);
456 static inline int setup_sigcontext32(struct pt_regs *regs,
457 struct sigcontext32 *sc)
461 err |= __put_user(regs->cp0_epc, &sc->sc_pc);
462 err |= __put_user(regs->cp0_status, &sc->sc_status);
464 #define save_gp_reg(i) { \
465 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); \
467 __put_user(0, &sc->sc_regs[0]); save_gp_reg(1); save_gp_reg(2);
468 save_gp_reg(3); save_gp_reg(4); save_gp_reg(5); save_gp_reg(6);
469 save_gp_reg(7); save_gp_reg(8); save_gp_reg(9); save_gp_reg(10);
470 save_gp_reg(11); save_gp_reg(12); save_gp_reg(13); save_gp_reg(14);
471 save_gp_reg(15); save_gp_reg(16); save_gp_reg(17); save_gp_reg(18);
472 save_gp_reg(19); save_gp_reg(20); save_gp_reg(21); save_gp_reg(22);
473 save_gp_reg(23); save_gp_reg(24); save_gp_reg(25); save_gp_reg(26);
474 save_gp_reg(27); save_gp_reg(28); save_gp_reg(29); save_gp_reg(30);
478 err |= __put_user(regs->hi, &sc->sc_mdhi);
479 err |= __put_user(regs->lo, &sc->sc_mdlo);
480 err |= __put_user(regs->cp0_cause, &sc->sc_cause);
481 err |= __put_user(regs->cp0_badvaddr, &sc->sc_badvaddr);
483 err |= __put_user(current->used_math, &sc->sc_used_math);
485 if (!current->used_math)
489 * Save FPU state to signal context. Signal handler will "inherit"
492 if (!is_fpu_owner()) {
496 err |= save_fp_context32(sc);
503 * Determine which stack to use..
505 static inline void *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs,
510 /* Default to using normal stack */
514 * FPU emulator may have it's own trampoline active just
515 * above the user stack, 16-bytes before the next lowest
516 * 16 byte boundary. Try to avoid trashing it.
520 /* This is the X/Open sanctioned signal stack switching. */
521 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0))
522 sp = current->sas_ss_sp + current->sas_ss_size;
524 return (void *)((sp - frame_size) & ALMASK);
527 static inline void setup_frame(struct k_sigaction * ka, struct pt_regs *regs,
528 int signr, sigset_t *set)
530 struct sigframe *frame;
533 frame = get_sigframe(ka, regs, sizeof(*frame));
534 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
538 * Set up the return code ...
540 * li v0, __NR_O32_sigreturn
543 err |= __put_user(0x24020000 + __NR_O32_sigreturn, frame->sf_code + 0);
544 err |= __put_user(0x0000000c , frame->sf_code + 1);
545 flush_cache_sigtramp((unsigned long) frame->sf_code);
547 err |= setup_sigcontext32(regs, &frame->sf_sc);
548 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set));
553 * Arguments to signal handler:
556 * a1 = 0 (should be cause)
557 * a2 = pointer to struct sigcontext
559 * $25 and c0_epc point to the signal handler, $29 points to the
562 regs->regs[ 4] = signr;
564 regs->regs[ 6] = (unsigned long) &frame->sf_sc;
565 regs->regs[29] = (unsigned long) frame;
566 regs->regs[31] = (unsigned long) frame->sf_code;
567 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
570 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
571 current->comm, current->pid,
572 frame, regs->cp0_epc, frame->sf_code);
577 if (signr == SIGSEGV)
578 ka->sa.sa_handler = SIG_DFL;
579 force_sig(SIGSEGV, current);
582 static inline void setup_rt_frame(struct k_sigaction * ka,
583 struct pt_regs *regs, int signr,
584 sigset_t *set, siginfo_t *info)
586 struct rt_sigframe32 *frame;
590 frame = get_sigframe(ka, regs, sizeof(*frame));
591 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame)))
594 /* Set up to return from userspace. If provided, use a stub already
597 * Set up the return code ...
599 * li v0, __NR_O32_rt_sigreturn
602 err |= __put_user(0x24020000 + __NR_O32_rt_sigreturn, frame->rs_code + 0);
603 err |= __put_user(0x0000000c , frame->rs_code + 1);
604 flush_cache_sigtramp((unsigned long) frame->rs_code);
606 /* Convert (siginfo_t -> siginfo_t32) and copy to user. */
607 err |= copy_siginfo_to_user32(&frame->rs_info, info);
609 /* Create the ucontext. */
610 err |= __put_user(0, &frame->rs_uc.uc_flags);
611 err |= __put_user(0, &frame->rs_uc.uc_link);
612 sp = (int) (long) current->sas_ss_sp;
613 err |= __put_user(sp,
614 &frame->rs_uc.uc_stack.ss_sp);
615 err |= __put_user(sas_ss_flags(regs->regs[29]),
616 &frame->rs_uc.uc_stack.ss_flags);
617 err |= __put_user(current->sas_ss_size,
618 &frame->rs_uc.uc_stack.ss_size);
619 err |= setup_sigcontext32(regs, &frame->rs_uc.uc_mcontext);
620 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set));
626 * Arguments to signal handler:
629 * a1 = 0 (should be cause)
630 * a2 = pointer to ucontext
632 * $25 and c0_epc point to the signal handler, $29 points to
633 * the struct rt_sigframe32.
635 regs->regs[ 4] = signr;
636 regs->regs[ 5] = (unsigned long) &frame->rs_info;
637 regs->regs[ 6] = (unsigned long) &frame->rs_uc;
638 regs->regs[29] = (unsigned long) frame;
639 regs->regs[31] = (unsigned long) frame->rs_code;
640 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler;
643 printk("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%p\n",
644 current->comm, current->pid,
645 frame, regs->cp0_epc, frame->rs_code);
650 if (signr == SIGSEGV)
651 ka->sa.sa_handler = SIG_DFL;
652 force_sig(SIGSEGV, current);
655 static inline void handle_signal(unsigned long sig, siginfo_t *info,
656 sigset_t *oldset, struct pt_regs * regs)
658 struct k_sigaction *ka = ¤t->sighand->action[sig-1];
660 switch (regs->regs[0]) {
661 case ERESTART_RESTARTBLOCK:
663 regs->regs[2] = EINTR;
666 if(!(ka->sa.sa_flags & SA_RESTART)) {
667 regs->regs[2] = EINTR;
671 case ERESTARTNOINTR: /* Userland will reload $v0. */
672 regs->regs[7] = regs->regs[26];
676 regs->regs[0] = 0; /* Don't deal with this again. */
678 if (ka->sa.sa_flags & SA_SIGINFO)
679 setup_rt_frame(ka, regs, sig, oldset, info);
681 setup_frame(ka, regs, sig, oldset);
683 if (ka->sa.sa_flags & SA_ONESHOT)
684 ka->sa.sa_handler = SIG_DFL;
685 if (!(ka->sa.sa_flags & SA_NODEFER)) {
686 spin_lock_irq(¤t->sighand->siglock);
687 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
688 sigaddset(¤t->blocked,sig);
690 spin_unlock_irq(¤t->sighand->siglock);
694 asmlinkage int do_signal32(sigset_t *oldset, struct pt_regs *regs)
700 oldset = ¤t->blocked;
702 signr = get_signal_to_deliver(&info, regs, NULL);
704 handle_signal(signr, &info, oldset, regs);
709 * Who's code doesn't conform to the restartable syscall convention
710 * dies here!!! The li instruction, a single machine instruction,
711 * must directly be followed by the syscall instruction.
714 if (regs->regs[2] == ERESTARTNOHAND ||
715 regs->regs[2] == ERESTARTSYS ||
716 regs->regs[2] == ERESTARTNOINTR) {
717 regs->regs[7] = regs->regs[26];
720 if (regs->regs[2] == ERESTART_RESTARTBLOCK) {
721 regs->regs[2] = __NR_O32_restart_syscall;
722 regs->regs[7] = regs->regs[26];
729 asmlinkage int sys32_rt_sigaction(int sig, const struct sigaction32 *act,
730 struct sigaction32 *oact,
731 unsigned int sigsetsize)
733 struct k_sigaction new_sa, old_sa;
736 /* XXX: Don't preclude handling different sized sigset_t's. */
737 if (sigsetsize != sizeof(sigset_t))
743 if (!access_ok(VERIFY_READ, act, sizeof(*act)))
745 err |= __get_user((u32)(u64)new_sa.sa.sa_handler,
747 err |= __get_user(new_sa.sa.sa_flags, &act->sa_flags);
748 err |= get_sigset(&new_sa.sa.sa_mask, &act->sa_mask);
753 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
758 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)))
761 err |= __put_user((u32)(u64)old_sa.sa.sa_handler,
763 err |= __put_user(old_sa.sa.sa_flags, &oact->sa_flags);
764 err |= put_sigset(&old_sa.sa.sa_mask, &oact->sa_mask);
772 asmlinkage int sys32_rt_sigprocmask(int how, compat_sigset_t *set,
773 compat_sigset_t *oset, unsigned int sigsetsize)
775 sigset_t old_set, new_set;
777 mm_segment_t old_fs = get_fs();
779 if (set && get_sigset(&new_set, set))
783 ret = sys_rt_sigprocmask(how, set ? &new_set : NULL,
784 oset ? &old_set : NULL, sigsetsize);
787 if (!ret && oset && put_sigset(&old_set, oset))
793 asmlinkage int sys32_rt_sigpending(compat_sigset_t *uset,
794 unsigned int sigsetsize)
798 mm_segment_t old_fs = get_fs();
801 ret = sys_rt_sigpending(&set, sigsetsize);
804 if (!ret && put_sigset(&set, uset))
810 asmlinkage int sys32_rt_sigtimedwait(compat_sigset_t *uthese,
811 siginfo_t32 *uinfo, struct compat_timespec *uts,
812 compat_time_t sigsetsize)
816 compat_sigset_t these32;
822 * As the result of a brainfarting competition a few years ago the
823 * size of sigset_t for the 32-bit kernel was choosen to be 128 bits
824 * but nothing so far is actually using that many, 64 are enough. So
825 * for now we just drop the high bits.
827 if (copy_from_user (&these32, uthese, sizeof(compat_old_sigset_t)))
830 switch (_NSIG_WORDS) {
832 case 4: these.sig[3] = these32.sig[6] | (((long)these32.sig[7]) << 32);
833 case 3: these.sig[2] = these32.sig[4] | (((long)these32.sig[5]) << 32);
834 case 2: these.sig[1] = these32.sig[2] | (((long)these32.sig[3]) << 32);
835 case 1: these.sig[0] = these32.sig[0] | (((long)these32.sig[1]) << 32);
838 case 4: these.sig[3] = these32.sig[7] | (((long)these32.sig[6]) << 32);
839 case 3: these.sig[2] = these32.sig[5] | (((long)these32.sig[4]) << 32);
840 case 2: these.sig[1] = these32.sig[3] | (((long)these32.sig[2]) << 32);
841 case 1: these.sig[0] = these32.sig[1] | (((long)these32.sig[0]) << 32);
846 * Invert the set of allowed signals to get those we
849 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
853 if (get_user (ts.tv_sec, &uts->tv_sec) ||
854 get_user (ts.tv_nsec, &uts->tv_nsec))
856 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
861 spin_lock_irq(¤t->sighand->siglock);
862 sig = dequeue_signal(current, &these, &info);
864 /* None ready -- temporarily unblock those we're interested
865 in so that we'll be awakened when they arrive. */
866 sigset_t oldblocked = current->blocked;
867 sigandsets(¤t->blocked, ¤t->blocked, &these);
869 spin_unlock_irq(¤t->sighand->siglock);
871 timeout = MAX_SCHEDULE_TIMEOUT;
873 timeout = (timespec_to_jiffies(&ts)
874 + (ts.tv_sec || ts.tv_nsec));
876 current->state = TASK_INTERRUPTIBLE;
877 timeout = schedule_timeout(timeout);
879 spin_lock_irq(¤t->sighand->siglock);
880 sig = dequeue_signal(current, &these, &info);
881 current->blocked = oldblocked;
884 spin_unlock_irq(¤t->sighand->siglock);
889 if (copy_siginfo_to_user32(uinfo, &info))
901 asmlinkage int sys32_rt_sigqueueinfo(int pid, int sig, siginfo_t32 *uinfo)
905 mm_segment_t old_fs = get_fs();
907 if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
908 copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE))
911 ret = sys_rt_sigqueueinfo(pid, sig, &info);