Pileus Git - ~andy/linux/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/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 __user *)(u64) (tmp & PSW32_ADDR_INSN);
 145                         break;
 146                 case __SI_POLL >> 16:
 147                         err |= __get_user(to->si_band, &from->si_band);
 148                         err |= __get_user(to->si_fd, &from->si_fd);
 149                         break;
 150                 case __SI_TIMER >> 16:
 151                         err |= __get_user(to->si_tid, &from->si_tid);
 152                         err |= __get_user(to->si_overrun, &from->si_overrun);
 153                         err |= __get_user(to->si_int, &from->si_int);
 154                         break;
 155                 default:
 156                         break;
 157                 }
 158         }
 159         return err;
 160 }
 161
 162 asmlinkage long
 163 sys32_sigaction(int sig, const struct old_sigaction32 __user *act,
 164                  struct old_sigaction32 __user *oact)
 165 {
 166         struct k_sigaction new_ka, old_ka;
 167         unsigned long sa_handler, sa_restorer;
 168         int ret;
 169
 170         if (act) {
 171                 compat_old_sigset_t mask;
 172                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
 173                     __get_user(sa_handler, &act->sa_handler) ||
 174                     __get_user(sa_restorer, &act->sa_restorer) ||
 175                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
 176                     __get_user(mask, &act->sa_mask))
 177                         return -EFAULT;
 178                 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
 179                 new_ka.sa.sa_restorer = (void (*)(void)) sa_restorer;
 180                 siginitset(&new_ka.sa.sa_mask, mask);
 181         }
 182
 183         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 184
 185         if (!ret && oact) {
 186                 sa_handler = (unsigned long) old_ka.sa.sa_handler;
 187                 sa_restorer = (unsigned long) old_ka.sa.sa_restorer;
 188                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
 189                     __put_user(sa_handler, &oact->sa_handler) ||
 190                     __put_user(sa_restorer, &oact->sa_restorer) ||
 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                         return -EFAULT;
 194         }
 195
 196         return ret;
 197 }
 198
 199 asmlinkage long
 200 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
 201            struct sigaction32 __user *oact,  size_t sigsetsize)
 202 {
 203         struct k_sigaction new_ka, old_ka;
 204         unsigned long sa_handler;
 205         int ret;
 206         compat_sigset_t set32;
 207
 208         /* XXX: Don't preclude handling different sized sigset_t's.  */
 209         if (sigsetsize != sizeof(compat_sigset_t))
 210                 return -EINVAL;
 211
 212         if (act) {
 213                 ret = get_user(sa_handler, &act->sa_handler);
 214                 ret |= __copy_from_user(&set32, &act->sa_mask,
 215                                         sizeof(compat_sigset_t));
 216                 new_ka.sa.sa_mask.sig[0] =
 217                         set32.sig[0] | (((long)set32.sig[1]) << 32);
 218                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 219
 220                 if (ret)
 221                         return -EFAULT;
 222                 new_ka.sa.sa_handler = (__sighandler_t) sa_handler;
 223         }
 224
 225         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 226
 227         if (!ret && oact) {
 228                 set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
 229                 set32.sig[0] = old_ka.sa.sa_mask.sig[0];
 230                 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
 231                 ret |= __copy_to_user(&oact->sa_mask, &set32,
 232                                       sizeof(compat_sigset_t));
 233                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 234         }
 235
 236         return ret;
 237 }
 238
 239 asmlinkage long
 240 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss)
 241 {
 242         struct pt_regs *regs = task_pt_regs(current);
 243         stack_t kss, koss;
 244         unsigned long ss_sp;
 245         int ret, err = 0;
 246         mm_segment_t old_fs = get_fs();
 247
 248         if (uss) {
 249                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
 250                         return -EFAULT;
 251                 err |= __get_user(ss_sp, &uss->ss_sp);
 252                 err |= __get_user(kss.ss_size, &uss->ss_size);
 253                 err |= __get_user(kss.ss_flags, &uss->ss_flags);
 254                 if (err)
 255                         return -EFAULT;
 256                 kss.ss_sp = (void __user *) ss_sp;
 257         }
 258
 259         set_fs (KERNEL_DS);
 260         ret = do_sigaltstack((stack_t __force __user *) (uss ? &kss : NULL),
 261                              (stack_t __force __user *) (uoss ? &koss : NULL),
 262                              regs->gprs[15]);
 263         set_fs (old_fs);
 264
 265         if (!ret && uoss) {
 266                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
 267                         return -EFAULT;
 268                 ss_sp = (unsigned long) koss.ss_sp;
 269                 err |= __put_user(ss_sp, &uoss->ss_sp);
 270                 err |= __put_user(koss.ss_size, &uoss->ss_size);
 271                 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
 272                 if (err)
 273                         return -EFAULT;
 274         }
 275         return ret;
 276 }
 277
 278 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
 279 {
 280         _s390_regs_common32 regs32;
 281         int err, i;
 282
 283         regs32.psw.mask = psw32_user_bits |
 284                 ((__u32)(regs->psw.mask >> 32) & PSW32_MASK_USER);
 285         regs32.psw.addr = (__u32) regs->psw.addr |
 286                 (__u32)(regs->psw.mask & PSW_MASK_BA);
 287         for (i = 0; i < NUM_GPRS; i++)
 288                 regs32.gprs[i] = (__u32) regs->gprs[i];
 289         save_access_regs(current->thread.acrs);
 290         memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
 291         err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
 292         if (err)
 293                 return err;
 294         save_fp_regs(&current->thread.fp_regs);
 295         /* s390_fp_regs and _s390_fp_regs32 are the same ! */
 296         return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
 297                               sizeof(_s390_fp_regs32));
 298 }
 299
 300 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
 301 {
 302         _s390_regs_common32 regs32;
 303         int err, i;
 304
 305         /* Alwys make any pending restarted system call return -EINTR */
 306         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 307
 308         err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
 309         if (err)
 310                 return err;
 311         regs->psw.mask = (regs->psw.mask & ~PSW_MASK_USER) |
 312                 (__u64)(regs32.psw.mask & PSW32_MASK_USER) << 32 |
 313                 (__u64)(regs32.psw.addr & PSW32_ADDR_AMODE);
 314         regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
 315         for (i = 0; i < NUM_GPRS; i++)
 316                 regs->gprs[i] = (__u64) regs32.gprs[i];
 317         memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
 318         restore_access_regs(current->thread.acrs);
 319
 320         err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
 321                                sizeof(_s390_fp_regs32));
 322         current->thread.fp_regs.fpc &= FPC_VALID_MASK;
 323         if (err)
 324                 return err;
 325
 326         restore_fp_regs(&current->thread.fp_regs);
 327         clear_thread_flag(TIF_SYSCALL); /* No longer in a system call */
 328         return 0;
 329 }
 330
 331 static int save_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
 332 {
 333         __u32 gprs_high[NUM_GPRS];
 334         int i;
 335
 336         for (i = 0; i < NUM_GPRS; i++)
 337                 gprs_high[i] = regs->gprs[i] >> 32;
 338
 339         return __copy_to_user(uregs, &gprs_high, sizeof(gprs_high));
 340 }
 341
 342 static int restore_sigregs_gprs_high(struct pt_regs *regs, __u32 __user *uregs)
 343 {
 344         __u32 gprs_high[NUM_GPRS];
 345         int err, i;
 346
 347         err = __copy_from_user(&gprs_high, uregs, sizeof(gprs_high));
 348         if (err)
 349                 return err;
 350         for (i = 0; i < NUM_GPRS; i++)
 351                 *(__u32 *)&regs->gprs[i] = gprs_high[i];
 352         return 0;
 353 }
 354
 355 asmlinkage long sys32_sigreturn(void)
 356 {
 357         struct pt_regs *regs = task_pt_regs(current);
 358         sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
 359         sigset_t set;
 360
 361         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 362                 goto badframe;
 363         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
 364                 goto badframe;
 365         sigdelsetmask(&set, ~_BLOCKABLE);
 366         set_current_blocked(&set);
 367         if (restore_sigregs32(regs, &frame->sregs))
 368                 goto badframe;
 369         if (restore_sigregs_gprs_high(regs, frame->gprs_high))
 370                 goto badframe;
 371         return regs->gprs[2];
 372 badframe:
 373         force_sig(SIGSEGV, current);
 374         return 0;
 375 }
 376
 377 asmlinkage long sys32_rt_sigreturn(void)
 378 {
 379         struct pt_regs *regs = task_pt_regs(current);
 380         rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
 381         sigset_t set;
 382         stack_t st;
 383         __u32 ss_sp;
 384         int err;
 385         mm_segment_t old_fs = get_fs();
 386
 387         if (!access_ok(VERIFY_READ, frame, sizeof(*frame)))
 388                 goto badframe;
 389         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 390                 goto badframe;
 391         sigdelsetmask(&set, ~_BLOCKABLE);
 392         set_current_blocked(&set);
 393         if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
 394                 goto badframe;
 395         if (restore_sigregs_gprs_high(regs, frame->gprs_high))
 396                 goto badframe;
 397         err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
 398         st.ss_sp = compat_ptr(ss_sp);
 399         err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
 400         err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
 401         if (err)
 402                 goto badframe;
 403         set_fs (KERNEL_DS);
 404         do_sigaltstack((stack_t __force __user *)&st, NULL, regs->gprs[15]);
 405         set_fs (old_fs);
 406         return regs->gprs[2];
 407 badframe:
 408         force_sig(SIGSEGV, current);
 409         return 0;
 410 }
 411
 412 /*
 413  * Set up a signal frame.
 414  */
 415
 416
 417 /*
 418  * Determine which stack to use..
 419  */
 420 static inline void __user *
 421 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 422 {
 423         unsigned long sp;
 424
 425         /* Default to using normal stack */
 426         sp = (unsigned long) A(regs->gprs[15]);
 427
 428         /* Overflow on alternate signal stack gives SIGSEGV. */
 429         if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
 430                 return (void __user *) -1UL;
 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 (frame == (void __user *) -1UL)
 466                 goto give_sigsegv;
 467
 468         if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
 469                 goto give_sigsegv;
 470
 471         if (save_sigregs32(regs, &frame->sregs))
 472                 goto give_sigsegv;
 473         if (save_sigregs_gprs_high(regs, frame->gprs_high))
 474                 goto give_sigsegv;
 475         if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
 476                 goto give_sigsegv;
 477
 478         /* Set up to return from userspace.  If provided, use a stub
 479            already in userspace.  */
 480         if (ka->sa.sa_flags & SA_RESTORER) {
 481                 regs->gprs[14] = (__u64) ka->sa.sa_restorer | PSW32_ADDR_AMODE;
 482         } else {
 483                 regs->gprs[14] = (__u64) frame->retcode | PSW32_ADDR_AMODE;
 484                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
 485                                (u16 __user *)(frame->retcode)))
 486                         goto give_sigsegv;
 487         }
 488
 489         /* Set up backchain. */
 490         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 491                 goto give_sigsegv;
 492
 493         /* Set up registers for signal handler */
 494         regs->gprs[15] = (__u64) frame;
 495         regs->psw.mask |= PSW_MASK_BA;          /* force amode 31 */
 496         regs->psw.addr = (__u64) ka->sa.sa_handler;
 497
 498         regs->gprs[2] = map_signal(sig);
 499         regs->gprs[3] = (__u64) &frame->sc;
 500
 501         /* We forgot to include these in the sigcontext.
 502            To avoid breaking binary compatibility, they are passed as args. */
 503         regs->gprs[4] = current->thread.trap_no;
 504         regs->gprs[5] = current->thread.prot_addr;
 505
 506         /* Place signal number on stack to allow backtrace from handler.  */
 507         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
 508                 goto give_sigsegv;
 509         return 0;
 510
 511 give_sigsegv:
 512         force_sigsegv(sig, current);
 513         return -EFAULT;
 514 }
 515
 516 static int setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
 517                            sigset_t *set, struct pt_regs * regs)
 518 {
 519         int err = 0;
 520         rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
 521         if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
 522                 goto give_sigsegv;
 523
 524         if (frame == (void __user *) -1UL)
 525                 goto give_sigsegv;
 526
 527         if (copy_siginfo_to_user32(&frame->info, info))
 528                 goto give_sigsegv;
 529
 530         /* Create the ucontext.  */
 531         err |= __put_user(UC_EXTENDED, &frame->uc.uc_flags);
 532         err |= __put_user(0, &frame->uc.uc_link);
 533         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 534         err |= __put_user(sas_ss_flags(regs->gprs[15]),
 535                           &frame->uc.uc_stack.ss_flags);
 536         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 537         err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
 538         err |= save_sigregs_gprs_high(regs, frame->gprs_high);
 539         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 540         if (err)
 541                 goto give_sigsegv;
 542
 543         /* Set up to return from userspace.  If provided, use a stub
 544            already in userspace.  */
 545         if (ka->sa.sa_flags & SA_RESTORER) {
 546                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
 547         } else {
 548                 regs->gprs[14] = (__u64) frame->retcode;
 549                 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
 550                                   (u16 __user *)(frame->retcode));
 551         }
 552
 553         /* Set up backchain. */
 554         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 555                 goto give_sigsegv;
 556
 557         /* Set up registers for signal handler */
 558         regs->gprs[15] = (__u64) frame;
 559         regs->psw.mask |= PSW_MASK_BA;          /* force amode 31 */
 560         regs->psw.addr = (__u64) ka->sa.sa_handler;
 561
 562         regs->gprs[2] = map_signal(sig);
 563         regs->gprs[3] = (__u64) &frame->info;
 564         regs->gprs[4] = (__u64) &frame->uc;
 565         return 0;
 566
 567 give_sigsegv:
 568         force_sigsegv(sig, current);
 569         return -EFAULT;
 570 }
 571
 572 /*
 573  * OK, we're invoking a handler
 574  */
 575
 576 int handle_signal32(unsigned long sig, struct k_sigaction *ka,
 577                     siginfo_t *info, sigset_t *oldset, struct pt_regs *regs)
 578 {
 579         sigset_t blocked;
 580         int ret;
 581
 582         /* Set up the stack frame */
 583         if (ka->sa.sa_flags & SA_SIGINFO)
 584                 ret = setup_rt_frame32(sig, ka, info, oldset, regs);
 585         else
 586                 ret = setup_frame32(sig, ka, oldset, regs);
 587         if (ret)
 588                 return ret;
 589         sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask);
 590         if (!(ka->sa.sa_flags & SA_NODEFER))
 591                 sigaddset(&blocked, sig);
 592         set_current_blocked(&blocked);
 593         return 0;
 594 }
 595