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 78 static long 79 restore_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 94 void 95 sys_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 regs->orig_r28 = 1; /* no restarts for sigreturn */ 117 118 #ifdef CONFIG_64BIT 119 compat_frame = (struct compat_rt_sigframe __user *)frame; 120 121 if (is_compat_task()) { 122 DBG(2,"sys_rt_sigreturn: ELF32 process.\n"); 123 if (__copy_from_user(&compat_set, &compat_frame->uc.uc_sigmask, sizeof(compat_set))) 124 goto give_sigsegv; 125 sigset_32to64(&set,&compat_set); 126 } else 127 #endif 128 { 129 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 130 goto give_sigsegv; 131 } 132 133 set_current_blocked(&set); 134 135 /* Good thing we saved the old gr[30], eh? */ 136 #ifdef CONFIG_64BIT 137 if (is_compat_task()) { 138 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n", 139 &compat_frame->uc.uc_mcontext); 140 // FIXME: Load upper half from register file 141 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext, 142 &compat_frame->regs, regs)) 143 goto give_sigsegv; 144 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 145 usp, &compat_frame->uc.uc_stack); 146 if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT) 147 goto give_sigsegv; 148 } else 149 #endif 150 { 151 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n", 152 &frame->uc.uc_mcontext); 153 if (restore_sigcontext(&frame->uc.uc_mcontext, regs)) 154 goto give_sigsegv; 155 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 156 usp, &frame->uc.uc_stack); 157 if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT) 158 goto give_sigsegv; 159 } 160 161 162 163 /* If we are on the syscall path IAOQ will not be restored, and 164 * if we are on the interrupt path we must not corrupt gr31. 165 */ 166 if (in_syscall) 167 regs->gr[31] = regs->iaoq[0]; 168 #if DEBUG_SIG 169 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]); 170 show_regs(regs); 171 #endif 172 return; 173 174 give_sigsegv: 175 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n"); 176 force_sig(SIGSEGV, current); 177 return; 178 } 179 180 /* 181 * Set up a signal frame. 182 */ 183 184 static inline void __user * 185 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size) 186 { 187 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we 188 don't use the parameter it doesn't matter */ 189 190 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n", 191 (unsigned long)ka, sp, frame_size); 192 193 /* Align alternate stack and reserve 64 bytes for the signal 194 handler's frame marker. */ 195 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp)) 196 sp = (current->sas_ss_sp + 0x7f) & ~0x3f; /* Stacks grow up! */ 197 198 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp); 199 return (void __user *) sp; /* Stacks grow up. Fun. */ 200 } 201 202 static long 203 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall) 204 205 { 206 unsigned long flags = 0; 207 long err = 0; 208 209 if (on_sig_stack((unsigned long) sc)) 210 flags |= PARISC_SC_FLAG_ONSTACK; 211 if (in_syscall) { 212 flags |= PARISC_SC_FLAG_IN_SYSCALL; 213 /* regs->iaoq is undefined in the syscall return path */ 214 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]); 215 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]); 216 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]); 217 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]); 218 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n", 219 regs->gr[31], regs->gr[31]+4); 220 } else { 221 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq)); 222 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq)); 223 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n", 224 regs->iaoq[0], regs->iaoq[1]); 225 } 226 227 err |= __put_user(flags, &sc->sc_flags); 228 err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr)); 229 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr)); 230 err |= __put_user(regs->sar, &sc->sc_sar); 231 DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]); 232 233 return err; 234 } 235 236 static long 237 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 238 sigset_t *set, struct pt_regs *regs, int in_syscall) 239 { 240 struct rt_sigframe __user *frame; 241 unsigned long rp, usp; 242 unsigned long haddr, sigframe_size; 243 int err = 0; 244 #ifdef CONFIG_64BIT 245 compat_int_t compat_val; 246 struct compat_rt_sigframe __user * compat_frame; 247 compat_sigset_t compat_set; 248 #endif 249 250 usp = (regs->gr[30] & ~(0x01UL)); 251 /*FIXME: frame_size parameter is unused, remove it. */ 252 frame = get_sigframe(ka, usp, sizeof(*frame)); 253 254 DBG(1,"SETUP_RT_FRAME: START\n"); 255 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info); 256 257 258 #ifdef CONFIG_64BIT 259 260 compat_frame = (struct compat_rt_sigframe __user *)frame; 261 262 if (is_compat_task()) { 263 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info); 264 err |= copy_siginfo_to_user32(&compat_frame->info, info); 265 DBG(1,"SETUP_RT_FRAME: 1\n"); 266 compat_val = (compat_int_t)current->sas_ss_sp; 267 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp); 268 DBG(1,"SETUP_RT_FRAME: 2\n"); 269 compat_val = (compat_int_t)current->sas_ss_size; 270 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size); 271 DBG(1,"SETUP_RT_FRAME: 3\n"); 272 compat_val = sas_ss_flags(regs->gr[30]); 273 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags); 274 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc); 275 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext); 276 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext, 277 &compat_frame->regs, regs, in_syscall); 278 sigset_64to32(&compat_set,set); 279 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set)); 280 } else 281 #endif 282 { 283 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info); 284 err |= copy_siginfo_to_user(&frame->info, info); 285 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 286 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 287 err |= __put_user(sas_ss_flags(regs->gr[30]), 288 &frame->uc.uc_stack.ss_flags); 289 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc); 290 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext); 291 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall); 292 /* FIXME: Should probably be converted as well for the compat case */ 293 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 294 } 295 296 if (err) 297 goto give_sigsegv; 298 299 /* Set up to return from userspace. If provided, use a stub 300 already in userspace. The first words of tramp are used to 301 save the previous sigrestartblock trampoline that might be 302 on the stack. We start the sigreturn trampoline at 303 SIGRESTARTBLOCK_TRAMP+X. */ 304 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0, 305 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]); 306 err |= __put_user(INSN_LDI_R20, 307 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]); 308 err |= __put_user(INSN_BLE_SR2_R0, 309 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]); 310 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]); 311 312 #if DEBUG_SIG 313 /* Assert that we're flushing in the correct space... */ 314 { 315 int sid; 316 asm ("mfsp %%sr3,%0" : "=r" (sid)); 317 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n", 318 sid, frame->tramp); 319 } 320 #endif 321 322 flush_user_dcache_range((unsigned long) &frame->tramp[0], 323 (unsigned long) &frame->tramp[TRAMP_SIZE]); 324 flush_user_icache_range((unsigned long) &frame->tramp[0], 325 (unsigned long) &frame->tramp[TRAMP_SIZE]); 326 327 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP 328 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP 329 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP 330 */ 331 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP]; 332 333 if (err) 334 goto give_sigsegv; 335 336 haddr = A(ka->sa.sa_handler); 337 /* The sa_handler may be a pointer to a function descriptor */ 338 #ifdef CONFIG_64BIT 339 if (is_compat_task()) { 340 #endif 341 if (haddr & PA_PLABEL_FDESC) { 342 Elf32_Fdesc fdesc; 343 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3); 344 345 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc)); 346 347 if (err) 348 goto give_sigsegv; 349 350 haddr = fdesc.addr; 351 regs->gr[19] = fdesc.gp; 352 } 353 #ifdef CONFIG_64BIT 354 } else { 355 Elf64_Fdesc fdesc; 356 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3); 357 358 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc)); 359 360 if (err) 361 goto give_sigsegv; 362 363 haddr = fdesc.addr; 364 regs->gr[19] = fdesc.gp; 365 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n", 366 haddr, regs->gr[19], in_syscall); 367 } 368 #endif 369 370 /* The syscall return path will create IAOQ values from r31. 371 */ 372 sigframe_size = PARISC_RT_SIGFRAME_SIZE; 373 #ifdef CONFIG_64BIT 374 if (is_compat_task()) 375 sigframe_size = PARISC_RT_SIGFRAME_SIZE32; 376 #endif 377 if (in_syscall) { 378 regs->gr[31] = haddr; 379 #ifdef CONFIG_64BIT 380 if (!test_thread_flag(TIF_32BIT)) 381 sigframe_size |= 1; 382 #endif 383 } else { 384 unsigned long psw = USER_PSW; 385 #ifdef CONFIG_64BIT 386 if (!test_thread_flag(TIF_32BIT)) 387 psw |= PSW_W; 388 #endif 389 390 /* If we are singlestepping, arrange a trap to be delivered 391 when we return to userspace. Note the semantics -- we 392 should trap before the first insn in the handler is 393 executed. Ref: 394 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html 395 */ 396 if (pa_psw(current)->r) { 397 pa_psw(current)->r = 0; 398 psw |= PSW_R; 399 mtctl(-1, 0); 400 } 401 402 regs->gr[0] = psw; 403 regs->iaoq[0] = haddr | 3; 404 regs->iaoq[1] = regs->iaoq[0] + 4; 405 } 406 407 regs->gr[2] = rp; /* userland return pointer */ 408 regs->gr[26] = sig; /* signal number */ 409 410 #ifdef CONFIG_64BIT 411 if (is_compat_task()) { 412 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */ 413 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */ 414 } else 415 #endif 416 { 417 regs->gr[25] = A(&frame->info); /* siginfo pointer */ 418 regs->gr[24] = A(&frame->uc); /* ucontext pointer */ 419 } 420 421 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n", 422 regs->gr[30], sigframe_size, 423 regs->gr[30] + sigframe_size); 424 /* Raise the user stack pointer to make a proper call frame. */ 425 regs->gr[30] = (A(frame) + sigframe_size); 426 427 428 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n", 429 current->comm, current->pid, frame, regs->gr[30], 430 regs->iaoq[0], regs->iaoq[1], rp); 431 432 return 1; 433 434 give_sigsegv: 435 DBG(1,"setup_rt_frame: sending SIGSEGV\n"); 436 force_sigsegv(sig, current); 437 return 0; 438 } 439 440 /* 441 * OK, we're invoking a handler. 442 */ 443 444 static void 445 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 446 struct pt_regs *regs, int in_syscall) 447 { 448 sigset_t *oldset = sigmask_to_save(); 449 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n", 450 sig, ka, info, oldset, regs); 451 452 /* Set up the stack frame */ 453 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall)) 454 return; 455 456 signal_delivered(sig, info, ka, regs, 457 test_thread_flag(TIF_SINGLESTEP) || 458 test_thread_flag(TIF_BLOCKSTEP)); 459 460 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n", 461 regs->gr[28]); 462 } 463 464 static inline void 465 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka) 466 { 467 if (regs->orig_r28) 468 return; 469 regs->orig_r28 = 1; /* no more restarts */ 470 /* Check the return code */ 471 switch (regs->gr[28]) { 472 case -ERESTART_RESTARTBLOCK: 473 case -ERESTARTNOHAND: 474 DBG(1,"ERESTARTNOHAND: returning -EINTR\n"); 475 regs->gr[28] = -EINTR; 476 break; 477 478 case -ERESTARTSYS: 479 if (!(ka->sa.sa_flags & SA_RESTART)) { 480 DBG(1,"ERESTARTSYS: putting -EINTR\n"); 481 regs->gr[28] = -EINTR; 482 break; 483 } 484 /* fallthrough */ 485 case -ERESTARTNOINTR: 486 /* A syscall is just a branch, so all 487 * we have to do is fiddle the return pointer. 488 */ 489 regs->gr[31] -= 8; /* delayed branching */ 490 break; 491 } 492 } 493 494 static inline void 495 insert_restart_trampoline(struct pt_regs *regs) 496 { 497 if (regs->orig_r28) 498 return; 499 regs->orig_r28 = 1; /* no more restarts */ 500 switch(regs->gr[28]) { 501 case -ERESTART_RESTARTBLOCK: { 502 /* Restart the system call - no handlers present */ 503 unsigned int *usp = (unsigned int *)regs->gr[30]; 504 505 /* Setup a trampoline to restart the syscall 506 * with __NR_restart_syscall 507 * 508 * 0: <return address (orig r31)> 509 * 4: <2nd half for 64-bit> 510 * 8: ldw 0(%sp), %r31 511 * 12: be 0x100(%sr2, %r0) 512 * 16: ldi __NR_restart_syscall, %r20 513 */ 514 #ifdef CONFIG_64BIT 515 put_user(regs->gr[31] >> 32, &usp[0]); 516 put_user(regs->gr[31] & 0xffffffff, &usp[1]); 517 put_user(0x0fc010df, &usp[2]); 518 #else 519 put_user(regs->gr[31], &usp[0]); 520 put_user(0x0fc0109f, &usp[2]); 521 #endif 522 put_user(0xe0008200, &usp[3]); 523 put_user(0x34140000, &usp[4]); 524 525 /* Stack is 64-byte aligned, and we only need 526 * to flush 1 cache line. 527 * Flushing one cacheline is cheap. 528 * "sync" on bigger (> 4 way) boxes is not. 529 */ 530 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4); 531 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4); 532 533 regs->gr[31] = regs->gr[30] + 8; 534 return; 535 } 536 case -ERESTARTNOHAND: 537 case -ERESTARTSYS: 538 case -ERESTARTNOINTR: { 539 /* Hooray for delayed branching. We don't 540 * have to restore %r20 (the system call 541 * number) because it gets loaded in the delay 542 * slot of the branch external instruction. 543 */ 544 regs->gr[31] -= 8; 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 */ 563 asmlinkage void 564 do_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 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 574 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 575 576 if (signr > 0) { 577 /* Restart a system call if necessary. */ 578 if (in_syscall) 579 syscall_restart(regs, &ka); 580 581 handle_signal(signr, &info, &ka, regs, in_syscall); 582 return; 583 } 584 585 /* Did we come from a system call? */ 586 if (in_syscall) 587 insert_restart_trampoline(regs); 588 589 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 590 regs->gr[28]); 591 592 restore_saved_sigmask(); 593 } 594 595 void do_notify_resume(struct pt_regs *regs, long in_syscall) 596 { 597 if (test_thread_flag(TIF_SIGPENDING)) 598 do_signal(regs, in_syscall); 599 600 if (test_thread_flag(TIF_NOTIFY_RESUME)) { 601 clear_thread_flag(TIF_NOTIFY_RESUME); 602 tracehook_notify_resume(regs); 603 } 604 } 605