arch/s390/kernel/compat_signal.c

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