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