1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * PA-RISC architecture-specific signal handling support.
4 *
5 * Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
6 * Copyright (C) 2000 Linuxcare, Inc.
7 * Copyright (C) 2000-2022 Helge Deller <deller@gmx.de>
8 * Copyright (C) 2022 John David Anglin <dave.anglin@bell.net>
9 *
10 * Based on the ia64, i386, and alpha versions.
11 */
12
13 #include <linux/sched.h>
14 #include <linux/sched/debug.h>
15 #include <linux/mm.h>
16 #include <linux/smp.h>
17 #include <linux/kernel.h>
18 #include <linux/signal.h>
19 #include <linux/errno.h>
20 #include <linux/wait.h>
21 #include <linux/ptrace.h>
22 #include <linux/resume_user_mode.h>
23 #include <linux/unistd.h>
24 #include <linux/stddef.h>
25 #include <linux/compat.h>
26 #include <linux/elf.h>
27 #include <asm/ucontext.h>
28 #include <asm/rt_sigframe.h>
29 #include <linux/uaccess.h>
30 #include <asm/cacheflush.h>
31 #include <asm/asm-offsets.h>
32 #include <asm/vdso.h>
33
34 #ifdef CONFIG_COMPAT
35 #include "signal32.h"
36 #endif
37
38 #define DEBUG_SIG 0
39 #define DEBUG_SIG_LEVEL 2
40
41 #if DEBUG_SIG
42 #define DBG(LEVEL, ...) \
43 ((DEBUG_SIG_LEVEL >= LEVEL) \
44 ? printk(__VA_ARGS__) : (void) 0)
45 #else
46 #define DBG(LEVEL, ...)
47 #endif
48
49 /* gcc will complain if a pointer is cast to an integer of different
50 * size. If you really need to do this (and we do for an ELF32 user
51 * application in an ELF64 kernel) then you have to do a cast to an
52 * integer of the same size first. The A() macro accomplishes
53 * this. */
54 #define A(__x) ((unsigned long)(__x))
55
56 /*
57 * Do a signal return - restore sigcontext.
58 */
59
60 static long
restore_sigcontext(struct sigcontext __user * sc,struct pt_regs * regs)61 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
62 {
63 long err = 0;
64
65 err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr));
66 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr));
67 err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq));
68 err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq));
69 err |= __get_user(regs->sar, &sc->sc_sar);
70 DBG(2, "%s: iaoq is %#lx / %#lx\n",
71 __func__, regs->iaoq[0], regs->iaoq[1]);
72 DBG(2, "%s: r28 is %ld\n", __func__, regs->gr[28]);
73 return err;
74 }
75
76 asmlinkage void
sys_rt_sigreturn(struct pt_regs * regs,int in_syscall)77 sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
78 {
79 struct rt_sigframe __user *frame;
80 sigset_t set;
81 unsigned long usp = (regs->gr[30] & ~(0x01UL));
82 unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
83 #ifdef CONFIG_64BIT
84 struct compat_rt_sigframe __user * compat_frame;
85
86 if (is_compat_task())
87 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
88 #endif
89
90 current->restart_block.fn = do_no_restart_syscall;
91
92 /* Unwind the user stack to get the rt_sigframe structure. */
93 frame = (struct rt_sigframe __user *)
94 (usp - sigframe_size);
95 DBG(2, "%s: frame is %p pid %d\n", __func__, frame, task_pid_nr(current));
96
97 regs->orig_r28 = 1; /* no restarts for sigreturn */
98
99 #ifdef CONFIG_64BIT
100 compat_frame = (struct compat_rt_sigframe __user *)frame;
101
102 if (is_compat_task()) {
103 if (get_compat_sigset(&set, &compat_frame->uc.uc_sigmask))
104 goto give_sigsegv;
105 } else
106 #endif
107 {
108 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
109 goto give_sigsegv;
110 }
111
112 set_current_blocked(&set);
113
114 /* Good thing we saved the old gr[30], eh? */
115 #ifdef CONFIG_64BIT
116 if (is_compat_task()) {
117 DBG(1, "%s: compat_frame->uc.uc_mcontext 0x%p\n",
118 __func__, &compat_frame->uc.uc_mcontext);
119 // FIXME: Load upper half from register file
120 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext,
121 &compat_frame->regs, regs))
122 goto give_sigsegv;
123 DBG(1, "%s: usp %#08lx stack 0x%p\n",
124 __func__, usp, &compat_frame->uc.uc_stack);
125 if (compat_restore_altstack(&compat_frame->uc.uc_stack))
126 goto give_sigsegv;
127 } else
128 #endif
129 {
130 DBG(1, "%s: frame->uc.uc_mcontext 0x%p\n",
131 __func__, &frame->uc.uc_mcontext);
132 if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
133 goto give_sigsegv;
134 DBG(1, "%s: usp %#08lx stack 0x%p\n",
135 __func__, usp, &frame->uc.uc_stack);
136 if (restore_altstack(&frame->uc.uc_stack))
137 goto give_sigsegv;
138 }
139
140
141
142 /* If we are on the syscall path IAOQ will not be restored, and
143 * if we are on the interrupt path we must not corrupt gr31.
144 */
145 if (in_syscall)
146 regs->gr[31] = regs->iaoq[0];
147
148 return;
149
150 give_sigsegv:
151 DBG(1, "%s: Sending SIGSEGV\n", __func__);
152 force_sig(SIGSEGV);
153 return;
154 }
155
156 /*
157 * Set up a signal frame.
158 */
159
160 static inline void __user *
get_sigframe(struct k_sigaction * ka,unsigned long sp,size_t frame_size)161 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
162 {
163 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
164 don't use the parameter it doesn't matter */
165
166 DBG(1, "%s: ka = %#lx, sp = %#lx, frame_size = %zu\n",
167 __func__, (unsigned long)ka, sp, frame_size);
168
169 /* Align alternate stack and reserve 64 bytes for the signal
170 handler's frame marker. */
171 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
172 sp = (current->sas_ss_sp + 0x7f) & ~0x3f; /* Stacks grow up! */
173
174 DBG(1, "%s: Returning sp = %#lx\n", __func__, (unsigned long)sp);
175 return (void __user *) sp; /* Stacks grow up. Fun. */
176 }
177
178 static long
setup_sigcontext(struct sigcontext __user * sc,struct pt_regs * regs,long in_syscall)179 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, long in_syscall)
180
181 {
182 unsigned long flags = 0;
183 long err = 0;
184
185 if (on_sig_stack((unsigned long) sc))
186 flags |= PARISC_SC_FLAG_ONSTACK;
187 if (in_syscall) {
188 flags |= PARISC_SC_FLAG_IN_SYSCALL;
189 /* regs->iaoq is undefined in the syscall return path */
190 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
191 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
192 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
193 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
194 DBG(1, "%s: iaoq %#lx / %#lx (in syscall)\n",
195 __func__, regs->gr[31], regs->gr[31]+4);
196 } else {
197 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
198 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
199 DBG(1, "%s: iaoq %#lx / %#lx (not in syscall)\n",
200 __func__, regs->iaoq[0], regs->iaoq[1]);
201 }
202
203 err |= __put_user(flags, &sc->sc_flags);
204 err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
205 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
206 err |= __put_user(regs->sar, &sc->sc_sar);
207 DBG(1, "%s: r28 is %ld\n", __func__, regs->gr[28]);
208
209 return err;
210 }
211
212 static long
setup_rt_frame(struct ksignal * ksig,sigset_t * set,struct pt_regs * regs,long in_syscall)213 setup_rt_frame(struct ksignal *ksig, sigset_t *set, struct pt_regs *regs,
214 long in_syscall)
215 {
216 struct rt_sigframe __user *frame;
217 unsigned long rp, usp;
218 unsigned long haddr, sigframe_size;
219 unsigned long start;
220 int err = 0;
221 #ifdef CONFIG_64BIT
222 struct compat_rt_sigframe __user * compat_frame;
223 #endif
224
225 usp = (regs->gr[30] & ~(0x01UL));
226 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
227 #ifdef CONFIG_64BIT
228 if (is_compat_task()) {
229 /* The gcc alloca implementation leaves garbage in the upper 32 bits of sp */
230 usp = (compat_uint_t)usp;
231 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
232 }
233 #endif
234 frame = get_sigframe(&ksig->ka, usp, sigframe_size);
235
236 DBG(1, "%s: frame %p info %p\n", __func__, frame, &ksig->info);
237
238 start = (unsigned long) frame;
239 if (start >= TASK_SIZE_MAX - sigframe_size)
240 return -EFAULT;
241
242 #ifdef CONFIG_64BIT
243
244 compat_frame = (struct compat_rt_sigframe __user *)frame;
245
246 if (is_compat_task()) {
247 DBG(1, "%s: frame->info = 0x%p\n", __func__, &compat_frame->info);
248 err |= copy_siginfo_to_user32(&compat_frame->info, &ksig->info);
249 err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
250 DBG(1, "%s: frame->uc = 0x%p\n", __func__, &compat_frame->uc);
251 DBG(1, "%s: frame->uc.uc_mcontext = 0x%p\n",
252 __func__, &compat_frame->uc.uc_mcontext);
253 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
254 &compat_frame->regs, regs, in_syscall);
255 err |= put_compat_sigset(&compat_frame->uc.uc_sigmask, set,
256 sizeof(compat_sigset_t));
257 } else
258 #endif
259 {
260 DBG(1, "%s: frame->info = 0x%p\n", __func__, &frame->info);
261 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
262 err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
263 DBG(1, "%s: frame->uc = 0x%p\n", __func__, &frame->uc);
264 DBG(1, "%s: frame->uc.uc_mcontext = 0x%p\n",
265 __func__, &frame->uc.uc_mcontext);
266 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
267 /* FIXME: Should probably be converted as well for the compat case */
268 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
269 }
270
271 if (err)
272 return -EFAULT;
273
274 #ifdef CONFIG_64BIT
275 if (!is_compat_task())
276 rp = VDSO64_SYMBOL(current, sigtramp_rt);
277 else
278 #endif
279 rp = VDSO32_SYMBOL(current, sigtramp_rt);
280
281 if (in_syscall)
282 rp += 4*4; /* skip 4 instructions and start at ldi 1,%r25 */
283
284 haddr = A(ksig->ka.sa.sa_handler);
285 /* The sa_handler may be a pointer to a function descriptor */
286 #ifdef CONFIG_64BIT
287 if (is_compat_task()) {
288 #endif
289 if (haddr & PA_PLABEL_FDESC) {
290 Elf32_Fdesc fdesc;
291 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
292
293 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
294
295 if (err)
296 return -EFAULT;
297
298 haddr = fdesc.addr;
299 regs->gr[19] = fdesc.gp;
300 }
301 #ifdef CONFIG_64BIT
302 } else {
303 Elf64_Fdesc fdesc;
304 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
305
306 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
307
308 if (err)
309 return -EFAULT;
310
311 haddr = fdesc.addr;
312 regs->gr[19] = fdesc.gp;
313 DBG(1, "%s: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
314 __func__, haddr, regs->gr[19], in_syscall);
315 }
316 #endif
317
318 /* The syscall return path will create IAOQ values from r31.
319 */
320 if (in_syscall) {
321 regs->gr[31] = haddr;
322 #ifdef CONFIG_64BIT
323 if (!test_thread_flag(TIF_32BIT))
324 sigframe_size |= 1; /* XXX ???? */
325 #endif
326 } else {
327 unsigned long psw = USER_PSW;
328 #ifdef CONFIG_64BIT
329 if (!test_thread_flag(TIF_32BIT))
330 psw |= PSW_W;
331 #endif
332
333 /* If we are singlestepping, arrange a trap to be delivered
334 when we return to userspace. Note the semantics -- we
335 should trap before the first insn in the handler is
336 executed. Ref:
337 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
338 */
339 if (pa_psw(current)->r) {
340 pa_psw(current)->r = 0;
341 psw |= PSW_R;
342 mtctl(-1, 0);
343 }
344
345 regs->gr[0] = psw;
346 regs->iaoq[0] = haddr | PRIV_USER;
347 regs->iaoq[1] = regs->iaoq[0] + 4;
348 }
349
350 regs->gr[2] = rp; /* userland return pointer */
351 regs->gr[26] = ksig->sig; /* signal number */
352
353 #ifdef CONFIG_64BIT
354 if (is_compat_task()) {
355 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
356 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
357 } else
358 #endif
359 {
360 regs->gr[25] = A(&frame->info); /* siginfo pointer */
361 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
362 }
363
364 DBG(1, "%s: making sigreturn frame: %#lx + %#lx = %#lx\n", __func__,
365 regs->gr[30], sigframe_size,
366 regs->gr[30] + sigframe_size);
367 /* Raise the user stack pointer to make a proper call frame. */
368 regs->gr[30] = (A(frame) + sigframe_size);
369
370
371 DBG(1, "%s: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
372 __func__, current->comm, current->pid, frame, regs->gr[30],
373 regs->iaoq[0], regs->iaoq[1], rp);
374
375 return 0;
376 }
377
378 /*
379 * OK, we're invoking a handler.
380 */
381
382 static void
handle_signal(struct ksignal * ksig,struct pt_regs * regs,long in_syscall)383 handle_signal(struct ksignal *ksig, struct pt_regs *regs, long in_syscall)
384 {
385 int ret;
386 sigset_t *oldset = sigmask_to_save();
387
388 DBG(1, "%s: sig=%d, ka=%p, info=%p, oldset=%p, regs=%p\n",
389 __func__, ksig->sig, &ksig->ka, &ksig->info, oldset, regs);
390
391 /* Set up the stack frame */
392 ret = setup_rt_frame(ksig, oldset, regs, in_syscall);
393
394 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP) ||
395 test_thread_flag(TIF_BLOCKSTEP));
396
397 DBG(1, "%s: Exit (success), regs->gr[28] = %ld\n",
398 __func__, regs->gr[28]);
399 }
400
401 /*
402 * Check how the syscall number gets loaded into %r20 within
403 * the delay branch in userspace and adjust as needed.
404 */
405
check_syscallno_in_delay_branch(struct pt_regs * regs)406 static void check_syscallno_in_delay_branch(struct pt_regs *regs)
407 {
408 u32 opcode, source_reg;
409 u32 __user *uaddr;
410 int err;
411
412 /* Usually we don't have to restore %r20 (the system call number)
413 * because it gets loaded in the delay slot of the branch external
414 * instruction via the ldi instruction.
415 * In some cases a register-to-register copy instruction might have
416 * been used instead, in which case we need to copy the syscall
417 * number into the source register before returning to userspace.
418 */
419
420 /* A syscall is just a branch, so all we have to do is fiddle the
421 * return pointer so that the ble instruction gets executed again.
422 */
423 regs->gr[31] -= 8; /* delayed branching */
424
425 /* Get assembler opcode of code in delay branch */
426 uaddr = (u32 __user *) ((regs->gr[31] & ~3) + 4);
427 err = get_user(opcode, uaddr);
428 if (err)
429 return;
430
431 /* Check if delay branch uses "ldi int,%r20" */
432 if ((opcode & 0xffff0000) == 0x34140000)
433 return; /* everything ok, just return */
434
435 /* Check if delay branch uses "nop" */
436 if (opcode == INSN_NOP)
437 return;
438
439 /* Check if delay branch uses "copy %rX,%r20" */
440 if ((opcode & 0xffe0ffff) == 0x08000254) {
441 source_reg = (opcode >> 16) & 31;
442 regs->gr[source_reg] = regs->gr[20];
443 return;
444 }
445
446 pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
447 current->comm, task_pid_nr(current), opcode);
448 }
449
450 static inline void
syscall_restart(struct pt_regs * regs,struct k_sigaction * ka)451 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
452 {
453 if (regs->orig_r28)
454 return;
455 regs->orig_r28 = 1; /* no more restarts */
456
457 DBG(1, "%s: orig_r28 = %ld pid %d r20 %ld\n",
458 __func__, regs->orig_r28, task_pid_nr(current), regs->gr[20]);
459
460 /* Check the return code */
461 switch (regs->gr[28]) {
462 case -ERESTART_RESTARTBLOCK:
463 case -ERESTARTNOHAND:
464 DBG(1, "%s: ERESTARTNOHAND: returning -EINTR\n", __func__);
465 regs->gr[28] = -EINTR;
466 break;
467 case -ERESTARTSYS:
468 if (!(ka->sa.sa_flags & SA_RESTART)) {
469 DBG(1, "%s: ERESTARTSYS: putting -EINTR pid %d\n",
470 __func__, task_pid_nr(current));
471 regs->gr[28] = -EINTR;
472 break;
473 }
474 fallthrough;
475 case -ERESTARTNOINTR:
476 DBG(1, "%s: %ld\n", __func__, regs->gr[28]);
477 check_syscallno_in_delay_branch(regs);
478 break;
479 }
480 }
481
482 static inline void
insert_restart_trampoline(struct pt_regs * regs)483 insert_restart_trampoline(struct pt_regs *regs)
484 {
485 if (regs->orig_r28)
486 return;
487 regs->orig_r28 = 1; /* no more restarts */
488
489 DBG(2, "%s: gr28 = %ld pid %d\n",
490 __func__, regs->gr[28], task_pid_nr(current));
491
492 switch (regs->gr[28]) {
493 case -ERESTART_RESTARTBLOCK: {
494 /* Restart the system call - no handlers present */
495 unsigned int *usp = (unsigned int *)regs->gr[30];
496 unsigned long rp;
497 long err = 0;
498
499 /* check that we don't exceed the stack */
500 if (A(&usp[0]) >= TASK_SIZE_MAX - 5 * sizeof(int))
501 return;
502
503 /* Call trampoline in vdso to restart the syscall
504 * with __NR_restart_syscall.
505 * Original return addresses are on stack like this:
506 *
507 * 0: <return address (orig r31)>
508 * 4: <2nd half for 64-bit>
509 */
510 #ifdef CONFIG_64BIT
511 if (!is_compat_task()) {
512 err |= put_user(regs->gr[31] >> 32, &usp[0]);
513 err |= put_user(regs->gr[31] & 0xffffffff, &usp[1]);
514 rp = VDSO64_SYMBOL(current, restart_syscall);
515 } else
516 #endif
517 {
518 err |= put_user(regs->gr[31], &usp[0]);
519 rp = VDSO32_SYMBOL(current, restart_syscall);
520 }
521 WARN_ON(err);
522
523 regs->gr[31] = rp;
524 DBG(1, "%s: ERESTART_RESTARTBLOCK\n", __func__);
525 return;
526 }
527 case -EINTR:
528 /* ok, was handled before and should be returned. */
529 break;
530 case -ERESTARTNOHAND:
531 case -ERESTARTSYS:
532 case -ERESTARTNOINTR:
533 DBG(1, "%s: Type %ld\n", __func__, regs->gr[28]);
534 check_syscallno_in_delay_branch(regs);
535 return;
536 default:
537 break;
538 }
539 }
540
541 /*
542 * We need to be able to restore the syscall arguments (r21-r26) to
543 * restart syscalls. Thus, the syscall path should save them in the
544 * pt_regs structure (it's okay to do so since they are caller-save
545 * registers). As noted below, the syscall number gets restored for
546 * us due to the magic of delayed branching.
547 */
do_signal(struct pt_regs * regs,long in_syscall)548 static void do_signal(struct pt_regs *regs, long in_syscall)
549 {
550 struct ksignal ksig;
551 int restart_syscall;
552 bool has_handler;
553
554 has_handler = get_signal(&ksig);
555
556 restart_syscall = 0;
557 if (in_syscall)
558 restart_syscall = 1;
559
560 if (has_handler) {
561 /* Restart a system call if necessary. */
562 if (restart_syscall)
563 syscall_restart(regs, &ksig.ka);
564
565 handle_signal(&ksig, regs, in_syscall);
566 DBG(1, "%s: Handled signal pid %d\n",
567 __func__, task_pid_nr(current));
568 return;
569 }
570
571 /* Do we need to restart the system call? */
572 if (restart_syscall)
573 insert_restart_trampoline(regs);
574
575 DBG(1, "%s: Exit (not delivered), regs->gr[28] = %ld orig_r28 = %ld pid %d\n",
576 __func__, regs->gr[28], regs->orig_r28, task_pid_nr(current));
577
578 restore_saved_sigmask();
579 }
580
do_notify_resume(struct pt_regs * regs,long in_syscall)581 asmlinkage void do_notify_resume(struct pt_regs *regs, long in_syscall)
582 {
583 if (test_thread_flag(TIF_SIGPENDING) ||
584 test_thread_flag(TIF_NOTIFY_SIGNAL))
585 do_signal(regs, in_syscall);
586
587 if (test_thread_flag(TIF_NOTIFY_RESUME))
588 resume_user_mode_work(regs);
589 }
590