arch/m68k/coldfire/signal.c

   1 /*
   2  *  linux/arch/m68k/kernel/signal.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  *
   6  * This file is subject to the terms and conditions of the GNU General Public
   7  * License.  See the file COPYING in the main directory of this archive
   8  * for more details.
   9  */
  10
  11 /*
  12  * Derived from m68k/kernel/signal.c and the original authors are credited
  13  * there.
  14  *
  15  * Coldfire support by:
  16  * Matt Waddel Matt.Waddel@freescale.com
  17  * Copyright Freescale Semiconductor, Inc 2007
  18  */
  19
  20 #include <linux/sched.h>
  21 #include <linux/mm.h>
  22 #include <linux/kernel.h>
  23 #include <linux/signal.h>
  24 #include <linux/syscalls.h>
  25 #include <linux/errno.h>
  26 #include <linux/wait.h>
  27 #include <linux/ptrace.h>
  28 #include <linux/unistd.h>
  29 #include <linux/stddef.h>
  30 #include <linux/highuid.h>
  31 #include <linux/personality.h>
  32 #include <linux/tty.h>
  33 #include <linux/binfmts.h>
  34
  35 #include <asm/setup.h>
  36 #include <asm/cf_uaccess.h>
  37 #include <asm/cf_pgtable.h>
  38 #include <asm/traps.h>
  39 #include <asm/ucontext.h>
  40 #include <asm/cacheflush.h>
  41
  42 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  43
  44 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs);
  45
  46 const int frame_extra_sizes[16] = {
  47   [1]   = -1,
  48   [2]   = sizeof(((struct frame *)0)->un.fmt2),
  49   [3]   = sizeof(((struct frame *)0)->un.fmt3),
  50   [4]   = 0,
  51   [5]   = -1,
  52   [6]   = -1,
  53   [7]   = sizeof(((struct frame *)0)->un.fmt7),
  54   [8]   = -1,
  55   [9]   = sizeof(((struct frame *)0)->un.fmt9),
  56   [10]  = sizeof(((struct frame *)0)->un.fmta),
  57   [11]  = sizeof(((struct frame *)0)->un.fmtb),
  58   [12]  = -1,
  59   [13]  = -1,
  60   [14]  = -1,
  61   [15]  = -1,
  62 };
  63
  64 /*
  65  * Atomically swap in the new signal mask, and wait for a signal.
  66  */
  67 asmlinkage int do_sigsuspend(struct pt_regs *regs)
  68 {
  69         old_sigset_t mask = regs->d3;
  70         sigset_t saveset;
  71
  72         mask &= _BLOCKABLE;
  73         spin_lock_irq(&current->sighand->siglock);
  74         saveset = current->blocked;
  75         siginitset(&current->blocked, mask);
  76         recalc_sigpending();
  77         spin_unlock_irq(&current->sighand->siglock);
  78
  79         regs->d0 = -EINTR;
  80         while (1) {
  81                 current->state = TASK_INTERRUPTIBLE;
  82                 schedule();
  83                 if (do_signal(&saveset, regs))
  84                         return -EINTR;
  85         }
  86 }
  87
  88 asmlinkage int
  89 do_rt_sigsuspend(struct pt_regs *regs)
  90 {
  91         sigset_t __user *unewset = (sigset_t __user *)regs->d1;
  92         size_t sigsetsize = (size_t)regs->d2;
  93         sigset_t saveset, newset;
  94
  95         /* XXX: Don't preclude handling different sized sigset_t's.  */
  96         if (sigsetsize != sizeof(sigset_t))
  97                 return -EINVAL;
  98
  99         if (copy_from_user(&newset, unewset, sizeof(newset)))
 100                 return -EFAULT;
 101         sigdelsetmask(&newset, ~_BLOCKABLE);
 102
 103         spin_lock_irq(&current->sighand->siglock);
 104         saveset = current->blocked;
 105         current->blocked = newset;
 106         recalc_sigpending();
 107         spin_unlock_irq(&current->sighand->siglock);
 108
 109         regs->d0 = -EINTR;
 110         while (1) {
 111                 current->state = TASK_INTERRUPTIBLE;
 112                 schedule();
 113                 if (do_signal(&saveset, regs))
 114                         return -EINTR;
 115         }
 116 }
 117
 118 asmlinkage int
 119 sys_sigaction(int sig, const struct old_sigaction __user *act,
 120               struct old_sigaction __user *oact)
 121 {
 122         struct k_sigaction new_ka, old_ka;
 123         int ret;
 124
 125         if (act) {
 126                 old_sigset_t mask;
 127                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 128                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 129                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer))
 130                         return -EFAULT;
 131                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 132                 __get_user(mask, &act->sa_mask);
 133                 siginitset(&new_ka.sa.sa_mask, mask);
 134         }
 135
 136         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 137
 138         if (!ret && oact) {
 139                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 140                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 141                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer))
 142                         return -EFAULT;
 143                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 144                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 145         }
 146
 147         return ret;
 148 }
 149
 150 asmlinkage int
 151 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
 152 {
 153         return do_sigaltstack(uss, uoss, rdusp());
 154 }
 155
 156
 157 /*
 158  * Do a signal return; undo the signal stack.
 159  *
 160  * Keep the return code on the stack quadword aligned!
 161  * That makes the cache flush below easier.
 162  */
 163
 164 struct sigframe
 165 {
 166         char __user *pretcode;
 167         int sig;
 168         int code;
 169         struct sigcontext __user *psc;
 170         char retcode[16];
 171         unsigned long extramask[_NSIG_WORDS-1];
 172         struct sigcontext sc;
 173 };
 174
 175 struct rt_sigframe
 176 {
 177         char __user *pretcode;
 178         int sig;
 179         struct siginfo __user *pinfo;
 180         void __user *puc;
 181         char retcode[16];
 182         struct siginfo info;
 183         struct ucontext uc;
 184 };
 185
 186 #define FPCONTEXT_SIZE  216
 187 #define uc_fpstate      uc_filler[0]
 188 #define uc_formatvec    uc_filler[FPCONTEXT_SIZE/4]
 189 #define uc_extra        uc_filler[FPCONTEXT_SIZE/4+1]
 190
 191 #ifdef CONFIG_FPU
 192 static unsigned char fpu_version; /* version num of fpu, set by setup_frame */
 193
 194 static inline int restore_fpu_state(struct sigcontext *sc)
 195 {
 196         int err = 1;
 197
 198         if (FPU_IS_EMU) {
 199             /* restore registers */
 200             memcpy(current->thread.fpcntl, sc->sc_fpcntl, 12);
 201             memcpy(current->thread.fp, sc->sc_fpregs, 24);
 202             return 0;
 203         }
 204
 205         if (CPU_IS_060 ? sc->sc_fpstate[2] : sc->sc_fpstate[0]) {
 206             /* Verify the frame format.  */
 207             if (!CPU_IS_060 && (sc->sc_fpstate[0] != fpu_version))
 208                 goto out;
 209             if (CPU_IS_020_OR_030) {
 210                 if (m68k_fputype & FPU_68881 &&
 211                     !(sc->sc_fpstate[1] == 0x18 || sc->sc_fpstate[1] == 0xb4))
 212                     goto out;
 213                 if (m68k_fputype & FPU_68882 &&
 214                     !(sc->sc_fpstate[1] == 0x38 || sc->sc_fpstate[1] == 0xd4))
 215                     goto out;
 216             } else if (CPU_IS_040) {
 217                 if (!(sc->sc_fpstate[1] == 0x00 ||
 218                       sc->sc_fpstate[1] == 0x28 ||
 219                       sc->sc_fpstate[1] == 0x60))
 220                     goto out;
 221             } else if (CPU_IS_060) {
 222                 if (!(sc->sc_fpstate[3] == 0x00 ||
 223                       sc->sc_fpstate[3] == 0x60 ||
 224                       sc->sc_fpstate[3] == 0xe0))
 225                     goto out;
 226             } else
 227                 goto out;
 228
 229         }
 230         err = 0;
 231
 232 out:
 233         return err;
 234 }
 235
 236 static inline int rt_restore_fpu_state(struct ucontext __user *uc)
 237 {
 238         unsigned char fpstate[FPCONTEXT_SIZE];
 239         int context_size = CPU_IS_060 ? 8 : 0;
 240         fpregset_t fpregs;
 241         int err = 1;
 242
 243         if (FPU_IS_EMU) {
 244                 /* restore fpu control register */
 245                 if (__copy_from_user(current->thread.fpcntl,
 246                                 uc->uc_mcontext.fpregs.f_fpcntl, 12))
 247                         goto out;
 248                 /* restore all other fpu register */
 249                 if (__copy_from_user(current->thread.fp,
 250                                 uc->uc_mcontext.fpregs.f_fpregs, 96))
 251                         goto out;
 252                 return 0;
 253         }
 254
 255         if (__get_user(*(long *)fpstate, (long __user *)&uc->uc_fpstate))
 256                 goto out;
 257         if (CPU_IS_060 ? fpstate[2] : fpstate[0]) {
 258                 if (!CPU_IS_060)
 259                         context_size = fpstate[1];
 260                 /* Verify the frame format.  */
 261                 if (!CPU_IS_060 && (fpstate[0] != fpu_version))
 262                         goto out;
 263                 if (CPU_IS_020_OR_030) {
 264                         if (m68k_fputype & FPU_68881 &&
 265                             !(context_size == 0x18 || context_size == 0xb4))
 266                                 goto out;
 267                         if (m68k_fputype & FPU_68882 &&
 268                             !(context_size == 0x38 || context_size == 0xd4))
 269                                 goto out;
 270                 } else if (CPU_IS_040) {
 271                         if (!(context_size == 0x00 ||
 272                               context_size == 0x28 ||
 273                               context_size == 0x60))
 274                                 goto out;
 275                 } else if (CPU_IS_060) {
 276                         if (!(fpstate[3] == 0x00 ||
 277                               fpstate[3] == 0x60 ||
 278                               fpstate[3] == 0xe0))
 279                                 goto out;
 280                 } else
 281                         goto out;
 282                 if (__copy_from_user(&fpregs, &uc->uc_mcontext.fpregs,
 283                                      sizeof(fpregs)))
 284                         goto out;
 285         }
 286         if (context_size &&
 287             __copy_from_user(fpstate + 4, (long __user *)&uc->uc_fpstate + 1,
 288                              context_size))
 289                 goto out;
 290         err = 0;
 291
 292 out:
 293         return err;
 294 }
 295 #endif
 296
 297 static inline int
 298 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *usc,
 299         void __user *fp, int *pd0)
 300 {
 301         int fsize, formatvec;
 302         struct sigcontext context;
 303         int err = 0;
 304
 305         /* get previous context */
 306         if (copy_from_user(&context, usc, sizeof(context)))
 307                 goto badframe;
 308
 309         /* restore passed registers */
 310         regs->d1 = context.sc_d1;
 311         regs->a0 = context.sc_a0;
 312         regs->a1 = context.sc_a1;
 313         regs->sr = (regs->sr & 0xff00) | (context.sc_sr & 0xff);
 314         regs->pc = context.sc_pc;
 315         regs->orig_d0 = -1;             /* disable syscall checks */
 316         wrusp(context.sc_usp);
 317         formatvec = context.sc_formatvec;
 318         regs->format = formatvec >> 12;
 319         regs->vector = formatvec & 0xfff;
 320
 321 #ifdef CONFIG_FPU
 322         err = restore_fpu_state(&context);
 323 #endif
 324
 325         fsize = frame_extra_sizes[regs->format];
 326         if (fsize < 0) {
 327                 /*
 328                  * user process trying to return with weird frame format
 329                  */
 330 #ifdef DEBUG
 331                 printk(KERN_DEBUG "user process returning with weird \
 332                         frame format\n");
 333 #endif
 334                 goto badframe;
 335         }
 336
 337         /* OK.  Make room on the supervisor stack for the extra junk,
 338          * if necessary.
 339          */
 340
 341         {
 342                 struct switch_stack *sw = (struct switch_stack *)regs - 1;
 343                 regs->d0 = context.sc_d0;
 344 #define frame_offset (sizeof(struct pt_regs)+sizeof(struct switch_stack))
 345                 __asm__ __volatile__
 346                         ("   movel %0,%/sp\n\t"
 347                          "   bra ret_from_signal\n"
 348                          "4:\n"
 349                          ".section __ex_table,\"a\"\n"
 350                          "   .align 4\n"
 351                          "   .long 2b,4b\n"
 352                          ".previous"
 353                          : /* no outputs, it doesn't ever return */
 354                          : "a" (sw), "d" (fsize), "d" (frame_offset/4-1),
 355                            "n" (frame_offset), "a" (fp)
 356                          : "a0");
 357 #undef frame_offset
 358                 /*
 359                  * If we ever get here an exception occurred while
 360                  * building the above stack-frame.
 361                  */
 362                 goto badframe;
 363         }
 364
 365         *pd0 = context.sc_d0;
 366         return err;
 367
 368 badframe:
 369         return 1;
 370 }
 371
 372 static inline int
 373 rt_restore_ucontext(struct pt_regs *regs, struct switch_stack *sw,
 374                     struct ucontext __user *uc, int *pd0)
 375 {
 376         int fsize, temp;
 377         greg_t __user *gregs = uc->uc_mcontext.gregs;
 378         unsigned long usp;
 379         int err;
 380
 381         err = __get_user(temp, &uc->uc_mcontext.version);
 382         if (temp != MCONTEXT_VERSION)
 383                 goto badframe;
 384         /* restore passed registers */
 385         err |= __get_user(regs->d0, &gregs[0]);
 386         err |= __get_user(regs->d1, &gregs[1]);
 387         err |= __get_user(regs->d2, &gregs[2]);
 388         err |= __get_user(regs->d3, &gregs[3]);
 389         err |= __get_user(regs->d4, &gregs[4]);
 390         err |= __get_user(regs->d5, &gregs[5]);
 391         err |= __get_user(sw->d6, &gregs[6]);
 392         err |= __get_user(sw->d7, &gregs[7]);
 393         err |= __get_user(regs->a0, &gregs[8]);
 394         err |= __get_user(regs->a1, &gregs[9]);
 395         err |= __get_user(regs->a2, &gregs[10]);
 396         err |= __get_user(sw->a3, &gregs[11]);
 397         err |= __get_user(sw->a4, &gregs[12]);
 398         err |= __get_user(sw->a5, &gregs[13]);
 399         err |= __get_user(sw->a6, &gregs[14]);
 400         err |= __get_user(usp, &gregs[15]);
 401         wrusp(usp);
 402         err |= __get_user(regs->pc, &gregs[16]);
 403         err |= __get_user(temp, &gregs[17]);
 404         regs->sr = (regs->sr & 0xff00) | (temp & 0xff);
 405         regs->orig_d0 = -1;             /* disable syscall checks */
 406         err |= __get_user(temp, &uc->uc_formatvec);
 407         regs->format = temp >> 12;
 408         regs->vector = temp & 0xfff;
 409
 410 #ifdef CONFIG_FPU
 411         err |= rt_restore_fpu_state(uc);
 412 #endif
 413
 414         if (do_sigaltstack(&uc->uc_stack, NULL, usp) == -EFAULT)
 415                 goto badframe;
 416
 417         fsize = frame_extra_sizes[regs->format];
 418         if (fsize < 0) {
 419                 /*
 420                  * user process trying to return with weird frame format
 421                  */
 422 #ifdef DEBUG
 423                 printk(KERN_DEBUG "user process returning with weird \
 424                         frame format\n");
 425 #endif
 426                 goto badframe;
 427         }
 428
 429         /* OK.  Make room on the supervisor stack for the extra junk,
 430          * if necessary.
 431          */
 432
 433         {
 434 #define frame_offset (sizeof(struct pt_regs)+sizeof(struct switch_stack))
 435                 __asm__ __volatile__
 436                         ("   movel %0,%/sp\n\t"
 437                          "   bra ret_from_signal\n"
 438                          "4:\n"
 439                          ".section __ex_table,\"a\"\n"
 440                          "   .align 4\n"
 441                          "   .long 2b,4b\n"
 442                          ".previous"
 443                          : /* no outputs, it doesn't ever return */
 444                          : "a" (sw), "d" (fsize), "d" (frame_offset/4-1),
 445                            "n" (frame_offset), "a" (&uc->uc_extra)
 446                          : "a0");
 447 #undef frame_offset
 448                 /*
 449                  * If we ever get here an exception occurred while
 450                  * building the above stack-frame.
 451                  */
 452                 goto badframe;
 453         }
 454
 455         *pd0 = regs->d0;
 456         return err;
 457
 458 badframe:
 459         return 1;
 460 }
 461
 462 asmlinkage int do_sigreturn(unsigned long __unused)
 463 {
 464         struct switch_stack *sw = (struct switch_stack *) &__unused;
 465         struct pt_regs *regs = (struct pt_regs *) (sw + 1);
 466         unsigned long usp = rdusp();
 467         struct sigframe __user *frame = (struct sigframe __user *)(usp - 4);
 468         sigset_t set;
 469         int d0;
 470
 471         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 472                 goto badframe;
 473         if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
 474             (_NSIG_WORDS > 1 &&
 475              __copy_from_user(&set.sig[1], &frame->extramask,
 476                               sizeof(frame->extramask))))
 477                 goto badframe;
 478
 479         sigdelsetmask(&set, ~_BLOCKABLE);
 480         spin_lock_irq(&current->sighand->siglock);
 481         current->blocked = set;
 482         recalc_sigpending();
 483         spin_unlock_irq(&current->sighand->siglock);
 484
 485         if (restore_sigcontext(regs, &frame->sc, frame + 1, &d0))
 486                 goto badframe;
 487         return d0;
 488
 489 badframe:
 490         force_sig(SIGSEGV, current);
 491         return 0;
 492 }
 493
 494 asmlinkage int do_rt_sigreturn(unsigned long __unused)
 495 {
 496         struct switch_stack *sw = (struct switch_stack *) &__unused;
 497         struct pt_regs *regs = (struct pt_regs *) (sw + 1);
 498         unsigned long usp = rdusp();
 499         struct rt_sigframe __user *frame =
 500                 (struct rt_sigframe __user *)(usp - 4);
 501         sigset_t set;
 502         int d0;
 503
 504         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 505                 goto badframe;
 506         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 507                 goto badframe;
 508
 509         sigdelsetmask(&set, ~_BLOCKABLE);
 510         spin_lock_irq(&current->sighand->siglock);
 511         current->blocked = set;
 512         recalc_sigpending();
 513         spin_unlock_irq(&current->sighand->siglock);
 514
 515         if (rt_restore_ucontext(regs, sw, &frame->uc, &d0))
 516                 goto badframe;
 517         return d0;
 518
 519 badframe:
 520         force_sig(SIGSEGV, current);
 521         return 0;
 522 }
 523
 524 #ifdef CONFIG_FPU
 525 /*
 526  * Set up a signal frame.
 527  */
 528
 529 static inline void save_fpu_state(struct sigcontext *sc, struct pt_regs *regs)
 530 {
 531         if (FPU_IS_EMU) {
 532                 /* save registers */
 533                 memcpy(sc->sc_fpcntl, current->thread.fpcntl, 12);
 534                 memcpy(sc->sc_fpregs, current->thread.fp, 24);
 535                 return;
 536         }
 537 }
 538
 539 static inline int rt_save_fpu_state(struct ucontext __user *uc,
 540         struct pt_regs *regs)
 541 {
 542         int err = 0;
 543
 544         if (FPU_IS_EMU) {
 545                 /* save fpu control register */
 546                 err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpcntl,
 547                                 current->thread.fpcntl, 12);
 548                 /* save all other fpu register */
 549                 err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpregs,
 550                                 current->thread.fp, 96);
 551                 return err;
 552         }
 553
 554         return err;
 555 }
 556 #endif
 557
 558 static void setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
 559                              unsigned long mask)
 560 {
 561         sc->sc_mask = mask;
 562         sc->sc_usp = rdusp();
 563         sc->sc_d0 = regs->d0;
 564         sc->sc_d1 = regs->d1;
 565         sc->sc_a0 = regs->a0;
 566         sc->sc_a1 = regs->a1;
 567         sc->sc_sr = regs->sr;
 568         sc->sc_pc = regs->pc;
 569         sc->sc_formatvec = regs->format << 12 | regs->vector;
 570 #ifdef CONFIG_FPU
 571         save_fpu_state(sc, regs);
 572 #endif
 573 }
 574
 575 static inline int rt_setup_ucontext(struct ucontext __user *uc,
 576         struct pt_regs *regs)
 577 {
 578         struct switch_stack *sw = (struct switch_stack *)regs - 1;
 579         greg_t __user *gregs = uc->uc_mcontext.gregs;
 580         int err = 0;
 581
 582         err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
 583         err |= __put_user(regs->d0, &gregs[0]);
 584         err |= __put_user(regs->d1, &gregs[1]);
 585         err |= __put_user(regs->d2, &gregs[2]);
 586         err |= __put_user(regs->d3, &gregs[3]);
 587         err |= __put_user(regs->d4, &gregs[4]);
 588         err |= __put_user(regs->d5, &gregs[5]);
 589         err |= __put_user(sw->d6, &gregs[6]);
 590         err |= __put_user(sw->d7, &gregs[7]);
 591         err |= __put_user(regs->a0, &gregs[8]);
 592         err |= __put_user(regs->a1, &gregs[9]);
 593         err |= __put_user(regs->a2, &gregs[10]);
 594         err |= __put_user(sw->a3, &gregs[11]);
 595         err |= __put_user(sw->a4, &gregs[12]);
 596         err |= __put_user(sw->a5, &gregs[13]);
 597         err |= __put_user(sw->a6, &gregs[14]);
 598         err |= __put_user(rdusp(), &gregs[15]);
 599         err |= __put_user(regs->pc, &gregs[16]);
 600         err |= __put_user(regs->sr, &gregs[17]);
 601         err |= __put_user((regs->format << 12) | regs->vector,
 602                           &uc->uc_formatvec);
 603 #ifdef CONFIG_FPU
 604         err |= rt_save_fpu_state(uc, regs);
 605 #endif
 606         return err;
 607 }
 608
 609 static inline void push_cache(unsigned long vaddr)
 610 {
 611 #if 0
 612 // JKM -- need to add into the old cpushl cache stuff
 613         cf_cache_push(__pa(vaddr), 8);
 614 #endif
 615 }
 616
 617 static inline void __user *
 618 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 619 {
 620         unsigned long usp;
 621
 622         /* Default to using normal stack.  */
 623         usp = rdusp();
 624
 625         /* This is the X/Open sanctioned signal stack switching.  */
 626         if (ka->sa.sa_flags & SA_ONSTACK) {
 627                 if (!sas_ss_flags(usp))
 628                         usp = current->sas_ss_sp + current->sas_ss_size;
 629         }
 630         return (void __user *)((usp - frame_size) & -8UL);
 631 }
 632
 633 static void setup_frame(int sig, struct k_sigaction *ka,
 634                          sigset_t *set, struct pt_regs *regs)
 635 {
 636         struct sigframe __user *frame;
 637         int fsize = frame_extra_sizes[regs->format];
 638         struct sigcontext context;
 639         int err = 0;
 640
 641         if (fsize < 0) {
 642 #ifdef DEBUG
 643                 printk(KERN_DEBUG "setup_frame: Unknown frame format %#x\n",
 644                         regs->format);
 645 #endif
 646                 goto give_sigsegv;
 647         }
 648
 649         frame = get_sigframe(ka, regs, sizeof(*frame));
 650
 651         err |= __put_user((current_thread_info()->exec_domain
 652                         && current_thread_info()->exec_domain->signal_invmap
 653                         && sig < 32
 654                         ? current_thread_info()->exec_domain->signal_invmap[sig]
 655                         : sig),
 656                         &frame->sig);
 657
 658         err |= __put_user(regs->vector, &frame->code);
 659         err |= __put_user(&frame->sc, &frame->psc);
 660
 661         if (_NSIG_WORDS > 1)
 662                 err |= copy_to_user(frame->extramask, &set->sig[1],
 663                                     sizeof(frame->extramask));
 664
 665         setup_sigcontext(&context, regs, set->sig[0]);
 666         err |= copy_to_user(&frame->sc, &context, sizeof(context));
 667
 668         /* Set up to return from userspace.  */
 669         err |= __put_user(frame->retcode, &frame->pretcode);
 670         /* moveq #,d0; trap #0 */
 671         err |= __put_user(0x70004e40 + (__NR_sigreturn << 16),
 672                           (long __user *)(frame->retcode));
 673
 674         if (err)
 675                 goto give_sigsegv;
 676
 677         push_cache((unsigned long) &frame->retcode);
 678
 679         /* Set up registers for signal handler */
 680         wrusp((unsigned long) frame);
 681         regs->pc = (unsigned long) ka->sa.sa_handler;
 682
 683 adjust_stack:
 684         /* Prepare to skip over the extra stuff in the exception frame.  */
 685         if (regs->stkadj) {
 686                 struct pt_regs *tregs =
 687                         (struct pt_regs *)((ulong)regs + regs->stkadj);
 688 #ifdef DEBUG
 689                 printk(KERN_DEBUG "Performing stackadjust=%04x\n",
 690                         regs->stkadj);
 691 #endif
 692                 /* This must be copied with decreasing addresses to
 693                    handle overlaps.  */
 694                 tregs->vector = 0;
 695                 tregs->format = 0;
 696                 tregs->pc = regs->pc;
 697                 tregs->sr = regs->sr;
 698         }
 699         return;
 700
 701 give_sigsegv:
 702         force_sigsegv(sig, current);
 703         goto adjust_stack;
 704 }
 705
 706 static void setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
 707         sigset_t *set, struct pt_regs *regs)
 708 {
 709         struct rt_sigframe __user *frame;
 710         int fsize = frame_extra_sizes[regs->format];
 711         int err = 0;
 712
 713         if (fsize < 0) {
 714 #ifdef DEBUG
 715                 printk(KERN_DEBUG "setup_frame: Unknown frame format %#x\n",
 716                         regs->format);
 717 #endif
 718                 goto give_sigsegv;
 719         }
 720
 721         frame = get_sigframe(ka, regs, sizeof(*frame));
 722
 723         if (fsize) {
 724                 err |= copy_to_user(&frame->uc.uc_extra, regs + 1, fsize);
 725                 regs->stkadj = fsize;
 726         }
 727
 728         err |= __put_user((current_thread_info()->exec_domain
 729                         && current_thread_info()->exec_domain->signal_invmap
 730                         && sig < 32
 731                         ? current_thread_info()->exec_domain->signal_invmap[sig]
 732                         : sig),
 733                         &frame->sig);
 734         err |= __put_user(&frame->info, &frame->pinfo);
 735         err |= __put_user(&frame->uc, &frame->puc);
 736         err |= copy_siginfo_to_user(&frame->info, info);
 737
 738         /* Create the ucontext.  */
 739         err |= __put_user(0, &frame->uc.uc_flags);
 740         err |= __put_user(NULL, &frame->uc.uc_link);
 741         err |= __put_user((void __user *)current->sas_ss_sp,
 742                           &frame->uc.uc_stack.ss_sp);
 743         err |= __put_user(sas_ss_flags(rdusp()),
 744                           &frame->uc.uc_stack.ss_flags);
 745         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 746         err |= rt_setup_ucontext(&frame->uc, regs);
 747         err |= copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 748
 749         /* Set up to return from userspace.  */
 750         err |= __put_user(frame->retcode, &frame->pretcode);
 751
 752         /* moveq #,d0; andi.l #,D0; trap #0 */
 753         err |= __put_user(0x70AD0280, (long *)(frame->retcode + 0));
 754         err |= __put_user(0x000000ff, (long *)(frame->retcode + 4));
 755         err |= __put_user(0x4e400000, (long *)(frame->retcode + 8));
 756
 757         if (err)
 758                 goto give_sigsegv;
 759
 760         push_cache((unsigned long) &frame->retcode);
 761
 762         /* Set up registers for signal handler */
 763         wrusp((unsigned long) frame);
 764         regs->pc = (unsigned long) ka->sa.sa_handler;
 765
 766 adjust_stack:
 767         /* Prepare to skip over the extra stuff in the exception frame.  */
 768         if (regs->stkadj) {
 769                 struct pt_regs *tregs =
 770                         (struct pt_regs *)((ulong)regs + regs->stkadj);
 771 #ifdef DEBUG
 772                 printk(KERN_DEBUG "Performing stackadjust=%04x\n",
 773                         regs->stkadj);
 774 #endif
 775                 /* This must be copied with decreasing addresses to
 776                    handle overlaps.  */
 777                 tregs->vector = 0;
 778                 tregs->format = 0;
 779                 tregs->pc = regs->pc;
 780                 tregs->sr = regs->sr;
 781         }
 782         return;
 783
 784 give_sigsegv:
 785         force_sigsegv(sig, current);
 786         goto adjust_stack;
 787 }
 788
 789 static inline void
 790 handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
 791 {
 792         switch (regs->d0) {
 793         case -ERESTARTNOHAND:
 794                 if (!has_handler)
 795                         goto do_restart;
 796                 regs->d0 = -EINTR;
 797                 break;
 798
 799         case -ERESTARTSYS:
 800                 if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
 801                         regs->d0 = -EINTR;
 802                         break;
 803                 }
 804         /* fallthrough */
 805         case -ERESTARTNOINTR:
 806 do_restart:
 807                 regs->d0 = regs->orig_d0;
 808                 regs->pc -= 2;
 809                 break;
 810         }
 811 }
 812
 813 /*
 814  * OK, we're invoking a handler
 815  */
 816 static void
 817 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
 818               sigset_t *oldset, struct pt_regs *regs)
 819 {
 820         /* are we from a system call? */
 821         if (regs->orig_d0 >= 0)
 822                 /* If so, check system call restarting.. */
 823                 handle_restart(regs, ka, 1);
 824
 825         /* set up the stack frame */
 826         if (ka->sa.sa_flags & SA_SIGINFO)
 827                 setup_rt_frame(sig, ka, info, oldset, regs);
 828         else
 829                 setup_frame(sig, ka, oldset, regs);
 830
 831         if (ka->sa.sa_flags & SA_ONESHOT)
 832                 ka->sa.sa_handler = SIG_DFL;
 833
 834         spin_lock_irq(&current->sighand->siglock);
 835         sigorsets(&current->blocked, &current->blocked, &ka->sa.sa_mask);
 836         if (!(ka->sa.sa_flags & SA_NODEFER))
 837                 sigaddset(&current->blocked, sig);
 838         recalc_sigpending();
 839         spin_unlock_irq(&current->sighand->siglock);
 840 }
 841
 842 /*
 843  * Note that 'init' is a special process: it doesn't get signals it doesn't
 844  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 845  * mistake.
 846  */
 847 asmlinkage int do_signal(sigset_t *oldset, struct pt_regs *regs)
 848 {
 849         siginfo_t info;
 850         struct k_sigaction ka;
 851         int signr;
 852
 853         current->thread.esp0 = (unsigned long) regs;
 854
 855         if (!oldset)
 856                 oldset = &current->blocked;
 857
 858         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 859         if (signr > 0) {
 860                 /* Whee!  Actually deliver the signal.  */
 861                 handle_signal(signr, &ka, &info, oldset, regs);
 862                 return 1;
 863         }
 864
 865         /* Did we come from a system call? */
 866         if (regs->orig_d0 >= 0)
 867                 /* Restart the system call - no handlers present */
 868                 handle_restart(regs, NULL, 0);
 869
 870         return 0;
 871 }