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