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 sigset_t
*oldset
, struct pt_regs
*regs
, int in_syscall
)
448 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
449 sig
, ka
, info
, oldset
, regs
);
451 /* Set up the stack frame */
452 if (!setup_rt_frame(sig
, ka
, info
, oldset
, regs
, in_syscall
))
455 block_sigmask(ka
, sig
);
457 tracehook_signal_handler(sig
, info
, ka
, regs
,
458 test_thread_flag(TIF_SINGLESTEP
) ||
459 test_thread_flag(TIF_BLOCKSTEP
));
465 syscall_restart(struct pt_regs
*regs
, struct k_sigaction
*ka
)
467 /* Check the return code */
468 switch (regs
->gr
[28]) {
469 case -ERESTART_RESTARTBLOCK
:
470 case -ERESTARTNOHAND
:
471 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
472 regs
->gr
[28] = -EINTR
;
476 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
477 DBG(1,"ERESTARTSYS: putting -EINTR\n");
478 regs
->gr
[28] = -EINTR
;
482 case -ERESTARTNOINTR
:
483 /* A syscall is just a branch, so all
484 * we have to do is fiddle the return pointer.
486 regs
->gr
[31] -= 8; /* delayed branching */
487 /* Preserve original r28. */
488 regs
->gr
[28] = regs
->orig_r28
;
494 insert_restart_trampoline(struct pt_regs
*regs
)
496 switch(regs
->gr
[28]) {
497 case -ERESTART_RESTARTBLOCK
: {
498 /* Restart the system call - no handlers present */
499 unsigned int *usp
= (unsigned int *)regs
->gr
[30];
501 /* Setup a trampoline to restart the syscall
502 * with __NR_restart_syscall
504 * 0: <return address (orig r31)>
505 * 4: <2nd half for 64-bit>
506 * 8: ldw 0(%sp), %r31
507 * 12: be 0x100(%sr2, %r0)
508 * 16: ldi __NR_restart_syscall, %r20
511 put_user(regs
->gr
[31] >> 32, &usp
[0]);
512 put_user(regs
->gr
[31] & 0xffffffff, &usp
[1]);
513 put_user(0x0fc010df, &usp
[2]);
515 put_user(regs
->gr
[31], &usp
[0]);
516 put_user(0x0fc0109f, &usp
[2]);
518 put_user(0xe0008200, &usp
[3]);
519 put_user(0x34140000, &usp
[4]);
521 /* Stack is 64-byte aligned, and we only need
522 * to flush 1 cache line.
523 * Flushing one cacheline is cheap.
524 * "sync" on bigger (> 4 way) boxes is not.
526 flush_user_dcache_range(regs
->gr
[30], regs
->gr
[30] + 4);
527 flush_user_icache_range(regs
->gr
[30], regs
->gr
[30] + 4);
529 regs
->gr
[31] = regs
->gr
[30] + 8;
530 /* Preserve original r28. */
531 regs
->gr
[28] = regs
->orig_r28
;
535 case -ERESTARTNOHAND
:
537 case -ERESTARTNOINTR
: {
538 /* Hooray for delayed branching. We don't
539 * have to restore %r20 (the system call
540 * number) because it gets loaded in the delay
541 * slot of the branch external instruction.
544 /* Preserve original r28. */
545 regs
->gr
[28] = regs
->orig_r28
;
555 * Note that 'init' is a special process: it doesn't get signals it doesn't
556 * want to handle. Thus you cannot kill init even with a SIGKILL even by
559 * We need to be able to restore the syscall arguments (r21-r26) to
560 * restart syscalls. Thus, the syscall path should save them in the
561 * pt_regs structure (it's okay to do so since they are caller-save
562 * registers). As noted below, the syscall number gets restored for
563 * us due to the magic of delayed branching.
566 do_signal(struct pt_regs
*regs
, long in_syscall
)
569 struct k_sigaction ka
;
573 DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n",
574 oldset
, regs
, regs
->sr
[7], in_syscall
);
576 /* Everyone else checks to see if they are in kernel mode at
577 this point and exits if that's the case. I'm not sure why
578 we would be called in that case, but for some reason we
581 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
582 oldset
= ¤t
->saved_sigmask
;
584 oldset
= ¤t
->blocked
;
586 DBG(1,"do_signal: oldset %08lx / %08lx\n",
587 oldset
->sig
[0], oldset
->sig
[1]);
590 /* May need to force signal if handle_signal failed to deliver */
593 signr
= get_signal_to_deliver(&info
, &ka
, regs
, NULL
);
594 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr
, regs
->gr
[28]);
599 /* Restart a system call if necessary. */
601 syscall_restart(regs
, &ka
);
603 /* Whee! Actually deliver the signal. If the
604 delivery failed, we need to continue to iterate in
605 this loop so we can deliver the SIGSEGV... */
606 if (handle_signal(signr
, &info
, &ka
, oldset
,
608 DBG(1,KERN_DEBUG
"do_signal: Exit (success), regs->gr[28] = %ld\n",
610 if (test_thread_flag(TIF_RESTORE_SIGMASK
))
611 clear_thread_flag(TIF_RESTORE_SIGMASK
);
615 /* end of while(1) looping forever if we can't force a signal */
617 /* Did we come from a system call? */
619 insert_restart_trampoline(regs
);
621 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
624 if (test_thread_flag(TIF_RESTORE_SIGMASK
)) {
625 clear_thread_flag(TIF_RESTORE_SIGMASK
);
626 sigprocmask(SIG_SETMASK
, ¤t
->saved_sigmask
, NULL
);
632 void do_notify_resume(struct pt_regs
*regs
, long in_syscall
)
634 if (test_thread_flag(TIF_SIGPENDING
) ||
635 test_thread_flag(TIF_RESTORE_SIGMASK
))
636 do_signal(regs
, in_syscall
);
638 if (test_thread_flag(TIF_NOTIFY_RESUME
)) {
639 clear_thread_flag(TIF_NOTIFY_RESUME
);
640 tracehook_notify_resume(regs
);
641 if (current
->replacement_session_keyring
)
642 key_replace_session_keyring();