2 * linux/arch/parisc/kernel/signal.c: Architecture-specific signal
5 * Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
6 * Copyright (C) 2000 Linuxcare, Inc.
8 * Based on the ia64, i386, and alpha versions.
10 * Like the IA-64, we are a recent enough port (we are *starting*
11 * with glibc2.2) that we do not need to support the old non-realtime
12 * Linux signals. Therefore we don't. HP/UX signals will go in
13 * arch/parisc/hpux/signal.c when we figure out how to do them.
16 #include <linux/sched.h>
18 #include <linux/smp.h>
19 #include <linux/kernel.h>
20 #include <linux/signal.h>
21 #include <linux/errno.h>
22 #include <linux/wait.h>
23 #include <linux/ptrace.h>
24 #include <linux/unistd.h>
25 #include <linux/stddef.h>
26 #include <linux/compat.h>
27 #include <linux/elf.h>
28 #include <asm/ucontext.h>
29 #include <asm/rt_sigframe.h>
30 #include <asm/uaccess.h>
31 #include <asm/pgalloc.h>
32 #include <asm/cacheflush.h>
33 #include <asm/asm-offsets.h>
36 #include <linux/compat.h>
41 #define DEBUG_SIG_LEVEL 2
44 #define DBG(LEVEL, ...) \
45 ((DEBUG_SIG_LEVEL >= LEVEL) \
46 ? printk(__VA_ARGS__) : (void) 0)
48 #define DBG(LEVEL, ...)
52 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
54 /* gcc will complain if a pointer is cast to an integer of different
55 * size. If you really need to do this (and we do for an ELF32 user
56 * application in an ELF64 kernel) then you have to do a cast to an
57 * integer of the same size first. The A() macro accomplishes
59 #define A(__x) ((unsigned long)(__x))
62 * Atomically swap in the new signal mask, and wait for a signal.
69 * Do a signal return - restore sigcontext.
72 /* Trampoline for calling rt_sigreturn() */
73 #define INSN_LDI_R25_0 0x34190000 /* ldi 0,%r25 (in_syscall=0) */
74 #define INSN_LDI_R25_1 0x34190002 /* ldi 1,%r25 (in_syscall=1) */
75 #define INSN_LDI_R20 0x3414015a /* ldi __NR_rt_sigreturn,%r20 */
76 #define INSN_BLE_SR2_R0 0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
77 #define INSN_NOP 0x08000240 /* nop */
79 #define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
82 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
86 err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
87 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
88 err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
89 err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
90 err |= __get_user(regs->sar, &sc->sc_sar);
91 DBG(2,"restore_sigcontext: iaoq is 0x%#lx / 0x%#lx\n",
92 regs->iaoq[0],regs->iaoq[1]);
93 DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
98 sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
100 struct rt_sigframe __user *frame;
103 unsigned long usp = (regs->gr[30] & ~(0x01UL));
104 unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
106 compat_sigset_t compat_set;
107 struct compat_rt_sigframe __user * compat_frame;
109 if (is_compat_task())
110 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
114 /* Unwind the user stack to get the rt_sigframe structure. */
115 frame = (struct rt_sigframe __user *)
116 (usp - sigframe_size);
117 DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);
120 compat_frame = (struct compat_rt_sigframe __user *)frame;
122 if (is_compat_task()) {
123 DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
124 if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set)))
126 sigset_32to64(&set,&compat_set);
130 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
134 sigdelsetmask(&set, ~_BLOCKABLE);
135 spin_lock_irq(¤t->sighand->siglock);
136 current->blocked = set;
138 spin_unlock_irq(¤t->sighand->siglock);
140 /* Good thing we saved the old gr[30], eh? */
142 if (is_compat_task()) {
143 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
144 &compat_frame->uc.uc_mcontext);
145 // FIXME: Load upper half from register file
146 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext,
147 &compat_frame->regs, regs))
149 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
150 usp, &compat_frame->uc.uc_stack);
151 if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT)
156 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
157 &frame->uc.uc_mcontext);
158 if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
160 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
161 usp, &frame->uc.uc_stack);
162 if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
168 /* If we are on the syscall path IAOQ will not be restored, and
169 * if we are on the interrupt path we must not corrupt gr31.
172 regs->gr[31] = regs->iaoq[0];
174 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
180 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
181 si.si_signo = SIGSEGV;
183 si.si_code = SI_KERNEL;
184 si.si_pid = task_pid_vnr(current);
185 si.si_uid = current_uid();
186 si.si_addr = &frame->uc;
187 force_sig_info(SIGSEGV, &si, current);
192 * Set up a signal frame.
195 static inline void __user *
196 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
198 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
199 don't use the parameter it doesn't matter */
201 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
202 (unsigned long)ka, sp, frame_size);
204 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
205 sp = current->sas_ss_sp; /* Stacks grow up! */
207 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
208 return (void __user *) sp; /* Stacks grow up. Fun. */
212 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
215 unsigned long flags = 0;
218 if (on_sig_stack((unsigned long) sc))
219 flags |= PARISC_SC_FLAG_ONSTACK;
221 flags |= PARISC_SC_FLAG_IN_SYSCALL;
222 /* regs->iaoq is undefined in the syscall return path */
223 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
224 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
225 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
226 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
227 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
228 regs->gr[31], regs->gr[31]+4);
230 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
231 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
232 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
233 regs->iaoq[0], regs->iaoq[1]);
236 err |= __put_user(flags, &sc->sc_flags);
237 err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
238 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
239 err |= __put_user(regs->sar, &sc->sc_sar);
240 DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
246 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
247 sigset_t *set, struct pt_regs *regs, int in_syscall)
249 struct rt_sigframe __user *frame;
250 unsigned long rp, usp;
251 unsigned long haddr, sigframe_size;
254 compat_int_t compat_val;
255 struct compat_rt_sigframe __user * compat_frame;
256 compat_sigset_t compat_set;
259 usp = (regs->gr[30] & ~(0x01UL));
260 /*FIXME: frame_size parameter is unused, remove it. */
261 frame = get_sigframe(ka, usp, sizeof(*frame));
263 DBG(1,"SETUP_RT_FRAME: START\n");
264 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
269 compat_frame = (struct compat_rt_sigframe __user *)frame;
271 if (is_compat_task()) {
272 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
273 err |= copy_siginfo_to_user32(&compat_frame->info, info);
274 DBG(1,"SETUP_RT_FRAME: 1\n");
275 compat_val = (compat_int_t)current->sas_ss_sp;
276 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp);
277 DBG(1,"SETUP_RT_FRAME: 2\n");
278 compat_val = (compat_int_t)current->sas_ss_size;
279 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size);
280 DBG(1,"SETUP_RT_FRAME: 3\n");
281 compat_val = sas_ss_flags(regs->gr[30]);
282 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags);
283 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
284 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
285 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
286 &compat_frame->regs, regs, in_syscall);
287 sigset_64to32(&compat_set,set);
288 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
292 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
293 err |= copy_siginfo_to_user(&frame->info, info);
294 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
295 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
296 err |= __put_user(sas_ss_flags(regs->gr[30]),
297 &frame->uc.uc_stack.ss_flags);
298 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
299 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
300 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
301 /* FIXME: Should probably be converted aswell for the compat case */
302 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
308 /* Set up to return from userspace. If provided, use a stub
309 already in userspace. The first words of tramp are used to
310 save the previous sigrestartblock trampoline that might be
311 on the stack. We start the sigreturn trampoline at
312 SIGRESTARTBLOCK_TRAMP+X. */
313 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
314 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
315 err |= __put_user(INSN_LDI_R20,
316 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
317 err |= __put_user(INSN_BLE_SR2_R0,
318 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
319 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
322 /* Assert that we're flushing in the correct space... */
325 asm ("mfsp %%sr3,%0" : "=r" (sid));
326 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
331 flush_user_dcache_range((unsigned long) &frame->tramp[0],
332 (unsigned long) &frame->tramp[TRAMP_SIZE]);
333 flush_user_icache_range((unsigned long) &frame->tramp[0],
334 (unsigned long) &frame->tramp[TRAMP_SIZE]);
336 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
337 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
338 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
340 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
345 haddr = A(ka->sa.sa_handler);
346 /* The sa_handler may be a pointer to a function descriptor */
348 if (is_compat_task()) {
350 if (haddr & PA_PLABEL_FDESC) {
352 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
354 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
360 regs->gr[19] = fdesc.gp;
365 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
367 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
373 regs->gr[19] = fdesc.gp;
374 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
375 haddr, regs->gr[19], in_syscall);
379 /* The syscall return path will create IAOQ values from r31.
381 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
383 if (is_compat_task())
384 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
387 regs->gr[31] = haddr;
389 if (!test_thread_flag(TIF_32BIT))
393 unsigned long psw = USER_PSW;
395 if (!test_thread_flag(TIF_32BIT))
399 /* If we are singlestepping, arrange a trap to be delivered
400 when we return to userspace. Note the semantics -- we
401 should trap before the first insn in the handler is
403 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
405 if (pa_psw(current)->r) {
406 pa_psw(current)->r = 0;
412 regs->iaoq[0] = haddr | 3;
413 regs->iaoq[1] = regs->iaoq[0] + 4;
416 regs->gr[2] = rp; /* userland return pointer */
417 regs->gr[26] = sig; /* signal number */
420 if (is_compat_task()) {
421 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
422 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
426 regs->gr[25] = A(&frame->info); /* siginfo pointer */
427 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
430 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
431 regs->gr[30], sigframe_size,
432 regs->gr[30] + sigframe_size);
433 /* Raise the user stack pointer to make a proper call frame. */
434 regs->gr[30] = (A(frame) + sigframe_size);
437 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
438 current->comm, current->pid, frame, regs->gr[30],
439 regs->iaoq[0], regs->iaoq[1], rp);
444 DBG(1,"setup_rt_frame: sending SIGSEGV\n");
445 force_sigsegv(sig, current);
450 * OK, we're invoking a handler.
454 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
455 sigset_t *oldset, struct pt_regs *regs, int in_syscall)
457 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
458 sig, ka, info, oldset, regs);
460 /* Set up the stack frame */
461 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
464 spin_lock_irq(¤t->sighand->siglock);
465 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
466 if (!(ka->sa.sa_flags & SA_NODEFER))
467 sigaddset(¤t->blocked,sig);
469 spin_unlock_irq(¤t->sighand->siglock);
474 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
476 /* Check the return code */
477 switch (regs->gr[28]) {
478 case -ERESTART_RESTARTBLOCK:
479 current_thread_info()->restart_block.fn =
480 do_no_restart_syscall;
481 case -ERESTARTNOHAND:
482 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
483 regs->gr[28] = -EINTR;
487 if (!(ka->sa.sa_flags & SA_RESTART)) {
488 DBG(1,"ERESTARTSYS: putting -EINTR\n");
489 regs->gr[28] = -EINTR;
493 case -ERESTARTNOINTR:
494 /* A syscall is just a branch, so all
495 * we have to do is fiddle the return pointer.
497 regs->gr[31] -= 8; /* delayed branching */
498 /* Preserve original r28. */
499 regs->gr[28] = regs->orig_r28;
505 insert_restart_trampoline(struct pt_regs *regs)
507 switch(regs->gr[28]) {
508 case -ERESTART_RESTARTBLOCK: {
509 /* Restart the system call - no handlers present */
510 unsigned int *usp = (unsigned int *)regs->gr[30];
512 /* Setup a trampoline to restart the syscall
513 * with __NR_restart_syscall
515 * 0: <return address (orig r31)>
516 * 4: <2nd half for 64-bit>
517 * 8: ldw 0(%sp), %r31
518 * 12: be 0x100(%sr2, %r0)
519 * 16: ldi __NR_restart_syscall, %r20
522 put_user(regs->gr[31] >> 32, &usp[0]);
523 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
524 put_user(0x0fc010df, &usp[2]);
526 put_user(regs->gr[31], &usp[0]);
527 put_user(0x0fc0109f, &usp[2]);
529 put_user(0xe0008200, &usp[3]);
530 put_user(0x34140000, &usp[4]);
532 /* Stack is 64-byte aligned, and we only need
533 * to flush 1 cache line.
534 * Flushing one cacheline is cheap.
535 * "sync" on bigger (> 4 way) boxes is not.
537 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
538 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
540 regs->gr[31] = regs->gr[30] + 8;
541 /* Preserve original r28. */
542 regs->gr[28] = regs->orig_r28;
546 case -ERESTARTNOHAND:
548 case -ERESTARTNOINTR: {
549 /* Hooray for delayed branching. We don't
550 * have to restore %r20 (the system call
551 * number) because it gets loaded in the delay
552 * slot of the branch external instruction.
555 /* Preserve original r28. */
556 regs->gr[28] = regs->orig_r28;
566 * Note that 'init' is a special process: it doesn't get signals it doesn't
567 * want to handle. Thus you cannot kill init even with a SIGKILL even by
570 * We need to be able to restore the syscall arguments (r21-r26) to
571 * restart syscalls. Thus, the syscall path should save them in the
572 * pt_regs structure (it's okay to do so since they are caller-save
573 * registers). As noted below, the syscall number gets restored for
574 * us due to the magic of delayed branching.
577 do_signal(struct pt_regs *regs, long in_syscall)
580 struct k_sigaction ka;
584 DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
585 oldset, regs, regs->sr[7], in_syscall);
587 /* Everyone else checks to see if they are in kernel mode at
588 this point and exits if that's the case. I'm not sure why
589 we would be called in that case, but for some reason we
592 if (test_thread_flag(TIF_RESTORE_SIGMASK))
593 oldset = ¤t->saved_sigmask;
595 oldset = ¤t->blocked;
597 DBG(1,"do_signal: oldset %08lx / %08lx\n",
598 oldset->sig[0], oldset->sig[1]);
601 /* May need to force signal if handle_signal failed to deliver */
604 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
605 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
610 /* Restart a system call if necessary. */
612 syscall_restart(regs, &ka);
614 /* Whee! Actually deliver the signal. If the
615 delivery failed, we need to continue to iterate in
616 this loop so we can deliver the SIGSEGV... */
617 if (handle_signal(signr, &info, &ka, oldset,
619 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
621 if (test_thread_flag(TIF_RESTORE_SIGMASK))
622 clear_thread_flag(TIF_RESTORE_SIGMASK);
626 /* end of while(1) looping forever if we can't force a signal */
628 /* Did we come from a system call? */
630 insert_restart_trampoline(regs);
632 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
635 if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
636 clear_thread_flag(TIF_RESTORE_SIGMASK);
637 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL);
643 void do_notify_resume(struct pt_regs *regs, long in_syscall)
645 if (test_thread_flag(TIF_SIGPENDING) ||
646 test_thread_flag(TIF_RESTORE_SIGMASK))
647 do_signal(regs, in_syscall);
649 if (test_thread_flag(TIF_NOTIFY_RESUME)) {
650 clear_thread_flag(TIF_NOTIFY_RESUME);
651 tracehook_notify_resume(regs);
652 if (current->replacement_session_keyring)
653 key_replace_session_keyring();