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