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 (from->si_code < 0)
 122                 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 123         else {
 124                 switch (from->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         int ret;
 222
 223         if (act) {
 224                 compat_old_sigset_t mask;
 225                 if (verify_area(VERIFY_READ, act, sizeof(*act)) ||
 226                     __get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler) ||
 227                     __get_user((unsigned long)new_ka.sa.sa_restorer, &act->sa_restorer))
 228                         return -EFAULT;
 229                 __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 230                 __get_user(mask, &act->sa_mask);
 231                 siginitset(&new_ka.sa.sa_mask, mask);
 232         }
 233
 234         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 235
 236         if (!ret && oact) {
 237                 if (verify_area(VERIFY_WRITE, oact, sizeof(*oact)) ||
 238                     __put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler) ||
 239                     __put_user((unsigned long)old_ka.sa.sa_restorer, &oact->sa_restorer))
 240                         return -EFAULT;
 241                 __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 242                 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask);
 243         }
 244
 245         return ret;
 246 }
 247
 248 int
 249 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact);
 250
 251 asmlinkage long
 252 sys32_rt_sigaction(int sig, const struct sigaction32 __user *act,
 253            struct sigaction32 __user *oact,  size_t sigsetsize)
 254 {
 255         struct k_sigaction new_ka, old_ka;
 256         int ret;
 257         compat_sigset_t set32;
 258
 259         /* XXX: Don't preclude handling different sized sigset_t's.  */
 260         if (sigsetsize != sizeof(compat_sigset_t))
 261                 return -EINVAL;
 262
 263         if (act) {
 264                 ret = get_user((unsigned long)new_ka.sa.sa_handler, &act->sa_handler);
 265                 ret |= __copy_from_user(&set32, &act->sa_mask,
 266                                         sizeof(compat_sigset_t));
 267                 switch (_NSIG_WORDS) {
 268                 case 4: new_ka.sa.sa_mask.sig[3] = set32.sig[6]
 269                                 | (((long)set32.sig[7]) << 32);
 270                 case 3: new_ka.sa.sa_mask.sig[2] = set32.sig[4]
 271                                 | (((long)set32.sig[5]) << 32);
 272                 case 2: new_ka.sa.sa_mask.sig[1] = set32.sig[2]
 273                                 | (((long)set32.sig[3]) << 32);
 274                 case 1: new_ka.sa.sa_mask.sig[0] = set32.sig[0]
 275                                 | (((long)set32.sig[1]) << 32);
 276                 }
 277                 ret |= __get_user(new_ka.sa.sa_flags, &act->sa_flags);
 278
 279                 if (ret)
 280                         return -EFAULT;
 281         }
 282
 283         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
 284
 285         if (!ret && oact) {
 286                 switch (_NSIG_WORDS) {
 287                 case 4:
 288                         set32.sig[7] = (old_ka.sa.sa_mask.sig[3] >> 32);
 289                         set32.sig[6] = old_ka.sa.sa_mask.sig[3];
 290                 case 3:
 291                         set32.sig[5] = (old_ka.sa.sa_mask.sig[2] >> 32);
 292                         set32.sig[4] = old_ka.sa.sa_mask.sig[2];
 293                 case 2:
 294                         set32.sig[3] = (old_ka.sa.sa_mask.sig[1] >> 32);
 295                         set32.sig[2] = old_ka.sa.sa_mask.sig[1];
 296                 case 1:
 297                         set32.sig[1] = (old_ka.sa.sa_mask.sig[0] >> 32);
 298                         set32.sig[0] = old_ka.sa.sa_mask.sig[0];
 299                 }
 300                 ret = put_user((unsigned long)old_ka.sa.sa_handler, &oact->sa_handler);
 301                 ret |= __copy_to_user(&oact->sa_mask, &set32,
 302                                       sizeof(compat_sigset_t));
 303                 ret |= __put_user(old_ka.sa.sa_flags, &oact->sa_flags);
 304         }
 305
 306         return ret;
 307 }
 308
 309 asmlinkage long
 310 sys32_sigaltstack(const stack_t32 __user *uss, stack_t32 __user *uoss,
 311                                                         struct pt_regs *regs)
 312 {
 313         stack_t kss, koss;
 314         int ret, err = 0;
 315         mm_segment_t old_fs = get_fs();
 316
 317         if (uss) {
 318                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
 319                         return -EFAULT;
 320                 err |= __get_user((unsigned long) kss.ss_sp, &uss->ss_sp);
 321                 err |= __get_user(kss.ss_size, &uss->ss_size);
 322                 err |= __get_user(kss.ss_flags, &uss->ss_flags);
 323                 if (err)
 324                         return -EFAULT;
 325         }
 326
 327         set_fs (KERNEL_DS);
 328         ret = do_sigaltstack((stack_t __user *) (uss ? &kss : NULL),
 329                              (stack_t __user *) (uoss ? &koss : NULL),
 330                              regs->gprs[15]);
 331         set_fs (old_fs);
 332
 333         if (!ret && uoss) {
 334                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
 335                         return -EFAULT;
 336                 err |= __put_user((unsigned long) koss.ss_sp, &uoss->ss_sp);
 337                 err |= __put_user(koss.ss_size, &uoss->ss_size);
 338                 err |= __put_user(koss.ss_flags, &uoss->ss_flags);
 339                 if (err)
 340                         return -EFAULT;
 341         }
 342         return ret;
 343 }
 344
 345 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
 346 {
 347         _s390_regs_common32 regs32;
 348         int err, i;
 349
 350         regs32.psw.mask = PSW32_MASK_MERGE(PSW32_USER_BITS,
 351                                            (__u32)(regs->psw.mask >> 32));
 352         regs32.psw.addr = PSW32_ADDR_AMODE31 | (__u32) regs->psw.addr;
 353         for (i = 0; i < NUM_GPRS; i++)
 354                 regs32.gprs[i] = (__u32) regs->gprs[i];
 355         save_access_regs(current->thread.acrs);
 356         memcpy(regs32.acrs, current->thread.acrs, sizeof(regs32.acrs));
 357         err = __copy_to_user(&sregs->regs, &regs32, sizeof(regs32));
 358         if (err)
 359                 return err;
 360         save_fp_regs(&current->thread.fp_regs);
 361         /* s390_fp_regs and _s390_fp_regs32 are the same ! */
 362         return __copy_to_user(&sregs->fpregs, &current->thread.fp_regs,
 363                               sizeof(_s390_fp_regs32));
 364 }
 365
 366 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
 367 {
 368         _s390_regs_common32 regs32;
 369         int err, i;
 370
 371         /* Alwys make any pending restarted system call return -EINTR */
 372         current_thread_info()->restart_block.fn = do_no_restart_syscall;
 373
 374         err = __copy_from_user(&regs32, &sregs->regs, sizeof(regs32));
 375         if (err)
 376                 return err;
 377         regs->psw.mask = PSW_MASK_MERGE(regs->psw.mask,
 378                                         (__u64)regs32.psw.mask << 32);
 379         regs->psw.addr = (__u64)(regs32.psw.addr & PSW32_ADDR_INSN);
 380         for (i = 0; i < NUM_GPRS; i++)
 381                 regs->gprs[i] = (__u64) regs32.gprs[i];
 382         memcpy(current->thread.acrs, regs32.acrs, sizeof(current->thread.acrs));
 383         restore_access_regs(current->thread.acrs);
 384
 385         err = __copy_from_user(&current->thread.fp_regs, &sregs->fpregs,
 386                                sizeof(_s390_fp_regs32));
 387         current->thread.fp_regs.fpc &= FPC_VALID_MASK;
 388         if (err)
 389                 return err;
 390
 391         restore_fp_regs(&current->thread.fp_regs);
 392         regs->trap = -1;        /* disable syscall checks */
 393         return 0;
 394 }
 395
 396 asmlinkage long sys32_sigreturn(struct pt_regs *regs)
 397 {
 398         sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
 399         sigset_t set;
 400
 401         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 402                 goto badframe;
 403         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
 404                 goto badframe;
 405
 406         sigdelsetmask(&set, ~_BLOCKABLE);
 407         spin_lock_irq(&current->sighand->siglock);
 408         current->blocked = set;
 409         recalc_sigpending();
 410         spin_unlock_irq(&current->sighand->siglock);
 411
 412         if (restore_sigregs32(regs, &frame->sregs))
 413                 goto badframe;
 414
 415         return regs->gprs[2];
 416
 417 badframe:
 418         force_sig(SIGSEGV, current);
 419         return 0;
 420 }
 421
 422 asmlinkage long sys32_rt_sigreturn(struct pt_regs *regs)
 423 {
 424         rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
 425         sigset_t set;
 426         stack_t st;
 427         __u32 ss_sp;
 428         int err;
 429         mm_segment_t old_fs = get_fs();
 430
 431         if (verify_area(VERIFY_READ, frame, sizeof(*frame)))
 432                 goto badframe;
 433         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
 434                 goto badframe;
 435
 436         sigdelsetmask(&set, ~_BLOCKABLE);
 437         spin_lock_irq(&current->sighand->siglock);
 438         current->blocked = set;
 439         recalc_sigpending();
 440         spin_unlock_irq(&current->sighand->siglock);
 441
 442         if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
 443                 goto badframe;
 444
 445         err = __get_user(ss_sp, &frame->uc.uc_stack.ss_sp);
 446         st.ss_sp = (void *) A((unsigned long)ss_sp);
 447         err |= __get_user(st.ss_size, &frame->uc.uc_stack.ss_size);
 448         err |= __get_user(st.ss_flags, &frame->uc.uc_stack.ss_flags);
 449         if (err)
 450                 goto badframe;
 451
 452         /* It is more difficult to avoid calling this function than to
 453            call it and ignore errors.  */
 454         set_fs (KERNEL_DS);
 455         do_sigaltstack((stack_t __user *)&st, NULL, regs->gprs[15]);
 456         set_fs (old_fs);
 457
 458         return regs->gprs[2];
 459
 460 badframe:
 461         force_sig(SIGSEGV, current);
 462         return 0;
 463 }
 464
 465 /*
 466  * Set up a signal frame.
 467  */
 468
 469
 470 /*
 471  * Determine which stack to use..
 472  */
 473 static inline void __user *
 474 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 475 {
 476         unsigned long sp;
 477
 478         /* Default to using normal stack */
 479         sp = (unsigned long) A(regs->gprs[15]);
 480
 481         /* This is the X/Open sanctioned signal stack switching.  */
 482         if (ka->sa.sa_flags & SA_ONSTACK) {
 483                 if (! on_sig_stack(sp))
 484                         sp = current->sas_ss_sp + current->sas_ss_size;
 485         }
 486
 487         /* This is the legacy signal stack switching. */
 488         else if (!user_mode(regs) &&
 489                  !(ka->sa.sa_flags & SA_RESTORER) &&
 490                  ka->sa.sa_restorer) {
 491                 sp = (unsigned long) ka->sa.sa_restorer;
 492         }
 493
 494         return (void __user *)((sp - frame_size) & -8ul);
 495 }
 496
 497 static inline int map_signal(int sig)
 498 {
 499         if (current_thread_info()->exec_domain
 500             && current_thread_info()->exec_domain->signal_invmap
 501             && sig < 32)
 502                 return current_thread_info()->exec_domain->signal_invmap[sig];
 503         else
 504                 return sig;
 505 }
 506
 507 static void setup_frame32(int sig, struct k_sigaction *ka,
 508                         sigset_t *set, struct pt_regs * regs)
 509 {
 510         sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(sigframe32));
 511         if (!access_ok(VERIFY_WRITE, frame, sizeof(sigframe32)))
 512                 goto give_sigsegv;
 513
 514         if (__copy_to_user(&frame->sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE32))
 515                 goto give_sigsegv;
 516
 517         if (save_sigregs32(regs, &frame->sregs))
 518                 goto give_sigsegv;
 519         if (__put_user((unsigned long) &frame->sregs, &frame->sc.sregs))
 520                 goto give_sigsegv;
 521
 522         /* Set up to return from userspace.  If provided, use a stub
 523            already in userspace.  */
 524         if (ka->sa.sa_flags & SA_RESTORER) {
 525                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
 526         } else {
 527                 regs->gprs[14] = (__u64) frame->retcode;
 528                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn,
 529                                (u16 __user *)(frame->retcode)))
 530                         goto give_sigsegv;
 531         }
 532
 533         /* Set up backchain. */
 534         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 535                 goto give_sigsegv;
 536
 537         /* Set up registers for signal handler */
 538         regs->gprs[15] = (__u64) frame;
 539         regs->psw.addr = (__u64) ka->sa.sa_handler;
 540
 541         regs->gprs[2] = map_signal(sig);
 542         regs->gprs[3] = (__u64) &frame->sc;
 543
 544         /* We forgot to include these in the sigcontext.
 545            To avoid breaking binary compatibility, they are passed as args. */
 546         regs->gprs[4] = current->thread.trap_no;
 547         regs->gprs[5] = current->thread.prot_addr;
 548
 549         /* Place signal number on stack to allow backtrace from handler.  */
 550         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
 551                 goto give_sigsegv;
 552         return;
 553
 554 give_sigsegv:
 555         if (sig == SIGSEGV)
 556                 ka->sa.sa_handler = SIG_DFL;
 557         force_sig(SIGSEGV, current);
 558 }
 559
 560 static void setup_rt_frame32(int sig, struct k_sigaction *ka, siginfo_t *info,
 561                            sigset_t *set, struct pt_regs * regs)
 562 {
 563         int err = 0;
 564         rt_sigframe32 __user *frame = get_sigframe(ka, regs, sizeof(rt_sigframe32));
 565         if (!access_ok(VERIFY_WRITE, frame, sizeof(rt_sigframe32)))
 566                 goto give_sigsegv;
 567
 568         if (copy_siginfo_to_user32(&frame->info, info))
 569                 goto give_sigsegv;
 570
 571         /* Create the ucontext.  */
 572         err |= __put_user(0, &frame->uc.uc_flags);
 573         err |= __put_user(0, &frame->uc.uc_link);
 574         err |= __put_user(current->sas_ss_sp, &frame->uc.uc_stack.ss_sp);
 575         err |= __put_user(sas_ss_flags(regs->gprs[15]),
 576                           &frame->uc.uc_stack.ss_flags);
 577         err |= __put_user(current->sas_ss_size, &frame->uc.uc_stack.ss_size);
 578         err |= save_sigregs32(regs, &frame->uc.uc_mcontext);
 579         err |= __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set));
 580         if (err)
 581                 goto give_sigsegv;
 582
 583         /* Set up to return from userspace.  If provided, use a stub
 584            already in userspace.  */
 585         if (ka->sa.sa_flags & SA_RESTORER) {
 586                 regs->gprs[14] = (__u64) ka->sa.sa_restorer;
 587         } else {
 588                 regs->gprs[14] = (__u64) frame->retcode;
 589                 err |= __put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn,
 590                                   (u16 __user *)(frame->retcode));
 591         }
 592
 593         /* Set up backchain. */
 594         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 595                 goto give_sigsegv;
 596
 597         /* Set up registers for signal handler */
 598         regs->gprs[15] = (__u64) frame;
 599         regs->psw.addr = (__u64) ka->sa.sa_handler;
 600
 601         regs->gprs[2] = map_signal(sig);
 602         regs->gprs[3] = (__u64) &frame->info;
 603         regs->gprs[4] = (__u64) &frame->uc;
 604         return;
 605
 606 give_sigsegv:
 607         if (sig == SIGSEGV)
 608                 ka->sa.sa_handler = SIG_DFL;
 609         force_sig(SIGSEGV, current);
 610 }
 611
 612 /*
 613  * OK, we're invoking a handler
 614  */
 615
 616 void
 617 handle_signal32(unsigned long sig, siginfo_t *info, sigset_t *oldset,
 618         struct pt_regs * regs)
 619 {
 620         struct k_sigaction *ka = &current->sighand->action[sig-1];
 621
 622         /* Set up the stack frame */
 623         if (ka->sa.sa_flags & SA_SIGINFO)
 624                 setup_rt_frame32(sig, ka, info, oldset, regs);
 625         else
 626                 setup_frame32(sig, ka, oldset, regs);
 627
 628         if (ka->sa.sa_flags & SA_ONESHOT)
 629                 ka->sa.sa_handler = SIG_DFL;
 630
 631         if (!(ka->sa.sa_flags & SA_NODEFER)) {
 632                 spin_lock_irq(&current->sighand->siglock);
 633                 sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask);
 634                 sigaddset(&current->blocked,sig);
 635                 recalc_sigpending();
 636                 spin_unlock_irq(&current->sighand->siglock);
 637         }
 638 }
 639