able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/security/common/debug/debuglib/debug.c

1711 lines
41 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1993.
//
// File: debug.c
//
// Contents:
//
// Classes:
//
// Functions:
//
// History: 3-14-95 RichardW Created
//
//----------------------------------------------------------------------------
#include "debuglib.h"
SECURITY_DESCRIPTOR DbgpPartySd;
BOOL DbgpPartySdInit = FALSE;
PDebugHeader DbgpHeader = NULL;
DebugModule * * DbgpFixupModules[] = { &__pAssertModule,
&__pExceptionModule,
NULL };
CHAR szDebugSection[] = "DSysDebug";
CHAR szDebugFlags[] = "DebugFlags";
DEBUG_KEY DbgpKeys[] = { {DEBUG_NO_DEBUGIO, "NoDebugger"},
{DEBUG_TIMESTAMP, "TimeStamp"},
{DEBUG_DEBUGGER_OK, "DebuggerOk"},
{DEBUG_LOGFILE, "Logfile"},
{DEBUG_AUTO_DEBUG, "AutoDebug"},
{DEBUG_USE_KDEBUG, "UseKD"},
{DEBUG_HEAP_CHECK, "HeapCheck"},
{DEBUG_MULTI_THREAD, "MultiThread"},
{DEBUG_DISABLE_ASRT, "DisableAssert"},
{DEBUG_PROMPTS, "AssertPrompts"},
{DEBUG_BREAK_ON_ERROR,"BreakOnError"},
{0, NULL }
};
#define DEBUG_NUMBER_OF_KEYS ((sizeof(DbgpKeys) / sizeof(DEBUG_KEY)) - 1)
#define _ALIGN(x,a) (x & (a-1) ? (x + a) & ~(a - 1) : x);
#define ALIGN_8(x) _ALIGN(x, 8)
#define ALIGN_16(x) _ALIGN(x, 16)
#ifdef WIN64
#define DBG_ALIGN ALIGN_16
#else
#define DBG_ALIGN ALIGN_8
#endif
#define DEBUGMEM_ALLOCATED 0x00000001
typedef struct _DebugMemory {
struct _DebugMemory * pNext;
DWORD Size;
DWORD Flags;
} DebugMemory, * PDebugMemory;
#ifdef DEBUG_DEBUG
#define LockDebugHeader(p) EnterCriticalSection(&((p)->csDebug)); OutputDebugStringA("Lock")
#define UnlockDebugHeader(p) LeaveCriticalSection(&((p)->csDebug)); OutputDebugStringA("Unlock")
#else
#define LockDebugHeader(p) EnterCriticalSection(&((p)->csDebug))
#define UnlockDebugHeader(p) LeaveCriticalSection(&((p)->csDebug))
#endif
//+---------------------------------------------------------------------------
//
// Function: DbgpComputeMappingName
//
// Synopsis: Computes the mapping object name
//
// Arguments: [pszName] -- place to stick the name (no more than 32 wchars)
//
// History: 3-22-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
void
DbgpComputeMappingName(PWSTR pszName)
{
swprintf(pszName, TEXT("Debug.Memory.%x"), GetCurrentProcessId());
}
//+---------------------------------------------------------------------------
//
// Function: DbgpInitializeMM
//
// Synopsis: Initializes our simple memory manager within the shared mem
// section.
//
// Arguments: [pHeader] -- Header to initialize
//
// History: 3-22-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
VOID
DbgpInitializeMM(PDebugHeader pHeader)
{
PDebugMemory pMem;
pMem = (PDebugMemory) (pHeader + 1);
pMem->pNext = NULL;
pMem->Size = pHeader->CommitRange - (sizeof(DebugHeader) + sizeof(DebugMemory));
pHeader->pFreeList = pMem;
}
//+---------------------------------------------------------------------------
//
// Function: DbgpAlloc
//
// Synopsis: Very, very simple allocator
//
// Arguments: [pHeader] -- Header from which to allocate
// [cSize] -- size to allocate
//
// History: 3-22-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
PVOID
DbgpAlloc(
PDebugHeader pHeader,
DWORD cSize)
{
PDebugMemory pSearch;
PDebugMemory pLargest = NULL;
PDebugMemory pNew;
DWORD cLargest;
cLargest = 0;
cSize = DBG_ALIGN(cSize);
//
// Very, very simple allocator. Search free list for an exact match,
//
pSearch = (PDebugMemory) pHeader->pFreeList;
while (pSearch)
{
if ( ( pSearch->Flags & DEBUGMEM_ALLOCATED ) == 0 )
{
if ( pSearch->Size == cSize )
{
break;
}
if (pSearch->Size > cLargest)
{
pLargest = pSearch;
cLargest = pSearch->Size;
}
}
pSearch = pSearch->pNext;
}
//
// If no match yet
//
if (!pSearch)
{
//
// If the largest free block is still too small,
//
if (cLargest < (cSize + sizeof(DebugMemory) * 2))
{
//
// Extend the mapped range
//
if (pHeader->CommitRange < pHeader->ReserveRange)
{
if ( VirtualAlloc(
(PUCHAR) pHeader + pHeader->CommitRange,
pHeader->PageSize,
MEM_COMMIT,
PAGE_READWRITE ) )
{
pNew = (PDebugMemory) ((PUCHAR) pHeader + pHeader->CommitRange );
pHeader->CommitRange += pHeader->PageSize ;
pNew->Size = pHeader->PageSize - sizeof( DebugMemory );
pNew->pNext = pHeader->pFreeList ;
pHeader->pFreeList = pNew ;
return DbgpAlloc( pHeader, cSize );
}
else
{
return NULL ;
}
}
return(NULL);
}
//
// Otherwise, split the largest block into something better...
//
pNew = (PDebugMemory) ((PUCHAR) pLargest + (cSize + sizeof(DebugMemory)) );
pNew->Size = pLargest->Size - (cSize + sizeof(DebugMemory) * 2);
pNew->pNext = pLargest->pNext ;
pNew->Flags = 0;
pLargest->Size = cSize;
pLargest->Flags |= DEBUGMEM_ALLOCATED;
pLargest->pNext = pNew;
return((PVOID) (pLargest + 1) );
}
else
{
pSearch->Flags |= DEBUGMEM_ALLOCATED ;
return((PVOID) (pSearch + 1) );
}
return(NULL);
}
//+---------------------------------------------------------------------------
//
// Function: DbgpFree
//
// Synopsis: Returns memory to the shared mem segment
//
// Arguments: [pHeader] -- Shared memory header
// [pMemory] -- Memory to free
//
// History: 3-22-95 RichardW Created
//
// Notes: No compaction.
//
//----------------------------------------------------------------------------
VOID
DbgpFree(
PDebugHeader pHeader,
PVOID pMemory)
{
PDebugMemory pMem;
pMem = (PDebugMemory) ((PUCHAR) pMemory - sizeof(DebugMemory));
pMem->Flags &= ~DEBUGMEM_ALLOCATED;
ZeroMemory( pMemory, pMem->Size );
}
//+---------------------------------------------------------------------------
//
// Function: DbgpFindModule
//
// Synopsis: Locates a module based on a name
//
// Arguments: [pHeader] -- Header to search
// [pszName] -- module to find
//
// History: 3-22-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
PDebugModule
DbgpFindModule(
PDebugHeader pHeader,
CHAR * pszName)
{
PDebugModule pSearch;
pSearch = pHeader->pModules;
while (pSearch)
{
if (_strcmpi(pSearch->pModuleName, pszName) == 0)
{
return(pSearch);
}
pSearch = pSearch->pNext;
}
return(NULL);
}
//+---------------------------------------------------------------------------
//
// Function: DbgpCopyModule
//
// Synopsis: Copies a module into a new module. Used for the builtins.
// note, no references to the code module that the builtin lived
// in is kept. This way, the module can unload.
//
// Arguments: [pHeader] --
// [pSource] --
// [ppDest] --
//
// Requires: Header must be locked.
//
// Returns: 0 for failure, non-zero for success
//
// History: 7-19-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
DWORD
DbgpCopyModule(
PDebugHeader pHeader,
PDebugModule pSource,
PDebugModule * ppDest)
{
PDebugModule pModule;
DWORD i;
DWORD cStringSpace;
PCHAR pStrings;
*ppDest = NULL;
cStringSpace = strlen(pSource->pModuleName) + 1;
for (i = 0; i < 32 ; i++ )
{
if (pSource->TagLevels[i])
{
cStringSpace += (strlen(pSource->TagLevels[i]) + 1);
}
}
//
// Allocate an extra DWORD to store the infolevel.
//
pModule = DbgpAlloc(pHeader, sizeof(DebugModule) + sizeof( DWORD ) );
if (!pModule)
{
return(0);
}
pStrings = DbgpAlloc(pHeader, cStringSpace);
if ( !pStrings )
{
DbgpFree( pHeader, pModule );
return 0 ;
}
pModule->pModuleName = pStrings;
cStringSpace = strlen(pSource->pModuleName) + 1;
strcpy(pModule->pModuleName, pSource->pModuleName);
pStrings += cStringSpace;
for (i = 0; i < 32 ; i++ )
{
if (pSource->TagLevels[i])
{
pModule->TagLevels[i] = pStrings;
cStringSpace = strlen(pSource->TagLevels[i]) + 1;
strcpy(pStrings, pSource->TagLevels[i]);
pStrings += cStringSpace;
}
else
{
pSource->TagLevels[i] = NULL;
}
}
//
// Add this in to the global list
//
pModule->pNext = pHeader->pModules;
pHeader->pModules = pModule;
//
// Do not increment module count - this is a builtin
//
//
// Copy the rest of the interesting stuff
//
pModule->pInfoLevel = (PDWORD) (pModule + 1);
*pModule->pInfoLevel = *pSource->pInfoLevel;
pModule->InfoLevel = pSource->InfoLevel;
pModule->fModule = pSource->fModule | DEBUGMOD_BUILTIN_MODULE ;
pModule->pHeader = pHeader;
pModule->TotalOutput = pSource->TotalOutput;
pModule->Reserved = 0;
*ppDest = pModule;
return(1);
}
//+---------------------------------------------------------------------------
//
// Function: DbgpAttachBuiltinModules
//
// Synopsis: Attaches the builtin library modules to the global shared
// list
//
// Arguments: [pHeader] --
//
// History: 7-19-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
BOOL
DbgpAttachBuiltinModules(
PDebugHeader pHeader)
{
PDebugModule pModule;
PDebugModule pFixup;
DWORD i;
BOOL Success = FALSE;
i = 0;
while (DbgpFixupModules[i])
{
pFixup = *DbgpFixupModules[i];
pModule = DbgpFindModule(pHeader, pFixup->pModuleName);
if (pModule)
{
*DbgpFixupModules[i] = pModule;
Success = TRUE;
}
else
{
if (DbgpCopyModule(pHeader, pFixup, &pModule))
{
*DbgpFixupModules[i] = pModule;
Success = TRUE;
}
}
i++;
}
return(Success);
}
//+---------------------------------------------------------------------------
//
// Function: DbgpBuildModule
//
// Synopsis: Initializes a Module, builds the string table
//
// Arguments: [pModule] -- Module pointer
// [pHeader] -- Header
// [pKeys] -- Key table
// [pszName] -- Name
// [pInfoLevel] -- Pointer to info level
//
// History: 4-03-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
DWORD
DbgpBuildModule(
PDebugModule pModule,
PDebugHeader pHeader,
PDEBUG_KEY pKeys,
PCHAR pszName,
PDWORD pInfoLevel)
{
PCHAR pStringData;
DWORD cStringData;
DWORD cKeys;
DWORD i;
DWORD KeyIndex;
DWORD BitScan;
//
// Easy stuff to start..
//
pModule->pInfoLevel = pInfoLevel;
pModule->pHeader = pHeader;
cStringData = strlen(pszName) + 1;
//
// Search through the list of masks and string tags, computing
// the size needed for containing them all. If a tag has more
// than one bit set, reject it.
//
for (i = 0; i < 32 ; i++ )
{
if (pKeys[i].Mask)
{
if (pKeys[i].Mask & (pKeys[i].Mask - 1))
{
continue;
}
}
if (pKeys[i].Tag)
{
cStringData += strlen(pKeys[i].Tag) + 1;
}
else
{
break;
}
}
//
// We know how many keys there are, and how big a space they need.
//
cKeys = i;
pStringData = DbgpAlloc(pHeader, cStringData);
if ( !pStringData )
{
return 0 ;
}
pModule->pModuleName = pStringData;
strcpy(pStringData, pszName);
pStringData += strlen(pStringData) + 1;
for (i = 0, KeyIndex = 0; i < cKeys ; i++ )
{
if (pKeys[i].Mask & (pKeys[i].Mask - 1))
{
continue;
}
if (!(pKeys[i].Mask & (1 << KeyIndex)))
{
//
// Grr, out of order. Do a bit-wise scan.
//
KeyIndex = 0;
BitScan = 1;
while ((pKeys[i].Mask & BitScan) == 0)
{
BitScan <<= 1;
KeyIndex ++;
}
}
pModule->TagLevels[KeyIndex] = pStringData;
strcpy(pStringData, pKeys[i].Tag);
pStringData += strlen(pKeys[i].Tag) + 1;
KeyIndex++;
}
return(cKeys);
}
//+---------------------------------------------------------------------------
//
// Function: DbgpGetBitmask
//
// Synopsis: Based on a parameter line and a key table, builds the bitmask
//
// Arguments: [pKeys] --
// [cKeys] --
// [pszLine] --
// [ParameterIndex] --
// [ParameterValue] --
//
// History: 4-03-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
DWORD
DbgpGetBitmask(
DEBUG_KEY * pKeys,
DWORD cKeys,
PCHAR pszLine,
DWORD ParameterIndex,
PCHAR ParameterValue)
{
PCHAR pszSearch;
PCHAR pszParam;
PCHAR pszScan;
DWORD i;
DWORD Mask;
DWORD cbParameter = 0;
DWORD Compare;
CHAR Saved;
if (ParameterIndex < cKeys)
{
cbParameter = strlen(pKeys[ParameterIndex].Tag);
}
Mask = 0;
pszSearch = pszLine;
//
// Scan through the line, searching for flags. Note: do NOT use strtok,
// since that is not exported by ntdll, and we would not be able to make
// security.dll
//
while (*pszSearch)
{
pszScan = pszSearch;
while ((*pszScan) && (*pszScan != ','))
{
pszScan++;
}
Saved = *pszScan;
*pszScan = '\0';
for (i = 0; i < cKeys ; i++ )
{
if (i == ParameterIndex)
{
if (_strnicmp(pKeys[i].Tag, pszSearch, cbParameter) == 0)
{
pszParam = strchr(pszSearch, ':');
if (pszParam)
{
strcpy(ParameterValue, pszParam+1);
}
Mask |= pKeys[i].Mask;
}
}
else
{
if (_strcmpi(pKeys[i].Tag, pszSearch) == 0)
{
Mask |= pKeys[i].Mask;
}
}
}
*pszScan = Saved;
if (Saved)
{
while ((*pszScan) && ((*pszScan == ',') || (*pszScan == ' ')))
{
pszScan++;
}
}
pszSearch = pszScan;
}
return(Mask);
}
//+---------------------------------------------------------------------------
//
// Function: DbgpInitializeDebug
//
// Synopsis: Initialize the base memory
//
// Arguments: [pHeader] --
//
// History: 4-03-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
VOID
DbgpInitializeDebug(
PDebugHeader pHeader)
{
CHAR szExeName[MAX_PATH];
PCHAR pszExeName;
PCHAR dot;
DWORD cbExeName;
CHAR LogFile[MAX_PATH];
CHAR Line[MAX_PATH];
SECURITY_ATTRIBUTES sa;
PDebugModule pModule;
HANDLE Token ;
TOKEN_STATISTICS TokenStat ;
ULONG Size ;
LUID LocalSys = SYSTEM_LUID ;
//
// Plug the debug section in first
//
pModule = DbgpAlloc(pHeader, sizeof(DebugModule));
if (!pModule)
{
return;
}
DbgpBuildModule(pModule,
pHeader,
DbgpKeys,
DEBUG_MODULE_NAME,
&pHeader->fDebug);
GetModuleFileNameA(NULL, szExeName, MAX_PATH);
pszExeName = strrchr(szExeName, '\\');
if (pszExeName)
{
pszExeName++;
}
else
{
pszExeName = szExeName;
}
dot = strrchr(pszExeName, '.');
if (dot)
{
*dot = '\0';
}
cbExeName = (DWORD) (dot - pszExeName);
pHeader->pszExeName = DbgpAlloc(pHeader, cbExeName + 1);
if (pHeader->pszExeName)
{
strcpy(pHeader->pszExeName, pszExeName);
}
LogFile[0] = '\0';
if (GetProfileStringA( szDebugSection,
pszExeName,
"",
Line,
MAX_PATH))
{
pHeader->fDebug = DbgpGetBitmask( DbgpKeys,
DEBUG_NUMBER_OF_KEYS,
Line,
3,
LogFile);
}
//
// If running as local system, turn on the kd flag. That
// way,
if ( OpenProcessToken( GetCurrentProcess(),
TOKEN_QUERY,
&Token ) )
{
if ( GetTokenInformation( Token,
TokenStatistics,
&TokenStat,
sizeof( TokenStat ),
&Size ) )
{
if ( (TokenStat.AuthenticationId.LowPart == LocalSys.LowPart ) &&
(TokenStat.AuthenticationId.HighPart == LocalSys.HighPart ) )
{
pHeader->fDebug |= DEBUG_USE_KDEBUG ;
}
}
CloseHandle( Token );
}
if (GetProfileStringA( szDebugSection,
szDebugFlags,
"",
Line,
MAX_PATH))
{
pHeader->fDebug |= DbgpGetBitmask( DbgpKeys,
DEBUG_NUMBER_OF_KEYS,
Line,
3,
LogFile);
}
if ( pHeader->fDebug & DEBUG_USE_KDEBUG )
{
//
// Verify that there is a kernel debugger
//
SYSTEM_KERNEL_DEBUGGER_INFORMATION KdInfo ;
NTSTATUS Status ;
Status = NtQuerySystemInformation(
SystemKernelDebuggerInformation,
&KdInfo,
sizeof( KdInfo ),
NULL );
if ( NT_SUCCESS( Status ) )
{
if ( !KdInfo.KernelDebuggerEnabled )
{
pHeader->fDebug &= ~(DEBUG_USE_KDEBUG) ;
}
}
}
if (pHeader->fDebug & DEBUG_LOGFILE)
{
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = &DbgpPartySd;
sa.bInheritHandle = FALSE;
if (LogFile[0] == '\0')
{
strcpy(LogFile, szExeName);
strcat(LogFile, ".log");
}
pHeader->hLogFile = CreateFileA(LogFile,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ,
&sa,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL |
FILE_FLAG_WRITE_THROUGH,
NULL);
}
pHeader->pModules = pModule;
pHeader->pGlobalModule = pModule;
pModule->pInfoLevel = &pHeader->fDebug;
pModule->InfoLevel = pHeader->fDebug;
DbgpAttachBuiltinModules(pHeader);
}
//+---------------------------------------------------------------------------
//
// Function: DbgpOpenLogFileRandom
//
// Synopsis: Opens the logfile dynamically
//
// Arguments: [pHeader] --
//
// History: 4-27-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
BOOL
DbgpOpenLogFileRandom(
PDebugHeader pHeader)
{
WCHAR szLogPath[MAX_PATH];
DWORD dwPath;
PWSTR pszDot;
SECURITY_ATTRIBUTES sa;
dwPath = GetModuleFileName(NULL, szLogPath, MAX_PATH);
pszDot = wcsrchr(szLogPath, L'.');
if (!pszDot)
{
pszDot = &szLogPath[dwPath];
}
wcscpy(pszDot, L".log");
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = &DbgpPartySd;
sa.bInheritHandle = FALSE;
LockDebugHeader(pHeader);
pHeader->hLogFile = CreateFileW(szLogPath,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ,
&sa,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL |
FILE_FLAG_WRITE_THROUGH,
NULL);
if (pHeader->hLogFile == INVALID_HANDLE_VALUE)
{
pHeader->fDebug &= ~(DEBUG_LOGFILE);
UnlockDebugHeader(pHeader);
return(FALSE);
}
UnlockDebugHeader(pHeader);
return(TRUE);
}
//+---------------------------------------------------------------------------
//
// Function: DbgpOpenOrCreateSharedMem
//
// Synopsis: Returns a pointer to the shared memory segment,
// creating it if necessary. Header is LOCKED on return
//
// Arguments: (none)
//
// History: 3-22-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
PVOID
DbgpOpenOrCreateSharedMem(DWORD Flags)
{
HANDLE hMapping;
WCHAR szMappingName[32];
SECURITY_ATTRIBUTES sa;
PDebugHeader pHeader;
SYSTEM_INFO SysInfo;
if (!DbgpPartySdInit)
{
InitializeSecurityDescriptor(&DbgpPartySd, SECURITY_DESCRIPTOR_REVISION);
SetSecurityDescriptorDacl(&DbgpPartySd, TRUE, NULL, FALSE);
DbgpPartySdInit = TRUE;
}
if (DbgpHeader)
{
LockDebugHeader(DbgpHeader);
return(DbgpHeader);
}
GetSystemInfo(&SysInfo);
DbgpComputeMappingName(szMappingName);
hMapping = OpenFileMapping( FILE_MAP_ALL_ACCESS,
FALSE,
szMappingName);
if (hMapping)
{
//
// Ok, someone else has created the section. So, we just need to map
// it.
//
pHeader = MapViewOfFileEx( hMapping,
FILE_MAP_READ | FILE_MAP_WRITE,
0,
0,
SysInfo.dwPageSize,
NULL);
if ( pHeader )
{
if (pHeader != pHeader->pvSection)
{
DbgpHeader = pHeader->pvSection;
}
else
{
DbgpHeader = pHeader;
}
UnmapViewOfFile(pHeader);
}
else
{
DbgpHeader = NULL ;
}
//
// Now that we have the other guy's address, we can throw away this
// one.
//
CloseHandle(hMapping);
if ( DbgpHeader )
{
LockDebugHeader(DbgpHeader);
DbgpAttachBuiltinModules(DbgpHeader);
}
return(DbgpHeader);
}
if (Flags & DSYSDBG_OPEN_ONLY)
{
return(NULL);
}
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = &DbgpPartySd;
sa.bInheritHandle = FALSE;
hMapping = CreateFileMapping( INVALID_HANDLE_VALUE,
NULL, //&sa,
PAGE_READWRITE | SEC_RESERVE,
0,
SysInfo.dwAllocationGranularity,
szMappingName);
if (hMapping)
{
pHeader = MapViewOfFileEx(hMapping,
FILE_MAP_READ | FILE_MAP_WRITE,
0,
0,
SysInfo.dwAllocationGranularity,
NULL);
if (!pHeader)
{
return(NULL);
}
//
// Commit the view, so we can initialize the header
//
pHeader = (PDebugHeader) VirtualAlloc( pHeader,
SysInfo.dwPageSize,
MEM_COMMIT,
PAGE_READWRITE);
pHeader->Tag = DEBUG_TAG;
pHeader->pvSection = pHeader;
pHeader->hMapping = hMapping;
pHeader->hLogFile = INVALID_HANDLE_VALUE;
pHeader->CommitRange = SysInfo.dwPageSize;
pHeader->ReserveRange = SysInfo.dwAllocationGranularity;
pHeader->PageSize = SysInfo.dwPageSize;
pHeader->pModules = NULL;
pHeader->pFreeList = NULL;
pHeader->pBufferList = &pHeader->DefaultBuffer ;
pHeader->DefaultBuffer.Next = NULL ;
InitializeCriticalSection(&pHeader->csDebug);
LockDebugHeader(pHeader);
DbgpInitializeMM(pHeader);
DbgpInitializeDebug(pHeader);
DbgpHeader = pHeader;
return(pHeader);
}
return(NULL);
}
//+---------------------------------------------------------------------------
//
// Function: DbgpLoadValidateRoutine
//
// Synopsis: Loads RtlValidateProcessHeaps() from ntdll
//
// Arguments: [pHeader] --
//
// History: 5-02-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
VOID
DbgpLoadValidateRoutine(PDebugHeader pHeader)
{
HMODULE hNtDll;
hNtDll = LoadLibrary(TEXT("ntdll.dll"));
if (hNtDll)
{
pHeader->pfnValidate = (HEAPVALIDATE) GetProcAddress(hNtDll, "RtlValidateProcessHeaps");
if (!pHeader->pfnValidate)
{
pHeader->fDebug &= ~(DEBUG_HEAP_CHECK);
}
//
// We can safely free this handle, since kernel32 and advapi32 DLLs
// both use ntdll, so the refcount won't go to zero.
//
FreeLibrary(hNtDll);
}
}
//+---------------------------------------------------------------------------
//
// Function: _InitDebug
//
// Synopsis: Workhorse of the initializers
//
// Arguments: [pInfoLevel] -- Pointer to module specific infolevel
// [ppControlBlock] -- Pointer to module specific control pointer
// [szName] -- Name
// [pKeys] -- Key data
//
// History: 3-22-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
VOID
_InitDebug(
DWORD Flags,
DWORD * pInfoLevel,
PVOID * ppControlBlock,
CHAR * szName,
PDEBUG_KEY pKeys)
{
PDebugHeader pHeader;
PDebugModule pModule;
CHAR Line[MAX_PATH];
DWORD cKeys;
DWORD i;
if ( (*ppControlBlock) && (*ppControlBlock != INVALID_HANDLE_VALUE) )
{
//
// Already Initialized
//
return ;
}
*ppControlBlock = NULL;
//
// Find the shared section.
//
pHeader = DbgpOpenOrCreateSharedMem(Flags);
if (!pHeader)
{
if (Flags & DSYSDBG_DEMAND_OPEN)
{
*ppControlBlock = (PVOID) INVALID_HANDLE_VALUE;
}
return;
}
//
// See if we have already registered (dll being loaded several times)
// if not, allocate a new module.
//
pModule = DbgpFindModule(pHeader, szName);
if (!pModule)
{
pModule = DbgpAlloc(pHeader, sizeof(DebugModule) );
if (!pModule)
{
UnlockDebugHeader(pHeader);
return;
}
}
else
{
//
// Found module already loaded. Check to see that everything
// lines up:
//
if ( pModule->pInfoLevel != pInfoLevel )
{
//
// Uh oh, there's a module with our name already loaded,
// but the pointers don't match. So, let's create our
// own now.
//
pModule = DbgpAlloc( pHeader, sizeof( DebugModule ) );
if ( !pModule )
{
UnlockDebugHeader( pHeader );
return;
}
}
else
{
*ppControlBlock = pModule;
UnlockDebugHeader(pHeader);
return;
}
}
//
// Initialize module
//
cKeys = DbgpBuildModule(pModule,
pHeader,
pKeys,
szName,
pInfoLevel);
//
// Now, load up info levels from ini or registry
// First, try a module specific entry.
//
if (GetProfileStringA(szName, szDebugFlags, "", Line, MAX_PATH))
{
pModule->InfoLevel = DbgpGetBitmask(pKeys,
cKeys,
Line,
0xFFFFFFFF,
NULL );
}
if (pHeader->pszExeName)
{
if (GetProfileStringA(szName, pHeader->pszExeName, "", Line, MAX_PATH))
{
pModule->InfoLevel = DbgpGetBitmask(pKeys,
cKeys,
Line,
0xFFFFFFFF,
NULL );
}
}
// HACK - Make Default DBG / DEBUG_SUPPORT dependent. See dsysdbg.h
if (GetProfileStringA(szDebugSection, szName, SZ_DEFAULT_PROFILE_STRING, Line, MAX_PATH))
{
pModule->InfoLevel |= DbgpGetBitmask( pKeys,
cKeys,
Line,
0xFFFFFFFF,
NULL );
}
*pModule->pInfoLevel = pModule->InfoLevel;
pModule->pNext = pHeader->pModules;
pHeader->pModules = pModule;
pHeader->ModuleCount++ ;
*ppControlBlock = pModule;
UnlockDebugHeader(pHeader);
}
VOID
_UnloadDebug(
PVOID pControlBlock
)
{
PDebugHeader pHeader;
PDebugModule pModule;
PDebugModule pScan ;
BOOL FreeIt = FALSE ;
pModule = (PDebugModule) pControlBlock ;
if ( !pModule )
{
return ;
}
if ( pModule->pInfoLevel == NULL )
{
return ;
}
pHeader = pModule->pHeader ;
LockDebugHeader( pHeader );
pScan = pHeader->pModules ;
if ( pScan == pModule )
{
pHeader->pModules = pModule->pNext ;
}
else
{
while ( pScan && ( pScan->pNext != pModule ) )
{
pScan = pScan->pNext ;
}
if ( pScan )
{
pScan->pNext = pModule->pNext ;
}
pModule->pNext = NULL ;
}
DbgpFree( pHeader, pModule->pModuleName );
DbgpFree( pHeader, pModule );
pHeader->ModuleCount-- ;
if ( pHeader->ModuleCount == 0 )
{
FreeIt = TRUE ;
}
UnlockDebugHeader( pHeader );
if ( FreeIt )
{
if ( pHeader->hLogFile != INVALID_HANDLE_VALUE )
{
CloseHandle( pHeader->hLogFile );
}
if ( pHeader->hMapping )
{
CloseHandle( pHeader->hMapping );
}
DeleteCriticalSection( &pHeader->csDebug );
UnmapViewOfFile( pHeader );
}
}
//+---------------------------------------------------------------------------
//
// Function: DbgpGetTextBuffer
//
// Synopsis: Gets a text buffer from the header, allocating if necessary
//
// Arguments: [pHeader] --
//
// History: 3-19-98 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
PDEBUG_TEXT_BUFFER
DbgpGetTextBuffer(
PDebugHeader pHeader
)
{
PDEBUG_TEXT_BUFFER pBuffer ;
LockDebugHeader( pHeader );
if ( pHeader->pBufferList )
{
pBuffer = pHeader->pBufferList ;
pHeader->pBufferList = pBuffer->Next ;
}
else
{
pBuffer = DbgpAlloc( pHeader, sizeof( DEBUG_TEXT_BUFFER ) );
}
UnlockDebugHeader( pHeader );
if ( pBuffer )
{
pBuffer->Next = NULL ;
}
return pBuffer ;
}
//+---------------------------------------------------------------------------
//
// Function: DbgpReleaseTextBuffer
//
// Synopsis: Releases a text buffer back to the pool of buffers
//
// Arguments: [pHeader] --
// [pBuffer] --
//
// History: 3-19-98 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
VOID
DbgpReleaseTextBuffer(
PDebugHeader pHeader,
PDEBUG_TEXT_BUFFER pBuffer
)
{
LockDebugHeader( pHeader );
pBuffer->Next = pHeader->pBufferList ;
pHeader->pBufferList = pBuffer ;
UnlockDebugHeader( pHeader );
}
//+---------------------------------------------------------------------------
//
// Function: _DebugOut
//
// Synopsis: Workhorse for the debug out functions
//
// Arguments: [pControl] -- Control pointer
// [Mask] -- Event mask
// [Format] -- format string
// [ArgList] -- va_list...
//
// History: 3-22-95 RichardW Created
//
// Notes:
//
//----------------------------------------------------------------------------
VOID
_DebugOut(
PVOID pControl,
ULONG Mask,
CHAR * Format,
va_list ArgList)
{
PDebugModule pModule;
int Level = 0;
int PrefixSize = 0;
int TotalSize;
BOOL fLocked;
BOOL fClean;
PCHAR Tag;
BOOL Break = FALSE ;
PDEBUG_TEXT_BUFFER pBuffer ;
if ( pControl == NULL )
{
return ;
}
pModule = (PDebugModule) pControl;
if ( pModule->pInfoLevel == NULL )
{
return ;
}
if (!pModule || (pModule == INVALID_HANDLE_VALUE))
{
if (Mask & DSYSDBG_FORCE)
{
NOTHING ;
}
else
return;
}
if (pModule->fModule & DEBUGMOD_CHANGE_INFOLEVEL)
{
*pModule->pInfoLevel = pModule->InfoLevel;
pModule->fModule &= ~(DEBUGMOD_CHANGE_INFOLEVEL);
}
if (pModule->pHeader->pGlobalModule->fModule & DEBUGMOD_CHANGE_INFOLEVEL)
{
pModule->pHeader->fDebug = pModule->pHeader->pGlobalModule->InfoLevel;
pModule->pHeader->pGlobalModule->fModule &= ~(DEBUGMOD_CHANGE_INFOLEVEL);
}
pModule->InfoLevel = *pModule->pInfoLevel;
if (pModule->pHeader->fDebug & DEBUG_MULTI_THREAD)
{
LockDebugHeader(pModule->pHeader);
fLocked = TRUE;
}
else
fLocked = FALSE;
if (pModule->pHeader->fDebug & DEBUG_HEAP_CHECK)
{
if (!pModule->pHeader->pfnValidate)
{
DbgpLoadValidateRoutine(pModule->pHeader);
}
if (pModule->pHeader->pfnValidate)
{
pModule->pHeader->pfnValidate();
}
}
fClean = ((Mask & DSYSDBG_CLEAN) != 0);
if ( ( Mask & DEB_ERROR ) &&
( pModule->pHeader->fDebug & DEBUG_BREAK_ON_ERROR ) )
{
Break = TRUE ;
}
pBuffer = DbgpGetTextBuffer( pModule->pHeader );
if ( !pBuffer )
{
OutputDebugStringA( "_DebugOut : Out of memory\n" );
if ( fLocked )
{
UnlockDebugHeader( pModule->pHeader );
}
return;
}
if (Mask & (pModule->InfoLevel | DSYSDBG_FORCE))
{
if (Mask & DSYSDBG_FORCE)
{
Tag = "FORCE";
}
else
{
while (!(Mask & 1))
{
Level++;
Mask >>= 1;
}
Tag = pModule->TagLevels[Level];
}
//
// Make the prefix first: "Process.Thread> Module-Tag:
//
if (!fClean)
{
if (pModule->pHeader->fDebug & DEBUG_TIMESTAMP)
{
SYSTEMTIME stTime;
GetLocalTime(&stTime);
PrefixSize = sprintf(pBuffer->TextBuffer,
"[%2d/%2d %02d:%02d:%02d] %d.%d> %s-%s: ",
stTime.wMonth, stTime.wDay,
stTime.wHour, stTime.wMinute, stTime.wSecond,
GetCurrentProcessId(),
GetCurrentThreadId(), pModule->pModuleName,
Tag);
}
else
{
PrefixSize = sprintf(pBuffer->TextBuffer, "%d.%d> %s-%s: ",
GetCurrentProcessId(), GetCurrentThreadId(),
pModule->pModuleName, Tag);
}
}
if ((TotalSize = _vsnprintf(&pBuffer->TextBuffer[PrefixSize],
DEBUG_TEXT_BUFFER_SIZE - PrefixSize,
Format, ArgList)) < 0)
{
//
// Less than zero indicates that the string could not be
// fitted into the buffer. Output a special message indicating
// that:
//
OutputDebugStringA("dsysdbg: Could not pack string into 512 bytes\n");
}
else
{
TotalSize += PrefixSize;
if ((pModule->pHeader->fDebug & DEBUG_NO_DEBUGIO) == 0 )
{
OutputDebugStringA( pBuffer->TextBuffer );
}
if ((pModule->pHeader->fDebug & DEBUG_LOGFILE))
{
if (pModule->pHeader->hLogFile == INVALID_HANDLE_VALUE)
{
DbgpOpenLogFileRandom(pModule->pHeader);
}
WriteFile( pModule->pHeader->hLogFile,
pBuffer->TextBuffer,
(DWORD) TotalSize,
(PDWORD) &PrefixSize,
NULL );
}
pModule->pHeader->TotalWritten += TotalSize;
pModule->TotalOutput += TotalSize;
}
}
if (fLocked)
{
UnlockDebugHeader(pModule->pHeader);
}
DbgpReleaseTextBuffer( pModule->pHeader, pBuffer );
if ( Break )
{
OutputDebugStringA( "BreakOnError\n" );
DebugBreak();
}
}
VOID
_DbgSetOption(
PVOID pControl,
DWORD Option,
BOOL On,
BOOL Global
)
{
PDebugModule pModule;
pModule = (PDebugModule) pControl ;
if ( pModule )
{
if ( Global )
{
pModule = pModule->pHeader->pGlobalModule ;
}
if ( On )
{
pModule->InfoLevel |= Option ;
*pModule->pInfoLevel |= Option ;
}
else
{
pModule->InfoLevel &= (~Option) ;
*pModule->pInfoLevel &= (~Option) ;
}
}
}
VOID
_DbgSetLoggingOption(
PVOID pControl,
BOOL On
)
{
PDebugModule pModule;
pModule = (PDebugModule)pControl;
if ( pModule )
{
if (((pModule->pHeader->fDebug & DEBUG_LOGFILE) == 0) && On )// off, turn it on
{
pModule->pHeader->fDebug |= DEBUG_LOGFILE;
}
else if ((pModule->pHeader->fDebug & DEBUG_LOGFILE) && !On) // on, turn it off
{
pModule->pHeader->fDebug &= (~DEBUG_LOGFILE);
if ( pModule->pHeader->hLogFile != INVALID_HANDLE_VALUE )
{
CloseHandle( pModule->pHeader->hLogFile );
pModule->pHeader->hLogFile = INVALID_HANDLE_VALUE;
}
}
}
}
Reference in a new issue Copy permalink