You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1285 lines
34 KiB
1285 lines
34 KiB
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dma.c
|
|
|
|
Abstract:
|
|
|
|
WinDbg Extension Api
|
|
|
|
Author:
|
|
|
|
Eric Nelson (enelson) 05-April-2000
|
|
|
|
Environment:
|
|
|
|
User Mode
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
typedef struct _DBG_LIST_ENTRY {
|
|
ULONG64 Flink;
|
|
ULONG64 Blink;
|
|
} DBG_LIST_ENTRY, *PDBG_LIST_ENTRY;
|
|
|
|
#define GetDbgListEntry(Address, DbgListEntry) \
|
|
(GetFieldValue((Address), "LIST_ENTRY", "Blink", ((PDBG_LIST_ENTRY)(DbgListEntry))->Blink) || GetFieldValue((Address), "LIST_ENTRY", "Flink", ((PDBG_LIST_ENTRY)(DbgListEntry))->Flink))
|
|
|
|
#define RECUR DBG_DUMP_FIELD_RECUR_ON_THIS
|
|
#define COPY DBG_DUMP_FIELD_COPY_FIELD_DATA
|
|
#define NOFF DBG_DUMP_NO_OFFSET
|
|
#define NOIN DBG_DUMP_NO_INDENT
|
|
|
|
#define MAP_REGISTER_FILE_SIGNATURE 0xACEFD00D
|
|
|
|
//
|
|
// Flags for specifying dump levels
|
|
//
|
|
#define DMA_DUMP_BASIC 0x0
|
|
#define DMA_DUMP_ADAPTER_INFORMATION 0x1
|
|
#define DMA_DUMP_MAP_REGISTER 0x2
|
|
#define DMA_DUMP_COMMON_BUFFER 0x4
|
|
#define DMA_DUMP_TRANSFER_INFORMATION 0x8
|
|
#define DMA_DUMP_DEVICE_DESCRIPTION 0x10
|
|
#define DMA_DUMP_WCB 0x20
|
|
#define DMA_DUMP_MAX 0x100
|
|
|
|
|
|
PUCHAR DbgInterfaceTypes[] =
|
|
{
|
|
"Internal",
|
|
"Isa",
|
|
"Eisa",
|
|
"MicroChannel",
|
|
"TurboChannel",
|
|
"PCIBus",
|
|
"VMEBus",
|
|
"NuBus",
|
|
"PCMCIABus",
|
|
"CBus",
|
|
"MPIBus",
|
|
"MPSABus",
|
|
"ProcessorInternal",
|
|
"InternalPowerBus",
|
|
"PNPISABus",
|
|
"PNPBus"
|
|
};
|
|
#define MAX_INTERFACE 15
|
|
|
|
ULONG
|
|
DumpDmaAdapter(
|
|
IN ULONG64 Adapter,
|
|
IN ULONG Flags
|
|
);
|
|
|
|
ULONG
|
|
ValidateAdapter(
|
|
IN ULONG64 Address
|
|
);
|
|
|
|
ULONG
|
|
DumpMasterAdapter(
|
|
ULONG64 MasterAdapter
|
|
);
|
|
|
|
ULONG
|
|
DumpWcb(
|
|
IN ULONG64 CurrentWcb
|
|
);
|
|
|
|
VOID DmaUsage(
|
|
VOID
|
|
);
|
|
|
|
ULONG64
|
|
GetVerifierAdapterInformation(
|
|
ULONG64 Address
|
|
);
|
|
|
|
|
|
VOID
|
|
DumpVerifiedMapRegisterFiles(
|
|
IN ULONG64 MapRegisterFileListHead
|
|
);
|
|
|
|
VOID
|
|
DumpVerifiedCommonBuffers(
|
|
IN ULONG64 CommonBufferListHead
|
|
);
|
|
|
|
VOID
|
|
DumpVerifiedScatterGatherLists(
|
|
IN ULONG64 ScatterGatherListHead
|
|
);
|
|
|
|
VOID
|
|
DumpDeviceDescription(
|
|
IN ULONG64 DeviceDescription
|
|
);
|
|
|
|
VOID
|
|
DumpSymbolicAddress(
|
|
ULONG64 Address,
|
|
PUCHAR Buffer,
|
|
ULONG BufferSize,
|
|
BOOL AlwaysShowHex
|
|
)
|
|
{
|
|
ULONG64 displacement;
|
|
PCHAR s;
|
|
ULONG size;
|
|
|
|
Buffer[0] = '!';
|
|
GetSymbol((ULONG64)Address, Buffer, &displacement);
|
|
s = (PCHAR) Buffer + strlen( (PCHAR) Buffer );
|
|
if (BufferSize < strlen((PCHAR)Buffer)) {
|
|
return;
|
|
}
|
|
size = BufferSize - strlen((PCHAR)Buffer);
|
|
if (s == (PCHAR) Buffer) {
|
|
_snprintf( s, size, "0x%08x", Address );
|
|
}
|
|
else {
|
|
if (displacement != 0) {
|
|
_snprintf( s, size, "+0x%I64x", displacement );
|
|
}
|
|
if (AlwaysShowHex) {
|
|
_snprintf( s, size, " (0x%08x)", Address );
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
DECLARE_API( dma )
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dumps out 32-bit dma adapters
|
|
|
|
Arguments:
|
|
|
|
address
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
ULONG Offset;
|
|
ULONG Flags = 0;
|
|
|
|
ULONG64 Address = 0;
|
|
ULONG64 StartAddress = 0;
|
|
ULONG64 MasterAdapter = 0;
|
|
|
|
ULONG64 CallersAddress = 0;
|
|
ULONG64 AdapterInformation = 0;
|
|
|
|
DBG_LIST_ENTRY AdapterList = {0,0};
|
|
|
|
if (sscanf(args, "%lx %x", &Address, &Flags)) {
|
|
Address = GetExpression(args);
|
|
}
|
|
|
|
if (Flags > DMA_DUMP_MAX)
|
|
{
|
|
DmaUsage();
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
|
|
//
|
|
// Aha! Must not forget that we are in wierdo land and all 32 bit addresses
|
|
// must be sign extended to 64 bits. By order of the emperor.
|
|
//
|
|
if (!IsPtr64()) {
|
|
Address = (ULONG64)(LONG64)(LONG)Address;
|
|
}
|
|
|
|
|
|
if (Address)
|
|
//
|
|
// If we've been passed an adapter address, we are just printing out
|
|
// the single adapter
|
|
//
|
|
{
|
|
if (! ValidateAdapter(Address))
|
|
{
|
|
dprintf("\n%08p is not a valid adapter object\n",Address);
|
|
DmaUsage();
|
|
return E_INVALIDARG;
|
|
}
|
|
|
|
//
|
|
// Dump out info about the adapter
|
|
//
|
|
if (! DumpDmaAdapter(Address, Flags | DMA_DUMP_ADAPTER_INFORMATION))
|
|
{
|
|
return S_FALSE;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// A specific adapter address wasn't passed in so we are going to print out
|
|
// all adapters
|
|
//
|
|
|
|
//
|
|
// Find the address of the dma adapter list head
|
|
// This will also make sure that we are using the right
|
|
// version.
|
|
//
|
|
StartAddress = GetExpression("hal!HalpDmaAdapterList");
|
|
|
|
if (StartAddress == 0) {
|
|
dprintf("\nCould not find symbol hal!HalpDmaAdapterList.\n\n");
|
|
return S_OK;
|
|
}
|
|
|
|
//
|
|
// Determine the list entry offset we will use to calculate
|
|
// adapter addresses
|
|
//
|
|
if (GetFieldOffset("hal!_ADAPTER_OBJECT", "AdapterList", &Offset)) {
|
|
dprintf("\nError retrieving adapter list offset.\n\n");
|
|
return S_FALSE;
|
|
}
|
|
|
|
//
|
|
// Read the dma adapter list head
|
|
//
|
|
if (GetDbgListEntry(StartAddress, &AdapterList)) {
|
|
dprintf("\nError reading dma adapter list head: 0x%08p\n\n",
|
|
StartAddress);
|
|
return S_FALSE;
|
|
}
|
|
|
|
//
|
|
// Report the empty list case
|
|
//
|
|
if (AdapterList.Flink == StartAddress) {
|
|
dprintf("\nThe dma adapter list is empty.\n\n");
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// Enumerate and dump all dma adapters that do not use channels
|
|
//
|
|
MasterAdapter = 0;
|
|
|
|
|
|
dprintf("\nDumping all DMA adapters...\n\n");
|
|
|
|
while (AdapterList.Flink != StartAddress) {
|
|
|
|
Address = AdapterList.Flink - Offset;
|
|
|
|
DumpDmaAdapter(Address, Flags);
|
|
|
|
//
|
|
// Read the next adapter list entry
|
|
//
|
|
Address = AdapterList.Flink;
|
|
if (GetDbgListEntry(Address, &AdapterList)) {
|
|
dprintf("\nError reading adapter list entry: 0x%08p\n", Address);
|
|
break;
|
|
}
|
|
|
|
if (CheckControlC())
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
//
|
|
// Dump the master adapter
|
|
//
|
|
Address = GetExpression("hal!MasterAdapter32");
|
|
|
|
if (Address) {
|
|
|
|
if (Flags & DMA_DUMP_ADAPTER_INFORMATION) {
|
|
|
|
DumpMasterAdapter(Address);
|
|
|
|
} else {
|
|
|
|
dprintf("Master adapter: %08p\n", Address);
|
|
}
|
|
|
|
} else {
|
|
|
|
dprintf("\nCould not find symbol hal!MasterAdapter32.\n");
|
|
}
|
|
|
|
|
|
dprintf("\n");
|
|
|
|
return S_OK;
|
|
} // ! dma //
|
|
|
|
ULONG
|
|
DumpDmaAdapter(
|
|
IN ULONG64 Adapter,
|
|
IN ULONG Flags
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given the address of a hal!_ADAPTER_OBJECT, this routine dumps
|
|
out all the useful information to the debugger
|
|
|
|
Arguments:
|
|
|
|
Adapter - Physical address of a hal!_ADAPTER_OBJECT in debuggee
|
|
Flags - What kind of information we want to print
|
|
|
|
Return Value:
|
|
|
|
Returns 0 on SUCCESS
|
|
|
|
--*/
|
|
{
|
|
|
|
ULONG64 AdapterInformation = 0;
|
|
|
|
ULONG64 AllocatedAdapterChannels = 0, FreedAdapterChannels = 0;
|
|
|
|
AdapterInformation = GetVerifierAdapterInformation(Adapter);
|
|
|
|
//
|
|
// Print out: Adapter: <adapter> [<module allocating adapter>!CallingFunction+0x<offset>]
|
|
// (the part in brackets only shows up when we have dma verifier enabled for this adapter)
|
|
//
|
|
dprintf("Adapter: %08p ", Adapter);
|
|
|
|
|
|
if (AdapterInformation)
|
|
{
|
|
ULONG64 CallingAddress = 0;
|
|
CHAR CallerName[256];
|
|
|
|
CallerName[sizeof(CallerName) - 1] = 0;
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","CallingAddress", CallingAddress);
|
|
|
|
if(CallingAddress)
|
|
{
|
|
|
|
DumpSymbolicAddress(CallingAddress, CallerName, sizeof(CallerName) - 1, TRUE);
|
|
dprintf(" Owner: %s",CallerName);
|
|
}
|
|
|
|
}
|
|
dprintf("\n");
|
|
|
|
|
|
if (Flags & DMA_DUMP_ADAPTER_INFORMATION)
|
|
{
|
|
ULONG64 MasterAdapter = 0;
|
|
ULONG64 MapRegistersPerChannel = 0;
|
|
ULONG64 AdapterBaseVa = 0;
|
|
ULONG64 MapRegisterBase = 0;
|
|
ULONG64 CommittedMapRegisters = 0;
|
|
ULONG64 NumberOfMapRegisters = 0;
|
|
ULONG64 CurrentWcb = 0;
|
|
|
|
GetFieldValue(Adapter, "hal!_ADAPTER_OBJECT","MasterAdapter", MasterAdapter);
|
|
GetFieldValue(Adapter, "hal!_ADAPTER_OBJECT","MapRegistersPerChannel", MapRegistersPerChannel);
|
|
GetFieldValue(Adapter, "hal!_ADAPTER_OBJECT","AdapterBaseVa", AdapterBaseVa);
|
|
GetFieldValue(Adapter, "hal!_ADAPTER_OBJECT","MapRegisterBase", MapRegisterBase);
|
|
GetFieldValue(Adapter, "hal!_ADAPTER_OBJECT","CommittedMapRegisters", CommittedMapRegisters);
|
|
GetFieldValue(Adapter, "hal!_ADAPTER_OBJECT","NumberOfMapRegisters", NumberOfMapRegisters);
|
|
GetFieldValue(Adapter, "hal!_ADAPTER_OBJECT","CurrentWcb", CurrentWcb);
|
|
|
|
|
|
|
|
dprintf(" MasterAdapter: %08p\n", MasterAdapter);
|
|
dprintf(" Adapter base Va %08p\n", AdapterBaseVa);
|
|
dprintf(" Map register base: %08p\n", MapRegisterBase);
|
|
dprintf(" WCB: %08p\n", CurrentWcb);
|
|
dprintf(" Map registers: %08p mapped, %08p allocated, %08p max\n",
|
|
CommittedMapRegisters, NumberOfMapRegisters, MapRegistersPerChannel);
|
|
|
|
|
|
|
|
if (AdapterInformation) {
|
|
//
|
|
// Adapter is being verified
|
|
//
|
|
|
|
ULONG64 DeviceObject = 0;
|
|
ULONG64 AllocatedMapRegisters = 0, ActiveMapRegisters = 0;
|
|
ULONG64 AllocatedScatterGatherLists = 0, ActiveScatterGatherLists = 0;
|
|
ULONG64 AllocatedCommonBuffers = 0, FreedCommonBuffers = 0;
|
|
|
|
ULONG64 MappedTransferWithoutFlushing = 0;
|
|
BOOLEAN Inactive = 0;
|
|
|
|
|
|
|
|
|
|
//
|
|
// If this adapter is being verified, get the dma verifier info we need
|
|
//
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","DeviceObject", DeviceObject);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","AllocatedMapRegisters", AllocatedMapRegisters);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","ActiveMapRegisters", ActiveMapRegisters);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","AllocatedScatterGatherLists", AllocatedScatterGatherLists);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","ActiveScatterGatherLists", ActiveScatterGatherLists);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","AllocatedCommonBuffers", AllocatedCommonBuffers);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","FreedCommonBuffers", FreedCommonBuffers);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","AllocatedAdapterChannels", AllocatedAdapterChannels);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","FreedAdapterChannels", FreedAdapterChannels);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","MappedTransferWithoutFlushing", MappedTransferWithoutFlushing);
|
|
GetFieldValue(AdapterInformation, "nt!_ADAPTER_INFORMATION","Inactive", Inactive);
|
|
|
|
|
|
|
|
dprintf("\n Dma verifier additional information:\n");
|
|
|
|
if (Inactive)
|
|
dprintf("\n This adapter has been freed!\n\n");
|
|
|
|
dprintf(" DeviceObject: %08p\n", DeviceObject);
|
|
dprintf(" Map registers: %08p allocated, %08p freed\n", AllocatedMapRegisters,
|
|
AllocatedMapRegisters - ActiveMapRegisters);
|
|
|
|
dprintf(" Scatter-gather lists: %08p allocated, %08p freed\n", AllocatedScatterGatherLists,
|
|
AllocatedScatterGatherLists - ActiveScatterGatherLists);
|
|
dprintf(" Common buffers: %08p allocated, %08p freed\n", AllocatedCommonBuffers, FreedCommonBuffers);
|
|
dprintf(" Adapter channels: %08p allocated, %08p freed\n", AllocatedAdapterChannels, FreedAdapterChannels);
|
|
dprintf(" Bytes mapped since last flush: %08p\n", MappedTransferWithoutFlushing);
|
|
|
|
dprintf("\n");
|
|
|
|
} // Dma verifier enabled for adapter //
|
|
|
|
} // Flags & DMA_DUMP_ADAPTER_INFORMATION //
|
|
|
|
|
|
|
|
if (CheckControlC())
|
|
return TRUE;
|
|
|
|
if (Flags & DMA_DUMP_MAP_REGISTER && AdapterInformation) {
|
|
ULONG64 MapRegisterFileListHead = 0;
|
|
ULONG Offset;
|
|
|
|
|
|
if ( ! GetFieldOffset("nt!_ADAPTER_INFORMATION",
|
|
"MapRegisterFiles.ListEntry",
|
|
&Offset
|
|
)) {
|
|
|
|
|
|
MapRegisterFileListHead = AdapterInformation + Offset;
|
|
|
|
DumpVerifiedMapRegisterFiles(MapRegisterFileListHead);
|
|
}
|
|
}
|
|
|
|
if (CheckControlC())
|
|
return TRUE;
|
|
|
|
if (Flags & DMA_DUMP_COMMON_BUFFER && AdapterInformation) {
|
|
ULONG64 CommonBufferListHead = 0;
|
|
ULONG Offset;
|
|
|
|
if ( ! GetFieldOffset("nt!_ADAPTER_INFORMATION",
|
|
"CommonBuffers.ListEntry",
|
|
&Offset
|
|
)) {
|
|
|
|
CommonBufferListHead = AdapterInformation + Offset;
|
|
|
|
DumpVerifiedCommonBuffers(CommonBufferListHead);
|
|
|
|
}
|
|
}
|
|
|
|
if (CheckControlC())
|
|
return TRUE;
|
|
|
|
#if 0
|
|
if (Flags & DMA_DUMP_SCATTER_GATHER && AdapterInformation) {
|
|
ULONG64 ScatterGatherListHead = 0;
|
|
ULONG Offset;
|
|
|
|
if ( ! GetFieldOffset("nt!_ADAPTER_INFORMATION",
|
|
"ScatterGatherLists.ListEntry",
|
|
&Offset
|
|
)) {
|
|
|
|
ScatterGatherListHead = AdapterInformation + Offset;
|
|
|
|
DumpVerifiedScatterGatherLists(ScatterGatherListHead);
|
|
}
|
|
}
|
|
#endif
|
|
if (CheckControlC())
|
|
return TRUE;
|
|
|
|
|
|
if (Flags & DMA_DUMP_DEVICE_DESCRIPTION && AdapterInformation)
|
|
{
|
|
ULONG64 DeviceDescription;
|
|
ULONG Offset;
|
|
|
|
if ( ! GetFieldOffset("nt!_ADAPTER_INFORMATION",
|
|
"DeviceDescription",
|
|
&Offset
|
|
)) {
|
|
|
|
DeviceDescription = AdapterInformation + Offset;
|
|
|
|
DumpDeviceDescription(DeviceDescription);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
if (CheckControlC())
|
|
return TRUE;
|
|
|
|
|
|
if (Flags & DMA_DUMP_WCB ) {
|
|
|
|
if (! AdapterInformation) {
|
|
ULONG64 CurrentWcb = 0;
|
|
|
|
GetFieldValue(Adapter, "hal!_ADAPTER_OBJECT","CurrentWcb", CurrentWcb);
|
|
|
|
if (CurrentWcb)
|
|
DumpWcb(CurrentWcb);
|
|
}
|
|
else if (AllocatedAdapterChannels > FreedAdapterChannels && Flags & DMA_DUMP_WCB )
|
|
{
|
|
|
|
//DumpVerifiedWcb(Wcb)
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
ULONG
|
|
DumpMasterAdapter(
|
|
ULONG64 MasterAdapter
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given the address of a hal!_MASTER_ADAPTER_OBJECT, this routine dumps
|
|
out all the useful information to the debugger
|
|
|
|
Arguments:
|
|
|
|
MasterAdapter - Physical address of a hal!_MASTER_ADAPTER_OBJECT
|
|
in debuggee
|
|
|
|
Return Value:
|
|
|
|
Returns 0 on SUCCESS
|
|
|
|
--*/
|
|
{
|
|
FIELD_INFO MasterAdapterFields[] = {
|
|
{ "AdapterObject", NULL, 0, 0, 0, 0 },
|
|
{ "MaxBufferPages", NULL, 0, 0, 0, 0 },
|
|
{ "MapBufferSize", NULL, 0, 0, 0, 0 },
|
|
{ "MapBufferPhysicalAddress", NULL, RECUR, 0, 0, 0 },
|
|
{ "MapBufferPhysicalAddress.HighPart", NULL, 0, 0, 0, 0 },
|
|
{ "MapBufferPhysicalAddress.LowPart", NULL, 0, 0, 0, 0 }
|
|
};
|
|
|
|
SYM_DUMP_PARAM MasterAdapterDumpParams = {
|
|
sizeof(SYM_DUMP_PARAM), "hal!_MASTER_ADAPTER_OBJECT", NOFF,
|
|
MasterAdapter, NULL, NULL, NULL,
|
|
sizeof(MasterAdapterFields) / sizeof(FIELD_INFO),
|
|
&MasterAdapterFields[0]
|
|
};
|
|
|
|
//
|
|
// This is so gnarly, dump all the cool stuff for me!
|
|
//
|
|
dprintf("\nMaster DMA adapter: 0x%08p\n", MasterAdapter);
|
|
if ((Ioctl(IG_DUMP_SYMBOL_INFO,
|
|
&MasterAdapterDumpParams,
|
|
MasterAdapterDumpParams.size))) {
|
|
dprintf("\nError reading master adapter: 0x%08p\n", MasterAdapter);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
ULONG
|
|
DumpWcb(
|
|
IN ULONG64 Wcb
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given the address of a hal!_WAIT_CONTEXT_BLOCK, this routine dumps
|
|
out all the useful information to the debugger
|
|
|
|
Arguments:
|
|
|
|
Wcb - Physical address of a hal!_WAIT_CONTEXT_BLOCK in debuggee
|
|
|
|
Return Value:
|
|
|
|
Returns 0 on SUCCESS
|
|
|
|
--*/
|
|
{
|
|
FIELD_INFO WcbFields[] = {
|
|
{ "DeviceRoutine", NULL, 0, 0, 0, 0 },
|
|
{ "NumberOfMapRegisters", NULL, 0, 0, 0, 0 }
|
|
};
|
|
|
|
SYM_DUMP_PARAM WcbDumpParams = {
|
|
sizeof(SYM_DUMP_PARAM), "hal!_WAIT_CONTEXT_BLOCK", NOFF, Wcb, NULL,
|
|
NULL, NULL, sizeof(WcbFields) / sizeof(FIELD_INFO), &WcbFields[0]
|
|
};
|
|
|
|
//
|
|
// This is so gnarly, dump all the cool stuff for me!
|
|
//
|
|
dprintf(" Wait context block: 0x%08p (may be free)\n", Wcb);
|
|
if ((Ioctl(IG_DUMP_SYMBOL_INFO,
|
|
&WcbDumpParams,
|
|
WcbDumpParams.size))) {
|
|
dprintf("\nError reading wait context block: 0x%08p\n", Wcb);
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
ULONG
|
|
ValidateAdapter(
|
|
IN ULONG64 Address
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Figures out whether this is a valid adapter.
|
|
|
|
Arguments:
|
|
|
|
Address -- Address of what we think may be an adapter object.
|
|
|
|
Return Value:
|
|
|
|
TRUE -- Valid adapter.
|
|
FALSE -- Not a valid adapter.
|
|
|
|
--*/
|
|
{
|
|
DBG_LIST_ENTRY AdapterList = {0,0};
|
|
ULONG64 StartAddress = 0;
|
|
ULONG64 CurrentAddress = 0;
|
|
|
|
ULONG Offset;
|
|
|
|
if (! Address )
|
|
return FALSE;
|
|
|
|
|
|
//
|
|
// Find the address of the dma adapter list head
|
|
// This will also make sure that we are using the right
|
|
// version.
|
|
//
|
|
StartAddress = GetExpression("hal!HalpDmaAdapterList");
|
|
|
|
if (StartAddress == 0) {
|
|
dprintf("\nCould not find symbol hal!HalpDmaAdapterList.\n\n");
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Determine the list entry offset we will use to calculate
|
|
// adapter addresses
|
|
//
|
|
if (GetFieldOffset("hal!_ADAPTER_OBJECT", "AdapterList", &Offset)) {
|
|
dprintf("\nError retrieving adapter list offset.\n\n");
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// Read the dma adapter list head
|
|
//
|
|
if (GetDbgListEntry(StartAddress, &AdapterList)) {
|
|
dprintf("\nError reading dma adapter list head: 0x%08p\n\n",
|
|
StartAddress);
|
|
return FALSE;
|
|
}
|
|
|
|
while (AdapterList.Flink != StartAddress) {
|
|
|
|
|
|
CurrentAddress = AdapterList.Flink - Offset;
|
|
|
|
if (Address == CurrentAddress) {
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//
|
|
// Read the next adapter list entry
|
|
//
|
|
CurrentAddress = AdapterList.Flink;
|
|
if (GetDbgListEntry(CurrentAddress, &AdapterList)) {
|
|
dprintf("\nError reading adapter list entry: 0x%08p\n", AdapterList);
|
|
break;
|
|
}
|
|
|
|
|
|
if (CheckControlC())
|
|
break;
|
|
}
|
|
|
|
|
|
//
|
|
// Check to see if we have the master adapter
|
|
//
|
|
CurrentAddress = GetExpression("hal!MasterAdapter32");
|
|
if(CurrentAddress == Address)
|
|
return TRUE;
|
|
|
|
|
|
//
|
|
// Check to see if it is on the verifier adapter list ...
|
|
// we leave adapters that have been 'put' there so that
|
|
// we can catch drivers that do dma after puting the adapter.
|
|
//
|
|
if (GetVerifierAdapterInformation(Address))
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
} // ValidateAdapter //
|
|
|
|
|
|
VOID DmaUsage(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Prints out correct usage for !dma
|
|
|
|
Arguments:
|
|
|
|
NONE
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
{
|
|
|
|
dprintf("\nUsage: !dma [adapter address] [flags]\n");
|
|
dprintf("Where: [adapter address] is address of specific dma adapter\n");
|
|
dprintf(" or 0x0 for all adapters\n");
|
|
dprintf(" [flags] are:\n");
|
|
dprintf(" 0x1: Dump generic adapter information\n");
|
|
dprintf(" 0x2: Dump map register information\n");
|
|
dprintf(" 0x4: Dump common buffer information\n");
|
|
dprintf(" 0x8: Dump scatter-gather list information\n");
|
|
dprintf(" 0x10: Dump device description for device\n");
|
|
dprintf(" 0x20: Dump Wait-context-block information\n");
|
|
dprintf("Note: flags {2,4,8,10} require dma verifier to be enabled for the adapter\n\n");
|
|
|
|
|
|
} // DmaUsage //
|
|
|
|
ULONG64
|
|
GetVerifierAdapterInformation(
|
|
ULONG64 AdapterAddress
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds out whether the adapter at AdapterAddress is being verified. If it is, return a pointer
|
|
to the ADAPTER_INFORMATION structure corresponding to the adapter.
|
|
|
|
Arguments:
|
|
|
|
AdapterAddress -- Address of the adapter we are trying to find out if it is being verified
|
|
|
|
Return Value:
|
|
|
|
ULONG64 -- Address of ADAPTER_INFORMATION struct for verified adapter
|
|
0 -- Not verifying adapter;
|
|
|
|
--*/
|
|
{
|
|
DBG_LIST_ENTRY AdapterInfoList = {0,0};
|
|
ULONG64 StartAddress = 0;
|
|
ULONG64 CurrentAdapter = 0;
|
|
ULONG64 CurrentAdapterInfo = 0;
|
|
|
|
ULONG64 VerifiedDmaAdapter = 0;
|
|
ULONG ListEntryOffset = 0;
|
|
|
|
UINT64 VerifyingDma = 0;
|
|
|
|
if (! AdapterAddress )
|
|
return 0;
|
|
|
|
|
|
ReadPointer(GetExpression("nt!ViVerifyDma"), &VerifyingDma);
|
|
if (0 == VerifyingDma)
|
|
//
|
|
// Not verifying dma ...
|
|
//
|
|
{
|
|
return 0;
|
|
}
|
|
//
|
|
// Find the address of the dma adapter list head
|
|
//
|
|
|
|
StartAddress = GetExpression("nt!ViAdapterList");
|
|
|
|
if (StartAddress == 0) {
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Determine the list entry offset we will use to calculate
|
|
// adapter addresses
|
|
//
|
|
if (GetFieldOffset("nt!_ADAPTER_INFORMATION", "ListEntry", &ListEntryOffset)) {
|
|
dprintf("\nError retrieving verifier adapter information list offset.\n\n");
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Read the dma adapter list head
|
|
//
|
|
if (GetDbgListEntry(StartAddress, &AdapterInfoList)) {
|
|
dprintf("\nError reading verifier adapter information list head: 0x%08p\n\n",
|
|
StartAddress);
|
|
return 0;
|
|
}
|
|
|
|
if (AdapterInfoList.Flink == 0 || AdapterInfoList.Blink == 0)
|
|
return 0;
|
|
|
|
while (AdapterInfoList.Flink != StartAddress) {
|
|
|
|
CurrentAdapterInfo = AdapterInfoList.Flink - ListEntryOffset;
|
|
|
|
GetFieldValue(CurrentAdapterInfo, "nt!_ADAPTER_INFORMATION","DmaAdapter", VerifiedDmaAdapter);
|
|
|
|
if (AdapterAddress == VerifiedDmaAdapter)
|
|
{
|
|
return CurrentAdapterInfo;
|
|
}
|
|
//
|
|
// Read the next adapter list entry
|
|
//
|
|
if (GetDbgListEntry(AdapterInfoList.Flink, &AdapterInfoList)) {
|
|
dprintf("\nError reading adapter info list entry: 0x%08p\n", AdapterInfoList);
|
|
break;
|
|
}
|
|
|
|
|
|
if (CheckControlC())
|
|
break;
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
|
} // GetVerifierAdapterInformation //
|
|
|
|
|
|
|
|
VOID
|
|
DumpVerifiedMapRegisterFiles(
|
|
IN ULONG64 MapRegisterFileListHead
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dump pertinent info pertaining to verified map registers.
|
|
NOTE: This may not be all map registers for the adapter -- just the ones
|
|
that are being verified. There is a limit to how many map registers
|
|
we verify for each adapter -- since each time we use three pages
|
|
of physical memory.
|
|
|
|
NOTE ON TERMINOLOGY: Map register file: a single allocation of map registers
|
|
recieved in the callback routine from IoAllocateAdapterChannel. Any number
|
|
or combination of these registers can be mapped at one time.
|
|
|
|
Arguments:
|
|
|
|
MapRegisterFileListHead -- head of list of map register files.
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
|
|
{
|
|
DBG_LIST_ENTRY MapRegisterFileListEntry = {0,0};
|
|
ULONG64 MapRegisterFile = 0;
|
|
|
|
ULONG ListEntryOffset = 0;
|
|
|
|
ULONG64 Signature = 0;
|
|
ULONG64 NumberOfMapRegisters = 0;
|
|
ULONG64 NumberOfRegistersMapped = 0;
|
|
ULONG64 MapRegisterMdl = 0;
|
|
|
|
ULONG64 MapRegister;
|
|
|
|
ULONG64 MappedToAddress;
|
|
ULONG64 BytesMapped;
|
|
ULONG64 MapRegisterStart;
|
|
|
|
ULONG SizeofMapRegister;
|
|
ULONG CurrentMapRegister;
|
|
ULONG MapRegisterOffset;
|
|
|
|
|
|
if (GetDbgListEntry(MapRegisterFileListHead, &MapRegisterFileListEntry))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (MapRegisterFileListEntry.Flink == MapRegisterFileListHead)
|
|
//
|
|
// Empty list
|
|
//
|
|
{
|
|
dprintf("\n No map register files\n\n");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Determine the list entry offset we will use to calculate
|
|
// the beginning of the map register file
|
|
//
|
|
if (GetFieldOffset("nt!_MAP_REGISTER_FILE", "ListEntry", &ListEntryOffset)) {
|
|
dprintf("\nError retrieving list entry offset.\n\n");
|
|
return;
|
|
}
|
|
|
|
SizeofMapRegister = GetTypeSize("nt!_MAP_REGISTER");
|
|
if (! SizeofMapRegister )
|
|
{
|
|
dprintf("\n Could not get size of nt!_MAP_REGISTER\n\n");
|
|
return;
|
|
}
|
|
|
|
|
|
if (GetFieldOffset("nt!_MAP_REGISTER_FILE","MapRegisters", &MapRegisterOffset))
|
|
{
|
|
dprintf("\n Couuld not get map register offset\n\n");
|
|
}
|
|
|
|
while (MapRegisterFileListEntry.Flink != MapRegisterFileListHead) {
|
|
|
|
MapRegisterFile = MapRegisterFileListEntry.Flink - ListEntryOffset;
|
|
|
|
GetFieldValue(MapRegisterFile, "nt!_MAP_REGISTER_FILE","Signature", Signature);
|
|
|
|
if (((ULONG) Signature) != MAP_REGISTER_FILE_SIGNATURE) {
|
|
dprintf("\n Invalid signature for map register file %08p\n\n", MapRegisterFile);
|
|
return;
|
|
}
|
|
|
|
GetFieldValue(MapRegisterFile, "nt!_MAP_REGISTER_FILE","NumberOfMapRegisters", NumberOfMapRegisters);
|
|
GetFieldValue(MapRegisterFile, "nt!_MAP_REGISTER_FILE","NumberOfRegistersMapped", NumberOfRegistersMapped);
|
|
GetFieldValue(MapRegisterFile, "nt!_MAP_REGISTER_FILE","MapRegisterMdl", MapRegisterMdl);
|
|
|
|
|
|
|
|
|
|
dprintf(" Map register file %08p (%x/%x mapped)\n",
|
|
MapRegisterFile, (ULONG) NumberOfRegistersMapped, (ULONG) NumberOfMapRegisters);
|
|
dprintf(" Double buffer mdl: %08p\n", MapRegisterMdl);
|
|
dprintf(" Map registers:\n");
|
|
|
|
MapRegister = MapRegisterFile + MapRegisterOffset;
|
|
for (CurrentMapRegister = 0; CurrentMapRegister < NumberOfMapRegisters; CurrentMapRegister++) {
|
|
GetFieldValue(MapRegister, "nt!_MAP_REGISTER", "MappedToSa", MappedToAddress);
|
|
GetFieldValue(MapRegister, "nt!_MAP_REGISTER", "BytesMapped", BytesMapped);
|
|
|
|
dprintf(" %08x: ", MapRegister);
|
|
//dprintf(" %03x: ", CurrentMapRegister);
|
|
if (BytesMapped) {
|
|
|
|
dprintf("%04x bytes mapped to %08p\n", (ULONG) BytesMapped, MappedToAddress);
|
|
|
|
} else {
|
|
|
|
dprintf("Not mapped\n");
|
|
}
|
|
|
|
if (CheckControlC())
|
|
return;
|
|
//
|
|
// Increment our map register pointer
|
|
//
|
|
MapRegister += SizeofMapRegister;
|
|
} // End dump of map registers //
|
|
|
|
dprintf("\n");
|
|
|
|
|
|
//
|
|
// Advance to the next map register file
|
|
//
|
|
if (GetDbgListEntry(MapRegisterFileListEntry.Flink , &MapRegisterFileListEntry)) {
|
|
|
|
dprintf("\nError reading map register file list entry: 0x%08p\n",
|
|
MapRegisterFileListEntry.Flink);
|
|
break;
|
|
}
|
|
|
|
if (CheckControlC())
|
|
return;
|
|
|
|
} // End dump of map register files //
|
|
|
|
|
|
return;
|
|
} // DumpVerifiedMapRegisterFiles //
|
|
|
|
VOID
|
|
DumpVerifiedCommonBuffers(
|
|
IN ULONG64 CommonBufferListHead
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dump pertinent info pertaining to verified common buffers
|
|
|
|
Arguments:
|
|
|
|
CommonBufferListHead -- head of list of common buffers for a single adapter
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
{
|
|
DBG_LIST_ENTRY CommonBufferListEntry = {0,0};
|
|
|
|
ULONG64 CommonBuffer;
|
|
ULONG AdvertisedLength;
|
|
|
|
UINT64 AdvertisedStartAddress;
|
|
UINT64 RealStartAddress;
|
|
UINT64 RealLogicalStartAddress;
|
|
UINT64 AdvertisedLogicalStartAddress;
|
|
|
|
UINT64 AllocatorAddress;
|
|
|
|
ULONG ListEntryOffset;
|
|
CHAR AllocatorName[256];
|
|
|
|
AllocatorName[sizeof(AllocatorName) - 1] = 0;
|
|
|
|
if (GetDbgListEntry(CommonBufferListHead, &CommonBufferListEntry))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (CommonBufferListEntry.Flink == CommonBufferListHead)
|
|
//
|
|
// Empty list
|
|
//
|
|
{
|
|
dprintf("\n No common buffers\n\n");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Determine the list entry offset we will use to calculate
|
|
// the beginning of the map register file
|
|
//
|
|
if (GetFieldOffset("nt!_HAL_VERIFIER_BUFFER", "ListEntry", &ListEntryOffset)) {
|
|
dprintf("\n Error retrieving list entry offset.\n\n");
|
|
return;
|
|
}
|
|
|
|
while (CommonBufferListEntry.Flink != CommonBufferListHead) {
|
|
|
|
CommonBuffer = CommonBufferListEntry.Flink - ListEntryOffset;
|
|
|
|
|
|
GetFieldValue(CommonBuffer, "nt!_HAL_VERIFIER_BUFFER","AdvertisedLength", AdvertisedLength);
|
|
GetFieldValue(CommonBuffer, "nt!_HAL_VERIFIER_BUFFER","AdvertisedStartAddress", AdvertisedStartAddress);
|
|
GetFieldValue(CommonBuffer, "nt!_HAL_VERIFIER_BUFFER","RealStartAddress", RealStartAddress);
|
|
GetFieldValue(CommonBuffer, "nt!_HAL_VERIFIER_BUFFER","RealLogicalStartAddress", RealLogicalStartAddress);
|
|
GetFieldValue(CommonBuffer, "nt!_HAL_VERIFIER_BUFFER","AllocatorAddress", AllocatorAddress);
|
|
|
|
DumpSymbolicAddress(AllocatorAddress, AllocatorName, sizeof(AllocatorName) - 1, TRUE);
|
|
|
|
dprintf(" Common buffer allocated by %s:\n", AllocatorName);
|
|
|
|
dprintf(" Length: %x\n", AdvertisedLength);
|
|
dprintf(" Virtual address: %08p\n", AdvertisedStartAddress);
|
|
dprintf(" Physical address: %I64lx\n",
|
|
(AdvertisedStartAddress - RealStartAddress) + RealLogicalStartAddress);
|
|
|
|
dprintf("\n");
|
|
//
|
|
// Advance to the next common buffer in the list
|
|
//
|
|
if (GetDbgListEntry(CommonBufferListEntry.Flink , &CommonBufferListEntry)) {
|
|
|
|
dprintf("\nError reading common buffer list entry: 0x%08p\n",
|
|
CommonBufferListEntry.Flink);
|
|
break;
|
|
}
|
|
|
|
if (CheckControlC())
|
|
return;
|
|
|
|
} // End dump of common buffers //
|
|
|
|
|
|
return;
|
|
} // DumpVerifiedCommonBuffers //
|
|
|
|
VOID
|
|
DumpVerifiedScatterGatherLists(
|
|
IN ULONG64 ScatterGatherListHead
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dump pertinent info pertaining to scatter gather lists in use by a single
|
|
adapter.
|
|
|
|
Arguments:
|
|
|
|
ScatterGatherListHead -- head of a list of ScatterGather lists.
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
{
|
|
UNREFERENCED_PARAMETER(ScatterGatherListHead);
|
|
|
|
return;
|
|
} // DumpVerifiedScatterGatherLists //
|
|
|
|
VOID
|
|
DumpDeviceDescription(
|
|
IN ULONG64 DeviceDescription
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Dump pertinent info from a device description struct
|
|
|
|
Arguments:
|
|
|
|
ScatterGatherListHead -- head of a list of ScatterGather lists.
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
{
|
|
ULONG Version;
|
|
BOOLEAN Master;
|
|
BOOLEAN ScatterGather;
|
|
BOOLEAN Dma32BitAddresses;
|
|
BOOLEAN Dma64BitAddresses;
|
|
ULONG InterfaceType;
|
|
ULONG MaximumLength;
|
|
|
|
|
|
GetFieldValue(DeviceDescription, "hal!_DEVICE_DESCRIPTION","Version", Version);
|
|
|
|
if (Version > 2) {
|
|
dprintf("\nBad device description version: %x\n\n", Version);
|
|
return;
|
|
}
|
|
|
|
GetFieldValue(DeviceDescription, "hal!_DEVICE_DESCRIPTION","Master", Master);
|
|
GetFieldValue(DeviceDescription, "hal!_DEVICE_DESCRIPTION","ScatterGather", ScatterGather);
|
|
GetFieldValue(DeviceDescription, "hal!_DEVICE_DESCRIPTION","Dma32BitAddresses", Dma32BitAddresses);
|
|
GetFieldValue(DeviceDescription, "hal!_DEVICE_DESCRIPTION","Dma64BitAddresses", Dma64BitAddresses);
|
|
GetFieldValue(DeviceDescription, "hal!_DEVICE_DESCRIPTION","InterfaceType", InterfaceType);
|
|
|
|
dprintf(" Device Description Version %02x\n", Version);
|
|
|
|
if (InterfaceType < MAX_INTERFACE) {
|
|
|
|
dprintf(" Interface type %s\n", DbgInterfaceTypes[InterfaceType]);
|
|
|
|
} else {
|
|
|
|
dprintf(" Interface type unknown\n");
|
|
|
|
}
|
|
|
|
dprintf(" DMA Capabilities:\n");
|
|
|
|
if(Master) {
|
|
dprintf(" Busmaster\n");
|
|
} else {
|
|
dprintf(" Slave\n");
|
|
}
|
|
|
|
if (ScatterGather)
|
|
dprintf(" Scatter Gather\n");
|
|
|
|
if (Dma32BitAddresses)
|
|
dprintf(" 32-bit DMA\n");
|
|
if (Dma64BitAddresses)
|
|
dprintf(" 64-bit DMA\n");
|
|
if (! Dma32BitAddresses && ! Dma64BitAddresses)
|
|
dprintf(" 24-bit DMA only\n");
|
|
|
|
dprintf("\n");
|
|
|
|
|
|
|
|
|
|
} // DumpDeviceDescription //
|
|
|