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