archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/base/tools/kdexts2/devnode.c

6184 lines
184 KiB
Raw Blame History

/*++
Copyright (c) 1997-2000 Microsoft Corporation
Module Name:
devnode.c
Abstract:
WinDbg Extension Api
Revision History:
--*/
#include "precomp.h"
//#include "pci.h"
#pragma hdrstop
#include "stddef.h"
#include <initguid.h>
#include "devnode.h"
#define FLAG_NAME(flag) {flag, # flag}
FLAG_NAME DeviceNodeFlags[] = {
FLAG_NAME(DNF_MADEUP), // 00000001
FLAG_NAME(DNF_DUPLICATE), // 00000002
FLAG_NAME(DNF_HAL_NODE), // 00000004
FLAG_NAME(DNF_REENUMERATE), // 00000008
FLAG_NAME(DNF_ENUMERATED), // 00000010
FLAG_NAME(DNF_IDS_QUERIED), // 00000020
FLAG_NAME(DNF_HAS_BOOT_CONFIG), // 00000040
FLAG_NAME(DNF_BOOT_CONFIG_RESERVED), // 00000080
FLAG_NAME(DNF_NO_RESOURCE_REQUIRED), // 00000100
FLAG_NAME(DNF_RESOURCE_REQUIREMENTS_NEED_FILTERED), // 00000200
FLAG_NAME(DNF_RESOURCE_REQUIREMENTS_CHANGED), // 00000400
FLAG_NAME(DNF_NON_STOPPED_REBALANCE), // 00000800
FLAG_NAME(DNF_LEGACY_DRIVER), // 00001000
FLAG_NAME(DNF_HAS_PROBLEM), // 00002000
FLAG_NAME(DNF_HAS_PRIVATE_PROBLEM), // 00004000
FLAG_NAME(DNF_HARDWARE_VERIFICATION), // 00008000
FLAG_NAME(DNF_DEVICE_GONE), // 00010000
FLAG_NAME(DNF_LEGACY_RESOURCE_DEVICENODE), // 00020000
FLAG_NAME(DNF_NEEDS_REBALANCE), // 00040000
FLAG_NAME(DNF_LOCKED_FOR_EJECT), // 00080000
FLAG_NAME(DNF_DRIVER_BLOCKED), // 00100000
{0,0}
};
FLAG_NAME DeviceNodeUserFlags[] = {
FLAG_NAME(DNUF_WILL_BE_REMOVED), // 00000001
FLAG_NAME(DNUF_DONT_SHOW_IN_UI), // 00000002
FLAG_NAME(DNUF_NEED_RESTART), // 00000004
FLAG_NAME(DNUF_NOT_DISABLEABLE), // 00000008
FLAG_NAME(DNUF_SHUTDOWN_QUERIED), // 00000010
FLAG_NAME(DNUF_SHUTDOWN_SUBTREE_DONE), // 00000020
{0,0}
};
#define DeviceD1 0x00000001
#define DeviceD2 0x00000002
#define LockSupported 0x00000004
#define EjectSupported 0x00000008
#define Removable 0x00000010
#define DockDevice 0x00000020
#define UniqueID 0x00000040
#define SilentInstall 0x00000080
#define RawDeviceOK 0x00000100
#define SurpriseRemovalOK 0x00000200
#define WakeFromD0 0x00000400
#define WakeFromD1 0x00000800
#define WakeFromD2 0x00001000
#define WakeFromD3 0x00002000
#define HardwareDisabled 0x00004000
#define NonDynamic 0x00008000
#define WarmEjectSupported 0x00010000
#define NoDisplayInUI 0x00020000
FLAG_NAME DeviceNodeCapabilityFlags[] = {
FLAG_NAME(DeviceD1), // 00000001
FLAG_NAME(DeviceD2), // 00000002
FLAG_NAME(LockSupported), // 00000004
FLAG_NAME(EjectSupported), // 00000008
FLAG_NAME(Removable), // 00000010
FLAG_NAME(DockDevice), // 00000020
FLAG_NAME(UniqueID), // 00000040
FLAG_NAME(SilentInstall), // 00000080
FLAG_NAME(RawDeviceOK), // 00000100
FLAG_NAME(SurpriseRemovalOK), // 00000200
FLAG_NAME(WakeFromD0), // 00000400
FLAG_NAME(WakeFromD1), // 00000800
FLAG_NAME(WakeFromD2), // 00001000
FLAG_NAME(WakeFromD3), // 00002000
FLAG_NAME(HardwareDisabled), // 00004000
FLAG_NAME(NonDynamic), // 00008000
FLAG_NAME(WarmEjectSupported), // 00010000
FLAG_NAME(NoDisplayInUI), // 00020000
{0,0}
};
#define PROBLEM_MAP_SIZE 0x33
#if PROBLEM_MAP_SIZE != NUM_CM_PROB
#error Add new problem code to DevNodeProblems and update PROBLEM_MAP_SIZE.
#endif
PUCHAR DevNodeProblems[] = {
NULL,
"CM_PROB_NOT_CONFIGURED",
"CM_PROB_DEVLOADER_FAILED",
"CM_PROB_OUT_OF_MEMORY",
"CM_PROB_ENTRY_IS_WRONG_TYPE",
"CM_PROB_LACKED_ARBITRATOR",
"CM_PROB_BOOT_CONFIG_CONFLICT",
"CM_PROB_FAILED_FILTER",
"CM_PROB_DEVLOADER_NOT_FOUND",
"CM_PROB_INVALID_DATA",
"CM_PROB_FAILED_START",
"CM_PROB_LIAR",
"CM_PROB_NORMAL_CONFLICT",
"CM_PROB_NOT_VERIFIED",
"CM_PROB_NEED_RESTART",
"CM_PROB_REENUMERATION",
"CM_PROB_PARTIAL_LOG_CONF",
"CM_PROB_UNKNOWN_RESOURCE",
"CM_PROB_REINSTALL",
"CM_PROB_REGISTRY",
"CM_PROB_VXDLDR",
"CM_PROB_WILL_BE_REMOVED",
"CM_PROB_DISABLED",
"CM_PROB_DEVLOADER_NOT_READY",
"CM_PROB_DEVICE_NOT_THERE",
"CM_PROB_MOVED",
"CM_PROB_TOO_EARLY",
"CM_PROB_NO_VALID_LOG_CONF",
"CM_PROB_FAILED_INSTALL",
"CM_PROB_HARDWARE_DISABLED",
"CM_PROB_CANT_SHARE_IRQ",
"CM_PROB_FAILED_ADD",
"CM_PROB_DISABLED_SERVICE",
"CM_PROB_TRANSLATION_FAILED",
"CM_PROB_NO_SOFTCONFIG",
"CM_PROB_BIOS_TABLE",
"CM_PROB_IRQ_TRANSLATION_FAILED",
"CM_PROB_FAILED_DRIVER_ENTRY",
"CM_PROB_DRIVER_FAILED_PRIOR_UNLOAD",
"CM_PROB_DRIVER_FAILED_LOAD",
"CM_PROB_DRIVER_SERVICE_KEY_INVALID",
"CM_PROB_LEGACY_SERVICE_NO_DEVICES",
"CM_PROB_DUPLICATE_DEVICE",
"CM_PROB_FAILED_POST_START",
"CM_PROB_HALTED",
"CM_PROB_PHANTOM",
"CM_PROB_SYSTEM_SHUTDOWN",
"CM_PROB_HELD_FOR_EJECT",
"CM_PROB_DRIVER_BLOCKED",
"CM_PROB_REGISTRY_TOO_LARGE",
"CM_PROB_SETPROPERTIES_FAILED"
};
extern
VOID
DevExtIsapnp(
ULONG64 Extension
);
extern
VOID
DevExtPcmcia(
ULONG64 Extension
);
extern
VOID
DevExtHID(
ULONG64 Extension
);
VOID
DumpResourceDescriptorHeader(
ULONG Depth,
ULONG Number,
UCHAR Option,
UCHAR Type,
UCHAR SharingDisposition,
USHORT Flags
);
BOOLEAN
DumpDevNode(
ULONG64 DeviceNode,
ULONG Depth,
BOOLEAN DumpSibling,
BOOLEAN DumpChild,
BOOLEAN DumpCmRes,
BOOLEAN DumpCmResReqList,
BOOLEAN DumpCmResTrans,
BOOLEAN DumpOnlyDevnodesWithProblems,
BOOLEAN DumpOnlyNonStartedDevnodes,
PUNICODE_STRING ServiceName,
BOOLEAN PrintDefault,
BOOLEAN DumpStateHistory
);
BOOLEAN
DumpPendingEjects(
BOOLEAN DumpCmRes,
BOOLEAN DumpCmResReqList,
BOOLEAN DumpCmResTrans
);
BOOLEAN
DumpPendingRemovals(
BOOLEAN DumpCmRes,
BOOLEAN DumpCmResReqList,
BOOLEAN DumpCmResTrans
);
BOOLEAN
DumpDeviceEventEntry(
ULONG64 DeviceEvent,
ULONG64 ListHead,
BOOL FollowLinks
);
VOID
DumpPlugPlayEventBlock(
ULONG64 PlugPlayEventBlock,
ULONG Size
);
BOOLEAN
DumpResourceList64(
LPSTR Description,
ULONG Depth,
ULONG64 ResourceList
);
BOOLEAN
DumpResourceRequirementList64(
ULONG Depth,
ULONG64 ResourceRequirementList
);
BOOLEAN
DumpE820ResourceList64(
ULONG Depth,
ULONG64 ResourceList
);
BOOLEAN
DumpArbiter(
IN DWORD Depth,
IN ULONG64 ArbiterAddr,
IN BOOLEAN DisplayAliases
);
#define ARBITER_DUMP_IO 0x1
#define ARBITER_DUMP_MEMORY 0x2
#define ARBITER_DUMP_IRQ 0x4
#define ARBITER_DUMP_DMA 0x8
#define ARBITER_DUMP_BUS_NUMBER 0x10
#define ARBITER_NO_DUMP_ALIASES 0x100
#define ARBITER_DUMP_ALL (ARBITER_DUMP_IO | \
ARBITER_DUMP_MEMORY | \
ARBITER_DUMP_IRQ | \
ARBITER_DUMP_DMA | \
ARBITER_DUMP_BUS_NUMBER)
BOOLEAN
DumpArbitersForDevNode(
IN DWORD Depth,
IN ULONG64 DevNodeAddr,
IN DWORD Flags
);
VOID
PrintDevNodeState(
IN ULONG Depth,
IN PUCHAR Field,
IN ULONG State
);
DECLARE_API( ioreslist )
/*++
Routine Description:
Dump a device object.
Arguments:
args - the location of the device object to dump.
Return Value:
None
--*/
{
ULONG64 requirementList;
requirementList = GetExpression(args);
DumpResourceRequirementList64(0, requirementList);
return S_OK;
}
DECLARE_API( cmreslist )
/*++
Routine Description:
Dump a device object.
Arguments:
args - the location of the device object to dump.
Return Value:
None
--*/
{
ULONG64 resourceList;
resourceList = GetExpression(args);
DumpResourceList64("CmResourceList", 0, resourceList);
return S_OK;
}
DECLARE_API( e820reslist )
/*++
Routine Description:
Dump an e820 resource table
Arguments:
args - the location of the resources list to dump
Return Value:
None
--*/
{
ULONG64 resourceList;
resourceList = GetExpression(args);
DumpE820ResourceList64(0, resourceList );
return S_OK;
}
#define DUMP_CHILD 1
#define DUMP_CM_RES 2
#define DUMP_CM_RES_REQ_LIST 4
#define DUMP_CM_RES_TRANS 8
#define DUMP_NOT_STARTED 0x10
#define DUMP_PROBLEMS 0x20
BOOLEAN
xReadMemory(
ULONG64 S,
PVOID D,
ULONG Len
)
{
ULONG result;
return (ReadMemory((S), D, Len, &result) && (result == Len));
}
DECLARE_API( devnode )
/*++
Routine Description:
Dump a device object.
Arguments:
args - the location of the device object to dump.
Return Value:
None
--*/
{
ULONG64 deviceNode=0;
ULONG verbose = 0;
PUCHAR buffer = NULL;
UNICODE_STRING serviceName;
ANSI_STRING ansiString;
BOOLEAN serviceNameAllocated = FALSE;
NTSTATUS status;
ULONG64 tmp;
buffer = LocalAlloc(LPTR, 256);
if (buffer) {
RtlZeroMemory(buffer, 256);
if (GetExpressionEx(args, &deviceNode, &args)) {
if (sscanf(args, "%lx %255s", &verbose, buffer)) {
if (buffer [0] != '\0') {
RtlInitAnsiString(&ansiString, (PCSZ)buffer);
status = RtlAnsiStringToUnicodeString(&serviceName,
&ansiString,
TRUE);
if (NT_SUCCESS(status)) {
serviceNameAllocated = TRUE;
}
}
}
}
LocalFree(buffer);
} else if (GetExpressionEx(args, &deviceNode, &args)) {
if (sscanf(args,"%lx", &tmp)) {
verbose = (ULONG) tmp;
}
}
if (deviceNode == 0) {
ULONG64 addr = GetExpression( "nt!IopRootDeviceNode" );
ULONG64 dummy;
if (addr == 0) {
dprintf("Error retrieving address of IopRootDeviceNode\n");
return E_INVALIDARG;
}
if (!ReadPointer(addr, &deviceNode)) {
dprintf("Error reading value of IopRootDeviceNode (%#010p)\n", addr);
return E_INVALIDARG;
}
dprintf("Dumping IopRootDeviceNode (= %#08p)\n", deviceNode);
} else if (deviceNode == 1) {
DumpPendingRemovals((BOOLEAN) ((verbose & DUMP_CM_RES) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES_REQ_LIST) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES_TRANS) != 0)
);
return E_INVALIDARG;
} else if (deviceNode == 2) {
DumpPendingEjects((BOOLEAN) ((verbose & DUMP_CM_RES) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES_REQ_LIST) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES_TRANS) != 0)
);
return E_INVALIDARG;
}
if (serviceNameAllocated) {
DumpDevNode( deviceNode,
0,
FALSE,
(BOOLEAN) ((verbose & DUMP_CHILD) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES_REQ_LIST) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES_TRANS) != 0),
(BOOLEAN) ((verbose & DUMP_PROBLEMS) != 0),
(BOOLEAN) ((verbose & DUMP_NOT_STARTED) != 0),
&serviceName,
FALSE,
TRUE
);
RtlFreeUnicodeString(&serviceName);
} else {
DumpDevNode( deviceNode,
0,
FALSE,
(BOOLEAN) ((verbose & DUMP_CHILD) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES_REQ_LIST) != 0),
(BOOLEAN) ((verbose & DUMP_CM_RES_TRANS) != 0),
(BOOLEAN) ((verbose & DUMP_PROBLEMS) != 0),
(BOOLEAN) ((verbose & DUMP_NOT_STARTED) != 0),
NULL,
FALSE,
TRUE
);
}
return S_OK;
}
static CCHAR DebugBuffer[300];
VOID
xdprintf(
ULONG Depth,
PCCHAR S,
...
)
{
va_list ap;
ULONG i;
for (i=0; i<Depth; i++) {
dprintf (" ");
}
va_start(ap, S);
vsprintf(DebugBuffer, S, ap);
dprintf(DebugBuffer);
va_end(ap);
}
VOID
DumpFlags(
ULONG Depth,
LPSTR FlagDescription,
ULONG Flags,
PFLAG_NAME FlagTable
)
{
ULONG i;
ULONG mask = 0;
ULONG count = 0;
UCHAR prolog[64];
if (StringCbPrintf(prolog, sizeof(prolog), "%s (%#010x) ", FlagDescription, Flags) != S_OK)
{
return;
}
xdprintf(Depth, "%s", prolog);
if (Flags == 0) {
dprintf("\n");
return;
}
memset(prolog, ' ', strlen(prolog));
for (i = 0; FlagTable[i].Name != 0; i++) {
PFLAG_NAME flag = &(FlagTable[i]);
mask |= flag->Flag;
if ((Flags & flag->Flag) == flag->Flag) {
//
// print trailing comma
//
if (count != 0) {
dprintf(", ");
//
// Only print two flags per line.
//
if ((count % 2) == 0) {
dprintf("\n");
xdprintf(Depth, "%s", prolog);
}
}
dprintf("%s", flag->Name);
count++;
}
}
dprintf("\n");
if ((Flags & (~mask)) != 0) {
xdprintf(Depth, "%sUnknown flags %#010lx\n", prolog, (Flags & (~mask)));
}
return;
}
BOOLEAN
DumpE820ResourceList64(
ULONG Depth,
ULONG64 ResourceList
)
{
BOOLEAN continueDump = TRUE;
CHAR Buff[80];
ULONG i;
ULONG ListOffset;
ULONG64 Count;
ULONG64 Type;
ULONG64 V1;
ULONG64 V2;
#define Res2(F, V) GetFieldValue(ResourceList, "nt!_ACPI_BIOS_MULTI_NODE", #F, V)
#define Res(F) GetFieldValue(ResourceList, "nt!_ACPI_BIOS_MULTI_NODE", #F, F)
#define Entry(F,V) (sprintf(Buff,"E820Entry[%lx].%s",i,#F),\
GetFieldValue(ResourceList,"nt!_ACPI_BIOS_MULTI_NODE", Buff, V))
if (ResourceList == 0) {
goto GetOut;
}
if (Res(Count)) {
goto GetOut;
}
if (Count == 0) {
goto GetOut;
}
xdprintf(Depth, "ACPI_BIOS_MULTI_NODE (an E820 Resource List) at %#010p\n", ResourceList);
Depth++;
for (i = 0; i < Count; i++) {
if (CheckControlC()) {
continueDump = FALSE;
break;
}
Entry(Type,Type);
switch(Type) {
case 1: // AcpiAddressRangeMemory
xdprintf(Depth,"Memory - ");
break;
case 2: // AcpiAddressRangeReserved
xdprintf(Depth,"Reserved - ");
break;
case 3: // AcpiAddressRangeACPI
xdprintf(Depth,"ACPI - ");
break;
case 4: // AcpiAddressRangeNVS
xdprintf(Depth,"NVS - ");
break;
case 5: // AcpiAddressRangeMaximum
default:
xdprintf(Depth,"Unknown - ");
break;
}
Entry(Base.QuadPart, V1);
Entry(Length.QuadPart, V2);
dprintf( "%16I64x - %#16I64x (Length %#10I64x)", V1, (V1 + V2 - 1), V2 );
if (Type == 2) {
dprintf(" [Ignored]");
}
if (Type == 3 || Type == 4) {
if (V2 > 0xFFFFFFFF) {
dprintf(" [Illegal Range]");
}
}
dprintf("\n");
}
GetOut:
#undef Res
#undef Res2
#undef Entry
return continueDump;
}
BOOLEAN
DumpResourceRequirementList64(
ULONG Depth,
ULONG64 ResourceRequirementList
)
{
ULONG64 requirementList = 0;
ULONG64 resourceList;
ULONG64 descriptors;
ULONG ListSize;
ULONG i;
ULONG j;
ULONG k;
ULONG result;
BOOLEAN continueDump = TRUE;
ULONG InterfaceType, BusNumber, SlotNumber, Reserved1, Reserved2, Reserved3;
ULONG AlternativeLists;
ULONG ListOffset, SizeOfIoResList, SizeofIoDesc;
#define Res2(F, V) GetFieldValue(ResourceRequirementList, "nt!_IO_RESOURCE_REQUIREMENTS_LIST", #F, V)
#define Res(F) GetFieldValue(ResourceRequirementList, "nt!_IO_RESOURCE_REQUIREMENTS_LIST", #F, F)
if (ResourceRequirementList == 0) {
goto GetOut;
}
if (Res(ListSize)) {
goto GetOut;
}
if (ListSize == 0) {
goto GetOut;
}
Res(InterfaceType); Res(BusNumber); Res(SlotNumber);
xdprintf(Depth, "IoResList at ");
dprintf("%#010p : Interface %#x Bus %#x Slot %#x\n",
ResourceRequirementList,
InterfaceType,
BusNumber,
SlotNumber);
Res2(Reserved[0], Reserved1); Res2(Reserved[1], Reserved2);
Res2(Reserved[2], Reserved3);
if ((Reserved1 |
Reserved2 |
Reserved3) != 0) {
xdprintf(Depth, "Reserved Values = {%#010lx, %#010lx, %#010lx}\n",
Reserved1,
Reserved2,
Reserved3);
}
Depth++;
Res(AlternativeLists);
GetFieldOffset("nt!_IO_RESOURCE_REQUIREMENTS_LIST", "List", &ListOffset);
resourceList = ResourceRequirementList + ListOffset;
SizeOfIoResList = GetTypeSize("IO_RESOURCE_LIST");
SizeofIoDesc = GetTypeSize("IO_RESOURCE_DESCRIPTOR");
for (i = 0; i < AlternativeLists; i++) {
ULONG Version, Revision, Count;
if (CheckControlC()) {
continueDump = FALSE;
break;
}
GetFieldValue(resourceList, "nt!_IO_RESOURCE_LIST", "Version", Version);
GetFieldValue(resourceList, "nt!_IO_RESOURCE_LIST", "Revision", Revision);
GetFieldValue(resourceList, "nt!_IO_RESOURCE_LIST", "Count", Count);
xdprintf(Depth, "Alternative %d (Version %d.%d)\n",
i,
Version,
Revision);
Depth++;
for (j = 0; j < Count; j++) {
CHAR Buff[80];
ULONG64 Q1, Q2;
ULONG Option, Type, ShareDisposition, Flags, V1, V2, V3, Data[3];
#define Desc(F,V) (sprintf(Buff,"Descriptors[%lx].%s",j, #F), \
GetFieldValue(resourceList, "nt!_IO_RESOURCE_LIST", Buff, V))
if (CheckControlC()) {
continueDump = FALSE;
goto GetOut;
}
// descriptors = resourceList->Descriptors + j;
Desc(Option,Option); Desc(Type,Type);
Desc(ShareDisposition,ShareDisposition);
Desc(Flags,Flags);
DumpResourceDescriptorHeader(Depth,
j,
(UCHAR)Option,
(UCHAR) Type,
(UCHAR) ShareDisposition,
(USHORT) Flags);
Depth++;
switch (Type) {
case CmResourceTypeBusNumber:
Desc(u.BusNumber.MinBusNumber, V1);
Desc(u.BusNumber.MaxBusNumber, V2);
Desc(u.BusNumber.Length, V3);
xdprintf(Depth, "0x%x - 0x%x for length 0x%x\n",
V1, V2, V3);
break;
case CmResourceTypePort:
case CmResourceTypeMemory:
Desc(u.Generic.Length, V1);
Desc(u.Generic.Alignment, V2);
Desc(u.Port.MinimumAddress.QuadPart, Q1);
Desc(u.Port.MaximumAddress.QuadPart, Q2);
xdprintf(Depth, "%#08lx byte range with alignment %#08lx\n", V1, V2);
xdprintf(Depth, "%I64x - %#I64x\n", Q1, Q2);
break;
case CmResourceTypeInterrupt:
Desc(u.Interrupt.MinimumVector,V1);
Desc(u.Interrupt.MaximumVector,V2);
xdprintf(Depth, "0x%x - 0x%x\n", V1,V2);
break;
default:
Desc(u.DevicePrivate.Data, Data);
xdprintf(Depth,
"Data: : 0x%x 0x%x 0x%x\n",
Data[0],
Data[1],
Data[2]);
break;
}
Depth--;
#undef Desc
}
Depth--;
resourceList += (SizeOfIoResList + SizeofIoDesc*(j-1));
}
GetOut:
xdprintf(Depth, "\n");
#undef Res
#undef Res2
return continueDump;
}
BOOLEAN
DumpResourceList64(
LPSTR Description,
ULONG Depth,
ULONG64 ResourceList
)
{
ULONG64 resourceListWalker;
ULONG i;
ULONG j;
ULONG k;
BOOLEAN continueDump = TRUE;
ULONG Count, ListSize, ListOffset;
ULONG64 ListAddr;
if (ResourceList == 0) {
goto GetOut;
}
resourceListWalker = ResourceList;
if (GetFieldOffset("nt!_CM_RESOURCE_LIST", "List", &ListOffset)) {
goto GetOut;
}
ListAddr = ResourceList + ListOffset;
GetFieldValue(ResourceList, "nt!_CM_RESOURCE_LIST", "Count", Count);
resourceListWalker = ListAddr;
for (i = 0; i < Count; i++) {
ULONG Partial_Count=0, PartialListAddr, BusNumber=0, Partial_Version=0, Partial_Revision=0;
CHAR ResListType[] = "nt!_CM_FULL_RESOURCE_DESCRIPTOR";
ULONG64 InterfaceType=0;
ULONG PartDescOffset;
if (CheckControlC()) {
continueDump = FALSE;
break;
}
GetFieldValue(resourceListWalker, ResListType, "InterfaceType", InterfaceType);
GetFieldValue(resourceListWalker, ResListType, "BusNumber", BusNumber);
GetFieldValue(resourceListWalker, ResListType, "PartialResourceList.Version", Partial_Version);
GetFieldValue(resourceListWalker, ResListType, "PartialResourceList.Revision", Partial_Revision);
GetFieldValue(resourceListWalker, ResListType, "PartialResourceList.Count", Partial_Count);
GetFieldOffset(ResListType, "PartialResourceList.PartialDescriptors", &PartDescOffset);
resourceListWalker = resourceListWalker + PartDescOffset;
xdprintf(Depth, "%s at ", Description);
dprintf("%#010p Version %d.%d Interface %#x Bus #%#x\n",
ResourceList,
Partial_Version,
Partial_Revision,
(ULONG) InterfaceType,
BusNumber);
Depth++;
for (j = 0; j < Partial_Count; j++) {
CHAR PartResType[] = "nt!_CM_PARTIAL_RESOURCE_DESCRIPTOR";
ULONG Type=0, ShareDisposition=0, Flags=0, sz, u_Port_Length=0, u_Memory_Length=0,
u_Interrupt_Level=0, u_Interrupt_Vector=0,
u_Dma_Channel=0, u_Dma_Port=0, u_Dma_Reserved1=0, u_BusNumber_Start=0,
u_BusNumber_Length=0, u_DevicePrivate_Data[3];
ULONG64 u_Port_QuadPart=0, u_Memory_QuadPart=0, u_Interrupt_Affinity=0;
if (CheckControlC()) {
continueDump = FALSE;
goto GetOut;
}
sz = GetTypeSize(PartResType);
if (GetFieldValue(resourceListWalker,
PartResType,
"Type",
Type)) {
goto GetOut;
}
GetFieldValue(resourceListWalker, PartResType, "ShareDisposition", ShareDisposition);
GetFieldValue(resourceListWalker, PartResType, "Flags", Flags);
xdprintf(Depth, "Entry %d - %s (%#x) %s (%#x)\n",
j,
(Type == CmResourceTypeNull ? "Null" :
Type == CmResourceTypePort ? "Port" :
Type == CmResourceTypeInterrupt ? "Interrupt" :
Type == CmResourceTypeMemory ? "Memory" :
Type == CmResourceTypeDma ? "Dma" :
Type == CmResourceTypeDeviceSpecific ? "DeviceSpecific" :
Type == CmResourceTypeBusNumber ? "BusNumber" :
Type == CmResourceTypeDevicePrivate ? "DevicePrivate" :
Type == CmResourceTypeConfigData ? "ConfigData" : "Unknown"),
Type,
(ShareDisposition == CmResourceShareUndetermined ? "Undetermined Sharing" :
ShareDisposition == CmResourceShareDeviceExclusive ? "Device Exclusive" :
ShareDisposition == CmResourceShareDriverExclusive ? "Driver Exclusive" :
ShareDisposition == CmResourceShareShared ? "Shared" : "Unknown Sharing"),
ShareDisposition);
Depth++;
xdprintf(Depth, "Flags (%#04wx) - ", Flags);
switch (Type) {
case CmResourceTypePort:
//
// CM_RESOURCE_PORT_MEMORY = ~CM_RESOURCE_PORT_IO
//
if ( (~Flags) & ~CM_RESOURCE_PORT_MEMORY) {
dprintf("PORT_MEMORY ");
}
if (Flags & CM_RESOURCE_PORT_IO) {
dprintf("PORT_IO ");
}
if (Flags & CM_RESOURCE_PORT_10_BIT_DECODE) {
dprintf("10_BIT_DECODE ");
}
if (Flags & CM_RESOURCE_PORT_12_BIT_DECODE) {
dprintf("12_BIT_DECODE ");
}
if (Flags & CM_RESOURCE_PORT_16_BIT_DECODE) {
dprintf("16_BIT_DECODE ");
}
if (Flags & CM_RESOURCE_PORT_POSITIVE_DECODE) {
dprintf("POSITIVE_DECODE ");
}
if (Flags & CM_RESOURCE_PORT_PASSIVE_DECODE) {
dprintf ("PASSIVE_DECODE ");
}
if (Flags & CM_RESOURCE_PORT_WINDOW_DECODE) {
dprintf ("WINDOW_DECODE ");
}
dprintf("\n");
GetFieldValue(resourceListWalker, PartResType, "u.Port.Start.QuadPart", u_Port_QuadPart);
GetFieldValue(resourceListWalker, PartResType, "u.Port.Length", u_Port_Length);
xdprintf(Depth, "Range starts at %#I64lx for %#x bytes\n",
u_Port_QuadPart,
u_Port_Length);
break;
case CmResourceTypeMemory:
if (Flags == CM_RESOURCE_MEMORY_READ_WRITE) {
dprintf("READ_WRITE ");
}
if (Flags & CM_RESOURCE_MEMORY_READ_ONLY) {
dprintf("READ_ONLY ");
}
if (Flags & CM_RESOURCE_MEMORY_WRITE_ONLY) {
dprintf("WRITE_ONLY ");
}
if (Flags & CM_RESOURCE_MEMORY_PREFETCHABLE) {
dprintf("PREFETCHABLE ");
}
if (Flags & CM_RESOURCE_MEMORY_COMBINEDWRITE) {
dprintf("COMBINEDWRITE ");
}
if (Flags & CM_RESOURCE_MEMORY_24) {
dprintf("MEMORY_24 ");
}
dprintf("\n");
GetFieldValue(resourceListWalker, PartResType, "u.Memory.Start.QuadPart", u_Memory_QuadPart);
GetFieldValue(resourceListWalker, PartResType, "u.Memory.Length", u_Memory_Length);
xdprintf(Depth, "Range starts at %#018I64lx for %#x bytes\n",
u_Memory_QuadPart,
u_Memory_Length);
break;
case CmResourceTypeInterrupt:
if (Flags == CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE) {
dprintf("LEVEL_SENSITIVE ");
}
if (Flags & CM_RESOURCE_INTERRUPT_LATCHED) {
dprintf("LATCHED ");
}
dprintf("\n");
GetFieldValue(resourceListWalker, PartResType, "u.Interrupt.Level", u_Interrupt_Level);
GetFieldValue(resourceListWalker, PartResType, "u.Interrupt.Vector", u_Interrupt_Vector);
GetFieldValue(resourceListWalker, PartResType, "u.Interrupt.Affinity", u_Interrupt_Affinity);
xdprintf(Depth, "Level %#x, Vector %#x, Affinity %#I64x\n",
u_Interrupt_Level,
u_Interrupt_Vector,
u_Interrupt_Affinity);
break;
case CmResourceTypeDma:
if (Flags & CM_RESOURCE_DMA_8) {
dprintf("DMA_8 ");
}
if (Flags & CM_RESOURCE_DMA_16) {
dprintf("DMA_16 ");
}
if (Flags & CM_RESOURCE_DMA_32) {
dprintf("DMA_32 ");
}
if (Flags & CM_RESOURCE_DMA_8_AND_16) {
dprintf("DMA_8_AND_16 ");
}
if (Flags & CM_RESOURCE_DMA_BUS_MASTER) {
dprintf("DMA_BUS_MASTER ");
}
if (Flags & CM_RESOURCE_DMA_TYPE_A) {
dprintf("DMA_A ");
}
if (Flags & CM_RESOURCE_DMA_TYPE_B) {
dprintf("DMA_B ");
}
if (Flags & CM_RESOURCE_DMA_TYPE_F) {
dprintf("DMA_F ");
}
dprintf("\n");
GetFieldValue(resourceListWalker, PartResType, "u.Dma.Channel", u_Dma_Channel);
GetFieldValue(resourceListWalker, PartResType, "u.Dma.Port", u_Dma_Port);
GetFieldValue(resourceListWalker, PartResType, "u.Dma.Reserved1", u_Dma_Reserved1);
xdprintf(Depth, "Channel %#x Port %#x (Reserved1 %#x)\n",
u_Dma_Channel,
u_Dma_Port,
u_Dma_Reserved1);
break;
case CmResourceTypeBusNumber:
dprintf("\n");
GetFieldValue(resourceListWalker, PartResType, "u.BusNumber.Start", u_BusNumber_Start);
GetFieldValue(resourceListWalker, PartResType, "u.BusNumber.Length", u_BusNumber_Length);
xdprintf(Depth, "Range starts at %#010lx for %#x values\n",
u_BusNumber_Start,
u_BusNumber_Length);
break;
default:
dprintf("\n");
GetFieldValue(resourceListWalker, PartResType, "u.DevicePrivate.Data", u_DevicePrivate_Data);
xdprintf(Depth, "Data - {%#010lx, %#010lx, %#010lx}\n",
u_DevicePrivate_Data[0],
u_DevicePrivate_Data[1],
u_DevicePrivate_Data[2]);
break;
}
Depth--;
resourceListWalker += sz; // sizeof(partialDescriptors);
}
}
GetOut:
xdprintf(Depth, "\n");
return continueDump;
}
BOOLEAN
DumpRelationsList(
ULONG64 RelationsList,
BOOLEAN DumpCmRes,
BOOLEAN DumpCmResReqList,
BOOLEAN DumpCmResTrans
)
{
ULONG64 listEntryAddr;
ULONG64 deviceObjectAddr;
ULONG i, j, EntrySize;
BOOLEAN continueDump = TRUE;
CHAR RelListType[] = "nt!_RELATION_LIST", RelListentryType[] = "nt!_RELATION_LIST_ENTRY";
ULONG64 EntryAddr;
ULONG Count=0, TagCount=0, FirstLevel=0, MaxLevel=0;
ULONG EntryOffset;
if (GetFieldValue(RelationsList, RelListType, "Count",Count)) {
xdprintf(1, "Error reading relation list @ ");
dprintf("0x%08p)\n", RelationsList);
return continueDump;
}
EntrySize = DBG_PTR_SIZE;
GetFieldOffset(RelListType, "Entries", &EntryOffset);
EntryAddr=RelationsList + EntryOffset;
GetFieldValue(RelationsList, RelListType, "TagCount", TagCount);
GetFieldValue(RelationsList, RelListType, "FirstLevel", FirstLevel);
GetFieldValue(RelationsList, RelListType, "MaxLevel", MaxLevel);
xdprintf(1, "Relation List @ "); dprintf("0x%08p\n", RelationsList);
xdprintf(2, "Count = %d, TagCount = %d, FirstLevel = %d, MaxLevel = %d\n",
Count,
TagCount,
FirstLevel,
MaxLevel);
for (i = 0; i <= (MaxLevel - FirstLevel); i++) {
ULONG res,Entry_Count=0, MaxCount=0, DeviceSize;
ULONG64 DeviceAddr;
FIELD_INFO relListEntryFields[] = {
{"Devices", "", 0, DBG_DUMP_FIELD_RETURN_ADDRESS, 0, NULL},
};
if (CheckControlC()) {
continueDump = FALSE;
break;
}
listEntryAddr = 0;
if (ReadPointer( EntryAddr + i*EntrySize,
&listEntryAddr)) {
if (!listEntryAddr) {
xdprintf(2, "Null relation list entry\n");
}else if (!GetFieldValue(listEntryAddr, RelListentryType,
"Count",Entry_Count)) {
ULONG DeviceOffset;
GetFieldOffset(RelListentryType, "Devices", &DeviceOffset);
DeviceAddr = listEntryAddr + DeviceOffset;
DeviceSize = EntrySize; // == pointer size
GetFieldValue(listEntryAddr, RelListentryType, "MaxCount", MaxCount);
xdprintf(2, "Relation List Entry @ "); dprintf("0x%08p\n", listEntryAddr);
xdprintf(3, "Count = %d, MaxCount = %d\n", Entry_Count, MaxCount);
xdprintf(3, "Devices at level %d\n", FirstLevel + i);
for (j = 0; j < Entry_Count; j++) {
if (CheckControlC()) {
continueDump = FALSE;
break;
}
if (ReadPointer( DeviceAddr + j*DeviceSize,
&deviceObjectAddr)) {
ULONG64 DeviceNode=0;
FIELD_INFO DevObjFields[] = {
// Implicitly reads the pointer DeviceObjectExtension and its field DeviceNode
{"DeviceObjectExtension", "", 0, DBG_DUMP_FIELD_RECUR_ON_THIS, 0, NULL},
{"DeviceObjectExtension.DeviceNode", "", 0, DBG_DUMP_FIELD_COPY_FIELD_DATA, 0, (PVOID) &DeviceNode}
};
if (!deviceObjectAddr) {
continue;
}
xdprintf(4, "Device Object = ");
dprintf("0x%08p (%sagged, %sirect)\n",
deviceObjectAddr & ~3,
(deviceObjectAddr & 1) ? "T" : "Not t",
(deviceObjectAddr & 2) ? "D" : "Ind");
if (!GetFieldValue(deviceObjectAddr, "nt!_DEVICE_OBJECT",
"DeviceObjectExtension.DeviceNode",
DeviceNode)) {
if (DeviceNode) {
continueDump = DumpDevNode(DeviceNode,
5,
FALSE,
FALSE,
DumpCmRes,
DumpCmResReqList,
DumpCmResTrans,
FALSE,
FALSE,
(PUNICODE_STRING)NULL,
TRUE,
TRUE
);
}
} else {
xdprintf(5, "Error reading device object @ ");
dprintf("0x%08p)\n",deviceObjectAddr);
}
} else {
xdprintf(4, "Error reading relation list entry device ");
dprintf("%d @ 0x%08p)\n",
j,
DeviceAddr + j*DeviceSize);
}
if (!continueDump) {
break;
}
}
} else {
xdprintf(2, "Error reading relation list entry @ ");
dprintf("0x%08p)\n",
listEntryAddr);
}
} else {
xdprintf(1, "Error reading relation list entry ");
dprintf("%d @ 0x%08p)\n",
i,
EntryAddr + i*EntrySize);
}
if (!continueDump) {
break;
}
}
return continueDump;
}
BOOLEAN
DumpPendingRemovals(
BOOLEAN DumpCmRes,
BOOLEAN DumpCmResReqList,
BOOLEAN DumpCmResTrans
)
{
ULONG64 listHeadAddr, pendingEntryAddr;
BOOLEAN continueDump = TRUE;
ULONG64 Head_Blink=0, Head_Flink=0, Link_Flink=0;
listHeadAddr = GetExpression( "nt!IopPendingSurpriseRemovals" );
if (listHeadAddr == 0) {
dprintf("Error retrieving address of IopPendingSurpriseRemovals\n");
return continueDump;
}
if (GetFieldValue(listHeadAddr, "nt!_LIST_ENTRY", "Flink", Head_Flink) ||
GetFieldValue(listHeadAddr, "nt!_LIST_ENTRY", "Blink", Head_Blink)) {
dprintf("Error reading value of IopPendingSurpriseRemovals (0x%08p)\n", listHeadAddr);
return continueDump;
}
if (Head_Flink == listHeadAddr) {
dprintf("There are no removals currently pending\n");
return continueDump;
}
for (pendingEntryAddr = Head_Flink;
pendingEntryAddr != listHeadAddr;
pendingEntryAddr = Link_Flink) {
ULONG64 RelationsList=0, DeviceObject=0;
if (CheckControlC()) {
continueDump = FALSE;
break;
}
if (GetFieldValue(pendingEntryAddr, "nt!_PENDING_RELATIONS_LIST_ENTRY", "DeviceObject", DeviceObject)){
dprintf("Error reading pending relations list entry (0x%08p)\n", pendingEntryAddr);
return continueDump;
}
GetFieldValue(pendingEntryAddr, "nt!_PENDING_RELATIONS_LIST_ENTRY", "Link.Flink", Link_Flink);
GetFieldValue(pendingEntryAddr, "nt!_PENDING_RELATIONS_LIST_ENTRY", "RelationsList", RelationsList);
dprintf("Pending Removal of PDO 0x%08p, Pending Relations List Entry @ 0x%08p\n",
DeviceObject,
pendingEntryAddr
);
continueDump = DumpRelationsList( RelationsList,
DumpCmRes,
DumpCmResReqList,
DumpCmResTrans
);
if (!continueDump) {
break;
}
}
return continueDump;
}
BOOLEAN
DumpPendingEjects(
BOOLEAN DumpCmRes,
BOOLEAN DumpCmResReqList,
BOOLEAN DumpCmResTrans
)
{
ULONG64 listHeadAddr, pendingEntryAddr;
BOOLEAN continueDump = TRUE;
ULONG64 Head_Blink=0, Head_Flink=0, Link_Flink=0;
listHeadAddr = GetExpression( "nt!IopPendingEjects" );
if (listHeadAddr == 0) {
dprintf("Error retrieving address of IopEjects\n");
return continueDump;
}
if (GetFieldValue(listHeadAddr, "nt!_LIST_ENTRY", "Flink", Head_Flink) ||
GetFieldValue(listHeadAddr, "nt!_LIST_ENTRY", "Blink", Head_Blink)) {
dprintf("Error reading value of IopPendingSurpriseRemovals (0x%08p)\n", listHeadAddr);
return continueDump;
}
if (Head_Flink == listHeadAddr) {
dprintf("There are no ejects currently pending\n");
return continueDump;
}
for (pendingEntryAddr = Head_Flink;
pendingEntryAddr != listHeadAddr;
pendingEntryAddr = Link_Flink) {
ULONG64 RelationsList=0, DeviceObject=0, EjectIrp=0;
if (CheckControlC()) {
continueDump = FALSE;
break;
}
if (GetFieldValue(pendingEntryAddr, "nt!_PENDING_RELATIONS_LIST_ENTRY", "DeviceObject", DeviceObject)){
dprintf("Error reading pending relations list entry (0x%08p)\n", pendingEntryAddr);
return continueDump;
}
GetFieldValue(pendingEntryAddr, "nt!_PENDING_RELATIONS_LIST_ENTRY", "Link.Flink", Link_Flink);
GetFieldValue(pendingEntryAddr, "nt!_PENDING_RELATIONS_LIST_ENTRY", "RelationsList", RelationsList);
GetFieldValue(pendingEntryAddr, "nt!_PENDING_RELATIONS_LIST_ENTRY", "EjectIrp", EjectIrp);
dprintf("Pending Eject of PDO 0x%08p, EjectIrp = 0x%08p, \nPending Relations List Entry @ 0x%08p\n",
DeviceObject,
EjectIrp,
pendingEntryAddr
);
continueDump = DumpRelationsList( RelationsList,
DumpCmRes,
DumpCmResReqList,
DumpCmResTrans
);
if (!continueDump) {
break;
}
}
return continueDump;
}
BOOLEAN
DumpDevNode(
ULONG64 DeviceNode,
ULONG Depth,
BOOLEAN DumpSibling,
BOOLEAN DumpChild,
BOOLEAN DumpCmRes,
BOOLEAN DumpCmResReqList,
BOOLEAN DumpCmResTrans,
BOOLEAN DumpOnlyDevnodesWithProblems,
BOOLEAN DumpOnlyNonStartedDevnodes,
PUNICODE_STRING ServiceName OPTIONAL,
BOOLEAN PrintDefault,
BOOLEAN DumpStateHistory
)
/*++
Routine Description:
Displays the driver name for the device object if FullDetail == FALSE.
Otherwise displays more information about the device and the device queue.
Arguments:
DeviceAddress - address of device object to dump.
FullDetail - TRUE means the device object name, driver name, and
information about Irps queued to the device.
DumpOnlyDevnodesWithFlags -
if set, then the only devnodes that will be dumped are
those with one of the FlagsSet bits set or one of the
FlagsNotSet bits not set.
Return Value:
None
--*/
{
ULONG result;
// DEVICE_NODE deviceNode;
BOOLEAN print = TRUE;
BOOLEAN continueDump = TRUE;
CHAR DevNodeType[]="nt!_DEVICE_NODE";
USHORT ServiceName_Len=0, ServiceName_MaxLen=0, InstancePath_Len=0, InstancePath_Max=0;
ULONG Flags=0, BusNumber=0, Header_SignalState=0, UserFlags=0;
ULONG CapabilityFlags=0, DisableableDepends=0, Problem=0;
ULONG FailureStatus=0, State=0, PreviousState=0;
ULONG StateHistoryEntry = 0;
ULONG StateHistoryValue = 0;
ULONG64 ServiceName_Buff=0, PhysicalDeviceObject=0, Parent=0, Sibling=0,
Child=0, InterfaceType=0, DuplicatePDO=0, TargetDeviceNotify_Blink=0, TargetDeviceNotify_Flink=0,
PreviousResourceList=0, ResourceList=0, BootResources=0, ResourceListTranslated=0,
ResourceRequirements=0, InstancePath_Buff=0, PreviousResourceRequirements=0;
ULONG64 TargetDeviceNotifyAddress;
ULONG AmountRead;
PNP_DEVNODE_STATE StateHistory[STATE_HISTORY_SIZE];
if (CheckControlC()) {
return FALSE;
}
GetFieldOffset("nt!_DEVICE_NODE", "TargetDeviceNotify", &result);
TargetDeviceNotifyAddress = DeviceNode + result;
#define DevFld(F) GetFieldValue(DeviceNode, DevNodeType, #F, F)
#define DevFld2(F, V) GetFieldValue(DeviceNode, DevNodeType, #F, V)
if (DevFld2(ServiceName.Length, ServiceName_Len)) {
xdprintf(Depth, "");
dprintf("%08p: Could not read device node\n", DeviceNode);
return TRUE;
}
DevFld2(ServiceName.MaximumLength, ServiceName_MaxLen);
DevFld2(ServiceName.Buffer, ServiceName_Buff);
DevFld(Flags); DevFld(PhysicalDeviceObject); DevFld(Parent);
DevFld(Sibling); DevFld(Child); DevFld(InterfaceType);
DevFld(BusNumber);DevFld(DuplicatePDO); DevFld(State);
DevFld(PreviousState);
DevFld2(InstancePath.Length, InstancePath_Len);
DevFld2(InstancePath.MaximumLength, InstancePath_Max);
DevFld2(InstancePath.Buffer, InstancePath_Buff);
DevFld2(TargetDeviceNotify.Blink, TargetDeviceNotify_Blink);
DevFld2(TargetDeviceNotify.Flink, TargetDeviceNotify_Flink);
DevFld(UserFlags); DevFld(CapabilityFlags); DevFld(DisableableDepends);
DevFld(Problem); DevFld(FailureStatus);
DevFld(PreviousResourceList); DevFld(PreviousResourceRequirements);
DevFld(ResourceList);
DevFld(BootResources); DevFld(ResourceListTranslated);
DevFld(ResourceRequirements); DevFld(StateHistoryEntry);
#undef DevFld
#undef DevFld2
//
// Check if printing should be suppressed
//
if (!PrintDefault && ServiceName != NULL) {
if ((ServiceName_Buff == 0) || (ServiceName_MaxLen <= 0) ||
(ServiceName_MaxLen > 1024)) {
print = FALSE;
} else {
//
// Compare the service names
//
UNICODE_STRING v;
v.Buffer = LocalAlloc(LPTR, ServiceName_MaxLen);
if (v.Buffer != NULL) {
v.MaximumLength = ServiceName_MaxLen;
v.Length = ServiceName_Len;
if (ReadMemory(ServiceName_Buff,
v.Buffer,
ServiceName_Len,
(PULONG) &AmountRead)) {
if (RtlCompareUnicodeString(ServiceName,
&v,
TRUE) != 0) {
//
// We are not interested in this devnode
//
print = FALSE;
}
}
LocalFree(v.Buffer);
}
}
}
if (DumpOnlyDevnodesWithProblems) {
print = (BOOLEAN) ((Flags & (DNF_HAS_PROBLEM | DNF_HAS_PRIVATE_PROBLEM)) != 0);
} else if (DumpOnlyNonStartedDevnodes) {
print = (BOOLEAN) (State != DeviceNodeStarted);
}
if (print) {
xdprintf(Depth, "");
dprintf("DevNode %#010p for PDO %#010p\n",
DeviceNode,
PhysicalDeviceObject);
Depth++;
if (!DumpChild) {
xdprintf(Depth, "");
dprintf("Parent %#010p Sibling %#010p Child %#010p\n",
Parent,
Sibling,
Child);
if ((LONG) InterfaceType != -1 ||
(BusNumber != -1 && BusNumber != -16)) {
xdprintf(Depth, "InterfaceType %#x Bus Number %#x\n",
(LONG) InterfaceType,
BusNumber);
}
if (DuplicatePDO != 0) {
dprintf("Duplicate PDO %#010p", DuplicatePDO);
}
}
if (InstancePath_Buff != 0) {
UNICODE_STRING64 v;
xdprintf(Depth, "InstancePath is \"");
v.MaximumLength = InstancePath_Max;
v.Length = InstancePath_Len;
v.Buffer = InstancePath_Buff;
DumpUnicode64(v);
dprintf("\"\n");
}
if (ServiceName_Buff != 0) {
UNICODE_STRING64 v;
xdprintf(Depth, "ServiceName is \"");
v.MaximumLength = ServiceName_MaxLen;
v.Length = ServiceName_Len;
v.Buffer = ServiceName_Buff;
DumpUnicode64(v);
dprintf("\"\n");
}
if ((TargetDeviceNotify_Flink != 0 ||
TargetDeviceNotify_Blink != 0) &&
(TargetDeviceNotify_Blink != TargetDeviceNotifyAddress ||
TargetDeviceNotify_Flink != TargetDeviceNotifyAddress)) {
xdprintf(Depth, "TargetDeviceNotify List - ");
dprintf ("f %#010p b %#010p\n",
TargetDeviceNotify_Flink,
TargetDeviceNotify_Blink);
}
PrintDevNodeState(Depth, "State", State);
PrintDevNodeState(Depth, "Previous State", PreviousState);
if (!DumpChild) {
if (DumpStateHistory) {
GetFieldOffset("nt!_DEVICE_NODE", "StateHistory", &result);
if (ReadMemory(DeviceNode+result,
StateHistory,
sizeof(StateHistory),
&AmountRead)) {
UCHAR Description[20];
ULONG index;
INT i;
for (i = STATE_HISTORY_SIZE - 1; i >= 0; i--) {
index = (i + StateHistoryEntry) % STATE_HISTORY_SIZE;
sprintf(Description, "StateHistory[%02d]", index);
PrintDevNodeState(Depth, Description, StateHistory[index]);
}
}
DumpFlags(Depth, "Flags", Flags, DeviceNodeFlags);
if (UserFlags != 0) {
DumpFlags(Depth, "UserFlags", UserFlags, DeviceNodeUserFlags);
}
if (CapabilityFlags != 0) {
DumpFlags(Depth, "CapabilityFlags", CapabilityFlags, DeviceNodeCapabilityFlags);
}
if (DisableableDepends != 0) {
xdprintf(Depth, "DisableableDepends = %d (%s)\n", DisableableDepends,
(UserFlags&DNUF_NOT_DISABLEABLE)?"including self":"from children");
}
}
}
if (Flags & DNF_HAS_PROBLEM) {
if (Problem < NUM_CM_PROB && DevNodeProblems[Problem] != NULL) {
xdprintf(Depth, "Problem = %s\n", DevNodeProblems[Problem]);
} else {
xdprintf(Depth, "Problem = Unknown problem (%d)\n", Problem);
}
if (Problem == CM_PROB_FAILED_START) {
xdprintf(Depth, "Failure Status %#010lx\n", FailureStatus);
continueDump = DumpResourceList64( "Previous CmResourceList",
Depth,
PreviousResourceList);
if (continueDump) {
continueDump = DumpResourceRequirementList64( Depth,
PreviousResourceRequirements);
}
}
}
if (continueDump && DumpCmRes) {
continueDump = DumpResourceList64( "CmResourceList",
Depth,
ResourceList);
if (continueDump) {
continueDump = DumpResourceList64( "BootResourcesList",
Depth,
BootResources);
}
}
if (continueDump && DumpCmResTrans) {
continueDump = DumpResourceList64( "TranslatedResourceList",
Depth,
ResourceListTranslated);
}
if (continueDump && DumpCmResReqList) {
continueDump = DumpResourceRequirementList64( Depth,
ResourceRequirements);
}
}
if (continueDump && DumpChild && Child) {
continueDump = DumpDevNode( Child,
Depth,
DumpChild, // whem dumping a child, dump its siblings, too
DumpChild,
DumpCmRes,
DumpCmResReqList,
DumpCmResTrans,
DumpOnlyDevnodesWithProblems,
DumpOnlyNonStartedDevnodes,
ServiceName,
print,
DumpStateHistory
);
}
if (continueDump && DumpSibling && Sibling) {
continueDump = DumpDevNode( Sibling,
(print ? (Depth - 1):Depth),
DumpSibling,
DumpChild,
DumpCmRes,
DumpCmResReqList,
DumpCmResTrans,
DumpOnlyDevnodesWithProblems,
DumpOnlyNonStartedDevnodes,
ServiceName,
PrintDefault,
DumpStateHistory
);
}
return continueDump;
}
LPSTR
GetCmResourceTypeString(
IN UCHAR Type
)
{
LPSTR typeString;
switch (Type) {
case CmResourceTypeNull:
typeString = "Null";
break;
case CmResourceTypePort:
typeString = "Port";
break;
case CmResourceTypeInterrupt:
typeString = "Interrupt";
break;
case CmResourceTypeMemory:
typeString = "Memory";
break;
case CmResourceTypeDma:
typeString = "Dma";
break;
case CmResourceTypeDeviceSpecific:
typeString = "DeviceSpeific";
break;
case CmResourceTypeBusNumber:
typeString = "BusNumber";
break;
case CmResourceTypeMaximum:
typeString = "Maximum";
break;
case CmResourceTypeNonArbitrated:
typeString = "NonArbitrated/ConfigData";
break;
case CmResourceTypeDevicePrivate:
typeString = "DevicePrivate";
break;
case CmResourceTypePcCardConfig:
typeString = "PcCardConfig";
break;
default:
typeString = "Unknown";
break;
}
return typeString;
}
VOID
DumpResourceDescriptorHeader(
ULONG Depth,
ULONG Number,
UCHAR Option,
UCHAR Type,
UCHAR SharingDisposition,
USHORT Flags
)
{
PUCHAR typeString;
PUCHAR sharingString;
xdprintf (Depth, "");
if (Option & IO_RESOURCE_PREFERRED) {
dprintf("Preferred ");
}
if (Option & IO_RESOURCE_DEFAULT) {
dprintf("Default ");
}
if (Option & IO_RESOURCE_ALTERNATIVE) {
dprintf("Alternative ");
}
dprintf ("Descriptor %d - ", Number);
typeString = GetCmResourceTypeString(Type);
switch (SharingDisposition) {
case CmResourceShareUndetermined:
sharingString = "Undetermined Sharing";
break;
case CmResourceShareDeviceExclusive:
sharingString = "Device Exclusive";
break;
case CmResourceShareDriverExclusive:
sharingString = "Driver Exclusive";
break;
case CmResourceShareShared:
sharingString = "Shared";
break;
default:
sharingString = "Unknown Sharing";
break;
}
dprintf("%s (%#x) %s (%#x)\n",
typeString,
Type,
sharingString,
SharingDisposition);
Depth++;
xdprintf (Depth, "Flags (%#04wx) - ", Flags);
switch (Type) {
case CmResourceTypePort:
if (Flags == CM_RESOURCE_PORT_MEMORY) {
dprintf ("PORT_MEMORY ");
}
if (Flags & CM_RESOURCE_PORT_IO) {
dprintf ("PORT_IO ");
}
if (Flags & CM_RESOURCE_PORT_10_BIT_DECODE) {
dprintf ("10_BIT_DECODE ");
}
if (Flags & CM_RESOURCE_PORT_12_BIT_DECODE) {
dprintf ("12_BIT_DECODE ");
}
if (Flags & CM_RESOURCE_PORT_16_BIT_DECODE) {
dprintf ("16_BIT_DECODE ");
}
if (Flags & CM_RESOURCE_PORT_POSITIVE_DECODE) {
dprintf ("POSITIVE_DECODE ");
}
break;
case CmResourceTypeMemory:
if (Flags == CM_RESOURCE_MEMORY_READ_WRITE) {
dprintf ("READ_WRITE ");
}
if (Flags & CM_RESOURCE_MEMORY_READ_ONLY) {
dprintf ("READ_ONLY ");
}
if (Flags & CM_RESOURCE_MEMORY_WRITE_ONLY) {
dprintf ("WRITE_ONLY ");
}
if (Flags & CM_RESOURCE_MEMORY_PREFETCHABLE) {
dprintf ("PREFETCHABLE ");
}
if (Flags & CM_RESOURCE_MEMORY_COMBINEDWRITE) {
dprintf ("COMBINEDWRITE ");
}
if (Flags & CM_RESOURCE_MEMORY_24) {
dprintf ("MEMORY_24 ");
}
break;
case CmResourceTypeInterrupt:
if (Flags == CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE) {
dprintf ("LEVEL_SENSITIVE ");
}
if (Flags & CM_RESOURCE_INTERRUPT_LATCHED) {
dprintf ("LATCHED ");
}
break;
case CmResourceTypeDma:
if (Flags & CM_RESOURCE_DMA_8) {
dprintf ("DMA_8 ");
}
if (Flags & CM_RESOURCE_DMA_16) {
dprintf ("DMA_16 ");
}
if (Flags & CM_RESOURCE_DMA_32) {
dprintf ("DMA_32 ");
}
if (Flags & CM_RESOURCE_DMA_8_AND_16) {
dprintf ("DMA_8_AND_16");
}
if (Flags & CM_RESOURCE_DMA_TYPE_A) {
dprintf ("DMA_TYPE_A");
}
if (Flags & CM_RESOURCE_DMA_TYPE_B) {
dprintf ("DMA_TYPE_B");
}
if (Flags & CM_RESOURCE_DMA_TYPE_F) {
dprintf ("DMA_TYPE_F");
}
break;
}
dprintf("\n");
}
DECLARE_API( arbiter )
/*++
Routine Description:
Dumps all the arbiters in the system, their allocated ranges, and
the owners of the ranges.
!arbiter [flags]
flags 1 - I/O port arbiters
2 - memory arbiters
4 - IRQ arbiters
8 - DMA arbiters
If no flags are specified, all arbiters are dumped.
Arguments:
args - optional flags specifying which arbiters to dump
Return Value:
None
--*/
{
DWORD Flags=0;
ULONG64 addr;
ULONG64 deviceNode;
Flags = (ULONG) GetExpression(args);
if (Flags == 0) {
Flags = ARBITER_DUMP_ALL;
} else if (Flags == ARBITER_NO_DUMP_ALIASES) {
Flags = ARBITER_NO_DUMP_ALIASES + ARBITER_DUMP_ALL;
}
//
// Find the root devnode and dump its arbiters
//
addr = GetExpression( "nt!IopRootDeviceNode" );
if (addr == 0) {
dprintf("Error retrieving address of IopRootDeviceNode\n");
return E_INVALIDARG;
}
if (!ReadPointer(addr, &deviceNode)) {
dprintf("Error reading value of IopRootDeviceNode (%#010p)\n", addr);
return E_INVALIDARG;
}
DumpArbitersForDevNode(0, deviceNode, Flags);
return S_OK;
}
BOOLEAN
DumpArbitersForDevNode(
IN DWORD Depth,
IN ULONG64 DevNodeAddr,
IN DWORD Flags
)
/*++
Routine Description:
Dumps all the arbiters for the specified devnode. Recursively calls
itself on the specified devnode's children.
Arguments:
Depth - Supplies the print depth.
DevNodeAddr - Supplies the address of the devnode.
Flags - Supplies the type of arbiters to dump:
ARBITER_DUMP_IO
ARBITER_DUMP_MEMORY
ARBITER_DUMP_IRQ
ARBITER_DUMP_DMA
Return Value:
None
--*/
{
ULONG result;
ULONG64 NextArbiter, startAddress;
ULONG64 ArbiterAddr;
BOOLEAN PrintedHeader = FALSE;
BOOLEAN continueDump = TRUE;
UCHAR devNodeType[] = "nt!_DEVICE_NODE";
ULONG DevArbOffset, DevNodeOffset;
ULONG64 DeviceArbiterList_Flink=0, InstancePath_Buffer=0, Child=0, Sibling=0;
UNICODE_STRING64 InstancePath;
// Get offset for listing
if (GetFieldOffset("nt!_PI_RESOURCE_ARBITER_ENTRY", "DeviceArbiterList.Flink", &DevArbOffset)) {
return TRUE;
}
if (GetFieldValue(DevNodeAddr, devNodeType, "DeviceArbiterList.Flink", DeviceArbiterList_Flink)) {
xdprintf(Depth, ""); dprintf("%08p: Could not read device node\n", DevNodeAddr);
return TRUE;
}
GetFieldOffset("nt!_DEVICE_NODE", "DeviceArbiterList.Flink", &DevNodeOffset);
GetFieldValue(DevNodeAddr, devNodeType, "Child", Child);
GetFieldValue(DevNodeAddr, devNodeType, "Sibling", Sibling);
GetFieldValue(DevNodeAddr, devNodeType, "InstancePath.Buffer", InstancePath.Buffer);
GetFieldValue(DevNodeAddr, devNodeType, "InstancePath.Length", InstancePath.Length);
GetFieldValue(DevNodeAddr, devNodeType, "InstancePath.MaximumLength", InstancePath.MaximumLength);
//
// Dump the list of arbiters
//
startAddress = DevNodeAddr + DevNodeOffset;
NextArbiter = DeviceArbiterList_Flink;
while (NextArbiter != startAddress) {
ULONG ResourceType=0;
if (CheckControlC()) {
return FALSE;
}
ArbiterAddr = NextArbiter - DevArbOffset;
// CONTAINING_RECORD(NextArbiter, PI_RESOURCE_ARBITER_ENTRY, DeviceArbiterList);
if (GetFieldValue(ArbiterAddr, "nt!_PI_RESOURCE_ARBITER_ENTRY", "ResourceType", ResourceType)) {
xdprintf(Depth, "Could not read arbiter entry ");
dprintf("%08p for devnode %08p\n", ArbiterAddr, DevNodeAddr);
break;
}
if (((ResourceType == CmResourceTypePort) && (Flags & ARBITER_DUMP_IO)) ||
((ResourceType == CmResourceTypeInterrupt) && (Flags & ARBITER_DUMP_IRQ)) ||
((ResourceType == CmResourceTypeMemory) && (Flags & ARBITER_DUMP_MEMORY)) ||
((ResourceType == CmResourceTypeDma) && (Flags & ARBITER_DUMP_DMA)) ||
((ResourceType == CmResourceTypeBusNumber) && (Flags & ARBITER_DUMP_BUS_NUMBER))) {
if (!PrintedHeader) {
dprintf("\n");
xdprintf(Depth, ""); dprintf("DEVNODE %08p ", DevNodeAddr);
if (InstancePath.Buffer != 0) {
dprintf("(");
DumpUnicode64(InstancePath);
dprintf(")");
}
dprintf("\n");
PrintedHeader = TRUE;
}
continueDump = DumpArbiter( Depth+1,
ArbiterAddr,
// &ArbiterEntry,
(BOOLEAN)!(Flags & ARBITER_NO_DUMP_ALIASES)
);
if (!continueDump) {
break;
}
}
GetFieldValue(ArbiterAddr, "nt!_PI_RESOURCE_ARBITER_ENTRY", "DeviceArbiterList.Flink", NextArbiter);
}
//
// Dump this devnode's children (if any)
//
if (continueDump && Child) {
continueDump = DumpArbitersForDevNode( Depth + 1, Child, Flags);
}
//
// Dump this devnode's siblings (if any)
//
if (continueDump && Sibling) {
continueDump = DumpArbitersForDevNode( Depth, Sibling, Flags);
}
return continueDump;
}
BOOLEAN
DumpArbiter(
IN DWORD Depth,
IN ULONG64 ArbiterAddr,
IN BOOLEAN DisplayAliases
)
/*++
Routine Description:
Dumps out the specified arbiter.
Arguments:
Depth - Supplies the print depth.
ArbiterAddr - Supplies the original address of the arbiter (on the target)
Arbiter - Supplies the arbiter
Return Value:
None.
--*/
{
ULONG64 PciInstance;
ULONG64 InstanceAddr;
BOOL IsPciArbiter = FALSE;
WCHAR NameBuffer[64];
BOOLEAN continueDump = TRUE;
UCHAR ArbiterTyp[] = "nt!_PI_RESOURCE_ARBITER_ENTRY";
UCHAR ArbIntfTyp[] = "nt!_ARBITER_INTERFACE";
ULONG64 ArbiterInterface=0, Context=0, NamePtr=0, ResourceType=0;
ULONG ListHeadOff;
//
// First obtain the ARBITER_INTERFACE.
//
if (GetFieldValue(ArbiterAddr, ArbiterTyp, "ArbiterInterface", ArbiterInterface)) {
dprintf("Error reading ArbiterInterface %08p for ArbiterEntry at %08p\n",
ArbiterInterface,
ArbiterAddr);
return continueDump;
}
if (!ArbiterInterface ||
GetFieldValue(ArbiterInterface, ArbIntfTyp, "Context", Context)) {
dprintf("Error reading ArbiterInterface %08p for ArbiterEntry at %08p\n",
ArbiterInterface,
ArbiterAddr);
return continueDump;
}
//
// Now that we have the ARBITER_INTERFACE we need to get the ARBITER_INSTANCE.
// This is not as easy as it should be since PeterJ is paranoid and encrypts the
// pointer to it. Luckily, we know his secret encryption method and can decrypt it.
// First we have to figure out if this is PCI's arbiter. Quick hack check is to see
// if the low bit is set.
//
if (Context & 1) {
ULONG Offset;
GetFieldOffset("nt!_PCI_ARBITER_INSTANCE", "CommonInstance", &Offset);
IsPciArbiter = TRUE;
PciInstance = (Context ^ PciFdoExtensionType);
InstanceAddr = PciInstance + Offset;
} else {
//
// We will assume that the context is just a pointer to an ARBITER_INSTANCE structure
//
InstanceAddr = Context;
}
//
// Read the instance
//
if (GetFieldValue(InstanceAddr, "nt!_ARBITER_INSTANCE", "Name", NamePtr)) {
dprintf("Error reading ArbiterInstance %08p for ArbiterInterface at %08p\n",
InstanceAddr,
ArbiterInterface);
return continueDump;
}
GetFieldValue(InstanceAddr, "nt!_ARBITER_INSTANCE", "ResourceType", ResourceType);
xdprintf(Depth,
"%s Arbiter \"",
GetCmResourceTypeString((UCHAR)ResourceType));
if (NamePtr != 0) {
ULONG result;
if (ReadMemory(NamePtr,NameBuffer,sizeof(NameBuffer),&result)) {
NameBuffer[sizeof(NameBuffer)/sizeof(WCHAR) - 1] = 0;
dprintf("%ws",NameBuffer);
}
}
dprintf("\" at %08p\n",InstanceAddr);
xdprintf(Depth+1,"Allocated ranges:\n");
GetFieldOffset("nt!_RTL_RANGE_LIST", "ListHead", &ListHeadOff);
InitTypeRead(InstanceAddr, nt!_ARBITER_INSTANCE);
continueDump = DumpRangeList( Depth+2,
ReadField(Allocation) + ListHeadOff,
FALSE,
TRUE,
DisplayAliases,
NULL);
if (continueDump) {
InitTypeRead(InstanceAddr, nt!_ARBITER_INSTANCE);
xdprintf(Depth+1,"Possible allocation:\n");
continueDump = DumpRangeList(Depth+2, ReadField(PossibleAllocation) + ListHeadOff,
FALSE, TRUE, DisplayAliases, NULL);
}
return continueDump;
}
VOID
DumpRangeEntry(
IN DWORD Depth,
IN ULONG64 RangeEntry,
IN BOOLEAN OwnerIsDevObj,
IN BOOLEAN DisplayAliases,
IN pUserDataInterpretationFunction PrintUserData OPTIONAL
)
/*++
Routine Description:
Dumps out the specified RTLP_RANGE_LIST_ENTRY
Arguments:
Depth - Supplies the print depth.
RangeList - Supplies the address of the RTLP_RANGE_LIST_ENTRY
OwnerIsDevObj - Indicates that the owner field is a pointer to a DEVICE_OBJECT
Return Value:
None.
--*/
{
ULONG PrivateFlags=0, Attributes=0, PublicFlags=0;
ULONG64 Owner=0, Start=0, End=0, UserData=0;
if (GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "PrivateFlags", PrivateFlags)) {
dprintf("Cannot find _RTLP_RANGE_LIST_ENTRY type.\n");
return ;
}
// dprintf("Range Entry %p\n", RangeEntry);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "Attributes", Attributes);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "Start", Start);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "End", End);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "PublicFlags", PublicFlags);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "Allocated.Owner", Owner);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "Allocated.UserData", UserData);
if (!(PrivateFlags & RTLP_RANGE_LIST_ENTRY_MERGED)) {
ULONG64 DeviceObjectExtension=0, DeviceNode=0;
if ((Attributes & ARBITER_RANGE_ALIAS) && !DisplayAliases) {
return;
}
if (OwnerIsDevObj && Owner) {
if (GetFieldValue(Owner, "nt!_DEVICE_OBJECT", "DeviceObjectExtension", DeviceObjectExtension)) {
dprintf("Error reading DeviceObject %08p\n",
Owner
);
return;
}
if (GetFieldValue(DeviceObjectExtension, "nt!_DEVOBJ_EXTENSION", "DeviceNode", DeviceNode)) {
dprintf("Error reading DeviceObjectExtension %08p\n",
DeviceObjectExtension
);
return;
}
}
xdprintf(Depth,
"%016I64x - %016I64x %c%c%c%c%c",
Start,
End,
PublicFlags & RTL_RANGE_SHARED ? 'S' : ' ',
PublicFlags & RTL_RANGE_CONFLICT ? 'C' : ' ',
(Attributes & ARBITER_RANGE_BOOT_ALLOCATED)? 'B' : (Attributes & ARBITER_RANGE_SHARE_DRIVER_EXCLUSIVE)? 'D' : ' ',
Attributes & ARBITER_RANGE_ALIAS ? 'A' : ' ',
Attributes & ARBITER_RANGE_POSITIVE_DECODE ? 'P' : ' ');
dprintf(" %08p ",Owner);
if (Owner) {
UNICODE_STRING64 ServiceName;
GetFieldValue(DeviceNode, "nt!_DEVICE_NODE", "ServiceName.Buffer", ServiceName.Buffer);
if (OwnerIsDevObj && ServiceName.Buffer) {
GetFieldValue(DeviceNode, "nt!_DEVICE_NODE", "ServiceName.Length", ServiceName.Length);
GetFieldValue(DeviceNode, "nt!_DEVICE_NODE", "ServiceName.MaximumLength", ServiceName.MaximumLength);
dprintf(" (");
DumpUnicode64(ServiceName);
dprintf(")");
}
} else {
dprintf("<Not on bus>");
}
if (PrintUserData) {
PrintUserData(UserData);
}
} else {
xdprintf(Depth,
"%016I64x - %016I64x %c%c ",
Start,
End,
PublicFlags & RTL_RANGE_SHARED ? 'S' : ' ',
PublicFlags & RTL_RANGE_CONFLICT ? 'C' : ' '
);
}
dprintf("\n");
}
BOOLEAN
DumpRangeList(
IN DWORD Depth,
IN ULONG64 RangeListHead,
IN BOOLEAN IsMerged,
IN BOOLEAN OwnerIsDevObj,
IN BOOLEAN DisplayAliases,
IN pUserDataInterpretationFunction PrintUserData OPTIONAL
)
/*++
Routine Description:
Dumps out the specified RTL_RANGE_LIST
Arguments:
Depth - Supplies the print depth.
RangeListHead - Supplies the address of the LIST_ENTRY containing the RTLP_RANGE_LIST_ENTRYs
IsMerged - Indicates whether this list is in a merged range
OwnerIsDevObj - Indicates that the owner field is a pointer to a DEVICE_OBJECT
Return Value:
None.
--*/
{
ULONG64 ListEntry, EntryAddr;
ULONG ListEntryOffset, ListHeadOffset;
BOOLEAN continueDump = TRUE;
GetFieldOffset("nt!_RTLP_RANGE_LIST_ENTRY", "ListEntry", &ListEntryOffset);
GetFieldOffset("nt!_RTLP_RANGE_LIST_ENTRY", "Merged.ListHead", &ListHeadOffset);
//
// Read the range list
//
if (GetFieldValue(RangeListHead, "nt!_LIST_ENTRY", "Flink", ListEntry)) {
dprintf("Error reading RangeList %08p\n", RangeListHead);
return TRUE;
}
if (ListEntry == RangeListHead) {
xdprintf(Depth, "< none >\n");
return TRUE;
}
while (ListEntry != RangeListHead) {
ULONG PrivateFlags=0;
ULONG64 ListHeadAddr=0;
if (CheckControlC()) {
continueDump = FALSE;
break;
}
EntryAddr = ListEntry - ListEntryOffset;
if (GetFieldValue(EntryAddr, "nt!_RTLP_RANGE_LIST_ENTRY", "PrivateFlags", PrivateFlags)) {
dprintf("Error reading RangeEntry %08p from RangeList %08p\n",
EntryAddr,
RangeListHead);
return TRUE;
}
if (PrivateFlags & RTLP_RANGE_LIST_ENTRY_MERGED) {
//
// This is a merged range list, call ourselves recursively
//
DumpRangeEntry(Depth, EntryAddr, FALSE, DisplayAliases, PrintUserData);
continueDump = DumpRangeList(Depth + 1, EntryAddr + ListHeadOffset, TRUE, TRUE, DisplayAliases, PrintUserData);
if (!continueDump) {
break;
}
} else {
DumpRangeEntry(Depth, EntryAddr, OwnerIsDevObj, DisplayAliases, PrintUserData);
}
GetFieldValue(EntryAddr, "nt!_RTLP_RANGE_LIST_ENTRY", "ListEntry.Flink", ListEntry);
}
return continueDump;
}
DECLARE_API( range )
/*++
Routine Description:
Dumps an RTL_RANGE_LIST
Arguments:
args - specifies the address of the RTL_RANGE_LIST
Return Value:
None
--*/
{
ULONG ListHeadOffset;
BOOLEAN continueDump = TRUE;
ULONG64 RangeList;
if (GetFieldOffset("nt!_RTL_RANGE_LIST", "ListHead", &ListHeadOffset)) {
dprintf("Cannot find _RTL_RANGE_LIST type.\n");
return E_INVALIDARG;
}
RangeList = GetExpression(args);
DumpRangeList(0, RangeList + ListHeadOffset, FALSE, FALSE, TRUE, NULL);
return S_OK;
}
ULONG
DumpArbList(
PFIELD_INFO ListElement,
PVOID Context
)
{
UCHAR andOr = ' ';
ULONG resourceType = 0xffffffff;
ULONG remaining;
PULONG data;
PCHAR headingDefault = " Owner Data";
PCHAR formatDefault = "%c %s %c %08x %08x %08x %08x %08x %08x\n";
PCHAR headingMemIo = " Owner Length Alignment Minimum Address - Maximum Address\n";
PCHAR formatMemIo = "%c %s %c %8x %8x %08x%08x - %08x%08x\n";
PCHAR headingIrqDma = " Owner Minimum - Maximum\n";
PCHAR formatIrqDma = "%c %s %c %8x - %-8x\n";
PCHAR heading = headingDefault;
PCHAR format = formatDefault;
CHAR shared;
CHAR ownerBuffer[20];
PCHAR ownerBlank = " ";
PCHAR ownerText = ownerBlank;
ULONG64 pcurrent=ListElement->address;
ULONG64 palternative;
static ULONG64 previousOwner = 0;
BOOLEAN doHeading = TRUE;
BOOLEAN verbose = FALSE;
ULONG Flag = *((PULONG) Context);
ULONG AlternativeCount=0, resDescSize;
ULONG64 PhysicalDeviceObject, Alternatives;
ULONG Flags=0, InterfaceType=0, RequestSource=0;
//
// Check if user wants out.
//
if (CheckControlC()) {
dprintf("User terminated with <control>C\n");
return TRUE;
}
if ((LONG64)pcurrent >= 0) {
dprintf("List broken, forward entry is not a valid kernel address.\n");
return TRUE;
}
if (Flag & 1) {
verbose = TRUE;
}
//
// Get the arbitration list entry from host memory.
//
if (GetFieldValue(pcurrent, "nt!_ARBITER_LIST_ENTRY", "PhysicalDeviceObject", PhysicalDeviceObject)) {
dprintf("Couldn't read _ARBITER_LIST_ENTRY at %p\n", pcurrent);
return TRUE;
}
//
// Check if we've changed device objects.
//
if (previousOwner != PhysicalDeviceObject) {
previousOwner = PhysicalDeviceObject;
sprintf(ownerBuffer, "%08I64lx", previousOwner);
ownerText = ownerBuffer;
andOr = ' ';
if (verbose) {
doHeading = TRUE;
}
}
//
// Run the alternatives for this device object.
//
GetFieldValue(pcurrent, "nt!_ARBITER_LIST_ENTRY", "AlternativeCount", AlternativeCount);
GetFieldValue(pcurrent, "nt!_ARBITER_LIST_ENTRY", "Alternatives", Alternatives);
GetFieldValue(pcurrent, "nt!_ARBITER_LIST_ENTRY", "Flags", Flags);
GetFieldValue(pcurrent, "nt!_ARBITER_LIST_ENTRY", "InterfaceType", InterfaceType);
GetFieldValue(pcurrent, "nt!_ARBITER_LIST_ENTRY", "RequestSource", RequestSource);
resDescSize = GetTypeSize("nt!_IO_RESOURCE_DESCRIPTOR");
for (remaining = AlternativeCount, palternative = Alternatives;
remaining;
remaining--, palternative+=resDescSize) {
ULONG Type=0, ShareDisposition=0, Gen_Length=0, Gen_Alignment=0;
ULONG Gen_Min_Low, Gen_Min_Hi=0, Gen_Max_Low=0, Gen_Max_Hi=0;
ULONG Int_Min=0, Int_Max=0, DevData[6]={0};
//
// Check if user wants out.
//
if (CheckControlC()) {
dprintf("User terminated with <control>C\n");
return TRUE;
}
//
// Read this resource descriptor from memory. (An optimization
// would be to read the entire array or to buffer it).
//
if (GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "Type", Type)){
dprintf("Couldn't read IO_RESOURCE_DESCRIPTOR at %08p, quitting.\n",
palternative
);
return TRUE;
}
if (Type != resourceType) {
if (resourceType == 0xffffffff) {
//
// Go look at the first alternative to figure out what
// resource type is being arbitrated.
//
resourceType = Type;
switch (resourceType) {
case CmResourceTypeNull:
dprintf("Arbitration list resource type is NULL. Seems odd.\n");
break;
case CmResourceTypePort:
dprintf("Arbitrating CmResourceTypePort resources\n");
format = formatMemIo;
heading = headingMemIo;
break;
case CmResourceTypeInterrupt:
dprintf("Arbitrating CmResourceTypeInterrupt resources\n");
format = formatIrqDma;
heading = headingIrqDma;
break;
case CmResourceTypeMemory:
dprintf("Arbitrating CmResourceTypeMemory resources\n");
format = formatMemIo;
heading = headingMemIo;
break;
case CmResourceTypeDma:
dprintf("Arbitrating CmResourceTypeDma resources\n");
format = formatIrqDma;
heading = headingIrqDma;
break;
default:
dprintf("Arbitrating resource type 0x%x\n", Type);
}
} else {
dprintf("error: Resource Type change, arbiters don't do multiple\n");
dprintf("types. Resource Type was 0x%x, new type 0x%x, quitting.\n",
resourceType, Type);
return TRUE;
}
}
if (doHeading) {
if (verbose) {
dprintf("Owning object %08p, Flags 0x%x, Interface 0x%x, Source 0x%x\n",
PhysicalDeviceObject,
Flags,
InterfaceType,
RequestSource
);
}
dprintf(heading);
doHeading = FALSE;
}
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "ShareDisposition", ShareDisposition);
shared = ShareDisposition == CmResourceShareShared ? 'S' : ' ';
switch (resourceType) {
case CmResourceTypePort:
case CmResourceTypeMemory:
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "u.Generic.Length", Gen_Length);
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "u.Generic.Alignment", Gen_Alignment);
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "u.Generic.MinimumAddress.HighPart", Gen_Min_Hi);
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "u.Generic.MinimumAddress.LowPart", Gen_Min_Low);
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "u.Generic.MaximumAddress.HighPart", Gen_Max_Hi);
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "u.Generic.MaximumAddress.LowPart", Gen_Max_Low );
dprintf(format,
andOr,
ownerText,
shared,
Gen_Length,
Gen_Alignment,
Gen_Min_Hi,
Gen_Min_Low,
Gen_Max_Hi,
Gen_Max_Low
);
break;
case CmResourceTypeInterrupt:
case CmResourceTypeDma:
//
// Dma and Interrupt are same format,... overload.
//
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "u.Interrupt.MinimumVector", Int_Min);
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "u.Interrupt.MaximumVector", Int_Max);
dprintf(format,
andOr,
ownerText,
shared,
Int_Min,
Int_Max
);
break;
default:
GetFieldValue(palternative, "nt!_IO_RESOURCE_DESCRIPTOR", "u.DevicePrivate.Data", DevData);
data = DevData;
dprintf(format,
andOr,
ownerText,
shared,
*data,
*(data + 0),
*(data + 1),
*(data + 2),
*(data + 3),
*(data + 4),
*(data + 5)
);
break;
}
ownerText = ownerBlank;
andOr = '|';
}
if (AlternativeCount == 0) {
//
// Get here if the alternatives list was empty.
//
if (doHeading) {
dprintf("Owning object %08p, Flags 0x%x, Interface 0x%x\n",
PhysicalDeviceObject,
Flags,
InterfaceType
);
}
dprintf("Arbiter list entry (@%08p) has 0 resources. Seems odd.\n",
pcurrent
);
}
andOr = '&';
return FALSE; // Continue dumping the list
}
DECLARE_API( arblist )
/*++
Routine Description:
Dumps an arbitration list (2nd parameter to PnpTestAllocation).
!arblist address
If no address specified we try to tell you what to do.
Arguments:
address of the arbitration list.
Return Value:
None
--*/
{
ULONG64 ArbitrationList = 0;
ULONG Flags = 0;
ULONG64 pcurrent;
ULONG64 palternative;
ULONG64 KModeCheck;
BOOL Ptr64 = IsPtr64();
if (GetExpressionEx(args, &ArbitrationList, &args)) {
Flags = (ULONG) GetExpression(args);
}
if (ArbitrationList == 0) {
dprintf("!arblist <address> [flags]\n");
dprintf(" <address> is the address of an arbitration list.\n");
dprintf(" [flags] Bitmask used to adjust what is printed.\n");
dprintf(" 0001 Include interface, flags and source for each device\n");
dprintf("\n");
dprintf(" Prints out an arbitration list. An arbitration list\n");
dprintf(" is the set of resources for which arbitration is\n");
dprintf(" needed. (eg second parameter to PnpTestAllocation).\n");
return E_INVALIDARG;
}
if (Ptr64) {
KModeCheck = 0x8000000000000000L;
} else {
KModeCheck = 0xffffffff80000000L;
}
//
// The argument is a pointer to a list head.
//
if (!((LONG64)ArbitrationList & KModeCheck)) {
dprintf("The arbitration list pointer must be a kernel mode address.\n");
return E_INVALIDARG;
}
if (GetFieldValue(ArbitrationList, "nt!_LIST_ENTRY", "Flink", pcurrent)) {
dprintf("error reading arbitration list ListHead, cannot continue.\n");
return E_INVALIDARG;
}
//
// A little validation.
//
if (!(pcurrent & KModeCheck)) {
dprintf("%08p does not point to a valid list head.\n", ArbitrationList);
return E_INVALIDARG;
}
if (pcurrent == ArbitrationList) {
dprintf("%08p points to an empty list.\n", ArbitrationList);
return E_INVALIDARG;
}
//
// Run the list.
//
ListType("_ARBITER_LIST_ENTRY", pcurrent, TRUE, "ListEntry.Flink", (PVOID) &Flags, DumpArbList);
return S_OK;
}
ULONG
TokenizeString(
PUCHAR Input,
PUCHAR *Output,
ULONG Max
)
/*++
Routine Description:
Convert an input string of white space delimited tokens into
an array of strings. The routine will produce an array of
pointers to strings where the (maximum) size of the array is
given by Max. Note, if Max is too small to fully tokenize the
string, the last element of the array will point to the remainder
of the string.
Arguments:
Input Input string
Output Pointer to an array which will be filled in with
pointers to each new token.
Max Maximum number of strings.
Return Value:
Number of tokens found.
--*/
{
ULONG count = 0;
PUCHAR tok;
BOOLEAN inToken = FALSE;
UCHAR c;
if (Max == 0) {
return 0;
}
while ((c = *Input++) != '\0') {
if (isspace(c)) {
if (!inToken) {
//
// Continue skipping characters.
//
continue;
}
//
// Found end of Token, delimit it and change state.
//
inToken = FALSE;
*(Input - 1) = '\0';
} else {
//
// Non-blank character.
//
if (inToken) {
//
// Continue search for end of token.
//
continue;
}
//
// New Token.
//
inToken = TRUE;
*Output++ = Input - 1;
count++;
if (count == Max) {
//
// We can't find any more so return what we still
// have as the last thing.
//
return count;
}
}
}
return count;
}
//
// DevExtPCI
//
// Data structures and functions to implement !devext pci.
//
PUCHAR DevExtPciDeviceState[] = {
"PciNotStarted",
"PciStarted",
"PciDeleted",
"PciStopped",
"PciSurpriseRemoved",
"PciSynchronizedOperation"
};
PUCHAR DevExtPciSystemPowerState[] = {
"Unspecified",
"Working",
"Sleeping1",
"Sleeping2",
"Sleeping3",
"Hibernate",
"Shutdown"
};
PUCHAR DevExtPciDevicePowerState[] = {
"Unspecified",
"D0",
"D1",
"D2",
"D3"
};
struct {
USHORT VendorId;
PUCHAR VendorName;
} DevExtPciVendors[] = {
{ 0x003D, "LOCKHEED MARTIN"},
{ 0x0E11, "COMPAQ"},
{ 0x1002, "ATI TECHNOLOGIES INC"},
{ 0x1003, "ULSI SYSTEMS"},
{ 0x1004, "VLSI TECHNOLOGY INC"},
{ 0x1006, "REPLY GROUP"},
{ 0x1007, "NETFRAME SYSTEMS INC"},
{ 0x1008, "EPSON"},
{ 0x100A, "PHOENIX TECHNOLOGIES"},
{ 0x100B, "NATIONAL SEMICONDUCTOR CORPORATION"},
{ 0x100C, "TSENG LABS INC"},
{ 0x100D, "AST RESEARCH INC"},
{ 0x1010, "VIDEO LOGIC LTD"},
{ 0x1011, "DIGITAL EQUIPMENT CORPORATION"},
{ 0x1012, "MICRONICS COMPUTERS INC"},
{ 0x1013, "CIRRUS LOGIC"},
{ 0x1014, "IBM"},
{ 0x1015, "LSI LOGIC CORP OF CANADA"},
{ 0x1016, "ICL PERSONAL SYSTEMS"},
{ 0x1017, "SPEA SOFTWARE AG"},
{ 0x1018, "UNISYS SYSTEMS"},
{ 0x1019, "ELITEGROUP COMPUTER SYS"},
{ 0x101A, "NCR"},
{ 0x101C, "WESTERN DIGITAL"},
{ 0x101E, "AMERICAN MEGATRENDS"},
{ 0x101F, "PICTURETEL"},
{ 0x1021, "OKI ELECTRIC INDUSTRY"},
{ 0x1022, "ADVANCED MICRO DEVICES"},
{ 0x1023, "TRIDENT MICROSYSTEMS"},
{ 0x1025, "ACER INCORPORATED"},
{ 0x1028, "DELL COMPUTER CORPORATION"},
{ 0x102B, "MATROX"},
{ 0x102C, "CHIPS AND TECHNOLOGIES"},
{ 0x102E, "OLIVETTI ADVANCED TECHNOLOGY"},
{ 0x102F, "TOSHIBA AMERICA ELECT."},
{ 0x1030, "TMC RESEARCH"},
{ 0x1031, "MIRO COMPUTER PRODUCTS AG"},
{ 0x1033, "NEC CORPORATION"},
{ 0x1033, "NEC CORPORATION"},
{ 0x1034, "BURNDY CORPORATION"},
{ 0x1035, "COMP.&COMM. RESH. LAB"},
{ 0x1036, "FUTURE DOMAIN"},
{ 0x1037, "HITACHI MICRO SYSTEMS"},
{ 0x1038, "AMP, INC"},
{ 0x1039, "SILICON INTEGRATED SYSTEM"},
{ 0x103A, "SEIKO EPSON CORPORATION"},
{ 0x103B, "TATUNG CO. OF AMERICA"},
{ 0x103C, "HEWLETT PACKARD"},
{ 0x103E, "SOLLIDAY ENGINEERING"},
{ 0x103F, "SYNOPSYS INC."},
{ 0x1040, "ACCELGRAPHICS INC."},
{ 0x1042, "PC TECHNOLOGY INC"},
{ 0x1043, "ASUSTEK COMPUTER, INC."},
{ 0x1044, "DISTRIBUTED PROCESSING TECHNOLOGY"},
{ 0x1045, "OPTI"},
{ 0x1046, "IPC CORPORATION, LTD."},
{ 0x1047, "GENOA SYSTEMS CORP"},
{ 0x1048, "ELSA GMBH"},
{ 0x1049, "FOUNTAIN TECHNOLOGY"},
{ 0x104A, "SGS THOMSON"},
{ 0x104B, "BUSLOGIC"},
{ 0x104C, "TEXAS INSTRUMENTS"},
{ 0x104D, "SONY CORPORATION"},
{ 0x104E, "OAK TECHNOLOGY, INC"},
{ 0x1050, "WINBOND ELECTRONICS CORP"},
{ 0x1051, "ANIGMA, INC."},
{ 0x1055, "EFAR MICROSYSTEMS"},
{ 0x1057, "MOTOROLA"},
{ 0x1058, "ELECTRONICS & TELEC. RSH"},
{ 0x1059, "TEKNOR INDUSTRIAL COMPUTERS INC"},
{ 0x105A, "PROMISE TECHNOLOGY"},
{ 0x105B, "FOXCONN INTERNATIONAL"},
{ 0x105C, "WIPRO INFOTECH LIMITED"},
{ 0x105D, "NUMBER 9 COMPUTER COMPANY"},
{ 0x105E, "VTECH COMPUTERS LTD"},
{ 0x105F, "INFOTRONIC AMERICA INC"},
{ 0x1060, "UNITED MICROELECTRONICS"},
{ 0x1061, "I.T.T."},
{ 0x1062, "MASPAR COMPUTER CORP"},
{ 0x1063, "OCEAN OFFICE AUTOMATION"},
{ 0x1064, "ALCATEL CIT"},
{ 0x1065, "TEXAS MICROSYSTEMS"},
{ 0x1066, "PICOPOWER TECHNOLOGY"},
{ 0x1067, "MITSUBISHI ELECTRONICS"},
{ 0x1068, "DIVERSIFIED TECHNOLOGY"},
{ 0x1069, "MYLEX CORPORATION"},
{ 0x106B, "APPLE COMPUTER INC."},
{ 0x106C, "HYUNDAI ELECTRONICS AMERI"},
{ 0x106D, "SEQUENT"},
{ 0x106E, "DFI, INC"},
{ 0x106F, "CITY GATE DEVELOPMENT LTD"},
{ 0x1070, "DAEWOO TELECOM LTD"},
{ 0x1073, "YAMAHA CORPORATION"},
{ 0x1074, "NEXGEN MICROSYSTEME"},
{ 0x1075, "ADVANCED INTEGRATION RES."},
{ 0x1076, "CHAINTECH COMPUTER CO. LTD"},
{ 0x1077, "Q LOGIC"},
{ 0x1078, "CYRIX CORPORATION"},
{ 0x1079, "I-BUS"},
{ 0x107B, "GATEWAY 2000"},
{ 0x107C, "LG ELECTRONICS"},
{ 0x107D, "LEADTEK RESEARCH INC."},
{ 0x107E, "INTERPHASE CORPORATION"},
{ 0x107F, "DATA TECHNOLOGY CORPORATION"},
{ 0x1080, "CYPRESS SEMICONDUCTOR"},
{ 0x1081, "RADIUS"},
{ 0x1083, "FOREX COMPUTER CORPORATION"},
{ 0x1085, "TULIP COMPUTERS INT.B.V."},
{ 0x1089, "DATA GENERAL CORPORATION"},
{ 0x108A, "BIT 3 COMPUTER"},
{ 0x108C, "OAKLEIGH SYSTEMS INC."},
{ 0x108D, "OLICOM"},
{ 0x108E, "SUN MICROSYSTEMS"},
{ 0x108F, "SYSTEMSOFT"},
{ 0x1090, "ENCORE COMPUTER CORPORATION"},
{ 0x1091, "INTERGRAPH CORPORATION"},
{ 0x1092, "DIAMOND MULTMEDIA SYSTEMS"},
{ 0x1093, "NATIONAL INSTRUMENTS"},
{ 0x1094, "FIRST INT'L COMPUTERS"},
{ 0x1095, "CMD TECHNOLOGY INC"},
{ 0x1096, "ALACRON"},
{ 0x1098, "QUANTUM DESIGNS (H.K.) LTD"},
{ 0x109B, "GEMLIGHT COMPUTER LTD."},
{ 0x109E, "BROOKTREE CORPORATION"},
{ 0x109F, "TRIGEM COMPUTER INC."},
{ 0x10A0, "MEIDENSHA CORPORATION"},
{ 0x10A2, "QUANTUM CORPORATION"},
{ 0x10A3, "EVEREX SYSTEMS INC"},
{ 0x10A5, "RACAL INTERLAN"},
{ 0x10A8, "SIERRA SEMICONDUCTOR"},
{ 0x10A9, "SILICON GRAPHICS"},
{ 0x10AA, "ACC MICROELECTRONICS"},
{ 0x10AD, "SYMPHONY LABS"},
{ 0x10AE, "CORNERSTONE TECHNOLOGY"},
{ 0x10B0, "CARDEXPERT TECHNOLOGY"},
{ 0x10B1, "CABLETRON SYSTEMS INC"},
{ 0x10B2, "RAYTHEON COMPANY"},
{ 0x10B3, "DATABOOK INC"},
{ 0x10B4, "STB SYSTEMS INC"},
{ 0x10B5, "PLX TECHNOLOGY"},
{ 0x10B6, "MADGE NETWORKS"},
{ 0x10B7, "3COM CORPORATION"},
{ 0x10B8, "STANDARD MICROSYSTEMS"},
{ 0x10B9, "ACER LABS"},
{ 0x10BA, "MITSUBISHI ELECTRONICS CORP."},
{ 0x10BC, "ADVANCED LOGIC RESEARCH"},
{ 0x10BD, "SURECOM TECHNOLOGY"},
{ 0x10C0, "BOCA RESEARCH INC."},
{ 0x10C1, "ICM CO., LTD."},
{ 0x10C2, "AUSPEX SYSTEMS INC."},
{ 0x10C3, "SAMSUNG SEMICONDUCTORS"},
{ 0x10C4, "AWARD SOFTWARE INTERNATIONAL INC."},
{ 0x10C5, "XEROX CORPORATION"},
{ 0x10C6, "RAMBUS INC."},
{ 0x10C8, "NEOMAGIC CORPORATION"},
{ 0x10C9, "DATAEXPERT CORPORATION"},
{ 0x10CB, "OMRON CORPORATION"},
{ 0x10CC, "MENTOR ARC INC"},
{ 0x10CD, "ADVANCED SYSTEM PRODUCTS, INC"},
{ 0x10D0, "FUJITSU LIMITED"},
{ 0x10D1, "FUTURE+ SYSTEMS"},
{ 0x10D2, "MOLEX INCORPORATED"},
{ 0x10D3, "JABIL CIRCUIT INC"},
{ 0x10D4, "HUALON MICROELECTRONICS"},
{ 0x10D6, "CETIA"},
{ 0x10D7, "BCM ADVANCED"},
{ 0x10D8, "ADVANCED PERIPHERALS LABS"},
{ 0x10DA, "THOMAS-CONRAD CORPORATION"},
{ 0x10DC, "CERN/ECP/EDU"},
{ 0x10DD, "EVANS & SUTHERLAND"},
{ 0x10DE, "NVIDIA CORPORATION"},
{ 0x10DF, "EMULEX CORPORATION"},
{ 0x10E0, "INTEGRATED MICRO SOLUTIONS INC."},
{ 0x10E1, "TEKRAM TECHNOLOGY CO.,LTD."},
{ 0x10E2, "APTIX CORPORATION"},
{ 0x10E3, "TUNDRA SEMICONDUCTOR (formerly NEWBRIDGE MICROSYSTEMS)"},
{ 0x10E4, "TANDEM COMPUTERS"},
{ 0x10E5, "MICRO INDUSTRIES CORPORATION"},
{ 0x10E6, "GAINBERY COMPUTER PRODUCTS INC."},
{ 0x10E7, "VADEM"},
{ 0x10E8, "APPLIED MICRO CIRCUITS CORPORATION"},
{ 0x10E9, "ALPS ELECTRIC CO. LTD."},
{ 0x10EB, "ARTISTS GRAPHICS"},
{ 0x10EC, "REALTEK SEMICONDUCTOR CO., LTD."},
{ 0x10ED, "ASCII CORPORATION"},
{ 0x10EE, "XILINX CORPORATION"},
{ 0x10EF, "RACORE COMPUTER PRODUCTS, INC."},
{ 0x10F0, "PERITEK CORPORATION"},
{ 0x10F1, "TYAN COMPUTER"},
{ 0x10F3, "ALARIS, INC."},
{ 0x10F4, "S-MOS SYSTEMS"},
{ 0x10F5, "NKK CORPORATION"},
{ 0x10F6, "CREATIVE ELECTRONIC SYSTEMS SA"},
{ 0x10F7, "MATSUSHITA ELECTRIC INDUSTRIAL CO., LTD."},
{ 0x10F8, "ALTOS INDIA LTD"},
{ 0x10F9, "PC DIRECT"},
{ 0x10FA, "TRUEVISION"},
{ 0x10FB, "THESYS GES. F. MIKROELEKTRONIK MGH"},
{ 0x10FC, "I-O DATA DEVICE, INC."},
{ 0x10FD, "SOYO COMPUTER INC."},
{ 0x10FE, "FAST ELECTRONIC GMBH"},
{ 0x10FF, "NCUBE"},
{ 0x1100, "JAZZ MULTIMEDIA"},
{ 0x1101, "INITIO CORPORATION"},
{ 0x1102, "CREATIVE LABS"},
{ 0x1103, "TRIONES TECHNOLOGIES, INC."},
{ 0x1104, "RASTEROPS"},
{ 0x1105, "SIGMA DESIGNS, INC"},
{ 0x1106, "VIA TECHNOLOGIES, INC."},
{ 0x1107, "STRATUS COMPUTERS"},
{ 0x1108, "PROTEON, INC."},
{ 0x1109, "COGENT DATA TECHNOLOGIES"},
{ 0x110A, "SIEMENS NIXDORF IS/AG"},
{ 0x110B, "CHROMATIC RESEARCH INC."},
{ 0x110C, "MINI-MAX TECHNOLOGY, INC."},
{ 0x110D, "ZNYX ADVANCED SYSTEMS"},
{ 0x110E, "CPU TECHNOLOGY"},
{ 0x110F, "ROSS TECHNOLOGY"},
{ 0x1110, "Fire Power Systems, Inc."},
{ 0x1111, "SANTA CRUZ OPERATION"},
{ 0x1112, "RNS (formerly ROCKWELL NETWORK SYSTEMS)"},
{ 0x1114, "ATMEL CORPORATION"},
{ 0x1117, "DATACUBE, INC"},
{ 0x1118, "BERG ELECTRONICS"},
{ 0x1119, "VORTEX COMPUTERSYSTEME GMBH"},
{ 0x111A, "EFFICIENT NETWORKS"},
{ 0x111B, "LITTON GCS"},
{ 0x111C, "TRICORD SYSTEMS"},
{ 0x111D, "INTEGRATED DEVICE TECH"},
{ 0x111F, "PRECISION DIGITAL IMAGES"},
{ 0x1120, "EMC CORPORATION"},
{ 0x1122, "MULTI-TECH SYSTEMS, INC."},
{ 0x1123, "EXCELLENT DESIGN, INC."},
{ 0x1124, "LEUTRON VISION AG"},
{ 0x1127, "FORE SYSTEMS INC"},
{ 0x1129, "FIRMWORKS"},
{ 0x112A, "HERMES ELECTRONICS COMPANY, LTD."},
{ 0x112B, "LINOTYPE - HELL AG"},
{ 0x112C, "ZENITH DATA SYSTEMS"},
{ 0x112E, "INFOMEDIA MICROELECTRONICS INC."},
{ 0x112F, "IMAGING TECHNLOGY INC"},
{ 0x1130, "COMPUTERVISION"},
{ 0x1131, "PHILIPS SEMICONDUCTORS"},
{ 0x1132, "MITEL CORP."},
{ 0x1133, "EICON TECHNOLOGY CORPORATION"},
{ 0x1134, "MERCURY COMPUTER SYSTEMS"},
{ 0x1135, "FUJI XEROX CO LTD"},
{ 0x1136, "MOMENTUM DATA SYSTEMS"},
{ 0x1137, "CISCO SYSTEMS INC"},
{ 0x1138, "ZIATECH CORPORATION"},
{ 0x1139, "DYNAMIC PICTURES INC"},
{ 0x113A, "FWB INC"},
{ 0x113B, "NETWORK COMPUTING DEVICES"},
{ 0x113C, "CYCLONE MICROSYSTEMS"},
{ 0x113D, "LEADING EDGE PRODUCTS INC"},
{ 0x113E, "SANYO ELECTRIC CO"},
{ 0x113F, "EQUINOX SYSTEMS"},
{ 0x1140, "INTERVOICE INC"},
{ 0x1141, "CREST MICROSYSTEM INC"},
{ 0x1142, "ALLIANCE SEMICONDUCTOR CORPORATION"},
{ 0x1143, "NETPOWER, INC"},
{ 0x1144, "CINCINNATI MILACRON"},
{ 0x1145, "WORKBIT CORP"},
{ 0x1146, "FORCE COMPUTERS"},
{ 0x1147, "INTERFACE CORP"},
{ 0x1148, "SYSKONNECT"},
{ 0x1149, "WIN SYSTEM CORPORATION"},
{ 0x114A, "VMIC"},
{ 0x114B, "CANOPUS CO., LTD"},
{ 0x114C, "ANNABOOKS"},
{ 0x114D, "IC CORPORATION"},
{ 0x114E, "NIKON SYSTEMS INC"},
{ 0x114F, "DIGI INTERNATIONAL"},
{ 0x1151, "JAE ELECTRONICS INC."},
{ 0x1152, "MEGATEK"},
{ 0x1153, "LAND WIN ELECTRONIC CORP"},
{ 0x1154, "MELCO INC"},
{ 0x1155, "PINE TECHNOLOGY LTD"},
{ 0x1156, "PERISCOPE ENGINEERING"},
{ 0x1157, "AVSYS CORPORATION"},
{ 0x1158, "VOARX R & D INC"},
{ 0x1159, "MUTECH CORP"},
{ 0x115A, "HARLEQUIN LTD"},
{ 0x115B, "PARALLAX GRAPHICS"},
{ 0x115C, "PHOTRON LTD."},
{ 0x115D, "XIRCOM"},
{ 0x115E, "PEER PROTOCOLS INC"},
{ 0x115F, "MAXTOR CORPORATION"},
{ 0x1160, "MEGASOFT INC"},
{ 0x1161, "PFU LIMITED"},
{ 0x1162, "OA LABORATORY CO LTD"},
{ 0x1163, "RENDITION"},
{ 0x1164, "ADVANCED PERIPHERALS TECH"},
{ 0x1165, "IMAGRAPH"},
{ 0x1166, "RELIANCE COMPUTER CORP."},
{ 0x1167, "MUTOH INDUSTRIES INC"},
{ 0x1168, "THINE ELECTRONICS INC"},
{ 0x116A, "POLARIS COMMUNICATIONS"},
{ 0x116B, "CONNECTWARE INC"},
{ 0x116C, "INTELLIGENT RESOURCES"},
{ 0x116E, "ELECTRONICS FOR IMAGING"},
{ 0x116F, "WORKSTATION TECHNOLOGY"},
{ 0x1170, "INVENTEC CORPORATION"},
{ 0x1171, "LOUGHBOROUGH SOUND IMAGES"},
{ 0x1172, "ALTERA CORPORATION"},
{ 0x1173, "ADOBE SYSTEMS, INC"},
{ 0x1174, "BRIDGEPORT MACHINES"},
{ 0x1175, "MITRON COMPUTER INC."},
{ 0x1176, "SBE INCORPORATED"},
{ 0x1177, "SILICON ENGINEERING"},
{ 0x1178, "ALFA, INC."},
{ 0x117A, "A-TREND TECHNOLOGY"},
{ 0x117C, "ATTO TECHNOLOGY"},
{ 0x117D, "BECTON & DICKINSON"},
{ 0x117E, "T/R SYSTEMS"},
{ 0x117F, "INTEGRATED CIRCUIT SYSTEMS"},
{ 0x1180, "RICOH CO LTD"},
{ 0x1181, "TELMATICS INTERNATIONAL"},
{ 0x1183, "FUJIKURA LTD"},
{ 0x1184, "FORKS INC"},
{ 0x1185, "DATAWORLD"},
{ 0x1186, "D-LINK SYSTEM INC"},
{ 0x1187, "ADVANCED TECHNOLOGY LABORATORIES"},
{ 0x1188, "SHIMA SEIKI MANUFACTURING LTD."},
{ 0x1189, "MATSUSHITA ELECTRONICS CO LTD"},
{ 0x118A, "HILEVEL TECHNOLOGY"},
{ 0x118B, "HYPERTEC PTY LIMITED"},
{ 0x118C, "COROLLARY, INC"},
{ 0x118D, "BITFLOW INC"},
{ 0x118E, "HERMSTEDT GMBH"},
{ 0x118F, "GREEN LOGIC"},
{ 0x1191, "ARTOP ELECTRONIC CORP"},
{ 0x1192, "DENSAN CO., LTD"},
{ 0x1193, "ZEITNET INC."},
{ 0x1194, "TOUCAN TECHNOLOGY"},
{ 0x1195, "RATOC SYSTEM INC"},
{ 0x1196, "HYTEC ELECTRONICS LTD"},
{ 0x1197, "GAGE APPLIED SCIENCES, INC."},
{ 0x1198, "LAMBDA SYSTEMS INC"},
{ 0x1199, "ATTACHMATE CORPORATION"},
{ 0x1199, "DIGITAL COMMUNICATIONS ASSOCIATES INC"},
{ 0x119A, "MIND SHARE, INC."},
{ 0x119B, "OMEGA MICRO INC."},
{ 0x119C, "INFORMATION TECHNOLOGY INST."},
{ 0x119D, "BUG SAPPORO JAPAN"},
{ 0x119E, "FUJITSU"},
{ 0x119F, "BULL HN INFORMATION SYSTEMS"},
{ 0x11A0, "CONVEX COMPUTER CORPORATION"},
{ 0x11A1, "HAMAMATSU PHOTONICS K.K."},
{ 0x11A2, "SIERRA RESEARCH AND TECHNOLOGY"},
{ 0x11A4, "BARCO GRAPHICS NV"},
{ 0x11A5, "MICROUNITY SYSTEMS ENG. INC"},
{ 0x11A6, "PURE DATA"},
{ 0x11A7, "POWER COMPUTING CORP."},
{ 0x11A8, "SYSTECH CORP."},
{ 0x11A9, "INNOSYS"},
{ 0x11AA, "ACTEL"},
{ 0x11AB, "GALILEO TECHNOLOGY LTD."},
{ 0x11AC, "CANON INFORMATION SYSTEMS"},
{ 0x11AD, "LITE-ON COMMUNICATIONS INC"},
{ 0x11AE, "AZTECH SYSTEM LTD"},
{ 0x11AE, "SCITEX CORPORATION"},
{ 0x11AF, "AVID TECHNOLOGY INC"},
{ 0x11AF, "PRO-LOG CORPORATION"},
{ 0x11B0, "V3 SEMICONDUCTOR"},
{ 0x11B1, "APRICOT COMPUTERS"},
{ 0x11B2, "EASTMAN KODAK"},
{ 0x11B3, "BARR SYSTEMS INC."},
{ 0x11B4, "LEITCH TECHNOLOGY INTERNATIONAL"},
{ 0x11B5, "RADSTONE TECHNOLOGY PLC"},
{ 0x11B6, "UNITED VIDEO CORP"},
{ 0x11B8, "XPOINT TECHNOLOGIES INC"},
{ 0x11B9, "PATHLIGHT TECHNOLOGY INC"},
{ 0x11BA, "VIDEOTRON CORP"},
{ 0x11BB, "PYRAMID TECHNOLOGY"},
{ 0x11BC, "NETWORK PERIPHERALS INC"},
{ 0x11BD, "PINNACLE SYSTEMS INC."},
{ 0x11BE, "INTERNATIONAL MICROCIRCUITS INC"},
{ 0x11BF, "ASTRODESIGN, INC."},
{ 0x11C0, "HEWLETT PACKARD"},
{ 0x11C1, "AT&T MICROELECTRONICS"},
{ 0x11C2, "SAND MICROELECTRONICS"},
{ 0x11C4, "DOCUMENT TECHNOLOGIES, IND"},
{ 0x11C5, "SHIVA CORPORATION"},
{ 0x11C6, "DAINIPPON SCREEN MFG. CO. LTD"},
{ 0x11C7, "D.C.M. DATA SYSTEMS"},
{ 0x11C8, "DOLPHIN INTERCONNECT"},
{ 0x11C9, "MAGMA"},
{ 0x11CA, "LSI SYSTEMS, INC"},
{ 0x11CB, "SPECIALIX RESEARCH LTD"},
{ 0x11CC, "MICHELS & KLEBERHOFF COMPUTER GMBH"},
{ 0x11CD, "HAL COMPUTER SYSTEMS, INC."},
{ 0x11CE, "PRIMARY RATE INC"},
{ 0x11CF, "PIONEER ELECTRONIC CORPORATION"},
{ 0x11D0, "LORAL FREDERAL SYSTEMS - MANASSAS"},
{ 0x11D1, "AURAVISION"},
{ 0x11D2, "INTERCOM INC."},
{ 0x11D3, "TRANCELL SYSTEMS INC"},
{ 0x11D4, "ANALOG DEVICES"},
{ 0x11D5, "IKON CORPORATION"},
{ 0x11D6, "TEKELEC TECHNOLOGIES"},
{ 0x11D7, "TRENTON TERMINALS INC"},
{ 0x11D8, "IMAGE TECHNOLOGIES DEVELOPMENT"},
{ 0x11D9, "TEC CORPORATION"},
{ 0x11DA, "NOVELL"},
{ 0x11DB, "SEGA ENTERPRISES LITD"},
{ 0x11DC, "QUESTRA CORPORATION"},
{ 0x11DD, "CROSFIELD ELECTRONICS LIMITED"},
{ 0x11DE, "ZORAN CORPORATION"},
{ 0x11DF, "NEW WAVE PDG"},
{ 0x11E0, "CRAY COMMUNICATIONS A/S"},
{ 0x11E1, "GEC PLESSEY SEMI INC."},
{ 0x11E2, "SAMSUNG INFORMATION SYSTEMS AMERICA"},
{ 0x11E3, "QUICKLOGIC CORPORATION"},
{ 0x11E4, "SECOND WAVE INC"},
{ 0x11E5, "IIX CONSULTING"},
{ 0x11E6, "MITSUI-ZOSEN SYSTEM RESEARCH"},
{ 0x11E7, "TOSHIBA AMERICA, ELEC. COMPANY"},
{ 0x11E8, "DIGITAL PROCESSING SYSTEMS INC."},
{ 0x11E9, "HIGHWATER DESIGNS LTD."},
{ 0x11EA, "ELSAG BAILEY"},
{ 0x11EB, "FORMATION INC."},
{ 0x11EC, "CORECO INC"},
{ 0x11ED, "MEDIAMATICS"},
{ 0x11EE, "DOME IMAGING SYSTEMS INC"},
{ 0x11EF, "NICOLET TECHNOLOGIES B.V."},
{ 0x11F0, "COMPU-SHACK GMBH"},
{ 0x11F1, "SYMBIOS LOGIC INC"},
{ 0x11F2, "PICTURE TEL JAPAN K.K."},
{ 0x11F3, "KEITHLEY METRABYTE"},
{ 0x11F4, "KINETIC SYSTEMS CORPORATION"},
{ 0x11F5, "COMPUTING DEVICES INTERNATIONAL"},
{ 0x11F6, "POWERMATIC DATA SYSTEMS LTD"},
{ 0x11F7, "SCIENTIFIC ATLANTA"},
{ 0x11F8, "PMC-SIERRA INC"},
{ 0x11F9, "I-CUBE INC"},
{ 0x11FA, "KASAN ELECTRONICS COMPANY, LTD."},
{ 0x11FB, "DATEL INC"},
{ 0x11FC, "SILICON MAGIC"},
{ 0x11FD, "HIGH STREET CONSULTANTS"},
{ 0x11FE, "COMTROL CORPORATION"},
{ 0x11FF, "SCION CORPORATION"},
{ 0x1200, "CSS CORPORATION"},
{ 0x1201, "VISTA CONTROLS CORP"},
{ 0x1202, "NETWORK GENERAL CORP."},
{ 0x1203, "BAYER CORPORATION, AGFA DIVISION"},
{ 0x1204, "LATTICE SEMICONDUCTOR CORPORATION"},
{ 0x1205, "ARRAY CORPORATION"},
{ 0x1206, "AMDAHL CORPORATION"},
{ 0x1208, "PARSYTEC GMBH"},
{ 0x1209, "SCI SYSTEMS INC"},
{ 0x120A, "SYNAPTEL"},
{ 0x120B, "ADAPTIVE SOLUTIONS"},
{ 0x120D, "COMPRESSION LABS, INC."},
{ 0x120E, "CYCLADES CORPORATION"},
{ 0x120F, "ESSENTIAL COMMUNICATIONS"},
{ 0x1210, "HYPERPARALLEL TECHNOLOGIES"},
{ 0x1211, "BRAINTECH INC"},
{ 0x1212, "KINGSTON TECHNOLOGY CORP."},
{ 0x1213, "APPLIED INTELLIGENT SYSTEMS, INC."},
{ 0x1214, "PERFORMANCE TECHNOLOGIES, INC."},
{ 0x1215, "INTERWARE CO., LTD"},
{ 0x1216, "PURUP PREPRESS A/S"},
{ 0x1217, "2 MICRO, INC."},
{ 0x1218, "HYBRICON CORP."},
{ 0x1219, "FIRST VIRTUAL CORPORATION"},
{ 0x121A, "3DFX INTERACTIVE, INC."},
{ 0x121B, "ADVANCED TELECOMMUNICATIONS MODULES"},
{ 0x121C, "NIPPON TEXA CO., LTD"},
{ 0x121D, "LIPPERT AUTOMATIONSTECHNIK GMBH"},
{ 0x121E, "CSPI"},
{ 0x121F, "ARCUS TECHNOLOGY, INC."},
{ 0x1220, "ARIEL CORPORATION"},
{ 0x1221, "CONTEC CO., LTD"},
{ 0x1222, "ANCOR COMMUNICATIONS, INC."},
{ 0x1223, "HEURIKON/COMPUTER PRODUCTS"},
{ 0x122C, "SICAN GMBH"},
{ 0x1234, "TECHNICAL CORP."},
{ 0x1239, "THE 3DO Company"},
{ 0x124F, "INFORTREND TECHNOLOGY INC."},
{ 0x126F, "SILICON MOTION"},
{ 0x1275, "NETWORK APPLIANCE"},
{ 0x1278, "TRANSTECH PARALLEL SYSTEMS"},
{ 0x127B, "PIXERA CORPORATION"},
{ 0x1297, "HOLCO ENTERPRISE"},
{ 0x12A1, "SIMPACT, INC"},
{ 0x12BA, "BITTWARE RESEARCH SYSTEMS, INC."},
{ 0x12E7, "SEBRING SYSTEMS, INC."},
{ 0x12EB, "AUREAL SEMICONDUCTOR"},
{ 0x3D3D, "3DLABS"},
{ 0x4005, "AVANCE LOGIC INC"},
{ 0x5333, "S3 INC."},
{ 0x8086, "INTEL"},
{ 0x8E0E, "COMPUTONE CORPORATION"},
{ 0x9004, "ADAPTEC"},
{ 0xE159, "TIGER JET NETWORK INC."},
{ 0xEDD8, "ARK LOGIC INC"}
};
//
// Taken from the PCI driver
//
#define PCI_TYPE0_RANGE_COUNT ((PCI_TYPE0_ADDRESSES) + 1)
#define PCI_TYPE1_RANGE_COUNT ((PCI_TYPE1_ADDRESSES) + 4)
#define PCI_TYPE2_RANGE_COUNT ((PCI_TYPE2_ADDRESSES) + 1)
#if PCI_TYPE0_RANGE_COUNT > PCI_TYPE1_RANGE_COUNT
#if PCI_TYPE0_RANGE_COUNT > PCI_TYPE2_RANGE_COUNT
#define PCI_MAX_RANGE_COUNT PCI_TYPE0_RANGE_COUNT
#else
#define PCI_MAX_RANGE_COUNT PCI_TYPE2_RANGE_COUNT
#endif
#else
#if PCI_TYPE1_RANGE_COUNT > PCI_TYPE2_RANGE_COUNT
#define PCI_MAX_RANGE_COUNT PCI_TYPE1_RANGE_COUNT
#else
#define PCI_MAX_RANGE_COUNT PCI_TYPE2_RANGE_COUNT
#endif
#endif
VOID
DevExtUsage()
{
dprintf("!devext [<address> <type>]\n");
dprintf(" <address> is the address of a device extension to\n");
dprintf(" be dumped.\n");
dprintf(" <type> is the type of the object owning this extension:\n");
dprintf(" PCI if it is a PCI device extension\n");
dprintf(" ISAPNP if it is an ISAPNP device extension\n");
dprintf(" PCMCIA if it is a PCMCIA device extension\n");
dprintf(" HID if it is an HID device extension\n");
return;
}
VOID
DevExtPciFindClassCodes(
ULONG PdoxBaseClass,
ULONG PdoxSubClass,
PUCHAR * BaseClass,
PUCHAR * SubClass
)
{
PUCHAR bc = "Unknown Base Class";
PUCHAR sc = "Unknown Sub Class";
switch (PdoxBaseClass) {
case PCI_CLASS_PRE_20:
// Class 00 - PCI_CLASS_PRE_20:
bc = "Pre PCI 2.0";
switch (PdoxSubClass) {
case PCI_SUBCLASS_PRE_20_NON_VGA:
sc = "Pre PCI 2.0 Non-VGA Device";
break;
case PCI_SUBCLASS_PRE_20_VGA:
sc = "Pre PCI 2.0 VGA Device";
break;
}
break;
case PCI_CLASS_MASS_STORAGE_CTLR:
// Class 01 - PCI_CLASS_MASS_STORAGE_CTLR:
bc = "Mass Storage Controller";
switch (PdoxSubClass) {
case PCI_SUBCLASS_MSC_SCSI_BUS_CTLR:
sc = "SCSI";
break;
case PCI_SUBCLASS_MSC_IDE_CTLR:
sc = "IDE";
break;
case PCI_SUBCLASS_MSC_FLOPPY_CTLR:
sc = "Floppy";
break;
case PCI_SUBCLASS_MSC_IPI_CTLR:
sc = "IPI";
break;
case PCI_SUBCLASS_MSC_RAID_CTLR:
sc = "RAID";
break;
case PCI_SUBCLASS_MSC_OTHER:
sc = "'Other'";
break;
}
break;
case PCI_CLASS_NETWORK_CTLR:
// Class 02 - PCI_CLASS_NETWORK_CTLR:
bc = "Network Controller";
switch (PdoxSubClass) {
case PCI_SUBCLASS_NET_ETHERNET_CTLR:
sc = "Ethernet";
break;
case PCI_SUBCLASS_NET_TOKEN_RING_CTLR:
sc = "Token Ring";
break;
case PCI_SUBCLASS_NET_FDDI_CTLR:
sc = "FDDI";
break;
case PCI_SUBCLASS_NET_ATM_CTLR:
sc = "ATM";
break;
case PCI_SUBCLASS_NET_OTHER:
sc = "'Other'";
break;
}
break;
case PCI_CLASS_DISPLAY_CTLR:
// Class 03 - PCI_CLASS_DISPLAY_CTLR:
// N.B. Sub Class 00 could be VGA or 8514 depending on Interface byte:
bc = "Display Controller";
switch (PdoxSubClass) {
case PCI_SUBCLASS_VID_VGA_CTLR:
sc = "VGA";
break;
case PCI_SUBCLASS_VID_XGA_CTLR:
sc = "XGA";
break;
case PCI_SUBCLASS_VID_OTHER:
sc = "'Other'";
break;
}
break;
case PCI_CLASS_MULTIMEDIA_DEV:
// Class 04 - PCI_CLASS_MULTIMEDIA_DEV:
bc = "Multimedia Device";
switch (PdoxSubClass) {
case PCI_SUBCLASS_MM_VIDEO_DEV:
sc = "Video";
break;
case PCI_SUBCLASS_MM_AUDIO_DEV:
sc = "Audio";
break;
case PCI_SUBCLASS_MM_OTHER:
sc = "'Other'";
break;
}
break;
case PCI_CLASS_MEMORY_CTLR:
// Class 05 - PCI_CLASS_MEMORY_CTLR:
bc = "Memory Controller";
switch (PdoxSubClass) {
case PCI_SUBCLASS_MEM_RAM:
sc = "RAM";
break;
case PCI_SUBCLASS_MEM_FLASH:
sc = "FLASH";
break;
case PCI_SUBCLASS_MEM_OTHER:
sc = "'Other'";
break;
}
break;
case PCI_CLASS_BRIDGE_DEV:
// Class 06 - PCI_CLASS_BRIDGE_DEV:
bc = "Bridge";
switch (PdoxSubClass) {
case PCI_SUBCLASS_BR_HOST:
sc = "HOST to PCI";
break;
case PCI_SUBCLASS_BR_ISA:
sc = "PCI to ISA";
break;
case PCI_SUBCLASS_BR_EISA:
sc = "PCI to EISA";
break;
case PCI_SUBCLASS_BR_MCA:
sc = "PCI to MCA";
break;
case PCI_SUBCLASS_BR_PCI_TO_PCI:
sc = "PCI to PCI";
break;
case PCI_SUBCLASS_BR_PCMCIA:
sc = "PCI to PCMCIA";
break;
case PCI_SUBCLASS_BR_NUBUS:
sc = "PCI to NUBUS";
break;
case PCI_SUBCLASS_BR_CARDBUS:
sc = "PCI to CardBus";
break;
case PCI_SUBCLASS_BR_OTHER:
sc = "PCI to 'Other'";
break;
}
break;
case PCI_CLASS_SIMPLE_COMMS_CTLR:
// Class 07 - PCI_CLASS_SIMPLE_COMMS_CTLR:
// N.B. Sub Class 00 and 01 additional info in Interface byte:
bc = "Simple Serial Communications Controller";
switch (PdoxSubClass) {
case PCI_SUBCLASS_COM_SERIAL:
sc = "Serial Port";
break;
case PCI_SUBCLASS_COM_PARALLEL:
sc = "Parallel Port";
break;
case PCI_SUBCLASS_COM_OTHER:
sc = "'Other'";
break;
}
break;
case PCI_CLASS_BASE_SYSTEM_DEV:
// Class 08 - PCI_CLASS_BASE_SYSTEM_DEV:
// N.B. See Interface byte for additional info.:
bc = "Base System Device";
switch (PdoxSubClass) {
case PCI_SUBCLASS_SYS_INTERRUPT_CTLR:
sc = "Interrupt Controller";
break;
case PCI_SUBCLASS_SYS_DMA_CTLR:
sc = "DMA Controller";
break;
case PCI_SUBCLASS_SYS_SYSTEM_TIMER:
sc = "System Timer";
break;
case PCI_SUBCLASS_SYS_REAL_TIME_CLOCK:
sc = "Real Time Clock";
break;
case PCI_SUBCLASS_SYS_OTHER:
sc = "'Other' base system device";
break;
}
break;
case PCI_CLASS_INPUT_DEV:
// Class 09 - PCI_CLASS_INPUT_DEV:
bc = "Input Device";
switch (PdoxSubClass) {
case PCI_SUBCLASS_INP_KEYBOARD:
sc = "Keyboard";
break;
case PCI_SUBCLASS_INP_DIGITIZER:
sc = "Digitizer";
break;
case PCI_SUBCLASS_INP_MOUSE:
sc = "Mouse";
break;
case PCI_SUBCLASS_INP_OTHER:
sc = "'Other'";
break;
}
break;
case PCI_CLASS_DOCKING_STATION:
// Class 0a - PCI_CLASS_DOCKING_STATION:
bc = "Docking Station";
switch (PdoxSubClass) {
case PCI_SUBCLASS_DOC_GENERIC:
sc = "Generic";
break;
case PCI_SUBCLASS_DOC_OTHER:
sc = "'Other'";
break;
}
break;
case PCI_CLASS_PROCESSOR:
// Class 0b - PCI_CLASS_PROCESSOR:
bc = "Processor";
switch (PdoxSubClass) {
case PCI_SUBCLASS_PROC_386:
sc = "386";
break;
case PCI_SUBCLASS_PROC_486:
sc = "486";
break;
case PCI_SUBCLASS_PROC_PENTIUM:
sc = "Pentium";
break;
case PCI_SUBCLASS_PROC_ALPHA:
sc = "Alpha";
break;
case PCI_SUBCLASS_PROC_POWERPC:
sc = "PowerPC";
break;
case PCI_SUBCLASS_PROC_COPROCESSOR:
sc = "CoProcessor";
break;
}
break;
case PCI_CLASS_SERIAL_BUS_CTLR:
// Class 0c - PCI_CLASS_SERIAL_BUS_CTLR:
bc = "Serial Bus Controller";
switch (PdoxSubClass) {
case PCI_SUBCLASS_SB_IEEE1394:
sc = "1394";
break;
case PCI_SUBCLASS_SB_ACCESS:
sc = "Access Bus";
break;
case PCI_SUBCLASS_SB_SSA:
sc = "SSA";
break;
case PCI_SUBCLASS_SB_USB:
sc = "USB";
break;
case PCI_SUBCLASS_SB_FIBRE_CHANNEL:
sc = "Fibre Channel";
break;
}
break;
case PCI_CLASS_NOT_DEFINED:
bc = "(Explicitly) Undefined";
break;
}
*BaseClass = bc;
*SubClass = sc;
}
VOID
DevExtPciPrintDeviceState(
PCI_OBJECT_STATE State
)
{
if ((sizeof(DevExtPciDeviceState) / sizeof(DevExtPciDeviceState[0])) !=
PciMaxObjectState) {
dprintf("\nWARNING: PCI_OBJECT_STATE enumeration changed, please review.\n");
}
if (State >= PciMaxObjectState) {
dprintf("Unknown PCI Object state.\n");
return;
}
dprintf(" Driver State = %s\n", DevExtPciDeviceState[State]);
}
//#if 0
VOID
DevExtPciPrintPowerState(
ULONG64 Power
)
{
#define MAXSYSPOWSTATES \
(sizeof(DevExtPciSystemPowerState) / sizeof(DevExtPciSystemPowerState[0]))
#define MAXDEVPOWSTATES \
(sizeof(DevExtPciDevicePowerState) / sizeof(DevExtPciDevicePowerState[0]))
SYSTEM_POWER_STATE index;
DEVICE_POWER_STATE systemStateMapping[PowerSystemMaximum];
ULONG64 pwrState, waitWakeIrp=0;
PUCHAR sw, sc, dd, dc, dw;
//
// A little sanity.
//
if (MAXSYSPOWSTATES != PowerSystemMaximum) {
dprintf("WARNING: System Power State definition has changed, ext dll is out of date.\n");
}
if (MAXDEVPOWSTATES != PowerDeviceMaximum) {
dprintf("WARNING: Device Power State definition has changed, ext dll is out of date.\n");
}
sw = sc = dc = dw = "<*BAD VAL*>";
GetFieldValue(Power, "pci!PCI_POWER_STATE", "CurrentSystemState", pwrState);
if (pwrState < PowerSystemMaximum) {
sc = DevExtPciSystemPowerState[pwrState];
}
GetFieldValue(Power, "pci!PCI_POWER_STATE", "CurrentDeviceState", pwrState);
if (pwrState < PowerDeviceMaximum) {
dc = DevExtPciDevicePowerState[pwrState];
}
GetFieldValue(Power, "pci!PCI_POWER_STATE", "DeviceWakeLevel", pwrState);
if (pwrState < PowerDeviceMaximum) {
dw = DevExtPciDevicePowerState[pwrState];
}
GetFieldValue(Power, "pci!PCI_POWER_STATE", "SystemWakeLevel", pwrState);
if (pwrState < PowerSystemMaximum) {
sw = DevExtPciSystemPowerState[pwrState];
}
dprintf(
" CurrentState: System %s, Device %s\n"
" WakeLevel: System %s, Device %s\n",
sc,
dc,
sw,
dw
);
GetFieldValue(Power, "pci!PCI_POWER_STATE", "SystemStateMapping", systemStateMapping);
for (index = PowerSystemWorking; index < PowerSystemMaximum; index++) {
if (systemStateMapping[index] != PowerDeviceUnspecified) {
if (systemStateMapping[index] < PowerDeviceMaximum) {
dc = DevExtPciDevicePowerState[systemStateMapping[index]];
} else {
dc = "<*BAD VAL*>";
}
dprintf(" %s:\t%s\n",
DevExtPciSystemPowerState[index],
dc
);
}
}
GetFieldValue(Power, "pci!PCI_POWER_STATE", "WaitWakeIrp", waitWakeIrp);
if (waitWakeIrp) {
dprintf(" WaitWakeIrp: %#08p\n",
waitWakeIrp
);
}
#undef MAXSYSPOWSTATES
#undef MAXDEVPOWSTATES
}
VOID
DevExtPciPrintSecondaryExtensions(
ULONG64 ListEntry
)
{
ULONG64 extension = 0, extype = 0;
if (!ListEntry) {
return;
}
xdprintf(1, "Secondary Extensions\n");
do {
GetFieldValue(ListEntry, "pci!PCI_SECONDARY_EXTENSION", "ExtensionType", extype);
switch (extype) {
case PciArb_Io:
xdprintf(2, "Arbiter - IO Port");
break;
case PciArb_Memory:
xdprintf(2, "Arbiter - Memory");
break;
case PciArb_Interrupt:
xdprintf(2, "Arbiter - Interrupt");
break;
case PciArb_BusNumber:
xdprintf(2, "Arbiter - Bus Number");
break;
case PciTrans_Interrupt:
xdprintf(2, "Translator - Interrupt");
break;
case PciInterface_BusHandler:
xdprintf(2, "Interface - Bus Handler");
break;
case PciInterface_IntRouteHandler:
xdprintf(2, "Interface - Interrupt Route Handler");
break;
default:
xdprintf(2, "Unknown Extension Type.");
break;
}
dprintf("\n");
GetFieldValue(ListEntry, "nt!_SINGLE_LIST_ENTRY", "Next", ListEntry);
} while (ListEntry);
}
PUCHAR
DevExtPciFindVendorId(
USHORT VendorId
)
/*++
Routine Description:
Get the vendor name given the vendor ID (assuming we know it).
Arguments:
VendorId 16 bit PCI Vendor ID.
Return Value:
Pointer to the vendor's name (or NULL).
--*/
{
#define PCIIDCOUNT (sizeof(DevExtPciVendors) / sizeof(DevExtPciVendors[0]))
ULONG index;
//
// Yep, a binary search would be much faster, good thing we only
// do this once per user iteration.
//
for (index = 0; index < PCIIDCOUNT; index++) {
if (DevExtPciVendors[index].VendorId == VendorId) {
return DevExtPciVendors[index].VendorName;
}
}
return NULL;
#undef PCIIDCOUNT
}
#define GET_PCI_PDO_FIELD(Pdo,Field,Value) \
GetPciExtensionField(TRUE, Pdo, Field, sizeof(Value), (PVOID)(&(Value)))
#define GET_PCI_FDO_FIELD(Fdo,Field,Value) \
GetPciExtensionField(FALSE, Fdo, Field, sizeof(Value), (PVOID)(&(Value)))
ULONG
GetPciExtensionField(
IN BOOLEAN IsPdo, // TRUE for PDO, false for FDO
IN ULONG64 TypeAddress,
IN PUCHAR Field,
IN ULONG OutSize,
OUT PVOID OutValue
)
{
ULONG ret;
static PCHAR pciFDO = "nt!_PCI_FDO_EXTENSION", pciPDO = "nt!_PCI_PDO_EXTENSION";
//
// Try the post Win2k name for a pci extension (includes a PCI_ prefix)
//
// This would work for public symbols
ret = GetFieldData(TypeAddress,
IsPdo ? pciPDO : pciFDO,
Field,
OutSize,
OutValue
);
if (ret) {
pciFDO = "pci!PCI_FDO_EXTENSION";
pciPDO = "pci!PCI_PDO_EXTENSION";
//
// If we have private symbols, nt won't have those types, so try in pci
//
ret = GetFieldData(TypeAddress,
IsPdo ? pciPDO : pciFDO,
Field,
OutSize,
OutValue
);
}
//
// If that failed then fall back on the name without the PCI_ prefix. This
// allows debugging Win2k clients with the post Win2k debugger
//
if (ret) {
ret = GetFieldData(TypeAddress,
IsPdo ? "pci!PDO_EXTENSION" : "pci!FDO_EXTENSION",
Field,
OutSize,
OutValue
);
}
if (ret) {
// didn't find anything, reste these
pciFDO = "nt!_PCI_FDO_EXTENSION";
pciPDO = "nt!_PCI_PDO_EXTENSION";
}
return ret;
}
typedef struct _PCI_SLOT_NUMBER {
union {
struct {
ULONG DeviceNumber:5;
ULONG FunctionNumber:3;
ULONG Reserved:24;
} bits;
ULONG AsULONG;
} u;
} PCI_SLOT_NUMBER, *PPCI_SLOT_NUMBER;
VOID
DevExtPciGetBusDevFunc(
IN ULONG64 PdoExt,
OUT PULONG Bus,
OUT PULONG Dev,
OUT PULONG Func
)
{
ULONG BaseBus=0;
ULONG64 ParentFdoExtension=0;
PCI_SLOT_NUMBER slot;
GET_PCI_PDO_FIELD(PdoExt, "ParentFdoExtension", ParentFdoExtension);
if (GET_PCI_FDO_FIELD(ParentFdoExtension, "BaseBus", BaseBus)) {
dprintf(
"Failed to read memory at %08x for sizeof FDO Extension.\n",
ParentFdoExtension
);
}
if (GET_PCI_PDO_FIELD(PdoExt, "Slot", slot)){
dprintf(
"Failed to read memory at %08x\n",
PdoExt
);
}
*Bus = BaseBus;
*Dev = slot.u.bits.DeviceNumber;
*Func = slot.u.bits.FunctionNumber;
}
VOID
DevExtPci(
ULONG64 Extension
)
/*++
Routine Description:
Dump a PCI Device extension.
Arguments:
Extension Address of the extension to be dumped.
Return Value:
None.
--*/
{
ULONG64 pdo=0, fdoX=0, pdoX=0, pcifield=0;
ULONG Signature=0, fieldoffset=0;
ULONG bus=0xff,dev=0xff,func=0xff;
USHORT vendorId=0xffff, deviceId=0xffff, subsystemVendorId=0xfff, subsystemId=0xffff;
UCHAR deviceState, baseClass, subClass, progIf, revisionId, interruptPin, rawInterruptLine, adjustedInterruptLine;
UCHAR secBus=0xff, subBus=0xff;
PUCHAR s;
PUCHAR bc;
PUCHAR sc;
ULONG i;
BOOLEAN found, subDecode=FALSE, isaBit=FALSE, vgaBit=FALSE;
if (GET_PCI_PDO_FIELD(Extension, "ExtensionType", Signature)) {
dprintf(
"Failed to read PCI object signature at %008p, giving up.\n",
Extension
);
return;
}
switch (Signature) {
case PciPdoExtensionType:
//
// PDO Extension.
//
DevExtPciGetBusDevFunc(Extension, &bus, &dev, &func);
dprintf("PDO Extension, Bus 0x%x, Device %x, Function %d.\n",
bus, dev, func
);
GET_PCI_PDO_FIELD(Extension, "PhysicalDeviceObject", pdo);
GET_PCI_PDO_FIELD(Extension, "ParentFdoExtension", fdoX);
dprintf(" DevObj %#08p PCI Parent Bus FDO DevExt %#08p\n",
pdo, fdoX
);
GET_PCI_PDO_FIELD(Extension, "DeviceState", deviceState);
GET_PCI_PDO_FIELD(Extension, "VendorId", vendorId);
GET_PCI_PDO_FIELD(Extension, "DeviceId", deviceId);
DevExtPciPrintDeviceState(deviceState);
s = DevExtPciFindVendorId(vendorId);
if (s != NULL) {
dprintf(" Vendor ID %04x (%s) Device ID %04X\n",
vendorId,
s,
deviceId
);
} else {
dprintf(
" Vendor ID %04x, Device ID %04X\n",
vendorId,
deviceId
);
}
GET_PCI_PDO_FIELD(Extension, "SubsystemVendorId", subsystemVendorId);
GET_PCI_PDO_FIELD(Extension, "SubsystemId", subsystemId);
if (subsystemVendorId || subsystemId) {
s = DevExtPciFindVendorId(subsystemVendorId);
if (s != NULL) {
dprintf(
" Subsystem Vendor ID %04x (%s) Subsystem ID %04X\n",
subsystemVendorId,
s,
subsystemId
);
} else {
dprintf(" Subsystem Vendor ID %04x, Subsystem ID %04X\n",
subsystemVendorId,
subsystemId
);
}
}
GET_PCI_PDO_FIELD(Extension, "BaseClass", baseClass);
GET_PCI_PDO_FIELD(Extension, "SubClass", subClass);
DevExtPciFindClassCodes(baseClass, subClass, &bc, &sc);
dprintf(" Class Base/Sub %02x/%02x (%s/%s)\n",
baseClass,
subClass,
bc,
sc);
GET_PCI_PDO_FIELD(Extension, "ProgIf", progIf);
GET_PCI_PDO_FIELD(Extension, "RevisionId", revisionId);
GET_PCI_PDO_FIELD(Extension, "InterruptPin", interruptPin);
GET_PCI_PDO_FIELD(Extension, "RawInterruptLine", rawInterruptLine);
GET_PCI_PDO_FIELD(Extension, "AdjustedInterruptLine", adjustedInterruptLine);
dprintf(" Programming Interface: %02x, Revision: %02x, IntPin: %02x, Line Raw/Adj %02x/%02x\n",
progIf,
revisionId,
interruptPin,
rawInterruptLine,
adjustedInterruptLine
);
{
USHORT enables=0;
GET_PCI_PDO_FIELD(Extension, "CommandEnables", enables);
dprintf(" Enables ((cmd & 7) = %x): %s%s%s",
enables,
enables == 0 ? "<none>" :
(enables & PCI_ENABLE_BUS_MASTER) ? "B" : "",
(enables & PCI_ENABLE_MEMORY_SPACE) ? "M" : "",
(enables & PCI_ENABLE_IO_SPACE) ? "I" : ""
);
GET_PCI_PDO_FIELD(Extension, "CapabilitiesPtr", pcifield);
if (pcifield) {
dprintf(" Capabilities Pointer = %02x\n", pcifield);
} else {
dprintf(" Capabilities Pointer = <none>\n");
}
}
GetFieldOffset("pci!PCI_PDO_EXTENSION", "PowerState", &fieldoffset);
DevExtPciPrintPowerState(Extension+fieldoffset);
if (baseClass == PCI_CLASS_BRIDGE_DEV) {
if ((subClass == PCI_SUBCLASS_BR_PCI_TO_PCI) ||
(subClass == PCI_SUBCLASS_BR_CARDBUS)) {
GetFieldOffset("pci!PCI_PDO_EXTENSION", "Dependent", &fieldoffset);
GetFieldValue(Extension+fieldoffset,
"pci!PCI_HEADER_TYPE_DEPENDENT",
"type1.SecondaryBus",
secBus);
GetFieldValue(Extension+fieldoffset,
"pci!PCI_HEADER_TYPE_DEPENDENT",
"type1.SecondaryBus",
subBus);
dprintf(" Bridge PCI-%s Secondary Bus = 0x%x, Subordinate Bus = 0x%x\n",
subClass == PCI_SUBCLASS_BR_PCI_TO_PCI
? "PCI" : "CardBus",
secBus,
subBus
);
GetFieldValue(Extension+fieldoffset,
"pci!PCI_HEADER_TYPE_DEPENDENT",
"type1.SubtractiveDecode",
subDecode);
GetFieldValue(Extension+fieldoffset,
"pci!PCI_HEADER_TYPE_DEPENDENT",
"type1.IsaBitSet",
isaBit);
GetFieldValue(Extension+fieldoffset,
"pci!PCI_HEADER_TYPE_DEPENDENT",
"type1.VgaBitSet",
vgaBit);
if (subDecode || isaBit || vgaBit) {
CHAR preceed = ' ';
dprintf(" Bridge Flags:");
if (subDecode) {
dprintf("%c Subtractive Decode", preceed);
preceed = ',';
}
if (isaBit) {
dprintf("%c ISA", preceed);
preceed = ',';
}
if (vgaBit) {
dprintf("%c VGA", preceed);
preceed = ',';
}
dprintf("\n");
}
}
}
//
// Now lets parse our PCI_FUNCTION_RESOURCES struct
//
pcifield = 0;
GET_PCI_PDO_FIELD(Extension, "Resources", pcifield);
dprintf(" Requirements:");
if (pcifield) {
ULONG64 limit = 0, current=0;
ULONG ioSize=0, cmSize=0, type=0;
ULONG alignment, length, minhighpart, minlowpart, maxhighpart, maxlowpart;
ioSize = GetTypeSize("nt!IO_RESOURCE_DESCRIPTOR");
cmSize = GetTypeSize("nt!CM_PARTIAL_RESOURCE_DESCRIPTOR");
//
// Limit begins at offset 0
//
limit = pcifield;
found = FALSE;
dprintf(" Alignment Length Minimum Maximum\n");
for (i = 0; i < PCI_MAX_RANGE_COUNT; i++) {
type=0;
GetFieldValue(limit, "nt!IO_RESOURCE_DESCRIPTOR", "Type", type);
if (type == CmResourceTypeNull) {
continue;
}
GetFieldValue(limit, "nt!IO_RESOURCE_DESCRIPTOR", "u.Generic.Alignment", alignment);
GetFieldValue(limit, "nt!IO_RESOURCE_DESCRIPTOR", "u.Generic.Length", length);
GetFieldValue(limit, "nt!IO_RESOURCE_DESCRIPTOR", "u.Generic.MinimumAddress.HighPart", minhighpart);
GetFieldValue(limit, "nt!IO_RESOURCE_DESCRIPTOR", "u.Generic.MinimumAddress.LowPart", minlowpart);
GetFieldValue(limit, "nt!IO_RESOURCE_DESCRIPTOR", "u.Generic.MaximumAddress.HighPart", maxhighpart);
GetFieldValue(limit, "nt!IO_RESOURCE_DESCRIPTOR", "u.Generic.MaximumAddress.LowPart", maxlowpart);
dprintf(" %s: %08x %08x %08x%08x %08x%08x\n",
type == CmResourceTypeMemory ? "Memory" : " Io",
alignment,
length,
minhighpart,
minlowpart,
maxhighpart,
maxlowpart
);
limit += ioSize;
}
//
// Get the offset for Current so we can dump it next
//
GetFieldOffset("pci!PCI_FUNCTION_RESOURCES", "Current", &fieldoffset);
current = pcifield+fieldoffset;
dprintf(" Current:");
for (i = 0; i < PCI_MAX_RANGE_COUNT; i++) {
type=0;
length=0;
maxhighpart=0;
maxlowpart=0;
GetFieldValue(current, "nt!CM_PARTIAL_RESOURCE_DESCRIPTOR", "Type", type);
if (type == CmResourceTypeNull) {
continue;
}
if (!found) {
dprintf(" Start Length\n");
found = TRUE;
}
GetFieldValue(current, "nt!CM_PARTIAL_RESOURCE_DESCRIPTOR", "u.Generic.Start.HighPart", maxhighpart);
GetFieldValue(current, "nt!CM_PARTIAL_RESOURCE_DESCRIPTOR", "u.Generic.Start.LowPart", maxlowpart);
GetFieldValue(current, "nt!CM_PARTIAL_RESOURCE_DESCRIPTOR", "u.Generic.Length", length);
dprintf(" %s: %08x%08x %08x\n",
type == CmResourceTypeMemory ? "Memory" : " Io",
maxhighpart,
maxlowpart,
length
);
current += cmSize;
}
if (!found) {
dprintf(" <none>\n");
}
} else {
dprintf(" <none>\n");
}
GetFieldOffset("pci!PCI_PDO_EXTENSION", "SecondaryExtension", &fieldoffset);
GetFieldValue(Extension+fieldoffset, "nt!_SINGLE_LIST_ENTRY", "Next", pcifield);
DevExtPciPrintSecondaryExtensions(pcifield);
break;
case PciFdoExtensionType:
//
// FDO Extension
//
GET_PCI_FDO_FIELD(Extension, "BaseBus", bus);
GET_PCI_FDO_FIELD(Extension, "PhysicalDeviceObject", pdo);
dprintf("FDO Extension, Bus 0x%x, Parent PDO %#08p Bus is ", bus,pdo);
GET_PCI_FDO_FIELD(Extension, "BusRootFdoExtension", pcifield);
if (pcifield == Extension) {
dprintf("a root bus.\n");
} else {
GET_PCI_FDO_FIELD(Extension, "PhysicalDeviceObject", pcifield);
GetFieldValue(pcifield, "nt!_DEVICE_OBJECT", "DeviceExtension", pdoX);
if (!pdoX) {
dprintf("a child bus.\n");
}else{
DevExtPciGetBusDevFunc(pdoX, &bus, &dev, &func);
dprintf("a child of bus 0x%x.\n", bus);
}
}
GET_PCI_FDO_FIELD(Extension, "DeviceState", deviceState);
DevExtPciPrintDeviceState(deviceState);
GetFieldOffset("pci!PCI_FDO_EXTENSION", "PowerState", &fieldoffset);
DevExtPciPrintPowerState(Extension+fieldoffset);
GET_PCI_FDO_FIELD(Extension, "ChildWaitWakeCount", pcifield);
if (pcifield) {
dprintf("Number of PDO's with outstanding WAIT_WAKEs = %d\n", pcifield);
}
{
PUCHAR heading = " Child PDOXs:";
ULONG counter = 0;
ULONG64 list = 0;
GET_PCI_FDO_FIELD(Extension, "ChildPdoList", list);
while (list) {
if (counter == 0) {
dprintf(heading);
heading = "\n ";
counter = 1;
} else if (counter == 2) {
counter = 0;
} else {
counter++;
}
dprintf(" %#08p", list);
GET_PCI_PDO_FIELD(list, "Next", list);
}
dprintf("\n");
}
GetFieldOffset("pci!PCI_FDO_EXTENSION", "SecondaryExtension", &fieldoffset);
GetFieldValue(Extension+fieldoffset, "nt!_SINGLE_LIST_ENTRY", "Next", pcifield);
DevExtPciPrintSecondaryExtensions(pcifield);
break;
default:
dprintf("%08x doesn't seem to point to a PCI PDO or FDO extension,\n", Signature);
dprintf("the PCI Device object extension signatures don't match.\n");
return;
}
}
DECLARE_API( devext )
/*++
Routine Description:
Dumps a device extension.
Arguments:
address Address of the device extension to be dumped.
type Type of device extension.
Return Value:
None
--*/
{
#define DEVEXT_MAXTOKENS 3
#define DEVEXT_MAXBUFFER 80
#define DEVEXT_USAGE() { DevExtUsage(); return E_INVALIDARG; }
ULONG64 Extension = 0;
PUCHAR ExtensionType;
PUCHAR Tokens[DEVEXT_MAXTOKENS];
UCHAR Buffer[DEVEXT_MAXBUFFER];
PUCHAR s;
UCHAR c;
ULONG count;
//
// Validate parameters. Tokenize the incoming string, the first
// argument should be a (kernel mode) address, the second a string.
//
//
// args is const, we need to modify the buffer, copy it.
//
for (count = 0; count < DEVEXT_MAXBUFFER; count++) {
if ((Buffer[count] = args[count]) == '\0') {
break;
}
}
if (count == DEVEXT_MAXBUFFER) {
dprintf("Buffer to small to contain input arguments\n");
DEVEXT_USAGE();
}
if (TokenizeString(Buffer, Tokens, DEVEXT_MAXTOKENS) !=
(DEVEXT_MAXTOKENS - 1)) {
DEVEXT_USAGE();
}
if ((Extension = GetExpression(Tokens[0])) == 0) {
DEVEXT_USAGE();
}
// Signextend it
if (DBG_PTR_SIZE == sizeof(ULONG)) {
Extension = (ULONG64) (LONG64) (LONG) Extension;
}
if ((LONG64)Extension >= 0) {
DEVEXT_USAGE();
}
//
// The second argument should be a string telling us what kind of
// device extension to dump. Convert it to upper case to make life
// easier.
//
s = Tokens[1];
while ((c = *s) != '\0') {
*s++ = (UCHAR)toupper(c);
}
s = Tokens[1];
if (!strcmp(s, "PCI")) {
//
// It's a PCI device extension.
//
DevExtPci(Extension);
} else if (!strcmp(s, "PCMCIA")) {
//
// It's a PCMCIA device extension
//
DevExtPcmcia(Extension);
} else if (!strcmp(s, "HID")) {
//
// It's a HID device extension
//
DevExtHID(Extension);
} else if (!strcmp(s, "ISAPNP")) {
//
// Congratulations! It's an ISAPNP device extension
//
DevExtIsapnp(Extension);
#if 0
} else if (!strcmp(s, "SOME_OTHER_EXTENSION_TYPE")) {
//
// It's some other extension type.
//
DevExtSomeOther(Extension);
#endif
} else {
dprintf("Device extension type '%s' is not handled by !devext.\n", s);
}
return S_OK;
}
//
// pcitree data structures and functions
//
BOOLEAN
pcitreeProcessBus(
ULONG Indent,
ULONG64 InMemoryBusFdoX,
ULONG64 TreeTop
)
{
ULONG64 BusFdoX=InMemoryBusFdoX;
ULONG64 next;
PUCHAR bc, sc, vendor;
ULONG BaseBus, BaseClass, SubClass;
ULONG64 ChildPdoList;
#define PdoxFld(F,V) GET_PCI_PDO_FIELD(next, #F, V)
GET_PCI_FDO_FIELD(BusFdoX, "BaseBus", BaseBus);
GET_PCI_FDO_FIELD(BusFdoX, "ChildPdoList", next);
xdprintf(Indent,"");
dprintf( "Bus 0x%x (FDO Ext %08p)\n",
BaseBus,
InMemoryBusFdoX);
if (next == 0) {
xdprintf(Indent, "No devices have been enumerated on this bus.\n");
return TRUE;
}
Indent++;
do {
ULONG DeviceId, VendorId, DeviceNumber, FunctionNumber;
ULONG64 BridgeFdoExtension;
if (CheckControlC()) {
return FALSE;
}
if (PdoxFld(BaseClass,BaseClass)) {
xdprintf(Indent,"FAILED to read PDO Ext at ");
dprintf("%08p, cannot continue this bus.\n",
next
);
return TRUE;
}
PdoxFld(SubClass,SubClass);
PdoxFld(DeviceId,DeviceId);
PdoxFld(VendorId,VendorId);
PdoxFld(Slot.u.bits.DeviceNumber,DeviceNumber);
PdoxFld(Slot.u.bits.FunctionNumber,FunctionNumber);
DevExtPciFindClassCodes(BaseClass, SubClass, &bc, &sc);
xdprintf(Indent, "");
dprintf("%02x%02x %04x%04x (d=%x,%s f=%d) devext %08p %s/%s\n",
BaseClass,
SubClass,
DeviceId,
VendorId,
DeviceNumber,
(DeviceNumber > 9 ? "" : " "),
FunctionNumber,
next,
bc,
sc
);
#if 0
// removed, too talkative. plj.
vendor = DevExtPciFindVendorId(PdoX.VendorId);
if (vendor) {
xdprintf(Indent, " (%s)\n", vendor);
}
#endif
if (BaseClass == PCI_CLASS_BRIDGE_DEV && SubClass == PCI_SUBCLASS_BR_PCI_TO_PCI) {
//
// Process child bus.
//
PdoxFld(BridgeFdoExtension,BridgeFdoExtension);
//
// Recurse.
//
if (pcitreeProcessBus(Indent, BridgeFdoExtension, TreeTop) == FALSE) {
//
// Error, exit.
//
return FALSE;
}
}
PdoxFld(Next, next);
} while (next);
#undef PdoxFld
return TRUE;
}
DECLARE_API( pcitree )
/*++
Routine Description:
Dumps the pci tree. (Why is this here? Because the other PCI stuff
ended up in here because devnode was such a useful base).
Arguments:
None
Return Value:
None
--*/
{
ULONG Signature;
ULONG64 TreeTop;
ULONG64 list;
ULONG64 addr;
ULONG indent = 0;
ULONG rootCount = 0;
addr = GetExpression("Pci!PciFdoExtensionListHead");
if (addr == 0) {
dprintf("Error retrieving address of PciFdoExtensionListHead\n");
return E_INVALIDARG;
}
if (!ReadPointer(addr, &list)) {
dprintf("Error reading PciFdoExtensionListHead (@%08p)\n", addr);
return E_INVALIDARG;
}
if (list == 0) {
dprintf(
"PciFdoExtensionListHead forward pointer is NULL, list is empty\n"
);
return E_INVALIDARG;
}
TreeTop = list;
do {
ULONG64 BusRootFdoExtension;
if (CheckControlC()) {
dprintf("User terminated with <control>C\n");
break;
}
if (GET_PCI_FDO_FIELD(list, "BusRootFdoExtension", BusRootFdoExtension)) {
dprintf(
"Error reading PCI FDO extension at %08p, quitting.\n",
list
);
return E_INVALIDARG;
}
if (BusRootFdoExtension == list) {
//
// This is the FDO for a root bus.
//
rootCount++;
if (pcitreeProcessBus(0, list, TreeTop) == FALSE) {
//
// Asked not to continue;
//
dprintf("User terminated output.\n");
break;
}
}
GET_PCI_FDO_FIELD(list, "List.Next", list);
} while (list != 0);
dprintf("Total PCI Root busses processed = %d\n", rootCount);
return S_OK;
}
VOID
DumpDeviceCapabilities(
ULONG64 caps
) {
FIELD_INFO fields [] = {
{ "DeviceD1", "Spare1", 0, 0, 0, NULL},
{ "DeviceD2", "\tDeviceD2", 0, 0, 0, NULL},
{ "LockSupported", "\tLock", 0, 0, 0, NULL},
{ "EjectSupported","\tEject", 0, 0, 0, NULL},
{ "Removeable", "\tRemoveable", 0, 0, 0, NULL},
{ "DockDevice", "\nDock Device",0, 0, 0, NULL},
{ "UniqueID", "Unique ID", 0, 0, 0, NULL},
{ "SilentInstall", "\tSilent Install", 0, 0, 0, NULL},
{ "RawDeviceOK", "\tRawDeviceOK",0, 0, 0, NULL},
{ "Address", "\nAddress", 0, 0, 0, NULL},
{ "UINumber", "", 0, 0, 0, NULL},
{ "DeviceState", "\nDevice State : ", 0, DBG_DUMP_FIELD_ARRAY , 0, NULL},
{ "SystemWake", "\nSystemWake", 0, 0, 0, NULL},
{ "DeviceWake", "", 0, 0, 0, NULL},
};
UCHAR nm[] = "_DEVICE_CAPABILITIES";
SYM_DUMP_PARAM Sym = {
sizeof (SYM_DUMP_PARAM),
&nm[0],
DBG_DUMP_NO_OFFSET | DBG_DUMP_COMPACT_OUT,
caps,
NULL,
NULL,
NULL,
sizeof (fields) / sizeof (FIELD_INFO),
&fields[0],
};
dprintf ("PnP CAPS: \n");
Ioctl(IG_DUMP_SYMBOL_INFO, &Sym, sizeof (Sym));
}
#if 0
VOID
DumpDeviceCapabilities(
PDEVICE_CAPABILITIES caps
)
{
ULONG i,j,k;
ULONG bitmask;
PCHAR bits [] = {
"Spare1",
"Spare1",
"Lock",
"Eject",
"Removeable",
"Dock Device",
"Unique ID",
"Silent Install",
"RawDeviceOK"
};
bitmask = * (((PULONG) caps) + 1);
dprintf ("PnP CAPS: ");
for (i = 0, j = 1, k = 0; i < sizeof (bits); i++, j <<= 1) {
if (bitmask & j) {
if (k) {
dprintf("\n ");
}
k ^= 1;
dprintf(bits [i]);
}
}
dprintf("\n");
dprintf(" Address %x UINumber %x \n",
caps->Address,
caps->UINumber);
dprintf(" Device State [");
for (i = 0; i < PowerSystemMaximum; i ++) {
dprintf ("%02x ", (caps->DeviceState [i] & 0xFF));
}
dprintf("]\n");
dprintf(" System Wake %x Device Wake %x\n",
caps->SystemWake,
caps->DeviceWake);
dprintf("\n");
}
#endif
VOID
DumpTranslator(
IN DWORD Depth,
IN ULONG64 TranslatorAddr
)
/*++
Routine Description:
Dumps out the specified translator.
Arguments:
Depth - Supplies the print depth.
TranslatorAddr - Supplies the original address of the arbiter (on the target)
Translator - Supplies the arbiter
Return Value:
None.
--*/
{
// TRANSLATOR_INTERFACE interface;
UCHAR buffer[256];
ULONG64 displacement;
ULONG ResourceType;
ULONG64 TranslatorInterface, TranslateResources, TranslateResourceRequirements;
if (GetFieldValue(TranslatorAddr,
"nt!_PI_RESOURCE_TRANSLATOR_ENTRY",
"ResourceType",
ResourceType)) {
xdprintf( Depth, "");
dprintf( "Could not read translator entry %08p\n",
TranslatorAddr
);
return;
}
GetFieldValue(TranslatorAddr,"nt!_PI_RESOURCE_TRANSLATOR_ENTRY","TranslatorInterface", TranslatorInterface);
xdprintf(Depth,
"%s Translator\n",
GetCmResourceTypeString((UCHAR)ResourceType)
);
if (GetFieldValue(TranslatorInterface,
"nt!_TRANSLATOR_INTERFACE",
"TranslateResources",
TranslateResources)) {
dprintf("Error reading TranslatorInterface %08p for TranslatorEntry at %08p\n",
TranslatorInterface,
TranslatorAddr);
return;
}
GetSymbol(TranslateResources, buffer, &displacement);
xdprintf(Depth+1, "Resources: %s", buffer, displacement);
if (displacement != 0) {
dprintf("+0x%1p\n", displacement);
} else {
dprintf("\n");
}
GetFieldValue(TranslatorInterface,"nt!_TRANSLATOR_INTERFACE",
"TranslateResourceRequirements",TranslateResourceRequirements);
GetSymbol(TranslateResourceRequirements, buffer, &displacement);
xdprintf(Depth+1, "Requirements: %s", buffer, displacement);
if (displacement != 0) {
dprintf("+0x%1p\n", displacement);
} else {
dprintf("\n");
}
return;
}
BOOLEAN
DumpTranslatorsForDevNode(
IN DWORD Depth,
IN ULONG64 DevNodeAddr,
IN DWORD Flags
)
/*++
Routine Description:
Dumps all the translators for the specified devnode. Recursively calls
itself on the specified devnode's children.
Arguments:
Depth - Supplies the print depth.
DevNodeAddr - Supplies the address of the devnode.
Flags - Supplies the type of arbiters to dump:
ARBITER_DUMP_IO
ARBITER_DUMP_MEMORY
ARBITER_DUMP_IRQ
ARBITER_DUMP_DMA
Return Value:
None
--*/
{
ULONG result;
ULONG64 nextTranslator;
ULONG64 translatorAddr;
BOOLEAN PrintedHeader = FALSE;
BOOLEAN continueDump = TRUE;
ULONG DeviceTranslatorListOffset, TransEntryOffset;
ULONG64 Child, Sibling;
if (GetFieldOffset("nt!_DEVICE_NODE", "DeviceTranslatorList", &DeviceTranslatorListOffset)) {
dprintf("_DEVICE_NODE type not found.\n");
return continueDump;
}
if (GetFieldOffset("nt!_PI_RESOURCE_TRANSLATOR_ENTRY", "DeviceTranslatorList", &TransEntryOffset)) {
dprintf("_PI_RESOURCE_TRANSLATOR_ENTRY type not found.\n");
return continueDump;
}
if (GetFieldValue(DevNodeAddr,
"nt!_DEVICE_NODE",
"DeviceTranslatorList.Flink",
nextTranslator)) {
xdprintf(Depth, ""); dprintf("%08p: Could not read device node\n", DevNodeAddr);
return continueDump;
}
// dprintf("Next %p, Devnode %p, Trans Off %x", nextTranslator, DevNodeAddr, DeviceTranslatorListOffset);
//
// Dump the list of translators
//
while (nextTranslator != DevNodeAddr+DeviceTranslatorListOffset) {
ULONG ResourceType;
if (CheckControlC()) {
continueDump = FALSE;
break;
}
translatorAddr = (nextTranslator-TransEntryOffset);
if (GetFieldValue(translatorAddr,
"nt!_PI_RESOURCE_TRANSLATOR_ENTRY",
"ResourceType",
ResourceType)) {
xdprintf( Depth, "");
dprintf ("Could not read translator entry %08p for devnode %08p\n",
translatorAddr,
DevNodeAddr);
break;
}
if (!PrintedHeader) {
UNICODE_STRING64 u;
dprintf("\n");
xdprintf(Depth, ""); dprintf("DEVNODE %08p ", DevNodeAddr);
GetFieldValue(DevNodeAddr,"nt!_DEVICE_NODE","InstancePath.Buffer", u.Buffer);
GetFieldValue(DevNodeAddr,"nt!_DEVICE_NODE","InstancePath.Length", u.Length);
GetFieldValue(DevNodeAddr,"nt!_DEVICE_NODE","InstancePath.MaximumLength", u.MaximumLength);
if (u.Buffer != 0) {
dprintf("(");
DumpUnicode64(u);
dprintf(")");
}
dprintf("\n");
PrintedHeader = TRUE;
}
if (((ResourceType == CmResourceTypePort) && (Flags & ARBITER_DUMP_IO)) ||
((ResourceType == CmResourceTypeInterrupt) && (Flags & ARBITER_DUMP_IRQ)) ||
((ResourceType == CmResourceTypeMemory) && (Flags & ARBITER_DUMP_MEMORY)) ||
((ResourceType == CmResourceTypeDma) && (Flags & ARBITER_DUMP_DMA)) ||
((ResourceType == CmResourceTypeBusNumber) && (Flags & ARBITER_DUMP_BUS_NUMBER))) {
DumpTranslator( Depth+1, translatorAddr);
}
GetFieldValue(translatorAddr,"nt!_PI_RESOURCE_TRANSLATOR_ENTRY","DeviceTranslatorList.Flink",nextTranslator);
}
GetFieldValue(DevNodeAddr,"nt!_DEVICE_NODE","Sibling", Sibling);
GetFieldValue(DevNodeAddr,"nt!_DEVICE_NODE","Child", Child);
//
// Dump this devnode's children (if any)
//
if (continueDump && Child) {
continueDump = DumpTranslatorsForDevNode( Depth+1, Child, Flags);
}
//
// Dump this devnode's siblings (if any)
//
if (continueDump && Sibling) {
continueDump = DumpTranslatorsForDevNode( Depth, Sibling, Flags);
}
return continueDump;
}
DECLARE_API( translator )
/*++
Routine Description:
Dumps all the translators in the system
!translator [flags]
flags 1 - I/O port arbiters
2 - memory arbiters
4 - IRQ arbiters
8 - DMA arbiters
If no flags are specified, all translators are dumped.
Arguments:
args - optional flags specifying which arbiters to dump
Return Value:
None
--*/
{
DWORD Flags=0;
ULONG64 addr;
ULONG64 deviceNode;
if (!(Flags = (ULONG) GetExpression(args))) {
Flags = ARBITER_DUMP_ALL;
}
//
// Find the root devnode and dump its arbiters
//
addr = GetExpression( "nt!IopRootDeviceNode" );
if (addr == 0) {
dprintf("Error retrieving address of IopRootDeviceNode\n");
return E_INVALIDARG;
}
if (!ReadPointer(addr, &deviceNode)) {
dprintf("Error reading value of IopRootDeviceNode (%#010p)\n", addr);
return E_INVALIDARG;
}
DumpTranslatorsForDevNode(0, deviceNode, Flags);
return S_OK;
}
#define RAW_RANGE_DUMP_STATS_ONLY 0x00000001
VOID
DumpRawRangeEntry(
IN DWORD Depth,
IN ULONG64 RangeEntry
)
/*++
Routine Description:
Dumps out the specified RTLP_RANGE_LIST_ENTRY
Arguments:
Depth - Supplies the print depth.
RangeList - Supplies the address of the RTLP_RANGE_LIST_ENTRY
OwnerIsDevObj - Indicates that the owner field is a pointer to a DEVICE_OBJECT
Return Value:
None.
--*/
{
ULONG PublicFlags;
ULONG64 UserData, Owner;
ULONG64 Start, End;
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "Start", Start);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "End", End);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "PublicFlags", PublicFlags);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "Allocated.UserData", UserData);
GetFieldValue(RangeEntry, "nt!_RTLP_RANGE_LIST_ENTRY", "Allocated.Owner", Owner);
xdprintf(Depth, "");
dprintf ("%016I64x - %016I64x %c%c %08p %08p\n",
Start,
End,
PublicFlags & RTL_RANGE_SHARED ? 'S' : ' ',
PublicFlags & RTL_RANGE_CONFLICT ? 'C' : ' ',
UserData,
Owner
);
}
BOOLEAN
DumpRawRangeList(
IN DWORD Depth,
IN ULONG64 RangeListHead,
IN ULONG Flags,
IN PULONG MergedCount OPTIONAL,
IN PULONG EntryCount
)
/*++
Routine Description:
Dumps out the specified RTL_RANGE_LIST
Arguments:
Depth - Supplies the print depth.
RangeListHead - Supplies the address of the LIST_ENTRY containing the RTLP_RANGE_LIST_ENTRYs
Return Value:
None.
--*/
{
ULONG64 EntryAddr;
ULONG64 ListEntry;
ULONG ListEntryOffset;
BOOLEAN continueDump = TRUE;
//
// Read the range list
//
if (GetFieldValue(RangeListHead, "nt!_LIST_ENTRY", "Flink", ListEntry)) {
dprintf("Error reading RangeList %08p\n", RangeListHead);
return continueDump;
}
if (ListEntry == RangeListHead) {
xdprintf(Depth, "< none >\n");
return continueDump;
}
GetFieldOffset("nt!RTLP_RANGE_LIST_ENTRY", "ListEntry", &ListEntryOffset);
while (ListEntry != RangeListHead) {
ULONG PrivateFlags;
ULONG64 Start, End;
if (CheckControlC()) {
continueDump = FALSE;
break;
}
EntryAddr = ( ListEntry - ListEntryOffset);
if (GetFieldValue(EntryAddr, "nt!_RTLP_RANGE_LIST_ENTRY",
"PrivateFlags", PrivateFlags)) {
dprintf("Error reading RangeEntry %08p from RangeList %08p\n",
EntryAddr,
RangeListHead);
return continueDump;
}
(*EntryCount)++;
if (PrivateFlags & RTLP_RANGE_LIST_ENTRY_MERGED) {
ULONG MergedOffset;
//
// This is a merged range list, call ourselves recursively
//
if (MergedCount) {
(*MergedCount)++;
}
if (!(Flags & RAW_RANGE_DUMP_STATS_ONLY)) {
GetFieldValue(EntryAddr, "nt!_RTLP_RANGE_LIST_ENTRY", "Start", Start);
GetFieldValue(EntryAddr, "nt!_RTLP_RANGE_LIST_ENTRY", "End", End);
xdprintf(Depth, "Merged Range - %I64x-%I64x\n", Start, End);
}
GetFieldOffset("nt!_RTLP_RANGE_LIST_ENTRY", "Merged.ListHead", &MergedOffset);
continueDump = DumpRawRangeList( Depth+1,
EntryAddr + MergedOffset,
Flags,
MergedCount,
EntryCount);
if (!continueDump) {
break;
}
} else if (!(Flags & RAW_RANGE_DUMP_STATS_ONLY)) {
DumpRawRangeEntry(Depth, EntryAddr);
}
GetFieldValue(EntryAddr, "nt!_RTLP_RANGE_LIST_ENTRY", "ListEntry.Flink", ListEntry);
}
return continueDump;
}
DECLARE_API( rawrange )
/*++
Routine Description:
Dumps an RTL_RANGE_LIST
Arguments:
args - specifies the address of the RTL_RANGE_LIST
Return Value:
None
--*/
{
ULONG64 RangeList=0;
ULONG mergedCount = 0, entryCount = 0, flags=0, Offset;
if (GetExpressionEx(args, &RangeList, &args)) {
flags = (ULONG) GetExpression(args);
}
GetFieldOffset("nt!_RTLP_RANGE_LIST_ENTRY", "ListHead", &Offset);
DumpRawRangeList(0, RangeList + Offset, flags, &mergedCount, &entryCount);
dprintf("Stats\nMerged = %i\nEntries = %i\n", mergedCount, entryCount);
return S_OK;
}
VOID
DumpIoResourceDescriptor(
IN ULONG Depth,
IN ULONG64 Descriptor
)
{
ULONG64 Q1, Q2;
ULONG Option, Type, ShareDisposition, Flags, V1, V2, V3, Data[3];
#define Desc(F,V) GetFieldValue(Descriptor, "nt!IO_RESOURCE_LIST", #F, V)
Desc(Option,Option); Desc(Type,Type);
Desc(ShareDisposition,ShareDisposition);
Desc(Flags,Flags);
DumpResourceDescriptorHeader(Depth,
0,
(UCHAR) Option,
(UCHAR) Type,
(UCHAR) ShareDisposition,
(USHORT) Flags);
Depth++;
switch (Type) {
case CmResourceTypeBusNumber:
Desc(u.BusNumber.MinBusNumber, V1);
Desc(u.BusNumber.MaxBusNumber, V2);
Desc(u.BusNumber.Length, V3);
xdprintf(Depth, "0x%x - 0x%x for length 0x%x\n",
V1, V2, V3);
break;
case CmResourceTypePort:
case CmResourceTypeMemory:
Desc(u.Generic.Length, V1);
Desc(u.Generic.Alignment, V2);
Desc(u.Port.MinimumAddress.QuadPart, Q1);
Desc(u.Port.MaximumAddress.QuadPart, Q2);
xdprintf(Depth, "%#08lx byte range with alignment %#08lx\n", V1, V2);
xdprintf(Depth, "%I64x - %#I64x\n", Q1, Q2);
case CmResourceTypeInterrupt:
Desc(u.Interrupt.MinimumVector,V1);
Desc(u.Interrupt.MaximumVector,V2);
xdprintf(Depth, "0x%x - 0x%x\n", V1,V2);
break;
case CmResourceTypeDma:
Desc(u.Dma.MinimumChannel,V1);
Desc(u.Dma.MaximumChannel,V2);
xdprintf(Depth, "0x%x - 0x%x\n",V1, V2);
break;
default:
Desc(u.DevicePrivate.Data, Data);
xdprintf(Depth,
"Data: : 0x%x 0x%x 0x%x\n",
Data[0],
Data[1],
Data[2]);
break;
}
#undef Desc
}
DECLARE_API( ioresdes )
{
ULONG64 descriptorAddr;
descriptorAddr = GetExpression(args);
DumpIoResourceDescriptor(0, descriptorAddr);
return S_OK;
}
DECLARE_API(pnpevent)
/*++
Routine Description:
Dump a device object.
Arguments:
args - the location of the device object to dump.
Return Value:
None
--*/
{
ULONG64 deviceEventListAddr;
ULONG64 listHead;
ULONG64 deviceEvent = 0;
ULONG verbose = 0;
ULONG64 address;
ULONG offset;
BOOL followLinks;
ULONG64 status = 0, flink = 0, blink = 0;
ULONG eventQ_Header_SignalState = 0, lk_Event_Hdr_SignalState = 0;
address = GetExpression( "nt!PpDeviceEventList" );
if (address == 0) {
dprintf("Error retrieving address of PpDeviceEventList\n");
return E_INVALIDARG;
}
if (!ReadPointer(address, &deviceEventListAddr)) {
dprintf("Error reading value of PpDeviceEventList (%#010lx)\n", address);
return E_INVALIDARG;
}
if (GetFieldOffset("nt!_PNP_DEVICE_EVENT_LIST", "List", &offset)) {
dprintf("Cannot find _PNP_DEVICE_EVENT_LIST.List type.\n");
return E_INVALIDARG;
}
listHead = deviceEventListAddr + offset;
dprintf("\n********************************************************************************\n");
dprintf("Dumping PnP DeviceEvent Queue @ 0x%08p\n", deviceEventListAddr);
dprintf("********************************************************************************\n\n");
if (GetFieldValue(deviceEventListAddr, "nt!_PNP_DEVICE_EVENT_LIST", "Status", status)) {
dprintf("Error reading PpDeviceEventList->Status (%#010p)\n", deviceEventListAddr);
return E_INVALIDARG;
}
if (GetFieldValue(deviceEventListAddr, "nt!_PNP_DEVICE_EVENT_LIST", "EventQueueMutex.Header.SignalState", eventQ_Header_SignalState)) {
dprintf("Error reading PpDeviceEventList->EventQueueMutex.Header.SignalState (%#010p)\n", deviceEventListAddr);
return E_INVALIDARG;
}
if (GetFieldValue(deviceEventListAddr, "nt!_PNP_DEVICE_EVENT_LIST", "Lock.Event.Header.SignalState", lk_Event_Hdr_SignalState)) {
dprintf("Error reading PpDeviceEventList->Lock.Event.Header.SignalState (%#010p)\n", deviceEventListAddr);
return E_INVALIDARG;
}
if (GetFieldValue(deviceEventListAddr, "nt!_PNP_DEVICE_EVENT_LIST", "List.Flink", flink)) {
dprintf("Error reading PpDeviceEventList->List.Flink (%#010p)\n", deviceEventListAddr);
return E_INVALIDARG;
}
if (GetFieldValue(deviceEventListAddr, "nt!_PNP_DEVICE_EVENT_LIST", "List.Blink", blink)) {
dprintf("Error reading PpDeviceEventList->List.Blink (%#010p)\n", deviceEventListAddr);
return E_INVALIDARG;
}
dprintf(" Status = 0x%08I64X, EventQueueMutex is %sheld, Lock is %sheld\n",
status,
eventQ_Header_SignalState ? "not " : "",
lk_Event_Hdr_SignalState ? "not " : "");
dprintf(" List = 0x%08p, 0x%08p\n", flink, blink);
if (GetExpressionEx(args, &deviceEvent, &args)) {
verbose = (ULONG) GetExpression(args);
}
if (deviceEvent == 0) {
ULONG listEntryOffset = 0;
if (flink == listHead) {
dprintf("Event list is empty\n");
return E_INVALIDARG;
}
//
// Now get addtess of PNP_DEVICE_EVENT_ENTRY
//
if (GetFieldOffset("nt!_PNP_DEVICE_EVENT_ENTRY", "ListEntry", &offset)) {
dprintf("Cannot find _PNP_DEVICE_EVENT_ENTRY type.\n");
return E_INVALIDARG;
}
deviceEvent = flink - offset; // CONTAINING_RECORD(deviceEventList.List.Flink, PNP_DEVICE_EVENT_ENTRY, ListEntry);
followLinks = TRUE;
} else {
followLinks = FALSE;
}
DumpDeviceEventEntry( deviceEvent, listHead, followLinks );
return S_OK;
}
BOOLEAN
DumpDeviceEventEntry(
ULONG64 DeviceEvent,
ULONG64 ListHead,
BOOL FollowLinks
)
{
BOOLEAN continueDump = TRUE;
ULONG64 flink=0, blink=0, argument=0, callerEvent=0, callback=0, context=0;
ULONG64 vetoType=0, vetoName=0;
ULONG dataSize=0;
ULONG offset;
ULONG64 dataAddress;
dprintf("\nDumping DeviceEventEntry @ 0x%08p\n", DeviceEvent);
if (GetFieldValue(DeviceEvent, "nt!_PNP_DEVICE_EVENT_ENTRY", "ListEntry.Flink", flink)) {
dprintf("Error reading DeviceEvent->ListEntry.Flink (%#010p)\n", DeviceEvent);
return FALSE;
}
if (GetFieldValue(DeviceEvent, "nt!_PNP_DEVICE_EVENT_ENTRY", "ListEntry.Blink", blink)) {
dprintf("Error reading DeviceEvent->ListEntry.Blink (%#010p)\n", DeviceEvent);
return FALSE;
}
if (GetFieldValue(DeviceEvent, "nt!_PNP_DEVICE_EVENT_ENTRY", "CallerEvent", callerEvent)) {
dprintf("Error reading DeviceEvent->CallerEvent (%#010p)\n", DeviceEvent);
return FALSE;
}
if (GetFieldValue(DeviceEvent, "nt!_PNP_DEVICE_EVENT_ENTRY", "Callback", callback)) {
dprintf("Error reading DeviceEvent->Callback (%#010p)\n", DeviceEvent);
return FALSE;
}
if (GetFieldValue(DeviceEvent, "nt!_PNP_DEVICE_EVENT_ENTRY", "Context", context)) {
dprintf("Error reading DeviceEvent->Context (%#010p)\n", DeviceEvent);
return FALSE;
}
if (GetFieldValue(DeviceEvent, "nt!_PNP_DEVICE_EVENT_ENTRY", "VetoType", vetoType)) {
dprintf("Error reading DeviceEvent->VetoType (%#010p)\n", DeviceEvent);
return FALSE;
}
if (GetFieldValue(DeviceEvent, "nt!_PNP_DEVICE_EVENT_ENTRY", "VetoName", vetoName)) {
dprintf("Error reading DeviceEvent->VetoName (%#010p)\n", DeviceEvent);
return FALSE;
}
dprintf(" ListEntry = 0x%08p, 0x%08p, Argument = 0x%08I64x\n",
flink, blink, argument);
dprintf(" CallerEvent = 0x%08p, Callback = 0x%08p, Context = 0x%08p\n",
callerEvent, callback, context);
dprintf(" VetoType = 0x%08p, VetoName = 0x%08p\n",
vetoType, vetoName);
if (GetFieldOffset("nt!_PNP_DEVICE_EVENT_ENTRY", "Data", &offset)) {
dprintf("Cannot find offset of Data in _PNP_DEVICE_EVENT_ENTRY type.\n");
return FALSE;
}
dataAddress = DeviceEvent + offset;
if (GetFieldValue(DeviceEvent, "nt!_PNP_DEVICE_EVENT_ENTRY", "Data.TotalSize", dataSize)) {
dprintf("Error reading DeviceEvent->Data.TotalSize (%#010p)\n", DeviceEvent);
return FALSE;
}
DumpPlugPlayEventBlock( dataAddress, dataSize );
if (FollowLinks && flink != ListHead) {
if (CheckControlC()) {
continueDump = FALSE;
} else {
if (GetFieldOffset("nt!_PNP_DEVICE_EVENT_ENTRY", "ListEntry", &offset)) {
dprintf("Cannot find offset of ListEntry in _PNP_DEVICE_EVENT_ENTRY type.\n");
return FALSE;
}
continueDump = DumpDeviceEventEntry(flink - offset,
ListHead,
TRUE);
}
}
return continueDump;
}
PUCHAR DevNodeStateNames[] = {
"DeviceNodeUnspecified",
"DeviceNodeUninitialized",
"DeviceNodeInitialized",
"DeviceNodeDriversAdded",
"DeviceNodeResourcesAssigned",
"DeviceNodeStartPending",
"DeviceNodeStartCompletion",
"DeviceNodeStartPostWork",
"DeviceNodeStarted",
"DeviceNodeQueryStopped",
"DeviceNodeStopped",
"DeviceNodeRestartCompletion",
"DeviceNodeEnumeratePending",
"DeviceNodeEnumerateCompletion",
"DeviceNodeAwaitingQueuedDeletion",
"DeviceNodeAwaitingQueuedRemoval",
"DeviceNodeQueryRemoved",
"DeviceNodeRemovePendingCloses",
"DeviceNodeRemoved",
"DeviceNodeDeletePendingCloses",
"DeviceNodeDeleted"
};
#define DEVNODE_STATE_NAMES_SIZE (sizeof(DevNodeStateNames) / sizeof(DevNodeStateNames[0]))
VOID
PrintDevNodeState(
IN ULONG Depth,
IN PUCHAR Field,
IN ULONG State
)
{
UCHAR *Description;
ULONG stateIndex;
stateIndex = State - 0x300; //DeviceNodeUnspecified;
if (stateIndex < DEVNODE_STATE_NAMES_SIZE) {
Description = DevNodeStateNames[stateIndex];
} else {
Description = "Unknown State";
}
xdprintf(Depth, "%s = %s (0x%x)\n", Field, Description, State);
}
VOID
DumpMultiSz(
IN PWCHAR MultiSz
)
{
PWCHAR p = MultiSz;
ULONG length;
while (*p) {
length = wcslen(p);
dprintf(" %S\n", p);
p += length + 1;
}
}
struct {
CONST GUID *Guid;
PCHAR Name;
} EventGuidTable[] = {
// From wdmguid.h
{ &GUID_HWPROFILE_QUERY_CHANGE, "GUID_HWPROFILE_QUERY_CHANGE" },
{ &GUID_HWPROFILE_CHANGE_CANCELLED, "GUID_HWPROFILE_CHANGE_CANCELLED" },
{ &GUID_HWPROFILE_CHANGE_COMPLETE, "GUID_HWPROFILE_CHANGE_COMPLETE" },
{ &GUID_DEVICE_INTERFACE_ARRIVAL, "GUID_DEVICE_INTERFACE_ARRIVAL" },
{ &GUID_DEVICE_INTERFACE_REMOVAL, "GUID_DEVICE_INTERFACE_REMOVAL" },
{ &GUID_TARGET_DEVICE_QUERY_REMOVE, "GUID_TARGET_DEVICE_QUERY_REMOVE" },
{ &GUID_TARGET_DEVICE_REMOVE_CANCELLED, "GUID_TARGET_DEVICE_REMOVE_CANCELLED" },
{ &GUID_TARGET_DEVICE_REMOVE_COMPLETE, "GUID_TARGET_DEVICE_REMOVE_COMPLETE" },
{ &GUID_PNP_CUSTOM_NOTIFICATION, "GUID_PNP_CUSTOM_NOTIFICATION" },
{ &GUID_PNP_POWER_NOTIFICATION, "GUID_PNP_POWER_NOTIFICATION" },
// From pnpmgr.h
{ &GUID_DEVICE_ARRIVAL, "GUID_DEVICE_ARRIVAL" },
{ &GUID_DEVICE_ENUMERATED, "GUID_DEVICE_ENUMERATED" },
{ &GUID_DEVICE_ENUMERATE_REQUEST, "GUID_DEVICE_ENUMERATE_REQUEST" },
{ &GUID_DEVICE_START_REQUEST, "GUID_DEVICE_START_REQUEST" },
{ &GUID_DEVICE_REMOVE_PENDING, "GUID_DEVICE_REMOVE_PENDING" },
{ &GUID_DEVICE_QUERY_AND_REMOVE, "GUID_DEVICE_QUERY_AND_REMOVE" },
{ &GUID_DEVICE_EJECT, "GUID_DEVICE_EJECT" },
{ &GUID_DEVICE_NOOP, "GUID_DEVICE_NOOP" },
{ &GUID_DEVICE_SURPRISE_REMOVAL, "GUID_DEVICE_SURPRISE_REMOVAL" },
{ &GUID_DRIVER_BLOCKED, "GUID_DRIVER_BLOCKED" },
};
#define EVENT_GUID_TABLE_SIZE (sizeof(EventGuidTable) / sizeof(EventGuidTable[0]))
VOID
LookupGuid(
IN CONST GUID *Guid,
IN OUT PCHAR String,
IN ULONG StringLength
)
{
int i;
for (i = 0; i < EVENT_GUID_TABLE_SIZE; i++) {
if (memcmp(Guid, EventGuidTable[i].Guid, sizeof(Guid)) == 0) {
strncpy(String, EventGuidTable[i].Name, StringLength - 1);
String[StringLength - 1] = '\0';
return;
}
}
_snprintf( String, StringLength, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
Guid->Data1,
Guid->Data2,
Guid->Data3,
Guid->Data4[0],
Guid->Data4[1],
Guid->Data4[2],
Guid->Data4[3],
Guid->Data4[4],
Guid->Data4[5],
Guid->Data4[6],
Guid->Data4[7] );
}
PUCHAR EventCategoryStrings[] = {
"HardwareProfileChangeEvent",
"TargetDeviceChangeEvent",
"DeviceClassChangeEvent",
"CustomDeviceEvent",
"DeviceInstallEvent",
"DeviceArrivalEvent",
"PowerEvent",
"VetoEvent",
"BlockedDriverEvent"
};
#define N_EVENT_CATEGORIES (sizeof(EventCategoryStrings) / sizeof(EventCategoryStrings[0]))
VOID
DumpPlugPlayEventBlock(
ULONG64 PlugPlayEventBlock,
ULONG Size
)
{
GUID EventGuid;
UCHAR guidString[256];
UCHAR PnpEventTyp[] = "nt!PLUGPLAY_EVENT_BLOCK";
char categoryString[80];
ULONG64 Result=0, DeviceObject=0;
ULONG EventCategory=0, TotalSize=0, Flags=0;
ULONG64 PtrVal=0;
ULONG offset;
PUCHAR buffer;
ULONG powerData;
dprintf("\n Dumping PlugPlayEventBlock @ 0x%08X\n", PlugPlayEventBlock);
if (GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "EventGuid", EventGuid)) {
dprintf("Error reading PlugPlayEventBlock (%#010p)\n", PlugPlayEventBlock);
return;
}
LookupGuid(&EventGuid, guidString, sizeof(guidString));
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "EventCategory", EventCategory);
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "Result", Result );
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "Flags", Flags );
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "TotalSize", TotalSize );
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "DeviceObject", DeviceObject );
if ( EventCategory > N_EVENT_CATEGORIES) {
sprintf(categoryString, "Unknown category (%d)", EventCategory);
} else {
if (StringCchCopy(categoryString, sizeof(categoryString), EventCategoryStrings[ EventCategory ]) != S_OK)
{
categoryString[0] = 0;
}
}
dprintf(" EventGuid = %s\n Category = %s\n",
guidString, categoryString);
dprintf(" Result = 0x%08p, Flags = 0x%08X, TotalSize = %d\n",
Result, Flags, TotalSize );
dprintf(" DeviceObject = 0x%08p\n", DeviceObject);
switch (EventCategory) {
case HardwareProfileChangeEvent:
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "u.ProfileNotification.Notification", PtrVal);
dprintf( " Notification = 0x%08p\n", PtrVal );
break;
case DeviceArrivalEvent:
break;
case TargetDeviceChangeEvent:
dprintf( " DeviceIds:\n");
GetFieldOffset(PnpEventTyp, "u.TargetDevice.DeviceIds", &offset);
buffer = LocalAlloc(LPTR, Size - offset);
xReadMemory(PlugPlayEventBlock + offset, buffer, Size - offset);
DumpMultiSz( (PWCHAR)buffer );
LocalFree(buffer);
break;
case DeviceClassChangeEvent:
#if DEBUGGER_GETS_FIXED
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "u.DeviceClass.ClassGuid", EventGuid);
#else
GetFieldOffset(PnpEventTyp, "u.DeviceClass.ClassGuid", &offset);
xReadMemory(PlugPlayEventBlock + offset, &EventGuid, sizeof(EventGuid));
#endif
LookupGuid(&EventGuid, guidString, sizeof(guidString));
dprintf( " ClassGuid = %s\n", guidString );
GetFieldOffset(PnpEventTyp, "u.DeviceClass.SymbolicLinkName", &offset);
buffer = LocalAlloc(LPTR, Size - offset);
xReadMemory(PlugPlayEventBlock + offset, buffer, Size - offset);
dprintf( " SymbolicLinkName = %S\n", (PWCHAR) buffer );
LocalFree(buffer);
break;
case CustomDeviceEvent:
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "u.CustomNotification.NotificationStructure", PtrVal);
dprintf( " NotificationStructure = 0x%08p\n DeviceIds:\n",
PtrVal);
GetFieldOffset(PnpEventTyp, "u.CustomNotification.DeviceIds", &offset);
buffer = LocalAlloc(LPTR, Size - offset);
xReadMemory(PlugPlayEventBlock + offset, buffer, Size - offset);
DumpMultiSz( (PWCHAR) buffer );
LocalFree(buffer);
break;
case DeviceInstallEvent:
GetFieldOffset(PnpEventTyp, "u.InstallDevice.DeviceId", &offset);
buffer = LocalAlloc(LPTR, Size - offset);
xReadMemory(PlugPlayEventBlock + offset, buffer, Size - offset);
dprintf( " DeviceId = %S\n", (PWCHAR) buffer );
LocalFree(buffer);
break;
case PowerEvent:
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "u.PowerNotification.NotificationCode", powerData);
dprintf( " NotificationCode = 0x%08X\n", powerData );
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "u.PowerNotification.NotificationData", powerData);
dprintf( " NotificationData = 0x%08X\n", powerData );
break;
case BlockedDriverEvent:
#if DEBUGGER_GETS_FIXED
GetFieldValue(PlugPlayEventBlock, PnpEventTyp, "u.BlockedDriverNotification.BlockedDriverGuid", EventGuid);
#else
GetFieldOffset(PnpEventTyp, "u.BlockedDriverNotification.BlockedDriverGuid", &offset);
xReadMemory(PlugPlayEventBlock + offset, &EventGuid, sizeof(EventGuid));
#endif
LookupGuid(&EventGuid, guidString, sizeof(guidString));
dprintf( " BlockedDriverGuid = %s\n", guidString );
break;
}
}
DECLARE_API( rellist )
/*++
Routine Description:
Dump a device object.
Arguments:
args - the location of the device object to dump.
Return Value:
None
--*/
{
ULONG64 relationList=0;
ULONG verbose=0;
if (GetExpressionEx(args, &relationList, &args)) {
verbose = (ULONG) GetExpression(args);
}
DumpRelationsList( relationList,
(BOOLEAN) (verbose & DUMP_CM_RES),
(BOOLEAN) (verbose & DUMP_CM_RES_REQ_LIST),
(BOOLEAN) (verbose & DUMP_CM_RES_TRANS)
);
return S_OK;
}
DECLARE_API( lbt )
/*++
Routine Description:
Dump the legacy bus information table.
Arguments:
args - none.
Return Value:
None
--*/
{
CHAR buffer[256];
ULONG size, deviceNodeOffset;
ULONG64 deviceNode;
ULONG64 listHeadAddr, legacyBusEntryAddr;
ULONG64 head_Flink, head_Blink, link_Flink;
USHORT instancePath_Len, instancePath_Max;
ULONG busNumber;
ULONG64 instancePath_Buff, interfaceType;
CHAR deviceNodeType[] ="nt!_DEVICE_NODE";
CHAR listEntryType[] = "nt!_LIST_ENTRY" ;
INTERFACE_TYPE Iface;
if ((size = GetTypeSize(listEntryType)) == 0) {
dprintf("Failed to get the size of %s\n", listEntryType);
return E_INVALIDARG;
}
if (GetFieldOffset(deviceNodeType, "LegacyBusListEntry.Flink", &deviceNodeOffset)) {
dprintf("Failed to get the offset of LegacyBusListEntry from %s\n", deviceNodeType);
return E_INVALIDARG;
}
dprintf("Legacy Bus Information Table...\n");
for (Iface = Internal; Iface < MaximumInterfaceType; Iface++) {
sprintf(buffer, "nt!IopLegacyBusInformationTable + %x", Iface * size);
if ((listHeadAddr = GetExpression(buffer)) == 0) {
dprintf("Error retrieving address of bus number list for interface %d\n", Iface);
continue;
}
if (GetFieldValue(listHeadAddr, listEntryType, "Flink", head_Flink) ||
GetFieldValue(listHeadAddr, listEntryType, "Blink", head_Blink)) {
dprintf("Error reading value of bus number list head (0x%08p) for interface %d\n", listHeadAddr, Iface);
continue;
}
if (head_Flink == listHeadAddr) {
continue;
}
for ( legacyBusEntryAddr = head_Flink;
legacyBusEntryAddr != listHeadAddr;
legacyBusEntryAddr = link_Flink) {
deviceNode = legacyBusEntryAddr - deviceNodeOffset;
if (GetFieldValue(deviceNode, deviceNodeType, "BusNumber", busNumber)) {
dprintf("Error reading BusNumber from (0x%08p)\n", deviceNode);
break;
}
if (GetFieldValue(deviceNode, deviceNodeType, "InstancePath.Length", instancePath_Len)) {
dprintf("Error reading InstancePath.Length from (0x%08p)\n", deviceNode);
break;
}
if (GetFieldValue(deviceNode, deviceNodeType, "InstancePath.MaximumLength", instancePath_Max)) {
dprintf("Error reading InstancePath.MaximumLength from (0x%08p)\n", deviceNode);
break;
}
if (GetFieldValue(deviceNode, deviceNodeType, "InstancePath.Buffer", instancePath_Buff)) {
dprintf("Error reading InstancePath.Buffer from (0x%08p)\n", deviceNode);
break;
}
if (instancePath_Buff != 0) {
UNICODE_STRING64 v;
switch (Iface) {
case InterfaceTypeUndefined: dprintf("InterfaceTypeUndefined"); break;
case Internal: dprintf("Internal"); break;
case Isa: dprintf("Isa"); break;
case Eisa: dprintf("Eisa"); break;
case MicroChannel: dprintf("Micro Channel"); break;
case TurboChannel: dprintf("Turbo Channel"); break;
case PCIBus: dprintf("PCI"); break;
case VMEBus: dprintf("VME"); break;
case NuBus: dprintf("NuBus"); break;
case PCMCIABus: dprintf("PCMCIA"); break;
case CBus: dprintf("CBus"); break;
case MPIBus: dprintf("MPIBus"); break;
case MPSABus: dprintf("MPSABus"); break;
case ProcessorInternal: dprintf("Processor Internal"); break;
case InternalPowerBus: dprintf("Internal Power Bus"); break;
case PNPISABus: dprintf("PnP Isa"); break;
case PNPBus: dprintf("PnP Bus"); break;
default: dprintf("** Unknown Interface Type **"); break;
}
dprintf("%d - !devnode 0x%08p\n", busNumber, deviceNode);
v.Buffer = instancePath_Buff;
v.Length = instancePath_Len;
v.MaximumLength = instancePath_Max;
dprintf("\t\""); DumpUnicode64(v); dprintf("\"\n");
}
if (GetFieldValue(legacyBusEntryAddr, listEntryType, "Flink", link_Flink)) {
dprintf("Error reading Flink from (0x%08p)\n", legacyBusEntryAddr);
break;
}
}
}
return S_OK;
}