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