arch/powerpc/platforms/pseries/ras.c

   1 /*
   2  * Copyright (C) 2001 Dave Engebretsen IBM Corporation
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17  */
  18
  19 #include <linux/sched.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/irq.h>
  22 #include <linux/of.h>
  23 #include <linux/fs.h>
  24 #include <linux/reboot.h>
  25 #include <linux/irq_work.h>
  26
  27 #include <asm/machdep.h>
  28 #include <asm/rtas.h>
  29 #include <asm/firmware.h>
  30 #include <asm/mce.h>
  31
  32 #include "pseries.h"
  33
  34 static unsigned char ras_log_buf[RTAS_ERROR_LOG_MAX];
  35 static DEFINE_SPINLOCK(ras_log_buf_lock);
  36
  37 static int ras_check_exception_token;
  38
  39 static void mce_process_errlog_event(struct irq_work *work);
  40 static struct irq_work mce_errlog_process_work = {
  41         .func = mce_process_errlog_event,
  42 };
  43
  44 #define EPOW_SENSOR_TOKEN       9
  45 #define EPOW_SENSOR_INDEX       0
  46
  47 /* EPOW events counter variable */
  48 static int num_epow_events;
  49
  50 static irqreturn_t ras_hotplug_interrupt(int irq, void *dev_id);
  51 static irqreturn_t ras_epow_interrupt(int irq, void *dev_id);
  52 static irqreturn_t ras_error_interrupt(int irq, void *dev_id);
  53
  54 /* RTAS pseries MCE errorlog section. */
  55 struct pseries_mc_errorlog {
  56         __be32  fru_id;
  57         __be32  proc_id;
  58         u8      error_type;
  59         /*
  60          * sub_err_type (1 byte). Bit fields depends on error_type
  61          *
  62          *   MSB0
  63          *   |
  64          *   V
  65          *   01234567
  66          *   XXXXXXXX
  67          *
  68          * For error_type == MC_ERROR_TYPE_UE
  69          *   XXXXXXXX
  70          *   X          1: Permanent or Transient UE.
  71          *    X         1: Effective address provided.
  72          *     X        1: Logical address provided.
  73          *      XX      2: Reserved.
  74          *        XXX   3: Type of UE error.
  75          *
  76          * For error_type != MC_ERROR_TYPE_UE
  77          *   XXXXXXXX
  78          *   X          1: Effective address provided.
  79          *    XXXXX     5: Reserved.
  80          *         XX   2: Type of SLB/ERAT/TLB error.
  81          */
  82         u8      sub_err_type;
  83         u8      reserved_1[6];
  84         __be64  effective_address;
  85         __be64  logical_address;
  86 } __packed;
  87
  88 /* RTAS pseries MCE error types */
  89 #define MC_ERROR_TYPE_UE                0x00
  90 #define MC_ERROR_TYPE_SLB               0x01
  91 #define MC_ERROR_TYPE_ERAT              0x02
  92 #define MC_ERROR_TYPE_TLB               0x04
  93 #define MC_ERROR_TYPE_D_CACHE           0x05
  94 #define MC_ERROR_TYPE_I_CACHE           0x07
  95
  96 /* RTAS pseries MCE error sub types */
  97 #define MC_ERROR_UE_INDETERMINATE               0
  98 #define MC_ERROR_UE_IFETCH                      1
  99 #define MC_ERROR_UE_PAGE_TABLE_WALK_IFETCH      2
 100 #define MC_ERROR_UE_LOAD_STORE                  3
 101 #define MC_ERROR_UE_PAGE_TABLE_WALK_LOAD_STORE  4
 102
 103 #define MC_ERROR_SLB_PARITY             0
 104 #define MC_ERROR_SLB_MULTIHIT           1
 105 #define MC_ERROR_SLB_INDETERMINATE      2
 106
 107 #define MC_ERROR_ERAT_PARITY            1
 108 #define MC_ERROR_ERAT_MULTIHIT          2
 109 #define MC_ERROR_ERAT_INDETERMINATE     3
 110
 111 #define MC_ERROR_TLB_PARITY             1
 112 #define MC_ERROR_TLB_MULTIHIT           2
 113 #define MC_ERROR_TLB_INDETERMINATE      3
 114
 115 static inline u8 rtas_mc_error_sub_type(const struct pseries_mc_errorlog *mlog)
 116 {
 117         switch (mlog->error_type) {
 118         case    MC_ERROR_TYPE_UE:
 119                 return (mlog->sub_err_type & 0x07);
 120         case    MC_ERROR_TYPE_SLB:
 121         case    MC_ERROR_TYPE_ERAT:
 122         case    MC_ERROR_TYPE_TLB:
 123                 return (mlog->sub_err_type & 0x03);
 124         default:
 125                 return 0;
 126         }
 127 }
 128
 129 static
 130 inline u64 rtas_mc_get_effective_addr(const struct pseries_mc_errorlog *mlog)
 131 {
 132         __be64 addr = 0;
 133
 134         switch (mlog->error_type) {
 135         case    MC_ERROR_TYPE_UE:
 136                 if (mlog->sub_err_type & 0x40)
 137                         addr = mlog->effective_address;
 138                 break;
 139         case    MC_ERROR_TYPE_SLB:
 140         case    MC_ERROR_TYPE_ERAT:
 141         case    MC_ERROR_TYPE_TLB:
 142                 if (mlog->sub_err_type & 0x80)
 143                         addr = mlog->effective_address;
 144         default:
 145                 break;
 146         }
 147         return be64_to_cpu(addr);
 148 }
 149
 150 /*
 151  * Enable the hotplug interrupt late because processing them may touch other
 152  * devices or systems (e.g. hugepages) that have not been initialized at the
 153  * subsys stage.
 154  */
 155 int __init init_ras_hotplug_IRQ(void)
 156 {
 157         struct device_node *np;
 158
 159         /* Hotplug Events */
 160         np = of_find_node_by_path("/event-sources/hot-plug-events");
 161         if (np != NULL) {
 162                 if (dlpar_workqueue_init() == 0)
 163                         request_event_sources_irqs(np, ras_hotplug_interrupt,
 164                                                    "RAS_HOTPLUG");
 165                 of_node_put(np);
 166         }
 167
 168         return 0;
 169 }
 170 machine_late_initcall(pseries, init_ras_hotplug_IRQ);
 171
 172 /*
 173  * Initialize handlers for the set of interrupts caused by hardware errors
 174  * and power system events.
 175  */
 176 static int __init init_ras_IRQ(void)
 177 {
 178         struct device_node *np;
 179
 180         ras_check_exception_token = rtas_token("check-exception");
 181
 182         /* Internal Errors */
 183         np = of_find_node_by_path("/event-sources/internal-errors");
 184         if (np != NULL) {
 185                 request_event_sources_irqs(np, ras_error_interrupt,
 186                                            "RAS_ERROR");
 187                 of_node_put(np);
 188         }
 189
 190         /* EPOW Events */
 191         np = of_find_node_by_path("/event-sources/epow-events");
 192         if (np != NULL) {
 193                 request_event_sources_irqs(np, ras_epow_interrupt, "RAS_EPOW");
 194                 of_node_put(np);
 195         }
 196
 197         return 0;
 198 }
 199 machine_subsys_initcall(pseries, init_ras_IRQ);
 200
 201 #define EPOW_SHUTDOWN_NORMAL                            1
 202 #define EPOW_SHUTDOWN_ON_UPS                            2
 203 #define EPOW_SHUTDOWN_LOSS_OF_CRITICAL_FUNCTIONS        3
 204 #define EPOW_SHUTDOWN_AMBIENT_TEMPERATURE_TOO_HIGH      4
 205
 206 static void handle_system_shutdown(char event_modifier)
 207 {
 208         switch (event_modifier) {
 209         case EPOW_SHUTDOWN_NORMAL:
 210                 pr_emerg("Power off requested\n");
 211                 orderly_poweroff(true);
 212                 break;
 213
 214         case EPOW_SHUTDOWN_ON_UPS:
 215                 pr_emerg("Loss of system power detected. System is running on"
 216                          " UPS/battery. Check RTAS error log for details\n");
 217                 orderly_poweroff(true);
 218                 break;
 219
 220         case EPOW_SHUTDOWN_LOSS_OF_CRITICAL_FUNCTIONS:
 221                 pr_emerg("Loss of system critical functions detected. Check"
 222                          " RTAS error log for details\n");
 223                 orderly_poweroff(true);
 224                 break;
 225
 226         case EPOW_SHUTDOWN_AMBIENT_TEMPERATURE_TOO_HIGH:
 227                 pr_emerg("High ambient temperature detected. Check RTAS"
 228                          " error log for details\n");
 229                 orderly_poweroff(true);
 230                 break;
 231
 232         default:
 233                 pr_err("Unknown power/cooling shutdown event (modifier = %d)\n",
 234                         event_modifier);
 235         }
 236 }
 237
 238 struct epow_errorlog {
 239         unsigned char sensor_value;
 240         unsigned char event_modifier;
 241         unsigned char extended_modifier;
 242         unsigned char reserved;
 243         unsigned char platform_reason;
 244 };
 245
 246 #define EPOW_RESET                      0
 247 #define EPOW_WARN_COOLING               1
 248 #define EPOW_WARN_POWER                 2
 249 #define EPOW_SYSTEM_SHUTDOWN            3
 250 #define EPOW_SYSTEM_HALT                4
 251 #define EPOW_MAIN_ENCLOSURE             5
 252 #define EPOW_POWER_OFF                  7
 253
 254 static void rtas_parse_epow_errlog(struct rtas_error_log *log)
 255 {
 256         struct pseries_errorlog *pseries_log;
 257         struct epow_errorlog *epow_log;
 258         char action_code;
 259         char modifier;
 260
 261         pseries_log = get_pseries_errorlog(log, PSERIES_ELOG_SECT_ID_EPOW);
 262         if (pseries_log == NULL)
 263                 return;
 264
 265         epow_log = (struct epow_errorlog *)pseries_log->data;
 266         action_code = epow_log->sensor_value & 0xF;     /* bottom 4 bits */
 267         modifier = epow_log->event_modifier & 0xF;      /* bottom 4 bits */
 268
 269         switch (action_code) {
 270         case EPOW_RESET:
 271                 if (num_epow_events) {
 272                         pr_info("Non critical power/cooling issue cleared\n");
 273                         num_epow_events--;
 274                 }
 275                 break;
 276
 277         case EPOW_WARN_COOLING:
 278                 pr_info("Non-critical cooling issue detected. Check RTAS error"
 279                         " log for details\n");
 280                 break;
 281
 282         case EPOW_WARN_POWER:
 283                 pr_info("Non-critical power issue detected. Check RTAS error"
 284                         " log for details\n");
 285                 break;
 286
 287         case EPOW_SYSTEM_SHUTDOWN:
 288                 handle_system_shutdown(epow_log->event_modifier);
 289                 break;
 290
 291         case EPOW_SYSTEM_HALT:
 292                 pr_emerg("Critical power/cooling issue detected. Check RTAS"
 293                          " error log for details. Powering off.\n");
 294                 orderly_poweroff(true);
 295                 break;
 296
 297         case EPOW_MAIN_ENCLOSURE:
 298         case EPOW_POWER_OFF:
 299                 pr_emerg("System about to lose power. Check RTAS error log "
 300                          " for details. Powering off immediately.\n");
 301                 emergency_sync();
 302                 kernel_power_off();
 303                 break;
 304
 305         default:
 306                 pr_err("Unknown power/cooling event (action code  = %d)\n",
 307                         action_code);
 308         }
 309
 310         /* Increment epow events counter variable */
 311         if (action_code != EPOW_RESET)
 312                 num_epow_events++;
 313 }
 314
 315 static irqreturn_t ras_hotplug_interrupt(int irq, void *dev_id)
 316 {
 317         struct pseries_errorlog *pseries_log;
 318         struct pseries_hp_errorlog *hp_elog;
 319
 320         spin_lock(&ras_log_buf_lock);
 321
 322         rtas_call(ras_check_exception_token, 6, 1, NULL,
 323                   RTAS_VECTOR_EXTERNAL_INTERRUPT, virq_to_hw(irq),
 324                   RTAS_HOTPLUG_EVENTS, 0, __pa(&ras_log_buf),
 325                   rtas_get_error_log_max());
 326
 327         pseries_log = get_pseries_errorlog((struct rtas_error_log *)ras_log_buf,
 328                                            PSERIES_ELOG_SECT_ID_HOTPLUG);
 329         hp_elog = (struct pseries_hp_errorlog *)pseries_log->data;
 330
 331         /*
 332          * Since PCI hotplug is not currently supported on pseries, put PCI
 333          * hotplug events on the ras_log_buf to be handled by rtas_errd.
 334          */
 335         if (hp_elog->resource == PSERIES_HP_ELOG_RESOURCE_MEM ||
 336             hp_elog->resource == PSERIES_HP_ELOG_RESOURCE_CPU ||
 337             hp_elog->resource == PSERIES_HP_ELOG_RESOURCE_PMEM)
 338                 queue_hotplug_event(hp_elog);
 339         else
 340                 log_error(ras_log_buf, ERR_TYPE_RTAS_LOG, 0);
 341
 342         spin_unlock(&ras_log_buf_lock);
 343         return IRQ_HANDLED;
 344 }
 345
 346 /* Handle environmental and power warning (EPOW) interrupts. */
 347 static irqreturn_t ras_epow_interrupt(int irq, void *dev_id)
 348 {
 349         int status;
 350         int state;
 351         int critical;
 352
 353         status = rtas_get_sensor_fast(EPOW_SENSOR_TOKEN, EPOW_SENSOR_INDEX,
 354                                       &state);
 355
 356         if (state > 3)
 357                 critical = 1;           /* Time Critical */
 358         else
 359                 critical = 0;
 360
 361         spin_lock(&ras_log_buf_lock);
 362
 363         status = rtas_call(ras_check_exception_token, 6, 1, NULL,
 364                            RTAS_VECTOR_EXTERNAL_INTERRUPT,
 365                            virq_to_hw(irq),
 366                            RTAS_EPOW_WARNING,
 367                            critical, __pa(&ras_log_buf),
 368                                 rtas_get_error_log_max());
 369
 370         log_error(ras_log_buf, ERR_TYPE_RTAS_LOG, 0);
 371
 372         rtas_parse_epow_errlog((struct rtas_error_log *)ras_log_buf);
 373
 374         spin_unlock(&ras_log_buf_lock);
 375         return IRQ_HANDLED;
 376 }
 377
 378 /*
 379  * Handle hardware error interrupts.
 380  *
 381  * RTAS check-exception is called to collect data on the exception.  If
 382  * the error is deemed recoverable, we log a warning and return.
 383  * For nonrecoverable errors, an error is logged and we stop all processing
 384  * as quickly as possible in order to prevent propagation of the failure.
 385  */
 386 static irqreturn_t ras_error_interrupt(int irq, void *dev_id)
 387 {
 388         struct rtas_error_log *rtas_elog;
 389         int status;
 390         int fatal;
 391
 392         spin_lock(&ras_log_buf_lock);
 393
 394         status = rtas_call(ras_check_exception_token, 6, 1, NULL,
 395                            RTAS_VECTOR_EXTERNAL_INTERRUPT,
 396                            virq_to_hw(irq),
 397                            RTAS_INTERNAL_ERROR, 1 /* Time Critical */,
 398                            __pa(&ras_log_buf),
 399                                 rtas_get_error_log_max());
 400
 401         rtas_elog = (struct rtas_error_log *)ras_log_buf;
 402
 403         if (status == 0 &&
 404             rtas_error_severity(rtas_elog) >= RTAS_SEVERITY_ERROR_SYNC)
 405                 fatal = 1;
 406         else
 407                 fatal = 0;
 408
 409         /* format and print the extended information */
 410         log_error(ras_log_buf, ERR_TYPE_RTAS_LOG, fatal);
 411
 412         if (fatal) {
 413                 pr_emerg("Fatal hardware error detected. Check RTAS error"
 414                          " log for details. Powering off immediately\n");
 415                 emergency_sync();
 416                 kernel_power_off();
 417         } else {
 418                 pr_err("Recoverable hardware error detected\n");
 419         }
 420
 421         spin_unlock(&ras_log_buf_lock);
 422         return IRQ_HANDLED;
 423 }
 424
 425 /*
 426  * Some versions of FWNMI place the buffer inside the 4kB page starting at
 427  * 0x7000. Other versions place it inside the rtas buffer. We check both.
 428  */
 429 #define VALID_FWNMI_BUFFER(A) \
 430         ((((A) >= 0x7000) && ((A) < 0x7ff0)) || \
 431         (((A) >= rtas.base) && ((A) < (rtas.base + rtas.size - 16))))
 432
 433 static inline struct rtas_error_log *fwnmi_get_errlog(void)
 434 {
 435         return (struct rtas_error_log *)local_paca->mce_data_buf;
 436 }
 437
 438 /*
 439  * Get the error information for errors coming through the
 440  * FWNMI vectors.  The pt_regs' r3 will be updated to reflect
 441  * the actual r3 if possible, and a ptr to the error log entry
 442  * will be returned if found.
 443  *
 444  * Use one buffer mce_data_buf per cpu to store RTAS error.
 445  *
 446  * The mce_data_buf does not have any locks or protection around it,
 447  * if a second machine check comes in, or a system reset is done
 448  * before we have logged the error, then we will get corruption in the
 449  * error log.  This is preferable over holding off on calling
 450  * ibm,nmi-interlock which would result in us checkstopping if a
 451  * second machine check did come in.
 452  */
 453 static struct rtas_error_log *fwnmi_get_errinfo(struct pt_regs *regs)
 454 {
 455         unsigned long *savep;
 456         struct rtas_error_log *h;
 457
 458         /* Mask top two bits */
 459         regs->gpr[3] &= ~(0x3UL << 62);
 460
 461         if (!VALID_FWNMI_BUFFER(regs->gpr[3])) {
 462                 printk(KERN_ERR "FWNMI: corrupt r3 0x%016lx\n", regs->gpr[3]);
 463                 return NULL;
 464         }
 465
 466         savep = __va(regs->gpr[3]);
 467         regs->gpr[3] = be64_to_cpu(savep[0]);   /* restore original r3 */
 468
 469         h = (struct rtas_error_log *)&savep[1];
 470         /* Use the per cpu buffer from paca to store rtas error log */
 471         memset(local_paca->mce_data_buf, 0, RTAS_ERROR_LOG_MAX);
 472         if (!rtas_error_extended(h)) {
 473                 memcpy(local_paca->mce_data_buf, h, sizeof(__u64));
 474         } else {
 475                 int len, error_log_length;
 476
 477                 error_log_length = 8 + rtas_error_extended_log_length(h);
 478                 len = min_t(int, error_log_length, RTAS_ERROR_LOG_MAX);
 479                 memcpy(local_paca->mce_data_buf, h, len);
 480         }
 481
 482         return (struct rtas_error_log *)local_paca->mce_data_buf;
 483 }
 484
 485 /* Call this when done with the data returned by FWNMI_get_errinfo.
 486  * It will release the saved data area for other CPUs in the
 487  * partition to receive FWNMI errors.
 488  */
 489 static void fwnmi_release_errinfo(void)
 490 {
 491         int ret = rtas_call(rtas_token("ibm,nmi-interlock"), 0, 1, NULL);
 492         if (ret != 0)
 493                 printk(KERN_ERR "FWNMI: nmi-interlock failed: %d\n", ret);
 494 }
 495
 496 int pSeries_system_reset_exception(struct pt_regs *regs)
 497 {
 498 #ifdef __LITTLE_ENDIAN__
 499         /*
 500          * Some firmware byteswaps SRR registers and gives incorrect SRR1. Try
 501          * to detect the bad SRR1 pattern here. Flip the NIP back to correct
 502          * endian for reporting purposes. Unfortunately the MSR can't be fixed,
 503          * so clear it. It will be missing MSR_RI so we won't try to recover.
 504          */
 505         if ((be64_to_cpu(regs->msr) &
 506                         (MSR_LE|MSR_RI|MSR_DR|MSR_IR|MSR_ME|MSR_PR|
 507                          MSR_ILE|MSR_HV|MSR_SF)) == (MSR_DR|MSR_SF)) {
 508                 regs->nip = be64_to_cpu((__be64)regs->nip);
 509                 regs->msr = 0;
 510         }
 511 #endif
 512
 513         if (fwnmi_active) {
 514                 struct rtas_error_log *errhdr = fwnmi_get_errinfo(regs);
 515                 if (errhdr) {
 516                         /* XXX Should look at FWNMI information */
 517                 }
 518                 fwnmi_release_errinfo();
 519         }
 520
 521         if (smp_handle_nmi_ipi(regs))
 522                 return 1;
 523
 524         return 0; /* need to perform reset */
 525 }
 526
 527 #define VAL_TO_STRING(ar, val)  \
 528         (((val) < ARRAY_SIZE(ar)) ? ar[(val)] : "Unknown")
 529
 530 static void pseries_print_mce_info(struct pt_regs *regs,
 531                                    struct rtas_error_log *errp)
 532 {
 533         const char *level, *sevstr;
 534         struct pseries_errorlog *pseries_log;
 535         struct pseries_mc_errorlog *mce_log;
 536         u8 error_type, err_sub_type;
 537         u64 addr;
 538         u8 initiator = rtas_error_initiator(errp);
 539         int disposition = rtas_error_disposition(errp);
 540
 541         static const char * const initiators[] = {
 542                 "Unknown",
 543                 "CPU",
 544                 "PCI",
 545                 "ISA",
 546                 "Memory",
 547                 "Power Mgmt",
 548         };
 549         static const char * const mc_err_types[] = {
 550                 "UE",
 551                 "SLB",
 552                 "ERAT",
 553                 "Unknown",
 554                 "TLB",
 555                 "D-Cache",
 556                 "Unknown",
 557                 "I-Cache",
 558         };
 559         static const char * const mc_ue_types[] = {
 560                 "Indeterminate",
 561                 "Instruction fetch",
 562                 "Page table walk ifetch",
 563                 "Load/Store",
 564                 "Page table walk Load/Store",
 565         };
 566
 567         /* SLB sub errors valid values are 0x0, 0x1, 0x2 */
 568         static const char * const mc_slb_types[] = {
 569                 "Parity",
 570                 "Multihit",
 571                 "Indeterminate",
 572         };
 573
 574         /* TLB and ERAT sub errors valid values are 0x1, 0x2, 0x3 */
 575         static const char * const mc_soft_types[] = {
 576                 "Unknown",
 577                 "Parity",
 578                 "Multihit",
 579                 "Indeterminate",
 580         };
 581
 582         if (!rtas_error_extended(errp)) {
 583                 pr_err("Machine check interrupt: Missing extended error log\n");
 584                 return;
 585         }
 586
 587         pseries_log = get_pseries_errorlog(errp, PSERIES_ELOG_SECT_ID_MCE);
 588         if (pseries_log == NULL)
 589                 return;
 590
 591         mce_log = (struct pseries_mc_errorlog *)pseries_log->data;
 592
 593         error_type = mce_log->error_type;
 594         err_sub_type = rtas_mc_error_sub_type(mce_log);
 595
 596         switch (rtas_error_severity(errp)) {
 597         case RTAS_SEVERITY_NO_ERROR:
 598                 level = KERN_INFO;
 599                 sevstr = "Harmless";
 600                 break;
 601         case RTAS_SEVERITY_WARNING:
 602                 level = KERN_WARNING;
 603                 sevstr = "";
 604                 break;
 605         case RTAS_SEVERITY_ERROR:
 606         case RTAS_SEVERITY_ERROR_SYNC:
 607                 level = KERN_ERR;
 608                 sevstr = "Severe";
 609                 break;
 610         case RTAS_SEVERITY_FATAL:
 611         default:
 612                 level = KERN_ERR;
 613                 sevstr = "Fatal";
 614                 break;
 615         }
 616
 617 #ifdef CONFIG_PPC_BOOK3S_64
 618         /* Display faulty slb contents for SLB errors. */
 619         if (error_type == MC_ERROR_TYPE_SLB)
 620                 slb_dump_contents(local_paca->mce_faulty_slbs);
 621 #endif
 622
 623         printk("%s%s Machine check interrupt [%s]\n", level, sevstr,
 624                disposition == RTAS_DISP_FULLY_RECOVERED ?
 625                "Recovered" : "Not recovered");
 626         if (user_mode(regs)) {
 627                 printk("%s  NIP: [%016lx] PID: %d Comm: %s\n", level,
 628                        regs->nip, current->pid, current->comm);
 629         } else {
 630                 printk("%s  NIP [%016lx]: %pS\n", level, regs->nip,
 631                        (void *)regs->nip);
 632         }
 633         printk("%s  Initiator: %s\n", level,
 634                VAL_TO_STRING(initiators, initiator));
 635
 636         switch (error_type) {
 637         case MC_ERROR_TYPE_UE:
 638                 printk("%s  Error type: %s [%s]\n", level,
 639                        VAL_TO_STRING(mc_err_types, error_type),
 640                        VAL_TO_STRING(mc_ue_types, err_sub_type));
 641                 break;
 642         case MC_ERROR_TYPE_SLB:
 643                 printk("%s  Error type: %s [%s]\n", level,
 644                        VAL_TO_STRING(mc_err_types, error_type),
 645                        VAL_TO_STRING(mc_slb_types, err_sub_type));
 646                 break;
 647         case MC_ERROR_TYPE_ERAT:
 648         case MC_ERROR_TYPE_TLB:
 649                 printk("%s  Error type: %s [%s]\n", level,
 650                        VAL_TO_STRING(mc_err_types, error_type),
 651                        VAL_TO_STRING(mc_soft_types, err_sub_type));
 652                 break;
 653         default:
 654                 printk("%s  Error type: %s\n", level,
 655                        VAL_TO_STRING(mc_err_types, error_type));
 656                 break;
 657         }
 658
 659         addr = rtas_mc_get_effective_addr(mce_log);
 660         if (addr)
 661                 printk("%s    Effective address: %016llx\n", level, addr);
 662 }
 663
 664 static int mce_handle_error(struct rtas_error_log *errp)
 665 {
 666         struct pseries_errorlog *pseries_log;
 667         struct pseries_mc_errorlog *mce_log;
 668         int disposition = rtas_error_disposition(errp);
 669         u8 error_type;
 670
 671         if (!rtas_error_extended(errp))
 672                 goto out;
 673
 674         pseries_log = get_pseries_errorlog(errp, PSERIES_ELOG_SECT_ID_MCE);
 675         if (pseries_log == NULL)
 676                 goto out;
 677
 678         mce_log = (struct pseries_mc_errorlog *)pseries_log->data;
 679         error_type = mce_log->error_type;
 680
 681 #ifdef CONFIG_PPC_BOOK3S_64
 682         if (disposition == RTAS_DISP_NOT_RECOVERED) {
 683                 switch (error_type) {
 684                 case    MC_ERROR_TYPE_SLB:
 685                 case    MC_ERROR_TYPE_ERAT:
 686                         /*
 687                          * Store the old slb content in paca before flushing.
 688                          * Print this when we go to virtual mode.
 689                          * There are chances that we may hit MCE again if there
 690                          * is a parity error on the SLB entry we trying to read
 691                          * for saving. Hence limit the slb saving to single
 692                          * level of recursion.
 693                          */
 694                         if (local_paca->in_mce == 1)
 695                                 slb_save_contents(local_paca->mce_faulty_slbs);
 696                         flush_and_reload_slb();
 697                         disposition = RTAS_DISP_FULLY_RECOVERED;
 698                         rtas_set_disposition_recovered(errp);
 699                         break;
 700                 default:
 701                         break;
 702                 }
 703         }
 704 #endif
 705
 706 out:
 707         return disposition;
 708 }
 709
 710 /*
 711  * Process MCE rtas errlog event.
 712  */
 713 static void mce_process_errlog_event(struct irq_work *work)
 714 {
 715         struct rtas_error_log *err;
 716
 717         err = fwnmi_get_errlog();
 718         log_error((char *)err, ERR_TYPE_RTAS_LOG, 0);
 719 }
 720
 721 /*
 722  * See if we can recover from a machine check exception.
 723  * This is only called on power4 (or above) and only via
 724  * the Firmware Non-Maskable Interrupts (fwnmi) handler
 725  * which provides the error analysis for us.
 726  *
 727  * Return 1 if corrected (or delivered a signal).
 728  * Return 0 if there is nothing we can do.
 729  */
 730 static int recover_mce(struct pt_regs *regs, struct rtas_error_log *err)
 731 {
 732         int recovered = 0;
 733         int disposition = rtas_error_disposition(err);
 734
 735         pseries_print_mce_info(regs, err);
 736
 737         if (!(regs->msr & MSR_RI)) {
 738                 /* If MSR_RI isn't set, we cannot recover */
 739                 pr_err("Machine check interrupt unrecoverable: MSR(RI=0)\n");
 740                 recovered = 0;
 741
 742         } else if (disposition == RTAS_DISP_FULLY_RECOVERED) {
 743                 /* Platform corrected itself */
 744                 recovered = 1;
 745
 746         } else if (disposition == RTAS_DISP_LIMITED_RECOVERY) {
 747                 /* Platform corrected itself but could be degraded */
 748                 printk(KERN_ERR "MCE: limited recovery, system may "
 749                        "be degraded\n");
 750                 recovered = 1;
 751
 752         } else if (user_mode(regs) && !is_global_init(current) &&
 753                    rtas_error_severity(err) == RTAS_SEVERITY_ERROR_SYNC) {
 754
 755                 /*
 756                  * If we received a synchronous error when in userspace
 757                  * kill the task. Firmware may report details of the fail
 758                  * asynchronously, so we can't rely on the target and type
 759                  * fields being valid here.
 760                  */
 761                 printk(KERN_ERR "MCE: uncorrectable error, killing task "
 762                        "%s:%d\n", current->comm, current->pid);
 763
 764                 _exception(SIGBUS, regs, BUS_MCEERR_AR, regs->nip);
 765                 recovered = 1;
 766         }
 767
 768         /* Queue irq work to log this rtas event later. */
 769         irq_work_queue(&mce_errlog_process_work);
 770
 771         return recovered;
 772 }
 773
 774 /*
 775  * Handle a machine check.
 776  *
 777  * Note that on Power 4 and beyond Firmware Non-Maskable Interrupts (fwnmi)
 778  * should be present.  If so the handler which called us tells us if the
 779  * error was recovered (never true if RI=0).
 780  *
 781  * On hardware prior to Power 4 these exceptions were asynchronous which
 782  * means we can't tell exactly where it occurred and so we can't recover.
 783  */
 784 int pSeries_machine_check_exception(struct pt_regs *regs)
 785 {
 786         struct rtas_error_log *errp;
 787
 788         if (fwnmi_active) {
 789                 fwnmi_release_errinfo();
 790                 errp = fwnmi_get_errlog();
 791                 if (errp && recover_mce(regs, errp))
 792                         return 1;
 793         }
 794
 795         return 0;
 796 }
 797
 798 long pseries_machine_check_realmode(struct pt_regs *regs)
 799 {
 800         struct rtas_error_log *errp;
 801         int disposition;
 802
 803         if (fwnmi_active) {
 804                 errp = fwnmi_get_errinfo(regs);
 805                 /*
 806                  * Call to fwnmi_release_errinfo() in real mode causes kernel
 807                  * to panic. Hence we will call it as soon as we go into
 808                  * virtual mode.
 809                  */
 810                 disposition = mce_handle_error(errp);
 811                 if (disposition == RTAS_DISP_FULLY_RECOVERED)
 812                         return 1;
 813         }
 814
 815         return 0;
 816 }