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