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