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 #include <linux/freezer.h>
  39 #endif
  40
  41 #include <asm/uaccess.h>
  42 #include <asm/cacheflush.h>
  43 #include <asm/syscalls.h>
  44 #include <asm/sigcontext.h>
  45 #include <asm/vdso.h>
  46 #ifdef CONFIG_PPC64
  47 #include "ppc32.h"
  48 #include <asm/unistd.h>
  49 #else
  50 #include <asm/ucontext.h>
  51 #include <asm/pgtable.h>
  52 #endif
  53
  54 #include "signal.h"
  55
  56 #undef DEBUG_SIG
  57
  58 #ifdef CONFIG_PPC64
  59 #define sys_sigsuspend  compat_sys_sigsuspend
  60 #define sys_rt_sigsuspend       compat_sys_rt_sigsuspend
  61 #define sys_rt_sigreturn        compat_sys_rt_sigreturn
  62 #define sys_sigaction   compat_sys_sigaction
  63 #define sys_swapcontext compat_sys_swapcontext
  64 #define sys_sigreturn   compat_sys_sigreturn
  65
  66 #define old_sigaction   old_sigaction32
  67 #define sigcontext      sigcontext32
  68 #define mcontext        mcontext32
  69 #define ucontext        ucontext32
  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 static inline int get_old_sigaction(struct k_sigaction *new_ka,
 134                 struct old_sigaction __user *act)
 135 {
 136         compat_old_sigset_t mask;
 137         compat_uptr_t handler, restorer;
 138
 139         if (get_user(handler, &act->sa_handler) ||
 140             __get_user(restorer, &act->sa_restorer) ||
 141             __get_user(new_ka->sa.sa_flags, &act->sa_flags) ||
 142             __get_user(mask, &act->sa_mask))
 143                 return -EFAULT;
 144         new_ka->sa.sa_handler = compat_ptr(handler);
 145         new_ka->sa.sa_restorer = compat_ptr(restorer);
 146         siginitset(&new_ka->sa.sa_mask, mask);
 147         return 0;
 148 }
 149
 150 #define to_user_ptr(p)          ptr_to_compat(p)
 151 #define from_user_ptr(p)        compat_ptr(p)
 152
 153 static inline int save_general_regs(struct pt_regs *regs,
 154                 struct mcontext __user *frame)
 155 {
 156         elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
 157         int i;
 158
 159         WARN_ON(!FULL_REGS(regs));
 160
 161         for (i = 0; i <= PT_RESULT; i ++) {
 162                 if (i == 14 && !FULL_REGS(regs))
 163                         i = 32;
 164                 if (__put_user((unsigned int)gregs[i], &frame->mc_gregs[i]))
 165                         return -EFAULT;
 166         }
 167         return 0;
 168 }
 169
 170 static inline int restore_general_regs(struct pt_regs *regs,
 171                 struct mcontext __user *sr)
 172 {
 173         elf_greg_t64 *gregs = (elf_greg_t64 *)regs;
 174         int i;
 175
 176         for (i = 0; i <= PT_RESULT; i++) {
 177                 if ((i == PT_MSR) || (i == PT_SOFTE))
 178                         continue;
 179                 if (__get_user(gregs[i], &sr->mc_gregs[i]))
 180                         return -EFAULT;
 181         }
 182         return 0;
 183 }
 184
 185 #else /* CONFIG_PPC64 */
 186
 187 #define GP_REGS_SIZE    min(sizeof(elf_gregset_t), sizeof(struct pt_regs))
 188
 189 static inline int put_sigset_t(sigset_t __user *uset, sigset_t *set)
 190 {
 191         return copy_to_user(uset, set, sizeof(*uset));
 192 }
 193
 194 static inline int get_sigset_t(sigset_t *set, const sigset_t __user *uset)
 195 {
 196         return copy_from_user(set, uset, sizeof(*uset));
 197 }
 198
 199 static inline int get_old_sigaction(struct k_sigaction *new_ka,
 200                 struct old_sigaction __user *act)
 201 {
 202         old_sigset_t mask;
 203
 204         if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 205                         __get_user(new_ka->sa.sa_handler, &act->sa_handler) ||
 206                         __get_user(new_ka->sa.sa_restorer, &act->sa_restorer))
 207                 return -EFAULT;
 208         __get_user(new_ka->sa.sa_flags, &act->sa_flags);
 209         __get_user(mask, &act->sa_mask);
 210         siginitset(&new_ka->sa.sa_mask, mask);
 211         return 0;
 212 }
 213
 214 #define to_user_ptr(p)          ((unsigned long)(p))
 215 #define from_user_ptr(p)        ((void __user *)(p))
 216
 217 static inline int save_general_regs(struct pt_regs *regs,
 218                 struct mcontext __user *frame)
 219 {
 220         WARN_ON(!FULL_REGS(regs));
 221         return __copy_to_user(&frame->mc_gregs, regs, GP_REGS_SIZE);
 222 }
 223
 224 static inline int restore_general_regs(struct pt_regs *regs,
 225                 struct mcontext __user *sr)
 226 {
 227         /* copy up to but not including MSR */
 228         if (__copy_from_user(regs, &sr->mc_gregs,
 229                                 PT_MSR * sizeof(elf_greg_t)))
 230                 return -EFAULT;
 231         /* copy from orig_r3 (the word after the MSR) up to the end */
 232         if (__copy_from_user(&regs->orig_gpr3, &sr->mc_gregs[PT_ORIG_R3],
 233                                 GP_REGS_SIZE - PT_ORIG_R3 * sizeof(elf_greg_t)))
 234                 return -EFAULT;
 235         return 0;
 236 }
 237
 238 #endif /* CONFIG_PPC64 */
 239
 240 /*
 241  * Atomically swap in the new signal mask, and wait for a signal.
 242  */
 243 long sys_sigsuspend(old_sigset_t mask)
 244 {
 245         sigset_t blocked;
 246
 247         current->saved_sigmask = current->blocked;
 248
 249         mask &= _BLOCKABLE;
 250         siginitset(&blocked, mask);
 251         set_current_blocked(&blocked);
 252
 253         current->state = TASK_INTERRUPTIBLE;
 254         schedule();
 255         set_restore_sigmask();
 256         return -ERESTARTNOHAND;
 257 }
 258
 259 long sys_sigaction(int sig, struct old_sigaction __user *act,
 260                 struct old_sigaction __user *oact)
 261 {
 262         struct k_sigaction new_ka, old_ka;
 263         int ret;
 264
 265 #ifdef CONFIG_PPC64
 266         if (sig < 0)
 267                 sig = -sig;
 268 #endif
 269
 270         if (act) {
 271                 if (get_old_sigaction(&new_ka, act))
 272                         return -EFAULT;
 273         }
 274
 275         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 276         if (!ret && oact) {
 277                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 278                     __put_user(to_user_ptr(old_ka.sa.sa_handler),
 279                             &oact->sa_handler) ||
 280                     __put_user(to_user_ptr(old_ka.sa.sa_restorer),
 281                             &oact->sa_restorer) ||
 282                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
 283                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
 284                         return -EFAULT;
 285         }
 286
 287         return ret;
 288 }
 289
 290 /*
 291  * When we have signals to deliver, we set up on the
 292  * user stack, going down from the original stack pointer:
 293  *      an ABI gap of 56 words
 294  *      an mcontext struct
 295  *      a sigcontext struct
 296  *      a gap of __SIGNAL_FRAMESIZE bytes
 297  *
 298  * Each of these things must be a multiple of 16 bytes in size. The following
 299  * structure represent all of this except the __SIGNAL_FRAMESIZE gap
 300  *
 301  */
 302 struct sigframe {
 303         struct sigcontext sctx;         /* the sigcontext */
 304         struct mcontext mctx;           /* all the register values */
 305         /*
 306          * Programs using the rs6000/xcoff abi can save up to 19 gp
 307          * regs and 18 fp regs below sp before decrementing it.
 308          */
 309         int                     abigap[56];
 310 };
 311
 312 /* We use the mc_pad field for the signal return trampoline. */
 313 #define tramp   mc_pad
 314
 315 /*
 316  *  When we have rt signals to deliver, we set up on the
 317  *  user stack, going down from the original stack pointer:
 318  *      one rt_sigframe struct (siginfo + ucontext + ABI gap)
 319  *      a gap of __SIGNAL_FRAMESIZE+16 bytes
 320  *  (the +16 is to get the siginfo and ucontext in the same
 321  *  positions as in older kernels).
 322  *
 323  *  Each of these things must be a multiple of 16 bytes in size.
 324  *
 325  */
 326 struct rt_sigframe {
 327 #ifdef CONFIG_PPC64
 328         compat_siginfo_t info;
 329 #else
 330         struct siginfo info;
 331 #endif
 332         struct ucontext uc;
 333         /*
 334          * Programs using the rs6000/xcoff abi can save up to 19 gp
 335          * regs and 18 fp regs below sp before decrementing it.
 336          */
 337         int                     abigap[56];
 338 };
 339
 340 #ifdef CONFIG_VSX
 341 unsigned long copy_fpr_to_user(void __user *to,
 342                                struct task_struct *task)
 343 {
 344         double buf[ELF_NFPREG];
 345         int i;
 346
 347         /* save FPR copy to local buffer then write to the thread_struct */
 348         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
 349                 buf[i] = task->thread.TS_FPR(i);
 350         memcpy(&buf[i], &task->thread.fpscr, sizeof(double));
 351         return __copy_to_user(to, buf, ELF_NFPREG * sizeof(double));
 352 }
 353
 354 unsigned long copy_fpr_from_user(struct task_struct *task,
 355                                  void __user *from)
 356 {
 357         double buf[ELF_NFPREG];
 358         int i;
 359
 360         if (__copy_from_user(buf, from, ELF_NFPREG * sizeof(double)))
 361                 return 1;
 362         for (i = 0; i < (ELF_NFPREG - 1) ; i++)
 363                 task->thread.TS_FPR(i) = buf[i];
 364         memcpy(&task->thread.fpscr, &buf[i], sizeof(double));
 365
 366         return 0;
 367 }
 368
 369 unsigned long copy_vsx_to_user(void __user *to,
 370                                struct task_struct *task)
 371 {
 372         double buf[ELF_NVSRHALFREG];
 373         int i;
 374
 375         /* save FPR copy to local buffer then write to the thread_struct */
 376         for (i = 0; i < ELF_NVSRHALFREG; i++)
 377                 buf[i] = task->thread.fpr[i][TS_VSRLOWOFFSET];
 378         return __copy_to_user(to, buf, ELF_NVSRHALFREG * sizeof(double));
 379 }
 380
 381 unsigned long copy_vsx_from_user(struct task_struct *task,
 382                                  void __user *from)
 383 {
 384         double buf[ELF_NVSRHALFREG];
 385         int i;
 386
 387         if (__copy_from_user(buf, from, ELF_NVSRHALFREG * sizeof(double)))
 388                 return 1;
 389         for (i = 0; i < ELF_NVSRHALFREG ; i++)
 390                 task->thread.fpr[i][TS_VSRLOWOFFSET] = buf[i];
 391         return 0;
 392 }
 393 #else
 394 inline unsigned long copy_fpr_to_user(void __user *to,
 395                                       struct task_struct *task)
 396 {
 397         return __copy_to_user(to, task->thread.fpr,
 398                               ELF_NFPREG * sizeof(double));
 399 }
 400
 401 inline unsigned long copy_fpr_from_user(struct task_struct *task,
 402                                         void __user *from)
 403 {
 404         return __copy_from_user(task->thread.fpr, from,
 405                               ELF_NFPREG * sizeof(double));
 406 }
 407 #endif
 408
 409 /*
 410  * Save the current user registers on the user stack.
 411  * We only save the altivec/spe registers if the process has used
 412  * altivec/spe instructions at some point.
 413  */
 414 static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,
 415                 int sigret, int ctx_has_vsx_region)
 416 {
 417         unsigned long msr = regs->msr;
 418
 419         /* Make sure floating point registers are stored in regs */
 420         flush_fp_to_thread(current);
 421
 422         /* save general registers */
 423         if (save_general_regs(regs, frame))
 424                 return 1;
 425
 426 #ifdef CONFIG_ALTIVEC
 427         /* save altivec registers */
 428         if (current->thread.used_vr) {
 429                 flush_altivec_to_thread(current);
 430                 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
 431                                    ELF_NVRREG * sizeof(vector128)))
 432                         return 1;
 433                 /* set MSR_VEC in the saved MSR value to indicate that
 434                    frame->mc_vregs contains valid data */
 435                 msr |= MSR_VEC;
 436         }
 437         /* else assert((regs->msr & MSR_VEC) == 0) */
 438
 439         /* We always copy to/from vrsave, it's 0 if we don't have or don't
 440          * use altivec. Since VSCR only contains 32 bits saved in the least
 441          * significant bits of a vector, we "cheat" and stuff VRSAVE in the
 442          * most significant bits of that same vector. --BenH
 443          */
 444         if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
 445                 return 1;
 446 #endif /* CONFIG_ALTIVEC */
 447         if (copy_fpr_to_user(&frame->mc_fregs, current))
 448                 return 1;
 449 #ifdef CONFIG_VSX
 450         /*
 451          * Copy VSR 0-31 upper half from thread_struct to local
 452          * buffer, then write that to userspace.  Also set MSR_VSX in
 453          * the saved MSR value to indicate that frame->mc_vregs
 454          * contains valid data
 455          */
 456         if (current->thread.used_vsr && ctx_has_vsx_region) {
 457                 __giveup_vsx(current);
 458                 if (copy_vsx_to_user(&frame->mc_vsregs, current))
 459                         return 1;
 460                 msr |= MSR_VSX;
 461         }
 462 #endif /* CONFIG_VSX */
 463 #ifdef CONFIG_SPE
 464         /* save spe registers */
 465         if (current->thread.used_spe) {
 466                 flush_spe_to_thread(current);
 467                 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
 468                                    ELF_NEVRREG * sizeof(u32)))
 469                         return 1;
 470                 /* set MSR_SPE in the saved MSR value to indicate that
 471                    frame->mc_vregs contains valid data */
 472                 msr |= MSR_SPE;
 473         }
 474         /* else assert((regs->msr & MSR_SPE) == 0) */
 475
 476         /* We always copy to/from spefscr */
 477         if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
 478                 return 1;
 479 #endif /* CONFIG_SPE */
 480
 481         if (__put_user(msr, &frame->mc_gregs[PT_MSR]))
 482                 return 1;
 483         if (sigret) {
 484                 /* Set up the sigreturn trampoline: li r0,sigret; sc */
 485                 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
 486                     || __put_user(0x44000002UL, &frame->tramp[1]))
 487                         return 1;
 488                 flush_icache_range((unsigned long) &frame->tramp[0],
 489                                    (unsigned long) &frame->tramp[2]);
 490         }
 491
 492         return 0;
 493 }
 494
 495 /*
 496  * Restore the current user register values from the user stack,
 497  * (except for MSR).
 498  */
 499 static long restore_user_regs(struct pt_regs *regs,
 500                               struct mcontext __user *sr, int sig)
 501 {
 502         long err;
 503         unsigned int save_r2 = 0;
 504         unsigned long msr;
 505 #ifdef CONFIG_VSX
 506         int i;
 507 #endif
 508
 509         /*
 510          * restore general registers but not including MSR or SOFTE. Also
 511          * take care of keeping r2 (TLS) intact if not a signal
 512          */
 513         if (!sig)
 514                 save_r2 = (unsigned int)regs->gpr[2];
 515         err = restore_general_regs(regs, sr);
 516         regs->trap = 0;
 517         err |= __get_user(msr, &sr->mc_gregs[PT_MSR]);
 518         if (!sig)
 519                 regs->gpr[2] = (unsigned long) save_r2;
 520         if (err)
 521                 return 1;
 522
 523         /* if doing signal return, restore the previous little-endian mode */
 524         if (sig)
 525                 regs->msr = (regs->msr & ~MSR_LE) | (msr & MSR_LE);
 526
 527         /*
 528          * Do this before updating the thread state in
 529          * current->thread.fpr/vr/evr.  That way, if we get preempted
 530          * and another task grabs the FPU/Altivec/SPE, it won't be
 531          * tempted to save the current CPU state into the thread_struct
 532          * and corrupt what we are writing there.
 533          */
 534         discard_lazy_cpu_state();
 535
 536 #ifdef CONFIG_ALTIVEC
 537         /*
 538          * Force the process to reload the altivec registers from
 539          * current->thread when it next does altivec instructions
 540          */
 541         regs->msr &= ~MSR_VEC;
 542         if (msr & MSR_VEC) {
 543                 /* restore altivec registers from the stack */
 544                 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
 545                                      sizeof(sr->mc_vregs)))
 546                         return 1;
 547         } else if (current->thread.used_vr)
 548                 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
 549
 550         /* Always get VRSAVE back */
 551         if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
 552                 return 1;
 553 #endif /* CONFIG_ALTIVEC */
 554         if (copy_fpr_from_user(current, &sr->mc_fregs))
 555                 return 1;
 556
 557 #ifdef CONFIG_VSX
 558         /*
 559          * Force the process to reload the VSX registers from
 560          * current->thread when it next does VSX instruction.
 561          */
 562         regs->msr &= ~MSR_VSX;
 563         if (msr & MSR_VSX) {
 564                 /*
 565                  * Restore altivec registers from the stack to a local
 566                  * buffer, then write this out to the thread_struct
 567                  */
 568                 if (copy_vsx_from_user(current, &sr->mc_vsregs))
 569                         return 1;
 570         } else if (current->thread.used_vsr)
 571                 for (i = 0; i < 32 ; i++)
 572                         current->thread.fpr[i][TS_VSRLOWOFFSET] = 0;
 573 #endif /* CONFIG_VSX */
 574         /*
 575          * force the process to reload the FP registers from
 576          * current->thread when it next does FP instructions
 577          */
 578         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
 579
 580 #ifdef CONFIG_SPE
 581         /* force the process to reload the spe registers from
 582            current->thread when it next does spe instructions */
 583         regs->msr &= ~MSR_SPE;
 584         if (msr & MSR_SPE) {
 585                 /* restore spe registers from the stack */
 586                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
 587                                      ELF_NEVRREG * sizeof(u32)))
 588                         return 1;
 589         } else if (current->thread.used_spe)
 590                 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
 591
 592         /* Always get SPEFSCR back */
 593         if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
 594                 return 1;
 595 #endif /* CONFIG_SPE */
 596
 597         return 0;
 598 }
 599
 600 #ifdef CONFIG_PPC64
 601 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
 602                 struct sigaction32 __user *oact, size_t sigsetsize)
 603 {
 604         struct k_sigaction new_ka, old_ka;
 605         int ret;
 606
 607         /* XXX: Don't preclude handling different sized sigset_t's.  */
 608         if (sigsetsize != sizeof(compat_sigset_t))
 609                 return -EINVAL;
 610
 611         if (act) {
 612                 compat_uptr_t handler;
 613
 614                 ret = get_user(handler, &act->sa_handler);
 615                 new_ka.sa.sa_handler = compat_ptr(handler);
 616                 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
 617                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 618                 if (ret)
 619                         return -EFAULT;
 620         }
 621
 622         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 623         if (!ret && oact) {
 624                 ret = put_user(to_user_ptr(old_ka.sa.sa_handler), &oact->sa_handler);
 625                 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
 626                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 627         }
 628         return ret;
 629 }
 630
 631 /*
 632  * Note: it is necessary to treat how as an unsigned int, with the
 633  * corresponding cast to a signed int to insure that the proper
 634  * conversion (sign extension) between the register representation
 635  * of a signed int (msr in 32-bit mode) and the register representation
 636  * of a signed int (msr in 64-bit mode) is performed.
 637  */
 638 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
 639                 compat_sigset_t __user *oset, size_t sigsetsize)
 640 {
 641         sigset_t s;
 642         sigset_t __user *up;
 643         int ret;
 644         mm_segment_t old_fs = get_fs();
 645
 646         if (set) {
 647                 if (get_sigset_t(&s, set))
 648                         return -EFAULT;
 649         }
 650
 651         set_fs(KERNEL_DS);
 652         /* This is valid because of the set_fs() */
 653         up = (sigset_t __user *) &s;
 654         ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
 655                                  sigsetsize);
 656         set_fs(old_fs);
 657         if (ret)
 658                 return ret;
 659         if (oset) {
 660                 if (put_sigset_t(oset, &s))
 661                         return -EFAULT;
 662         }
 663         return 0;
 664 }
 665
 666 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
 667 {
 668         sigset_t s;
 669         int ret;
 670         mm_segment_t old_fs = get_fs();
 671
 672         set_fs(KERNEL_DS);
 673         /* The __user pointer cast is valid because of the set_fs() */
 674         ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
 675         set_fs(old_fs);
 676         if (!ret) {
 677                 if (put_sigset_t(set, &s))
 678                         return -EFAULT;
 679         }
 680         return ret;
 681 }
 682
 683
 684 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
 685 {
 686         int err;
 687
 688         if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
 689                 return -EFAULT;
 690
 691         /* If you change siginfo_t structure, please be sure
 692          * this code is fixed accordingly.
 693          * It should never copy any pad contained in the structure
 694          * to avoid security leaks, but must copy the generic
 695          * 3 ints plus the relevant union member.
 696          * This routine must convert siginfo from 64bit to 32bit as well
 697          * at the same time.
 698          */
 699         err = __put_user(s->si_signo, &d->si_signo);
 700         err |= __put_user(s->si_errno, &d->si_errno);
 701         err |= __put_user((short)s->si_code, &d->si_code);
 702         if (s->si_code < 0)
 703                 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
 704                                       SI_PAD_SIZE32);
 705         else switch(s->si_code >> 16) {
 706         case __SI_CHLD >> 16:
 707                 err |= __put_user(s->si_pid, &d->si_pid);
 708                 err |= __put_user(s->si_uid, &d->si_uid);
 709                 err |= __put_user(s->si_utime, &d->si_utime);
 710                 err |= __put_user(s->si_stime, &d->si_stime);
 711                 err |= __put_user(s->si_status, &d->si_status);
 712                 break;
 713         case __SI_FAULT >> 16:
 714                 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
 715                                   &d->si_addr);
 716                 break;
 717         case __SI_POLL >> 16:
 718                 err |= __put_user(s->si_band, &d->si_band);
 719                 err |= __put_user(s->si_fd, &d->si_fd);
 720                 break;
 721         case __SI_TIMER >> 16:
 722                 err |= __put_user(s->si_tid, &d->si_tid);
 723                 err |= __put_user(s->si_overrun, &d->si_overrun);
 724                 err |= __put_user(s->si_int, &d->si_int);
 725                 break;
 726         case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 727         case __SI_MESGQ >> 16:
 728                 err |= __put_user(s->si_int, &d->si_int);
 729                 /* fallthrough */
 730         case __SI_KILL >> 16:
 731         default:
 732                 err |= __put_user(s->si_pid, &d->si_pid);
 733                 err |= __put_user(s->si_uid, &d->si_uid);
 734                 break;
 735         }
 736         return err;
 737 }
 738
 739 #define copy_siginfo_to_user    copy_siginfo_to_user32
 740
 741 int copy_siginfo_from_user32(siginfo_t *to, struct compat_siginfo __user *from)
 742 {
 743         memset(to, 0, sizeof *to);
 744
 745         if (copy_from_user(to, from, 3*sizeof(int)) ||
 746             copy_from_user(to->_sifields._pad,
 747                            from->_sifields._pad, SI_PAD_SIZE32))
 748                 return -EFAULT;
 749
 750         return 0;
 751 }
 752
 753 /*
 754  * Note: it is necessary to treat pid and sig as unsigned ints, with the
 755  * corresponding cast to a signed int to insure that the proper conversion
 756  * (sign extension) between the register representation of a signed int
 757  * (msr in 32-bit mode) and the register representation of a signed int
 758  * (msr in 64-bit mode) is performed.
 759  */
 760 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
 761 {
 762         siginfo_t info;
 763         int ret;
 764         mm_segment_t old_fs = get_fs();
 765
 766         ret = copy_siginfo_from_user32(&info, uinfo);
 767         if (unlikely(ret))
 768                 return ret;
 769
 770         set_fs (KERNEL_DS);
 771         /* The __user pointer cast is valid becasuse of the set_fs() */
 772         ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
 773         set_fs (old_fs);
 774         return ret;
 775 }
 776 /*
 777  *  Start Alternate signal stack support
 778  *
 779  *  System Calls
 780  *       sigaltatck               compat_sys_sigaltstack
 781  */
 782
 783 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
 784                       int r6, int r7, int r8, struct pt_regs *regs)
 785 {
 786         stack_32_t __user * newstack = compat_ptr(__new);
 787         stack_32_t __user * oldstack = compat_ptr(__old);
 788         stack_t uss, uoss;
 789         int ret;
 790         mm_segment_t old_fs;
 791         unsigned long sp;
 792         compat_uptr_t ss_sp;
 793
 794         /*
 795          * set sp to the user stack on entry to the system call
 796          * the system call router sets R9 to the saved registers
 797          */
 798         sp = regs->gpr[1];
 799
 800         /* Put new stack info in local 64 bit stack struct */
 801         if (newstack) {
 802                 if (get_user(ss_sp, &newstack->ss_sp) ||
 803                     __get_user(uss.ss_flags, &newstack->ss_flags) ||
 804                     __get_user(uss.ss_size, &newstack->ss_size))
 805                         return -EFAULT;
 806                 uss.ss_sp = compat_ptr(ss_sp);
 807         }
 808
 809         old_fs = get_fs();
 810         set_fs(KERNEL_DS);
 811         /* The __user pointer casts are valid because of the set_fs() */
 812         ret = do_sigaltstack(
 813                 newstack ? (stack_t __user *) &uss : NULL,
 814                 oldstack ? (stack_t __user *) &uoss : NULL,
 815                 sp);
 816         set_fs(old_fs);
 817         /* Copy the stack information to the user output buffer */
 818         if (!ret && oldstack  &&
 819                 (put_user(ptr_to_compat(uoss.ss_sp), &oldstack->ss_sp) ||
 820                  __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
 821                  __put_user(uoss.ss_size, &oldstack->ss_size)))
 822                 return -EFAULT;
 823         return ret;
 824 }
 825 #endif /* CONFIG_PPC64 */
 826
 827 /*
 828  * Set up a signal frame for a "real-time" signal handler
 829  * (one which gets siginfo).
 830  */
 831 int handle_rt_signal32(unsigned long sig, struct k_sigaction *ka,
 832                 siginfo_t *info, sigset_t *oldset,
 833                 struct pt_regs *regs)
 834 {
 835         struct rt_sigframe __user *rt_sf;
 836         struct mcontext __user *frame;
 837         void __user *addr;
 838         unsigned long newsp = 0;
 839
 840         /* Set up Signal Frame */
 841         /* Put a Real Time Context onto stack */
 842         rt_sf = get_sigframe(ka, regs, sizeof(*rt_sf), 1);
 843         addr = rt_sf;
 844         if (unlikely(rt_sf == NULL))
 845                 goto badframe;
 846
 847         /* Put the siginfo & fill in most of the ucontext */
 848         if (copy_siginfo_to_user(&rt_sf->info, info)
 849             || __put_user(0, &rt_sf->uc.uc_flags)
 850             || __put_user(0, &rt_sf->uc.uc_link)
 851             || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
 852             || __put_user(sas_ss_flags(regs->gpr[1]),
 853                           &rt_sf->uc.uc_stack.ss_flags)
 854             || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
 855             || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
 856                     &rt_sf->uc.uc_regs)
 857             || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
 858                 goto badframe;
 859
 860         /* Save user registers on the stack */
 861         frame = &rt_sf->uc.uc_mcontext;
 862         addr = frame;
 863         if (vdso32_rt_sigtramp && current->mm->context.vdso_base) {
 864                 if (save_user_regs(regs, frame, 0, 1))
 865                         goto badframe;
 866                 regs->link = current->mm->context.vdso_base + vdso32_rt_sigtramp;
 867         } else {
 868                 if (save_user_regs(regs, frame, __NR_rt_sigreturn, 1))
 869                         goto badframe;
 870                 regs->link = (unsigned long) frame->tramp;
 871         }
 872
 873         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
 874
 875         /* create a stack frame for the caller of the handler */
 876         newsp = ((unsigned long)rt_sf) - (__SIGNAL_FRAMESIZE + 16);
 877         addr = (void __user *)regs->gpr[1];
 878         if (put_user(regs->gpr[1], (u32 __user *)newsp))
 879                 goto badframe;
 880
 881         /* Fill registers for signal handler */
 882         regs->gpr[1] = newsp;
 883         regs->gpr[3] = sig;
 884         regs->gpr[4] = (unsigned long) &rt_sf->info;
 885         regs->gpr[5] = (unsigned long) &rt_sf->uc;
 886         regs->gpr[6] = (unsigned long) rt_sf;
 887         regs->nip = (unsigned long) ka->sa.sa_handler;
 888         /* enter the signal handler in big-endian mode */
 889         regs->msr &= ~MSR_LE;
 890         return 1;
 891
 892 badframe:
 893 #ifdef DEBUG_SIG
 894         printk("badframe in handle_rt_signal, regs=%p frame=%p newsp=%lx\n",
 895                regs, frame, newsp);
 896 #endif
 897         if (show_unhandled_signals)
 898                 printk_ratelimited(KERN_INFO
 899                                    "%s[%d]: bad frame in handle_rt_signal32: "
 900                                    "%p nip %08lx lr %08lx\n",
 901                                    current->comm, current->pid,
 902                                    addr, regs->nip, regs->link);
 903
 904         force_sigsegv(sig, current);
 905         return 0;
 906 }
 907
 908 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
 909 {
 910         sigset_t set;
 911         struct mcontext __user *mcp;
 912
 913         if (get_sigset_t(&set, &ucp->uc_sigmask))
 914                 return -EFAULT;
 915 #ifdef CONFIG_PPC64
 916         {
 917                 u32 cmcp;
 918
 919                 if (__get_user(cmcp, &ucp->uc_regs))
 920                         return -EFAULT;
 921                 mcp = (struct mcontext __user *)(u64)cmcp;
 922                 /* no need to check access_ok(mcp), since mcp < 4GB */
 923         }
 924 #else
 925         if (__get_user(mcp, &ucp->uc_regs))
 926                 return -EFAULT;
 927         if (!access_ok(VERIFY_READ, mcp, sizeof(*mcp)))
 928                 return -EFAULT;
 929 #endif
 930         restore_sigmask(&set);
 931         if (restore_user_regs(regs, mcp, sig))
 932                 return -EFAULT;
 933
 934         return 0;
 935 }
 936
 937 long sys_swapcontext(struct ucontext __user *old_ctx,
 938                      struct ucontext __user *new_ctx,
 939                      int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
 940 {
 941         unsigned char tmp;
 942         int ctx_has_vsx_region = 0;
 943
 944 #ifdef CONFIG_PPC64
 945         unsigned long new_msr = 0;
 946
 947         if (new_ctx) {
 948                 struct mcontext __user *mcp;
 949                 u32 cmcp;
 950
 951                 /*
 952                  * Get pointer to the real mcontext.  No need for
 953                  * access_ok since we are dealing with compat
 954                  * pointers.
 955                  */
 956                 if (__get_user(cmcp, &new_ctx->uc_regs))
 957                         return -EFAULT;
 958                 mcp = (struct mcontext __user *)(u64)cmcp;
 959                 if (__get_user(new_msr, &mcp->mc_gregs[PT_MSR]))
 960                         return -EFAULT;
 961         }
 962         /*
 963          * Check that the context is not smaller than the original
 964          * size (with VMX but without VSX)
 965          */
 966         if (ctx_size < UCONTEXTSIZEWITHOUTVSX)
 967                 return -EINVAL;
 968         /*
 969          * If the new context state sets the MSR VSX bits but
 970          * it doesn't provide VSX state.
 971          */
 972         if ((ctx_size < sizeof(struct ucontext)) &&
 973             (new_msr & MSR_VSX))
 974                 return -EINVAL;
 975         /* Does the context have enough room to store VSX data? */
 976         if (ctx_size >= sizeof(struct ucontext))
 977                 ctx_has_vsx_region = 1;
 978 #else
 979         /* Context size is for future use. Right now, we only make sure
 980          * we are passed something we understand
 981          */
 982         if (ctx_size < sizeof(struct ucontext))
 983                 return -EINVAL;
 984 #endif
 985         if (old_ctx != NULL) {
 986                 struct mcontext __user *mctx;
 987
 988                 /*
 989                  * old_ctx might not be 16-byte aligned, in which
 990                  * case old_ctx->uc_mcontext won't be either.
 991                  * Because we have the old_ctx->uc_pad2 field
 992                  * before old_ctx->uc_mcontext, we need to round down
 993                  * from &old_ctx->uc_mcontext to a 16-byte boundary.
 994                  */
 995                 mctx = (struct mcontext __user *)
 996                         ((unsigned long) &old_ctx->uc_mcontext & ~0xfUL);
 997                 if (!access_ok(VERIFY_WRITE, old_ctx, ctx_size)
 998                     || save_user_regs(regs, mctx, 0, ctx_has_vsx_region)
 999                     || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
1000                     || __put_user(to_user_ptr(mctx), &old_ctx->uc_regs))
1001                         return -EFAULT;
1002         }
1003         if (new_ctx == NULL)
1004                 return 0;
1005         if (!access_ok(VERIFY_READ, new_ctx, ctx_size)
1006             || __get_user(tmp, (u8 __user *) new_ctx)
1007             || __get_user(tmp, (u8 __user *) new_ctx + ctx_size - 1))
1008                 return -EFAULT;
1009
1010         /*
1011          * If we get a fault copying the context into the kernel's
1012          * image of the user's registers, we can't just return -EFAULT
1013          * because the user's registers will be corrupted.  For instance
1014          * the NIP value may have been updated but not some of the
1015          * other registers.  Given that we have done the access_ok
1016          * and successfully read the first and last bytes of the region
1017          * above, this should only happen in an out-of-memory situation
1018          * or if another thread unmaps the region containing the context.
1019          * We kill the task with a SIGSEGV in this situation.
1020          */
1021         if (do_setcontext(new_ctx, regs, 0))
1022                 do_exit(SIGSEGV);
1023
1024         set_thread_flag(TIF_RESTOREALL);
1025         return 0;
1026 }
1027
1028 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1029                      struct pt_regs *regs)
1030 {
1031         struct rt_sigframe __user *rt_sf;
1032
1033         /* Always make any pending restarted system calls return -EINTR */
1034         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1035
1036         rt_sf = (struct rt_sigframe __user *)
1037                 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
1038         if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
1039                 goto bad;
1040         if (do_setcontext(&rt_sf->uc, regs, 1))
1041                 goto bad;
1042
1043         /*
1044          * It's not clear whether or why it is desirable to save the
1045          * sigaltstack setting on signal delivery and restore it on
1046          * signal return.  But other architectures do this and we have
1047          * always done it up until now so it is probably better not to
1048          * change it.  -- paulus
1049          */
1050 #ifdef CONFIG_PPC64
1051         /*
1052          * We use the compat_sys_ version that does the 32/64 bits conversion
1053          * and takes userland pointer directly. What about error checking ?
1054          * nobody does any...
1055          */
1056         compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
1057 #else
1058         do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
1059 #endif
1060         set_thread_flag(TIF_RESTOREALL);
1061         return 0;
1062
1063  bad:
1064         if (show_unhandled_signals)
1065                 printk_ratelimited(KERN_INFO
1066                                    "%s[%d]: bad frame in sys_rt_sigreturn: "
1067                                    "%p nip %08lx lr %08lx\n",
1068                                    current->comm, current->pid,
1069                                    rt_sf, regs->nip, regs->link);
1070
1071         force_sig(SIGSEGV, current);
1072         return 0;
1073 }
1074
1075 #ifdef CONFIG_PPC32
1076 int sys_debug_setcontext(struct ucontext __user *ctx,
1077                          int ndbg, struct sig_dbg_op __user *dbg,
1078                          int r6, int r7, int r8,
1079                          struct pt_regs *regs)
1080 {
1081         struct sig_dbg_op op;
1082         int i;
1083         unsigned char tmp;
1084         unsigned long new_msr = regs->msr;
1085 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1086         unsigned long new_dbcr0 = current->thread.dbcr0;
1087 #endif
1088
1089         for (i=0; i<ndbg; i++) {
1090                 if (copy_from_user(&op, dbg + i, sizeof(op)))
1091                         return -EFAULT;
1092                 switch (op.dbg_type) {
1093                 case SIG_DBG_SINGLE_STEPPING:
1094 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1095                         if (op.dbg_value) {
1096                                 new_msr |= MSR_DE;
1097                                 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
1098                         } else {
1099                                 new_dbcr0 &= ~DBCR0_IC;
1100                                 if (!DBCR_ACTIVE_EVENTS(new_dbcr0,
1101                                                 current->thread.dbcr1)) {
1102                                         new_msr &= ~MSR_DE;
1103                                         new_dbcr0 &= ~DBCR0_IDM;
1104                                 }
1105                         }
1106 #else
1107                         if (op.dbg_value)
1108                                 new_msr |= MSR_SE;
1109                         else
1110                                 new_msr &= ~MSR_SE;
1111 #endif
1112                         break;
1113                 case SIG_DBG_BRANCH_TRACING:
1114 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1115                         return -EINVAL;
1116 #else
1117                         if (op.dbg_value)
1118                                 new_msr |= MSR_BE;
1119                         else
1120                                 new_msr &= ~MSR_BE;
1121 #endif
1122                         break;
1123
1124                 default:
1125                         return -EINVAL;
1126                 }
1127         }
1128
1129         /* We wait until here to actually install the values in the
1130            registers so if we fail in the above loop, it will not
1131            affect the contents of these registers.  After this point,
1132            failure is a problem, anyway, and it's very unlikely unless
1133            the user is really doing something wrong. */
1134         regs->msr = new_msr;
1135 #ifdef CONFIG_PPC_ADV_DEBUG_REGS
1136         current->thread.dbcr0 = new_dbcr0;
1137 #endif
1138
1139         if (!access_ok(VERIFY_READ, ctx, sizeof(*ctx))
1140             || __get_user(tmp, (u8 __user *) ctx)
1141             || __get_user(tmp, (u8 __user *) (ctx + 1) - 1))
1142                 return -EFAULT;
1143
1144         /*
1145          * If we get a fault copying the context into the kernel's
1146          * image of the user's registers, we can't just return -EFAULT
1147          * because the user's registers will be corrupted.  For instance
1148          * the NIP value may have been updated but not some of the
1149          * other registers.  Given that we have done the access_ok
1150          * and successfully read the first and last bytes of the region
1151          * above, this should only happen in an out-of-memory situation
1152          * or if another thread unmaps the region containing the context.
1153          * We kill the task with a SIGSEGV in this situation.
1154          */
1155         if (do_setcontext(ctx, regs, 1)) {
1156                 if (show_unhandled_signals)
1157                         printk_ratelimited(KERN_INFO "%s[%d]: bad frame in "
1158                                            "sys_debug_setcontext: %p nip %08lx "
1159                                            "lr %08lx\n",
1160                                            current->comm, current->pid,
1161                                            ctx, regs->nip, regs->link);
1162
1163                 force_sig(SIGSEGV, current);
1164                 goto out;
1165         }
1166
1167         /*
1168          * It's not clear whether or why it is desirable to save the
1169          * sigaltstack setting on signal delivery and restore it on
1170          * signal return.  But other architectures do this and we have
1171          * always done it up until now so it is probably better not to
1172          * change it.  -- paulus
1173          */
1174         do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1175
1176         set_thread_flag(TIF_RESTOREALL);
1177  out:
1178         return 0;
1179 }
1180 #endif
1181
1182 /*
1183  * OK, we're invoking a handler
1184  */
1185 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
1186                     siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
1187 {
1188         struct sigcontext __user *sc;
1189         struct sigframe __user *frame;
1190         unsigned long newsp = 0;
1191
1192         /* Set up Signal Frame */
1193         frame = get_sigframe(ka, regs, sizeof(*frame), 1);
1194         if (unlikely(frame == NULL))
1195                 goto badframe;
1196         sc = (struct sigcontext __user *) &frame->sctx;
1197
1198 #if _NSIG != 64
1199 #error "Please adjust handle_signal()"
1200 #endif
1201         if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1202             || __put_user(oldset->sig[0], &sc->oldmask)
1203 #ifdef CONFIG_PPC64
1204             || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1205 #else
1206             || __put_user(oldset->sig[1], &sc->_unused[3])
1207 #endif
1208             || __put_user(to_user_ptr(&frame->mctx), &sc->regs)
1209             || __put_user(sig, &sc->signal))
1210                 goto badframe;
1211
1212         if (vdso32_sigtramp && current->mm->context.vdso_base) {
1213                 if (save_user_regs(regs, &frame->mctx, 0, 1))
1214                         goto badframe;
1215                 regs->link = current->mm->context.vdso_base + vdso32_sigtramp;
1216         } else {
1217                 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn, 1))
1218                         goto badframe;
1219                 regs->link = (unsigned long) frame->mctx.tramp;
1220         }
1221
1222         current->thread.fpscr.val = 0;  /* turn off all fp exceptions */
1223
1224         /* create a stack frame for the caller of the handler */
1225         newsp = ((unsigned long)frame) - __SIGNAL_FRAMESIZE;
1226         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1227                 goto badframe;
1228
1229         regs->gpr[1] = newsp;
1230         regs->gpr[3] = sig;
1231         regs->gpr[4] = (unsigned long) sc;
1232         regs->nip = (unsigned long) ka->sa.sa_handler;
1233         /* enter the signal handler in big-endian mode */
1234         regs->msr &= ~MSR_LE;
1235
1236         return 1;
1237
1238 badframe:
1239 #ifdef DEBUG_SIG
1240         printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1241                regs, frame, newsp);
1242 #endif
1243         if (show_unhandled_signals)
1244                 printk_ratelimited(KERN_INFO
1245                                    "%s[%d]: bad frame in handle_signal32: "
1246                                    "%p nip %08lx lr %08lx\n",
1247                                    current->comm, current->pid,
1248                                    frame, regs->nip, regs->link);
1249
1250         force_sigsegv(sig, current);
1251         return 0;
1252 }
1253
1254 /*
1255  * Do a signal return; undo the signal stack.
1256  */
1257 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1258                        struct pt_regs *regs)
1259 {
1260         struct sigcontext __user *sc;
1261         struct sigcontext sigctx;
1262         struct mcontext __user *sr;
1263         void __user *addr;
1264         sigset_t set;
1265
1266         /* Always make any pending restarted system calls return -EINTR */
1267         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1268
1269         sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1270         addr = sc;
1271         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1272                 goto badframe;
1273
1274 #ifdef CONFIG_PPC64
1275         /*
1276          * Note that PPC32 puts the upper 32 bits of the sigmask in the
1277          * unused part of the signal stackframe
1278          */
1279         set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1280 #else
1281         set.sig[0] = sigctx.oldmask;
1282         set.sig[1] = sigctx._unused[3];
1283 #endif
1284         restore_sigmask(&set);
1285
1286         sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1287         addr = sr;
1288         if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1289             || restore_user_regs(regs, sr, 1))
1290                 goto badframe;
1291
1292         set_thread_flag(TIF_RESTOREALL);
1293         return 0;
1294
1295 badframe:
1296         if (show_unhandled_signals)
1297                 printk_ratelimited(KERN_INFO
1298                                    "%s[%d]: bad frame in sys_sigreturn: "
1299                                    "%p nip %08lx lr %08lx\n",
1300                                    current->comm, current->pid,
1301                                    addr, regs->nip, regs->link);
1302
1303         force_sig(SIGSEGV, current);
1304         return 0;
1305 }