/*
* Linux Machine check exception handler parser.
* (c) 2002 Dave Jones <davej@suse.de>
* http://www.codemonkey.org.uk/parsemce/
*
* TODO:
* - Isolate Intel/AMD differences
* - Work around various errata
* Intel P3 E24: MC2_STATUS MSR has error codes reversed
* Athlon: MSR 408H returns crap in upper 32 bits
*
* 0.0.1 - 0.0.4 Ancient history, initial program.
* 0.0.5 Command line parsing courtesy of Randy Dunlap.
* 0.0.6 parse_input and 'multishot' courtesy of Ingo Oeser.
* 0.0.7 Fix incorrect parsing of certain flags.
* 0.0.8 Minor fixes.
*
*/
/*
* Sample kernel output..
* Sep 4 21:43:41 hamlet kernel: CPU 0: Machine Check Exception: 0000000000000004
* Sep 4 21:43:41 hamlet kernel: Bank 1: f600200000000152 at 7600200000000152
* Sep 4 21:43:41 hamlet kernel: Bank 2: d40040000000017a at 540040000000017a
* Sep 4 21:43:41 hamlet kernel: Kernel panic: CPU context corrupt
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <linux/types.h>
typedef u_int64_t u64;
union {
u_int64_t full;
struct { /* Note - little endian */
unsigned int low;
unsigned int high;
} split;
} msr64;
#define PROGNAME "parsemce"
#define VERSION "0.0.7"
static char optstring[] = "f:e:b:s:a:Vi";
static void usage(void)
{
fprintf (stderr, "usage: %s [options]\n", PROGNAME);
fprintf (stderr, " options: -V <version number>\n");
fprintf (stderr, " -e <MCE status code>\n");
fprintf (stderr, " -b <bank number>\n");
fprintf (stderr, " -s <bank status code>\n");
fprintf (stderr, " -a <bank address>\n");
fprintf (stderr, " -f <filename, with MCE dump inside>\n");
fprintf (stderr, " -i <get MCE dump from stdin>\n");
exit (1);
}
static void decode_ll(int code)
{
printf ("\tMemory/IO : ");
switch (code) {
case 0: printf ("Memory access"); break;
case 1: printf ("Reserved"); break;
case 2: printf ("I/O"); break;
case 3: printf ("Other"); break;
default:
printf ("Invalid"); break;
}
printf ("\n");
}
static void decode_transaction(int code)
{
printf ("\tTransaction type : ");
switch (code) {
case 0: printf ("Instruction"); break;
case 1: printf ("Data"); break;
case 2: printf ("Generic"); break;
default:
printf ("Invalid"); break;
}
printf ("\n");
}
static void decode_request(int code)
{
printf ("\tRequest: ");
switch (code) {
case 0: printf ("Generic error"); break;
case 1: printf ("Generic read"); break;
case 2: printf ("Generic write"); break;
case 3: printf ("Data read"); break;
case 4: printf ("Data write"); break;
case 5: printf ("Instruction fetch"); break;
case 6: printf ("Prefetch"); break;
case 7: printf ("Eviction"); break;
case 8: printf ("Snoop"); break;
default:
printf ("Invalid"); break;
}
printf ("\n");
}
static void parse_bank(int bank, u64 value, u64 addr)
{
int low, high;
int errorcode;
int ms_errorcode;
errorcode = value & 0xffff;
ms_errorcode = (value>>17) & 0x7fff; /* bits 17:31*/
low = value & 0xffff;
high = value >> 32;
/* Could be simple MCA code */
switch (errorcode) {
case 0: printf ("No error reported\n");
return;
case 1: printf ("Not a known MCA error class\n");
return;
case 2: printf ("Internal microcode ROM has parity error\n");
return;
case 3: printf ("External error caused by another CPU\n");
return;
case 4: printf ("Functional redundancy check failed\n");
return;
}
if ((errorcode & 0xfc00) == 0x0400) {
printf ("Internal error is not a known MCA error class\n");
return;
}
printf ("parsebank(%d): %llx @ %llx\n", bank, value, addr);
if ((high & (1<<31)) == 0) {
printf ("Bank contents invalid, not parsing\n");
return;
}
if ((low & (1<<16)) == 1)
printf ("\tIn");
else
printf ("\tEx");
printf ("ternal tag parity error\n");
if ((high & (1<<13)))
printf ("\tUncorrectable ECC error\n");
if ((high & (1<<14)))
printf ("\tCorrectable ECC error\n");
if ((high & (1<<25)))
printf ("\tCPU state corrupt. Restart not possible\n");
if ((high & (1<<26)))
printf ("\tAddress in addr register valid\n");
if ((high & (1<<27)))
printf ("\tMISC register information valid\n");
// FIXME: Parse MISC register.
if ((high & (1<<28)))
printf ("\tError enabled in control register\n");
if ((high & (1<<29)))
printf ("\tError not corrected.\n");
if ((high & (1<<30)))
printf ("\tError overflow\n");
/* Decode error code. */
if ((errorcode & (0xff00)) == 0) {
printf ("\tTLB Error\n");
decode_transaction ((errorcode>>2 & (1<<0 | 1<<1)));
decode_ll (errorcode & (1<<0 | 1<<1));
}
if ((errorcode & (0xff00)) == 0x0100) {
printf ("\tMemory heirarchy error\n");
decode_request ((errorcode & 0xf)>>4);
decode_transaction ((errorcode>>2 & (1<<0 | 1<<1)));
decode_ll (errorcode & (1<<0 | 1<<1));
return;
}
if ((errorcode & (0xf800)) == 0x0800) {
printf ("\tBus and interconnect error\n");
printf ("\tParticipation: ");
switch ((errorcode & 0x0600) >>9) {
case 0: printf ("Local processor originated request"); break;
case 1: printf ("Local processor responded to request"); break;
case 2: printf ("Local processor observed error as third party"); break;
case 3: printf ("Generic"); break;
default:
printf ("Invalid"); break;
}
printf ("\n");
printf ("\tTimeout: ");
switch (errorcode & 0x0100) {
case 0: printf ("Request did not timeout"); break;
case 1: printf ("Request timed out"); break;
}
printf ("\n");
decode_request ((errorcode & 0xf)>>4);
decode_transaction ((errorcode>>2 & (1<<0 | 1<<1)));
decode_ll (errorcode & (1<<0 | 1<<1));
return;
}
}
void parse_status(u64 status)
{
printf ("Status: (%llx) ", status);
if (status & 1<<2)
printf ("Machine Check in progress.\n");
if (status & 1<<1)
printf ("Error IP valid\n");
if (status & 1<<0)
printf ("Restart IP valid.\n");
else
printf ("Restart IP invalid.\n");
}
/* Input file parser */
struct state_string_struct {
unsigned char len;
char *string;
};
typedef enum {
PS_NONE,
PS_CPU_STR,
PS_CPU_NR,
PS_MCE_STR,
PS_MCE_VAL,
PS_BANK_STR,
PS_BANK_NR,
PS_BANK_VAL,
PS_BANK_AT,
PS_BANK_ADDR,
PS_STATE_LAST, /* Last entry */
} parse_state_t;
const struct state_string_struct states[PS_STATE_LAST] = {
[PS_NONE] = { .string = 0, .len = 0 },
[PS_CPU_STR] = { .string = "CPU", .len = 3 },
[PS_CPU_NR] = { .string = 0, .len = 1 },
[PS_MCE_STR] = { .string = "Machine Check Exception",.len = 23 },
[PS_MCE_VAL] = { .string = 0, .len = 16 },
[PS_BANK_STR] = { .string = "Bank", .len = 4 },
[PS_BANK_NR] = { .string = 0, .len = 1 },
[PS_BANK_VAL] = { .string = 0, .len = 16 },
[PS_BANK_AT] = { .string = "at", .len = 2 },
[PS_BANK_ADDR] = { .string = 0, .len = 16 },
};
/* Must be 2 chars larger than the largest ".len" above */
#define STRING_SZ 25
u64 scan_val64(const char *s, const char *what) {
u64 val=0;
if (sscanf(s,"%Lx",&val) != 1) {
fprintf(stderr,"Error converting <%s>. Aborting\n",what);
usage();
exit(1);
}
return val;
}
void parse_input(FILE* f) {
char s[STRING_SZ];
int first_mce=1;
int do_recovery=0,state_changed=0;
int c;
char *e=&s[0];
char *b;
unsigned int collected = 0, todo;
u64 nr=~0,val=~0,addr; /* keep GCC happy */
parse_state_t expect = PS_NONE + 1, prev = PS_NONE;
b=states[expect].string;
todo=states[expect].len;
s[0]=0;
while ((c=fgetc(f)) != EOF) {
/* Mask out non-ascii or invalid characters */
c&=0x7f;
if (!collected && !(isalnum(c)))
continue;
/* if we had a CPU already, expect could be bank or CPU */
if (!first_mce && !collected && b) {
if (expect == PS_BANK_STR && c == 'C') {
expect=PS_CPU_STR;
state_changed=do_recovery=1;
} else if (expect == PS_CPU_STR && c == 'B') {
expect=PS_BANK_STR;
state_changed=do_recovery=1;
}
}
/* Collecting, but not all collected yet */
if (collected < todo) {
/* Are we collecting the right string? */
if (b && (b[collected] == c)) {
collected++;
continue;
/* Are we collecting number elements? */
} else if ((todo == 16 && isxdigit(c)) || isdigit(c)) {
/* collect it */
*e++=c;
*e=0;
collected++;
continue;
/* String not equal -> restart scanning */
} else if (b && (expect == PS_BANK_STR
|| expect == PS_CPU_STR)) {
if (collected) do_recovery=1;
} else {
/* Completely invalid input */
if (prev == PS_NONE) break;
/* Recovery from unwanted input */
expect=prev;
state_changed=do_recovery=1;
}
/* We have enough characters collected */
} else if (collected == todo) {
/* Found string -> look for value */
if (b) {
prev=expect++;
/* This is special */
if (prev == PS_BANK_AT)
prev=PS_BANK_STR;
state_changed=do_recovery=1;
/* found value string -> convert to number */
} else {
prev=expect-1;
switch (expect) {
case PS_CPU_NR:
nr=s[0]-'0';
break;
case PS_MCE_VAL:
val=scan_val64(&s[0],"MCE status");
first_mce=0;
printf("CPU %Lu\n",nr);
parse_status(val);
break;
case PS_BANK_NR:
nr=s[0]-'0';
break;
case PS_BANK_VAL:
val=scan_val64(&s[0],"Bank status");
prev=PS_BANK_STR;
break;
case PS_BANK_ADDR:
addr=scan_val64(&s[0],"Bank address");
parse_bank(nr,val,addr);
prev=PS_BANK_STR;
break;
default:
return;
}
expect++;
state_changed=do_recovery=1;
}
} else {
/* share code */
if (expect == PS_BANK_STR || expect == PS_CPU_STR) {
do_recovery=1;
} else if (prev != PS_NONE) {
/* Recovery */
expect=prev;
state_changed=do_recovery=1;
fprintf(stderr,
"Too much input: expected %u bytes ",todo);
if (b)
fprintf(stderr,"%s\n",b);
else if (todo <= 16)
fprintf(stderr,"number\n");
else
fprintf(stderr,"64b hex value\n");
} else {
/* Cannot recover */
break;
}
}
/* These are here, to share code */
if (do_recovery) {
collected=0;
e=&s[0];
*e=0;
ungetc(c,f);
do_recovery=0;
}
if (state_changed) {
if (expect == PS_STATE_LAST)
expect=PS_BANK_STR;
b=states[expect].string;
todo=states[expect].len;
state_changed=0;
}
}
/* Nothing printed? Provide the user with a clue */
if (first_mce)
fprintf(stderr, "This file contains no MCE dump\n");
}
int main(int argc, char *argv[])
{
int optch;
int multishot = 0;
u64 exception = 0, bank_status = 0, bank_address = 0;
int bank_number = 0;
int have_exception = 0;
int have_bank_nr = 0;
int have_bank_status = 0;
int have_bank_address = 0;
if (argc == 1) usage();
while ((optch = getopt (argc, argv, optstring)) != -1) {
switch (optch) {
case 'a':
bank_address=scan_val64(optarg,"Bank address");
have_bank_address = 1;
/* print it out, if user supplied right order */
if (have_exception && have_bank_nr && have_bank_status) {
if (!multishot)
parse_status (exception);
parse_bank(bank_number, bank_status, bank_address);
have_bank_address = 0;
have_bank_nr = 0;
have_bank_status = 0;
multishot++;
}
break;
case 'e':
exception=scan_val64(optarg,"MCE status");
have_exception = 1;
break;
case 'b':
bank_number=scan_val64(optarg,"Bank number");
have_bank_nr = 1;
break;
case 's':
bank_status=scan_val64(optarg,"Bank status");
have_bank_status = 1;
break;
case 'V':
printf ("%s version %s\n", PROGNAME, VERSION);
exit (0);
case 'i':
parse_input(stdin);
return 0;
break;
case 'f':
if (optarg[0] == '-' && optarg[1] == 0) {
parse_input(stdin);
} else {
FILE *f=fopen(optarg,"r");
if (!f) {
fprintf (stderr,
"Error opening data file: %s\n",
strerror(errno));
return 1;
}
parse_input(f);
fclose(f);
}
return 0;
break; /* to keep GCC happy */
default:
usage();
break;
}
}
if (!have_exception) {
fprintf (stderr, "'-e <MCE status>' is required\n");
usage();
}
if (!multishot) {
parse_status (exception);
if (have_bank_nr && have_bank_status && have_bank_address)
parse_bank(bank_number, bank_status, bank_address);
}
return 0;
}
