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 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
 625 {
 626         memset(to, 0, sizeof *to);
 627
 628         if (copy_from_user(to, from, 3*sizeof(int)) ||
 629             copy_from_user(to->_sifields._pad,
 630                            from->_sifields._pad, SI_PAD_SIZE32))
 631                 return -EFAULT;
 632
 633         return 0;
 634 }
 635
 636 /*
 637  * Note: it is necessary to treat pid and sig as unsigned ints, with the
 638  * corresponding cast to a signed int to insure that the proper conversion
 639  * (sign extension) between the register representation of a signed int
 640  * (msr in 32-bit mode) and the register representation of a signed int
 641  * (msr in 64-bit mode) is performed.
 642  */
 643 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
 644 {
 645         siginfo_t info;
 646         int ret;
 647         mm_segment_t old_fs = get_fs();
 648
 649         ret = copy_siginfo_from_user32(&info, uinfo);
 650         if (unlikely(ret))
 651                 return ret;
 652
 653         set_fs (KERNEL_DS);
 654         /* The __user pointer cast is valid becasuse of the set_fs() */
 655         ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
 656         set_fs (old_fs);
 657         return ret;
 658 }
 659 /*
 660  *  Start Alternate signal stack support
 661  *
 662  *  System Calls
 663  *       sigaltatck               compat_sys_sigaltstack
 664  */
 665
 666 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
 667                       int r6, int r7, int r8, struct pt_regs *regs)
 668 {
 669         stack_32_t __user * newstack = compat_ptr(__new);
 670         stack_32_t __user * oldstack = compat_ptr(__old);
 671         stack_t uss, uoss;
 672         int ret;
 673         mm_segment_t old_fs;
 674         unsigned long sp;
 675         compat_uptr_t ss_sp;
 676
 677         /*
 678          * set sp to the user stack on entry to the system call
 679          * the system call router sets R9 to the saved registers
 680          */
 681         sp = regs->gpr[1];
 682
 683         /* Put new stack info in local 64 bit stack struct */
 684         if (newstack) {
 685                 if (get_user(ss_sp, &newstack->ss_sp) ||
 686                     __get_user(uss.ss_flags, &newstack->ss_flags) ||
 687                     __get_user(uss.ss_size, &newstack->ss_size))
 688                         return -EFAULT;
 689                 uss.ss_sp = compat_ptr(ss_sp);
 690         }
 691
 692         old_fs = get_fs();
 693         set_fs(KERNEL_DS);
 694         /* The __user pointer casts are valid because of the set_fs() */
 695         ret = do_sigaltstack(
 696                 newstack ? (stack_t __user *) &uss : NULL,
 697                 oldstack ? (stack_t __user *) &uoss : NULL,
 698                 sp);
 699         set_fs(old_fs);
 700         /* Copy the stack information to the user output buffer */
 701         if (!ret && oldstack  &&
 702                 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
 703                  __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
 704                  __put_user(uoss.ss_size, &oldstack->ss_size)))
 705                 return -EFAULT;
 706         return ret;
 707 }
 708 #endif /* CONFIG_PPC64 */
 709
 710 /*
 711  * Set up a signal frame for a "real-time" signal handler
 712  * (one which gets siginfo).
 713  */
 714 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
 715                 siginfo_t *info, sigset_t *oldset,
 716                 struct pt_regs *regs)
 717 {
 718         struct rt_sigframe __user *rt_sf;
 719         struct mcontext __user *frame;
 720         void __user *addr;
 721         unsigned long newsp = 0;
 722
 723         /* Set up Signal Frame */
 724         /* Put a Real Time Context onto stack */
 725         rt_sf = get_sigframe(ka, regs, sizeof(*rt_sf));
 726         addr = rt_sf;
 727         if (unlikely(rt_sf == NULL))
 728                 goto badframe;
 729
 730         /* Put the siginfo & fill in most of the ucontext */
 731         if (copy_siginfo_to_user(&rt_sf->info, info)
 732             || __put_user(0, &rt_sf->uc.uc_flags)
 733             || __put_user(0, &rt_sf->uc.uc_link)
 734             || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
 735             || __put_user(sas_ss_flags(regs->gpr[1]),
 736                           &rt_sf->uc.uc_stack.ss_flags)
 737             || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
 738             || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
 739                     &rt_sf->uc.uc_regs)
 740             || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
 741                 goto badframe;
 742
 743         /* Save user registers on the stack */
 744         frame = &rt_sf->uc.uc_mcontext;
 745         addr = frame;
 746         if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
 747                 if (save_user_regs(regs, frame, 0))
 748                         goto badframe;
 749                 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp;
 750         } else {
 751                 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
 752                         goto badframe;
 753                 regs->link = (unsigned long) frame->tramp;
 754         }
 755
 756         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
 757
 758         /* create a stack frame for the caller of the handler */
 759         newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
 760         addr = (void __user *)regs->gpr[1];
 761         if (put_user(regs->gpr[1], (u32 __user *)newsp))
 762                 goto badframe;
 763
 764         /* Fill registers for signal handler */
 765         regs->gpr[1] = newsp;
 766         regs->gpr[3] = sig;
 767         regs->gpr[4] = (unsigned long) &rt_sf->info;
 768         regs->gpr[5] = (unsigned long) &rt_sf->uc;
 769         regs->gpr[6] = (unsigned long) rt_sf;
 770         regs->nip = (unsigned long) ka->sa.sa_handler;
 771         /* enter the signal handler in big-endian mode */
 772         regs->msr &= ~MSR_LE;
 773         regs->trap = 0;
 774         return 1;
 775
 776 badframe:
 777 #ifdef DEBUG_SIG
 778         printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
 779                regs, frame, newsp);
 780 #endif
 781         if (show_unhandled_signals && printk_ratelimit())
 782                 printk(KERN_INFO "%s[%d]: bad frame in handle_rt_signal32: "
 783                         "%p nip %08lx lr %08lx\n",
 784                         current->comm, current->pid,
 785                         addr, regs->nip, regs->link);
 786
 787         force_sigsegv(sig, current);
 788         return 0;
 789 }
 790
 791 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
 792 {
 793         sigset_t set;
 794         struct mcontext __user *mcp;
 795
 796         if (get_sigset_t(&set, &ucp->uc_sigmask))
 797                 return -EFAULT;
 798 #ifdef CONFIG_PPC64
 799         {
 800                 u32 cmcp;
 801
 802                 if (__get_user(cmcp, &ucp->uc_regs))
 803                         return -EFAULT;
 804                 mcp = (struct mcontext __user *)(u64)cmcp;
 805                 /* no need to check access_ok(mcp), since mcp < 4GB */
 806         }
 807 #else
 808         if (__get_user(mcp, &ucp->uc_regs))
 809                 return -EFAULT;
 810         if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
 811                 return -EFAULT;
 812 #endif
 813         restore_sigmask(&set);
 814         if (restore_user_regs(regs, mcp, sig))
 815                 return -EFAULT;
 816
 817         return 0;
 818 }
 819
 820 long sys_swapcontext(struct ucontext __user *old_ctx,
 821                      struct ucontext __user *new_ctx,
 822                      int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
 823 {
 824         unsigned char tmp;
 825
 826         /* Context size is for future use. Right now, we only make sure
 827          * we are passed something we understand
 828          */
 829         if (ctx_size < sizeof(struct ucontext))
 830                 return -EINVAL;
 831
 832         if (old_ctx != NULL) {
 833                 struct mcontext __user *mctx;
 834
 835                 /*
 836                  * old_ctx might not be 16-byte aligned, in which
 837                  * case old_ctx->uc_mcontext won't be either.
 838                  * Because we have the old_ctx->uc_pad2 field
 839                  * before old_ctx->uc_mcontext, we need to round down
 840                  * from &old_ctx->uc_mcontext to a 16-byte boundary.
 841                  */
 842                 mctx = (struct mcontext __user *)
 843                         ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
 844                 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
 845                     || save_user_regs(regs, mctx, 0)
 846                     || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
 847                     || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
 848                         return -EFAULT;
 849         }
 850         if (new_ctx == NULL)
 851                 return 0;
 852         if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
 853             || __get_user(tmp, (u8 __user *) new_ctx)
 854             || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
 855                 return -EFAULT;
 856
 857         /*
 858          * If we get a fault copying the context into the kernel's
 859          * image of the user's registers, we can't just return -EFAULT
 860          * because the user's registers will be corrupted.  For instance
 861          * the NIP value may have been updated but not some of the
 862          * other registers.  Given that we have done the access_ok
 863          * and successfully read the first and last bytes of the region
 864          * above, this should only happen in an out-of-memory situation
 865          * or if another thread unmaps the region containing the context.
 866          * We kill the task with a SIGSEGV in this situation.
 867          */
 868         if (do_setcontext(new_ctx, regs, 0))
 869                 do_exit(SIGSEGV);
 870
 871         set_thread_flag(TIF_RESTOREALL);
 872         return 0;
 873 }
 874
 875 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
 876                      struct pt_regs *regs)
 877 {
 878         struct rt_sigframe __user *rt_sf;
 879
 880         /* Always make any pending restarted system calls return -EINTR */
 881         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 882
 883         rt_sf = (struct rt_sigframe __user *)
 884                 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
 885         if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
 886                 goto bad;
 887         if (do_setcontext(&rt_sf->uc, regs, 1))
 888                 goto bad;
 889
 890         /*
 891          * It's not clear whether or why it is desirable to save the
 892          * sigaltstack setting on signal delivery and restore it on
 893          * signal return.  But other architectures do this and we have
 894          * always done it up until now so it is probably better not to
 895          * change it.  -- paulus
 896          */
 897 #ifdef CONFIG_PPC64
 898         /*
 899          * We use the compat_sys_ version that does the 32/64 bits conversion
 900          * and takes userland pointer directly. What about error checking ?
 901          * nobody does any...
 902          */
 903         compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
 904 #else
 905         do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
 906 #endif
 907         set_thread_flag(TIF_RESTOREALL);
 908         return 0;
 909
 910  bad:
 911         if (show_unhandled_signals && printk_ratelimit())
 912                 printk(KERN_INFO "%s[%d]: bad frame in sys_rt_sigreturn: "
 913                         "%p nip %08lx lr %08lx\n",
 914                         current->comm, current->pid,
 915                         rt_sf, regs->nip, regs->link);
 916
 917         force_sig(SIGSEGV, current);
 918         return 0;
 919 }
 920
 921 #ifdef CONFIG_PPC32
 922 int sys_debug_setcontext(struct ucontext __user *ctx,
 923                          int ndbg, struct sig_dbg_op __user *dbg,
 924                          int r6, int r7, int r8,
 925                          struct pt_regs *regs)
 926 {
 927         struct sig_dbg_op op;
 928         int i;
 929         unsigned char tmp;
 930         unsigned long new_msr = regs->msr;
 931 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 932         unsigned long new_dbcr0 = current->thread.dbcr0;
 933 #endif
 934
 935         for (i=0; i<ndbg; i++) {
 936                 if (copy_from_user(&op, dbg + i, sizeof(op)))
 937                         return -EFAULT;
 938                 switch (op.dbg_type) {
 939                 case SIG_DBG_SINGLE_STEPPING:
 940 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 941                         if (op.dbg_value) {
 942                                 new_msr |= MSR_DE;
 943                                 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
 944                         } else {
 945                                 new_msr &= ~MSR_DE;
 946                                 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
 947                         }
 948 #else
 949                         if (op.dbg_value)
 950                                 new_msr |= MSR_SE;
 951                         else
 952                                 new_msr &= ~MSR_SE;
 953 #endif
 954                         break;
 955                 case SIG_DBG_BRANCH_TRACING:
 956 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 957                         return -EINVAL;
 958 #else
 959                         if (op.dbg_value)
 960                                 new_msr |= MSR_BE;
 961                         else
 962                                 new_msr &= ~MSR_BE;
 963 #endif
 964                         break;
 965
 966                 default:
 967                         return -EINVAL;
 968                 }
 969         }
 970
 971         /* We wait until here to actually install the values in the
 972            registers so if we fail in the above loop, it will not
 973            affect the contents of these registers.  After this point,
 974            failure is a problem, anyway, and it's very unlikely unless
 975            the user is really doing something wrong. */
 976         regs->msr = new_msr;
 977 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 978         current->thread.dbcr0 = new_dbcr0;
 979 #endif
 980
 981         if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
 982             || __get_user(tmp, (u8 __user *) ctx)
 983             || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
 984                 return -EFAULT;
 985
 986         /*
 987          * If we get a fault copying the context into the kernel's
 988          * image of the user's registers, we can't just return -EFAULT
 989          * because the user's registers will be corrupted.  For instance
 990          * the NIP value may have been updated but not some of the
 991          * other registers.  Given that we have done the access_ok
 992          * and successfully read the first and last bytes of the region
 993          * above, this should only happen in an out-of-memory situation
 994          * or if another thread unmaps the region containing the context.
 995          * We kill the task with a SIGSEGV in this situation.
 996          */
 997         if (do_setcontext(ctx, regs, 1)) {
 998                 if (show_unhandled_signals && printk_ratelimit())
 999                         printk(KERN_INFO "%s[%d]: bad frame in "
1000                                 "sys_debug_setcontext: %p nip %08lx "
1001                                 "lr %08lx\n",
1002                                 current->comm, current->pid,
1003                                 ctx, regs->nip, regs->link);
1004
1005                 force_sig(SIGSEGV, current);
1006                 goto out;
1007         }
1008
1009         /*
1010          * It's not clear whether or why it is desirable to save the
1011          * sigaltstack setting on signal delivery and restore it on
1012          * signal return.  But other architectures do this and we have
1013          * always done it up until now so it is probably better not to
1014          * change it.  -- paulus
1015          */
1016         do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1017
1018         set_thread_flag(TIF_RESTOREALL);
1019  out:
1020         return 0;
1021 }
1022 #endif
1023
1024 /*
1025  * OK, we're invoking a handler
1026  */
1027 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1028                     siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1029 {
1030         struct sigcontext __user *sc;
1031         struct sigframe __user *frame;
1032         unsigned long newsp = 0;
1033
1034         /* Set up Signal Frame */
1035         frame = get_sigframe(ka, regs, sizeof(*frame));
1036         if (unlikely(frame == NULL))
1037                 goto badframe;
1038         sc = (struct sigcontext __user *) &frame->sctx;
1039
1040 #if _NSIG != 64
1041 #error "Please adjust handle_signal()"
1042 #endif
1043         if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1044             || __put_user(oldset->sig[0], &sc->oldmask)
1045 #ifdef CONFIG_PPC64
1046             || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1047 #else
1048             || __put_user(oldset->sig[1], &sc->_unused[3])
1049 #endif
1050             || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1051             || __put_user(sig, &sc->signal))
1052                 goto badframe;
1053
1054         if (vdso32_sigtramp && current->mm->context.vdso_base) {
1055                 if (save_user_regs(regs, &frame->mctx, 0))
1056                         goto badframe;
1057                 regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
1058         } else {
1059                 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1060                         goto badframe;
1061                 regs->link = (unsigned long) frame->mctx.tramp;
1062         }
1063
1064         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
1065
1066         /* create a stack frame for the caller of the handler */
1067         newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1068         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1069                 goto badframe;
1070
1071         regs->gpr[1] = newsp;
1072         regs->gpr[3] = sig;
1073         regs->gpr[4] = (unsigned long) sc;
1074         regs->nip = (unsigned long) ka->sa.sa_handler;
1075         /* enter the signal handler in big-endian mode */
1076         regs->msr &= ~MSR_LE;
1077         regs->trap = 0;
1078
1079         return 1;
1080
1081 badframe:
1082 #ifdef DEBUG_SIG
1083         printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1084                regs, frame, newsp);
1085 #endif
1086         if (show_unhandled_signals && printk_ratelimit())
1087                 printk(KERN_INFO "%s[%d]: bad frame in handle_signal32: "
1088                         "%p nip %08lx lr %08lx\n",
1089                         current->comm, current->pid,
1090                         frame, regs->nip, regs->link);
1091
1092         force_sigsegv(sig, current);
1093         return 0;
1094 }
1095
1096 /*
1097  * Do a signal return; undo the signal stack.
1098  */
1099 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1100                        struct pt_regs *regs)
1101 {
1102         struct sigcontext __user *sc;
1103         struct sigcontext sigctx;
1104         struct mcontext __user *sr;
1105         void __user *addr;
1106         sigset_t set;
1107
1108         /* Always make any pending restarted system calls return -EINTR */
1109         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1110
1111         sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1112         addr = sc;
1113         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1114                 goto badframe;
1115
1116 #ifdef CONFIG_PPC64
1117         /*
1118          * Note that PPC32 puts the upper 32 bits of the sigmask in the
1119          * unused part of the signal stackframe
1120          */
1121         set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1122 #else
1123         set.sig[0] = sigctx.oldmask;
1124         set.sig[1] = sigctx._unused[3];
1125 #endif
1126         restore_sigmask(&set);
1127
1128         sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1129         addr = sr;
1130         if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1131             || restore_user_regs(regs, sr, 1))
1132                 goto badframe;
1133
1134         set_thread_flag(TIF_RESTOREALL);
1135         return 0;
1136
1137 badframe:
1138         if (show_unhandled_signals && printk_ratelimit())
1139                 printk(KERN_INFO "%s[%d]: bad frame in sys_sigreturn: "
1140                         "%p nip %08lx lr %08lx\n",
1141                         current->comm, current->pid,
1142                         addr, regs->nip, regs->link);
1143
1144         force_sig(SIGSEGV, current);
1145         return 0;
1146 }