git.oblomov.eu Git - linux-2.6/blob - arch/s390/kernel/compat_signal.c

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