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
71 static long
restore_sigcontext(struct sigcontext __user * sc,struct pt_regs * regs)72 restore_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
87 void
sys_rt_sigreturn(struct pt_regs * regs,int in_syscall)88 sys_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
165 give_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
175 static inline void __user *
get_sigframe(struct k_sigaction * ka,unsigned long sp,size_t frame_size)176 get_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
193 static long
setup_sigcontext(struct sigcontext __user * sc,struct pt_regs * regs,int in_syscall)194 setup_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
227 static long
setup_rt_frame(struct ksignal * ksig,sigset_t * set,struct pt_regs * regs,int in_syscall)228 setup_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 #ifdef CONFIG_64BIT
242 if (is_compat_task()) {
243 /* The gcc alloca implementation leaves garbage in the upper 32 bits of sp */
244 usp = (compat_uint_t)usp;
245 }
246 #endif
247 /*FIXME: frame_size parameter is unused, remove it. */
248 frame = get_sigframe(&ksig->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, ksig->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, &ksig->info);
261 err |= __compat_save_altstack( &compat_frame->uc.uc_stack, regs->gr[30]);
262 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc);
263 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext);
264 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext,
265 &compat_frame->regs, regs, in_syscall);
266 err |= put_compat_sigset(&compat_frame->uc.uc_sigmask, set,
267 sizeof(compat_sigset_t));
268 } else
269 #endif
270 {
271 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info);
272 err |= copy_siginfo_to_user(&frame->info, &ksig->info);
273 err |= __save_altstack(&frame->uc.uc_stack, regs->gr[30]);
274 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc);
275 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext);
276 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall);
277 /* FIXME: Should probably be converted as well for the compat case */
278 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
279 }
280
281 if (err)
282 return -EFAULT;
283
284 /* Set up to return from userspace. If provided, use a stub
285 already in userspace. The first words of tramp are used to
286 save the previous sigrestartblock trampoline that might be
287 on the stack. We start the sigreturn trampoline at
288 SIGRESTARTBLOCK_TRAMP+X. */
289 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0,
290 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]);
291 err |= __put_user(INSN_LDI_R20,
292 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]);
293 err |= __put_user(INSN_BLE_SR2_R0,
294 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]);
295 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]);
296
297 #if DEBUG_SIG
298 /* Assert that we're flushing in the correct space... */
299 {
300 unsigned long sid;
301 asm ("mfsp %%sr3,%0" : "=r" (sid));
302 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n",
303 sid, frame->tramp);
304 }
305 #endif
306
307 start = (unsigned long) &frame->tramp[0];
308 end = (unsigned long) &frame->tramp[TRAMP_SIZE];
309 flush_user_dcache_range_asm(start, end);
310 flush_user_icache_range_asm(start, end);
311
312 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP
313 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP
314 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP
315 */
316 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP];
317
318 if (err)
319 return -EFAULT;
320
321 haddr = A(ksig->ka.sa.sa_handler);
322 /* The sa_handler may be a pointer to a function descriptor */
323 #ifdef CONFIG_64BIT
324 if (is_compat_task()) {
325 #endif
326 if (haddr & PA_PLABEL_FDESC) {
327 Elf32_Fdesc fdesc;
328 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3);
329
330 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
331
332 if (err)
333 return -EFAULT;
334
335 haddr = fdesc.addr;
336 regs->gr[19] = fdesc.gp;
337 }
338 #ifdef CONFIG_64BIT
339 } else {
340 Elf64_Fdesc fdesc;
341 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3);
342
343 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc));
344
345 if (err)
346 return -EFAULT;
347
348 haddr = fdesc.addr;
349 regs->gr[19] = fdesc.gp;
350 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n",
351 haddr, regs->gr[19], in_syscall);
352 }
353 #endif
354
355 /* The syscall return path will create IAOQ values from r31.
356 */
357 sigframe_size = PARISC_RT_SIGFRAME_SIZE;
358 #ifdef CONFIG_64BIT
359 if (is_compat_task())
360 sigframe_size = PARISC_RT_SIGFRAME_SIZE32;
361 #endif
362 if (in_syscall) {
363 regs->gr[31] = haddr;
364 #ifdef CONFIG_64BIT
365 if (!test_thread_flag(TIF_32BIT))
366 sigframe_size |= 1;
367 #endif
368 } else {
369 unsigned long psw = USER_PSW;
370 #ifdef CONFIG_64BIT
371 if (!test_thread_flag(TIF_32BIT))
372 psw |= PSW_W;
373 #endif
374
375 /* If we are singlestepping, arrange a trap to be delivered
376 when we return to userspace. Note the semantics -- we
377 should trap before the first insn in the handler is
378 executed. Ref:
379 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html
380 */
381 if (pa_psw(current)->r) {
382 pa_psw(current)->r = 0;
383 psw |= PSW_R;
384 mtctl(-1, 0);
385 }
386
387 regs->gr[0] = psw;
388 regs->iaoq[0] = haddr | 3;
389 regs->iaoq[1] = regs->iaoq[0] + 4;
390 }
391
392 regs->gr[2] = rp; /* userland return pointer */
393 regs->gr[26] = ksig->sig; /* signal number */
394
395 #ifdef CONFIG_64BIT
396 if (is_compat_task()) {
397 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */
398 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */
399 } else
400 #endif
401 {
402 regs->gr[25] = A(&frame->info); /* siginfo pointer */
403 regs->gr[24] = A(&frame->uc); /* ucontext pointer */
404 }
405
406 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n",
407 regs->gr[30], sigframe_size,
408 regs->gr[30] + sigframe_size);
409 /* Raise the user stack pointer to make a proper call frame. */
410 regs->gr[30] = (A(frame) + sigframe_size);
411
412
413 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n",
414 current->comm, current->pid, frame, regs->gr[30],
415 regs->iaoq[0], regs->iaoq[1], rp);
416
417 return 0;
418 }
419
420 /*
421 * OK, we're invoking a handler.
422 */
423
424 static void
handle_signal(struct ksignal * ksig,struct pt_regs * regs,int in_syscall)425 handle_signal(struct ksignal *ksig, struct pt_regs *regs, int in_syscall)
426 {
427 int ret;
428 sigset_t *oldset = sigmask_to_save();
429
430 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n",
431 ksig->sig, ksig->ka, ksig->info, oldset, regs);
432
433 /* Set up the stack frame */
434 ret = setup_rt_frame(ksig, oldset, regs, in_syscall);
435
436 signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLESTEP) ||
437 test_thread_flag(TIF_BLOCKSTEP));
438
439 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n",
440 regs->gr[28]);
441 }
442
443 /*
444 * Check how the syscall number gets loaded into %r20 within
445 * the delay branch in userspace and adjust as needed.
446 */
447
check_syscallno_in_delay_branch(struct pt_regs * regs)448 static void check_syscallno_in_delay_branch(struct pt_regs *regs)
449 {
450 u32 opcode, source_reg;
451 u32 __user *uaddr;
452 int err;
453
454 /* Usually we don't have to restore %r20 (the system call number)
455 * because it gets loaded in the delay slot of the branch external
456 * instruction via the ldi instruction.
457 * In some cases a register-to-register copy instruction might have
458 * been used instead, in which case we need to copy the syscall
459 * number into the source register before returning to userspace.
460 */
461
462 /* A syscall is just a branch, so all we have to do is fiddle the
463 * return pointer so that the ble instruction gets executed again.
464 */
465 regs->gr[31] -= 8; /* delayed branching */
466
467 /* Get assembler opcode of code in delay branch */
468 uaddr = (unsigned int *) ((regs->gr[31] & ~3) + 4);
469 err = get_user(opcode, uaddr);
470 if (err)
471 return;
472
473 /* Check if delay branch uses "ldi int,%r20" */
474 if ((opcode & 0xffff0000) == 0x34140000)
475 return; /* everything ok, just return */
476
477 /* Check if delay branch uses "nop" */
478 if (opcode == INSN_NOP)
479 return;
480
481 /* Check if delay branch uses "copy %rX,%r20" */
482 if ((opcode & 0xffe0ffff) == 0x08000254) {
483 source_reg = (opcode >> 16) & 31;
484 regs->gr[source_reg] = regs->gr[20];
485 return;
486 }
487
488 pr_warn("syscall restart: %s (pid %d): unexpected opcode 0x%08x\n",
489 current->comm, task_pid_nr(current), opcode);
490 }
491
492 static inline void
syscall_restart(struct pt_regs * regs,struct k_sigaction * ka)493 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka)
494 {
495 if (regs->orig_r28)
496 return;
497 regs->orig_r28 = 1; /* no more restarts */
498 /* Check the return code */
499 switch (regs->gr[28]) {
500 case -ERESTART_RESTARTBLOCK:
501 case -ERESTARTNOHAND:
502 DBG(1,"ERESTARTNOHAND: returning -EINTR\n");
503 regs->gr[28] = -EINTR;
504 break;
505
506 case -ERESTARTSYS:
507 if (!(ka->sa.sa_flags & SA_RESTART)) {
508 DBG(1,"ERESTARTSYS: putting -EINTR\n");
509 regs->gr[28] = -EINTR;
510 break;
511 }
512 /* fallthrough */
513 case -ERESTARTNOINTR:
514 check_syscallno_in_delay_branch(regs);
515 break;
516 }
517 }
518
519 static inline void
insert_restart_trampoline(struct pt_regs * regs)520 insert_restart_trampoline(struct pt_regs *regs)
521 {
522 if (regs->orig_r28)
523 return;
524 regs->orig_r28 = 1; /* no more restarts */
525 switch(regs->gr[28]) {
526 case -ERESTART_RESTARTBLOCK: {
527 /* Restart the system call - no handlers present */
528 unsigned int *usp = (unsigned int *)regs->gr[30];
529 unsigned long start = (unsigned long) &usp[2];
530 unsigned long end = (unsigned long) &usp[5];
531 long err = 0;
532
533 /* Setup a trampoline to restart the syscall
534 * with __NR_restart_syscall
535 *
536 * 0: <return address (orig r31)>
537 * 4: <2nd half for 64-bit>
538 * 8: ldw 0(%sp), %r31
539 * 12: be 0x100(%sr2, %r0)
540 * 16: ldi __NR_restart_syscall, %r20
541 */
542 #ifdef CONFIG_64BIT
543 err |= put_user(regs->gr[31] >> 32, &usp[0]);
544 err |= put_user(regs->gr[31] & 0xffffffff, &usp[1]);
545 err |= put_user(0x0fc010df, &usp[2]);
546 #else
547 err |= put_user(regs->gr[31], &usp[0]);
548 err |= put_user(0x0fc0109f, &usp[2]);
549 #endif
550 err |= put_user(0xe0008200, &usp[3]);
551 err |= put_user(0x34140000, &usp[4]);
552
553 WARN_ON(err);
554
555 /* flush data/instruction cache for new insns */
556 flush_user_dcache_range_asm(start, end);
557 flush_user_icache_range_asm(start, end);
558
559 regs->gr[31] = regs->gr[30] + 8;
560 return;
561 }
562 case -ERESTARTNOHAND:
563 case -ERESTARTSYS:
564 case -ERESTARTNOINTR:
565 check_syscallno_in_delay_branch(regs);
566 return;
567 default:
568 break;
569 }
570 }
571
572 /*
573 * Note that 'init' is a special process: it doesn't get signals it doesn't
574 * want to handle. Thus you cannot kill init even with a SIGKILL even by
575 * mistake.
576 *
577 * We need to be able to restore the syscall arguments (r21-r26) to
578 * restart syscalls. Thus, the syscall path should save them in the
579 * pt_regs structure (it's okay to do so since they are caller-save
580 * registers). As noted below, the syscall number gets restored for
581 * us due to the magic of delayed branching.
582 */
583 asmlinkage void
do_signal(struct pt_regs * regs,long in_syscall)584 do_signal(struct pt_regs *regs, long in_syscall)
585 {
586 struct ksignal ksig;
587
588 DBG(1,"\ndo_signal: regs=0x%p, sr7 %#lx, in_syscall=%d\n",
589 regs, regs->sr[7], in_syscall);
590
591 if (get_signal(&ksig)) {
592 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]);
593 /* Restart a system call if necessary. */
594 if (in_syscall)
595 syscall_restart(regs, &ksig.ka);
596
597 handle_signal(&ksig, regs, in_syscall);
598 return;
599 }
600
601 /* Did we come from a system call? */
602 if (in_syscall)
603 insert_restart_trampoline(regs);
604
605 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n",
606 regs->gr[28]);
607
608 restore_saved_sigmask();
609 }
610
do_notify_resume(struct pt_regs * regs,long in_syscall)611 void do_notify_resume(struct pt_regs *regs, long in_syscall)
612 {
613 if (test_thread_flag(TIF_SIGPENDING))
614 do_signal(regs, in_syscall);
615
616 if (test_thread_flag(TIF_NOTIFY_RESUME)) {
617 clear_thread_flag(TIF_NOTIFY_RESUME);
618 tracehook_notify_resume(regs);
619 }
620 }
621