You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
478 lines
14 KiB
478 lines
14 KiB
/*++
|
|
|
|
Module Name:
|
|
|
|
MCALOG.C
|
|
|
|
Abstract:
|
|
|
|
Sample Application for logging errors for Machine Check Architecture
|
|
|
|
Author:
|
|
|
|
Anil Aggarwal (10/12/98)
|
|
Intel Corporation
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include <windows.h>
|
|
#include <winioctl.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <winbase.h>
|
|
#include <mce.h>
|
|
#include "imca.h"
|
|
|
|
//
|
|
// Variables for parsing command line arguments
|
|
//
|
|
extern int opterr;
|
|
extern int optind;
|
|
extern char *optarg;
|
|
|
|
//
|
|
// Print the usage information for MCA logging application
|
|
//
|
|
|
|
VOID
|
|
McaUsage(
|
|
PCHAR Name
|
|
)
|
|
{
|
|
fprintf(stderr,"Usage\n\t%s: [-s] [-a]\n",Name);
|
|
fprintf(stderr,"\n\t-s: Read Machine Check registers now\n");
|
|
fprintf(stderr,"\n\t-a: Post asynchronous request for errors\n");
|
|
|
|
ExitProcess(1);
|
|
}
|
|
|
|
//
|
|
// This routine prints the Machine Check registers
|
|
//
|
|
|
|
#if defined(_AMD64_)
|
|
|
|
VOID
|
|
McaPrintLog(
|
|
PMCA_EXCEPTION McaException
|
|
)
|
|
{
|
|
if (McaException->ExceptionType != HAL_MCA_RECORD) {
|
|
fprintf(stderr, "Bad exception record type\n");
|
|
//ExitProcess(1);
|
|
}
|
|
|
|
printf("Processor Number = %d\n", McaException->ProcessorNumber);
|
|
|
|
printf("Bank Number = %d\n", McaException->u.Mca.BankNumber);
|
|
printf("Mci_Status %I64X\n", McaException->u.Mca.Status.QuadPart);
|
|
printf("Mci_Address %I64X\n", McaException->u.Mca.Address.QuadPart);
|
|
printf("Mci_Misc %I64X\n", McaException->u.Mca.Misc);
|
|
|
|
} // McaPrintLog()
|
|
|
|
#endif // _AMD64_
|
|
|
|
#if defined(_X86_)
|
|
|
|
VOID
|
|
PrintX86McaLog(
|
|
PMCA_EXCEPTION McaException
|
|
)
|
|
{
|
|
if (McaException->ExceptionType != HAL_MCA_RECORD) {
|
|
fprintf(stderr, "Bad exception record type\n");
|
|
//ExitProcess(1);
|
|
}
|
|
|
|
printf("Processor Number = %d\n", McaException->ProcessorNumber);
|
|
|
|
printf("Bank Number = %d\n", (__int64)McaException->u.Mca.BankNumber);
|
|
printf("Mci_Status %I64X\n", (__int64)McaException->u.Mca.Status.QuadPart);
|
|
printf("Mci_Address %I64X\n", (__int64)McaException->u.Mca.Address.QuadPart);
|
|
printf("Mci_Misc %I64X\n", (__int64)McaException->u.Mca.Misc);
|
|
|
|
} // PrintX86McaLog()
|
|
|
|
#define McaPrintLog PrintX86McaLog
|
|
|
|
#endif // _X86_
|
|
|
|
#if defined(_IA64_)
|
|
|
|
#define ERROR_RECORD_HEADER_FORMAT \
|
|
"MCA Error Record Header\n" \
|
|
"\tId : 0x%I64x\n" \
|
|
"\tRevision : 0x%x\n" \
|
|
"\t\tMajor : %x\n" \
|
|
"\t\tMinor : %x\n" \
|
|
"\tSeverity : 0x%x\n" \
|
|
"\tValid : 0x%x\n" \
|
|
"\t\tPlatformId: %x\n" \
|
|
"\tLength : 0x%x\n" \
|
|
"\tTimeStamp : 0x%I64x\n" \
|
|
"\t\tSeconds: %x\n" \
|
|
"\t\tMinutes: %x\n" \
|
|
"\t\tHours : %x\n" \
|
|
"\t\tDay : %x\n" \
|
|
"\t\tMonth : %x\n" \
|
|
"\t\tYear : %x\n" \
|
|
"\t\tCentury: %x\n" \
|
|
"\tPlatformId: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n"
|
|
|
|
VOID
|
|
PrintIa64ErrorRecordHeader(
|
|
PERROR_RECORD_HEADER Header
|
|
)
|
|
{
|
|
printf( ERROR_RECORD_HEADER_FORMAT,
|
|
(ULONGLONG) Header->Id,
|
|
(ULONG) Header->Revision.Revision,
|
|
(ULONG) Header->Revision.Major, (ULONG) Header->Revision.Minor,
|
|
(ULONG) Header->ErrorSeverity,
|
|
(ULONG) Header->Valid.Valid,
|
|
(ULONG) Header->Valid.OemPlatformID,
|
|
(ULONG) Header->Length,
|
|
(ULONGLONG) Header->TimeStamp.TimeStamp,
|
|
(ULONG) Header->TimeStamp.Seconds,
|
|
(ULONG) Header->TimeStamp.Minutes,
|
|
(ULONG) Header->TimeStamp.Hours,
|
|
(ULONG) Header->TimeStamp.Day,
|
|
(ULONG) Header->TimeStamp.Month,
|
|
(ULONG) Header->TimeStamp.Year,
|
|
(ULONG) Header->TimeStamp.Century,
|
|
(ULONG) Header->OemPlatformId[0],
|
|
(ULONG) Header->OemPlatformId[1],
|
|
(ULONG) Header->OemPlatformId[2],
|
|
(ULONG) Header->OemPlatformId[3],
|
|
(ULONG) Header->OemPlatformId[4],
|
|
(ULONG) Header->OemPlatformId[5],
|
|
(ULONG) Header->OemPlatformId[6],
|
|
(ULONG) Header->OemPlatformId[7],
|
|
(ULONG) Header->OemPlatformId[8],
|
|
(ULONG) Header->OemPlatformId[9],
|
|
(ULONG) Header->OemPlatformId[10],
|
|
(ULONG) Header->OemPlatformId[11],
|
|
(ULONG) Header->OemPlatformId[12],
|
|
(ULONG) Header->OemPlatformId[13],
|
|
(ULONG) Header->OemPlatformId[14],
|
|
(ULONG) Header->OemPlatformId[15]
|
|
);
|
|
|
|
return;
|
|
|
|
} // PrintIa64ErrorRecordHeader()
|
|
|
|
VOID
|
|
PrintIa64McaLog(
|
|
PMCA_EXCEPTION McaException
|
|
)
|
|
{
|
|
|
|
//
|
|
// Start by printing the record header.
|
|
//
|
|
|
|
PrintIa64ErrorRecordHeader( McaException );
|
|
|
|
//
|
|
// Then print and/or process error device specific information here.
|
|
//
|
|
|
|
return;
|
|
|
|
} // PrintIa64McaLog()
|
|
|
|
#define McaPrintLog PrintIa64McaLog
|
|
|
|
#endif // _IA64_
|
|
|
|
//
|
|
// This routine prints a user friendly error message based on GetLastError()
|
|
//
|
|
|
|
VOID
|
|
McaPrintError(
|
|
VOID
|
|
)
|
|
{
|
|
LPVOID lpMsgBuf;
|
|
DWORD Err = GetLastError();
|
|
|
|
if (FormatMessage(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
FORMAT_MESSAGE_FROM_SYSTEM |
|
|
FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
NULL,
|
|
Err,
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
|
(LPTSTR) &lpMsgBuf,
|
|
0,
|
|
NULL
|
|
)) {
|
|
fprintf(stderr, "%s\n", lpMsgBuf);
|
|
|
|
LocalFree( lpMsgBuf );
|
|
} else {
|
|
fprintf(stderr, "%d\n", Err);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Main entry point
|
|
//
|
|
|
|
int
|
|
__cdecl
|
|
main(
|
|
int argc,
|
|
char *argv[]
|
|
)
|
|
{
|
|
CHAR Option;
|
|
BOOLEAN ReadBanks = FALSE;
|
|
BOOLEAN PostAsyncRequest = FALSE;
|
|
HANDLE McaDeviceHandle;
|
|
HANDLE LogEvent;
|
|
OVERLAPPED Overlap;
|
|
BOOL ReturnStatus;
|
|
DWORD ActualCount;
|
|
DWORD WaitStatus;
|
|
DWORD NumberOfBytes;
|
|
MCA_EXCEPTION McaException;
|
|
LONG i;
|
|
|
|
//
|
|
// Process the command line arguments
|
|
//
|
|
for (i=1; i < argc; i++) {
|
|
if (!((argv[i][0] == '-') || (argv[i][2] != 0)) ) {
|
|
McaUsage(argv[0]);
|
|
}
|
|
|
|
Option = argv[i][1];
|
|
|
|
switch (Option) {
|
|
case 's':
|
|
ReadBanks = TRUE;
|
|
break;
|
|
|
|
case 'a':
|
|
PostAsyncRequest = TRUE;
|
|
break;
|
|
|
|
default:
|
|
McaUsage(argv[0]);
|
|
}
|
|
}
|
|
|
|
if ((ReadBanks != TRUE) && (PostAsyncRequest != TRUE)) {
|
|
fprintf(stderr, "One of -s and -a options must be specified\n");
|
|
ExitProcess(1);
|
|
}
|
|
|
|
if ((ReadBanks == TRUE) && (PostAsyncRequest == TRUE)) {
|
|
fprintf(stderr, "Only one of -s and -a options can be specified\n");
|
|
ExitProcess(1);
|
|
}
|
|
|
|
//
|
|
// Open MCA device with overlap flag set
|
|
//
|
|
|
|
McaDeviceHandle = CreateFile(
|
|
MCA_DEVICE_NAME_WIN32,
|
|
GENERIC_READ|GENERIC_WRITE,
|
|
0,
|
|
(LPSECURITY_ATTRIBUTES)NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,
|
|
(HANDLE)NULL
|
|
);
|
|
|
|
if (McaDeviceHandle == INVALID_HANDLE_VALUE) {
|
|
fprintf(stderr, "%s: Error 0x%lx opening MCA device\n",
|
|
argv[0], GetLastError());
|
|
ExitProcess(1);
|
|
}
|
|
|
|
if (ReadBanks == TRUE) {
|
|
|
|
//
|
|
// Read the error logs on all banks on all procs.
|
|
// IOCTL_READ_BANKS will read only one error at a time. So
|
|
// we need to keep issuing this ioctl till all the errors are read
|
|
//
|
|
|
|
do {
|
|
ReturnStatus = DeviceIoControl(
|
|
McaDeviceHandle,
|
|
(ULONG)IOCTL_READ_BANKS,
|
|
NULL,
|
|
0,
|
|
&McaException,
|
|
sizeof(MCA_EXCEPTION),
|
|
&ActualCount,
|
|
NULL
|
|
);
|
|
|
|
if (ReturnStatus == 0) {
|
|
//
|
|
// Some error has occurred. Either there are no more machine
|
|
// check errors present or the processor does not have
|
|
// support for Intel Machine Check Architecture
|
|
//
|
|
|
|
if (GetLastError() == ERROR_NOT_FOUND) {
|
|
fprintf(stderr, "No Machine Check errors present\n");
|
|
} else if (GetLastError() == ERROR_FILE_NOT_FOUND) {
|
|
fprintf(stderr, "Intel Machine Check support not available\n");
|
|
ExitProcess(1);
|
|
} else {
|
|
fprintf(stderr, "%s: Error 0x%lx in DeviceIoControl\n",
|
|
argv[0], GetLastError());
|
|
ExitProcess(1);
|
|
}
|
|
|
|
} else {
|
|
//
|
|
// Successfully read the error. Print it.
|
|
//
|
|
McaPrintLog(&McaException);
|
|
}
|
|
|
|
} while (ReturnStatus != 0);
|
|
|
|
//
|
|
// We are done
|
|
//
|
|
return 1;
|
|
}
|
|
|
|
//
|
|
// If we are here, we are supposed to post asynchronous calls to MCA driver
|
|
//
|
|
|
|
//
|
|
// Set up structures for asynchronous call for reading the log
|
|
// Create the event object
|
|
//
|
|
|
|
LogEvent = CreateEvent(
|
|
NULL, // No Security Attributes
|
|
FALSE, // Auto Reset Event
|
|
FALSE, // Initial State = non-signaled
|
|
NULL // Unnamed object
|
|
);
|
|
|
|
if (LogEvent == NULL) {
|
|
fprintf(stderr, "%s: Error 0x%lx creating event\n",
|
|
argv[0], GetLastError());
|
|
ExitProcess(1);
|
|
}
|
|
|
|
//
|
|
// Initialize the overlap structure
|
|
//
|
|
|
|
Overlap.hEvent = LogEvent; // Specify event for overlapped object
|
|
Overlap.Offset = 0; // Offset is zero for devices
|
|
Overlap.OffsetHigh = 0; // OffsetHigh is zero for devices
|
|
|
|
ReturnStatus = DeviceIoControl(
|
|
McaDeviceHandle,
|
|
(ULONG)IOCTL_READ_BANKS_ASYNC,
|
|
NULL,
|
|
0,
|
|
&McaException,
|
|
sizeof(MCA_EXCEPTION),
|
|
&ActualCount,
|
|
&Overlap
|
|
);
|
|
|
|
if ((ReturnStatus == 0) && (GetLastError() != ERROR_IO_PENDING)) {
|
|
fprintf(stderr, "%s: Error 0x%lx in IOCTL_READ_BANKS_ASYNC\n",
|
|
argv[0], GetLastError());
|
|
ExitProcess(1);
|
|
}
|
|
|
|
//
|
|
// Either Ioctl was successful or IO is currently pending
|
|
// If successful then display the log else wait for specified interval
|
|
//
|
|
if (ReturnStatus == TRUE) {
|
|
//
|
|
// Read log async returned succesfully. Display it
|
|
//
|
|
|
|
McaPrintLog(&McaException);
|
|
|
|
}
|
|
|
|
//
|
|
// Wait forever to get an error
|
|
//
|
|
|
|
WaitStatus = WaitForSingleObject(
|
|
LogEvent,
|
|
INFINITE
|
|
);
|
|
|
|
if (WaitStatus == WAIT_OBJECT_0) {
|
|
|
|
//
|
|
// The state of the event object is signalled
|
|
// check if the I/O operation was successful
|
|
//
|
|
|
|
ReturnStatus = GetOverlappedResult(
|
|
McaDeviceHandle,
|
|
&Overlap,
|
|
&NumberOfBytes,
|
|
FALSE // Return immediately
|
|
);
|
|
|
|
if (ReturnStatus == 0) {
|
|
|
|
fprintf(stderr, "%s: Error 0x%lx in GetOverlappedResult\n",
|
|
argv[0], GetLastError());
|
|
ExitProcess(1);
|
|
}
|
|
|
|
if (NumberOfBytes) {
|
|
|
|
//
|
|
// Print the results
|
|
//
|
|
|
|
McaPrintLog(&McaException);
|
|
|
|
} else {
|
|
|
|
//
|
|
// Error as the I/O operation was signalled complete before
|
|
// timeout but no data transferred
|
|
//
|
|
|
|
fprintf(stderr, "%s: No data from GetOverlappedResult\n",
|
|
argv[0]);
|
|
ExitProcess(1);
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// We should not get any other return value
|
|
//
|
|
|
|
fprintf(stderr, "%s: Unexpected return value from WaitForSingleObject()\n", argv[0]);
|
|
ExitProcess(1);
|
|
}
|
|
|
|
CloseHandle(McaDeviceHandle);
|
|
|
|
return 1;
|
|
}
|
|
|