arch/cris/arch-v10/kernel/signal.c

   1 /*
   2  *  linux/arch/cris/kernel/signal.c
   3  *
   4  *  Based on arch/i386/kernel/signal.c by
   5  *     Copyright (C) 1991, 1992  Linus Torvalds
   6  *     1997-11-28  Modified for POSIX.1b signals by Richard Henderson *
   7  *
   8  *  Ideas also taken from arch/arm.
   9  *
  10  *  Copyright (C) 2000, 2001 Axis Communications AB
  11  *
  12  *  Authors:  Bjorn Wesen (bjornw@axis.com)
  13  *
  14  */
  15
  16 #include <linux/sched.h>
  17 #include <linux/mm.h>
  18 #include <linux/smp.h>
  19 #include <linux/smp_lock.h>
  20 #include <linux/kernel.h>
  21 #include <linux/signal.h>
  22 #include <linux/errno.h>
  23 #include <linux/wait.h>
  24 #include <linux/ptrace.h>
  25 #include <linux/unistd.h>
  26 #include <linux/stddef.h>
  27
  28 #include <asm/processor.h>
  29 #include <asm/ucontext.h>
  30 #include <asm/uaccess.h>
  31
  32 #define DEBUG_SIG 0
  33
  34 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  35
  36 /* a syscall in Linux/CRIS is a break 13 instruction which is 2 bytes */
  37 /* manipulate regs so that upon return, it will be re-executed */
  38
  39 /* We rely on that pc points to the instruction after "break 13", so the
  40  * library must never do strange things like putting it in a delay slot.
  41  */
  42 #define RESTART_CRIS_SYS(regs) regs->r10 = regs->orig_r10; regs->irp -= 2;
  43
  44 int do_signal(int canrestart, sigset_t *oldset, struct pt_regs *regs);
  45
  46 /*
  47  * Atomically swap in the new signal mask, and wait for a signal.  Define
  48  * dummy arguments to be able to reach the regs argument.  (Note that this
  49  * arrangement relies on old_sigset_t occupying one register.)
  50  */
  51 int
  52 sys_sigsuspend(old_sigset_t mask, long r11, long r12, long r13, long mof,
  53                long srp, struct pt_regs *regs)
  54 {
  55         sigset_t saveset;
  56
  57         mask &= _BLOCKABLE;
  58         spin_lock_irq(&current->sighand->siglock);
  59         saveset = current->blocked;
  60         siginitset(&current->blocked, mask);
  61         recalc_sigpending();
  62         spin_unlock_irq(&current->sighand->siglock);
  63
  64         regs->r10 = -EINTR;
  65         while (1) {
  66                 current->state = TASK_INTERRUPTIBLE;
  67                 schedule();
  68                 if (do_signal(0, &saveset, regs))
  69                         /* We will get here twice: once to call the signal
  70                            handler, then again to return from the
  71                            sigsuspend system call.  When calling the
  72                            signal handler, R10 holds the signal number as
  73                            set through do_signal.  The sigsuspend call
  74                            will return with the restored value set above;
  75                            always -EINTR.  */
  76                         return regs->r10;
  77         }
  78 }
  79
  80 /* Define dummy arguments to be able to reach the regs argument.  (Note that
  81  * this arrangement relies on size_t occupying one register.)
  82  */
  83 int
  84 sys_rt_sigsuspend(sigset_t *unewset, size_t sigsetsize, long r12, long r13,
  85                   long mof, long srp, struct pt_regs *regs)
  86 {
  87         sigset_t saveset, newset;
  88
  89         /* XXX: Don't preclude handling different sized sigset_t's.  */
  90         if (sigsetsize != sizeof(sigset_t))
  91                 return -EINVAL;
  92
  93         if (copy_from_user(&newset, unewset, sizeof(newset)))
  94                 return -EFAULT;
  95         sigdelsetmask(&newset, ~_BLOCKABLE);
  96
  97         spin_lock_irq(&current->sighand->siglock);
  98         saveset = current->blocked;
  99         current->blocked = newset;
 100         recalc_sigpending();
 101         spin_unlock_irq(&current->sighand->siglock);
 102
 103         regs->r10 = -EINTR;
 104         while (1) {
 105                 current->state = TASK_INTERRUPTIBLE;
 106                 schedule();
 107                 if (do_signal(0, &saveset, regs))
 108                         /* We will get here twice: once to call the signal
 109                            handler, then again to return from the
 110                            sigsuspend system call.  When calling the
 111                            signal handler, R10 holds the signal number as
 112                            set through do_signal.  The sigsuspend call
 113                            will return with the restored value set above;
 114                            always -EINTR.  */
 115                         return regs->r10;
 116         }
 117 }
 118
 119 int
 120 sys_sigaction(int sig, const struct old_sigaction __user *act,
 121               struct old_sigaction *oact)
 122 {
 123         struct k_sigaction new_ka, old_ka;
 124         int ret;
 125
 126         if (act) {
 127                 old_sigset_t mask;
 128                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 129                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 130                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 131                         return -EFAULT;
 132                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 133                 __get_user(mask, &act->sa_mask);
 134                 siginitset(&new_ka.sa.sa_mask, mask);
 135         }
 136
 137         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 138
 139         if (!ret && oact) {
 140                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 141                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 142                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 143                         return -EFAULT;
 144                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 145                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 146         }
 147
 148         return ret;
 149 }
 150
 151 int
 152 sys_sigaltstack(const stack_t *uss, stack_t __user *uoss)
 153 {
 154         return do_sigaltstack(uss, uoss, rdusp());
 155 }
 156
 157
 158 /*
 159  * Do a signal return; undo the signal stack.
 160  */
 161
 162 struct sigframe {
 163         struct sigcontext sc;
 164         unsigned long extramask[_NSIG_WORDS-1];
 165         unsigned char retcode[8];  /* trampoline code */
 166 };
 167
 168 struct rt_sigframe {
 169         struct siginfo *pinfo;
 170         void *puc;
 171         struct siginfo info;
 172         struct ucontext uc;
 173         unsigned char retcode[8];  /* trampoline code */
 174 };
 175
 176
 177 static int
 178 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc)
 179 {
 180         unsigned int err = 0;
 181         unsigned long old_usp;
 182
 183         /* Always make any pending restarted system calls return -EINTR */
 184         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 185
 186         /* restore the regs from &sc->regs (same as sc, since regs is first)
 187          * (sc is already checked for VERIFY_READ since the sigframe was
 188          *  checked in sys_sigreturn previously)
 189          */
 190
 191         if (__copy_from_user(regs, sc, sizeof(struct pt_regs)))
 192                 goto badframe;
 193
 194         /* make sure the U-flag is set so user-mode cannot fool us */
 195
 196         regs->dccr |= 1 << 8;
 197
 198         /* restore the old USP as it was before we stacked the sc etc.
 199          * (we cannot just pop the sigcontext since we aligned the sp and
 200          *  stuff after pushing it)
 201          */
 202
 203         err |= __get_user(old_usp, &sc->usp);
 204
 205         wrusp(old_usp);
 206
 207         /* TODO: the other ports use regs->orig_XX to disable syscall checks
 208          * after this completes, but we don't use that mechanism. maybe we can
 209          * use it now ?
 210          */
 211
 212         return err;
 213
 214 badframe:
 215         return 1;
 216 }
 217
 218 /* Define dummy arguments to be able to reach the regs argument.  */
 219
 220 asmlinkage int sys_sigreturn(long r10, long r11, long r12, long r13, long mof,
 221                              long srp, struct pt_regs *regs)
 222 {
 223         struct sigframe __user *frame = (struct sigframe *)rdusp();
 224         sigset_t set;
 225
 226         /*
 227          * Since we stacked the signal on a dword boundary,
 228          * then frame should be dword aligned here.  If it's
 229          * not, then the user is trying to mess with us.
 230          */
 231         if (((long)frame) & 3)
 232                 goto badframe;
 233
 234         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 235                 goto badframe;
 236         if (__get_user(set.sig[0], &frame->sc.oldmask)
 237             || (_NSIG_WORDS > 1
 238                 && __copy_from_user(&set.sig[1], frame->extramask,
 239                                     sizeof(frame->extramask))))
 240                 goto badframe;
 241
 242         sigdelsetmask(&set, ~_BLOCKABLE);
 243         spin_lock_irq(&current->sighand->siglock);
 244         current->blocked = set;
 245         recalc_sigpending();
 246         spin_unlock_irq(&current->sighand->siglock);
 247
 248         if (restore_sigcontext(regs, &frame->sc))
 249                 goto badframe;
 250
 251         /* TODO: SIGTRAP when single-stepping as in arm ? */
 252
 253         return regs->r10;
 254
 255 badframe:
 256         force_sig(SIGSEGV, current);
 257         return 0;
 258 }
 259
 260 /* Define dummy arguments to be able to reach the regs argument.  */
 261
 262 asmlinkage int sys_rt_sigreturn(long r10, long r11, long r12, long r13,
 263                                 long mof, long srp, struct pt_regs *regs)
 264 {
 265         struct rt_sigframe __user *frame = (struct rt_sigframe *)rdusp();
 266         sigset_t set;
 267         stack_t st;
 268
 269         /*
 270          * Since we stacked the signal on a dword boundary,
 271          * then frame should be dword aligned here.  If it's
 272          * not, then the user is trying to mess with us.
 273          */
 274         if (((long)frame) & 3)
 275                 goto badframe;
 276
 277         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 278                 goto badframe;
 279         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 280                 goto badframe;
 281
 282         sigdelsetmask(&set, ~_BLOCKABLE);
 283         spin_lock_irq(&current->sighand->siglock);
 284         current->blocked = set;
 285         recalc_sigpending();
 286         spin_unlock_irq(&current->sighand->siglock);
 287
 288         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
 289                 goto badframe;
 290
 291         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 292                 goto badframe;
 293         /* It is more difficult to avoid calling this function than to
 294            call it and ignore errors.  */
 295         do_sigaltstack(&st, NULL, rdusp());
 296
 297         return regs->r10;
 298
 299 badframe:
 300         force_sig(SIGSEGV, current);
 301         return 0;
 302 }
 303
 304 /*
 305  * Set up a signal frame.
 306  */
 307
 308 static int
 309 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs, unsigned long mask)
 310 {
 311         int err = 0;
 312         unsigned long usp = rdusp();
 313
 314         /* copy the regs. they are first in sc so we can use sc directly */
 315
 316         err |= __copy_to_user(sc, regs, sizeof(struct pt_regs));
 317
 318         /* Set the frametype to CRIS_FRAME_NORMAL for the execution of
 319            the signal handler. The frametype will be restored to its previous
 320            value in restore_sigcontext. */
 321         regs->frametype = CRIS_FRAME_NORMAL;
 322
 323         /* then some other stuff */
 324
 325         err |= __put_user(mask, &sc->oldmask);
 326
 327         err |= __put_user(usp, &sc->usp);
 328
 329         return err;
 330 }
 331
 332 /* figure out where we want to put the new signal frame - usually on the stack */
 333
 334 static inline void __user *
 335 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 336 {
 337         unsigned long sp = rdusp();
 338
 339         /* This is the X/Open sanctioned signal stack switching.  */
 340         if (ka->sa.sa_flags & SA_ONSTACK) {
 341                 if (! on_sig_stack(sp))
 342                         sp = current->sas_ss_sp + current->sas_ss_size;
 343         }
 344
 345         /* make sure the frame is dword-aligned */
 346
 347         sp &= ~3;
 348
 349         return (void __user*)(sp - frame_size);
 350 }
 351
 352 /* grab and setup a signal frame.
 353  *
 354  * basically we stack a lot of state info, and arrange for the
 355  * user-mode program to return to the kernel using either a
 356  * trampoline which performs the syscall sigreturn, or a provided
 357  * user-mode trampoline.
 358  */
 359
 360 static void setup_frame(int sig, struct k_sigaction *ka,
 361                         sigset_t *set, struct pt_regs * regs)
 362 {
 363         struct sigframe __user *frame;
 364         unsigned long return_ip;
 365         int err = 0;
 366
 367         frame = get_sigframe(ka, regs, sizeof(*frame));
 368
 369         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 370                 goto give_sigsegv;
 371
 372         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 373         if (err)
 374                 goto give_sigsegv;
 375
 376         if (_NSIG_WORDS > 1) {
 377                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 378                                       sizeof(frame->extramask));
 379         }
 380         if (err)
 381                 goto give_sigsegv;
 382
 383         /* Set up to return from userspace.  If provided, use a stub
 384            already in userspace.  */
 385         if (ka->sa.sa_flags & SA_RESTORER) {
 386                 return_ip = (unsigned long)ka->sa.sa_restorer;
 387         } else {
 388                 /* trampoline - the desired return ip is the retcode itself */
 389                 return_ip = (unsigned long)&frame->retcode;
 390                 /* This is movu.w __NR_sigreturn, r9; break 13; */
 391                 err |= __put_user(0x9c5f,         (short *)(frame->retcode+0));
 392                 err |= __put_user(__NR_sigreturn, (short *)(frame->retcode+2));
 393                 err |= __put_user(0xe93d,         (short *)(frame->retcode+4));
 394         }
 395
 396         if (err)
 397                 goto give_sigsegv;
 398
 399         /* Set up registers for signal handler */
 400
 401         regs->irp = (unsigned long) ka->sa.sa_handler;  /* what we enter NOW   */
 402         regs->srp = return_ip;                          /* what we enter LATER */
 403         regs->r10 = sig;                                /* first argument is signo */
 404
 405         /* actually move the usp to reflect the stacked frame */
 406
 407         wrusp((unsigned long)frame);
 408
 409         return;
 410
 411 give_sigsegv:
 412         force_sigsegv(sig, current);
 413 }
 414
 415 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 416                            sigset_t *set, struct pt_regs * regs)
 417 {
 418         struct rt_sigframe __user *frame;
 419         unsigned long return_ip;
 420         int err = 0;
 421
 422         frame = get_sigframe(ka, regs, sizeof(*frame));
 423
 424         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 425                 goto give_sigsegv;
 426
 427         err |= __put_user(&frame->info, &frame->pinfo);
 428         err |= __put_user(&frame->uc, &frame->puc);
 429         err |= copy_siginfo_to_user(&frame->info, info);
 430         if (err)
 431                 goto give_sigsegv;
 432
 433         /* Clear all the bits of the ucontext we don't use.  */
 434         err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
 435
 436         err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
 437
 438         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 439
 440         if (err)
 441                 goto give_sigsegv;
 442
 443         /* Set up to return from userspace.  If provided, use a stub
 444            already in userspace.  */
 445         if (ka->sa.sa_flags & SA_RESTORER) {
 446                 return_ip = (unsigned long)ka->sa.sa_restorer;
 447         } else {
 448                 /* trampoline - the desired return ip is the retcode itself */
 449                 return_ip = (unsigned long)&frame->retcode;
 450                 /* This is movu.w __NR_rt_sigreturn, r9; break 13; */
 451                 err |= __put_user(0x9c5f,            (short *)(frame->retcode+0));
 452                 err |= __put_user(__NR_rt_sigreturn, (short *)(frame->retcode+2));
 453                 err |= __put_user(0xe93d,            (short *)(frame->retcode+4));
 454         }
 455
 456         if (err)
 457                 goto give_sigsegv;
 458
 459         /* TODO what is the current->exec_domain stuff and invmap ? */
 460
 461         /* Set up registers for signal handler */
 462
 463         regs->irp = (unsigned long) ka->sa.sa_handler;  /* what we enter NOW   */
 464         regs->srp = return_ip;                          /* what we enter LATER */
 465         regs->r10 = sig;                                /* first argument is signo */
 466         regs->r11 = (unsigned long) &frame->info;       /* second argument is (siginfo_t *) */
 467         regs->r12 = 0;                                  /* third argument is unused */
 468
 469         /* actually move the usp to reflect the stacked frame */
 470
 471         wrusp((unsigned long)frame);
 472
 473         return;
 474
 475 give_sigsegv:
 476         force_sigsegv(sig, current);
 477 }
 478
 479 /*
 480  * OK, we're invoking a handler
 481  */
 482
 483 extern inline void
 484 handle_signal(int canrestart, unsigned long sig,
 485               siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
 486 {
 487         struct k_sigaction *ka = &current->sighand->action[sig-1];
 488
 489         /* Are we from a system call? */
 490         if (canrestart) {
 491                 /* If so, check system call restarting.. */
 492                 switch (regs->r10) {
 493                         case -ERESTART_RESTARTBLOCK:
 494                         case -ERESTARTNOHAND:
 495                                 /* ERESTARTNOHAND means that the syscall should only be
 496                                    restarted if there was no handler for the signal, and since
 497                                    we only get here if there is a handler, we don't restart */
 498                                 regs->r10 = -EINTR;
 499                                 break;
 500
 501                         case -ERESTARTSYS:
 502                                 /* ERESTARTSYS means to restart the syscall if there is no
 503                                    handler or the handler was registered with SA_RESTART */
 504                                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 505                                         regs->r10 = -EINTR;
 506                                         break;
 507                                 }
 508                         /* fallthrough */
 509                         case -ERESTARTNOINTR:
 510                                 /* ERESTARTNOINTR means that the syscall should be called again
 511                                    after the signal handler returns. */
 512                                 RESTART_CRIS_SYS(regs);
 513                 }
 514         }
 515
 516         /* Set up the stack frame */
 517         if (ka->sa.sa_flags & SA_SIGINFO)
 518                 setup_rt_frame(sig, ka, info, oldset, regs);
 519         else
 520                 setup_frame(sig, ka, oldset, regs);
 521
 522         if (ka->sa.sa_flags & SA_ONESHOT)
 523                 ka->sa.sa_handler = SIG_DFL;
 524
 525         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 526                 spin_lock_irq(&current->sighand->siglock);
 527                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 528                 sigaddset(&current->blocked,sig);
 529                 recalc_sigpending();
 530                 spin_unlock_irq(&current->sighand->siglock);
 531         }
 532 }
 533
 534 /*
 535  * Note that 'init' is a special process: it doesn't get signals it doesn't
 536  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 537  * mistake.
 538  *
 539  * Also note that the regs structure given here as an argument, is the latest
 540  * pushed pt_regs. It may or may not be the same as the first pushed registers
 541  * when the initial usermode->kernelmode transition took place. Therefore
 542  * we can use user_mode(regs) to see if we came directly from kernel or user
 543  * mode below.
 544  */
 545
 546 int do_signal(int canrestart, sigset_t *oldset, struct pt_regs *regs)
 547 {
 548         siginfo_t info;
 549         int signr;
 550
 551         /*
 552          * We want the common case to go fast, which
 553          * is why we may in certain cases get here from
 554          * kernel mode. Just return without doing anything
 555          * if so.
 556          */
 557         if (!user_mode(regs))
 558                 return 1;
 559
 560         if (!oldset)
 561                 oldset = &current->blocked;
 562
 563         signr = get_signal_to_deliver(&info, regs, NULL);
 564         if (signr > 0) {
 565                 /* Whee!  Actually deliver the signal.  */
 566                 handle_signal(canrestart, signr, &info, oldset, regs);
 567                 return 1;
 568         }
 569
 570         /* Did we come from a system call? */
 571         if (canrestart) {
 572                 /* Restart the system call - no handlers present */
 573                 if (regs->r10 == -ERESTARTNOHAND ||
 574                     regs->r10 == -ERESTARTSYS ||
 575                     regs->r10 == -ERESTARTNOINTR) {
 576                         RESTART_CRIS_SYS(regs);
 577                 }
 578                 if (regs->r10 == -ERESTART_RESTARTBLOCK){
 579                         regs->r10 = __NR_restart_syscall;
 580                         regs->irp -= 2;
 581                 }
 582         }
 583         return 0;
 584 }