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