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 #ifdef CONFIG_PPC64
  46 #include <asm/ppc32.h>
  47 #include <asm/ppcdebug.h>
  48 #include <asm/unistd.h>
  49 #include <asm/vdso.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         current->thread.fpscr = 0;      /* turn off all fp exceptions */
 407
 408 #ifdef CONFIG_ALTIVEC
 409         /* save altivec registers */
 410         if (current->thread.used_vr) {
 411                 flush_altivec_to_thread(current);
 412                 if (__copy_to_user(&frame->mc_vregs, current->thread.vr,
 413                                    ELF_NVRREG * sizeof(vector128)))
 414                         return 1;
 415                 /* set MSR_VEC in the saved MSR value to indicate that
 416                    frame->mc_vregs contains valid data */
 417                 if (__put_user(regs->msr | MSR_VEC, &frame->mc_gregs[PT_MSR]))
 418                         return 1;
 419         }
 420         /* else assert((regs->msr & MSR_VEC) == 0) */
 421
 422         /* We always copy to/from vrsave, it's 0 if we don't have or don't
 423          * use altivec. Since VSCR only contains 32 bits saved in the least
 424          * significant bits of a vector, we "cheat" and stuff VRSAVE in the
 425          * most significant bits of that same vector. --BenH
 426          */
 427         if (__put_user(current->thread.vrsave, (u32 __user *)&frame->mc_vregs[32]))
 428                 return 1;
 429 #endif /* CONFIG_ALTIVEC */
 430
 431 #ifdef CONFIG_SPE
 432         /* save spe registers */
 433         if (current->thread.used_spe) {
 434                 flush_spe_to_thread(current);
 435                 if (__copy_to_user(&frame->mc_vregs, current->thread.evr,
 436                                    ELF_NEVRREG * sizeof(u32)))
 437                         return 1;
 438                 /* set MSR_SPE in the saved MSR value to indicate that
 439                    frame->mc_vregs contains valid data */
 440                 if (__put_user(regs->msr | MSR_SPE, &frame->mc_gregs[PT_MSR]))
 441                         return 1;
 442         }
 443         /* else assert((regs->msr & MSR_SPE) == 0) */
 444
 445         /* We always copy to/from spefscr */
 446         if (__put_user(current->thread.spefscr, (u32 __user *)&frame->mc_vregs + ELF_NEVRREG))
 447                 return 1;
 448 #endif /* CONFIG_SPE */
 449
 450         if (sigret) {
 451                 /* Set up the sigreturn trampoline: li r0,sigret; sc */
 452                 if (__put_user(0x38000000UL + sigret, &frame->tramp[0])
 453                     || __put_user(0x44000002UL, &frame->tramp[1]))
 454                         return 1;
 455                 flush_icache_range((unsigned long) &frame->tramp[0],
 456                                    (unsigned long) &frame->tramp[2]);
 457         }
 458
 459         return 0;
 460 }
 461
 462 /*
 463  * Restore the current user register values from the user stack,
 464  * (except for MSR).
 465  */
 466 static long restore_user_regs(struct pt_regs *regs,
 467                               struct mcontext __user *sr, int sig)
 468 {
 469         long err;
 470         unsigned int save_r2 = 0;
 471 #if defined(CONFIG_ALTIVEC) || defined(CONFIG_SPE)
 472         unsigned long msr;
 473 #endif
 474
 475         /*
 476          * restore general registers but not including MSR or SOFTE. Also
 477          * take care of keeping r2 (TLS) intact if not a signal
 478          */
 479         if (!sig)
 480                 save_r2 = (unsigned int)regs->gpr[2];
 481         err = restore_general_regs(regs, sr);
 482         if (!sig)
 483                 regs->gpr[2] = (unsigned long) save_r2;
 484         if (err)
 485                 return 1;
 486
 487         /* force the process to reload the FP registers from
 488            current->thread when it next does FP instructions */
 489         regs->msr &= ~(MSR_FP | MSR_FE0 | MSR_FE1);
 490         if (__copy_from_user(current->thread.fpr, &sr->mc_fregs,
 491                              sizeof(sr->mc_fregs)))
 492                 return 1;
 493
 494 #ifdef CONFIG_ALTIVEC
 495         /* force the process to reload the altivec registers from
 496            current->thread when it next does altivec instructions */
 497         regs->msr &= ~MSR_VEC;
 498         if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_VEC) != 0) {
 499                 /* restore altivec registers from the stack */
 500                 if (__copy_from_user(current->thread.vr, &sr->mc_vregs,
 501                                      sizeof(sr->mc_vregs)))
 502                         return 1;
 503         } else if (current->thread.used_vr)
 504                 memset(current->thread.vr, 0, ELF_NVRREG * sizeof(vector128));
 505
 506         /* Always get VRSAVE back */
 507         if (__get_user(current->thread.vrsave, (u32 __user *)&sr->mc_vregs[32]))
 508                 return 1;
 509 #endif /* CONFIG_ALTIVEC */
 510
 511 #ifdef CONFIG_SPE
 512         /* force the process to reload the spe registers from
 513            current->thread when it next does spe instructions */
 514         regs->msr &= ~MSR_SPE;
 515         if (!__get_user(msr, &sr->mc_gregs[PT_MSR]) && (msr & MSR_SPE) != 0) {
 516                 /* restore spe registers from the stack */
 517                 if (__copy_from_user(current->thread.evr, &sr->mc_vregs,
 518                                      ELF_NEVRREG * sizeof(u32)))
 519                         return 1;
 520         } else if (current->thread.used_spe)
 521                 memset(current->thread.evr, 0, ELF_NEVRREG * sizeof(u32));
 522
 523         /* Always get SPEFSCR back */
 524         if (__get_user(current->thread.spefscr, (u32 __user *)&sr->mc_vregs + ELF_NEVRREG))
 525                 return 1;
 526 #endif /* CONFIG_SPE */
 527
 528 #ifndef CONFIG_SMP
 529         preempt_disable();
 530         if (last_task_used_math == current)
 531                 last_task_used_math = NULL;
 532         if (last_task_used_altivec == current)
 533                 last_task_used_altivec = NULL;
 534 #ifdef CONFIG_SPE
 535         if (last_task_used_spe == current)
 536                 last_task_used_spe = NULL;
 537 #endif
 538         preempt_enable();
 539 #endif
 540         return 0;
 541 }
 542
 543 #ifdef CONFIG_PPC64
 544 long compat_sys_rt_sigaction(int sig, const struct sigaction32 __user *act,
 545                 struct sigaction32 __user *oact, size_t sigsetsize)
 546 {
 547         struct k_sigaction new_ka, old_ka;
 548         int ret;
 549
 550         /* XXX: Don't preclude handling different sized sigset_t's.  */
 551         if (sigsetsize != sizeof(compat_sigset_t))
 552                 return -EINVAL;
 553
 554         if (act) {
 555                 compat_uptr_t handler;
 556
 557                 ret = get_user(handler, &act->sa_handler);
 558                 new_ka.sa.sa_handler = compat_ptr(handler);
 559                 ret |= get_sigset_t(&new_ka.sa.sa_mask, &act->sa_mask);
 560                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 561                 if (ret)
 562                         return -EFAULT;
 563         }
 564
 565         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 566         if (!ret && oact) {
 567                 ret = put_user((long)old_ka.sa.sa_handler, &oact->sa_handler);
 568                 ret |= put_sigset_t(&oact->sa_mask, &old_ka.sa.sa_mask);
 569                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 570         }
 571         return ret;
 572 }
 573
 574 /*
 575  * Note: it is necessary to treat how as an unsigned int, with the
 576  * corresponding cast to a signed int to insure that the proper
 577  * conversion (sign extension) between the register representation
 578  * of a signed int (msr in 32-bit mode) and the register representation
 579  * of a signed int (msr in 64-bit mode) is performed.
 580  */
 581 long compat_sys_rt_sigprocmask(u32 how, compat_sigset_t __user *set,
 582                 compat_sigset_t __user *oset, size_t sigsetsize)
 583 {
 584         sigset_t s;
 585         sigset_t __user *up;
 586         int ret;
 587         mm_segment_t old_fs = get_fs();
 588
 589         if (set) {
 590                 if (get_sigset_t(&s, set))
 591                         return -EFAULT;
 592         }
 593
 594         set_fs(KERNEL_DS);
 595         /* This is valid because of the set_fs() */
 596         up = (sigset_t __user *) &s;
 597         ret = sys_rt_sigprocmask((int)how, set ? up : NULL, oset ? up : NULL,
 598                                  sigsetsize);
 599         set_fs(old_fs);
 600         if (ret)
 601                 return ret;
 602         if (oset) {
 603                 if (put_sigset_t(oset, &s))
 604                         return -EFAULT;
 605         }
 606         return 0;
 607 }
 608
 609 long compat_sys_rt_sigpending(compat_sigset_t __user *set, compat_size_t sigsetsize)
 610 {
 611         sigset_t s;
 612         int ret;
 613         mm_segment_t old_fs = get_fs();
 614
 615         set_fs(KERNEL_DS);
 616         /* The __user pointer cast is valid because of the set_fs() */
 617         ret = sys_rt_sigpending((sigset_t __user *) &s, sigsetsize);
 618         set_fs(old_fs);
 619         if (!ret) {
 620                 if (put_sigset_t(set, &s))
 621                         return -EFAULT;
 622         }
 623         return ret;
 624 }
 625
 626
 627 int copy_siginfo_to_user32(struct compat_siginfo __user *d, siginfo_t *s)
 628 {
 629         int err;
 630
 631         if (!access_ok (VERIFY_WRITE, d, sizeof(*d)))
 632                 return -EFAULT;
 633
 634         /* If you change siginfo_t structure, please be sure
 635          * this code is fixed accordingly.
 636          * It should never copy any pad contained in the structure
 637          * to avoid security leaks, but must copy the generic
 638          * 3 ints plus the relevant union member.
 639          * This routine must convert siginfo from 64bit to 32bit as well
 640          * at the same time.
 641          */
 642         err = __put_user(s->si_signo, &d->si_signo);
 643         err |= __put_user(s->si_errno, &d->si_errno);
 644         err |= __put_user((short)s->si_code, &d->si_code);
 645         if (s->si_code < 0)
 646                 err |= __copy_to_user(&d->_sifields._pad, &s->_sifields._pad,
 647                                       SI_PAD_SIZE32);
 648         else switch(s->si_code >> 16) {
 649         case __SI_CHLD >> 16:
 650                 err |= __put_user(s->si_pid, &d->si_pid);
 651                 err |= __put_user(s->si_uid, &d->si_uid);
 652                 err |= __put_user(s->si_utime, &d->si_utime);
 653                 err |= __put_user(s->si_stime, &d->si_stime);
 654                 err |= __put_user(s->si_status, &d->si_status);
 655                 break;
 656         case __SI_FAULT >> 16:
 657                 err |= __put_user((unsigned int)(unsigned long)s->si_addr,
 658                                   &d->si_addr);
 659                 break;
 660         case __SI_POLL >> 16:
 661                 err |= __put_user(s->si_band, &d->si_band);
 662                 err |= __put_user(s->si_fd, &d->si_fd);
 663                 break;
 664         case __SI_TIMER >> 16:
 665                 err |= __put_user(s->si_tid, &d->si_tid);
 666                 err |= __put_user(s->si_overrun, &d->si_overrun);
 667                 err |= __put_user(s->si_int, &d->si_int);
 668                 break;
 669         case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 670         case __SI_MESGQ >> 16:
 671                 err |= __put_user(s->si_int, &d->si_int);
 672                 /* fallthrough */
 673         case __SI_KILL >> 16:
 674         default:
 675                 err |= __put_user(s->si_pid, &d->si_pid);
 676                 err |= __put_user(s->si_uid, &d->si_uid);
 677                 break;
 678         }
 679         return err;
 680 }
 681
 682 #define copy_siginfo_to_user    copy_siginfo_to_user32
 683
 684 /*
 685  * Note: it is necessary to treat pid and sig as unsigned ints, with the
 686  * corresponding cast to a signed int to insure that the proper conversion
 687  * (sign extension) between the register representation of a signed int
 688  * (msr in 32-bit mode) and the register representation of a signed int
 689  * (msr in 64-bit mode) is performed.
 690  */
 691 long compat_sys_rt_sigqueueinfo(u32 pid, u32 sig, compat_siginfo_t __user *uinfo)
 692 {
 693         siginfo_t info;
 694         int ret;
 695         mm_segment_t old_fs = get_fs();
 696
 697         if (copy_from_user (&info, uinfo, 3*sizeof(int)) ||
 698             copy_from_user (info._sifields._pad, uinfo->_sifields._pad, SI_PAD_SIZE32))
 699                 return -EFAULT;
 700         set_fs (KERNEL_DS);
 701         /* The __user pointer cast is valid becasuse of the set_fs() */
 702         ret = sys_rt_sigqueueinfo((int)pid, (int)sig, (siginfo_t __user *) &info);
 703         set_fs (old_fs);
 704         return ret;
 705 }
 706 /*
 707  *  Start Alternate signal stack support
 708  *
 709  *  System Calls
 710  *       sigaltatck               compat_sys_sigaltstack
 711  */
 712
 713 int compat_sys_sigaltstack(u32 __new, u32 __old, int r5,
 714                       int r6, int r7, int r8, struct pt_regs *regs)
 715 {
 716         stack_32_t __user * newstack = (stack_32_t __user *)(long) __new;
 717         stack_32_t __user * oldstack = (stack_32_t __user *)(long) __old;
 718         stack_t uss, uoss;
 719         int ret;
 720         mm_segment_t old_fs;
 721         unsigned long sp;
 722         compat_uptr_t ss_sp;
 723
 724         /*
 725          * set sp to the user stack on entry to the system call
 726          * the system call router sets R9 to the saved registers
 727          */
 728         sp = regs->gpr[1];
 729
 730         /* Put new stack info in local 64 bit stack struct */
 731         if (newstack) {
 732                 if (get_user(ss_sp, &newstack->ss_sp) ||
 733                     __get_user(uss.ss_flags, &newstack->ss_flags) ||
 734                     __get_user(uss.ss_size, &newstack->ss_size))
 735                         return -EFAULT;
 736                 uss.ss_sp = compat_ptr(ss_sp);
 737         }
 738
 739         old_fs = get_fs();
 740         set_fs(KERNEL_DS);
 741         /* The __user pointer casts are valid because of the set_fs() */
 742         ret = do_sigaltstack(
 743                 newstack ? (stack_t __user *) &uss : NULL,
 744                 oldstack ? (stack_t __user *) &uoss : NULL,
 745                 sp);
 746         set_fs(old_fs);
 747         /* Copy the stack information to the user output buffer */
 748         if (!ret && oldstack  &&
 749                 (put_user((long)uoss.ss_sp, &oldstack->ss_sp) ||
 750                  __put_user(uoss.ss_flags, &oldstack->ss_flags) ||
 751                  __put_user(uoss.ss_size, &oldstack->ss_size)))
 752                 return -EFAULT;
 753         return ret;
 754 }
 755 #endif /* CONFIG_PPC64 */
 756
 757
 758 /*
 759  * Restore the user process's signal mask
 760  */
 761 #ifdef CONFIG_PPC64
 762 extern void restore_sigmask(sigset_t *set);
 763 #else /* CONFIG_PPC64 */
 764 static void restore_sigmask(sigset_t *set)
 765 {
 766         sigdelsetmask(set, ~_BLOCKABLE);
 767         spin_lock_irq(&current->sighand->siglock);
 768         current->blocked = *set;
 769         recalc_sigpending();
 770         spin_unlock_irq(&current->sighand->siglock);
 771 }
 772 #endif
 773
 774 /*
 775  * Set up a signal frame for a "real-time" signal handler
 776  * (one which gets siginfo).
 777  */
 778 static int handle_rt_signal(unsigned long sig, struct k_sigaction *ka,
 779                 siginfo_t *info, sigset_t *oldset,
 780                 struct pt_regs *regs, unsigned long newsp)
 781 {
 782         struct rt_sigframe __user *rt_sf;
 783         struct mcontext __user *frame;
 784         unsigned long origsp = newsp;
 785
 786         /* Set up Signal Frame */
 787         /* Put a Real Time Context onto stack */
 788         newsp -= sizeof(*rt_sf);
 789         rt_sf = (struct rt_sigframe __user *)newsp;
 790
 791         /* create a stack frame for the caller of the handler */
 792         newsp -= __SIGNAL_FRAMESIZE + 16;
 793
 794         if (!access_ok(VERIFY_WRITE, (void __user *)newsp, origsp - newsp))
 795                 goto badframe;
 796
 797         /* Put the siginfo & fill in most of the ucontext */
 798         if (copy_siginfo_to_user(&rt_sf->info, info)
 799             || __put_user(0, &rt_sf->uc.uc_flags)
 800             || __put_user(0, &rt_sf->uc.uc_link)
 801             || __put_user(current->sas_ss_sp, &rt_sf->uc.uc_stack.ss_sp)
 802             || __put_user(sas_ss_flags(regs->gpr[1]),
 803                           &rt_sf->uc.uc_stack.ss_flags)
 804             || __put_user(current->sas_ss_size, &rt_sf->uc.uc_stack.ss_size)
 805             || __put_user(to_user_ptr(&rt_sf->uc.uc_mcontext),
 806                     &rt_sf->uc.uc_regs)
 807             || put_sigset_t(&rt_sf->uc.uc_sigmask, oldset))
 808                 goto badframe;
 809
 810         /* Save user registers on the stack */
 811         frame = &rt_sf->uc.uc_mcontext;
 812 #ifdef CONFIG_PPC64
 813         if (vdso32_rt_sigtramp && current->thread.vdso_base) {
 814                 if (save_user_regs(regs, frame, 0))
 815                         goto badframe;
 816                 regs->link = current->thread.vdso_base + vdso32_rt_sigtramp;
 817         } else
 818 #endif
 819         {
 820                 if (save_user_regs(regs, frame, __NR_rt_sigreturn))
 821                         goto badframe;
 822                 regs->link = (unsigned long) frame->tramp;
 823         }
 824         if (put_user(regs->gpr[1], (unsigned long __user *)newsp))
 825                 goto badframe;
 826         regs->gpr[1] = newsp;
 827         regs->gpr[3] = sig;
 828         regs->gpr[4] = (unsigned long) &rt_sf->info;
 829         regs->gpr[5] = (unsigned long) &rt_sf->uc;
 830         regs->gpr[6] = (unsigned long) rt_sf;
 831         regs->nip = (unsigned long) ka->sa.sa_handler;
 832         regs->link = (unsigned long) frame->tramp;
 833         regs->trap = 0;
 834 #ifdef CONFIG_PPC64
 835         regs->result = 0;
 836
 837         if (test_thread_flag(TIF_SINGLESTEP))
 838                 ptrace_notify(SIGTRAP);
 839 #endif
 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         force_sigsegv(sig, current);
 848         return 0;
 849 }
 850
 851 static int do_setcontext(struct ucontext __user *ucp, struct pt_regs *regs, int sig)
 852 {
 853         sigset_t set;
 854         struct mcontext __user *mcp;
 855
 856         if (get_sigset_t(&set, &ucp->uc_sigmask))
 857                 return -EFAULT;
 858 #ifdef CONFIG_PPC64
 859         {
 860                 u32 cmcp;
 861
 862                 if (__get_user(cmcp, &ucp->uc_regs))
 863                         return -EFAULT;
 864                 mcp = (struct mcontext __user *)(u64)cmcp;
 865         }
 866 #else
 867         if (__get_user(mcp, &ucp->uc_regs))
 868                 return -EFAULT;
 869 #endif
 870         restore_sigmask(&set);
 871         if (restore_user_regs(regs, mcp, sig))
 872                 return -EFAULT;
 873
 874         return 0;
 875 }
 876
 877 long sys_swapcontext(struct ucontext __user *old_ctx,
 878                        struct ucontext __user *new_ctx,
 879                        int ctx_size, int r6, int r7, int r8, struct pt_regs *regs)
 880 {
 881         unsigned char tmp;
 882
 883         /* Context size is for future use. Right now, we only make sure
 884          * we are passed something we understand
 885          */
 886         if (ctx_size < sizeof(struct ucontext))
 887                 return -EINVAL;
 888
 889         if (old_ctx != NULL) {
 890                 if (!access_ok(VERIFY_WRITE, old_ctx, sizeof(*old_ctx))
 891                     || save_user_regs(regs, &old_ctx->uc_mcontext, 0)
 892                     || put_sigset_t(&old_ctx->uc_sigmask, &current->blocked)
 893                     || __put_user(to_user_ptr(&old_ctx->uc_mcontext),
 894                             &old_ctx->uc_regs))
 895                         return -EFAULT;
 896         }
 897         if (new_ctx == NULL)
 898                 return 0;
 899         if (!access_ok(VERIFY_READ, new_ctx, sizeof(*new_ctx))
 900             || __get_user(tmp, (u8 __user *) new_ctx)
 901             || __get_user(tmp, (u8 __user *) (new_ctx + 1) - 1))
 902                 return -EFAULT;
 903
 904         /*
 905          * If we get a fault copying the context into the kernel's
 906          * image of the user's registers, we can't just return -EFAULT
 907          * because the user's registers will be corrupted.  For instance
 908          * the NIP value may have been updated but not some of the
 909          * other registers.  Given that we have done the access_ok
 910          * and successfully read the first and last bytes of the region
 911          * above, this should only happen in an out-of-memory situation
 912          * or if another thread unmaps the region containing the context.
 913          * We kill the task with a SIGSEGV in this situation.
 914          */
 915         if (do_setcontext(new_ctx, regs, 0))
 916                 do_exit(SIGSEGV);
 917         sigreturn_exit(regs);
 918         /* doesn't actually return back to here */
 919         return 0;
 920 }
 921
 922 long sys_rt_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
 923                      struct pt_regs *regs)
 924 {
 925         struct rt_sigframe __user *rt_sf;
 926
 927         /* Always make any pending restarted system calls return -EINTR */
 928         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 929
 930         rt_sf = (struct rt_sigframe __user *)
 931                 (regs->gpr[1] + __SIGNAL_FRAMESIZE + 16);
 932         if (!access_ok(VERIFY_READ, rt_sf, sizeof(*rt_sf)))
 933                 goto bad;
 934         if (do_setcontext(&rt_sf->uc, regs, 1))
 935                 goto bad;
 936
 937         /*
 938          * It's not clear whether or why it is desirable to save the
 939          * sigaltstack setting on signal delivery and restore it on
 940          * signal return.  But other architectures do this and we have
 941          * always done it up until now so it is probably better not to
 942          * change it.  -- paulus
 943          */
 944 #ifdef CONFIG_PPC64
 945         /*
 946          * We use the compat_sys_ version that does the 32/64 bits conversion
 947          * and takes userland pointer directly. What about error checking ?
 948          * nobody does any...
 949          */
 950         compat_sys_sigaltstack((u32)(u64)&rt_sf->uc.uc_stack, 0, 0, 0, 0, 0, regs);
 951         return (int)regs->result;
 952 #else
 953         do_sigaltstack(&rt_sf->uc.uc_stack, NULL, regs->gpr[1]);
 954         sigreturn_exit(regs);           /* doesn't return here */
 955         return 0;
 956 #endif
 957
 958  bad:
 959         force_sig(SIGSEGV, current);
 960         return 0;
 961 }
 962
 963 #ifdef CONFIG_PPC32
 964 int sys_debug_setcontext(struct ucontext __user *ctx,
 965                          int ndbg, struct sig_dbg_op __user *dbg,
 966                          int r6, int r7, int r8,
 967                          struct pt_regs *regs)
 968 {
 969         struct sig_dbg_op op;
 970         int i;
 971         unsigned long new_msr = regs->msr;
 972 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 973         unsigned long new_dbcr0 = current->thread.dbcr0;
 974 #endif
 975
 976         for (i=0; i<ndbg; i++) {
 977                 if (__copy_from_user(&op, dbg, sizeof(op)))
 978                         return -EFAULT;
 979                 switch (op.dbg_type) {
 980                 case SIG_DBG_SINGLE_STEPPING:
 981 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 982                         if (op.dbg_value) {
 983                                 new_msr |= MSR_DE;
 984                                 new_dbcr0 |= (DBCR0_IDM | DBCR0_IC);
 985                         } else {
 986                                 new_msr &= ~MSR_DE;
 987                                 new_dbcr0 &= ~(DBCR0_IDM | DBCR0_IC);
 988                         }
 989 #else
 990                         if (op.dbg_value)
 991                                 new_msr |= MSR_SE;
 992                         else
 993                                 new_msr &= ~MSR_SE;
 994 #endif
 995                         break;
 996                 case SIG_DBG_BRANCH_TRACING:
 997 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
 998                         return -EINVAL;
 999 #else
1000                         if (op.dbg_value)
1001                                 new_msr |= MSR_BE;
1002                         else
1003                                 new_msr &= ~MSR_BE;
1004 #endif
1005                         break;
1006
1007                 default:
1008                         return -EINVAL;
1009                 }
1010         }
1011
1012         /* We wait until here to actually install the values in the
1013            registers so if we fail in the above loop, it will not
1014            affect the contents of these registers.  After this point,
1015            failure is a problem, anyway, and it's very unlikely unless
1016            the user is really doing something wrong. */
1017         regs->msr = new_msr;
1018 #if defined(CONFIG_4xx) || defined(CONFIG_BOOKE)
1019         current->thread.dbcr0 = new_dbcr0;
1020 #endif
1021
1022         /*
1023          * If we get a fault copying the context into the kernel's
1024          * image of the user's registers, we can't just return -EFAULT
1025          * because the user's registers will be corrupted.  For instance
1026          * the NIP value may have been updated but not some of the
1027          * other registers.  Given that we have done the access_ok
1028          * and successfully read the first and last bytes of the region
1029          * above, this should only happen in an out-of-memory situation
1030          * or if another thread unmaps the region containing the context.
1031          * We kill the task with a SIGSEGV in this situation.
1032          */
1033         if (do_setcontext(ctx, regs, 1)) {
1034                 force_sig(SIGSEGV, current);
1035                 goto out;
1036         }
1037
1038         /*
1039          * It's not clear whether or why it is desirable to save the
1040          * sigaltstack setting on signal delivery and restore it on
1041          * signal return.  But other architectures do this and we have
1042          * always done it up until now so it is probably better not to
1043          * change it.  -- paulus
1044          */
1045         do_sigaltstack(&ctx->uc_stack, NULL, regs->gpr[1]);
1046
1047         sigreturn_exit(regs);
1048         /* doesn't actually return back to here */
1049
1050  out:
1051         return 0;
1052 }
1053 #endif
1054
1055 /*
1056  * OK, we're invoking a handler
1057  */
1058 static int handle_signal(unsigned long sig, struct k_sigaction *ka,
1059                 siginfo_t *info, sigset_t *oldset, struct pt_regs *regs,
1060                 unsigned long newsp)
1061 {
1062         struct sigcontext __user *sc;
1063         struct sigregs __user *frame;
1064         unsigned long origsp = newsp;
1065
1066         /* Set up Signal Frame */
1067         newsp -= sizeof(struct sigregs);
1068         frame = (struct sigregs __user *) newsp;
1069
1070         /* Put a sigcontext on the stack */
1071         newsp -= sizeof(*sc);
1072         sc = (struct sigcontext __user *) newsp;
1073
1074         /* create a stack frame for the caller of the handler */
1075         newsp -= __SIGNAL_FRAMESIZE;
1076
1077         if (!access_ok(VERIFY_WRITE, (void __user *) newsp, origsp - newsp))
1078                 goto badframe;
1079
1080 #if _NSIG != 64
1081 #error "Please adjust handle_signal()"
1082 #endif
1083         if (__put_user(to_user_ptr(ka->sa.sa_handler), &sc->handler)
1084             || __put_user(oldset->sig[0], &sc->oldmask)
1085 #ifdef CONFIG_PPC64
1086             || __put_user((oldset->sig[0] >> 32), &sc->_unused[3])
1087 #else
1088             || __put_user(oldset->sig[1], &sc->_unused[3])
1089 #endif
1090             || __put_user(to_user_ptr(frame), &sc->regs)
1091             || __put_user(sig, &sc->signal))
1092                 goto badframe;
1093
1094 #ifdef CONFIG_PPC64
1095         if (vdso32_sigtramp && current->thread.vdso_base) {
1096                 if (save_user_regs(regs, &frame->mctx, 0))
1097                         goto badframe;
1098                 regs->link = current->thread.vdso_base + vdso32_sigtramp;
1099         } else
1100 #endif
1101         {
1102                 if (save_user_regs(regs, &frame->mctx, __NR_sigreturn))
1103                         goto badframe;
1104                 regs->link = (unsigned long) frame->mctx.tramp;
1105         }
1106
1107         if (put_user(regs->gpr[1], (u32 __user *)newsp))
1108                 goto badframe;
1109         regs->gpr[1] = newsp;
1110         regs->gpr[3] = sig;
1111         regs->gpr[4] = (unsigned long) sc;
1112         regs->nip = (unsigned long) ka->sa.sa_handler;
1113         regs->trap = 0;
1114 #ifdef CONFIG_PPC64
1115         regs->result = 0;
1116
1117         if (test_thread_flag(TIF_SINGLESTEP))
1118                 ptrace_notify(SIGTRAP);
1119 #endif
1120
1121         return 1;
1122
1123 badframe:
1124 #ifdef DEBUG_SIG
1125         printk("badframe in handle_signal, regs=%p frame=%p newsp=%lx\n",
1126                regs, frame, newsp);
1127 #endif
1128         force_sigsegv(sig, current);
1129         return 0;
1130 }
1131
1132 /*
1133  * Do a signal return; undo the signal stack.
1134  */
1135 long sys_sigreturn(int r3, int r4, int r5, int r6, int r7, int r8,
1136                        struct pt_regs *regs)
1137 {
1138         struct sigcontext __user *sc;
1139         struct sigcontext sigctx;
1140         struct mcontext __user *sr;
1141         sigset_t set;
1142
1143         /* Always make any pending restarted system calls return -EINTR */
1144         current_thread_info()->restart_block.fn = do_no_restart_syscall;
1145
1146         sc = (struct sigcontext __user *)(regs->gpr[1] + __SIGNAL_FRAMESIZE);
1147         if (copy_from_user(&sigctx, sc, sizeof(sigctx)))
1148                 goto badframe;
1149
1150 #ifdef CONFIG_PPC64
1151         /*
1152          * Note that PPC32 puts the upper 32 bits of the sigmask in the
1153          * unused part of the signal stackframe
1154          */
1155         set.sig[0] = sigctx.oldmask + ((long)(sigctx._unused[3]) << 32);
1156 #else
1157         set.sig[0] = sigctx.oldmask;
1158         set.sig[1] = sigctx._unused[3];
1159 #endif
1160         restore_sigmask(&set);
1161
1162         sr = (struct mcontext __user *)from_user_ptr(sigctx.regs);
1163         if (!access_ok(VERIFY_READ, sr, sizeof(*sr))
1164             || restore_user_regs(regs, sr, 1))
1165                 goto badframe;
1166
1167 #ifdef CONFIG_PPC64
1168         return (int)regs->result;
1169 #else
1170         sigreturn_exit(regs);           /* doesn't return */
1171         return 0;
1172 #endif
1173
1174 badframe:
1175         force_sig(SIGSEGV, current);
1176         return 0;
1177 }
1178
1179 /*
1180  * Note that 'init' is a special process: it doesn't get signals it doesn't
1181  * want to handle. Thus you cannot kill init even with a SIGKILL even by
1182  * mistake.
1183  */
1184 int do_signal(sigset_t *oldset, struct pt_regs *regs)
1185 {
1186         siginfo_t info;
1187         struct k_sigaction ka;
1188         unsigned int frame, newsp;
1189         int signr, ret;
1190
1191 #ifdef CONFIG_PPC32
1192         if (try_to_freeze()) {
1193                 signr = 0;
1194                 if (!signal_pending(current))
1195                         goto no_signal;
1196         }
1197 #endif
1198
1199         if (!oldset)
1200                 oldset = &current->blocked;
1201
1202         newsp = frame = 0;
1203
1204         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
1205 #ifdef CONFIG_PPC32
1206 no_signal:
1207 #endif
1208         if (TRAP(regs) == 0x0C00                /* System Call! */
1209             && regs->ccr & 0x10000000           /* error signalled */
1210             && ((ret = regs->gpr[3]) == ERESTARTSYS
1211                 || ret == ERESTARTNOHAND || ret == ERESTARTNOINTR
1212                 || ret == ERESTART_RESTARTBLOCK)) {
1213
1214                 if (signr > 0
1215                     && (ret == ERESTARTNOHAND || ret == ERESTART_RESTARTBLOCK
1216                         || (ret == ERESTARTSYS
1217                             && !(ka.sa.sa_flags & SA_RESTART)))) {
1218                         /* make the system call return an EINTR error */
1219                         regs->result = -EINTR;
1220                         regs->gpr[3] = EINTR;
1221                         /* note that the cr0.SO bit is already set */
1222                 } else {
1223                         regs->nip -= 4; /* Back up & retry system call */
1224                         regs->result = 0;
1225                         regs->trap = 0;
1226                         if (ret == ERESTART_RESTARTBLOCK)
1227                                 regs->gpr[0] = __NR_restart_syscall;
1228                         else
1229                                 regs->gpr[3] = regs->orig_gpr3;
1230                 }
1231         }
1232
1233         if (signr == 0)
1234                 return 0;               /* no signals delivered */
1235
1236         if ((ka.sa.sa_flags & SA_ONSTACK) && current->sas_ss_size
1237             && !on_sig_stack(regs->gpr[1]))
1238                 newsp = current->sas_ss_sp + current->sas_ss_size;
1239         else
1240                 newsp = regs->gpr[1];
1241         newsp &= ~0xfUL;
1242
1243 #ifdef CONFIG_PPC64
1244         /*
1245          * Reenable the DABR before delivering the signal to
1246          * user space. The DABR will have been cleared if it
1247          * triggered inside the kernel.
1248          */
1249         if (current->thread.dabr)
1250                 set_dabr(current->thread.dabr);
1251 #endif
1252
1253         /* Whee!  Actually deliver the signal.  */
1254         if (ka.sa.sa_flags & SA_SIGINFO)
1255                 ret = handle_rt_signal(signr, &ka, &info, oldset, regs, newsp);
1256         else
1257                 ret = handle_signal(signr, &ka, &info, oldset, regs, newsp);
1258
1259         if (ret) {
1260                 spin_lock_irq(&current->sighand->siglock);
1261                 sigorsets(&current->blocked, &current->blocked,
1262                           &ka.sa.sa_mask);
1263                 if (!(ka.sa.sa_flags & SA_NODEFER))
1264                         sigaddset(&current->blocked, signr);
1265                 recalc_sigpending();
1266                 spin_unlock_irq(&current->sighand->siglock);
1267         }
1268
1269         return ret;
1270 }