arch/s390/kernel/compat_signal.c

   1 /*
   2  *    Copyright IBM Corp. 2000, 2006
   3  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
   4  *               Gerhard Tonn (ton@de.ibm.com)
   5  *
   6  *  Copyright (C) 1991, 1992  Linus Torvalds
   7  *
   8  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
   9  */
  10
  11 #include <linux/compat.h>
  12 #include <linux/sched.h>
  13 #include <linux/mm.h>
  14 #include <linux/smp.h>
  15 #include <linux/kernel.h>
  16 #include <linux/signal.h>
  17 #include <linux/errno.h>
  18 #include <linux/wait.h>
  19 #include <linux/ptrace.h>
  20 #include <linux/unistd.h>
  21 #include <linux/stddef.h>
  22 #include <linux/tty.h>
  23 #include <linux/personality.h>
  24 #include <linux/binfmts.h>
  25 #include <asm/ucontext.h>
  26 #include <asm/uaccess.h>
  27 #include <asm/lowcore.h>
  28 #include <asm/switch_to.h>
  29 #include "compat_linux.h"
  30 #include "compat_ptrace.h"
  31 #include "entry.h"
  32
  33 typedef struct
  34 {
  35         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  36         struct sigcontext32 sc;
  37         _sigregs32 sregs;
  38         int signo;
  39         _sigregs_ext32 sregs_ext;
  40         __u16 svc_insn;         /* Offset of svc_insn is NOT fixed! */
  41 } sigframe32;
  42
  43 typedef struct
  44 {
  45         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  46         __u16 svc_insn;
  47         compat_siginfo_t info;
  48         struct ucontext32 uc;
  49 } rt_sigframe32;
  50
  51 static inline void sigset_to_sigset32(unsigned long *set64,
  52                                       compat_sigset_word *set32)
  53 {
  54         set32[0] = (compat_sigset_word) set64[0];
  55         set32[1] = (compat_sigset_word)(set64[0] >> 32);
  56 }
  57
  58 static inline void sigset32_to_sigset(compat_sigset_word *set32,
  59                                       unsigned long *set64)
  60 {
  61         set64[0] = (unsigned long) set32[0] | ((unsigned long) set32[1] << 32);
  62 }
  63
  64 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
  65 {
  66         int err;
  67
  68         /* If you change siginfo_t structure, please be sure
  69            this code is fixed accordingly.
  70            It should never copy any pad contained in the structure
  71            to avoid security leaks, but must copy the generic
  72            3 ints plus the relevant union member.
  73            This routine must convert siginfo from 64bit to 32bit as well
  74            at the same time.  */
  75         err = __put_user(from->si_signo, &to->si_signo);
  76         err |= __put_user(from->si_errno, &to->si_errno);
  77         err |= __put_user((short)from->si_code, &to->si_code);
  78         if (from->si_code < 0)
  79                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  80         else {
  81                 switch (from->si_code >> 16) {
  82                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
  83                 case __SI_MESGQ >> 16:
  84                         err |= __put_user(from->si_int, &to->si_int);
  85                         /* fallthrough */
  86                 case __SI_KILL >> 16:
  87                         err |= __put_user(from->si_pid, &to->si_pid);
  88                         err |= __put_user(from->si_uid, &to->si_uid);
  89                         break;
  90                 case __SI_CHLD >> 16:
  91                         err |= __put_user(from->si_pid, &to->si_pid);
  92                         err |= __put_user(from->si_uid, &to->si_uid);
  93                         err |= __put_user(from->si_utime, &to->si_utime);
  94                         err |= __put_user(from->si_stime, &to->si_stime);
  95                         err |= __put_user(from->si_status, &to->si_status);
  96                         break;
  97                 case __SI_FAULT >> 16:
  98                         err |= __put_user((unsigned long) from->si_addr,
  99                                           &to->si_addr);
 100                         break;
 101                 case __SI_POLL >> 16:
 102                         err |= __put_user(from->si_band, &to->si_band);
 103                         err |= __put_user(from->si_fd, &to->si_fd);
 104                         break;
 105                 case __SI_TIMER >> 16:
 106                         err |= __put_user(from->si_tid, &to->si_tid);
 107                         err |= __put_user(from->si_overrun, &to->si_overrun);
 108                         err |= __put_user(from->si_int, &to->si_int);
 109                         break;
 110                 default:
 111                         break;
 112                 }
 113         }
 114         return err ? -EFAULT : 0;
 115 }
 116
 117 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 118 {
 119         int err;
 120         u32 tmp;
 121
 122         err = __get_user(to->si_signo, &from->si_signo);
 123         err |= __get_user(to->si_errno, &from->si_errno);
 124         err |= __get_user(to->si_code, &from->si_code);
 125
 126         if (to->si_code < 0)
 127                 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 128         else {
 129                 switch (to->si_code >> 16) {
 130                 case __SI_RT >> 16: /* This is not generated by the kernel as of now.  */
 131                 case __SI_MESGQ >> 16:
 132                         err |= __get_user(to->si_int, &from->si_int);
 133                         /* fallthrough */
 134                 case __SI_KILL >> 16:
 135                         err |= __get_user(to->si_pid, &from->si_pid);
 136                         err |= __get_user(to->si_uid, &from->si_uid);
 137                         break;
 138                 case __SI_CHLD >> 16:
 139                         err |= __get_user(to->si_pid, &from->si_pid);
 140                         err |= __get_user(to->si_uid, &from->si_uid);
 141                         err |= __get_user(to->si_utime, &from->si_utime);
 142                         err |= __get_user(to->si_stime, &from->si_stime);
 143                         err |= __get_user(to->si_status, &from->si_status);
 144                         break;
 145                 case __SI_FAULT >> 16:
 146                         err |= __get_user(tmp, &from->si_addr);
 147                         to->si_addr = (void __force __user *)
 148                                 (u64) (tmp & PSW32_ADDR_INSN);
 149                         break;
 150                 case __SI_POLL >> 16:
 151                         err |= __get_user(to->si_band, &from->si_band);
 152                         err |= __get_user(to->si_fd, &from->si_fd);
 153                         break;
 154                 case __SI_TIMER >> 16:
 155                         err |= __get_user(to->si_tid, &from->si_tid);
 156                         err |= __get_user(to->si_overrun, &from->si_overrun);
 157                         err |= __get_user(to->si_int, &from->si_int);
 158                         break;
 159                 default:
 160                         break;
 161                 }
 162         }
 163         return err ? -EFAULT : 0;
 164 }
 165
 166 /* Store registers needed to create the signal frame */
 167 static void store_sigregs(void)
 168 {
 169         save_access_regs(current->thread.acrs);
 170         save_fpu_regs();
 171 }
 172
 173 /* Load registers after signal return */
 174 static void load_sigregs(void)
 175 {
 176         restore_access_regs(current->thread.acrs);
 177 }
 178
 179 static int save_sigregs32(struct pt_regs *regs, _sigregs32 __user *sregs)
 180 {
 181         _sigregs32 user_sregs;
 182         int i;
 183
 184         user_sregs.regs.psw.mask = (__u32)(regs->psw.mask >> 32);
 185         user_sregs.regs.psw.mask &= PSW32_MASK_USER | PSW32_MASK_RI;
 186         user_sregs.regs.psw.mask |= PSW32_USER_BITS;
 187         user_sregs.regs.psw.addr = (__u32) regs->psw.addr |
 188                 (__u32)(regs->psw.mask & PSW_MASK_BA);
 189         for (i = 0; i < NUM_GPRS; i++)
 190                 user_sregs.regs.gprs[i] = (__u32) regs->gprs[i];
 191         memcpy(&user_sregs.regs.acrs, current->thread.acrs,
 192                sizeof(user_sregs.regs.acrs));
 193         fpregs_store((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);
 194         if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs32)))
 195                 return -EFAULT;
 196         return 0;
 197 }
 198
 199 static int restore_sigregs32(struct pt_regs *regs,_sigregs32 __user *sregs)
 200 {
 201         _sigregs32 user_sregs;
 202         int i;
 203
 204         /* Alwys make any pending restarted system call return -EINTR */
 205         current->restart_block.fn = do_no_restart_syscall;
 206
 207         if (__copy_from_user(&user_sregs, &sregs->regs, sizeof(user_sregs)))
 208                 return -EFAULT;
 209
 210         if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW32_MASK_RI))
 211                 return -EINVAL;
 212
 213         /* Test the floating-point-control word. */
 214         if (test_fp_ctl(user_sregs.fpregs.fpc))
 215                 return -EINVAL;
 216
 217         /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
 218         regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
 219                 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_USER) << 32 |
 220                 (__u64)(user_sregs.regs.psw.mask & PSW32_MASK_RI) << 32 |
 221                 (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_AMODE);
 222         /* Check for invalid user address space control. */
 223         if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
 224                 regs->psw.mask = PSW_ASC_PRIMARY |
 225                         (regs->psw.mask & ~PSW_MASK_ASC);
 226         regs->psw.addr = (__u64)(user_sregs.regs.psw.addr & PSW32_ADDR_INSN);
 227         for (i = 0; i < NUM_GPRS; i++)
 228                 regs->gprs[i] = (__u64) user_sregs.regs.gprs[i];
 229         memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
 230                sizeof(current->thread.acrs));
 231         fpregs_load((_s390_fp_regs *) &user_sregs.fpregs, &current->thread.fpu);
 232
 233         clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
 234         return 0;
 235 }
 236
 237 static int save_sigregs_ext32(struct pt_regs *regs,
 238                               _sigregs_ext32 __user *sregs_ext)
 239 {
 240         __u32 gprs_high[NUM_GPRS];
 241         __u64 vxrs[__NUM_VXRS_LOW];
 242         int i;
 243
 244         /* Save high gprs to signal stack */
 245         for (i = 0; i < NUM_GPRS; i++)
 246                 gprs_high[i] = regs->gprs[i] >> 32;
 247         if (__copy_to_user(&sregs_ext->gprs_high, &gprs_high,
 248                            sizeof(sregs_ext->gprs_high)))
 249                 return -EFAULT;
 250
 251         /* Save vector registers to signal stack */
 252         if (is_vx_task(current)) {
 253                 for (i = 0; i < __NUM_VXRS_LOW; i++)
 254                         vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
 255                 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
 256                                    sizeof(sregs_ext->vxrs_low)) ||
 257                     __copy_to_user(&sregs_ext->vxrs_high,
 258                                    current->thread.fpu.vxrs + __NUM_VXRS_LOW,
 259                                    sizeof(sregs_ext->vxrs_high)))
 260                         return -EFAULT;
 261         }
 262         return 0;
 263 }
 264
 265 static int restore_sigregs_ext32(struct pt_regs *regs,
 266                                  _sigregs_ext32 __user *sregs_ext)
 267 {
 268         __u32 gprs_high[NUM_GPRS];
 269         __u64 vxrs[__NUM_VXRS_LOW];
 270         int i;
 271
 272         /* Restore high gprs from signal stack */
 273         if (__copy_from_user(&gprs_high, &sregs_ext->gprs_high,
 274                              sizeof(&sregs_ext->gprs_high)))
 275                 return -EFAULT;
 276         for (i = 0; i < NUM_GPRS; i++)
 277                 *(__u32 *)&regs->gprs[i] = gprs_high[i];
 278
 279         /* Restore vector registers from signal stack */
 280         if (is_vx_task(current)) {
 281                 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
 282                                      sizeof(sregs_ext->vxrs_low)) ||
 283                     __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
 284                                      &sregs_ext->vxrs_high,
 285                                      sizeof(sregs_ext->vxrs_high)))
 286                         return -EFAULT;
 287                 for (i = 0; i < __NUM_VXRS_LOW; i++)
 288                         *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
 289         }
 290         return 0;
 291 }
 292
 293 COMPAT_SYSCALL_DEFINE0(sigreturn)
 294 {
 295         struct pt_regs *regs = task_pt_regs(current);
 296         sigframe32 __user *frame = (sigframe32 __user *)regs->gprs[15];
 297         compat_sigset_t cset;
 298         sigset_t set;
 299
 300         if (__copy_from_user(&cset.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE32))
 301                 goto badframe;
 302         sigset32_to_sigset(cset.sig, set.sig);
 303         set_current_blocked(&set);
 304         save_fpu_regs();
 305         if (restore_sigregs32(regs, &frame->sregs))
 306                 goto badframe;
 307         if (restore_sigregs_ext32(regs, &frame->sregs_ext))
 308                 goto badframe;
 309         load_sigregs();
 310         return regs->gprs[2];
 311 badframe:
 312         force_sig(SIGSEGV, current);
 313         return 0;
 314 }
 315
 316 COMPAT_SYSCALL_DEFINE0(rt_sigreturn)
 317 {
 318         struct pt_regs *regs = task_pt_regs(current);
 319         rt_sigframe32 __user *frame = (rt_sigframe32 __user *)regs->gprs[15];
 320         compat_sigset_t cset;
 321         sigset_t set;
 322
 323         if (__copy_from_user(&cset, &frame->uc.uc_sigmask, sizeof(cset)))
 324                 goto badframe;
 325         sigset32_to_sigset(cset.sig, set.sig);
 326         set_current_blocked(&set);
 327         if (compat_restore_altstack(&frame->uc.uc_stack))
 328                 goto badframe;
 329         save_fpu_regs();
 330         if (restore_sigregs32(regs, &frame->uc.uc_mcontext))
 331                 goto badframe;
 332         if (restore_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
 333                 goto badframe;
 334         load_sigregs();
 335         return regs->gprs[2];
 336 badframe:
 337         force_sig(SIGSEGV, current);
 338         return 0;
 339 }
 340
 341 /*
 342  * Set up a signal frame.
 343  */
 344
 345
 346 /*
 347  * Determine which stack to use..
 348  */
 349 static inline void __user *
 350 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 351 {
 352         unsigned long sp;
 353
 354         /* Default to using normal stack */
 355         sp = (unsigned long) A(regs->gprs[15]);
 356
 357         /* Overflow on alternate signal stack gives SIGSEGV. */
 358         if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
 359                 return (void __user *) -1UL;
 360
 361         /* This is the X/Open sanctioned signal stack switching.  */
 362         if (ka->sa.sa_flags & SA_ONSTACK) {
 363                 if (! sas_ss_flags(sp))
 364                         sp = current->sas_ss_sp + current->sas_ss_size;
 365         }
 366
 367         return (void __user *)((sp - frame_size) & -8ul);
 368 }
 369
 370 static int setup_frame32(struct ksignal *ksig, sigset_t *set,
 371                          struct pt_regs *regs)
 372 {
 373         int sig = ksig->sig;
 374         sigframe32 __user *frame;
 375         struct sigcontext32 sc;
 376         unsigned long restorer;
 377         size_t frame_size;
 378
 379         /*
 380          * gprs_high are always present for 31-bit compat tasks.
 381          * The space for vector registers is only allocated if
 382          * the machine supports it
 383          */
 384         frame_size = sizeof(*frame) - sizeof(frame->sregs_ext.__reserved);
 385         if (!MACHINE_HAS_VX)
 386                 frame_size -= sizeof(frame->sregs_ext.vxrs_low) +
 387                               sizeof(frame->sregs_ext.vxrs_high);
 388         frame = get_sigframe(&ksig->ka, regs, frame_size);
 389         if (frame == (void __user *) -1UL)
 390                 return -EFAULT;
 391
 392         /* Set up backchain. */
 393         if (__put_user(regs->gprs[15], (unsigned int __user *) frame))
 394                 return -EFAULT;
 395
 396         /* Create struct sigcontext32 on the signal stack */
 397         sigset_to_sigset32(set->sig, sc.oldmask);
 398         sc.sregs = (__u32)(unsigned long __force) &frame->sregs;
 399         if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
 400                 return -EFAULT;
 401
 402         /* Store registers needed to create the signal frame */
 403         store_sigregs();
 404
 405         /* Create _sigregs32 on the signal stack */
 406         if (save_sigregs32(regs, &frame->sregs))
 407                 return -EFAULT;
 408
 409         /* Place signal number on stack to allow backtrace from handler.  */
 410         if (__put_user(regs->gprs[2], (int __force __user *) &frame->signo))
 411                 return -EFAULT;
 412
 413         /* Create _sigregs_ext32 on the signal stack */
 414         if (save_sigregs_ext32(regs, &frame->sregs_ext))
 415                 return -EFAULT;
 416
 417         /* Set up to return from userspace.  If provided, use a stub
 418            already in userspace.  */
 419         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 420                 restorer = (unsigned long __force)
 421                         ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
 422         } else {
 423                 /* Signal frames without vectors registers are short ! */
 424                 __u16 __user *svc = (void __user *) frame + frame_size - 2;
 425                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
 426                         return -EFAULT;
 427                 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
 428         }
 429
 430         /* Set up registers for signal handler */
 431         regs->gprs[14] = restorer;
 432         regs->gprs[15] = (__force __u64) frame;
 433         /* Force 31 bit amode and default user address space control. */
 434         regs->psw.mask = PSW_MASK_BA |
 435                 (PSW_USER_BITS & PSW_MASK_ASC) |
 436                 (regs->psw.mask & ~PSW_MASK_ASC);
 437         regs->psw.addr = (__force __u64) ksig->ka.sa.sa_handler;
 438
 439         regs->gprs[2] = sig;
 440         regs->gprs[3] = (__force __u64) &frame->sc;
 441
 442         /* We forgot to include these in the sigcontext.
 443            To avoid breaking binary compatibility, they are passed as args. */
 444         if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
 445             sig == SIGTRAP || sig == SIGFPE) {
 446                 /* set extra registers only for synchronous signals */
 447                 regs->gprs[4] = regs->int_code & 127;
 448                 regs->gprs[5] = regs->int_parm_long;
 449                 regs->gprs[6] = task_thread_info(current)->last_break;
 450         }
 451
 452         return 0;
 453 }
 454
 455 static int setup_rt_frame32(struct ksignal *ksig, sigset_t *set,
 456                             struct pt_regs *regs)
 457 {
 458         compat_sigset_t cset;
 459         rt_sigframe32 __user *frame;
 460         unsigned long restorer;
 461         size_t frame_size;
 462         u32 uc_flags;
 463
 464         frame_size = sizeof(*frame) -
 465                      sizeof(frame->uc.uc_mcontext_ext.__reserved);
 466         /*
 467          * gprs_high are always present for 31-bit compat tasks.
 468          * The space for vector registers is only allocated if
 469          * the machine supports it
 470          */
 471         uc_flags = UC_GPRS_HIGH;
 472         if (MACHINE_HAS_VX) {
 473                 if (is_vx_task(current))
 474                         uc_flags |= UC_VXRS;
 475         } else
 476                 frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) +
 477                               sizeof(frame->uc.uc_mcontext_ext.vxrs_high);
 478         frame = get_sigframe(&ksig->ka, regs, frame_size);
 479         if (frame == (void __user *) -1UL)
 480                 return -EFAULT;
 481
 482         /* Set up backchain. */
 483         if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
 484                 return -EFAULT;
 485
 486         /* Set up to return from userspace.  If provided, use a stub
 487            already in userspace.  */
 488         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 489                 restorer = (unsigned long __force)
 490                         ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
 491         } else {
 492                 __u16 __user *svc = &frame->svc_insn;
 493                 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
 494                         return -EFAULT;
 495                 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
 496         }
 497
 498         /* Create siginfo on the signal stack */
 499         if (copy_siginfo_to_user32(&frame->info, &ksig->info))
 500                 return -EFAULT;
 501
 502         /* Store registers needed to create the signal frame */
 503         store_sigregs();
 504
 505         /* Create ucontext on the signal stack. */
 506         sigset_to_sigset32(set->sig, cset.sig);
 507         if (__put_user(uc_flags, &frame->uc.uc_flags) ||
 508             __put_user(0, &frame->uc.uc_link) ||
 509             __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
 510             save_sigregs32(regs, &frame->uc.uc_mcontext) ||
 511             __copy_to_user(&frame->uc.uc_sigmask, &cset, sizeof(cset)) ||
 512             save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
 513                 return -EFAULT;
 514
 515         /* Set up registers for signal handler */
 516         regs->gprs[14] = restorer;
 517         regs->gprs[15] = (__force __u64) frame;
 518         /* Force 31 bit amode and default user address space control. */
 519         regs->psw.mask = PSW_MASK_BA |
 520                 (PSW_USER_BITS & PSW_MASK_ASC) |
 521                 (regs->psw.mask & ~PSW_MASK_ASC);
 522         regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler;
 523
 524         regs->gprs[2] = ksig->sig;
 525         regs->gprs[3] = (__force __u64) &frame->info;
 526         regs->gprs[4] = (__force __u64) &frame->uc;
 527         regs->gprs[5] = task_thread_info(current)->last_break;
 528         return 0;
 529 }
 530
 531 /*
 532  * OK, we're invoking a handler
 533  */
 534
 535 void handle_signal32(struct ksignal *ksig, sigset_t *oldset,
 536                      struct pt_regs *regs)
 537 {
 538         int ret;
 539
 540         /* Set up the stack frame */
 541         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 542                 ret = setup_rt_frame32(ksig, oldset, regs);
 543         else
 544                 ret = setup_frame32(ksig, oldset, regs);
 545
 546         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
 547 }
 548