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>
16 #include <linux/sched/debug.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 <linux/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, ...)
51 /* gcc will complain if a pointer is cast to an integer of different
52 * size. If you really need to do this (and we do for an ELF32 user
53 * application in an ELF64 kernel) then you have to do a cast to an
54 * integer of the same size first. The A() macro accomplishes
56 #define A(__x) ((unsigned long)(__x))
59 * Do a signal return - restore sigcontext.
62 /* Trampoline for calling rt_sigreturn() */
63 #define INSN_LDI_R25_0 0x34190000 /* ldi 0,%r25 (in_syscall=0) */
64 #define INSN_LDI_R25_1 0x34190002 /* ldi 1,%r25 (in_syscall=1) */
65 #define INSN_LDI_R20 0x3414015a /* ldi __NR_rt_sigreturn,%r20 */
66 #define INSN_BLE_SR2_R0 0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
67 #define INSN_NOP 0x08000240 /* nop */
69 #define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
72 restore_sigcontext(struct sigcontext __user
*sc
, struct pt_regs
*regs
)
76 err
|= __copy_from_user(regs
->gr
, sc
->sc_gr
, sizeof(regs
->gr
));
77 err
|= __copy_from_user(regs
->fr
, sc
->sc_fr
, sizeof(regs
->fr
));
78 err
|= __copy_from_user(regs
->iaoq
, sc
->sc_iaoq
, sizeof(regs
->iaoq
));
79 err
|= __copy_from_user(regs
->iasq
, sc
->sc_iasq
, sizeof(regs
->iasq
));
80 err
|= __get_user(regs
->sar
, &sc
->sc_sar
);
81 DBG(2,"restore_sigcontext: iaoq is %#lx / %#lx\n",
82 regs
->iaoq
[0],regs
->iaoq
[1]);
83 DBG(2,"restore_sigcontext: r28 is %ld\n", regs
->gr
[28]);
88 sys_rt_sigreturn(struct pt_regs
*regs
, int in_syscall
)
90 struct rt_sigframe __user
*frame
;
92 unsigned long usp
= (regs
->gr
[30] & ~(0x01UL
));
93 unsigned long sigframe_size
= PARISC_RT_SIGFRAME_SIZE
;
95 compat_sigset_t compat_set
;
96 struct compat_rt_sigframe __user
* compat_frame
;
99 sigframe_size
= PARISC_RT_SIGFRAME_SIZE32
;
102 current
->restart_block
.fn
= do_no_restart_syscall
;
104 /* Unwind the user stack to get the rt_sigframe structure. */
105 frame
= (struct rt_sigframe __user
*)
106 (usp
- sigframe_size
);
107 DBG(2,"sys_rt_sigreturn: frame is %p\n", frame
);
109 regs
->orig_r28
= 1; /* no restarts for sigreturn */
112 compat_frame
= (struct compat_rt_sigframe __user
*)frame
;
114 if (is_compat_task()) {
115 DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
116 if (__copy_from_user(&compat_set
, &compat_frame
->uc
.uc_sigmask
, sizeof(compat_set
)))
118 sigset_32to64(&set
,&compat_set
);
122 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
126 set_current_blocked(&set
);
128 /* Good thing we saved the old gr[30], eh? */
130 if (is_compat_task()) {
131 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
132 &compat_frame
->uc
.uc_mcontext
);
133 // FIXME: Load upper half from register file
134 if (restore_sigcontext32(&compat_frame
->uc
.uc_mcontext
,
135 &compat_frame
->regs
, regs
))
137 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
138 usp
, &compat_frame
->uc
.uc_stack
);
139 if (compat_restore_altstack(&compat_frame
->uc
.uc_stack
))
144 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
145 &frame
->uc
.uc_mcontext
);
146 if (restore_sigcontext(&frame
->uc
.uc_mcontext
, regs
))
148 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
149 usp
, &frame
->uc
.uc_stack
);
150 if (restore_altstack(&frame
->uc
.uc_stack
))
156 /* If we are on the syscall path IAOQ will not be restored, and
157 * if we are on the interrupt path we must not corrupt gr31.
160 regs
->gr
[31] = regs
->iaoq
[0];
162 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs
->iaoq
[0]);
168 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
169 force_sig(SIGSEGV
, current
);
174 * Set up a signal frame.
177 static inline void __user
*
178 get_sigframe(struct k_sigaction
*ka
, unsigned long sp
, size_t frame_size
)
180 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
181 don't use the parameter it doesn't matter */
183 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
184 (unsigned long)ka
, sp
, frame_size
);
186 /* Align alternate stack and reserve 64 bytes for the signal
187 handler's frame marker. */
188 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) != 0 && ! sas_ss_flags(sp
))
189 sp
= (current
->sas_ss_sp
+ 0x7f) & ~0x3f; /* Stacks grow up! */
191 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp
);
192 return (void __user
*) sp
; /* Stacks grow up. Fun. */
196 setup_sigcontext(struct sigcontext __user
*sc
, struct pt_regs
*regs
, int in_syscall
)
199 unsigned long flags
= 0;
202 if (on_sig_stack((unsigned long) sc
))
203 flags
|= PARISC_SC_FLAG_ONSTACK
;
205 flags
|= PARISC_SC_FLAG_IN_SYSCALL
;
206 /* regs->iaoq is undefined in the syscall return path */
207 err
|= __put_user(regs
->gr
[31], &sc
->sc_iaoq
[0]);
208 err
|= __put_user(regs
->gr
[31]+4, &sc
->sc_iaoq
[1]);
209 err
|= __put_user(regs
->sr
[3], &sc
->sc_iasq
[0]);
210 err
|= __put_user(regs
->sr
[3], &sc
->sc_iasq
[1]);
211 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
212 regs
->gr
[31], regs
->gr
[31]+4);
214 err
|= __copy_to_user(sc
->sc_iaoq
, regs
->iaoq
, sizeof(regs
->iaoq
));
215 err
|= __copy_to_user(sc
->sc_iasq
, regs
->iasq
, sizeof(regs
->iasq
));
216 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
217 regs
->iaoq
[0], regs
->iaoq
[1]);
220 err
|= __put_user(flags
, &sc
->sc_flags
);
221 err
|= __copy_to_user(sc
->sc_gr
, regs
->gr
, sizeof(regs
->gr
));
222 err
|= __copy_to_user(sc
->sc_fr
, regs
->fr
, sizeof(regs
->fr
));
223 err
|= __put_user(regs
->sar
, &sc
->sc_sar
);
224 DBG(1,"setup_sigcontext: r28 is %ld\n", regs
->gr
[28]);
230 setup_rt_frame(struct ksignal
*ksig
, sigset_t
*set
, struct pt_regs
*regs
,
233 struct rt_sigframe __user
*frame
;
234 unsigned long rp
, usp
;
235 unsigned long haddr
, sigframe_size
;
238 struct compat_rt_sigframe __user
* compat_frame
;
239 compat_sigset_t compat_set
;
242 usp
= (regs
->gr
[30] & ~(0x01UL
));
243 /*FIXME: frame_size parameter is unused, remove it. */
244 frame
= get_sigframe(&ksig
->ka
, usp
, sizeof(*frame
));
246 DBG(1,"SETUP_RT_FRAME: START\n");
247 DBG(1,"setup_rt_frame: frame %p info %p\n", frame
, ksig
->info
);
252 compat_frame
= (struct compat_rt_sigframe __user
*)frame
;
254 if (is_compat_task()) {
255 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame
->info
);
256 err
|= copy_siginfo_to_user32(&compat_frame
->info
, &ksig
->info
);
257 err
|= __compat_save_altstack( &compat_frame
->uc
.uc_stack
, regs
->gr
[30]);
258 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame
->uc
);
259 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame
->uc
.uc_mcontext
);
260 err
|= setup_sigcontext32(&compat_frame
->uc
.uc_mcontext
,
261 &compat_frame
->regs
, regs
, in_syscall
);
262 sigset_64to32(&compat_set
,set
);
263 err
|= __copy_to_user(&compat_frame
->uc
.uc_sigmask
, &compat_set
, sizeof(compat_set
));
267 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame
->info
);
268 err
|= copy_siginfo_to_user(&frame
->info
, &ksig
->info
);
269 err
|= __save_altstack(&frame
->uc
.uc_stack
, regs
->gr
[30]);
270 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame
->uc
);
271 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame
->uc
.uc_mcontext
);
272 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, regs
, in_syscall
);
273 /* FIXME: Should probably be converted as well for the compat case */
274 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
280 /* Set up to return from userspace. If provided, use a stub
281 already in userspace. The first words of tramp are used to
282 save the previous sigrestartblock trampoline that might be
283 on the stack. We start the sigreturn trampoline at
284 SIGRESTARTBLOCK_TRAMP+X. */
285 err
|= __put_user(in_syscall
? INSN_LDI_R25_1
: INSN_LDI_R25_0
,
286 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+0]);
287 err
|= __put_user(INSN_LDI_R20
,
288 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+1]);
289 err
|= __put_user(INSN_BLE_SR2_R0
,
290 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+2]);
291 err
|= __put_user(INSN_NOP
, &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+3]);
294 /* Assert that we're flushing in the correct space... */
297 asm ("mfsp %%sr3,%0" : "=r" (sid
));
298 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
303 flush_user_dcache_range((unsigned long) &frame
->tramp
[0],
304 (unsigned long) &frame
->tramp
[TRAMP_SIZE
]);
305 flush_user_icache_range((unsigned long) &frame
->tramp
[0],
306 (unsigned long) &frame
->tramp
[TRAMP_SIZE
]);
308 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
309 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
310 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
312 rp
= (unsigned long) &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
];
317 haddr
= A(ksig
->ka
.sa
.sa_handler
);
318 /* The sa_handler may be a pointer to a function descriptor */
320 if (is_compat_task()) {
322 if (haddr
& PA_PLABEL_FDESC
) {
324 Elf32_Fdesc __user
*ufdesc
= (Elf32_Fdesc __user
*)A(haddr
& ~3);
326 err
= __copy_from_user(&fdesc
, ufdesc
, sizeof(fdesc
));
332 regs
->gr
[19] = fdesc
.gp
;
337 Elf64_Fdesc __user
*ufdesc
= (Elf64_Fdesc __user
*)A(haddr
& ~3);
339 err
= __copy_from_user(&fdesc
, ufdesc
, sizeof(fdesc
));
345 regs
->gr
[19] = fdesc
.gp
;
346 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
347 haddr
, regs
->gr
[19], in_syscall
);
351 /* The syscall return path will create IAOQ values from r31.
353 sigframe_size
= PARISC_RT_SIGFRAME_SIZE
;
355 if (is_compat_task())
356 sigframe_size
= PARISC_RT_SIGFRAME_SIZE32
;
359 regs
->gr
[31] = haddr
;
361 if (!test_thread_flag(TIF_32BIT
))
365 unsigned long psw
= USER_PSW
;
367 if (!test_thread_flag(TIF_32BIT
))
371 /* If we are singlestepping, arrange a trap to be delivered
372 when we return to userspace. Note the semantics -- we
373 should trap before the first insn in the handler is
375 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
377 if (pa_psw(current
)->r
) {
378 pa_psw(current
)->r
= 0;
384 regs
->iaoq
[0] = haddr
| 3;
385 regs
->iaoq
[1] = regs
->iaoq
[0] + 4;
388 regs
->gr
[2] = rp
; /* userland return pointer */
389 regs
->gr
[26] = ksig
->sig
; /* signal number */
392 if (is_compat_task()) {
393 regs
->gr
[25] = A(&compat_frame
->info
); /* siginfo pointer */
394 regs
->gr
[24] = A(&compat_frame
->uc
); /* ucontext pointer */
398 regs
->gr
[25] = A(&frame
->info
); /* siginfo pointer */
399 regs
->gr
[24] = A(&frame
->uc
); /* ucontext pointer */
402 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
403 regs
->gr
[30], sigframe_size
,
404 regs
->gr
[30] + sigframe_size
);
405 /* Raise the user stack pointer to make a proper call frame. */
406 regs
->gr
[30] = (A(frame
) + sigframe_size
);
409 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
410 current
->comm
, current
->pid
, frame
, regs
->gr
[30],
411 regs
->iaoq
[0], regs
->iaoq
[1], rp
);
417 * OK, we're invoking a handler.
421 handle_signal(struct ksignal
*ksig
, struct pt_regs
*regs
, int in_syscall
)
424 sigset_t
*oldset
= sigmask_to_save();
426 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
427 ksig
->sig
, ksig
->ka
, ksig
->info
, oldset
, regs
);
429 /* Set up the stack frame */
430 ret
= setup_rt_frame(ksig
, oldset
, regs
, in_syscall
);
432 signal_setup_done(ret
, ksig
, test_thread_flag(TIF_SINGLESTEP
) ||
433 test_thread_flag(TIF_BLOCKSTEP
));
435 DBG(1,KERN_DEBUG
"do_signal: Exit (success), regs->gr[28] = %ld\n",
440 * Check how the syscall number gets loaded into %r20 within
441 * the delay branch in userspace and adjust as needed.
444 static void check_syscallno_in_delay_branch(struct pt_regs
*regs
)
446 u32 opcode
, source_reg
;
450 /* Usually we don't have to restore %r20 (the system call number)
451 * because it gets loaded in the delay slot of the branch external
452 * instruction via the ldi instruction.
453 * In some cases a register-to-register copy instruction might have
454 * been used instead, in which case we need to copy the syscall
455 * number into the source register before returning to userspace.
458 /* A syscall is just a branch, so all we have to do is fiddle the
459 * return pointer so that the ble instruction gets executed again.
461 regs
->gr
[31] -= 8; /* delayed branching */
463 /* Get assembler opcode of code in delay branch */
464 uaddr
= (unsigned int *) ((regs
->gr
[31] & ~3) + 4);
465 err
= get_user(opcode
, uaddr
);
469 /* Check if delay branch uses "ldi int,%r20" */
470 if ((opcode
& 0xffff0000) == 0x34140000)
471 return; /* everything ok, just return */
473 /* Check if delay branch uses "nop" */
474 if (opcode
== INSN_NOP
)
477 /* Check if delay branch uses "copy %rX,%r20" */
478 if ((opcode
& 0xffe0ffff) == 0x08000254) {
479 source_reg
= (opcode
>> 16) & 31;
480 regs
->gr
[source_reg
] = regs
->gr
[20];
484 pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
485 current
->comm
, task_pid_nr(current
), opcode
);
489 syscall_restart(struct pt_regs
*regs
, struct k_sigaction
*ka
)
493 regs
->orig_r28
= 1; /* no more restarts */
494 /* Check the return code */
495 switch (regs
->gr
[28]) {
496 case -ERESTART_RESTARTBLOCK
:
497 case -ERESTARTNOHAND
:
498 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
499 regs
->gr
[28] = -EINTR
;
503 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
504 DBG(1,"ERESTARTSYS: putting -EINTR\n");
505 regs
->gr
[28] = -EINTR
;
509 case -ERESTARTNOINTR
:
510 check_syscallno_in_delay_branch(regs
);
516 insert_restart_trampoline(struct pt_regs
*regs
)
520 regs
->orig_r28
= 1; /* no more restarts */
521 switch(regs
->gr
[28]) {
522 case -ERESTART_RESTARTBLOCK
: {
523 /* Restart the system call - no handlers present */
524 unsigned int *usp
= (unsigned int *)regs
->gr
[30];
525 unsigned long start
= (unsigned long) &usp
[2];
526 unsigned long end
= (unsigned long) &usp
[5];
529 /* Setup a trampoline to restart the syscall
530 * with __NR_restart_syscall
532 * 0: <return address (orig r31)>
533 * 4: <2nd half for 64-bit>
534 * 8: ldw 0(%sp), %r31
535 * 12: be 0x100(%sr2, %r0)
536 * 16: ldi __NR_restart_syscall, %r20
539 err
|= put_user(regs
->gr
[31] >> 32, &usp
[0]);
540 err
|= put_user(regs
->gr
[31] & 0xffffffff, &usp
[1]);
541 err
|= put_user(0x0fc010df, &usp
[2]);
543 err
|= put_user(regs
->gr
[31], &usp
[0]);
544 err
|= put_user(0x0fc0109f, &usp
[2]);
546 err
|= put_user(0xe0008200, &usp
[3]);
547 err
|= put_user(0x34140000, &usp
[4]);
551 /* flush data/instruction cache for new insns */
552 flush_user_dcache_range(start
, end
);
553 flush_user_icache_range(start
, end
);
555 regs
->gr
[31] = regs
->gr
[30] + 8;
558 case -ERESTARTNOHAND
:
560 case -ERESTARTNOINTR
:
561 check_syscallno_in_delay_branch(regs
);
569 * Note that 'init' is a special process: it doesn't get signals it doesn't
570 * want to handle. Thus you cannot kill init even with a SIGKILL even by
573 * We need to be able to restore the syscall arguments (r21-r26) to
574 * restart syscalls. Thus, the syscall path should save them in the
575 * pt_regs structure (it's okay to do so since they are caller-save
576 * registers). As noted below, the syscall number gets restored for
577 * us due to the magic of delayed branching.
580 do_signal(struct pt_regs
*regs
, long in_syscall
)
584 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
585 regs
, regs
->sr
[7], in_syscall
);
587 if (get_signal(&ksig
)) {
588 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr
, regs
->gr
[28]);
589 /* Restart a system call if necessary. */
591 syscall_restart(regs
, &ksig
.ka
);
593 handle_signal(&ksig
, regs
, in_syscall
);
597 /* Did we come from a system call? */
599 insert_restart_trampoline(regs
);
601 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
604 restore_saved_sigmask();
607 void do_notify_resume(struct pt_regs
*regs
, long in_syscall
)
609 if (test_thread_flag(TIF_SIGPENDING
))
610 do_signal(regs
, in_syscall
);
612 if (test_thread_flag(TIF_NOTIFY_RESUME
)) {
613 clear_thread_flag(TIF_NOTIFY_RESUME
);
614 tracehook_notify_resume(regs
);