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