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 <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  * 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_thread_info()->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 k_sigaction *ka, unsigned long sp, size_t frame_size)
 276 {
 277         if ((ka->sa.sa_flags & SA_ONSTACK) != 0 && ! sas_ss_flags(sp))
 278                 sp = current->sas_ss_sp + current->sas_ss_size;
 279
 280         return (void __user *)((sp - frame_size) & -32ul);
 281 }
 282
 283 static long
 284 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 285                  unsigned long mask, unsigned long sp)
 286 {
 287         struct switch_stack *sw = (struct switch_stack *)regs - 1;
 288         long i, err = 0;
 289
 290         err |= __put_user(on_sig_stack((unsigned long)sc), &sc->sc_onstack);
 291         err |= __put_user(mask, &sc->sc_mask);
 292         err |= __put_user(regs->pc, &sc->sc_pc);
 293         err |= __put_user(8, &sc->sc_ps);
 294
 295         err |= __put_user(regs->r0 , sc->sc_regs+0);
 296         err |= __put_user(regs->r1 , sc->sc_regs+1);
 297         err |= __put_user(regs->r2 , sc->sc_regs+2);
 298         err |= __put_user(regs->r3 , sc->sc_regs+3);
 299         err |= __put_user(regs->r4 , sc->sc_regs+4);
 300         err |= __put_user(regs->r5 , sc->sc_regs+5);
 301         err |= __put_user(regs->r6 , sc->sc_regs+6);
 302         err |= __put_user(regs->r7 , sc->sc_regs+7);
 303         err |= __put_user(regs->r8 , sc->sc_regs+8);
 304         err |= __put_user(sw->r9   , sc->sc_regs+9);
 305         err |= __put_user(sw->r10  , sc->sc_regs+10);
 306         err |= __put_user(sw->r11  , sc->sc_regs+11);
 307         err |= __put_user(sw->r12  , sc->sc_regs+12);
 308         err |= __put_user(sw->r13  , sc->sc_regs+13);
 309         err |= __put_user(sw->r14  , sc->sc_regs+14);
 310         err |= __put_user(sw->r15  , sc->sc_regs+15);
 311         err |= __put_user(regs->r16, sc->sc_regs+16);
 312         err |= __put_user(regs->r17, sc->sc_regs+17);
 313         err |= __put_user(regs->r18, sc->sc_regs+18);
 314         err |= __put_user(regs->r19, sc->sc_regs+19);
 315         err |= __put_user(regs->r20, sc->sc_regs+20);
 316         err |= __put_user(regs->r21, sc->sc_regs+21);
 317         err |= __put_user(regs->r22, sc->sc_regs+22);
 318         err |= __put_user(regs->r23, sc->sc_regs+23);
 319         err |= __put_user(regs->r24, sc->sc_regs+24);
 320         err |= __put_user(regs->r25, sc->sc_regs+25);
 321         err |= __put_user(regs->r26, sc->sc_regs+26);
 322         err |= __put_user(regs->r27, sc->sc_regs+27);
 323         err |= __put_user(regs->r28, sc->sc_regs+28);
 324         err |= __put_user(regs->gp , sc->sc_regs+29);
 325         err |= __put_user(sp, sc->sc_regs+30);
 326         err |= __put_user(0, sc->sc_regs+31);
 327
 328         for (i = 0; i < 31; i++)
 329                 err |= __put_user(sw->fp[i], sc->sc_fpregs+i);
 330         err |= __put_user(0, sc->sc_fpregs+31);
 331         err |= __put_user(sw->fp[31], &sc->sc_fpcr);
 332
 333         err |= __put_user(regs->trap_a0, &sc->sc_traparg_a0);
 334         err |= __put_user(regs->trap_a1, &sc->sc_traparg_a1);
 335         err |= __put_user(regs->trap_a2, &sc->sc_traparg_a2);
 336
 337         return err;
 338 }
 339
 340 static int
 341 setup_frame(int sig, struct k_sigaction *ka, sigset_t *set,
 342             struct pt_regs *regs)
 343 {
 344         unsigned long oldsp, r26, err = 0;
 345         struct sigframe __user *frame;
 346
 347         oldsp = rdusp();
 348         frame = get_sigframe(ka, oldsp, sizeof(*frame));
 349         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 350                 return -EFAULT;
 351
 352         err |= setup_sigcontext(&frame->sc, regs, set->sig[0], oldsp);
 353         if (err)
 354                 return -EFAULT;
 355
 356         /* Set up to return from userspace.  If provided, use a stub
 357            already in userspace.  */
 358         if (ka->ka_restorer) {
 359                 r26 = (unsigned long) ka->ka_restorer;
 360         } else {
 361                 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
 362                 err |= __put_user(INSN_LDI_R0+__NR_sigreturn, frame->retcode+1);
 363                 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
 364                 imb();
 365                 r26 = (unsigned long) frame->retcode;
 366         }
 367
 368         /* Check that everything was written properly.  */
 369         if (err)
 370                 return err;
 371
 372         /* "Return" to the handler */
 373         regs->r26 = r26;
 374         regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
 375         regs->r16 = sig;                        /* a0: signal number */
 376         regs->r17 = 0;                          /* a1: exception code */
 377         regs->r18 = (unsigned long) &frame->sc; /* a2: sigcontext pointer */
 378         wrusp((unsigned long) frame);
 379
 380 #if DEBUG_SIG
 381         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 382                 current->comm, current->pid, frame, regs->pc, regs->r26);
 383 #endif
 384         return 0;
 385 }
 386
 387 static int
 388 setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 389                sigset_t *set, struct pt_regs *regs)
 390 {
 391         unsigned long oldsp, r26, err = 0;
 392         struct rt_sigframe __user *frame;
 393
 394         oldsp = rdusp();
 395         frame = get_sigframe(ka, oldsp, sizeof(*frame));
 396         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 397                 return -EFAULT;
 398
 399         err |= copy_siginfo_to_user(&frame->info, info);
 400
 401         /* Create the ucontext.  */
 402         err |= __put_user(0, &frame->uc.uc_flags);
 403         err |= __put_user(0, &frame->uc.uc_link);
 404         err |= __put_user(set->sig[0], &frame->uc.uc_osf_sigmask);
 405         err |= __save_altstack(&frame->uc.uc_stack, oldsp);
 406         err |= setup_sigcontext(&frame->uc.uc_mcontext, regs,
 407                                 set->sig[0], oldsp);
 408         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 409         if (err)
 410                 return -EFAULT;
 411
 412         /* Set up to return from userspace.  If provided, use a stub
 413            already in userspace.  */
 414         if (ka->ka_restorer) {
 415                 r26 = (unsigned long) ka->ka_restorer;
 416         } else {
 417                 err |= __put_user(INSN_MOV_R30_R16, frame->retcode+0);
 418                 err |= __put_user(INSN_LDI_R0+__NR_rt_sigreturn,
 419                                   frame->retcode+1);
 420                 err |= __put_user(INSN_CALLSYS, frame->retcode+2);
 421                 imb();
 422                 r26 = (unsigned long) frame->retcode;
 423         }
 424
 425         if (err)
 426                 return -EFAULT;
 427
 428         /* "Return" to the handler */
 429         regs->r26 = r26;
 430         regs->r27 = regs->pc = (unsigned long) ka->sa.sa_handler;
 431         regs->r16 = sig;                          /* a0: signal number */
 432         regs->r17 = (unsigned long) &frame->info; /* a1: siginfo pointer */
 433         regs->r18 = (unsigned long) &frame->uc;   /* a2: ucontext pointer */
 434         wrusp((unsigned long) frame);
 435
 436 #if DEBUG_SIG
 437         printk("SIG deliver (%s:%d): sp=%p pc=%p ra=%p\n",
 438                 current->comm, current->pid, frame, regs->pc, regs->r26);
 439 #endif
 440
 441         return 0;
 442 }
 443
 444
 445 /*
 446  * OK, we're invoking a handler.
 447  */
 448 static inline void
 449 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
 450               struct pt_regs * regs)
 451 {
 452         sigset_t *oldset = sigmask_to_save();
 453         int ret;
 454
 455         if (ka->sa.sa_flags & SA_SIGINFO)
 456                 ret = setup_rt_frame(sig, ka, info, oldset, regs);
 457         else
 458                 ret = setup_frame(sig, ka, oldset, regs);
 459
 460         if (ret) {
 461                 force_sigsegv(sig, current);
 462                 return;
 463         }
 464         signal_delivered(sig, info, ka, regs, 0);
 465 }
 466
 467 static inline void
 468 syscall_restart(unsigned long r0, unsigned long r19,
 469                 struct pt_regs *regs, struct k_sigaction *ka)
 470 {
 471         switch (regs->r0) {
 472         case ERESTARTSYS:
 473                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 474                 case ERESTARTNOHAND:
 475                         regs->r0 = EINTR;
 476                         break;
 477                 }
 478                 /* fallthrough */
 479         case ERESTARTNOINTR:
 480                 regs->r0 = r0;  /* reset v0 and a3 and replay syscall */
 481                 regs->r19 = r19;
 482                 regs->pc -= 4;
 483                 break;
 484         case ERESTART_RESTARTBLOCK:
 485                 regs->r0 = EINTR;
 486                 break;
 487         }
 488 }
 489
 490
 491 /*
 492  * Note that 'init' is a special process: it doesn't get signals it doesn't
 493  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 494  * mistake.
 495  *
 496  * Note that we go through the signals twice: once to check the signals that
 497  * the kernel can handle, and then we build all the user-level signal handling
 498  * stack-frames in one go after that.
 499  *
 500  * "r0" and "r19" are the registers we need to restore for system call
 501  * restart. "r0" is also used as an indicator whether we can restart at
 502  * all (if we get here from anything but a syscall return, it will be 0)
 503  */
 504 static void
 505 do_signal(struct pt_regs *regs, unsigned long r0, unsigned long r19)
 506 {
 507         siginfo_t info;
 508         int signr;
 509         unsigned long single_stepping = ptrace_cancel_bpt(current);
 510         struct k_sigaction ka;
 511
 512         /* This lets the debugger run, ... */
 513         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 514
 515         /* ... so re-check the single stepping. */
 516         single_stepping |= ptrace_cancel_bpt(current);
 517
 518         if (signr > 0) {
 519                 /* Whee!  Actually deliver the signal.  */
 520                 if (r0)
 521                         syscall_restart(r0, r19, regs, &ka);
 522                 handle_signal(signr, &ka, &info, regs);
 523                 if (single_stepping)
 524                         ptrace_set_bpt(current); /* re-set bpt */
 525                 return;
 526         }
 527
 528         if (r0) {
 529                 switch (regs->r0) {
 530                 case ERESTARTNOHAND:
 531                 case ERESTARTSYS:
 532                 case ERESTARTNOINTR:
 533                         /* Reset v0 and a3 and replay syscall.  */
 534                         regs->r0 = r0;
 535                         regs->r19 = r19;
 536                         regs->pc -= 4;
 537                         break;
 538                 case ERESTART_RESTARTBLOCK:
 539                         /* Force v0 to the restart syscall and reply.  */
 540                         regs->r0 = __NR_restart_syscall;
 541                         regs->pc -= 4;
 542                         break;
 543                 }
 544         }
 545
 546         /* If there's no signal to deliver, we just restore the saved mask.  */
 547         restore_saved_sigmask();
 548         if (single_stepping)
 549                 ptrace_set_bpt(current);        /* re-set breakpoint */
 550 }
 551
 552 void
 553 do_work_pending(struct pt_regs *regs, unsigned long thread_flags,
 554                  unsigned long r0, unsigned long r19)
 555 {
 556         do {
 557                 if (thread_flags & _TIF_NEED_RESCHED) {
 558                         schedule();
 559                 } else {
 560                         local_irq_enable();
 561                         if (thread_flags & _TIF_SIGPENDING) {
 562                                 do_signal(regs, r0, r19);
 563                                 r0 = 0;
 564                         } else {
 565                                 clear_thread_flag(TIF_NOTIFY_RESUME);
 566                                 tracehook_notify_resume(regs);
 567                         }
 568                 }
 569                 local_irq_disable();
 570                 thread_flags = current_thread_info()->flags;
 571         } while (thread_flags & _TIF_WORK_MASK);
 572 }