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