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));
241 if (is_compat_task()) {
242 /* The gcc alloca implementation leaves garbage in the upper 32 bits of sp */
243 usp = (compat_uint_t)usp;
246 /*FIXME: frame_size parameter is unused, remove it. */
247 frame = get_sigframe(&ksig->ka, usp, sizeof(*frame));
249 DBG(1,"SETUP_RT_FRAME: START\n");
250 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, ksig->info);
255 compat_frame = (struct compat_rt_sigframe __user *)frame;
257 if (is_compat_task()) {
258 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
259 err |= copy_siginfo_to_user32(&compat_frame->info, &ksig->info);
260 err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
261 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
262 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
263 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
264 &compat_frame->regs, regs, in_syscall);
265 err |= put_compat_sigset(&compat_frame->uc.uc_sigmask, set,
266 sizeof(compat_sigset_t));
270 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
271 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
272 err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
273 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
274 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
275 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
276 /* FIXME: Should probably be converted as well for the compat case */
277 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
283 /* Set up to return from userspace. If provided, use a stub
284 already in userspace. The first words of tramp are used to
285 save the previous sigrestartblock trampoline that might be
286 on the stack. We start the sigreturn trampoline at
287 SIGRESTARTBLOCK_TRAMP+X. */
288 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
289 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
290 err |= __put_user(INSN_LDI_R20,
291 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
292 err |= __put_user(INSN_BLE_SR2_R0,
293 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
294 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
297 /* Assert that we're flushing in the correct space... */
300 asm ("mfsp %%sr3,%0" : "=r" (sid));
301 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
306 start = (unsigned long) &frame->tramp[0];
307 end = (unsigned long) &frame->tramp[TRAMP_SIZE];
308 flush_user_dcache_range_asm(start, end);
309 flush_user_icache_range_asm(start, end);
311 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
312 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
313 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
315 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
320 haddr = A(ksig->ka.sa.sa_handler);
321 /* The sa_handler may be a pointer to a function descriptor */
323 if (is_compat_task()) {
325 if (haddr & PA_PLABEL_FDESC) {
327 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
329 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
335 regs->gr[19] = fdesc.gp;
340 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
342 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
348 regs->gr[19] = fdesc.gp;
349 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
350 haddr, regs->gr[19], in_syscall);
354 /* The syscall return path will create IAOQ values from r31.
356 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
358 if (is_compat_task())
359 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
362 regs->gr[31] = haddr;
364 if (!test_thread_flag(TIF_32BIT))
368 unsigned long psw = USER_PSW;
370 if (!test_thread_flag(TIF_32BIT))
374 /* If we are singlestepping, arrange a trap to be delivered
375 when we return to userspace. Note the semantics -- we
376 should trap before the first insn in the handler is
378 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
380 if (pa_psw(current)->r) {
381 pa_psw(current)->r = 0;
387 regs->iaoq[0] = haddr | 3;
388 regs->iaoq[1] = regs->iaoq[0] + 4;
391 regs->gr[2] = rp; /* userland return pointer */
392 regs->gr[26] = ksig->sig; /* signal number */
395 if (is_compat_task()) {
396 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
397 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
401 regs->gr[25] = A(&frame->info); /* siginfo pointer */
402 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
405 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
406 regs->gr[30], sigframe_size,
407 regs->gr[30] + sigframe_size);
408 /* Raise the user stack pointer to make a proper call frame. */
409 regs->gr[30] = (A(frame) + sigframe_size);
412 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
413 current->comm, current->pid, frame, regs->gr[30],
414 regs->iaoq[0], regs->iaoq[1], rp);
420 * OK, we're invoking a handler.
424 handle_signal(struct ksignal *ksig, struct pt_regs *regs, int in_syscall)
427 sigset_t *oldset = sigmask_to_save();
429 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
430 ksig->sig, ksig->ka, ksig->info, oldset, regs);
432 /* Set up the stack frame */
433 ret = setup_rt_frame(ksig, oldset, regs, in_syscall);
435 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP) ||
436 test_thread_flag(TIF_BLOCKSTEP));
438 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
443 * Check how the syscall number gets loaded into %r20 within
444 * the delay branch in userspace and adjust as needed.
447 static void check_syscallno_in_delay_branch(struct pt_regs *regs)
449 u32 opcode, source_reg;
453 /* Usually we don't have to restore %r20 (the system call number)
454 * because it gets loaded in the delay slot of the branch external
455 * instruction via the ldi instruction.
456 * In some cases a register-to-register copy instruction might have
457 * been used instead, in which case we need to copy the syscall
458 * number into the source register before returning to userspace.
461 /* A syscall is just a branch, so all we have to do is fiddle the
462 * return pointer so that the ble instruction gets executed again.
464 regs->gr[31] -= 8; /* delayed branching */
466 /* Get assembler opcode of code in delay branch */
467 uaddr = (unsigned int *) ((regs->gr[31] & ~3) + 4);
468 err = get_user(opcode, uaddr);
472 /* Check if delay branch uses "ldi int,%r20" */
473 if ((opcode & 0xffff0000) == 0x34140000)
474 return; /* everything ok, just return */
476 /* Check if delay branch uses "nop" */
477 if (opcode == INSN_NOP)
480 /* Check if delay branch uses "copy %rX,%r20" */
481 if ((opcode & 0xffe0ffff) == 0x08000254) {
482 source_reg = (opcode >> 16) & 31;
483 regs->gr[source_reg] = regs->gr[20];
487 pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
488 current->comm, task_pid_nr(current), opcode);
492 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
496 regs->orig_r28 = 1; /* no more restarts */
497 /* Check the return code */
498 switch (regs->gr[28]) {
499 case -ERESTART_RESTARTBLOCK:
500 case -ERESTARTNOHAND:
501 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
502 regs->gr[28] = -EINTR;
506 if (!(ka->sa.sa_flags & SA_RESTART)) {
507 DBG(1,"ERESTARTSYS: putting -EINTR\n");
508 regs->gr[28] = -EINTR;
512 case -ERESTARTNOINTR:
513 check_syscallno_in_delay_branch(regs);
519 insert_restart_trampoline(struct pt_regs *regs)
523 regs->orig_r28 = 1; /* no more restarts */
524 switch(regs->gr[28]) {
525 case -ERESTART_RESTARTBLOCK: {
526 /* Restart the system call - no handlers present */
527 unsigned int *usp = (unsigned int *)regs->gr[30];
528 unsigned long start = (unsigned long) &usp[2];
529 unsigned long end = (unsigned long) &usp[5];
532 /* Setup a trampoline to restart the syscall
533 * with __NR_restart_syscall
535 * 0: <return address (orig r31)>
536 * 4: <2nd half for 64-bit>
537 * 8: ldw 0(%sp), %r31
538 * 12: be 0x100(%sr2, %r0)
539 * 16: ldi __NR_restart_syscall, %r20
542 err |= put_user(regs->gr[31] >> 32, &usp[0]);
543 err |= put_user(regs->gr[31] & 0xffffffff, &usp[1]);
544 err |= put_user(0x0fc010df, &usp[2]);
546 err |= put_user(regs->gr[31], &usp[0]);
547 err |= put_user(0x0fc0109f, &usp[2]);
549 err |= put_user(0xe0008200, &usp[3]);
550 err |= put_user(0x34140000, &usp[4]);
554 /* flush data/instruction cache for new insns */
555 flush_user_dcache_range_asm(start, end);
556 flush_user_icache_range_asm(start, end);
558 regs->gr[31] = regs->gr[30] + 8;
561 case -ERESTARTNOHAND:
563 case -ERESTARTNOINTR:
564 check_syscallno_in_delay_branch(regs);
572 * Note that 'init' is a special process: it doesn't get signals it doesn't
573 * want to handle. Thus you cannot kill init even with a SIGKILL even by
576 * We need to be able to restore the syscall arguments (r21-r26) to
577 * restart syscalls. Thus, the syscall path should save them in the
578 * pt_regs structure (it's okay to do so since they are caller-save
579 * registers). As noted below, the syscall number gets restored for
580 * us due to the magic of delayed branching.
583 do_signal(struct pt_regs *regs, long in_syscall)
587 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
588 regs, regs->sr[7], in_syscall);
590 if (get_signal(&ksig)) {
591 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
592 /* Restart a system call if necessary. */
594 syscall_restart(regs, &ksig.ka);
596 handle_signal(&ksig, regs, in_syscall);
600 /* Did we come from a system call? */
602 insert_restart_trampoline(regs);
604 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
607 restore_saved_sigmask();
610 void do_notify_resume(struct pt_regs *regs, long in_syscall)
612 if (test_thread_flag(TIF_SIGPENDING) ||
613 test_thread_flag(TIF_NOTIFY_SIGNAL))
614 do_signal(regs, in_syscall);
616 if (test_thread_flag(TIF_NOTIFY_RESUME))
617 tracehook_notify_resume(regs);