able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/net/ms/e100bex/kd/e100kd.c

1317 lines
31 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// This is a 64 bit aware debugger extension
#define KDEXT_64BIT
#include <windows.h>
#include <wdbgexts.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "e100_equ.h"
#include "e100_557.h"
#include "mp_cmn.h"
#include "e100kd.h"
WINDBG_EXTENSION_APIS ExtensionApis;
EXT_API_VERSION ApiVersion = { 5, 0, EXT_API_VERSION_NUMBER64, 0};
USHORT SavedMajorVersion;
USHORT SavedMinorVersion;
BOOL ChkTarget; // is debuggee a CHK build?
typedef struct
{
char Name[16];
unsigned int Val;
} DBG_LEVEL;
DBG_LEVEL DbgLevel[] = {
{"ERROR", MP_ERROR},
{"WARN", MP_WARN},
{"TRACE", MP_TRACE},
{"INFO", MP_INFO},
{"LOUD", MP_LOUD}
};
typedef struct
{
char Name[32];
unsigned int Val;
} DBG_ADAPTER_FLAGS, DBG_FILTER;
DBG_ADAPTER_FLAGS DbgAdapterFlags[] = {
{"SCATTER_GATHER", fMP_ADAPTER_SCATTER_GATHER},
{"MAP_REGISTER", fMP_ADAPTER_MAP_REGISTER},
{"RECV_LOOKASIDE", fMP_ADAPTER_RECV_LOOKASIDE},
{"INTERRUPT_IN_USE", fMP_ADAPTER_INTERRUPT_IN_USE},
{"RESET_IN_PROGRESS", fMP_ADAPTER_RESET_IN_PROGRESS},
{"NO_CABLE", fMP_ADAPTER_NO_CABLE},
{"HARDWARE_ERROR", fMP_ADAPTER_HARDWARE_ERROR}
};
//
// Ndis Packet Filter Bits (OID_GEN_CURRENT_PACKET_FILTER).
//
#define NDIS_PACKET_TYPE_DIRECTED 0x00000001
#define NDIS_PACKET_TYPE_MULTICAST 0x00000002
#define NDIS_PACKET_TYPE_ALL_MULTICAST 0x00000004
#define NDIS_PACKET_TYPE_BROADCAST 0x00000008
#define NDIS_PACKET_TYPE_SOURCE_ROUTING 0x00000010
#define NDIS_PACKET_TYPE_PROMISCUOUS 0x00000020
#define NDIS_PACKET_TYPE_SMT 0x00000040
#define NDIS_PACKET_TYPE_ALL_LOCAL 0x00000080
#define NDIS_PACKET_TYPE_GROUP 0x00001000
#define NDIS_PACKET_TYPE_ALL_FUNCTIONAL 0x00002000
#define NDIS_PACKET_TYPE_FUNCTIONAL 0x00004000
#define NDIS_PACKET_TYPE_MAC_FRAME 0x00008000
DBG_FILTER DbgFilterTable[] = {
{"DIRECTED", NDIS_PACKET_TYPE_DIRECTED},
{"MULTICAST", NDIS_PACKET_TYPE_MULTICAST},
{"ALL_MULTICAST", NDIS_PACKET_TYPE_ALL_MULTICAST},
{"BROADCAST", NDIS_PACKET_TYPE_BROADCAST},
{"SOURCE_ROUTING", NDIS_PACKET_TYPE_SOURCE_ROUTING},
{"PROMISCUOUS", NDIS_PACKET_TYPE_PROMISCUOUS},
{"SMT", NDIS_PACKET_TYPE_SMT},
{"ALL_LOCAL", NDIS_PACKET_TYPE_ALL_LOCAL},
{"GROUP", NDIS_PACKET_TYPE_GROUP},
{"ALL_FUNCTIONAL", NDIS_PACKET_TYPE_ALL_FUNCTIONAL},
{"FUNCTIONAL", NDIS_PACKET_TYPE_FUNCTIONAL},
{"MAC_FRAME", NDIS_PACKET_TYPE_MAC_FRAME}
};
typedef struct
{
char Name[32];
USHORT Val;
} DBG_RFD_STATUS, DBG_RFD_COMMAND, DBG_USHORT_BITS, DBG_USHORT_VALUE;
typedef struct
{
char Name[32];
UCHAR Val;
} DBG_UCHAR_BITS, DBG_UCHAR_VALUE;
DBG_RFD_STATUS DbgRfdStatus[] = {
{"COMPLETE", RFD_STATUS_COMPLETE},
{"OK", RFD_STATUS_OK},
{"CRC_ERROR", RFD_CRC_ERROR},
{"ALIGNMENT_ERROR", RFD_ALIGNMENT_ERROR},
{"NO_RESOURCES", RFD_NO_RESOURCES},
{"DMA_OVERRUN", RFD_DMA_OVERRUN},
{"FRAME_TOO_SHORT", RFD_FRAME_TOO_SHORT},
{"RX_ERR", RFD_RX_ERR},
{"IA_MATCH", RFD_IA_MATCH},
{"RECEIVE_COLLISION", RFD_RECEIVE_COLLISION},
};
DBG_RFD_COMMAND DbgRfdCommand[] = {
{"EL", RFD_EL_BIT},
{"S", RFD_S_BIT},
{"H", RFD_H_BIT},
{"SF", RFD_SF_BIT}
};
DBG_USHORT_BITS DbgCbCommandBits[] = {
{"EL", CB_EL_BIT},
{"S", CB_S_BIT},
{"I", CB_I_BIT},
{"TX_SF", CB_TX_SF_BIT}
};
DBG_USHORT_VALUE DbgCbCommands[] = {
{"CB_NOP", CB_NOP},
{"CB_IA_ADDRESS", CB_IA_ADDRESS},
{"CB_CONFIGURE", CB_CONFIGURE},
{"CB_MULTICAST", CB_MULTICAST},
{"CB_TRANSMIT", CB_TRANSMIT},
{"CB_LOAD_MICROCODE", CB_LOAD_MICROCODE},
{"CB_DUMP", CB_DUMP},
{"CB_DIAGNOSE", CB_DIAGNOSE}
};
DBG_USHORT_VALUE DbgScbStatusRus[] = {
{"IDLE", SCB_RUS_IDLE},
{"SUSPEND", SCB_RUS_SUSPEND},
{"NO_RESOURCES", SCB_RUS_NO_RESOURCES},
{"READY", SCB_RUS_READY},
{"SUSP_NO_RBDS", SCB_RUS_SUSP_NO_RBDS},
{"NO_RBDS", SCB_RUS_NO_RBDS},
{"READY_NO_RBDS", SCB_RUS_READY_NO_RBDS},
};
DBG_USHORT_BITS DbgScbStatusBits[] = {
{"CX", SCB_STATUS_CX},
{"FR", SCB_STATUS_FR},
{"CNA", SCB_STATUS_CNA},
{"RNR", SCB_STATUS_RNR},
{"MDI", SCB_STATUS_MDI},
{"SWI", SCB_STATUS_SWI}
};
DBG_UCHAR_VALUE DbgScbCommandCuc[] = {
{"START", SCB_CUC_START},
{"RESUME", SCB_CUC_RESUME},
{"DUMP_ADDR", SCB_CUC_DUMP_ADDR},
{"DUMP_STAT", SCB_CUC_DUMP_STAT},
{"LOAD_BASE", SCB_CUC_LOAD_BASE},
{"DUMP_RST_STAT", SCB_CUC_DUMP_RST_STAT},
{"STATIC_RESUME", SCB_CUC_STATIC_RESUME}
};
DBG_UCHAR_VALUE DbgScbCommandRuc[] = {
{"START", SCB_RUC_START},
{"RESUME", SCB_RUC_RESUME},
{"ABORT", SCB_RUC_ABORT},
{"LOAD_HDS", SCB_RUC_LOAD_HDS},
{"LOAD_BASE", SCB_RUC_LOAD_BASE},
{"RBD_RESUME", SCB_RUC_RBD_RESUME}
};
VOID WinDbgExtensionDllInit(
PWINDBG_EXTENSION_APIS64 lpExtensionApis,
USHORT MajorVersion,
USHORT MinorVersion
)
{
ExtensionApis = *lpExtensionApis;
SavedMajorVersion = MajorVersion;
SavedMinorVersion = MinorVersion;
ChkTarget = SavedMajorVersion == 0x0c ? TRUE : FALSE;
}
LPEXT_API_VERSION ExtensionApiVersion(VOID)
{
return &ApiVersion;
}
VOID CheckVersion(VOID)
{
//
// for now don't bother to version check
//
return;
}
DECLARE_API( help )
{
int i;
dprintf("E100 extensions:\n");
dprintf(" dbglevel dump debug level\n");
dprintf(" mpadapter <MP_ADAPTER> <verbosity>> dump MP_ADAPTER block\n");
dprintf(" csr <CSRAddress> dump CSR block\n");
dprintf(" sendlist <CurrSendHead> <verbosity> dump send list\n");
dprintf(" mptcb <MP_TCB> dump MP_TCB block\n");
dprintf(" hwtcb <HW_TCB> dump HW_TCB block\n");
dprintf(" sendqueue <SendWaitQueue> dump queued send packets\n");
dprintf(" recvlist <RecvList> <verbosity> dump receive list\n");
dprintf(" mprfd <MP_RFD> dump MP_RFD block\n");
dprintf(" hwrfd <HW_RFD> dump HW_RFD block\n");
dprintf(" recvpendlist <RecvPendList> dump pending indicated rx packets\n");
}
DECLARE_API(dbglevel)
{
ULONG64 debugLevelPtr;
ULONG debugLevel, NewLevel;
ULONG64 Val;
int i;
ULONG Bytes;
debugLevelPtr = GetExpression("e100bnt5!MPDebugLevel");
if(debugLevelPtr == 0)
{
dprintf("Error retrieving address of MPDebugLevel\n");
dprintf("Target is %s\n", ChkTarget ? "Checked" : "Free");
}
dprintf("MPDebugLevel @ %p\n", debugLevelPtr);
debugLevel = GetUlongFromAddress(debugLevelPtr);
dprintf("Current MPDebugLevel = %d", debugLevel);
for(i = 0; i < sizeof(DbgLevel)/sizeof(DBG_LEVEL); i++)
{
if(debugLevel == DbgLevel[i].Val)
{
dprintf(" - %s", DbgLevel[i].Name);
break;
}
}
dprintf("\n");
dprintf("Available settings: ");
for(i = 0; i < sizeof(DbgLevel)/sizeof(DBG_LEVEL); i++)
{
if(debugLevel != DbgLevel[i].Val)
{
dprintf("%d-%s ", DbgLevel[i].Val, DbgLevel[i].Name);
}
}
dprintf("\n");
if(!*args)
{
return;
}
i = sscanf(args, "%lx", &NewLevel);
if(i == 1)
{
for(i = 0; i < sizeof(DbgLevel)/sizeof(DBG_LEVEL); i++)
{
if(NewLevel == DbgLevel[i].Val)
{
if(NewLevel != debugLevel)
{
dprintf("New MPDebugLevel = %d\n", NewLevel);
WriteMemory(debugLevelPtr, &NewLevel, sizeof(ULONG), &Bytes);
}
break;
}
}
}
}
DECLARE_API(version)
{
#if DBG
PCSTR kind = "Checked";
#else
PCSTR kind = "Free";
#endif
dprintf("%s E100 Extension dll on a %s system\n",
kind, ChkTarget? "Checked" : "Free");
}
#define MAX_FLAGS_PER_LINE 4
#define MAC_ADDRESS_LENGTH 6
DECLARE_API(mpadapter)
{
ULONG64 pAdapter;
int ArgCount = 0;
ULONG i, j;
ULONG Flags;
ULONG PacketFilter;
ULONG Off;
UCHAR MacAddress[MAC_ADDRESS_LENGTH];
UINT MCAddressCount;
PUCHAR pBuffer;
if(*args)
{
ArgCount = sscanf(args,"%I64lx",&pAdapter);
}
//check for arguments
if(ArgCount < 1)
{
dprintf("Usage: mpadapter <pointer to MP_ADAPTER>\n");
return ;
}
dprintf(" pAdapter %p : \n", pAdapter);
InitTypeRead(pAdapter, MP_ADAPTER);
dprintf(" AdapterHandle : %p\n", ReadField(AdapterHandle));
Flags = (ULONG) ReadField(Flags);
dprintf(" Flags : 0x%08x\n", Flags);
j = 0;
for(i = 0; i < sizeof(DbgAdapterFlags)/sizeof(DBG_ADAPTER_FLAGS); i++)
{
if(Flags & DbgAdapterFlags[i].Val)
{
if(j == 0)
{
dprintf(" ");
}
dprintf("%s", DbgAdapterFlags[i].Name);
j++;
if(j != MAX_FLAGS_PER_LINE)
{
dprintf(", ");
}
else
{
dprintf("\n");
j = 0;
}
}
}
if(j != 0)
{
dprintf("\n");
}
if(!GetFieldOffset("MP_ADAPTER", "PermanentAddress", &Off))
{
if(GetData(MacAddress, pAdapter+Off, MAC_ADDRESS_LENGTH, "PermanentAddress[]"))
{
dprintf(" Permanent address : %02x-%02x-%02x-%02x-%02x-%02x\n",
MacAddress[0], MacAddress[1],
MacAddress[2], MacAddress[3],
MacAddress[4], MacAddress[5]);
}
}
if((BOOLEAN) ReadField(OverrideAddress))
{
if(!GetFieldOffset("MP_ADAPTER", "CurrentAddress", &Off))
{
if(GetData(MacAddress, pAdapter+Off, MAC_ADDRESS_LENGTH, "CurrentAddress[]"))
{
dprintf(" Current address : %02x-%02x-%02x-%02x-%02x-%02x\n",
MacAddress[0], MacAddress[1],
MacAddress[2], MacAddress[3],
MacAddress[4], MacAddress[5]);
}
}
}
else
{
dprintf(" Current address : same as above\n");
}
dprintf("\n");
dprintf(" --- SEND ---\n");
dprintf(" CurrSendHead = %p , CurrSendTail = %p , nBusySend = %d\n",
ReadField(CurrSendHead), ReadField(CurrSendTail), (LONG)ReadField(nBusySend));
dprintf(" SendWaitQueue Head = %p, Tail = %p\n",
ReadField(SendWaitQueue.Head), ReadField(SendWaitQueue.Tail));
dprintf(" NumTcb = %d, RegNumTcb = %d, NumBuffers = %d\n",
(LONG)ReadField(NumTcb), (LONG)ReadField(RegNumTcb), (LONG)ReadField(NumBuffers));
dprintf(" MpTcbMem = %p\n", ReadField(MpTcbMem));
if(DBG_TEST_FLAG(Flags, fMP_ADAPTER_MAP_REGISTER))
{
dprintf(" CurrMapRegHead = %d, CurrMapRegTail = %d\n",
(UINT)ReadField(CurrMapRegHead), (UINT)ReadField(CurrMapRegTail));
}
dprintf(" TransmitIdle = %s, ResumeWait = %s\n",
(BOOLEAN)ReadField(TransmitIdle) ? "TRUE" : "FALSE",
(BOOLEAN)ReadField(ResumeWait) ? "TRUE" : "FALSE");
dprintf(" SendBufferPool = %p\n", ReadField(SendBufferPool));
dprintf("\n");
dprintf(" --- RECV ---\n");
if(!GetFieldOffset("MP_ADAPTER", "RecvList", &Off))
{
dprintf(" RecvList @ %p , nReadyRecv = %d\n",
pAdapter+Off, (LONG)ReadField(nReadyRecv));
}
if(!GetFieldOffset("MP_ADAPTER", "RecvPendList", &Off))
{
dprintf(" RecvPendList @ %p , RefCount = %d\n",
pAdapter+Off, (LONG)ReadField(RefCount));
}
dprintf(" NumRfd = %d, CurrNumRfd = %d , HwRfdSize = %d\n",
(LONG)ReadField(NumRfd), (LONG)ReadField(CurrNumRfd), (LONG)ReadField(HwRfdSize));
dprintf(" bAllocNewRfd = %s, RfdShrinkCount = %d\n",
(BOOLEAN)ReadField(bAllocNewRfd) ? "TRUE" : "FALSE",
(LONG)ReadField(RfdShrinkCount));
dprintf(" RecvPacketPool = %p , RecvBufferPool = %p\n",
ReadField(RecvPacketPool), ReadField(RecvBufferPool));
dprintf("\n");
PacketFilter = (ULONG)ReadField(PacketFilter);
dprintf(" PacketFilter : 0x%08x\n", PacketFilter);
j = 0;
for(i = 0; i < sizeof(DbgFilterTable)/sizeof(DBG_FILTER); i++)
{
if(PacketFilter & DbgFilterTable[i].Val)
{
if(j == 0)
{
dprintf(" ");
}
dprintf("%s", DbgFilterTable[i].Name);
j++;
if(j != MAX_FLAGS_PER_LINE)
{
dprintf(", ");
}
else
{
dprintf("\n");
j = 0;
}
}
}
if(j != 0)
{
dprintf("\n");
}
dprintf(" ulLookAhead=%d, usLinkSpeed=%d, usDuplexMode=%d\n",
(ULONG)ReadField(ulLookAhead), (USHORT)ReadField(usLinkSpeed),
(USHORT)ReadField(usDuplexMode));
dprintf("\n");
MCAddressCount = (UINT)ReadField(MCAddressCount);
dprintf(" MCAddressCount = %d\n", MCAddressCount);
pBuffer = malloc(MCAddressCount * MAC_ADDRESS_LENGTH);
if(pBuffer)
{
if(!GetFieldOffset("MP_ADAPTER", "MCList", &Off))
{
if(GetData(pBuffer, pAdapter+Off, MCAddressCount * MAC_ADDRESS_LENGTH, "MCList[]"))
{
for(i=0; i<MCAddressCount; i++)
{
j = i * MAC_ADDRESS_LENGTH;
dprintf(" (%d) = %02x-%02x-%02x-%02x-%02x-%02x\n",
i, pBuffer[j], pBuffer[j+1], pBuffer[j+2],
pBuffer[j+3], pBuffer[j+4], pBuffer[j+5]);
}
}
}
free(pBuffer);
}
else
{
}
dprintf("\n");
dprintf(" IoBaseAddress = 0x%x, IoRange = 0x%x, InterrupLevel = 0x%x, MemPhysAddress = 0x%x\n",
(ULONG)ReadField(IoBaseAddress), (ULONG)ReadField(IoRange),
(ULONG)ReadField(InterruptLevel), (ULONG)ReadField(MemPhysAddress.LowPart));
dprintf(" PortOffset = %p , CSRAddress = %p\n",
ReadField(PortOffset), ReadField(CSRAddress));
dprintf(" RevsionID = %d, SubVendorID = 0x%02x, SubSystemID = 0x%02x\n",
(UCHAR)ReadField(RevsionID), (USHORT)ReadField(SubVendorID),
(USHORT)ReadField(SubSystemID));
}
DECLARE_API(csr)
{
ULONG64 pHwCsr;
int ArgCount = 0;
UCHAR ucVal;
USHORT usVal;
ULONG i;
if(*args)
{
ArgCount = sscanf(args,"%I64lx", &pHwCsr);
}
//check for arguments
if(ArgCount < 1)
{
dprintf("Usage: csr <CSRAddress>\n");
return ;
}
dprintf(" pHwCsr %x : \n", pHwCsr);
InitTypeRead(pHwCsr, HW_CSR);
// ScbStatus
usVal = (USHORT)ReadField(ScbStatus);
dprintf(" ScbStatus - 0x%04x ", usVal);
dprintf("CUS-");
switch(usVal & SCB_CUS_MASK)
{
case SCB_CUS_IDLE:
dprintf("IDLE ");
break;
case SCB_CUS_SUSPEND:
dprintf("SUSPEND ");
break;
case SCB_CUS_ACTIVE:
dprintf("ACTIVE ");
break;
default:
dprintf("Reserved ");
}
for(i = 0; i < sizeof(DbgScbStatusRus)/sizeof(DBG_USHORT_VALUE); i++)
{
if((usVal & SCB_RUS_MASK) == DbgScbStatusRus[i].Val)
{
dprintf("RUS-%s ", DbgScbStatusRus[i].Name);
break;
}
}
dprintf("STAT-");
for(i = 0; i < sizeof(DbgScbStatusBits)/sizeof(DBG_USHORT_BITS); i++)
{
if(usVal & DbgScbStatusBits[i].Val)
{
dprintf("%s ", DbgScbStatusBits[i].Name);
}
}
dprintf("\n");
//ScbCommandLow
ucVal = (UCHAR)ReadField(ScbCommandLow);
dprintf(" ScbCommandLow - 0x%02x ", ucVal);
for(i = 0; i < sizeof(DbgScbCommandCuc)/sizeof(DBG_UCHAR_VALUE); i++)
{
if((ucVal & SCB_CUC_MASK) == DbgScbCommandCuc[i].Val)
{
dprintf("CUC-%s ", DbgScbCommandCuc[i].Name);
break;
}
}
for(i = 0; i < sizeof(DbgScbCommandRuc)/sizeof(DBG_UCHAR_VALUE); i++)
{
if((ucVal & SCB_RUC_MASK) == DbgScbCommandRuc[i].Val)
{
dprintf("RUC-%s ", DbgScbCommandRuc[i].Name);
break;
}
}
//ScbCommandHigh
ucVal = (UCHAR)ReadField(ScbCommandHigh);
dprintf(" ScbCommandHigh - 0x%02x ", ucVal);
if(ucVal & SCB_INT_MASK)
{
dprintf("INT_MASK ");
}
if(ucVal & SCB_SOFT_INT)
{
dprintf("SOFT_INT ");
}
dprintf("\n");
}
DECLARE_API(sendlist)
{
ULONG64 pMpTcb;
ULONG64 pFirstMpTcb;
int ArgCount = 0;
int Verbosity = 0;
int index = 0;
if(*args)
{
ArgCount = sscanf(args,"%I64lx %lx", &pMpTcb, &Verbosity);
}
//check for arguments
if(ArgCount < 1 || Verbosity > 1)
{
dprintf("Usage: sendlist <CurrSendHead> <verbosity>\n");
dprintf("1-Show HW_TCB info\n");
return ;
}
SIGN_EXTEND(pMpTcb);
pFirstMpTcb = pMpTcb;
do
{
dprintf(" (%d) pMpTcb %p : \n", index, pMpTcb);
PrintMpTcbDetails(pMpTcb, Verbosity);
if(GetFieldValue(pMpTcb, "MP_TCB", "Next", pMpTcb))
{
break;
}
index++;
if(CheckControlC())
{
dprintf("***Control-C***\n");
break;
}
} while(pMpTcb != pFirstMpTcb);
}
DECLARE_API(mptcb)
{
ULONG64 pMpTcb;
int ArgCount = 0;
if(*args)
{
ArgCount = sscanf(args,"%I64lx", &pMpTcb);
}
//check for arguments
if(ArgCount < 1)
{
dprintf("Usage: mptcb <MP_TCB>\n");
return ;
}
dprintf(" pMpTcb %p : \n", pMpTcb);
PrintMpTcbDetails(pMpTcb, 1);
}
DECLARE_API(hwtcb)
{
ULONG64 pHwTcb;
int ArgCount = 0;
if(*args)
{
ArgCount = sscanf(args,"%I64lx", &pHwTcb);
}
//check for arguments
if(ArgCount < 1)
{
dprintf("Usage: hwtcb <HW_TCB>\n");
return ;
}
dprintf(" pHwTcb %p : \n", pHwTcb);
PrintHwTcbDetails(pHwTcb);
}
void PrintMpTcbDetails(ULONG64 pMpTcb, int Verbosity)
{
ULONG Flags;
ULONG64 pMpTxBuf;
ULONG64 pHwTcb;
ULONG64 pVal;
ULONG ulVal;
USHORT usVal;
InitTypeRead(pMpTcb, MP_TCB);
dprintf(" Next %p", ReadField(Next));
Flags = (ULONG) ReadField(Flags);
dprintf(" , Flags - 0x%x", Flags);
if(Flags & fMP_TCB_IN_USE)
{
dprintf(" IN_USE");
}
if(Flags & fMP_TCB_USE_LOCAL_BUF)
{
dprintf(" USE_LOCAL_BUF");
}
if(Flags & fMP_TCB_MULTICAST)
{
dprintf(" MULTICAST");
}
dprintf("\n");
if(Flags & fMP_TCB_USE_LOCAL_BUF)
{
pMpTxBuf = ReadField(MpTxBuf);
dprintf(" MpTxBuf = %p", pMpTxBuf);
GetFieldValue(pMpTxBuf, "MP_TXBUF", "NdisBuffer", pVal);
dprintf(" - NdisBuffer = %p", pVal);
GetFieldValue(pMpTxBuf, "MP_TXBUF", "AllocSize", ulVal);
dprintf(" , AllocSize = %d", ulVal);
GetFieldValue(pMpTxBuf, "MP_TXBUF", "AllocVa", pVal);
dprintf(" , AllocVa = %p", pVal);
GetFieldValue(pMpTxBuf, "MP_TXBUF", "pBuffer", pVal);
dprintf(" , pBuffer = %p\n", pVal);
dprintf("\n");
}
if(Flags & fMP_TCB_IN_USE)
{
dprintf(" Packet = %p\n", ReadField(Packet));
pHwTcb = ReadField(HwTcb);
dprintf(" HwTcb = %p , HwTcbPhys = 0x%lx , PrevHwTcb = 0x%x\n",
pHwTcb, (ULONG)ReadField(HwTcbPhys), ReadField(PrevHwTcb));
dprintf(" HwTbd (First) = %p , HwTbdPhys = 0x%x\n",
ReadField(HwTbd), (ULONG)ReadField(HwTbdPhys));
dprintf(" PhysBufCount = %d, BufferCount = %d, FirstBuffer = %p , PacketLength = %d\n",
(ULONG)ReadField(PhysBufCount), (ULONG)ReadField(BufferCount),
ReadField(FirstBuffer), (ULONG)ReadField(PacketLength));
}
dprintf("\n");
if((Flags & fMP_TCB_IN_USE) && Verbosity == 1)
{
PrintHwTcbDetails(pHwTcb);
}
}
void PrintHwTcbDetails(ULONG64 pHwTcb)
{
USHORT HwCbStatus;
USHORT HwCbCommand;
ULONG i;
InitTypeRead(pHwTcb, HW_TCB);
HwCbStatus = (USHORT) ReadField(TxCbHeader.CbStatus);
HwCbCommand = (USHORT) ReadField(TxCbHeader.CbCommand);
dprintf(" TxCbHeader.CbStatus = 0x%04x ,", HwCbStatus);
if(HwCbStatus & CB_STATUS_COMPLETE)
{
dprintf(" COMPLETE");
}
if(HwCbStatus & CB_STATUS_OK)
{
dprintf(" OK");
}
if(HwCbStatus & CB_STATUS_UNDERRUN)
{
dprintf(" UNDERRUN");
}
dprintf("\n");
dprintf(" TxCbHeader.CbCommand = 0x%04x ", HwCbCommand);
for(i = 0; i < sizeof(DbgCbCommandBits)/sizeof(DBG_USHORT_BITS); i++)
{
if(HwCbCommand & DbgCbCommandBits[i].Val)
{
dprintf(", %s", DbgCbCommandBits[i].Name);
}
}
for(i = 0; i < sizeof(DbgCbCommands)/sizeof(DBG_USHORT_VALUE); i++)
{
if((HwCbCommand & CB_CMD_MASK) == DbgCbCommands[i].Val)
{
dprintf(", %s", DbgCbCommands[i].Name);
break;
}
}
if(i == sizeof(DbgCbCommands)/sizeof(DBG_USHORT_VALUE))
{
dprintf(", UNKNOWN COMMAND");
}
dprintf("\n");
dprintf(" TxCbHeader.CbLinkPointer = 0x%x\n", (ULONG)ReadField(TxCbHeader.CbLinkPointer));
if((HwCbCommand & CB_CMD_MASK) == CB_TRANSMIT)
{
dprintf(" TxCbTbdPointer = 0x%08x\n", (ULONG)ReadField(TxCbTbdPointer));
dprintf(" TxCbCount = %d, ", (USHORT)ReadField(TxCbCount));
dprintf("TxCbThreshold = %d, ", (UCHAR)ReadField(TxCbThreshold));
dprintf("TxCbTbdNumber = %d\n", (UCHAR)ReadField(TxCbTbdNumber));
}
}
DECLARE_API(sendqueue)
{
ULONG64 pEntry;
ULONG64 pPacket;
ULONG ulSize;
int ArgCount = 0;
int index = 0;
if(*args)
{
ArgCount = sscanf(args,"%I64lx", &pEntry);
}
//check for arguments
if(ArgCount < 1)
{
dprintf("Usage: sendqueue <SendWaitQueue address>\n");
return ;
}
SIGN_EXTEND(pEntry);
if(!(ulSize = GetTypeSize("NDIS_PACKET_PRIVATE")))
{
dprintf("Failed to get the type size of NDIS_PACKET_PRIVATE\n");
return;
}
dprintf("NDIS_PACKET_PRIVATE size is 0x%x\n", ulSize);
while(pEntry)
{
pPacket = pEntry - ulSize;
if(pPacket > pEntry)
{
dprintf("Invalid pEntry %p\n", pEntry);
break;
}
dprintf(" (%d) pEntry = %p, Pkt = %p\n", index, pEntry, pPacket);
if(ReadPtr(pEntry, &pEntry))
{
break;
}
index++;
if(CheckControlC())
{
dprintf("***Control-C***\n");
break;
}
}
}
DECLARE_API(recvlist)
{
ULONG64 pListHead;
ULONG64 pMpRfd;
ULONG64 pHwRfd;
int ArgCount = 0;
int Verbosity = 0;
int index = 0;
if(*args)
{
ArgCount = sscanf(args,"%I64lx %lx", &pListHead, &Verbosity);
}
//check for arguments
if(ArgCount < 1 || Verbosity > 1)
{
dprintf("Usage: recvlist <RecvList address> <verbosity>\n");
dprintf("1-Show HW_RFD info\n");
return ;
}
SIGN_EXTEND(pListHead);
if(GetFieldValue(pListHead, "LIST_ENTRY", "Flink", pMpRfd))
{
dprintf("Failed to get LIST_ENTRY Flink at %p\n", pListHead);
return;
}
while((pMpRfd != pListHead))
{
dprintf(" (%d) pMpRfd %p :\n", index, pMpRfd);
PrintMpRfdDetails(pMpRfd, Verbosity);
if(GetFieldValue(pMpRfd, "LIST_ENTRY", "Flink", pMpRfd))
{
dprintf("Failed to get LIST_ENTRY Flink at %p\n", pMpRfd);
break;
}
index++;
if(CheckControlC())
{
dprintf("***Control-C***\n");
break;
}
}
dprintf("RecvList has %d RFDs\n", index);
}
DECLARE_API(mprfd)
{
ULONG64 pMpRfd;
int ArgCount = 0;
if(*args)
{
ArgCount = sscanf(args,"%I64lx", &pMpRfd);
}
//check for arguments
if(ArgCount < 1)
{
dprintf("Usage: mprfd <MP_RFD>\n");
return ;
}
dprintf(" pMpRfd %p : \n", pMpRfd);
PrintMpRfdDetails(pMpRfd, 1);
}
DECLARE_API(hwrfd)
{
ULONG64 pHwRfd;
int ArgCount = 0;
if(*args)
{
ArgCount = sscanf(args,"%I64lx", &pHwRfd);
}
//check for arguments
if(ArgCount < 1)
{
dprintf("Usage: hwrfd <HW_RFD>\n");
return ;
}
dprintf(" pHwRfd = %p : \n", pHwRfd);
PrintHwRfdDetails(pHwRfd);
}
void PrintMpRfdDetails(ULONG64 pMpRfd, int Verbosity)
{
ULONG64 pHwRfd;
ULONG Flags;
InitTypeRead(pMpRfd, MP_RFD);
dprintf(" Flink %p", ReadField(List.Flink));
dprintf(" , Blink %p\n", ReadField(List.Blink));
pHwRfd = ReadField(HwRfd);
dprintf(" NdisPacket = %p , NdisBuffer = %p , HwRfd = %p\n",
ReadField(NdisPacket), ReadField(NdisBuffer), pHwRfd);
dprintf(" PacketSize = %d, ", (ULONG) ReadField(PacketSize));
Flags = (ULONG) ReadField(Flags);
dprintf("Flags 0x%x", Flags);
if(Flags & fMP_RFD_RECV_PEND)
{
dprintf(" RECV_PEND ");
}
if(Flags & fMP_RFD_ALLOC_PEND)
{
dprintf(" ALLOC_PEND ");
}
if(Flags & fMP_RFD_RECV_READY)
{
dprintf(" RECV_READY ");
}
if(Flags & fMP_RFD_RESOURCES)
{
dprintf(" RESOURCES ");
}
dprintf("\n");
if(Verbosity == 1)
{
PrintHwRfdDetails(pHwRfd);
}
}
void PrintHwRfdDetails(ULONG64 pHwRfd)
{
USHORT RfdStatus;
USHORT RfdCommand;
ULONG i;
InitTypeRead(pHwRfd, HW_RFD);
RfdStatus = (USHORT) ReadField(RfdCbHeader.CbStatus);
RfdCommand = (USHORT) ReadField(RfdCbHeader.CbCommand);
dprintf(" RfdCbHeader.CbStatus = 0x%04x", RfdStatus);
for(i = 0; i < sizeof(DbgRfdStatus)/sizeof(DBG_RFD_STATUS); i++)
{
if(RfdStatus & DbgRfdStatus[i].Val)
{
dprintf(", %s", DbgRfdStatus[i].Name);
}
}
dprintf("\n");
dprintf(" RfdCbHeader.CbCommand = %04x", RfdCommand);
for(i = 0; i < sizeof(DbgRfdCommand)/sizeof(DBG_RFD_COMMAND); i++)
{
if(RfdCommand & DbgRfdCommand[i].Val)
{
dprintf(", %s", DbgRfdCommand[i].Name);
}
}
dprintf("\n");
dprintf(" RfdCbHeader.CbLinkPointer = 0x%x\n", (ULONG)ReadField(RfdCbHeader.CbLinkPointer));
//dprintf(" RfdRbdPointer = 0x%x\n", (ULONG)ReadField(RfdRbdPointer));
dprintf(" RfdActualCount = %x , %d", (USHORT)ReadField(RfdActualCount), (USHORT)ReadField(RfdActualCount) & 0x3fff);
dprintf(", RfdSize = %d\n", (USHORT)ReadField(RfdSize));
}
DECLARE_API(recvpendlist)
{
ULONG64 pListHead;
ULONG64 pMpRfd;
ULONG64 pPacket;
int ArgCount = 0;
int index = 0;
if(*args)
{
ArgCount = sscanf(args,"%I64lx", &pListHead);
}
//check for arguments
if(ArgCount < 1)
{
dprintf("Usage: recvpendlist <RecvPendList address>\n");
return ;
}
SIGN_EXTEND(pListHead);
if(GetFieldValue(pListHead, "LIST_ENTRY", "Flink", pMpRfd))
{
dprintf("Failed to get LIST_ENTRY Flink at %p\n", pListHead);
return;
}
while(pMpRfd != pListHead)
{
dprintf(" (%d) pMpRfd %x :\n", index, pMpRfd);
PrintMpRfdDetails(pMpRfd, 0);
if(GetFieldValue(pMpRfd, "LIST_ENTRY", "Flink", pMpRfd))
{
dprintf("Failed to get LIST_ENTRY Flink at %p\n", pMpRfd);
break;
}
index++;
if(CheckControlC())
{
dprintf("***Control-C***\n");
break;
}
}
dprintf("RecvPendList has %d RFDs\n", index);
}
/**
Get 'size' bytes from the debuggee program at 'dwAddress' and place it
in our address space at 'ptr'. Use 'type' in an error printout if necessary
**/
BOOL GetData( IN LPVOID ptr, IN ULONG64 AddressPtr, IN ULONG size, IN PCSTR type )
{
BOOL b;
ULONG BytesRead;
ULONG count = size;
while(size > 0)
{
if(count >= 3000)
count = 3000;
b = ReadMemory(AddressPtr, ptr, count, &BytesRead );
if(!b || BytesRead != count)
{
dprintf( "Unable to read %u bytes at %X, for %s\n", size, AddressPtr, type );
return FALSE;
}
AddressPtr += count;
size -= count;
ptr = (LPVOID)((ULONG_PTR)ptr + count);
}
return TRUE;
}
/**
Routine to get offset and size of a "Field" of "Type" on a debugee machine. This uses
Ioctl call for type info.
Returns 0 on success, Ioctl error value otherwise.
**/
ULONG GetFieldOffsetAndSize(
IN LPSTR Type,
IN LPSTR Field,
OUT PULONG pOffset,
OUT PULONG pSize)
{
FIELD_INFO flds = {
Field, "", 0,
DBG_DUMP_FIELD_FULL_NAME | DBG_DUMP_FIELD_RETURN_ADDRESS | DBG_DUMP_FIELD_SIZE_IN_BITS,
0, NULL};
SYM_DUMP_PARAM Sym = {
sizeof (SYM_DUMP_PARAM), Type, DBG_DUMP_NO_PRINT, 0,
NULL, NULL, NULL, 1, &flds
};
ULONG Err, i=0;
LPSTR dot, last=Field;
Sym.nFields = 1;
Err = Ioctl( IG_DUMP_SYMBOL_INFO, &Sym, Sym.size );
*pOffset = (ULONG) (flds.address - Sym.addr);
*pSize = flds.size;
return Err;
}
ULONG GetUlongFromAddress (
ULONG64 Location)
{
ULONG Value;
ULONG result;
if((!ReadMemory(Location,&Value,sizeof(ULONG),&result)) ||
(result < sizeof(ULONG)))
{
dprintf("unable to read from %08x\n",Location);
return 0;
}
return Value;
}
ULONG64 GetPointerFromAddress(
ULONG64 Location)
{
ULONG64 Value;
ULONG result;
if(ReadPtr(Location,&Value))
{
dprintf("unable to read from %p\n",Location);
return 0;
}
return Value;
}
ULONG GetUlongValue (
PCHAR String)
{
ULONG64 Location;
ULONG Value;
ULONG result;
Location = GetExpression(String);
if(!Location)
{
dprintf("unable to get %s\n",String);
return 0;
}
return GetUlongFromAddress(Location);
}
ULONG64 GetPointerValue (
PCHAR String)
{
ULONG64 Location, Val=0;
Location = GetExpression(String);
if(!Location)
{
dprintf("unable to get %s\n",String);
return 0;
}
ReadPtr(Location, &Val);
return Val;
}
Reference in a new issue Copy permalink