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