arch/s390/kernel/compat_signal.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *    Copyright IBM Corp. 2000, 2006
   4  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
   5  *               Gerhard Tonn (ton@de.ibm.com)
   6  *
   7  *  Copyright (C) 1991, 1992  Linus Torvalds
   8  *
   9  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  10  */
  11
  12 #include <linux/compat.h>
  13 #include <linux/sched.h>
  14 #include <linux/sched/task_stack.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 <linux/uaccess.h>
  29 #include <asm/lowcore.h>
  30 #include <asm/switch_to.h>
  31 #include "compat_linux.h"
  32 #include "compat_ptrace.h"
  33 #include "entry.h"
  34
  35 typedef struct
  36 {
  37         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  38         struct sigcontext32 sc;
  39         _sigregs32 sregs;
  40         int signo;
  41         _sigregs_ext32 sregs_ext;
  42         __u16 svc_insn;         /* Offset of svc_insn is NOT fixed! */
  43 } sigframe32;
  44
  45 typedef struct
  46 {
  47         __u8 callee_used_stack[__SIGNAL_FRAMESIZE32];
  48         __u16 svc_insn;
  49         compat_siginfo_t info;
  50         struct ucontext32 uc;
  51 } rt_sigframe32;
  52
  53 static inline void sigset_to_sigset32(unsigned long *set64,
  54                                       compat_sigset_word *set32)
  55 {
  56         set32[0] = (compat_sigset_word) set64[0];
  57         set32[1] = (compat_sigset_word)(set64[0] >> 32);
  58 }
  59
  60 static inline void sigset32_to_sigset(compat_sigset_word *set32,
  61                                       unsigned long *set64)
  62 {
  63         set64[0] = (unsigned long) set32[0] | ((unsigned long) set32[1] << 32);
  64 }
  65
  66 int copy_siginfo_to_user32(compat_siginfo_t __user *to, const siginfo_t *from)
  67 {
  68         int err;
  69
  70         /* If you change siginfo_t structure, please be sure
  71            this code is fixed accordingly.
  72            It should never copy any pad contained in the structure
  73            to avoid security leaks, but must copy the generic
  74            3 ints plus the relevant union member.
  75            This routine must convert siginfo from 64bit to 32bit as well
  76            at the same time.  */
  77         err = __put_user(from->si_signo, &to->si_signo);
  78         err |= __put_user(from->si_errno, &to->si_errno);
  79         err |= __put_user(from->si_code, &to->si_code);
  80         if (from->si_code < 0)
  81                 err |= __copy_to_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
  82         else {
  83                 switch (siginfo_layout(from->si_signo, from->si_code)) {
  84                 case SIL_RT:
  85                         err |= __put_user(from->si_int, &to->si_int);
  86                         /* fallthrough */
  87                 case SIL_KILL:
  88                         err |= __put_user(from->si_pid, &to->si_pid);
  89                         err |= __put_user(from->si_uid, &to->si_uid);
  90                         break;
  91                 case SIL_CHLD:
  92                         err |= __put_user(from->si_pid, &to->si_pid);
  93                         err |= __put_user(from->si_uid, &to->si_uid);
  94                         err |= __put_user(from->si_utime, &to->si_utime);
  95                         err |= __put_user(from->si_stime, &to->si_stime);
  96                         err |= __put_user(from->si_status, &to->si_status);
  97                         break;
  98                 case SIL_FAULT:
  99                         err |= __put_user((unsigned long) from->si_addr,
 100                                           &to->si_addr);
 101                         break;
 102                 case SIL_POLL:
 103                         err |= __put_user(from->si_band, &to->si_band);
 104                         err |= __put_user(from->si_fd, &to->si_fd);
 105                         break;
 106                 case SIL_TIMER:
 107                         err |= __put_user(from->si_tid, &to->si_tid);
 108                         err |= __put_user(from->si_overrun, &to->si_overrun);
 109                         err |= __put_user(from->si_int, &to->si_int);
 110                         break;
 111                 default:
 112                         break;
 113                 }
 114         }
 115         return err ? -EFAULT : 0;
 116 }
 117
 118 int copy_siginfo_from_user32(siginfo_t *to, compat_siginfo_t __user *from)
 119 {
 120         int err;
 121         u32 tmp;
 122
 123         err = __get_user(to->si_signo, &from->si_signo);
 124         err |= __get_user(to->si_errno, &from->si_errno);
 125         err |= __get_user(to->si_code, &from->si_code);
 126
 127         if (to->si_code < 0)
 128                 err |= __copy_from_user(&to->_sifields._pad, &from->_sifields._pad, SI_PAD_SIZE);
 129         else {
 130                 switch (siginfo_layout(to->si_signo, to->si_code)) {
 131                 case SIL_RT:
 132                         err |= __get_user(to->si_int, &from->si_int);
 133                         /* fallthrough */
 134                 case SIL_KILL:
 135                         err |= __get_user(to->si_pid, &from->si_pid);
 136                         err |= __get_user(to->si_uid, &from->si_uid);
 137                         break;
 138                 case SIL_CHLD:
 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 SIL_FAULT:
 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 SIL_POLL:
 151                         err |= __get_user(to->si_band, &from->si_band);
 152                         err |= __get_user(to->si_fd, &from->si_fd);
 153                         break;
 154                 case SIL_TIMER:
 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 (MACHINE_HAS_VX) {
 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 (MACHINE_HAS_VX) {
 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] = current->thread.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                 uc_flags |= UC_VXRS;
 474         } else
 475                 frame_size -= sizeof(frame->uc.uc_mcontext_ext.vxrs_low) +
 476                               sizeof(frame->uc.uc_mcontext_ext.vxrs_high);
 477         frame = get_sigframe(&ksig->ka, regs, frame_size);
 478         if (frame == (void __user *) -1UL)
 479                 return -EFAULT;
 480
 481         /* Set up backchain. */
 482         if (__put_user(regs->gprs[15], (unsigned int __force __user *) frame))
 483                 return -EFAULT;
 484
 485         /* Set up to return from userspace.  If provided, use a stub
 486            already in userspace.  */
 487         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 488                 restorer = (unsigned long __force)
 489                         ksig->ka.sa.sa_restorer | PSW32_ADDR_AMODE;
 490         } else {
 491                 __u16 __user *svc = &frame->svc_insn;
 492                 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
 493                         return -EFAULT;
 494                 restorer = (unsigned long __force) svc | PSW32_ADDR_AMODE;
 495         }
 496
 497         /* Create siginfo on the signal stack */
 498         if (copy_siginfo_to_user32(&frame->info, &ksig->info))
 499                 return -EFAULT;
 500
 501         /* Store registers needed to create the signal frame */
 502         store_sigregs();
 503
 504         /* Create ucontext on the signal stack. */
 505         sigset_to_sigset32(set->sig, cset.sig);
 506         if (__put_user(uc_flags, &frame->uc.uc_flags) ||
 507             __put_user(0, &frame->uc.uc_link) ||
 508             __compat_save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
 509             save_sigregs32(regs, &frame->uc.uc_mcontext) ||
 510             __copy_to_user(&frame->uc.uc_sigmask, &cset, sizeof(cset)) ||
 511             save_sigregs_ext32(regs, &frame->uc.uc_mcontext_ext))
 512                 return -EFAULT;
 513
 514         /* Set up registers for signal handler */
 515         regs->gprs[14] = restorer;
 516         regs->gprs[15] = (__force __u64) frame;
 517         /* Force 31 bit amode and default user address space control. */
 518         regs->psw.mask = PSW_MASK_BA |
 519                 (PSW_USER_BITS & PSW_MASK_ASC) |
 520                 (regs->psw.mask & ~PSW_MASK_ASC);
 521         regs->psw.addr = (__u64 __force) ksig->ka.sa.sa_handler;
 522
 523         regs->gprs[2] = ksig->sig;
 524         regs->gprs[3] = (__force __u64) &frame->info;
 525         regs->gprs[4] = (__force __u64) &frame->uc;
 526         regs->gprs[5] = current->thread.last_break;
 527         return 0;
 528 }
 529
 530 /*
 531  * OK, we're invoking a handler
 532  */
 533
 534 void handle_signal32(struct ksignal *ksig, sigset_t *oldset,
 535                      struct pt_regs *regs)
 536 {
 537         int ret;
 538
 539         /* Set up the stack frame */
 540         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 541                 ret = setup_rt_frame32(ksig, oldset, regs);
 542         else
 543                 ret = setup_frame32(ksig, oldset, regs);
 544
 545         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
 546 }
 547