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 #include <linux/ratelimit.h>
  29 #ifdef CONFIG_PPC64
  30 #include <linux/syscalls.h>
  31 #include <linux/compat.h>
  32 #else
  33 #include <linux/wait.h>
  34 #include <linux/unistd.h>
  35 #include <linux/stddef.h>
  36 #include <linux/tty.h>
  37 #include <linux/binfmts.h>
  38 #endif
  39
  40 #include <linux/uaccess.h>
  41 #include <asm/cacheflush.h>
  42 #include <asm/syscalls.h>
  43 #include <asm/sigcontext.h>
  44 #include <asm/vdso.h>
  45 #include <asm/switch_to.h>
  46 #include <asm/tm.h>
  47 #include <asm/asm-prototypes.h>
  48 #ifdef CONFIG_PPC64
  49 #include "ppc32.h"
  50 #include <asm/unistd.h>
  51 #else
  52 #include <asm/ucontext.h>
  53 #include <asm/pgtable.h>
  54 #endif
  55
  56 #include "signal.h"
  57
  58
  59 #ifdef CONFIG_PPC64
  60 #define sys_rt_sigreturn        compat_sys_rt_sigreturn
  61 #define sys_swapcontext compat_sys_swapcontext
  62 #define sys_sigreturn   compat_sys_sigreturn
  63
  64 #define old_sigaction   old_sigaction32
  65 #define sigcontext      sigcontext32
  66 #define mcontext        mcontext32
  67 #define ucontext        ucontext32
  68
  69 #define __save_altstack __compat_save_altstack
  70
  71 /*
  72  * Userspace code may pass a ucontext which doesn't include VSX added
  73  * at the end.  We need to check for this case.
  74  */
  75 #define UCONTEXTSIZEWITHOUTVSX \
  76                 (sizeof(struct ucontext) - sizeof(elf_vsrreghalf_t32))
  77
  78 /*
  79  * Returning 0 means we return to userspace via
  80  * ret_from_except and thus restore all user
  81  * registers from *regs.  This is what we need
  82  * to do when a signal has been delivered.
  83  */
  84
  85 #define GP_REGS_SIZE    min(sizeof(elf_gregset_t32), sizeof(struct pt_regs32))
  86 #undef __SIGNAL_FRAMESIZE
  87 #define __SIGNAL_FRAMESIZE      __SIGNAL_FRAMESIZE32
  88 #undef ELF_NVRREG
  89 #define ELF_NVRREG      ELF_NVRREG32
  90
  91 /*
  92  * Functions for flipping sigsets (thanks to brain dead generic
  93  * implementation that makes things simple for little endian only)
  94  */
  95 static inline int put_sigset_t(compat_sigset_t __user *uset, sigset_t *set)
  96 {
  97         compat_sigset_t cset;
  98
  99         switch (_NSIG_WORDS) {
 100         case 4: cset.sig[6] = set->sig[3] & 0xffffffffull;
 101                 cset.sig[7] = set->sig[3] >> 32;
 102         case 3: cset.sig[4] = set->sig[2] & 0xffffffffull;
 103                 cset.sig[5] = set->sig[2] >> 32;
 104         case 2: cset.sig[2] = set->sig[1] & 0xffffffffull;
 105                 cset.sig[3] = set->sig[1] >> 32;
 106         case 1: cset.sig[0] = set->sig[0] & 0xffffffffull;
 107                 cset.sig[1] = set->sig[0] >> 32;
 108         }
 109         return copy_to_user(uset, &cset, sizeof(*uset));
 110 }
 111
 112 static inline int get_sigset_t(sigset_t *set,
 113                                const compat_sigset_t __user *uset)
 114 {
 115         compat_sigset_t s32;
 116
 117         if (copy_from_user(&s32, uset, sizeof(*uset)))
 118                 return -EFAULT;
 119
 120         /*
 121          * Swap the 2 words of the 64-bit sigset_t (they are stored
 122          * in the "wrong" endian in 32-bit user storage).
 123          */
 124         switch (_NSIG_WORDS) {
 125         case 4: set->sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32);
 126         case 3: set->sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32);
 127         case 2: set->sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32);
 128         case 1: set->sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32);
 129         }
 130         return 0;
 131 }
 132
 133 #define to_user_ptr(p)          ptr_to_compat(p)
 134 #define from_user_ptr(p)        compat_ptr(p)
 135
 136 static inline int save_general_regs(struct pt_regs *regs,
 137                 struct mcontext __user *frame)
 138 {
 139         elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
 140         int i;
 141
 142         WARN_ON(!FULL_REGS(regs));
 143
 144         for (i = 0; i <= PT_RESULT; i ++) {
 145                 if (i == 14 && !FULL_REGS(regs))
 146                         i = 32;
 147                 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
 148                         return -EFAULT;
 149         }
 150         return 0;
 151 }
 152
 153 static inline int restore_general_regs(struct pt_regs *regs,
 154                 struct mcontext __user *sr)
 155 {
 156         elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
 157         int i;
 158
 159         for (i = 0; i <= PT_RESULT; i++) {
 160                 if ((i == PT_MSR) || (i == PT_SOFTE))
 161                         continue;
 162                 if (__get_user(gregs[i], &sr->mc_gregs[i]))
 163                         return -EFAULT;
 164         }
 165         return 0;
 166 }
 167
 168 #else /* CONFIG_PPC64 */
 169
 170 #define GP_REGS_SIZE    min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
 171
 172 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
 173 {
 174         return copy_to_user(uset, set, sizeof(*uset));
 175 }
 176
 177 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
 178 {
 179         return copy_from_user(set, uset, sizeof(*uset));
 180 }
 181
 182 #define to_user_ptr(p)          ((unsigned long)(p))
 183 #define from_user_ptr(p)        ((void __user *)(p))
 184
 185 static inline int save_general_regs(struct pt_regs *regs,
 186                 struct mcontext __user *frame)
 187 {
 188         WARN_ON(!FULL_REGS(regs));
 189         return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
 190 }
 191
 192 static inline int restore_general_regs(struct pt_regs *regs,
 193                 struct mcontext __user *sr)
 194 {
 195         /* copy up to but not including MSR */
 196         if (__copy_from_user(regs, &sr->mc_gregs,
 197                                 PT_MSR * sizeof(elf_greg_t)))
 198                 return -EFAULT;
 199         /* copy from orig_r3 (the word after the MSR) up to the end */
 200         if (__copy_from_user(&regs->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
 201                                 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
 202                 return -EFAULT;
 203         return 0;
 204 }
 205 #endif
 206
 207 /*
 208  * When we have signals to deliver, we set up on the
 209  * user stack, going down from the original stack pointer:
 210  *      an ABI gap of 56 words
 211  *      an mcontext struct
 212  *      a sigcontext struct
 213  *      a gap of __SIGNAL_FRAMESIZE bytes
 214  *
 215  * Each of these things must be a multiple of 16 bytes in size. The following
 216  * structure represent all of this except the __SIGNAL_FRAMESIZE gap
 217  *
 218  */
 219 struct sigframe {
 220         struct sigcontext sctx;         /* the sigcontext */
 221         struct mcontext mctx;           /* all the register values */
 222 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 223         struct sigcontext sctx_transact;
 224         struct mcontext mctx_transact;
 225 #endif
 226         /*
 227          * Programs using the rs6000/xcoff abi can save up to 19 gp
 228          * regs and 18 fp regs below sp before decrementing it.
 229          */
 230         int                     abigap[56];
 231 };
 232
 233 /* We use the mc_pad field for the signal return trampoline. */
 234 #define tramp   mc_pad
 235
 236 /*
 237  *  When we have rt signals to deliver, we set up on the
 238  *  user stack, going down from the original stack pointer:
 239  *      one rt_sigframe struct (siginfo + ucontext + ABI gap)
 240  *      a gap of __SIGNAL_FRAMESIZE+16 bytes
 241  *  (the +16 is to get the siginfo and ucontext in the same
 242  *  positions as in older kernels).
 243  *
 244  *  Each of these things must be a multiple of 16 bytes in size.
 245  *
 246  */
 247 struct rt_sigframe {
 248 #ifdef CONFIG_PPC64
 249         compat_siginfo_t info;
 250 #else
 251         struct siginfo info;
 252 #endif
 253         struct ucontext uc;
 254 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 255         struct ucontext uc_transact;
 256 #endif
 257         /*
 258          * Programs using the rs6000/xcoff abi can save up to 19 gp
 259          * regs and 18 fp regs below sp before decrementing it.
 260          */
 261         int                     abigap[56];
 262 };
 263
 264 #ifdef CONFIG_VSX
 265 unsigned long copy_fpr_to_user(void __user *to,
 266                                struct task_struct *task)
 267 {
 268         u64 buf[ELF_NFPREG];
 269         int i;
 270
 271         /* save FPR copy to local buffer then write to the thread_struct */
 272         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
 273                 buf[i] = task->thread.TS_FPR(i);
 274         buf[i] = task->thread.fp_state.fpscr;
 275         return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
 276 }
 277
 278 unsigned long copy_fpr_from_user(struct task_struct *task,
 279                                  void __user *from)
 280 {
 281         u64 buf[ELF_NFPREG];
 282         int i;
 283
 284         if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
 285                 return 1;
 286         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
 287                 task->thread.TS_FPR(i) = buf[i];
 288         task->thread.fp_state.fpscr = buf[i];
 289
 290         return 0;
 291 }
 292
 293 unsigned long copy_vsx_to_user(void __user *to,
 294                                struct task_struct *task)
 295 {
 296         u64 buf[ELF_NVSRHALFREG];
 297         int i;
 298
 299         /* save FPR copy to local buffer then write to the thread_struct */
 300         for (i = 0; i < ELF_NVSRHALFREG; i++)
 301                 buf[i] = task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET];
 302         return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
 303 }
 304
 305 unsigned long copy_vsx_from_user(struct task_struct *task,
 306                                  void __user *from)
 307 {
 308         u64 buf[ELF_NVSRHALFREG];
 309         int i;
 310
 311         if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
 312                 return 1;
 313         for (i = 0; i < ELF_NVSRHALFREG ; i++)
 314                 task->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
 315         return 0;
 316 }
 317
 318 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 319 unsigned long copy_ckfpr_to_user(void __user *to,
 320                                   struct task_struct *task)
 321 {
 322         u64 buf[ELF_NFPREG];
 323         int i;
 324
 325         /* save FPR copy to local buffer then write to the thread_struct */
 326         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
 327                 buf[i] = task->thread.TS_CKFPR(i);
 328         buf[i] = task->thread.ckfp_state.fpscr;
 329         return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
 330 }
 331
 332 unsigned long copy_ckfpr_from_user(struct task_struct *task,
 333                                           void __user *from)
 334 {
 335         u64 buf[ELF_NFPREG];
 336         int i;
 337
 338         if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
 339                 return 1;
 340         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
 341                 task->thread.TS_CKFPR(i) = buf[i];
 342         task->thread.ckfp_state.fpscr = buf[i];
 343
 344         return 0;
 345 }
 346
 347 unsigned long copy_ckvsx_to_user(void __user *to,
 348                                   struct task_struct *task)
 349 {
 350         u64 buf[ELF_NVSRHALFREG];
 351         int i;
 352
 353         /* save FPR copy to local buffer then write to the thread_struct */
 354         for (i = 0; i < ELF_NVSRHALFREG; i++)
 355                 buf[i] = task->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET];
 356         return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
 357 }
 358
 359 unsigned long copy_ckvsx_from_user(struct task_struct *task,
 360                                           void __user *from)
 361 {
 362         u64 buf[ELF_NVSRHALFREG];
 363         int i;
 364
 365         if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
 366                 return 1;
 367         for (i = 0; i < ELF_NVSRHALFREG ; i++)
 368                 task->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = buf[i];
 369         return 0;
 370 }
 371 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
 372 #else
 373 inline unsigned long copy_fpr_to_user(void __user *to,
 374                                       struct task_struct *task)
 375 {
 376         return __copy_to_user(to, task->thread.fp_state.fpr,
 377                               ELF_NFPREG * sizeof(double));
 378 }
 379
 380 inline unsigned long copy_fpr_from_user(struct task_struct *task,
 381                                         void __user *from)
 382 {
 383         return __copy_from_user(task->thread.fp_state.fpr, from,
 384                               ELF_NFPREG * sizeof(double));
 385 }
 386
 387 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 388 inline unsigned long copy_ckfpr_to_user(void __user *to,
 389                                          struct task_struct *task)
 390 {
 391         return __copy_to_user(to, task->thread.ckfp_state.fpr,
 392                               ELF_NFPREG * sizeof(double));
 393 }
 394
 395 inline unsigned long copy_ckfpr_from_user(struct task_struct *task,
 396                                                  void __user *from)
 397 {
 398         return __copy_from_user(task->thread.ckfp_state.fpr, from,
 399                                 ELF_NFPREG * sizeof(double));
 400 }
 401 #endif /* CONFIG_PPC_TRANSACTIONAL_MEM */
 402 #endif
 403
 404 /*
 405  * Save the current user registers on the user stack.
 406  * We only save the altivec/spe registers if the process has used
 407  * altivec/spe instructions at some point.
 408  */
 409 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
 410                           struct mcontext __user *tm_frame, int sigret,
 411                           int ctx_has_vsx_region)
 412 {
 413         unsigned long msr = regs->msr;
 414
 415         /* Make sure floating point registers are stored in regs */
 416         flush_fp_to_thread(current);
 417
 418         /* save general registers */
 419         if (save_general_regs(regs, frame))
 420                 return 1;
 421
 422 #ifdef CONFIG_ALTIVEC
 423         /* save altivec registers */
 424         if (current->thread.used_vr) {
 425                 flush_altivec_to_thread(current);
 426                 if (__copy_to_user(&frame->mc_vregs, &current->thread.vr_state,
 427                                    ELF_NVRREG * sizeof(vector128)))
 428                         return 1;
 429                 /* set MSR_VEC in the saved MSR value to indicate that
 430                    frame->mc_vregs contains valid data */
 431                 msr |= MSR_VEC;
 432         }
 433         /* else assert((regs->msr & MSR_VEC) == 0) */
 434
 435         /* We always copy to/from vrsave, it's 0 if we don't have or don't
 436          * use altivec. Since VSCR only contains 32 bits saved in the least
 437          * significant bits of a vector, we "cheat" and stuff VRSAVE in the
 438          * most significant bits of that same vector. --BenH
 439          * Note that the current VRSAVE value is in the SPR at this point.
 440          */
 441         if (cpu_has_feature(CPU_FTR_ALTIVEC))
 442                 current->thread.vrsave = mfspr(SPRN_VRSAVE);
 443         if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
 444                 return 1;
 445 #endif /* CONFIG_ALTIVEC */
 446         if (copy_fpr_to_user(&frame->mc_fregs, current))
 447                 return 1;
 448
 449         /*
 450          * Clear the MSR VSX bit to indicate there is no valid state attached
 451          * to this context, except in the specific case below where we set it.
 452          */
 453         msr &= ~MSR_VSX;
 454 #ifdef CONFIG_VSX
 455         /*
 456          * Copy VSR 0-31 upper half from thread_struct to local
 457          * buffer, then write that to userspace.  Also set MSR_VSX in
 458          * the saved MSR value to indicate that frame->mc_vregs
 459          * contains valid data
 460          */
 461         if (current->thread.used_vsr && ctx_has_vsx_region) {
 462                 flush_vsx_to_thread(current);
 463                 if (copy_vsx_to_user(&frame->mc_vsregs, current))
 464                         return 1;
 465                 msr |= MSR_VSX;
 466         }
 467 #endif /* CONFIG_VSX */
 468 #ifdef CONFIG_SPE
 469         /* save spe registers */
 470         if (current->thread.used_spe) {
 471                 flush_spe_to_thread(current);
 472                 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
 473                                    ELF_NEVRREG * sizeof(u32)))
 474                         return 1;
 475                 /* set MSR_SPE in the saved MSR value to indicate that
 476                    frame->mc_vregs contains valid data */
 477                 msr |= MSR_SPE;
 478         }
 479         /* else assert((regs->msr & MSR_SPE) == 0) */
 480
 481         /* We always copy to/from spefscr */
 482         if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
 483                 return 1;
 484 #endif /* CONFIG_SPE */
 485
 486         if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
 487                 return 1;
 488         /* We need to write 0 the MSR top 32 bits in the tm frame so that we
 489          * can check it on the restore to see if TM is active
 490          */
 491         if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
 492                 return 1;
 493
 494         if (sigret) {
 495                 /* Set up the sigreturn trampoline: li r0,sigret; sc */
 496                 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
 497                     || __put_user(0x44000002UL, &frame->tramp[1]))
 498                         return 1;
 499                 flush_icache_range((unsigned long) &frame->tramp[0],
 500                                    (unsigned long) &frame->tramp[2]);
 501         }
 502
 503         return 0;
 504 }
 505
 506 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 507 /*
 508  * Save the current user registers on the user stack.
 509  * We only save the altivec/spe registers if the process has used
 510  * altivec/spe instructions at some point.
 511  * We also save the transactional registers to a second ucontext in the
 512  * frame.
 513  *
 514  * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
 515  */
 516 static int save_tm_user_regs(struct pt_regs *regs,
 517                              struct mcontext __user *frame,
 518                              struct mcontext __user *tm_frame, int sigret)
 519 {
 520         unsigned long msr = regs->msr;
 521
 522         /* Remove TM bits from thread's MSR.  The MSR in the sigcontext
 523          * just indicates to userland that we were doing a transaction, but we
 524          * don't want to return in transactional state.  This also ensures
 525          * that flush_fp_to_thread won't set TIF_RESTORE_TM again.
 526          */
 527         regs->msr &= ~MSR_TS_MASK;
 528
 529         /* Save both sets of general registers */
 530         if (save_general_regs(&current->thread.ckpt_regs, frame)
 531             || save_general_regs(regs, tm_frame))
 532                 return 1;
 533
 534         /* Stash the top half of the 64bit MSR into the 32bit MSR word
 535          * of the transactional mcontext.  This way we have a backward-compatible
 536          * MSR in the 'normal' (checkpointed) mcontext and additionally one can
 537          * also look at what type of transaction (T or S) was active at the
 538          * time of the signal.
 539          */
 540         if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
 541                 return 1;
 542
 543 #ifdef CONFIG_ALTIVEC
 544         /* save altivec registers */
 545         if (current->thread.used_vr) {
 546                 if (__copy_to_user(&frame->mc_vregs, &current->thread.ckvr_state,
 547                                    ELF_NVRREG * sizeof(vector128)))
 548                         return 1;
 549                 if (msr & MSR_VEC) {
 550                         if (__copy_to_user(&tm_frame->mc_vregs,
 551                                            &current->thread.vr_state,
 552                                            ELF_NVRREG * sizeof(vector128)))
 553                                 return 1;
 554                 } else {
 555                         if (__copy_to_user(&tm_frame->mc_vregs,
 556                                            &current->thread.ckvr_state,
 557                                            ELF_NVRREG * sizeof(vector128)))
 558                                 return 1;
 559                 }
 560
 561                 /* set MSR_VEC in the saved MSR value to indicate that
 562                  * frame->mc_vregs contains valid data
 563                  */
 564                 msr |= MSR_VEC;
 565         }
 566
 567         /* We always copy to/from vrsave, it's 0 if we don't have or don't
 568          * use altivec. Since VSCR only contains 32 bits saved in the least
 569          * significant bits of a vector, we "cheat" and stuff VRSAVE in the
 570          * most significant bits of that same vector. --BenH
 571          */
 572         if (cpu_has_feature(CPU_FTR_ALTIVEC))
 573                 current->thread.ckvrsave = mfspr(SPRN_VRSAVE);
 574         if (__put_user(current->thread.ckvrsave,
 575                        (u32 __user *)&frame->mc_vregs[32]))
 576                 return 1;
 577         if (msr & MSR_VEC) {
 578                 if (__put_user(current->thread.vrsave,
 579                                (u32 __user *)&tm_frame->mc_vregs[32]))
 580                         return 1;
 581         } else {
 582                 if (__put_user(current->thread.ckvrsave,
 583                                (u32 __user *)&tm_frame->mc_vregs[32]))
 584                         return 1;
 585         }
 586 #endif /* CONFIG_ALTIVEC */
 587
 588         if (copy_ckfpr_to_user(&frame->mc_fregs, current))
 589                 return 1;
 590         if (msr & MSR_FP) {
 591                 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
 592                         return 1;
 593         } else {
 594                 if (copy_ckfpr_to_user(&tm_frame->mc_fregs, current))
 595                         return 1;
 596         }
 597
 598 #ifdef CONFIG_VSX
 599         /*
 600          * Copy VSR 0-31 upper half from thread_struct to local
 601          * buffer, then write that to userspace.  Also set MSR_VSX in
 602          * the saved MSR value to indicate that frame->mc_vregs
 603          * contains valid data
 604          */
 605         if (current->thread.used_vsr) {
 606                 if (copy_ckvsx_to_user(&frame->mc_vsregs, current))
 607                         return 1;
 608                 if (msr & MSR_VSX) {
 609                         if (copy_vsx_to_user(&tm_frame->mc_vsregs,
 610                                                       current))
 611                                 return 1;
 612                 } else {
 613                         if (copy_ckvsx_to_user(&tm_frame->mc_vsregs, current))
 614                                 return 1;
 615                 }
 616
 617                 msr |= MSR_VSX;
 618         }
 619 #endif /* CONFIG_VSX */
 620 #ifdef CONFIG_SPE
 621         /* SPE regs are not checkpointed with TM, so this section is
 622          * simply the same as in save_user_regs().
 623          */
 624         if (current->thread.used_spe) {
 625                 flush_spe_to_thread(current);
 626                 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
 627                                    ELF_NEVRREG * sizeof(u32)))
 628                         return 1;
 629                 /* set MSR_SPE in the saved MSR value to indicate that
 630                  * frame->mc_vregs contains valid data */
 631                 msr |= MSR_SPE;
 632         }
 633
 634         /* We always copy to/from spefscr */
 635         if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
 636                 return 1;
 637 #endif /* CONFIG_SPE */
 638
 639         if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
 640                 return 1;
 641         if (sigret) {
 642                 /* Set up the sigreturn trampoline: li r0,sigret; sc */
 643                 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
 644                     || __put_user(0x44000002UL, &frame->tramp[1]))
 645                         return 1;
 646                 flush_icache_range((unsigned long) &frame->tramp[0],
 647                                    (unsigned long) &frame->tramp[2]);
 648         }
 649
 650         return 0;
 651 }
 652 #endif
 653
 654 /*
 655  * Restore the current user register values from the user stack,
 656  * (except for MSR).
 657  */
 658 static long restore_user_regs(struct pt_regs *regs,
 659                               struct mcontext __user *sr, int sig)
 660 {
 661         long err;
 662         unsigned int save_r2 = 0;
 663         unsigned long msr;
 664 #ifdef CONFIG_VSX
 665         int i;
 666 #endif
 667
 668         /*
 669          * restore general registers but not including MSR or SOFTE. Also
 670          * take care of keeping r2 (TLS) intact if not a signal
 671          */
 672         if (!sig)
 673                 save_r2 = (unsigned int)regs->gpr[2];
 674         err = restore_general_regs(regs, sr);
 675         regs->trap = 0;
 676         err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
 677         if (!sig)
 678                 regs->gpr[2] = (unsigned long) save_r2;
 679         if (err)
 680                 return 1;
 681
 682         /* if doing signal return, restore the previous little-endian mode */
 683         if (sig)
 684                 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
 685
 686 #ifdef CONFIG_ALTIVEC
 687         /*
 688          * Force the process to reload the altivec registers from
 689          * current->thread when it next does altivec instructions
 690          */
 691         regs->msr &= ~MSR_VEC;
 692         if (msr & MSR_VEC) {
 693                 /* restore altivec registers from the stack */
 694                 if (__copy_from_user(&current->thread.vr_state, &sr->mc_vregs,
 695                                      sizeof(sr->mc_vregs)))
 696                         return 1;
 697                 current->thread.used_vr = true;
 698         } else if (current->thread.used_vr)
 699                 memset(&current->thread.vr_state, 0,
 700                        ELF_NVRREG * sizeof(vector128));
 701
 702         /* Always get VRSAVE back */
 703         if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
 704                 return 1;
 705         if (cpu_has_feature(CPU_FTR_ALTIVEC))
 706                 mtspr(SPRN_VRSAVE, current->thread.vrsave);
 707 #endif /* CONFIG_ALTIVEC */
 708         if (copy_fpr_from_user(current, &sr->mc_fregs))
 709                 return 1;
 710
 711 #ifdef CONFIG_VSX
 712         /*
 713          * Force the process to reload the VSX registers from
 714          * current->thread when it next does VSX instruction.
 715          */
 716         regs->msr &= ~MSR_VSX;
 717         if (msr & MSR_VSX) {
 718                 /*
 719                  * Restore altivec registers from the stack to a local
 720                  * buffer, then write this out to the thread_struct
 721                  */
 722                 if (copy_vsx_from_user(current, &sr->mc_vsregs))
 723                         return 1;
 724                 current->thread.used_vsr = true;
 725         } else if (current->thread.used_vsr)
 726                 for (i = 0; i < 32 ; i++)
 727                         current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
 728 #endif /* CONFIG_VSX */
 729         /*
 730          * force the process to reload the FP registers from
 731          * current->thread when it next does FP instructions
 732          */
 733         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
 734
 735 #ifdef CONFIG_SPE
 736         /* force the process to reload the spe registers from
 737            current->thread when it next does spe instructions */
 738         regs->msr &= ~MSR_SPE;
 739         if (msr & MSR_SPE) {
 740                 /* restore spe registers from the stack */
 741                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
 742                                      ELF_NEVRREG * sizeof(u32)))
 743                         return 1;
 744                 current->thread.used_spe = true;
 745         } else if (current->thread.used_spe)
 746                 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
 747
 748         /* Always get SPEFSCR back */
 749         if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
 750                 return 1;
 751 #endif /* CONFIG_SPE */
 752
 753         return 0;
 754 }
 755
 756 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 757 /*
 758  * Restore the current user register values from the user stack, except for
 759  * MSR, and recheckpoint the original checkpointed register state for processes
 760  * in transactions.
 761  */
 762 static long restore_tm_user_regs(struct pt_regs *regs,
 763                                  struct mcontext __user *sr,
 764                                  struct mcontext __user *tm_sr)
 765 {
 766         long err;
 767         unsigned long msr, msr_hi;
 768 #ifdef CONFIG_VSX
 769         int i;
 770 #endif
 771
 772         /*
 773          * restore general registers but not including MSR or SOFTE. Also
 774          * take care of keeping r2 (TLS) intact if not a signal.
 775          * See comment in signal_64.c:restore_tm_sigcontexts();
 776          * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
 777          * were set by the signal delivery.
 778          */
 779         err = restore_general_regs(regs, tm_sr);
 780         err |= restore_general_regs(&current->thread.ckpt_regs, sr);
 781
 782         err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
 783
 784         err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
 785         if (err)
 786                 return 1;
 787
 788         /* Restore the previous little-endian mode */
 789         regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
 790
 791 #ifdef CONFIG_ALTIVEC
 792         regs->msr &= ~MSR_VEC;
 793         if (msr & MSR_VEC) {
 794                 /* restore altivec registers from the stack */
 795                 if (__copy_from_user(&current->thread.ckvr_state, &sr->mc_vregs,
 796                                      sizeof(sr->mc_vregs)) ||
 797                     __copy_from_user(&current->thread.vr_state,
 798                                      &tm_sr->mc_vregs,
 799                                      sizeof(sr->mc_vregs)))
 800                         return 1;
 801                 current->thread.used_vr = true;
 802         } else if (current->thread.used_vr) {
 803                 memset(&current->thread.vr_state, 0,
 804                        ELF_NVRREG * sizeof(vector128));
 805                 memset(&current->thread.ckvr_state, 0,
 806                        ELF_NVRREG * sizeof(vector128));
 807         }
 808
 809         /* Always get VRSAVE back */
 810         if (__get_user(current->thread.ckvrsave,
 811                        (u32 __user *)&sr->mc_vregs[32]) ||
 812             __get_user(current->thread.vrsave,
 813                        (u32 __user *)&tm_sr->mc_vregs[32]))
 814                 return 1;
 815         if (cpu_has_feature(CPU_FTR_ALTIVEC))
 816                 mtspr(SPRN_VRSAVE, current->thread.ckvrsave);
 817 #endif /* CONFIG_ALTIVEC */
 818
 819         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
 820
 821         if (copy_fpr_from_user(current, &sr->mc_fregs) ||
 822             copy_ckfpr_from_user(current, &tm_sr->mc_fregs))
 823                 return 1;
 824
 825 #ifdef CONFIG_VSX
 826         regs->msr &= ~MSR_VSX;
 827         if (msr & MSR_VSX) {
 828                 /*
 829                  * Restore altivec registers from the stack to a local
 830                  * buffer, then write this out to the thread_struct
 831                  */
 832                 if (copy_vsx_from_user(current, &tm_sr->mc_vsregs) ||
 833                     copy_ckvsx_from_user(current, &sr->mc_vsregs))
 834                         return 1;
 835                 current->thread.used_vsr = true;
 836         } else if (current->thread.used_vsr)
 837                 for (i = 0; i < 32 ; i++) {
 838                         current->thread.fp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
 839                         current->thread.ckfp_state.fpr[i][TS_VSRLOWOFFSET] = 0;
 840                 }
 841 #endif /* CONFIG_VSX */
 842
 843 #ifdef CONFIG_SPE
 844         /* SPE regs are not checkpointed with TM, so this section is
 845          * simply the same as in restore_user_regs().
 846          */
 847         regs->msr &= ~MSR_SPE;
 848         if (msr & MSR_SPE) {
 849                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
 850                                      ELF_NEVRREG * sizeof(u32)))
 851                         return 1;
 852                 current->thread.used_spe = true;
 853         } else if (current->thread.used_spe)
 854                 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
 855
 856         /* Always get SPEFSCR back */
 857         if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
 858                        + ELF_NEVRREG))
 859                 return 1;
 860 #endif /* CONFIG_SPE */
 861
 862         /* Get the top half of the MSR from the user context */
 863         if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
 864                 return 1;
 865         msr_hi <<= 32;
 866         /* If TM bits are set to the reserved value, it's an invalid context */
 867         if (MSR_TM_RESV(msr_hi))
 868                 return 1;
 869
 870         /*
 871          * Disabling preemption, since it is unsafe to be preempted
 872          * with MSR[TS] set without recheckpointing.
 873          */
 874         preempt_disable();
 875
 876         /*
 877          * CAUTION:
 878          * After regs->MSR[TS] being updated, make sure that get_user(),
 879          * put_user() or similar functions are *not* called. These
 880          * functions can generate page faults which will cause the process
 881          * to be de-scheduled with MSR[TS] set but without calling
 882          * tm_recheckpoint(). This can cause a bug.
 883          *
 884          * Pull in the MSR TM bits from the user context
 885          */
 886         regs->msr = (regs->msr & ~MSR_TS_MASK) | (msr_hi & MSR_TS_MASK);
 887         /* Now, recheckpoint.  This loads up all of the checkpointed (older)
 888          * registers, including FP and V[S]Rs.  After recheckpointing, the
 889          * transactional versions should be loaded.
 890          */
 891         tm_enable();
 892         /* Make sure the transaction is marked as failed */
 893         current->thread.tm_texasr |= TEXASR_FS;
 894         /* This loads the checkpointed FP/VEC state, if used */
 895         tm_recheckpoint(&current->thread, msr);
 896
 897         /* This loads the speculative FP/VEC state, if used */
 898         msr_check_and_set(msr & (MSR_FP | MSR_VEC));
 899         if (msr & MSR_FP) {
 900                 load_fp_state(&current->thread.fp_state);
 901                 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
 902         }
 903 #ifdef CONFIG_ALTIVEC
 904         if (msr & MSR_VEC) {
 905                 load_vr_state(&current->thread.vr_state);
 906                 regs->msr |= MSR_VEC;
 907         }
 908 #endif
 909
 910         preempt_enable();
 911
 912         return 0;
 913 }
 914 #endif
 915
 916 #ifdef CONFIG_PPC64
 917 int copy_siginfo_to_user32(struct compat_siginfo __user *d, const siginfo_t *s)
 918 {
 919         int err;
 920
 921         if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
 922                 return -EFAULT;
 923
 924         /* If you change siginfo_t structure, please be sure
 925          * this code is fixed accordingly.
 926          * It should never copy any pad contained in the structure
 927          * to avoid security leaks, but must copy the generic
 928          * 3 ints plus the relevant union member.
 929          * This routine must convert siginfo from 64bit to 32bit as well
 930          * at the same time.
 931          */
 932         err = __put_user(s->si_signo, &d->si_signo);
 933         err |= __put_user(s->si_errno, &d->si_errno);
 934         err |= __put_user(s->si_code, &d->si_code);
 935         if (s->si_code < 0)
 936                 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
 937                                       SI_PAD_SIZE32);
 938         else switch(siginfo_layout(s->si_signo, s->si_code)) {
 939         case SIL_CHLD:
 940                 err |= __put_user(s->si_pid, &d->si_pid);
 941                 err |= __put_user(s->si_uid, &d->si_uid);
 942                 err |= __put_user(s->si_utime, &d->si_utime);
 943                 err |= __put_user(s->si_stime, &d->si_stime);
 944                 err |= __put_user(s->si_status, &d->si_status);
 945                 break;
 946         case SIL_FAULT:
 947                 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
 948                                   &d->si_addr);
 949                 break;
 950         case SIL_POLL:
 951                 err |= __put_user(s->si_band, &d->si_band);
 952                 err |= __put_user(s->si_fd, &d->si_fd);
 953                 break;
 954         case SIL_TIMER:
 955                 err |= __put_user(s->si_tid, &d->si_tid);
 956                 err |= __put_user(s->si_overrun, &d->si_overrun);
 957                 err |= __put_user(s->si_int, &d->si_int);
 958                 break;
 959         case SIL_SYS:
 960                 err |= __put_user(ptr_to_compat(s->si_call_addr), &d->si_call_addr);
 961                 err |= __put_user(s->si_syscall, &d->si_syscall);
 962                 err |= __put_user(s->si_arch, &d->si_arch);
 963                 break;
 964         case SIL_RT:
 965                 err |= __put_user(s->si_int, &d->si_int);
 966                 /* fallthrough */
 967         case SIL_KILL:
 968                 err |= __put_user(s->si_pid, &d->si_pid);
 969                 err |= __put_user(s->si_uid, &d->si_uid);
 970                 break;
 971         }
 972         return err;
 973 }
 974
 975 #define copy_siginfo_to_user    copy_siginfo_to_user32
 976
 977 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
 978 {
 979         if (copy_from_user(to, from, 3*sizeof(int)) ||
 980             copy_from_user(to->_sifields._pad,
 981                            from->_sifields._pad, SI_PAD_SIZE32))
 982                 return -EFAULT;
 983
 984         return 0;
 985 }
 986 #endif /* CONFIG_PPC64 */
 987
 988 /*
 989  * Set up a signal frame for a "real-time" signal handler
 990  * (one which gets siginfo).
 991  */
 992 int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,
 993                        struct task_struct *tsk)
 994 {
 995         struct rt_sigframe __user *rt_sf;
 996         struct mcontext __user *frame;
 997         struct mcontext __user *tm_frame = NULL;
 998         void __user *addr;
 999         unsigned long newsp = 0;
1000         int sigret;
1001         unsigned long tramp;
1002         struct pt_regs *regs = tsk->thread.regs;
1003
1004         BUG_ON(tsk != current);
1005
1006         /* Set up Signal Frame */
1007         /* Put a Real Time Context onto stack */
1008         rt_sf = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*rt_sf), 1);
1009         addr = rt_sf;
1010         if (unlikely(rt_sf == NULL))
1011                 goto badframe;
1012
1013         /* Put the siginfo & fill in most of the ucontext */
1014         if (copy_siginfo_to_user(&rt_sf->info, &ksig->info)
1015             || __put_user(0, &rt_sf->uc.uc_flags)
1016             || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
1017             || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
1018                     &rt_sf->uc.uc_regs)
1019             || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
1020                 goto badframe;
1021
1022         /* Save user registers on the stack */
1023         frame = &rt_sf->uc.uc_mcontext;
1024         addr = frame;
1025         if (vdso32_rt_sigtramp && tsk->mm->context.vdso_base) {
1026                 sigret = 0;
1027                 tramp = tsk->mm->context.vdso_base + vdso32_rt_sigtramp;
1028         } else {
1029                 sigret = __NR_rt_sigreturn;
1030                 tramp = (unsigned long) frame->tramp;
1031         }
1032
1033 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1034         tm_frame = &rt_sf->uc_transact.uc_mcontext;
1035         if (MSR_TM_ACTIVE(regs->msr)) {
1036                 if (__put_user((unsigned long)&rt_sf->uc_transact,
1037                                &rt_sf->uc.uc_link) ||
1038                     __put_user((unsigned long)tm_frame,
1039                                &rt_sf->uc_transact.uc_regs))
1040                         goto badframe;
1041                 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
1042                         goto badframe;
1043         }
1044         else
1045 #endif
1046         {
1047                 if (__put_user(0, &rt_sf->uc.uc_link))
1048                         goto badframe;
1049                 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
1050                         goto badframe;
1051         }
1052         regs->link = tramp;
1053
1054         tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1055
1056         /* create a stack frame for the caller of the handler */
1057         newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1058         addr = (void __user *)regs->gpr[1];
1059         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1060                 goto badframe;
1061
1062         /* Fill registers for signal handler */
1063         regs->gpr[1] = newsp;
1064         regs->gpr[3] = ksig->sig;
1065         regs->gpr[4] = (unsigned long) &rt_sf->info;
1066         regs->gpr[5] = (unsigned long) &rt_sf->uc;
1067         regs->gpr[6] = (unsigned long) rt_sf;
1068         regs->nip = (unsigned long) ksig->ka.sa.sa_handler;
1069         /* enter the signal handler in native-endian mode */
1070         regs->msr &= ~MSR_LE;
1071         regs->msr |= (MSR_KERNEL & MSR_LE);
1072         return 0;
1073
1074 badframe:
1075         if (show_unhandled_signals)
1076                 printk_ratelimited(KERN_INFO
1077                                    "%s[%d]: bad frame in handle_rt_signal32: "
1078                                    "%p nip %08lx lr %08lx\n",
1079                                    tsk->comm, tsk->pid,
1080                                    addr, regs->nip, regs->link);
1081
1082         return 1;
1083 }
1084
1085 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1086 {
1087         sigset_t set;
1088         struct mcontext __user *mcp;
1089
1090         if (get_sigset_t(&set, &ucp->uc_sigmask))
1091                 return -EFAULT;
1092 #ifdef CONFIG_PPC64
1093         {
1094                 u32 cmcp;
1095
1096                 if (__get_user(cmcp, &ucp->uc_regs))
1097                         return -EFAULT;
1098                 mcp = (struct mcontext __user *)(u64)cmcp;
1099                 /* no need to check access_ok(mcp), since mcp < 4GB */
1100         }
1101 #else
1102         if (__get_user(mcp, &ucp->uc_regs))
1103                 return -EFAULT;
1104         if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1105                 return -EFAULT;
1106 #endif
1107         set_current_blocked(&set);
1108         if (restore_user_regs(regs, mcp, sig))
1109                 return -EFAULT;
1110
1111         return 0;
1112 }
1113
1114 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1115 static int do_setcontext_tm(struct ucontext __user *ucp,
1116                             struct ucontext __user *tm_ucp,
1117                             struct pt_regs *regs)
1118 {
1119         sigset_t set;
1120         struct mcontext __user *mcp;
1121         struct mcontext __user *tm_mcp;
1122         u32 cmcp;
1123         u32 tm_cmcp;
1124
1125         if (get_sigset_t(&set, &ucp->uc_sigmask))
1126                 return -EFAULT;
1127
1128         if (__get_user(cmcp, &ucp->uc_regs) ||
1129             __get_user(tm_cmcp, &tm_ucp->uc_regs))
1130                 return -EFAULT;
1131         mcp = (struct mcontext __user *)(u64)cmcp;
1132         tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1133         /* no need to check access_ok(mcp), since mcp < 4GB */
1134
1135         set_current_blocked(&set);
1136         if (restore_tm_user_regs(regs, mcp, tm_mcp))
1137                 return -EFAULT;
1138
1139         return 0;
1140 }
1141 #endif
1142
1143 long sys_swapcontext(struct ucontext __user *old_ctx,
1144                      struct ucontext __user *new_ctx,
1145                      int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
1146 {
1147         unsigned char tmp;
1148         int ctx_has_vsx_region = 0;
1149
1150 #ifdef CONFIG_PPC64
1151         unsigned long new_msr = 0;
1152
1153         if (new_ctx) {
1154                 struct mcontext __user *mcp;
1155                 u32 cmcp;
1156
1157                 /*
1158                  * Get pointer to the real mcontext.  No need for
1159                  * access_ok since we are dealing with compat
1160                  * pointers.
1161                  */
1162                 if (__get_user(cmcp, &new_ctx->uc_regs))
1163                         return -EFAULT;
1164                 mcp = (struct mcontext __user *)(u64)cmcp;
1165                 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1166                         return -EFAULT;
1167         }
1168         /*
1169          * Check that the context is not smaller than the original
1170          * size (with VMX but without VSX)
1171          */
1172         if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1173                 return -EINVAL;
1174         /*
1175          * If the new context state sets the MSR VSX bits but
1176          * it doesn't provide VSX state.
1177          */
1178         if ((ctx_size < sizeof(struct ucontext)) &&
1179             (new_msr & MSR_VSX))
1180                 return -EINVAL;
1181         /* Does the context have enough room to store VSX data? */
1182         if (ctx_size >= sizeof(struct ucontext))
1183                 ctx_has_vsx_region = 1;
1184 #else
1185         /* Context size is for future use. Right now, we only make sure
1186          * we are passed something we understand
1187          */
1188         if (ctx_size < sizeof(struct ucontext))
1189                 return -EINVAL;
1190 #endif
1191         if (old_ctx != NULL) {
1192                 struct mcontext __user *mctx;
1193
1194                 /*
1195                  * old_ctx might not be 16-byte aligned, in which
1196                  * case old_ctx->uc_mcontext won't be either.
1197                  * Because we have the old_ctx->uc_pad2 field
1198                  * before old_ctx->uc_mcontext, we need to round down
1199                  * from &old_ctx->uc_mcontext to a 16-byte boundary.
1200                  */
1201                 mctx = (struct mcontext __user *)
1202                         ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1203                 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1204                     || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1205                     || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
1206                     || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1207                         return -EFAULT;
1208         }
1209         if (new_ctx == NULL)
1210                 return 0;
1211         if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1212             || __get_user(tmp, (u8 __user *) new_ctx)
1213             || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1214                 return -EFAULT;
1215
1216         /*
1217          * If we get a fault copying the context into the kernel's
1218          * image of the user's registers, we can't just return -EFAULT
1219          * because the user's registers will be corrupted.  For instance
1220          * the NIP value may have been updated but not some of the
1221          * other registers.  Given that we have done the access_ok
1222          * and successfully read the first and last bytes of the region
1223          * above, this should only happen in an out-of-memory situation
1224          * or if another thread unmaps the region containing the context.
1225          * We kill the task with a SIGSEGV in this situation.
1226          */
1227         if (do_setcontext(new_ctx, regs, 0))
1228                 do_exit(SIGSEGV);
1229
1230         set_thread_flag(TIF_RESTOREALL);
1231         return 0;
1232 }
1233
1234 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1235                      struct pt_regs *regs)
1236 {
1237         struct rt_sigframe __user *rt_sf;
1238 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1239         struct ucontext __user *uc_transact;
1240         unsigned long msr_hi;
1241         unsigned long tmp;
1242         int tm_restore = 0;
1243 #endif
1244         /* Always make any pending restarted system calls return -EINTR */
1245         current->restart_block.fn = do_no_restart_syscall;
1246
1247         rt_sf = (struct rt_sigframe __user *)
1248                 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1249         if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1250                 goto bad;
1251
1252 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1253         /*
1254          * If there is a transactional state then throw it away.
1255          * The purpose of a sigreturn is to destroy all traces of the
1256          * signal frame, this includes any transactional state created
1257          * within in. We only check for suspended as we can never be
1258          * active in the kernel, we are active, there is nothing better to
1259          * do than go ahead and Bad Thing later.
1260          * The cause is not important as there will never be a
1261          * recheckpoint so it's not user visible.
1262          */
1263         if (MSR_TM_SUSPENDED(mfmsr()))
1264                 tm_reclaim_current(0);
1265
1266         if (__get_user(tmp, &rt_sf->uc.uc_link))
1267                 goto bad;
1268         uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1269         if (uc_transact) {
1270                 u32 cmcp;
1271                 struct mcontext __user *mcp;
1272
1273                 if (__get_user(cmcp, &uc_transact->uc_regs))
1274                         return -EFAULT;
1275                 mcp = (struct mcontext __user *)(u64)cmcp;
1276                 /* The top 32 bits of the MSR are stashed in the transactional
1277                  * ucontext. */
1278                 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1279                         goto bad;
1280
1281                 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1282                         /* Trying to start TM on non TM system */
1283                         if (!cpu_has_feature(CPU_FTR_TM))
1284                                 goto bad;
1285                         /* We only recheckpoint on return if we're
1286                          * transaction.
1287                          */
1288                         tm_restore = 1;
1289                         if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1290                                 goto bad;
1291                 }
1292         }
1293         if (!tm_restore)
1294                 /* Fall through, for non-TM restore */
1295 #endif
1296         if (do_setcontext(&rt_sf->uc, regs, 1))
1297                 goto bad;
1298
1299         /*
1300          * It's not clear whether or why it is desirable to save the
1301          * sigaltstack setting on signal delivery and restore it on
1302          * signal return.  But other architectures do this and we have
1303          * always done it up until now so it is probably better not to
1304          * change it.  -- paulus
1305          */
1306 #ifdef CONFIG_PPC64
1307         if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1308                 goto bad;
1309 #else
1310         if (restore_altstack(&rt_sf->uc.uc_stack))
1311                 goto bad;
1312 #endif
1313         set_thread_flag(TIF_RESTOREALL);
1314         return 0;
1315
1316  bad:
1317         if (show_unhandled_signals)
1318                 printk_ratelimited(KERN_INFO
1319                                    "%s[%d]: bad frame in sys_rt_sigreturn: "
1320                                    "%p nip %08lx lr %08lx\n",
1321                                    current->comm, current->pid,
1322                                    rt_sf, regs->nip, regs->link);
1323
1324         force_sig(SIGSEGV, current);
1325         return 0;
1326 }
1327
1328 #ifdef CONFIG_PPC32
1329 int sys_debug_setcontext(struct ucontext __user *ctx,
1330                          int ndbg, struct sig_dbg_op __user *dbg,
1331                          int r6, int r7, int r8,
1332                          struct pt_regs *regs)
1333 {
1334         struct sig_dbg_op op;
1335         int i;
1336         unsigned char tmp;
1337         unsigned long new_msr = regs->msr;
1338 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1339         unsigned long new_dbcr0 = current->thread.debug.dbcr0;
1340 #endif
1341
1342         for (i=0; i<ndbg; i++) {
1343                 if (copy_from_user(&op, dbg + i, sizeof(op)))
1344                         return -EFAULT;
1345                 switch (op.dbg_type) {
1346                 case SIG_DBG_SINGLE_STEPPING:
1347 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1348                         if (op.dbg_value) {
1349                                 new_msr |= MSR_DE;
1350                                 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1351                         } else {
1352                                 new_dbcr0 &= ~DBCR0_IC;
1353                                 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1354                                                 current->thread.debug.dbcr1)) {
1355                                         new_msr &= ~MSR_DE;
1356                                         new_dbcr0 &= ~DBCR0_IDM;
1357                                 }
1358                         }
1359 #else
1360                         if (op.dbg_value)
1361                                 new_msr |= MSR_SE;
1362                         else
1363                                 new_msr &= ~MSR_SE;
1364 #endif
1365                         break;
1366                 case SIG_DBG_BRANCH_TRACING:
1367 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1368                         return -EINVAL;
1369 #else
1370                         if (op.dbg_value)
1371                                 new_msr |= MSR_BE;
1372                         else
1373                                 new_msr &= ~MSR_BE;
1374 #endif
1375                         break;
1376
1377                 default:
1378                         return -EINVAL;
1379                 }
1380         }
1381
1382         /* We wait until here to actually install the values in the
1383            registers so if we fail in the above loop, it will not
1384            affect the contents of these registers.  After this point,
1385            failure is a problem, anyway, and it's very unlikely unless
1386            the user is really doing something wrong. */
1387         regs->msr = new_msr;
1388 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1389         current->thread.debug.dbcr0 = new_dbcr0;
1390 #endif
1391
1392         if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1393             || __get_user(tmp, (u8 __user *) ctx)
1394             || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1395                 return -EFAULT;
1396
1397         /*
1398          * If we get a fault copying the context into the kernel's
1399          * image of the user's registers, we can't just return -EFAULT
1400          * because the user's registers will be corrupted.  For instance
1401          * the NIP value may have been updated but not some of the
1402          * other registers.  Given that we have done the access_ok
1403          * and successfully read the first and last bytes of the region
1404          * above, this should only happen in an out-of-memory situation
1405          * or if another thread unmaps the region containing the context.
1406          * We kill the task with a SIGSEGV in this situation.
1407          */
1408         if (do_setcontext(ctx, regs, 1)) {
1409                 if (show_unhandled_signals)
1410                         printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1411                                            "sys_debug_setcontext: %p nip %08lx "
1412                                            "lr %08lx\n",
1413                                            current->comm, current->pid,
1414                                            ctx, regs->nip, regs->link);
1415
1416                 force_sig(SIGSEGV, current);
1417                 goto out;
1418         }
1419
1420         /*
1421          * It's not clear whether or why it is desirable to save the
1422          * sigaltstack setting on signal delivery and restore it on
1423          * signal return.  But other architectures do this and we have
1424          * always done it up until now so it is probably better not to
1425          * change it.  -- paulus
1426          */
1427         restore_altstack(&ctx->uc_stack);
1428
1429         set_thread_flag(TIF_RESTOREALL);
1430  out:
1431         return 0;
1432 }
1433 #endif
1434
1435 /*
1436  * OK, we're invoking a handler
1437  */
1438 int handle_signal32(struct ksignal *ksig, sigset_t *oldset,
1439                 struct task_struct *tsk)
1440 {
1441         struct sigcontext __user *sc;
1442         struct sigframe __user *frame;
1443         struct mcontext __user *tm_mctx = NULL;
1444         unsigned long newsp = 0;
1445         int sigret;
1446         unsigned long tramp;
1447         struct pt_regs *regs = tsk->thread.regs;
1448
1449         BUG_ON(tsk != current);
1450
1451         /* Set up Signal Frame */
1452         frame = get_sigframe(ksig, get_tm_stackpointer(tsk), sizeof(*frame), 1);
1453         if (unlikely(frame == NULL))
1454                 goto badframe;
1455         sc = (struct sigcontext __user *) &frame->sctx;
1456
1457 #if _NSIG != 64
1458 #error "Please adjust handle_signal()"
1459 #endif
1460         if (__put_user(to_user_ptr(ksig->ka.sa.sa_handler), &sc->handler)
1461             || __put_user(oldset->sig[0], &sc->oldmask)
1462 #ifdef CONFIG_PPC64
1463             || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1464 #else
1465             || __put_user(oldset->sig[1], &sc->_unused[3])
1466 #endif
1467             || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1468             || __put_user(ksig->sig, &sc->signal))
1469                 goto badframe;
1470
1471         if (vdso32_sigtramp && tsk->mm->context.vdso_base) {
1472                 sigret = 0;
1473                 tramp = tsk->mm->context.vdso_base + vdso32_sigtramp;
1474         } else {
1475                 sigret = __NR_sigreturn;
1476                 tramp = (unsigned long) frame->mctx.tramp;
1477         }
1478
1479 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1480         tm_mctx = &frame->mctx_transact;
1481         if (MSR_TM_ACTIVE(regs->msr)) {
1482                 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1483                                       sigret))
1484                         goto badframe;
1485         }
1486         else
1487 #endif
1488         {
1489                 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1490                         goto badframe;
1491         }
1492
1493         regs->link = tramp;
1494
1495         tsk->thread.fp_state.fpscr = 0; /* turn off all fp exceptions */
1496
1497         /* create a stack frame for the caller of the handler */
1498         newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1499         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1500                 goto badframe;
1501
1502         regs->gpr[1] = newsp;
1503         regs->gpr[3] = ksig->sig;
1504         regs->gpr[4] = (unsigned long) sc;
1505         regs->nip = (unsigned long) (unsigned long)ksig->ka.sa.sa_handler;
1506         /* enter the signal handler in big-endian mode */
1507         regs->msr &= ~MSR_LE;
1508         return 0;
1509
1510 badframe:
1511         if (show_unhandled_signals)
1512                 printk_ratelimited(KERN_INFO
1513                                    "%s[%d]: bad frame in handle_signal32: "
1514                                    "%p nip %08lx lr %08lx\n",
1515                                    tsk->comm, tsk->pid,
1516                                    frame, regs->nip, regs->link);
1517
1518         return 1;
1519 }
1520
1521 /*
1522  * Do a signal return; undo the signal stack.
1523  */
1524 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1525                        struct pt_regs *regs)
1526 {
1527         struct sigframe __user *sf;
1528         struct sigcontext __user *sc;
1529         struct sigcontext sigctx;
1530         struct mcontext __user *sr;
1531         void __user *addr;
1532         sigset_t set;
1533 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1534         struct mcontext __user *mcp, *tm_mcp;
1535         unsigned long msr_hi;
1536 #endif
1537
1538         /* Always make any pending restarted system calls return -EINTR */
1539         current->restart_block.fn = do_no_restart_syscall;
1540
1541         sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1542         sc = &sf->sctx;
1543         addr = sc;
1544         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1545                 goto badframe;
1546
1547 #ifdef CONFIG_PPC64
1548         /*
1549          * Note that PPC32 puts the upper 32 bits of the sigmask in the
1550          * unused part of the signal stackframe
1551          */
1552         set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1553 #else
1554         set.sig[0] = sigctx.oldmask;
1555         set.sig[1] = sigctx._unused[3];
1556 #endif
1557         set_current_blocked(&set);
1558
1559 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1560         mcp = (struct mcontext __user *)&sf->mctx;
1561         tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1562         if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1563                 goto badframe;
1564         if (MSR_TM_ACTIVE(msr_hi<<32)) {
1565                 if (!cpu_has_feature(CPU_FTR_TM))
1566                         goto badframe;
1567                 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1568                         goto badframe;
1569         } else
1570 #endif
1571         {
1572                 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1573                 addr = sr;
1574                 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1575                     || restore_user_regs(regs, sr, 1))
1576                         goto badframe;
1577         }
1578
1579         set_thread_flag(TIF_RESTOREALL);
1580         return 0;
1581
1582 badframe:
1583         if (show_unhandled_signals)
1584                 printk_ratelimited(KERN_INFO
1585                                    "%s[%d]: bad frame in sys_sigreturn: "
1586                                    "%p nip %08lx lr %08lx\n",
1587                                    current->comm, current->pid,
1588                                    addr, regs->nip, regs->link);
1589
1590         force_sig(SIGSEGV, current);
1591         return 0;
1592 }