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