2 * linux/arch/alpha/kernel/signal.c
4 * Copyright (C) 1995 Linus Torvalds
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
9 #include <linux/sched.h>
10 #include <linux/kernel.h>
11 #include <linux/signal.h>
12 #include <linux/errno.h>
13 #include <linux/wait.h>
14 #include <linux/ptrace.h>
15 #include <linux/unistd.h>
17 #include <linux/smp.h>
18 #include <linux/stddef.h>
19 #include <linux/tty.h>
20 #include <linux/binfmts.h>
21 #include <linux/bitops.h>
22 #include <linux/syscalls.h>
23 #include <linux/tracehook.h>
25 #include <asm/uaccess.h>
26 #include <asm/sigcontext.h>
27 #include <asm/ucontext.h>
34 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
36 asmlinkage void ret_from_sys_call(void);
37 static void do_signal(struct pt_regs *, struct switch_stack *,
38 unsigned long, unsigned long);
42 * The OSF/1 sigprocmask calling sequence is different from the
43 * C sigprocmask() sequence..
50 * We change the range to -1 .. 1 in order to let gcc easily
51 * use the conditional move instructions.
53 * Note that we don't need to acquire the kernel lock for SMP
54 * operation, as all of this is local to this thread.
56 SYSCALL_DEFINE3(osf_sigprocmask, int, how, unsigned long, newmask,
57 struct pt_regs *, regs)
59 unsigned long oldmask = -EINVAL;
61 if ((unsigned long)how-1 <= 2) {
62 long sign = how-2; /* -1 .. 1 */
63 unsigned long block, unblock;
65 newmask &= _BLOCKABLE;
66 spin_lock_irq(¤t->sighand->siglock);
67 oldmask = current->blocked.sig[0];
69 unblock = oldmask & ~newmask;
70 block = oldmask | newmask;
75 if (_NSIG_WORDS > 1 && sign > 0)
76 sigemptyset(¤t->blocked);
77 current->blocked.sig[0] = newmask;
79 spin_unlock_irq(¤t->sighand->siglock);
81 regs->r0 = 0; /* special no error return */
86 SYSCALL_DEFINE3(osf_sigaction, int, sig,
87 const struct osf_sigaction __user *, act,
88 struct osf_sigaction __user *, oact)
90 struct k_sigaction new_ka, old_ka;
95 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
96 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
97 __get_user(new_ka.sa.sa_flags, &act->sa_flags))
99 __get_user(mask, &act->sa_mask);
100 siginitset(&new_ka.sa.sa_mask, mask);
101 new_ka.ka_restorer = NULL;
104 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
107 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
108 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
109 __put_user(old_ka.sa.sa_flags, &oact->sa_flags))
111 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
117 SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
118 struct sigaction __user *, oact,
119 size_t, sigsetsize, void __user *, restorer)
121 struct k_sigaction new_ka, old_ka;
124 /* XXX: Don't preclude handling different sized sigset_t's. */
125 if (sigsetsize != sizeof(sigset_t))
129 new_ka.ka_restorer = restorer;
130 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
134 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
137 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
145 * Atomically swap in the new signal mask, and wait for a signal.
147 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
150 spin_lock_irq(¤t->sighand->siglock);
151 current->saved_sigmask = current->blocked;
152 siginitset(¤t->blocked, mask);
154 spin_unlock_irq(¤t->sighand->siglock);
156 current->state = TASK_INTERRUPTIBLE;
158 set_thread_flag(TIF_RESTORE_SIGMASK);
159 return -ERESTARTNOHAND;
163 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
165 return do_sigaltstack(uss, uoss, rdusp());
169 * Do a signal return; undo the signal stack.
173 # error "Non SA_SIGINFO frame needs rearranging"
178 struct sigcontext sc;
179 unsigned int retcode[3];
186 unsigned int retcode[3];
189 /* If this changes, userland unwinders that Know Things about our signal
190 frame will break. Do not undertake lightly. It also implies an ABI
191 change wrt the size of siginfo_t, which may cause some pain. */
192 extern char compile_time_assert
193 [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];
195 #define INSN_MOV_R30_R16 0x47fe0410
196 #define INSN_LDI_R0 0x201f0000
197 #define INSN_CALLSYS 0x00000083
200 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
201 struct switch_stack *sw)
204 long i, err = __get_user(regs->pc, &sc->sc_pc);
206 current_thread_info()->restart_block.fn = do_no_restart_syscall;
208 sw->r26 = (unsigned long) ret_from_sys_call;
210 err |= __get_user(regs->r0, sc->sc_regs+0);
211 err |= __get_user(regs->r1, sc->sc_regs+1);
212 err |= __get_user(regs->r2, sc->sc_regs+2);
213 err |= __get_user(regs->r3, sc->sc_regs+3);
214 err |= __get_user(regs->r4, sc->sc_regs+4);
215 err |= __get_user(regs->r5, sc->sc_regs+5);
216 err |= __get_user(regs->r6, sc->sc_regs+6);
217 err |= __get_user(regs->r7, sc->sc_regs+7);
218 err |= __get_user(regs->r8, sc->sc_regs+8);
219 err |= __get_user(sw->r9, sc->sc_regs+9);
220 err |= __get_user(sw->r10, sc->sc_regs+10);
221 err |= __get_user(sw->r11, sc->sc_regs+11);
222 err |= __get_user(sw->r12, sc->sc_regs+12);
223 err |= __get_user(sw->r13, sc->sc_regs+13);
224 err |= __get_user(sw->r14, sc->sc_regs+14);
225 err |= __get_user(sw->r15, sc->sc_regs+15);
226 err |= __get_user(regs->r16, sc->sc_regs+16);
227 err |= __get_user(regs->r17, sc->sc_regs+17);
228 err |= __get_user(regs->r18, sc->sc_regs+18);
229 err |= __get_user(regs->r19, sc->sc_regs+19);
230 err |= __get_user(regs->r20, sc->sc_regs+20);
231 err |= __get_user(regs->r21, sc->sc_regs+21);
232 err |= __get_user(regs->r22, sc->sc_regs+22);
233 err |= __get_user(regs->r23, sc->sc_regs+23);
234 err |= __get_user(regs->r24, sc->sc_regs+24);
235 err |= __get_user(regs->r25, sc->sc_regs+25);
236 err |= __get_user(regs->r26, sc->sc_regs+26);
237 err |= __get_user(regs->r27, sc->sc_regs+27);
238 err |= __get_user(regs->r28, sc->sc_regs+28);
239 err |= __get_user(regs->gp, sc->sc_regs+29);
240 err |= __get_user(usp, sc->sc_regs+30);
243 for (i = 0; i < 31; i++)
244 err |= __get_user(sw->fp[i], sc->sc_fpregs+i);
245 err |= __get_user(sw->fp[31], &sc->sc_fpcr);
250 /* Note that this syscall is also used by setcontext(3) to install
251 a given sigcontext. This because it's impossible to set *all*
252 registers and transfer control from userland. */
255 do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs,
256 struct switch_stack *sw)
260 /* Verify that it's a good sigcontext before using it */
261 if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
263 if (__get_user(set.sig[0], &sc->sc_mask))
266 sigdelsetmask(&set, ~_BLOCKABLE);
267 spin_lock_irq(¤t->sighand->siglock);
268 current->blocked = set;
270 spin_unlock_irq(¤t->sighand->siglock);
272 if (restore_sigcontext(sc, regs, sw))
275 /* Send SIGTRAP if we're single-stepping: */
276 if (ptrace_cancel_bpt (current)) {
279 info.si_signo = SIGTRAP;
281 info.si_code = TRAP_BRKPT;
282 info.si_addr = (void __user *) regs->pc;
284 send_sig_info(SIGTRAP, &info, current);
289 force_sig(SIGSEGV, current);
293 do_rt_sigreturn(struct rt_sigframe __user *frame, struct pt_regs *regs,
294 struct switch_stack *sw)
298 /* Verify that it's a good ucontext_t before using it */
299 if (!access_ok(VERIFY_READ, &frame->uc, sizeof(frame->uc)))
301 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
304 sigdelsetmask(&set, ~_BLOCKABLE);
305 spin_lock_irq(¤t->sighand->siglock);
306 current->blocked = set;
308 spin_unlock_irq(¤t->sighand->siglock);
310 if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
313 /* Send SIGTRAP if we're single-stepping: */
314 if (ptrace_cancel_bpt (current)) {
317 info.si_signo = SIGTRAP;
319 info.si_code = TRAP_BRKPT;
320 info.si_addr = (void __user *) regs->pc;
322 send_sig_info(SIGTRAP, &info, current);
327 force_sig(SIGSEGV, current);
332 * Set up a signal frame.
335 static inline void __user *
336 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
338 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
339 sp = current->sas_ss_sp + current->sas_ss_size;
341 return (void __user *)((sp - frame_size) & -32ul);
345 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
346 struct switch_stack *sw, unsigned long mask, unsigned long sp)
350 err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
351 err |= __put_user(mask, &sc->sc_mask);
352 err |= __put_user(regs->pc, &sc->sc_pc);
353 err |= __put_user(8, &sc->sc_ps);
355 err |= __put_user(regs->r0 , sc->sc_regs+0);
356 err |= __put_user(regs->r1 , sc->sc_regs+1);
357 err |= __put_user(regs->r2 , sc->sc_regs+2);
358 err |= __put_user(regs->r3 , sc->sc_regs+3);
359 err |= __put_user(regs->r4 , sc->sc_regs+4);
360 err |= __put_user(regs->r5 , sc->sc_regs+5);
361 err |= __put_user(regs->r6 , sc->sc_regs+6);
362 err |= __put_user(regs->r7 , sc->sc_regs+7);
363 err |= __put_user(regs->r8 , sc->sc_regs+8);
364 err |= __put_user(sw->r9 , sc->sc_regs+9);
365 err |= __put_user(sw->r10 , sc->sc_regs+10);
366 err |= __put_user(sw->r11 , sc->sc_regs+11);
367 err |= __put_user(sw->r12 , sc->sc_regs+12);
368 err |= __put_user(sw->r13 , sc->sc_regs+13);
369 err |= __put_user(sw->r14 , sc->sc_regs+14);
370 err |= __put_user(sw->r15 , sc->sc_regs+15);
371 err |= __put_user(regs->r16, sc->sc_regs+16);
372 err |= __put_user(regs->r17, sc->sc_regs+17);
373 err |= __put_user(regs->r18, sc->sc_regs+18);
374 err |= __put_user(regs->r19, sc->sc_regs+19);
375 err |= __put_user(regs->r20, sc->sc_regs+20);
376 err |= __put_user(regs->r21, sc->sc_regs+21);
377 err |= __put_user(regs->r22, sc->sc_regs+22);
378 err |= __put_user(regs->r23, sc->sc_regs+23);
379 err |= __put_user(regs->r24, sc->sc_regs+24);
380 err |= __put_user(regs->r25, sc->sc_regs+25);
381 err |= __put_user(regs->r26, sc->sc_regs+26);
382 err |= __put_user(regs->r27, sc->sc_regs+27);
383 err |= __put_user(regs->r28, sc->sc_regs+28);
384 err |= __put_user(regs->gp , sc->sc_regs+29);
385 err |= __put_user(sp, sc->sc_regs+30);
386 err |= __put_user(0, sc->sc_regs+31);
388 for (i = 0; i < 31; i++)
389 err |= __put_user(sw->fp[i], sc->sc_fpregs+i);
390 err |= __put_user(0, sc->sc_fpregs+31);
391 err |= __put_user(sw->fp[31], &sc->sc_fpcr);
393 err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
394 err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
395 err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
401 setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
402 struct pt_regs *regs, struct switch_stack * sw)
404 unsigned long oldsp, r26, err = 0;
405 struct sigframe __user *frame;
408 frame = get_sigframe(ka, oldsp, sizeof(*frame));
409 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
412 err |= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp);
416 /* Set up to return from userspace. If provided, use a stub
417 already in userspace. */
418 if (ka->ka_restorer) {
419 r26 = (unsigned long) ka->ka_restorer;
421 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
422 err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
423 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
425 r26 = (unsigned long) frame->retcode;
428 /* Check that everything was written properly. */
432 /* "Return" to the handler */
434 regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
435 regs->r16 = sig; /* a0: signal number */
436 regs->r17 = 0; /* a1: exception code */
437 regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
438 wrusp((unsigned long) frame);
441 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
442 current->comm, current->pid, frame, regs->pc, regs->r26);
448 force_sigsegv(sig, current);
453 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
454 sigset_t *set, struct pt_regs *regs, struct switch_stack * sw)
456 unsigned long oldsp, r26, err = 0;
457 struct rt_sigframe __user *frame;
460 frame = get_sigframe(ka, oldsp, sizeof(*frame));
461 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
464 err |= copy_siginfo_to_user(&frame->info, info);
466 /* Create the ucontext. */
467 err |= __put_user(0, &frame->uc.uc_flags);
468 err |= __put_user(0, &frame->uc.uc_link);
469 err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
470 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
471 err |= __put_user(sas_ss_flags(oldsp), &frame->uc.uc_stack.ss_flags);
472 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
473 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, sw,
475 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
479 /* Set up to return from userspace. If provided, use a stub
480 already in userspace. */
481 if (ka->ka_restorer) {
482 r26 = (unsigned long) ka->ka_restorer;
484 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
485 err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
487 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
489 r26 = (unsigned long) frame->retcode;
495 /* "Return" to the handler */
497 regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
498 regs->r16 = sig; /* a0: signal number */
499 regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
500 regs->r18 = (unsigned long) &frame->uc; /* a2: ucontext pointer */
501 wrusp((unsigned long) frame);
504 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
505 current->comm, current->pid, frame, regs->pc, regs->r26);
511 force_sigsegv(sig, current);
517 * OK, we're invoking a handler.
520 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
521 sigset_t *oldset, struct pt_regs * regs, struct switch_stack *sw)
525 if (ka->sa.sa_flags & SA_SIGINFO)
526 ret = setup_rt_frame(sig, ka, info, oldset, regs, sw);
528 ret = setup_frame(sig, ka, oldset, regs, sw);
531 spin_lock_irq(¤t->sighand->siglock);
532 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
533 if (!(ka->sa.sa_flags & SA_NODEFER))
534 sigaddset(¤t->blocked,sig);
536 spin_unlock_irq(¤t->sighand->siglock);
543 syscall_restart(unsigned long r0, unsigned long r19,
544 struct pt_regs *regs, struct k_sigaction *ka)
548 if (!(ka->sa.sa_flags & SA_RESTART)) {
555 regs->r0 = r0; /* reset v0 and a3 and replay syscall */
559 case ERESTART_RESTARTBLOCK:
567 * Note that 'init' is a special process: it doesn't get signals it doesn't
568 * want to handle. Thus you cannot kill init even with a SIGKILL even by
571 * Note that we go through the signals twice: once to check the signals that
572 * the kernel can handle, and then we build all the user-level signal handling
573 * stack-frames in one go after that.
575 * "r0" and "r19" are the registers we need to restore for system call
576 * restart. "r0" is also used as an indicator whether we can restart at
577 * all (if we get here from anything but a syscall return, it will be 0)
580 do_signal(struct pt_regs * regs, struct switch_stack * sw,
581 unsigned long r0, unsigned long r19)
585 unsigned long single_stepping = ptrace_cancel_bpt(current);
586 struct k_sigaction ka;
589 if (test_thread_flag(TIF_RESTORE_SIGMASK))
590 oldset = ¤t->saved_sigmask;
592 oldset = ¤t->blocked;
594 /* This lets the debugger run, ... */
595 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
597 /* ... so re-check the single stepping. */
598 single_stepping |= ptrace_cancel_bpt(current);
601 /* Whee! Actually deliver the signal. */
603 syscall_restart(r0, r19, regs, &ka);
604 if (handle_signal(signr, &ka, &info, oldset, regs, sw) == 0) {
605 /* A signal was successfully delivered, and the
606 saved sigmask was stored on the signal frame,
607 and will be restored by sigreturn. So we can
608 simply clear the restore sigmask flag. */
609 if (test_thread_flag(TIF_RESTORE_SIGMASK))
610 clear_thread_flag(TIF_RESTORE_SIGMASK);
613 ptrace_set_bpt(current); /* re-set bpt */
622 /* Reset v0 and a3 and replay syscall. */
627 case ERESTART_RESTARTBLOCK:
628 /* Force v0 to the restart syscall and reply. */
629 regs->r0 = __NR_restart_syscall;
635 /* If there's no signal to deliver, we just restore the saved mask. */
636 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
637 clear_thread_flag(TIF_RESTORE_SIGMASK);
638 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
642 ptrace_set_bpt(current); /* re-set breakpoint */
646 do_notify_resume(struct pt_regs *regs, struct switch_stack *sw,
647 unsigned long thread_info_flags,
648 unsigned long r0, unsigned long r19)
650 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
651 do_signal(regs, sw, r0, r19);
653 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
654 clear_thread_flag(TIF_NOTIFY_RESUME);
655 tracehook_notify_resume(regs);
656 if (current->replacement_session_keyring)
657 key_replace_session_keyring();