arch/powerpc/kernel/mce.c

   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
  21 #include <asm/machdep.h>
  22 #include <asm/mce.h>
  23 #include <asm/nmi.h>
  24
  25 static DEFINE_PER_CPU(int, mce_nest_count);
  26 static DEFINE_PER_CPU(struct machine_check_event[MAX_MC_EVT], mce_event);
  27
  28 /* Queue for delayed MCE events. */
  29 static DEFINE_PER_CPU(int, mce_queue_count);
  30 static DEFINE_PER_CPU(struct machine_check_event[MAX_MC_EVT], mce_event_queue);
  31
  32 /* Queue for delayed MCE UE events. */
  33 static DEFINE_PER_CPU(int, mce_ue_count);
  34 static DEFINE_PER_CPU(struct machine_check_event[MAX_MC_EVT],
  35                                         mce_ue_event_queue);
  36
  37 static void machine_check_process_queued_event(struct irq_work *work);
  38 static void machine_check_ue_irq_work(struct irq_work *work);
  39 static void machine_check_ue_event(struct machine_check_event *evt);
  40 static void machine_process_ue_event(struct work_struct *work);
  41
  42 static struct irq_work mce_event_process_work = {
  43         .func = machine_check_process_queued_event,
  44 };
  45
  46 static struct irq_work mce_ue_event_irq_work = {
  47         .func = machine_check_ue_irq_work,
  48 };
  49
  50 DECLARE_WORK(mce_ue_event_work, machine_process_ue_event);
  51
  52 static BLOCKING_NOTIFIER_HEAD(mce_notifier_list);
  53
  54 int mce_register_notifier(struct notifier_block *nb)
  55 {
  56         return blocking_notifier_chain_register(&mce_notifier_list, nb);
  57 }
  58 EXPORT_SYMBOL_GPL(mce_register_notifier);
  59
  60 int mce_unregister_notifier(struct notifier_block *nb)
  61 {
  62         return blocking_notifier_chain_unregister(&mce_notifier_list, nb);
  63 }
  64 EXPORT_SYMBOL_GPL(mce_unregister_notifier);
  65
  66 static void mce_set_error_info(struct machine_check_event *mce,
  67                                struct mce_error_info *mce_err)
  68 {
  69         mce->error_type = mce_err->error_type;
  70         switch (mce_err->error_type) {
  71         case MCE_ERROR_TYPE_UE:
  72                 mce->u.ue_error.ue_error_type = mce_err->u.ue_error_type;
  73                 break;
  74         case MCE_ERROR_TYPE_SLB:
  75                 mce->u.slb_error.slb_error_type = mce_err->u.slb_error_type;
  76                 break;
  77         case MCE_ERROR_TYPE_ERAT:
  78                 mce->u.erat_error.erat_error_type = mce_err->u.erat_error_type;
  79                 break;
  80         case MCE_ERROR_TYPE_TLB:
  81                 mce->u.tlb_error.tlb_error_type = mce_err->u.tlb_error_type;
  82                 break;
  83         case MCE_ERROR_TYPE_USER:
  84                 mce->u.user_error.user_error_type = mce_err->u.user_error_type;
  85                 break;
  86         case MCE_ERROR_TYPE_RA:
  87                 mce->u.ra_error.ra_error_type = mce_err->u.ra_error_type;
  88                 break;
  89         case MCE_ERROR_TYPE_LINK:
  90                 mce->u.link_error.link_error_type = mce_err->u.link_error_type;
  91                 break;
  92         case MCE_ERROR_TYPE_UNKNOWN:
  93         default:
  94                 break;
  95         }
  96 }
  97
  98 /*
  99  * Decode and save high level MCE information into per cpu buffer which
 100  * is an array of machine_check_event structure.
 101  */
 102 void save_mce_event(struct pt_regs *regs, long handled,
 103                     struct mce_error_info *mce_err,
 104                     uint64_t nip, uint64_t addr, uint64_t phys_addr)
 105 {
 106         int index = __this_cpu_inc_return(mce_nest_count) - 1;
 107         struct machine_check_event *mce = this_cpu_ptr(&mce_event[index]);
 108
 109         /*
 110          * Return if we don't have enough space to log mce event.
 111          * mce_nest_count may go beyond MAX_MC_EVT but that's ok,
 112          * the check below will stop buffer overrun.
 113          */
 114         if (index >= MAX_MC_EVT)
 115                 return;
 116
 117         /* Populate generic machine check info */
 118         mce->version = MCE_V1;
 119         mce->srr0 = nip;
 120         mce->srr1 = regs->msr;
 121         mce->gpr3 = regs->gpr[3];
 122         mce->in_use = 1;
 123         mce->cpu = get_paca()->paca_index;
 124
 125         /* Mark it recovered if we have handled it and MSR(RI=1). */
 126         if (handled && (regs->msr & MSR_RI))
 127                 mce->disposition = MCE_DISPOSITION_RECOVERED;
 128         else
 129                 mce->disposition = MCE_DISPOSITION_NOT_RECOVERED;
 130
 131         mce->initiator = mce_err->initiator;
 132         mce->severity = mce_err->severity;
 133         mce->sync_error = mce_err->sync_error;
 134         mce->error_class = mce_err->error_class;
 135
 136         /*
 137          * Populate the mce error_type and type-specific error_type.
 138          */
 139         mce_set_error_info(mce, mce_err);
 140
 141         if (!addr)
 142                 return;
 143
 144         if (mce->error_type == MCE_ERROR_TYPE_TLB) {
 145                 mce->u.tlb_error.effective_address_provided = true;
 146                 mce->u.tlb_error.effective_address = addr;
 147         } else if (mce->error_type == MCE_ERROR_TYPE_SLB) {
 148                 mce->u.slb_error.effective_address_provided = true;
 149                 mce->u.slb_error.effective_address = addr;
 150         } else if (mce->error_type == MCE_ERROR_TYPE_ERAT) {
 151                 mce->u.erat_error.effective_address_provided = true;
 152                 mce->u.erat_error.effective_address = addr;
 153         } else if (mce->error_type == MCE_ERROR_TYPE_USER) {
 154                 mce->u.user_error.effective_address_provided = true;
 155                 mce->u.user_error.effective_address = addr;
 156         } else if (mce->error_type == MCE_ERROR_TYPE_RA) {
 157                 mce->u.ra_error.effective_address_provided = true;
 158                 mce->u.ra_error.effective_address = addr;
 159         } else if (mce->error_type == MCE_ERROR_TYPE_LINK) {
 160                 mce->u.link_error.effective_address_provided = true;
 161                 mce->u.link_error.effective_address = addr;
 162         } else if (mce->error_type == MCE_ERROR_TYPE_UE) {
 163                 mce->u.ue_error.effective_address_provided = true;
 164                 mce->u.ue_error.effective_address = addr;
 165                 if (phys_addr != ULONG_MAX) {
 166                         mce->u.ue_error.physical_address_provided = true;
 167                         mce->u.ue_error.physical_address = phys_addr;
 168                         mce->u.ue_error.ignore_event = mce_err->ignore_event;
 169                         machine_check_ue_event(mce);
 170                 }
 171         }
 172         return;
 173 }
 174
 175 /*
 176  * get_mce_event:
 177  *      mce     Pointer to machine_check_event structure to be filled.
 178  *      release Flag to indicate whether to free the event slot or not.
 179  *              0 <= do not release the mce event. Caller will invoke
 180  *                   release_mce_event() once event has been consumed.
 181  *              1 <= release the slot.
 182  *
 183  *      return  1 = success
 184  *              0 = failure
 185  *
 186  * get_mce_event() will be called by platform specific machine check
 187  * handle routine and in KVM.
 188  * When we call get_mce_event(), we are still in interrupt context and
 189  * preemption will not be scheduled until ret_from_expect() routine
 190  * is called.
 191  */
 192 int get_mce_event(struct machine_check_event *mce, bool release)
 193 {
 194         int index = __this_cpu_read(mce_nest_count) - 1;
 195         struct machine_check_event *mc_evt;
 196         int ret = 0;
 197
 198         /* Sanity check */
 199         if (index < 0)
 200                 return ret;
 201
 202         /* Check if we have MCE info to process. */
 203         if (index < MAX_MC_EVT) {
 204                 mc_evt = this_cpu_ptr(&mce_event[index]);
 205                 /* Copy the event structure and release the original */
 206                 if (mce)
 207                         *mce = *mc_evt;
 208                 if (release)
 209                         mc_evt->in_use = 0;
 210                 ret = 1;
 211         }
 212         /* Decrement the count to free the slot. */
 213         if (release)
 214                 __this_cpu_dec(mce_nest_count);
 215
 216         return ret;
 217 }
 218
 219 void release_mce_event(void)
 220 {
 221         get_mce_event(NULL, true);
 222 }
 223
 224 static void machine_check_ue_irq_work(struct irq_work *work)
 225 {
 226         schedule_work(&mce_ue_event_work);
 227 }
 228
 229 /*
 230  * Queue up the MCE event which then can be handled later.
 231  */
 232 static void machine_check_ue_event(struct machine_check_event *evt)
 233 {
 234         int index;
 235
 236         index = __this_cpu_inc_return(mce_ue_count) - 1;
 237         /* If queue is full, just return for now. */
 238         if (index >= MAX_MC_EVT) {
 239                 __this_cpu_dec(mce_ue_count);
 240                 return;
 241         }
 242         memcpy(this_cpu_ptr(&mce_ue_event_queue[index]), evt, sizeof(*evt));
 243
 244         /* Queue work to process this event later. */
 245         irq_work_queue(&mce_ue_event_irq_work);
 246 }
 247
 248 /*
 249  * Queue up the MCE event which then can be handled later.
 250  */
 251 void machine_check_queue_event(void)
 252 {
 253         int index;
 254         struct machine_check_event evt;
 255
 256         if (!get_mce_event(&evt, MCE_EVENT_RELEASE))
 257                 return;
 258
 259         index = __this_cpu_inc_return(mce_queue_count) - 1;
 260         /* If queue is full, just return for now. */
 261         if (index >= MAX_MC_EVT) {
 262                 __this_cpu_dec(mce_queue_count);
 263                 return;
 264         }
 265         memcpy(this_cpu_ptr(&mce_event_queue[index]), &evt, sizeof(evt));
 266
 267         /* Queue irq work to process this event later. */
 268         irq_work_queue(&mce_event_process_work);
 269 }
 270
 271 void mce_common_process_ue(struct pt_regs *regs,
 272                            struct mce_error_info *mce_err)
 273 {
 274         const struct exception_table_entry *entry;
 275
 276         entry = search_kernel_exception_table(regs->nip);
 277         if (entry) {
 278                 mce_err->ignore_event = true;
 279                 regs->nip = extable_fixup(entry);
 280         }
 281 }
 282
 283 /*
 284  * process pending MCE event from the mce event queue. This function will be
 285  * called during syscall exit.
 286  */
 287 static void machine_process_ue_event(struct work_struct *work)
 288 {
 289         int index;
 290         struct machine_check_event *evt;
 291
 292         while (__this_cpu_read(mce_ue_count) > 0) {
 293                 index = __this_cpu_read(mce_ue_count) - 1;
 294                 evt = this_cpu_ptr(&mce_ue_event_queue[index]);
 295                 blocking_notifier_call_chain(&mce_notifier_list, 0, evt);
 296 #ifdef CONFIG_MEMORY_FAILURE
 297                 /*
 298                  * This should probably queued elsewhere, but
 299                  * oh! well
 300                  *
 301                  * Don't report this machine check because the caller has a
 302                  * asked us to ignore the event, it has a fixup handler which
 303                  * will do the appropriate error handling and reporting.
 304                  */
 305                 if (evt->error_type == MCE_ERROR_TYPE_UE) {
 306                         if (evt->u.ue_error.ignore_event) {
 307                                 __this_cpu_dec(mce_ue_count);
 308                                 continue;
 309                         }
 310
 311                         if (evt->u.ue_error.physical_address_provided) {
 312                                 unsigned long pfn;
 313
 314                                 pfn = evt->u.ue_error.physical_address >>
 315                                         PAGE_SHIFT;
 316                                 memory_failure(pfn, 0);
 317                         } else
 318                                 pr_warn("Failed to identify bad address from "
 319                                         "where the uncorrectable error (UE) "
 320                                         "was generated\n");
 321                 }
 322 #endif
 323                 __this_cpu_dec(mce_ue_count);
 324         }
 325 }
 326 /*
 327  * process pending MCE event from the mce event queue. This function will be
 328  * called during syscall exit.
 329  */
 330 static void machine_check_process_queued_event(struct irq_work *work)
 331 {
 332         int index;
 333         struct machine_check_event *evt;
 334
 335         add_taint(TAINT_MACHINE_CHECK, LOCKDEP_NOW_UNRELIABLE);
 336
 337         /*
 338          * For now just print it to console.
 339          * TODO: log this error event to FSP or nvram.
 340          */
 341         while (__this_cpu_read(mce_queue_count) > 0) {
 342                 index = __this_cpu_read(mce_queue_count) - 1;
 343                 evt = this_cpu_ptr(&mce_event_queue[index]);
 344
 345                 if (evt->error_type == MCE_ERROR_TYPE_UE &&
 346                     evt->u.ue_error.ignore_event) {
 347                         __this_cpu_dec(mce_queue_count);
 348                         continue;
 349                 }
 350                 machine_check_print_event_info(evt, false, false);
 351                 __this_cpu_dec(mce_queue_count);
 352         }
 353 }
 354
 355 void machine_check_print_event_info(struct machine_check_event *evt,
 356                                     bool user_mode, bool in_guest)
 357 {
 358         const char *level, *sevstr, *subtype, *err_type, *initiator;
 359         uint64_t ea = 0, pa = 0;
 360         int n = 0;
 361         char dar_str[50];
 362         char pa_str[50];
 363         static const char *mc_ue_types[] = {
 364                 "Indeterminate",
 365                 "Instruction fetch",
 366                 "Page table walk ifetch",
 367                 "Load/Store",
 368                 "Page table walk Load/Store",
 369         };
 370         static const char *mc_slb_types[] = {
 371                 "Indeterminate",
 372                 "Parity",
 373                 "Multihit",
 374         };
 375         static const char *mc_erat_types[] = {
 376                 "Indeterminate",
 377                 "Parity",
 378                 "Multihit",
 379         };
 380         static const char *mc_tlb_types[] = {
 381                 "Indeterminate",
 382                 "Parity",
 383                 "Multihit",
 384         };
 385         static const char *mc_user_types[] = {
 386                 "Indeterminate",
 387                 "tlbie(l) invalid",
 388         };
 389         static const char *mc_ra_types[] = {
 390                 "Indeterminate",
 391                 "Instruction fetch (bad)",
 392                 "Instruction fetch (foreign)",
 393                 "Page table walk ifetch (bad)",
 394                 "Page table walk ifetch (foreign)",
 395                 "Load (bad)",
 396                 "Store (bad)",
 397                 "Page table walk Load/Store (bad)",
 398                 "Page table walk Load/Store (foreign)",
 399                 "Load/Store (foreign)",
 400         };
 401         static const char *mc_link_types[] = {
 402                 "Indeterminate",
 403                 "Instruction fetch (timeout)",
 404                 "Page table walk ifetch (timeout)",
 405                 "Load (timeout)",
 406                 "Store (timeout)",
 407                 "Page table walk Load/Store (timeout)",
 408         };
 409         static const char *mc_error_class[] = {
 410                 "Unknown",
 411                 "Hardware error",
 412                 "Probable Hardware error (some chance of software cause)",
 413                 "Software error",
 414                 "Probable Software error (some chance of hardware cause)",
 415         };
 416
 417         /* Print things out */
 418         if (evt->version != MCE_V1) {
 419                 pr_err("Machine Check Exception, Unknown event version %d !\n",
 420                        evt->version);
 421                 return;
 422         }
 423         switch (evt->severity) {
 424         case MCE_SEV_NO_ERROR:
 425                 level = KERN_INFO;
 426                 sevstr = "Harmless";
 427                 break;
 428         case MCE_SEV_WARNING:
 429                 level = KERN_WARNING;
 430                 sevstr = "Warning";
 431                 break;
 432         case MCE_SEV_SEVERE:
 433                 level = KERN_ERR;
 434                 sevstr = "Severe";
 435                 break;
 436         case MCE_SEV_FATAL:
 437         default:
 438                 level = KERN_ERR;
 439                 sevstr = "Fatal";
 440                 break;
 441         }
 442
 443         switch(evt->initiator) {
 444         case MCE_INITIATOR_CPU:
 445                 initiator = "CPU";
 446                 break;
 447         case MCE_INITIATOR_PCI:
 448                 initiator = "PCI";
 449                 break;
 450         case MCE_INITIATOR_ISA:
 451                 initiator = "ISA";
 452                 break;
 453         case MCE_INITIATOR_MEMORY:
 454                 initiator = "Memory";
 455                 break;
 456         case MCE_INITIATOR_POWERMGM:
 457                 initiator = "Power Management";
 458                 break;
 459         case MCE_INITIATOR_UNKNOWN:
 460         default:
 461                 initiator = "Unknown";
 462                 break;
 463         }
 464
 465         switch (evt->error_type) {
 466         case MCE_ERROR_TYPE_UE:
 467                 err_type = "UE";
 468                 subtype = evt->u.ue_error.ue_error_type <
 469                         ARRAY_SIZE(mc_ue_types) ?
 470                         mc_ue_types[evt->u.ue_error.ue_error_type]
 471                         : "Unknown";
 472                 if (evt->u.ue_error.effective_address_provided)
 473                         ea = evt->u.ue_error.effective_address;
 474                 if (evt->u.ue_error.physical_address_provided)
 475                         pa = evt->u.ue_error.physical_address;
 476                 break;
 477         case MCE_ERROR_TYPE_SLB:
 478                 err_type = "SLB";
 479                 subtype = evt->u.slb_error.slb_error_type <
 480                         ARRAY_SIZE(mc_slb_types) ?
 481                         mc_slb_types[evt->u.slb_error.slb_error_type]
 482                         : "Unknown";
 483                 if (evt->u.slb_error.effective_address_provided)
 484                         ea = evt->u.slb_error.effective_address;
 485                 break;
 486         case MCE_ERROR_TYPE_ERAT:
 487                 err_type = "ERAT";
 488                 subtype = evt->u.erat_error.erat_error_type <
 489                         ARRAY_SIZE(mc_erat_types) ?
 490                         mc_erat_types[evt->u.erat_error.erat_error_type]
 491                         : "Unknown";
 492                 if (evt->u.erat_error.effective_address_provided)
 493                         ea = evt->u.erat_error.effective_address;
 494                 break;
 495         case MCE_ERROR_TYPE_TLB:
 496                 err_type = "TLB";
 497                 subtype = evt->u.tlb_error.tlb_error_type <
 498                         ARRAY_SIZE(mc_tlb_types) ?
 499                         mc_tlb_types[evt->u.tlb_error.tlb_error_type]
 500                         : "Unknown";
 501                 if (evt->u.tlb_error.effective_address_provided)
 502                         ea = evt->u.tlb_error.effective_address;
 503                 break;
 504         case MCE_ERROR_TYPE_USER:
 505                 err_type = "User";
 506                 subtype = evt->u.user_error.user_error_type <
 507                         ARRAY_SIZE(mc_user_types) ?
 508                         mc_user_types[evt->u.user_error.user_error_type]
 509                         : "Unknown";
 510                 if (evt->u.user_error.effective_address_provided)
 511                         ea = evt->u.user_error.effective_address;
 512                 break;
 513         case MCE_ERROR_TYPE_RA:
 514                 err_type = "Real address";
 515                 subtype = evt->u.ra_error.ra_error_type <
 516                         ARRAY_SIZE(mc_ra_types) ?
 517                         mc_ra_types[evt->u.ra_error.ra_error_type]
 518                         : "Unknown";
 519                 if (evt->u.ra_error.effective_address_provided)
 520                         ea = evt->u.ra_error.effective_address;
 521                 break;
 522         case MCE_ERROR_TYPE_LINK:
 523                 err_type = "Link";
 524                 subtype = evt->u.link_error.link_error_type <
 525                         ARRAY_SIZE(mc_link_types) ?
 526                         mc_link_types[evt->u.link_error.link_error_type]
 527                         : "Unknown";
 528                 if (evt->u.link_error.effective_address_provided)
 529                         ea = evt->u.link_error.effective_address;
 530                 break;
 531         case MCE_ERROR_TYPE_DCACHE:
 532                 err_type = "D-Cache";
 533                 subtype = "Unknown";
 534                 break;
 535         case MCE_ERROR_TYPE_ICACHE:
 536                 err_type = "I-Cache";
 537                 subtype = "Unknown";
 538                 break;
 539         default:
 540         case MCE_ERROR_TYPE_UNKNOWN:
 541                 err_type = "Unknown";
 542                 subtype = "";
 543                 break;
 544         }
 545
 546         dar_str[0] = pa_str[0] = '\0';
 547         if (ea && evt->srr0 != ea) {
 548                 /* Load/Store address */
 549                 n = sprintf(dar_str, "DAR: %016llx ", ea);
 550                 if (pa)
 551                         sprintf(dar_str + n, "paddr: %016llx ", pa);
 552         } else if (pa) {
 553                 sprintf(pa_str, " paddr: %016llx", pa);
 554         }
 555
 556         printk("%sMCE: CPU%d: machine check (%s) %s %s %s %s[%s]\n",
 557                 level, evt->cpu, sevstr, in_guest ? "Guest" : "Host",
 558                 err_type, subtype, dar_str,
 559                 evt->disposition == MCE_DISPOSITION_RECOVERED ?
 560                 "Recovered" : "Not recovered");
 561
 562         if (in_guest || user_mode) {
 563                 printk("%sMCE: CPU%d: PID: %d Comm: %s %sNIP: [%016llx]%s\n",
 564                         level, evt->cpu, current->pid, current->comm,
 565                         in_guest ? "Guest " : "", evt->srr0, pa_str);
 566         } else {
 567                 printk("%sMCE: CPU%d: NIP: [%016llx] %pS%s\n",
 568                         level, evt->cpu, evt->srr0, (void *)evt->srr0, pa_str);
 569         }
 570
 571         printk("%sMCE: CPU%d: Initiator %s\n", level, evt->cpu, initiator);
 572
 573         subtype = evt->error_class < ARRAY_SIZE(mc_error_class) ?
 574                 mc_error_class[evt->error_class] : "Unknown";
 575         printk("%sMCE: CPU%d: %s\n", level, evt->cpu, subtype);
 576
 577 #ifdef CONFIG_PPC_BOOK3S_64
 578         /* Display faulty slb contents for SLB errors. */
 579         if (evt->error_type == MCE_ERROR_TYPE_SLB)
 580                 slb_dump_contents(local_paca->mce_faulty_slbs);
 581 #endif
 582 }
 583 EXPORT_SYMBOL_GPL(machine_check_print_event_info);
 584
 585 /*
 586  * This function is called in real mode. Strictly no printk's please.
 587  *
 588  * regs->nip and regs->msr contains srr0 and ssr1.
 589  */
 590 long notrace machine_check_early(struct pt_regs *regs)
 591 {
 592         long handled = 0;
 593         bool nested = in_nmi();
 594         u8 ftrace_enabled = this_cpu_get_ftrace_enabled();
 595
 596         this_cpu_set_ftrace_enabled(0);
 597
 598         if (!nested)
 599                 nmi_enter();
 600
 601         hv_nmi_check_nonrecoverable(regs);
 602
 603         /*
 604          * See if platform is capable of handling machine check.
 605          */
 606         if (ppc_md.machine_check_early)
 607                 handled = ppc_md.machine_check_early(regs);
 608
 609         if (!nested)
 610                 nmi_exit();
 611
 612         this_cpu_set_ftrace_enabled(ftrace_enabled);
 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 long hmi_exception_realmode(struct pt_regs *regs)
 726 {
 727         int ret;
 728
 729         __this_cpu_inc(irq_stat.hmi_exceptions);
 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 }