arch/s390/kernel/compat_signal.c

   1 /*
   2  *  arch/s390/kernel/signal32.c
   3  *
   4  *  S390 version
   5  *    Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation
   6  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
   7  *               Gerhard Tonn (ton@de.ibm.com)
   8  *
   9  *  Copyright (C) 1991, 1992  Linus Torvalds
  10  *
  11  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  12  */
  13
  14 #include <linux/config.h>
  15 #include <linux/compat.h>
  16 #include <linux/sched.h>
  17 #include <linux/mm.h>
  18 #include <linux/smp.h>
  19 #include <linux/smp_lock.h>
  20 #include <linux/kernel.h>
  21 #include <linux/signal.h>
  22 #include <linux/errno.h>
  23 #include <linux/wait.h>
  24 #include <linux/ptrace.h>
  25 #include <linux/unistd.h>
  26 #include <linux/stddef.h>
  27 #include <linux/tty.h>
  28 #include <linux/personality.h>
  29 #include <linux/binfmts.h>
  30 #include <asm/ucontext.h>
  31 #include <asm/uaccess.h>
  32 #include <asm/lowcore.h>
  33 #include "compat_linux.h"
  34 #include "compat_ptrace.h"
  35
  36 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  37
  38 typedef struct
  39 {
  40         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  41         struct sigcontext32 sc;
  42         _sigregs32 sregs;
  43         __u8 retcode[S390_SYSCALL_SIZE];
  44 } sigframe32;
  45
  46 typedef struct
  47 {
  48         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  49         __u8 retcode[S390_SYSCALL_SIZE];
  50         struct siginfo32 info;
  51         struct ucontext32 uc;
  52 } rt_sigframe32;
  53
  54 asmlinkage int FASTCALL(do_signal(struct pt_regs *regs, sigset_t *oldset));
  55
  56 int copy_siginfo_to_user32(siginfo_t32 __user *to, siginfo_t *from)
  57 {
  58         int err;
  59
  60         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t32)))
  61                 return -EFAULT;
  62
  63         /* If you change siginfo_t structure, please be sure
  64            this code is fixed accordingly.
  65            It should never copy any pad contained in the structure
  66            to avoid security leaks, but must copy the generic
  67            3 ints plus the relevant union member.
  68            This routine must convert siginfo from 64bit to 32bit as well
  69            at the same time.  */
  70         err = __put_user(from->si_signo, &to->si_signo);
  71         err |= __put_user(from->si_errno, &to->si_errno);
  72         err |= __put_user((short)from->si_code, &to->si_code);
  73         if (from->si_code < 0)
  74                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  75         else {
  76                 switch (from->si_code >> 16) {
  77                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
  78                 case __SI_MESGQ >> 16:
  79                         err |= __put_user(from->si_int, &to->si_int);
  80                         /* fallthrough */
  81                 case __SI_KILL >> 16:
  82                         err |= __put_user(from->si_pid, &to->si_pid);
  83                         err |= __put_user(from->si_uid, &to->si_uid);
  84                         break;
  85                 case __SI_CHLD >> 16:
  86                         err |= __put_user(from->si_pid, &to->si_pid);
  87                         err |= __put_user(from->si_uid, &to->si_uid);
  88                         err |= __put_user(from->si_utime, &to->si_utime);
  89                         err |= __put_user(from->si_stime, &to->si_stime);
  90                         err |= __put_user(from->si_status, &to->si_status);
  91                         break;
  92                 case __SI_FAULT >> 16:
  93                         err |= __put_user((unsigned long) from->si_addr,
  94                                           &to->si_addr);
  95                         break;
  96                 case __SI_POLL >> 16:
  97                 case __SI_TIMER >> 16:
  98                         err |= __put_user(from->si_band, &to->si_band);
  99                         err |= __put_user(from->si_fd, &to->si_fd);
 100                         break;
 101                 default:
 102                         break;
 103                 }
 104         }
 105         return err;
 106 }
 107
 108 /*
 109  * Atomically swap in the new signal mask, and wait for a signal.
 110  */
 111 asmlinkage int
 112 sys32_sigsuspend(struct pt_regs * regs,int history0, int history1, old_sigset_t mask)
 113 {
 114         sigset_t saveset;
 115
 116         mask &= _BLOCKABLE;
 117         spin_lock_irq(&current->sighand->siglock);
 118         saveset = current->blocked;
 119         siginitset(&current->blocked, mask);
 120         recalc_sigpending();
 121         spin_unlock_irq(&current->sighand->siglock);
 122         regs->gprs[2] = -EINTR;
 123
 124         while (1) {
 125                 set_current_state(TASK_INTERRUPTIBLE);
 126                 schedule();
 127                 if (do_signal(regs, &saveset))
 128                         return -EINTR;
 129         }
 130 }
 131
 132 asmlinkage int
 133 sys32_rt_sigsuspend(struct pt_regs * regs, compat_sigset_t __user *unewset,
 134                                                                 size_t sigsetsize)
 135 {
 136         sigset_t saveset, newset;
 137         compat_sigset_t set32;
 138
 139         /* XXX: Don't preclude handling different sized sigset_t's.  */
 140         if (sigsetsize != sizeof(sigset_t))
 141                 return -EINVAL;
 142
 143         if (copy_from_user(&set32, unewset, sizeof(set32)))
 144                 return -EFAULT;
 145         switch (_NSIG_WORDS) {
 146         case 4: newset.sig[3] = set32.sig[6] + (((long)set32.sig[7]) << 32);
 147         case 3: newset.sig[2] = set32.sig[4] + (((long)set32.sig[5]) << 32);
 148         case 2: newset.sig[1] = set32.sig[2] + (((long)set32.sig[3]) << 32);
 149         case 1: newset.sig[0] = set32.sig[0] + (((long)set32.sig[1]) << 32);
 150         }
 151         sigdelsetmask(&newset, ~_BLOCKABLE);
 152
 153         spin_lock_irq(&current->sighand->siglock);
 154         saveset = current->blocked;
 155         current->blocked = newset;
 156         recalc_sigpending();
 157         spin_unlock_irq(&current->sighand->siglock);
 158         regs->gprs[2] = -EINTR;
 159
 160         while (1) {
 161                 set_current_state(TASK_INTERRUPTIBLE);
 162                 schedule();
 163                 if (do_signal(regs, &saveset))
 164                         return -EINTR;
 165         }
 166 }
 167
 168 asmlinkage long
 169 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
 170                  struct old_sigaction32 __user *oact)
 171 {
 172         struct k_sigaction new_ka, old_ka;
 173         int ret;
 174
 175         if (act) {
 176                 compat_old_sigset_t mask;
 177                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 178                     __get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler) ||
 179                     __get_user((unsigned long)new_ka.sa.sa_restorer, &act->sa_restorer))
 180                         return -EFAULT;
 181                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 182                 __get_user(mask, &act->sa_mask);
 183                 siginitset(&new_ka.sa.sa_mask, mask);
 184         }
 185
 186         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 187
 188         if (!ret && oact) {
 189                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 190                     __put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler) ||
 191                     __put_user((unsigned long)old_ka.sa.sa_restorer, &oact->sa_restorer))
 192                         return -EFAULT;
 193                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 194                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 195         }
 196
 197         return ret;
 198 }
 199
 200 int
 201 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
 202
 203 asmlinkage long
 204 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
 205            struct sigaction32 __user *oact,  size_t sigsetsize)
 206 {
 207         struct k_sigaction new_ka, old_ka;
 208         int ret;
 209         compat_sigset_t set32;
 210
 211         /* XXX: Don't preclude handling different sized sigset_t's.  */
 212         if (sigsetsize != sizeof(compat_sigset_t))
 213                 return -EINVAL;
 214
 215         if (act) {
 216                 ret = get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler);
 217                 ret |= __copy_from_user(&set32, &act->sa_mask,
 218                                         sizeof(compat_sigset_t));
 219                 switch (_NSIG_WORDS) {
 220                 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
 221                                 | (((long)set32.sig[7]) << 32);
 222                 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
 223                                 | (((long)set32.sig[5]) << 32);
 224                 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
 225                                 | (((long)set32.sig[3]) << 32);
 226                 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
 227                                 | (((long)set32.sig[1]) << 32);
 228                 }
 229                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 230
 231                 if (ret)
 232                         return -EFAULT;
 233         }
 234
 235         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 236
 237         if (!ret && oact) {
 238                 switch (_NSIG_WORDS) {
 239                 case 4:
 240                         set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
 241                         set32.sig[6] = old_ka.sa.sa_mask.sig[3];
 242                 case 3:
 243                         set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
 244                         set32.sig[4] = old_ka.sa.sa_mask.sig[2];
 245                 case 2:
 246                         set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
 247                         set32.sig[2] = old_ka.sa.sa_mask.sig[1];
 248                 case 1:
 249                         set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
 250                         set32.sig[0] = old_ka.sa.sa_mask.sig[0];
 251                 }
 252                 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
 253                 ret |= __copy_to_user(&oact->sa_mask, &set32,
 254                                       sizeof(compat_sigset_t));
 255                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 256         }
 257
 258         return ret;
 259 }
 260
 261 asmlinkage long
 262 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss,
 263                                                         struct pt_regs *regs)
 264 {
 265         stack_t kss, koss;
 266         int ret, err = 0;
 267         mm_segment_t old_fs = get_fs();
 268
 269         if (uss) {
 270                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
 271                         return -EFAULT;
 272                 err |= __get_user((unsigned long) kss.ss_sp, &uss->ss_sp);
 273                 err |= __get_user(kss.ss_size, &uss->ss_size);
 274                 err |= __get_user(kss.ss_flags, &uss->ss_flags);
 275                 if (err)
 276                         return -EFAULT;
 277         }
 278
 279         set_fs (KERNEL_DS);
 280         ret = do_sigaltstack((stack_t __user *) (uss ? &kss : NULL),
 281                              (stack_t __user *) (uoss ? &koss : NULL),
 282                              regs->gprs[15]);
 283         set_fs (old_fs);
 284
 285         if (!ret && uoss) {
 286                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
 287                         return -EFAULT;
 288                 err |= __put_user((unsigned long) koss.ss_sp, &uoss->ss_sp);
 289                 err |= __put_user(koss.ss_size, &uoss->ss_size);
 290                 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
 291                 if (err)
 292                         return -EFAULT;
 293         }
 294         return ret;
 295 }
 296
 297 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
 298 {
 299         _s390_regs_common32 regs32;
 300         int err, i;
 301
 302         regs32.psw.mask = PSW32_MASK_MERGE(PSW32_USER_BITS,
 303                                            (__u32)(regs->psw.mask >> 32));
 304         regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
 305         for (i = 0; i < NUM_GPRS; i++)
 306                 regs32.gprs[i] = (__u32) regs->gprs[i];
 307         save_access_regs(current->thread.acrs);
 308         memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
 309         err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
 310         if (err)
 311                 return err;
 312         save_fp_regs(&current->thread.fp_regs);
 313         /* s390_fp_regs and _s390_fp_regs32 are the same ! */
 314         return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
 315                               sizeof(_s390_fp_regs32));
 316 }
 317
 318 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
 319 {
 320         _s390_regs_common32 regs32;
 321         int err, i;
 322
 323         /* Alwys make any pending restarted system call return -EINTR */
 324         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 325
 326         err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
 327         if (err)
 328                 return err;
 329         regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
 330                                         (__u64)regs32.psw.mask << 32);
 331         regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
 332         for (i = 0; i < NUM_GPRS; i++)
 333                 regs->gprs[i] = (__u64) regs32.gprs[i];
 334         memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
 335         restore_access_regs(current->thread.acrs);
 336
 337         err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
 338                                sizeof(_s390_fp_regs32));
 339         current->thread.fp_regs.fpc &= FPC_VALID_MASK;
 340         if (err)
 341                 return err;
 342
 343         restore_fp_regs(&current->thread.fp_regs);
 344         regs->trap = -1;        /* disable syscall checks */
 345         return 0;
 346 }
 347
 348 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 349 {
 350         sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
 351         sigset_t set;
 352
 353         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 354                 goto badframe;
 355         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
 356                 goto badframe;
 357
 358         sigdelsetmask(&set, ~_BLOCKABLE);
 359         spin_lock_irq(&current->sighand->siglock);
 360         current->blocked = set;
 361         recalc_sigpending();
 362         spin_unlock_irq(&current->sighand->siglock);
 363
 364         if (restore_sigregs32(regs, &frame->sregs))
 365                 goto badframe;
 366
 367         return regs->gprs[2];
 368
 369 badframe:
 370         force_sig(SIGSEGV, current);
 371         return 0;
 372 }
 373
 374 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 375 {
 376         rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
 377         sigset_t set;
 378         stack_t st;
 379         __u32 ss_sp;
 380         int err;
 381         mm_segment_t old_fs = get_fs();
 382
 383         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 384                 goto badframe;
 385         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 386                 goto badframe;
 387
 388         sigdelsetmask(&set, ~_BLOCKABLE);
 389         spin_lock_irq(&current->sighand->siglock);
 390         current->blocked = set;
 391         recalc_sigpending();
 392         spin_unlock_irq(&current->sighand->siglock);
 393
 394         if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
 395                 goto badframe;
 396
 397         err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
 398         st.ss_sp = (void *) A((unsigned long)ss_sp);
 399         err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
 400         err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
 401         if (err)
 402                 goto badframe;
 403
 404         /* It is more difficult to avoid calling this function than to
 405            call it and ignore errors.  */
 406         set_fs (KERNEL_DS);
 407         do_sigaltstack((stack_t __user *)&st, NULL, regs->gprs[15]);
 408         set_fs (old_fs);
 409
 410         return regs->gprs[2];
 411
 412 badframe:
 413         force_sig(SIGSEGV, current);
 414         return 0;
 415 }
 416
 417 /*
 418  * Set up a signal frame.
 419  */
 420
 421
 422 /*
 423  * Determine which stack to use..
 424  */
 425 static inline void __user *
 426 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 427 {
 428         unsigned long sp;
 429
 430         /* Default to using normal stack */
 431         sp = (unsigned long) A(regs->gprs[15]);
 432
 433         /* This is the X/Open sanctioned signal stack switching.  */
 434         if (ka->sa.sa_flags & SA_ONSTACK) {
 435                 if (! on_sig_stack(sp))
 436                         sp = current->sas_ss_sp + current->sas_ss_size;
 437         }
 438
 439         /* This is the legacy signal stack switching. */
 440         else if (!user_mode(regs) &&
 441                  !(ka->sa.sa_flags & SA_RESTORER) &&
 442                  ka->sa.sa_restorer) {
 443                 sp = (unsigned long) ka->sa.sa_restorer;
 444         }
 445
 446         return (void __user *)((sp - frame_size) & -8ul);
 447 }
 448
 449 static inline int map_signal(int sig)
 450 {
 451         if (current_thread_info()->exec_domain
 452             && current_thread_info()->exec_domain->signal_invmap
 453             && sig < 32)
 454                 return current_thread_info()->exec_domain->signal_invmap[sig];
 455         else
 456                 return sig;
 457 }
 458
 459 static void setup_frame32(int sig, struct k_sigaction *ka,
 460                         sigset_t *set, struct pt_regs * regs)
 461 {
 462         sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
 463         if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
 464                 goto give_sigsegv;
 465
 466         if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
 467                 goto give_sigsegv;
 468
 469         if (save_sigregs32(regs, &frame->sregs))
 470                 goto give_sigsegv;
 471         if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
 472                 goto give_sigsegv;
 473
 474         /* Set up to return from userspace.  If provided, use a stub
 475            already in userspace.  */
 476         if (ka->sa.sa_flags & SA_RESTORER) {
 477                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
 478         } else {
 479                 regs->gprs[14] = (__u64) frame->retcode;
 480                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
 481                                (u16 __user *)(frame->retcode)))
 482                         goto give_sigsegv;
 483         }
 484
 485         /* Set up backchain. */
 486         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 487                 goto give_sigsegv;
 488
 489         /* Set up registers for signal handler */
 490         regs->gprs[15] = (__u64) frame;
 491         regs->psw.addr = (__u64) ka->sa.sa_handler;
 492
 493         regs->gprs[2] = map_signal(sig);
 494         regs->gprs[3] = (__u64) &frame->sc;
 495
 496         /* We forgot to include these in the sigcontext.
 497            To avoid breaking binary compatibility, they are passed as args. */
 498         regs->gprs[4] = current->thread.trap_no;
 499         regs->gprs[5] = current->thread.prot_addr;
 500         return;
 501
 502 give_sigsegv:
 503         if (sig == SIGSEGV)
 504                 ka->sa.sa_handler = SIG_DFL;
 505         force_sig(SIGSEGV, current);
 506 }
 507
 508 static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
 509                            sigset_t *set, struct pt_regs * regs)
 510 {
 511         int err = 0;
 512         rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
 513         if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
 514                 goto give_sigsegv;
 515
 516         if (copy_siginfo_to_user32(&frame->info, info))
 517                 goto give_sigsegv;
 518
 519         /* Create the ucontext.  */
 520         err |= __put_user(0, &frame->uc.uc_flags);
 521         err |= __put_user(0, &frame->uc.uc_link);
 522         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 523         err |= __put_user(sas_ss_flags(regs->gprs[15]),
 524                           &frame->uc.uc_stack.ss_flags);
 525         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 526         err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
 527         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 528         if (err)
 529                 goto give_sigsegv;
 530
 531         /* Set up to return from userspace.  If provided, use a stub
 532            already in userspace.  */
 533         if (ka->sa.sa_flags & SA_RESTORER) {
 534                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
 535         } else {
 536                 regs->gprs[14] = (__u64) frame->retcode;
 537                 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
 538                                   (u16 __user *)(frame->retcode));
 539         }
 540
 541         /* Set up backchain. */
 542         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 543                 goto give_sigsegv;
 544
 545         /* Set up registers for signal handler */
 546         regs->gprs[15] = (__u64) frame;
 547         regs->psw.addr = (__u64) ka->sa.sa_handler;
 548
 549         regs->gprs[2] = map_signal(sig);
 550         regs->gprs[3] = (__u64) &frame->info;
 551         regs->gprs[4] = (__u64) &frame->uc;
 552         return;
 553
 554 give_sigsegv:
 555         if (sig == SIGSEGV)
 556                 ka->sa.sa_handler = SIG_DFL;
 557         force_sig(SIGSEGV, current);
 558 }
 559
 560 /*
 561  * OK, we're invoking a handler
 562  */
 563
 564 void
 565 handle_signal32(unsigned long sig, siginfo_t *info, sigset_t *oldset,
 566         struct pt_regs * regs)
 567 {
 568         struct k_sigaction *ka = &current->sighand->action[sig-1];
 569
 570         /* Set up the stack frame */
 571         if (ka->sa.sa_flags & SA_SIGINFO)
 572                 setup_rt_frame32(sig, ka, info, oldset, regs);
 573         else
 574                 setup_frame32(sig, ka, oldset, regs);
 575
 576         if (ka->sa.sa_flags & SA_ONESHOT)
 577                 ka->sa.sa_handler = SIG_DFL;
 578
 579         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 580                 spin_lock_irq(&current->sighand->siglock);
 581                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 582                 sigaddset(&current->blocked,sig);
 583                 recalc_sigpending();
 584                 spin_unlock_irq(&current->sighand->siglock);
 585         }
 586 }
 587