Loading...
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
60static long
61restore_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
76asmlinkage void
77sys_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
150give_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
160static inline void __user *
161get_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
178static long
179setup_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
212static long
213setup_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
382static void
383handle_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
406static 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
450static inline void
451syscall_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
482static inline void
483insert_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 */
548static 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
581asmlinkage 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}
1/*
2 * linux/arch/parisc/kernel/signal.c: Architecture-specific signal
3 * handling support.
4 *
5 * Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
6 * Copyright (C) 2000 Linuxcare, Inc.
7 *
8 * Based on the ia64, i386, and alpha versions.
9 *
10 * Like the IA-64, we are a recent enough port (we are *starting*
11 * with glibc2.2) that we do not need to support the old non-realtime
12 * Linux signals. Therefore we don't. HP/UX signals will go in
13 * arch/parisc/hpux/signal.c when we figure out how to do them.
14 */
15
16#include <linux/sched.h>
17#include <linux/mm.h>
18#include <linux/smp.h>
19#include <linux/kernel.h>
20#include <linux/signal.h>
21#include <linux/errno.h>
22#include <linux/wait.h>
23#include <linux/ptrace.h>
24#include <linux/tracehook.h>
25#include <linux/unistd.h>
26#include <linux/stddef.h>
27#include <linux/compat.h>
28#include <linux/elf.h>
29#include <asm/ucontext.h>
30#include <asm/rt_sigframe.h>
31#include <asm/uaccess.h>
32#include <asm/pgalloc.h>
33#include <asm/cacheflush.h>
34#include <asm/asm-offsets.h>
35
36#ifdef CONFIG_COMPAT
37#include "signal32.h"
38#endif
39
40#define DEBUG_SIG 0
41#define DEBUG_SIG_LEVEL 2
42
43#if DEBUG_SIG
44#define DBG(LEVEL, ...) \
45 ((DEBUG_SIG_LEVEL >= LEVEL) \
46 ? printk(__VA_ARGS__) : (void) 0)
47#else
48#define DBG(LEVEL, ...)
49#endif
50
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
55 * this. */
56#define A(__x) ((unsigned long)(__x))
57
58/*
59 * Do a signal return - restore sigcontext.
60 */
61
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 */
67#define INSN_NOP 0x08000240 /* nop */
68/* For debugging */
69#define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */
70
71static long
72restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs)
73{
74 long err = 0;
75
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]);
84 return err;
85}
86
87void
88sys_rt_sigreturn(struct pt_regs *regs, int in_syscall)
89{
90 struct rt_sigframe __user *frame;
91 sigset_t set;
92 unsigned long usp = (regs->gr[30] & ~(0x01UL));
93 unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE;
94#ifdef CONFIG_64BIT
95 compat_sigset_t compat_set;
96 struct compat_rt_sigframe __user * compat_frame;
97
98 if (is_compat_task())
99 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
100#endif
101
102 current_thread_info()->restart_block.fn = do_no_restart_syscall;
103
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);
108
109 regs->orig_r28 = 1; /* no restarts for sigreturn */
110
111#ifdef CONFIG_64BIT
112 compat_frame = (struct compat_rt_sigframe __user *)frame;
113
114 if (is_compat_task()) {
115 DBG(2,"sys_rt_sigreturn: ELF32 process.\n");
116 if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set)))
117 goto give_sigsegv;
118 sigset_32to64(&set,&compat_set);
119 } else
120#endif
121 {
122 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
123 goto give_sigsegv;
124 }
125
126 set_current_blocked(&set);
127
128 /* Good thing we saved the old gr[30], eh? */
129#ifdef CONFIG_64BIT
130 if (is_compat_task()) {
131 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n",
132 &compat_frame->uc.uc_mcontext);
133// FIXME: Load upper half from register file
134 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext,
135 &compat_frame->regs, regs))
136 goto give_sigsegv;
137 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
138 usp, &compat_frame->uc.uc_stack);
139 if (compat_restore_altstack(&compat_frame->uc.uc_stack))
140 goto give_sigsegv;
141 } else
142#endif
143 {
144 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n",
145 &frame->uc.uc_mcontext);
146 if (restore_sigcontext(&frame->uc.uc_mcontext, regs))
147 goto give_sigsegv;
148 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n",
149 usp, &frame->uc.uc_stack);
150 if (restore_altstack(&frame->uc.uc_stack))
151 goto give_sigsegv;
152 }
153
154
155
156 /* If we are on the syscall path IAOQ will not be restored, and
157 * if we are on the interrupt path we must not corrupt gr31.
158 */
159 if (in_syscall)
160 regs->gr[31] = regs->iaoq[0];
161#if DEBUG_SIG
162 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]);
163 show_regs(regs);
164#endif
165 return;
166
167give_sigsegv:
168 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n");
169 force_sig(SIGSEGV, current);
170 return;
171}
172
173/*
174 * Set up a signal frame.
175 */
176
177static inline void __user *
178get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
179{
180 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we
181 don't use the parameter it doesn't matter */
182
183 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n",
184 (unsigned long)ka, sp, frame_size);
185
186 /* Align alternate stack and reserve 64 bytes for the signal
187 handler's frame marker. */
188 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
189 sp = (current->sas_ss_sp + 0x7f) & ~0x3f; /* Stacks grow up! */
190
191 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp);
192 return (void __user *) sp; /* Stacks grow up. Fun. */
193}
194
195static long
196setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall)
197
198{
199 unsigned long flags = 0;
200 long err = 0;
201
202 if (on_sig_stack((unsigned long) sc))
203 flags |= PARISC_SC_FLAG_ONSTACK;
204 if (in_syscall) {
205 flags |= PARISC_SC_FLAG_IN_SYSCALL;
206 /* regs->iaoq is undefined in the syscall return path */
207 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]);
208 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]);
209 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]);
210 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]);
211 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n",
212 regs->gr[31], regs->gr[31]+4);
213 } else {
214 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq));
215 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq));
216 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n",
217 regs->iaoq[0], regs->iaoq[1]);
218 }
219
220 err |= __put_user(flags, &sc->sc_flags);
221 err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr));
222 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr));
223 err |= __put_user(regs->sar, &sc->sc_sar);
224 DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]);
225
226 return err;
227}
228
229static long
230setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
231 sigset_t *set, struct pt_regs *regs, int in_syscall)
232{
233 struct rt_sigframe __user *frame;
234 unsigned long rp, usp;
235 unsigned long haddr, sigframe_size;
236 int err = 0;
237#ifdef CONFIG_64BIT
238 struct compat_rt_sigframe __user * compat_frame;
239 compat_sigset_t compat_set;
240#endif
241
242 usp = (regs->gr[30] & ~(0x01UL));
243 /*FIXME: frame_size parameter is unused, remove it. */
244 frame = get_sigframe(ka, usp, sizeof(*frame));
245
246 DBG(1,"SETUP_RT_FRAME: START\n");
247 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info);
248
249
250#ifdef CONFIG_64BIT
251
252 compat_frame = (struct compat_rt_sigframe __user *)frame;
253
254 if (is_compat_task()) {
255 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info);
256 err |= copy_siginfo_to_user32(&compat_frame->info, info);
257 err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
258 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
259 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
260 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
261 &compat_frame->regs, regs, in_syscall);
262 sigset_64to32(&compat_set,set);
263 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set));
264 } else
265#endif
266 {
267 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
268 err |= copy_siginfo_to_user(&frame->info, info);
269 err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
270 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
271 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
272 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
273 /* FIXME: Should probably be converted as well for the compat case */
274 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
275 }
276
277 if (err)
278 goto give_sigsegv;
279
280 /* Set up to return from userspace. If provided, use a stub
281 already in userspace. The first words of tramp are used to
282 save the previous sigrestartblock trampoline that might be
283 on the stack. We start the sigreturn trampoline at
284 SIGRESTARTBLOCK_TRAMP+X. */
285 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
286 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
287 err |= __put_user(INSN_LDI_R20,
288 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
289 err |= __put_user(INSN_BLE_SR2_R0,
290 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
291 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
292
293#if DEBUG_SIG
294 /* Assert that we're flushing in the correct space... */
295 {
296 unsigned long sid;
297 asm ("mfsp %%sr3,%0" : "=r" (sid));
298 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
299 sid, frame->tramp);
300 }
301#endif
302
303 flush_user_dcache_range((unsigned long) &frame->tramp[0],
304 (unsigned long) &frame->tramp[TRAMP_SIZE]);
305 flush_user_icache_range((unsigned long) &frame->tramp[0],
306 (unsigned long) &frame->tramp[TRAMP_SIZE]);
307
308 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
309 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
310 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
311 */
312 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
313
314 if (err)
315 goto give_sigsegv;
316
317 haddr = A(ka->sa.sa_handler);
318 /* The sa_handler may be a pointer to a function descriptor */
319#ifdef CONFIG_64BIT
320 if (is_compat_task()) {
321#endif
322 if (haddr & PA_PLABEL_FDESC) {
323 Elf32_Fdesc fdesc;
324 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
325
326 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
327
328 if (err)
329 goto give_sigsegv;
330
331 haddr = fdesc.addr;
332 regs->gr[19] = fdesc.gp;
333 }
334#ifdef CONFIG_64BIT
335 } else {
336 Elf64_Fdesc fdesc;
337 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
338
339 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
340
341 if (err)
342 goto give_sigsegv;
343
344 haddr = fdesc.addr;
345 regs->gr[19] = fdesc.gp;
346 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
347 haddr, regs->gr[19], in_syscall);
348 }
349#endif
350
351 /* The syscall return path will create IAOQ values from r31.
352 */
353 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
354#ifdef CONFIG_64BIT
355 if (is_compat_task())
356 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
357#endif
358 if (in_syscall) {
359 regs->gr[31] = haddr;
360#ifdef CONFIG_64BIT
361 if (!test_thread_flag(TIF_32BIT))
362 sigframe_size |= 1;
363#endif
364 } else {
365 unsigned long psw = USER_PSW;
366#ifdef CONFIG_64BIT
367 if (!test_thread_flag(TIF_32BIT))
368 psw |= PSW_W;
369#endif
370
371 /* If we are singlestepping, arrange a trap to be delivered
372 when we return to userspace. Note the semantics -- we
373 should trap before the first insn in the handler is
374 executed. Ref:
375 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
376 */
377 if (pa_psw(current)->r) {
378 pa_psw(current)->r = 0;
379 psw |= PSW_R;
380 mtctl(-1, 0);
381 }
382
383 regs->gr[0] = psw;
384 regs->iaoq[0] = haddr | 3;
385 regs->iaoq[1] = regs->iaoq[0] + 4;
386 }
387
388 regs->gr[2] = rp; /* userland return pointer */
389 regs->gr[26] = sig; /* signal number */
390
391#ifdef CONFIG_64BIT
392 if (is_compat_task()) {
393 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
394 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
395 } else
396#endif
397 {
398 regs->gr[25] = A(&frame->info); /* siginfo pointer */
399 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
400 }
401
402 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
403 regs->gr[30], sigframe_size,
404 regs->gr[30] + sigframe_size);
405 /* Raise the user stack pointer to make a proper call frame. */
406 regs->gr[30] = (A(frame) + sigframe_size);
407
408
409 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
410 current->comm, current->pid, frame, regs->gr[30],
411 regs->iaoq[0], regs->iaoq[1], rp);
412
413 return 1;
414
415give_sigsegv:
416 DBG(1,"setup_rt_frame: sending SIGSEGV\n");
417 force_sigsegv(sig, current);
418 return 0;
419}
420
421/*
422 * OK, we're invoking a handler.
423 */
424
425static void
426handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka,
427 struct pt_regs *regs, int in_syscall)
428{
429 sigset_t *oldset = sigmask_to_save();
430 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
431 sig, ka, info, oldset, regs);
432
433 /* Set up the stack frame */
434 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall))
435 return;
436
437 signal_delivered(sig, info, ka, regs,
438 test_thread_flag(TIF_SINGLESTEP) ||
439 test_thread_flag(TIF_BLOCKSTEP));
440
441 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
442 regs->gr[28]);
443}
444
445static inline void
446syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
447{
448 if (regs->orig_r28)
449 return;
450 regs->orig_r28 = 1; /* no more restarts */
451 /* Check the return code */
452 switch (regs->gr[28]) {
453 case -ERESTART_RESTARTBLOCK:
454 case -ERESTARTNOHAND:
455 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
456 regs->gr[28] = -EINTR;
457 break;
458
459 case -ERESTARTSYS:
460 if (!(ka->sa.sa_flags & SA_RESTART)) {
461 DBG(1,"ERESTARTSYS: putting -EINTR\n");
462 regs->gr[28] = -EINTR;
463 break;
464 }
465 /* fallthrough */
466 case -ERESTARTNOINTR:
467 /* A syscall is just a branch, so all
468 * we have to do is fiddle the return pointer.
469 */
470 regs->gr[31] -= 8; /* delayed branching */
471 break;
472 }
473}
474
475static inline void
476insert_restart_trampoline(struct pt_regs *regs)
477{
478 if (regs->orig_r28)
479 return;
480 regs->orig_r28 = 1; /* no more restarts */
481 switch(regs->gr[28]) {
482 case -ERESTART_RESTARTBLOCK: {
483 /* Restart the system call - no handlers present */
484 unsigned int *usp = (unsigned int *)regs->gr[30];
485
486 /* Setup a trampoline to restart the syscall
487 * with __NR_restart_syscall
488 *
489 * 0: <return address (orig r31)>
490 * 4: <2nd half for 64-bit>
491 * 8: ldw 0(%sp), %r31
492 * 12: be 0x100(%sr2, %r0)
493 * 16: ldi __NR_restart_syscall, %r20
494 */
495#ifdef CONFIG_64BIT
496 put_user(regs->gr[31] >> 32, &usp[0]);
497 put_user(regs->gr[31] & 0xffffffff, &usp[1]);
498 put_user(0x0fc010df, &usp[2]);
499#else
500 put_user(regs->gr[31], &usp[0]);
501 put_user(0x0fc0109f, &usp[2]);
502#endif
503 put_user(0xe0008200, &usp[3]);
504 put_user(0x34140000, &usp[4]);
505
506 /* Stack is 64-byte aligned, and we only need
507 * to flush 1 cache line.
508 * Flushing one cacheline is cheap.
509 * "sync" on bigger (> 4 way) boxes is not.
510 */
511 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4);
512 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4);
513
514 regs->gr[31] = regs->gr[30] + 8;
515 return;
516 }
517 case -ERESTARTNOHAND:
518 case -ERESTARTSYS:
519 case -ERESTARTNOINTR: {
520 /* Hooray for delayed branching. We don't
521 * have to restore %r20 (the system call
522 * number) because it gets loaded in the delay
523 * slot of the branch external instruction.
524 */
525 regs->gr[31] -= 8;
526 return;
527 }
528 default:
529 break;
530 }
531}
532
533/*
534 * Note that 'init' is a special process: it doesn't get signals it doesn't
535 * want to handle. Thus you cannot kill init even with a SIGKILL even by
536 * mistake.
537 *
538 * We need to be able to restore the syscall arguments (r21-r26) to
539 * restart syscalls. Thus, the syscall path should save them in the
540 * pt_regs structure (it's okay to do so since they are caller-save
541 * registers). As noted below, the syscall number gets restored for
542 * us due to the magic of delayed branching.
543 */
544asmlinkage void
545do_signal(struct pt_regs *regs, long in_syscall)
546{
547 siginfo_t info;
548 struct k_sigaction ka;
549 int signr;
550
551 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
552 regs, regs->sr[7], in_syscall);
553
554 signr = get_signal_to_deliver(&info, &ka, regs, NULL);
555 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
556
557 if (signr > 0) {
558 /* Restart a system call if necessary. */
559 if (in_syscall)
560 syscall_restart(regs, &ka);
561
562 handle_signal(signr, &info, &ka, regs, in_syscall);
563 return;
564 }
565
566 /* Did we come from a system call? */
567 if (in_syscall)
568 insert_restart_trampoline(regs);
569
570 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
571 regs->gr[28]);
572
573 restore_saved_sigmask();
574}
575
576void do_notify_resume(struct pt_regs *regs, long in_syscall)
577{
578 if (test_thread_flag(TIF_SIGPENDING))
579 do_signal(regs, in_syscall);
580
581 if (test_thread_flag(TIF_NOTIFY_RESUME)) {
582 clear_thread_flag(TIF_NOTIFY_RESUME);
583 tracehook_notify_resume(regs);
584 }
585}