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/tracehook.h>
25 #include <linux/unistd.h>
26 #include <linux/stddef.h>
27 #include <linux/compat.h>
28 #include <linux/elf.h>
29 #include <asm/ucontext.h>
30 #include <asm/rt_sigframe.h>
31 #include <asm/uaccess.h>
32 #include <asm/pgalloc.h>
33 #include <asm/cacheflush.h>
34 #include <asm/asm-offsets.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;
102 unsigned long usp = (regs->gr[30] & ~(0x01UL));
103 unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
105 compat_sigset_t compat_set;
106 struct compat_rt_sigframe __user * compat_frame;
108 if (is_compat_task())
109 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
112 current_thread_info()->restart_block.fn = do_no_restart_syscall;
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 set_current_blocked(&set);
137 /* Good thing we saved the old gr[30], eh? */
139 if (is_compat_task()) {
140 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
141 &compat_frame->uc.uc_mcontext);
142 // FIXME: Load upper half from register file
143 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext,
144 &compat_frame->regs, regs))
146 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
147 usp, &compat_frame->uc.uc_stack);
148 if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT)
153 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
154 &frame->uc.uc_mcontext);
155 if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
157 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
158 usp, &frame->uc.uc_stack);
159 if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
165 /* If we are on the syscall path IAOQ will not be restored, and
166 * if we are on the interrupt path we must not corrupt gr31.
169 regs->gr[31] = regs->iaoq[0];
171 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
177 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
178 force_sig(SIGSEGV, current);
183 * Set up a signal frame.
186 static inline void __user *
187 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
189 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
190 don't use the parameter it doesn't matter */
192 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
193 (unsigned long)ka, sp, frame_size);
195 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
196 sp = current->sas_ss_sp; /* Stacks grow up! */
198 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
199 return (void __user *) sp; /* Stacks grow up. Fun. */
203 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
206 unsigned long flags = 0;
209 if (on_sig_stack((unsigned long) sc))
210 flags |= PARISC_SC_FLAG_ONSTACK;
212 flags |= PARISC_SC_FLAG_IN_SYSCALL;
213 /* regs->iaoq is undefined in the syscall return path */
214 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
215 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
216 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
217 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
218 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
219 regs->gr[31], regs->gr[31]+4);
221 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
222 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
223 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
224 regs->iaoq[0], regs->iaoq[1]);
227 err |= __put_user(flags, &sc->sc_flags);
228 err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
229 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
230 err |= __put_user(regs->sar, &sc->sc_sar);
231 DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
237 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
238 sigset_t *set, struct pt_regs *regs, int in_syscall)
240 struct rt_sigframe __user *frame;
241 unsigned long rp, usp;
242 unsigned long haddr, sigframe_size;
245 compat_int_t compat_val;
246 struct compat_rt_sigframe __user * compat_frame;
247 compat_sigset_t compat_set;
250 usp = (regs->gr[30] & ~(0x01UL));
251 /*FIXME: frame_size parameter is unused, remove it. */
252 frame = get_sigframe(ka, usp, sizeof(*frame));
254 DBG(1,"SETUP_RT_FRAME: START\n");
255 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
260 compat_frame = (struct compat_rt_sigframe __user *)frame;
262 if (is_compat_task()) {
263 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
264 err |= copy_siginfo_to_user32(&compat_frame->info, info);
265 DBG(1,"SETUP_RT_FRAME: 1\n");
266 compat_val = (compat_int_t)current->sas_ss_sp;
267 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp);
268 DBG(1,"SETUP_RT_FRAME: 2\n");
269 compat_val = (compat_int_t)current->sas_ss_size;
270 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size);
271 DBG(1,"SETUP_RT_FRAME: 3\n");
272 compat_val = sas_ss_flags(regs->gr[30]);
273 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags);
274 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
275 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
276 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
277 &compat_frame->regs, regs, in_syscall);
278 sigset_64to32(&compat_set,set);
279 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
283 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
284 err |= copy_siginfo_to_user(&frame->info, info);
285 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
286 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
287 err |= __put_user(sas_ss_flags(regs->gr[30]),
288 &frame->uc.uc_stack.ss_flags);
289 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
290 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
291 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
292 /* FIXME: Should probably be converted as well for the compat case */
293 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
299 /* Set up to return from userspace. If provided, use a stub
300 already in userspace. The first words of tramp are used to
301 save the previous sigrestartblock trampoline that might be
302 on the stack. We start the sigreturn trampoline at
303 SIGRESTARTBLOCK_TRAMP+X. */
304 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
305 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
306 err |= __put_user(INSN_LDI_R20,
307 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
308 err |= __put_user(INSN_BLE_SR2_R0,
309 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
310 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
313 /* Assert that we're flushing in the correct space... */
316 asm ("mfsp %%sr3,%0" : "=r" (sid));
317 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
322 flush_user_dcache_range((unsigned long) &frame->tramp[0],
323 (unsigned long) &frame->tramp[TRAMP_SIZE]);
324 flush_user_icache_range((unsigned long) &frame->tramp[0],
325 (unsigned long) &frame->tramp[TRAMP_SIZE]);
327 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
328 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
329 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
331 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
336 haddr = A(ka->sa.sa_handler);
337 /* The sa_handler may be a pointer to a function descriptor */
339 if (is_compat_task()) {
341 if (haddr & PA_PLABEL_FDESC) {
343 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
345 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
351 regs->gr[19] = fdesc.gp;
356 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
358 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
364 regs->gr[19] = fdesc.gp;
365 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
366 haddr, regs->gr[19], in_syscall);
370 /* The syscall return path will create IAOQ values from r31.
372 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
374 if (is_compat_task())
375 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
378 regs->gr[31] = haddr;
380 if (!test_thread_flag(TIF_32BIT))
384 unsigned long psw = USER_PSW;
386 if (!test_thread_flag(TIF_32BIT))
390 /* If we are singlestepping, arrange a trap to be delivered
391 when we return to userspace. Note the semantics -- we
392 should trap before the first insn in the handler is
394 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
396 if (pa_psw(current)->r) {
397 pa_psw(current)->r = 0;
403 regs->iaoq[0] = haddr | 3;
404 regs->iaoq[1] = regs->iaoq[0] + 4;
407 regs->gr[2] = rp; /* userland return pointer */
408 regs->gr[26] = sig; /* signal number */
411 if (is_compat_task()) {
412 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
413 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
417 regs->gr[25] = A(&frame->info); /* siginfo pointer */
418 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
421 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
422 regs->gr[30], sigframe_size,
423 regs->gr[30] + sigframe_size);
424 /* Raise the user stack pointer to make a proper call frame. */
425 regs->gr[30] = (A(frame) + sigframe_size);
428 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
429 current->comm, current->pid, frame, regs->gr[30],
430 regs->iaoq[0], regs->iaoq[1], rp);
435 DBG(1,"setup_rt_frame: sending SIGSEGV\n");
436 force_sigsegv(sig, current);
441 * OK, we're invoking a handler.
445 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
446 struct pt_regs *regs, int in_syscall)
448 sigset_t *oldset = sigmask_to_save();
449 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
450 sig, ka, info, oldset, regs);
452 /* Set up the stack frame */
453 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
456 block_sigmask(ka, sig);
458 tracehook_signal_handler(sig, info, ka, regs,
459 test_thread_flag(TIF_SINGLESTEP) ||
460 test_thread_flag(TIF_BLOCKSTEP));
462 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
469 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
471 /* Check the return code */
472 switch (regs->gr[28]) {
473 case -ERESTART_RESTARTBLOCK:
474 case -ERESTARTNOHAND:
475 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
476 regs->gr[28] = -EINTR;
480 if (!(ka->sa.sa_flags & SA_RESTART)) {
481 DBG(1,"ERESTARTSYS: putting -EINTR\n");
482 regs->gr[28] = -EINTR;
486 case -ERESTARTNOINTR:
487 /* A syscall is just a branch, so all
488 * we have to do is fiddle the return pointer.
490 regs->gr[31] -= 8; /* delayed branching */
491 /* Preserve original r28. */
492 regs->gr[28] = regs->orig_r28;
498 insert_restart_trampoline(struct pt_regs *regs)
500 switch(regs->gr[28]) {
501 case -ERESTART_RESTARTBLOCK: {
502 /* Restart the system call - no handlers present */
503 unsigned int *usp = (unsigned int *)regs->gr[30];
505 /* Setup a trampoline to restart the syscall
506 * with __NR_restart_syscall
508 * 0: <return address (orig r31)>
509 * 4: <2nd half for 64-bit>
510 * 8: ldw 0(%sp), %r31
511 * 12: be 0x100(%sr2, %r0)
512 * 16: ldi __NR_restart_syscall, %r20
515 put_user(regs->gr[31] >> 32, &usp[0]);
516 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
517 put_user(0x0fc010df, &usp[2]);
519 put_user(regs->gr[31], &usp[0]);
520 put_user(0x0fc0109f, &usp[2]);
522 put_user(0xe0008200, &usp[3]);
523 put_user(0x34140000, &usp[4]);
525 /* Stack is 64-byte aligned, and we only need
526 * to flush 1 cache line.
527 * Flushing one cacheline is cheap.
528 * "sync" on bigger (> 4 way) boxes is not.
530 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
531 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
533 regs->gr[31] = regs->gr[30] + 8;
534 /* Preserve original r28. */
535 regs->gr[28] = regs->orig_r28;
539 case -ERESTARTNOHAND:
541 case -ERESTARTNOINTR: {
542 /* Hooray for delayed branching. We don't
543 * have to restore %r20 (the system call
544 * number) because it gets loaded in the delay
545 * slot of the branch external instruction.
548 /* Preserve original r28. */
549 regs->gr[28] = regs->orig_r28;
559 * Note that 'init' is a special process: it doesn't get signals it doesn't
560 * want to handle. Thus you cannot kill init even with a SIGKILL even by
563 * We need to be able to restore the syscall arguments (r21-r26) to
564 * restart syscalls. Thus, the syscall path should save them in the
565 * pt_regs structure (it's okay to do so since they are caller-save
566 * registers). As noted below, the syscall number gets restored for
567 * us due to the magic of delayed branching.
570 do_signal(struct pt_regs *regs, long in_syscall)
573 struct k_sigaction ka;
576 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
577 regs, regs->sr[7], in_syscall);
579 /* Everyone else checks to see if they are in kernel mode at
580 this point and exits if that's the case. I'm not sure why
581 we would be called in that case, but for some reason we
584 /* May need to force signal if handle_signal failed to deliver */
586 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
587 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
592 /* Restart a system call if necessary. */
594 syscall_restart(regs, &ka);
596 /* Whee! Actually deliver the signal. If the
597 delivery failed, we need to continue to iterate in
598 this loop so we can deliver the SIGSEGV... */
599 if (handle_signal(signr, &info, &ka, regs, in_syscall))
602 /* end of while(1) looping forever if we can't force a signal */
604 /* Did we come from a system call? */
606 insert_restart_trampoline(regs);
608 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
611 restore_saved_sigmask();
614 void do_notify_resume(struct pt_regs *regs, long in_syscall)
616 if (test_thread_flag(TIF_SIGPENDING) ||
617 test_thread_flag(TIF_RESTORE_SIGMASK))
618 do_signal(regs, in_syscall);
620 if (test_thread_flag(TIF_NOTIFY_RESUME)) {
621 clear_thread_flag(TIF_NOTIFY_RESUME);
622 tracehook_notify_resume(regs);