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