EDKLOG.C
// --edklog.c-------------------------------------------------------------------
//
// Functions to log debugging information in DEBUG builds.
//
// Copyright (C) Microsoft Corp. 1986-1996. All Rights Reserved.
// -----------------------------------------------------------------------------
#define _PRIVATE_EDKDEBUG_H
#define _PRIVATE_MEMORY_H
#include "edk.h"
#define REPORT_ERROR(x) \
_WriteDebugString( \
"***** error: %s, %lu, [%08lX] *****\n", __FILE__,__LINE__,(x))
#define DECL_FENCE(_name) ULONG _dbg_##_name = 0xAAAAAAAA
#define TEST_FENCE(_name) \
{ \
if(_dbg_##_name != 0xAAAAAAAA) \
{ \
_WriteDebugString( \
"***** error: %s, %lu, memory overwrite at tag '%s'! *****\n", \
__FILE__,__LINE__,#_name); \
} \
}
DECL_FENCE(EDKDEBUG1);
static BOOL fDebugLevel[D_LAST] =
{
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE,
TRUE
};
DECL_FENCE(EDKDEBUG2);
static BOOL IsAssertOff = TRUE;
DECL_FENCE(EDKDEBUG3);
static BOOL IsDebugOff = FALSE;
DECL_FENCE(EDKDEBUG4);
static CHAR szFileName[MAX_PATH+1] = {0};
DECL_FENCE(EDKDEBUG5);
static FILE* fp = NULL;
DECL_FENCE(EDKDEBUG6);
static CRITICAL_SECTION cs = {0};
DECL_FENCE(EDKDEBUG7);
#define TEST_ALL_FENCES \
{ \
TEST_FENCE(EDKDEBUG1); \
TEST_FENCE(EDKDEBUG2); \
TEST_FENCE(EDKDEBUG3); \
TEST_FENCE(EDKDEBUG4); \
TEST_FENCE(EDKDEBUG5); \
TEST_FENCE(EDKDEBUG6); \
TEST_FENCE(EDKDEBUG7); \
}
//$--_WriteDebugString----------------------------------------------------------
//
// Write a string to the debugger output window.
//
// -----------------------------------------------------------------------------
void _WriteDebugString( // RETURNS: nothing
IN LPSTR lpszFormat, // format string
...) // arguments
{
char lpsz[BUFSIZ+1] = {0};
va_list va_alist = {0};
SetLastError(ERROR_SUCCESS);
__try
{
va_start( va_alist, lpszFormat );
_vsnprintf( lpsz, BUFSIZ, lpszFormat, va_alist );
va_end( va_alist );
OutputDebugString(lpsz);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
SetLastError(_exception_code());
}
}
//$--_StatusShowAssert----------------------------------------------------------
//
// Status of the assert prompt.
//
// -----------------------------------------------------------------------------
BOOL _StatusShowAssert( // RETURNS: TRUE if assert prompt
void) // no arguments
{
TEST_ALL_FENCES // Check for memory overwrites in global variables
return(!IsAssertOff);
}
//$--_StatusDebugFile-----------------------------------------------------------
//
// Status of the debug log file.
//
// -----------------------------------------------------------------------------
BOOL _StatusDebugFile( // RETURNS: TRUE if debug log available
void) // no arguments
{
BOOL fStatus = TRUE;
TEST_ALL_FENCES // Check for memory overwrites in global variables
if((fp == NULL) || (IsDebugOff == TRUE))
{
fStatus = FALSE;
}
return(fStatus);
}
//$--_StatusDebugLevel----------------------------------------------------------
//
// Status of the debug level.
//
// -----------------------------------------------------------------------------
BOOL _StatusDebugLevel( // RETURNS: nothing
IN DEBUGLEVEL level) // debug level
{
BOOL fStatus = TRUE;
TEST_ALL_FENCES // Check for memory overwrites in global variables
if( (_StatusDebugFile() == FALSE) ||
(level >= D_LAST) ||
(fDebugLevel[(int)level] == FALSE))
{
fStatus = FALSE;
}
return(fStatus);
}
//$--_LockDebugFile-------------------------------------------------------------
//
// Lock the debug log file.
//
// -----------------------------------------------------------------------------
void _LockDebugFile( // RETURNS: nothing
void) // no arguments
{
CHAR sz[BUFSIZ+1] = {0};
TEST_ALL_FENCES // Check for memory overwrites in global variables
__try
{
EnterCriticalSection(&cs);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
REPORT_ERROR(_exception_code());
}
}
//$--_UnlockDebugFile-----------------------------------------------------------
//
// Unlock the debug log file.
//
// -----------------------------------------------------------------------------
void _UnlockDebugFile( // RETURNS: nothing
void) // no arguments
{
CHAR sz[BUFSIZ+1] = {0};
TEST_ALL_FENCES // Check for memory overwrites in global variables
__try
{
LeaveCriticalSection(&cs);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
REPORT_ERROR(_exception_code());
}
}
//$--_WriteDebugFile------------------------------------------------------------
//
// Write to the debug log file.
//
// -----------------------------------------------------------------------------
void _WriteDebugFile( // RETURNS: nothing
IN LPSTR lpszFormat, // format string
...) // arguments
{
va_list va_alist = {0};
TEST_ALL_FENCES // Check for memory overwrites in global variables
if(fp == NULL)
{
REPORT_ERROR(ERROR_INVALID_PARAMETER);
goto cleanup;
}
__try
{
EnterCriticalSection(&cs);
__try
{
va_start( va_alist, lpszFormat );
vfprintf( fp, lpszFormat, va_alist );
va_end( va_alist );
fflush(fp);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
REPORT_ERROR(_exception_code());
}
LeaveCriticalSection(&cs);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
REPORT_ERROR(_exception_code());
}
cleanup:
return;
}
//$--SetDebugLevel--------------------------------------------------------------
// Set debug levels to log.
// -----------------------------------------------------------------------------
static void SetDebugLevel( // RETURNS: nothing
IN LPSTR lpszLevel) // textized debug level
{
int level = 0;
char* lpszToken = NULL;
char buf[BUFSIZ+1] = {0};
TEST_ALL_FENCES // Check for memory overwrites in global variables
if(lpszLevel == NULL)
{
goto cleanup;
}
if(IsBadStringPtrA(lpszLevel, INFINITE))
{
REPORT_ERROR(ERROR_INVALID_PARAMETER);
goto cleanup;
}
IsDebugOff = TRUE;
for(level = 0; level < D_LAST; level++)
{
// Turn the debug level off
fDebugLevel[level] = FALSE;
}
strncpy(buf, lpszLevel, BUFSIZ);
buf[BUFSIZ] = 0;
lpszToken = strtok(buf,", ");
while(lpszToken != NULL)
{
if(!_stricmp("D_PUBLIC", lpszToken))
{
// Turn the debug level on
fDebugLevel[(int)D_PUBLIC] = TRUE; IsDebugOff = FALSE;
}
else if(!_stricmp("D_PRIVATE", lpszToken))
{
// Turn the debug level on
fDebugLevel[(int)D_PRIVATE] = TRUE; IsDebugOff = FALSE;
}
else if(!_stricmp("D_ERROR", lpszToken))
{
// Turn the debug level on
fDebugLevel[(int)D_ERROR] = TRUE; IsDebugOff = FALSE;
}
else if(!_stricmp("D_WARNING", lpszToken))
{
// Turn the debug level on
fDebugLevel[(int)D_WARNING] = TRUE; IsDebugOff = FALSE;
}
else if(!_stricmp("D_STATUS", lpszToken))
{
// Turn the debug level on
fDebugLevel[(int)D_STATUS] = TRUE; IsDebugOff = FALSE;
}
else if(!_stricmp("D_ACTION", lpszToken))
{
// Turn the debug level on
fDebugLevel[(int)D_ACTION] = TRUE; IsDebugOff = FALSE;
}
else if(!_stricmp("D_OTHER", lpszToken))
{
// Turn the debug level on
fDebugLevel[(int)D_OTHER] = TRUE; IsDebugOff = FALSE;
}
lpszToken = strtok(NULL, ", ");
}
cleanup:
return;
}
//$--_InitDebugFile-------------------------------------------------------------
//
// Initialize the debug log file.
//
// -----------------------------------------------------------------------------
void _InitDebugFile( // RETURNS: nothing
void) // no arguments
{
HANDLE hT = NULL;
DWORD dwT = 0;
CHAR szMutexName[MAX_PATH+1] = {0};
CHAR szTempPath[MAX_PATH+1] = {0}; // temporary file name path
TEST_ALL_FENCES // Check for memory overwrites in global variables
if((fp == NULL) && (IsDebugOff == FALSE))
{
_snprintf(szMutexName, MAX_PATH, "EDK%08lX", GetCurrentProcessId());
hT = CreateMutex(NULL, FALSE, szMutexName);
if(hT == NULL)
{
REPORT_ERROR(GetLastError());
return;
}
if((hT != NULL) && (GetLastError() == ERROR_ALREADY_EXISTS))
{
__try
{
dwT = WaitForSingleObject(hT, INFINITE);
if((dwT == WAIT_OBJECT_0) || (dwT == WAIT_ABANDONED))
{
ReleaseMutex(hT);
}
CloseHandle(hT);
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
REPORT_ERROR(_exception_code());
}
return;
}
dwT = WaitForSingleObject(hT, INFINITE);
if((dwT == WAIT_OBJECT_0) || (dwT == WAIT_ABANDONED))
{
LPSTR lpsz = NULL;
InitializeCriticalSection(&cs);
SetDebugLevel(getenv("EDK_DEBUG"));
if(IsDebugOff == FALSE)
{
lpsz = getenv("EDK_DEBUG_FILE");
if(lpsz == NULL)
{
// Create a file in the temporary file directory
// with name equal to "EDKxxx.log".
dwT = GetTempPath(
MAX_PATH,// length of buffer
szTempPath);// string buffer
if ( dwT != 0 )
{
// If TEMP has been removed, we'll create it
(VOID)CreateDirectory(
szTempPath,
NULL);
dwT = GetTempFileName(
szTempPath,// temporary file path
EDK_LOG_FILE_PREFIX,// log file prefix
0,// creates unique file name
szFileName);// file name buffer
if ( dwT != 0 )
{
UINT iFileSuffix = 0;
// Delete the edk*.tmp file created as a side
// effect of GetTempFileName().
(VOID)DeleteFile(szFileName);
// Replace .TMP suffix with .LOG suffix.
iFileSuffix = cbStrLenA(szFileName) - sizeof("TMP");
lstrcpyA( &szFileName[iFileSuffix], EDK_LOG_FILE_SUFFIX);
}
else
{
REPORT_ERROR(GetLastError());
}
}
else
{
REPORT_ERROR(GetLastError());
}
}
else
{
strncpy((char *)szFileName, lpsz, MAX_PATH);
}
szFileName[MAX_PATH] = 0;
if((fp = fopen(szFileName, "w")) == NULL)
{
REPORT_ERROR(ERROR_INVALID_PARAMETER);
}
}
lpsz = getenv("EDK_ASSERT");
if((lpsz != NULL) && (lstrcmpiA(lpsz, "TRUE") == 0))
{
IsAssertOff = FALSE;
}
ReleaseMutex(hT);
}
else
{
REPORT_ERROR(GetLastError());
}
CloseHandle(hT);
}
}