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