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.
15 #include <linux/sched.h>
17 #include <linux/smp.h>
18 #include <linux/kernel.h>
19 #include <linux/signal.h>
20 #include <linux/errno.h>
21 #include <linux/wait.h>
22 #include <linux/ptrace.h>
23 #include <linux/tracehook.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>
40 #define DEBUG_SIG_LEVEL 2
43 #define DBG(LEVEL, ...) \
44 ((DEBUG_SIG_LEVEL >= LEVEL) \
45 ? printk(__VA_ARGS__) : (void) 0)
47 #define DBG(LEVEL, ...)
50 /* gcc will complain if a pointer is cast to an integer of different
51 * size. If you really need to do this (and we do for an ELF32 user
52 * application in an ELF64 kernel) then you have to do a cast to an
53 * integer of the same size first. The A() macro accomplishes
55 #define A(__x) ((unsigned long)(__x))
58 * Do a signal return - restore sigcontext.
61 /* Trampoline for calling rt_sigreturn() */
62 #define INSN_LDI_R25_0 0x34190000 /* ldi 0,%r25 (in_syscall=0) */
63 #define INSN_LDI_R25_1 0x34190002 /* ldi 1,%r25 (in_syscall=1) */
64 #define INSN_LDI_R20 0x3414015a /* ldi __NR_rt_sigreturn,%r20 */
65 #define INSN_BLE_SR2_R0 0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
66 #define INSN_NOP 0x08000240 /* nop */
68 #define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
71 restore_sigcontext(struct sigcontext __user
*sc
, struct pt_regs
*regs
)
75 err
|= __copy_from_user(regs
->gr
, sc
->sc_gr
, sizeof(regs
->gr
));
76 err
|= __copy_from_user(regs
->fr
, sc
->sc_fr
, sizeof(regs
->fr
));
77 err
|= __copy_from_user(regs
->iaoq
, sc
->sc_iaoq
, sizeof(regs
->iaoq
));
78 err
|= __copy_from_user(regs
->iasq
, sc
->sc_iasq
, sizeof(regs
->iasq
));
79 err
|= __get_user(regs
->sar
, &sc
->sc_sar
);
80 DBG(2,"restore_sigcontext: iaoq is %#lx / %#lx\n",
81 regs
->iaoq
[0],regs
->iaoq
[1]);
82 DBG(2,"restore_sigcontext: r28 is %ld\n", regs
->gr
[28]);
87 sys_rt_sigreturn(struct pt_regs
*regs
, int in_syscall
)
89 struct rt_sigframe __user
*frame
;
91 unsigned long usp
= (regs
->gr
[30] & ~(0x01UL
));
92 unsigned long sigframe_size
= PARISC_RT_SIGFRAME_SIZE
;
94 compat_sigset_t compat_set
;
95 struct compat_rt_sigframe __user
* compat_frame
;
98 sigframe_size
= PARISC_RT_SIGFRAME_SIZE32
;
101 current
->restart_block
.fn
= do_no_restart_syscall
;
103 /* Unwind the user stack to get the rt_sigframe structure. */
104 frame
= (struct rt_sigframe __user
*)
105 (usp
- sigframe_size
);
106 DBG(2,"sys_rt_sigreturn: frame is %p\n", frame
);
108 regs
->orig_r28
= 1; /* no restarts for sigreturn */
111 compat_frame
= (struct compat_rt_sigframe __user
*)frame
;
113 if (is_compat_task()) {
114 DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
115 if (__copy_from_user(&compat_set
, &compat_frame
->uc
.uc_sigmask
, sizeof(compat_set
)))
117 sigset_32to64(&set
,&compat_set
);
121 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
125 set_current_blocked(&set
);
127 /* Good thing we saved the old gr[30], eh? */
129 if (is_compat_task()) {
130 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
131 &compat_frame
->uc
.uc_mcontext
);
132 // FIXME: Load upper half from register file
133 if (restore_sigcontext32(&compat_frame
->uc
.uc_mcontext
,
134 &compat_frame
->regs
, regs
))
136 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
137 usp
, &compat_frame
->uc
.uc_stack
);
138 if (compat_restore_altstack(&compat_frame
->uc
.uc_stack
))
143 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
144 &frame
->uc
.uc_mcontext
);
145 if (restore_sigcontext(&frame
->uc
.uc_mcontext
, regs
))
147 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
148 usp
, &frame
->uc
.uc_stack
);
149 if (restore_altstack(&frame
->uc
.uc_stack
))
155 /* If we are on the syscall path IAOQ will not be restored, and
156 * if we are on the interrupt path we must not corrupt gr31.
159 regs
->gr
[31] = regs
->iaoq
[0];
161 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs
->iaoq
[0]);
167 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
168 force_sig(SIGSEGV
, current
);
173 * Set up a signal frame.
176 static inline void __user
*
177 get_sigframe(struct k_sigaction
*ka
, unsigned long sp
, size_t frame_size
)
179 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
180 don't use the parameter it doesn't matter */
182 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
183 (unsigned long)ka
, sp
, frame_size
);
185 /* Align alternate stack and reserve 64 bytes for the signal
186 handler's frame marker. */
187 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) != 0 && ! sas_ss_flags(sp
))
188 sp
= (current
->sas_ss_sp
+ 0x7f) & ~0x3f; /* Stacks grow up! */
190 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp
);
191 return (void __user
*) sp
; /* Stacks grow up. Fun. */
195 setup_sigcontext(struct sigcontext __user
*sc
, struct pt_regs
*regs
, int in_syscall
)
198 unsigned long flags
= 0;
201 if (on_sig_stack((unsigned long) sc
))
202 flags
|= PARISC_SC_FLAG_ONSTACK
;
204 flags
|= PARISC_SC_FLAG_IN_SYSCALL
;
205 /* regs->iaoq is undefined in the syscall return path */
206 err
|= __put_user(regs
->gr
[31], &sc
->sc_iaoq
[0]);
207 err
|= __put_user(regs
->gr
[31]+4, &sc
->sc_iaoq
[1]);
208 err
|= __put_user(regs
->sr
[3], &sc
->sc_iasq
[0]);
209 err
|= __put_user(regs
->sr
[3], &sc
->sc_iasq
[1]);
210 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
211 regs
->gr
[31], regs
->gr
[31]+4);
213 err
|= __copy_to_user(sc
->sc_iaoq
, regs
->iaoq
, sizeof(regs
->iaoq
));
214 err
|= __copy_to_user(sc
->sc_iasq
, regs
->iasq
, sizeof(regs
->iasq
));
215 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
216 regs
->iaoq
[0], regs
->iaoq
[1]);
219 err
|= __put_user(flags
, &sc
->sc_flags
);
220 err
|= __copy_to_user(sc
->sc_gr
, regs
->gr
, sizeof(regs
->gr
));
221 err
|= __copy_to_user(sc
->sc_fr
, regs
->fr
, sizeof(regs
->fr
));
222 err
|= __put_user(regs
->sar
, &sc
->sc_sar
);
223 DBG(1,"setup_sigcontext: r28 is %ld\n", regs
->gr
[28]);
229 setup_rt_frame(struct ksignal
*ksig
, sigset_t
*set
, struct pt_regs
*regs
,
232 struct rt_sigframe __user
*frame
;
233 unsigned long rp
, usp
;
234 unsigned long haddr
, sigframe_size
;
237 struct compat_rt_sigframe __user
* compat_frame
;
238 compat_sigset_t compat_set
;
241 usp
= (regs
->gr
[30] & ~(0x01UL
));
242 /*FIXME: frame_size parameter is unused, remove it. */
243 frame
= get_sigframe(&ksig
->ka
, usp
, sizeof(*frame
));
245 DBG(1,"SETUP_RT_FRAME: START\n");
246 DBG(1,"setup_rt_frame: frame %p info %p\n", frame
, ksig
->info
);
251 compat_frame
= (struct compat_rt_sigframe __user
*)frame
;
253 if (is_compat_task()) {
254 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame
->info
);
255 err
|= copy_siginfo_to_user32(&compat_frame
->info
, &ksig
->info
);
256 err
|= __compat_save_altstack( &compat_frame
->uc
.uc_stack
, regs
->gr
[30]);
257 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame
->uc
);
258 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame
->uc
.uc_mcontext
);
259 err
|= setup_sigcontext32(&compat_frame
->uc
.uc_mcontext
,
260 &compat_frame
->regs
, regs
, in_syscall
);
261 sigset_64to32(&compat_set
,set
);
262 err
|= __copy_to_user(&compat_frame
->uc
.uc_sigmask
, &compat_set
, sizeof(compat_set
));
266 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame
->info
);
267 err
|= copy_siginfo_to_user(&frame
->info
, &ksig
->info
);
268 err
|= __save_altstack(&frame
->uc
.uc_stack
, regs
->gr
[30]);
269 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame
->uc
);
270 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame
->uc
.uc_mcontext
);
271 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, regs
, in_syscall
);
272 /* FIXME: Should probably be converted as well for the compat case */
273 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
279 /* Set up to return from userspace. If provided, use a stub
280 already in userspace. The first words of tramp are used to
281 save the previous sigrestartblock trampoline that might be
282 on the stack. We start the sigreturn trampoline at
283 SIGRESTARTBLOCK_TRAMP+X. */
284 err
|= __put_user(in_syscall
? INSN_LDI_R25_1
: INSN_LDI_R25_0
,
285 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+0]);
286 err
|= __put_user(INSN_LDI_R20
,
287 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+1]);
288 err
|= __put_user(INSN_BLE_SR2_R0
,
289 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+2]);
290 err
|= __put_user(INSN_NOP
, &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+3]);
293 /* Assert that we're flushing in the correct space... */
296 asm ("mfsp %%sr3,%0" : "=r" (sid
));
297 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
302 flush_user_dcache_range((unsigned long) &frame
->tramp
[0],
303 (unsigned long) &frame
->tramp
[TRAMP_SIZE
]);
304 flush_user_icache_range((unsigned long) &frame
->tramp
[0],
305 (unsigned long) &frame
->tramp
[TRAMP_SIZE
]);
307 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
308 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
309 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
311 rp
= (unsigned long) &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
];
316 haddr
= A(ksig
->ka
.sa
.sa_handler
);
317 /* The sa_handler may be a pointer to a function descriptor */
319 if (is_compat_task()) {
321 if (haddr
& PA_PLABEL_FDESC
) {
323 Elf32_Fdesc __user
*ufdesc
= (Elf32_Fdesc __user
*)A(haddr
& ~3);
325 err
= __copy_from_user(&fdesc
, ufdesc
, sizeof(fdesc
));
331 regs
->gr
[19] = fdesc
.gp
;
336 Elf64_Fdesc __user
*ufdesc
= (Elf64_Fdesc __user
*)A(haddr
& ~3);
338 err
= __copy_from_user(&fdesc
, ufdesc
, sizeof(fdesc
));
344 regs
->gr
[19] = fdesc
.gp
;
345 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
346 haddr
, regs
->gr
[19], in_syscall
);
350 /* The syscall return path will create IAOQ values from r31.
352 sigframe_size
= PARISC_RT_SIGFRAME_SIZE
;
354 if (is_compat_task())
355 sigframe_size
= PARISC_RT_SIGFRAME_SIZE32
;
358 regs
->gr
[31] = haddr
;
360 if (!test_thread_flag(TIF_32BIT
))
364 unsigned long psw
= USER_PSW
;
366 if (!test_thread_flag(TIF_32BIT
))
370 /* If we are singlestepping, arrange a trap to be delivered
371 when we return to userspace. Note the semantics -- we
372 should trap before the first insn in the handler is
374 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
376 if (pa_psw(current
)->r
) {
377 pa_psw(current
)->r
= 0;
383 regs
->iaoq
[0] = haddr
| 3;
384 regs
->iaoq
[1] = regs
->iaoq
[0] + 4;
387 regs
->gr
[2] = rp
; /* userland return pointer */
388 regs
->gr
[26] = ksig
->sig
; /* signal number */
391 if (is_compat_task()) {
392 regs
->gr
[25] = A(&compat_frame
->info
); /* siginfo pointer */
393 regs
->gr
[24] = A(&compat_frame
->uc
); /* ucontext pointer */
397 regs
->gr
[25] = A(&frame
->info
); /* siginfo pointer */
398 regs
->gr
[24] = A(&frame
->uc
); /* ucontext pointer */
401 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
402 regs
->gr
[30], sigframe_size
,
403 regs
->gr
[30] + sigframe_size
);
404 /* Raise the user stack pointer to make a proper call frame. */
405 regs
->gr
[30] = (A(frame
) + sigframe_size
);
408 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
409 current
->comm
, current
->pid
, frame
, regs
->gr
[30],
410 regs
->iaoq
[0], regs
->iaoq
[1], rp
);
416 * OK, we're invoking a handler.
420 handle_signal(struct ksignal
*ksig
, struct pt_regs
*regs
, int in_syscall
)
423 sigset_t
*oldset
= sigmask_to_save();
425 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
426 ksig
->sig
, ksig
->ka
, ksig
->info
, oldset
, regs
);
428 /* Set up the stack frame */
429 ret
= setup_rt_frame(ksig
, oldset
, regs
, in_syscall
);
431 signal_setup_done(ret
, ksig
, test_thread_flag(TIF_SINGLESTEP
) ||
432 test_thread_flag(TIF_BLOCKSTEP
));
434 DBG(1,KERN_DEBUG
"do_signal: Exit (success), regs->gr[28] = %ld\n",
439 * Check how the syscall number gets loaded into %r20 within
440 * the delay branch in userspace and adjust as needed.
443 static void check_syscallno_in_delay_branch(struct pt_regs
*regs
)
445 u32 opcode
, source_reg
;
449 /* Usually we don't have to restore %r20 (the system call number)
450 * because it gets loaded in the delay slot of the branch external
451 * instruction via the ldi instruction.
452 * In some cases a register-to-register copy instruction might have
453 * been used instead, in which case we need to copy the syscall
454 * number into the source register before returning to userspace.
457 /* A syscall is just a branch, so all we have to do is fiddle the
458 * return pointer so that the ble instruction gets executed again.
460 regs
->gr
[31] -= 8; /* delayed branching */
462 /* Get assembler opcode of code in delay branch */
463 uaddr
= (unsigned int *) ((regs
->gr
[31] & ~3) + 4);
464 err
= get_user(opcode
, uaddr
);
468 /* Check if delay branch uses "ldi int,%r20" */
469 if ((opcode
& 0xffff0000) == 0x34140000)
470 return; /* everything ok, just return */
472 /* Check if delay branch uses "nop" */
473 if (opcode
== INSN_NOP
)
476 /* Check if delay branch uses "copy %rX,%r20" */
477 if ((opcode
& 0xffe0ffff) == 0x08000254) {
478 source_reg
= (opcode
>> 16) & 31;
479 regs
->gr
[source_reg
] = regs
->gr
[20];
483 pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
484 current
->comm
, task_pid_nr(current
), opcode
);
488 syscall_restart(struct pt_regs
*regs
, struct k_sigaction
*ka
)
492 regs
->orig_r28
= 1; /* no more restarts */
493 /* Check the return code */
494 switch (regs
->gr
[28]) {
495 case -ERESTART_RESTARTBLOCK
:
496 case -ERESTARTNOHAND
:
497 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
498 regs
->gr
[28] = -EINTR
;
502 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
503 DBG(1,"ERESTARTSYS: putting -EINTR\n");
504 regs
->gr
[28] = -EINTR
;
508 case -ERESTARTNOINTR
:
509 check_syscallno_in_delay_branch(regs
);
515 insert_restart_trampoline(struct pt_regs
*regs
)
519 regs
->orig_r28
= 1; /* no more restarts */
520 switch(regs
->gr
[28]) {
521 case -ERESTART_RESTARTBLOCK
: {
522 /* Restart the system call - no handlers present */
523 unsigned int *usp
= (unsigned int *)regs
->gr
[30];
524 unsigned long start
= (unsigned long) &usp
[2];
525 unsigned long end
= (unsigned long) &usp
[5];
528 /* Setup a trampoline to restart the syscall
529 * with __NR_restart_syscall
531 * 0: <return address (orig r31)>
532 * 4: <2nd half for 64-bit>
533 * 8: ldw 0(%sp), %r31
534 * 12: be 0x100(%sr2, %r0)
535 * 16: ldi __NR_restart_syscall, %r20
538 err
|= put_user(regs
->gr
[31] >> 32, &usp
[0]);
539 err
|= put_user(regs
->gr
[31] & 0xffffffff, &usp
[1]);
540 err
|= put_user(0x0fc010df, &usp
[2]);
542 err
|= put_user(regs
->gr
[31], &usp
[0]);
543 err
|= put_user(0x0fc0109f, &usp
[2]);
545 err
|= put_user(0xe0008200, &usp
[3]);
546 err
|= put_user(0x34140000, &usp
[4]);
550 /* flush data/instruction cache for new insns */
551 flush_user_dcache_range(start
, end
);
552 flush_user_icache_range(start
, end
);
554 regs
->gr
[31] = regs
->gr
[30] + 8;
557 case -ERESTARTNOHAND
:
559 case -ERESTARTNOINTR
:
560 check_syscallno_in_delay_branch(regs
);
568 * Note that 'init' is a special process: it doesn't get signals it doesn't
569 * want to handle. Thus you cannot kill init even with a SIGKILL even by
572 * We need to be able to restore the syscall arguments (r21-r26) to
573 * restart syscalls. Thus, the syscall path should save them in the
574 * pt_regs structure (it's okay to do so since they are caller-save
575 * registers). As noted below, the syscall number gets restored for
576 * us due to the magic of delayed branching.
579 do_signal(struct pt_regs
*regs
, long in_syscall
)
583 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
584 regs
, regs
->sr
[7], in_syscall
);
586 if (get_signal(&ksig
)) {
587 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr
, regs
->gr
[28]);
588 /* Restart a system call if necessary. */
590 syscall_restart(regs
, &ksig
.ka
);
592 handle_signal(&ksig
, regs
, in_syscall
);
596 /* Did we come from a system call? */
598 insert_restart_trampoline(regs
);
600 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
603 restore_saved_sigmask();
606 void do_notify_resume(struct pt_regs
*regs
, long in_syscall
)
608 if (test_thread_flag(TIF_SIGPENDING
))
609 do_signal(regs
, in_syscall
);
611 if (test_thread_flag(TIF_NOTIFY_RESUME
)) {
612 clear_thread_flag(TIF_NOTIFY_RESUME
);
613 tracehook_notify_resume(regs
);