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