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 #ifdef CONFIG_PPC64
  48 #include "ppc32.h"
  49 #include <asm/unistd.h>
  50 #else
  51 #include <asm/ucontext.h>
  52 #include <asm/pgtable.h>
  53 #endif
  54
  55 #include "signal.h"
  56
  57 #undef DEBUG_SIG
  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         double 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         memcpy(&buf[i], &task->thread.fpscr, sizeof(double));
 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         double 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         memcpy(&task->thread.fpscr, &buf[i], sizeof(double));
 289
 290         return 0;
 291 }
 292
 293 unsigned long copy_vsx_to_user(void __user *to,
 294                                struct task_struct *task)
 295 {
 296         double 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.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         double 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.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         double 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         memcpy(&buf[i], &task->thread.transact_fpscr, sizeof(double));
 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         double 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         memcpy(&task->thread.transact_fpscr, &buf[i], sizeof(double));
 343
 344         return 0;
 345 }
 346
 347 unsigned long copy_transact_vsx_to_user(void __user *to,
 348                                   struct task_struct *task)
 349 {
 350         double 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_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         double 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_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.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.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_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_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,
 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          */
 440         if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
 441                 return 1;
 442 #endif /* CONFIG_ALTIVEC */
 443         if (copy_fpr_to_user(&frame->mc_fregs, current))
 444                 return 1;
 445
 446         /*
 447          * Clear the MSR VSX bit to indicate there is no valid state attached
 448          * to this context, except in the specific case below where we set it.
 449          */
 450         msr &= ~MSR_VSX;
 451 #ifdef CONFIG_VSX
 452         /*
 453          * Copy VSR 0-31 upper half from thread_struct to local
 454          * buffer, then write that to userspace.  Also set MSR_VSX in
 455          * the saved MSR value to indicate that frame->mc_vregs
 456          * contains valid data
 457          */
 458         if (current->thread.used_vsr && ctx_has_vsx_region) {
 459                 __giveup_vsx(current);
 460                 if (copy_vsx_to_user(&frame->mc_vsregs, current))
 461                         return 1;
 462                 msr |= MSR_VSX;
 463         }
 464 #endif /* CONFIG_VSX */
 465 #ifdef CONFIG_SPE
 466         /* save spe registers */
 467         if (current->thread.used_spe) {
 468                 flush_spe_to_thread(current);
 469                 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
 470                                    ELF_NEVRREG * sizeof(u32)))
 471                         return 1;
 472                 /* set MSR_SPE in the saved MSR value to indicate that
 473                    frame->mc_vregs contains valid data */
 474                 msr |= MSR_SPE;
 475         }
 476         /* else assert((regs->msr & MSR_SPE) == 0) */
 477
 478         /* We always copy to/from spefscr */
 479         if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
 480                 return 1;
 481 #endif /* CONFIG_SPE */
 482
 483         if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
 484                 return 1;
 485         /* We need to write 0 the MSR top 32 bits in the tm frame so that we
 486          * can check it on the restore to see if TM is active
 487          */
 488         if (tm_frame && __put_user(0, &tm_frame->mc_gregs[PT_MSR]))
 489                 return 1;
 490
 491         if (sigret) {
 492                 /* Set up the sigreturn trampoline: li r0,sigret; sc */
 493                 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
 494                     || __put_user(0x44000002UL, &frame->tramp[1]))
 495                         return 1;
 496                 flush_icache_range((unsigned long) &frame->tramp[0],
 497                                    (unsigned long) &frame->tramp[2]);
 498         }
 499
 500         return 0;
 501 }
 502
 503 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 504 /*
 505  * Save the current user registers on the user stack.
 506  * We only save the altivec/spe registers if the process has used
 507  * altivec/spe instructions at some point.
 508  * We also save the transactional registers to a second ucontext in the
 509  * frame.
 510  *
 511  * See save_user_regs() and signal_64.c:setup_tm_sigcontexts().
 512  */
 513 static int save_tm_user_regs(struct pt_regs *regs,
 514                              struct mcontext __user *frame,
 515                              struct mcontext __user *tm_frame, int sigret)
 516 {
 517         unsigned long msr = regs->msr;
 518
 519         /* Make sure floating point registers are stored in regs */
 520         flush_fp_to_thread(current);
 521
 522         /* Save both sets of general registers */
 523         if (save_general_regs(&current->thread.ckpt_regs, frame)
 524             || save_general_regs(regs, tm_frame))
 525                 return 1;
 526
 527         /* Stash the top half of the 64bit MSR into the 32bit MSR word
 528          * of the transactional mcontext.  This way we have a backward-compatible
 529          * MSR in the 'normal' (checkpointed) mcontext and additionally one can
 530          * also look at what type of transaction (T or S) was active at the
 531          * time of the signal.
 532          */
 533         if (__put_user((msr >> 32), &tm_frame->mc_gregs[PT_MSR]))
 534                 return 1;
 535
 536 #ifdef CONFIG_ALTIVEC
 537         /* save altivec registers */
 538         if (current->thread.used_vr) {
 539                 flush_altivec_to_thread(current);
 540                 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
 541                                    ELF_NVRREG * sizeof(vector128)))
 542                         return 1;
 543                 if (msr & MSR_VEC) {
 544                         if (__copy_to_user(&tm_frame->mc_vregs,
 545                                            current->thread.transact_vr,
 546                                            ELF_NVRREG * sizeof(vector128)))
 547                                 return 1;
 548                 } else {
 549                         if (__copy_to_user(&tm_frame->mc_vregs,
 550                                            current->thread.vr,
 551                                            ELF_NVRREG * sizeof(vector128)))
 552                                 return 1;
 553                 }
 554
 555                 /* set MSR_VEC in the saved MSR value to indicate that
 556                  * frame->mc_vregs contains valid data
 557                  */
 558                 msr |= MSR_VEC;
 559         }
 560
 561         /* We always copy to/from vrsave, it's 0 if we don't have or don't
 562          * use altivec. Since VSCR only contains 32 bits saved in the least
 563          * significant bits of a vector, we "cheat" and stuff VRSAVE in the
 564          * most significant bits of that same vector. --BenH
 565          */
 566         if (__put_user(current->thread.vrsave,
 567                        (u32 __user *)&frame->mc_vregs[32]))
 568                 return 1;
 569         if (msr & MSR_VEC) {
 570                 if (__put_user(current->thread.transact_vrsave,
 571                                (u32 __user *)&tm_frame->mc_vregs[32]))
 572                         return 1;
 573         } else {
 574                 if (__put_user(current->thread.vrsave,
 575                                (u32 __user *)&tm_frame->mc_vregs[32]))
 576                         return 1;
 577         }
 578 #endif /* CONFIG_ALTIVEC */
 579
 580         if (copy_fpr_to_user(&frame->mc_fregs, current))
 581                 return 1;
 582         if (msr & MSR_FP) {
 583                 if (copy_transact_fpr_to_user(&tm_frame->mc_fregs, current))
 584                         return 1;
 585         } else {
 586                 if (copy_fpr_to_user(&tm_frame->mc_fregs, current))
 587                         return 1;
 588         }
 589
 590 #ifdef CONFIG_VSX
 591         /*
 592          * Copy VSR 0-31 upper half from thread_struct to local
 593          * buffer, then write that to userspace.  Also set MSR_VSX in
 594          * the saved MSR value to indicate that frame->mc_vregs
 595          * contains valid data
 596          */
 597         if (current->thread.used_vsr) {
 598                 __giveup_vsx(current);
 599                 if (copy_vsx_to_user(&frame->mc_vsregs, current))
 600                         return 1;
 601                 if (msr & MSR_VSX) {
 602                         if (copy_transact_vsx_to_user(&tm_frame->mc_vsregs,
 603                                                       current))
 604                                 return 1;
 605                 } else {
 606                         if (copy_vsx_to_user(&tm_frame->mc_vsregs, current))
 607                                 return 1;
 608                 }
 609
 610                 msr |= MSR_VSX;
 611         }
 612 #endif /* CONFIG_VSX */
 613 #ifdef CONFIG_SPE
 614         /* SPE regs are not checkpointed with TM, so this section is
 615          * simply the same as in save_user_regs().
 616          */
 617         if (current->thread.used_spe) {
 618                 flush_spe_to_thread(current);
 619                 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
 620                                    ELF_NEVRREG * sizeof(u32)))
 621                         return 1;
 622                 /* set MSR_SPE in the saved MSR value to indicate that
 623                  * frame->mc_vregs contains valid data */
 624                 msr |= MSR_SPE;
 625         }
 626
 627         /* We always copy to/from spefscr */
 628         if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
 629                 return 1;
 630 #endif /* CONFIG_SPE */
 631
 632         if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
 633                 return 1;
 634         if (sigret) {
 635                 /* Set up the sigreturn trampoline: li r0,sigret; sc */
 636                 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
 637                     || __put_user(0x44000002UL, &frame->tramp[1]))
 638                         return 1;
 639                 flush_icache_range((unsigned long) &frame->tramp[0],
 640                                    (unsigned long) &frame->tramp[2]);
 641         }
 642
 643         return 0;
 644 }
 645 #endif
 646
 647 /*
 648  * Restore the current user register values from the user stack,
 649  * (except for MSR).
 650  */
 651 static long restore_user_regs(struct pt_regs *regs,
 652                               struct mcontext __user *sr, int sig)
 653 {
 654         long err;
 655         unsigned int save_r2 = 0;
 656         unsigned long msr;
 657 #ifdef CONFIG_VSX
 658         int i;
 659 #endif
 660
 661         /*
 662          * restore general registers but not including MSR or SOFTE. Also
 663          * take care of keeping r2 (TLS) intact if not a signal
 664          */
 665         if (!sig)
 666                 save_r2 = (unsigned int)regs->gpr[2];
 667         err = restore_general_regs(regs, sr);
 668         regs->trap = 0;
 669         err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
 670         if (!sig)
 671                 regs->gpr[2] = (unsigned long) save_r2;
 672         if (err)
 673                 return 1;
 674
 675         /* if doing signal return, restore the previous little-endian mode */
 676         if (sig)
 677                 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
 678
 679         /*
 680          * Do this before updating the thread state in
 681          * current->thread.fpr/vr/evr.  That way, if we get preempted
 682          * and another task grabs the FPU/Altivec/SPE, it won't be
 683          * tempted to save the current CPU state into the thread_struct
 684          * and corrupt what we are writing there.
 685          */
 686         discard_lazy_cpu_state();
 687
 688 #ifdef CONFIG_ALTIVEC
 689         /*
 690          * Force the process to reload the altivec registers from
 691          * current->thread when it next does altivec instructions
 692          */
 693         regs->msr &= ~MSR_VEC;
 694         if (msr & MSR_VEC) {
 695                 /* restore altivec registers from the stack */
 696                 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
 697                                      sizeof(sr->mc_vregs)))
 698                         return 1;
 699         } else if (current->thread.used_vr)
 700                 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
 701
 702         /* Always get VRSAVE back */
 703         if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
 704                 return 1;
 705 #endif /* CONFIG_ALTIVEC */
 706         if (copy_fpr_from_user(current, &sr->mc_fregs))
 707                 return 1;
 708
 709 #ifdef CONFIG_VSX
 710         /*
 711          * Force the process to reload the VSX registers from
 712          * current->thread when it next does VSX instruction.
 713          */
 714         regs->msr &= ~MSR_VSX;
 715         if (msr & MSR_VSX) {
 716                 /*
 717                  * Restore altivec registers from the stack to a local
 718                  * buffer, then write this out to the thread_struct
 719                  */
 720                 if (copy_vsx_from_user(current, &sr->mc_vsregs))
 721                         return 1;
 722         } else if (current->thread.used_vsr)
 723                 for (i = 0; i < 32 ; i++)
 724                         current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
 725 #endif /* CONFIG_VSX */
 726         /*
 727          * force the process to reload the FP registers from
 728          * current->thread when it next does FP instructions
 729          */
 730         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
 731
 732 #ifdef CONFIG_SPE
 733         /* force the process to reload the spe registers from
 734            current->thread when it next does spe instructions */
 735         regs->msr &= ~MSR_SPE;
 736         if (msr & MSR_SPE) {
 737                 /* restore spe registers from the stack */
 738                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
 739                                      ELF_NEVRREG * sizeof(u32)))
 740                         return 1;
 741         } else if (current->thread.used_spe)
 742                 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
 743
 744         /* Always get SPEFSCR back */
 745         if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
 746                 return 1;
 747 #endif /* CONFIG_SPE */
 748
 749         return 0;
 750 }
 751
 752 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
 753 /*
 754  * Restore the current user register values from the user stack, except for
 755  * MSR, and recheckpoint the original checkpointed register state for processes
 756  * in transactions.
 757  */
 758 static long restore_tm_user_regs(struct pt_regs *regs,
 759                                  struct mcontext __user *sr,
 760                                  struct mcontext __user *tm_sr)
 761 {
 762         long err;
 763         unsigned long msr, msr_hi;
 764 #ifdef CONFIG_VSX
 765         int i;
 766 #endif
 767
 768         /*
 769          * restore general registers but not including MSR or SOFTE. Also
 770          * take care of keeping r2 (TLS) intact if not a signal.
 771          * See comment in signal_64.c:restore_tm_sigcontexts();
 772          * TFHAR is restored from the checkpointed NIP; TEXASR and TFIAR
 773          * were set by the signal delivery.
 774          */
 775         err = restore_general_regs(regs, tm_sr);
 776         err |= restore_general_regs(&current->thread.ckpt_regs, sr);
 777
 778         err |= __get_user(current->thread.tm_tfhar, &sr->mc_gregs[PT_NIP]);
 779
 780         err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
 781         if (err)
 782                 return 1;
 783
 784         /* Restore the previous little-endian mode */
 785         regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
 786
 787         /*
 788          * Do this before updating the thread state in
 789          * current->thread.fpr/vr/evr.  That way, if we get preempted
 790          * and another task grabs the FPU/Altivec/SPE, it won't be
 791          * tempted to save the current CPU state into the thread_struct
 792          * and corrupt what we are writing there.
 793          */
 794         discard_lazy_cpu_state();
 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, &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         } else if (current->thread.used_vr) {
 807                 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
 808                 memset(current->thread.transact_vr, 0,
 809                        ELF_NVRREG * sizeof(vector128));
 810         }
 811
 812         /* Always get VRSAVE back */
 813         if (__get_user(current->thread.vrsave,
 814                        (u32 __user *)&sr->mc_vregs[32]) ||
 815             __get_user(current->thread.transact_vrsave,
 816                        (u32 __user *)&tm_sr->mc_vregs[32]))
 817                 return 1;
 818 #endif /* CONFIG_ALTIVEC */
 819
 820         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
 821
 822         if (copy_fpr_from_user(current, &sr->mc_fregs) ||
 823             copy_transact_fpr_from_user(current, &tm_sr->mc_fregs))
 824                 return 1;
 825
 826 #ifdef CONFIG_VSX
 827         regs->msr &= ~MSR_VSX;
 828         if (msr & MSR_VSX) {
 829                 /*
 830                  * Restore altivec registers from the stack to a local
 831                  * buffer, then write this out to the thread_struct
 832                  */
 833                 if (copy_vsx_from_user(current, &sr->mc_vsregs) ||
 834                     copy_transact_vsx_from_user(current, &tm_sr->mc_vsregs))
 835                         return 1;
 836         } else if (current->thread.used_vsr)
 837                 for (i = 0; i < 32 ; i++) {
 838                         current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
 839                         current->thread.transact_fpr[i][TS_VSRLOWOFFSET] = 0;
 840                 }
 841 #endif /* CONFIG_VSX */
 842
 843 #ifdef CONFIG_SPE
 844         /* SPE regs are not checkpointed with TM, so this section is
 845          * simply the same as in restore_user_regs().
 846          */
 847         regs->msr &= ~MSR_SPE;
 848         if (msr & MSR_SPE) {
 849                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
 850                                      ELF_NEVRREG * sizeof(u32)))
 851                         return 1;
 852         } else if (current->thread.used_spe)
 853                 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
 854
 855         /* Always get SPEFSCR back */
 856         if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs
 857                        + ELF_NEVRREG))
 858                 return 1;
 859 #endif /* CONFIG_SPE */
 860
 861         /* Now, recheckpoint.  This loads up all of the checkpointed (older)
 862          * registers, including FP and V[S]Rs.  After recheckpointing, the
 863          * transactional versions should be loaded.
 864          */
 865         tm_enable();
 866         /* Make sure the transaction is marked as failed */
 867         current->thread.tm_texasr |= TEXASR_FS;
 868         /* This loads the checkpointed FP/VEC state, if used */
 869         tm_recheckpoint(&current->thread, msr);
 870         /* Get the top half of the MSR */
 871         if (__get_user(msr_hi, &tm_sr->mc_gregs[PT_MSR]))
 872                 return 1;
 873         /* Pull in MSR TM from user context */
 874         regs->msr = (regs->msr & ~MSR_TS_MASK) | ((msr_hi<<32) & MSR_TS_MASK);
 875
 876         /* This loads the speculative FP/VEC state, if used */
 877         if (msr & MSR_FP) {
 878                 do_load_up_transact_fpu(&current->thread);
 879                 regs->msr |= (MSR_FP | current->thread.fpexc_mode);
 880         }
 881 #ifdef CONFIG_ALTIVEC
 882         if (msr & MSR_VEC) {
 883                 do_load_up_transact_altivec(&current->thread);
 884                 regs->msr |= MSR_VEC;
 885         }
 886 #endif
 887
 888         return 0;
 889 }
 890 #endif
 891
 892 #ifdef CONFIG_PPC64
 893 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
 894 {
 895         int err;
 896
 897         if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
 898                 return -EFAULT;
 899
 900         /* If you change siginfo_t structure, please be sure
 901          * this code is fixed accordingly.
 902          * It should never copy any pad contained in the structure
 903          * to avoid security leaks, but must copy the generic
 904          * 3 ints plus the relevant union member.
 905          * This routine must convert siginfo from 64bit to 32bit as well
 906          * at the same time.
 907          */
 908         err = __put_user(s->si_signo, &d->si_signo);
 909         err |= __put_user(s->si_errno, &d->si_errno);
 910         err |= __put_user((short)s->si_code, &d->si_code);
 911         if (s->si_code < 0)
 912                 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
 913                                       SI_PAD_SIZE32);
 914         else switch(s->si_code >> 16) {
 915         case __SI_CHLD >> 16:
 916                 err |= __put_user(s->si_pid, &d->si_pid);
 917                 err |= __put_user(s->si_uid, &d->si_uid);
 918                 err |= __put_user(s->si_utime, &d->si_utime);
 919                 err |= __put_user(s->si_stime, &d->si_stime);
 920                 err |= __put_user(s->si_status, &d->si_status);
 921                 break;
 922         case __SI_FAULT >> 16:
 923                 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
 924                                   &d->si_addr);
 925                 break;
 926         case __SI_POLL >> 16:
 927                 err |= __put_user(s->si_band, &d->si_band);
 928                 err |= __put_user(s->si_fd, &d->si_fd);
 929                 break;
 930         case __SI_TIMER >> 16:
 931                 err |= __put_user(s->si_tid, &d->si_tid);
 932                 err |= __put_user(s->si_overrun, &d->si_overrun);
 933                 err |= __put_user(s->si_int, &d->si_int);
 934                 break;
 935         case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 936         case __SI_MESGQ >> 16:
 937                 err |= __put_user(s->si_int, &d->si_int);
 938                 /* fallthrough */
 939         case __SI_KILL >> 16:
 940         default:
 941                 err |= __put_user(s->si_pid, &d->si_pid);
 942                 err |= __put_user(s->si_uid, &d->si_uid);
 943                 break;
 944         }
 945         return err;
 946 }
 947
 948 #define copy_siginfo_to_user    copy_siginfo_to_user32
 949
 950 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
 951 {
 952         memset(to, 0, sizeof *to);
 953
 954         if (copy_from_user(to, from, 3*sizeof(int)) ||
 955             copy_from_user(to->_sifields._pad,
 956                            from->_sifields._pad, SI_PAD_SIZE32))
 957                 return -EFAULT;
 958
 959         return 0;
 960 }
 961 #endif /* CONFIG_PPC64 */
 962
 963 /*
 964  * Set up a signal frame for a "real-time" signal handler
 965  * (one which gets siginfo).
 966  */
 967 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
 968                 siginfo_t *info, sigset_t *oldset,
 969                 struct pt_regs *regs)
 970 {
 971         struct rt_sigframe __user *rt_sf;
 972         struct mcontext __user *frame;
 973         struct mcontext __user *tm_frame = NULL;
 974         void __user *addr;
 975         unsigned long newsp = 0;
 976         int sigret;
 977         unsigned long tramp;
 978
 979         /* Set up Signal Frame */
 980         /* Put a Real Time Context onto stack */
 981         rt_sf = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*rt_sf), 1);
 982         addr = rt_sf;
 983         if (unlikely(rt_sf == NULL))
 984                 goto badframe;
 985
 986         /* Put the siginfo & fill in most of the ucontext */
 987         if (copy_siginfo_to_user(&rt_sf->info, info)
 988             || __put_user(0, &rt_sf->uc.uc_flags)
 989             || __save_altstack(&rt_sf->uc.uc_stack, regs->gpr[1])
 990             || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
 991                     &rt_sf->uc.uc_regs)
 992             || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
 993                 goto badframe;
 994
 995         /* Save user registers on the stack */
 996         frame = &rt_sf->uc.uc_mcontext;
 997         addr = frame;
 998         if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
 999                 sigret = 0;
1000                 tramp = current->mm->context.vdso_base + vdso32_rt_sigtramp;
1001         } else {
1002                 sigret = __NR_rt_sigreturn;
1003                 tramp = (unsigned long) frame->tramp;
1004         }
1005
1006 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1007         tm_frame = &rt_sf->uc_transact.uc_mcontext;
1008         if (MSR_TM_ACTIVE(regs->msr)) {
1009                 if (save_tm_user_regs(regs, frame, tm_frame, sigret))
1010                         goto badframe;
1011         }
1012         else
1013 #endif
1014         {
1015                 if (save_user_regs(regs, frame, tm_frame, sigret, 1))
1016                         goto badframe;
1017         }
1018         regs->link = tramp;
1019
1020 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1021         if (MSR_TM_ACTIVE(regs->msr)) {
1022                 if (__put_user((unsigned long)&rt_sf->uc_transact,
1023                                &rt_sf->uc.uc_link)
1024                     || __put_user((unsigned long)tm_frame, &rt_sf->uc_transact.uc_regs))
1025                         goto badframe;
1026         }
1027         else
1028 #endif
1029                 if (__put_user(0, &rt_sf->uc.uc_link))
1030                         goto badframe;
1031
1032         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
1033
1034         /* create a stack frame for the caller of the handler */
1035         newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
1036         addr = (void __user *)regs->gpr[1];
1037         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1038                 goto badframe;
1039
1040         /* Fill registers for signal handler */
1041         regs->gpr[1] = newsp;
1042         regs->gpr[3] = sig;
1043         regs->gpr[4] = (unsigned long) &rt_sf->info;
1044         regs->gpr[5] = (unsigned long) &rt_sf->uc;
1045         regs->gpr[6] = (unsigned long) rt_sf;
1046         regs->nip = (unsigned long) ka->sa.sa_handler;
1047         /* enter the signal handler in big-endian mode */
1048         regs->msr &= ~MSR_LE;
1049 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1050         /* Remove TM bits from thread's MSR.  The MSR in the sigcontext
1051          * just indicates to userland that we were doing a transaction, but we
1052          * don't want to return in transactional state:
1053          */
1054         regs->msr &= ~MSR_TS_MASK;
1055 #endif
1056         return 1;
1057
1058 badframe:
1059 #ifdef DEBUG_SIG
1060         printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
1061                regs, frame, newsp);
1062 #endif
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                                    current->comm, current->pid,
1068                                    addr, regs->nip, regs->link);
1069
1070         force_sigsegv(sig, current);
1071         return 0;
1072 }
1073
1074 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
1075 {
1076         sigset_t set;
1077         struct mcontext __user *mcp;
1078
1079         if (get_sigset_t(&set, &ucp->uc_sigmask))
1080                 return -EFAULT;
1081 #ifdef CONFIG_PPC64
1082         {
1083                 u32 cmcp;
1084
1085                 if (__get_user(cmcp, &ucp->uc_regs))
1086                         return -EFAULT;
1087                 mcp = (struct mcontext __user *)(u64)cmcp;
1088                 /* no need to check access_ok(mcp), since mcp < 4GB */
1089         }
1090 #else
1091         if (__get_user(mcp, &ucp->uc_regs))
1092                 return -EFAULT;
1093         if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
1094                 return -EFAULT;
1095 #endif
1096         set_current_blocked(&set);
1097         if (restore_user_regs(regs, mcp, sig))
1098                 return -EFAULT;
1099
1100         return 0;
1101 }
1102
1103 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1104 static int do_setcontext_tm(struct ucontext __user *ucp,
1105                             struct ucontext __user *tm_ucp,
1106                             struct pt_regs *regs)
1107 {
1108         sigset_t set;
1109         struct mcontext __user *mcp;
1110         struct mcontext __user *tm_mcp;
1111         u32 cmcp;
1112         u32 tm_cmcp;
1113
1114         if (get_sigset_t(&set, &ucp->uc_sigmask))
1115                 return -EFAULT;
1116
1117         if (__get_user(cmcp, &ucp->uc_regs) ||
1118             __get_user(tm_cmcp, &tm_ucp->uc_regs))
1119                 return -EFAULT;
1120         mcp = (struct mcontext __user *)(u64)cmcp;
1121         tm_mcp = (struct mcontext __user *)(u64)tm_cmcp;
1122         /* no need to check access_ok(mcp), since mcp < 4GB */
1123
1124         set_current_blocked(&set);
1125         if (restore_tm_user_regs(regs, mcp, tm_mcp))
1126                 return -EFAULT;
1127
1128         return 0;
1129 }
1130 #endif
1131
1132 long sys_swapcontext(struct ucontext __user *old_ctx,
1133                      struct ucontext __user *new_ctx,
1134                      int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
1135 {
1136         unsigned char tmp;
1137         int ctx_has_vsx_region = 0;
1138
1139 #ifdef CONFIG_PPC64
1140         unsigned long new_msr = 0;
1141
1142         if (new_ctx) {
1143                 struct mcontext __user *mcp;
1144                 u32 cmcp;
1145
1146                 /*
1147                  * Get pointer to the real mcontext.  No need for
1148                  * access_ok since we are dealing with compat
1149                  * pointers.
1150                  */
1151                 if (__get_user(cmcp, &new_ctx->uc_regs))
1152                         return -EFAULT;
1153                 mcp = (struct mcontext __user *)(u64)cmcp;
1154                 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
1155                         return -EFAULT;
1156         }
1157         /*
1158          * Check that the context is not smaller than the original
1159          * size (with VMX but without VSX)
1160          */
1161         if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
1162                 return -EINVAL;
1163         /*
1164          * If the new context state sets the MSR VSX bits but
1165          * it doesn't provide VSX state.
1166          */
1167         if ((ctx_size < sizeof(struct ucontext)) &&
1168             (new_msr & MSR_VSX))
1169                 return -EINVAL;
1170         /* Does the context have enough room to store VSX data? */
1171         if (ctx_size >= sizeof(struct ucontext))
1172                 ctx_has_vsx_region = 1;
1173 #else
1174         /* Context size is for future use. Right now, we only make sure
1175          * we are passed something we understand
1176          */
1177         if (ctx_size < sizeof(struct ucontext))
1178                 return -EINVAL;
1179 #endif
1180         if (old_ctx != NULL) {
1181                 struct mcontext __user *mctx;
1182
1183                 /*
1184                  * old_ctx might not be 16-byte aligned, in which
1185                  * case old_ctx->uc_mcontext won't be either.
1186                  * Because we have the old_ctx->uc_pad2 field
1187                  * before old_ctx->uc_mcontext, we need to round down
1188                  * from &old_ctx->uc_mcontext to a 16-byte boundary.
1189                  */
1190                 mctx = (struct mcontext __user *)
1191                         ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
1192                 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
1193                     || save_user_regs(regs, mctx, NULL, 0, ctx_has_vsx_region)
1194                     || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
1195                     || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1196                         return -EFAULT;
1197         }
1198         if (new_ctx == NULL)
1199                 return 0;
1200         if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1201             || __get_user(tmp, (u8 __user *) new_ctx)
1202             || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1203                 return -EFAULT;
1204
1205         /*
1206          * If we get a fault copying the context into the kernel's
1207          * image of the user's registers, we can't just return -EFAULT
1208          * because the user's registers will be corrupted.  For instance
1209          * the NIP value may have been updated but not some of the
1210          * other registers.  Given that we have done the access_ok
1211          * and successfully read the first and last bytes of the region
1212          * above, this should only happen in an out-of-memory situation
1213          * or if another thread unmaps the region containing the context.
1214          * We kill the task with a SIGSEGV in this situation.
1215          */
1216         if (do_setcontext(new_ctx, regs, 0))
1217                 do_exit(SIGSEGV);
1218
1219         set_thread_flag(TIF_RESTOREALL);
1220         return 0;
1221 }
1222
1223 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1224                      struct pt_regs *regs)
1225 {
1226         struct rt_sigframe __user *rt_sf;
1227 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1228         struct ucontext __user *uc_transact;
1229         unsigned long msr_hi;
1230         unsigned long tmp;
1231         int tm_restore = 0;
1232 #endif
1233         /* Always make any pending restarted system calls return -EINTR */
1234         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1235
1236         rt_sf = (struct rt_sigframe __user *)
1237                 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1238         if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1239                 goto bad;
1240 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1241         if (__get_user(tmp, &rt_sf->uc.uc_link))
1242                 goto bad;
1243         uc_transact = (struct ucontext __user *)(uintptr_t)tmp;
1244         if (uc_transact) {
1245                 u32 cmcp;
1246                 struct mcontext __user *mcp;
1247
1248                 if (__get_user(cmcp, &uc_transact->uc_regs))
1249                         return -EFAULT;
1250                 mcp = (struct mcontext __user *)(u64)cmcp;
1251                 /* The top 32 bits of the MSR are stashed in the transactional
1252                  * ucontext. */
1253                 if (__get_user(msr_hi, &mcp->mc_gregs[PT_MSR]))
1254                         goto bad;
1255
1256                 if (MSR_TM_ACTIVE(msr_hi<<32)) {
1257                         /* We only recheckpoint on return if we're
1258                          * transaction.
1259                          */
1260                         tm_restore = 1;
1261                         if (do_setcontext_tm(&rt_sf->uc, uc_transact, regs))
1262                                 goto bad;
1263                 }
1264         }
1265         if (!tm_restore)
1266                 /* Fall through, for non-TM restore */
1267 #endif
1268         if (do_setcontext(&rt_sf->uc, regs, 1))
1269                 goto bad;
1270
1271         /*
1272          * It's not clear whether or why it is desirable to save the
1273          * sigaltstack setting on signal delivery and restore it on
1274          * signal return.  But other architectures do this and we have
1275          * always done it up until now so it is probably better not to
1276          * change it.  -- paulus
1277          */
1278 #ifdef CONFIG_PPC64
1279         if (compat_restore_altstack(&rt_sf->uc.uc_stack))
1280                 goto bad;
1281 #else
1282         if (restore_altstack(&rt_sf->uc.uc_stack))
1283                 goto bad;
1284 #endif
1285         set_thread_flag(TIF_RESTOREALL);
1286         return 0;
1287
1288  bad:
1289         if (show_unhandled_signals)
1290                 printk_ratelimited(KERN_INFO
1291                                    "%s[%d]: bad frame in sys_rt_sigreturn: "
1292                                    "%p nip %08lx lr %08lx\n",
1293                                    current->comm, current->pid,
1294                                    rt_sf, regs->nip, regs->link);
1295
1296         force_sig(SIGSEGV, current);
1297         return 0;
1298 }
1299
1300 #ifdef CONFIG_PPC32
1301 int sys_debug_setcontext(struct ucontext __user *ctx,
1302                          int ndbg, struct sig_dbg_op __user *dbg,
1303                          int r6, int r7, int r8,
1304                          struct pt_regs *regs)
1305 {
1306         struct sig_dbg_op op;
1307         int i;
1308         unsigned char tmp;
1309         unsigned long new_msr = regs->msr;
1310 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1311         unsigned long new_dbcr0 = current->thread.dbcr0;
1312 #endif
1313
1314         for (i=0; i<ndbg; i++) {
1315                 if (copy_from_user(&op, dbg + i, sizeof(op)))
1316                         return -EFAULT;
1317                 switch (op.dbg_type) {
1318                 case SIG_DBG_SINGLE_STEPPING:
1319 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1320                         if (op.dbg_value) {
1321                                 new_msr |= MSR_DE;
1322                                 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1323                         } else {
1324                                 new_dbcr0 &= ~DBCR0_IC;
1325                                 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1326                                                 current->thread.dbcr1)) {
1327                                         new_msr &= ~MSR_DE;
1328                                         new_dbcr0 &= ~DBCR0_IDM;
1329                                 }
1330                         }
1331 #else
1332                         if (op.dbg_value)
1333                                 new_msr |= MSR_SE;
1334                         else
1335                                 new_msr &= ~MSR_SE;
1336 #endif
1337                         break;
1338                 case SIG_DBG_BRANCH_TRACING:
1339 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1340                         return -EINVAL;
1341 #else
1342                         if (op.dbg_value)
1343                                 new_msr |= MSR_BE;
1344                         else
1345                                 new_msr &= ~MSR_BE;
1346 #endif
1347                         break;
1348
1349                 default:
1350                         return -EINVAL;
1351                 }
1352         }
1353
1354         /* We wait until here to actually install the values in the
1355            registers so if we fail in the above loop, it will not
1356            affect the contents of these registers.  After this point,
1357            failure is a problem, anyway, and it's very unlikely unless
1358            the user is really doing something wrong. */
1359         regs->msr = new_msr;
1360 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1361         current->thread.dbcr0 = new_dbcr0;
1362 #endif
1363
1364         if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1365             || __get_user(tmp, (u8 __user *) ctx)
1366             || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1367                 return -EFAULT;
1368
1369         /*
1370          * If we get a fault copying the context into the kernel's
1371          * image of the user's registers, we can't just return -EFAULT
1372          * because the user's registers will be corrupted.  For instance
1373          * the NIP value may have been updated but not some of the
1374          * other registers.  Given that we have done the access_ok
1375          * and successfully read the first and last bytes of the region
1376          * above, this should only happen in an out-of-memory situation
1377          * or if another thread unmaps the region containing the context.
1378          * We kill the task with a SIGSEGV in this situation.
1379          */
1380         if (do_setcontext(ctx, regs, 1)) {
1381                 if (show_unhandled_signals)
1382                         printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1383                                            "sys_debug_setcontext: %p nip %08lx "
1384                                            "lr %08lx\n",
1385                                            current->comm, current->pid,
1386                                            ctx, regs->nip, regs->link);
1387
1388                 force_sig(SIGSEGV, current);
1389                 goto out;
1390         }
1391
1392         /*
1393          * It's not clear whether or why it is desirable to save the
1394          * sigaltstack setting on signal delivery and restore it on
1395          * signal return.  But other architectures do this and we have
1396          * always done it up until now so it is probably better not to
1397          * change it.  -- paulus
1398          */
1399         restore_altstack(&ctx->uc_stack);
1400
1401         set_thread_flag(TIF_RESTOREALL);
1402  out:
1403         return 0;
1404 }
1405 #endif
1406
1407 /*
1408  * OK, we're invoking a handler
1409  */
1410 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1411                     siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1412 {
1413         struct sigcontext __user *sc;
1414         struct sigframe __user *frame;
1415         struct mcontext __user *tm_mctx = NULL;
1416         unsigned long newsp = 0;
1417         int sigret;
1418         unsigned long tramp;
1419
1420         /* Set up Signal Frame */
1421         frame = get_sigframe(ka, get_tm_stackpointer(regs), sizeof(*frame), 1);
1422         if (unlikely(frame == NULL))
1423                 goto badframe;
1424         sc = (struct sigcontext __user *) &frame->sctx;
1425
1426 #if _NSIG != 64
1427 #error "Please adjust handle_signal()"
1428 #endif
1429         if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1430             || __put_user(oldset->sig[0], &sc->oldmask)
1431 #ifdef CONFIG_PPC64
1432             || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1433 #else
1434             || __put_user(oldset->sig[1], &sc->_unused[3])
1435 #endif
1436             || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1437             || __put_user(sig, &sc->signal))
1438                 goto badframe;
1439
1440         if (vdso32_sigtramp && current->mm->context.vdso_base) {
1441                 sigret = 0;
1442                 tramp = current->mm->context.vdso_base + vdso32_sigtramp;
1443         } else {
1444                 sigret = __NR_sigreturn;
1445                 tramp = (unsigned long) frame->mctx.tramp;
1446         }
1447
1448 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1449         tm_mctx = &frame->mctx_transact;
1450         if (MSR_TM_ACTIVE(regs->msr)) {
1451                 if (save_tm_user_regs(regs, &frame->mctx, &frame->mctx_transact,
1452                                       sigret))
1453                         goto badframe;
1454         }
1455         else
1456 #endif
1457         {
1458                 if (save_user_regs(regs, &frame->mctx, tm_mctx, sigret, 1))
1459                         goto badframe;
1460         }
1461
1462         regs->link = tramp;
1463
1464         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
1465
1466         /* create a stack frame for the caller of the handler */
1467         newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1468         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1469                 goto badframe;
1470
1471         regs->gpr[1] = newsp;
1472         regs->gpr[3] = sig;
1473         regs->gpr[4] = (unsigned long) sc;
1474         regs->nip = (unsigned long) ka->sa.sa_handler;
1475         /* enter the signal handler in big-endian mode */
1476         regs->msr &= ~MSR_LE;
1477 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1478         /* Remove TM bits from thread's MSR.  The MSR in the sigcontext
1479          * just indicates to userland that we were doing a transaction, but we
1480          * don't want to return in transactional state:
1481          */
1482         regs->msr &= ~MSR_TS_MASK;
1483 #endif
1484         return 1;
1485
1486 badframe:
1487 #ifdef DEBUG_SIG
1488         printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1489                regs, frame, newsp);
1490 #endif
1491         if (show_unhandled_signals)
1492                 printk_ratelimited(KERN_INFO
1493                                    "%s[%d]: bad frame in handle_signal32: "
1494                                    "%p nip %08lx lr %08lx\n",
1495                                    current->comm, current->pid,
1496                                    frame, regs->nip, regs->link);
1497
1498         force_sigsegv(sig, current);
1499         return 0;
1500 }
1501
1502 /*
1503  * Do a signal return; undo the signal stack.
1504  */
1505 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1506                        struct pt_regs *regs)
1507 {
1508         struct sigframe __user *sf;
1509         struct sigcontext __user *sc;
1510         struct sigcontext sigctx;
1511         struct mcontext __user *sr;
1512         void __user *addr;
1513         sigset_t set;
1514 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1515         struct mcontext __user *mcp, *tm_mcp;
1516         unsigned long msr_hi;
1517 #endif
1518
1519         /* Always make any pending restarted system calls return -EINTR */
1520         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1521
1522         sf = (struct sigframe __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1523         sc = &sf->sctx;
1524         addr = sc;
1525         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1526                 goto badframe;
1527
1528 #ifdef CONFIG_PPC64
1529         /*
1530          * Note that PPC32 puts the upper 32 bits of the sigmask in the
1531          * unused part of the signal stackframe
1532          */
1533         set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1534 #else
1535         set.sig[0] = sigctx.oldmask;
1536         set.sig[1] = sigctx._unused[3];
1537 #endif
1538         set_current_blocked(&set);
1539
1540 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
1541         mcp = (struct mcontext __user *)&sf->mctx;
1542         tm_mcp = (struct mcontext __user *)&sf->mctx_transact;
1543         if (__get_user(msr_hi, &tm_mcp->mc_gregs[PT_MSR]))
1544                 goto badframe;
1545         if (MSR_TM_ACTIVE(msr_hi<<32)) {
1546                 if (!cpu_has_feature(CPU_FTR_TM))
1547                         goto badframe;
1548                 if (restore_tm_user_regs(regs, mcp, tm_mcp))
1549                         goto badframe;
1550         } else
1551 #endif
1552         {
1553                 sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1554                 addr = sr;
1555                 if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1556                     || restore_user_regs(regs, sr, 1))
1557                         goto badframe;
1558         }
1559
1560         set_thread_flag(TIF_RESTOREALL);
1561         return 0;
1562
1563 badframe:
1564         if (show_unhandled_signals)
1565                 printk_ratelimited(KERN_INFO
1566                                    "%s[%d]: bad frame in sys_sigreturn: "
1567                                    "%p nip %08lx lr %08lx\n",
1568                                    current->comm, current->pid,
1569                                    addr, regs->nip, regs->link);
1570
1571         force_sig(SIGSEGV, current);
1572         return 0;
1573 }