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