1 // SPDX-License-Identifier: GPL-2.0
3 * linux/arch/parisc/kernel/signal.c: Architecture-specific signal
6 * Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
7 * Copyright (C) 2000 Linuxcare, Inc.
9 * Based on the ia64, i386, and alpha versions.
11 * Like the IA-64, we are a recent enough port (we are *starting*
12 * with glibc2.2) that we do not need to support the old non-realtime
13 * Linux signals. Therefore we don't.
16 #include <linux/sched.h>
17 #include <linux/sched/debug.h>
19 #include <linux/smp.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/tracehook.h>
26 #include <linux/unistd.h>
27 #include <linux/stddef.h>
28 #include <linux/compat.h>
29 #include <linux/elf.h>
30 #include <asm/ucontext.h>
31 #include <asm/rt_sigframe.h>
32 #include <linux/uaccess.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 */
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 struct compat_rt_sigframe __user
* compat_frame
;
97 sigframe_size
= PARISC_RT_SIGFRAME_SIZE32
;
100 current
->restart_block
.fn
= do_no_restart_syscall
;
102 /* Unwind the user stack to get the rt_sigframe structure. */
103 frame
= (struct rt_sigframe __user
*)
104 (usp
- sigframe_size
);
105 DBG(2,"sys_rt_sigreturn: frame is %p\n", frame
);
107 regs
->orig_r28
= 1; /* no restarts for sigreturn */
110 compat_frame
= (struct compat_rt_sigframe __user
*)frame
;
112 if (is_compat_task()) {
113 DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
114 if (get_compat_sigset(&set
, &compat_frame
->uc
.uc_sigmask
))
119 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
123 set_current_blocked(&set
);
125 /* Good thing we saved the old gr[30], eh? */
127 if (is_compat_task()) {
128 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
129 &compat_frame
->uc
.uc_mcontext
);
130 // FIXME: Load upper half from register file
131 if (restore_sigcontext32(&compat_frame
->uc
.uc_mcontext
,
132 &compat_frame
->regs
, regs
))
134 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
135 usp
, &compat_frame
->uc
.uc_stack
);
136 if (compat_restore_altstack(&compat_frame
->uc
.uc_stack
))
141 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
142 &frame
->uc
.uc_mcontext
);
143 if (restore_sigcontext(&frame
->uc
.uc_mcontext
, regs
))
145 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
146 usp
, &frame
->uc
.uc_stack
);
147 if (restore_altstack(&frame
->uc
.uc_stack
))
153 /* If we are on the syscall path IAOQ will not be restored, and
154 * if we are on the interrupt path we must not corrupt gr31.
157 regs
->gr
[31] = regs
->iaoq
[0];
159 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs
->iaoq
[0]);
165 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
171 * Set up a signal frame.
174 static inline void __user
*
175 get_sigframe(struct k_sigaction
*ka
, unsigned long sp
, size_t frame_size
)
177 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
178 don't use the parameter it doesn't matter */
180 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
181 (unsigned long)ka
, sp
, frame_size
);
183 /* Align alternate stack and reserve 64 bytes for the signal
184 handler's frame marker. */
185 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) != 0 && ! sas_ss_flags(sp
))
186 sp
= (current
->sas_ss_sp
+ 0x7f) & ~0x3f; /* Stacks grow up! */
188 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp
);
189 return (void __user
*) sp
; /* Stacks grow up. Fun. */
193 setup_sigcontext(struct sigcontext __user
*sc
, struct pt_regs
*regs
, int in_syscall
)
196 unsigned long flags
= 0;
199 if (on_sig_stack((unsigned long) sc
))
200 flags
|= PARISC_SC_FLAG_ONSTACK
;
202 flags
|= PARISC_SC_FLAG_IN_SYSCALL
;
203 /* regs->iaoq is undefined in the syscall return path */
204 err
|= __put_user(regs
->gr
[31], &sc
->sc_iaoq
[0]);
205 err
|= __put_user(regs
->gr
[31]+4, &sc
->sc_iaoq
[1]);
206 err
|= __put_user(regs
->sr
[3], &sc
->sc_iasq
[0]);
207 err
|= __put_user(regs
->sr
[3], &sc
->sc_iasq
[1]);
208 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
209 regs
->gr
[31], regs
->gr
[31]+4);
211 err
|= __copy_to_user(sc
->sc_iaoq
, regs
->iaoq
, sizeof(regs
->iaoq
));
212 err
|= __copy_to_user(sc
->sc_iasq
, regs
->iasq
, sizeof(regs
->iasq
));
213 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
214 regs
->iaoq
[0], regs
->iaoq
[1]);
217 err
|= __put_user(flags
, &sc
->sc_flags
);
218 err
|= __copy_to_user(sc
->sc_gr
, regs
->gr
, sizeof(regs
->gr
));
219 err
|= __copy_to_user(sc
->sc_fr
, regs
->fr
, sizeof(regs
->fr
));
220 err
|= __put_user(regs
->sar
, &sc
->sc_sar
);
221 DBG(1,"setup_sigcontext: r28 is %ld\n", regs
->gr
[28]);
227 setup_rt_frame(struct ksignal
*ksig
, sigset_t
*set
, struct pt_regs
*regs
,
230 struct rt_sigframe __user
*frame
;
231 unsigned long rp
, usp
;
232 unsigned long haddr
, sigframe_size
;
233 unsigned long start
, end
;
236 struct compat_rt_sigframe __user
* compat_frame
;
239 usp
= (regs
->gr
[30] & ~(0x01UL
));
240 /*FIXME: frame_size parameter is unused, remove it. */
241 frame
= get_sigframe(&ksig
->ka
, usp
, sizeof(*frame
));
243 DBG(1,"SETUP_RT_FRAME: START\n");
244 DBG(1,"setup_rt_frame: frame %p info %p\n", frame
, ksig
->info
);
249 compat_frame
= (struct compat_rt_sigframe __user
*)frame
;
251 if (is_compat_task()) {
252 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame
->info
);
253 err
|= copy_siginfo_to_user32(&compat_frame
->info
, &ksig
->info
);
254 err
|= __compat_save_altstack( &compat_frame
->uc
.uc_stack
, regs
->gr
[30]);
255 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame
->uc
);
256 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame
->uc
.uc_mcontext
);
257 err
|= setup_sigcontext32(&compat_frame
->uc
.uc_mcontext
,
258 &compat_frame
->regs
, regs
, in_syscall
);
259 err
|= put_compat_sigset(&compat_frame
->uc
.uc_sigmask
, set
,
260 sizeof(compat_sigset_t
));
264 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame
->info
);
265 err
|= copy_siginfo_to_user(&frame
->info
, &ksig
->info
);
266 err
|= __save_altstack(&frame
->uc
.uc_stack
, regs
->gr
[30]);
267 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame
->uc
);
268 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame
->uc
.uc_mcontext
);
269 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, regs
, in_syscall
);
270 /* FIXME: Should probably be converted as well for the compat case */
271 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
277 /* Set up to return from userspace. If provided, use a stub
278 already in userspace. The first words of tramp are used to
279 save the previous sigrestartblock trampoline that might be
280 on the stack. We start the sigreturn trampoline at
281 SIGRESTARTBLOCK_TRAMP+X. */
282 err
|= __put_user(in_syscall
? INSN_LDI_R25_1
: INSN_LDI_R25_0
,
283 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+0]);
284 err
|= __put_user(INSN_LDI_R20
,
285 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+1]);
286 err
|= __put_user(INSN_BLE_SR2_R0
,
287 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+2]);
288 err
|= __put_user(INSN_NOP
, &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+3]);
291 /* Assert that we're flushing in the correct space... */
294 asm ("mfsp %%sr3,%0" : "=r" (sid
));
295 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
300 start
= (unsigned long) &frame
->tramp
[0];
301 end
= (unsigned long) &frame
->tramp
[TRAMP_SIZE
];
302 flush_user_dcache_range_asm(start
, end
);
303 flush_user_icache_range_asm(start
, end
);
305 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
306 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
307 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
309 rp
= (unsigned long) &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
];
314 haddr
= A(ksig
->ka
.sa
.sa_handler
);
315 /* The sa_handler may be a pointer to a function descriptor */
317 if (is_compat_task()) {
319 if (haddr
& PA_PLABEL_FDESC
) {
321 Elf32_Fdesc __user
*ufdesc
= (Elf32_Fdesc __user
*)A(haddr
& ~3);
323 err
= __copy_from_user(&fdesc
, ufdesc
, sizeof(fdesc
));
329 regs
->gr
[19] = fdesc
.gp
;
334 Elf64_Fdesc __user
*ufdesc
= (Elf64_Fdesc __user
*)A(haddr
& ~3);
336 err
= __copy_from_user(&fdesc
, ufdesc
, sizeof(fdesc
));
342 regs
->gr
[19] = fdesc
.gp
;
343 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
344 haddr
, regs
->gr
[19], in_syscall
);
348 /* The syscall return path will create IAOQ values from r31.
350 sigframe_size
= PARISC_RT_SIGFRAME_SIZE
;
352 if (is_compat_task())
353 sigframe_size
= PARISC_RT_SIGFRAME_SIZE32
;
356 regs
->gr
[31] = haddr
;
358 if (!test_thread_flag(TIF_32BIT
))
362 unsigned long psw
= USER_PSW
;
364 if (!test_thread_flag(TIF_32BIT
))
368 /* If we are singlestepping, arrange a trap to be delivered
369 when we return to userspace. Note the semantics -- we
370 should trap before the first insn in the handler is
372 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
374 if (pa_psw(current
)->r
) {
375 pa_psw(current
)->r
= 0;
381 regs
->iaoq
[0] = haddr
| 3;
382 regs
->iaoq
[1] = regs
->iaoq
[0] + 4;
385 regs
->gr
[2] = rp
; /* userland return pointer */
386 regs
->gr
[26] = ksig
->sig
; /* signal number */
389 if (is_compat_task()) {
390 regs
->gr
[25] = A(&compat_frame
->info
); /* siginfo pointer */
391 regs
->gr
[24] = A(&compat_frame
->uc
); /* ucontext pointer */
395 regs
->gr
[25] = A(&frame
->info
); /* siginfo pointer */
396 regs
->gr
[24] = A(&frame
->uc
); /* ucontext pointer */
399 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
400 regs
->gr
[30], sigframe_size
,
401 regs
->gr
[30] + sigframe_size
);
402 /* Raise the user stack pointer to make a proper call frame. */
403 regs
->gr
[30] = (A(frame
) + sigframe_size
);
406 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
407 current
->comm
, current
->pid
, frame
, regs
->gr
[30],
408 regs
->iaoq
[0], regs
->iaoq
[1], rp
);
414 * OK, we're invoking a handler.
418 handle_signal(struct ksignal
*ksig
, struct pt_regs
*regs
, int in_syscall
)
421 sigset_t
*oldset
= sigmask_to_save();
423 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
424 ksig
->sig
, ksig
->ka
, ksig
->info
, oldset
, regs
);
426 /* Set up the stack frame */
427 ret
= setup_rt_frame(ksig
, oldset
, regs
, in_syscall
);
429 signal_setup_done(ret
, ksig
, test_thread_flag(TIF_SINGLESTEP
) ||
430 test_thread_flag(TIF_BLOCKSTEP
));
432 DBG(1,KERN_DEBUG
"do_signal: Exit (success), regs->gr[28] = %ld\n",
437 * Check how the syscall number gets loaded into %r20 within
438 * the delay branch in userspace and adjust as needed.
441 static void check_syscallno_in_delay_branch(struct pt_regs
*regs
)
443 u32 opcode
, source_reg
;
447 /* Usually we don't have to restore %r20 (the system call number)
448 * because it gets loaded in the delay slot of the branch external
449 * instruction via the ldi instruction.
450 * In some cases a register-to-register copy instruction might have
451 * been used instead, in which case we need to copy the syscall
452 * number into the source register before returning to userspace.
455 /* A syscall is just a branch, so all we have to do is fiddle the
456 * return pointer so that the ble instruction gets executed again.
458 regs
->gr
[31] -= 8; /* delayed branching */
460 /* Get assembler opcode of code in delay branch */
461 uaddr
= (unsigned int *) ((regs
->gr
[31] & ~3) + 4);
462 err
= get_user(opcode
, uaddr
);
466 /* Check if delay branch uses "ldi int,%r20" */
467 if ((opcode
& 0xffff0000) == 0x34140000)
468 return; /* everything ok, just return */
470 /* Check if delay branch uses "nop" */
471 if (opcode
== INSN_NOP
)
474 /* Check if delay branch uses "copy %rX,%r20" */
475 if ((opcode
& 0xffe0ffff) == 0x08000254) {
476 source_reg
= (opcode
>> 16) & 31;
477 regs
->gr
[source_reg
] = regs
->gr
[20];
481 pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
482 current
->comm
, task_pid_nr(current
), opcode
);
486 syscall_restart(struct pt_regs
*regs
, struct k_sigaction
*ka
)
490 regs
->orig_r28
= 1; /* no more restarts */
491 /* Check the return code */
492 switch (regs
->gr
[28]) {
493 case -ERESTART_RESTARTBLOCK
:
494 case -ERESTARTNOHAND
:
495 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
496 regs
->gr
[28] = -EINTR
;
500 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
501 DBG(1,"ERESTARTSYS: putting -EINTR\n");
502 regs
->gr
[28] = -EINTR
;
506 case -ERESTARTNOINTR
:
507 check_syscallno_in_delay_branch(regs
);
513 insert_restart_trampoline(struct pt_regs
*regs
)
517 regs
->orig_r28
= 1; /* no more restarts */
518 switch(regs
->gr
[28]) {
519 case -ERESTART_RESTARTBLOCK
: {
520 /* Restart the system call - no handlers present */
521 unsigned int *usp
= (unsigned int *)regs
->gr
[30];
522 unsigned long start
= (unsigned long) &usp
[2];
523 unsigned long end
= (unsigned long) &usp
[5];
526 /* Setup a trampoline to restart the syscall
527 * with __NR_restart_syscall
529 * 0: <return address (orig r31)>
530 * 4: <2nd half for 64-bit>
531 * 8: ldw 0(%sp), %r31
532 * 12: be 0x100(%sr2, %r0)
533 * 16: ldi __NR_restart_syscall, %r20
536 err
|= put_user(regs
->gr
[31] >> 32, &usp
[0]);
537 err
|= put_user(regs
->gr
[31] & 0xffffffff, &usp
[1]);
538 err
|= put_user(0x0fc010df, &usp
[2]);
540 err
|= put_user(regs
->gr
[31], &usp
[0]);
541 err
|= put_user(0x0fc0109f, &usp
[2]);
543 err
|= put_user(0xe0008200, &usp
[3]);
544 err
|= put_user(0x34140000, &usp
[4]);
548 /* flush data/instruction cache for new insns */
549 flush_user_dcache_range_asm(start
, end
);
550 flush_user_icache_range_asm(start
, end
);
552 regs
->gr
[31] = regs
->gr
[30] + 8;
555 case -ERESTARTNOHAND
:
557 case -ERESTARTNOINTR
:
558 check_syscallno_in_delay_branch(regs
);
566 * Note that 'init' is a special process: it doesn't get signals it doesn't
567 * want to handle. Thus you cannot kill init even with a SIGKILL even by
570 * We need to be able to restore the syscall arguments (r21-r26) to
571 * restart syscalls. Thus, the syscall path should save them in the
572 * pt_regs structure (it's okay to do so since they are caller-save
573 * registers). As noted below, the syscall number gets restored for
574 * us due to the magic of delayed branching.
577 do_signal(struct pt_regs
*regs
, long in_syscall
)
581 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
582 regs
, regs
->sr
[7], in_syscall
);
584 if (get_signal(&ksig
)) {
585 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr
, regs
->gr
[28]);
586 /* Restart a system call if necessary. */
588 syscall_restart(regs
, &ksig
.ka
);
590 handle_signal(&ksig
, regs
, in_syscall
);
594 /* Did we come from a system call? */
596 insert_restart_trampoline(regs
);
598 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
601 restore_saved_sigmask();
604 void do_notify_resume(struct pt_regs
*regs
, long in_syscall
)
606 if (test_thread_flag(TIF_SIGPENDING
) ||
607 test_thread_flag(TIF_NOTIFY_SIGNAL
))
608 do_signal(regs
, in_syscall
);
610 if (test_thread_flag(TIF_NOTIFY_RESUME
))
611 tracehook_notify_resume(regs
);