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