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_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         unsigned long msr = regs->msr;
 340 #ifdef CONFIG_VSX
 341         double buf[32];
 342         int i;
 343 #endif
 344
 345         /* Make sure floating point registers are stored in regs */
 346         flush_fp_to_thread(current);
 347
 348         /* save general registers */
 349         if (save_general_regs(regs, frame))
 350                 return 1;
 351
 352 #ifdef CONFIG_ALTIVEC
 353         /* save altivec registers */
 354         if (current->thread.used_vr) {
 355                 flush_altivec_to_thread(current);
 356                 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
 357                                    ELF_NVRREG * sizeof(vector128)))
 358                         return 1;
 359                 /* set MSR_VEC in the saved MSR value to indicate that
 360                    frame->mc_vregs contains valid data */
 361                 msr |= MSR_VEC;
 362         }
 363         /* else assert((regs->msr & MSR_VEC) == 0) */
 364
 365         /* We always copy to/from vrsave, it's 0 if we don't have or don't
 366          * use altivec. Since VSCR only contains 32 bits saved in the least
 367          * significant bits of a vector, we "cheat" and stuff VRSAVE in the
 368          * most significant bits of that same vector. --BenH
 369          */
 370         if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
 371                 return 1;
 372 #endif /* CONFIG_ALTIVEC */
 373 #ifdef CONFIG_VSX
 374         /* save FPR copy to local buffer then write to the thread_struct */
 375         flush_fp_to_thread(current);
 376         for (i = 0; i < 32 ; i++)
 377                 buf[i] = current->thread.TS_FPR(i);
 378         memcpy(&buf[i], &current->thread.fpscr, sizeof(double));
 379         if (__copy_to_user(&frame->mc_fregs, buf, ELF_NFPREG * sizeof(double)))
 380                 return 1;
 381 #else
 382         /* save floating-point registers */
 383         if (__copy_to_user(&frame->mc_fregs, current->thread.fpr,
 384                     ELF_NFPREG * sizeof(double)))
 385                 return 1;
 386 #endif /* CONFIG_VSX */
 387 #ifdef CONFIG_SPE
 388         /* save spe registers */
 389         if (current->thread.used_spe) {
 390                 flush_spe_to_thread(current);
 391                 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
 392                                    ELF_NEVRREG * sizeof(u32)))
 393                         return 1;
 394                 /* set MSR_SPE in the saved MSR value to indicate that
 395                    frame->mc_vregs contains valid data */
 396                 msr |= MSR_SPE;
 397         }
 398         /* else assert((regs->msr & MSR_SPE) == 0) */
 399
 400         /* We always copy to/from spefscr */
 401         if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
 402                 return 1;
 403 #endif /* CONFIG_SPE */
 404
 405         if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
 406                 return 1;
 407         if (sigret) {
 408                 /* Set up the sigreturn trampoline: li r0,sigret; sc */
 409                 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
 410                     || __put_user(0x44000002UL, &frame->tramp[1]))
 411                         return 1;
 412                 flush_icache_range((unsigned long) &frame->tramp[0],
 413                                    (unsigned long) &frame->tramp[2]);
 414         }
 415
 416         return 0;
 417 }
 418
 419 /*
 420  * Restore the current user register values from the user stack,
 421  * (except for MSR).
 422  */
 423 static long restore_user_regs(struct pt_regs *regs,
 424                               struct mcontext __user *sr, int sig)
 425 {
 426         long err;
 427         unsigned int save_r2 = 0;
 428         unsigned long msr;
 429 #ifdef CONFIG_VSX
 430         double buf[32];
 431         int i;
 432 #endif
 433
 434         /*
 435          * restore general registers but not including MSR or SOFTE. Also
 436          * take care of keeping r2 (TLS) intact if not a signal
 437          */
 438         if (!sig)
 439                 save_r2 = (unsigned int)regs->gpr[2];
 440         err = restore_general_regs(regs, sr);
 441         err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
 442         if (!sig)
 443                 regs->gpr[2] = (unsigned long) save_r2;
 444         if (err)
 445                 return 1;
 446
 447         /* if doing signal return, restore the previous little-endian mode */
 448         if (sig)
 449                 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
 450
 451         /*
 452          * Do this before updating the thread state in
 453          * current->thread.fpr/vr/evr.  That way, if we get preempted
 454          * and another task grabs the FPU/Altivec/SPE, it won't be
 455          * tempted to save the current CPU state into the thread_struct
 456          * and corrupt what we are writing there.
 457          */
 458         discard_lazy_cpu_state();
 459
 460 #ifdef CONFIG_ALTIVEC
 461         /*
 462          * Force the process to reload the altivec registers from
 463          * current->thread when it next does altivec instructions
 464          */
 465         regs->msr &= ~MSR_VEC;
 466         if (msr & MSR_VEC) {
 467                 /* restore altivec registers from the stack */
 468                 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
 469                                      sizeof(sr->mc_vregs)))
 470                         return 1;
 471         } else if (current->thread.used_vr)
 472                 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
 473
 474         /* Always get VRSAVE back */
 475         if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
 476                 return 1;
 477 #endif /* CONFIG_ALTIVEC */
 478
 479 #ifdef CONFIG_VSX
 480         if (__copy_from_user(buf, &sr->mc_fregs,sizeof(sr->mc_fregs)))
 481                 return 1;
 482         for (i = 0; i < 32 ; i++)
 483                 current->thread.TS_FPR(i) = buf[i];
 484         memcpy(&current->thread.fpscr, &buf[i], sizeof(double));
 485 #else
 486         if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
 487                              sizeof(sr->mc_fregs)))
 488                 return 1;
 489 #endif /* CONFIG_VSX */
 490         /*
 491          * force the process to reload the FP registers from
 492          * current->thread when it next does FP instructions
 493          */
 494         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
 495
 496 #ifdef CONFIG_SPE
 497         /* force the process to reload the spe registers from
 498            current->thread when it next does spe instructions */
 499         regs->msr &= ~MSR_SPE;
 500         if (msr & MSR_SPE) {
 501                 /* restore spe registers from the stack */
 502                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
 503                                      ELF_NEVRREG * sizeof(u32)))
 504                         return 1;
 505         } else if (current->thread.used_spe)
 506                 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
 507
 508         /* Always get SPEFSCR back */
 509         if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
 510                 return 1;
 511 #endif /* CONFIG_SPE */
 512
 513         return 0;
 514 }
 515
 516 #ifdef CONFIG_PPC64
 517 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
 518                 struct sigaction32 __user *oact, size_t sigsetsize)
 519 {
 520         struct k_sigaction new_ka, old_ka;
 521         int ret;
 522
 523         /* XXX: Don't preclude handling different sized sigset_t's.  */
 524         if (sigsetsize != sizeof(compat_sigset_t))
 525                 return -EINVAL;
 526
 527         if (act) {
 528                 compat_uptr_t handler;
 529
 530                 ret = get_user(handler, &act->sa_handler);
 531                 new_ka.sa.sa_handler = compat_ptr(handler);
 532                 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
 533                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 534                 if (ret)
 535                         return -EFAULT;
 536         }
 537
 538         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 539         if (!ret && oact) {
 540                 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
 541                 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
 542                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 543         }
 544         return ret;
 545 }
 546
 547 /*
 548  * Note: it is necessary to treat how as an unsigned int, with the
 549  * corresponding cast to a signed int to insure that the proper
 550  * conversion (sign extension) between the register representation
 551  * of a signed int (msr in 32-bit mode) and the register representation
 552  * of a signed int (msr in 64-bit mode) is performed.
 553  */
 554 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
 555                 compat_sigset_t __user *oset, size_t sigsetsize)
 556 {
 557         sigset_t s;
 558         sigset_t __user *up;
 559         int ret;
 560         mm_segment_t old_fs = get_fs();
 561
 562         if (set) {
 563                 if (get_sigset_t(&s, set))
 564                         return -EFAULT;
 565         }
 566
 567         set_fs(KERNEL_DS);
 568         /* This is valid because of the set_fs() */
 569         up = (sigset_t __user *) &s;
 570         ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
 571                                  sigsetsize);
 572         set_fs(old_fs);
 573         if (ret)
 574                 return ret;
 575         if (oset) {
 576                 if (put_sigset_t(oset, &s))
 577                         return -EFAULT;
 578         }
 579         return 0;
 580 }
 581
 582 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
 583 {
 584         sigset_t s;
 585         int ret;
 586         mm_segment_t old_fs = get_fs();
 587
 588         set_fs(KERNEL_DS);
 589         /* The __user pointer cast is valid because of the set_fs() */
 590         ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
 591         set_fs(old_fs);
 592         if (!ret) {
 593                 if (put_sigset_t(set, &s))
 594                         return -EFAULT;
 595         }
 596         return ret;
 597 }
 598
 599
 600 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
 601 {
 602         int err;
 603
 604         if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
 605                 return -EFAULT;
 606
 607         /* If you change siginfo_t structure, please be sure
 608          * this code is fixed accordingly.
 609          * It should never copy any pad contained in the structure
 610          * to avoid security leaks, but must copy the generic
 611          * 3 ints plus the relevant union member.
 612          * This routine must convert siginfo from 64bit to 32bit as well
 613          * at the same time.
 614          */
 615         err = __put_user(s->si_signo, &d->si_signo);
 616         err |= __put_user(s->si_errno, &d->si_errno);
 617         err |= __put_user((short)s->si_code, &d->si_code);
 618         if (s->si_code < 0)
 619                 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
 620                                       SI_PAD_SIZE32);
 621         else switch(s->si_code >> 16) {
 622         case __SI_CHLD >> 16:
 623                 err |= __put_user(s->si_pid, &d->si_pid);
 624                 err |= __put_user(s->si_uid, &d->si_uid);
 625                 err |= __put_user(s->si_utime, &d->si_utime);
 626                 err |= __put_user(s->si_stime, &d->si_stime);
 627                 err |= __put_user(s->si_status, &d->si_status);
 628                 break;
 629         case __SI_FAULT >> 16:
 630                 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
 631                                   &d->si_addr);
 632                 break;
 633         case __SI_POLL >> 16:
 634                 err |= __put_user(s->si_band, &d->si_band);
 635                 err |= __put_user(s->si_fd, &d->si_fd);
 636                 break;
 637         case __SI_TIMER >> 16:
 638                 err |= __put_user(s->si_tid, &d->si_tid);
 639                 err |= __put_user(s->si_overrun, &d->si_overrun);
 640                 err |= __put_user(s->si_int, &d->si_int);
 641                 break;
 642         case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 643         case __SI_MESGQ >> 16:
 644                 err |= __put_user(s->si_int, &d->si_int);
 645                 /* fallthrough */
 646         case __SI_KILL >> 16:
 647         default:
 648                 err |= __put_user(s->si_pid, &d->si_pid);
 649                 err |= __put_user(s->si_uid, &d->si_uid);
 650                 break;
 651         }
 652         return err;
 653 }
 654
 655 #define copy_siginfo_to_user    copy_siginfo_to_user32
 656
 657 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
 658 {
 659         memset(to, 0, sizeof *to);
 660
 661         if (copy_from_user(to, from, 3*sizeof(int)) ||
 662             copy_from_user(to->_sifields._pad,
 663                            from->_sifields._pad, SI_PAD_SIZE32))
 664                 return -EFAULT;
 665
 666         return 0;
 667 }
 668
 669 /*
 670  * Note: it is necessary to treat pid and sig as unsigned ints, with the
 671  * corresponding cast to a signed int to insure that the proper conversion
 672  * (sign extension) between the register representation of a signed int
 673  * (msr in 32-bit mode) and the register representation of a signed int
 674  * (msr in 64-bit mode) is performed.
 675  */
 676 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
 677 {
 678         siginfo_t info;
 679         int ret;
 680         mm_segment_t old_fs = get_fs();
 681
 682         ret = copy_siginfo_from_user32(&info, uinfo);
 683         if (unlikely(ret))
 684                 return ret;
 685
 686         set_fs (KERNEL_DS);
 687         /* The __user pointer cast is valid becasuse of the set_fs() */
 688         ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
 689         set_fs (old_fs);
 690         return ret;
 691 }
 692 /*
 693  *  Start Alternate signal stack support
 694  *
 695  *  System Calls
 696  *       sigaltatck               compat_sys_sigaltstack
 697  */
 698
 699 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
 700                       int r6, int r7, int r8, struct pt_regs *regs)
 701 {
 702         stack_32_t __user * newstack = compat_ptr(__new);
 703         stack_32_t __user * oldstack = compat_ptr(__old);
 704         stack_t uss, uoss;
 705         int ret;
 706         mm_segment_t old_fs;
 707         unsigned long sp;
 708         compat_uptr_t ss_sp;
 709
 710         /*
 711          * set sp to the user stack on entry to the system call
 712          * the system call router sets R9 to the saved registers
 713          */
 714         sp = regs->gpr[1];
 715
 716         /* Put new stack info in local 64 bit stack struct */
 717         if (newstack) {
 718                 if (get_user(ss_sp, &newstack->ss_sp) ||
 719                     __get_user(uss.ss_flags, &newstack->ss_flags) ||
 720                     __get_user(uss.ss_size, &newstack->ss_size))
 721                         return -EFAULT;
 722                 uss.ss_sp = compat_ptr(ss_sp);
 723         }
 724
 725         old_fs = get_fs();
 726         set_fs(KERNEL_DS);
 727         /* The __user pointer casts are valid because of the set_fs() */
 728         ret = do_sigaltstack(
 729                 newstack ? (stack_t __user *) &uss : NULL,
 730                 oldstack ? (stack_t __user *) &uoss : NULL,
 731                 sp);
 732         set_fs(old_fs);
 733         /* Copy the stack information to the user output buffer */
 734         if (!ret && oldstack  &&
 735                 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
 736                  __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
 737                  __put_user(uoss.ss_size, &oldstack->ss_size)))
 738                 return -EFAULT;
 739         return ret;
 740 }
 741 #endif /* CONFIG_PPC64 */
 742
 743 /*
 744  * Set up a signal frame for a "real-time" signal handler
 745  * (one which gets siginfo).
 746  */
 747 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
 748                 siginfo_t *info, sigset_t *oldset,
 749                 struct pt_regs *regs)
 750 {
 751         struct rt_sigframe __user *rt_sf;
 752         struct mcontext __user *frame;
 753         void __user *addr;
 754         unsigned long newsp = 0;
 755
 756         /* Set up Signal Frame */
 757         /* Put a Real Time Context onto stack */
 758         rt_sf = get_sigframe(ka, regs, sizeof(*rt_sf));
 759         addr = rt_sf;
 760         if (unlikely(rt_sf == NULL))
 761                 goto badframe;
 762
 763         /* Put the siginfo & fill in most of the ucontext */
 764         if (copy_siginfo_to_user(&rt_sf->info, info)
 765             || __put_user(0, &rt_sf->uc.uc_flags)
 766             || __put_user(0, &rt_sf->uc.uc_link)
 767             || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
 768             || __put_user(sas_ss_flags(regs->gpr[1]),
 769                           &rt_sf->uc.uc_stack.ss_flags)
 770             || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
 771             || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
 772                     &rt_sf->uc.uc_regs)
 773             || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
 774                 goto badframe;
 775
 776         /* Save user registers on the stack */
 777         frame = &rt_sf->uc.uc_mcontext;
 778         addr = frame;
 779         if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
 780                 if (save_user_regs(regs, frame, 0))
 781                         goto badframe;
 782                 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp;
 783         } else {
 784                 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
 785                         goto badframe;
 786                 regs->link = (unsigned long) frame->tramp;
 787         }
 788
 789         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
 790
 791         /* create a stack frame for the caller of the handler */
 792         newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
 793         addr = (void __user *)regs->gpr[1];
 794         if (put_user(regs->gpr[1], (u32 __user *)newsp))
 795                 goto badframe;
 796
 797         /* Fill registers for signal handler */
 798         regs->gpr[1] = newsp;
 799         regs->gpr[3] = sig;
 800         regs->gpr[4] = (unsigned long) &rt_sf->info;
 801         regs->gpr[5] = (unsigned long) &rt_sf->uc;
 802         regs->gpr[6] = (unsigned long) rt_sf;
 803         regs->nip = (unsigned long) ka->sa.sa_handler;
 804         /* enter the signal handler in big-endian mode */
 805         regs->msr &= ~MSR_LE;
 806         regs->trap = 0;
 807         return 1;
 808
 809 badframe:
 810 #ifdef DEBUG_SIG
 811         printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
 812                regs, frame, newsp);
 813 #endif
 814         if (show_unhandled_signals && printk_ratelimit())
 815                 printk(KERN_INFO "%s[%d]: bad frame in handle_rt_signal32: "
 816                         "%p nip %08lx lr %08lx\n",
 817                         current->comm, current->pid,
 818                         addr, regs->nip, regs->link);
 819
 820         force_sigsegv(sig, current);
 821         return 0;
 822 }
 823
 824 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
 825 {
 826         sigset_t set;
 827         struct mcontext __user *mcp;
 828
 829         if (get_sigset_t(&set, &ucp->uc_sigmask))
 830                 return -EFAULT;
 831 #ifdef CONFIG_PPC64
 832         {
 833                 u32 cmcp;
 834
 835                 if (__get_user(cmcp, &ucp->uc_regs))
 836                         return -EFAULT;
 837                 mcp = (struct mcontext __user *)(u64)cmcp;
 838                 /* no need to check access_ok(mcp), since mcp < 4GB */
 839         }
 840 #else
 841         if (__get_user(mcp, &ucp->uc_regs))
 842                 return -EFAULT;
 843         if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
 844                 return -EFAULT;
 845 #endif
 846         restore_sigmask(&set);
 847         if (restore_user_regs(regs, mcp, sig))
 848                 return -EFAULT;
 849
 850         return 0;
 851 }
 852
 853 long sys_swapcontext(struct ucontext __user *old_ctx,
 854                      struct ucontext __user *new_ctx,
 855                      int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
 856 {
 857         unsigned char tmp;
 858
 859         /* Context size is for future use. Right now, we only make sure
 860          * we are passed something we understand
 861          */
 862         if (ctx_size < sizeof(struct ucontext))
 863                 return -EINVAL;
 864
 865         if (old_ctx != NULL) {
 866                 struct mcontext __user *mctx;
 867
 868                 /*
 869                  * old_ctx might not be 16-byte aligned, in which
 870                  * case old_ctx->uc_mcontext won't be either.
 871                  * Because we have the old_ctx->uc_pad2 field
 872                  * before old_ctx->uc_mcontext, we need to round down
 873                  * from &old_ctx->uc_mcontext to a 16-byte boundary.
 874                  */
 875                 mctx = (struct mcontext __user *)
 876                         ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
 877                 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
 878                     || save_user_regs(regs, mctx, 0)
 879                     || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
 880                     || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
 881                         return -EFAULT;
 882         }
 883         if (new_ctx == NULL)
 884                 return 0;
 885         if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
 886             || __get_user(tmp, (u8 __user *) new_ctx)
 887             || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
 888                 return -EFAULT;
 889
 890         /*
 891          * If we get a fault copying the context into the kernel's
 892          * image of the user's registers, we can't just return -EFAULT
 893          * because the user's registers will be corrupted.  For instance
 894          * the NIP value may have been updated but not some of the
 895          * other registers.  Given that we have done the access_ok
 896          * and successfully read the first and last bytes of the region
 897          * above, this should only happen in an out-of-memory situation
 898          * or if another thread unmaps the region containing the context.
 899          * We kill the task with a SIGSEGV in this situation.
 900          */
 901         if (do_setcontext(new_ctx, regs, 0))
 902                 do_exit(SIGSEGV);
 903
 904         set_thread_flag(TIF_RESTOREALL);
 905         return 0;
 906 }
 907
 908 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
 909                      struct pt_regs *regs)
 910 {
 911         struct rt_sigframe __user *rt_sf;
 912
 913         /* Always make any pending restarted system calls return -EINTR */
 914         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 915
 916         rt_sf = (struct rt_sigframe __user *)
 917                 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
 918         if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
 919                 goto bad;
 920         if (do_setcontext(&rt_sf->uc, regs, 1))
 921                 goto bad;
 922
 923         /*
 924          * It's not clear whether or why it is desirable to save the
 925          * sigaltstack setting on signal delivery and restore it on
 926          * signal return.  But other architectures do this and we have
 927          * always done it up until now so it is probably better not to
 928          * change it.  -- paulus
 929          */
 930 #ifdef CONFIG_PPC64
 931         /*
 932          * We use the compat_sys_ version that does the 32/64 bits conversion
 933          * and takes userland pointer directly. What about error checking ?
 934          * nobody does any...
 935          */
 936         compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
 937 #else
 938         do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
 939 #endif
 940         set_thread_flag(TIF_RESTOREALL);
 941         return 0;
 942
 943  bad:
 944         if (show_unhandled_signals && printk_ratelimit())
 945                 printk(KERN_INFO "%s[%d]: bad frame in sys_rt_sigreturn: "
 946                         "%p nip %08lx lr %08lx\n",
 947                         current->comm, current->pid,
 948                         rt_sf, regs->nip, regs->link);
 949
 950         force_sig(SIGSEGV, current);
 951         return 0;
 952 }
 953
 954 #ifdef CONFIG_PPC32
 955 int sys_debug_setcontext(struct ucontext __user *ctx,
 956                          int ndbg, struct sig_dbg_op __user *dbg,
 957                          int r6, int r7, int r8,
 958                          struct pt_regs *regs)
 959 {
 960         struct sig_dbg_op op;
 961         int i;
 962         unsigned char tmp;
 963         unsigned long new_msr = regs->msr;
 964 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 965         unsigned long new_dbcr0 = current->thread.dbcr0;
 966 #endif
 967
 968         for (i=0; i<ndbg; i++) {
 969                 if (copy_from_user(&op, dbg + i, sizeof(op)))
 970                         return -EFAULT;
 971                 switch (op.dbg_type) {
 972                 case SIG_DBG_SINGLE_STEPPING:
 973 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 974                         if (op.dbg_value) {
 975                                 new_msr |= MSR_DE;
 976                                 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
 977                         } else {
 978                                 new_msr &= ~MSR_DE;
 979                                 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
 980                         }
 981 #else
 982                         if (op.dbg_value)
 983                                 new_msr |= MSR_SE;
 984                         else
 985                                 new_msr &= ~MSR_SE;
 986 #endif
 987                         break;
 988                 case SIG_DBG_BRANCH_TRACING:
 989 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 990                         return -EINVAL;
 991 #else
 992                         if (op.dbg_value)
 993                                 new_msr |= MSR_BE;
 994                         else
 995                                 new_msr &= ~MSR_BE;
 996 #endif
 997                         break;
 998
 999                 default:
1000                         return -EINVAL;
1001                 }
1002         }
1003
1004         /* We wait until here to actually install the values in the
1005            registers so if we fail in the above loop, it will not
1006            affect the contents of these registers.  After this point,
1007            failure is a problem, anyway, and it's very unlikely unless
1008            the user is really doing something wrong. */
1009         regs->msr = new_msr;
1010 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1011         current->thread.dbcr0 = new_dbcr0;
1012 #endif
1013
1014         if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1015             || __get_user(tmp, (u8 __user *) ctx)
1016             || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1017                 return -EFAULT;
1018
1019         /*
1020          * If we get a fault copying the context into the kernel's
1021          * image of the user's registers, we can't just return -EFAULT
1022          * because the user's registers will be corrupted.  For instance
1023          * the NIP value may have been updated but not some of the
1024          * other registers.  Given that we have done the access_ok
1025          * and successfully read the first and last bytes of the region
1026          * above, this should only happen in an out-of-memory situation
1027          * or if another thread unmaps the region containing the context.
1028          * We kill the task with a SIGSEGV in this situation.
1029          */
1030         if (do_setcontext(ctx, regs, 1)) {
1031                 if (show_unhandled_signals && printk_ratelimit())
1032                         printk(KERN_INFO "%s[%d]: bad frame in "
1033                                 "sys_debug_setcontext: %p nip %08lx "
1034                                 "lr %08lx\n",
1035                                 current->comm, current->pid,
1036                                 ctx, regs->nip, regs->link);
1037
1038                 force_sig(SIGSEGV, current);
1039                 goto out;
1040         }
1041
1042         /*
1043          * It's not clear whether or why it is desirable to save the
1044          * sigaltstack setting on signal delivery and restore it on
1045          * signal return.  But other architectures do this and we have
1046          * always done it up until now so it is probably better not to
1047          * change it.  -- paulus
1048          */
1049         do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1050
1051         set_thread_flag(TIF_RESTOREALL);
1052  out:
1053         return 0;
1054 }
1055 #endif
1056
1057 /*
1058  * OK, we're invoking a handler
1059  */
1060 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1061                     siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1062 {
1063         struct sigcontext __user *sc;
1064         struct sigframe __user *frame;
1065         unsigned long newsp = 0;
1066
1067         /* Set up Signal Frame */
1068         frame = get_sigframe(ka, regs, sizeof(*frame));
1069         if (unlikely(frame == NULL))
1070                 goto badframe;
1071         sc = (struct sigcontext __user *) &frame->sctx;
1072
1073 #if _NSIG != 64
1074 #error "Please adjust handle_signal()"
1075 #endif
1076         if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1077             || __put_user(oldset->sig[0], &sc->oldmask)
1078 #ifdef CONFIG_PPC64
1079             || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1080 #else
1081             || __put_user(oldset->sig[1], &sc->_unused[3])
1082 #endif
1083             || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1084             || __put_user(sig, &sc->signal))
1085                 goto badframe;
1086
1087         if (vdso32_sigtramp && current->mm->context.vdso_base) {
1088                 if (save_user_regs(regs, &frame->mctx, 0))
1089                         goto badframe;
1090                 regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
1091         } else {
1092                 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1093                         goto badframe;
1094                 regs->link = (unsigned long) frame->mctx.tramp;
1095         }
1096
1097         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
1098
1099         /* create a stack frame for the caller of the handler */
1100         newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1101         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1102                 goto badframe;
1103
1104         regs->gpr[1] = newsp;
1105         regs->gpr[3] = sig;
1106         regs->gpr[4] = (unsigned long) sc;
1107         regs->nip = (unsigned long) ka->sa.sa_handler;
1108         /* enter the signal handler in big-endian mode */
1109         regs->msr &= ~MSR_LE;
1110         regs->trap = 0;
1111
1112         return 1;
1113
1114 badframe:
1115 #ifdef DEBUG_SIG
1116         printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1117                regs, frame, newsp);
1118 #endif
1119         if (show_unhandled_signals && printk_ratelimit())
1120                 printk(KERN_INFO "%s[%d]: bad frame in handle_signal32: "
1121                         "%p nip %08lx lr %08lx\n",
1122                         current->comm, current->pid,
1123                         frame, regs->nip, regs->link);
1124
1125         force_sigsegv(sig, current);
1126         return 0;
1127 }
1128
1129 /*
1130  * Do a signal return; undo the signal stack.
1131  */
1132 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1133                        struct pt_regs *regs)
1134 {
1135         struct sigcontext __user *sc;
1136         struct sigcontext sigctx;
1137         struct mcontext __user *sr;
1138         void __user *addr;
1139         sigset_t set;
1140
1141         /* Always make any pending restarted system calls return -EINTR */
1142         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1143
1144         sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1145         addr = sc;
1146         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1147                 goto badframe;
1148
1149 #ifdef CONFIG_PPC64
1150         /*
1151          * Note that PPC32 puts the upper 32 bits of the sigmask in the
1152          * unused part of the signal stackframe
1153          */
1154         set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1155 #else
1156         set.sig[0] = sigctx.oldmask;
1157         set.sig[1] = sigctx._unused[3];
1158 #endif
1159         restore_sigmask(&set);
1160
1161         sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1162         addr = sr;
1163         if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1164             || restore_user_regs(regs, sr, 1))
1165                 goto badframe;
1166
1167         set_thread_flag(TIF_RESTOREALL);
1168         return 0;
1169
1170 badframe:
1171         if (show_unhandled_signals && printk_ratelimit())
1172                 printk(KERN_INFO "%s[%d]: bad frame in sys_sigreturn: "
1173                         "%p nip %08lx lr %08lx\n",
1174                         current->comm, current->pid,
1175                         addr, regs->nip, regs->link);
1176
1177         force_sig(SIGSEGV, current);
1178         return 0;
1179 }