sys/x86/x86/mca.c

   1 /*-
   2  * Copyright (c) 2009 Hudson River Trading LLC
   3  * Written by: John H. Baldwin <jhb@FreeBSD.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 /*
  29  * Support for x86 machine check architecture.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #ifdef __amd64__
  36 #define DEV_APIC
  37 #else
  38 #include "opt_apic.h"
  39 #endif
  40
  41 #include <sys/param.h>
  42 #include <sys/bus.h>
  43 #include <sys/interrupt.h>
  44 #include <sys/kernel.h>
  45 #include <sys/lock.h>
  46 #include <sys/malloc.h>
  47 #include <sys/mutex.h>
  48 #include <sys/proc.h>
  49 #include <sys/sched.h>
  50 #include <sys/smp.h>
  51 #include <sys/sysctl.h>
  52 #include <sys/systm.h>
  53 #include <sys/taskqueue.h>
  54 #include <machine/intr_machdep.h>
  55 #include <machine/apicvar.h>
  56 #include <machine/cpu.h>
  57 #include <machine/cputypes.h>
  58 #include <machine/mca.h>
  59 #include <machine/md_var.h>
  60 #include <machine/specialreg.h>
  61
  62 /* Modes for mca_scan() */
  63 enum scan_mode {
  64         POLLED,
  65         MCE,
  66         CMCI,
  67 };
  68
  69 #ifdef DEV_APIC
  70 /*
  71  * State maintained for each monitored MCx bank to control the
  72  * corrected machine check interrupt threshold.
  73  */
  74 struct cmc_state {
  75         int     max_threshold;
  76         int     last_intr;
  77 };
  78 #endif
  79
  80 struct mca_internal {
  81         struct mca_record rec;
  82         int             logged;
  83         STAILQ_ENTRY(mca_internal) link;
  84 };
  85
  86 static MALLOC_DEFINE(M_MCA, "MCA", "Machine Check Architecture");
  87
  88 static volatile int mca_count;  /* Number of records stored. */
  89 static int mca_banks;           /* Number of per-CPU register banks. */
  90
  91 SYSCTL_NODE(_hw, OID_AUTO, mca, CTLFLAG_RD, NULL, "Machine Check Architecture");
  92
  93 static int mca_enabled = 1;
  94 TUNABLE_INT("hw.mca.enabled", &mca_enabled);
  95 SYSCTL_INT(_hw_mca, OID_AUTO, enabled, CTLFLAG_RDTUN, &mca_enabled, 0,
  96     "Administrative toggle for machine check support");
  97
  98 static int amd10h_L1TP = 1;
  99 TUNABLE_INT("hw.mca.amd10h_L1TP", &amd10h_L1TP);
 100 SYSCTL_INT(_hw_mca, OID_AUTO, amd10h_L1TP, CTLFLAG_RDTUN, &amd10h_L1TP, 0,
 101     "Administrative toggle for logging of level one TLB parity (L1TP) errors");
 102
 103 static int intel6h_HSD131;
 104 TUNABLE_INT("hw.mca.intel6h_hsd131", &intel6h_HSD131);
 105 SYSCTL_INT(_hw_mca, OID_AUTO, intel6h_HSD131, CTLFLAG_RDTUN, &intel6h_HSD131, 0,
 106     "Administrative toggle for logging of spurious corrected errors");
 107
 108 int workaround_erratum383;
 109 SYSCTL_INT(_hw_mca, OID_AUTO, erratum383, CTLFLAG_RD, &workaround_erratum383, 0,
 110     "Is the workaround for Erratum 383 on AMD Family 10h processors enabled?");
 111
 112 static STAILQ_HEAD(, mca_internal) mca_freelist;
 113 static int mca_freecount;
 114 static STAILQ_HEAD(, mca_internal) mca_records;
 115 static struct callout mca_timer;
 116 static int mca_ticks = 3600;    /* Check hourly by default. */
 117 static struct taskqueue *mca_tq;
 118 static struct task mca_refill_task, mca_scan_task;
 119 static struct mtx mca_lock;
 120
 121 #ifdef DEV_APIC
 122 static struct cmc_state **cmc_state;    /* Indexed by cpuid, bank */
 123 static int cmc_throttle = 60;   /* Time in seconds to throttle CMCI. */
 124 #endif
 125
 126 static int
 127 sysctl_positive_int(SYSCTL_HANDLER_ARGS)
 128 {
 129         int error, value;
 130
 131         value = *(int *)arg1;
 132         error = sysctl_handle_int(oidp, &value, 0, req);
 133         if (error || req->newptr == NULL)
 134                 return (error);
 135         if (value <= 0)
 136                 return (EINVAL);
 137         *(int *)arg1 = value;
 138         return (0);
 139 }
 140
 141 static int
 142 sysctl_mca_records(SYSCTL_HANDLER_ARGS)
 143 {
 144         int *name = (int *)arg1;
 145         u_int namelen = arg2;
 146         struct mca_record record;
 147         struct mca_internal *rec;
 148         int i;
 149
 150         if (namelen != 1)
 151                 return (EINVAL);
 152
 153         if (name[0] < 0 || name[0] >= mca_count)
 154                 return (EINVAL);
 155
 156         mtx_lock_spin(&mca_lock);
 157         if (name[0] >= mca_count) {
 158                 mtx_unlock_spin(&mca_lock);
 159                 return (EINVAL);
 160         }
 161         i = 0;
 162         STAILQ_FOREACH(rec, &mca_records, link) {
 163                 if (i == name[0]) {
 164                         record = rec->rec;
 165                         break;
 166                 }
 167                 i++;
 168         }
 169         mtx_unlock_spin(&mca_lock);
 170         return (SYSCTL_OUT(req, &record, sizeof(record)));
 171 }
 172
 173 static const char *
 174 mca_error_ttype(uint16_t mca_error)
 175 {
 176
 177         switch ((mca_error & 0x000c) >> 2) {
 178         case 0:
 179                 return ("I");
 180         case 1:
 181                 return ("D");
 182         case 2:
 183                 return ("G");
 184         }
 185         return ("?");
 186 }
 187
 188 static const char *
 189 mca_error_level(uint16_t mca_error)
 190 {
 191
 192         switch (mca_error & 0x0003) {
 193         case 0:
 194                 return ("L0");
 195         case 1:
 196                 return ("L1");
 197         case 2:
 198                 return ("L2");
 199         case 3:
 200                 return ("LG");
 201         }
 202         return ("L?");
 203 }
 204
 205 static const char *
 206 mca_error_request(uint16_t mca_error)
 207 {
 208
 209         switch ((mca_error & 0x00f0) >> 4) {
 210         case 0x0:
 211                 return ("ERR");
 212         case 0x1:
 213                 return ("RD");
 214         case 0x2:
 215                 return ("WR");
 216         case 0x3:
 217                 return ("DRD");
 218         case 0x4:
 219                 return ("DWR");
 220         case 0x5:
 221                 return ("IRD");
 222         case 0x6:
 223                 return ("PREFETCH");
 224         case 0x7:
 225                 return ("EVICT");
 226         case 0x8:
 227                 return ("SNOOP");
 228         }
 229         return ("???");
 230 }
 231
 232 static const char *
 233 mca_error_mmtype(uint16_t mca_error)
 234 {
 235
 236         switch ((mca_error & 0x70) >> 4) {
 237         case 0x0:
 238                 return ("GEN");
 239         case 0x1:
 240                 return ("RD");
 241         case 0x2:
 242                 return ("WR");
 243         case 0x3:
 244                 return ("AC");
 245         case 0x4:
 246                 return ("MS");
 247         }
 248         return ("???");
 249 }
 250
 251 static int __nonnull(1)
 252 mca_mute(const struct mca_record *rec)
 253 {
 254
 255         /*
 256          * Skip spurious corrected parity errors generated by desktop Haswell
 257          * (see HSD131 erratum) unless reporting is enabled.
 258          * Note that these errors also have been observed with D0-stepping,
 259          * while the revision 014 desktop Haswell specification update only
 260          * talks about C0-stepping.
 261          */
 262         if (rec->mr_cpu_vendor_id == CPU_VENDOR_INTEL &&
 263             rec->mr_cpu_id == 0x306c3 && rec->mr_bank == 0 &&
 264             rec->mr_status == 0x90000040000f0005 && !intel6h_HSD131)
 265                 return (1);
 266
 267         return (0);
 268 }
 269
 270 /* Dump details about a single machine check. */
 271 static void __nonnull(1)
 272 mca_log(const struct mca_record *rec)
 273 {
 274         uint16_t mca_error;
 275
 276         if (mca_mute(rec))
 277                 return;
 278
 279         printf("MCA: Bank %d, Status 0x%016llx\n", rec->mr_bank,
 280             (long long)rec->mr_status);
 281         printf("MCA: Global Cap 0x%016llx, Status 0x%016llx\n",
 282             (long long)rec->mr_mcg_cap, (long long)rec->mr_mcg_status);
 283         printf("MCA: Vendor \"%s\", ID 0x%x, APIC ID %d\n", cpu_vendor,
 284             rec->mr_cpu_id, rec->mr_apic_id);
 285         printf("MCA: CPU %d ", rec->mr_cpu);
 286         if (rec->mr_status & MC_STATUS_UC)
 287                 printf("UNCOR ");
 288         else {
 289                 printf("COR ");
 290                 if (rec->mr_mcg_cap & MCG_CAP_CMCI_P)
 291                         printf("(%lld) ", ((long long)rec->mr_status &
 292                             MC_STATUS_COR_COUNT) >> 38);
 293         }
 294         if (rec->mr_status & MC_STATUS_PCC)
 295                 printf("PCC ");
 296         if (rec->mr_status & MC_STATUS_OVER)
 297                 printf("OVER ");
 298         mca_error = rec->mr_status & MC_STATUS_MCA_ERROR;
 299         switch (mca_error) {
 300                 /* Simple error codes. */
 301         case 0x0000:
 302                 printf("no error");
 303                 break;
 304         case 0x0001:
 305                 printf("unclassified error");
 306                 break;
 307         case 0x0002:
 308                 printf("ucode ROM parity error");
 309                 break;
 310         case 0x0003:
 311                 printf("external error");
 312                 break;
 313         case 0x0004:
 314                 printf("FRC error");
 315                 break;
 316         case 0x0005:
 317                 printf("internal parity error");
 318                 break;
 319         case 0x0400:
 320                 printf("internal timer error");
 321                 break;
 322         default:
 323                 if ((mca_error & 0xfc00) == 0x0400) {
 324                         printf("internal error %x", mca_error & 0x03ff);
 325                         break;
 326                 }
 327
 328                 /* Compound error codes. */
 329
 330                 /* Memory hierarchy error. */
 331                 if ((mca_error & 0xeffc) == 0x000c) {
 332                         printf("%s memory error", mca_error_level(mca_error));
 333                         break;
 334                 }
 335
 336                 /* TLB error. */
 337                 if ((mca_error & 0xeff0) == 0x0010) {
 338                         printf("%sTLB %s error", mca_error_ttype(mca_error),
 339                             mca_error_level(mca_error));
 340                         break;
 341                 }
 342
 343                 /* Memory controller error. */
 344                 if ((mca_error & 0xef80) == 0x0080) {
 345                         printf("%s channel ", mca_error_mmtype(mca_error));
 346                         if ((mca_error & 0x000f) != 0x000f)
 347                                 printf("%d", mca_error & 0x000f);
 348                         else
 349                                 printf("??");
 350                         printf(" memory error");
 351                         break;
 352                 }
 353
 354                 /* Cache error. */
 355                 if ((mca_error & 0xef00) == 0x0100) {
 356                         printf("%sCACHE %s %s error",
 357                             mca_error_ttype(mca_error),
 358                             mca_error_level(mca_error),
 359                             mca_error_request(mca_error));
 360                         break;
 361                 }
 362
 363                 /* Bus and/or Interconnect error. */
 364                 if ((mca_error & 0xe800) == 0x0800) {
 365                         printf("BUS%s ", mca_error_level(mca_error));
 366                         switch ((mca_error & 0x0600) >> 9) {
 367                         case 0:
 368                                 printf("Source");
 369                                 break;
 370                         case 1:
 371                                 printf("Responder");
 372                                 break;
 373                         case 2:
 374                                 printf("Observer");
 375                                 break;
 376                         default:
 377                                 printf("???");
 378                                 break;
 379                         }
 380                         printf(" %s ", mca_error_request(mca_error));
 381                         switch ((mca_error & 0x000c) >> 2) {
 382                         case 0:
 383                                 printf("Memory");
 384                                 break;
 385                         case 2:
 386                                 printf("I/O");
 387                                 break;
 388                         case 3:
 389                                 printf("Other");
 390                                 break;
 391                         default:
 392                                 printf("???");
 393                                 break;
 394                         }
 395                         if (mca_error & 0x0100)
 396                                 printf(" timed out");
 397                         break;
 398                 }
 399
 400                 printf("unknown error %x", mca_error);
 401                 break;
 402         }
 403         printf("\n");
 404         if (rec->mr_status & MC_STATUS_ADDRV)
 405                 printf("MCA: Address 0x%llx\n", (long long)rec->mr_addr);
 406         if (rec->mr_status & MC_STATUS_MISCV)
 407                 printf("MCA: Misc 0x%llx\n", (long long)rec->mr_misc);
 408 }
 409
 410 static int __nonnull(2)
 411 mca_check_status(int bank, struct mca_record *rec)
 412 {
 413         uint64_t status;
 414         u_int p[4];
 415
 416         status = rdmsr(MSR_MC_STATUS(bank));
 417         if (!(status & MC_STATUS_VAL))
 418                 return (0);
 419
 420         /* Save exception information. */
 421         rec->mr_status = status;
 422         rec->mr_bank = bank;
 423         rec->mr_addr = 0;
 424         if (status & MC_STATUS_ADDRV)
 425                 rec->mr_addr = rdmsr(MSR_MC_ADDR(bank));
 426         rec->mr_misc = 0;
 427         if (status & MC_STATUS_MISCV)
 428                 rec->mr_misc = rdmsr(MSR_MC_MISC(bank));
 429         rec->mr_tsc = rdtsc();
 430         rec->mr_apic_id = PCPU_GET(apic_id);
 431         rec->mr_mcg_cap = rdmsr(MSR_MCG_CAP);
 432         rec->mr_mcg_status = rdmsr(MSR_MCG_STATUS);
 433         rec->mr_cpu_id = cpu_id;
 434         rec->mr_cpu_vendor_id = cpu_vendor_id;
 435         rec->mr_cpu = PCPU_GET(cpuid);
 436
 437         /*
 438          * Clear machine check.  Don't do this for uncorrectable
 439          * errors so that the BIOS can see them.
 440          */
 441         if (!(rec->mr_status & (MC_STATUS_PCC | MC_STATUS_UC))) {
 442                 wrmsr(MSR_MC_STATUS(bank), 0);
 443                 do_cpuid(0, p);
 444         }
 445         return (1);
 446 }
 447
 448 static void
 449 mca_fill_freelist(void)
 450 {
 451         struct mca_internal *rec;
 452         int desired;
 453
 454         /*
 455          * Ensure we have at least one record for each bank and one
 456          * record per CPU.
 457          */
 458         desired = imax(mp_ncpus, mca_banks);
 459         mtx_lock_spin(&mca_lock);
 460         while (mca_freecount < desired) {
 461                 mtx_unlock_spin(&mca_lock);
 462                 rec = malloc(sizeof(*rec), M_MCA, M_WAITOK);
 463                 mtx_lock_spin(&mca_lock);
 464                 STAILQ_INSERT_TAIL(&mca_freelist, rec, link);
 465                 mca_freecount++;
 466         }
 467         mtx_unlock_spin(&mca_lock);
 468 }
 469
 470 static void
 471 mca_refill(void *context, int pending)
 472 {
 473
 474         mca_fill_freelist();
 475 }
 476
 477 static void __nonnull(2)
 478 mca_record_entry(enum scan_mode mode, const struct mca_record *record)
 479 {
 480         struct mca_internal *rec;
 481
 482         if (mode == POLLED) {
 483                 rec = malloc(sizeof(*rec), M_MCA, M_WAITOK);
 484                 mtx_lock_spin(&mca_lock);
 485         } else {
 486                 mtx_lock_spin(&mca_lock);
 487                 rec = STAILQ_FIRST(&mca_freelist);
 488                 if (rec == NULL) {
 489                         printf("MCA: Unable to allocate space for an event.\n");
 490                         mca_log(record);
 491                         mtx_unlock_spin(&mca_lock);
 492                         return;
 493                 }
 494                 STAILQ_REMOVE_HEAD(&mca_freelist, link);
 495                 mca_freecount--;
 496         }
 497
 498         rec->rec = *record;
 499         rec->logged = 0;
 500         STAILQ_INSERT_TAIL(&mca_records, rec, link);
 501         mca_count++;
 502         mtx_unlock_spin(&mca_lock);
 503         if (mode == CMCI)
 504                 taskqueue_enqueue_fast(mca_tq, &mca_refill_task);
 505 }
 506
 507 #ifdef DEV_APIC
 508 /*
 509  * Update the interrupt threshold for a CMCI.  The strategy is to use
 510  * a low trigger that interrupts as soon as the first event occurs.
 511  * However, if a steady stream of events arrive, the threshold is
 512  * increased until the interrupts are throttled to once every
 513  * cmc_throttle seconds or the periodic scan.  If a periodic scan
 514  * finds that the threshold is too high, it is lowered.
 515  */
 516 static void
 517 cmci_update(enum scan_mode mode, int bank, int valid, struct mca_record *rec)
 518 {
 519         struct cmc_state *cc;
 520         uint64_t ctl;
 521         u_int delta;
 522         int count, limit;
 523
 524         /* Fetch the current limit for this bank. */
 525         cc = &cmc_state[PCPU_GET(cpuid)][bank];
 526         ctl = rdmsr(MSR_MC_CTL2(bank));
 527         count = (rec->mr_status & MC_STATUS_COR_COUNT) >> 38;
 528         delta = (u_int)(ticks - cc->last_intr);
 529
 530         /*
 531          * If an interrupt was received less than cmc_throttle seconds
 532          * since the previous interrupt and the count from the current
 533          * event is greater than or equal to the current threshold,
 534          * double the threshold up to the max.
 535          */
 536         if (mode == CMCI && valid) {
 537                 limit = ctl & MC_CTL2_THRESHOLD;
 538                 if (delta < cmc_throttle && count >= limit &&
 539                     limit < cc->max_threshold) {
 540                         limit = min(limit << 1, cc->max_threshold);
 541                         ctl &= ~MC_CTL2_THRESHOLD;
 542                         ctl |= limit;
 543                         wrmsr(MSR_MC_CTL2(bank), limit);
 544                 }
 545                 cc->last_intr = ticks;
 546                 return;
 547         }
 548
 549         /*
 550          * When the banks are polled, check to see if the threshold
 551          * should be lowered.
 552          */
 553         if (mode != POLLED)
 554                 return;
 555
 556         /* If a CMCI occured recently, do nothing for now. */
 557         if (delta < cmc_throttle)
 558                 return;
 559
 560         /*
 561          * Compute a new limit based on the average rate of events per
 562          * cmc_throttle seconds since the last interrupt.
 563          */
 564         if (valid) {
 565                 count = (rec->mr_status & MC_STATUS_COR_COUNT) >> 38;
 566                 limit = count * cmc_throttle / delta;
 567                 if (limit <= 0)
 568                         limit = 1;
 569                 else if (limit > cc->max_threshold)
 570                         limit = cc->max_threshold;
 571         } else
 572                 limit = 1;
 573         if ((ctl & MC_CTL2_THRESHOLD) != limit) {
 574                 ctl &= ~MC_CTL2_THRESHOLD;
 575                 ctl |= limit;
 576                 wrmsr(MSR_MC_CTL2(bank), limit);
 577         }
 578 }
 579 #endif
 580
 581 /*
 582  * This scans all the machine check banks of the current CPU to see if
 583  * there are any machine checks.  Any non-recoverable errors are
 584  * reported immediately via mca_log().  The current thread must be
 585  * pinned when this is called.  The 'mode' parameter indicates if we
 586  * are being called from the MC exception handler, the CMCI handler,
 587  * or the periodic poller.  In the MC exception case this function
 588  * returns true if the system is restartable.  Otherwise, it returns a
 589  * count of the number of valid MC records found.
 590  */
 591 static int
 592 mca_scan(enum scan_mode mode)
 593 {
 594         struct mca_record rec;
 595         uint64_t mcg_cap, ucmask;
 596         int count, i, recoverable, valid;
 597
 598         count = 0;
 599         recoverable = 1;
 600         ucmask = MC_STATUS_UC | MC_STATUS_PCC;
 601
 602         /* When handling a MCE#, treat the OVER flag as non-restartable. */
 603         if (mode == MCE)
 604                 ucmask |= MC_STATUS_OVER;
 605         mcg_cap = rdmsr(MSR_MCG_CAP);
 606         for (i = 0; i < (mcg_cap & MCG_CAP_COUNT); i++) {
 607 #ifdef DEV_APIC
 608                 /*
 609                  * For a CMCI, only check banks this CPU is
 610                  * responsible for.
 611                  */
 612                 if (mode == CMCI && !(PCPU_GET(cmci_mask) & 1 << i))
 613                         continue;
 614 #endif
 615
 616                 valid = mca_check_status(i, &rec);
 617                 if (valid) {
 618                         count++;
 619                         if (rec.mr_status & ucmask) {
 620                                 recoverable = 0;
 621                                 mtx_lock_spin(&mca_lock);
 622                                 mca_log(&rec);
 623                                 mtx_unlock_spin(&mca_lock);
 624                         }
 625                         mca_record_entry(mode, &rec);
 626                 }
 627
 628 #ifdef DEV_APIC
 629                 /*
 630                  * If this is a bank this CPU monitors via CMCI,
 631                  * update the threshold.
 632                  */
 633                 if (PCPU_GET(cmci_mask) & 1 << i)
 634                         cmci_update(mode, i, valid, &rec);
 635 #endif
 636         }
 637         if (mode == POLLED)
 638                 mca_fill_freelist();
 639         return (mode == MCE ? recoverable : count);
 640 }
 641
 642 /*
 643  * Scan the machine check banks on all CPUs by binding to each CPU in
 644  * turn.  If any of the CPUs contained new machine check records, log
 645  * them to the console.
 646  */
 647 static void
 648 mca_scan_cpus(void *context, int pending)
 649 {
 650         struct mca_internal *mca;
 651         struct thread *td;
 652         int count, cpu;
 653
 654         mca_fill_freelist();
 655         td = curthread;
 656         count = 0;
 657         thread_lock(td);
 658         CPU_FOREACH(cpu) {
 659                 sched_bind(td, cpu);
 660                 thread_unlock(td);
 661                 count += mca_scan(POLLED);
 662                 thread_lock(td);
 663                 sched_unbind(td);
 664         }
 665         thread_unlock(td);
 666         if (count != 0) {
 667                 mtx_lock_spin(&mca_lock);
 668                 STAILQ_FOREACH(mca, &mca_records, link) {
 669                         if (!mca->logged) {
 670                                 mca->logged = 1;
 671                                 mca_log(&mca->rec);
 672                         }
 673                 }
 674                 mtx_unlock_spin(&mca_lock);
 675         }
 676 }
 677
 678 static void
 679 mca_periodic_scan(void *arg)
 680 {
 681
 682         taskqueue_enqueue_fast(mca_tq, &mca_scan_task);
 683         callout_reset(&mca_timer, mca_ticks * hz, mca_periodic_scan, NULL);
 684 }
 685
 686 static int
 687 sysctl_mca_scan(SYSCTL_HANDLER_ARGS)
 688 {
 689         int error, i;
 690
 691         i = 0;
 692         error = sysctl_handle_int(oidp, &i, 0, req);
 693         if (error)
 694                 return (error);
 695         if (i)
 696                 taskqueue_enqueue_fast(mca_tq, &mca_scan_task);
 697         return (0);
 698 }
 699
 700 static void
 701 mca_createtq(void *dummy)
 702 {
 703         if (mca_banks <= 0)
 704                 return;
 705
 706         mca_tq = taskqueue_create_fast("mca", M_WAITOK,
 707             taskqueue_thread_enqueue, &mca_tq);
 708         taskqueue_start_threads(&mca_tq, 1, PI_SWI(SWI_TQ), "mca taskq");
 709 }
 710 SYSINIT(mca_createtq, SI_SUB_CONFIGURE, SI_ORDER_ANY, mca_createtq, NULL);
 711
 712 static void
 713 mca_startup(void *dummy)
 714 {
 715
 716         if (mca_banks <= 0)
 717                 return;
 718
 719         callout_reset(&mca_timer, mca_ticks * hz, mca_periodic_scan, NULL);
 720 }
 721 SYSINIT(mca_startup, SI_SUB_SMP, SI_ORDER_ANY, mca_startup, NULL);
 722
 723 #ifdef DEV_APIC
 724 static void
 725 cmci_setup(void)
 726 {
 727         int i;
 728
 729         cmc_state = malloc((mp_maxid + 1) * sizeof(struct cmc_state *), M_MCA,
 730             M_WAITOK);
 731         for (i = 0; i <= mp_maxid; i++)
 732                 cmc_state[i] = malloc(sizeof(struct cmc_state) * mca_banks,
 733                     M_MCA, M_WAITOK | M_ZERO);
 734         SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_mca), OID_AUTO,
 735             "cmc_throttle", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE,
 736             &cmc_throttle, 0, sysctl_positive_int, "I",
 737             "Interval in seconds to throttle corrected MC interrupts");
 738 }
 739 #endif
 740
 741 static void
 742 mca_setup(uint64_t mcg_cap)
 743 {
 744
 745         /*
 746          * On AMD Family 10h processors, unless logging of level one TLB
 747          * parity (L1TP) errors is disabled, enable the recommended workaround
 748          * for Erratum 383.
 749          */
 750         if (cpu_vendor_id == CPU_VENDOR_AMD &&
 751             CPUID_TO_FAMILY(cpu_id) == 0x10 && amd10h_L1TP)
 752                 workaround_erratum383 = 1;
 753
 754         mca_banks = mcg_cap & MCG_CAP_COUNT;
 755         mtx_init(&mca_lock, "mca", NULL, MTX_SPIN);
 756         STAILQ_INIT(&mca_records);
 757         TASK_INIT(&mca_scan_task, 0, mca_scan_cpus, NULL);
 758         callout_init(&mca_timer, CALLOUT_MPSAFE);
 759         STAILQ_INIT(&mca_freelist);
 760         TASK_INIT(&mca_refill_task, 0, mca_refill, NULL);
 761         mca_fill_freelist();
 762         SYSCTL_ADD_INT(NULL, SYSCTL_STATIC_CHILDREN(_hw_mca), OID_AUTO,
 763             "count", CTLFLAG_RD, (int *)(uintptr_t)&mca_count, 0,
 764             "Record count");
 765         SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_mca), OID_AUTO,
 766             "interval", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, &mca_ticks,
 767             0, sysctl_positive_int, "I",
 768             "Periodic interval in seconds to scan for machine checks");
 769         SYSCTL_ADD_NODE(NULL, SYSCTL_STATIC_CHILDREN(_hw_mca), OID_AUTO,
 770             "records", CTLFLAG_RD, sysctl_mca_records, "Machine check records");
 771         SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_mca), OID_AUTO,
 772             "force_scan", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, 0,
 773             sysctl_mca_scan, "I", "Force an immediate scan for machine checks");
 774 #ifdef DEV_APIC
 775         if (mcg_cap & MCG_CAP_CMCI_P)
 776                 cmci_setup();
 777 #endif
 778 }
 779
 780 #ifdef DEV_APIC
 781 /*
 782  * See if we should monitor CMCI for this bank.  If CMCI_EN is already
 783  * set in MC_CTL2, then another CPU is responsible for this bank, so
 784  * ignore it.  If CMCI_EN returns zero after being set, then this bank
 785  * does not support CMCI_EN.  If this CPU sets CMCI_EN, then it should
 786  * now monitor this bank.
 787  */
 788 static void
 789 cmci_monitor(int i)
 790 {
 791         struct cmc_state *cc;
 792         uint64_t ctl;
 793
 794         KASSERT(i < mca_banks, ("CPU %d has more MC banks", PCPU_GET(cpuid)));
 795
 796         ctl = rdmsr(MSR_MC_CTL2(i));
 797         if (ctl & MC_CTL2_CMCI_EN)
 798                 /* Already monitored by another CPU. */
 799                 return;
 800
 801         /* Set the threshold to one event for now. */
 802         ctl &= ~MC_CTL2_THRESHOLD;
 803         ctl |= MC_CTL2_CMCI_EN | 1;
 804         wrmsr(MSR_MC_CTL2(i), ctl);
 805         ctl = rdmsr(MSR_MC_CTL2(i));
 806         if (!(ctl & MC_CTL2_CMCI_EN))
 807                 /* This bank does not support CMCI. */
 808                 return;
 809
 810         cc = &cmc_state[PCPU_GET(cpuid)][i];
 811
 812         /* Determine maximum threshold. */
 813         ctl &= ~MC_CTL2_THRESHOLD;
 814         ctl |= 0x7fff;
 815         wrmsr(MSR_MC_CTL2(i), ctl);
 816         ctl = rdmsr(MSR_MC_CTL2(i));
 817         cc->max_threshold = ctl & MC_CTL2_THRESHOLD;
 818
 819         /* Start off with a threshold of 1. */
 820         ctl &= ~MC_CTL2_THRESHOLD;
 821         ctl |= 1;
 822         wrmsr(MSR_MC_CTL2(i), ctl);
 823
 824         /* Mark this bank as monitored. */
 825         PCPU_SET(cmci_mask, PCPU_GET(cmci_mask) | 1 << i);
 826 }
 827
 828 /*
 829  * For resume, reset the threshold for any banks we monitor back to
 830  * one and throw away the timestamp of the last interrupt.
 831  */
 832 static void
 833 cmci_resume(int i)
 834 {
 835         struct cmc_state *cc;
 836         uint64_t ctl;
 837
 838         KASSERT(i < mca_banks, ("CPU %d has more MC banks", PCPU_GET(cpuid)));
 839
 840         /* Ignore banks not monitored by this CPU. */
 841         if (!(PCPU_GET(cmci_mask) & 1 << i))
 842                 return;
 843
 844         cc = &cmc_state[PCPU_GET(cpuid)][i];
 845         cc->last_intr = -ticks;
 846         ctl = rdmsr(MSR_MC_CTL2(i));
 847         ctl &= ~MC_CTL2_THRESHOLD;
 848         ctl |= MC_CTL2_CMCI_EN | 1;
 849         wrmsr(MSR_MC_CTL2(i), ctl);
 850 }
 851 #endif
 852
 853 /*
 854  * Initializes per-CPU machine check registers and enables corrected
 855  * machine check interrupts.
 856  */
 857 static void
 858 _mca_init(int boot)
 859 {
 860         uint64_t mcg_cap;
 861         uint64_t ctl, mask;
 862         int i, skip;
 863
 864         /* MCE is required. */
 865         if (!mca_enabled || !(cpu_feature & CPUID_MCE))
 866                 return;
 867
 868         if (cpu_feature & CPUID_MCA) {
 869                 if (boot)
 870                         PCPU_SET(cmci_mask, 0);
 871
 872                 mcg_cap = rdmsr(MSR_MCG_CAP);
 873                 if (mcg_cap & MCG_CAP_CTL_P)
 874                         /* Enable MCA features. */
 875                         wrmsr(MSR_MCG_CTL, MCG_CTL_ENABLE);
 876                 if (PCPU_GET(cpuid) == 0 && boot)
 877                         mca_setup(mcg_cap);
 878
 879                 /*
 880                  * Disable logging of level one TLB parity (L1TP) errors by
 881                  * the data cache as an alternative workaround for AMD Family
 882                  * 10h Erratum 383.  Unlike the recommended workaround, there
 883                  * is no performance penalty to this workaround.  However,
 884                  * L1TP errors will go unreported.
 885                  */
 886                 if (cpu_vendor_id == CPU_VENDOR_AMD &&
 887                     CPUID_TO_FAMILY(cpu_id) == 0x10 && !amd10h_L1TP) {
 888                         mask = rdmsr(MSR_MC0_CTL_MASK);
 889                         if ((mask & (1UL << 5)) == 0)
 890                                 wrmsr(MSR_MC0_CTL_MASK, mask | (1UL << 5));
 891                 }
 892                 for (i = 0; i < (mcg_cap & MCG_CAP_COUNT); i++) {
 893                         /* By default enable logging of all errors. */
 894                         ctl = 0xffffffffffffffffUL;
 895                         skip = 0;
 896
 897                         if (cpu_vendor_id == CPU_VENDOR_INTEL) {
 898                                 /*
 899                                  * For P6 models before Nehalem MC0_CTL is
 900                                  * always enabled and reserved.
 901                                  */
 902                                 if (i == 0 && CPUID_TO_FAMILY(cpu_id) == 0x6
 903                                     && CPUID_TO_MODEL(cpu_id) < 0x1a)
 904                                         skip = 1;
 905                         } else if (cpu_vendor_id == CPU_VENDOR_AMD) {
 906                                 /* BKDG for Family 10h: unset GartTblWkEn. */
 907                                 if (i == 4 && CPUID_TO_FAMILY(cpu_id) >= 0xf)
 908                                         ctl &= ~(1UL << 10);
 909                         }
 910
 911                         if (!skip)
 912                                 wrmsr(MSR_MC_CTL(i), ctl);
 913
 914 #ifdef DEV_APIC
 915                         if (mcg_cap & MCG_CAP_CMCI_P) {
 916                                 if (boot)
 917                                         cmci_monitor(i);
 918                                 else
 919                                         cmci_resume(i);
 920                         }
 921 #endif
 922
 923                         /* Clear all errors. */
 924                         wrmsr(MSR_MC_STATUS(i), 0);
 925                 }
 926
 927 #ifdef DEV_APIC
 928                 if (PCPU_GET(cmci_mask) != 0 && boot)
 929                         lapic_enable_cmc();
 930 #endif
 931         }
 932
 933         load_cr4(rcr4() | CR4_MCE);
 934 }
 935
 936 /* Must be executed on each CPU during boot. */
 937 void
 938 mca_init(void)
 939 {
 940
 941         _mca_init(1);
 942 }
 943
 944 /* Must be executed on each CPU during resume. */
 945 void
 946 mca_resume(void)
 947 {
 948
 949         _mca_init(0);
 950 }
 951
 952 /*
 953  * The machine check registers for the BSP cannot be initialized until
 954  * the local APIC is initialized.  This happens at SI_SUB_CPU,
 955  * SI_ORDER_SECOND.
 956  */
 957 static void
 958 mca_init_bsp(void *arg __unused)
 959 {
 960
 961         mca_init();
 962 }
 963 SYSINIT(mca_init_bsp, SI_SUB_CPU, SI_ORDER_ANY, mca_init_bsp, NULL);
 964
 965 /* Called when a machine check exception fires. */
 966 void
 967 mca_intr(void)
 968 {
 969         uint64_t mcg_status;
 970         int old_count, recoverable;
 971
 972         if (!(cpu_feature & CPUID_MCA)) {
 973                 /*
 974                  * Just print the values of the old Pentium registers
 975                  * and panic.
 976                  */
 977                 printf("MC Type: 0x%jx  Address: 0x%jx\n",
 978                     (uintmax_t)rdmsr(MSR_P5_MC_TYPE),
 979                     (uintmax_t)rdmsr(MSR_P5_MC_ADDR));
 980                 panic("Machine check");
 981         }
 982
 983         /* Scan the banks and check for any non-recoverable errors. */
 984         old_count = mca_count;
 985         recoverable = mca_scan(MCE);
 986         mcg_status = rdmsr(MSR_MCG_STATUS);
 987         if (!(mcg_status & MCG_STATUS_RIPV))
 988                 recoverable = 0;
 989
 990         if (!recoverable) {
 991                 /*
 992                  * Wait for at least one error to be logged before
 993                  * panic'ing.  Some errors will assert a machine check
 994                  * on all CPUs, but only certain CPUs will find a valid
 995                  * bank to log.
 996                  */
 997                 while (mca_count == old_count)
 998                         cpu_spinwait();
 999
1000                 panic("Unrecoverable machine check exception");
1001         }
1002
1003         /* Clear MCIP. */
1004         wrmsr(MSR_MCG_STATUS, mcg_status & ~MCG_STATUS_MCIP);
1005 }
1006
1007 #ifdef DEV_APIC
1008 /* Called for a CMCI (correctable machine check interrupt). */
1009 void
1010 cmc_intr(void)
1011 {
1012         struct mca_internal *mca;
1013         int count;
1014
1015         /*
1016          * Serialize MCA bank scanning to prevent collisions from
1017          * sibling threads.
1018          */
1019         count = mca_scan(CMCI);
1020
1021         /* If we found anything, log them to the console. */
1022         if (count != 0) {
1023                 mtx_lock_spin(&mca_lock);
1024                 STAILQ_FOREACH(mca, &mca_records, link) {
1025                         if (!mca->logged) {
1026                                 mca->logged = 1;
1027                                 mca_log(&mca->rec);
1028                         }
1029                 }
1030                 mtx_unlock_spin(&mca_lock);
1031         }
1032 }
1033 #endif