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