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