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/smp_lock.h>
20 #include <linux/kernel.h>
21 #include <linux/signal.h>
22 #include <linux/errno.h>
23 #include <linux/wait.h>
24 #include <linux/ptrace.h>
25 #include <linux/unistd.h>
26 #include <linux/stddef.h>
27 #include <linux/compat.h>
28 #include <linux/elf.h>
29 #include <linux/personality.h>
30 #include <asm/ucontext.h>
31 #include <asm/rt_sigframe.h>
32 #include <asm/uaccess.h>
33 #include <asm/pgalloc.h>
34 #include <asm/cacheflush.h>
37 #include <linux/compat.h>
42 #define DEBUG_SIG_LEVEL 2
45 #define DBG(LEVEL, ...) \
46 ((DEBUG_SIG_LEVEL >= LEVEL) \
47 ? printk(__VA_ARGS__) : (void) 0)
49 #define DBG(LEVEL, ...)
53 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
55 /* gcc will complain if a pointer is cast to an integer of different
56 * size. If you really need to do this (and we do for an ELF32 user
57 * application in an ELF64 kernel) then you have to do a cast to an
58 * integer of the same size first. The A() macro accomplishes
60 #define A(__x) ((unsigned long)(__x))
62 int do_signal(sigset_t *oldset, struct pt_regs *regs, int in_syscall);
65 * Atomically swap in the new signal mask, and wait for a signal.
72 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, struct pt_regs *regs)
74 sigset_t saveset, newset;
76 compat_sigset_t newset32;
78 if(personality(current->personality) == PER_LINUX32){
79 /* XXX: Don't preclude handling different sized sigset_t's. */
80 if (sigsetsize != sizeof(compat_sigset_t))
82 if (copy_from_user(&newset32, (compat_sigset_t *)unewset, sizeof(newset32)))
84 sigset_32to64(&newset,&newset32);
89 /* XXX: Don't preclude handling different sized sigset_t's. */
90 if (sigsetsize != sizeof(sigset_t))
93 if (copy_from_user(&newset, unewset, sizeof(newset)))
97 sigdelsetmask(&newset, ~_BLOCKABLE);
99 spin_lock_irq(¤t->sighand->siglock);
100 saveset = current->blocked;
101 current->blocked = newset;
103 spin_unlock_irq(¤t->sighand->siglock);
105 regs->gr[28] = -EINTR;
107 current->state = TASK_INTERRUPTIBLE;
109 if (do_signal(&saveset, regs, 1))
115 * Do a signal return - restore sigcontext.
118 /* Trampoline for calling rt_sigreturn() */
119 #define INSN_LDI_R25_0 0x34190000 /* ldi 0,%r25 (in_syscall=0) */
120 #define INSN_LDI_R25_1 0x34190002 /* ldi 1,%r25 (in_syscall=1) */
121 #define INSN_LDI_R20 0x3414015a /* ldi __NR_rt_sigreturn,%r20 */
122 #define INSN_BLE_SR2_R0 0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
123 #define INSN_NOP 0x08000240 /* nop */
125 #define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
128 restore_sigcontext(struct sigcontext *sc, struct pt_regs *regs)
132 err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
133 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
134 err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
135 err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
136 err |= __get_user(regs->sar, &sc->sc_sar);
137 DBG(2,"restore_sigcontext: iaoq is 0x%#lx / 0x%#lx\n",
138 regs->iaoq[0],regs->iaoq[1]);
139 DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
144 sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
146 struct rt_sigframe *frame;
149 unsigned long usp = (regs->gr[30] & ~(0x01UL));
150 unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
152 compat_sigset_t compat_set;
153 struct compat_rt_sigframe * compat_frame;
155 if(personality(current->personality) == PER_LINUX32)
156 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
160 /* Unwind the user stack to get the rt_sigframe structure. */
161 frame = (struct rt_sigframe *)
162 (usp - sigframe_size);
163 DBG(2,"sys_rt_sigreturn: frame is %p\n", frame);
166 compat_frame = (struct compat_rt_sigframe *)frame;
168 if(personality(current->personality) == PER_LINUX32){
169 DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
170 if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set)))
172 sigset_32to64(&set,&compat_set);
176 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
180 sigdelsetmask(&set, ~_BLOCKABLE);
181 spin_lock_irq(¤t->sighand->siglock);
182 current->blocked = set;
184 spin_unlock_irq(¤t->sighand->siglock);
186 /* Good thing we saved the old gr[30], eh? */
188 if(personality(current->personality) == PER_LINUX32){
189 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
190 &compat_frame->uc.uc_mcontext);
191 // FIXME: Load upper half from register file
192 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext,
193 &compat_frame->regs, regs))
195 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
196 usp, &compat_frame->uc.uc_stack);
197 if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT)
202 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
203 &frame->uc.uc_mcontext);
204 if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
206 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
207 usp, &frame->uc.uc_stack);
208 if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT)
214 /* If we are on the syscall path IAOQ will not be restored, and
215 * if we are on the interrupt path we must not corrupt gr31.
218 regs->gr[31] = regs->iaoq[0];
220 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
226 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
227 si.si_signo = SIGSEGV;
229 si.si_code = SI_KERNEL;
230 si.si_pid = current->pid;
231 si.si_uid = current->uid;
232 si.si_addr = &frame->uc;
233 force_sig_info(SIGSEGV, &si, current);
238 * Set up a signal frame.
242 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
244 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
245 don't use the parameter it doesn't matter */
247 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
248 (unsigned long)ka, sp, frame_size);
250 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! on_sig_stack(sp))
251 sp = current->sas_ss_sp; /* Stacks grow up! */
253 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
254 return (void *) sp; /* Stacks grow up. Fun. */
258 setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs, int in_syscall)
261 unsigned long flags = 0;
264 if (on_sig_stack((unsigned long) sc))
265 flags |= PARISC_SC_FLAG_ONSTACK;
267 flags |= PARISC_SC_FLAG_IN_SYSCALL;
268 /* regs->iaoq is undefined in the syscall return path */
269 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
270 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
271 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
272 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
273 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
274 regs->gr[31], regs->gr[31]+4);
276 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
277 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
278 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
279 regs->iaoq[0], regs->iaoq[1]);
282 err |= __put_user(flags, &sc->sc_flags);
283 err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
284 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
285 err |= __put_user(regs->sar, &sc->sc_sar);
286 DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
292 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
293 sigset_t *set, struct pt_regs *regs, int in_syscall)
295 struct rt_sigframe *frame;
296 unsigned long rp, usp;
297 unsigned long haddr, sigframe_size;
301 compat_int_t compat_val;
302 struct compat_rt_sigframe * compat_frame;
303 compat_sigset_t compat_set;
306 usp = (regs->gr[30] & ~(0x01UL));
307 /*FIXME: frame_size parameter is unused, remove it. */
308 frame = get_sigframe(ka, usp, sizeof(*frame));
310 DBG(1,"SETUP_RT_FRAME: START\n");
311 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
316 compat_frame = (struct compat_rt_sigframe *)frame;
318 if(personality(current->personality) == PER_LINUX32) {
319 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
320 err |= compat_copy_siginfo_to_user(&compat_frame->info, info);
321 DBG(1,"SETUP_RT_FRAME: 1\n");
322 compat_val = (compat_int_t)current->sas_ss_sp;
323 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp);
324 DBG(1,"SETUP_RT_FRAME: 2\n");
325 compat_val = (compat_int_t)current->sas_ss_size;
326 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size);
327 DBG(1,"SETUP_RT_FRAME: 3\n");
328 compat_val = sas_ss_flags(regs->gr[30]);
329 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags);
330 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
331 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
332 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
333 &compat_frame->regs, regs, in_syscall);
334 sigset_64to32(&compat_set,set);
335 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
339 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
340 err |= copy_siginfo_to_user(&frame->info, info);
341 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
342 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
343 err |= __put_user(sas_ss_flags(regs->gr[30]),
344 &frame->uc.uc_stack.ss_flags);
345 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
346 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
347 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
348 /* FIXME: Should probably be converted aswell for the compat case */
349 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
355 /* Set up to return from userspace. If provided, use a stub
356 already in userspace. The first words of tramp are used to
357 save the previous sigrestartblock trampoline that might be
358 on the stack. We start the sigreturn trampoline at
359 SIGRESTARTBLOCK_TRAMP+X. */
360 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
361 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
362 err |= __put_user(INSN_LDI_R20,
363 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
364 err |= __put_user(INSN_BLE_SR2_R0,
365 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
366 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
369 /* Assert that we're flushing in the correct space... */
372 asm ("mfsp %%sr3,%0" : "=r" (sid));
373 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
378 flush_user_dcache_range((unsigned long) &frame->tramp[0],
379 (unsigned long) &frame->tramp[TRAMP_SIZE]);
380 flush_user_icache_range((unsigned long) &frame->tramp[0],
381 (unsigned long) &frame->tramp[TRAMP_SIZE]);
383 /* TRAMP Words 0-4, Lenght 5 = SIGRESTARTBLOCK_TRAMP
384 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
385 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
387 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
392 haddr = A(ka->sa.sa_handler);
393 /* The sa_handler may be a pointer to a function descriptor */
395 if(personality(current->personality) == PER_LINUX32) {
397 if (haddr & PA_PLABEL_FDESC) {
399 Elf32_Fdesc *ufdesc = (Elf32_Fdesc *)A(haddr & ~3);
401 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
407 regs->gr[19] = fdesc.gp;
412 Elf64_Fdesc *ufdesc = (Elf64_Fdesc *)A(haddr & ~3);
414 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
420 regs->gr[19] = fdesc.gp;
421 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
422 haddr, regs->gr[19], in_syscall);
426 /* The syscall return path will create IAOQ values from r31.
428 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
430 if(personality(current->personality) == PER_LINUX32)
431 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
434 regs->gr[31] = haddr;
436 if(personality(current->personality) == PER_LINUX)
440 unsigned long psw = USER_PSW;
442 if(personality(current->personality) == PER_LINUX)
447 regs->iaoq[0] = haddr | 3;
448 regs->iaoq[1] = regs->iaoq[0] + 4;
451 regs->gr[2] = rp; /* userland return pointer */
452 regs->gr[26] = sig; /* signal number */
455 if(personality(current->personality) == PER_LINUX32){
456 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
457 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
461 regs->gr[25] = A(&frame->info); /* siginfo pointer */
462 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
465 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
466 regs->gr[30], sigframe_size,
467 regs->gr[30] + sigframe_size);
468 /* Raise the user stack pointer to make a proper call frame. */
469 regs->gr[30] = (A(frame) + sigframe_size);
472 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
473 current->comm, current->pid, frame, regs->gr[30],
474 regs->iaoq[0], regs->iaoq[1], rp);
479 DBG(1,"setup_rt_frame: sending SIGSEGV\n");
481 ka->sa.sa_handler = SIG_DFL;
482 si.si_signo = SIGSEGV;
484 si.si_code = SI_KERNEL;
485 si.si_pid = current->pid;
486 si.si_uid = current->uid;
488 force_sig_info(SIGSEGV, &si, current);
493 * OK, we're invoking a handler.
497 handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
498 struct pt_regs *regs, int in_syscall)
500 struct k_sigaction *ka = ¤t->sighand->action[sig-1];
502 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
503 sig, ka, info, oldset, regs);
505 /* Set up the stack frame */
506 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
509 if (ka->sa.sa_flags & SA_ONESHOT)
510 ka->sa.sa_handler = SIG_DFL;
512 if (!(ka->sa.sa_flags & SA_NODEFER)) {
513 spin_lock_irq(¤t->sighand->siglock);
514 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
515 sigaddset(¤t->blocked,sig);
517 spin_unlock_irq(¤t->sighand->siglock);
523 * Note that 'init' is a special process: it doesn't get signals it doesn't
524 * want to handle. Thus you cannot kill init even with a SIGKILL even by
527 * We need to be able to restore the syscall arguments (r21-r26) to
528 * restart syscalls. Thus, the syscall path should save them in the
529 * pt_regs structure (it's okay to do so since they are caller-save
530 * registers). As noted below, the syscall number gets restored for
531 * us due to the magic of delayed branching.
535 do_signal(sigset_t *oldset, struct pt_regs *regs, int in_syscall)
538 struct k_sigaction *ka;
541 DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
542 oldset, regs, regs->sr[7], in_syscall);
544 /* Everyone else checks to see if they are in kernel mode at
545 this point and exits if that's the case. I'm not sure why
546 we would be called in that case, but for some reason we
550 oldset = ¤t->blocked;
552 DBG(1,"do_signal: oldset %08lx / %08lx\n",
553 oldset->sig[0], oldset->sig[1]);
556 signr = get_signal_to_deliver(&info, regs, NULL);
557 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
560 /* Restart a system call if necessary. */
562 /* Check the return code */
563 switch (regs->gr[28]) {
564 case -ERESTART_RESTARTBLOCK:
565 current_thread_info()->restart_block.fn = do_no_restart_syscall;
566 case -ERESTARTNOHAND:
567 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
568 regs->gr[28] = -EINTR;
572 ka = ¤t->sighand->action[signr-1];
573 if (!(ka->sa.sa_flags & SA_RESTART)) {
574 DBG(1,"ERESTARTSYS: putting -EINTR\n");
575 regs->gr[28] = -EINTR;
579 case -ERESTARTNOINTR:
580 /* A syscall is just a branch, so all
581 we have to do is fiddle the return
583 regs->gr[31] -= 8; /* delayed branching */
584 /* Preserve original r28. */
585 regs->gr[28] = regs->orig_r28;
589 /* Whee! Actually deliver the signal. If the
590 delivery failed, we need to continue to iterate in
591 this loop so we can deliver the SIGSEGV... */
592 if (handle_signal(signr, &info, oldset, regs, in_syscall)) {
593 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
599 /* Did we come from a system call? */
601 /* Restart the system call - no handlers present */
602 if (regs->gr[28] == -ERESTART_RESTARTBLOCK) {
603 unsigned int *usp = (unsigned int *)regs->gr[30];
605 /* Setup a trampoline to restart the syscall
606 * with __NR_restart_syscall
608 * 0: <return address (orig r31)>
609 * 4: <2nd half for 64-bit>
610 * 8: ldw 0(%sp), %r31
611 * 12: be 0x100(%sr2, %r0)
612 * 16: ldi __NR_restart_syscall, %r20
615 put_user(regs->gr[31], &usp[0]);
616 put_user(0x0fc0109f, &usp[2]);
618 put_user(regs->gr[31] >> 32, &usp[0]);
619 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
620 put_user(0x0fc010df, &usp[2]);
622 put_user(0xe0008200, &usp[3]);
623 put_user(0x34140000, &usp[4]);
625 /* Stack is 64-byte aligned, and we only
626 * need to flush 1 cache line */
627 asm("fdc 0(%%sr3, %0)\n"
630 : : "r"(regs->gr[30]));
632 regs->gr[31] = regs->gr[30] + 8;
633 /* Preserve original r28. */
634 regs->gr[28] = regs->orig_r28;
635 } else if (regs->gr[28] == -ERESTARTNOHAND ||
636 regs->gr[28] == -ERESTARTSYS ||
637 regs->gr[28] == -ERESTARTNOINTR) {
638 /* Hooray for delayed branching. We don't
639 have to restore %r20 (the system call
640 number) because it gets loaded in the delay
641 slot of the branch external instruction. */
643 /* Preserve original r28. */
644 regs->gr[28] = regs->orig_r28;
648 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",