arch/s390/kernel/nmi.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *   Machine check handler
   4  *
   5  *    Copyright IBM Corp. 2000, 2009
   6  *    Author(s): Ingo Adlung <adlung@de.ibm.com>,
   7  *               Martin Schwidefsky <schwidefsky@de.ibm.com>,
   8  *               Cornelia Huck <cornelia.huck@de.ibm.com>,
   9  *               Heiko Carstens <heiko.carstens@de.ibm.com>,
  10  */
  11
  12 #include <linux/kernel_stat.h>
  13 #include <linux/init.h>
  14 #include <linux/errno.h>
  15 #include <linux/hardirq.h>
  16 #include <linux/log2.h>
  17 #include <linux/kprobes.h>
  18 #include <linux/kmemleak.h>
  19 #include <linux/time.h>
  20 #include <linux/module.h>
  21 #include <linux/sched/signal.h>
  22
  23 #include <linux/export.h>
  24 #include <asm/lowcore.h>
  25 #include <asm/smp.h>
  26 #include <asm/stp.h>
  27 #include <asm/cputime.h>
  28 #include <asm/nmi.h>
  29 #include <asm/crw.h>
  30 #include <asm/switch_to.h>
  31 #include <asm/ctl_reg.h>
  32 #include <asm/asm-offsets.h>
  33 #include <linux/kvm_host.h>
  34
  35 struct mcck_struct {
  36         unsigned int kill_task : 1;
  37         unsigned int channel_report : 1;
  38         unsigned int warning : 1;
  39         unsigned int stp_queue : 1;
  40         unsigned long mcck_code;
  41 };
  42
  43 static DEFINE_PER_CPU(struct mcck_struct, cpu_mcck);
  44 static struct kmem_cache *mcesa_cache;
  45 static unsigned long mcesa_origin_lc;
  46
  47 static inline int nmi_needs_mcesa(void)
  48 {
  49         return MACHINE_HAS_VX || MACHINE_HAS_GS;
  50 }
  51
  52 static inline unsigned long nmi_get_mcesa_size(void)
  53 {
  54         if (MACHINE_HAS_GS)
  55                 return MCESA_MAX_SIZE;
  56         return MCESA_MIN_SIZE;
  57 }
  58
  59 /*
  60  * The initial machine check extended save area for the boot CPU.
  61  * It will be replaced on the boot CPU reinit with an allocated
  62  * structure. The structure is required for machine check happening
  63  * early in the boot process.
  64  */
  65 static struct mcesa boot_mcesa __initdata __aligned(MCESA_MAX_SIZE);
  66
  67 void __init nmi_alloc_mcesa_early(u64 *mcesad)
  68 {
  69         if (!nmi_needs_mcesa())
  70                 return;
  71         *mcesad = __pa(&boot_mcesa);
  72         if (MACHINE_HAS_GS)
  73                 *mcesad |= ilog2(MCESA_MAX_SIZE);
  74 }
  75
  76 static void __init nmi_alloc_cache(void)
  77 {
  78         unsigned long size;
  79
  80         if (!nmi_needs_mcesa())
  81                 return;
  82         size = nmi_get_mcesa_size();
  83         if (size > MCESA_MIN_SIZE)
  84                 mcesa_origin_lc = ilog2(size);
  85         /* create slab cache for the machine-check-extended-save-areas */
  86         mcesa_cache = kmem_cache_create("nmi_save_areas", size, size, 0, NULL);
  87         if (!mcesa_cache)
  88                 panic("Couldn't create nmi save area cache");
  89 }
  90
  91 int __ref nmi_alloc_mcesa(u64 *mcesad)
  92 {
  93         unsigned long origin;
  94
  95         *mcesad = 0;
  96         if (!nmi_needs_mcesa())
  97                 return 0;
  98         if (!mcesa_cache)
  99                 nmi_alloc_cache();
 100         origin = (unsigned long) kmem_cache_alloc(mcesa_cache, GFP_KERNEL);
 101         if (!origin)
 102                 return -ENOMEM;
 103         /* The pointer is stored with mcesa_bits ORed in */
 104         kmemleak_not_leak((void *) origin);
 105         *mcesad = __pa(origin) | mcesa_origin_lc;
 106         return 0;
 107 }
 108
 109 void nmi_free_mcesa(u64 *mcesad)
 110 {
 111         if (!nmi_needs_mcesa())
 112                 return;
 113         kmem_cache_free(mcesa_cache, __va(*mcesad & MCESA_ORIGIN_MASK));
 114 }
 115
 116 static notrace void s390_handle_damage(void)
 117 {
 118         smp_emergency_stop();
 119         disabled_wait();
 120         while (1);
 121 }
 122 NOKPROBE_SYMBOL(s390_handle_damage);
 123
 124 /*
 125  * Main machine check handler function. Will be called with interrupts disabled
 126  * and machine checks enabled.
 127  */
 128 void __s390_handle_mcck(void)
 129 {
 130         struct mcck_struct mcck;
 131
 132         /*
 133          * Disable machine checks and get the current state of accumulated
 134          * machine checks. Afterwards delete the old state and enable machine
 135          * checks again.
 136          */
 137         local_mcck_disable();
 138         mcck = *this_cpu_ptr(&cpu_mcck);
 139         memset(this_cpu_ptr(&cpu_mcck), 0, sizeof(mcck));
 140         local_mcck_enable();
 141
 142         if (mcck.channel_report)
 143                 crw_handle_channel_report();
 144         /*
 145          * A warning may remain for a prolonged period on the bare iron.
 146          * (actually until the machine is powered off, or the problem is gone)
 147          * So we just stop listening for the WARNING MCH and avoid continuously
 148          * being interrupted.  One caveat is however, that we must do this per
 149          * processor and cannot use the smp version of ctl_clear_bit().
 150          * On VM we only get one interrupt per virtally presented machinecheck.
 151          * Though one suffices, we may get one interrupt per (virtual) cpu.
 152          */
 153         if (mcck.warning) {     /* WARNING pending ? */
 154                 static int mchchk_wng_posted = 0;
 155
 156                 /* Use single cpu clear, as we cannot handle smp here. */
 157                 __ctl_clear_bit(14, 24);        /* Disable WARNING MCH */
 158                 if (xchg(&mchchk_wng_posted, 1) == 0)
 159                         kill_cad_pid(SIGPWR, 1);
 160         }
 161         if (mcck.stp_queue)
 162                 stp_queue_work();
 163         if (mcck.kill_task) {
 164                 local_irq_enable();
 165                 printk(KERN_EMERG "mcck: Terminating task because of machine "
 166                        "malfunction (code 0x%016lx).\n", mcck.mcck_code);
 167                 printk(KERN_EMERG "mcck: task: %s, pid: %d.\n",
 168                        current->comm, current->pid);
 169                 make_task_dead(SIGSEGV);
 170         }
 171 }
 172
 173 void noinstr s390_handle_mcck(void)
 174 {
 175         trace_hardirqs_off();
 176         __s390_handle_mcck();
 177         trace_hardirqs_on();
 178 }
 179 /*
 180  * returns 0 if all required registers are available
 181  * returns 1 otherwise
 182  */
 183 static int notrace s390_validate_registers(union mci mci, int umode)
 184 {
 185         struct mcesa *mcesa;
 186         void *fpt_save_area;
 187         union ctlreg2 cr2;
 188         int kill_task;
 189         u64 zero;
 190
 191         kill_task = 0;
 192         zero = 0;
 193
 194         if (!mci.gr) {
 195                 /*
 196                  * General purpose registers couldn't be restored and have
 197                  * unknown contents. Stop system or terminate process.
 198                  */
 199                 if (!umode)
 200                         s390_handle_damage();
 201                 kill_task = 1;
 202         }
 203         if (!mci.fp) {
 204                 /*
 205                  * Floating point registers can't be restored. If the
 206                  * kernel currently uses floating point registers the
 207                  * system is stopped. If the process has its floating
 208                  * pointer registers loaded it is terminated.
 209                  */
 210                 if (S390_lowcore.fpu_flags & KERNEL_VXR_V0V7)
 211                         s390_handle_damage();
 212                 if (!test_cpu_flag(CIF_FPU))
 213                         kill_task = 1;
 214         }
 215         fpt_save_area = &S390_lowcore.floating_pt_save_area;
 216         if (!mci.fc) {
 217                 /*
 218                  * Floating point control register can't be restored.
 219                  * If the kernel currently uses the floating pointer
 220                  * registers and needs the FPC register the system is
 221                  * stopped. If the process has its floating pointer
 222                  * registers loaded it is terminated. Otherwise the
 223                  * FPC is just validated.
 224                  */
 225                 if (S390_lowcore.fpu_flags & KERNEL_FPC)
 226                         s390_handle_damage();
 227                 asm volatile(
 228                         "       lfpc    %0\n"
 229                         :
 230                         : "Q" (zero));
 231                 if (!test_cpu_flag(CIF_FPU))
 232                         kill_task = 1;
 233         } else {
 234                 asm volatile(
 235                         "       lfpc    %0\n"
 236                         :
 237                         : "Q" (S390_lowcore.fpt_creg_save_area));
 238         }
 239
 240         mcesa = __va(S390_lowcore.mcesad & MCESA_ORIGIN_MASK);
 241         if (!MACHINE_HAS_VX) {
 242                 /* Validate floating point registers */
 243                 asm volatile(
 244                         "       ld      0,0(%0)\n"
 245                         "       ld      1,8(%0)\n"
 246                         "       ld      2,16(%0)\n"
 247                         "       ld      3,24(%0)\n"
 248                         "       ld      4,32(%0)\n"
 249                         "       ld      5,40(%0)\n"
 250                         "       ld      6,48(%0)\n"
 251                         "       ld      7,56(%0)\n"
 252                         "       ld      8,64(%0)\n"
 253                         "       ld      9,72(%0)\n"
 254                         "       ld      10,80(%0)\n"
 255                         "       ld      11,88(%0)\n"
 256                         "       ld      12,96(%0)\n"
 257                         "       ld      13,104(%0)\n"
 258                         "       ld      14,112(%0)\n"
 259                         "       ld      15,120(%0)\n"
 260                         :
 261                         : "a" (fpt_save_area)
 262                         : "memory");
 263         } else {
 264                 /* Validate vector registers */
 265                 union ctlreg0 cr0;
 266
 267                 if (!mci.vr) {
 268                         /*
 269                          * Vector registers can't be restored. If the kernel
 270                          * currently uses vector registers the system is
 271                          * stopped. If the process has its vector registers
 272                          * loaded it is terminated. Otherwise just validate
 273                          * the registers.
 274                          */
 275                         if (S390_lowcore.fpu_flags & KERNEL_VXR)
 276                                 s390_handle_damage();
 277                         if (!test_cpu_flag(CIF_FPU))
 278                                 kill_task = 1;
 279                 }
 280                 cr0.val = S390_lowcore.cregs_save_area[0];
 281                 cr0.afp = cr0.vx = 1;
 282                 __ctl_load(cr0.val, 0, 0);
 283                 asm volatile(
 284                         "       la      1,%0\n"
 285                         "       .word   0xe70f,0x1000,0x0036\n" /* vlm 0,15,0(1) */
 286                         "       .word   0xe70f,0x1100,0x0c36\n" /* vlm 16,31,256(1) */
 287                         :
 288                         : "Q" (*(struct vx_array *)mcesa->vector_save_area)
 289                         : "1");
 290                 __ctl_load(S390_lowcore.cregs_save_area[0], 0, 0);
 291         }
 292         /* Validate access registers */
 293         asm volatile(
 294                 "       lam     0,15,0(%0)\n"
 295                 :
 296                 : "a" (&S390_lowcore.access_regs_save_area)
 297                 : "memory");
 298         if (!mci.ar) {
 299                 /*
 300                  * Access registers have unknown contents.
 301                  * Terminating task.
 302                  */
 303                 kill_task = 1;
 304         }
 305         /* Validate guarded storage registers */
 306         cr2.val = S390_lowcore.cregs_save_area[2];
 307         if (cr2.gse) {
 308                 if (!mci.gs) {
 309                         /*
 310                          * Guarded storage register can't be restored and
 311                          * the current processes uses guarded storage.
 312                          * It has to be terminated.
 313                          */
 314                         kill_task = 1;
 315                 } else {
 316                         load_gs_cb((struct gs_cb *)mcesa->guarded_storage_save_area);
 317                 }
 318         }
 319         /*
 320          * The getcpu vdso syscall reads CPU number from the programmable
 321          * field of the TOD clock. Disregard the TOD programmable register
 322          * validity bit and load the CPU number into the TOD programmable
 323          * field unconditionally.
 324          */
 325         set_tod_programmable_field(raw_smp_processor_id());
 326         /* Validate clock comparator register */
 327         set_clock_comparator(S390_lowcore.clock_comparator);
 328
 329         if (!mci.ms || !mci.pm || !mci.ia)
 330                 kill_task = 1;
 331
 332         return kill_task;
 333 }
 334 NOKPROBE_SYMBOL(s390_validate_registers);
 335
 336 /*
 337  * Backup the guest's machine check info to its description block
 338  */
 339 static void notrace s390_backup_mcck_info(struct pt_regs *regs)
 340 {
 341         struct mcck_volatile_info *mcck_backup;
 342         struct sie_page *sie_page;
 343
 344         /* r14 contains the sie block, which was set in sie64a */
 345         struct kvm_s390_sie_block *sie_block =
 346                         (struct kvm_s390_sie_block *) regs->gprs[14];
 347
 348         if (sie_block == NULL)
 349                 /* Something's seriously wrong, stop system. */
 350                 s390_handle_damage();
 351
 352         sie_page = container_of(sie_block, struct sie_page, sie_block);
 353         mcck_backup = &sie_page->mcck_info;
 354         mcck_backup->mcic = S390_lowcore.mcck_interruption_code &
 355                                 ~(MCCK_CODE_CP | MCCK_CODE_EXT_DAMAGE);
 356         mcck_backup->ext_damage_code = S390_lowcore.external_damage_code;
 357         mcck_backup->failing_storage_address
 358                         = S390_lowcore.failing_storage_address;
 359 }
 360 NOKPROBE_SYMBOL(s390_backup_mcck_info);
 361
 362 #define MAX_IPD_COUNT   29
 363 #define MAX_IPD_TIME    (5 * 60 * USEC_PER_SEC) /* 5 minutes */
 364
 365 #define ED_STP_ISLAND   6       /* External damage STP island check */
 366 #define ED_STP_SYNC     7       /* External damage STP sync check */
 367
 368 #define MCCK_CODE_NO_GUEST      (MCCK_CODE_CP | MCCK_CODE_EXT_DAMAGE)
 369
 370 /*
 371  * machine check handler.
 372  */
 373 int notrace s390_do_machine_check(struct pt_regs *regs)
 374 {
 375         static int ipd_count;
 376         static DEFINE_SPINLOCK(ipd_lock);
 377         static unsigned long long last_ipd;
 378         struct mcck_struct *mcck;
 379         unsigned long long tmp;
 380         union mci mci;
 381         unsigned long mcck_dam_code;
 382         int mcck_pending = 0;
 383
 384         nmi_enter();
 385
 386         if (user_mode(regs))
 387                 update_timer_mcck();
 388         inc_irq_stat(NMI_NMI);
 389         mci.val = S390_lowcore.mcck_interruption_code;
 390         mcck = this_cpu_ptr(&cpu_mcck);
 391
 392         /*
 393          * Reinject the instruction processing damages' machine checks
 394          * including Delayed Access Exception into the guest
 395          * instead of damaging the host if they happen in the guest.
 396          */
 397         if (mci.pd && !test_cpu_flag(CIF_MCCK_GUEST)) {
 398                 if (mci.b) {
 399                         /* Processing backup -> verify if we can survive this */
 400                         u64 z_mcic, o_mcic, t_mcic;
 401                         z_mcic = (1ULL<<63 | 1ULL<<59 | 1ULL<<29);
 402                         o_mcic = (1ULL<<43 | 1ULL<<42 | 1ULL<<41 | 1ULL<<40 |
 403                                   1ULL<<36 | 1ULL<<35 | 1ULL<<34 | 1ULL<<32 |
 404                                   1ULL<<30 | 1ULL<<21 | 1ULL<<20 | 1ULL<<17 |
 405                                   1ULL<<16);
 406                         t_mcic = mci.val;
 407
 408                         if (((t_mcic & z_mcic) != 0) ||
 409                             ((t_mcic & o_mcic) != o_mcic)) {
 410                                 s390_handle_damage();
 411                         }
 412
 413                         /*
 414                          * Nullifying exigent condition, therefore we might
 415                          * retry this instruction.
 416                          */
 417                         spin_lock(&ipd_lock);
 418                         tmp = get_tod_clock();
 419                         if (((tmp - last_ipd) >> 12) < MAX_IPD_TIME)
 420                                 ipd_count++;
 421                         else
 422                                 ipd_count = 1;
 423                         last_ipd = tmp;
 424                         if (ipd_count == MAX_IPD_COUNT)
 425                                 s390_handle_damage();
 426                         spin_unlock(&ipd_lock);
 427                 } else {
 428                         /* Processing damage -> stopping machine */
 429                         s390_handle_damage();
 430                 }
 431         }
 432         if (s390_validate_registers(mci, user_mode(regs))) {
 433                 /*
 434                  * Couldn't restore all register contents for the
 435                  * user space process -> mark task for termination.
 436                  */
 437                 mcck->kill_task = 1;
 438                 mcck->mcck_code = mci.val;
 439                 mcck_pending = 1;
 440         }
 441
 442         /*
 443          * Backup the machine check's info if it happens when the guest
 444          * is running.
 445          */
 446         if (test_cpu_flag(CIF_MCCK_GUEST))
 447                 s390_backup_mcck_info(regs);
 448
 449         if (mci.cd) {
 450                 /* Timing facility damage */
 451                 s390_handle_damage();
 452         }
 453         if (mci.ed && mci.ec) {
 454                 /* External damage */
 455                 if (S390_lowcore.external_damage_code & (1U << ED_STP_SYNC))
 456                         mcck->stp_queue |= stp_sync_check();
 457                 if (S390_lowcore.external_damage_code & (1U << ED_STP_ISLAND))
 458                         mcck->stp_queue |= stp_island_check();
 459                 mcck_pending = 1;
 460         }
 461
 462         if (mci.cp) {
 463                 /* Channel report word pending */
 464                 mcck->channel_report = 1;
 465                 mcck_pending = 1;
 466         }
 467         if (mci.w) {
 468                 /* Warning pending */
 469                 mcck->warning = 1;
 470                 mcck_pending = 1;
 471         }
 472
 473         /*
 474          * If there are only Channel Report Pending and External Damage
 475          * machine checks, they will not be reinjected into the guest
 476          * because they refer to host conditions only.
 477          */
 478         mcck_dam_code = (mci.val & MCIC_SUBCLASS_MASK);
 479         if (test_cpu_flag(CIF_MCCK_GUEST) &&
 480         (mcck_dam_code & MCCK_CODE_NO_GUEST) != mcck_dam_code) {
 481                 /* Set exit reason code for host's later handling */
 482                 *((long *)(regs->gprs[15] + __SF_SIE_REASON)) = -EINTR;
 483         }
 484         clear_cpu_flag(CIF_MCCK_GUEST);
 485
 486         if (user_mode(regs) && mcck_pending) {
 487                 nmi_exit();
 488                 return 1;
 489         }
 490
 491         if (mcck_pending)
 492                 schedule_mcck_handler();
 493
 494         nmi_exit();
 495         return 0;
 496 }
 497 NOKPROBE_SYMBOL(s390_do_machine_check);
 498
 499 static int __init machine_check_init(void)
 500 {
 501         ctl_set_bit(14, 25);    /* enable external damage MCH */
 502         ctl_set_bit(14, 27);    /* enable system recovery MCH */
 503         ctl_set_bit(14, 24);    /* enable warning MCH */
 504         return 0;
 505 }
 506 early_initcall(machine_check_init);