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