Pileus Git - ~andy/linux/blob - arch/sh/kernel/signal.c

   1 /*
   2  *  linux/arch/sh/kernel/signal.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
   7  *
   8  *  SuperH version:  Copyright (C) 1999, 2000  Niibe Yutaka & Kaz Kojima
   9  *
  10  */
  11
  12 #include <linux/sched.h>
  13 #include <linux/mm.h>
  14 #include <linux/smp.h>
  15 #include <linux/smp_lock.h>
  16 #include <linux/kernel.h>
  17 #include <linux/signal.h>
  18 #include <linux/errno.h>
  19 #include <linux/wait.h>
  20 #include <linux/ptrace.h>
  21 #include <linux/unistd.h>
  22 #include <linux/stddef.h>
  23 #include <linux/tty.h>
  24 #include <linux/personality.h>
  25 #include <linux/binfmts.h>
  26
  27 #include <asm/ucontext.h>
  28 #include <asm/uaccess.h>
  29 #include <asm/pgtable.h>
  30 #include <asm/cacheflush.h>
  31
  32 #undef DEBUG
  33
  34 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  35
  36 /*
  37  * Atomically swap in the new signal mask, and wait for a signal.
  38  */
  39 asmlinkage int
  40 sys_sigsuspend(old_sigset_t mask,
  41                unsigned long r5, unsigned long r6, unsigned long r7,
  42                struct pt_regs regs)
  43 {
  44         mask &= _BLOCKABLE;
  45         spin_lock_irq(&current->sighand->siglock);
  46         current->saved_sigmask = current->blocked;
  47         siginitset(&current->blocked, mask);
  48         recalc_sigpending();
  49         spin_unlock_irq(&current->sighand->siglock);
  50
  51         current->state = TASK_INTERRUPTIBLE;
  52         schedule();
  53         set_thread_flag(TIF_RESTORE_SIGMASK);
  54         return -ERESTARTNOHAND;
  55 }
  56
  57 asmlinkage int
  58 sys_sigaction(int sig, const struct old_sigaction __user *act,
  59               struct old_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_restorer, &act->sa_restorer))
  69                         return -EFAULT;
  70                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
  71                 __get_user(mask, &act->sa_mask);
  72                 siginitset(&new_ka.sa.sa_mask, mask);
  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_restorer, &oact->sa_restorer))
  81                         return -EFAULT;
  82                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
  83                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
  84         }
  85
  86         return ret;
  87 }
  88
  89 asmlinkage int
  90 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss,
  91                 unsigned long r6, unsigned long r7,
  92                 struct pt_regs regs)
  93 {
  94         return do_sigaltstack(uss, uoss, regs.regs[15]);
  95 }
  96
  97
  98 /*
  99  * Do a signal return; undo the signal stack.
 100  */
 101
 102 #define MOVW(n)  (0x9300|((n)-2))       /* Move mem word at PC+n to R3 */
 103 #define TRAP16   0xc310                 /* Syscall w/no args (NR in R3) */
 104 #define OR_R0_R0 0x200b                 /* or r0,r0 (insert to avoid hardware bug) */
 105
 106 struct sigframe
 107 {
 108         struct sigcontext sc;
 109         unsigned long extramask[_NSIG_WORDS-1];
 110         u16 retcode[8];
 111 };
 112
 113 struct rt_sigframe
 114 {
 115         struct siginfo info;
 116         struct ucontext uc;
 117         u16 retcode[8];
 118 };
 119
 120 #ifdef CONFIG_SH_FPU
 121 static inline int restore_sigcontext_fpu(struct sigcontext __user *sc)
 122 {
 123         struct task_struct *tsk = current;
 124
 125         if (!(cpu_data->flags & CPU_HAS_FPU))
 126                 return 0;
 127
 128         set_used_math();
 129         return __copy_from_user(&tsk->thread.fpu.hard, &sc->sc_fpregs[0],
 130                                 sizeof(long)*(16*2+2));
 131 }
 132
 133 static inline int save_sigcontext_fpu(struct sigcontext __user *sc,
 134                                       struct pt_regs *regs)
 135 {
 136         struct task_struct *tsk = current;
 137
 138         if (!(cpu_data->flags & CPU_HAS_FPU))
 139                 return 0;
 140
 141         if (!used_math()) {
 142                 __put_user(0, &sc->sc_ownedfp);
 143                 return 0;
 144         }
 145
 146         __put_user(1, &sc->sc_ownedfp);
 147
 148         /* This will cause a "finit" to be triggered by the next
 149            attempted FPU operation by the 'current' process.
 150            */
 151         clear_used_math();
 152
 153         unlazy_fpu(tsk, regs);
 154         return __copy_to_user(&sc->sc_fpregs[0], &tsk->thread.fpu.hard,
 155                               sizeof(long)*(16*2+2));
 156 }
 157 #endif /* CONFIG_SH_FPU */
 158
 159 static int
 160 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *sc, int *r0_p)
 161 {
 162         unsigned int err = 0;
 163
 164 #define COPY(x)         err |= __get_user(regs->x, &sc->sc_##x)
 165                         COPY(regs[1]);
 166         COPY(regs[2]);  COPY(regs[3]);
 167         COPY(regs[4]);  COPY(regs[5]);
 168         COPY(regs[6]);  COPY(regs[7]);
 169         COPY(regs[8]);  COPY(regs[9]);
 170         COPY(regs[10]); COPY(regs[11]);
 171         COPY(regs[12]); COPY(regs[13]);
 172         COPY(regs[14]); COPY(regs[15]);
 173         COPY(gbr);      COPY(mach);
 174         COPY(macl);     COPY(pr);
 175         COPY(sr);       COPY(pc);
 176 #undef COPY
 177
 178 #ifdef CONFIG_SH_FPU
 179         if (cpu_data->flags & CPU_HAS_FPU) {
 180                 int owned_fp;
 181                 struct task_struct *tsk = current;
 182
 183                 regs->sr |= SR_FD; /* Release FPU */
 184                 clear_fpu(tsk, regs);
 185                 clear_used_math();
 186                 __get_user (owned_fp, &sc->sc_ownedfp);
 187                 if (owned_fp)
 188                         err |= restore_sigcontext_fpu(sc);
 189         }
 190 #endif
 191
 192         regs->tra = -1;         /* disable syscall checks */
 193         err |= __get_user(*r0_p, &sc->sc_regs[0]);
 194         return err;
 195 }
 196
 197 asmlinkage int sys_sigreturn(unsigned long r4, unsigned long r5,
 198                              unsigned long r6, unsigned long r7,
 199                              struct pt_regs regs)
 200 {
 201         struct sigframe __user *frame = (struct sigframe __user *)regs.regs[15];
 202         sigset_t set;
 203         int r0;
 204
 205         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 206                 goto badframe;
 207
 208         if (__get_user(set.sig[0], &frame->sc.oldmask)
 209             || (_NSIG_WORDS > 1
 210                 && __copy_from_user(&set.sig[1], &frame->extramask,
 211                                     sizeof(frame->extramask))))
 212                 goto badframe;
 213
 214         sigdelsetmask(&set, ~_BLOCKABLE);
 215
 216         spin_lock_irq(&current->sighand->siglock);
 217         current->blocked = set;
 218         recalc_sigpending();
 219         spin_unlock_irq(&current->sighand->siglock);
 220
 221         if (restore_sigcontext(&regs, &frame->sc, &r0))
 222                 goto badframe;
 223         return r0;
 224
 225 badframe:
 226         force_sig(SIGSEGV, current);
 227         return 0;
 228 }
 229
 230 asmlinkage int sys_rt_sigreturn(unsigned long r4, unsigned long r5,
 231                                 unsigned long r6, unsigned long r7,
 232                                 struct pt_regs regs)
 233 {
 234         struct rt_sigframe __user *frame = (struct rt_sigframe __user *)regs.regs[15];
 235         sigset_t set;
 236         stack_t st;
 237         int r0;
 238
 239         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 240                 goto badframe;
 241
 242         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 243                 goto badframe;
 244
 245         sigdelsetmask(&set, ~_BLOCKABLE);
 246         spin_lock_irq(&current->sighand->siglock);
 247         current->blocked = set;
 248         recalc_sigpending();
 249         spin_unlock_irq(&current->sighand->siglock);
 250
 251         if (restore_sigcontext(&regs, &frame->uc.uc_mcontext, &r0))
 252                 goto badframe;
 253
 254         if (__copy_from_user(&st, &frame->uc.uc_stack, sizeof(st)))
 255                 goto badframe;
 256         /* It is more difficult to avoid calling this function than to
 257            call it and ignore errors.  */
 258         do_sigaltstack(&st, NULL, regs.regs[15]);
 259
 260         return r0;
 261
 262 badframe:
 263         force_sig(SIGSEGV, current);
 264         return 0;
 265 }
 266
 267 /*
 268  * Set up a signal frame.
 269  */
 270
 271 static int
 272 setup_sigcontext(struct sigcontext __user *sc, struct pt_regs *regs,
 273                  unsigned long mask)
 274 {
 275         int err = 0;
 276
 277 #define COPY(x)         err |= __put_user(regs->x, &sc->sc_##x)
 278         COPY(regs[0]);  COPY(regs[1]);
 279         COPY(regs[2]);  COPY(regs[3]);
 280         COPY(regs[4]);  COPY(regs[5]);
 281         COPY(regs[6]);  COPY(regs[7]);
 282         COPY(regs[8]);  COPY(regs[9]);
 283         COPY(regs[10]); COPY(regs[11]);
 284         COPY(regs[12]); COPY(regs[13]);
 285         COPY(regs[14]); COPY(regs[15]);
 286         COPY(gbr);      COPY(mach);
 287         COPY(macl);     COPY(pr);
 288         COPY(sr);       COPY(pc);
 289 #undef COPY
 290
 291 #ifdef CONFIG_SH_FPU
 292         err |= save_sigcontext_fpu(sc, regs);
 293 #endif
 294
 295         /* non-iBCS2 extensions.. */
 296         err |= __put_user(mask, &sc->oldmask);
 297
 298         return err;
 299 }
 300
 301 /*
 302  * Determine which stack to use..
 303  */
 304 static inline void __user *
 305 get_sigframe(struct k_sigaction *ka, unsigned long sp, size_t frame_size)
 306 {
 307         if (ka->sa.sa_flags & SA_ONSTACK) {
 308                 if (sas_ss_flags(sp) == 0)
 309                         sp = current->sas_ss_sp + current->sas_ss_size;
 310         }
 311
 312         return (void __user *)((sp - frame_size) & -8ul);
 313 }
 314
 315 static int setup_frame(int sig, struct k_sigaction *ka,
 316                         sigset_t *set, struct pt_regs *regs)
 317 {
 318         struct sigframe __user *frame;
 319         int err = 0;
 320         int signal;
 321
 322         frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
 323
 324         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 325                 goto give_sigsegv;
 326
 327         signal = current_thread_info()->exec_domain
 328                 && current_thread_info()->exec_domain->signal_invmap
 329                 && sig < 32
 330                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 331                 : sig;
 332
 333         err |= setup_sigcontext(&frame->sc, regs, set->sig[0]);
 334
 335         if (_NSIG_WORDS > 1)
 336                 err |= __copy_to_user(frame->extramask, &set->sig[1],
 337                                       sizeof(frame->extramask));
 338
 339         /* Set up to return from userspace.  If provided, use a stub
 340            already in userspace.  */
 341         if (ka->sa.sa_flags & SA_RESTORER) {
 342                 regs->pr = (unsigned long) ka->sa.sa_restorer;
 343         } else {
 344                 /* Generate return code (system call to sigreturn) */
 345                 err |= __put_user(MOVW(7), &frame->retcode[0]);
 346                 err |= __put_user(TRAP16, &frame->retcode[1]);
 347                 err |= __put_user(OR_R0_R0, &frame->retcode[2]);
 348                 err |= __put_user(OR_R0_R0, &frame->retcode[3]);
 349                 err |= __put_user(OR_R0_R0, &frame->retcode[4]);
 350                 err |= __put_user(OR_R0_R0, &frame->retcode[5]);
 351                 err |= __put_user(OR_R0_R0, &frame->retcode[6]);
 352                 err |= __put_user((__NR_sigreturn), &frame->retcode[7]);
 353                 regs->pr = (unsigned long) frame->retcode;
 354         }
 355
 356         if (err)
 357                 goto give_sigsegv;
 358
 359         /* Set up registers for signal handler */
 360         regs->regs[15] = (unsigned long) frame;
 361         regs->regs[4] = signal; /* Arg for signal handler */
 362         regs->regs[5] = 0;
 363         regs->regs[6] = (unsigned long) &frame->sc;
 364         regs->pc = (unsigned long) ka->sa.sa_handler;
 365
 366         set_fs(USER_DS);
 367
 368         pr_debug("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
 369                  current->comm, current->pid, frame, regs->pc, regs->pr);
 370
 371         flush_cache_sigtramp(regs->pr);
 372
 373         if ((-regs->pr & (L1_CACHE_BYTES-1)) < sizeof(frame->retcode))
 374                 flush_cache_sigtramp(regs->pr + L1_CACHE_BYTES);
 375
 376         return 0;
 377
 378 give_sigsegv:
 379         force_sigsegv(sig, current);
 380         return -EFAULT;
 381 }
 382
 383 static int setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 384                            sigset_t *set, struct pt_regs *regs)
 385 {
 386         struct rt_sigframe __user *frame;
 387         int err = 0;
 388         int signal;
 389
 390         frame = get_sigframe(ka, regs->regs[15], sizeof(*frame));
 391
 392         if (!access_ok(VERIFY_WRITE, frame, sizeof(*frame)))
 393                 goto give_sigsegv;
 394
 395         signal = current_thread_info()->exec_domain
 396                 && current_thread_info()->exec_domain->signal_invmap
 397                 && sig < 32
 398                 ? current_thread_info()->exec_domain->signal_invmap[sig]
 399                 : sig;
 400
 401         err |= copy_siginfo_to_user(&frame->info, info);
 402
 403         /* Create the ucontext.  */
 404         err |= __put_user(0, &frame->uc.uc_flags);
 405         err |= __put_user(0, &frame->uc.uc_link);
 406         err |= __put_user((void *)current->sas_ss_sp,
 407                           &frame->uc.uc_stack.ss_sp);
 408         err |= __put_user(sas_ss_flags(regs->regs[15]),
 409                           &frame->uc.uc_stack.ss_flags);
 410         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 411         err |= setup_sigcontext(&frame->uc.uc_mcontext,
 412                                 regs, set->sig[0]);
 413         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 414
 415         /* Set up to return from userspace.  If provided, use a stub
 416            already in userspace.  */
 417         if (ka->sa.sa_flags & SA_RESTORER) {
 418                 regs->pr = (unsigned long) ka->sa.sa_restorer;
 419         } else {
 420                 /* Generate return code (system call to rt_sigreturn) */
 421                 err |= __put_user(MOVW(7), &frame->retcode[0]);
 422                 err |= __put_user(TRAP16, &frame->retcode[1]);
 423                 err |= __put_user(OR_R0_R0, &frame->retcode[2]);
 424                 err |= __put_user(OR_R0_R0, &frame->retcode[3]);
 425                 err |= __put_user(OR_R0_R0, &frame->retcode[4]);
 426                 err |= __put_user(OR_R0_R0, &frame->retcode[5]);
 427                 err |= __put_user(OR_R0_R0, &frame->retcode[6]);
 428                 err |= __put_user((__NR_rt_sigreturn), &frame->retcode[7]);
 429                 regs->pr = (unsigned long) frame->retcode;
 430         }
 431
 432         if (err)
 433                 goto give_sigsegv;
 434
 435         /* Set up registers for signal handler */
 436         regs->regs[15] = (unsigned long) frame;
 437         regs->regs[4] = signal; /* Arg for signal handler */
 438         regs->regs[5] = (unsigned long) &frame->info;
 439         regs->regs[6] = (unsigned long) &frame->uc;
 440         regs->pc = (unsigned long) ka->sa.sa_handler;
 441
 442         set_fs(USER_DS);
 443
 444         pr_debug("SIG deliver (%s:%d): sp=%p pc=%08lx pr=%08lx\n",
 445                  current->comm, current->pid, frame, regs->pc, regs->pr);
 446
 447         flush_cache_sigtramp(regs->pr);
 448
 449         if ((-regs->pr & (L1_CACHE_BYTES-1)) < sizeof(frame->retcode))
 450                 flush_cache_sigtramp(regs->pr + L1_CACHE_BYTES);
 451
 452         return 0;
 453
 454 give_sigsegv:
 455         force_sigsegv(sig, current);
 456         return -EFAULT;
 457 }
 458
 459 /*
 460  * OK, we're invoking a handler
 461  */
 462
 463 static int
 464 handle_signal(unsigned long sig, struct k_sigaction *ka, siginfo_t *info,
 465               sigset_t *oldset, struct pt_regs *regs)
 466 {
 467         int ret;
 468
 469         /* Are we from a system call? */
 470         if (regs->tra >= 0) {
 471                 /* If so, check system call restarting.. */
 472                 switch (regs->regs[0]) {
 473                         case -ERESTARTNOHAND:
 474                                 regs->regs[0] = -EINTR;
 475                                 break;
 476
 477                         case -ERESTARTSYS:
 478                                 if (!(ka->sa.sa_flags & SA_RESTART)) {
 479                                         regs->regs[0] = -EINTR;
 480                                         break;
 481                                 }
 482                         /* fallthrough */
 483                         case -ERESTARTNOINTR:
 484                                 regs->pc -= 2;
 485                 }
 486         } else {
 487                 /* gUSA handling */
 488 #ifdef CONFIG_PREEMPT
 489                 unsigned long flags;
 490
 491                 local_irq_save(flags);
 492 #endif
 493                 if (regs->regs[15] >= 0xc0000000) {
 494                         int offset = (int)regs->regs[15];
 495
 496                         /* Reset stack pointer: clear critical region mark */
 497                         regs->regs[15] = regs->regs[1];
 498                         if (regs->pc < regs->regs[0])
 499                                 /* Go to rewind point #1 */
 500                                 regs->pc = regs->regs[0] + offset - 2;
 501                 }
 502 #ifdef CONFIG_PREEMPT
 503                 local_irq_restore(flags);
 504 #endif
 505         }
 506
 507         /* Set up the stack frame */
 508         if (ka->sa.sa_flags & SA_SIGINFO)
 509                 ret = setup_rt_frame(sig, ka, info, oldset, regs);
 510         else
 511                 ret = setup_frame(sig, ka, oldset, regs);
 512
 513         if (ka->sa.sa_flags & SA_ONESHOT)
 514                 ka->sa.sa_handler = SIG_DFL;
 515
 516         if (ret == 0) {
 517                 spin_lock_irq(&current->sighand->siglock);
 518                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 519                 if (!(ka->sa.sa_flags & SA_NODEFER))
 520                         sigaddset(&current->blocked,sig);
 521                 recalc_sigpending();
 522                 spin_unlock_irq(&current->sighand->siglock);
 523         }
 524
 525         return ret;
 526 }
 527
 528 /*
 529  * Note that 'init' is a special process: it doesn't get signals it doesn't
 530  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 531  * mistake.
 532  *
 533  * Note that we go through the signals twice: once to check the signals that
 534  * the kernel can handle, and then we build all the user-level signal handling
 535  * stack-frames in one go after that.
 536  */
 537 static void do_signal(struct pt_regs *regs, unsigned int save_r0)
 538 {
 539         siginfo_t info;
 540         int signr;
 541         struct k_sigaction ka;
 542         sigset_t *oldset;
 543
 544         /*
 545          * We want the common case to go fast, which
 546          * is why we may in certain cases get here from
 547          * kernel mode. Just return without doing anything
 548          * if so.
 549          */
 550         if (!user_mode(regs))
 551                 return;
 552
 553         if (try_to_freeze())
 554                 goto no_signal;
 555
 556         if (test_thread_flag(TIF_RESTORE_SIGMASK))
 557                 oldset = &current->saved_sigmask;
 558         else
 559                 oldset = &current->blocked;
 560
 561         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 562         if (signr > 0) {
 563                 /* Whee!  Actually deliver the signal.  */
 564                 if (handle_signal(signr, &ka, &info, oldset, regs) == 0) {
 565                         /* a signal was successfully delivered; the saved
 566                          * sigmask will have been stored in the signal frame,
 567                          * and will be restored by sigreturn, so we can simply
 568                          * clear the TIF_RESTORE_SIGMASK flag */
 569                         if (test_thread_flag(TIF_RESTORE_SIGMASK))
 570                                 clear_thread_flag(TIF_RESTORE_SIGMASK);
 571                 }
 572         }
 573
 574  no_signal:
 575         /* Did we come from a system call? */
 576         if (regs->tra >= 0) {
 577                 /* Restart the system call - no handlers present */
 578                 if (regs->regs[0] == -ERESTARTNOHAND ||
 579                     regs->regs[0] == -ERESTARTSYS ||
 580                     regs->regs[0] == -ERESTARTNOINTR) {
 581                         regs->regs[0] = save_r0;
 582                         regs->pc -= 2;
 583                 } else if (regs->regs[0] == -ERESTART_RESTARTBLOCK) {
 584                         regs->pc -= 2;
 585                         regs->regs[3] = __NR_restart_syscall;
 586                 }
 587         }
 588
 589         /* if there's no signal to deliver, we just put the saved sigmask
 590          * back */
 591         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
 592                 clear_thread_flag(TIF_RESTORE_SIGMASK);
 593                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
 594         }
 595 }
 596
 597 asmlinkage void do_notify_resume(struct pt_regs *regs, unsigned int save_r0,
 598                                  __u32 thread_info_flags)
 599 {
 600         /* deal with pending signal delivery */
 601         if (thread_info_flags & (_TIF_SIGPENDING | _TIF_RESTORE_SIGMASK))
 602                 do_signal(regs, save_r0);
 603 }