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         if (sig == SIGSEGV)
 413                 ka->sa.sa_handler = SIG_DFL;
 414         force_sig(SIGSEGV, current);
 415 }
 416
 417 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 418                            sigset_t *set, struct pt_regs * regs)
 419 {
 420         struct rt_sigframe __user *frame;
 421         unsigned long return_ip;
 422         int err = 0;
 423
 424         frame = get_sigframe(ka, regs, sizeof(*frame));
 425
 426         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 427                 goto give_sigsegv;
 428
 429         err |= __put_user(&frame->info, &frame->pinfo);
 430         err |= __put_user(&frame->uc, &frame->puc);
 431         err |= copy_siginfo_to_user(&frame->info, info);
 432         if (err)
 433                 goto give_sigsegv;
 434
 435         /* Clear all the bits of the ucontext we don't use.  */
 436         err |= __clear_user(&frame->uc, offsetof(struct ucontext, uc_mcontext));
 437
 438         err |= setup_sigcontext(&frame->uc.uc_mcontext, regs, set->sig[0]);
 439
 440         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 441
 442         if (err)
 443                 goto give_sigsegv;
 444
 445         /* Set up to return from userspace.  If provided, use a stub
 446            already in userspace.  */
 447         if (ka->sa.sa_flags & SA_RESTORER) {
 448                 return_ip = (unsigned long)ka->sa.sa_restorer;
 449         } else {
 450                 /* trampoline - the desired return ip is the retcode itself */
 451                 return_ip = (unsigned long)&frame->retcode;
 452                 /* This is movu.w __NR_rt_sigreturn, r9; break 13; */
 453                 err |= __put_user(0x9c5f,            (short *)(frame->retcode+0));
 454                 err |= __put_user(__NR_rt_sigreturn, (short *)(frame->retcode+2));
 455                 err |= __put_user(0xe93d,            (short *)(frame->retcode+4));
 456         }
 457
 458         if (err)
 459                 goto give_sigsegv;
 460
 461         /* TODO what is the current->exec_domain stuff and invmap ? */
 462
 463         /* Set up registers for signal handler */
 464
 465         regs->irp = (unsigned long) ka->sa.sa_handler;  /* what we enter NOW   */
 466         regs->srp = return_ip;                          /* what we enter LATER */
 467         regs->r10 = sig;                                /* first argument is signo */
 468         regs->r11 = (unsigned long) &frame->info;       /* second argument is (siginfo_t *) */
 469         regs->r12 = 0;                                  /* third argument is unused */
 470
 471         /* actually move the usp to reflect the stacked frame */
 472
 473         wrusp((unsigned long)frame);
 474
 475         return;
 476
 477 give_sigsegv:
 478         if (sig == SIGSEGV)
 479                 ka->sa.sa_handler = SIG_DFL;
 480         force_sig(SIGSEGV, current);
 481 }
 482
 483 /*
 484  * OK, we're invoking a handler
 485  */
 486
 487 extern inline void
 488 handle_signal(int canrestart, unsigned long sig,
 489               siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
 490 {
 491         struct k_sigaction *ka = &current->sighand->action[sig-1];
 492
 493         /* Are we from a system call? */
 494         if (canrestart) {
 495                 /* If so, check system call restarting.. */
 496                 switch (regs->r10) {
 497                         case -ERESTART_RESTARTBLOCK:
 498                         case -ERESTARTNOHAND:
 499                                 /* ERESTARTNOHAND means that the syscall should only be
 500                                    restarted if there was no handler for the signal, and since
 501                                    we only get here if there is a handler, we don't restart */
 502                                 regs->r10 = -EINTR;
 503                                 break;
 504
 505                         case -ERESTARTSYS:
 506                                 /* ERESTARTSYS means to restart the syscall if there is no
 507                                    handler or the handler was registered with SA_RESTART */
 508                                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 509                                         regs->r10 = -EINTR;
 510                                         break;
 511                                 }
 512                         /* fallthrough */
 513                         case -ERESTARTNOINTR:
 514                                 /* ERESTARTNOINTR means that the syscall should be called again
 515                                    after the signal handler returns. */
 516                                 RESTART_CRIS_SYS(regs);
 517                 }
 518         }
 519
 520         /* Set up the stack frame */
 521         if (ka->sa.sa_flags & SA_SIGINFO)
 522                 setup_rt_frame(sig, ka, info, oldset, regs);
 523         else
 524                 setup_frame(sig, ka, oldset, regs);
 525
 526         if (ka->sa.sa_flags & SA_ONESHOT)
 527                 ka->sa.sa_handler = SIG_DFL;
 528
 529         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 530                 spin_lock_irq(&current->sighand->siglock);
 531                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 532                 sigaddset(&current->blocked,sig);
 533                 recalc_sigpending();
 534                 spin_unlock_irq(&current->sighand->siglock);
 535         }
 536 }
 537
 538 /*
 539  * Note that 'init' is a special process: it doesn't get signals it doesn't
 540  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 541  * mistake.
 542  *
 543  * Also note that the regs structure given here as an argument, is the latest
 544  * pushed pt_regs. It may or may not be the same as the first pushed registers
 545  * when the initial usermode->kernelmode transition took place. Therefore
 546  * we can use user_mode(regs) to see if we came directly from kernel or user
 547  * mode below.
 548  */
 549
 550 int do_signal(int canrestart, sigset_t *oldset, struct pt_regs *regs)
 551 {
 552         siginfo_t info;
 553         int signr;
 554
 555         /*
 556          * We want the common case to go fast, which
 557          * is why we may in certain cases get here from
 558          * kernel mode. Just return without doing anything
 559          * if so.
 560          */
 561         if (!user_mode(regs))
 562                 return 1;
 563
 564         if (!oldset)
 565                 oldset = &current->blocked;
 566
 567         signr = get_signal_to_deliver(&info, regs, NULL);
 568         if (signr > 0) {
 569                 /* Whee!  Actually deliver the signal.  */
 570                 handle_signal(canrestart, signr, &info, oldset, regs);
 571                 return 1;
 572         }
 573
 574         /* Did we come from a system call? */
 575         if (canrestart) {
 576                 /* Restart the system call - no handlers present */
 577                 if (regs->r10 == -ERESTARTNOHAND ||
 578                     regs->r10 == -ERESTARTSYS ||
 579                     regs->r10 == -ERESTARTNOINTR) {
 580                         RESTART_CRIS_SYS(regs);
 581                 }
 582                 if (regs->r10 == -ERESTART_RESTARTBLOCK){
 583                         regs->r10 = __NR_restart_syscall;
 584                         regs->irp -= 2;
 585                 }
 586         }
 587         return 0;
 588 }