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 52 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 53 54 /* gcc will complain if a pointer is cast to an integer of different 55 * size. If you really need to do this (and we do for an ELF32 user 56 * application in an ELF64 kernel) then you have to do a cast to an 57 * integer of the same size first. The A() macro accomplishes 58 * this. */ 59 #define A(__x) ((unsigned long)(__x)) 60 61 /* 62 * Atomically swap in the new signal mask, and wait for a signal. 63 */ 64 #ifdef CONFIG_64BIT 65 #include "sys32.h" 66 #endif 67 68 /* 69 * Do a signal return - restore sigcontext. 70 */ 71 72 /* Trampoline for calling rt_sigreturn() */ 73 #define INSN_LDI_R25_0 0x34190000 /* ldi 0,%r25 (in_syscall=0) */ 74 #define INSN_LDI_R25_1 0x34190002 /* ldi 1,%r25 (in_syscall=1) */ 75 #define INSN_LDI_R20 0x3414015a /* ldi __NR_rt_sigreturn,%r20 */ 76 #define INSN_BLE_SR2_R0 0xe4008200 /* be,l 0x100(%sr2,%r0),%sr0,%r31 */ 77 #define INSN_NOP 0x08000240 /* nop */ 78 /* For debugging */ 79 #define INSN_DIE_HORRIBLY 0x68000ccc /* stw %r0,0x666(%sr0,%r0) */ 80 81 static long 82 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs) 83 { 84 long err = 0; 85 86 err |= __copy_from_user(regs->gr, sc->sc_gr, sizeof(regs->gr)); 87 err |= __copy_from_user(regs->fr, sc->sc_fr, sizeof(regs->fr)); 88 err |= __copy_from_user(regs->iaoq, sc->sc_iaoq, sizeof(regs->iaoq)); 89 err |= __copy_from_user(regs->iasq, sc->sc_iasq, sizeof(regs->iasq)); 90 err |= __get_user(regs->sar, &sc->sc_sar); 91 DBG(2,"restore_sigcontext: iaoq is 0x%#lx / 0x%#lx\n", 92 regs->iaoq[0],regs->iaoq[1]); 93 DBG(2,"restore_sigcontext: r28 is %ld\n", regs->gr[28]); 94 return err; 95 } 96 97 void 98 sys_rt_sigreturn(struct pt_regs *regs, int in_syscall) 99 { 100 struct rt_sigframe __user *frame; 101 sigset_t set; 102 unsigned long usp = (regs->gr[30] & ~(0x01UL)); 103 unsigned long sigframe_size = PARISC_RT_SIGFRAME_SIZE; 104 #ifdef CONFIG_64BIT 105 compat_sigset_t compat_set; 106 struct compat_rt_sigframe __user * compat_frame; 107 108 if (is_compat_task()) 109 sigframe_size = PARISC_RT_SIGFRAME_SIZE32; 110 #endif 111 112 113 /* Unwind the user stack to get the rt_sigframe structure. */ 114 frame = (struct rt_sigframe __user *) 115 (usp - sigframe_size); 116 DBG(2,"sys_rt_sigreturn: frame is %p\n", frame); 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 sigdelsetmask(&set, ~_BLOCKABLE); 134 spin_lock_irq(¤t->sighand->siglock); 135 current->blocked = set; 136 recalc_sigpending(); 137 spin_unlock_irq(¤t->sighand->siglock); 138 139 /* Good thing we saved the old gr[30], eh? */ 140 #ifdef CONFIG_64BIT 141 if (is_compat_task()) { 142 DBG(1,"sys_rt_sigreturn: compat_frame->uc.uc_mcontext 0x%p\n", 143 &compat_frame->uc.uc_mcontext); 144 // FIXME: Load upper half from register file 145 if (restore_sigcontext32(&compat_frame->uc.uc_mcontext, 146 &compat_frame->regs, regs)) 147 goto give_sigsegv; 148 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 149 usp, &compat_frame->uc.uc_stack); 150 if (do_sigaltstack32(&compat_frame->uc.uc_stack, NULL, usp) == -EFAULT) 151 goto give_sigsegv; 152 } else 153 #endif 154 { 155 DBG(1,"sys_rt_sigreturn: frame->uc.uc_mcontext 0x%p\n", 156 &frame->uc.uc_mcontext); 157 if (restore_sigcontext(&frame->uc.uc_mcontext, regs)) 158 goto give_sigsegv; 159 DBG(1,"sys_rt_sigreturn: usp %#08lx stack 0x%p\n", 160 usp, &frame->uc.uc_stack); 161 if (do_sigaltstack(&frame->uc.uc_stack, NULL, usp) == -EFAULT) 162 goto give_sigsegv; 163 } 164 165 166 167 /* If we are on the syscall path IAOQ will not be restored, and 168 * if we are on the interrupt path we must not corrupt gr31. 169 */ 170 if (in_syscall) 171 regs->gr[31] = regs->iaoq[0]; 172 #if DEBUG_SIG 173 DBG(1,"sys_rt_sigreturn: returning to %#lx, DUMPING REGS:\n", regs->iaoq[0]); 174 show_regs(regs); 175 #endif 176 return; 177 178 give_sigsegv: 179 DBG(1,"sys_rt_sigreturn: Sending SIGSEGV\n"); 180 force_sig(SIGSEGV, current); 181 return; 182 } 183 184 /* 185 * Set up a signal frame. 186 */ 187 188 static inline void __user * 189 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size) 190 { 191 /*FIXME: ELF32 vs. ELF64 has different frame_size, but since we 192 don't use the parameter it doesn't matter */ 193 194 DBG(1,"get_sigframe: ka = %#lx, sp = %#lx, frame_size = %#lx\n", 195 (unsigned long)ka, sp, frame_size); 196 197 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp)) 198 sp = current->sas_ss_sp; /* Stacks grow up! */ 199 200 DBG(1,"get_sigframe: Returning sp = %#lx\n", (unsigned long)sp); 201 return (void __user *) sp; /* Stacks grow up. Fun. */ 202 } 203 204 static long 205 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, int in_syscall) 206 207 { 208 unsigned long flags = 0; 209 long err = 0; 210 211 if (on_sig_stack((unsigned long) sc)) 212 flags |= PARISC_SC_FLAG_ONSTACK; 213 if (in_syscall) { 214 flags |= PARISC_SC_FLAG_IN_SYSCALL; 215 /* regs->iaoq is undefined in the syscall return path */ 216 err |= __put_user(regs->gr[31], &sc->sc_iaoq[0]); 217 err |= __put_user(regs->gr[31]+4, &sc->sc_iaoq[1]); 218 err |= __put_user(regs->sr[3], &sc->sc_iasq[0]); 219 err |= __put_user(regs->sr[3], &sc->sc_iasq[1]); 220 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (in syscall)\n", 221 regs->gr[31], regs->gr[31]+4); 222 } else { 223 err |= __copy_to_user(sc->sc_iaoq, regs->iaoq, sizeof(regs->iaoq)); 224 err |= __copy_to_user(sc->sc_iasq, regs->iasq, sizeof(regs->iasq)); 225 DBG(1,"setup_sigcontext: iaoq %#lx / %#lx (not in syscall)\n", 226 regs->iaoq[0], regs->iaoq[1]); 227 } 228 229 err |= __put_user(flags, &sc->sc_flags); 230 err |= __copy_to_user(sc->sc_gr, regs->gr, sizeof(regs->gr)); 231 err |= __copy_to_user(sc->sc_fr, regs->fr, sizeof(regs->fr)); 232 err |= __put_user(regs->sar, &sc->sc_sar); 233 DBG(1,"setup_sigcontext: r28 is %ld\n", regs->gr[28]); 234 235 return err; 236 } 237 238 static long 239 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 240 sigset_t *set, struct pt_regs *regs, int in_syscall) 241 { 242 struct rt_sigframe __user *frame; 243 unsigned long rp, usp; 244 unsigned long haddr, sigframe_size; 245 int err = 0; 246 #ifdef CONFIG_64BIT 247 compat_int_t compat_val; 248 struct compat_rt_sigframe __user * compat_frame; 249 compat_sigset_t compat_set; 250 #endif 251 252 usp = (regs->gr[30] & ~(0x01UL)); 253 /*FIXME: frame_size parameter is unused, remove it. */ 254 frame = get_sigframe(ka, usp, sizeof(*frame)); 255 256 DBG(1,"SETUP_RT_FRAME: START\n"); 257 DBG(1,"setup_rt_frame: frame %p info %p\n", frame, info); 258 259 260 #ifdef CONFIG_64BIT 261 262 compat_frame = (struct compat_rt_sigframe __user *)frame; 263 264 if (is_compat_task()) { 265 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &compat_frame->info); 266 err |= copy_siginfo_to_user32(&compat_frame->info, info); 267 DBG(1,"SETUP_RT_FRAME: 1\n"); 268 compat_val = (compat_int_t)current->sas_ss_sp; 269 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_sp); 270 DBG(1,"SETUP_RT_FRAME: 2\n"); 271 compat_val = (compat_int_t)current->sas_ss_size; 272 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_size); 273 DBG(1,"SETUP_RT_FRAME: 3\n"); 274 compat_val = sas_ss_flags(regs->gr[30]); 275 err |= __put_user(compat_val, &compat_frame->uc.uc_stack.ss_flags); 276 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &compat_frame->uc); 277 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &compat_frame->uc.uc_mcontext); 278 err |= setup_sigcontext32(&compat_frame->uc.uc_mcontext, 279 &compat_frame->regs, regs, in_syscall); 280 sigset_64to32(&compat_set,set); 281 err |= __copy_to_user(&compat_frame->uc.uc_sigmask, &compat_set, sizeof(compat_set)); 282 } else 283 #endif 284 { 285 DBG(1,"setup_rt_frame: frame->info = 0x%p\n", &frame->info); 286 err |= copy_siginfo_to_user(&frame->info, info); 287 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 288 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 289 err |= __put_user(sas_ss_flags(regs->gr[30]), 290 &frame->uc.uc_stack.ss_flags); 291 DBG(1,"setup_rt_frame: frame->uc = 0x%p\n", &frame->uc); 292 DBG(1,"setup_rt_frame: frame->uc.uc_mcontext = 0x%p\n", &frame->uc.uc_mcontext); 293 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, in_syscall); 294 /* FIXME: Should probably be converted aswell for the compat case */ 295 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 296 } 297 298 if (err) 299 goto give_sigsegv; 300 301 /* Set up to return from userspace. If provided, use a stub 302 already in userspace. The first words of tramp are used to 303 save the previous sigrestartblock trampoline that might be 304 on the stack. We start the sigreturn trampoline at 305 SIGRESTARTBLOCK_TRAMP+X. */ 306 err |= __put_user(in_syscall ? INSN_LDI_R25_1 : INSN_LDI_R25_0, 307 &frame->tramp[SIGRESTARTBLOCK_TRAMP+0]); 308 err |= __put_user(INSN_LDI_R20, 309 &frame->tramp[SIGRESTARTBLOCK_TRAMP+1]); 310 err |= __put_user(INSN_BLE_SR2_R0, 311 &frame->tramp[SIGRESTARTBLOCK_TRAMP+2]); 312 err |= __put_user(INSN_NOP, &frame->tramp[SIGRESTARTBLOCK_TRAMP+3]); 313 314 #if DEBUG_SIG 315 /* Assert that we're flushing in the correct space... */ 316 { 317 int sid; 318 asm ("mfsp %%sr3,%0" : "=r" (sid)); 319 DBG(1,"setup_rt_frame: Flushing 64 bytes at space %#x offset %p\n", 320 sid, frame->tramp); 321 } 322 #endif 323 324 flush_user_dcache_range((unsigned long) &frame->tramp[0], 325 (unsigned long) &frame->tramp[TRAMP_SIZE]); 326 flush_user_icache_range((unsigned long) &frame->tramp[0], 327 (unsigned long) &frame->tramp[TRAMP_SIZE]); 328 329 /* TRAMP Words 0-4, Length 5 = SIGRESTARTBLOCK_TRAMP 330 * TRAMP Words 5-9, Length 4 = SIGRETURN_TRAMP 331 * So the SIGRETURN_TRAMP is at the end of SIGRESTARTBLOCK_TRAMP 332 */ 333 rp = (unsigned long) &frame->tramp[SIGRESTARTBLOCK_TRAMP]; 334 335 if (err) 336 goto give_sigsegv; 337 338 haddr = A(ka->sa.sa_handler); 339 /* The sa_handler may be a pointer to a function descriptor */ 340 #ifdef CONFIG_64BIT 341 if (is_compat_task()) { 342 #endif 343 if (haddr & PA_PLABEL_FDESC) { 344 Elf32_Fdesc fdesc; 345 Elf32_Fdesc __user *ufdesc = (Elf32_Fdesc __user *)A(haddr & ~3); 346 347 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc)); 348 349 if (err) 350 goto give_sigsegv; 351 352 haddr = fdesc.addr; 353 regs->gr[19] = fdesc.gp; 354 } 355 #ifdef CONFIG_64BIT 356 } else { 357 Elf64_Fdesc fdesc; 358 Elf64_Fdesc __user *ufdesc = (Elf64_Fdesc __user *)A(haddr & ~3); 359 360 err = __copy_from_user(&fdesc, ufdesc, sizeof(fdesc)); 361 362 if (err) 363 goto give_sigsegv; 364 365 haddr = fdesc.addr; 366 regs->gr[19] = fdesc.gp; 367 DBG(1,"setup_rt_frame: 64 bit signal, exe=%#lx, r19=%#lx, in_syscall=%d\n", 368 haddr, regs->gr[19], in_syscall); 369 } 370 #endif 371 372 /* The syscall return path will create IAOQ values from r31. 373 */ 374 sigframe_size = PARISC_RT_SIGFRAME_SIZE; 375 #ifdef CONFIG_64BIT 376 if (is_compat_task()) 377 sigframe_size = PARISC_RT_SIGFRAME_SIZE32; 378 #endif 379 if (in_syscall) { 380 regs->gr[31] = haddr; 381 #ifdef CONFIG_64BIT 382 if (!test_thread_flag(TIF_32BIT)) 383 sigframe_size |= 1; 384 #endif 385 } else { 386 unsigned long psw = USER_PSW; 387 #ifdef CONFIG_64BIT 388 if (!test_thread_flag(TIF_32BIT)) 389 psw |= PSW_W; 390 #endif 391 392 /* If we are singlestepping, arrange a trap to be delivered 393 when we return to userspace. Note the semantics -- we 394 should trap before the first insn in the handler is 395 executed. Ref: 396 http://sources.redhat.com/ml/gdb/2004-11/msg00245.html 397 */ 398 if (pa_psw(current)->r) { 399 pa_psw(current)->r = 0; 400 psw |= PSW_R; 401 mtctl(-1, 0); 402 } 403 404 regs->gr[0] = psw; 405 regs->iaoq[0] = haddr | 3; 406 regs->iaoq[1] = regs->iaoq[0] + 4; 407 } 408 409 regs->gr[2] = rp; /* userland return pointer */ 410 regs->gr[26] = sig; /* signal number */ 411 412 #ifdef CONFIG_64BIT 413 if (is_compat_task()) { 414 regs->gr[25] = A(&compat_frame->info); /* siginfo pointer */ 415 regs->gr[24] = A(&compat_frame->uc); /* ucontext pointer */ 416 } else 417 #endif 418 { 419 regs->gr[25] = A(&frame->info); /* siginfo pointer */ 420 regs->gr[24] = A(&frame->uc); /* ucontext pointer */ 421 } 422 423 DBG(1,"setup_rt_frame: making sigreturn frame: %#lx + %#lx = %#lx\n", 424 regs->gr[30], sigframe_size, 425 regs->gr[30] + sigframe_size); 426 /* Raise the user stack pointer to make a proper call frame. */ 427 regs->gr[30] = (A(frame) + sigframe_size); 428 429 430 DBG(1,"setup_rt_frame: sig deliver (%s,%d) frame=0x%p sp=%#lx iaoq=%#lx/%#lx rp=%#lx\n", 431 current->comm, current->pid, frame, regs->gr[30], 432 regs->iaoq[0], regs->iaoq[1], rp); 433 434 return 1; 435 436 give_sigsegv: 437 DBG(1,"setup_rt_frame: sending SIGSEGV\n"); 438 force_sigsegv(sig, current); 439 return 0; 440 } 441 442 /* 443 * OK, we're invoking a handler. 444 */ 445 446 static long 447 handle_signal(unsigned long sig, siginfo_t *info, struct k_sigaction *ka, 448 sigset_t *oldset, struct pt_regs *regs, int in_syscall) 449 { 450 DBG(1,"handle_signal: sig=%ld, ka=%p, info=%p, oldset=%p, regs=%p\n", 451 sig, ka, info, oldset, regs); 452 453 /* Set up the stack frame */ 454 if (!setup_rt_frame(sig, ka, info, oldset, regs, in_syscall)) 455 return 0; 456 457 spin_lock_irq(¤t->sighand->siglock); 458 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 459 if (!(ka->sa.sa_flags & SA_NODEFER)) 460 sigaddset(¤t->blocked,sig); 461 recalc_sigpending(); 462 spin_unlock_irq(¤t->sighand->siglock); 463 464 tracehook_signal_handler(sig, info, ka, regs, 465 test_thread_flag(TIF_SINGLESTEP) || 466 test_thread_flag(TIF_BLOCKSTEP)); 467 468 return 1; 469 } 470 471 static inline void 472 syscall_restart(struct pt_regs *regs, struct k_sigaction *ka) 473 { 474 /* Check the return code */ 475 switch (regs->gr[28]) { 476 case -ERESTART_RESTARTBLOCK: 477 current_thread_info()->restart_block.fn = 478 do_no_restart_syscall; 479 case -ERESTARTNOHAND: 480 DBG(1,"ERESTARTNOHAND: returning -EINTR\n"); 481 regs->gr[28] = -EINTR; 482 break; 483 484 case -ERESTARTSYS: 485 if (!(ka->sa.sa_flags & SA_RESTART)) { 486 DBG(1,"ERESTARTSYS: putting -EINTR\n"); 487 regs->gr[28] = -EINTR; 488 break; 489 } 490 /* fallthrough */ 491 case -ERESTARTNOINTR: 492 /* A syscall is just a branch, so all 493 * we have to do is fiddle the return pointer. 494 */ 495 regs->gr[31] -= 8; /* delayed branching */ 496 /* Preserve original r28. */ 497 regs->gr[28] = regs->orig_r28; 498 break; 499 } 500 } 501 502 static inline void 503 insert_restart_trampoline(struct pt_regs *regs) 504 { 505 switch(regs->gr[28]) { 506 case -ERESTART_RESTARTBLOCK: { 507 /* Restart the system call - no handlers present */ 508 unsigned int *usp = (unsigned int *)regs->gr[30]; 509 510 /* Setup a trampoline to restart the syscall 511 * with __NR_restart_syscall 512 * 513 * 0: <return address (orig r31)> 514 * 4: <2nd half for 64-bit> 515 * 8: ldw 0(%sp), %r31 516 * 12: be 0x100(%sr2, %r0) 517 * 16: ldi __NR_restart_syscall, %r20 518 */ 519 #ifdef CONFIG_64BIT 520 put_user(regs->gr[31] >> 32, &usp[0]); 521 put_user(regs->gr[31] & 0xffffffff, &usp[1]); 522 put_user(0x0fc010df, &usp[2]); 523 #else 524 put_user(regs->gr[31], &usp[0]); 525 put_user(0x0fc0109f, &usp[2]); 526 #endif 527 put_user(0xe0008200, &usp[3]); 528 put_user(0x34140000, &usp[4]); 529 530 /* Stack is 64-byte aligned, and we only need 531 * to flush 1 cache line. 532 * Flushing one cacheline is cheap. 533 * "sync" on bigger (> 4 way) boxes is not. 534 */ 535 flush_user_dcache_range(regs->gr[30], regs->gr[30] + 4); 536 flush_user_icache_range(regs->gr[30], regs->gr[30] + 4); 537 538 regs->gr[31] = regs->gr[30] + 8; 539 /* Preserve original r28. */ 540 regs->gr[28] = regs->orig_r28; 541 542 return; 543 } 544 case -ERESTARTNOHAND: 545 case -ERESTARTSYS: 546 case -ERESTARTNOINTR: { 547 /* Hooray for delayed branching. We don't 548 * have to restore %r20 (the system call 549 * number) because it gets loaded in the delay 550 * slot of the branch external instruction. 551 */ 552 regs->gr[31] -= 8; 553 /* Preserve original r28. */ 554 regs->gr[28] = regs->orig_r28; 555 556 return; 557 } 558 default: 559 break; 560 } 561 } 562 563 /* 564 * Note that 'init' is a special process: it doesn't get signals it doesn't 565 * want to handle. Thus you cannot kill init even with a SIGKILL even by 566 * mistake. 567 * 568 * We need to be able to restore the syscall arguments (r21-r26) to 569 * restart syscalls. Thus, the syscall path should save them in the 570 * pt_regs structure (it's okay to do so since they are caller-save 571 * registers). As noted below, the syscall number gets restored for 572 * us due to the magic of delayed branching. 573 */ 574 asmlinkage void 575 do_signal(struct pt_regs *regs, long in_syscall) 576 { 577 siginfo_t info; 578 struct k_sigaction ka; 579 int signr; 580 sigset_t *oldset; 581 582 DBG(1,"\ndo_signal: oldset=0x%p, regs=0x%p, sr7 %#lx, in_syscall=%d\n", 583 oldset, regs, regs->sr[7], in_syscall); 584 585 /* Everyone else checks to see if they are in kernel mode at 586 this point and exits if that's the case. I'm not sure why 587 we would be called in that case, but for some reason we 588 are. */ 589 590 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 591 oldset = ¤t->saved_sigmask; 592 else 593 oldset = ¤t->blocked; 594 595 DBG(1,"do_signal: oldset %08lx / %08lx\n", 596 oldset->sig[0], oldset->sig[1]); 597 598 599 /* May need to force signal if handle_signal failed to deliver */ 600 while (1) { 601 602 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 603 DBG(3,"do_signal: signr = %d, regs->gr[28] = %ld\n", signr, regs->gr[28]); 604 605 if (signr <= 0) 606 break; 607 608 /* Restart a system call if necessary. */ 609 if (in_syscall) 610 syscall_restart(regs, &ka); 611 612 /* Whee! Actually deliver the signal. If the 613 delivery failed, we need to continue to iterate in 614 this loop so we can deliver the SIGSEGV... */ 615 if (handle_signal(signr, &info, &ka, oldset, 616 regs, in_syscall)) { 617 DBG(1,KERN_DEBUG "do_signal: Exit (success), regs->gr[28] = %ld\n", 618 regs->gr[28]); 619 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 620 clear_thread_flag(TIF_RESTORE_SIGMASK); 621 return; 622 } 623 } 624 /* end of while(1) looping forever if we can't force a signal */ 625 626 /* Did we come from a system call? */ 627 if (in_syscall) 628 insert_restart_trampoline(regs); 629 630 DBG(1,"do_signal: Exit (not delivered), regs->gr[28] = %ld\n", 631 regs->gr[28]); 632 633 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 634 clear_thread_flag(TIF_RESTORE_SIGMASK); 635 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 636 } 637 638 return; 639 } 640 641 void do_notify_resume(struct pt_regs *regs, long in_syscall) 642 { 643 if (test_thread_flag(TIF_SIGPENDING) || 644 test_thread_flag(TIF_RESTORE_SIGMASK)) 645 do_signal(regs, in_syscall); 646 647 if (test_thread_flag(TIF_NOTIFY_RESUME)) { 648 clear_thread_flag(TIF_NOTIFY_RESUME); 649 tracehook_notify_resume(regs); 650 if (current->replacement_session_keyring) 651 key_replace_session_keyring(); 652 } 653 } 654