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