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