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