arch/sh/kernel/signal.c

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