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/config.h>
  14 #include <linux/compat.h>
  15 #include <linux/sched.h>
  16 #include <linux/mm.h>
  17 #include <linux/smp.h>
  18 #include <linux/smp_lock.h>
  19 #include <linux/kernel.h>
  20 #include <linux/signal.h>
  21 #include <linux/errno.h>
  22 #include <linux/wait.h>
  23 #include <linux/ptrace.h>
  24 #include <linux/unistd.h>
  25 #include <linux/stddef.h>
  26 #include <linux/tty.h>
  27 #include <linux/personality.h>
  28 #include <linux/binfmts.h>
  29 #include <asm/ucontext.h>
  30 #include <asm/uaccess.h>
  31 #include <asm/lowcore.h>
  32 #include "compat_linux.h"
  33 #include "compat_ptrace.h"
  34
  35 #define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
  36
  37 typedef struct
  38 {
  39         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  40         struct sigcontext32 sc;
  41         _sigregs32 sregs;
  42         int signo;
  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         compat_siginfo_t info;
  51         struct ucontext32 uc;
  52 } rt_sigframe32;
  53
  54 int copy_siginfo_to_user32(compat_siginfo_t __user *to, siginfo_t *from)
  55 {
  56         int err;
  57
  58         if (!access_ok (VERIFY_WRITE, to, sizeof(compat_siginfo_t)))
  59                 return -EFAULT;
  60
  61         /* If you change siginfo_t structure, please be sure
  62            this code is fixed accordingly.
  63            It should never copy any pad contained in the structure
  64            to avoid security leaks, but must copy the generic
  65            3 ints plus the relevant union member.
  66            This routine must convert siginfo from 64bit to 32bit as well
  67            at the same time.  */
  68         err = __put_user(from->si_signo, &to->si_signo);
  69         err |= __put_user(from->si_errno, &to->si_errno);
  70         err |= __put_user((short)from->si_code, &to->si_code);
  71         if (from->si_code < 0)
  72                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  73         else {
  74                 switch (from->si_code >> 16) {
  75                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
  76                 case __SI_MESGQ >> 16:
  77                         err |= __put_user(from->si_int, &to->si_int);
  78                         /* fallthrough */
  79                 case __SI_KILL >> 16:
  80                         err |= __put_user(from->si_pid, &to->si_pid);
  81                         err |= __put_user(from->si_uid, &to->si_uid);
  82                         break;
  83                 case __SI_CHLD >> 16:
  84                         err |= __put_user(from->si_pid, &to->si_pid);
  85                         err |= __put_user(from->si_uid, &to->si_uid);
  86                         err |= __put_user(from->si_utime, &to->si_utime);
  87                         err |= __put_user(from->si_stime, &to->si_stime);
  88                         err |= __put_user(from->si_status, &to->si_status);
  89                         break;
  90                 case __SI_FAULT >> 16:
  91                         err |= __put_user((unsigned long) from->si_addr,
  92                                           &to->si_addr);
  93                         break;
  94                 case __SI_POLL >> 16:
  95                         err |= __put_user(from->si_band, &to->si_band);
  96                         err |= __put_user(from->si_fd, &to->si_fd);
  97                         break;
  98                 case __SI_TIMER >> 16:
  99                         err |= __put_user(from->si_tid, &to->si_tid);
 100                         err |= __put_user(from->si_overrun, &to->si_overrun);
 101                         err |= __put_user(from->si_int, &to->si_int);
 102                         break;
 103                 default:
 104                         break;
 105                 }
 106         }
 107         return err;
 108 }
 109
 110 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 111 {
 112         int err;
 113         u32 tmp;
 114
 115         if (!access_ok (VERIFY_READ, from, sizeof(compat_siginfo_t)))
 116                 return -EFAULT;
 117
 118         err = __get_user(to->si_signo, &from->si_signo);
 119         err |= __get_user(to->si_errno, &from->si_errno);
 120         err |= __get_user(to->si_code, &from->si_code);
 121
 122         if (to->si_code < 0)
 123                 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 124         else {
 125                 switch (to->si_code >> 16) {
 126                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 127                 case __SI_MESGQ >> 16:
 128                         err |= __get_user(to->si_int, &from->si_int);
 129                         /* fallthrough */
 130                 case __SI_KILL >> 16:
 131                         err |= __get_user(to->si_pid, &from->si_pid);
 132                         err |= __get_user(to->si_uid, &from->si_uid);
 133                         break;
 134                 case __SI_CHLD >> 16:
 135                         err |= __get_user(to->si_pid, &from->si_pid);
 136                         err |= __get_user(to->si_uid, &from->si_uid);
 137                         err |= __get_user(to->si_utime, &from->si_utime);
 138                         err |= __get_user(to->si_stime, &from->si_stime);
 139                         err |= __get_user(to->si_status, &from->si_status);
 140                         break;
 141                 case __SI_FAULT >> 16:
 142                         err |= __get_user(tmp, &from->si_addr);
 143                         to->si_addr = (void __user *)(u64) (tmp & PSW32_ADDR_INSN);
 144                         break;
 145                 case __SI_POLL >> 16:
 146                         err |= __get_user(to->si_band, &from->si_band);
 147                         err |= __get_user(to->si_fd, &from->si_fd);
 148                         break;
 149                 case __SI_TIMER >> 16:
 150                         err |= __get_user(to->si_tid, &from->si_tid);
 151                         err |= __get_user(to->si_overrun, &from->si_overrun);
 152                         err |= __get_user(to->si_int, &from->si_int);
 153                         break;
 154                 default:
 155                         break;
 156                 }
 157         }
 158         return err;
 159 }
 160
 161 asmlinkage long
 162 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
 163                  struct old_sigaction32 __user *oact)
 164 {
 165         struct k_sigaction new_ka, old_ka;
 166         unsigned long sa_handler, sa_restorer;
 167         int ret;
 168
 169         if (act) {
 170                 compat_old_sigset_t mask;
 171                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 172                     __get_user(sa_handler, &act->sa_handler) ||
 173                     __get_user(sa_restorer, &act->sa_restorer))
 174                         return -EFAULT;
 175                 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
 176                 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
 177                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 178                 __get_user(mask, &act->sa_mask);
 179                 siginitset(&new_ka.sa.sa_mask, mask);
 180         }
 181
 182         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 183
 184         if (!ret && oact) {
 185                 sa_handler = (unsigned long) old_ka.sa.sa_handler;
 186                 sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
 187                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 188                     __put_user(sa_handler, &oact->sa_handler) ||
 189                     __put_user(sa_restorer, &oact->sa_restorer))
 190                         return -EFAULT;
 191                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 192                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 193         }
 194
 195         return ret;
 196 }
 197
 198 int
 199 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
 200
 201 asmlinkage long
 202 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
 203            struct sigaction32 __user *oact,  size_t sigsetsize)
 204 {
 205         struct k_sigaction new_ka, old_ka;
 206         unsigned long sa_handler;
 207         int ret;
 208         compat_sigset_t set32;
 209
 210         /* XXX: Don't preclude handling different sized sigset_t's.  */
 211         if (sigsetsize != sizeof(compat_sigset_t))
 212                 return -EINVAL;
 213
 214         if (act) {
 215                 ret = get_user(sa_handler, &act->sa_handler);
 216                 ret |= __copy_from_user(&set32, &act->sa_mask,
 217                                         sizeof(compat_sigset_t));
 218                 switch (_NSIG_WORDS) {
 219                 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
 220                                 | (((long)set32.sig[7]) << 32);
 221                 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
 222                                 | (((long)set32.sig[5]) << 32);
 223                 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
 224                                 | (((long)set32.sig[3]) << 32);
 225                 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
 226                                 | (((long)set32.sig[1]) << 32);
 227                 }
 228                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 229
 230                 if (ret)
 231                         return -EFAULT;
 232                 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
 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         unsigned long ss_sp;
 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(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                 kss.ss_sp = (void __user *) ss_sp;
 279         }
 280
 281         set_fs (KERNEL_DS);
 282         ret = do_sigaltstack((stack_t __user *) (uss ? &kss : NULL),
 283                              (stack_t __user *) (uoss ? &koss : NULL),
 284                              regs->gprs[15]);
 285         set_fs (old_fs);
 286
 287         if (!ret && uoss) {
 288                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
 289                         return -EFAULT;
 290                 ss_sp = (unsigned long) koss.ss_sp;
 291                 err |= __put_user(ss_sp, &uoss->ss_sp);
 292                 err |= __put_user(koss.ss_size, &uoss->ss_size);
 293                 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
 294                 if (err)
 295                         return -EFAULT;
 296         }
 297         return ret;
 298 }
 299
 300 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
 301 {
 302         _s390_regs_common32 regs32;
 303         int err, i;
 304
 305         regs32.psw.mask = PSW32_MASK_MERGE(PSW32_USER_BITS,
 306                                            (__u32)(regs->psw.mask >> 32));
 307         regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
 308         for (i = 0; i < NUM_GPRS; i++)
 309                 regs32.gprs[i] = (__u32) regs->gprs[i];
 310         save_access_regs(current->thread.acrs);
 311         memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
 312         err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
 313         if (err)
 314                 return err;
 315         save_fp_regs(&current->thread.fp_regs);
 316         /* s390_fp_regs and _s390_fp_regs32 are the same ! */
 317         return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
 318                               sizeof(_s390_fp_regs32));
 319 }
 320
 321 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
 322 {
 323         _s390_regs_common32 regs32;
 324         int err, i;
 325
 326         /* Alwys make any pending restarted system call return -EINTR */
 327         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 328
 329         err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
 330         if (err)
 331                 return err;
 332         regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
 333                                         (__u64)regs32.psw.mask << 32);
 334         regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
 335         for (i = 0; i < NUM_GPRS; i++)
 336                 regs->gprs[i] = (__u64) regs32.gprs[i];
 337         memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
 338         restore_access_regs(current->thread.acrs);
 339
 340         err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
 341                                sizeof(_s390_fp_regs32));
 342         current->thread.fp_regs.fpc &= FPC_VALID_MASK;
 343         if (err)
 344                 return err;
 345
 346         restore_fp_regs(&current->thread.fp_regs);
 347         regs->trap = -1;        /* disable syscall checks */
 348         return 0;
 349 }
 350
 351 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 352 {
 353         sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
 354         sigset_t set;
 355
 356         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 357                 goto badframe;
 358         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
 359                 goto badframe;
 360
 361         sigdelsetmask(&set, ~_BLOCKABLE);
 362         spin_lock_irq(&current->sighand->siglock);
 363         current->blocked = set;
 364         recalc_sigpending();
 365         spin_unlock_irq(&current->sighand->siglock);
 366
 367         if (restore_sigregs32(regs, &frame->sregs))
 368                 goto badframe;
 369
 370         return regs->gprs[2];
 371
 372 badframe:
 373         force_sig(SIGSEGV, current);
 374         return 0;
 375 }
 376
 377 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 378 {
 379         rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
 380         sigset_t set;
 381         stack_t st;
 382         __u32 ss_sp;
 383         int err;
 384         mm_segment_t old_fs = get_fs();
 385
 386         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 387                 goto badframe;
 388         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 389                 goto badframe;
 390
 391         sigdelsetmask(&set, ~_BLOCKABLE);
 392         spin_lock_irq(&current->sighand->siglock);
 393         current->blocked = set;
 394         recalc_sigpending();
 395         spin_unlock_irq(&current->sighand->siglock);
 396
 397         if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
 398                 goto badframe;
 399
 400         err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
 401         st.ss_sp = compat_ptr(ss_sp);
 402         err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
 403         err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
 404         if (err)
 405                 goto badframe;
 406
 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 int 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 0;
 506
 507 give_sigsegv:
 508         force_sigsegv(sig, current);
 509         return -EFAULT;
 510 }
 511
 512 static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
 513                            sigset_t *set, struct pt_regs * regs)
 514 {
 515         int err = 0;
 516         rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
 517         if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
 518                 goto give_sigsegv;
 519
 520         if (copy_siginfo_to_user32(&frame->info, info))
 521                 goto give_sigsegv;
 522
 523         /* Create the ucontext.  */
 524         err |= __put_user(0, &frame->uc.uc_flags);
 525         err |= __put_user(0, &frame->uc.uc_link);
 526         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 527         err |= __put_user(sas_ss_flags(regs->gprs[15]),
 528                           &frame->uc.uc_stack.ss_flags);
 529         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 530         err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
 531         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 532         if (err)
 533                 goto give_sigsegv;
 534
 535         /* Set up to return from userspace.  If provided, use a stub
 536            already in userspace.  */
 537         if (ka->sa.sa_flags & SA_RESTORER) {
 538                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
 539         } else {
 540                 regs->gprs[14] = (__u64) frame->retcode;
 541                 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
 542                                   (u16 __user *)(frame->retcode));
 543         }
 544
 545         /* Set up backchain. */
 546         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 547                 goto give_sigsegv;
 548
 549         /* Set up registers for signal handler */
 550         regs->gprs[15] = (__u64) frame;
 551         regs->psw.addr = (__u64) ka->sa.sa_handler;
 552
 553         regs->gprs[2] = map_signal(sig);
 554         regs->gprs[3] = (__u64) &frame->info;
 555         regs->gprs[4] = (__u64) &frame->uc;
 556         return 0;
 557
 558 give_sigsegv:
 559         force_sigsegv(sig, current);
 560         return -EFAULT;
 561 }
 562
 563 /*
 564  * OK, we're invoking a handler
 565  */
 566
 567 int
 568 handle_signal32(unsigned long sig, struct k_sigaction *ka,
 569                 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
 570 {
 571         int ret;
 572
 573         /* Set up the stack frame */
 574         if (ka->sa.sa_flags & SA_SIGINFO)
 575                 ret = setup_rt_frame32(sig, ka, info, oldset, regs);
 576         else
 577                 ret = setup_frame32(sig, ka, oldset, regs);
 578
 579         if (ret == 0) {
 580                 spin_lock_irq(&current->sighand->siglock);
 581                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 582                 if (!(ka->sa.sa_flags & SA_NODEFER))
 583                         sigaddset(&current->blocked,sig);
 584                 recalc_sigpending();
 585                 spin_unlock_irq(&current->sighand->siglock);
 586         }
 587         return ret;
 588 }
 589