1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Machine check exception handling. 4 * 5 * Copyright 2013 IBM Corporation 6 * Author: Mahesh Salgaonkar <mahesh@linux.vnet.ibm.com> 7 */ 8 9 #undef DEBUG 10 #define pr_fmt(fmt) "mce: " fmt 11 12 #include <linux/hardirq.h> 13 #include <linux/types.h> 14 #include <linux/ptrace.h> 15 #include <linux/percpu.h> 16 #include <linux/export.h> 17 #include <linux/irq_work.h> 18 #include <linux/extable.h> 19 #include <linux/ftrace.h> 20 #include <linux/memblock.h> 21 #include <linux/of.h> 22 23 #include <asm/interrupt.h> 24 #include <asm/machdep.h> 25 #include <asm/mce.h> 26 #include <asm/nmi.h> 27 #include <asm/asm-prototypes.h> 28 29 #include "setup.h" 30 31 static void machine_check_process_queued_event(struct irq_work *work); 32 static void machine_check_ue_irq_work(struct irq_work *work); 33 static void machine_check_ue_event(struct machine_check_event *evt); 34 static void machine_process_ue_event(struct work_struct *work); 35 36 static struct irq_work mce_event_process_work = { 37 .func = machine_check_process_queued_event, 38 }; 39 40 static struct irq_work mce_ue_event_irq_work = { 41 .func = machine_check_ue_irq_work, 42 }; 43 44 static DECLARE_WORK(mce_ue_event_work, machine_process_ue_event); 45 46 static BLOCKING_NOTIFIER_HEAD(mce_notifier_list); 47 48 int mce_register_notifier(struct notifier_block *nb) 49 { 50 return blocking_notifier_chain_register(&mce_notifier_list, nb); 51 } 52 EXPORT_SYMBOL_GPL(mce_register_notifier); 53 54 int mce_unregister_notifier(struct notifier_block *nb) 55 { 56 return blocking_notifier_chain_unregister(&mce_notifier_list, nb); 57 } 58 EXPORT_SYMBOL_GPL(mce_unregister_notifier); 59 60 static void mce_set_error_info(struct machine_check_event *mce, 61 struct mce_error_info *mce_err) 62 { 63 mce->error_type = mce_err->error_type; 64 switch (mce_err->error_type) { 65 case MCE_ERROR_TYPE_UE: 66 mce->u.ue_error.ue_error_type = mce_err->u.ue_error_type; 67 break; 68 case MCE_ERROR_TYPE_SLB: 69 mce->u.slb_error.slb_error_type = mce_err->u.slb_error_type; 70 break; 71 case MCE_ERROR_TYPE_ERAT: 72 mce->u.erat_error.erat_error_type = mce_err->u.erat_error_type; 73 break; 74 case MCE_ERROR_TYPE_TLB: 75 mce->u.tlb_error.tlb_error_type = mce_err->u.tlb_error_type; 76 break; 77 case MCE_ERROR_TYPE_USER: 78 mce->u.user_error.user_error_type = mce_err->u.user_error_type; 79 break; 80 case MCE_ERROR_TYPE_RA: 81 mce->u.ra_error.ra_error_type = mce_err->u.ra_error_type; 82 break; 83 case MCE_ERROR_TYPE_LINK: 84 mce->u.link_error.link_error_type = mce_err->u.link_error_type; 85 break; 86 case MCE_ERROR_TYPE_UNKNOWN: 87 default: 88 break; 89 } 90 } 91 92 /* 93 * Decode and save high level MCE information into per cpu buffer which 94 * is an array of machine_check_event structure. 95 */ 96 void save_mce_event(struct pt_regs *regs, long handled, 97 struct mce_error_info *mce_err, 98 uint64_t nip, uint64_t addr, uint64_t phys_addr) 99 { 100 int index = local_paca->mce_info->mce_nest_count++; 101 struct machine_check_event *mce; 102 103 mce = &local_paca->mce_info->mce_event[index]; 104 /* 105 * Return if we don't have enough space to log mce event. 106 * mce_nest_count may go beyond MAX_MC_EVT but that's ok, 107 * the check below will stop buffer overrun. 108 */ 109 if (index >= MAX_MC_EVT) 110 return; 111 112 /* Populate generic machine check info */ 113 mce->version = MCE_V1; 114 mce->srr0 = nip; 115 mce->srr1 = regs->msr; 116 mce->gpr3 = regs->gpr[3]; 117 mce->in_use = 1; 118 mce->cpu = get_paca()->paca_index; 119 120 /* Mark it recovered if we have handled it and MSR(RI=1). */ 121 if (handled && (regs->msr & MSR_RI)) 122 mce->disposition = MCE_DISPOSITION_RECOVERED; 123 else 124 mce->disposition = MCE_DISPOSITION_NOT_RECOVERED; 125 126 mce->initiator = mce_err->initiator; 127 mce->severity = mce_err->severity; 128 mce->sync_error = mce_err->sync_error; 129 mce->error_class = mce_err->error_class; 130 131 /* 132 * Populate the mce error_type and type-specific error_type. 133 */ 134 mce_set_error_info(mce, mce_err); 135 if (mce->error_type == MCE_ERROR_TYPE_UE) 136 mce->u.ue_error.ignore_event = mce_err->ignore_event; 137 138 if (!addr) 139 return; 140 141 if (mce->error_type == MCE_ERROR_TYPE_TLB) { 142 mce->u.tlb_error.effective_address_provided = true; 143 mce->u.tlb_error.effective_address = addr; 144 } else if (mce->error_type == MCE_ERROR_TYPE_SLB) { 145 mce->u.slb_error.effective_address_provided = true; 146 mce->u.slb_error.effective_address = addr; 147 } else if (mce->error_type == MCE_ERROR_TYPE_ERAT) { 148 mce->u.erat_error.effective_address_provided = true; 149 mce->u.erat_error.effective_address = addr; 150 } else if (mce->error_type == MCE_ERROR_TYPE_USER) { 151 mce->u.user_error.effective_address_provided = true; 152 mce->u.user_error.effective_address = addr; 153 } else if (mce->error_type == MCE_ERROR_TYPE_RA) { 154 mce->u.ra_error.effective_address_provided = true; 155 mce->u.ra_error.effective_address = addr; 156 } else if (mce->error_type == MCE_ERROR_TYPE_LINK) { 157 mce->u.link_error.effective_address_provided = true; 158 mce->u.link_error.effective_address = addr; 159 } else if (mce->error_type == MCE_ERROR_TYPE_UE) { 160 mce->u.ue_error.effective_address_provided = true; 161 mce->u.ue_error.effective_address = addr; 162 if (phys_addr != ULONG_MAX) { 163 mce->u.ue_error.physical_address_provided = true; 164 mce->u.ue_error.physical_address = phys_addr; 165 machine_check_ue_event(mce); 166 } 167 } 168 return; 169 } 170 171 /* 172 * get_mce_event: 173 * mce Pointer to machine_check_event structure to be filled. 174 * release Flag to indicate whether to free the event slot or not. 175 * 0 <= do not release the mce event. Caller will invoke 176 * release_mce_event() once event has been consumed. 177 * 1 <= release the slot. 178 * 179 * return 1 = success 180 * 0 = failure 181 * 182 * get_mce_event() will be called by platform specific machine check 183 * handle routine and in KVM. 184 * When we call get_mce_event(), we are still in interrupt context and 185 * preemption will not be scheduled until ret_from_expect() routine 186 * is called. 187 */ 188 int get_mce_event(struct machine_check_event *mce, bool release) 189 { 190 int index = local_paca->mce_info->mce_nest_count - 1; 191 struct machine_check_event *mc_evt; 192 int ret = 0; 193 194 /* Sanity check */ 195 if (index < 0) 196 return ret; 197 198 /* Check if we have MCE info to process. */ 199 if (index < MAX_MC_EVT) { 200 mc_evt = &local_paca->mce_info->mce_event[index]; 201 /* Copy the event structure and release the original */ 202 if (mce) 203 *mce = *mc_evt; 204 if (release) 205 mc_evt->in_use = 0; 206 ret = 1; 207 } 208 /* Decrement the count to free the slot. */ 209 if (release) 210 local_paca->mce_info->mce_nest_count--; 211 212 return ret; 213 } 214 215 void release_mce_event(void) 216 { 217 get_mce_event(NULL, true); 218 } 219 220 static void machine_check_ue_irq_work(struct irq_work *work) 221 { 222 schedule_work(&mce_ue_event_work); 223 } 224 225 /* 226 * Queue up the MCE event which then can be handled later. 227 */ 228 static void machine_check_ue_event(struct machine_check_event *evt) 229 { 230 int index; 231 232 index = local_paca->mce_info->mce_ue_count++; 233 /* If queue is full, just return for now. */ 234 if (index >= MAX_MC_EVT) { 235 local_paca->mce_info->mce_ue_count--; 236 return; 237 } 238 memcpy(&local_paca->mce_info->mce_ue_event_queue[index], 239 evt, sizeof(*evt)); 240 241 /* Queue work to process this event later. */ 242 irq_work_queue(&mce_ue_event_irq_work); 243 } 244 245 /* 246 * Queue up the MCE event which then can be handled later. 247 */ 248 void machine_check_queue_event(void) 249 { 250 int index; 251 struct machine_check_event evt; 252 unsigned long msr; 253 254 if (!get_mce_event(&evt, MCE_EVENT_RELEASE)) 255 return; 256 257 index = local_paca->mce_info->mce_queue_count++; 258 /* If queue is full, just return for now. */ 259 if (index >= MAX_MC_EVT) { 260 local_paca->mce_info->mce_queue_count--; 261 return; 262 } 263 memcpy(&local_paca->mce_info->mce_event_queue[index], 264 &evt, sizeof(evt)); 265 266 /* 267 * Queue irq work to process this event later. Before 268 * queuing the work enable translation for non radix LPAR, 269 * as irq_work_queue may try to access memory outside RMO 270 * region. 271 */ 272 if (!radix_enabled() && firmware_has_feature(FW_FEATURE_LPAR)) { 273 msr = mfmsr(); 274 mtmsr(msr | MSR_IR | MSR_DR); 275 irq_work_queue(&mce_event_process_work); 276 mtmsr(msr); 277 } else { 278 irq_work_queue(&mce_event_process_work); 279 } 280 } 281 282 void mce_common_process_ue(struct pt_regs *regs, 283 struct mce_error_info *mce_err) 284 { 285 const struct exception_table_entry *entry; 286 287 entry = search_kernel_exception_table(regs->nip); 288 if (entry) { 289 mce_err->ignore_event = true; 290 regs_set_return_ip(regs, extable_fixup(entry)); 291 } 292 } 293 294 /* 295 * process pending MCE event from the mce event queue. This function will be 296 * called during syscall exit. 297 */ 298 static void machine_process_ue_event(struct work_struct *work) 299 { 300 int index; 301 struct machine_check_event *evt; 302 303 while (local_paca->mce_info->mce_ue_count > 0) { 304 index = local_paca->mce_info->mce_ue_count - 1; 305 evt = &local_paca->mce_info->mce_ue_event_queue[index]; 306 blocking_notifier_call_chain(&mce_notifier_list, 0, evt); 307 #ifdef CONFIG_MEMORY_FAILURE 308 /* 309 * This should probably queued elsewhere, but 310 * oh! well 311 * 312 * Don't report this machine check because the caller has a 313 * asked us to ignore the event, it has a fixup handler which 314 * will do the appropriate error handling and reporting. 315 */ 316 if (evt->error_type == MCE_ERROR_TYPE_UE) { 317 if (evt->u.ue_error.ignore_event) { 318 local_paca->mce_info->mce_ue_count--; 319 continue; 320 } 321 322 if (evt->u.ue_error.physical_address_provided) { 323 unsigned long pfn; 324 325 pfn = evt->u.ue_error.physical_address >> 326 PAGE_SHIFT; 327 memory_failure(pfn, 0); 328 } else 329 pr_warn("Failed to identify bad address from " 330 "where the uncorrectable error (UE) " 331 "was generated\n"); 332 } 333 #endif 334 local_paca->mce_info->mce_ue_count--; 335 } 336 } 337 /* 338 * process pending MCE event from the mce event queue. This function will be 339 * called during syscall exit. 340 */ 341 static void machine_check_process_queued_event(struct irq_work *work) 342 { 343 int index; 344 struct machine_check_event *evt; 345 346 add_taint(TAINT_MACHINE_CHECK, LOCKDEP_NOW_UNRELIABLE); 347 348 /* 349 * For now just print it to console. 350 * TODO: log this error event to FSP or nvram. 351 */ 352 while (local_paca->mce_info->mce_queue_count > 0) { 353 index = local_paca->mce_info->mce_queue_count - 1; 354 evt = &local_paca->mce_info->mce_event_queue[index]; 355 356 if (evt->error_type == MCE_ERROR_TYPE_UE && 357 evt->u.ue_error.ignore_event) { 358 local_paca->mce_info->mce_queue_count--; 359 continue; 360 } 361 machine_check_print_event_info(evt, false, false); 362 local_paca->mce_info->mce_queue_count--; 363 } 364 } 365 366 void machine_check_print_event_info(struct machine_check_event *evt, 367 bool user_mode, bool in_guest) 368 { 369 const char *level, *sevstr, *subtype, *err_type, *initiator; 370 uint64_t ea = 0, pa = 0; 371 int n = 0; 372 char dar_str[50]; 373 char pa_str[50]; 374 static const char *mc_ue_types[] = { 375 "Indeterminate", 376 "Instruction fetch", 377 "Page table walk ifetch", 378 "Load/Store", 379 "Page table walk Load/Store", 380 }; 381 static const char *mc_slb_types[] = { 382 "Indeterminate", 383 "Parity", 384 "Multihit", 385 }; 386 static const char *mc_erat_types[] = { 387 "Indeterminate", 388 "Parity", 389 "Multihit", 390 }; 391 static const char *mc_tlb_types[] = { 392 "Indeterminate", 393 "Parity", 394 "Multihit", 395 }; 396 static const char *mc_user_types[] = { 397 "Indeterminate", 398 "tlbie(l) invalid", 399 "scv invalid", 400 }; 401 static const char *mc_ra_types[] = { 402 "Indeterminate", 403 "Instruction fetch (bad)", 404 "Instruction fetch (foreign/control memory)", 405 "Page table walk ifetch (bad)", 406 "Page table walk ifetch (foreign/control memory)", 407 "Load (bad)", 408 "Store (bad)", 409 "Page table walk Load/Store (bad)", 410 "Page table walk Load/Store (foreign/control memory)", 411 "Load/Store (foreign/control memory)", 412 }; 413 static const char *mc_link_types[] = { 414 "Indeterminate", 415 "Instruction fetch (timeout)", 416 "Page table walk ifetch (timeout)", 417 "Load (timeout)", 418 "Store (timeout)", 419 "Page table walk Load/Store (timeout)", 420 }; 421 static const char *mc_error_class[] = { 422 "Unknown", 423 "Hardware error", 424 "Probable Hardware error (some chance of software cause)", 425 "Software error", 426 "Probable Software error (some chance of hardware cause)", 427 }; 428 429 /* Print things out */ 430 if (evt->version != MCE_V1) { 431 pr_err("Machine Check Exception, Unknown event version %d !\n", 432 evt->version); 433 return; 434 } 435 switch (evt->severity) { 436 case MCE_SEV_NO_ERROR: 437 level = KERN_INFO; 438 sevstr = "Harmless"; 439 break; 440 case MCE_SEV_WARNING: 441 level = KERN_WARNING; 442 sevstr = "Warning"; 443 break; 444 case MCE_SEV_SEVERE: 445 level = KERN_ERR; 446 sevstr = "Severe"; 447 break; 448 case MCE_SEV_FATAL: 449 default: 450 level = KERN_ERR; 451 sevstr = "Fatal"; 452 break; 453 } 454 455 switch(evt->initiator) { 456 case MCE_INITIATOR_CPU: 457 initiator = "CPU"; 458 break; 459 case MCE_INITIATOR_PCI: 460 initiator = "PCI"; 461 break; 462 case MCE_INITIATOR_ISA: 463 initiator = "ISA"; 464 break; 465 case MCE_INITIATOR_MEMORY: 466 initiator = "Memory"; 467 break; 468 case MCE_INITIATOR_POWERMGM: 469 initiator = "Power Management"; 470 break; 471 case MCE_INITIATOR_UNKNOWN: 472 default: 473 initiator = "Unknown"; 474 break; 475 } 476 477 switch (evt->error_type) { 478 case MCE_ERROR_TYPE_UE: 479 err_type = "UE"; 480 subtype = evt->u.ue_error.ue_error_type < 481 ARRAY_SIZE(mc_ue_types) ? 482 mc_ue_types[evt->u.ue_error.ue_error_type] 483 : "Unknown"; 484 if (evt->u.ue_error.effective_address_provided) 485 ea = evt->u.ue_error.effective_address; 486 if (evt->u.ue_error.physical_address_provided) 487 pa = evt->u.ue_error.physical_address; 488 break; 489 case MCE_ERROR_TYPE_SLB: 490 err_type = "SLB"; 491 subtype = evt->u.slb_error.slb_error_type < 492 ARRAY_SIZE(mc_slb_types) ? 493 mc_slb_types[evt->u.slb_error.slb_error_type] 494 : "Unknown"; 495 if (evt->u.slb_error.effective_address_provided) 496 ea = evt->u.slb_error.effective_address; 497 break; 498 case MCE_ERROR_TYPE_ERAT: 499 err_type = "ERAT"; 500 subtype = evt->u.erat_error.erat_error_type < 501 ARRAY_SIZE(mc_erat_types) ? 502 mc_erat_types[evt->u.erat_error.erat_error_type] 503 : "Unknown"; 504 if (evt->u.erat_error.effective_address_provided) 505 ea = evt->u.erat_error.effective_address; 506 break; 507 case MCE_ERROR_TYPE_TLB: 508 err_type = "TLB"; 509 subtype = evt->u.tlb_error.tlb_error_type < 510 ARRAY_SIZE(mc_tlb_types) ? 511 mc_tlb_types[evt->u.tlb_error.tlb_error_type] 512 : "Unknown"; 513 if (evt->u.tlb_error.effective_address_provided) 514 ea = evt->u.tlb_error.effective_address; 515 break; 516 case MCE_ERROR_TYPE_USER: 517 err_type = "User"; 518 subtype = evt->u.user_error.user_error_type < 519 ARRAY_SIZE(mc_user_types) ? 520 mc_user_types[evt->u.user_error.user_error_type] 521 : "Unknown"; 522 if (evt->u.user_error.effective_address_provided) 523 ea = evt->u.user_error.effective_address; 524 break; 525 case MCE_ERROR_TYPE_RA: 526 err_type = "Real address"; 527 subtype = evt->u.ra_error.ra_error_type < 528 ARRAY_SIZE(mc_ra_types) ? 529 mc_ra_types[evt->u.ra_error.ra_error_type] 530 : "Unknown"; 531 if (evt->u.ra_error.effective_address_provided) 532 ea = evt->u.ra_error.effective_address; 533 break; 534 case MCE_ERROR_TYPE_LINK: 535 err_type = "Link"; 536 subtype = evt->u.link_error.link_error_type < 537 ARRAY_SIZE(mc_link_types) ? 538 mc_link_types[evt->u.link_error.link_error_type] 539 : "Unknown"; 540 if (evt->u.link_error.effective_address_provided) 541 ea = evt->u.link_error.effective_address; 542 break; 543 case MCE_ERROR_TYPE_DCACHE: 544 err_type = "D-Cache"; 545 subtype = "Unknown"; 546 break; 547 case MCE_ERROR_TYPE_ICACHE: 548 err_type = "I-Cache"; 549 subtype = "Unknown"; 550 break; 551 default: 552 case MCE_ERROR_TYPE_UNKNOWN: 553 err_type = "Unknown"; 554 subtype = ""; 555 break; 556 } 557 558 dar_str[0] = pa_str[0] = '\0'; 559 if (ea && evt->srr0 != ea) { 560 /* Load/Store address */ 561 n = sprintf(dar_str, "DAR: %016llx ", ea); 562 if (pa) 563 sprintf(dar_str + n, "paddr: %016llx ", pa); 564 } else if (pa) { 565 sprintf(pa_str, " paddr: %016llx", pa); 566 } 567 568 printk("%sMCE: CPU%d: machine check (%s) %s %s %s %s[%s]\n", 569 level, evt->cpu, sevstr, in_guest ? "Guest" : "", 570 err_type, subtype, dar_str, 571 evt->disposition == MCE_DISPOSITION_RECOVERED ? 572 "Recovered" : "Not recovered"); 573 574 if (in_guest || user_mode) { 575 printk("%sMCE: CPU%d: PID: %d Comm: %s %sNIP: [%016llx]%s\n", 576 level, evt->cpu, current->pid, current->comm, 577 in_guest ? "Guest " : "", evt->srr0, pa_str); 578 } else { 579 printk("%sMCE: CPU%d: NIP: [%016llx] %pS%s\n", 580 level, evt->cpu, evt->srr0, (void *)evt->srr0, pa_str); 581 } 582 583 printk("%sMCE: CPU%d: Initiator %s\n", level, evt->cpu, initiator); 584 585 subtype = evt->error_class < ARRAY_SIZE(mc_error_class) ? 586 mc_error_class[evt->error_class] : "Unknown"; 587 printk("%sMCE: CPU%d: %s\n", level, evt->cpu, subtype); 588 589 #ifdef CONFIG_PPC_64S_HASH_MMU 590 /* Display faulty slb contents for SLB errors. */ 591 if (evt->error_type == MCE_ERROR_TYPE_SLB && !in_guest) 592 slb_dump_contents(local_paca->mce_faulty_slbs); 593 #endif 594 } 595 EXPORT_SYMBOL_GPL(machine_check_print_event_info); 596 597 /* 598 * This function is called in real mode. Strictly no printk's please. 599 * 600 * regs->nip and regs->msr contains srr0 and ssr1. 601 */ 602 DEFINE_INTERRUPT_HANDLER_NMI(machine_check_early) 603 { 604 long handled = 0; 605 606 hv_nmi_check_nonrecoverable(regs); 607 608 /* 609 * See if platform is capable of handling machine check. 610 */ 611 if (ppc_md.machine_check_early) 612 handled = ppc_md.machine_check_early(regs); 613 614 return handled; 615 } 616 617 /* Possible meanings for HMER_DEBUG_TRIG bit being set on POWER9 */ 618 static enum { 619 DTRIG_UNKNOWN, 620 DTRIG_VECTOR_CI, /* need to emulate vector CI load instr */ 621 DTRIG_SUSPEND_ESCAPE, /* need to escape from TM suspend mode */ 622 } hmer_debug_trig_function; 623 624 static int init_debug_trig_function(void) 625 { 626 int pvr; 627 struct device_node *cpun; 628 struct property *prop = NULL; 629 const char *str; 630 631 /* First look in the device tree */ 632 preempt_disable(); 633 cpun = of_get_cpu_node(smp_processor_id(), NULL); 634 if (cpun) { 635 of_property_for_each_string(cpun, "ibm,hmi-special-triggers", 636 prop, str) { 637 if (strcmp(str, "bit17-vector-ci-load") == 0) 638 hmer_debug_trig_function = DTRIG_VECTOR_CI; 639 else if (strcmp(str, "bit17-tm-suspend-escape") == 0) 640 hmer_debug_trig_function = DTRIG_SUSPEND_ESCAPE; 641 } 642 of_node_put(cpun); 643 } 644 preempt_enable(); 645 646 /* If we found the property, don't look at PVR */ 647 if (prop) 648 goto out; 649 650 pvr = mfspr(SPRN_PVR); 651 /* Check for POWER9 Nimbus (scale-out) */ 652 if ((PVR_VER(pvr) == PVR_POWER9) && (pvr & 0xe000) == 0) { 653 /* DD2.2 and later */ 654 if ((pvr & 0xfff) >= 0x202) 655 hmer_debug_trig_function = DTRIG_SUSPEND_ESCAPE; 656 /* DD2.0 and DD2.1 - used for vector CI load emulation */ 657 else if ((pvr & 0xfff) >= 0x200) 658 hmer_debug_trig_function = DTRIG_VECTOR_CI; 659 } 660 661 out: 662 switch (hmer_debug_trig_function) { 663 case DTRIG_VECTOR_CI: 664 pr_debug("HMI debug trigger used for vector CI load\n"); 665 break; 666 case DTRIG_SUSPEND_ESCAPE: 667 pr_debug("HMI debug trigger used for TM suspend escape\n"); 668 break; 669 default: 670 break; 671 } 672 return 0; 673 } 674 __initcall(init_debug_trig_function); 675 676 /* 677 * Handle HMIs that occur as a result of a debug trigger. 678 * Return values: 679 * -1 means this is not a HMI cause that we know about 680 * 0 means no further handling is required 681 * 1 means further handling is required 682 */ 683 long hmi_handle_debugtrig(struct pt_regs *regs) 684 { 685 unsigned long hmer = mfspr(SPRN_HMER); 686 long ret = 0; 687 688 /* HMER_DEBUG_TRIG bit is used for various workarounds on P9 */ 689 if (!((hmer & HMER_DEBUG_TRIG) 690 && hmer_debug_trig_function != DTRIG_UNKNOWN)) 691 return -1; 692 693 hmer &= ~HMER_DEBUG_TRIG; 694 /* HMER is a write-AND register */ 695 mtspr(SPRN_HMER, ~HMER_DEBUG_TRIG); 696 697 switch (hmer_debug_trig_function) { 698 case DTRIG_VECTOR_CI: 699 /* 700 * Now to avoid problems with soft-disable we 701 * only do the emulation if we are coming from 702 * host user space 703 */ 704 if (regs && user_mode(regs)) 705 ret = local_paca->hmi_p9_special_emu = 1; 706 707 break; 708 709 default: 710 break; 711 } 712 713 /* 714 * See if any other HMI causes remain to be handled 715 */ 716 if (hmer & mfspr(SPRN_HMEER)) 717 return -1; 718 719 return ret; 720 } 721 722 /* 723 * Return values: 724 */ 725 DEFINE_INTERRUPT_HANDLER_NMI(hmi_exception_realmode) 726 { 727 int ret; 728 729 local_paca->hmi_irqs++; 730 731 ret = hmi_handle_debugtrig(regs); 732 if (ret >= 0) 733 return ret; 734 735 wait_for_subcore_guest_exit(); 736 737 if (ppc_md.hmi_exception_early) 738 ppc_md.hmi_exception_early(regs); 739 740 wait_for_tb_resync(); 741 742 return 1; 743 } 744 745 void __init mce_init(void) 746 { 747 struct mce_info *mce_info; 748 u64 limit; 749 int i; 750 751 limit = min(ppc64_bolted_size(), ppc64_rma_size); 752 for_each_possible_cpu(i) { 753 mce_info = memblock_alloc_try_nid(sizeof(*mce_info), 754 __alignof__(*mce_info), 755 MEMBLOCK_LOW_LIMIT, 756 limit, cpu_to_node(i)); 757 if (!mce_info) 758 goto err; 759 paca_ptrs[i]->mce_info = mce_info; 760 } 761 return; 762 err: 763 panic("Failed to allocate memory for MCE event data\n"); 764 } 765