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