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