1/* 2 * This file is subject to the terms and conditions of the GNU General Public 3 * License. See the file "COPYING" in the main directory of this archive 4 * for more details. 5 * 6 * Copyright (C) 1991, 1992 Linus Torvalds 7 * Copyright (C) 1994 - 2000 Ralf Baechle 8 * Copyright (C) 1999, 2000 Silicon Graphics, Inc. 9 */ 10#include <linux/cache.h> 11#include <linux/sched.h> 12#include <linux/mm.h> 13#include <linux/personality.h> 14#include <linux/smp.h> 15#include <linux/kernel.h> 16#include <linux/signal.h> 17#include <linux/errno.h> 18#include <linux/wait.h> 19#include <linux/ptrace.h> 20#include <linux/unistd.h> 21#include <linux/compiler.h> 22#include <linux/uaccess.h> 23 24#include <asm/abi.h> 25#include <asm/asm.h> 26#include <linux/bitops.h> 27#include <asm/cacheflush.h> 28#include <asm/fpu.h> 29#include <asm/sim.h> 30#include <asm/ucontext.h> 31#include <asm/cpu-features.h> 32#include <asm/war.h> 33 34#include "signal-common.h" 35 36/* 37 * Horribly complicated - with the bloody RM9000 workarounds enabled 38 * the signal trampolines is moving to the end of the structure so we can 39 * increase the alignment without breaking software compatibility. 40 */ 41#if ICACHE_REFILLS_WORKAROUND_WAR == 0 42 43struct sigframe { 44 u32 sf_ass[4]; /* argument save space for o32 */ 45 u32 sf_code[2]; /* signal trampoline */ 46 struct sigcontext sf_sc; 47 sigset_t sf_mask; 48}; 49 50struct rt_sigframe { 51 u32 rs_ass[4]; /* argument save space for o32 */ 52 u32 rs_code[2]; /* signal trampoline */ 53 struct siginfo rs_info; 54 struct ucontext rs_uc; 55}; 56 57#else 58 59struct sigframe { 60 u32 sf_ass[4]; /* argument save space for o32 */ 61 u32 sf_pad[2]; 62 struct sigcontext sf_sc; /* hw context */ 63 sigset_t sf_mask; 64 u32 sf_code[8] ____cacheline_aligned; /* signal trampoline */ 65}; 66 67struct rt_sigframe { 68 u32 rs_ass[4]; /* argument save space for o32 */ 69 u32 rs_pad[2]; 70 struct siginfo rs_info; 71 struct ucontext rs_uc; 72 u32 rs_code[8] ____cacheline_aligned; /* signal trampoline */ 73}; 74 75#endif 76 77/* 78 * Helper routines 79 */ 80static int protected_save_fp_context(struct sigcontext __user *sc) 81{ 82 int err; 83 while (1) { 84 lock_fpu_owner(); 85 own_fpu_inatomic(1); 86 err = save_fp_context(sc); /* this might fail */ 87 unlock_fpu_owner(); 88 if (likely(!err)) 89 break; 90 /* touch the sigcontext and try again */ 91 err = __put_user(0, &sc->sc_fpregs[0]) | 92 __put_user(0, &sc->sc_fpregs[31]) | 93 __put_user(0, &sc->sc_fpc_csr); 94 if (err) 95 break; /* really bad sigcontext */ 96 } 97 return err; 98} 99 100static int protected_restore_fp_context(struct sigcontext __user *sc) 101{ 102 int err, tmp; 103 while (1) { 104 lock_fpu_owner(); 105 own_fpu_inatomic(0); 106 err = restore_fp_context(sc); /* this might fail */ 107 unlock_fpu_owner(); 108 if (likely(!err)) 109 break; 110 /* touch the sigcontext and try again */ 111 err = __get_user(tmp, &sc->sc_fpregs[0]) | 112 __get_user(tmp, &sc->sc_fpregs[31]) | 113 __get_user(tmp, &sc->sc_fpc_csr); 114 if (err) 115 break; /* really bad sigcontext */ 116 } 117 return err; 118} 119 120int setup_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc) 121{ 122 int err = 0; 123 int i; 124 unsigned int used_math; 125 126 err |= __put_user(regs->cp0_epc, &sc->sc_pc); 127 128 err |= __put_user(0, &sc->sc_regs[0]); 129 for (i = 1; i < 32; i++) 130 err |= __put_user(regs->regs[i], &sc->sc_regs[i]); 131 132#ifdef CONFIG_CPU_HAS_SMARTMIPS 133 err |= __put_user(regs->acx, &sc->sc_acx); 134#endif 135 err |= __put_user(regs->hi, &sc->sc_mdhi); 136 err |= __put_user(regs->lo, &sc->sc_mdlo); 137 if (cpu_has_dsp) { 138 err |= __put_user(mfhi1(), &sc->sc_hi1); 139 err |= __put_user(mflo1(), &sc->sc_lo1); 140 err |= __put_user(mfhi2(), &sc->sc_hi2); 141 err |= __put_user(mflo2(), &sc->sc_lo2); 142 err |= __put_user(mfhi3(), &sc->sc_hi3); 143 err |= __put_user(mflo3(), &sc->sc_lo3); 144 err |= __put_user(rddsp(DSP_MASK), &sc->sc_dsp); 145 } 146 147 used_math = !!used_math(); 148 err |= __put_user(used_math, &sc->sc_used_math); 149 150 if (used_math) { 151 /* 152 * Save FPU state to signal context. Signal handler 153 * will "inherit" current FPU state. 154 */ 155 err |= protected_save_fp_context(sc); 156 } 157 return err; 158} 159 160int fpcsr_pending(unsigned int __user *fpcsr) 161{ 162 int err, sig = 0; 163 unsigned int csr, enabled; 164 165 err = __get_user(csr, fpcsr); 166 enabled = FPU_CSR_UNI_X | ((csr & FPU_CSR_ALL_E) << 5); 167 /* 168 * If the signal handler set some FPU exceptions, clear it and 169 * send SIGFPE. 170 */ 171 if (csr & enabled) { 172 csr &= ~enabled; 173 err |= __put_user(csr, fpcsr); 174 sig = SIGFPE; 175 } 176 return err ?: sig; 177} 178 179static int 180check_and_restore_fp_context(struct sigcontext __user *sc) 181{ 182 int err, sig; 183 184 err = sig = fpcsr_pending(&sc->sc_fpc_csr); 185 if (err > 0) 186 err = 0; 187 err |= protected_restore_fp_context(sc); 188 return err ?: sig; 189} 190 191int restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc) 192{ 193 unsigned int used_math; 194 unsigned long treg; 195 int err = 0; 196 int i; 197 198 /* Always make any pending restarted system calls return -EINTR */ 199 current_thread_info()->restart_block.fn = do_no_restart_syscall; 200 201 err |= __get_user(regs->cp0_epc, &sc->sc_pc); 202 203#ifdef CONFIG_CPU_HAS_SMARTMIPS 204 err |= __get_user(regs->acx, &sc->sc_acx); 205#endif 206 err |= __get_user(regs->hi, &sc->sc_mdhi); 207 err |= __get_user(regs->lo, &sc->sc_mdlo); 208 if (cpu_has_dsp) { 209 err |= __get_user(treg, &sc->sc_hi1); mthi1(treg); 210 err |= __get_user(treg, &sc->sc_lo1); mtlo1(treg); 211 err |= __get_user(treg, &sc->sc_hi2); mthi2(treg); 212 err |= __get_user(treg, &sc->sc_lo2); mtlo2(treg); 213 err |= __get_user(treg, &sc->sc_hi3); mthi3(treg); 214 err |= __get_user(treg, &sc->sc_lo3); mtlo3(treg); 215 err |= __get_user(treg, &sc->sc_dsp); wrdsp(treg, DSP_MASK); 216 } 217 218 for (i = 1; i < 32; i++) 219 err |= __get_user(regs->regs[i], &sc->sc_regs[i]); 220 221 err |= __get_user(used_math, &sc->sc_used_math); 222 conditional_used_math(used_math); 223 224 if (used_math) { 225 /* restore fpu context if we have used it before */ 226 if (!err) 227 err = check_and_restore_fp_context(sc); 228 } else { 229 /* signal handler may have used FPU. Give it up. */ 230 lose_fpu(0); 231 } 232 233 return err; 234} 235 236void __user *get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, 237 size_t frame_size) 238{ 239 unsigned long sp; 240 241 /* Default to using normal stack */ 242 sp = regs->regs[29]; 243 244 /* 245 * FPU emulator may have it's own trampoline active just 246 * above the user stack, 16-bytes before the next lowest 247 * 16 byte boundary. Try to avoid trashing it. 248 */ 249 sp -= 32; 250 251 /* This is the X/Open sanctioned signal stack switching. */ 252 if ((ka->sa.sa_flags & SA_ONSTACK) && (sas_ss_flags (sp) == 0)) 253 sp = current->sas_ss_sp + current->sas_ss_size; 254 255 return (void __user *)((sp - frame_size) & (ICACHE_REFILLS_WORKAROUND_WAR ? ~(cpu_icache_line_size()-1) : ALMASK)); 256} 257 258int install_sigtramp(unsigned int __user *tramp, unsigned int syscall) 259{ 260 int err; 261 262 /* 263 * Set up the return code ... 264 * 265 * li v0, __NR__foo_sigreturn 266 * syscall 267 */ 268 269 err = __put_user(0x24020000 + syscall, tramp + 0); 270 err |= __put_user(0x0000000c , tramp + 1); 271 if (ICACHE_REFILLS_WORKAROUND_WAR) { 272 err |= __put_user(0, tramp + 2); 273 err |= __put_user(0, tramp + 3); 274 err |= __put_user(0, tramp + 4); 275 err |= __put_user(0, tramp + 5); 276 err |= __put_user(0, tramp + 6); 277 err |= __put_user(0, tramp + 7); 278 } 279 flush_cache_sigtramp((unsigned long) tramp); 280 281 return err; 282} 283 284/* 285 * Atomically swap in the new signal mask, and wait for a signal. 286 */ 287 288#ifdef CONFIG_TRAD_SIGNALS 289asmlinkage int sys_sigsuspend(nabi_no_regargs struct pt_regs regs) 290{ 291 sigset_t newset; 292 sigset_t __user *uset; 293 294 uset = (sigset_t __user *) regs.regs[4]; 295 if (copy_from_user(&newset, uset, sizeof(sigset_t))) 296 return -EFAULT; 297 sigdelsetmask(&newset, ~_BLOCKABLE); 298 299 spin_lock_irq(¤t->sighand->siglock); 300 current->saved_sigmask = current->blocked; 301 current->blocked = newset; 302 recalc_sigpending(); 303 spin_unlock_irq(¤t->sighand->siglock); 304 305 current->state = TASK_INTERRUPTIBLE; 306 schedule(); 307 set_thread_flag(TIF_RESTORE_SIGMASK); 308 return -ERESTARTNOHAND; 309} 310#endif 311 312asmlinkage int sys_rt_sigsuspend(nabi_no_regargs struct pt_regs regs) 313{ 314 sigset_t newset; 315 sigset_t __user *unewset; 316 size_t sigsetsize; 317 318 sigsetsize = regs.regs[5]; 319 if (sigsetsize != sizeof(sigset_t)) 320 return -EINVAL; 321 322 unewset = (sigset_t __user *) regs.regs[4]; 323 if (copy_from_user(&newset, unewset, sizeof(newset))) 324 return -EFAULT; 325 sigdelsetmask(&newset, ~_BLOCKABLE); 326 327 spin_lock_irq(¤t->sighand->siglock); 328 current->saved_sigmask = current->blocked; 329 current->blocked = newset; 330 recalc_sigpending(); 331 spin_unlock_irq(¤t->sighand->siglock); 332 333 current->state = TASK_INTERRUPTIBLE; 334 schedule(); 335 set_thread_flag(TIF_RESTORE_SIGMASK); 336 return -ERESTARTNOHAND; 337} 338 339#ifdef CONFIG_TRAD_SIGNALS 340asmlinkage int sys_sigaction(int sig, const struct sigaction __user *act, 341 struct sigaction __user *oact) 342{ 343 struct k_sigaction new_ka, old_ka; 344 int ret; 345 int err = 0; 346 347 if (act) { 348 old_sigset_t mask; 349 350 if (!access_ok(VERIFY_READ, act, sizeof(*act))) 351 return -EFAULT; 352 err |= __get_user(new_ka.sa.sa_handler, &act->sa_handler); 353 err |= __get_user(new_ka.sa.sa_flags, &act->sa_flags); 354 err |= __get_user(mask, &act->sa_mask.sig[0]); 355 if (err) 356 return -EFAULT; 357 358 siginitset(&new_ka.sa.sa_mask, mask); 359 } 360 361 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 362 363 if (!ret && oact) { 364 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact))) 365 return -EFAULT; 366 err |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); 367 err |= __put_user(old_ka.sa.sa_handler, &oact->sa_handler); 368 err |= __put_user(old_ka.sa.sa_mask.sig[0], oact->sa_mask.sig); 369 err |= __put_user(0, &oact->sa_mask.sig[1]); 370 err |= __put_user(0, &oact->sa_mask.sig[2]); 371 err |= __put_user(0, &oact->sa_mask.sig[3]); 372 if (err) 373 return -EFAULT; 374 } 375 376 return ret; 377} 378#endif 379 380asmlinkage int sys_sigaltstack(nabi_no_regargs struct pt_regs regs) 381{ 382 const stack_t __user *uss = (const stack_t __user *) regs.regs[4]; 383 stack_t __user *uoss = (stack_t __user *) regs.regs[5]; 384 unsigned long usp = regs.regs[29]; 385 386 return do_sigaltstack(uss, uoss, usp); 387} 388 389#ifdef CONFIG_TRAD_SIGNALS 390asmlinkage void sys_sigreturn(nabi_no_regargs struct pt_regs regs) 391{ 392 struct sigframe __user *frame; 393 sigset_t blocked; 394 int sig; 395 396 frame = (struct sigframe __user *) regs.regs[29]; 397 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 398 goto badframe; 399 if (__copy_from_user(&blocked, &frame->sf_mask, sizeof(blocked))) 400 goto badframe; 401 402 sigdelsetmask(&blocked, ~_BLOCKABLE); 403 spin_lock_irq(¤t->sighand->siglock); 404 current->blocked = blocked; 405 recalc_sigpending(); 406 spin_unlock_irq(¤t->sighand->siglock); 407 408 sig = restore_sigcontext(®s, &frame->sf_sc); 409 if (sig < 0) 410 goto badframe; 411 else if (sig) 412 force_sig(sig, current); 413 414 /* 415 * Don't let your children do this ... 416 */ 417 __asm__ __volatile__( 418 "move\t$29, %0\n\t" 419 "j\tsyscall_exit" 420 :/* no outputs */ 421 :"r" (®s)); 422 /* Unreached */ 423 424badframe: 425 force_sig(SIGSEGV, current); 426} 427#endif /* CONFIG_TRAD_SIGNALS */ 428 429asmlinkage void sys_rt_sigreturn(nabi_no_regargs struct pt_regs regs) 430{ 431 struct rt_sigframe __user *frame; 432 sigset_t set; 433 stack_t st; 434 int sig; 435 436 frame = (struct rt_sigframe __user *) regs.regs[29]; 437 if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) 438 goto badframe; 439 if (__copy_from_user(&set, &frame->rs_uc.uc_sigmask, sizeof(set))) 440 goto badframe; 441 442 sigdelsetmask(&set, ~_BLOCKABLE); 443 spin_lock_irq(¤t->sighand->siglock); 444 current->blocked = set; 445 recalc_sigpending(); 446 spin_unlock_irq(¤t->sighand->siglock); 447 448 sig = restore_sigcontext(®s, &frame->rs_uc.uc_mcontext); 449 if (sig < 0) 450 goto badframe; 451 else if (sig) 452 force_sig(sig, current); 453 454 if (__copy_from_user(&st, &frame->rs_uc.uc_stack, sizeof(st))) 455 goto badframe; 456 /* It is more difficult to avoid calling this function than to 457 call it and ignore errors. */ 458 do_sigaltstack((stack_t __user *)&st, NULL, regs.regs[29]); 459 460 /* 461 * Don't let your children do this ... 462 */ 463 __asm__ __volatile__( 464 "move\t$29, %0\n\t" 465 "j\tsyscall_exit" 466 :/* no outputs */ 467 :"r" (®s)); 468 /* Unreached */ 469 470badframe: 471 force_sig(SIGSEGV, current); 472} 473 474#ifdef CONFIG_TRAD_SIGNALS 475static int setup_frame(struct k_sigaction * ka, struct pt_regs *regs, 476 int signr, sigset_t *set) 477{ 478 struct sigframe __user *frame; 479 int err = 0; 480 481 frame = get_sigframe(ka, regs, sizeof(*frame)); 482 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 483 goto give_sigsegv; 484 485 err |= install_sigtramp(frame->sf_code, __NR_sigreturn); 486 487 err |= setup_sigcontext(regs, &frame->sf_sc); 488 err |= __copy_to_user(&frame->sf_mask, set, sizeof(*set)); 489 if (err) 490 goto give_sigsegv; 491 492 /* 493 * Arguments to signal handler: 494 * 495 * a0 = signal number 496 * a1 = 0 (should be cause) 497 * a2 = pointer to struct sigcontext 498 * 499 * $25 and c0_epc point to the signal handler, $29 points to the 500 * struct sigframe. 501 */ 502 regs->regs[ 4] = signr; 503 regs->regs[ 5] = 0; 504 regs->regs[ 6] = (unsigned long) &frame->sf_sc; 505 regs->regs[29] = (unsigned long) frame; 506 regs->regs[31] = (unsigned long) frame->sf_code; 507 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 508 509 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 510 current->comm, current->pid, 511 frame, regs->cp0_epc, regs->regs[31]); 512 return 0; 513 514give_sigsegv: 515 force_sigsegv(signr, current); 516 return -EFAULT; 517} 518#endif 519 520static int setup_rt_frame(struct k_sigaction * ka, struct pt_regs *regs, 521 int signr, sigset_t *set, siginfo_t *info) 522{ 523 struct rt_sigframe __user *frame; 524 int err = 0; 525 526 frame = get_sigframe(ka, regs, sizeof(*frame)); 527 if (!access_ok(VERIFY_WRITE, frame, sizeof (*frame))) 528 goto give_sigsegv; 529 530 err |= install_sigtramp(frame->rs_code, __NR_rt_sigreturn); 531 532 /* Create siginfo. */ 533 err |= copy_siginfo_to_user(&frame->rs_info, info); 534 535 /* Create the ucontext. */ 536 err |= __put_user(0, &frame->rs_uc.uc_flags); 537 err |= __put_user(NULL, &frame->rs_uc.uc_link); 538 err |= __put_user((void __user *)current->sas_ss_sp, 539 &frame->rs_uc.uc_stack.ss_sp); 540 err |= __put_user(sas_ss_flags(regs->regs[29]), 541 &frame->rs_uc.uc_stack.ss_flags); 542 err |= __put_user(current->sas_ss_size, 543 &frame->rs_uc.uc_stack.ss_size); 544 err |= setup_sigcontext(regs, &frame->rs_uc.uc_mcontext); 545 err |= __copy_to_user(&frame->rs_uc.uc_sigmask, set, sizeof(*set)); 546 547 if (err) 548 goto give_sigsegv; 549 550 /* 551 * Arguments to signal handler: 552 * 553 * a0 = signal number 554 * a1 = 0 (should be cause) 555 * a2 = pointer to ucontext 556 * 557 * $25 and c0_epc point to the signal handler, $29 points to 558 * the struct rt_sigframe. 559 */ 560 regs->regs[ 4] = signr; 561 regs->regs[ 5] = (unsigned long) &frame->rs_info; 562 regs->regs[ 6] = (unsigned long) &frame->rs_uc; 563 regs->regs[29] = (unsigned long) frame; 564 regs->regs[31] = (unsigned long) frame->rs_code; 565 regs->cp0_epc = regs->regs[25] = (unsigned long) ka->sa.sa_handler; 566 567 DEBUGP("SIG deliver (%s:%d): sp=0x%p pc=0x%lx ra=0x%lx\n", 568 current->comm, current->pid, 569 frame, regs->cp0_epc, regs->regs[31]); 570 571 return 0; 572 573give_sigsegv: 574 force_sigsegv(signr, current); 575 return -EFAULT; 576} 577 578struct mips_abi mips_abi = { 579#ifdef CONFIG_TRAD_SIGNALS 580 .setup_frame = setup_frame, 581#endif 582 .setup_rt_frame = setup_rt_frame, 583 .restart = __NR_restart_syscall 584}; 585 586static int handle_signal(unsigned long sig, siginfo_t *info, 587 struct k_sigaction *ka, sigset_t *oldset, struct pt_regs *regs) 588{ 589 int ret; 590 591 switch(regs->regs[0]) { 592 case ERESTART_RESTARTBLOCK: 593 case ERESTARTNOHAND: 594 regs->regs[2] = EINTR; 595 break; 596 case ERESTARTSYS: 597 if (!(ka->sa.sa_flags & SA_RESTART)) { 598 regs->regs[2] = EINTR; 599 break; 600 } 601 /* fallthrough */ 602 case ERESTARTNOINTR: /* Userland will reload $v0. */ 603 regs->regs[7] = regs->regs[26]; 604 regs->cp0_epc -= 8; 605 } 606 607 regs->regs[0] = 0; /* Don't deal with this again. */ 608 609 if (sig_uses_siginfo(ka)) 610 ret = current->thread.abi->setup_rt_frame(ka, regs, sig, oldset, info); 611 else 612 ret = current->thread.abi->setup_frame(ka, regs, sig, oldset); 613 614 spin_lock_irq(¤t->sighand->siglock); 615 sigorsets(¤t->blocked,¤t->blocked,&ka->sa.sa_mask); 616 if (!(ka->sa.sa_flags & SA_NODEFER)) 617 sigaddset(¤t->blocked,sig); 618 recalc_sigpending(); 619 spin_unlock_irq(¤t->sighand->siglock); 620 621 return ret; 622} 623 624static void do_signal(struct pt_regs *regs) 625{ 626 struct k_sigaction ka; 627 sigset_t *oldset; 628 siginfo_t info; 629 int signr; 630 631 /* 632 * We want the common case to go fast, which is why we may in certain 633 * cases get here from kernel mode. Just return without doing anything 634 * if so. 635 */ 636 if (!user_mode(regs)) 637 return; 638 639 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 640 oldset = ¤t->saved_sigmask; 641 else 642 oldset = ¤t->blocked; 643 644 signr = get_signal_to_deliver(&info, &ka, regs, NULL); 645 if (signr > 0) { 646 /* Whee! Actually deliver the signal. */ 647 if (handle_signal(signr, &info, &ka, oldset, regs) == 0) { 648 /* 649 * A signal was successfully delivered; the saved 650 * sigmask will have been stored in the signal frame, 651 * and will be restored by sigreturn, so we can simply 652 * clear the TIF_RESTORE_SIGMASK flag. 653 */ 654 if (test_thread_flag(TIF_RESTORE_SIGMASK)) 655 clear_thread_flag(TIF_RESTORE_SIGMASK); 656 } 657 658 return; 659 } 660 661 /* 662 * Who's code doesn't conform to the restartable syscall convention 663 * dies here!!! The li instruction, a single machine instruction, 664 * must directly be followed by the syscall instruction. 665 */ 666 if (regs->regs[0]) { 667 if (regs->regs[2] == ERESTARTNOHAND || 668 regs->regs[2] == ERESTARTSYS || 669 regs->regs[2] == ERESTARTNOINTR) { 670 regs->regs[7] = regs->regs[26]; 671 regs->cp0_epc -= 8; 672 } 673 if (regs->regs[2] == ERESTART_RESTARTBLOCK) { 674 regs->regs[2] = current->thread.abi->restart; 675 regs->regs[7] = regs->regs[26]; 676 regs->cp0_epc -= 4; 677 } 678 regs->regs[0] = 0; /* Don't deal with this again. */ 679 } 680 681 /* 682 * If there's no signal to deliver, we just put the saved sigmask 683 * back 684 */ 685 if (test_thread_flag(TIF_RESTORE_SIGMASK)) { 686 clear_thread_flag(TIF_RESTORE_SIGMASK); 687 sigprocmask(SIG_SETMASK, ¤t->saved_sigmask, NULL); 688 } 689} 690 691/* 692 * notification of userspace execution resumption 693 * - triggered by the TIF_WORK_MASK flags 694 */ 695asmlinkage void do_notify_resume(struct pt_regs *regs, void *unused, 696 __u32 thread_info_flags) 697{ 698 /* deal with pending signal delivery */ 699 if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK)) 700 do_signal(regs); 701} 702