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