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 */
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 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 (get_compat_sigset(&set
, &compat_frame
->uc
.uc_sigmask
))
120 if (__copy_from_user(&set
, &frame
->uc
.uc_sigmask
, sizeof(set
)))
124 set_current_blocked(&set
);
126 /* Good thing we saved the old gr[30], eh? */
128 if (is_compat_task()) {
129 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
130 &compat_frame
->uc
.uc_mcontext
);
131 // FIXME: Load upper half from register file
132 if (restore_sigcontext32(&compat_frame
->uc
.uc_mcontext
,
133 &compat_frame
->regs
, regs
))
135 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
136 usp
, &compat_frame
->uc
.uc_stack
);
137 if (compat_restore_altstack(&compat_frame
->uc
.uc_stack
))
142 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
143 &frame
->uc
.uc_mcontext
);
144 if (restore_sigcontext(&frame
->uc
.uc_mcontext
, regs
))
146 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
147 usp
, &frame
->uc
.uc_stack
);
148 if (restore_altstack(&frame
->uc
.uc_stack
))
154 /* If we are on the syscall path IAOQ will not be restored, and
155 * if we are on the interrupt path we must not corrupt gr31.
158 regs
->gr
[31] = regs
->iaoq
[0];
160 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs
->iaoq
[0]);
166 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
172 * Set up a signal frame.
175 static inline void __user
*
176 get_sigframe(struct k_sigaction
*ka
, unsigned long sp
, size_t frame_size
)
178 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
179 don't use the parameter it doesn't matter */
181 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
182 (unsigned long)ka
, sp
, frame_size
);
184 /* Align alternate stack and reserve 64 bytes for the signal
185 handler's frame marker. */
186 if ((ka
->sa
.sa_flags
& SA_ONSTACK
) != 0 && ! sas_ss_flags(sp
))
187 sp
= (current
->sas_ss_sp
+ 0x7f) & ~0x3f; /* Stacks grow up! */
189 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp
);
190 return (void __user
*) sp
; /* Stacks grow up. Fun. */
194 setup_sigcontext(struct sigcontext __user
*sc
, struct pt_regs
*regs
, int in_syscall
)
197 unsigned long flags
= 0;
200 if (on_sig_stack((unsigned long) sc
))
201 flags
|= PARISC_SC_FLAG_ONSTACK
;
203 flags
|= PARISC_SC_FLAG_IN_SYSCALL
;
204 /* regs->iaoq is undefined in the syscall return path */
205 err
|= __put_user(regs
->gr
[31], &sc
->sc_iaoq
[0]);
206 err
|= __put_user(regs
->gr
[31]+4, &sc
->sc_iaoq
[1]);
207 err
|= __put_user(regs
->sr
[3], &sc
->sc_iasq
[0]);
208 err
|= __put_user(regs
->sr
[3], &sc
->sc_iasq
[1]);
209 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
210 regs
->gr
[31], regs
->gr
[31]+4);
212 err
|= __copy_to_user(sc
->sc_iaoq
, regs
->iaoq
, sizeof(regs
->iaoq
));
213 err
|= __copy_to_user(sc
->sc_iasq
, regs
->iasq
, sizeof(regs
->iasq
));
214 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
215 regs
->iaoq
[0], regs
->iaoq
[1]);
218 err
|= __put_user(flags
, &sc
->sc_flags
);
219 err
|= __copy_to_user(sc
->sc_gr
, regs
->gr
, sizeof(regs
->gr
));
220 err
|= __copy_to_user(sc
->sc_fr
, regs
->fr
, sizeof(regs
->fr
));
221 err
|= __put_user(regs
->sar
, &sc
->sc_sar
);
222 DBG(1,"setup_sigcontext: r28 is %ld\n", regs
->gr
[28]);
228 setup_rt_frame(struct ksignal
*ksig
, sigset_t
*set
, struct pt_regs
*regs
,
231 struct rt_sigframe __user
*frame
;
232 unsigned long rp
, usp
;
233 unsigned long haddr
, sigframe_size
;
234 unsigned long start
, end
;
237 struct compat_rt_sigframe __user
* compat_frame
;
240 usp
= (regs
->gr
[30] & ~(0x01UL
));
241 /*FIXME: frame_size parameter is unused, remove it. */
242 frame
= get_sigframe(&ksig
->ka
, usp
, sizeof(*frame
));
244 DBG(1,"SETUP_RT_FRAME: START\n");
245 DBG(1,"setup_rt_frame: frame %p info %p\n", frame
, ksig
->info
);
250 compat_frame
= (struct compat_rt_sigframe __user
*)frame
;
252 if (is_compat_task()) {
253 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame
->info
);
254 err
|= copy_siginfo_to_user32(&compat_frame
->info
, &ksig
->info
);
255 err
|= __compat_save_altstack( &compat_frame
->uc
.uc_stack
, regs
->gr
[30]);
256 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame
->uc
);
257 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame
->uc
.uc_mcontext
);
258 err
|= setup_sigcontext32(&compat_frame
->uc
.uc_mcontext
,
259 &compat_frame
->regs
, regs
, in_syscall
);
260 err
|= put_compat_sigset(&compat_frame
->uc
.uc_sigmask
, set
,
261 sizeof(compat_sigset_t
));
265 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame
->info
);
266 err
|= copy_siginfo_to_user(&frame
->info
, &ksig
->info
);
267 err
|= __save_altstack(&frame
->uc
.uc_stack
, regs
->gr
[30]);
268 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame
->uc
);
269 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame
->uc
.uc_mcontext
);
270 err
|= setup_sigcontext(&frame
->uc
.uc_mcontext
, regs
, in_syscall
);
271 /* FIXME: Should probably be converted as well for the compat case */
272 err
|= __copy_to_user(&frame
->uc
.uc_sigmask
, set
, sizeof(*set
));
278 /* Set up to return from userspace. If provided, use a stub
279 already in userspace. The first words of tramp are used to
280 save the previous sigrestartblock trampoline that might be
281 on the stack. We start the sigreturn trampoline at
282 SIGRESTARTBLOCK_TRAMP+X. */
283 err
|= __put_user(in_syscall
? INSN_LDI_R25_1
: INSN_LDI_R25_0
,
284 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+0]);
285 err
|= __put_user(INSN_LDI_R20
,
286 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+1]);
287 err
|= __put_user(INSN_BLE_SR2_R0
,
288 &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+2]);
289 err
|= __put_user(INSN_NOP
, &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
+3]);
292 /* Assert that we're flushing in the correct space... */
295 asm ("mfsp %%sr3,%0" : "=r" (sid
));
296 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
301 start
= (unsigned long) &frame
->tramp
[0];
302 end
= (unsigned long) &frame
->tramp
[TRAMP_SIZE
];
303 flush_user_dcache_range_asm(start
, end
);
304 flush_user_icache_range_asm(start
, end
);
306 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
307 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
308 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
310 rp
= (unsigned long) &frame
->tramp
[SIGRESTARTBLOCK_TRAMP
];
315 haddr
= A(ksig
->ka
.sa
.sa_handler
);
316 /* The sa_handler may be a pointer to a function descriptor */
318 if (is_compat_task()) {
320 if (haddr
& PA_PLABEL_FDESC
) {
322 Elf32_Fdesc __user
*ufdesc
= (Elf32_Fdesc __user
*)A(haddr
& ~3);
324 err
= __copy_from_user(&fdesc
, ufdesc
, sizeof(fdesc
));
330 regs
->gr
[19] = fdesc
.gp
;
335 Elf64_Fdesc __user
*ufdesc
= (Elf64_Fdesc __user
*)A(haddr
& ~3);
337 err
= __copy_from_user(&fdesc
, ufdesc
, sizeof(fdesc
));
343 regs
->gr
[19] = fdesc
.gp
;
344 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
345 haddr
, regs
->gr
[19], in_syscall
);
349 /* The syscall return path will create IAOQ values from r31.
351 sigframe_size
= PARISC_RT_SIGFRAME_SIZE
;
353 if (is_compat_task())
354 sigframe_size
= PARISC_RT_SIGFRAME_SIZE32
;
357 regs
->gr
[31] = haddr
;
359 if (!test_thread_flag(TIF_32BIT
))
363 unsigned long psw
= USER_PSW
;
365 if (!test_thread_flag(TIF_32BIT
))
369 /* If we are singlestepping, arrange a trap to be delivered
370 when we return to userspace. Note the semantics -- we
371 should trap before the first insn in the handler is
373 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
375 if (pa_psw(current
)->r
) {
376 pa_psw(current
)->r
= 0;
382 regs
->iaoq
[0] = haddr
| 3;
383 regs
->iaoq
[1] = regs
->iaoq
[0] + 4;
386 regs
->gr
[2] = rp
; /* userland return pointer */
387 regs
->gr
[26] = ksig
->sig
; /* signal number */
390 if (is_compat_task()) {
391 regs
->gr
[25] = A(&compat_frame
->info
); /* siginfo pointer */
392 regs
->gr
[24] = A(&compat_frame
->uc
); /* ucontext pointer */
396 regs
->gr
[25] = A(&frame
->info
); /* siginfo pointer */
397 regs
->gr
[24] = A(&frame
->uc
); /* ucontext pointer */
400 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
401 regs
->gr
[30], sigframe_size
,
402 regs
->gr
[30] + sigframe_size
);
403 /* Raise the user stack pointer to make a proper call frame. */
404 regs
->gr
[30] = (A(frame
) + sigframe_size
);
407 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
408 current
->comm
, current
->pid
, frame
, regs
->gr
[30],
409 regs
->iaoq
[0], regs
->iaoq
[1], rp
);
415 * OK, we're invoking a handler.
419 handle_signal(struct ksignal
*ksig
, struct pt_regs
*regs
, int in_syscall
)
422 sigset_t
*oldset
= sigmask_to_save();
424 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
425 ksig
->sig
, ksig
->ka
, ksig
->info
, oldset
, regs
);
427 /* Set up the stack frame */
428 ret
= setup_rt_frame(ksig
, oldset
, regs
, in_syscall
);
430 signal_setup_done(ret
, ksig
, test_thread_flag(TIF_SINGLESTEP
) ||
431 test_thread_flag(TIF_BLOCKSTEP
));
433 DBG(1,KERN_DEBUG
"do_signal: Exit (success), regs->gr[28] = %ld\n",
438 * Check how the syscall number gets loaded into %r20 within
439 * the delay branch in userspace and adjust as needed.
442 static void check_syscallno_in_delay_branch(struct pt_regs
*regs
)
444 u32 opcode
, source_reg
;
448 /* Usually we don't have to restore %r20 (the system call number)
449 * because it gets loaded in the delay slot of the branch external
450 * instruction via the ldi instruction.
451 * In some cases a register-to-register copy instruction might have
452 * been used instead, in which case we need to copy the syscall
453 * number into the source register before returning to userspace.
456 /* A syscall is just a branch, so all we have to do is fiddle the
457 * return pointer so that the ble instruction gets executed again.
459 regs
->gr
[31] -= 8; /* delayed branching */
461 /* Get assembler opcode of code in delay branch */
462 uaddr
= (unsigned int *) ((regs
->gr
[31] & ~3) + 4);
463 err
= get_user(opcode
, uaddr
);
467 /* Check if delay branch uses "ldi int,%r20" */
468 if ((opcode
& 0xffff0000) == 0x34140000)
469 return; /* everything ok, just return */
471 /* Check if delay branch uses "nop" */
472 if (opcode
== INSN_NOP
)
475 /* Check if delay branch uses "copy %rX,%r20" */
476 if ((opcode
& 0xffe0ffff) == 0x08000254) {
477 source_reg
= (opcode
>> 16) & 31;
478 regs
->gr
[source_reg
] = regs
->gr
[20];
482 pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
483 current
->comm
, task_pid_nr(current
), opcode
);
487 syscall_restart(struct pt_regs
*regs
, struct k_sigaction
*ka
)
491 regs
->orig_r28
= 1; /* no more restarts */
492 /* Check the return code */
493 switch (regs
->gr
[28]) {
494 case -ERESTART_RESTARTBLOCK
:
495 case -ERESTARTNOHAND
:
496 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
497 regs
->gr
[28] = -EINTR
;
501 if (!(ka
->sa
.sa_flags
& SA_RESTART
)) {
502 DBG(1,"ERESTARTSYS: putting -EINTR\n");
503 regs
->gr
[28] = -EINTR
;
507 case -ERESTARTNOINTR
:
508 check_syscallno_in_delay_branch(regs
);
514 insert_restart_trampoline(struct pt_regs
*regs
)
518 regs
->orig_r28
= 1; /* no more restarts */
519 switch(regs
->gr
[28]) {
520 case -ERESTART_RESTARTBLOCK
: {
521 /* Restart the system call - no handlers present */
522 unsigned int *usp
= (unsigned int *)regs
->gr
[30];
523 unsigned long start
= (unsigned long) &usp
[2];
524 unsigned long end
= (unsigned long) &usp
[5];
527 /* Setup a trampoline to restart the syscall
528 * with __NR_restart_syscall
530 * 0: <return address (orig r31)>
531 * 4: <2nd half for 64-bit>
532 * 8: ldw 0(%sp), %r31
533 * 12: be 0x100(%sr2, %r0)
534 * 16: ldi __NR_restart_syscall, %r20
537 err
|= put_user(regs
->gr
[31] >> 32, &usp
[0]);
538 err
|= put_user(regs
->gr
[31] & 0xffffffff, &usp
[1]);
539 err
|= put_user(0x0fc010df, &usp
[2]);
541 err
|= put_user(regs
->gr
[31], &usp
[0]);
542 err
|= put_user(0x0fc0109f, &usp
[2]);
544 err
|= put_user(0xe0008200, &usp
[3]);
545 err
|= put_user(0x34140000, &usp
[4]);
549 /* flush data/instruction cache for new insns */
550 flush_user_dcache_range_asm(start
, end
);
551 flush_user_icache_range_asm(start
, end
);
553 regs
->gr
[31] = regs
->gr
[30] + 8;
556 case -ERESTARTNOHAND
:
558 case -ERESTARTNOINTR
:
559 check_syscallno_in_delay_branch(regs
);
567 * Note that 'init' is a special process: it doesn't get signals it doesn't
568 * want to handle. Thus you cannot kill init even with a SIGKILL even by
571 * We need to be able to restore the syscall arguments (r21-r26) to
572 * restart syscalls. Thus, the syscall path should save them in the
573 * pt_regs structure (it's okay to do so since they are caller-save
574 * registers). As noted below, the syscall number gets restored for
575 * us due to the magic of delayed branching.
578 do_signal(struct pt_regs
*regs
, long in_syscall
)
582 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
583 regs
, regs
->sr
[7], in_syscall
);
585 if (get_signal(&ksig
)) {
586 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr
, regs
->gr
[28]);
587 /* Restart a system call if necessary. */
589 syscall_restart(regs
, &ksig
.ka
);
591 handle_signal(&ksig
, regs
, in_syscall
);
595 /* Did we come from a system call? */
597 insert_restart_trampoline(regs
);
599 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
602 restore_saved_sigmask();
605 void do_notify_resume(struct pt_regs
*regs
, long in_syscall
)
607 if (test_thread_flag(TIF_SIGPENDING
))
608 do_signal(regs
, in_syscall
);
610 if (test_thread_flag(TIF_NOTIFY_RESUME
)) {
611 clear_thread_flag(TIF_NOTIFY_RESUME
);
612 tracehook_notify_resume(regs
);