arch/powerpc/kernel/signal_32.c

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