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