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