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