arch/s390/kernel/compat_signal.c

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