arch/s390/kernel/signal.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *    Copyright IBM Corp. 1999, 2006
   4  *    Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com)
   5  *
   6  *    Based on Intel version
   7  *
   8  *  Copyright (C) 1991, 1992  Linus Torvalds
   9  *
  10  *  1997-11-28  Modified for POSIX.1b signals by Richard Henderson
  11  */
  12
  13 #include <linux/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 <linux/tracehook.h>
  28 #include <linux/syscalls.h>
  29 #include <linux/compat.h>
  30 #include <asm/ucontext.h>
  31 #include <linux/uaccess.h>
  32 #include <asm/lowcore.h>
  33 #include <asm/switch_to.h>
  34 #include "entry.h"
  35
  36 /*
  37  * Layout of an old-style signal-frame:
  38  *      -----------------------------------------
  39  *      | save area (_SIGNAL_FRAMESIZE)         |
  40  *      -----------------------------------------
  41  *      | struct sigcontext                     |
  42  *      |       oldmask                         |
  43  *      |       _sigregs *                      |
  44  *      -----------------------------------------
  45  *      | _sigregs with                         |
  46  *      |       _s390_regs_common               |
  47  *      |       _s390_fp_regs                   |
  48  *      -----------------------------------------
  49  *      | int signo                             |
  50  *      -----------------------------------------
  51  *      | _sigregs_ext with                     |
  52  *      |       gprs_high 64 byte (opt)         |
  53  *      |       vxrs_low 128 byte (opt)         |
  54  *      |       vxrs_high 256 byte (opt)        |
  55  *      |       reserved 128 byte (opt)         |
  56  *      -----------------------------------------
  57  *      | __u16 svc_insn                        |
  58  *      -----------------------------------------
  59  * The svc_insn entry with the sigreturn system call opcode does not
  60  * have a fixed position and moves if gprs_high or vxrs exist.
  61  * Future extensions will be added to _sigregs_ext.
  62  */
  63 struct sigframe
  64 {
  65         __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
  66         struct sigcontext sc;
  67         _sigregs sregs;
  68         int signo;
  69         _sigregs_ext sregs_ext;
  70         __u16 svc_insn;         /* Offset of svc_insn is NOT fixed! */
  71 };
  72
  73 /*
  74  * Layout of an rt signal-frame:
  75  *      -----------------------------------------
  76  *      | save area (_SIGNAL_FRAMESIZE)         |
  77  *      -----------------------------------------
  78  *      | svc __NR_rt_sigreturn 2 byte          |
  79  *      -----------------------------------------
  80  *      | struct siginfo                        |
  81  *      -----------------------------------------
  82  *      | struct ucontext_extended with         |
  83  *      |       unsigned long uc_flags          |
  84  *      |       struct ucontext *uc_link        |
  85  *      |       stack_t uc_stack                |
  86  *      |       _sigregs uc_mcontext with       |
  87  *      |               _s390_regs_common       |
  88  *      |               _s390_fp_regs           |
  89  *      |       sigset_t uc_sigmask             |
  90  *      |       _sigregs_ext uc_mcontext_ext    |
  91  *      |               gprs_high 64 byte (opt) |
  92  *      |               vxrs_low 128 byte (opt) |
  93  *      |               vxrs_high 256 byte (opt)|
  94  *      |               reserved 128 byte (opt) |
  95  *      -----------------------------------------
  96  * Future extensions will be added to _sigregs_ext.
  97  */
  98 struct rt_sigframe
  99 {
 100         __u8 callee_used_stack[__SIGNAL_FRAMESIZE];
 101         __u16 svc_insn;
 102         struct siginfo info;
 103         struct ucontext_extended uc;
 104 };
 105
 106 /* Store registers needed to create the signal frame */
 107 static void store_sigregs(void)
 108 {
 109         save_access_regs(current->thread.acrs);
 110         save_fpu_regs();
 111 }
 112
 113 /* Load registers after signal return */
 114 static void load_sigregs(void)
 115 {
 116         restore_access_regs(current->thread.acrs);
 117 }
 118
 119 /* Returns non-zero on fault. */
 120 static int save_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
 121 {
 122         _sigregs user_sregs;
 123
 124         /* Copy a 'clean' PSW mask to the user to avoid leaking
 125            information about whether PER is currently on.  */
 126         user_sregs.regs.psw.mask = PSW_USER_BITS |
 127                 (regs->psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
 128         user_sregs.regs.psw.addr = regs->psw.addr;
 129         memcpy(&user_sregs.regs.gprs, &regs->gprs, sizeof(sregs->regs.gprs));
 130         memcpy(&user_sregs.regs.acrs, current->thread.acrs,
 131                sizeof(user_sregs.regs.acrs));
 132         fpregs_store(&user_sregs.fpregs, &current->thread.fpu);
 133         if (__copy_to_user(sregs, &user_sregs, sizeof(_sigregs)))
 134                 return -EFAULT;
 135         return 0;
 136 }
 137
 138 static int restore_sigregs(struct pt_regs *regs, _sigregs __user *sregs)
 139 {
 140         _sigregs user_sregs;
 141
 142         /* Alwys make any pending restarted system call return -EINTR */
 143         current->restart_block.fn = do_no_restart_syscall;
 144
 145         if (__copy_from_user(&user_sregs, sregs, sizeof(user_sregs)))
 146                 return -EFAULT;
 147
 148         if (!is_ri_task(current) && (user_sregs.regs.psw.mask & PSW_MASK_RI))
 149                 return -EINVAL;
 150
 151         /* Test the floating-point-control word. */
 152         if (test_fp_ctl(user_sregs.fpregs.fpc))
 153                 return -EINVAL;
 154
 155         /* Use regs->psw.mask instead of PSW_USER_BITS to preserve PER bit. */
 156         regs->psw.mask = (regs->psw.mask & ~(PSW_MASK_USER | PSW_MASK_RI)) |
 157                 (user_sregs.regs.psw.mask & (PSW_MASK_USER | PSW_MASK_RI));
 158         /* Check for invalid user address space control. */
 159         if ((regs->psw.mask & PSW_MASK_ASC) == PSW_ASC_HOME)
 160                 regs->psw.mask = PSW_ASC_PRIMARY |
 161                         (regs->psw.mask & ~PSW_MASK_ASC);
 162         /* Check for invalid amode */
 163         if (regs->psw.mask & PSW_MASK_EA)
 164                 regs->psw.mask |= PSW_MASK_BA;
 165         regs->psw.addr = user_sregs.regs.psw.addr;
 166         memcpy(&regs->gprs, &user_sregs.regs.gprs, sizeof(sregs->regs.gprs));
 167         memcpy(&current->thread.acrs, &user_sregs.regs.acrs,
 168                sizeof(current->thread.acrs));
 169
 170         fpregs_load(&user_sregs.fpregs, &current->thread.fpu);
 171
 172         clear_pt_regs_flag(regs, PIF_SYSCALL); /* No longer in a system call */
 173         clear_pt_regs_flag(regs, PIF_SYSCALL_RESTART);
 174         return 0;
 175 }
 176
 177 /* Returns non-zero on fault. */
 178 static int save_sigregs_ext(struct pt_regs *regs,
 179                             _sigregs_ext __user *sregs_ext)
 180 {
 181         __u64 vxrs[__NUM_VXRS_LOW];
 182         int i;
 183
 184         /* Save vector registers to signal stack */
 185         if (MACHINE_HAS_VX) {
 186                 for (i = 0; i < __NUM_VXRS_LOW; i++)
 187                         vxrs[i] = *((__u64 *)(current->thread.fpu.vxrs + i) + 1);
 188                 if (__copy_to_user(&sregs_ext->vxrs_low, vxrs,
 189                                    sizeof(sregs_ext->vxrs_low)) ||
 190                     __copy_to_user(&sregs_ext->vxrs_high,
 191                                    current->thread.fpu.vxrs + __NUM_VXRS_LOW,
 192                                    sizeof(sregs_ext->vxrs_high)))
 193                         return -EFAULT;
 194         }
 195         return 0;
 196 }
 197
 198 static int restore_sigregs_ext(struct pt_regs *regs,
 199                                _sigregs_ext __user *sregs_ext)
 200 {
 201         __u64 vxrs[__NUM_VXRS_LOW];
 202         int i;
 203
 204         /* Restore vector registers from signal stack */
 205         if (MACHINE_HAS_VX) {
 206                 if (__copy_from_user(vxrs, &sregs_ext->vxrs_low,
 207                                      sizeof(sregs_ext->vxrs_low)) ||
 208                     __copy_from_user(current->thread.fpu.vxrs + __NUM_VXRS_LOW,
 209                                      &sregs_ext->vxrs_high,
 210                                      sizeof(sregs_ext->vxrs_high)))
 211                         return -EFAULT;
 212                 for (i = 0; i < __NUM_VXRS_LOW; i++)
 213                         *((__u64 *)(current->thread.fpu.vxrs + i) + 1) = vxrs[i];
 214         }
 215         return 0;
 216 }
 217
 218 SYSCALL_DEFINE0(sigreturn)
 219 {
 220         struct pt_regs *regs = task_pt_regs(current);
 221         struct sigframe __user *frame =
 222                 (struct sigframe __user *) regs->gprs[15];
 223         sigset_t set;
 224
 225         if (__copy_from_user(&set.sig, &frame->sc.oldmask, _SIGMASK_COPY_SIZE))
 226                 goto badframe;
 227         set_current_blocked(&set);
 228         save_fpu_regs();
 229         if (restore_sigregs(regs, &frame->sregs))
 230                 goto badframe;
 231         if (restore_sigregs_ext(regs, &frame->sregs_ext))
 232                 goto badframe;
 233         load_sigregs();
 234         return regs->gprs[2];
 235 badframe:
 236         force_sig(SIGSEGV);
 237         return 0;
 238 }
 239
 240 SYSCALL_DEFINE0(rt_sigreturn)
 241 {
 242         struct pt_regs *regs = task_pt_regs(current);
 243         struct rt_sigframe __user *frame =
 244                 (struct rt_sigframe __user *)regs->gprs[15];
 245         sigset_t set;
 246
 247         if (__copy_from_user(&set.sig, &frame->uc.uc_sigmask, sizeof(set)))
 248                 goto badframe;
 249         set_current_blocked(&set);
 250         if (restore_altstack(&frame->uc.uc_stack))
 251                 goto badframe;
 252         save_fpu_regs();
 253         if (restore_sigregs(regs, &frame->uc.uc_mcontext))
 254                 goto badframe;
 255         if (restore_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
 256                 goto badframe;
 257         load_sigregs();
 258         return regs->gprs[2];
 259 badframe:
 260         force_sig(SIGSEGV);
 261         return 0;
 262 }
 263
 264 /*
 265  * Determine which stack to use..
 266  */
 267 static inline void __user *
 268 get_sigframe(struct k_sigaction *ka, struct pt_regs * regs, size_t frame_size)
 269 {
 270         unsigned long sp;
 271
 272         /* Default to using normal stack */
 273         sp = regs->gprs[15];
 274
 275         /* Overflow on alternate signal stack gives SIGSEGV. */
 276         if (on_sig_stack(sp) && !on_sig_stack((sp - frame_size) & -8UL))
 277                 return (void __user *) -1UL;
 278
 279         /* This is the X/Open sanctioned signal stack switching.  */
 280         if (ka->sa.sa_flags & SA_ONSTACK) {
 281                 if (! sas_ss_flags(sp))
 282                         sp = current->sas_ss_sp + current->sas_ss_size;
 283         }
 284
 285         return (void __user *)((sp - frame_size) & -8ul);
 286 }
 287
 288 static int setup_frame(int sig, struct k_sigaction *ka,
 289                        sigset_t *set, struct pt_regs * regs)
 290 {
 291         struct sigframe __user *frame;
 292         struct sigcontext sc;
 293         unsigned long restorer;
 294         size_t frame_size;
 295
 296         /*
 297          * gprs_high are only present for a 31-bit task running on
 298          * a 64-bit kernel (see compat_signal.c) but the space for
 299          * gprs_high need to be allocated if vector registers are
 300          * included in the signal frame on a 31-bit system.
 301          */
 302         frame_size = sizeof(*frame) - sizeof(frame->sregs_ext);
 303         if (MACHINE_HAS_VX)
 304                 frame_size += sizeof(frame->sregs_ext);
 305         frame = get_sigframe(ka, regs, frame_size);
 306         if (frame == (void __user *) -1UL)
 307                 return -EFAULT;
 308
 309         /* Set up backchain. */
 310         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
 311                 return -EFAULT;
 312
 313         /* Create struct sigcontext on the signal stack */
 314         memcpy(&sc.oldmask, &set->sig, _SIGMASK_COPY_SIZE);
 315         sc.sregs = (_sigregs __user __force *) &frame->sregs;
 316         if (__copy_to_user(&frame->sc, &sc, sizeof(frame->sc)))
 317                 return -EFAULT;
 318
 319         /* Store registers needed to create the signal frame */
 320         store_sigregs();
 321
 322         /* Create _sigregs on the signal stack */
 323         if (save_sigregs(regs, &frame->sregs))
 324                 return -EFAULT;
 325
 326         /* Place signal number on stack to allow backtrace from handler.  */
 327         if (__put_user(regs->gprs[2], (int __user *) &frame->signo))
 328                 return -EFAULT;
 329
 330         /* Create _sigregs_ext on the signal stack */
 331         if (save_sigregs_ext(regs, &frame->sregs_ext))
 332                 return -EFAULT;
 333
 334         /* Set up to return from userspace.  If provided, use a stub
 335            already in userspace.  */
 336         if (ka->sa.sa_flags & SA_RESTORER) {
 337                 restorer = (unsigned long) ka->sa.sa_restorer;
 338         } else {
 339                 /* Signal frame without vector registers are short ! */
 340                 __u16 __user *svc = (void __user *) frame + frame_size - 2;
 341                 if (__put_user(S390_SYSCALL_OPCODE | __NR_sigreturn, svc))
 342                         return -EFAULT;
 343                 restorer = (unsigned long) svc;
 344         }
 345
 346         /* Set up registers for signal handler */
 347         regs->gprs[14] = restorer;
 348         regs->gprs[15] = (unsigned long) frame;
 349         /* Force default amode and default user address space control. */
 350         regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
 351                 (PSW_USER_BITS & PSW_MASK_ASC) |
 352                 (regs->psw.mask & ~PSW_MASK_ASC);
 353         regs->psw.addr = (unsigned long) ka->sa.sa_handler;
 354
 355         regs->gprs[2] = sig;
 356         regs->gprs[3] = (unsigned long) &frame->sc;
 357
 358         /* We forgot to include these in the sigcontext.
 359            To avoid breaking binary compatibility, they are passed as args. */
 360         if (sig == SIGSEGV || sig == SIGBUS || sig == SIGILL ||
 361             sig == SIGTRAP || sig == SIGFPE) {
 362                 /* set extra registers only for synchronous signals */
 363                 regs->gprs[4] = regs->int_code & 127;
 364                 regs->gprs[5] = regs->int_parm_long;
 365                 regs->gprs[6] = current->thread.last_break;
 366         }
 367         return 0;
 368 }
 369
 370 static int setup_rt_frame(struct ksignal *ksig, sigset_t *set,
 371                           struct pt_regs *regs)
 372 {
 373         struct rt_sigframe __user *frame;
 374         unsigned long uc_flags, restorer;
 375         size_t frame_size;
 376
 377         frame_size = sizeof(struct rt_sigframe) - sizeof(_sigregs_ext);
 378         /*
 379          * gprs_high are only present for a 31-bit task running on
 380          * a 64-bit kernel (see compat_signal.c) but the space for
 381          * gprs_high need to be allocated if vector registers are
 382          * included in the signal frame on a 31-bit system.
 383          */
 384         uc_flags = 0;
 385         if (MACHINE_HAS_VX) {
 386                 frame_size += sizeof(_sigregs_ext);
 387                 uc_flags |= UC_VXRS;
 388         }
 389         frame = get_sigframe(&ksig->ka, regs, frame_size);
 390         if (frame == (void __user *) -1UL)
 391                 return -EFAULT;
 392
 393         /* Set up backchain. */
 394         if (__put_user(regs->gprs[15], (addr_t __user *) frame))
 395                 return -EFAULT;
 396
 397         /* Set up to return from userspace.  If provided, use a stub
 398            already in userspace.  */
 399         if (ksig->ka.sa.sa_flags & SA_RESTORER) {
 400                 restorer = (unsigned long) ksig->ka.sa.sa_restorer;
 401         } else {
 402                 __u16 __user *svc = &frame->svc_insn;
 403                 if (__put_user(S390_SYSCALL_OPCODE | __NR_rt_sigreturn, svc))
 404                         return -EFAULT;
 405                 restorer = (unsigned long) svc;
 406         }
 407
 408         /* Create siginfo on the signal stack */
 409         if (copy_siginfo_to_user(&frame->info, &ksig->info))
 410                 return -EFAULT;
 411
 412         /* Store registers needed to create the signal frame */
 413         store_sigregs();
 414
 415         /* Create ucontext on the signal stack. */
 416         if (__put_user(uc_flags, &frame->uc.uc_flags) ||
 417             __put_user(NULL, &frame->uc.uc_link) ||
 418             __save_altstack(&frame->uc.uc_stack, regs->gprs[15]) ||
 419             save_sigregs(regs, &frame->uc.uc_mcontext) ||
 420             __copy_to_user(&frame->uc.uc_sigmask, set, sizeof(*set)) ||
 421             save_sigregs_ext(regs, &frame->uc.uc_mcontext_ext))
 422                 return -EFAULT;
 423
 424         /* Set up registers for signal handler */
 425         regs->gprs[14] = restorer;
 426         regs->gprs[15] = (unsigned long) frame;
 427         /* Force default amode and default user address space control. */
 428         regs->psw.mask = PSW_MASK_EA | PSW_MASK_BA |
 429                 (PSW_USER_BITS & PSW_MASK_ASC) |
 430                 (regs->psw.mask & ~PSW_MASK_ASC);
 431         regs->psw.addr = (unsigned long) ksig->ka.sa.sa_handler;
 432
 433         regs->gprs[2] = ksig->sig;
 434         regs->gprs[3] = (unsigned long) &frame->info;
 435         regs->gprs[4] = (unsigned long) &frame->uc;
 436         regs->gprs[5] = current->thread.last_break;
 437         return 0;
 438 }
 439
 440 static void handle_signal(struct ksignal *ksig, sigset_t *oldset,
 441                           struct pt_regs *regs)
 442 {
 443         int ret;
 444
 445         /* Set up the stack frame */
 446         if (ksig->ka.sa.sa_flags & SA_SIGINFO)
 447                 ret = setup_rt_frame(ksig, oldset, regs);
 448         else
 449                 ret = setup_frame(ksig->sig, &ksig->ka, oldset, regs);
 450
 451         signal_setup_done(ret, ksig, test_thread_flag(TIF_SINGLE_STEP));
 452 }
 453
 454 /*
 455  * Note that 'init' is a special process: it doesn't get signals it doesn't
 456  * want to handle. Thus you cannot kill init even with a SIGKILL even by
 457  * mistake.
 458  *
 459  * Note that we go through the signals twice: once to check the signals that
 460  * the kernel can handle, and then we build all the user-level signal handling
 461  * stack-frames in one go after that.
 462  */
 463
 464 void arch_do_signal_or_restart(struct pt_regs *regs, bool has_signal)
 465 {
 466         struct ksignal ksig;
 467         sigset_t *oldset = sigmask_to_save();
 468
 469         /*
 470          * Get signal to deliver. When running under ptrace, at this point
 471          * the debugger may change all our registers, including the system
 472          * call information.
 473          */
 474         current->thread.system_call =
 475                 test_pt_regs_flag(regs, PIF_SYSCALL) ? regs->int_code : 0;
 476
 477         if (has_signal && get_signal(&ksig)) {
 478                 /* Whee!  Actually deliver the signal.  */
 479                 if (current->thread.system_call) {
 480                         regs->int_code = current->thread.system_call;
 481                         /* Check for system call restarting. */
 482                         switch (regs->gprs[2]) {
 483                         case -ERESTART_RESTARTBLOCK:
 484                         case -ERESTARTNOHAND:
 485                                 regs->gprs[2] = -EINTR;
 486                                 break;
 487                         case -ERESTARTSYS:
 488                                 if (!(ksig.ka.sa.sa_flags & SA_RESTART)) {
 489                                         regs->gprs[2] = -EINTR;
 490                                         break;
 491                                 }
 492                                 fallthrough;
 493                         case -ERESTARTNOINTR:
 494                                 regs->gprs[2] = regs->orig_gpr2;
 495                                 regs->psw.addr =
 496                                         __rewind_psw(regs->psw,
 497                                                      regs->int_code >> 16);
 498                                 break;
 499                         }
 500                 }
 501                 /* No longer in a system call */
 502                 clear_pt_regs_flag(regs, PIF_SYSCALL);
 503                 clear_pt_regs_flag(regs, PIF_SYSCALL_RESTART);
 504                 rseq_signal_deliver(&ksig, regs);
 505                 if (is_compat_task())
 506                         handle_signal32(&ksig, oldset, regs);
 507                 else
 508                         handle_signal(&ksig, oldset, regs);
 509                 return;
 510         }
 511
 512         /* No handlers present - check for system call restart */
 513         clear_pt_regs_flag(regs, PIF_SYSCALL);
 514         clear_pt_regs_flag(regs, PIF_SYSCALL_RESTART);
 515         if (current->thread.system_call) {
 516                 regs->int_code = current->thread.system_call;
 517                 switch (regs->gprs[2]) {
 518                 case -ERESTART_RESTARTBLOCK:
 519                         /* Restart with sys_restart_syscall */
 520                         regs->int_code = __NR_restart_syscall;
 521                         fallthrough;
 522                 case -ERESTARTNOHAND:
 523                 case -ERESTARTSYS:
 524                 case -ERESTARTNOINTR:
 525                         /* Restart system call with magic TIF bit. */
 526                         regs->gprs[2] = regs->orig_gpr2;
 527                         set_pt_regs_flag(regs, PIF_SYSCALL_RESTART);
 528                         if (test_thread_flag(TIF_SINGLE_STEP))
 529                                 clear_thread_flag(TIF_PER_TRAP);
 530                         break;
 531                 }
 532         }
 533
 534         /*
 535          * If there's no signal to deliver, we just put the saved sigmask back.
 536          */
 537         restore_saved_sigmask();
 538 }
 539
 540 void do_notify_resume(struct pt_regs *regs)
 541 {
 542         tracehook_notify_resume(regs);
 543         rseq_handle_notify_resume(NULL, regs);
 544 }