arch/powerpc/kernel/signal_32.c

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