1 /* 2 * linux/arch/alpha/kernel/signal.c 3 * 4 * Copyright (C) 1995 Linus Torvalds 5 * 6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson 7 */ 8 9 #include <linux/sched.h> 10 #include <linux/kernel.h> 11 #include <linux/signal.h> 12 #include <linux/errno.h> 13 #include <linux/wait.h> 14 #include <linux/ptrace.h> 15 #include <linux/unistd.h> 16 #include <linux/mm.h> 17 #include <linux/smp.h> 18 #include <linux/stddef.h> 19 #include <linux/tty.h> 20 #include <linux/binfmts.h> 21 #include <linux/bitops.h> 22 #include <linux/syscalls.h> 23 #include <linux/tracehook.h> 24 25 #include <asm/uaccess.h> 26 #include <asm/sigcontext.h> 27 #include <asm/ucontext.h> 28 29 #include "proto.h" 30 31 32 #define DEBUG_SIG 0 33 34 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP))) 35 36 asmlinkage void ret_from_sys_call(void); 37 static void do_signal(struct pt_regs *, struct switch_stack *, 38 unsigned long, unsigned long); 39 40 41 /* 42 * The OSF/1 sigprocmask calling sequence is different from the 43 * C sigprocmask() sequence.. 44 */ 45 SYSCALL_DEFINE2(osf_sigprocmask, int, how, unsigned long, newmask) 46 { 47 sigset_t oldmask; 48 sigset_t mask; 49 unsigned long res; 50 51 siginitset(&mask, newmask & _BLOCKABLE); 52 res = sigprocmask(how, &mask, &oldmask); 53 if (!res) { 54 force_successful_syscall_return(); 55 res = oldmask.sig[0]; 56 } 57 return res; 58 } 59 60 SYSCALL_DEFINE3(osf_sigaction, int, sig, 61 const struct osf_sigaction __user *, act, 62 struct osf_sigaction __user *, oact) 63 { 64 struct k_sigaction new_ka, old_ka; 65 int ret; 66 67 if (act) { 68 old_sigset_t mask; 69 if (!access_ok(VERIFY_READ, act, sizeof(*act)) || 70 __get_user(new_ka.sa.sa_handler, &act->sa_handler) || 71 __get_user(new_ka.sa.sa_flags, &act->sa_flags) || 72 __get_user(mask, &act->sa_mask)) 73 return -EFAULT; 74 siginitset(&new_ka.sa.sa_mask, mask); 75 new_ka.ka_restorer = NULL; 76 } 77 78 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 79 80 if (!ret && oact) { 81 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) || 82 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) || 83 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) || 84 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) 85 return -EFAULT; 86 } 87 88 return ret; 89 } 90 91 SYSCALL_DEFINE5(rt_sigaction, int, sig, const struct sigaction __user *, act, 92 struct sigaction __user *, oact, 93 size_t, sigsetsize, void __user *, restorer) 94 { 95 struct k_sigaction new_ka, old_ka; 96 int ret; 97 98 /* XXX: Don't preclude handling different sized sigset_t's. */ 99 if (sigsetsize != sizeof(sigset_t)) 100 return -EINVAL; 101 102 if (act) { 103 new_ka.ka_restorer = restorer; 104 if (copy_from_user(&new_ka.sa, act, sizeof(*act))) 105 return -EFAULT; 106 } 107 108 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 109 110 if (!ret && oact) { 111 if (copy_to_user(oact, &old_ka.sa, sizeof(*oact))) 112 return -EFAULT; 113 } 114 115 return ret; 116 } 117 118 /* 119 * Atomically swap in the new signal mask, and wait for a signal. 120 */ 121 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask) 122 { 123 mask &= _BLOCKABLE; 124 spin_lock_irq(¤t->sighand->siglock); 125 current->saved_sigmask = current->blocked; 126 siginitset(¤t->blocked, mask); 127 recalc_sigpending(); 128 spin_unlock_irq(¤t->sighand->siglock); 129 130 current->state = TASK_INTERRUPTIBLE; 131 schedule(); 132 set_thread_flag(TIF_RESTORE_SIGMASK); 133 return -ERESTARTNOHAND; 134 } 135 136 asmlinkage int 137 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss) 138 { 139 return do_sigaltstack(uss, uoss, rdusp()); 140 } 141 142 /* 143 * Do a signal return; undo the signal stack. 144 */ 145 146 #if _NSIG_WORDS > 1 147 # error "Non SA_SIGINFO frame needs rearranging" 148 #endif 149 150 struct sigframe 151 { 152 struct sigcontext sc; 153 unsigned int retcode[3]; 154 }; 155 156 struct rt_sigframe 157 { 158 struct siginfo info; 159 struct ucontext uc; 160 unsigned int retcode[3]; 161 }; 162 163 /* If this changes, userland unwinders that Know Things about our signal 164 frame will break. Do not undertake lightly. It also implies an ABI 165 change wrt the size of siginfo_t, which may cause some pain. */ 166 extern char compile_time_assert 167 [offsetof(struct rt_sigframe, uc.uc_mcontext) == 176 ? 1 : -1]; 168 169 #define INSN_MOV_R30_R16 0x47fe0410 170 #define INSN_LDI_R0 0x201f0000 171 #define INSN_CALLSYS 0x00000083 172 173 static long 174 restore_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, 175 struct switch_stack *sw) 176 { 177 unsigned long usp; 178 long i, err = __get_user(regs->pc, &sc->sc_pc); 179 180 current_thread_info()->restart_block.fn = do_no_restart_syscall; 181 182 sw->r26 = (unsigned long) ret_from_sys_call; 183 184 err |= __get_user(regs->r0, sc->sc_regs+0); 185 err |= __get_user(regs->r1, sc->sc_regs+1); 186 err |= __get_user(regs->r2, sc->sc_regs+2); 187 err |= __get_user(regs->r3, sc->sc_regs+3); 188 err |= __get_user(regs->r4, sc->sc_regs+4); 189 err |= __get_user(regs->r5, sc->sc_regs+5); 190 err |= __get_user(regs->r6, sc->sc_regs+6); 191 err |= __get_user(regs->r7, sc->sc_regs+7); 192 err |= __get_user(regs->r8, sc->sc_regs+8); 193 err |= __get_user(sw->r9, sc->sc_regs+9); 194 err |= __get_user(sw->r10, sc->sc_regs+10); 195 err |= __get_user(sw->r11, sc->sc_regs+11); 196 err |= __get_user(sw->r12, sc->sc_regs+12); 197 err |= __get_user(sw->r13, sc->sc_regs+13); 198 err |= __get_user(sw->r14, sc->sc_regs+14); 199 err |= __get_user(sw->r15, sc->sc_regs+15); 200 err |= __get_user(regs->r16, sc->sc_regs+16); 201 err |= __get_user(regs->r17, sc->sc_regs+17); 202 err |= __get_user(regs->r18, sc->sc_regs+18); 203 err |= __get_user(regs->r19, sc->sc_regs+19); 204 err |= __get_user(regs->r20, sc->sc_regs+20); 205 err |= __get_user(regs->r21, sc->sc_regs+21); 206 err |= __get_user(regs->r22, sc->sc_regs+22); 207 err |= __get_user(regs->r23, sc->sc_regs+23); 208 err |= __get_user(regs->r24, sc->sc_regs+24); 209 err |= __get_user(regs->r25, sc->sc_regs+25); 210 err |= __get_user(regs->r26, sc->sc_regs+26); 211 err |= __get_user(regs->r27, sc->sc_regs+27); 212 err |= __get_user(regs->r28, sc->sc_regs+28); 213 err |= __get_user(regs->gp, sc->sc_regs+29); 214 err |= __get_user(usp, sc->sc_regs+30); 215 wrusp(usp); 216 217 for (i = 0; i < 31; i++) 218 err |= __get_user(sw->fp[i], sc->sc_fpregs+i); 219 err |= __get_user(sw->fp[31], &sc->sc_fpcr); 220 221 return err; 222 } 223 224 /* Note that this syscall is also used by setcontext(3) to install 225 a given sigcontext. This because it's impossible to set *all* 226 registers and transfer control from userland. */ 227 228 asmlinkage void 229 do_sigreturn(struct sigcontext __user *sc, struct pt_regs *regs, 230 struct switch_stack *sw) 231 { 232 sigset_t set; 233 234 /* Verify that it's a good sigcontext before using it */ 235 if (!access_ok(VERIFY_READ, sc, sizeof(*sc))) 236 goto give_sigsegv; 237 if (__get_user(set.sig[0], &sc->sc_mask)) 238 goto give_sigsegv; 239 240 sigdelsetmask(&set, ~_BLOCKABLE); 241 spin_lock_irq(¤t->sighand->siglock); 242 current->blocked = set; 243 recalc_sigpending(); 244 spin_unlock_irq(¤t->sighand->siglock); 245 246 if (restore_sigcontext(sc, regs, sw)) 247 goto give_sigsegv; 248 249 /* Send SIGTRAP if we're single-stepping: */ 250 if (ptrace_cancel_bpt (current)) { 251 siginfo_t info; 252 253 info.si_signo = SIGTRAP; 254 info.si_errno = 0; 255 info.si_code = TRAP_BRKPT; 256 info.si_addr = (void __user *) regs->pc; 257 info.si_trapno = 0; 258 send_sig_info(SIGTRAP, &info, current); 259 } 260 return; 261 262 give_sigsegv: 263 force_sig(SIGSEGV, current); 264 } 265 266 asmlinkage void 267 do_rt_sigreturn(struct rt_sigframe __user *frame, struct pt_regs *regs, 268 struct switch_stack *sw) 269 { 270 sigset_t set; 271 272 /* Verify that it's a good ucontext_t before using it */ 273 if (!access_ok(VERIFY_READ, &frame->uc, sizeof(frame->uc))) 274 goto give_sigsegv; 275 if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) 276 goto give_sigsegv; 277 278 sigdelsetmask(&set, ~_BLOCKABLE); 279 spin_lock_irq(¤t->sighand->siglock); 280 current->blocked = set; 281 recalc_sigpending(); 282 spin_unlock_irq(¤t->sighand->siglock); 283 284 if (restore_sigcontext(&frame->uc.uc_mcontext, regs, sw)) 285 goto give_sigsegv; 286 287 /* Send SIGTRAP if we're single-stepping: */ 288 if (ptrace_cancel_bpt (current)) { 289 siginfo_t info; 290 291 info.si_signo = SIGTRAP; 292 info.si_errno = 0; 293 info.si_code = TRAP_BRKPT; 294 info.si_addr = (void __user *) regs->pc; 295 info.si_trapno = 0; 296 send_sig_info(SIGTRAP, &info, current); 297 } 298 return; 299 300 give_sigsegv: 301 force_sig(SIGSEGV, current); 302 } 303 304 305 /* 306 * Set up a signal frame. 307 */ 308 309 static inline void __user * 310 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size) 311 { 312 if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp)) 313 sp = current->sas_ss_sp + current->sas_ss_size; 314 315 return (void __user *)((sp - frame_size) & -32ul); 316 } 317 318 static long 319 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, 320 struct switch_stack *sw, unsigned long mask, unsigned long sp) 321 { 322 long i, err = 0; 323 324 err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack); 325 err |= __put_user(mask, &sc->sc_mask); 326 err |= __put_user(regs->pc, &sc->sc_pc); 327 err |= __put_user(8, &sc->sc_ps); 328 329 err |= __put_user(regs->r0 , sc->sc_regs+0); 330 err |= __put_user(regs->r1 , sc->sc_regs+1); 331 err |= __put_user(regs->r2 , sc->sc_regs+2); 332 err |= __put_user(regs->r3 , sc->sc_regs+3); 333 err |= __put_user(regs->r4 , sc->sc_regs+4); 334 err |= __put_user(regs->r5 , sc->sc_regs+5); 335 err |= __put_user(regs->r6 , sc->sc_regs+6); 336 err |= __put_user(regs->r7 , sc->sc_regs+7); 337 err |= __put_user(regs->r8 , sc->sc_regs+8); 338 err |= __put_user(sw->r9 , sc->sc_regs+9); 339 err |= __put_user(sw->r10 , sc->sc_regs+10); 340 err |= __put_user(sw->r11 , sc->sc_regs+11); 341 err |= __put_user(sw->r12 , sc->sc_regs+12); 342 err |= __put_user(sw->r13 , sc->sc_regs+13); 343 err |= __put_user(sw->r14 , sc->sc_regs+14); 344 err |= __put_user(sw->r15 , sc->sc_regs+15); 345 err |= __put_user(regs->r16, sc->sc_regs+16); 346 err |= __put_user(regs->r17, sc->sc_regs+17); 347 err |= __put_user(regs->r18, sc->sc_regs+18); 348 err |= __put_user(regs->r19, sc->sc_regs+19); 349 err |= __put_user(regs->r20, sc->sc_regs+20); 350 err |= __put_user(regs->r21, sc->sc_regs+21); 351 err |= __put_user(regs->r22, sc->sc_regs+22); 352 err |= __put_user(regs->r23, sc->sc_regs+23); 353 err |= __put_user(regs->r24, sc->sc_regs+24); 354 err |= __put_user(regs->r25, sc->sc_regs+25); 355 err |= __put_user(regs->r26, sc->sc_regs+26); 356 err |= __put_user(regs->r27, sc->sc_regs+27); 357 err |= __put_user(regs->r28, sc->sc_regs+28); 358 err |= __put_user(regs->gp , sc->sc_regs+29); 359 err |= __put_user(sp, sc->sc_regs+30); 360 err |= __put_user(0, sc->sc_regs+31); 361 362 for (i = 0; i < 31; i++) 363 err |= __put_user(sw->fp[i], sc->sc_fpregs+i); 364 err |= __put_user(0, sc->sc_fpregs+31); 365 err |= __put_user(sw->fp[31], &sc->sc_fpcr); 366 367 err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0); 368 err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1); 369 err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2); 370 371 return err; 372 } 373 374 static int 375 setup_frame(int sig, struct k_sigaction *ka, sigset_t *set, 376 struct pt_regs *regs, struct switch_stack * sw) 377 { 378 unsigned long oldsp, r26, err = 0; 379 struct sigframe __user *frame; 380 381 oldsp = rdusp(); 382 frame = get_sigframe(ka, oldsp, sizeof(*frame)); 383 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 384 goto give_sigsegv; 385 386 err |= setup_sigcontext(&frame->sc, regs, sw, set->sig[0], oldsp); 387 if (err) 388 goto give_sigsegv; 389 390 /* Set up to return from userspace. If provided, use a stub 391 already in userspace. */ 392 if (ka->ka_restorer) { 393 r26 = (unsigned long) ka->ka_restorer; 394 } else { 395 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0); 396 err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1); 397 err |= __put_user(INSN_CALLSYS, frame->retcode+2); 398 imb(); 399 r26 = (unsigned long) frame->retcode; 400 } 401 402 /* Check that everything was written properly. */ 403 if (err) 404 goto give_sigsegv; 405 406 /* "Return" to the handler */ 407 regs->r26 = r26; 408 regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler; 409 regs->r16 = sig; /* a0: signal number */ 410 regs->r17 = 0; /* a1: exception code */ 411 regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */ 412 wrusp((unsigned long) frame); 413 414 #if DEBUG_SIG 415 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n", 416 current->comm, current->pid, frame, regs->pc, regs->r26); 417 #endif 418 419 return 0; 420 421 give_sigsegv: 422 force_sigsegv(sig, current); 423 return -EFAULT; 424 } 425 426 static int 427 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info, 428 sigset_t *set, struct pt_regs *regs, struct switch_stack * sw) 429 { 430 unsigned long oldsp, r26, err = 0; 431 struct rt_sigframe __user *frame; 432 433 oldsp = rdusp(); 434 frame = get_sigframe(ka, oldsp, sizeof(*frame)); 435 if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame))) 436 goto give_sigsegv; 437 438 err |= copy_siginfo_to_user(&frame->info, info); 439 440 /* Create the ucontext. */ 441 err |= __put_user(0, &frame->uc.uc_flags); 442 err |= __put_user(0, &frame->uc.uc_link); 443 err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask); 444 err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp); 445 err |= __put_user(sas_ss_flags(oldsp), &frame->uc.uc_stack.ss_flags); 446 err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size); 447 err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, sw, 448 set->sig[0], oldsp); 449 err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)); 450 if (err) 451 goto give_sigsegv; 452 453 /* Set up to return from userspace. If provided, use a stub 454 already in userspace. */ 455 if (ka->ka_restorer) { 456 r26 = (unsigned long) ka->ka_restorer; 457 } else { 458 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0); 459 err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn, 460 frame->retcode+1); 461 err |= __put_user(INSN_CALLSYS, frame->retcode+2); 462 imb(); 463 r26 = (unsigned long) frame->retcode; 464 } 465 466 if (err) 467 goto give_sigsegv; 468 469 /* "Return" to the handler */ 470 regs->r26 = r26; 471 regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler; 472 regs->r16 = sig; /* a0: signal number */ 473 regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */ 474 regs->r18 = (unsigned long) &frame->uc; /* a2: ucontext pointer */ 475 wrusp((unsigned long) frame); 476 477 #if DEBUG_SIG 478 printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n", 479 current->comm, current->pid, frame, regs->pc, regs->r26); 480 #endif 481 482 return 0; 483 484 give_sigsegv: 485 force_sigsegv(sig, current); 486 return -EFAULT; 487 } 488 489 490 /* 491 * OK, we're invoking a handler. 492 */ 493 static inline int 494 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info, 495 sigset_t *oldset, struct pt_regs * regs, struct switch_stack *sw) 496 { 497 int ret; 498 499 if (ka->sa.sa_flags & SA_SIGINFO) 500 ret = setup_rt_frame(sig, ka, info, oldset, regs, sw); 501 else 502 ret = setup_frame(sig, ka, oldset, regs, sw); 503 504 if (ret == 0) { 505 spin_lock_irq(¤t->sighand->siglock); 506 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 507 if (!(ka->sa.sa_flags & SA_NODEFER)) 508 sigaddset(¤t->blocked,sig); 509 recalc_sigpending(); 510 spin_unlock_irq(¤t->sighand->siglock); 511 } 512 513 return ret; 514 } 515 516 static inline void 517 syscall_restart(unsigned long r0, unsigned long r19, 518 struct pt_regs *regs, struct k_sigaction *ka) 519 { 520 switch (regs->r0) { 521 case ERESTARTSYS: 522 if (!(ka->sa.sa_flags & SA_RESTART)) { 523 case ERESTARTNOHAND: 524 regs->r0 = EINTR; 525 break; 526 } 527 /* fallthrough */ 528 case ERESTARTNOINTR: 529 regs->r0 = r0; /* reset v0 and a3 and replay syscall */ 530 regs->r19 = r19; 531 regs->pc -= 4; 532 break; 533 case ERESTART_RESTARTBLOCK: 534 regs->r0 = EINTR; 535 break; 536 } 537 } 538 539 540 /* 541 * Note that 'init' is a special process: it doesn't get signals it doesn't 542 * want to handle. Thus you cannot kill init even with a SIGKILL even by 543 * mistake. 544 * 545 * Note that we go through the signals twice: once to check the signals that 546 * the kernel can handle, and then we build all the user-level signal handling 547 * stack-frames in one go after that. 548 * 549 * "r0" and "r19" are the registers we need to restore for system call 550 * restart. "r0" is also used as an indicator whether we can restart at 551 * all (if we get here from anything but a syscall return, it will be 0) 552 */ 553 static void 554 do_signal(struct pt_regs * regs, struct switch_stack * sw, 555 unsigned long r0, unsigned long r19) 556 { 557 siginfo_t info; 558 int signr; 559 unsigned long single_stepping = ptrace_cancel_bpt(current); 560 struct k_sigaction ka; 561 sigset_t *oldset; 562 563 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 564 oldset = ¤t->saved_sigmask; 565 else 566 oldset = ¤t->blocked; 567 568 /* This lets the debugger run, ... */ 569 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 570 571 /* ... so re-check the single stepping. */ 572 single_stepping |= ptrace_cancel_bpt(current); 573 574 if (signr > 0) { 575 /* Whee! Actually deliver the signal. */ 576 if (r0) 577 syscall_restart(r0, r19, regs, &ka); 578 if (handle_signal(signr, &ka, &info, oldset, regs, sw) == 0) { 579 /* A signal was successfully delivered, and the 580 saved sigmask was stored on the signal frame, 581 and will be restored by sigreturn. So we can 582 simply clear the restore sigmask flag. */ 583 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 584 clear_thread_flag(TIF_RESTORE_SIGMASK); 585 } 586 if (single_stepping) 587 ptrace_set_bpt(current); /* re-set bpt */ 588 return; 589 } 590 591 if (r0) { 592 switch (regs->r0) { 593 case ERESTARTNOHAND: 594 case ERESTARTSYS: 595 case ERESTARTNOINTR: 596 /* Reset v0 and a3 and replay syscall. */ 597 regs->r0 = r0; 598 regs->r19 = r19; 599 regs->pc -= 4; 600 break; 601 case ERESTART_RESTARTBLOCK: 602 /* Force v0 to the restart syscall and reply. */ 603 regs->r0 = __NR_restart_syscall; 604 regs->pc -= 4; 605 break; 606 } 607 } 608 609 /* If there's no signal to deliver, we just restore the saved mask. */ 610 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 611 clear_thread_flag(TIF_RESTORE_SIGMASK); 612 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 613 } 614 615 if (single_stepping) 616 ptrace_set_bpt(current); /* re-set breakpoint */ 617 } 618 619 void 620 do_notify_resume(struct pt_regs *regs, struct switch_stack *sw, 621 unsigned long thread_info_flags, 622 unsigned long r0, unsigned long r19) 623 { 624 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK)) 625 do_signal(regs, sw, r0, r19); 626 627 if (thread_info_flags & _TIF_NOTIFY_RESUME) { 628 clear_thread_flag(TIF_NOTIFY_RESUME); 629 tracehook_notify_resume(regs); 630 if (current->replacement_session_keyring) 631 key_replace_session_keyring(); 632 } 633 } 634