1933 lines
53 KiB
C
1933 lines
53 KiB
C
/*++
|
|
|
|
Copyright (c) 1990 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
kdcn.c
|
|
|
|
Abstract:
|
|
|
|
Clustner Xport KD extension - based on Vert's skeleton
|
|
|
|
Author:
|
|
|
|
John Vert (jvert) 6-Aug-1992
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
//
|
|
// globals
|
|
//
|
|
|
|
EXT_API_VERSION ApiVersion = { 5, 0, EXT_API_VERSION_NUMBER, 0 };
|
|
WINDBG_EXTENSION_APIS ExtensionApis;
|
|
USHORT SavedMajorVersion;
|
|
USHORT SavedMinorVersion;
|
|
|
|
CHAR igrepLastPattern[256];
|
|
DWORD igrepSearchStartAddress;
|
|
DWORD igrepLastPc;
|
|
|
|
PCHAR EventTypes[] = {
|
|
"", // used if the number is out of range
|
|
"Node Up",
|
|
"Node Down",
|
|
"Poison Packet Received",
|
|
"Halt",
|
|
"Net IF Up",
|
|
"Net IF Unreachable",
|
|
"Net IF Failed",
|
|
"(not used)",
|
|
"Add Address",
|
|
"Delete Address"
|
|
};
|
|
|
|
PCHAR NetObjState[] = {
|
|
"Offline",
|
|
"OfflinePending",
|
|
"Partitioned",
|
|
"OnlinePending",
|
|
"Online"
|
|
};
|
|
|
|
PCHAR NodeObjCommState[] = {
|
|
"Offline",
|
|
"OfflinePending",
|
|
"Unreachable",
|
|
"OnlinePending",
|
|
"Online"
|
|
};
|
|
|
|
PCHAR NodeObjMemberState[] = {
|
|
"Alive",
|
|
"Joining",
|
|
"Dead",
|
|
"Not Configured"
|
|
};
|
|
|
|
PCHAR InterfaceState[] = {
|
|
"Offline",
|
|
"OfflinePending",
|
|
"Unreachable",
|
|
"OnlinePending",
|
|
"Online"
|
|
};
|
|
|
|
PCHAR CcmpMessageTypes[] = {
|
|
"Invalid",
|
|
"Heartbeat",
|
|
"Poison",
|
|
"Membership"
|
|
};
|
|
|
|
#define TrueOrFalse( _x ) ( _x ? "True" : "False" )
|
|
|
|
/* forwards */
|
|
|
|
VOID
|
|
DumpEventData(
|
|
PCLUSNET_EVENT_ENTRY EventAddress,
|
|
PCLUSNET_EVENT_ENTRY EventEntry
|
|
);
|
|
|
|
VOID
|
|
DumpInterfaceObj(
|
|
PCNP_INTERFACE TargetIfObj,
|
|
PCNP_INTERFACE LocalIfObj
|
|
);
|
|
|
|
BOOL
|
|
ReadNodeTable(
|
|
PCNP_NODE **LocalNodeTable,
|
|
CL_NODE_ID *MaxNodeId,
|
|
CL_NODE_ID *MinNodeId
|
|
);
|
|
|
|
VOID
|
|
DumpNodeObjFlags(
|
|
ULONG Flags
|
|
);
|
|
|
|
VOID
|
|
DumpNetObjFlags(
|
|
ULONG Flag
|
|
);
|
|
|
|
BOOL
|
|
ReadTargetMemory(
|
|
PVOID TargetAddress,
|
|
PVOID LocalBuffer,
|
|
ULONG BytesToRead
|
|
);
|
|
|
|
__inline PCHAR
|
|
ListInUse(
|
|
PLIST_ENTRY ListHead,
|
|
PLIST_ENTRY ListToCheck
|
|
);
|
|
|
|
__inline PCHAR
|
|
TrueFalse(
|
|
BOOLEAN Value
|
|
);
|
|
|
|
VOID
|
|
DprintUnicodeString(
|
|
PUNICODE_STRING String,
|
|
DWORD_PTR AddrString,
|
|
PCHAR Symbol OPTIONAL,
|
|
DWORD_PTR Displacement OPTIONAL
|
|
);
|
|
|
|
#if 0
|
|
VOID
|
|
DumpRGPCounters(
|
|
rgp_counter_t *counters
|
|
);
|
|
|
|
VOID
|
|
DumpClusterMask(
|
|
PCHAR Title,
|
|
cluster_t *
|
|
);
|
|
|
|
VOID
|
|
DumpRGPOSSpecific(
|
|
OS_specific_rgp_control_t *Target_rgpos,
|
|
OS_specific_rgp_control_t *Local_rgpos
|
|
);
|
|
#endif
|
|
|
|
/* end forwards */
|
|
|
|
DllInit(
|
|
HANDLE hModule,
|
|
DWORD dwReason,
|
|
DWORD dwReserved
|
|
)
|
|
{
|
|
switch (dwReason) {
|
|
case DLL_THREAD_ATTACH:
|
|
break;
|
|
|
|
case DLL_THREAD_DETACH:
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
|
|
case DLL_PROCESS_ATTACH:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
WinDbgExtensionDllInit(
|
|
PWINDBG_EXTENSION_APIS lpExtensionApis,
|
|
USHORT MajorVersion,
|
|
USHORT MinorVersion
|
|
)
|
|
{
|
|
ExtensionApis = *lpExtensionApis;
|
|
|
|
SavedMajorVersion = MajorVersion;
|
|
SavedMinorVersion = MinorVersion;
|
|
|
|
return;
|
|
}
|
|
|
|
DECLARE_API( version )
|
|
{
|
|
#if DBG
|
|
PCHAR DebuggerType = "Checked";
|
|
#else
|
|
PCHAR DebuggerType = "Free";
|
|
#endif
|
|
|
|
dprintf("%s Extension dll for Build %d debugging %s clusnet for Build %d\n",
|
|
DebuggerType,
|
|
VER_PRODUCTBUILD,
|
|
SavedMajorVersion == 0x0c ? "Checked" : "Free",
|
|
SavedMinorVersion
|
|
);
|
|
}
|
|
|
|
VOID
|
|
CheckVersion(
|
|
VOID
|
|
)
|
|
{
|
|
PVOID cnDebugAddr;
|
|
|
|
cnDebugAddr = (PVOID)GetExpression( "clusnet!cndebug" );
|
|
|
|
#if DBG
|
|
if ( cnDebugAddr == NULL ) {
|
|
dprintf("\r\nYou MUST use the checked built KDCN with the checked built driver!!!\n\n");
|
|
}
|
|
|
|
if ((SavedMajorVersion != 0x0c) || (SavedMinorVersion != VER_PRODUCTBUILD)) {
|
|
dprintf("\r\n*** Extension DLL(%d Checked) does not match target system(%d %s)\r\n\r\n",
|
|
VER_PRODUCTBUILD, SavedMinorVersion, (SavedMajorVersion==0x0f) ? "Free" : "Checked" );
|
|
}
|
|
#else
|
|
if ( cnDebugAddr != NULL ) {
|
|
dprintf("\r\nYou MUST use the free built KDCN with the free built driver!!!\n\n");
|
|
}
|
|
if ((SavedMajorVersion != 0x0f) || (SavedMinorVersion != VER_PRODUCTBUILD)) {
|
|
dprintf("\r\n*** Extension DLL(%d Free) does not match target system(%d %s)\r\n\r\n",
|
|
VER_PRODUCTBUILD, SavedMinorVersion, (SavedMajorVersion==0x0f) ? "Free" : "Checked" );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
LPEXT_API_VERSION
|
|
ExtensionApiVersion(
|
|
VOID
|
|
)
|
|
{
|
|
return &ApiVersion;
|
|
}
|
|
|
|
DECLARE_API( ustr )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This function is called as a KD extension to format and dump
|
|
counted unicode string.
|
|
|
|
Arguments:
|
|
|
|
see wdbgexts.h
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
UNICODE_STRING UnicodeString;
|
|
DWORD_PTR dwAddrString;
|
|
CHAR Symbol[64];
|
|
DWORD_PTR Displacement;
|
|
BOOL b;
|
|
|
|
//
|
|
// Evaluate the argument string to get the address of
|
|
// the string to dump.
|
|
//
|
|
|
|
dwAddrString = GetExpression(args);
|
|
if ( !dwAddrString ) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Get the symbolic name of the string
|
|
//
|
|
|
|
GetSymbol((LPVOID)dwAddrString,Symbol,&Displacement);
|
|
|
|
//
|
|
// Read the string from the debuggees address space into our
|
|
// own.
|
|
|
|
b = ReadMemory(dwAddrString, &UnicodeString, sizeof(UnicodeString), NULL);
|
|
|
|
if ( !b ) {
|
|
return;
|
|
}
|
|
|
|
DprintUnicodeString(&UnicodeString, dwAddrString, Symbol, Displacement);
|
|
|
|
} // ustr
|
|
|
|
DECLARE_API( netobj )
|
|
/*
|
|
* dump the specified clusnet network object structure or all if no
|
|
* arg is specified
|
|
*/
|
|
{
|
|
PCNP_NETWORK TargetNetObj;
|
|
CNP_NETWORK LocalNetObj;
|
|
PCNP_NETWORK LastNetObj;
|
|
LIST_ENTRY LocalListHead;
|
|
PLIST_ENTRY TargetListHead;
|
|
BOOLEAN DumpAllNetObjs = FALSE;
|
|
|
|
if ( *args == '\0' ) {
|
|
|
|
//
|
|
// run down the network object list, dumping the contents of each one
|
|
//
|
|
TargetListHead = (PLIST_ENTRY)GetExpression( "clusnet!cnpnetworklist" );
|
|
if ( !TargetListHead ) {
|
|
dprintf("Can't convert clusnet!cnpnetworklist symbol\n");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read network object listhead out of target's memory
|
|
//
|
|
if ( !ReadTargetMemory( TargetListHead, &LocalListHead, sizeof(LIST_ENTRY))) {
|
|
|
|
dprintf("Can't get CnpNetworkList data\n");
|
|
return;
|
|
}
|
|
|
|
TargetNetObj = (PCNP_NETWORK)LocalListHead.Flink;
|
|
LastNetObj = (PCNP_NETWORK)TargetListHead;
|
|
DumpAllNetObjs = TRUE;
|
|
|
|
} else {
|
|
|
|
TargetNetObj = (PCNP_NETWORK)GetExpression( args );
|
|
if ( !TargetNetObj ) {
|
|
dprintf("bad string conversion (%s) \n", args );
|
|
return;
|
|
}
|
|
|
|
LastNetObj = 0;
|
|
}
|
|
|
|
while ( TargetNetObj != LastNetObj ) {
|
|
|
|
if (CheckControlC()) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read network object struct out of target's memory
|
|
//
|
|
TargetNetObj = CONTAINING_RECORD( TargetNetObj, CNP_NETWORK, Linkage );
|
|
if ( !ReadTargetMemory( TargetNetObj, &LocalNetObj, sizeof( CNP_NETWORK ))) {
|
|
dprintf("Problem reading net obj at %p\n", TargetNetObj );
|
|
return;
|
|
}
|
|
|
|
#if DBG
|
|
if ( LocalNetObj.Signature != CNP_NETWORK_SIG ) {
|
|
dprintf( "CNP_NETWORK @ %p has the wrong signature\n", TargetNetObj );
|
|
}
|
|
#endif
|
|
|
|
dprintf( "\nNetObj @ %p\n\n", TargetNetObj );
|
|
dprintf( " Next NetObj @ %p\n", LocalNetObj.Linkage.Flink );
|
|
|
|
dprintf( " ID = %d\n", LocalNetObj.Id );
|
|
dprintf( " Lock @ %p\n", &TargetNetObj->Lock );
|
|
dprintf( " Irql = %d\n", LocalNetObj.Irql );
|
|
dprintf( " RefCount = %d\n", LocalNetObj.RefCount );
|
|
dprintf( " Active RefCount = %d\n", LocalNetObj.ActiveRefCount );
|
|
dprintf( " State = %s\n", NetObjState [ LocalNetObj.State ]);
|
|
DumpNetObjFlags( LocalNetObj.Flags );
|
|
dprintf( " Priority = %d\n", LocalNetObj.Priority );
|
|
dprintf( " DatagramHandle @ %p\n", LocalNetObj.DatagramHandle );
|
|
dprintf( " Datagram File Obj @ %p\n", LocalNetObj.DatagramFileObject );
|
|
dprintf( " Datagram Device Obj @ %p\n", LocalNetObj.DatagramDeviceObject );
|
|
dprintf( " TDI provider info @ %p\n", &TargetNetObj->ProviderInfo );
|
|
dprintf( " Current mcast group @ %p\n", LocalNetObj.CurrentMcastGroup );
|
|
dprintf( " Previous mcast group @ %p\n", LocalNetObj.PreviousMcastGroup );
|
|
dprintf( " Multicast reachable node set = %lx\n", LocalNetObj.McastReachableNodes);
|
|
dprintf( " Multicast reachable node count = %d\n", LocalNetObj.McastReachableCount);
|
|
dprintf( " Pending Delete IRP @ %p\n", LocalNetObj.PendingDeleteIrp );
|
|
dprintf( " Pending Offline IRP @ %p\n", LocalNetObj.PendingOfflineIrp );
|
|
dprintf( " Work Q Item @ %p\n", &TargetNetObj->ExWorkItem );
|
|
|
|
if ( !DumpAllNetObjs ) {
|
|
break;
|
|
} else {
|
|
TargetNetObj = (PCNP_NETWORK)LocalNetObj.Linkage.Flink;
|
|
}
|
|
}
|
|
} // netobj
|
|
|
|
VOID
|
|
DumpNetObjFlags(
|
|
ULONG Flags
|
|
)
|
|
{
|
|
dprintf(" Flags = %08X (", Flags );
|
|
if ( Flags & CNP_NET_FLAG_DELETING )
|
|
dprintf(" Deleting" );
|
|
if ( Flags & CNP_NET_FLAG_PARTITIONED )
|
|
dprintf(" Partitioned" );
|
|
if ( Flags & CNP_NET_FLAG_RESTRICTED )
|
|
dprintf(" Restricted" );
|
|
if ( Flags & CNP_NET_FLAG_LOCALDISCONN ) {
|
|
dprintf(" Local-Disconnect" );
|
|
}
|
|
if ( Flags & CNP_NET_FLAG_MULTICAST ) {
|
|
dprintf(" Multicast-Enabled" );
|
|
}
|
|
dprintf(")\n");
|
|
}
|
|
|
|
DECLARE_API( nodeobj )
|
|
/*
|
|
* if no arg, run down the node table, dumping each clusnet node object
|
|
* structure. otherwise, dump the indicated node obj
|
|
*/
|
|
{
|
|
PCNP_NODE TargetNodeObj;
|
|
CNP_NODE LocalNodeObj;
|
|
PCNP_NODE *LocalNodeTable = NULL;
|
|
CL_NODE_ID MaxNodeId, MinNodeId;
|
|
ULONG StartNode, EndNode, Node;
|
|
|
|
//
|
|
// read in the node table
|
|
//
|
|
if ( !ReadNodeTable( &LocalNodeTable, &MaxNodeId, &MinNodeId )) {
|
|
if ( LocalNodeTable )
|
|
free( LocalNodeTable );
|
|
return;
|
|
}
|
|
|
|
if ( *args == '\0' ) {
|
|
|
|
StartNode = MinNodeId;
|
|
EndNode = MaxNodeId;
|
|
} else {
|
|
|
|
StartNode = EndNode = (ULONG)GetExpression( args );
|
|
|
|
if ( StartNode > MaxNodeId ) {
|
|
dprintf("Node ID out of Range: 0 to %d\n", MaxNodeId );
|
|
|
|
if ( LocalNodeTable )
|
|
free( LocalNodeTable );
|
|
return;
|
|
}
|
|
}
|
|
|
|
dprintf("Min, Max Node ID = ( %u, %d )\n", MinNodeId, MaxNodeId );
|
|
|
|
for ( Node = StartNode; Node <= EndNode; ++Node ) {
|
|
|
|
if (CheckControlC()) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// read node object struct out of target's memory
|
|
//
|
|
TargetNodeObj = *(LocalNodeTable + Node);
|
|
if ( TargetNodeObj == NULL ) {
|
|
|
|
continue;
|
|
} else if ( !ReadTargetMemory( TargetNodeObj, &LocalNodeObj, sizeof( CNP_NODE ))) {
|
|
|
|
dprintf("Problem reading node obj at %p (Node %d)\n", TargetNodeObj, Node );
|
|
break;
|
|
}
|
|
|
|
#if DBG
|
|
if ( LocalNodeObj.Signature != CNP_NODE_SIG ) {
|
|
dprintf( "CNP_NODE @ %p has the wrong signature\n", TargetNodeObj );
|
|
}
|
|
#endif
|
|
|
|
dprintf( "\nNodeObj @ %p\n\n", TargetNodeObj );
|
|
dprintf( " Linkage.Flink @ %p\n", LocalNodeObj.Linkage.Flink );
|
|
|
|
dprintf( " ID = %d\n", LocalNodeObj.Id );
|
|
dprintf( " Lock @ %p\n", &TargetNodeObj->Lock );
|
|
dprintf( " Irql = %d\n", LocalNodeObj.Irql );
|
|
dprintf( " RefCount = %d\n", LocalNodeObj.RefCount );
|
|
dprintf( " Comm State = %s\n", NodeObjCommState [ LocalNodeObj.CommState ]);
|
|
dprintf( " MMState = %s\n", NodeObjMemberState [ LocalNodeObj.MMState ]);
|
|
DumpNodeObjFlags( LocalNodeObj.Flags );
|
|
dprintf( " Interface List @ %p", &TargetNodeObj->InterfaceList );
|
|
if ( &TargetNodeObj->InterfaceList == LocalNodeObj.InterfaceList.Flink ) {
|
|
dprintf( " (empty)" );
|
|
}
|
|
dprintf( "\n" );
|
|
|
|
dprintf( " Current Interface @ %p\n", LocalNodeObj.CurrentInterface );
|
|
dprintf( " Pending Delete IRP @ %p\n", LocalNodeObj.PendingDeleteIrp );
|
|
|
|
dprintf( " HBWasMissed = %s\n", TrueOrFalse( LocalNodeObj.HBWasMissed ));
|
|
dprintf( " Node Down Issued = %s\n", TrueOrFalse( LocalNodeObj.NodeDownIssued ));
|
|
dprintf( " MissedHBs = %u\n", LocalNodeObj.MissedHBs );
|
|
}
|
|
|
|
if ( LocalNodeTable ) {
|
|
free( LocalNodeTable );
|
|
}
|
|
} // nodeobj
|
|
|
|
VOID
|
|
DumpNodeObjFlags(
|
|
ULONG Flags
|
|
)
|
|
{
|
|
dprintf(" Flags = %08X (", Flags );
|
|
if ( Flags & CNP_NODE_FLAG_DELETING )
|
|
dprintf(" Deleting" );
|
|
if ( Flags & CNP_NODE_FLAG_UNREACHABLE )
|
|
dprintf(" Unreachable" );
|
|
if ( Flags & CNP_NODE_FLAG_LOCAL )
|
|
dprintf(" Local" );
|
|
dprintf(")\n");
|
|
}
|
|
|
|
DECLARE_API( nodeifs )
|
|
/*
|
|
* dump the interface list for the indicated node obj
|
|
*/
|
|
{
|
|
PCNP_NODE TargetNodeObj;
|
|
CNP_NODE LocalNodeObj;
|
|
PCNP_NODE *LocalNodeTable = NULL;
|
|
PCNP_INTERFACE NextTargetIfObj;
|
|
CNP_INTERFACE LocalIfObj;
|
|
CL_NODE_ID MaxNodeId, MinNodeId;
|
|
ULONG Node;
|
|
|
|
if ( *args == '\0' ) {
|
|
dprintf("Node ID must be specified\n");
|
|
return;
|
|
}
|
|
|
|
if ( !ReadNodeTable( &LocalNodeTable, &MaxNodeId, &MinNodeId )) {
|
|
|
|
if ( LocalNodeTable )
|
|
free( LocalNodeTable );
|
|
return;
|
|
}
|
|
|
|
Node = (ULONG)GetExpression( args );
|
|
|
|
if ( Node > MaxNodeId || Node < MinNodeId ) {
|
|
dprintf("Node ID is out of range: %u to %u\n", MinNodeId, MaxNodeId );
|
|
|
|
if ( LocalNodeTable )
|
|
free( LocalNodeTable );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read node object struct out of target's memory
|
|
//
|
|
|
|
TargetNodeObj = *(LocalNodeTable + Node);
|
|
if ( !ReadTargetMemory( TargetNodeObj, &LocalNodeObj, sizeof( CNP_NODE ))) {
|
|
dprintf("Problem reading node obj at %p (Node %d)\n", TargetNodeObj, Node );
|
|
|
|
if ( LocalNodeTable )
|
|
free( LocalNodeTable );
|
|
return;
|
|
|
|
}
|
|
|
|
#if DBG
|
|
if ( LocalNodeObj.Signature != CNP_NODE_SIG ) {
|
|
dprintf( "CNP_NODE @ %p has the wrong signature\n", TargetNodeObj );
|
|
}
|
|
#endif
|
|
|
|
dprintf( "\nNodeObj @ %p Interface List @ %p", TargetNodeObj, &TargetNodeObj->InterfaceList );
|
|
if ( &TargetNodeObj->InterfaceList == LocalNodeObj.InterfaceList.Flink ) {
|
|
dprintf( " (empty)" );
|
|
}
|
|
dprintf( "\n\n" );
|
|
|
|
NextTargetIfObj = (PCNP_INTERFACE)LocalNodeObj.InterfaceList.Flink;
|
|
|
|
while ( &TargetNodeObj->InterfaceList != (PLIST_ENTRY)NextTargetIfObj ) {
|
|
|
|
if (CheckControlC()) {
|
|
break;
|
|
}
|
|
|
|
NextTargetIfObj = CONTAINING_RECORD( NextTargetIfObj, CNP_INTERFACE, NodeLinkage );
|
|
if ( !ReadTargetMemory(
|
|
NextTargetIfObj,
|
|
&LocalIfObj,
|
|
FIELD_OFFSET( CNP_INTERFACE, TdiAddress ) + sizeof(TA_IP_ADDRESS)
|
|
)
|
|
) {
|
|
break;
|
|
}
|
|
|
|
DumpInterfaceObj( NextTargetIfObj, &LocalIfObj );
|
|
|
|
NextTargetIfObj = (PCNP_INTERFACE)LocalIfObj.NodeLinkage.Flink;
|
|
}
|
|
|
|
if ( LocalNodeTable ) {
|
|
free( LocalNodeTable );
|
|
}
|
|
} // nodeifs
|
|
|
|
DECLARE_API( currif )
|
|
/*
|
|
* for the specified node, dump the current interface obj
|
|
*/
|
|
{
|
|
PCNP_NODE TargetNodeObj;
|
|
CNP_NODE LocalNodeObj;
|
|
PCNP_NODE *LocalNodeTable = NULL;
|
|
CL_NODE_ID MaxNodeId, MinNodeId;
|
|
CNP_INTERFACE LocalIfObj;
|
|
ULONG Node;
|
|
|
|
if ( *args == '\0' ) {
|
|
dprintf("Node ID must be specified\n");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read in the node table
|
|
//
|
|
if ( !ReadNodeTable( &LocalNodeTable, &MaxNodeId, &MinNodeId )) {
|
|
|
|
if ( LocalNodeTable )
|
|
free( LocalNodeTable );
|
|
return;
|
|
}
|
|
|
|
Node = (ULONG)GetExpression( args );
|
|
|
|
if ( Node > MaxNodeId || Node < MinNodeId ) {
|
|
dprintf("Node ID is out of range: %u to %u\n", MinNodeId, MaxNodeId );
|
|
|
|
if ( LocalNodeTable )
|
|
free( LocalNodeTable );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read node object struct out of target's memory
|
|
//
|
|
TargetNodeObj = *(LocalNodeTable + Node);
|
|
|
|
if ( !ReadTargetMemory( TargetNodeObj, &LocalNodeObj, sizeof( CNP_NODE ))) {
|
|
|
|
dprintf("Problem reading node obj at %p (Node %d)\n", TargetNodeObj, Node );
|
|
if ( LocalNodeTable )
|
|
free( LocalNodeTable );
|
|
return;
|
|
}
|
|
|
|
#if DBG
|
|
if ( LocalNodeObj.Signature != CNP_NODE_SIG ) {
|
|
dprintf( "CNP_NODE @ %p has the wrong signature\n", TargetNodeObj );
|
|
}
|
|
#endif
|
|
|
|
dprintf( "\nNodeObj @ %p Current Interface @ %p\n\n", TargetNodeObj, LocalNodeObj.CurrentInterface );
|
|
|
|
if ( LocalNodeObj.CurrentInterface ) {
|
|
|
|
if ( ReadTargetMemory( LocalNodeObj.CurrentInterface, &LocalIfObj, sizeof( CNP_INTERFACE ))) {
|
|
DumpInterfaceObj( LocalNodeObj.CurrentInterface, &LocalIfObj );
|
|
}
|
|
}
|
|
|
|
if ( LocalNodeTable ) {
|
|
free( LocalNodeTable );
|
|
}
|
|
} // currif
|
|
|
|
VOID
|
|
DumpInterfaceObj(
|
|
PCNP_INTERFACE TargetIfObj,
|
|
PCNP_INTERFACE IfObj
|
|
)
|
|
{
|
|
LONG i, j;
|
|
TA_ADDRESS *TA;
|
|
TDI_ADDRESS_IP UNALIGNED *TAIp;
|
|
|
|
#if DBG
|
|
if ( IfObj->Signature != CNP_INTERFACE_SIG ) {
|
|
dprintf( "CNP_INTERFACE @ %p has the wrong signature\n", TargetIfObj );
|
|
}
|
|
#endif
|
|
|
|
dprintf("Interface Obj @ %p\n", TargetIfObj );
|
|
dprintf(" Node Obj @ %p\n", IfObj->Node );
|
|
dprintf(" Net Obj @ %p\n", IfObj->Network );
|
|
dprintf(" State = %s\n", InterfaceState[ IfObj->State ]);
|
|
dprintf(" Priority = %d\n", IfObj->Priority );
|
|
dprintf(" Flags = %08X\n", IfObj->Flags );
|
|
dprintf(" MissedHBs = %u\n", IfObj->MissedHBs );
|
|
dprintf(" Seq to send = %u\n", IfObj->SequenceToSend );
|
|
dprintf(" Last Seq Recv'd = %u\n", IfObj->LastSequenceReceived );
|
|
dprintf(" Multicast discovery count = %u\n", IfObj->McastDiscoverCount );
|
|
dprintf(" AdapterWMIProviderId = %08X\n", IfObj->AdapterWMIProviderId );
|
|
|
|
dprintf(" TDI Addr Len = %d\n", IfObj->TdiAddressLength );
|
|
dprintf(" TDI Addr Count = %d\n", IfObj->TdiAddress.TAAddressCount );
|
|
|
|
TA = IfObj->TdiAddress.Address;
|
|
for (i=0; i < IfObj->TdiAddress.TAAddressCount; ++i ) {
|
|
dprintf(" [%d] Addr Length = %d\n", i, TA->AddressLength );
|
|
dprintf(" [%d] Addr Type = %d", i, TA->AddressType );
|
|
|
|
switch ( TA->AddressType ) {
|
|
case TDI_ADDRESS_TYPE_IP:
|
|
TAIp = (TDI_ADDRESS_IP UNALIGNED *)TA->Address;
|
|
// dprintf("%08X %08X\n", TAIp->in_addr,ntohl(TAIp->in_addr));
|
|
dprintf(" (IP)\n [%d] Port: %d Addr: %d.%d.%d.%d\n",
|
|
i, ntohs(TAIp->sin_port), (ntohl(TAIp->in_addr) >> 24 ) & 0xFF,
|
|
(ntohl(TAIp->in_addr) >> 16 ) & 0xFF,
|
|
(ntohl(TAIp->in_addr) >> 8 ) & 0xFF,
|
|
ntohl(TAIp->in_addr) & 0xFF);
|
|
break;
|
|
|
|
default:
|
|
dprintf("\n [%d] Addr:", i );
|
|
for( j = 0; j < TA->AddressLength; ++j )
|
|
dprintf(" %02X", TA->Address[j]);
|
|
dprintf("\n");
|
|
}
|
|
TA = (TA_ADDRESS *)((CHAR UNALIGNED *)TA + TA->AddressLength);
|
|
}
|
|
}
|
|
|
|
DECLARE_API( memlog )
|
|
/*
|
|
* dump the heart beat log. can optionally specify starting entry number
|
|
*/
|
|
{
|
|
PMEMLOG_ENTRY TargetMemLog;
|
|
PMEMLOG_ENTRY TargetLogEntry;
|
|
MEMLOG_ENTRY LogEntry;
|
|
PULONG TargetLogEntries;
|
|
ULONG LogEntries;
|
|
PULONG TargetNextLogEntry;
|
|
ULONG NextLogEntry;
|
|
LONG NumEntries;
|
|
ULONG Pass;
|
|
ULONG LineCount = 0;
|
|
ULONG StartingEntry;
|
|
LARGE_INTEGER LastSysTime;
|
|
DOUBLE LastTimeDelta;
|
|
DOUBLE FirstTimeDelta;
|
|
BOOLEAN PrintTime = TRUE;
|
|
LARGE_INTEGER FirstEntryTime;
|
|
|
|
//
|
|
// get address of MemLog and read its contents to get the real start
|
|
// of the log
|
|
//
|
|
|
|
TargetMemLog = (PMEMLOG_ENTRY)GetExpression( "clusnet!memlog" );
|
|
if ( !TargetMemLog ) {
|
|
|
|
dprintf( "Can't find symbol clusnet!memlog\n" );
|
|
return;
|
|
}
|
|
|
|
if ( !ReadTargetMemory( TargetMemLog, &TargetMemLog, sizeof( PMEMLOG_ENTRY ))) {
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// repeat this process, getting the size of the log and the next entry index
|
|
//
|
|
|
|
TargetLogEntries = (PULONG)GetExpression( "clusnet!memlogentries" );
|
|
if ( !TargetLogEntries ) {
|
|
|
|
dprintf( "Can't find symbol clusnet!memlogentries\n" );
|
|
return;
|
|
}
|
|
|
|
if ( !ReadTargetMemory( TargetLogEntries, &LogEntries, sizeof( ULONG ))) {
|
|
|
|
return;
|
|
}
|
|
|
|
TargetNextLogEntry = (PULONG)GetExpression( "clusnet!memlognextlogentry" );
|
|
if ( !TargetNextLogEntry ) {
|
|
|
|
dprintf( "Can't find symbol clusnet!memlognextlogentry\n" );
|
|
return;
|
|
}
|
|
|
|
if ( !ReadTargetMemory( TargetNextLogEntry, &NextLogEntry, sizeof( ULONG ))) {
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// get optional starting entry number
|
|
//
|
|
|
|
if ( *args != '\0' ) {
|
|
|
|
StartingEntry = (ULONG)GetExpression( args );
|
|
if ( StartingEntry >= LogEntries ) {
|
|
|
|
dprintf("Starting entry out of range (0 to %d)\n", LogEntries - 1);
|
|
return;
|
|
}
|
|
|
|
if ( StartingEntry <= NextLogEntry ) {
|
|
|
|
//
|
|
// adjust starting number if on significant boundry
|
|
//
|
|
|
|
if ( StartingEntry == NextLogEntry ) {
|
|
if ( NextLogEntry == 0 )
|
|
StartingEntry = LogEntries - 1;
|
|
else
|
|
StartingEntry = NextLogEntry - 1;
|
|
}
|
|
|
|
Pass = 0;
|
|
NumEntries = StartingEntry + 1;
|
|
} else {
|
|
|
|
Pass = 1;
|
|
NumEntries = StartingEntry - NextLogEntry;
|
|
}
|
|
|
|
TargetLogEntry = TargetMemLog + StartingEntry;
|
|
} else {
|
|
|
|
Pass = 0;
|
|
|
|
if ( NextLogEntry == 0 )
|
|
NumEntries = LogEntries - 1;
|
|
else
|
|
NumEntries = NextLogEntry - 1;
|
|
|
|
TargetLogEntry = TargetMemLog + NumEntries;
|
|
}
|
|
|
|
//
|
|
// read in the most current entry to get its time. We calc the first time
|
|
// delta from this value
|
|
//
|
|
|
|
if ( !ReadTargetMemory(TargetMemLog + NextLogEntry - 1, &LogEntry, sizeof( MEMLOG_ENTRY ))) {
|
|
|
|
dprintf("can't read current log entry (%p) from memory\n\n", TargetLogEntry);
|
|
return;
|
|
}
|
|
|
|
LastSysTime.QuadPart = LogEntry.SysTime.QuadPart;
|
|
FirstEntryTime.QuadPart = LogEntry.SysTime.QuadPart;
|
|
|
|
dprintf("MemLog @ %p, Log Entries = %d, Next Entry = %d (%p)\n\n",
|
|
TargetMemLog, LogEntries, NextLogEntry, TargetMemLog + NextLogEntry);
|
|
|
|
//
|
|
// depending on our starting entry, look through the log twice.
|
|
// next entry might have wrapped so first time we
|
|
// dump all the entries down to the base. Next time we start at the end and
|
|
// dump out the remaining entries
|
|
|
|
dprintf("First Last\n");
|
|
dprintf("Entry Entry Line Log\n");
|
|
dprintf("Delta Delta No Type Desc\n");
|
|
|
|
while ( Pass < 2 ) {
|
|
|
|
while ( NumEntries-- ) {
|
|
|
|
if (CheckControlC()) {
|
|
return;
|
|
}
|
|
|
|
if ( !ReadTargetMemory(TargetLogEntry, &LogEntry, sizeof( MEMLOG_ENTRY ))) {
|
|
|
|
dprintf("can't read log entry (%p) from memory\n\n", TargetLogEntry);
|
|
return;
|
|
}
|
|
|
|
if ( LogEntry.Type == 0 )
|
|
break;
|
|
|
|
LastTimeDelta = ( LastSysTime.QuadPart - LogEntry.SysTime.QuadPart ) / 10000000.0;
|
|
FirstTimeDelta = ( FirstEntryTime.QuadPart - LogEntry.SysTime.QuadPart ) / 10000000.0;
|
|
|
|
if ( PrintTime ) {
|
|
dprintf("%8.3f %6.3f: (%4hu, 0x%02X) ", FirstTimeDelta, LastTimeDelta,
|
|
LogEntry.LineNo, LogEntry.Type );
|
|
}
|
|
|
|
PrintTime = TRUE;
|
|
|
|
switch ( LogEntry.Type ) {
|
|
case MemLogInitLog:
|
|
dprintf("Memory Log Init'ed\n");
|
|
break;
|
|
|
|
case MemLogInitHB:
|
|
dprintf("Heartbeats Init'ed\n");
|
|
break;
|
|
|
|
case MemLogHBStarted:
|
|
dprintf("START: Period = %u ms\n", LogEntry.Arg1);
|
|
break;
|
|
|
|
case MemLogHBStopped:
|
|
dprintf("STOPPED\n");
|
|
break;
|
|
|
|
case MemLogHBDpcRunning:
|
|
dprintf("DPC not removed. HeartBeatDpcRunning = %s\n",
|
|
TrueOrFalse( LogEntry.Arg1 ));
|
|
break;
|
|
|
|
case MemLogWaitForDpcFinish:
|
|
dprintf("DPC: Waiting to finish running\n");
|
|
break;
|
|
|
|
case MemLogMissedIfHB:
|
|
dprintf("HB MISSED on interface. Node = %u net = %u",
|
|
LogEntry.Arg1, LogEntry.Arg2);
|
|
PrintTime = FALSE;
|
|
break;
|
|
|
|
case MemLogMissedIfHB1:
|
|
dprintf(" (IF @ %p) MissedHBCount = %d\n", LogEntry.Arg1, LogEntry.Arg2);
|
|
break;
|
|
|
|
case MemLogFailingIf:
|
|
dprintf("IF FAILED. Node = %d, net = %d",
|
|
LogEntry.Arg1, LogEntry.Arg2);
|
|
PrintTime = FALSE;
|
|
break;
|
|
|
|
case MemLogFailingIf1:
|
|
dprintf(" (IF @ %p) IF State = %s\n", LogEntry.Arg1, InterfaceState[LogEntry.Arg2]);
|
|
break;
|
|
|
|
case MemLogSendHBWalkNode:
|
|
dprintf("Walking node %d to send HB. MMState = %s\n",
|
|
LogEntry.Arg1, NodeObjMemberState[LogEntry.Arg2]);
|
|
break;
|
|
|
|
case MemLogCheckHBWalkNode:
|
|
dprintf("Walking node %d to check for HB. MMState = %s.\n",
|
|
LogEntry.Arg1, NodeObjMemberState[LogEntry.Arg2]);
|
|
break;
|
|
|
|
case MemLogCheckHBNodeReachable:
|
|
dprintf("Node %d is currently %sreachable\n", LogEntry.Arg1,
|
|
(LogEntry.Arg2 ? "" : "NOT "));
|
|
break;
|
|
|
|
case MemLogCheckHBMissedHB:
|
|
dprintf("NODE MISSED HB on all IFs. MissedHBCount = %u MMState = %s\n",
|
|
LogEntry.Arg1, NodeObjMemberState[LogEntry.Arg2]);
|
|
break;
|
|
|
|
case MemLogSendingHB:
|
|
dprintf("Sending HB to Node %d on net %d\n", LogEntry.Arg1, LogEntry.Arg2);
|
|
break;
|
|
|
|
case MemLogNodeDown:
|
|
dprintf("NODE DOWN EVENT for node %d\n", LogEntry.Arg1);
|
|
break;
|
|
|
|
case MemLogSetDpcEvent:
|
|
dprintf("DPC: setting finished event\n");
|
|
break;
|
|
|
|
case MemLogNoNetID:
|
|
dprintf("BAD NET POINTER: Recv'd packet from node %d (%p)\n",
|
|
LogEntry.Arg1, LogEntry.Arg2);
|
|
break;
|
|
|
|
case MemLogOnlineIf:
|
|
dprintf("NODE %d ONLINE. IF State = %s\n", LogEntry.Arg1,
|
|
InterfaceState[LogEntry.Arg2]);
|
|
break;
|
|
|
|
case MemLogSeqAckMismatch:
|
|
dprintf("Recv'ed ack off with seq on IF %p. IF State = %s\n",
|
|
LogEntry.Arg1, InterfaceState[LogEntry.Arg2]);
|
|
break;
|
|
|
|
case MemLogNodeUp:
|
|
dprintf("NODE UP EVENT for node %d\n", LogEntry.Arg1);
|
|
break;
|
|
|
|
case MemLogReceivedPacket:
|
|
dprintf("Recv'ed HB from Node %d, net %d", LogEntry.Arg1, LogEntry.Arg2);
|
|
PrintTime = FALSE;
|
|
break;
|
|
|
|
case MemLogReceivedPacket1:
|
|
dprintf(" (S: %u A: %u)\n", LogEntry.Arg1, LogEntry.Arg2);
|
|
break;
|
|
|
|
case MemLogDpcTimeSkew:
|
|
dprintf("HB DPC fired %8.3f ms late\n", (double)(LogEntry.Arg1/10000.0));
|
|
break;
|
|
|
|
case MemLogHBPacketSend:
|
|
dprintf("%s Packet handed to CNP", CcmpMessageTypes[ LogEntry.Arg1 ]);
|
|
if ( LogEntry.Arg1 == CcmpHeartbeatMsgType )
|
|
dprintf(" (S:%u)", LogEntry.Arg2);
|
|
else if ( LogEntry.Arg1 == CcmpPoisonMsgType )
|
|
dprintf(" by %s", LogEntry.Arg2 == 1 ? "Heartbeat DPC" : "clussvc" );
|
|
dprintf("\n");
|
|
break;
|
|
|
|
case MemLogHBPacketSendComplete:
|
|
dprintf("%s Packet Send completed", CcmpMessageTypes[ LogEntry.Arg1 ]);
|
|
if ( LogEntry.Arg1 == CcmpHeartbeatMsgType )
|
|
dprintf(" (S:%u)", LogEntry.Arg2);
|
|
else if ( LogEntry.Arg1 == CcmpPoisonMsgType )
|
|
dprintf(" by %s", LogEntry.Arg2 == 1 ? "Heartbeat DPC" : "clussvc" );
|
|
dprintf("\n");
|
|
break;
|
|
|
|
case MemLogPoisonPktReceived:
|
|
dprintf("Poison Packet received from node %u\n", LogEntry.Arg1);
|
|
break;
|
|
|
|
case MemLogOuterscreen:
|
|
dprintf("Outerscreen changed to %04X\n",
|
|
((LogEntry.Arg1 & 0xFF ) << 8) | ((LogEntry.Arg1 >> 8 ) & 0xFF ));
|
|
break;
|
|
|
|
case MemLogNodeDownIssued:
|
|
dprintf("Node %u NodeDownIssued set to %s\n",
|
|
LogEntry.Arg1, TrueOrFalse( LogEntry.Arg2 ));
|
|
break;
|
|
|
|
case MemLogRegroupFinished:
|
|
dprintf("REGROUP FINISHED. New Epoch = %u\n", LogEntry.Arg1 );
|
|
break;
|
|
|
|
case MemLogInconsistentStates:
|
|
dprintf("INCONSISTENT STATES. STARTING NEW REGROUP. Node = %u, MMState = %s\n",
|
|
LogEntry.Arg1, NodeObjMemberState[ LogEntry.Arg2 ]);
|
|
break;
|
|
|
|
case MemLogOutOfSequence:
|
|
dprintf("Out Of Sequence Packet from Node = %u, SeqNo = %u\n",
|
|
LogEntry.Arg1, LogEntry.Arg2 );
|
|
break;
|
|
|
|
case MemLogInvalidSignature:
|
|
dprintf("Packet with bad Signature from Node = %u, type = %s\n",
|
|
LogEntry.Arg1, CcmpMessageTypes[ LogEntry.Arg2 ]);
|
|
break;
|
|
|
|
case MemLogSignatureSize:
|
|
dprintf("Invalid Signature buffer size from Node = %u, size = %u\n",
|
|
LogEntry.Arg1, LogEntry.Arg2 );
|
|
break;
|
|
|
|
case MemLogNoSecurityContext:
|
|
dprintf("No context to verify signature for Node = %u\n",
|
|
LogEntry.Arg1 );
|
|
break;
|
|
|
|
case MemLogPacketSendFailed:
|
|
dprintf("Packet not sent to Node %d, status = %08X\n",
|
|
LogEntry.Arg1, LogEntry.Arg2 );
|
|
break;
|
|
|
|
default:
|
|
dprintf(" unknown event, Arg1 = %p Arg2 = %p\n",
|
|
LogEntry.Arg1, LogEntry.Arg2);
|
|
}
|
|
|
|
LastSysTime.QuadPart = LogEntry.SysTime.QuadPart;
|
|
|
|
--TargetLogEntry;
|
|
}
|
|
|
|
if ( ++Pass < 2 ) {
|
|
|
|
NumEntries = LogEntries - NextLogEntry - 1;
|
|
TargetLogEntry = TargetMemLog + LogEntries - 1;
|
|
}
|
|
}
|
|
} // memlog
|
|
|
|
DECLARE_API( mlfind )
|
|
/*
|
|
* list the entry nums of the specified events in the memory log
|
|
*/
|
|
{
|
|
PMEMLOG_ENTRY TargetMemLog;
|
|
PMEMLOG_ENTRY TargetLogEntry;
|
|
MEMLOG_ENTRY LogEntry;
|
|
PULONG TargetLogEntries;
|
|
ULONG LogEntries;
|
|
PULONG TargetNextLogEntry;
|
|
ULONG NextLogEntry;
|
|
LONG NumEntries;
|
|
ULONG i;
|
|
DOUBLE FirstTimeDelta;
|
|
LARGE_INTEGER FirstEntryTime;
|
|
MEMLOG_TYPES LogType;
|
|
ULONG EntryDelta;
|
|
|
|
if ( *args == '\0' ) {
|
|
|
|
dprintf("Event type must be specified\n");
|
|
return;
|
|
}
|
|
|
|
LogType = (MEMLOG_TYPES)GetExpression( args );
|
|
|
|
//
|
|
// get address of MemLog and read its contents to get the real start
|
|
// of the log
|
|
//
|
|
|
|
TargetMemLog = (PMEMLOG_ENTRY)GetExpression( "clusnet!memlog" );
|
|
if ( !TargetMemLog ) {
|
|
|
|
dprintf( "Can't find symbol clusnet!memlog\n" );
|
|
return;
|
|
}
|
|
|
|
if ( !ReadTargetMemory( TargetMemLog, &TargetMemLog, sizeof( PMEMLOG_ENTRY ))) {
|
|
|
|
return;
|
|
}
|
|
|
|
//
|
|
// repeat this process, getting the size of the log and the next entry index
|
|
//
|
|
|
|
TargetLogEntries = (PULONG)GetExpression( "clusnet!memlogentries" );
|
|
if ( !TargetLogEntries ) {
|
|
|
|
dprintf( "Can't find symbol clusnet!memlogentries\n" );
|
|
return;
|
|
}
|
|
|
|
if ( !ReadTargetMemory( TargetLogEntries, &LogEntries, sizeof( ULONG ))) {
|
|
|
|
return;
|
|
}
|
|
|
|
TargetNextLogEntry = (PULONG)GetExpression( "clusnet!memlognextlogentry" );
|
|
if ( !TargetNextLogEntry ) {
|
|
|
|
dprintf( "Can't find symbol clusnet!memlognextlogentry\n" );
|
|
return;
|
|
}
|
|
|
|
if ( !ReadTargetMemory( TargetNextLogEntry, &NextLogEntry, sizeof( ULONG ))) {
|
|
|
|
return;
|
|
}
|
|
|
|
dprintf("MemLog @ %p, Log Entries = %d, Next Entry = %d (%p)\n",
|
|
TargetMemLog, LogEntries, NextLogEntry, TargetMemLog + NextLogEntry);
|
|
|
|
FirstEntryTime.QuadPart = 0;
|
|
|
|
//
|
|
// look through the log twice. next entry might have wrapped so first time we
|
|
// dump all the entries down to the base. Next time we start at the end and
|
|
// dump out the remaining entries
|
|
|
|
for ( i = 0; i < 2; ++i ) {
|
|
|
|
if ( i == 0 ) {
|
|
|
|
NumEntries = NextLogEntry;
|
|
TargetLogEntry = TargetMemLog + NumEntries;
|
|
} else {
|
|
|
|
NumEntries = LogEntries - NextLogEntry - 1;
|
|
TargetLogEntry = TargetMemLog + LogEntries;
|
|
}
|
|
|
|
while ( --TargetLogEntry, NumEntries-- ) {
|
|
|
|
if (CheckControlC()) {
|
|
return;
|
|
}
|
|
|
|
if ( !ReadTargetMemory(TargetLogEntry, &LogEntry, sizeof( MEMLOG_ENTRY ))) {
|
|
|
|
dprintf("can't read log entry (%p) from memory\n\n", TargetLogEntry);
|
|
return;
|
|
}
|
|
|
|
if ( LogEntry.Type == 0 )
|
|
break;
|
|
|
|
if ( FirstEntryTime.QuadPart == 0 ) {
|
|
FirstEntryTime.QuadPart = LogEntry.SysTime.QuadPart;
|
|
}
|
|
|
|
if ( LogEntry.Type != LogType )
|
|
continue;
|
|
|
|
FirstTimeDelta = ( FirstEntryTime.QuadPart - LogEntry.SysTime.QuadPart ) / 10000000.0;
|
|
|
|
EntryDelta = (DWORD)(TargetLogEntry - TargetMemLog);
|
|
dprintf("%8.3f: (%5hu) Entry at %d (0x%X)\n", FirstTimeDelta, LogEntry.LineNo,
|
|
EntryDelta, EntryDelta);
|
|
}
|
|
}
|
|
} // mlfind
|
|
|
|
DECLARE_API( events )
|
|
|
|
//
|
|
// run down the event file handle list, dumping interesting info for each one
|
|
//
|
|
|
|
{
|
|
PCN_FSCONTEXT targetFSContext;
|
|
PCN_FSCONTEXT lastFSContext;
|
|
CN_FSCONTEXT localFSContext;
|
|
LIST_ENTRY localListHead;
|
|
PLIST_ENTRY targetListHead;
|
|
PCLUSNET_EVENT_ENTRY nextEvent;
|
|
CLUSNET_EVENT_ENTRY localEvent;
|
|
|
|
//
|
|
// get the event file handle list head
|
|
//
|
|
targetListHead = (PLIST_ENTRY)GetExpression( "clusnet!eventfilehandles" );
|
|
if ( !targetListHead ) {
|
|
|
|
dprintf("Can't convert clusnet!eventfilehandles symbol\n");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read CN FS context object listhead out of target's memory
|
|
//
|
|
if ( !ReadTargetMemory( targetListHead, &localListHead, sizeof(LIST_ENTRY))) {
|
|
dprintf("Can't get EventFileHandles data\n");
|
|
return;
|
|
}
|
|
|
|
targetFSContext = (PCN_FSCONTEXT)localListHead.Flink;
|
|
lastFSContext = (PCN_FSCONTEXT)targetListHead;
|
|
|
|
if ( targetFSContext == lastFSContext ) {
|
|
dprintf("No file objects in EventFileHandles\n");
|
|
return;
|
|
}
|
|
|
|
while ( targetFSContext != lastFSContext ) {
|
|
|
|
if (CheckControlC()) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read FS context struct out of target's memory
|
|
//
|
|
targetFSContext = CONTAINING_RECORD( targetFSContext, CN_FSCONTEXT, Linkage );
|
|
if ( !ReadTargetMemory( targetFSContext, &localFSContext, sizeof( CN_FSCONTEXT ))) {
|
|
dprintf("Problem reading FS context at %p\n", targetFSContext );
|
|
return;
|
|
}
|
|
|
|
#if DBG
|
|
if ( localFSContext.Signature != CN_CONTROL_CHANNEL_SIG ) {
|
|
dprintf( "CN_FSCONTEXT @ %p has the wrong signature\n", targetFSContext );
|
|
}
|
|
#endif
|
|
|
|
dprintf( "\nFSContext @ %p\n\n", targetFSContext );
|
|
dprintf( " Next FSContext @ %p\n", localFSContext.Linkage.Flink );
|
|
|
|
dprintf( " Event Mask %08X\n", localFSContext.EventMask );
|
|
dprintf( " Event IRP @ %p\n", localFSContext.EventIrp );
|
|
dprintf( " Event list @ %p %s\n", &targetFSContext->EventList,
|
|
ListInUse( &targetFSContext->EventList, &localFSContext.EventList ));
|
|
|
|
nextEvent = (PCLUSNET_EVENT_ENTRY)localFSContext.EventList.Flink;
|
|
while ( &targetFSContext->EventList != (PLIST_ENTRY)nextEvent ) {
|
|
|
|
if (CheckControlC()) {
|
|
break;
|
|
}
|
|
|
|
nextEvent = CONTAINING_RECORD( nextEvent, CLUSNET_EVENT_ENTRY, Linkage );
|
|
if ( !ReadTargetMemory( nextEvent, &localEvent, sizeof( CLUSNET_EVENT_ENTRY ))) {
|
|
break;
|
|
}
|
|
|
|
DumpEventData( nextEvent, &localEvent );
|
|
|
|
nextEvent = (PCLUSNET_EVENT_ENTRY)localEvent.Linkage.Flink;
|
|
}
|
|
|
|
targetFSContext = (PCN_FSCONTEXT)localFSContext.Linkage.Flink;
|
|
}
|
|
} // events
|
|
|
|
DWORD
|
|
GetEventTypeIndex(
|
|
CLUSNET_EVENT_TYPE EventType
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Description
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD index;
|
|
|
|
for ( index = 0; index < 10; ++index ) {
|
|
if ( ( 1 << index ) & EventType ) {
|
|
return index + 1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
VOID
|
|
DumpEventData(
|
|
PCLUSNET_EVENT_ENTRY EventAddress,
|
|
PCLUSNET_EVENT_ENTRY EventEntry
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Description
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
dprintf(" Event @ %p\n", EventAddress );
|
|
dprintf(" Epoch %u\n", EventEntry->EventData.Epoch );
|
|
dprintf(" Type 0x%03X (%s)\n",
|
|
EventEntry->EventData.EventType,
|
|
EventTypes[ GetEventTypeIndex( EventEntry->EventData.EventType )]);
|
|
dprintf(" NodeId %u\n", EventEntry->EventData.NodeId );
|
|
dprintf(" NetId %u (%08X)\n", EventEntry->EventData.NetworkId,
|
|
EventEntry->EventData.NetworkId);
|
|
}
|
|
|
|
DECLARE_API( fsctxt )
|
|
/*
|
|
* dump the specified clusnet file object context struct
|
|
*/
|
|
{
|
|
PCN_FSCONTEXT targetFSContext;
|
|
CN_FSCONTEXT localFSContext;
|
|
|
|
if ( *args == '\0' ) {
|
|
dprintf("Address must be specified\n");
|
|
return;
|
|
}
|
|
|
|
targetFSContext = (PCN_FSCONTEXT)GetExpression( args );
|
|
if ( !targetFSContext ) {
|
|
dprintf("bad string conversion (%s) \n", args );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read network object struct out of target's memory
|
|
//
|
|
if ( !ReadTargetMemory( targetFSContext, &localFSContext, sizeof( CN_FSCONTEXT ))) {
|
|
dprintf("Problem reading FS Context obj at %p\n", targetFSContext );
|
|
return;
|
|
}
|
|
|
|
#if DBG
|
|
if ( localFSContext.Signature != CN_CONTROL_CHANNEL_SIG ) {
|
|
dprintf( "CN_FSCONTEXT @ %p has the wrong signature\n", targetFSContext );
|
|
}
|
|
#endif
|
|
|
|
dprintf( "\nFS Context @ %p\n\n", targetFSContext );
|
|
dprintf( " Next FS Ctxt on EventFileHandles @ %p\n", localFSContext.Linkage.Flink );
|
|
|
|
dprintf( " File Obj @ %p\n", localFSContext.FileObject );
|
|
dprintf( " RefCount = %d\n", localFSContext.ReferenceCount );
|
|
dprintf( " CancelIrps = %s\n", TrueOrFalse( localFSContext.CancelIrps ));
|
|
dprintf( " ShutdownOnClose = %s\n", TrueOrFalse( localFSContext.ShutdownOnClose ));
|
|
dprintf( " CleanupEvent @ %p\n", &targetFSContext->CleanupEvent );
|
|
dprintf( " Event List @ %p %s\n",
|
|
&targetFSContext->EventList,
|
|
ListInUse( &targetFSContext->EventList, &localFSContext.EventList ));
|
|
dprintf( " EventIrp @ %p\n", localFSContext.EventIrp );
|
|
dprintf( " EventMask = %08X\n", localFSContext.EventMask );
|
|
dprintf( " Krn Event Callback @ %p\n", localFSContext.KmodeEventCallback );
|
|
} // fsctxt
|
|
|
|
DECLARE_API( sendreq )
|
|
/*
|
|
* dump the specified CNP send request struct
|
|
*/
|
|
{
|
|
PCNP_SEND_REQUEST targetCnpSendReq;
|
|
CNP_SEND_REQUEST localCnpSendReq;
|
|
|
|
if ( *args == '\0' ) {
|
|
dprintf("Address must be specified\n");
|
|
return;
|
|
}
|
|
|
|
targetCnpSendReq = (PCNP_SEND_REQUEST)GetExpression( args );
|
|
if ( !targetCnpSendReq ) {
|
|
dprintf("bad string conversion (%s) \n", args );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read send request struct out of target's memory
|
|
//
|
|
if ( !ReadTargetMemory( targetCnpSendReq, &localCnpSendReq, sizeof( CNP_SEND_REQUEST ))) {
|
|
dprintf("Problem reading CNP send request at %p\n", targetCnpSendReq );
|
|
return;
|
|
}
|
|
|
|
dprintf( "\nCNP Send Request @ %p\n\n", targetCnpSendReq );
|
|
dprintf( " CnResource @ %p\n", &targetCnpSendReq->CnResource );
|
|
dprintf( " HeaderMdl @ %p\n", localCnpSendReq.HeaderMdl );
|
|
dprintf( " CnpHeader @ %p\n", localCnpSendReq.CnpHeader );
|
|
dprintf( " UpperProtocolIrp @ %p\n", localCnpSendReq.UpperProtocolIrp );
|
|
dprintf( " UpperProtocolHeader @ %p\n", localCnpSendReq.UpperProtocolHeader );
|
|
dprintf( " UpperProtocolHeaderLength %d\n", localCnpSendReq.UpperProtocolHeaderLength );
|
|
dprintf( " UpperProtocolIrpMode %d\n", localCnpSendReq.UpperProtocolIrpMode );
|
|
dprintf( " UpperProtocolMdl @ %p\n", localCnpSendReq.UpperProtocolMdl );
|
|
dprintf( " UpperProtocolContext @ %p\n", localCnpSendReq.UpperProtocolContext );
|
|
dprintf( " CompletionRoutine @ %p\n", localCnpSendReq.CompletionRoutine );
|
|
dprintf( " Network @ %p\n", localCnpSendReq.Network );
|
|
dprintf( " DestAddress @ %p\n", localCnpSendReq.TdiSendDatagramInfo.RemoteAddress );
|
|
dprintf( " Multicast Group @ %p\n", localCnpSendReq.McastGroup );
|
|
|
|
} // fsctxt
|
|
|
|
#if 0
|
|
// from when regroup was in the kernel
|
|
DECLARE_API( rgpdump )
|
|
/*
|
|
* dump the regroup struct
|
|
*/
|
|
{
|
|
rgp_control_t **TargetRGPAddress;
|
|
rgp_control_t *TargetRGP;
|
|
rgp_control_t LocalRGP;
|
|
OS_specific_rgp_control_t *Local_rgpos; // points to local memory
|
|
OS_specific_rgp_control_t *Target_rgpos; // points to target memory
|
|
BOOL success;
|
|
LONG BytesRead;
|
|
|
|
//
|
|
// get address of RGP symbol
|
|
//
|
|
|
|
TargetRGPAddress = (rgp_control_t **)GetExpression( "Clusnet!rgp" );
|
|
|
|
if ( !TargetRGPAddress ) {
|
|
|
|
dprintf("Can't convert Clusnet!rgp symbol\n");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read address of RGP block
|
|
//
|
|
|
|
if ( !ReadTargetMemory((PVOID)TargetRGPAddress,
|
|
(PVOID)&TargetRGP,
|
|
sizeof(rgp_control_t *))) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read actual RGP block into our local buffer
|
|
//
|
|
|
|
if ( !ReadTargetMemory((PVOID)TargetRGP,
|
|
(PVOID)&LocalRGP,
|
|
sizeof( rgp_control_t ))) {
|
|
return;
|
|
}
|
|
|
|
Target_rgpos = &TargetRGP->OS_specific_control;
|
|
Local_rgpos = &LocalRGP.OS_specific_control;
|
|
|
|
dprintf( "RGP @ %p\n\n", TargetRGP );
|
|
|
|
dprintf( "info:\n" );
|
|
dprintf( " Version = %u\n", LocalRGP.rgpinfo.version );
|
|
dprintf( " Seq number = %u\n", LocalRGP.rgpinfo.seqnum );
|
|
dprintf( " Clock Period = %hu ms\n", LocalRGP.rgpinfo.a_tick );
|
|
dprintf( " I Am Alive ticks = %hu\n", LocalRGP.rgpinfo.iamalive_ticks );
|
|
dprintf( " Check ticks = %hu\n", LocalRGP.rgpinfo.check_ticks );
|
|
dprintf( " Min stage1 ticks = %hu\n", LocalRGP.rgpinfo.Min_Stage1_ticks );
|
|
DumpClusterMask( " Cluster mask = ", &LocalRGP.rgpinfo.cluster );
|
|
|
|
dprintf( " My node = %hu\n", LocalRGP.mynode );
|
|
dprintf( " Tiebreaker node = %hu\n", LocalRGP.tiebreaker );
|
|
dprintf( " Number of nodes in cluster = %u\n", LocalRGP.num_nodes );
|
|
dprintf( " Clock tick counter = %hu\n", LocalRGP.clock_ticks );
|
|
dprintf( " RGP counter = %hu\n", LocalRGP.rgpcounter );
|
|
dprintf( " Restart counter = %hu\n", LocalRGP.restartcount );
|
|
dprintf( " Pruning ticks = %hu\n", LocalRGP.pruning_ticks );
|
|
dprintf( " PFail State = %hu\n", LocalRGP.pfail_state );
|
|
|
|
dprintf( " Cautious Mode = %u\n", LocalRGP.cautiousmode );
|
|
dprintf( " Send Stage = %u\n", LocalRGP.sendstage );
|
|
dprintf( " Tie Breaker Selected = %u\n", LocalRGP.tiebreaker_selected );
|
|
dprintf( " Has Unreachable Nodes = %u\n", LocalRGP.has_unreachable_nodes );
|
|
|
|
DumpClusterMask( " Outer Screen = ", &LocalRGP.outerscreen );
|
|
DumpClusterMask( " Inner Screen = ", &LocalRGP.innerscreen );
|
|
DumpClusterMask( " Status Targets = ", &LocalRGP.status_targets );
|
|
DumpClusterMask( " Poison Targets = ", &LocalRGP.poison_targets );
|
|
DumpClusterMask( " Init Nodes = ", &LocalRGP.initnodes );
|
|
DumpClusterMask( " End Nodes = ", &LocalRGP.endnodes );
|
|
DumpClusterMask( " Unreachable Nodes = ", &LocalRGP.unreachable_nodes );
|
|
|
|
DumpRGPOSSpecific( &TargetRGP->OS_specific_control, &LocalRGP.OS_specific_control );
|
|
}
|
|
|
|
DECLARE_API( rgposdump )
|
|
/*
|
|
* dump just the OS specific portion of the regroup struct
|
|
*/
|
|
{
|
|
rgp_control_t **TargetRGPAddress;
|
|
rgp_control_t *TargetRGP;
|
|
rgp_control_t LocalRGP;
|
|
OS_specific_rgp_control_t *Local_rgpos; // points to local memory
|
|
OS_specific_rgp_control_t *Target_rgpos; // points to target memory
|
|
BOOL success;
|
|
LONG BytesRead;
|
|
|
|
//
|
|
// get address of RGP symbol
|
|
//
|
|
|
|
TargetRGPAddress = (rgp_control_t **)GetExpression( "Clusnet!rgp" );
|
|
|
|
if ( !TargetRGPAddress ) {
|
|
|
|
dprintf("Can't convert Clusnet!rgp symbol\n");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read address of RGP block
|
|
//
|
|
|
|
if ( !ReadTargetMemory((PVOID)TargetRGPAddress,
|
|
(PVOID)&TargetRGP,
|
|
sizeof(rgp_control_t *))) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// read actual RGP block into our local buffer
|
|
//
|
|
|
|
if ( !ReadTargetMemory((PVOID)TargetRGP,
|
|
(PVOID)&LocalRGP,
|
|
sizeof( rgp_control_t ))) {
|
|
return;
|
|
}
|
|
|
|
Target_rgpos = &TargetRGP->OS_specific_control;
|
|
Local_rgpos = &LocalRGP.OS_specific_control;
|
|
|
|
dprintf( "RGP @ %p\n\n", TargetRGP );
|
|
|
|
DumpRGPOSSpecific( &TargetRGP->OS_specific_control, &LocalRGP.OS_specific_control );
|
|
}
|
|
|
|
VOID
|
|
DumpRGPOSSpecific(
|
|
OS_specific_rgp_control_t *Target_rgpos,
|
|
OS_specific_rgp_control_t *Local_rgpos
|
|
)
|
|
{
|
|
dprintf( "OS specific\n" );
|
|
|
|
dprintf( "RGP Counters:\n" );
|
|
DumpRGPCounters( &Local_rgpos->counter );
|
|
|
|
DumpClusterMask( " CPUUPMASK = ", &Local_rgpos->CPUUPMASK );
|
|
|
|
dprintf( " RgpLock @ %p\n", &Target_rgpos->RgpLock );
|
|
dprintf( " RGPTimer @ %p\n", &Target_rgpos->RGPTimer );
|
|
dprintf( " PeriodicCheckDPC @ %p\n", &Target_rgpos->PeriodicCheckDPC );
|
|
dprintf( " TimerDPCFinished @ %p\n", &Target_rgpos->TimerDPCFinished );
|
|
dprintf( " CallbackLock @ %p\n", &Target_rgpos->CallbackLock );
|
|
dprintf( " CallbackIRP @ %p\n", &Target_rgpos->CallbackIrp );
|
|
|
|
dprintf( " CallbackEvents @ %p %s\n", &Target_rgpos->CallbackEvents,
|
|
ListInUse( &Local_rgpos->CallbackEvents ));
|
|
|
|
dprintf( " SendMsgQLock @ %p\n", &Target_rgpos->SendMsgQLock );
|
|
dprintf( " SendMsgQDPC @ %p\n", &Target_rgpos->SendMsgQDPC );
|
|
dprintf( " SendMsgQ @ %p %s\n", &Target_rgpos->SendMsgQ,
|
|
ListInUse( &Local_rgpos->SendMsgQ ));
|
|
dprintf( " MsgShutdown: %s\n", TrueFalse( Local_rgpos->MsgShutdown ));
|
|
dprintf( " MsgDPCQueued: %s\n", TrueFalse( Local_rgpos->MsgDPCQueued ));
|
|
dprintf( " MsgDPCFinished @ %p\n", &Target_rgpos->MsgDPCFinished );
|
|
|
|
DumpClusterMask( " NeedsNodeDownCallback = ", &Local_rgpos->NeedsNodeDownCallback );
|
|
|
|
} // rgpdump
|
|
|
|
VOID
|
|
DumpRGPCounters(
|
|
rgp_counter_t *counters
|
|
)
|
|
{
|
|
dprintf( " QueuedIAmAlive = %u\n", counters->QueuedIAmAlive );
|
|
dprintf( " RcvdLocalIAmAlive = %u\n", counters->RcvdLocalIAmAlive );
|
|
dprintf( " RcvdRemoteIAmAlive = %u\n", counters->RcvdRemoteIAmAlive );
|
|
dprintf( " RcvdRegroup = %u\n", counters->RcvdRegroup );
|
|
}
|
|
|
|
VOID
|
|
DumpClusterMask(
|
|
PCHAR Title,
|
|
cluster_t *nodemask
|
|
)
|
|
{
|
|
UINT i;
|
|
|
|
dprintf( Title );
|
|
|
|
for ( i = 0; i < BYTES_IN_CLUSTER; ++i ) {
|
|
|
|
dprintf("%02X", (ULONG)(*nodemask[i]) );
|
|
}
|
|
dprintf("\n");
|
|
}
|
|
#endif
|
|
|
|
BOOL
|
|
ReadNodeTable(
|
|
PCNP_NODE **LocalNodeTable,
|
|
CL_NODE_ID *MaxNodeId,
|
|
CL_NODE_ID *MinNodeId
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Description
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
|
|
{
|
|
PCNP_NODE TargetNodeTable;
|
|
CL_NODE_ID *TargetMaxNodeId;
|
|
CL_NODE_ID *TargetMinNodeId;
|
|
ULONG NumberOfValidNodes;
|
|
|
|
//
|
|
// get the address of the node table symbol on the target machine
|
|
//
|
|
|
|
TargetNodeTable = (PCNP_NODE)GetExpression( "clusnet!cnpnodetable" );
|
|
|
|
if ( !TargetNodeTable ) {
|
|
|
|
dprintf("Can't convert clusnet!cnpnnodetable symbol\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !ReadTargetMemory( TargetNodeTable, &TargetNodeTable, sizeof(PCNP_NODE))) {
|
|
|
|
dprintf("Can't get pointer to target node table\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if ( TargetNodeTable == NULL ) {
|
|
|
|
dprintf("Node Table hasn't been allocated.\n");
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// get lowest and highest valid node in the cluster
|
|
//
|
|
|
|
TargetMaxNodeId = (CL_NODE_ID *)GetExpression( "clusnet!cnmaxvalidnodeid" );
|
|
|
|
if ( !TargetMaxNodeId ) {
|
|
|
|
dprintf("Can't convert clusnet!cnmaxvalidnodeid symbol\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !ReadTargetMemory( TargetMaxNodeId, MaxNodeId, sizeof(CL_NODE_ID))) {
|
|
|
|
dprintf("Can't get Max Node ID data\n");
|
|
return FALSE;
|
|
}
|
|
|
|
TargetMinNodeId = (CL_NODE_ID *)GetExpression( "clusnet!cnminvalidnodeid" );
|
|
|
|
if ( !TargetMinNodeId ) {
|
|
|
|
dprintf("Can't convert clusnet!cnMinvalidnodeid symbol\n");
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !ReadTargetMemory( TargetMinNodeId, MinNodeId, sizeof(CL_NODE_ID))) {
|
|
|
|
dprintf("Can't get Min Node ID data\n");
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// allocate space for local copy of node table. The max and min are added
|
|
// together since Node Ids may not be zero based while the node table is
|
|
// zero based.
|
|
//
|
|
|
|
NumberOfValidNodes = *MaxNodeId + *MinNodeId;
|
|
*LocalNodeTable = malloc( NumberOfValidNodes * sizeof( PCNP_NODE ));
|
|
|
|
if ( !*LocalNodeTable ) {
|
|
|
|
dprintf("Can't get local mem for node table\n");
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// read node table from target memory
|
|
//
|
|
|
|
if ( !ReadTargetMemory(TargetNodeTable,
|
|
*LocalNodeTable,
|
|
ClusterDefaultMaxNodes * sizeof(PCNP_NODE))) {
|
|
|
|
dprintf("Can't get local copy of node table data\n");
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
ReadTargetMemory(
|
|
PVOID TargetAddress,
|
|
PVOID LocalBuffer,
|
|
ULONG BytesToRead
|
|
)
|
|
{
|
|
BOOL success;
|
|
ULONG BytesRead;
|
|
|
|
success = ReadMemory((ULONG_PTR)TargetAddress, LocalBuffer, BytesToRead, &BytesRead);
|
|
|
|
if (success) {
|
|
|
|
if (BytesRead != BytesToRead) {
|
|
|
|
dprintf("wrong byte count. expected=%d, read =%d\n", BytesToRead, BytesRead);
|
|
}
|
|
|
|
} else {
|
|
dprintf("Problem reading memory at %p for %u bytes\n",
|
|
TargetAddress, BytesToRead);
|
|
|
|
success = FALSE;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
__inline PCHAR
|
|
ListInUse(
|
|
PLIST_ENTRY ListHead,
|
|
PLIST_ENTRY ListToCheck
|
|
)
|
|
{
|
|
return ListToCheck->Flink == ListHead ? "(empty)" : "";
|
|
}
|
|
|
|
__inline PCHAR
|
|
TrueFalse(
|
|
BOOLEAN Value
|
|
)
|
|
{
|
|
return Value ? "TRUE" : "FALSE";
|
|
}
|
|
|
|
VOID
|
|
DprintUnicodeString(
|
|
PUNICODE_STRING UnicodeString,
|
|
DWORD_PTR AddrString,
|
|
PCHAR Symbol OPTIONAL,
|
|
DWORD_PTR Displacement OPTIONAL
|
|
)
|
|
{
|
|
ANSI_STRING AnsiString;
|
|
LPSTR StringData;
|
|
BOOL b;
|
|
|
|
StringData = malloc(UnicodeString->Length+sizeof(UNICODE_NULL));
|
|
if ( StringData == NULL ) {
|
|
dprintf("Unable to allocate memory for string buffer\n");
|
|
return;
|
|
}
|
|
|
|
b = ReadMemory((ULONG_PTR)UnicodeString->Buffer,
|
|
StringData,
|
|
UnicodeString->Length,
|
|
NULL);
|
|
if ( !b ) {
|
|
free(StringData);
|
|
return;
|
|
}
|
|
|
|
UnicodeString->Buffer = (PWSTR)StringData;
|
|
UnicodeString->MaximumLength = UnicodeString->Length+(USHORT)sizeof(UNICODE_NULL);
|
|
|
|
RtlUnicodeStringToAnsiString(&AnsiString,UnicodeString,TRUE);
|
|
free(StringData);
|
|
|
|
if (Symbol == NULL || Displacement == (DWORD_PTR) NULL) {
|
|
dprintf("String(%d,%d) at %p: %s\n",
|
|
UnicodeString->Length,
|
|
UnicodeString->MaximumLength,
|
|
AddrString,
|
|
AnsiString.Buffer
|
|
);
|
|
}
|
|
else {
|
|
dprintf("String(%d,%d) %s+%p at %p: %s\n",
|
|
UnicodeString->Length,
|
|
UnicodeString->MaximumLength,
|
|
Symbol,
|
|
Displacement,
|
|
AddrString,
|
|
AnsiString.Buffer
|
|
);
|
|
}
|
|
|
|
RtlFreeAnsiString(&AnsiString);
|
|
|
|
} // DprintUnicodeString
|
|
|
|
DECLARE_API( help )
|
|
{
|
|
dprintf("Clusnet kd extensions\n\n");
|
|
dprintf("netobj [address] - dump a network object\n");
|
|
dprintf("nodeobj [node ID] - dump a node object\n");
|
|
dprintf("nodeifs <node ID> - dump the interface objects of a node object\n");
|
|
dprintf("currif <node ID> - dump the current interface object of a node object\n");
|
|
dprintf("memlog [starting entry number] - dump the in-memory log\n");
|
|
dprintf("mlfind <entry type> - find all specified entry types in the memory log\n");
|
|
dprintf("events - dump the FS context structs on the EventFileHandles list\n");
|
|
dprintf("fsctxt <address> - dump a CN_FSCONTEXT struct\n");
|
|
dprintf("sendreq <address> - dump a CNP send request struct\n");
|
|
}
|