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 {
 260         struct pt_regs *regs = task_pt_regs(current);
 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(void)
 348 {
 349         struct pt_regs *regs = task_pt_regs(current);
 350         sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
 351         sigset_t set;
 352
 353         if (!access_ok(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(void)
 375 {
 376         struct pt_regs *regs = task_pt_regs(current);
 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 (!access_ok(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 = compat_ptr(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         set_fs (KERNEL_DS);
 406         do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
 407         set_fs (old_fs);
 408
 409         return regs->gprs[2];
 410
 411 badframe:
 412         force_sig(SIGSEGV, current);
 413         return 0;
 414 }
 415
 416 /*
 417  * Set up a signal frame.
 418  */
 419
 420
 421 /*
 422  * Determine which stack to use..
 423  */
 424 static inline void __user *
 425 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 426 {
 427         unsigned long sp;
 428
 429         /* Default to using normal stack */
 430         sp = (unsigned long) A(regs->gprs[15]);
 431
 432         /* This is the X/Open sanctioned signal stack switching.  */
 433         if (ka->sa.sa_flags & SA_ONSTACK) {
 434                 if (! sas_ss_flags(sp))
 435                         sp = current->sas_ss_sp + current->sas_ss_size;
 436         }
 437
 438         /* This is the legacy signal stack switching. */
 439         else if (!user_mode(regs) &&
 440                  !(ka->sa.sa_flags & SA_RESTORER) &&
 441                  ka->sa.sa_restorer) {
 442                 sp = (unsigned long) ka->sa.sa_restorer;
 443         }
 444
 445         return (void __user *)((sp - frame_size) & -8ul);
 446 }
 447
 448 static inline int map_signal(int sig)
 449 {
 450         if (current_thread_info()->exec_domain
 451             && current_thread_info()->exec_domain->signal_invmap
 452             && sig < 32)
 453                 return current_thread_info()->exec_domain->signal_invmap[sig];
 454         else
 455                 return sig;
 456 }
 457
 458 static int setup_frame32(int sig, struct k_sigaction *ka,
 459                         sigset_t *set, struct pt_regs * regs)
 460 {
 461         sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
 462         if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
 463                 goto give_sigsegv;
 464
 465         if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
 466                 goto give_sigsegv;
 467
 468         if (save_sigregs32(regs, &frame->sregs))
 469                 goto give_sigsegv;
 470         if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
 471                 goto give_sigsegv;
 472
 473         /* Set up to return from userspace.  If provided, use a stub
 474            already in userspace.  */
 475         if (ka->sa.sa_flags & SA_RESTORER) {
 476                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
 477         } else {
 478                 regs->gprs[14] = (__u64) frame->retcode;
 479                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
 480                                (u16 __user *)(frame->retcode)))
 481                         goto give_sigsegv;
 482         }
 483
 484         /* Set up backchain. */
 485         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 486                 goto give_sigsegv;
 487
 488         /* Set up registers for signal handler */
 489         regs->gprs[15] = (__u64) frame;
 490         regs->psw.addr = (__u64) ka->sa.sa_handler;
 491
 492         regs->gprs[2] = map_signal(sig);
 493         regs->gprs[3] = (__u64) &frame->sc;
 494
 495         /* We forgot to include these in the sigcontext.
 496            To avoid breaking binary compatibility, they are passed as args. */
 497         regs->gprs[4] = current->thread.trap_no;
 498         regs->gprs[5] = current->thread.prot_addr;
 499
 500         /* Place signal number on stack to allow backtrace from handler.  */
 501         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
 502                 goto give_sigsegv;
 503         return 0;
 504
 505 give_sigsegv:
 506         force_sigsegv(sig, current);
 507         return -EFAULT;
 508 }
 509
 510 static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
 511                            sigset_t *set, struct pt_regs * regs)
 512 {
 513         int err = 0;
 514         rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
 515         if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
 516                 goto give_sigsegv;
 517
 518         if (copy_siginfo_to_user32(&frame->info, info))
 519                 goto give_sigsegv;
 520
 521         /* Create the ucontext.  */
 522         err |= __put_user(0, &frame->uc.uc_flags);
 523         err |= __put_user(0, &frame->uc.uc_link);
 524         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 525         err |= __put_user(sas_ss_flags(regs->gprs[15]),
 526                           &frame->uc.uc_stack.ss_flags);
 527         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 528         err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
 529         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 530         if (err)
 531                 goto give_sigsegv;
 532
 533         /* Set up to return from userspace.  If provided, use a stub
 534            already in userspace.  */
 535         if (ka->sa.sa_flags & SA_RESTORER) {
 536                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
 537         } else {
 538                 regs->gprs[14] = (__u64) frame->retcode;
 539                 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
 540                                   (u16 __user *)(frame->retcode));
 541         }
 542
 543         /* Set up backchain. */
 544         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 545                 goto give_sigsegv;
 546
 547         /* Set up registers for signal handler */
 548         regs->gprs[15] = (__u64) frame;
 549         regs->psw.addr = (__u64) ka->sa.sa_handler;
 550
 551         regs->gprs[2] = map_signal(sig);
 552         regs->gprs[3] = (__u64) &frame->info;
 553         regs->gprs[4] = (__u64) &frame->uc;
 554         return 0;
 555
 556 give_sigsegv:
 557         force_sigsegv(sig, current);
 558         return -EFAULT;
 559 }
 560
 561 /*
 562  * OK, we're invoking a handler
 563  */
 564
 565 int
 566 handle_signal32(unsigned long sig, struct k_sigaction *ka,
 567                 siginfo_t *info, sigset_t *oldset, struct pt_regs * regs)
 568 {
 569         int ret;
 570
 571         /* Set up the stack frame */
 572         if (ka->sa.sa_flags & SA_SIGINFO)
 573                 ret = setup_rt_frame32(sig, ka, info, oldset, regs);
 574         else
 575                 ret = setup_frame32(sig, ka, oldset, regs);
 576
 577         if (ret == 0) {
 578                 spin_lock_irq(&current->sighand->siglock);
 579                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 580                 if (!(ka->sa.sa_flags & SA_NODEFER))
 581                         sigaddset(&current->blocked,sig);
 582                 recalc_sigpending();
 583                 spin_unlock_irq(&current->sighand->siglock);
 584         }
 585         return ret;
 586 }
 587