arch/m68k/kernel/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  * Linux/m68k support by Hamish Macdonald
  13  *
  14  * 68060 fixes by Jesper Skov
  15  *
  16  * 1997-12-01  Modified for POSIX.1b signals by Andreas Schwab
  17  *
  18  * mathemu support by Roman Zippel
  19  *  (Note: fpstate in the signal context is completely ignored for the emulator
  20  *         and the internal floating point format is put on stack)
  21  */
  22
  23 /*
  24  * ++roman (07/09/96): implemented signal stacks (specially for tosemu on
  25  * Atari :-) Current limitation: Only one sigstack can be active at one time.
  26  * If a second signal with SA_ONSTACK set arrives while working on a sigstack,
  27  * SA_ONSTACK is ignored. This behaviour avoids lots of trouble with nested
  28  * signal handlers!
  29  */
  30
  31 #include <linux/sched.h>
  32 #include <linux/mm.h>
  33 #include <linux/kernel.h>
  34 #include <linux/signal.h>
  35 #include <linux/syscalls.h>
  36 #include <linux/errno.h>
  37 #include <linux/wait.h>
  38 #include <linux/ptrace.h>
  39 #include <linux/unistd.h>
  40 #include <linux/stddef.h>
  41 #include <linux/highuid.h>
  42 #include <linux/personality.h>
  43 #include <linux/tty.h>
  44 #include <linux/binfmts.h>
  45 #include <linux/module.h>
  46 #include <linux/tracehook.h>
  47
  48 #include <asm/setup.h>
  49 #include <asm/uaccess.h>
  50 #include <asm/pgtable.h>
  51 #include <asm/traps.h>
  52 #include <asm/ucontext.h>
  53
  54 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  55
  56 #ifdef CONFIG_MMU
  57
  58 /*
  59  * Handle the slight differences in classic 68k and ColdFire trap frames.
  60  */
  61 #ifdef CONFIG_COLDFIRE
  62 #define FORMAT          4
  63 #define FMT4SIZE        0
  64 #else
  65 #define FORMAT          0
  66 #define FMT4SIZE        sizeof(((struct frame *)0)->un.fmt4)
  67 #endif
  68
  69 static const int frame_size_change[16] = {
  70   [1]   = -1, /* sizeof(((struct frame *)0)->un.fmt1), */
  71   [2]   = sizeof(((struct frame *)0)->un.fmt2),
  72   [3]   = sizeof(((struct frame *)0)->un.fmt3),
  73   [4]   = FMT4SIZE,
  74   [5]   = -1, /* sizeof(((struct frame *)0)->un.fmt5), */
  75   [6]   = -1, /* sizeof(((struct frame *)0)->un.fmt6), */
  76   [7]   = sizeof(((struct frame *)0)->un.fmt7),
  77   [8]   = -1, /* sizeof(((struct frame *)0)->un.fmt8), */
  78   [9]   = sizeof(((struct frame *)0)->un.fmt9),
  79   [10]  = sizeof(((struct frame *)0)->un.fmta),
  80   [11]  = sizeof(((struct frame *)0)->un.fmtb),
  81   [12]  = -1, /* sizeof(((struct frame *)0)->un.fmtc), */
  82   [13]  = -1, /* sizeof(((struct frame *)0)->un.fmtd), */
  83   [14]  = -1, /* sizeof(((struct frame *)0)->un.fmte), */
  84   [15]  = -1, /* sizeof(((struct frame *)0)->un.fmtf), */
  85 };
  86
  87 static inline int frame_extra_sizes(int f)
  88 {
  89         return frame_size_change[f];
  90 }
  91
  92 int handle_kernel_fault(struct pt_regs *regs)
  93 {
  94         const struct exception_table_entry *fixup;
  95         struct pt_regs *tregs;
  96
  97         /* Are we prepared to handle this kernel fault? */
  98         fixup = search_exception_tables(regs->pc);
  99         if (!fixup)
 100                 return 0;
 101
 102         /* Create a new four word stack frame, discarding the old one. */
 103         regs->stkadj = frame_extra_sizes(regs->format);
 104         tregs = (struct pt_regs *)((long)regs + regs->stkadj);
 105         tregs->vector = regs->vector;
 106         tregs->format = FORMAT;
 107         tregs->pc = fixup->fixup;
 108         tregs->sr = regs->sr;
 109
 110         return 1;
 111 }
 112
 113 void ptrace_signal_deliver(struct pt_regs *regs, void *cookie)
 114 {
 115         if (regs->orig_d0 < 0)
 116                 return;
 117         switch (regs->d0) {
 118         case -ERESTARTNOHAND:
 119         case -ERESTARTSYS:
 120         case -ERESTARTNOINTR:
 121                 regs->d0 = regs->orig_d0;
 122                 regs->orig_d0 = -1;
 123                 regs->pc -= 2;
 124                 break;
 125         }
 126 }
 127
 128 static inline void push_cache (unsigned long vaddr)
 129 {
 130         /*
 131          * Using the old cache_push_v() was really a big waste.
 132          *
 133          * What we are trying to do is to flush 8 bytes to ram.
 134          * Flushing 2 cache lines of 16 bytes is much cheaper than
 135          * flushing 1 or 2 pages, as previously done in
 136          * cache_push_v().
 137          *                                                     Jes
 138          */
 139         if (CPU_IS_040) {
 140                 unsigned long temp;
 141
 142                 __asm__ __volatile__ (".chip 68040\n\t"
 143                                       "nop\n\t"
 144                                       "ptestr (%1)\n\t"
 145                                       "movec %%mmusr,%0\n\t"
 146                                       ".chip 68k"
 147                                       : "=r" (temp)
 148                                       : "a" (vaddr));
 149
 150                 temp &= PAGE_MASK;
 151                 temp |= vaddr & ~PAGE_MASK;
 152
 153                 __asm__ __volatile__ (".chip 68040\n\t"
 154                                       "nop\n\t"
 155                                       "cpushl %%bc,(%0)\n\t"
 156                                       ".chip 68k"
 157                                       : : "a" (temp));
 158         }
 159         else if (CPU_IS_060) {
 160                 unsigned long temp;
 161                 __asm__ __volatile__ (".chip 68060\n\t"
 162                                       "plpar (%0)\n\t"
 163                                       ".chip 68k"
 164                                       : "=a" (temp)
 165                                       : "0" (vaddr));
 166                 __asm__ __volatile__ (".chip 68060\n\t"
 167                                       "cpushl %%bc,(%0)\n\t"
 168                                       ".chip 68k"
 169                                       : : "a" (temp));
 170         } else if (!CPU_IS_COLDFIRE) {
 171                 /*
 172                  * 68030/68020 have no writeback cache;
 173                  * still need to clear icache.
 174                  * Note that vaddr is guaranteed to be long word aligned.
 175                  */
 176                 unsigned long temp;
 177                 asm volatile ("movec %%cacr,%0" : "=r" (temp));
 178                 temp += 4;
 179                 asm volatile ("movec %0,%%caar\n\t"
 180                               "movec %1,%%cacr"
 181                               : : "r" (vaddr), "r" (temp));
 182                 asm volatile ("movec %0,%%caar\n\t"
 183                               "movec %1,%%cacr"
 184                               : : "r" (vaddr + 4), "r" (temp));
 185         }
 186 }
 187
 188 static inline void adjustformat(struct pt_regs *regs)
 189 {
 190 }
 191
 192 static inline void save_a5_state(struct sigcontext *sc, struct pt_regs *regs)
 193 {
 194 }
 195
 196 #else /* CONFIG_MMU */
 197
 198 void ret_from_user_signal(void);
 199 void ret_from_user_rt_signal(void);
 200
 201 static inline int frame_extra_sizes(int f)
 202 {
 203         /* No frame size adjustments required on non-MMU CPUs */
 204         return 0;
 205 }
 206
 207 static inline void adjustformat(struct pt_regs *regs)
 208 {
 209         ((struct switch_stack *)regs - 1)->a5 = current->mm->start_data;
 210         /*
 211          * set format byte to make stack appear modulo 4, which it will
 212          * be when doing the rte
 213          */
 214         regs->format = 0x4;
 215 }
 216
 217 static inline void save_a5_state(struct sigcontext *sc, struct pt_regs *regs)
 218 {
 219         sc->sc_a5 = ((struct switch_stack *)regs - 1)->a5;
 220 }
 221
 222 static inline void push_cache(unsigned long vaddr)
 223 {
 224 }
 225
 226 #endif /* CONFIG_MMU */
 227
 228 /*
 229  * Atomically swap in the new signal mask, and wait for a signal.
 230  */
 231 asmlinkage int
 232 sys_sigsuspend(int unused0, int unused1, old_sigset_t mask)
 233 {
 234         sigset_t blocked;
 235         siginitset(&blocked, mask);
 236         return sigsuspend(&blocked);
 237 }
 238
 239 asmlinkage int
 240 sys_sigaction(int sig, const struct old_sigaction __user *act,
 241               struct old_sigaction __user *oact)
 242 {
 243         struct k_sigaction new_ka, old_ka;
 244         int ret;
 245
 246         if (act) {
 247                 old_sigset_t mask;
 248                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 249                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
 250                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
 251                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
 252                     __get_user(mask, &act->sa_mask))
 253                         return -EFAULT;
 254                 siginitset(&new_ka.sa.sa_mask, mask);
 255         }
 256
 257         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 258
 259         if (!ret && oact) {
 260                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 261                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
 262                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
 263                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
 264                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
 265                         return -EFAULT;
 266         }
 267
 268         return ret;
 269 }
 270
 271 asmlinkage int
 272 sys_sigaltstack(const stack_t __user *uss, stack_t __user *uoss)
 273 {
 274         return do_sigaltstack(uss, uoss, rdusp());
 275 }
 276
 277
 278 /*
 279  * Do a signal return; undo the signal stack.
 280  *
 281  * Keep the return code on the stack quadword aligned!
 282  * That makes the cache flush below easier.
 283  */
 284
 285 struct sigframe
 286 {
 287         char __user *pretcode;
 288         int sig;
 289         int code;
 290         struct sigcontext __user *psc;
 291         char retcode[8];
 292         unsigned long extramask[_NSIG_WORDS-1];
 293         struct sigcontext sc;
 294 };
 295
 296 struct rt_sigframe
 297 {
 298         char __user *pretcode;
 299         int sig;
 300         struct siginfo __user *pinfo;
 301         void __user *puc;
 302         char retcode[8];
 303         struct siginfo info;
 304         struct ucontext uc;
 305 };
 306
 307 #define FPCONTEXT_SIZE  216
 308 #define uc_fpstate      uc_filler[0]
 309 #define uc_formatvec    uc_filler[FPCONTEXT_SIZE/4]
 310 #define uc_extra        uc_filler[FPCONTEXT_SIZE/4+1]
 311
 312 #ifdef CONFIG_FPU
 313
 314 static unsigned char fpu_version;       /* version number of fpu, set by setup_frame */
 315
 316 static inline int restore_fpu_state(struct sigcontext *sc)
 317 {
 318         int err = 1;
 319
 320         if (FPU_IS_EMU) {
 321             /* restore registers */
 322             memcpy(current->thread.fpcntl, sc->sc_fpcntl, 12);
 323             memcpy(current->thread.fp, sc->sc_fpregs, 24);
 324             return 0;
 325         }
 326
 327         if (CPU_IS_060 ? sc->sc_fpstate[2] : sc->sc_fpstate[0]) {
 328             /* Verify the frame format.  */
 329             if (!(CPU_IS_060 || CPU_IS_COLDFIRE) &&
 330                  (sc->sc_fpstate[0] != fpu_version))
 331                 goto out;
 332             if (CPU_IS_020_OR_030) {
 333                 if (m68k_fputype & FPU_68881 &&
 334                     !(sc->sc_fpstate[1] == 0x18 || sc->sc_fpstate[1] == 0xb4))
 335                     goto out;
 336                 if (m68k_fputype & FPU_68882 &&
 337                     !(sc->sc_fpstate[1] == 0x38 || sc->sc_fpstate[1] == 0xd4))
 338                     goto out;
 339             } else if (CPU_IS_040) {
 340                 if (!(sc->sc_fpstate[1] == 0x00 ||
 341                       sc->sc_fpstate[1] == 0x28 ||
 342                       sc->sc_fpstate[1] == 0x60))
 343                     goto out;
 344             } else if (CPU_IS_060) {
 345                 if (!(sc->sc_fpstate[3] == 0x00 ||
 346                       sc->sc_fpstate[3] == 0x60 ||
 347                       sc->sc_fpstate[3] == 0xe0))
 348                     goto out;
 349             } else if (CPU_IS_COLDFIRE) {
 350                 if (!(sc->sc_fpstate[0] == 0x00 ||
 351                       sc->sc_fpstate[0] == 0x05 ||
 352                       sc->sc_fpstate[0] == 0xe5))
 353                     goto out;
 354             } else
 355                 goto out;
 356
 357             if (CPU_IS_COLDFIRE) {
 358                 __asm__ volatile ("fmovemd %0,%%fp0-%%fp1\n\t"
 359                                   "fmovel %1,%%fpcr\n\t"
 360                                   "fmovel %2,%%fpsr\n\t"
 361                                   "fmovel %3,%%fpiar"
 362                                   : /* no outputs */
 363                                   : "m" (sc->sc_fpregs[0]),
 364                                     "m" (sc->sc_fpcntl[0]),
 365                                     "m" (sc->sc_fpcntl[1]),
 366                                     "m" (sc->sc_fpcntl[2]));
 367             } else {
 368                 __asm__ volatile (".chip 68k/68881\n\t"
 369                                   "fmovemx %0,%%fp0-%%fp1\n\t"
 370                                   "fmoveml %1,%%fpcr/%%fpsr/%%fpiar\n\t"
 371                                   ".chip 68k"
 372                                   : /* no outputs */
 373                                   : "m" (*sc->sc_fpregs),
 374                                     "m" (*sc->sc_fpcntl));
 375             }
 376         }
 377
 378         if (CPU_IS_COLDFIRE) {
 379                 __asm__ volatile ("frestore %0" : : "m" (*sc->sc_fpstate));
 380         } else {
 381                 __asm__ volatile (".chip 68k/68881\n\t"
 382                                   "frestore %0\n\t"
 383                                   ".chip 68k"
 384                                   : : "m" (*sc->sc_fpstate));
 385         }
 386         err = 0;
 387
 388 out:
 389         return err;
 390 }
 391
 392 static inline int rt_restore_fpu_state(struct ucontext __user *uc)
 393 {
 394         unsigned char fpstate[FPCONTEXT_SIZE];
 395         int context_size = CPU_IS_060 ? 8 : (CPU_IS_COLDFIRE ? 12 : 0);
 396         fpregset_t fpregs;
 397         int err = 1;
 398
 399         if (FPU_IS_EMU) {
 400                 /* restore fpu control register */
 401                 if (__copy_from_user(current->thread.fpcntl,
 402                                 uc->uc_mcontext.fpregs.f_fpcntl, 12))
 403                         goto out;
 404                 /* restore all other fpu register */
 405                 if (__copy_from_user(current->thread.fp,
 406                                 uc->uc_mcontext.fpregs.f_fpregs, 96))
 407                         goto out;
 408                 return 0;
 409         }
 410
 411         if (__get_user(*(long *)fpstate, (long __user *)&uc->uc_fpstate))
 412                 goto out;
 413         if (CPU_IS_060 ? fpstate[2] : fpstate[0]) {
 414                 if (!(CPU_IS_060 || CPU_IS_COLDFIRE))
 415                         context_size = fpstate[1];
 416                 /* Verify the frame format.  */
 417                 if (!(CPU_IS_060 || CPU_IS_COLDFIRE) &&
 418                      (fpstate[0] != fpu_version))
 419                         goto out;
 420                 if (CPU_IS_020_OR_030) {
 421                         if (m68k_fputype & FPU_68881 &&
 422                             !(context_size == 0x18 || context_size == 0xb4))
 423                                 goto out;
 424                         if (m68k_fputype & FPU_68882 &&
 425                             !(context_size == 0x38 || context_size == 0xd4))
 426                                 goto out;
 427                 } else if (CPU_IS_040) {
 428                         if (!(context_size == 0x00 ||
 429                               context_size == 0x28 ||
 430                               context_size == 0x60))
 431                                 goto out;
 432                 } else if (CPU_IS_060) {
 433                         if (!(fpstate[3] == 0x00 ||
 434                               fpstate[3] == 0x60 ||
 435                               fpstate[3] == 0xe0))
 436                                 goto out;
 437                 } else if (CPU_IS_COLDFIRE) {
 438                         if (!(fpstate[3] == 0x00 ||
 439                               fpstate[3] == 0x05 ||
 440                               fpstate[3] == 0xe5))
 441                                 goto out;
 442                 } else
 443                         goto out;
 444                 if (__copy_from_user(&fpregs, &uc->uc_mcontext.fpregs,
 445                                      sizeof(fpregs)))
 446                         goto out;
 447
 448                 if (CPU_IS_COLDFIRE) {
 449                         __asm__ volatile ("fmovemd %0,%%fp0-%%fp7\n\t"
 450                                           "fmovel %1,%%fpcr\n\t"
 451                                           "fmovel %2,%%fpsr\n\t"
 452                                           "fmovel %3,%%fpiar"
 453                                           : /* no outputs */
 454                                           : "m" (fpregs.f_fpregs[0]),
 455                                             "m" (fpregs.f_fpcntl[0]),
 456                                             "m" (fpregs.f_fpcntl[1]),
 457                                             "m" (fpregs.f_fpcntl[2]));
 458                 } else {
 459                         __asm__ volatile (".chip 68k/68881\n\t"
 460                                           "fmovemx %0,%%fp0-%%fp7\n\t"
 461                                           "fmoveml %1,%%fpcr/%%fpsr/%%fpiar\n\t"
 462                                           ".chip 68k"
 463                                           : /* no outputs */
 464                                           : "m" (*fpregs.f_fpregs),
 465                                             "m" (*fpregs.f_fpcntl));
 466                 }
 467         }
 468         if (context_size &&
 469             __copy_from_user(fpstate + 4, (long __user *)&uc->uc_fpstate + 1,
 470                              context_size))
 471                 goto out;
 472
 473         if (CPU_IS_COLDFIRE) {
 474                 __asm__ volatile ("frestore %0" : : "m" (*fpstate));
 475         } else {
 476                 __asm__ volatile (".chip 68k/68881\n\t"
 477                                   "frestore %0\n\t"
 478                                   ".chip 68k"
 479                                   : : "m" (*fpstate));
 480         }
 481         err = 0;
 482
 483 out:
 484         return err;
 485 }
 486
 487 /*
 488  * Set up a signal frame.
 489  */
 490 static inline void save_fpu_state(struct sigcontext *sc, struct pt_regs *regs)
 491 {
 492         if (FPU_IS_EMU) {
 493                 /* save registers */
 494                 memcpy(sc->sc_fpcntl, current->thread.fpcntl, 12);
 495                 memcpy(sc->sc_fpregs, current->thread.fp, 24);
 496                 return;
 497         }
 498
 499         if (CPU_IS_COLDFIRE) {
 500                 __asm__ volatile ("fsave %0"
 501                                   : : "m" (*sc->sc_fpstate) : "memory");
 502         } else {
 503                 __asm__ volatile (".chip 68k/68881\n\t"
 504                                   "fsave %0\n\t"
 505                                   ".chip 68k"
 506                                   : : "m" (*sc->sc_fpstate) : "memory");
 507         }
 508
 509         if (CPU_IS_060 ? sc->sc_fpstate[2] : sc->sc_fpstate[0]) {
 510                 fpu_version = sc->sc_fpstate[0];
 511                 if (CPU_IS_020_OR_030 &&
 512                     regs->vector >= (VEC_FPBRUC * 4) &&
 513                     regs->vector <= (VEC_FPNAN * 4)) {
 514                         /* Clear pending exception in 68882 idle frame */
 515                         if (*(unsigned short *) sc->sc_fpstate == 0x1f38)
 516                                 sc->sc_fpstate[0x38] |= 1 << 3;
 517                 }
 518
 519                 if (CPU_IS_COLDFIRE) {
 520                         __asm__ volatile ("fmovemd %%fp0-%%fp1,%0\n\t"
 521                                           "fmovel %%fpcr,%1\n\t"
 522                                           "fmovel %%fpsr,%2\n\t"
 523                                           "fmovel %%fpiar,%3"
 524                                           : "=m" (sc->sc_fpregs[0]),
 525                                             "=m" (sc->sc_fpcntl[0]),
 526                                             "=m" (sc->sc_fpcntl[1]),
 527                                             "=m" (sc->sc_fpcntl[2])
 528                                           : /* no inputs */
 529                                           : "memory");
 530                 } else {
 531                         __asm__ volatile (".chip 68k/68881\n\t"
 532                                           "fmovemx %%fp0-%%fp1,%0\n\t"
 533                                           "fmoveml %%fpcr/%%fpsr/%%fpiar,%1\n\t"
 534                                           ".chip 68k"
 535                                           : "=m" (*sc->sc_fpregs),
 536                                             "=m" (*sc->sc_fpcntl)
 537                                           : /* no inputs */
 538                                           : "memory");
 539                 }
 540         }
 541 }
 542
 543 static inline int rt_save_fpu_state(struct ucontext __user *uc, struct pt_regs *regs)
 544 {
 545         unsigned char fpstate[FPCONTEXT_SIZE];
 546         int context_size = CPU_IS_060 ? 8 : (CPU_IS_COLDFIRE ? 12 : 0);
 547         int err = 0;
 548
 549         if (FPU_IS_EMU) {
 550                 /* save fpu control register */
 551                 err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpcntl,
 552                                 current->thread.fpcntl, 12);
 553                 /* save all other fpu register */
 554                 err |= copy_to_user(uc->uc_mcontext.fpregs.f_fpregs,
 555                                 current->thread.fp, 96);
 556                 return err;
 557         }
 558
 559         if (CPU_IS_COLDFIRE) {
 560                 __asm__ volatile ("fsave %0" : : "m" (*fpstate) : "memory");
 561         } else {
 562                 __asm__ volatile (".chip 68k/68881\n\t"
 563                                   "fsave %0\n\t"
 564                                   ".chip 68k"
 565                                   : : "m" (*fpstate) : "memory");
 566         }
 567
 568         err |= __put_user(*(long *)fpstate, (long __user *)&uc->uc_fpstate);
 569         if (CPU_IS_060 ? fpstate[2] : fpstate[0]) {
 570                 fpregset_t fpregs;
 571                 if (!(CPU_IS_060 || CPU_IS_COLDFIRE))
 572                         context_size = fpstate[1];
 573                 fpu_version = fpstate[0];
 574                 if (CPU_IS_020_OR_030 &&
 575                     regs->vector >= (VEC_FPBRUC * 4) &&
 576                     regs->vector <= (VEC_FPNAN * 4)) {
 577                         /* Clear pending exception in 68882 idle frame */
 578                         if (*(unsigned short *) fpstate == 0x1f38)
 579                                 fpstate[0x38] |= 1 << 3;
 580                 }
 581                 if (CPU_IS_COLDFIRE) {
 582                         __asm__ volatile ("fmovemd %%fp0-%%fp7,%0\n\t"
 583                                           "fmovel %%fpcr,%1\n\t"
 584                                           "fmovel %%fpsr,%2\n\t"
 585                                           "fmovel %%fpiar,%3"
 586                                           : "=m" (fpregs.f_fpregs[0]),
 587                                             "=m" (fpregs.f_fpcntl[0]),
 588                                             "=m" (fpregs.f_fpcntl[1]),
 589                                             "=m" (fpregs.f_fpcntl[2])
 590                                           : /* no inputs */
 591                                           : "memory");
 592                 } else {
 593                         __asm__ volatile (".chip 68k/68881\n\t"
 594                                           "fmovemx %%fp0-%%fp7,%0\n\t"
 595                                           "fmoveml %%fpcr/%%fpsr/%%fpiar,%1\n\t"
 596                                           ".chip 68k"
 597                                           : "=m" (*fpregs.f_fpregs),
 598                                             "=m" (*fpregs.f_fpcntl)
 599                                           : /* no inputs */
 600                                           : "memory");
 601                 }
 602                 err |= copy_to_user(&uc->uc_mcontext.fpregs, &fpregs,
 603                                     sizeof(fpregs));
 604         }
 605         if (context_size)
 606                 err |= copy_to_user((long __user *)&uc->uc_fpstate + 1, fpstate + 4,
 607                                     context_size);
 608         return err;
 609 }
 610
 611 #else /* CONFIG_FPU */
 612
 613 /*
 614  * For the case with no FPU configured these all do nothing.
 615  */
 616 static inline int restore_fpu_state(struct sigcontext *sc)
 617 {
 618         return 0;
 619 }
 620
 621 static inline int rt_restore_fpu_state(struct ucontext __user *uc)
 622 {
 623         return 0;
 624 }
 625
 626 static inline void save_fpu_state(struct sigcontext *sc, struct pt_regs *regs)
 627 {
 628 }
 629
 630 static inline int rt_save_fpu_state(struct ucontext __user *uc, struct pt_regs *regs)
 631 {
 632         return 0;
 633 }
 634
 635 #endif /* CONFIG_FPU */
 636
 637 static int mangle_kernel_stack(struct pt_regs *regs, int formatvec,
 638                                void __user *fp)
 639 {
 640         int fsize = frame_extra_sizes(formatvec >> 12);
 641         if (fsize < 0) {
 642                 /*
 643                  * user process trying to return with weird frame format
 644                  */
 645 #ifdef DEBUG
 646                 printk("user process returning with weird frame format\n");
 647 #endif
 648                 return 1;
 649         }
 650         if (!fsize) {
 651                 regs->format = formatvec >> 12;
 652                 regs->vector = formatvec & 0xfff;
 653         } else {
 654                 struct switch_stack *sw = (struct switch_stack *)regs - 1;
 655                 unsigned long buf[fsize / 2]; /* yes, twice as much */
 656
 657                 /* that'll make sure that expansion won't crap over data */
 658                 if (copy_from_user(buf + fsize / 4, fp, fsize))
 659                         return 1;
 660
 661                 /* point of no return */
 662                 regs->format = formatvec >> 12;
 663                 regs->vector = formatvec & 0xfff;
 664 #define frame_offset (sizeof(struct pt_regs)+sizeof(struct switch_stack))
 665                 __asm__ __volatile__ (
 666 #ifdef CONFIG_COLDFIRE
 667                          "   movel %0,%/sp\n\t"
 668                          "   bra ret_from_signal\n"
 669 #else
 670                          "   movel %0,%/a0\n\t"
 671                          "   subl %1,%/a0\n\t"     /* make room on stack */
 672                          "   movel %/a0,%/sp\n\t"  /* set stack pointer */
 673                          /* move switch_stack and pt_regs */
 674                          "1: movel %0@+,%/a0@+\n\t"
 675                          "   dbra %2,1b\n\t"
 676                          "   lea %/sp@(%c3),%/a0\n\t" /* add offset of fmt */
 677                          "   lsrl  #2,%1\n\t"
 678                          "   subql #1,%1\n\t"
 679                          /* copy to the gap we'd made */
 680                          "2: movel %4@+,%/a0@+\n\t"
 681                          "   dbra %1,2b\n\t"
 682                          "   bral ret_from_signal\n"
 683 #endif
 684                          : /* no outputs, it doesn't ever return */
 685                          : "a" (sw), "d" (fsize), "d" (frame_offset/4-1),
 686                            "n" (frame_offset), "a" (buf + fsize/4)
 687                          : "a0");
 688 #undef frame_offset
 689         }
 690         return 0;
 691 }
 692
 693 static inline int
 694 restore_sigcontext(struct pt_regs *regs, struct sigcontext __user *usc, void __user *fp)
 695 {
 696         int formatvec;
 697         struct sigcontext context;
 698         int err = 0;
 699
 700         /* Always make any pending restarted system calls return -EINTR */
 701         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 702
 703         /* get previous context */
 704         if (copy_from_user(&context, usc, sizeof(context)))
 705                 goto badframe;
 706
 707         /* restore passed registers */
 708         regs->d0 = context.sc_d0;
 709         regs->d1 = context.sc_d1;
 710         regs->a0 = context.sc_a0;
 711         regs->a1 = context.sc_a1;
 712         regs->sr = (regs->sr & 0xff00) | (context.sc_sr & 0xff);
 713         regs->pc = context.sc_pc;
 714         regs->orig_d0 = -1;             /* disable syscall checks */
 715         wrusp(context.sc_usp);
 716         formatvec = context.sc_formatvec;
 717
 718         err = restore_fpu_state(&context);
 719
 720         if (err || mangle_kernel_stack(regs, formatvec, fp))
 721                 goto badframe;
 722
 723         return 0;
 724
 725 badframe:
 726         return 1;
 727 }
 728
 729 static inline int
 730 rt_restore_ucontext(struct pt_regs *regs, struct switch_stack *sw,
 731                     struct ucontext __user *uc)
 732 {
 733         int temp;
 734         greg_t __user *gregs = uc->uc_mcontext.gregs;
 735         unsigned long usp;
 736         int err;
 737
 738         /* Always make any pending restarted system calls return -EINTR */
 739         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 740
 741         err = __get_user(temp, &uc->uc_mcontext.version);
 742         if (temp != MCONTEXT_VERSION)
 743                 goto badframe;
 744         /* restore passed registers */
 745         err |= __get_user(regs->d0, &gregs[0]);
 746         err |= __get_user(regs->d1, &gregs[1]);
 747         err |= __get_user(regs->d2, &gregs[2]);
 748         err |= __get_user(regs->d3, &gregs[3]);
 749         err |= __get_user(regs->d4, &gregs[4]);
 750         err |= __get_user(regs->d5, &gregs[5]);
 751         err |= __get_user(sw->d6, &gregs[6]);
 752         err |= __get_user(sw->d7, &gregs[7]);
 753         err |= __get_user(regs->a0, &gregs[8]);
 754         err |= __get_user(regs->a1, &gregs[9]);
 755         err |= __get_user(regs->a2, &gregs[10]);
 756         err |= __get_user(sw->a3, &gregs[11]);
 757         err |= __get_user(sw->a4, &gregs[12]);
 758         err |= __get_user(sw->a5, &gregs[13]);
 759         err |= __get_user(sw->a6, &gregs[14]);
 760         err |= __get_user(usp, &gregs[15]);
 761         wrusp(usp);
 762         err |= __get_user(regs->pc, &gregs[16]);
 763         err |= __get_user(temp, &gregs[17]);
 764         regs->sr = (regs->sr & 0xff00) | (temp & 0xff);
 765         regs->orig_d0 = -1;             /* disable syscall checks */
 766         err |= __get_user(temp, &uc->uc_formatvec);
 767
 768         err |= rt_restore_fpu_state(uc);
 769
 770         if (err || do_sigaltstack(&uc->uc_stack, NULL, usp) == -EFAULT)
 771                 goto badframe;
 772
 773         if (mangle_kernel_stack(regs, temp, &uc->uc_extra))
 774                 goto badframe;
 775
 776         return 0;
 777
 778 badframe:
 779         return 1;
 780 }
 781
 782 asmlinkage int do_sigreturn(unsigned long __unused)
 783 {
 784         struct switch_stack *sw = (struct switch_stack *) &__unused;
 785         struct pt_regs *regs = (struct pt_regs *) (sw + 1);
 786         unsigned long usp = rdusp();
 787         struct sigframe __user *frame = (struct sigframe __user *)(usp - 4);
 788         sigset_t set;
 789
 790         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 791                 goto badframe;
 792         if (__get_user(set.sig[0], &frame->sc.sc_mask) ||
 793             (_NSIG_WORDS > 1 &&
 794              __copy_from_user(&set.sig[1], &frame->extramask,
 795                               sizeof(frame->extramask))))
 796                 goto badframe;
 797
 798         sigdelsetmask(&set, ~_BLOCKABLE);
 799         set_current_blocked(&set);
 800
 801         if (restore_sigcontext(regs, &frame->sc, frame + 1))
 802                 goto badframe;
 803         return regs->d0;
 804
 805 badframe:
 806         force_sig(SIGSEGV, current);
 807         return 0;
 808 }
 809
 810 asmlinkage int do_rt_sigreturn(unsigned long __unused)
 811 {
 812         struct switch_stack *sw = (struct switch_stack *) &__unused;
 813         struct pt_regs *regs = (struct pt_regs *) (sw + 1);
 814         unsigned long usp = rdusp();
 815         struct rt_sigframe __user *frame = (struct rt_sigframe __user *)(usp - 4);
 816         sigset_t set;
 817
 818         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 819                 goto badframe;
 820         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 821                 goto badframe;
 822
 823         sigdelsetmask(&set, ~_BLOCKABLE);
 824         set_current_blocked(&set);
 825
 826         if (rt_restore_ucontext(regs, sw, &frame->uc))
 827                 goto badframe;
 828         return regs->d0;
 829
 830 badframe:
 831         force_sig(SIGSEGV, current);
 832         return 0;
 833 }
 834
 835 static void setup_sigcontext(struct sigcontext *sc, struct pt_regs *regs,
 836                              unsigned long mask)
 837 {
 838         sc->sc_mask = mask;
 839         sc->sc_usp = rdusp();
 840         sc->sc_d0 = regs->d0;
 841         sc->sc_d1 = regs->d1;
 842         sc->sc_a0 = regs->a0;
 843         sc->sc_a1 = regs->a1;
 844         sc->sc_sr = regs->sr;
 845         sc->sc_pc = regs->pc;
 846         sc->sc_formatvec = regs->format << 12 | regs->vector;
 847         save_a5_state(sc, regs);
 848         save_fpu_state(sc, regs);
 849 }
 850
 851 static inline int rt_setup_ucontext(struct ucontext __user *uc, struct pt_regs *regs)
 852 {
 853         struct switch_stack *sw = (struct switch_stack *)regs - 1;
 854         greg_t __user *gregs = uc->uc_mcontext.gregs;
 855         int err = 0;
 856
 857         err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version);
 858         err |= __put_user(regs->d0, &gregs[0]);
 859         err |= __put_user(regs->d1, &gregs[1]);
 860         err |= __put_user(regs->d2, &gregs[2]);
 861         err |= __put_user(regs->d3, &gregs[3]);
 862         err |= __put_user(regs->d4, &gregs[4]);
 863         err |= __put_user(regs->d5, &gregs[5]);
 864         err |= __put_user(sw->d6, &gregs[6]);
 865         err |= __put_user(sw->d7, &gregs[7]);
 866         err |= __put_user(regs->a0, &gregs[8]);
 867         err |= __put_user(regs->a1, &gregs[9]);
 868         err |= __put_user(regs->a2, &gregs[10]);
 869         err |= __put_user(sw->a3, &gregs[11]);
 870         err |= __put_user(sw->a4, &gregs[12]);
 871         err |= __put_user(sw->a5, &gregs[13]);
 872         err |= __put_user(sw->a6, &gregs[14]);
 873         err |= __put_user(rdusp(), &gregs[15]);
 874         err |= __put_user(regs->pc, &gregs[16]);
 875         err |= __put_user(regs->sr, &gregs[17]);
 876         err |= __put_user((regs->format << 12) | regs->vector, &uc->uc_formatvec);
 877         err |= rt_save_fpu_state(uc, regs);
 878         return err;
 879 }
 880
 881 static inline void __user *
 882 get_sigframe(struct k_sigaction *ka, struct pt_regs *regs, size_t frame_size)
 883 {
 884         unsigned long usp;
 885
 886         /* Default to using normal stack.  */
 887         usp = rdusp();
 888
 889         /* This is the X/Open sanctioned signal stack switching.  */
 890         if (ka->sa.sa_flags & SA_ONSTACK) {
 891                 if (!sas_ss_flags(usp))
 892                         usp = current->sas_ss_sp + current->sas_ss_size;
 893         }
 894         return (void __user *)((usp - frame_size) & -8UL);
 895 }
 896
 897 static int setup_frame (int sig, struct k_sigaction *ka,
 898                          sigset_t *set, struct pt_regs *regs)
 899 {
 900         struct sigframe __user *frame;
 901         int fsize = frame_extra_sizes(regs->format);
 902         struct sigcontext context;
 903         int err = 0;
 904
 905         if (fsize < 0) {
 906 #ifdef DEBUG
 907                 printk ("setup_frame: Unknown frame format %#x\n",
 908                         regs->format);
 909 #endif
 910                 goto give_sigsegv;
 911         }
 912
 913         frame = get_sigframe(ka, regs, sizeof(*frame) + fsize);
 914
 915         if (fsize)
 916                 err |= copy_to_user (frame + 1, regs + 1, fsize);
 917
 918         err |= __put_user((current_thread_info()->exec_domain
 919                            && current_thread_info()->exec_domain->signal_invmap
 920                            && sig < 32
 921                            ? current_thread_info()->exec_domain->signal_invmap[sig]
 922                            : sig),
 923                           &frame->sig);
 924
 925         err |= __put_user(regs->vector, &frame->code);
 926         err |= __put_user(&frame->sc, &frame->psc);
 927
 928         if (_NSIG_WORDS > 1)
 929                 err |= copy_to_user(frame->extramask, &set->sig[1],
 930                                     sizeof(frame->extramask));
 931
 932         setup_sigcontext(&context, regs, set->sig[0]);
 933         err |= copy_to_user (&frame->sc, &context, sizeof(context));
 934
 935         /* Set up to return from userspace.  */
 936 #ifdef CONFIG_MMU
 937         err |= __put_user(frame->retcode, &frame->pretcode);
 938         /* moveq #,d0; trap #0 */
 939         err |= __put_user(0x70004e40 + (__NR_sigreturn << 16),
 940                           (long __user *)(frame->retcode));
 941 #else
 942         err |= __put_user((void *) ret_from_user_signal, &frame->pretcode);
 943 #endif
 944
 945         if (err)
 946                 goto give_sigsegv;
 947
 948         push_cache ((unsigned long) &frame->retcode);
 949
 950         /*
 951          * Set up registers for signal handler.  All the state we are about
 952          * to destroy is successfully copied to sigframe.
 953          */
 954         wrusp ((unsigned long) frame);
 955         regs->pc = (unsigned long) ka->sa.sa_handler;
 956         adjustformat(regs);
 957
 958         /*
 959          * This is subtle; if we build more than one sigframe, all but the
 960          * first one will see frame format 0 and have fsize == 0, so we won't
 961          * screw stkadj.
 962          */
 963         if (fsize)
 964                 regs->stkadj = fsize;
 965
 966         /* Prepare to skip over the extra stuff in the exception frame.  */
 967         if (regs->stkadj) {
 968                 struct pt_regs *tregs =
 969                         (struct pt_regs *)((ulong)regs + regs->stkadj);
 970 #ifdef DEBUG
 971                 printk("Performing stackadjust=%04x\n", regs->stkadj);
 972 #endif
 973                 /* This must be copied with decreasing addresses to
 974                    handle overlaps.  */
 975                 tregs->vector = 0;
 976                 tregs->format = 0;
 977                 tregs->pc = regs->pc;
 978                 tregs->sr = regs->sr;
 979         }
 980         return 0;
 981
 982 give_sigsegv:
 983         force_sigsegv(sig, current);
 984         return err;
 985 }
 986
 987 static int setup_rt_frame (int sig, struct k_sigaction *ka, siginfo_t *info,
 988                             sigset_t *set, struct pt_regs *regs)
 989 {
 990         struct rt_sigframe __user *frame;
 991         int fsize = frame_extra_sizes(regs->format);
 992         int err = 0;
 993
 994         if (fsize < 0) {
 995 #ifdef DEBUG
 996                 printk ("setup_frame: Unknown frame format %#x\n",
 997                         regs->format);
 998 #endif
 999                 goto give_sigsegv;
1000         }
1001
1002         frame = get_sigframe(ka, regs, sizeof(*frame));
1003
1004         if (fsize)
1005                 err |= copy_to_user (&frame->uc.uc_extra, regs + 1, fsize);
1006
1007         err |= __put_user((current_thread_info()->exec_domain
1008                            && current_thread_info()->exec_domain->signal_invmap
1009                            && sig < 32
1010                            ? current_thread_info()->exec_domain->signal_invmap[sig]
1011                            : sig),
1012                           &frame->sig);
1013         err |= __put_user(&frame->info, &frame->pinfo);
1014         err |= __put_user(&frame->uc, &frame->puc);
1015         err |= copy_siginfo_to_user(&frame->info, info);
1016
1017         /* Create the ucontext.  */
1018         err |= __put_user(0, &frame->uc.uc_flags);
1019         err |= __put_user(NULL, &frame->uc.uc_link);
1020         err |= __put_user((void __user *)current->sas_ss_sp,
1021                           &frame->uc.uc_stack.ss_sp);
1022         err |= __put_user(sas_ss_flags(rdusp()),
1023                           &frame->uc.uc_stack.ss_flags);
1024         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
1025         err |= rt_setup_ucontext(&frame->uc, regs);
1026         err |= copy_to_user (&frame->uc.uc_sigmask, set, sizeof(*set));
1027
1028         /* Set up to return from userspace.  */
1029 #ifdef CONFIG_MMU
1030         err |= __put_user(frame->retcode, &frame->pretcode);
1031 #ifdef __mcoldfire__
1032         /* movel #__NR_rt_sigreturn,d0; trap #0 */
1033         err |= __put_user(0x203c0000, (long __user *)(frame->retcode + 0));
1034         err |= __put_user(0x00004e40 + (__NR_rt_sigreturn << 16),
1035                           (long __user *)(frame->retcode + 4));
1036 #else
1037         /* moveq #,d0; notb d0; trap #0 */
1038         err |= __put_user(0x70004600 + ((__NR_rt_sigreturn ^ 0xff) << 16),
1039                           (long __user *)(frame->retcode + 0));
1040         err |= __put_user(0x4e40, (short __user *)(frame->retcode + 4));
1041 #endif
1042 #else
1043         err |= __put_user((void *) ret_from_user_rt_signal, &frame->pretcode);
1044 #endif /* CONFIG_MMU */
1045
1046         if (err)
1047                 goto give_sigsegv;
1048
1049         push_cache ((unsigned long) &frame->retcode);
1050
1051         /*
1052          * Set up registers for signal handler.  All the state we are about
1053          * to destroy is successfully copied to sigframe.
1054          */
1055         wrusp ((unsigned long) frame);
1056         regs->pc = (unsigned long) ka->sa.sa_handler;
1057         adjustformat(regs);
1058
1059         /*
1060          * This is subtle; if we build more than one sigframe, all but the
1061          * first one will see frame format 0 and have fsize == 0, so we won't
1062          * screw stkadj.
1063          */
1064         if (fsize)
1065                 regs->stkadj = fsize;
1066
1067         /* Prepare to skip over the extra stuff in the exception frame.  */
1068         if (regs->stkadj) {
1069                 struct pt_regs *tregs =
1070                         (struct pt_regs *)((ulong)regs + regs->stkadj);
1071 #ifdef DEBUG
1072                 printk("Performing stackadjust=%04x\n", regs->stkadj);
1073 #endif
1074                 /* This must be copied with decreasing addresses to
1075                    handle overlaps.  */
1076                 tregs->vector = 0;
1077                 tregs->format = 0;
1078                 tregs->pc = regs->pc;
1079                 tregs->sr = regs->sr;
1080         }
1081         return 0;
1082
1083 give_sigsegv:
1084         force_sigsegv(sig, current);
1085         return err;
1086 }
1087
1088 static inline void
1089 handle_restart(struct pt_regs *regs, struct k_sigaction *ka, int has_handler)
1090 {
1091         switch (regs->d0) {
1092         case -ERESTARTNOHAND:
1093                 if (!has_handler)
1094                         goto do_restart;
1095                 regs->d0 = -EINTR;
1096                 break;
1097
1098         case -ERESTART_RESTARTBLOCK:
1099                 if (!has_handler) {
1100                         regs->d0 = __NR_restart_syscall;
1101                         regs->pc -= 2;
1102                         break;
1103                 }
1104                 regs->d0 = -EINTR;
1105                 break;
1106
1107         case -ERESTARTSYS:
1108                 if (has_handler && !(ka->sa.sa_flags & SA_RESTART)) {
1109                         regs->d0 = -EINTR;
1110                         break;
1111                 }
1112         /* fallthrough */
1113         case -ERESTARTNOINTR:
1114         do_restart:
1115                 regs->d0 = regs->orig_d0;
1116                 regs->pc -= 2;
1117                 break;
1118         }
1119 }
1120
1121 /*
1122  * OK, we're invoking a handler
1123  */
1124 static void
1125 handle_signal(int sig, struct k_sigaction *ka, siginfo_t *info,
1126               sigset_t *oldset, struct pt_regs *regs)
1127 {
1128         int err;
1129         /* are we from a system call? */
1130         if (regs->orig_d0 >= 0)
1131                 /* If so, check system call restarting.. */
1132                 handle_restart(regs, ka, 1);
1133
1134         /* set up the stack frame */
1135         if (ka->sa.sa_flags & SA_SIGINFO)
1136                 err = setup_rt_frame(sig, ka, info, oldset, regs);
1137         else
1138                 err = setup_frame(sig, ka, oldset, regs);
1139
1140         if (err)
1141                 return;
1142
1143         block_sigmask(ka, sig);
1144
1145         if (test_thread_flag(TIF_DELAYED_TRACE)) {
1146                 regs->sr &= ~0x8000;
1147                 send_sig(SIGTRAP, current, 1);
1148         }
1149
1150         clear_thread_flag(TIF_RESTORE_SIGMASK);
1151 }
1152
1153 /*
1154  * Note that 'init' is a special process: it doesn't get signals it doesn't
1155  * want to handle. Thus you cannot kill init even with a SIGKILL even by
1156  * mistake.
1157  */
1158 static void do_signal(struct pt_regs *regs)
1159 {
1160         siginfo_t info;
1161         struct k_sigaction ka;
1162         int signr;
1163         sigset_t *oldset;
1164
1165         current->thread.esp0 = (unsigned long) regs;
1166
1167         if (test_thread_flag(TIF_RESTORE_SIGMASK))
1168                 oldset = &current->saved_sigmask;
1169         else
1170                 oldset = &current->blocked;
1171
1172         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1173         if (signr > 0) {
1174                 /* Whee!  Actually deliver the signal.  */
1175                 handle_signal(signr, &ka, &info, oldset, regs);
1176                 return;
1177         }
1178
1179         /* Did we come from a system call? */
1180         if (regs->orig_d0 >= 0)
1181                 /* Restart the system call - no handlers present */
1182                 handle_restart(regs, NULL, 0);
1183
1184         /* If there's no signal to deliver, we just restore the saved mask.  */
1185         if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
1186                 clear_thread_flag(TIF_RESTORE_SIGMASK);
1187                 sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
1188         }
1189 }
1190
1191 void do_notify_resume(struct pt_regs *regs)
1192 {
1193         if (test_thread_flag(TIF_SIGPENDING))
1194                 do_signal(regs);
1195
1196         if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME)) {
1197                 tracehook_notify_resume(regs);
1198                 if (current->replacement_session_keyring)
1199                         key_replace_session_keyring();
1200         }
1201 }