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