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