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. */
357 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
358 &frame->tramp[SIGRETURN_TRAMP+0]);
359 err |= __put_user(INSN_LDI_R20, &frame->tramp[SIGRETURN_TRAMP+1]);
360 err |= __put_user(INSN_BLE_SR2_R0, &frame->tramp[SIGRETURN_TRAMP+2]);
361 err |= __put_user(INSN_NOP, &frame->tramp[SIGRETURN_TRAMP+3]);
364 /* Assert that we're flushing in the correct space... */
367 asm ("mfsp %%sr3,%0" : "=r" (sid));
368 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
373 flush_user_dcache_range((unsigned long) &frame->tramp[SIGRETURN_TRAMP],
374 (unsigned long) &frame->tramp[TRAMP_SIZE]);
375 flush_user_icache_range((unsigned long) &frame->tramp[SIGRETURN_TRAMP],
376 (unsigned long) &frame->tramp[TRAMP_SIZE]);
378 rp = (unsigned long) &frame->tramp[SIGRETURN_TRAMP];
383 haddr = A(ka->sa.sa_handler);
384 /* The sa_handler may be a pointer to a function descriptor */
386 if(personality(current->personality) == PER_LINUX32) {
388 if (haddr & PA_PLABEL_FDESC) {
390 Elf32_Fdesc *ufdesc = (Elf32_Fdesc *)A(haddr & ~3);
392 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
398 regs->gr[19] = fdesc.gp;
403 Elf64_Fdesc *ufdesc = (Elf64_Fdesc *)A(haddr & ~3);
405 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
411 regs->gr[19] = fdesc.gp;
412 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
413 haddr, regs->gr[19], in_syscall);
417 /* The syscall return path will create IAOQ values from r31.
419 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
421 if(personality(current->personality) == PER_LINUX32)
422 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
425 regs->gr[31] = haddr;
427 if(personality(current->personality) == PER_LINUX)
431 unsigned long psw = USER_PSW;
433 if(personality(current->personality) == PER_LINUX)
438 regs->iaoq[0] = haddr | 3;
439 regs->iaoq[1] = regs->iaoq[0] + 4;
442 regs->gr[2] = rp; /* userland return pointer */
443 regs->gr[26] = sig; /* signal number */
446 if(personality(current->personality) == PER_LINUX32){
447 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
448 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
452 regs->gr[25] = A(&frame->info); /* siginfo pointer */
453 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
456 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
457 regs->gr[30], sigframe_size,
458 regs->gr[30] + sigframe_size);
459 /* Raise the user stack pointer to make a proper call frame. */
460 regs->gr[30] = (A(frame) + sigframe_size);
463 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
464 current->comm, current->pid, frame, regs->gr[30],
465 regs->iaoq[0], regs->iaoq[1], rp);
470 DBG(1,"setup_rt_frame: sending SIGSEGV\n");
472 ka->sa.sa_handler = SIG_DFL;
473 si.si_signo = SIGSEGV;
475 si.si_code = SI_KERNEL;
476 si.si_pid = current->pid;
477 si.si_uid = current->uid;
479 force_sig_info(SIGSEGV, &si, current);
484 * OK, we're invoking a handler.
488 handle_signal(unsigned long sig, siginfo_t *info, sigset_t *oldset,
489 struct pt_regs *regs, int in_syscall)
491 struct k_sigaction *ka = ¤t->sighand->action[sig-1];
493 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
494 sig, ka, info, oldset, regs);
496 /* Set up the stack frame */
497 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
500 if (ka->sa.sa_flags & SA_ONESHOT)
501 ka->sa.sa_handler = SIG_DFL;
503 if (!(ka->sa.sa_flags & SA_NODEFER)) {
504 spin_lock_irq(¤t->sighand->siglock);
505 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask);
506 sigaddset(¤t->blocked,sig);
508 spin_unlock_irq(¤t->sighand->siglock);
514 * Note that 'init' is a special process: it doesn't get signals it doesn't
515 * want to handle. Thus you cannot kill init even with a SIGKILL even by
518 * We need to be able to restore the syscall arguments (r21-r26) to
519 * restart syscalls. Thus, the syscall path should save them in the
520 * pt_regs structure (it's okay to do so since they are caller-save
521 * registers). As noted below, the syscall number gets restored for
522 * us due to the magic of delayed branching.
526 do_signal(sigset_t *oldset, struct pt_regs *regs, int in_syscall)
529 struct k_sigaction *ka;
532 DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
533 oldset, regs, regs->sr[7], in_syscall);
535 /* Everyone else checks to see if they are in kernel mode at
536 this point and exits if that's the case. I'm not sure why
537 we would be called in that case, but for some reason we
541 oldset = ¤t->blocked;
543 DBG(1,"do_signal: oldset %08lx / %08lx\n",
544 oldset->sig[0], oldset->sig[1]);
547 signr = get_signal_to_deliver(&info, regs, NULL);
548 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
551 /* Restart a system call if necessary. */
553 /* Check the return code */
554 switch (regs->gr[28]) {
555 case -ERESTART_RESTARTBLOCK:
556 current_thread_info()->restart_block.fn = do_no_restart_syscall;
557 case -ERESTARTNOHAND:
558 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
559 regs->gr[28] = -EINTR;
563 ka = ¤t->sighand->action[signr-1];
564 if (!(ka->sa.sa_flags & SA_RESTART)) {
565 DBG(1,"ERESTARTSYS: putting -EINTR\n");
566 regs->gr[28] = -EINTR;
570 case -ERESTARTNOINTR:
571 /* A syscall is just a branch, so all
572 we have to do is fiddle the return
574 regs->gr[31] -= 8; /* delayed branching */
575 /* Preserve original r28. */
576 regs->gr[28] = regs->orig_r28;
580 /* Whee! Actually deliver the signal. If the
581 delivery failed, we need to continue to iterate in
582 this loop so we can deliver the SIGSEGV... */
583 if (handle_signal(signr, &info, oldset, regs, in_syscall)) {
584 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
590 /* Did we come from a system call? */
592 /* Restart the system call - no handlers present */
593 if (regs->gr[28] == -ERESTART_RESTARTBLOCK) {
594 unsigned int *usp = (unsigned int *)regs->gr[30];
596 /* Setup a trampoline to restart the syscall
597 * with __NR_restart_syscall
599 * 0: <return address (orig r31)>
600 * 4: <2nd half for 64-bit>
601 * 8: ldw 0(%sp), %r31
602 * 12: be 0x100(%sr2, %r0)
603 * 16: ldi __NR_restart_syscall, %r20
606 put_user(regs->gr[31], &usp[0]);
607 put_user(0x0fc0109f, &usp[2]);
609 put_user(regs->gr[31] >> 32, &usp[0]);
610 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
611 put_user(0x0fc010df, &usp[2]);
613 put_user(0xe0008200, &usp[3]);
614 put_user(0x34140000, &usp[4]);
616 /* Stack is 64-byte aligned, and we only
617 * need to flush 1 cache line */
618 asm("fdc 0(%%sr3, %0)\n"
621 : : "r"(regs->gr[30]));
623 regs->gr[31] = regs->gr[30] + 8;
624 /* Preserve original r28. */
625 regs->gr[28] = regs->orig_r28;
626 } else if (regs->gr[28] == -ERESTARTNOHAND ||
627 regs->gr[28] == -ERESTARTSYS ||
628 regs->gr[28] == -ERESTARTNOINTR) {
629 /* Hooray for delayed branching. We don't
630 have to restore %r20 (the system call
631 number) because it gets loaded in the delay
632 slot of the branch external instruction. */
634 /* Preserve original r28. */
635 regs->gr[28] = regs->orig_r28;
639 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",