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