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