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/pgalloc.h>
34 #include <asm/cacheflush.h>
35 #include <asm/asm-offsets.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, ...)
52 /* gcc will complain if a pointer is cast to an integer of different
53 * size. If you really need to do this (and we do for an ELF32 user
54 * application in an ELF64 kernel) then you have to do a cast to an
55 * integer of the same size first. The A() macro accomplishes
57 #define A(__x) ((unsigned long)(__x))
60 * Do a signal return - restore sigcontext.
63 /* Trampoline for calling rt_sigreturn() */
64 #define INSN_LDI_R25_0 0x34190000 /* ldi 0,%r25 (in_syscall=0) */
65 #define INSN_LDI_R25_1 0x34190002 /* ldi 1,%r25 (in_syscall=1) */
66 #define INSN_LDI_R20 0x3414015a /* ldi __NR_rt_sigreturn,%r20 */
67 #define INSN_BLE_SR2_R0 0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */
68 #define INSN_NOP 0x08000240 /* nop */
70 #define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
73 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
77 err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
78 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
79 err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
80 err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
81 err |= __get_user(regs->sar, &sc->sc_sar);
82 DBG(2,"restore_sigcontext: iaoq is %#lx / %#lx\n",
83 regs->iaoq[0],regs->iaoq[1]);
84 DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]);
89 sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
91 struct rt_sigframe __user *frame;
93 unsigned long usp = (regs->gr[30] & ~(0x01UL));
94 unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
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 (get_compat_sigset(&set, &compat_frame->uc.uc_sigmask))
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;
235 unsigned long start, end;
238 struct compat_rt_sigframe __user * compat_frame;
241 usp = (regs->gr[30] & ~(0x01UL));
243 if (is_compat_task()) {
244 /* The gcc alloca implementation leaves garbage in the upper 32 bits of sp */
245 usp = (compat_uint_t)usp;
248 /*FIXME: frame_size parameter is unused, remove it. */
249 frame = get_sigframe(&ksig->ka, usp, sizeof(*frame));
251 DBG(1,"SETUP_RT_FRAME: START\n");
252 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, ksig->info);
257 compat_frame = (struct compat_rt_sigframe __user *)frame;
259 if (is_compat_task()) {
260 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
261 err |= copy_siginfo_to_user32(&compat_frame->info, &ksig->info);
262 err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
263 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
264 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
265 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
266 &compat_frame->regs, regs, in_syscall);
267 err |= put_compat_sigset(&compat_frame->uc.uc_sigmask, set,
268 sizeof(compat_sigset_t));
272 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
273 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
274 err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
275 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
276 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
277 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
278 /* FIXME: Should probably be converted as well for the compat case */
279 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
285 /* Set up to return from userspace. If provided, use a stub
286 already in userspace. The first words of tramp are used to
287 save the previous sigrestartblock trampoline that might be
288 on the stack. We start the sigreturn trampoline at
289 SIGRESTARTBLOCK_TRAMP+X. */
290 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
291 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
292 err |= __put_user(INSN_LDI_R20,
293 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
294 err |= __put_user(INSN_BLE_SR2_R0,
295 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
296 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
299 /* Assert that we're flushing in the correct space... */
302 asm ("mfsp %%sr3,%0" : "=r" (sid));
303 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
308 start = (unsigned long) &frame->tramp[0];
309 end = (unsigned long) &frame->tramp[TRAMP_SIZE];
310 flush_user_dcache_range_asm(start, end);
311 flush_user_icache_range_asm(start, end);
313 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
314 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
315 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
317 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
322 haddr = A(ksig->ka.sa.sa_handler);
323 /* The sa_handler may be a pointer to a function descriptor */
325 if (is_compat_task()) {
327 if (haddr & PA_PLABEL_FDESC) {
329 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
331 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
337 regs->gr[19] = fdesc.gp;
342 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
344 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
350 regs->gr[19] = fdesc.gp;
351 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
352 haddr, regs->gr[19], in_syscall);
356 /* The syscall return path will create IAOQ values from r31.
358 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
360 if (is_compat_task())
361 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
364 regs->gr[31] = haddr;
366 if (!test_thread_flag(TIF_32BIT))
370 unsigned long psw = USER_PSW;
372 if (!test_thread_flag(TIF_32BIT))
376 /* If we are singlestepping, arrange a trap to be delivered
377 when we return to userspace. Note the semantics -- we
378 should trap before the first insn in the handler is
380 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
382 if (pa_psw(current)->r) {
383 pa_psw(current)->r = 0;
389 regs->iaoq[0] = haddr | 3;
390 regs->iaoq[1] = regs->iaoq[0] + 4;
393 regs->gr[2] = rp; /* userland return pointer */
394 regs->gr[26] = ksig->sig; /* signal number */
397 if (is_compat_task()) {
398 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
399 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
403 regs->gr[25] = A(&frame->info); /* siginfo pointer */
404 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
407 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
408 regs->gr[30], sigframe_size,
409 regs->gr[30] + sigframe_size);
410 /* Raise the user stack pointer to make a proper call frame. */
411 regs->gr[30] = (A(frame) + sigframe_size);
414 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
415 current->comm, current->pid, frame, regs->gr[30],
416 regs->iaoq[0], regs->iaoq[1], rp);
422 * OK, we're invoking a handler.
426 handle_signal(struct ksignal *ksig, struct pt_regs *regs, int in_syscall)
429 sigset_t *oldset = sigmask_to_save();
431 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
432 ksig->sig, ksig->ka, ksig->info, oldset, regs);
434 /* Set up the stack frame */
435 ret = setup_rt_frame(ksig, oldset, regs, in_syscall);
437 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP) ||
438 test_thread_flag(TIF_BLOCKSTEP));
440 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
445 * Check how the syscall number gets loaded into %r20 within
446 * the delay branch in userspace and adjust as needed.
449 static void check_syscallno_in_delay_branch(struct pt_regs *regs)
451 u32 opcode, source_reg;
455 /* Usually we don't have to restore %r20 (the system call number)
456 * because it gets loaded in the delay slot of the branch external
457 * instruction via the ldi instruction.
458 * In some cases a register-to-register copy instruction might have
459 * been used instead, in which case we need to copy the syscall
460 * number into the source register before returning to userspace.
463 /* A syscall is just a branch, so all we have to do is fiddle the
464 * return pointer so that the ble instruction gets executed again.
466 regs->gr[31] -= 8; /* delayed branching */
468 /* Get assembler opcode of code in delay branch */
469 uaddr = (unsigned int *) ((regs->gr[31] & ~3) + 4);
470 err = get_user(opcode, uaddr);
474 /* Check if delay branch uses "ldi int,%r20" */
475 if ((opcode & 0xffff0000) == 0x34140000)
476 return; /* everything ok, just return */
478 /* Check if delay branch uses "nop" */
479 if (opcode == INSN_NOP)
482 /* Check if delay branch uses "copy %rX,%r20" */
483 if ((opcode & 0xffe0ffff) == 0x08000254) {
484 source_reg = (opcode >> 16) & 31;
485 regs->gr[source_reg] = regs->gr[20];
489 pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
490 current->comm, task_pid_nr(current), opcode);
494 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
498 regs->orig_r28 = 1; /* no more restarts */
499 /* Check the return code */
500 switch (regs->gr[28]) {
501 case -ERESTART_RESTARTBLOCK:
502 case -ERESTARTNOHAND:
503 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
504 regs->gr[28] = -EINTR;
508 if (!(ka->sa.sa_flags & SA_RESTART)) {
509 DBG(1,"ERESTARTSYS: putting -EINTR\n");
510 regs->gr[28] = -EINTR;
514 case -ERESTARTNOINTR:
515 check_syscallno_in_delay_branch(regs);
521 insert_restart_trampoline(struct pt_regs *regs)
525 regs->orig_r28 = 1; /* no more restarts */
526 switch(regs->gr[28]) {
527 case -ERESTART_RESTARTBLOCK: {
528 /* Restart the system call - no handlers present */
529 unsigned int *usp = (unsigned int *)regs->gr[30];
530 unsigned long start = (unsigned long) &usp[2];
531 unsigned long end = (unsigned long) &usp[5];
534 /* Setup a trampoline to restart the syscall
535 * with __NR_restart_syscall
537 * 0: <return address (orig r31)>
538 * 4: <2nd half for 64-bit>
539 * 8: ldw 0(%sp), %r31
540 * 12: be 0x100(%sr2, %r0)
541 * 16: ldi __NR_restart_syscall, %r20
544 err |= put_user(regs->gr[31] >> 32, &usp[0]);
545 err |= put_user(regs->gr[31] & 0xffffffff, &usp[1]);
546 err |= put_user(0x0fc010df, &usp[2]);
548 err |= put_user(regs->gr[31], &usp[0]);
549 err |= put_user(0x0fc0109f, &usp[2]);
551 err |= put_user(0xe0008200, &usp[3]);
552 err |= put_user(0x34140000, &usp[4]);
556 /* flush data/instruction cache for new insns */
557 flush_user_dcache_range_asm(start, end);
558 flush_user_icache_range_asm(start, end);
560 regs->gr[31] = regs->gr[30] + 8;
563 case -ERESTARTNOHAND:
565 case -ERESTARTNOINTR:
566 check_syscallno_in_delay_branch(regs);
574 * Note that 'init' is a special process: it doesn't get signals it doesn't
575 * want to handle. Thus you cannot kill init even with a SIGKILL even by
578 * We need to be able to restore the syscall arguments (r21-r26) to
579 * restart syscalls. Thus, the syscall path should save them in the
580 * pt_regs structure (it's okay to do so since they are caller-save
581 * registers). As noted below, the syscall number gets restored for
582 * us due to the magic of delayed branching.
585 do_signal(struct pt_regs *regs, long in_syscall)
589 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
590 regs, regs->sr[7], in_syscall);
592 if (get_signal(&ksig)) {
593 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
594 /* Restart a system call if necessary. */
596 syscall_restart(regs, &ksig.ka);
598 handle_signal(&ksig, regs, in_syscall);
602 /* Did we come from a system call? */
604 insert_restart_trampoline(regs);
606 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
609 restore_saved_sigmask();
612 void do_notify_resume(struct pt_regs *regs, long in_syscall)
614 if (test_thread_flag(TIF_SIGPENDING))
615 do_signal(regs, in_syscall);
617 if (test_thread_flag(TIF_NOTIFY_RESUME)) {
618 clear_thread_flag(TIF_NOTIFY_RESUME);
619 tracehook_notify_resume(regs);