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