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