able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/inetsrv/iis/svcs/dbgext/dbglkrh.cxx

816 lines
20 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1998-1999 Microsoft Corporation
Module Name:
dbglkrh.cxx
Abstract:
LKRhash support
Author:
George V. Reilly (GeorgeRe) 22-Feb-1999
Revision History:
--*/
#include "inetdbgp.h"
#ifdef LOCK_INSTRUMENTATION
LONG CLKRLinearHashTable::CBucket::sm_cBuckets = 0;
LONG CLKRLinearHashTable::sm_cTables = 0;
#endif // LOCK_INSTRUMENTATION
// #define SAMPLE_LKRHASH_TESTCLASS
// #include <lkrhash.h>
// There are several different DLLs in the IISRTL family. This is to
// allow us to set the name of the DLL on the fly.
// TODO: add a command to set this name dynamically.
CHAR g_szIisRtlName[MAX_PATH] = IISRTL_NAME;
// sprintf-formatted string, e.g., "&%s!CLKRHashTable__sm_llGlobalList"
// Has to return LPSTR, not LPCSTR, because GetExpression is not const-correct
LPSTR
IisRtlVar(
LPCSTR pszFormat)
{
// we can get away with a static CHAR[] because debugger extensions
// are single-threaded
static CHAR szSymbol[MAX_SYMBOL_LEN];
sprintf(szSymbol, pszFormat, g_szIisRtlName);
return szSymbol;
}
class CTest
{
public:
enum {BUFFSIZE=20};
int m_n; // This will also be a key
char m_sz[BUFFSIZE]; // This will be the primary key
bool m_fWhatever;
mutable LONG m_cRefs; // Reference count for lifetime management.
// Must be mutable to use 'const CTest*' in
// hashtables
CTest(int n, const char* psz, bool f)
: m_n(n), m_fWhatever(f), m_cRefs(0)
{
strncpy(m_sz, psz, BUFFSIZE-1);
m_sz[BUFFSIZE-1] = '\0';
}
~CTest()
{
IRTLASSERT(m_cRefs == 0);
}
};
BOOL
TestEnum(
IN const void* pvParam,
IN DWORD dwSignature,
IN INT nVerbose)
{
CTest* pTest = (CTest*) pvParam;
CTest tst(0, "", 0);
ReadMemory(pTest, &tst, sizeof(tst), NULL);
dprintf("%8p: %d %s %d %d \n",
pTest, tst.m_n, tst.m_sz, tst.m_fWhatever, tst.m_cRefs);
return TRUE;
}
// Dummy implementations so that we can link
CLKRLinearHashTable::CLKRLinearHashTable(
LPCSTR pszName, // An identifier for debugging
PFnExtractKey pfnExtractKey, // Extract key from record
PFnCalcKeyHash pfnCalcKeyHash, // Calculate hash signature of key
PFnEqualKeys pfnEqualKeys, // Compare two keys
PFnAddRefRecord pfnAddRefRecord,// AddRef in FindKey, etc
double maxload, // Upperbound on average chain length
DWORD initsize, // Initial size of hash table.
DWORD num_subtbls // for signature compatiblity
// with CLKRHashTable
)
#ifdef LKR_NEWCODE
: m_nTableLockType(TableLock::LockType()),
m_nBucketLockType(BucketLock::LockType()),
m_phtParent(NULL)
#endif // LKR_NEWCODE
{}
#ifdef LKR_NEWCODE
CLKRLinearHashTable::CLKRLinearHashTable(
LPCSTR pszName, // An identifier for debugging
PFnExtractKey pfnExtractKey, // Extract key from record
PFnCalcKeyHash pfnCalcKeyHash, // Calculate hash signature of key
PFnEqualKeys pfnEqualKeys, // Compare two keys
PFnAddRefRecord pfnAddRefRecord,// AddRef in FindKey, etc
double maxload, // Upperbound on average chain length
DWORD initsize, // Initial size of hash table.
CLKRHashTable* phtParent // Owning table.
)
: m_nTableLockType(TableLock::LockType()),
m_nBucketLockType(BucketLock::LockType()),
m_phtParent(NULL)
{}
#endif // LKR_NEWCODE
CLKRLinearHashTable::~CLKRLinearHashTable()
{}
CLKRHashTable::CLKRHashTable(
LPCSTR pszName, // An identifier for debugging
PFnExtractKey pfnExtractKey, // Extract key from record
PFnCalcKeyHash pfnCalcKeyHash, // Calculate hash signature of key
PFnEqualKeys pfnEqualKeys, // Compare two keys
PFnAddRefRecord pfnAddRefRecord,// AddRef in FindKey, etc
double maxload, // Upperbound on average chain length
DWORD initsize, // Initial size of hash table.
DWORD num_subtbls // #subordinate hash tables
)
{}
CLKRHashTable::~CLKRHashTable()
{}
/************************************************************
* Dump LKRhash tables
************************************************************/
const char*
LKRC2String(
LK_RETCODE lkrc)
{
const char* psz = NULL;
switch (lkrc)
{
case LK_UNUSABLE:
psz = "LK_UNUSABLE";
break;
case LK_ALLOC_FAIL:
psz = "LK_ALLOC_FAIL";
break;
case LK_BAD_ITERATOR:
psz = "LK_BAD_ITERATOR";
break;
case LK_BAD_RECORD:
psz = "LK_BAD_RECORD";
break;
case LK_BAD_PARAMETERS:
psz = "LK_BAD_PARAMETERS";
break;
case LK_NOT_INITIALIZED:
psz = "LK_NOT_INITIALIZED";
break;
case LK_SUCCESS:
psz = "LK_SUCCESS";
break;
case LK_KEY_EXISTS:
psz = "LK_KEY_EXISTS";
break;
case LK_NO_SUCH_KEY:
psz = "LK_NO_SUCH_KEY";
break;
case LK_NO_MORE_ELEMENTS:
psz = "LK_NO_MORE_ELEMENTS";
break;
default:
psz = "Unknown LK_RETCODE";
break;
}
return psz;
}
BOOL
DefaultLKRhashEnum(
IN const void* pvParam,
IN DWORD dwSignature,
IN INT nVerbose)
{
dprintf("%8p (%08x)\n", pvParam, dwSignature);
return TRUE;
}
typedef CLKRLinearHashTable::CBucket CBucket;
typedef CLKRLinearHashTable::CNodeClump CNodeClump;
typedef CLKRLinearHashTable::CSegment CSegment;
typedef CLKRLinearHashTable::CSmallSegment CSmallSegment;
typedef CLKRLinearHashTable::CMediumSegment CMediumSegment;
typedef CLKRLinearHashTable::CLargeSegment CLargeSegment;
typedef CLKRLinearHashTable::CDirEntry CDirEntry;
enum {
NODES_PER_CLUMP = CNodeClump::NODES_PER_CLUMP,
HASH_INVALID_SIGNATURE = CLKRLinearHashTable::HASH_INVALID_SIGNATURE,
};
BOOL
EnumerateBucketChain(
IN PFN_ENUM_LKRHASH pfnEnum,
IN LOCK_LOCKTYPE ltBucketLockType,
IN CBucket* pbkt,
IN INT nVerbose)
{
PSTR cmdName = "lkrhash";
CBucket bkt;
CNodeClump nc;
CNodeClump* pncCurr;
CNodeClump* pncPrev = NULL;
DWORD cNodes = 0;
ReadMemory(pbkt, &bkt, sizeof(bkt), NULL);
PrintLock(ltBucketLockType, &pbkt->m_Lock, nVerbose);
for (pncCurr = (CNodeClump*) ((PBYTE) pbkt + LockSize(ltBucketLockType));
pncCurr != NULL;
pncPrev = pncCurr, pncCurr = nc.m_pncNext)
{
DWORD i, c;
ReadMemory(pncCurr, &nc, sizeof(nc), NULL);
for (i = c = 0; i < NODES_PER_CLUMP; i++)
{
if (nc.m_dwKeySigs[i] == HASH_INVALID_SIGNATURE)
c++;
}
if (c == NODES_PER_CLUMP)
{
dprintf(" 0-%d: -- empty\n", NODES_PER_CLUMP);
}
else
{
for (i = 0; i < NODES_PER_CLUMP; i++)
{
if (nc.m_dwKeySigs[i] == HASH_INVALID_SIGNATURE)
{
dprintf(" %d: --\n", i);
}
else
{
(*pfnEnum)(nc.m_pvNode[i], nc.m_dwKeySigs[i], nVerbose);
}
}
}
if (CheckControlC())
{
dprintf("\n^C\n");
return FALSE;
}
const DWORD MAX_NODES = 20;
if (++cNodes > MAX_NODES)
{
dprintf("inetdbg.%s: Bucket chain contains more than %d nodes! "
"Corrupted?\n", cmdName, MAX_NODES);
return TRUE;
}
}
return TRUE;
}
BOOL
EnumerateLKRLinearHashTable(
IN PFN_ENUM_LKRHASH pfnEnum,
IN CLKRLinearHashTable* plht,
IN INT nVerbose)
{
PSTR cmdName = "lkrhash";
CLKRLinearHashTable lht(NULL, NULL, NULL, NULL, NULL);
INT i;
BOOL fRet = FALSE;
LOCK_LOCKTYPE ltTableLockType = LOCK_SPINLOCK;
LOCK_LOCKTYPE ltBucketLockType = LOCK_SPINLOCK;
CDirEntry* paDirSegs = NULL;
//
// Read the header, perform some sanity checks.
//
if (!ReadMemory(plht, &lht, sizeof(lht), NULL) )
{
dprintf("inetdbg.%s: cannot read memory @ %p\n",
cmdName, (PVOID)plht);
goto cleanup;
}
dprintf(
"\ninetdbg.%s: @ %p:\n"
" CLKRLinearHashTable Signature = %08lx '%c%c%c%c' (%s), \"%s\",\n"
" State = %d (%s)\n",
cmdName,
plht,
lht.m_dwSignature,
DECODE_SIGNATURE(lht.m_dwSignature),
lht.m_dwSignature == CLKRLinearHashTable::SIGNATURE
? "OK" : (lht.m_dwSignature == CLKRLinearHashTable::SIGNATURE_FREE
? "FREED" : "INVALID"),
lht.m_szName,
lht.m_lkrcState, LKRC2String(lht.m_lkrcState));
if (nVerbose == 0)
goto done;
#ifdef LKR_NEWCODE
ltTableLockType = (LOCK_LOCKTYPE) lht.m_nTableLockType;
ltBucketLockType = (LOCK_LOCKTYPE) lht.m_nBucketLockType;
dprintf(
" TableLock = %s, BucketLock = %s, Parent CLKRHashTable = %p\n",
LockName(ltTableLockType),
LockName(ltBucketLockType),
lht.m_phtParent);
#endif // LKR_NEWCODE
dprintf(
" Size = %d, SegBits = %d, SegSize = %d, SegMask = %x\n",
lht.m_lkts, lht.m_dwSegBits, lht.m_dwSegSize, lht.m_dwSegMask);
dprintf(
" MaxLoad = %3.1f, paDirSegs = %p, cDirSegs = %d\n",
lht.m_MaxLoad, lht.m_paDirSegs, lht.m_cDirSegs);
dprintf(
" cRecords = %d, cActiveBuckets = %d, BucketSpins = %hd\n",
lht.m_cRecords, lht.m_cActiveBuckets, lht.m_wBucketLockSpins);
dprintf(
" nLevel = %d, dwBktAddrMask = %x, iExpansionIdx = %d\n",
lht.m_nLevel, lht.m_dwBktAddrMask, lht.m_iExpansionIdx);
PrintLock(ltTableLockType, &plht->m_Lock, nVerbose);
if (nVerbose == 1)
goto done;
paDirSegs = (CDirEntry*) calloc(lht.m_cDirSegs, sizeof(CDirEntry));
if (paDirSegs == NULL) {
dprintf("Out of memory\n");
goto cleanup;
}
ReadMemory(lht.m_paDirSegs, paDirSegs,
sizeof(CDirEntry) * lht.m_cDirSegs, NULL);
for (i = 0; i < (INT) (lht.m_cDirSegs * lht.m_dwSegSize); i++)
{
const DWORD iSeg = i >> lht.m_dwSegBits;
CLargeSegment* pseg =
static_cast<CLargeSegment*>(paDirSegs[iSeg].m_pseg);
if ((i & lht.m_dwSegMask) == 0)
dprintf("Segment %d: %p\n", iSeg, pseg);
if (pseg == NULL)
continue;
if (nVerbose >= 2)
{
CBucket* const pbkt = pseg->m_bktSlots + (i & lht.m_dwSegMask);
dprintf("Bucket %4d: ", i);
if (!EnumerateBucketChain(pfnEnum, ltBucketLockType,
pbkt, nVerbose))
goto cleanup;
}
if (CheckControlC())
{
dprintf("\n^C\n");
goto cleanup;
}
}
done:
fRet = TRUE;
cleanup:
if (paDirSegs)
free(paDirSegs);
return fRet;
}
BOOL
EnumerateLKRhashTable(
IN PFN_ENUM_LKRHASH pfnEnum,
IN CLKRHashTable* pht,
IN INT nVerbose)
{
CLKRHashTable ht(NULL, NULL, NULL, NULL, NULL);
PSTR cmdName = "lkrhash";
CLKRLinearHashTable** palhtDir = NULL;
UINT i;
BOOL fRet = FALSE;
//
// Read the header, perform some sanity checks.
//
if (!ReadMemory(pht, &ht, sizeof(ht), NULL) )
{
dprintf("inetdbg.%s: cannot read memory @ %p\n",
cmdName, (PVOID)pht);
goto cleanup;
}
dprintf(
"inetdbg.%s: @ %p:\n"
" CLKRHashTable Signature = %08lx '%c%c%c%c' (%s), \"%s\",\n"
" %d subtables, State = %d (%s)\n",
cmdName,
pht,
ht.m_dwSignature,
DECODE_SIGNATURE(ht.m_dwSignature),
ht.m_dwSignature == CLKRHashTable::SIGNATURE
? "OK"
: ht.m_dwSignature == CLKRHashTable::SIGNATURE_FREE
? "FREED"
: "INVALID",
ht.m_szName,
ht.m_cSubTables,
ht.m_lkrcState, LKRC2String(ht.m_lkrcState)
);
if (nVerbose == 0)
goto done;
palhtDir = (CLKRLinearHashTable**) calloc(ht.m_cSubTables,
sizeof(CLKRLinearHashTable*));
if (!palhtDir)
goto cleanup;
if (!ReadMemory(ht.m_palhtDir, palhtDir,
ht.m_cSubTables * sizeof(CLKRLinearHashTable*), NULL))
goto cleanup;
for (i = 0; i < ht.m_cSubTables; ++i)
{
dprintf("%d : ", i);
if (!EnumerateLKRLinearHashTable(pfnEnum, palhtDir[i], nVerbose))
break;
if (CheckControlC())
{
dprintf("\n^C\n");
goto cleanup;
}
}
done:
fRet = TRUE;
cleanup:
free(palhtDir);
return fRet;
}
VOID
PrintLKRLinearHashTableThunk(
PVOID psdDebuggee,
PVOID psdDebugger,
CHAR chVerbosity,
DWORD iThunk)
{
DWORD dwSig = ((CLKRLinearHashTable*) psdDebugger)->m_dwSignature;
if (dwSig != CLKRLinearHashTable::SIGNATURE)
{
dprintf( "CLKRLinearHashTable(%08p) signature %08lx '%c%c%c%c' doesn't"
" match expected: %08lx\n",
psdDebuggee, dwSig, DECODE_SIGNATURE(dwSig),
CLKRLinearHashTable::SIGNATURE
);
return;
}
EnumerateLKRLinearHashTable(DefaultLKRhashEnum,
(CLKRLinearHashTable*) psdDebuggee,
chVerbosity);
}
VOID
PrintLKRHashTableThunk(
PVOID psdDebuggee,
PVOID psdDebugger,
CHAR chVerbosity,
DWORD iThunk)
{
DWORD dwSig = ((CLKRHashTable*) psdDebugger)->m_dwSignature;
if (dwSig != CLKRHashTable::SIGNATURE)
{
dprintf( "CLKRHashTable(%08p) signature %08lx '%c%c%c%c' doesn't"
" match expected: %08lx\n",
psdDebuggee,
dwSig, DECODE_SIGNATURE(dwSig),
CLKRHashTable::SIGNATURE
);
return;
}
EnumerateLKRhashTable(DefaultLKRhashEnum, (CLKRHashTable*) psdDebuggee,
chVerbosity);
}
VOID
DumpLKRsList(
IN INT nVerbose)
{
CLockedDoubleList* plstHashTables = (CLockedDoubleList*) GetExpression(
IisRtlVar("&%s!CLKRHashTable__sm_llGlobalList"));
if (NULL == plstHashTables)
{
dprintf("Unable to get %s\n",
IisRtlVar("%s!CLKRHashTable__sm_llGlobalList"));
return;
}
dprintf("\nGlobal List of CLKRHashTables\n");
EnumLinkedList( (LIST_ENTRY*) &plstHashTables->m_list.m_leHead,
PrintLKRHashTableThunk,
(CHAR) nVerbose,
sizeof(CLKRHashTable),
FIELD_OFFSET( CLKRHashTable, m_leGlobalList)
);
plstHashTables = (CLockedDoubleList*) GetExpression(
IisRtlVar( "&%s!CLKRLinearHashTable__sm_llGlobalList"));
if (NULL == plstHashTables)
{
dprintf("Unable to get %s\n",
IisRtlVar("!CLKRLinearHashTable__sm_llGlobalList"));
return;
}
dprintf("\nGlobal List of CLKRLinearHashTables\n");
EnumLinkedList( (LIST_ENTRY*) &plstHashTables->m_list.m_leHead,
PrintLKRLinearHashTableThunk,
(CHAR) nVerbose,
sizeof(CLKRLinearHashTable),
FIELD_OFFSET( CLKRLinearHashTable, m_leGlobalList)
);
return;
} // DumpLKRsList()
DECLARE_API( lkrhash )
/*++
Routine Description:
This function is called as an NTSD extension to format and dump
an LKRhash table.
Arguments:
hCurrentProcess - Supplies a handle to the current process (at the
time the extension was called).
hCurrentThread - Supplies a handle to the current thread (at the
time the extension was called).
CurrentPc - Supplies the current pc at the time the extension is
called.
lpExtensionApis - Supplies the address of the functions callable
by this extension.
lpArgumentString - Supplies the asciiz string that describes the
ansi string to be dumped.
Return Value:
None.
--*/
{
INIT_API();
ULONG_PTR lkrAddress = 0;
INT nVerbose = 0;
PSTR cmdName = "lkrhash";
//
// Skip leading blanks.
//
while( *lpArgumentString == ' ' ||
*lpArgumentString == '\t' ) {
lpArgumentString++;
}
if( *lpArgumentString == '\0' ) {
PrintUsage( cmdName );
return;
}
if ( *lpArgumentString == '-' )
{
lpArgumentString++;
if ( *lpArgumentString == 'h' )
{
PrintUsage( cmdName );
return;
}
if ( *lpArgumentString == 'l' ) {
lpArgumentString++;
if ('0' <= *lpArgumentString && *lpArgumentString <= '9' ) {
nVerbose = *lpArgumentString++ - '0';
}
}
if ( *lpArgumentString == 'v' )
{
lpArgumentString++;
nVerbose = 99;
}
if ( *lpArgumentString == 'g' )
{
lpArgumentString++;
DumpLKRsList(nVerbose);
return;
}
}
while( *lpArgumentString == ' ' ||
*lpArgumentString == '\t' ) {
lpArgumentString++;
}
lkrAddress = (ULONG_PTR) GetExpression( lpArgumentString );
if (lkrAddress == 0) {
dprintf(
"inetdbg.%s: cannot evaluate \"%s\"\n",
cmdName,
lpArgumentString
);
return;
}
//
// Skip to end of expression, then skip any blanks.
//
while( *lpArgumentString != ' ' &&
*lpArgumentString != '\t' &&
*lpArgumentString != '\0' ) {
lpArgumentString++;
}
DWORD dwSig;
if (!ReadMemory(lkrAddress, &dwSig, sizeof(dwSig), NULL) )
{
dprintf("inetdbg.%s: cannot read memory @ %p\n",
cmdName, (PVOID)lkrAddress);
goto cleanup;
}
if (dwSig == CLKRHashTable::SIGNATURE ||
dwSig == CLKRHashTable::SIGNATURE_FREE)
{
EnumerateLKRhashTable(DefaultLKRhashEnum,
(CLKRHashTable*) lkrAddress,
nVerbose);
}
else if (dwSig == CLKRLinearHashTable::SIGNATURE ||
dwSig == CLKRLinearHashTable::SIGNATURE_FREE)
{
EnumerateLKRLinearHashTable(DefaultLKRhashEnum,
(CLKRLinearHashTable*) lkrAddress,
nVerbose);
}
else
{
dprintf("inetdbg.%s: %p does not contain a valid LKRhash table\n",
cmdName, (PVOID)lkrAddress);
}
cleanup:
return;
} // DECLARE_API( lkrhash )
DECLARE_API( testhash )
{
INIT_API();
ULONG_PTR lkrAddress = 0;
INT nVerbose = 0;
PSTR cmdName = "testhash";
//
// Skip leading blanks.
//
while( *lpArgumentString == ' ' ||
*lpArgumentString == '\t' ) {
lpArgumentString++;
}
if( *lpArgumentString == '\0' ) {
PrintUsage( cmdName );
return;
}
if ( *lpArgumentString == '-' )
{
lpArgumentString++;
if ( *lpArgumentString == 'h' )
{
PrintUsage( cmdName );
return;
}
if ( *lpArgumentString == 'l' ) {
lpArgumentString++;
if ('0' <= *lpArgumentString && *lpArgumentString <= '9' ) {
nVerbose = *lpArgumentString++ - '0';
}
}
}
while( *lpArgumentString == ' ' ||
*lpArgumentString == '\t' ) {
lpArgumentString++;
}
lkrAddress = (ULONG_PTR)GetExpression( lpArgumentString );
if( lkrAddress == 0 ) {
dprintf(
"inetdbg.%s: cannot evaluate \"%s\"\n",
cmdName,
lpArgumentString
);
return;
}
//
// Skip to end of expression, then skip any blanks.
//
while( *lpArgumentString != ' ' &&
*lpArgumentString != '\t' &&
*lpArgumentString != '\0' ) {
lpArgumentString++;
}
EnumerateLKRhashTable(TestEnum,
(CLKRHashTable*) lkrAddress,
nVerbose);
} // DECLARE_API( testhash )
Reference in a new issue Copy permalink