903 lines
21 KiB
C++
903 lines
21 KiB
C++
/*++
|
||
|
||
Copyright (c) 1995-1999 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
dbginet.cxx
|
||
|
||
Abstract:
|
||
|
||
This module contains the default ntsd debugger extensions for
|
||
Internet Information Server
|
||
|
||
Author:
|
||
|
||
Murali R. Krishnan (MuraliK) 16-Sept-1996
|
||
|
||
Revision History:
|
||
|
||
--*/
|
||
|
||
#include "inetdbgp.h"
|
||
|
||
|
||
|
||
/************************************************************
|
||
* Scheduler Related functions
|
||
************************************************************/
|
||
|
||
// Keep this array in synch with the SCHED_ITEM_STATE enumeration
|
||
|
||
char * g_rgchSchedState[] = {
|
||
"SiError",
|
||
"SiIdle",
|
||
"SiActive",
|
||
"SiActivePeriodic",
|
||
"SiCallbackPeriodic",
|
||
"SiToBeDeleted",
|
||
"SiMaxItems"
|
||
};
|
||
|
||
#define LookupSchedState( ItemState ) \
|
||
((((ItemState) >= SI_ERROR) && ((ItemState) <= SI_MAX_ITEMS)) ? \
|
||
g_rgchSchedState[ (ItemState)] : "<Invalid>")
|
||
|
||
|
||
// Initialize class static members
|
||
CSchedData* CSchedData::sm_psd = NULL;
|
||
CLockedDoubleList CSchedData::sm_lstSchedulers;
|
||
LONG CSchedData::sm_nID = 0;
|
||
LONG CThreadData::sm_nID = 1000;
|
||
LONG SCHED_ITEM::sm_lSerialNumber = SCHED_ITEM::SERIAL_NUM_INITIAL_VALUE;
|
||
|
||
|
||
VOID
|
||
PrintSchedItem( SCHED_ITEM * pschDebuggee,
|
||
SCHED_ITEM * pschDebugger,
|
||
CHAR Verbosity);
|
||
|
||
VOID
|
||
PrintThreadDataThunk( PVOID ptdDebuggee,
|
||
PVOID ptdDebugger,
|
||
CHAR chVerbosity,
|
||
DWORD iThunk);
|
||
|
||
VOID
|
||
PrintThreadData( CThreadData* ptdDebuggee,
|
||
CThreadData* ptdDebugger,
|
||
CHAR chVerbosity);
|
||
|
||
VOID
|
||
PrintSchedData( CSchedData* psdDebuggee,
|
||
CSchedData* psdDebugger,
|
||
CHAR chVerbosity);
|
||
|
||
VOID
|
||
PrintSchedDataThunk( PVOID psdDebuggee,
|
||
PVOID psdDebugger,
|
||
CHAR chVerbosity,
|
||
DWORD iThunk);
|
||
|
||
VOID
|
||
DumpSchedItemList(
|
||
CHAR Verbosity
|
||
);
|
||
|
||
VOID
|
||
DumpSchedulersList(
|
||
CHAR Verbosity
|
||
);
|
||
|
||
|
||
|
||
DECLARE_API( sched )
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function is called as an NTSD extension to format and dump
|
||
an object attributes structure.
|
||
|
||
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.
|
||
|
||
--*/
|
||
{
|
||
BOOL fRet;
|
||
SCHED_ITEM sch( NULL, NULL, NULL);
|
||
SCHED_ITEM * psch;
|
||
|
||
INIT_API();
|
||
|
||
while (*lpArgumentString == ' ')
|
||
lpArgumentString++;
|
||
|
||
if ( !*lpArgumentString )
|
||
{
|
||
PrintUsage( "sched" );
|
||
return;
|
||
}
|
||
|
||
if ( *lpArgumentString == '-' )
|
||
{
|
||
lpArgumentString++;
|
||
|
||
if ( *lpArgumentString == 'h' )
|
||
{
|
||
PrintUsage( "sched" );
|
||
return;
|
||
}
|
||
else if ( *lpArgumentString == 'l' )
|
||
{
|
||
DumpSchedItemList( lpArgumentString[1] );
|
||
return;
|
||
}
|
||
else if ( *lpArgumentString == 's' )
|
||
{
|
||
DumpSchedulersList( lpArgumentString[1] );
|
||
return;
|
||
}
|
||
else if ( *lpArgumentString == 'S' )
|
||
{
|
||
CSchedData* psd = (CSchedData*) GetExpression(++lpArgumentString);
|
||
|
||
if ( !psd )
|
||
{
|
||
dprintf( "inetdbg.sched: Unable to evaluate \"%s\"\n",
|
||
lpArgumentString );
|
||
|
||
return;
|
||
}
|
||
|
||
DEFINE_CPP_VAR(CSchedData, sd);
|
||
move(sd, psd);
|
||
|
||
PrintSchedData(psd, GET_CPP_VAR_PTR(CSchedData, sd), '2');
|
||
return;
|
||
}
|
||
else if ( *lpArgumentString == 'T' )
|
||
{
|
||
CThreadData* ptd =(CThreadData*) GetExpression(++lpArgumentString);
|
||
|
||
if ( !ptd )
|
||
{
|
||
dprintf( "inetdbg.sched: Unable to evaluate \"%s\"\n",
|
||
lpArgumentString );
|
||
|
||
return;
|
||
}
|
||
|
||
DEFINE_CPP_VAR(CThreadData, td);
|
||
move(td, ptd);
|
||
|
||
PrintThreadData(ptd, GET_CPP_VAR_PTR(CThreadData, td), '2');
|
||
return;
|
||
}
|
||
} // while
|
||
|
||
//
|
||
// Treat the argument as the address of a SCHED_ITEM
|
||
//
|
||
|
||
psch = (SCHED_ITEM * ) GetExpression( lpArgumentString );
|
||
|
||
if ( !psch )
|
||
{
|
||
dprintf( "inetdbg.sched: Unable to evaluate \"%s\"\n",
|
||
lpArgumentString );
|
||
|
||
return;
|
||
}
|
||
|
||
move( sch, psch );
|
||
PrintSchedItem( psch, &sch, '2' );
|
||
|
||
return;
|
||
} // DECLARE_API( sched )
|
||
|
||
|
||
VOID
|
||
PrintSchedItem( SCHED_ITEM * pschDebuggee,
|
||
SCHED_ITEM * pschDebugger,
|
||
CHAR chVerbosity)
|
||
{
|
||
if ( chVerbosity >= '0' )
|
||
{
|
||
// Print all with one line summary info
|
||
dprintf( "%p: Serial=%-6d Flink=%p, Blink=%p, State=%s\n",
|
||
pschDebuggee,
|
||
pschDebugger->_dwSerialNumber,
|
||
pschDebugger->_ListEntry.Flink,
|
||
pschDebugger->_ListEntry.Blink,
|
||
LookupSchedState( pschDebugger->_siState) );
|
||
}
|
||
|
||
if ( chVerbosity >= '1')
|
||
{
|
||
UCHAR szSymFnCallback[MAX_SYMBOL_LEN];
|
||
ULONG_PTR offset;
|
||
|
||
GetSymbol((ULONG_PTR) pschDebugger->_pfnCallback,
|
||
szSymFnCallback, &offset);
|
||
|
||
if (!*szSymFnCallback)
|
||
sprintf((char*) szSymFnCallback, "%p()",
|
||
pschDebugger->_pfnCallback);
|
||
|
||
dprintf( "\tSignature = '%c%c%c%c' Context = %08p\n"
|
||
"\tmsecInterval = %8d msecExpires = %I64d\n"
|
||
"\tpfnCallBack = %s\n",
|
||
DECODE_SIGNATURE(pschDebugger->_Signature),
|
||
pschDebugger->_pContext,
|
||
pschDebugger->_msecInterval,
|
||
pschDebugger->_msecExpires,
|
||
szSymFnCallback
|
||
);
|
||
}
|
||
|
||
return;
|
||
} // PrintSchedItem()
|
||
|
||
|
||
|
||
VOID
|
||
PrintSchedItemThunk( PVOID pschDebuggee,
|
||
PVOID pschDebugger,
|
||
CHAR chVerbosity,
|
||
DWORD iThunk)
|
||
{
|
||
if ( ((SCHED_ITEM * )pschDebugger)->_Signature != SIGNATURE_SCHED_ITEM) {
|
||
|
||
dprintf( "SCHED_ITEM(%p) signature %08lx doesn't"
|
||
" match expected %08lx\n",
|
||
pschDebuggee,
|
||
((SCHED_ITEM * )pschDebugger)->_Signature,
|
||
SIGNATURE_SCHED_ITEM
|
||
);
|
||
return;
|
||
}
|
||
|
||
PrintSchedItem( (SCHED_ITEM*) pschDebuggee,
|
||
(SCHED_ITEM*) pschDebugger,
|
||
chVerbosity);
|
||
|
||
} // PrintSchedItemThunk()
|
||
|
||
|
||
VOID
|
||
PrintThreadData( CThreadData* ptdDebuggee,
|
||
CThreadData* ptdDebugger,
|
||
CHAR chVerbosity)
|
||
{
|
||
if ( chVerbosity >= '0' )
|
||
{
|
||
// Print all with one line summary info
|
||
dprintf( "CThreadData %p: ID=%-6d, Flink=%p, Blink=%p\n",
|
||
ptdDebuggee,
|
||
ptdDebugger->m_nID,
|
||
ptdDebugger->m_leThreads.Flink,
|
||
ptdDebugger->m_leThreads.Blink
|
||
);
|
||
}
|
||
|
||
if ( chVerbosity >= '1')
|
||
{
|
||
dprintf( "\tm_dwSignature = '%c%c%c%c' m_psdOwner = %08lp\n"
|
||
"\tm_hevtShutdown = %08lp m_hThreadSelf = %08lx.\n"
|
||
,
|
||
DECODE_SIGNATURE(ptdDebugger->m_dwSignature),
|
||
ptdDebugger->m_psdOwner,
|
||
ptdDebugger->m_hevtShutdown,
|
||
ptdDebugger->m_hThreadSelf
|
||
);
|
||
}
|
||
|
||
return;
|
||
} // PrintThreadData()
|
||
|
||
|
||
|
||
VOID
|
||
PrintThreadDataThunk( PVOID ptdDebuggee,
|
||
PVOID ptdDebugger,
|
||
CHAR chVerbosity,
|
||
DWORD iThunk)
|
||
{
|
||
if (((CThreadData*) ptdDebugger)->m_dwSignature != SIGNATURE_THREADDATA)
|
||
{
|
||
dprintf( "CThreadData(%08p) signature %08lx doesn't"
|
||
" match expected: %08lx\n",
|
||
ptdDebuggee,
|
||
((CThreadData * )ptdDebugger)->m_dwSignature,
|
||
SIGNATURE_THREADDATA
|
||
);
|
||
return;
|
||
}
|
||
|
||
PrintThreadData( (CThreadData *) ptdDebuggee,
|
||
(CThreadData *) ptdDebugger,
|
||
chVerbosity);
|
||
|
||
} // PrintThreadDataThunk()
|
||
|
||
|
||
VOID
|
||
PrintSchedData( CSchedData* psdDebuggee,
|
||
CSchedData* psdDebugger,
|
||
CHAR chVerbosity)
|
||
{
|
||
if ( chVerbosity >= '0' )
|
||
{
|
||
// Print all with one line summary info
|
||
dprintf( "CSchedData %p: ID=%d, Flink=%p, Blink=%p\n",
|
||
psdDebuggee,
|
||
psdDebugger->m_nID,
|
||
psdDebugger->m_leGlobalList.Flink,
|
||
psdDebugger->m_leGlobalList.Blink
|
||
);
|
||
}
|
||
|
||
if ( chVerbosity >= '1')
|
||
{
|
||
dprintf( "\tm_dwSignature = '%c%c%c%c' m_lstItems = %08lp\n"
|
||
"\tm_lstThreads = %08lp m_cRefs = %d\n"
|
||
"\tm_hevtNotify = %08lp m_fShutdown = %s\n"
|
||
"\tm_pachSchedItems= %08lp\n"
|
||
,
|
||
DECODE_SIGNATURE(psdDebugger->m_dwSignature),
|
||
&psdDebuggee->m_lstItems,
|
||
&psdDebuggee->m_lstThreads,
|
||
psdDebugger->m_cRefs,
|
||
psdDebugger->m_hevtNotify,
|
||
BoolValue(psdDebugger->m_fShutdown),
|
||
psdDebugger->m_pachSchedItems
|
||
);
|
||
}
|
||
|
||
if ( chVerbosity >= '2')
|
||
{
|
||
dprintf("Threads\n");
|
||
|
||
EnumLinkedList((LIST_ENTRY*)&psdDebuggee->m_lstThreads.m_list.m_leHead,
|
||
PrintThreadDataThunk,
|
||
chVerbosity,
|
||
sizeof(CThreadData),
|
||
FIELD_OFFSET( CThreadData, m_leThreads)
|
||
);
|
||
}
|
||
|
||
return;
|
||
} // PrintSchedData()
|
||
|
||
|
||
|
||
VOID
|
||
PrintSchedDataThunk( PVOID psdDebuggee,
|
||
PVOID psdDebugger,
|
||
CHAR chVerbosity,
|
||
DWORD iThunk)
|
||
{
|
||
if (((CSchedData*) psdDebugger)->m_dwSignature != SIGNATURE_SCHEDDATA)
|
||
{
|
||
dprintf( "CSchedData(%08p) signature %08lx doesn't"
|
||
" match expected: %08lx\n",
|
||
psdDebuggee,
|
||
((CSchedData*) psdDebugger)->m_dwSignature,
|
||
SIGNATURE_SCHEDDATA
|
||
);
|
||
return;
|
||
}
|
||
|
||
PrintSchedData( (CSchedData*) psdDebuggee,
|
||
(CSchedData*) psdDebugger,
|
||
chVerbosity);
|
||
|
||
} // PrintSchedDataThunk()
|
||
|
||
|
||
|
||
|
||
VOID
|
||
DumpSchedItemList(
|
||
CHAR Verbosity
|
||
)
|
||
{
|
||
CSchedData** ppsd = (CSchedData**) GetExpression(
|
||
IisRtlVar("&%s!CSchedData__sm_psd"));
|
||
if (NULL == ppsd)
|
||
{
|
||
dprintf("Unable to get %s\n", IisRtlVar("&%s!CSchedData__sm_psd"));
|
||
return;
|
||
}
|
||
|
||
CSchedData* psd;
|
||
move(psd, ppsd);
|
||
|
||
DEFINE_CPP_VAR( CSchedData, sd);
|
||
move(sd, psd);
|
||
|
||
PrintSchedData(psd, GET_CPP_VAR_PTR(CSchedData, sd), Verbosity);
|
||
dprintf("\n");
|
||
|
||
EnumLinkedList( (LIST_ENTRY*) &psd->m_lstItems.m_list.m_leHead,
|
||
PrintSchedItemThunk,
|
||
Verbosity,
|
||
sizeof( SCHED_ITEM),
|
||
FIELD_OFFSET( SCHED_ITEM, _ListEntry)
|
||
);
|
||
return;
|
||
} // DumpSchedItemList()
|
||
|
||
|
||
|
||
VOID
|
||
DumpSchedulersList(
|
||
CHAR Verbosity
|
||
)
|
||
{
|
||
CLockedDoubleList* plstSchedulers = (CLockedDoubleList*) GetExpression(
|
||
IisRtlVar("&%s!CSchedData__sm_lstSchedulers"));
|
||
|
||
if (NULL == plstSchedulers)
|
||
{
|
||
dprintf("Unable to get %s\n",
|
||
IisRtlVar("&%s!CSchedData__sm_lstSchedulers"));
|
||
return;
|
||
}
|
||
|
||
EnumLinkedList( (LIST_ENTRY*) &plstSchedulers->m_list.m_leHead,
|
||
PrintSchedDataThunk,
|
||
Verbosity,
|
||
sizeof(CSchedData),
|
||
FIELD_OFFSET( CSchedData, m_leGlobalList)
|
||
);
|
||
return;
|
||
} // DumpSchedulersList()
|
||
|
||
|
||
|
||
|
||
/************************************************************
|
||
* Allocation cache Related functions
|
||
************************************************************/
|
||
|
||
ALLOC_CACHE_HANDLER::ALLOC_CACHE_HANDLER(
|
||
IN LPCSTR pszName,
|
||
IN const ALLOC_CACHE_CONFIGURATION * pacConfig)
|
||
{}
|
||
|
||
ALLOC_CACHE_HANDLER::~ALLOC_CACHE_HANDLER(VOID)
|
||
{}
|
||
|
||
|
||
VOID
|
||
PrintAcacheHandler( IN ALLOC_CACHE_HANDLER * pachDebuggee,
|
||
IN ALLOC_CACHE_HANDLER * pachDebugger,
|
||
IN CHAR chVerbostity);
|
||
|
||
VOID
|
||
DumpAcacheGlobals( VOID );
|
||
|
||
|
||
VOID
|
||
DumpAcacheList(
|
||
CHAR Verbosity
|
||
);
|
||
|
||
|
||
DECLARE_API( acache )
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function is called as an NTSD extension to format and dump
|
||
an object attributes structure.
|
||
|
||
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.
|
||
|
||
--*/
|
||
{
|
||
BOOL fRet;
|
||
ALLOC_CACHE_HANDLER * pach;
|
||
|
||
//
|
||
// Since ALLOC_CACHE_HANDLER is a C++ object with a non-void
|
||
// constructor, we will have to copy the contents to a temporary
|
||
// buffer and cast the value appropriately.
|
||
//
|
||
CHAR achItem[sizeof(ALLOC_CACHE_HANDLER)];
|
||
ALLOC_CACHE_HANDLER * pachCopy = (ALLOC_CACHE_HANDLER *) achItem;
|
||
|
||
INIT_API();
|
||
|
||
while (*lpArgumentString == ' ')
|
||
lpArgumentString++;
|
||
|
||
if ( !*lpArgumentString )
|
||
{
|
||
PrintUsage( "acache" );
|
||
return;
|
||
}
|
||
|
||
if ( *lpArgumentString == '-' )
|
||
{
|
||
lpArgumentString++;
|
||
|
||
if ( *lpArgumentString == 'h' )
|
||
{
|
||
PrintUsage( "acache" );
|
||
return;
|
||
}
|
||
|
||
if ( *lpArgumentString == 'g' )
|
||
{
|
||
DumpAcacheGlobals();
|
||
return;
|
||
}
|
||
|
||
if ( *lpArgumentString == 'l' ) {
|
||
|
||
DumpAcacheList( lpArgumentString[1] );
|
||
return;
|
||
}
|
||
|
||
} // while
|
||
|
||
//
|
||
// Treat the argument as the address of an AtqContext
|
||
//
|
||
|
||
dprintf( "inetdbg.acache: Trying to access %s\n",
|
||
lpArgumentString );
|
||
|
||
pach = (ALLOC_CACHE_HANDLER * ) GetExpression( lpArgumentString );
|
||
|
||
if ( !pach )
|
||
{
|
||
dprintf( "inetdbg.acache: Unable to evaluate \"%s\"\n",
|
||
lpArgumentString );
|
||
|
||
return;
|
||
}
|
||
|
||
moveBlock( achItem, pach, sizeof(ALLOC_CACHE_HANDLER));
|
||
PrintAcacheHandler( pach, pachCopy, '2' );
|
||
|
||
return;
|
||
} // DECLARE_API( acache )
|
||
|
||
|
||
VOID
|
||
PrintAcacheHandler( ALLOC_CACHE_HANDLER * pachDebuggee,
|
||
ALLOC_CACHE_HANDLER * pachDebugger,
|
||
CHAR chVerbosity)
|
||
{
|
||
if ( chVerbosity >= '0') {
|
||
dprintf(
|
||
"ACACHE[%8p] "
|
||
, pachDebuggee
|
||
);
|
||
dstring( "Name", (PVOID) pachDebugger->m_pszName, 40);
|
||
}
|
||
|
||
if ( chVerbosity >= '1') {
|
||
dprintf("\t(Size=%d bytes, Concurrency=%d, Threshold=%u)"
|
||
" FillPattern=%08lX\n"
|
||
"\tTotal=%d."
|
||
" Calls:(Alloc=%d, Free=%d)"
|
||
" FreeEntries=%d. Heap=%p.\n"
|
||
,
|
||
pachDebugger->m_acConfig.cbSize,
|
||
pachDebugger->m_acConfig.nConcurrency,
|
||
pachDebugger->m_acConfig.nThreshold,
|
||
pachDebugger->m_nFillPattern,
|
||
pachDebugger->m_nTotal,
|
||
pachDebugger->m_nAllocCalls, pachDebugger->m_nFreeCalls,
|
||
pachDebugger->m_nFreeEntries, pachDebugger->m_hHeap
|
||
);
|
||
}
|
||
|
||
return;
|
||
} // PrintAcacheHandler()
|
||
|
||
VOID
|
||
PrintAcacheHandlerThunk( PVOID pachDebuggee,
|
||
PVOID pachDebugger,
|
||
CHAR chVerbosity,
|
||
DWORD iCount)
|
||
{
|
||
dprintf( "[%d] ", iCount);
|
||
PrintAcacheHandler( (ALLOC_CACHE_HANDLER *) pachDebuggee,
|
||
(ALLOC_CACHE_HANDLER *) pachDebugger,
|
||
chVerbosity);
|
||
return;
|
||
} // PrintAcacheHandlerThunk()
|
||
|
||
VOID
|
||
DumpAcacheGlobals( VOID )
|
||
{
|
||
LIST_ENTRY * pachList;
|
||
LIST_ENTRY achList;
|
||
|
||
dprintf("Allocation Cache Globals:\n");
|
||
|
||
pachList = (LIST_ENTRY *)
|
||
GetExpression( IisRtlVar("&%s!ALLOC_CACHE_HANDLER__sm_lItemsHead"));
|
||
|
||
if ( NULL == pachList) {
|
||
|
||
dprintf( " Unable to get Allocation cache list object, %s\n",
|
||
IisRtlVar("&%s!ALLOC_CACHE_HANDLER__sm_lItemsHead"));
|
||
return;
|
||
}
|
||
|
||
move( achList, pachList);
|
||
|
||
dprintf( " AllocCacheList Flink = %08p Blink = %08p\n",
|
||
achList.Flink, achList.Blink
|
||
);
|
||
|
||
dprintf("\tsizeof(ALLOC_CACHE_HANDLER) = %d\n",
|
||
sizeof(ALLOC_CACHE_HANDLER));
|
||
return;
|
||
} // DumpAcacheGlobals()
|
||
|
||
|
||
|
||
|
||
VOID
|
||
DumpAcacheList(
|
||
CHAR Verbosity
|
||
)
|
||
{
|
||
LIST_ENTRY * pachListHead;
|
||
|
||
pachListHead = (LIST_ENTRY *)
|
||
GetExpression( IisRtlVar("&%s!ALLOC_CACHE_HANDLER__sm_lItemsHead"));
|
||
|
||
if ( NULL == pachListHead) {
|
||
|
||
dprintf( " Unable to get Alloc Cache List object, %s\n",
|
||
IisRtlVar("&%s!ALLOC_CACHE_HANDLER__sm_lItemsHead"));
|
||
return;
|
||
}
|
||
|
||
EnumLinkedList( pachListHead, PrintAcacheHandlerThunk, Verbosity,
|
||
sizeof( ALLOC_CACHE_HANDLER),
|
||
FIELD_OFFSET( ALLOC_CACHE_HANDLER, m_lItemsEntry)
|
||
);
|
||
return;
|
||
} // DumpAcacheList()
|
||
|
||
|
||
|
||
|
||
/************************************************************
|
||
* Dump Symbols from stack
|
||
************************************************************/
|
||
|
||
|
||
DECLARE_API( ds )
|
||
|
||
/*++
|
||
|
||
Routine Description:
|
||
|
||
This function is called as an NTSD extension to format and dump
|
||
symbols on the stack.
|
||
|
||
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.
|
||
|
||
--*/
|
||
|
||
{
|
||
ULONG_PTR startingAddress;
|
||
ULONG_PTR stack;
|
||
DWORD i;
|
||
UCHAR symbol[MAX_SYMBOL_LEN];
|
||
ULONG_PTR offset;
|
||
PCHAR format;
|
||
BOOL validSymbolsOnly = FALSE;
|
||
MODULE_INFO moduleInfo;
|
||
|
||
|
||
INIT_API();
|
||
|
||
//
|
||
// Skip leading blanks.
|
||
//
|
||
|
||
while( *lpArgumentString == ' ' ) {
|
||
lpArgumentString++;
|
||
}
|
||
|
||
if( *lpArgumentString == '-' ) {
|
||
lpArgumentString++;
|
||
switch( *lpArgumentString ) {
|
||
case 'v' :
|
||
case 'V' :
|
||
validSymbolsOnly = TRUE;
|
||
lpArgumentString++;
|
||
break;
|
||
|
||
default :
|
||
PrintUsage( "ds" );
|
||
return;
|
||
}
|
||
}
|
||
|
||
while( *lpArgumentString == ' ' ) {
|
||
lpArgumentString++;
|
||
}
|
||
|
||
//
|
||
// By default, start at the current stack location. Otherwise,
|
||
// start at the given address.
|
||
//
|
||
|
||
if( !*lpArgumentString ) {
|
||
#if defined(_X86_)
|
||
lpArgumentString = "esp";
|
||
#elif defined(_AMD64_)
|
||
lpArgumentString = "rsp";
|
||
#elif defined(_IA64_)
|
||
lpArgumentString = "sp";
|
||
#else
|
||
#error "unsupported CPU"
|
||
#endif
|
||
}
|
||
|
||
startingAddress = GetExpression( lpArgumentString );
|
||
|
||
if( startingAddress == 0 ) {
|
||
|
||
dprintf(
|
||
"!inetdbg.ds: cannot evaluate \"%s\"\n",
|
||
lpArgumentString
|
||
);
|
||
|
||
return;
|
||
|
||
}
|
||
|
||
//
|
||
// Ensure startingAddress is DWORD aligned.
|
||
//
|
||
|
||
startingAddress &= ~(sizeof(ULONG_PTR)-1);
|
||
|
||
//
|
||
// Read the stack.
|
||
//
|
||
|
||
for( i = 0 ; i < NUM_STACK_SYMBOLS_TO_DUMP ; startingAddress += sizeof(ULONG_PTR) ) {
|
||
|
||
if( CheckControlC() ) {
|
||
break;
|
||
}
|
||
|
||
if( ReadMemory(
|
||
startingAddress,
|
||
&stack,
|
||
sizeof(stack),
|
||
NULL
|
||
) ) {
|
||
|
||
GetSymbol(
|
||
stack,
|
||
symbol,
|
||
&offset
|
||
);
|
||
|
||
if( symbol[0] == '\0' ) {
|
||
if( FindModuleByAddress(
|
||
stack,
|
||
&moduleInfo
|
||
) ) {
|
||
strcpy( (CHAR *)symbol, moduleInfo.FullName );
|
||
offset = DIFF(stack - moduleInfo.DllBase);
|
||
}
|
||
}
|
||
|
||
if( symbol[0] == '\0' ) {
|
||
if( validSymbolsOnly ) {
|
||
continue;
|
||
}
|
||
format = "%p : %p\n";
|
||
} else
|
||
if( offset == 0 ) {
|
||
format = "%p : %p : %s\n";
|
||
} else {
|
||
format = "%p : %p : %s+0x%lx\n";
|
||
}
|
||
|
||
dprintf(
|
||
format,
|
||
startingAddress,
|
||
stack,
|
||
symbol,
|
||
(DWORD)offset
|
||
);
|
||
|
||
i++;
|
||
|
||
} else {
|
||
|
||
dprintf(
|
||
"!inetdbg.ds: cannot read memory @ %p\n",
|
||
startingAddress
|
||
);
|
||
|
||
return;
|
||
|
||
}
|
||
|
||
}
|
||
|
||
dprintf(
|
||
"!inetdbg.ds %s%lx to dump next block\n",
|
||
validSymbolsOnly ? "-v " : "",
|
||
startingAddress
|
||
);
|
||
|
||
} // DECLARE_API( ds )
|