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);
39 * The OSF/1 sigprocmask calling sequence is different from the
40 * C sigprocmask() sequence..
42 SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask)
48 siginitset(&mask, newmask & _BLOCKABLE);
49 res = sigprocmask(how, &mask, &oldmask);
51 force_successful_syscall_return();
57 SYSCALL_DEFINE3(osf_sigaction, int, sig,
58 const struct osf_sigaction __user *, act,
59 struct osf_sigaction __user *, oact)
61 struct k_sigaction new_ka, old_ka;
66 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
67 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
68 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
69 __get_user(mask, &act->sa_mask))
71 siginitset(&new_ka.sa.sa_mask, mask);
72 new_ka.ka_restorer = NULL;
75 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
78 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
79 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
80 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
81 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
88 SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act,
89 struct sigaction __user *, oact,
90 size_t, sigsetsize, void __user *, restorer)
92 struct k_sigaction new_ka, old_ka;
95 /* XXX: Don't preclude handling different sized sigset_t's. */
96 if (sigsetsize != sizeof(sigset_t))
100 new_ka.ka_restorer = restorer;
101 if (copy_from_user(&new_ka.sa, act, sizeof(*act)))
105 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
108 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact)))
116 * Atomically swap in the new signal mask, and wait for a signal.
118 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
121 siginitset(&blocked, mask);
122 return sigsuspend(&blocked);
126 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
128 return do_sigaltstack(uss, uoss, rdusp());
132 * Do a signal return; undo the signal stack.
136 # error "Non SA_SIGINFO frame needs rearranging"
141 struct sigcontext sc;
142 unsigned int retcode[3];
149 unsigned int retcode[3];
152 /* If this changes, userland unwinders that Know Things about our signal
153 frame will break. Do not undertake lightly. It also implies an ABI
154 change wrt the size of siginfo_t, which may cause some pain. */
155 extern char compile_time_assert
156 [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1];
158 #define INSN_MOV_R30_R16 0x47fe0410
159 #define INSN_LDI_R0 0x201f0000
160 #define INSN_CALLSYS 0x00000083
163 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
164 struct switch_stack *sw)
167 long i, err = __get_user(regs->pc, &sc->sc_pc);
169 current_thread_info()->restart_block.fn = do_no_restart_syscall;
171 sw->r26 = (unsigned long) ret_from_sys_call;
173 err |= __get_user(regs->r0, sc->sc_regs+0);
174 err |= __get_user(regs->r1, sc->sc_regs+1);
175 err |= __get_user(regs->r2, sc->sc_regs+2);
176 err |= __get_user(regs->r3, sc->sc_regs+3);
177 err |= __get_user(regs->r4, sc->sc_regs+4);
178 err |= __get_user(regs->r5, sc->sc_regs+5);
179 err |= __get_user(regs->r6, sc->sc_regs+6);
180 err |= __get_user(regs->r7, sc->sc_regs+7);
181 err |= __get_user(regs->r8, sc->sc_regs+8);
182 err |= __get_user(sw->r9, sc->sc_regs+9);
183 err |= __get_user(sw->r10, sc->sc_regs+10);
184 err |= __get_user(sw->r11, sc->sc_regs+11);
185 err |= __get_user(sw->r12, sc->sc_regs+12);
186 err |= __get_user(sw->r13, sc->sc_regs+13);
187 err |= __get_user(sw->r14, sc->sc_regs+14);
188 err |= __get_user(sw->r15, sc->sc_regs+15);
189 err |= __get_user(regs->r16, sc->sc_regs+16);
190 err |= __get_user(regs->r17, sc->sc_regs+17);
191 err |= __get_user(regs->r18, sc->sc_regs+18);
192 err |= __get_user(regs->r19, sc->sc_regs+19);
193 err |= __get_user(regs->r20, sc->sc_regs+20);
194 err |= __get_user(regs->r21, sc->sc_regs+21);
195 err |= __get_user(regs->r22, sc->sc_regs+22);
196 err |= __get_user(regs->r23, sc->sc_regs+23);
197 err |= __get_user(regs->r24, sc->sc_regs+24);
198 err |= __get_user(regs->r25, sc->sc_regs+25);
199 err |= __get_user(regs->r26, sc->sc_regs+26);
200 err |= __get_user(regs->r27, sc->sc_regs+27);
201 err |= __get_user(regs->r28, sc->sc_regs+28);
202 err |= __get_user(regs->gp, sc->sc_regs+29);
203 err |= __get_user(usp, sc->sc_regs+30);
206 for (i = 0; i < 31; i++)
207 err |= __get_user(sw->fp[i], sc->sc_fpregs+i);
208 err |= __get_user(sw->fp[31], &sc->sc_fpcr);
213 /* Note that this syscall is also used by setcontext(3) to install
214 a given sigcontext. This because it's impossible to set *all*
215 registers and transfer control from userland. */
218 do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs,
219 struct switch_stack *sw)
223 /* Verify that it's a good sigcontext before using it */
224 if (!access_ok(VERIFY_READ, sc, sizeof(*sc)))
226 if (__get_user(set.sig[0], &sc->sc_mask))
229 sigdelsetmask(&set, ~_BLOCKABLE);
230 set_current_blocked(&set);
232 if (restore_sigcontext(sc, regs, sw))
235 /* Send SIGTRAP if we're single-stepping: */
236 if (ptrace_cancel_bpt (current)) {
239 info.si_signo = SIGTRAP;
241 info.si_code = TRAP_BRKPT;
242 info.si_addr = (void __user *) regs->pc;
244 send_sig_info(SIGTRAP, &info, current);
249 force_sig(SIGSEGV, current);
253 do_rt_sigreturn(struct rt_sigframe __user *frame, struct pt_regs *regs,
254 struct switch_stack *sw)
258 /* Verify that it's a good ucontext_t before using it */
259 if (!access_ok(VERIFY_READ, &frame->uc, sizeof(frame->uc)))
261 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
264 sigdelsetmask(&set, ~_BLOCKABLE);
265 set_current_blocked(&set);
267 if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw))
270 /* Send SIGTRAP if we're single-stepping: */
271 if (ptrace_cancel_bpt (current)) {
274 info.si_signo = SIGTRAP;
276 info.si_code = TRAP_BRKPT;
277 info.si_addr = (void __user *) regs->pc;
279 send_sig_info(SIGTRAP, &info, current);
284 force_sig(SIGSEGV, current);
289 * Set up a signal frame.
292 static inline void __user *
293 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
295 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
296 sp = current->sas_ss_sp + current->sas_ss_size;
298 return (void __user *)((sp - frame_size) & -32ul);
302 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
303 struct switch_stack *sw, unsigned long mask, unsigned long sp)
307 err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
308 err |= __put_user(mask, &sc->sc_mask);
309 err |= __put_user(regs->pc, &sc->sc_pc);
310 err |= __put_user(8, &sc->sc_ps);
312 err |= __put_user(regs->r0 , sc->sc_regs+0);
313 err |= __put_user(regs->r1 , sc->sc_regs+1);
314 err |= __put_user(regs->r2 , sc->sc_regs+2);
315 err |= __put_user(regs->r3 , sc->sc_regs+3);
316 err |= __put_user(regs->r4 , sc->sc_regs+4);
317 err |= __put_user(regs->r5 , sc->sc_regs+5);
318 err |= __put_user(regs->r6 , sc->sc_regs+6);
319 err |= __put_user(regs->r7 , sc->sc_regs+7);
320 err |= __put_user(regs->r8 , sc->sc_regs+8);
321 err |= __put_user(sw->r9 , sc->sc_regs+9);
322 err |= __put_user(sw->r10 , sc->sc_regs+10);
323 err |= __put_user(sw->r11 , sc->sc_regs+11);
324 err |= __put_user(sw->r12 , sc->sc_regs+12);
325 err |= __put_user(sw->r13 , sc->sc_regs+13);
326 err |= __put_user(sw->r14 , sc->sc_regs+14);
327 err |= __put_user(sw->r15 , sc->sc_regs+15);
328 err |= __put_user(regs->r16, sc->sc_regs+16);
329 err |= __put_user(regs->r17, sc->sc_regs+17);
330 err |= __put_user(regs->r18, sc->sc_regs+18);
331 err |= __put_user(regs->r19, sc->sc_regs+19);
332 err |= __put_user(regs->r20, sc->sc_regs+20);
333 err |= __put_user(regs->r21, sc->sc_regs+21);
334 err |= __put_user(regs->r22, sc->sc_regs+22);
335 err |= __put_user(regs->r23, sc->sc_regs+23);
336 err |= __put_user(regs->r24, sc->sc_regs+24);
337 err |= __put_user(regs->r25, sc->sc_regs+25);
338 err |= __put_user(regs->r26, sc->sc_regs+26);
339 err |= __put_user(regs->r27, sc->sc_regs+27);
340 err |= __put_user(regs->r28, sc->sc_regs+28);
341 err |= __put_user(regs->gp , sc->sc_regs+29);
342 err |= __put_user(sp, sc->sc_regs+30);
343 err |= __put_user(0, sc->sc_regs+31);
345 for (i = 0; i < 31; i++)
346 err |= __put_user(sw->fp[i], sc->sc_fpregs+i);
347 err |= __put_user(0, sc->sc_fpregs+31);
348 err |= __put_user(sw->fp[31], &sc->sc_fpcr);
350 err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
351 err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
352 err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
358 setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
359 struct pt_regs *regs, struct switch_stack * sw)
361 unsigned long oldsp, r26, err = 0;
362 struct sigframe __user *frame;
365 frame = get_sigframe(ka, oldsp, sizeof(*frame));
366 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
369 err |= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp);
373 /* Set up to return from userspace. If provided, use a stub
374 already in userspace. */
375 if (ka->ka_restorer) {
376 r26 = (unsigned long) ka->ka_restorer;
378 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
379 err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
380 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
382 r26 = (unsigned long) frame->retcode;
385 /* Check that everything was written properly. */
389 /* "Return" to the handler */
391 regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
392 regs->r16 = sig; /* a0: signal number */
393 regs->r17 = 0; /* a1: exception code */
394 regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
395 wrusp((unsigned long) frame);
398 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
399 current->comm, current->pid, frame, regs->pc, regs->r26);
405 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
406 sigset_t *set, struct pt_regs *regs, struct switch_stack * sw)
408 unsigned long oldsp, r26, err = 0;
409 struct rt_sigframe __user *frame;
412 frame = get_sigframe(ka, oldsp, sizeof(*frame));
413 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
416 err |= copy_siginfo_to_user(&frame->info, info);
418 /* Create the ucontext. */
419 err |= __put_user(0, &frame->uc.uc_flags);
420 err |= __put_user(0, &frame->uc.uc_link);
421 err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
422 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
423 err |= __put_user(sas_ss_flags(oldsp), &frame->uc.uc_stack.ss_flags);
424 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
425 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, sw,
427 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
431 /* Set up to return from userspace. If provided, use a stub
432 already in userspace. */
433 if (ka->ka_restorer) {
434 r26 = (unsigned long) ka->ka_restorer;
436 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
437 err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
439 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
441 r26 = (unsigned long) frame->retcode;
447 /* "Return" to the handler */
449 regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
450 regs->r16 = sig; /* a0: signal number */
451 regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
452 regs->r18 = (unsigned long) &frame->uc; /* a2: ucontext pointer */
453 wrusp((unsigned long) frame);
456 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
457 current->comm, current->pid, frame, regs->pc, regs->r26);
465 * OK, we're invoking a handler.
468 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
469 struct pt_regs * regs, struct switch_stack *sw)
471 sigset_t *oldset = sigmask_to_save();
474 if (ka->sa.sa_flags & SA_SIGINFO)
475 ret = setup_rt_frame(sig, ka, info, oldset, regs, sw);
477 ret = setup_frame(sig, ka, oldset, regs, sw);
480 force_sigsegv(sig, current);
483 block_sigmask(ka, sig);
484 /* A signal was successfully delivered, and the
485 saved sigmask was stored on the signal frame,
486 and will be restored by sigreturn. So we can
487 simply clear the restore sigmask flag. */
488 clear_thread_flag(TIF_RESTORE_SIGMASK);
492 syscall_restart(unsigned long r0, unsigned long r19,
493 struct pt_regs *regs, struct k_sigaction *ka)
497 if (!(ka->sa.sa_flags & SA_RESTART)) {
504 regs->r0 = r0; /* reset v0 and a3 and replay syscall */
508 case ERESTART_RESTARTBLOCK:
516 * Note that 'init' is a special process: it doesn't get signals it doesn't
517 * want to handle. Thus you cannot kill init even with a SIGKILL even by
520 * Note that we go through the signals twice: once to check the signals that
521 * the kernel can handle, and then we build all the user-level signal handling
522 * stack-frames in one go after that.
524 * "r0" and "r19" are the registers we need to restore for system call
525 * restart. "r0" is also used as an indicator whether we can restart at
526 * all (if we get here from anything but a syscall return, it will be 0)
529 do_signal(struct pt_regs * regs, struct switch_stack * sw,
530 unsigned long r0, unsigned long r19)
534 unsigned long single_stepping = ptrace_cancel_bpt(current);
535 struct k_sigaction ka;
537 /* This lets the debugger run, ... */
538 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
540 /* ... so re-check the single stepping. */
541 single_stepping |= ptrace_cancel_bpt(current);
544 /* Whee! Actually deliver the signal. */
546 syscall_restart(r0, r19, regs, &ka);
547 handle_signal(signr, &ka, &info, regs, sw);
549 ptrace_set_bpt(current); /* re-set bpt */
558 /* Reset v0 and a3 and replay syscall. */
563 case ERESTART_RESTARTBLOCK:
564 /* Force v0 to the restart syscall and reply. */
565 regs->r0 = __NR_restart_syscall;
571 /* If there's no signal to deliver, we just restore the saved mask. */
572 restore_saved_sigmask();
574 ptrace_set_bpt(current); /* re-set breakpoint */
578 do_notify_resume(struct pt_regs *regs, struct switch_stack *sw,
579 unsigned long thread_info_flags,
580 unsigned long r0, unsigned long r19)
582 if (thread_info_flags & _TIF_SIGPENDING)
583 do_signal(regs, sw, r0, r19);
585 if (thread_info_flags & _TIF_NOTIFY_RESUME) {
586 clear_thread_flag(TIF_NOTIFY_RESUME);
587 tracehook_notify_resume(regs);