arch/alpha/kernel/signal.c

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