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