arch/powerpc/kernel/signal_32.c

   1 /*
   2  * Signal handling for 32bit PPC and 32bit tasks on 64bit PPC
   3  *
   4  *  PowerPC version
   5  *    Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
   6  * Copyright (C) 2001 IBM
   7  * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
   8  * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
   9  *
  10  *  Derived from "arch/i386/kernel/signal.c"
  11  *    Copyright (C) 1991, 1992 Linus Torvalds
  12  *    1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  13  *
  14  *  This program is free software; you can redistribute it and/or
  15  *  modify it under the terms of the GNU General Public License
  16  *  as published by the Free Software Foundation; either version
  17  *  2 of the License, or (at your option) any later version.
  18  */
  19
  20 #include <linux/sched.h>
  21 #include <linux/mm.h>
  22 #include <linux/smp.h>
  23 #include <linux/kernel.h>
  24 #include <linux/signal.h>
  25 #include <linux/errno.h>
  26 #include <linux/elf.h>
  27 #include <linux/ptrace.h>
  28 #ifdef CONFIG_PPC64
  29 #include <linux/syscalls.h>
  30 #include <linux/compat.h>
  31 #else
  32 #include <linux/wait.h>
  33 #include <linux/unistd.h>
  34 #include <linux/stddef.h>
  35 #include <linux/tty.h>
  36 #include <linux/binfmts.h>
  37 #include <linux/freezer.h>
  38 #endif
  39
  40 #include <asm/uaccess.h>
  41 #include <asm/cacheflush.h>
  42 #include <asm/syscalls.h>
  43 #include <asm/sigcontext.h>
  44 #include <asm/vdso.h>
  45 #ifdef CONFIG_PPC64
  46 #include "ppc32.h"
  47 #include <asm/unistd.h>
  48 #else
  49 #include <asm/ucontext.h>
  50 #include <asm/pgtable.h>
  51 #endif
  52
  53 #include "signal.h"
  54
  55 #undef DEBUG_SIG
  56
  57 #ifdef CONFIG_PPC64
  58 #define sys_sigsuspend  compat_sys_sigsuspend
  59 #define sys_rt_sigsuspend       compat_sys_rt_sigsuspend
  60 #define sys_rt_sigreturn        compat_sys_rt_sigreturn
  61 #define sys_sigaction   compat_sys_sigaction
  62 #define sys_swapcontext compat_sys_swapcontext
  63 #define sys_sigreturn   compat_sys_sigreturn
  64
  65 #define old_sigaction   old_sigaction32
  66 #define sigcontext      sigcontext32
  67 #define mcontext        mcontext32
  68 #define ucontext        ucontext32
  69
  70 /*
  71  * Returning 0 means we return to userspace via
  72  * ret_from_except and thus restore all user
  73  * registers from *regs.  This is what we need
  74  * to do when a signal has been delivered.
  75  */
  76
  77 #define GP_REGS_SIZE    min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
  78 #undef __SIGNAL_FRAMESIZE
  79 #define __SIGNAL_FRAMESIZE      __SIGNAL_FRAMESIZE32
  80 #undef ELF_NVRREG
  81 #define ELF_NVRREG      ELF_NVRREG32
  82
  83 /*
  84  * Functions for flipping sigsets (thanks to brain dead generic
  85  * implementation that makes things simple for little endian only)
  86  */
  87 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
  88 {
  89         compat_sigset_t cset;
  90
  91         switch (_NSIG_WORDS) {
  92         case 4: cset.sig[5] = set->sig[3] & 0xffffffffull;
  93                 cset.sig[7] = set->sig[3] >> 32;
  94         case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
  95                 cset.sig[5] = set->sig[2] >> 32;
  96         case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
  97                 cset.sig[3] = set->sig[1] >> 32;
  98         case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
  99                 cset.sig[1] = set->sig[0] >> 32;
 100         }
 101         return copy_to_user(uset, &cset, sizeof(*uset));
 102 }
 103
 104 static inline int get_sigset_t(sigset_t *set,
 105                                const compat_sigset_t __user *uset)
 106 {
 107         compat_sigset_t s32;
 108
 109         if (copy_from_user(&s32, uset, sizeof(*uset)))
 110                 return -EFAULT;
 111
 112         /*
 113          * Swap the 2 words of the 64-bit sigset_t (they are stored
 114          * in the "wrong" endian in 32-bit user storage).
 115          */
 116         switch (_NSIG_WORDS) {
 117         case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
 118         case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
 119         case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
 120         case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
 121         }
 122         return 0;
 123 }
 124
 125 static inline int get_old_sigaction(struct k_sigaction *new_ka,
 126                 struct old_sigaction __user *act)
 127 {
 128         compat_old_sigset_t mask;
 129         compat_uptr_t handler, restorer;
 130
 131         if (get_user(handler, &act->sa_handler) ||
 132             __get_user(restorer, &act->sa_restorer) ||
 133             __get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
 134             __get_user(mask, &act->sa_mask))
 135                 return -EFAULT;
 136         new_ka->sa.sa_handler = compat_ptr(handler);
 137         new_ka->sa.sa_restorer = compat_ptr(restorer);
 138         siginitset(&new_ka->sa.sa_mask, mask);
 139         return 0;
 140 }
 141
 142 #define to_user_ptr(p)          ptr_to_compat(p)
 143 #define from_user_ptr(p)        compat_ptr(p)
 144
 145 static inline int save_general_regs(struct pt_regs *regs,
 146                 struct mcontext __user *frame)
 147 {
 148         elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
 149         int i;
 150
 151         WARN_ON(!FULL_REGS(regs));
 152
 153         for (i = 0; i <= PT_RESULT; i ++) {
 154                 if (i == 14 && !FULL_REGS(regs))
 155                         i = 32;
 156                 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
 157                         return -EFAULT;
 158         }
 159         return 0;
 160 }
 161
 162 static inline int restore_general_regs(struct pt_regs *regs,
 163                 struct mcontext __user *sr)
 164 {
 165         elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
 166         int i;
 167
 168         for (i = 0; i <= PT_RESULT; i++) {
 169                 if ((i == PT_MSR) || (i == PT_SOFTE))
 170                         continue;
 171                 if (__get_user(gregs[i], &sr->mc_gregs[i]))
 172                         return -EFAULT;
 173         }
 174         return 0;
 175 }
 176
 177 #else /* CONFIG_PPC64 */
 178
 179 #define GP_REGS_SIZE    min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
 180
 181 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
 182 {
 183         return copy_to_user(uset, set, sizeof(*uset));
 184 }
 185
 186 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
 187 {
 188         return copy_from_user(set, uset, sizeof(*uset));
 189 }
 190
 191 static inline int get_old_sigaction(struct k_sigaction *new_ka,
 192                 struct old_sigaction __user *act)
 193 {
 194         old_sigset_t mask;
 195
 196         if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 197                         __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
 198                         __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
 199                 return -EFAULT;
 200         __get_user(new_ka->sa.sa_flags, &act->sa_flags);
 201         __get_user(mask, &act->sa_mask);
 202         siginitset(&new_ka->sa.sa_mask, mask);
 203         return 0;
 204 }
 205
 206 #define to_user_ptr(p)          ((unsigned long)(p))
 207 #define from_user_ptr(p)        ((void __user *)(p))
 208
 209 static inline int save_general_regs(struct pt_regs *regs,
 210                 struct mcontext __user *frame)
 211 {
 212         WARN_ON(!FULL_REGS(regs));
 213         return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
 214 }
 215
 216 static inline int restore_general_regs(struct pt_regs *regs,
 217                 struct mcontext __user *sr)
 218 {
 219         /* copy up to but not including MSR */
 220         if (__copy_from_user(regs, &sr->mc_gregs,
 221                                 PT_MSR * sizeof(elf_greg_t)))
 222                 return -EFAULT;
 223         /* copy from orig_r3 (the word after the MSR) up to the end */
 224         if (__copy_from_user(&regs->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
 225                                 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
 226                 return -EFAULT;
 227         return 0;
 228 }
 229
 230 #endif /* CONFIG_PPC64 */
 231
 232 /*
 233  * Atomically swap in the new signal mask, and wait for a signal.
 234  */
 235 long sys_sigsuspend(old_sigset_t mask)
 236 {
 237         mask &= _BLOCKABLE;
 238         spin_lock_irq(&current->sighand->siglock);
 239         current->saved_sigmask = current->blocked;
 240         siginitset(&current->blocked, mask);
 241         recalc_sigpending();
 242         spin_unlock_irq(&current->sighand->siglock);
 243
 244         current->state = TASK_INTERRUPTIBLE;
 245         schedule();
 246         set_thread_flag(TIF_RESTORE_SIGMASK);
 247         return -ERESTARTNOHAND;
 248 }
 249
 250 long sys_sigaction(int sig, struct old_sigaction __user *act,
 251                 struct old_sigaction __user *oact)
 252 {
 253         struct k_sigaction new_ka, old_ka;
 254         int ret;
 255
 256 #ifdef CONFIG_PPC64
 257         if (sig < 0)
 258                 sig = -sig;
 259 #endif
 260
 261         if (act) {
 262                 if (get_old_sigaction(&new_ka, act))
 263                         return -EFAULT;
 264         }
 265
 266         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 267         if (!ret && oact) {
 268                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 269                     __put_user(to_user_ptr(old_ka.sa.sa_handler),
 270                             &oact->sa_handler) ||
 271                     __put_user(to_user_ptr(old_ka.sa.sa_restorer),
 272                             &oact->sa_restorer) ||
 273                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
 274                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
 275                         return -EFAULT;
 276         }
 277
 278         return ret;
 279 }
 280
 281 /*
 282  * When we have signals to deliver, we set up on the
 283  * user stack, going down from the original stack pointer:
 284  *      an ABI gap of 56 words
 285  *      an mcontext struct
 286  *      a sigcontext struct
 287  *      a gap of __SIGNAL_FRAMESIZE bytes
 288  *
 289  * Each of these things must be a multiple of 16 bytes in size. The following
 290  * structure represent all of this except the __SIGNAL_FRAMESIZE gap
 291  *
 292  */
 293 struct sigframe {
 294         struct sigcontext sctx;         /* the sigcontext */
 295         struct mcontext mctx;           /* all the register values */
 296         /*
 297          * Programs using the rs6000/xcoff abi can save up to 19 gp
 298          * regs and 18 fp regs below sp before decrementing it.
 299          */
 300         int                     abigap[56];
 301 };
 302
 303 /* We use the mc_pad field for the signal return trampoline. */
 304 #define tramp   mc_pad
 305
 306 /*
 307  *  When we have rt signals to deliver, we set up on the
 308  *  user stack, going down from the original stack pointer:
 309  *      one rt_sigframe struct (siginfo + ucontext + ABI gap)
 310  *      a gap of __SIGNAL_FRAMESIZE+16 bytes
 311  *  (the +16 is to get the siginfo and ucontext in the same
 312  *  positions as in older kernels).
 313  *
 314  *  Each of these things must be a multiple of 16 bytes in size.
 315  *
 316  */
 317 struct rt_sigframe {
 318 #ifdef CONFIG_PPC64
 319         compat_siginfo_t info;
 320 #else
 321         struct siginfo info;
 322 #endif
 323         struct ucontext uc;
 324         /*
 325          * Programs using the rs6000/xcoff abi can save up to 19 gp
 326          * regs and 18 fp regs below sp before decrementing it.
 327          */
 328         int                     abigap[56];
 329 };
 330
 331 /*
 332  * Save the current user registers on the user stack.
 333  * We only save the altivec/spe registers if the process has used
 334  * altivec/spe instructions at some point.
 335  */
 336 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
 337                 int sigret)
 338 {
 339         /* Make sure floating point registers are stored in regs */
 340         flush_fp_to_thread(current);
 341
 342         /* save general and floating-point registers */
 343         if (save_general_regs(regs, frame) ||
 344             __copy_to_user(&frame->mc_fregs, current->thread.fpr,
 345                     ELF_NFPREG * sizeof(double)))
 346                 return 1;
 347
 348 #ifdef CONFIG_ALTIVEC
 349         /* save altivec registers */
 350         if (current->thread.used_vr) {
 351                 flush_altivec_to_thread(current);
 352                 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
 353                                    ELF_NVRREG * sizeof(vector128)))
 354                         return 1;
 355                 /* set MSR_VEC in the saved MSR value to indicate that
 356                    frame->mc_vregs contains valid data */
 357                 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
 358                         return 1;
 359         }
 360         /* else assert((regs->msr & MSR_VEC) == 0) */
 361
 362         /* We always copy to/from vrsave, it's 0 if we don't have or don't
 363          * use altivec. Since VSCR only contains 32 bits saved in the least
 364          * significant bits of a vector, we "cheat" and stuff VRSAVE in the
 365          * most significant bits of that same vector. --BenH
 366          */
 367         if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
 368                 return 1;
 369 #endif /* CONFIG_ALTIVEC */
 370
 371 #ifdef CONFIG_SPE
 372         /* save spe registers */
 373         if (current->thread.used_spe) {
 374                 flush_spe_to_thread(current);
 375                 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
 376                                    ELF_NEVRREG * sizeof(u32)))
 377                         return 1;
 378                 /* set MSR_SPE in the saved MSR value to indicate that
 379                    frame->mc_vregs contains valid data */
 380                 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
 381                         return 1;
 382         }
 383         /* else assert((regs->msr & MSR_SPE) == 0) */
 384
 385         /* We always copy to/from spefscr */
 386         if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
 387                 return 1;
 388 #endif /* CONFIG_SPE */
 389
 390         if (sigret) {
 391                 /* Set up the sigreturn trampoline: li r0,sigret; sc */
 392                 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
 393                     || __put_user(0x44000002UL, &frame->tramp[1]))
 394                         return 1;
 395                 flush_icache_range((unsigned long) &frame->tramp[0],
 396                                    (unsigned long) &frame->tramp[2]);
 397         }
 398
 399         return 0;
 400 }
 401
 402 /*
 403  * Restore the current user register values from the user stack,
 404  * (except for MSR).
 405  */
 406 static long restore_user_regs(struct pt_regs *regs,
 407                               struct mcontext __user *sr, int sig)
 408 {
 409         long err;
 410         unsigned int save_r2 = 0;
 411         unsigned long msr;
 412
 413         /*
 414          * restore general registers but not including MSR or SOFTE. Also
 415          * take care of keeping r2 (TLS) intact if not a signal
 416          */
 417         if (!sig)
 418                 save_r2 = (unsigned int)regs->gpr[2];
 419         err = restore_general_regs(regs, sr);
 420         err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
 421         if (!sig)
 422                 regs->gpr[2] = (unsigned long) save_r2;
 423         if (err)
 424                 return 1;
 425
 426         /* if doing signal return, restore the previous little-endian mode */
 427         if (sig)
 428                 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
 429
 430         /*
 431          * Do this before updating the thread state in
 432          * current->thread.fpr/vr/evr.  That way, if we get preempted
 433          * and another task grabs the FPU/Altivec/SPE, it won't be
 434          * tempted to save the current CPU state into the thread_struct
 435          * and corrupt what we are writing there.
 436          */
 437         discard_lazy_cpu_state();
 438
 439         /* force the process to reload the FP registers from
 440            current->thread when it next does FP instructions */
 441         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
 442         if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
 443                              sizeof(sr->mc_fregs)))
 444                 return 1;
 445
 446 #ifdef CONFIG_ALTIVEC
 447         /* force the process to reload the altivec registers from
 448            current->thread when it next does altivec instructions */
 449         regs->msr &= ~MSR_VEC;
 450         if (msr & MSR_VEC) {
 451                 /* restore altivec registers from the stack */
 452                 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
 453                                      sizeof(sr->mc_vregs)))
 454                         return 1;
 455         } else if (current->thread.used_vr)
 456                 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
 457
 458         /* Always get VRSAVE back */
 459         if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
 460                 return 1;
 461 #endif /* CONFIG_ALTIVEC */
 462
 463 #ifdef CONFIG_SPE
 464         /* force the process to reload the spe registers from
 465            current->thread when it next does spe instructions */
 466         regs->msr &= ~MSR_SPE;
 467         if (msr & MSR_SPE) {
 468                 /* restore spe registers from the stack */
 469                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
 470                                      ELF_NEVRREG * sizeof(u32)))
 471                         return 1;
 472         } else if (current->thread.used_spe)
 473                 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
 474
 475         /* Always get SPEFSCR back */
 476         if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
 477                 return 1;
 478 #endif /* CONFIG_SPE */
 479
 480         return 0;
 481 }
 482
 483 #ifdef CONFIG_PPC64
 484 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
 485                 struct sigaction32 __user *oact, size_t sigsetsize)
 486 {
 487         struct k_sigaction new_ka, old_ka;
 488         int ret;
 489
 490         /* XXX: Don't preclude handling different sized sigset_t's.  */
 491         if (sigsetsize != sizeof(compat_sigset_t))
 492                 return -EINVAL;
 493
 494         if (act) {
 495                 compat_uptr_t handler;
 496
 497                 ret = get_user(handler, &act->sa_handler);
 498                 new_ka.sa.sa_handler = compat_ptr(handler);
 499                 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
 500                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 501                 if (ret)
 502                         return -EFAULT;
 503         }
 504
 505         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 506         if (!ret && oact) {
 507                 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
 508                 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
 509                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 510         }
 511         return ret;
 512 }
 513
 514 /*
 515  * Note: it is necessary to treat how as an unsigned int, with the
 516  * corresponding cast to a signed int to insure that the proper
 517  * conversion (sign extension) between the register representation
 518  * of a signed int (msr in 32-bit mode) and the register representation
 519  * of a signed int (msr in 64-bit mode) is performed.
 520  */
 521 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
 522                 compat_sigset_t __user *oset, size_t sigsetsize)
 523 {
 524         sigset_t s;
 525         sigset_t __user *up;
 526         int ret;
 527         mm_segment_t old_fs = get_fs();
 528
 529         if (set) {
 530                 if (get_sigset_t(&s, set))
 531                         return -EFAULT;
 532         }
 533
 534         set_fs(KERNEL_DS);
 535         /* This is valid because of the set_fs() */
 536         up = (sigset_t __user *) &s;
 537         ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
 538                                  sigsetsize);
 539         set_fs(old_fs);
 540         if (ret)
 541                 return ret;
 542         if (oset) {
 543                 if (put_sigset_t(oset, &s))
 544                         return -EFAULT;
 545         }
 546         return 0;
 547 }
 548
 549 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
 550 {
 551         sigset_t s;
 552         int ret;
 553         mm_segment_t old_fs = get_fs();
 554
 555         set_fs(KERNEL_DS);
 556         /* The __user pointer cast is valid because of the set_fs() */
 557         ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
 558         set_fs(old_fs);
 559         if (!ret) {
 560                 if (put_sigset_t(set, &s))
 561                         return -EFAULT;
 562         }
 563         return ret;
 564 }
 565
 566
 567 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
 568 {
 569         int err;
 570
 571         if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
 572                 return -EFAULT;
 573
 574         /* If you change siginfo_t structure, please be sure
 575          * this code is fixed accordingly.
 576          * It should never copy any pad contained in the structure
 577          * to avoid security leaks, but must copy the generic
 578          * 3 ints plus the relevant union member.
 579          * This routine must convert siginfo from 64bit to 32bit as well
 580          * at the same time.
 581          */
 582         err = __put_user(s->si_signo, &d->si_signo);
 583         err |= __put_user(s->si_errno, &d->si_errno);
 584         err |= __put_user((short)s->si_code, &d->si_code);
 585         if (s->si_code < 0)
 586                 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
 587                                       SI_PAD_SIZE32);
 588         else switch(s->si_code >> 16) {
 589         case __SI_CHLD >> 16:
 590                 err |= __put_user(s->si_pid, &d->si_pid);
 591                 err |= __put_user(s->si_uid, &d->si_uid);
 592                 err |= __put_user(s->si_utime, &d->si_utime);
 593                 err |= __put_user(s->si_stime, &d->si_stime);
 594                 err |= __put_user(s->si_status, &d->si_status);
 595                 break;
 596         case __SI_FAULT >> 16:
 597                 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
 598                                   &d->si_addr);
 599                 break;
 600         case __SI_POLL >> 16:
 601                 err |= __put_user(s->si_band, &d->si_band);
 602                 err |= __put_user(s->si_fd, &d->si_fd);
 603                 break;
 604         case __SI_TIMER >> 16:
 605                 err |= __put_user(s->si_tid, &d->si_tid);
 606                 err |= __put_user(s->si_overrun, &d->si_overrun);
 607                 err |= __put_user(s->si_int, &d->si_int);
 608                 break;
 609         case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 610         case __SI_MESGQ >> 16:
 611                 err |= __put_user(s->si_int, &d->si_int);
 612                 /* fallthrough */
 613         case __SI_KILL >> 16:
 614         default:
 615                 err |= __put_user(s->si_pid, &d->si_pid);
 616                 err |= __put_user(s->si_uid, &d->si_uid);
 617                 break;
 618         }
 619         return err;
 620 }
 621
 622 #define copy_siginfo_to_user    copy_siginfo_to_user32
 623
 624 /*
 625  * Note: it is necessary to treat pid and sig as unsigned ints, with the
 626  * corresponding cast to a signed int to insure that the proper conversion
 627  * (sign extension) between the register representation of a signed int
 628  * (msr in 32-bit mode) and the register representation of a signed int
 629  * (msr in 64-bit mode) is performed.
 630  */
 631 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
 632 {
 633         siginfo_t info;
 634         int ret;
 635         mm_segment_t old_fs = get_fs();
 636
 637         if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
 638             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
 639                 return -EFAULT;
 640         set_fs (KERNEL_DS);
 641         /* The __user pointer cast is valid becasuse of the set_fs() */
 642         ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
 643         set_fs (old_fs);
 644         return ret;
 645 }
 646 /*
 647  *  Start Alternate signal stack support
 648  *
 649  *  System Calls
 650  *       sigaltatck               compat_sys_sigaltstack
 651  */
 652
 653 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
 654                       int r6, int r7, int r8, struct pt_regs *regs)
 655 {
 656         stack_32_t __user * newstack = compat_ptr(__new);
 657         stack_32_t __user * oldstack = compat_ptr(__old);
 658         stack_t uss, uoss;
 659         int ret;
 660         mm_segment_t old_fs;
 661         unsigned long sp;
 662         compat_uptr_t ss_sp;
 663
 664         /*
 665          * set sp to the user stack on entry to the system call
 666          * the system call router sets R9 to the saved registers
 667          */
 668         sp = regs->gpr[1];
 669
 670         /* Put new stack info in local 64 bit stack struct */
 671         if (newstack) {
 672                 if (get_user(ss_sp, &newstack->ss_sp) ||
 673                     __get_user(uss.ss_flags, &newstack->ss_flags) ||
 674                     __get_user(uss.ss_size, &newstack->ss_size))
 675                         return -EFAULT;
 676                 uss.ss_sp = compat_ptr(ss_sp);
 677         }
 678
 679         old_fs = get_fs();
 680         set_fs(KERNEL_DS);
 681         /* The __user pointer casts are valid because of the set_fs() */
 682         ret = do_sigaltstack(
 683                 newstack ? (stack_t __user *) &uss : NULL,
 684                 oldstack ? (stack_t __user *) &uoss : NULL,
 685                 sp);
 686         set_fs(old_fs);
 687         /* Copy the stack information to the user output buffer */
 688         if (!ret && oldstack  &&
 689                 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
 690                  __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
 691                  __put_user(uoss.ss_size, &oldstack->ss_size)))
 692                 return -EFAULT;
 693         return ret;
 694 }
 695 #endif /* CONFIG_PPC64 */
 696
 697 /*
 698  * Set up a signal frame for a "real-time" signal handler
 699  * (one which gets siginfo).
 700  */
 701 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
 702                 siginfo_t *info, sigset_t *oldset,
 703                 struct pt_regs *regs)
 704 {
 705         struct rt_sigframe __user *rt_sf;
 706         struct mcontext __user *frame;
 707         void __user *addr;
 708         unsigned long newsp = 0;
 709
 710         /* Set up Signal Frame */
 711         /* Put a Real Time Context onto stack */
 712         rt_sf = get_sigframe(ka, regs, sizeof(*rt_sf));
 713         addr = rt_sf;
 714         if (unlikely(rt_sf == NULL))
 715                 goto badframe;
 716
 717         /* Put the siginfo & fill in most of the ucontext */
 718         if (copy_siginfo_to_user(&rt_sf->info, info)
 719             || __put_user(0, &rt_sf->uc.uc_flags)
 720             || __put_user(0, &rt_sf->uc.uc_link)
 721             || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
 722             || __put_user(sas_ss_flags(regs->gpr[1]),
 723                           &rt_sf->uc.uc_stack.ss_flags)
 724             || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
 725             || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
 726                     &rt_sf->uc.uc_regs)
 727             || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
 728                 goto badframe;
 729
 730         /* Save user registers on the stack */
 731         frame = &rt_sf->uc.uc_mcontext;
 732         addr = frame;
 733         if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
 734                 if (save_user_regs(regs, frame, 0))
 735                         goto badframe;
 736                 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp;
 737         } else {
 738                 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
 739                         goto badframe;
 740                 regs->link = (unsigned long) frame->tramp;
 741         }
 742
 743         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
 744
 745         /* create a stack frame for the caller of the handler */
 746         newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
 747         addr = (void __user *)regs->gpr[1];
 748         if (put_user(regs->gpr[1], (u32 __user *)newsp))
 749                 goto badframe;
 750
 751         /* Fill registers for signal handler */
 752         regs->gpr[1] = newsp;
 753         regs->gpr[3] = sig;
 754         regs->gpr[4] = (unsigned long) &rt_sf->info;
 755         regs->gpr[5] = (unsigned long) &rt_sf->uc;
 756         regs->gpr[6] = (unsigned long) rt_sf;
 757         regs->nip = (unsigned long) ka->sa.sa_handler;
 758         /* enter the signal handler in big-endian mode */
 759         regs->msr &= ~MSR_LE;
 760         regs->trap = 0;
 761         return 1;
 762
 763 badframe:
 764 #ifdef DEBUG_SIG
 765         printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
 766                regs, frame, newsp);
 767 #endif
 768         if (show_unhandled_signals && printk_ratelimit())
 769                 printk(KERN_INFO "%s[%d]: bad frame in handle_rt_signal32: "
 770                         "%p nip %08lx lr %08lx\n",
 771                         current->comm, current->pid,
 772                         addr, regs->nip, regs->link);
 773
 774         force_sigsegv(sig, current);
 775         return 0;
 776 }
 777
 778 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
 779 {
 780         sigset_t set;
 781         struct mcontext __user *mcp;
 782
 783         if (get_sigset_t(&set, &ucp->uc_sigmask))
 784                 return -EFAULT;
 785 #ifdef CONFIG_PPC64
 786         {
 787                 u32 cmcp;
 788
 789                 if (__get_user(cmcp, &ucp->uc_regs))
 790                         return -EFAULT;
 791                 mcp = (struct mcontext __user *)(u64)cmcp;
 792                 /* no need to check access_ok(mcp), since mcp < 4GB */
 793         }
 794 #else
 795         if (__get_user(mcp, &ucp->uc_regs))
 796                 return -EFAULT;
 797         if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
 798                 return -EFAULT;
 799 #endif
 800         restore_sigmask(&set);
 801         if (restore_user_regs(regs, mcp, sig))
 802                 return -EFAULT;
 803
 804         return 0;
 805 }
 806
 807 long sys_swapcontext(struct ucontext __user *old_ctx,
 808                      struct ucontext __user *new_ctx,
 809                      int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
 810 {
 811         unsigned char tmp;
 812
 813         /* Context size is for future use. Right now, we only make sure
 814          * we are passed something we understand
 815          */
 816         if (ctx_size < sizeof(struct ucontext))
 817                 return -EINVAL;
 818
 819         if (old_ctx != NULL) {
 820                 struct mcontext __user *mctx;
 821
 822                 /*
 823                  * old_ctx might not be 16-byte aligned, in which
 824                  * case old_ctx->uc_mcontext won't be either.
 825                  * Because we have the old_ctx->uc_pad2 field
 826                  * before old_ctx->uc_mcontext, we need to round down
 827                  * from &old_ctx->uc_mcontext to a 16-byte boundary.
 828                  */
 829                 mctx = (struct mcontext __user *)
 830                         ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
 831                 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
 832                     || save_user_regs(regs, mctx, 0)
 833                     || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
 834                     || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
 835                         return -EFAULT;
 836         }
 837         if (new_ctx == NULL)
 838                 return 0;
 839         if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
 840             || __get_user(tmp, (u8 __user *) new_ctx)
 841             || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
 842                 return -EFAULT;
 843
 844         /*
 845          * If we get a fault copying the context into the kernel's
 846          * image of the user's registers, we can't just return -EFAULT
 847          * because the user's registers will be corrupted.  For instance
 848          * the NIP value may have been updated but not some of the
 849          * other registers.  Given that we have done the access_ok
 850          * and successfully read the first and last bytes of the region
 851          * above, this should only happen in an out-of-memory situation
 852          * or if another thread unmaps the region containing the context.
 853          * We kill the task with a SIGSEGV in this situation.
 854          */
 855         if (do_setcontext(new_ctx, regs, 0))
 856                 do_exit(SIGSEGV);
 857
 858         set_thread_flag(TIF_RESTOREALL);
 859         return 0;
 860 }
 861
 862 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
 863                      struct pt_regs *regs)
 864 {
 865         struct rt_sigframe __user *rt_sf;
 866
 867         /* Always make any pending restarted system calls return -EINTR */
 868         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 869
 870         rt_sf = (struct rt_sigframe __user *)
 871                 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
 872         if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
 873                 goto bad;
 874         if (do_setcontext(&rt_sf->uc, regs, 1))
 875                 goto bad;
 876
 877         /*
 878          * It's not clear whether or why it is desirable to save the
 879          * sigaltstack setting on signal delivery and restore it on
 880          * signal return.  But other architectures do this and we have
 881          * always done it up until now so it is probably better not to
 882          * change it.  -- paulus
 883          */
 884 #ifdef CONFIG_PPC64
 885         /*
 886          * We use the compat_sys_ version that does the 32/64 bits conversion
 887          * and takes userland pointer directly. What about error checking ?
 888          * nobody does any...
 889          */
 890         compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
 891 #else
 892         do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
 893 #endif
 894         set_thread_flag(TIF_RESTOREALL);
 895         return 0;
 896
 897  bad:
 898         if (show_unhandled_signals && printk_ratelimit())
 899                 printk(KERN_INFO "%s[%d]: bad frame in sys_rt_sigreturn: "
 900                         "%p nip %08lx lr %08lx\n",
 901                         current->comm, current->pid,
 902                         rt_sf, regs->nip, regs->link);
 903
 904         force_sig(SIGSEGV, current);
 905         return 0;
 906 }
 907
 908 #ifdef CONFIG_PPC32
 909 int sys_debug_setcontext(struct ucontext __user *ctx,
 910                          int ndbg, struct sig_dbg_op __user *dbg,
 911                          int r6, int r7, int r8,
 912                          struct pt_regs *regs)
 913 {
 914         struct sig_dbg_op op;
 915         int i;
 916         unsigned char tmp;
 917         unsigned long new_msr = regs->msr;
 918 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 919         unsigned long new_dbcr0 = current->thread.dbcr0;
 920 #endif
 921
 922         for (i=0; i<ndbg; i++) {
 923                 if (copy_from_user(&op, dbg + i, sizeof(op)))
 924                         return -EFAULT;
 925                 switch (op.dbg_type) {
 926                 case SIG_DBG_SINGLE_STEPPING:
 927 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 928                         if (op.dbg_value) {
 929                                 new_msr |= MSR_DE;
 930                                 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
 931                         } else {
 932                                 new_msr &= ~MSR_DE;
 933                                 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
 934                         }
 935 #else
 936                         if (op.dbg_value)
 937                                 new_msr |= MSR_SE;
 938                         else
 939                                 new_msr &= ~MSR_SE;
 940 #endif
 941                         break;
 942                 case SIG_DBG_BRANCH_TRACING:
 943 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 944                         return -EINVAL;
 945 #else
 946                         if (op.dbg_value)
 947                                 new_msr |= MSR_BE;
 948                         else
 949                                 new_msr &= ~MSR_BE;
 950 #endif
 951                         break;
 952
 953                 default:
 954                         return -EINVAL;
 955                 }
 956         }
 957
 958         /* We wait until here to actually install the values in the
 959            registers so if we fail in the above loop, it will not
 960            affect the contents of these registers.  After this point,
 961            failure is a problem, anyway, and it's very unlikely unless
 962            the user is really doing something wrong. */
 963         regs->msr = new_msr;
 964 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 965         current->thread.dbcr0 = new_dbcr0;
 966 #endif
 967
 968         if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
 969             || __get_user(tmp, (u8 __user *) ctx)
 970             || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
 971                 return -EFAULT;
 972
 973         /*
 974          * If we get a fault copying the context into the kernel's
 975          * image of the user's registers, we can't just return -EFAULT
 976          * because the user's registers will be corrupted.  For instance
 977          * the NIP value may have been updated but not some of the
 978          * other registers.  Given that we have done the access_ok
 979          * and successfully read the first and last bytes of the region
 980          * above, this should only happen in an out-of-memory situation
 981          * or if another thread unmaps the region containing the context.
 982          * We kill the task with a SIGSEGV in this situation.
 983          */
 984         if (do_setcontext(ctx, regs, 1)) {
 985                 if (show_unhandled_signals && printk_ratelimit())
 986                         printk(KERN_INFO "%s[%d]: bad frame in "
 987                                 "sys_debug_setcontext: %p nip %08lx "
 988                                 "lr %08lx\n",
 989                                 current->comm, current->pid,
 990                                 ctx, regs->nip, regs->link);
 991
 992                 force_sig(SIGSEGV, current);
 993                 goto out;
 994         }
 995
 996         /*
 997          * It's not clear whether or why it is desirable to save the
 998          * sigaltstack setting on signal delivery and restore it on
 999          * signal return.  But other architectures do this and we have
1000          * always done it up until now so it is probably better not to
1001          * change it.  -- paulus
1002          */
1003         do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1004
1005         set_thread_flag(TIF_RESTOREALL);
1006  out:
1007         return 0;
1008 }
1009 #endif
1010
1011 /*
1012  * OK, we're invoking a handler
1013  */
1014 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1015                     siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1016 {
1017         struct sigcontext __user *sc;
1018         struct sigframe __user *frame;
1019         unsigned long newsp = 0;
1020
1021         /* Set up Signal Frame */
1022         frame = get_sigframe(ka, regs, sizeof(*frame));
1023         if (unlikely(frame == NULL))
1024                 goto badframe;
1025         sc = (struct sigcontext __user *) &frame->sctx;
1026
1027 #if _NSIG != 64
1028 #error "Please adjust handle_signal()"
1029 #endif
1030         if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1031             || __put_user(oldset->sig[0], &sc->oldmask)
1032 #ifdef CONFIG_PPC64
1033             || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1034 #else
1035             || __put_user(oldset->sig[1], &sc->_unused[3])
1036 #endif
1037             || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1038             || __put_user(sig, &sc->signal))
1039                 goto badframe;
1040
1041         if (vdso32_sigtramp && current->mm->context.vdso_base) {
1042                 if (save_user_regs(regs, &frame->mctx, 0))
1043                         goto badframe;
1044                 regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
1045         } else {
1046                 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1047                         goto badframe;
1048                 regs->link = (unsigned long) frame->mctx.tramp;
1049         }
1050
1051         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
1052
1053         /* create a stack frame for the caller of the handler */
1054         newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1055         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1056                 goto badframe;
1057
1058         regs->gpr[1] = newsp;
1059         regs->gpr[3] = sig;
1060         regs->gpr[4] = (unsigned long) sc;
1061         regs->nip = (unsigned long) ka->sa.sa_handler;
1062         /* enter the signal handler in big-endian mode */
1063         regs->msr &= ~MSR_LE;
1064         regs->trap = 0;
1065
1066         return 1;
1067
1068 badframe:
1069 #ifdef DEBUG_SIG
1070         printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1071                regs, frame, newsp);
1072 #endif
1073         if (show_unhandled_signals && printk_ratelimit())
1074                 printk(KERN_INFO "%s[%d]: bad frame in handle_signal32: "
1075                         "%p nip %08lx lr %08lx\n",
1076                         current->comm, current->pid,
1077                         frame, regs->nip, regs->link);
1078
1079         force_sigsegv(sig, current);
1080         return 0;
1081 }
1082
1083 /*
1084  * Do a signal return; undo the signal stack.
1085  */
1086 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1087                        struct pt_regs *regs)
1088 {
1089         struct sigcontext __user *sc;
1090         struct sigcontext sigctx;
1091         struct mcontext __user *sr;
1092         void __user *addr;
1093         sigset_t set;
1094
1095         /* Always make any pending restarted system calls return -EINTR */
1096         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1097
1098         sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1099         addr = sc;
1100         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1101                 goto badframe;
1102
1103 #ifdef CONFIG_PPC64
1104         /*
1105          * Note that PPC32 puts the upper 32 bits of the sigmask in the
1106          * unused part of the signal stackframe
1107          */
1108         set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1109 #else
1110         set.sig[0] = sigctx.oldmask;
1111         set.sig[1] = sigctx._unused[3];
1112 #endif
1113         restore_sigmask(&set);
1114
1115         sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1116         addr = sr;
1117         if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1118             || restore_user_regs(regs, sr, 1))
1119                 goto badframe;
1120
1121         set_thread_flag(TIF_RESTOREALL);
1122         return 0;
1123
1124 badframe:
1125         if (show_unhandled_signals && printk_ratelimit())
1126                 printk(KERN_INFO "%s[%d]: bad frame in sys_sigreturn: "
1127                         "%p nip %08lx lr %08lx\n",
1128                         current->comm, current->pid,
1129                         addr, regs->nip, regs->link);
1130
1131         force_sig(SIGSEGV, current);
1132         return 0;
1133 }