|
|
/*----------------------------------------------------------------------
REGISTRY.C Async tracing Registry reading routines
Copyright (C) 1994 Microsoft Corporation All rights reserved.
Authors: gordm Gord Mangione
History: 01/30/95 gordm Created.----------------------------------------------------------------------*/
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN
#endif
#define _DBGTRACE_DLL_IMPLEMENTATION
#include <windows.h>
#include "traceint.h"
#include "randint.h"
char szTraceFileName[MAX_PATH];char szDebugAsyncTrace[] = "SOFTWARE\\Microsoft\\MosTrace\\CurrentVersion\\DebugAsyncTrace";
extern DbgTraceDLL DWORD __dwEnabledTraces;
__inline BOOL GetRegDword( HKEY hKey, LPSTR pszValue, LPDWORD pdw ){ DWORD cbData = sizeof( DWORD ); DWORD dwType = REG_DWORD;
return RegQueryValueEx(hKey, pszValue, NULL, &dwType, (LPBYTE)pdw, &cbData ) == ERROR_SUCCESS && dwType == REG_DWORD;}
__inline BOOL GetRegString( HKEY hKey, LPSTR pszValue, LPBYTE buf, LPDWORD lpcbData ){ DWORD dwType = REG_SZ;
return RegQueryValueEx(hKey, pszValue, NULL, &dwType, buf, lpcbData ) == ERROR_SUCCESS && dwType == REG_SZ;}
__inline BOOL GetRegMSZ( HKEY hKey, LPSTR pszValue, LPBYTE buf, LPDWORD lpcbData){
DWORD dwType = REG_MULTI_SZ;
return RegQueryValueEx(hKey, pszValue, NULL, &dwType, buf, lpcbData ) == ERROR_SUCCESS && dwType == REG_MULTI_SZ;
}
BOOL GetTraceFlagsFromRegistry( void ){static char szNewTraceFileName[MAX_PATH];static char mszNewModules[MODULES_BUFFER_SIZE]; DWORD dwNewEnabledTraces; DWORD dwNewTraceOutputType; DWORD dwNewAsyncTraceFlag; DWORD dwNewHeapIncrementCount; int nNewThreadPriority; long nNewFailRate; LONG cRandFailBuffer; HKEY hkConfig = NULL; BOOL bRC = FALSE; DWORD cbData; DWORD dwDisposition;
__try { if ( RegCreateKeyEx( HKEY_LOCAL_MACHINE, szDebugAsyncTrace, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ, NULL, &hkConfig, &dwDisposition) == ERROR_SUCCESS ) { if ( GetRegDword( hkConfig, "MaxTraceFileSize", &dwMaxFileSize ) == FALSE ) { dwMaxFileSize = DEFAULT_MAX_FILE_SIZE; }
//
// determine threshold count based on how we can fit in the file
//
PendQ.dwThresholdCount = dwMaxFileSize / AVERAGE_TRACE_SIZE; INT_TRACE( "PendQ.dwThresholdCount: %d\n", PendQ.dwThresholdCount );
//
// determine the modules to log
//
cbData = MODULES_BUFFER_SIZE; ZeroMemory(mszNewModules, sizeof(mszNewModules)); if ( GetRegMSZ( hkConfig, "Modules", mszNewModules, &cbData ) == FALSE) { INT_TRACE( "GetRegMSZ: Modules failed: %d\n", GetLastError()); INT_TRACE( "\tLogging all modules" ); ZeroMemory(mszNewModules, MODULES_BUFFER_SIZE); }
if ( GetRegDword( hkConfig, "EnabledTraces", &dwNewEnabledTraces ) == FALSE ) { //
// Optional reg entry
// default is existing value of __dwEnabledTraces
//
INT_TRACE( "GetRegDword: EnabledTraces failed: %d\n", GetLastError() ); dwNewEnabledTraces = __dwEnabledTraces; }
if ( GetRegDword( hkConfig, "OutputTraceType", &dwNewTraceOutputType ) == FALSE ) { //
// Optional reg entry
// default is existing value of dwTraceOutputType
//
INT_TRACE( "GetRegDword: OutputTraceType failed: %d\n", GetLastError() ); dwNewTraceOutputType = dwTraceOutputType; } // If ouput is disabled, clear the EnabledTraces bitmap
if (dwNewTraceOutputType == TRACE_OUTPUT_DISABLED ) dwNewEnabledTraces = 0;
if ( GetRegDword( hkConfig, "AsyncTraceFlag", &dwNewAsyncTraceFlag ) == FALSE ) { //
// Optional reg entry
// default is existing value of dwAsyncTraceFlag
//
INT_TRACE( "GetRegDword: AsyncTraceFlag failed: %d\n", GetLastError() ); dwNewAsyncTraceFlag = dwAsyncTraceFlag; }
if (GetRegDword(hkConfig, "HeapIncrementCount", (LPDWORD)&dwNewHeapIncrementCount ) == FALSE || dwNewHeapIncrementCount == 0 ) { //
// optional reg entry
// default is the number buffers in 64KB
//
dwNewHeapIncrementCount = 0x10000 / sizeof(TRACEBUF); } InterlockedExchange( (long *)&dwIncrementSize, (long)dwNewHeapIncrementCount );
if ( GetRegDword( hkConfig, "AsyncThreadPriority", (LPDWORD)&nNewThreadPriority ) == FALSE ) { //
// optional reg entry
//
nNewThreadPriority = THREAD_PRIORITY_BELOW_NORMAL; } else switch( nNewThreadPriority ) { //
// if successful verify the resulting value
//
case THREAD_PRIORITY_IDLE: case THREAD_PRIORITY_BELOW_NORMAL: case THREAD_PRIORITY_NORMAL: case THREAD_PRIORITY_ABOVE_NORMAL: case THREAD_PRIORITY_HIGHEST: break;
default: ASSERT( FALSE ); nNewThreadPriority = THREAD_PRIORITY_BELOW_NORMAL; }
if (GetRegDword(hkConfig, "FailureRate", (LPDWORD)&nNewFailRate ) == FALSE) { //
// optional reg entry
// default is to disable failure
//
nNewFailRate = kDontFail;
}
InterlockedExchange( &nFailRate, nNewFailRate );
cbData = MAX_PATH; if ( !GetRegString( hkConfig, "FailureFile", g_szRandFailFile, &cbData ) ) { *g_szRandFailFile = '\0'; }
if ( GetRegDword( hkConfig, "FailureBuffer", (LPDWORD)&cRandFailBuffer )) { g_cCallStack = cRandFailBuffer; } else g_cCallStack = 1; // default value
cbData = sizeof(szNewTraceFileName); if ( GetRegString( hkConfig, "TraceFile", szNewTraceFileName, &cbData ) == FALSE ) { //
// Only fail if user specifies FILE based tracing
//
if ( dwNewTraceOutputType & TRACE_OUTPUT_FILE ) { INT_TRACE( "GetRegString: TraceFile failed: %d\n", GetLastError() ); return bRC = FALSE; } }
bRC = TRUE;
}
} __finally { //
// preserve the original error code
//
DWORD dwLastError = GetLastError(); BOOL fLeaveCritSec = FALSE;
if ( bRC == TRUE ) { BOOL bNewFileName = lstrcmpi( szNewTraceFileName, szTraceFileName ) != 0; BOOL bNewTraces = dwNewEnabledTraces != __dwEnabledTraces; BOOL bNewFlags = dwNewAsyncTraceFlag != dwAsyncTraceFlag; BOOL bNewOutput = dwNewTraceOutputType != dwTraceOutputType; BOOL bNewModules = memcmp(mszModules, mszNewModules, MODULES_BUFFER_SIZE) != 0;
INT_TRACE( "GetTraceFlags... 0x%08X, 0x%08X, 0x%08X, %s\n", dwNewAsyncTraceFlag, dwNewEnabledTraces, dwNewTraceOutputType, szNewTraceFileName );
INT_TRACE( "bNewFileName:%d bNewTraces:%d bNewOutput:%d bNewFlags:%d bNewModules:%d\n", bNewFileName, bNewTraces, bNewOutput, bNewFlags, bNewModules );
if ( bNewFileName || bNewTraces || bNewOutput || bNewFlags || bNewModules ) { if ( __dwEnabledTraces ) { //
// not the initial time thru
//
fLeaveCritSec = TRUE;
if ( dwAsyncTraceFlag ) { FlushAsyncTrace(); } EnterCriticalSection( &critSecWrite ); }
if ( PendQ.hFile != INVALID_HANDLE_VALUE ) { //
// if the file name changed or tracing was disabled or the
// file tracing disabled, then close the currently open file
//
if( bNewFileName || dwNewEnabledTraces == 0 || IsTraceFile( dwNewTraceOutputType ) == FALSE ) { BOOL bSuccess;
EnterCriticalSection( &critSecWrite ); bSuccess = CloseHandle( PendQ.hFile ); INT_TRACE( "CloseHandle: %d, GetLastError: %d\n", bSuccess, GetLastError() ); PendQ.hFile = INVALID_HANDLE_VALUE; LeaveCriticalSection( &critSecWrite ); } }
if ( IsTraceFile( dwNewTraceOutputType ) ) { if (bNewFileName || IsTraceFile( dwTraceOutputType ) == FALSE || dwNewEnabledTraces != 0 && PendQ.hFile == INVALID_HANDLE_VALUE ) { PendQ.hFile = CreateFile(szNewTraceFileName, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
if ( PendQ.hFile != INVALID_HANDLE_VALUE ) { lstrcpy( szTraceFileName, szNewTraceFileName ); } else { INT_TRACE( "CreateFile failed for %s 0x%X\n", szNewTraceFileName, GetLastError() ); } } }
//
// set the new priority for the writer thread
//
if ( nNewThreadPriority != nAsyncThreadPriority ) { nAsyncThreadPriority = nNewThreadPriority; SetThreadPriority( PendQ.hWriteThread, nAsyncThreadPriority ); }
//
// set the new list of modules to log
//
if ( bNewModules ) { memcpy(mszModules, mszNewModules, MODULES_BUFFER_SIZE); }
dwTraceOutputType = dwNewTraceOutputType; dwAsyncTraceFlag = dwNewAsyncTraceFlag;
InterlockedExchange( &__dwEnabledTraces, dwNewEnabledTraces );
if ( fLeaveCritSec ) { //
// not the initial time thru
//
LeaveCriticalSection( &critSecWrite ); } } }
if ( hkConfig != NULL ) { RegCloseKey( hkConfig ); }
SetLastError( dwLastError );
} return bRC;}
#define NUM_REG_THREAD_OBJECTS 2
DWORD RegNotifyThread( LPDWORD lpdw ){ HANDLE Handles[NUM_REG_THREAD_OBJECTS]; HKEY hKey; DWORD dw;
Handles[0] = hShutdownEvent;
INT_TRACE( "RegNotifyThread 0x%X\n", GetCurrentThreadId() );
Handles[1] = CreateEvent( NULL, FALSE, FALSE, NULL ); if ( Handles[1] == NULL ) { ASSERT( FALSE ); INT_TRACE( "RegNotifyThread CreateEvent failed 0x%X\n", GetLastError() ); return 1; }
if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, szDebugAsyncTrace, 0, KEY_READ, &hKey ) != ERROR_SUCCESS ) { INT_TRACE( "RegNotifyThread RegOpenKeyEx failed 0x%X\n", GetLastError() ); CloseHandle( Handles[1] ); return 1; }
for ( ;; ) { if ( RegNotifyChangeKeyValue(hKey, FALSE, REG_NOTIFY_CHANGE_ATTRIBUTES | REG_NOTIFY_CHANGE_LAST_SET, Handles[1], TRUE ) != ERROR_SUCCESS ) { INT_TRACE( "RegNotifyThread RegNotify... failed 0x%X\n", GetLastError() ); RegCloseKey( hKey ); CloseHandle( Handles[1] ); return 1; }
dw = WaitForMultipleObjects(NUM_REG_THREAD_OBJECTS, Handles, FALSE, INFINITE );
switch( dw ) { //
// normal signalled event
//
case WAIT_OBJECT_0: RegCloseKey( hKey ); CloseHandle( Handles[1] ); INT_TRACE( "Exiting RegNotifyThread for hShutdownEvent\n" ); return 0;
//
// signalled that our registry keys have changed
//
case WAIT_OBJECT_0+1: GetTraceFlagsFromRegistry(); break;
default: INT_TRACE( "RegNotifyThread WFMO: dw: 0x%X, Error: 0x%X\n", dw, GetLastError() ); ASSERT( FALSE ); RegCloseKey( hKey ); CloseHandle( Handles[1] ); return 1; } }
INT_TRACE( "Exiting RegNotifyThread abnormally\n" ); RegCloseKey( hKey ); CloseHandle( Handles[1] );
return 2;}
|
