able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/tools/kdexts2/power.c

1257 lines
34 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1992-2000 Microsoft Corporation
Module Name:
power.c
Abstract:
WinDbg Extension Api
Revision History:
--*/
// podev - dump power relevent data (and other data) about a device object
// polist [arg] - if no arg, dump data about powerirpseriallist
// if arg, show entries in serialist that refer to that device object
// podevnode - dump inverted tree and inclusion %
// podevnode <any> - dump normal pnp tree, used only for testing with inverted tree
// postate - dump state statistics
#include "precomp.h"
#pragma hdrstop
VOID
popDumpDeviceName(
ULONG64 DeviceAddress
);
__inline
ULONG64
GetAddress(
IN ULONG64 Base,
IN PCHAR Type,
IN PCHAR Field)
{
ULONG Offset;
GetFieldOffset(Type, Field, &Offset);
return(Base + Offset);
}
typedef struct {
ULONG Flags;
PUCHAR String;
} DEFBITS, *PDEFBITS;
DEFBITS ActFlags[] = {
POWER_ACTION_QUERY_ALLOWED, "QueryApps",
POWER_ACTION_UI_ALLOWED, "UIAllowed",
POWER_ACTION_OVERRIDE_APPS, "OverrideApps",
POWER_ACTION_DISABLE_WAKES, "DisableWakes",
POWER_ACTION_CRITICAL, "Critical",
0, NULL
};
PUCHAR rgPowerNotifyOrder[PO_ORDER_MAXIMUM+1] = {
"Non-Paged, PnP, Video",
"Non-Paged, PnP",
"Non-Paged, Root-Enum, Video",
"Non-Paged, Root-Enum",
"Paged, PnP, Video",
"Paged, PnP",
"Paged, Root-Enum, Video",
"Paged, Root-Enum"
};
static UCHAR Buffer[50];
VOID
poDumpDevice(
ULONG64 DeviceAddress
);
DECLARE_API( podev )
/*++
Routine Description:
Dump the power relevent fields of a device object.
Arguments:
args - the location of the device object of interest
Return Value:
None
--*/
{
ULONG64 deviceToDump;
deviceToDump = GetExpression(args);
dprintf("Device object is for:\n");
poDumpDevice(deviceToDump);
return S_OK;
}
VOID
poDumpDevice(
ULONG64 DeviceAddress
)
/*++
Routine Description:
Displays the driver name for the device object if possible, and
then displays power relevent fields.
Arguments:
DeviceAddress - address of device object to dump.
Return Value:
None
--*/
{
ULONG result;
ULONG i;
PUCHAR buffer;
UNICODE_STRING unicodeString;
ULONG64 nextEntry;
ULONG64 queueAddress;
ULONG64 irp;
ULONG64 pObjectHeader;
ULONG64 pNameInfo;
ULONG rmr;
ULONG Type;
ULONG Flags;
ULONG64 Temp, DeviceObjectExtension, Dope;
USHORT Length;
if (GetFieldValue(DeviceAddress,
"nt!_DEVICE_OBJECT",
"Type",
Type)) {
dprintf("%08p: Could not read device object\n", DeviceAddress);
return;
}
if (Type != IO_TYPE_DEVICE) {
dprintf("%08p: is not a device object\n", DeviceAddress);
return;
}
//
// Dump the device name if present.
//
pObjectHeader = KD_OBJECT_TO_OBJECT_HEADER(DeviceAddress);
if (GetFieldValue(pObjectHeader,
"nt!_OBJECT_HEADER",
"Type",
Temp)) {
USHORT Length;
ULONG64 pName;
KD_OBJECT_HEADER_TO_NAME_INFO( pObjectHeader, &pNameInfo );
if (GetFieldValue(pNameInfo,
"nt!_OBJECT_HEADER_NAME_INFO",
"Name.Length",
Length)) {
buffer = LocalAlloc(LPTR, Length);
if (buffer != NULL) {
unicodeString.MaximumLength = Length;
unicodeString.Length = Length;
unicodeString.Buffer = (PWSTR)buffer;
GetFieldValue(pNameInfo,
"nt!_OBJECT_HEADER_NAME_INFO",
"Name.Buffer",
pName);
if (ReadMemory(pName,
buffer,
unicodeString.Length,
&result) && (result == unicodeString.Length)) {
dprintf(" %wZ", &unicodeString);
}
LocalFree(buffer);
}
}
}
//
// Dump Irps related to driver.
//
InitTypeRead(DeviceAddress, nt!_DEVICE_OBJECT);
dprintf(" DriverObject %08lx\n", ReadField(DriverObject));
dprintf("Current Irp %08lx RefCount %d Type %08lx ",
ReadField(CurrentIrp),
ReadField(ReferenceCount),
ReadField(DeviceType));
if (ReadField(AttachedDevice)) {
dprintf("AttachedDev %08p ", ReadField(AttachedDevice));
}
if (ReadField(Vpb)) {
dprintf("Vpb %08p ", ReadField(Vpb));
}
dprintf("DevFlags %08lx", (Flags = (ULONG) ReadField(Flags)));
if (Flags & DO_POWER_PAGABLE) dprintf(" DO_POWER_PAGABLE");
if (Flags & DO_POWER_INRUSH) dprintf(" DO_POWER_INRUSH");
if (Flags & DO_POWER_NOOP) dprintf(" DO_POWER_NOOP");
dprintf("\n");
DeviceObjectExtension = ReadField(DeviceObjectExtension);
if (ReadField(DeviceQueue.Busy)) {
ULONG Off;
GetFieldOffset("nt!_DEVICE_OBJECT", "DeviceQueue.DeviceListHead", &Off);
nextEntry = ReadField(DeviceQueue.DeviceListHead.Flink);
if (nextEntry == DeviceAddress + Off) {
dprintf("Device queue is busy -- Queue empty\n");
} else {
ULONG Qoffset, IrpOffset;
dprintf("DeviceQueue: ");
i = 0;
GetFieldOffset("nt!_DEVICE_OBJECT", "DeviceListEntry", &Qoffset);
GetFieldOffset("nt!_IRP", "Tail.Overlay.DeviceQueueEntry", &IrpOffset);
while ( nextEntry != ( DeviceAddress + Off )) {
queueAddress = (nextEntry - Qoffset);
if (GetFieldValue(queueAddress,
"nt!_KDEVICE_QUEUE_ENTRY",
"DeviceListEntry.Flink",
nextEntry)) {
dprintf("%08p: Could not read queue entry\n", DeviceAddress);
return;
}
// nextEntry = queueEntry.DeviceListEntry.Flink;
irp = (queueAddress - IrpOffset);
dprintf("%08p%s",
irp,
(i & 0x03) == 0x03 ? "\n\t " : " ");
if (CheckControlC()) {
break;
}
}
dprintf("\n");
}
} else {
dprintf("Device queue is not busy.\n");
}
dprintf("Device Object Extension: %08p:\n", DeviceObjectExtension);
if (GetFieldValue(DeviceObjectExtension,
"nt!_DEVOBJ_EXTENSION",
"PowerFlags",
Flags)) {
dprintf("Could not read Device Object Extension %p\n", DeviceObjectExtension);
return;
}
dprintf("PowerFlags: %08lx =>", Flags);
#define PopGetDoSystemPowerState(Flags) \
(Flags & POPF_SYSTEM_STATE)
#define PopGetDoDevicePowerState(Flags) \
((Flags & POPF_DEVICE_STATE) >> 4)
dprintf("SystemState=%1x", PopGetDoSystemPowerState(Flags) );
dprintf(" DeviceState=%lx", PopGetDoDevicePowerState(Flags) );
if (Flags & POPF_SYSTEM_ACTIVE) dprintf(" syact");
if (Flags & POPF_SYSTEM_PENDING) dprintf(" sypnd");
if (Flags & POPF_DEVICE_ACTIVE) dprintf(" dvact");
if (Flags & POPF_DEVICE_PENDING) dprintf(" dvpnd");
GetFieldValue(DeviceObjectExtension,"nt!_DEVOBJ_EXTENSION","Dope",Dope);
dprintf("\nDope: %08lx:\n", Dope);
if (Dope != 0) {
rmr = GetFieldValue(Dope, "nt!_DEVICE_OBJECT_POWER_EXTENSION",
"DeviceType", Type);
if (!rmr) {
InitTypeRead(Dope, nt!_DEVICE_OBJECT_POWER_EXTENSION);
dprintf("IdleCount: %08p ConIdlTime: %08p PerfIdlTime: %08p\n",
ReadField(IdleCount), ReadField(ConservationIdleTime), ReadField(PerformanceIdleTime));
dprintf("NotifySourceList fl:%08p bl:%08p\n",
ReadField(NotifySourceList.Flink), ReadField(NotifySourceList.Blink));
dprintf("NotifyTargetList fl:%08p bl:%08p\n",
ReadField(NotifyTargetList.Flink), ReadField(NotifyTargetList.Blink));
dprintf("PowerChannelSummary TotalCount: %08p D0Count: %08p\n",
ReadField(PowerChannelSummary.TotalCount), ReadField(PowerChannelSummary.D0Count));
dprintf("PowerChannelSummary NotifyList fl:%08p bl:%08p\n",
ReadField(PowerChannelSummary.NotifyList.Flink),
ReadField(PowerChannelSummary.NotifyList.Blink)
);
}
}
return;
}
VOID
poDumpList(
ULONG64 DeviceAddress
);
DECLARE_API( polist )
/*++
Routine Description:
Dump the irp serial list, unless a devobj address is given,
in which case dump the irps in the serial list that point to
that device object
Arguments:
args - the location of the device object of interest
Return Value:
None
--*/
{
ULONG64 deviceToDump;
deviceToDump = 0;
deviceToDump = GetExpression(args);
if (deviceToDump == 0) {
dprintf("All entries in Power Irp Serial List\n");
} else {
dprintf("Entries in Power Irp Serial List for: %08p:\n", deviceToDump);
}
if (!IsPtr64()) {
deviceToDump = (ULONG64) (LONG64) (LONG) deviceToDump;
}
poDumpList(deviceToDump);
return S_OK;
}
VOID
poDumpList(
ULONG64 DeviceAddress
)
/*++
Routine Description:
Arguments:
DeviceAddress - address of device object to dump.
Return Value:
None
--*/
{
ULONG64 listhead, irpa, iosla, p;
ULONG isll, result;
ULONG IrpOffset;
isll = GetUlongValue("nt!PopIrpSerialListLength");
dprintf("PopIrpSerialListLength = %d\n", isll);
listhead = GetExpression("nt!PopIrpSerialList");
GetFieldOffset("nt!_IRP", "Tail.Overlay.DeviceQueueEntry", &IrpOffset);
for (p = GetPointerFromAddress( listhead );
p != listhead;
p = GetPointerFromAddress( p))
{
ULONG64 DeviceObject, CurrentStackLocation;
irpa = p - IrpOffset;
if (GetFieldValue(irpa, "nt!_IRP", "Tail.Overlay.CurrentStackLocation", CurrentStackLocation))
{
dprintf("Cannot read Irp: %08p\n", irpa);
return;
}
iosla = CurrentStackLocation + DBG_PTR_SIZE;
if (GetFieldValue(iosla, "nt!_IO_STACK_LOCATION", "DeviceObject", DeviceObject) )
{
dprintf("Cannot read Io Stk Loc: %08p\n", iosla);
return;
}
InitTypeRead(iosla, nt!_IO_STACK_LOCATION);
if ((DeviceAddress == 0) || (DeviceAddress == DeviceObject)) {
dprintf("Irp:%08p DevObj:%08p ", irpa, DeviceObject);
dprintf("Ctx:%08p ", ReadField(Parameters.Power.SystemContext));
if (ReadField(Parameters.Power.SystemContext) & POP_INRUSH_CONTEXT) {
dprintf("inrush ");
} else {
dprintf(" ");
}
if (ReadField(Parameters.Power.Type) == SystemPowerState) {
dprintf("sysirp ");
dprintf("S%d\n", (LONG)(ReadField(Parameters.Power.State.SystemState)) - (LONG)PowerSystemWorking);
} else {
dprintf("devirp ");
dprintf("D%d\n", (LONG)(ReadField(Parameters.Power.State.DeviceState)) - (LONG)PowerDeviceD0);
}
}
}
return;
}
VOID
poDumpRequestedList(
ULONG64 DeviceAddress
);
DECLARE_API( poreqlist )
/*++
Routine Description:
Dump the irp serial list, unless a devobj address is given,
in which case dump the irps in the serial list that point to
that device object
Arguments:
args - the location of the device object of interest
Return Value:
None
--*/
{
ULONG64 deviceToDump;
deviceToDump = GetExpression(args);
if (deviceToDump == 0) {
dprintf("All active Power Irps from PoRequestPowerIrp\n");
} else {
dprintf("Active Power Irps from PoRequestPowerIrp for: %08p:\n",
deviceToDump);
}
poDumpRequestedList(deviceToDump);
return S_OK;
}
VOID
poDumpRequestedList (
ULONG64 DeviceAddress
)
/*++
Routine Description:
Dump PopRequestedIrps List, "A list of all the power irps created from
PoReqestPowerIrp.
Arguments:
DeviceAddress - optional address to which requested power IRPs were sent
--*/
{
BOOL blocked = FALSE;
ULONG64 listhead;
ULONG64 p, spAddr, irpAddr;
ULONG result;
ULONG Off;
dprintf("PopReqestedPowerIrpList\n");
listhead = GetExpression("nt!PopRequestedIrps");
GetFieldOffset("nt!_IO_STACK_LOCATION", "Parameters.Others.Argument1", &Off);
dprintf("FieldOffset = %p\n",Off);
for (p = GetPointerFromAddress( listhead );
p != listhead;
p = GetPointerFromAddress( p ))
{
ULONG64 CurrentStackLocation;
ULONG MajorFunction;
//
// Reguested list is a double list of stack locations
//
spAddr = p - Off;
if (GetFieldValue(spAddr, "nt!_IO_STACK_LOCATION",
"Parameters.Others.Argument3", irpAddr)) {
dprintf("Cannot read 1st stack Location: %08p\n", spAddr);
return;
}
//
// The 3rd argument of which has the pointer to the irp itself
//
if (GetFieldValue(irpAddr, "nt!_IRP", "Tail.Overlay.CurrentStackLocation", CurrentStackLocation))
{
dprintf("Cannot read Irp: %08p\n", irpAddr);
return;
}
dprintf ("Irp %08p ", irpAddr);
//
// Assume the if the IRP is in this list that it has a valid
// current stack location
//
spAddr = CurrentStackLocation;
if (GetFieldValue(spAddr, "nt!_IO_STACK_LOCATION", "MajorFunction", MajorFunction) )
{
dprintf("Cannot read current stack location: %08p\n", spAddr);
return;
}
//
// Check to see if the irp is blocked
//
blocked = FALSE;
if (MajorFunction != IRP_MJ_POWER) {
//
// Irp is blocked. The next stack location is the real one
//
blocked = TRUE;
spAddr = CurrentStackLocation + DBG_PTR_SIZE;
if (GetFieldValue(spAddr, "nt!_IO_STACK_LOCATION", "MajorFunction", MajorFunction) )
{
dprintf("Cannot read current stack location: %08p\n", spAddr);
return;
}
}
if ((DeviceAddress == 0) || (DeviceAddress == ReadField(DeviceObject))) {
ULONG MinorFunction = 0;
ULONG64 DeviceObject = 0;
ULONG64 SystemContext = 0;
ULONG64 Temp = 0;
UCHAR IOStack[] = "nt!_IO_STACK_LOCATION";
GetFieldValue(spAddr,IOStack, "DeviceObject", DeviceObject);
GetFieldValue(spAddr,IOStack, "Parameters.Power.SystemContext", SystemContext);
GetFieldValue(spAddr,IOStack, "MinorFunction", MinorFunction);
dprintf("DevObj %08p", DeviceObject);
DumpDevice(DeviceObject,0, FALSE);
dprintf(" Ctx %08p ", SystemContext);
if ((SystemContext & POP_INRUSH_CONTEXT) == POP_INRUSH_CONTEXT) {
dprintf("* ");
} else {
dprintf(" ");
}
switch (MinorFunction) {
case IRP_MN_QUERY_POWER:
dprintf ("Query Power ");
goto PoDumpRequestedListPowerPrint;
case IRP_MN_SET_POWER:
dprintf ("Set Power ");
PoDumpRequestedListPowerPrint:
GetFieldValue(spAddr, IOStack, "Parameters.Power.Type",Temp);
if ((ULONG) Temp == SystemPowerState) {
GetFieldValue(spAddr, IOStack, "Parameters.Power.State.SystemState", Temp);
dprintf("S%d ", (LONG)Temp - (LONG)PowerSystemWorking);
} else {
GetFieldValue(spAddr, IOStack, "Parameters.Power.State.DeviceState", Temp);
dprintf("D%d ", (LONG)Temp - (LONG)PowerDeviceD0);
}
GetFieldValue(spAddr,IOStack,"Parameters.Power.ShutdownType", Temp);
dprintf ("ShutdownType %x", (LONG) Temp);
break;
case IRP_MN_WAIT_WAKE:
GetFieldValue(spAddr, IOStack, "Parameters.WaitWake.PowerState", Temp);
dprintf ("Wait Wake S%d", (LONG)Temp - (LONG)PowerSystemWorking);
break;
case IRP_MN_POWER_SEQUENCE:
dprintf ("Power Sequence Irp");
break;
}
if (blocked) {
dprintf(" [blocked]");
}
dprintf("\n");
}
}
return;
}
VOID poDumpNodePower();
DECLARE_API( ponode )
/*++
Routine Description:
If an argument is present, dump the devnode list in pnp order.
(used only for testing)
Otherwise dump the devnode inverted stack.
(po enumeration order)
Arguments:
args - flag
Return Value:
None
--*/
{
ULONG flag;
dprintf("Dump Inverted DevNode Tree (power order)\n");
poDumpNodePower();
return S_OK;
}
VOID
poDumpNodePower(
)
/*++
Routine Description:
Dump the devnode tree in power order.
Arguments:
Return Value:
None
--*/
{
#if 0
LONG level, SizeOfLE, LevelOff, pdo_off;
ULONG64 parray, listhead, effaddr, pdo, devNodeAddr, limit;
level = GetUlongValue("nt!IopMaxDeviceNodeLevel");
parray = GetExpression("nt!IopDeviceNodeStack");
dprintf("Max level = %5d\n", level);
dprintf("IopDeviceNodeStack %08p\n", parray);
parray = GetPointerFromAddress(parray);
dprintf("*IopDeviceNodeStack %08p\n", parray);
dprintf("Level ListHead DevNode PDO\n");
dprintf("----- -------- -------- --------\n");
SizeOfLE = GetTypeSize("nt!_LIST_ENTRY");
GetFieldOffset("nt!_DEVICE_NODE", "LevelList", &LevelOff);
GetFieldOffset("nt!_DEVICE_NODE", "PhysicalDeviceObject", &pdo_off);
for ( ; level >= 0; level--) {
effaddr = (level * SizeOfLE) + parray;
listhead = GetPointerFromAddress( effaddr);
dprintf("%5d %08lx\n", level, listhead);
if (listhead) {
limit = 0;
for (effaddr = GetPointerFromAddress(listhead);
effaddr != listhead;
effaddr = GetPointerFromAddress(effaddr))
{
devNodeAddr = (effaddr - LevelOff);
pdo = GetPointerFromAddress((devNodeAddr+pdo_off));
dprintf(" %08p %08p ", devNodeAddr, pdo);
popDumpDeviceName(pdo);
dprintf("\n");
}
}
}
#endif
}
VOID
popDumpDeviceName(
ULONG64 DeviceAddress
)
{
ULONG result;
PUCHAR buffer;
UNICODE_STRING unicodeString;
ULONG64 pObjectHeader;
ULONG64 pNameInfo;
ULONG Type;
ULONG Flags;
ULONG64 Temp;
USHORT Length;
if (GetFieldValue(DeviceAddress, "nt!_DEVICE_OBJECT", "Type", Type)) {
dprintf("%08p: Could not read device object\n", DeviceAddress);
return;
}
if (Type != IO_TYPE_DEVICE) {
dprintf("%08p: is not a device object\n", DeviceAddress);
return;
}
//
// Dump the device name if present.
//
pObjectHeader = KD_OBJECT_TO_OBJECT_HEADER(DeviceAddress);
if (GetFieldValue(pObjectHeader, "nt!_OBJECT_HEADER", "Type", Temp)) {
ULONG64 pName;
KD_OBJECT_HEADER_TO_NAME_INFO( pObjectHeader, &pNameInfo );
if (GetFieldValue(pNameInfo, "nt!_OBJECT_HEADER_NAME_INFO",
"Name.Length",
Length)) {
buffer = LocalAlloc(LPTR, Length);
if (buffer != NULL) {
unicodeString.MaximumLength = Length;
unicodeString.Length = Length;
unicodeString.Buffer = (PWSTR)buffer;
GetFieldValue(pNameInfo,
"nt!_OBJECT_HEADER_NAME_INFO",
"Name.Buffer",
pName);
if (ReadMemory(pName,
buffer,
unicodeString.Length,
&result) && (result == unicodeString.Length)) {
dprintf(" %wZ", &unicodeString);
}
LocalFree(buffer);
}
}
}
return;
}
PUCHAR
PowerAction(
IN POWER_ACTION Action
)
{
switch (Action) {
case PowerActionNone: return "None";
case PowerActionReserved: return "Reserved";
case PowerActionSleep: return "Sleep";
case PowerActionHibernate: return "Hibernate";
case PowerActionShutdown: return "Shutdown";
case PowerActionShutdownReset: return "ShutdownReset";
case PowerActionShutdownOff: return "ShutdownOff";
case PowerActionWarmEject: return "WarmEject";
}
return "???";
}
PUCHAR
SystemState(
SYSTEM_POWER_STATE State
)
{
switch (State) {
case PowerSystemUnspecified: return "Unspecified";
case PowerSystemWorking: return "Working";
case PowerSystemSleeping1: return "Sleeping1";
case PowerSystemSleeping2: return "Sleeping2";
case PowerSystemSleeping3: return "Sleeping3";
case PowerSystemHibernate: return "Hibernate";
case PowerSystemShutdown: return "Shutdown";
}
sprintf (Buffer, "State=%x", State);
return Buffer;
}
PUCHAR
PoIrpMinor (
UCHAR IrpMinor
)
{
switch (IrpMinor) {
case IRP_MN_QUERY_POWER: return "QueryPower";
case IRP_MN_SET_POWER: return "SetPower";
}
return "??";
}
PUCHAR
TF (
BOOLEAN Flag
)
{
switch (Flag) {
case TRUE: return "TRUE";
case FALSE: return "FALSE";
}
sprintf (Buffer, "%x", Flag);
return Buffer;
}
PWCHAR
DumpDoName (
IN ULONG64 Str
)
{
static WCHAR Name[50];
memset (Name, 0, sizeof(Name));
ReadMemory (Str, Name, sizeof(Name), NULL);
Name[sizeof(Name)-1] = 0;
return Name;
}
PUCHAR
DumpQueueHead (
IN ULONG64 StrucAddr,
IN ULONG64 Struc,
IN ULONG Offset
)
{
ULONG64 Head, Flink, Blink;
ULONG64 Va;
Head = Struc + Offset;
Va = StrucAddr + Offset;
GetFieldValue(Head, "nt!_LIST_ENTRY", "Flink", Flink);
GetFieldValue(Head, "nt!_LIST_ENTRY", "Blink", Blink);
if (Flink == Va && Blink == Va) {
sprintf (Buffer, "Head:%08p Empty", Va);
} else {
sprintf (Buffer, "Head:%08p F:%08p B:%08p", Va, Flink, Blink);
}
return Buffer;
}
VOID
DumpDevicePowerIrp (
IN PUCHAR Desc,
IN ULONG64 StrucAddr,
IN ULONG64 Head,
IN ULONG Offset
)
{
ULONG64 Va;
ULONG64 Link;
ULONG64 Addr;
ULONG Off;
GetFieldOffset("nt!_POP_DEVICE_SYS_STATE", "Head", &Off);
Va = (StrucAddr + Off + Offset);
Link = GetPointerFromAddress(Head + Offset);
if (Link == Va) {
return ;
}
dprintf ("\n%s:\n", Desc);
while (Link != Va) {
ULONG64 Irp, Notify;
Addr = Link - Offset;
if (GetFieldValue(Addr, "nt!_POP_DEVICE_POWER_IRP", "Irp", Irp)) {
dprintf ("Could not power irp\n");
break;
}
GetFieldValue(Addr, "nt!_POP_DEVICE_SYS_STATE", "Notify", Notify);
dprintf (" Irp: %08p Notify %08p\n", Irp, Notify);
Link = GetPointerFromAddress(Addr + Offset);
}
}
VOID
poDumpOldNotifyList(
VOID
)
{
BOOLEAN GdiOff;
UCHAR LastOrder;
ULONG PartOffset, NoLists, SizeOfLE, Off, HeadOff;
ULONG64 DevState, Notify;
LONG i;
ULONG64 ListHead;
ULONG64 Link;
dprintf(" NoLists........: %p\n", (NoLists = (ULONG) ReadField(Order.NoLists)));
SizeOfLE = GetTypeSize("nt!_LIST_ENTRY");
GdiOff = FALSE;
LastOrder = 0xff;
Notify = ReadField(Order.Notify);
for (i=NoLists-1; i >= 0; i--) {
ListHead = Notify + i*SizeOfLE;
if (GetFieldValue(ListHead, "nt!_LIST_ENTRY", "Flink", Link)) {
dprintf ("Could not read list head\n");
break;
}
while (Link != ListHead) {
UCHAR OrderLevel;
if (GetFieldValue(Link, "nt!_PO_DEVICE_NOTIFY", "OrderLevel", OrderLevel)) {
dprintf ("Could not read link\n");
break;
}
if (LastOrder != OrderLevel) {
LastOrder = OrderLevel;
dprintf (" %x %s",
LastOrder,
LastOrder <= PO_ORDER_MAXIMUM ? rgPowerNotifyOrder[LastOrder] : ""
);
if (!GdiOff && OrderLevel <= PO_ORDER_GDI_NOTIFICATION) {
GdiOff = TRUE;
dprintf (", GdiOff\n");
} else {
dprintf ("\n");
}
}
InitTypeRead(Link, nt!_PO_DEVICE_NOTIFY);
dprintf (" %02x %x:%x %08x %c",
i,
OrderLevel,
(ULONG) ReadField(NodeLevel),
Link,
((UCHAR) ReadField(WakeNeeded) ? 'w' : ' ')
);
dprintf (" %ws\t", DumpDoName (ReadField(DriverName)));
dprintf (" %ws\n", DumpDoName (ReadField(DeviceName)));
Link = ReadField(Link.Flink);
if (CheckControlC()) {
return;
}
}
}
}
ULONG
DumpNotifyCallback(
PFIELD_INFO pAddrInfo,
PVOID Context
)
{
if (CheckControlC()) {return 0;}
InitTypeRead(pAddrInfo->address, nt!_PO_DEVICE_NOTIFY);
dprintf(" %c %08p: %08p %ws\t",
ReadField(WakeNeeded) ? 'w' : ' ',
pAddrInfo->address,
ReadField(Node),
DumpDoName(ReadField(DriverName)));
dprintf("%ws\n",DumpDoName(ReadField(DeviceName)));
return(0);
}
VOID
poDumpNewNotifyList(
IN ULONG64 DevState
)
{
BOOLEAN GdiOff;
UCHAR LastOrder;
ULONG PartOffset, NoLists, SizeOfLE, Off, HeadOff;
ULONG64 Level, Notify;
LONG i,j;
ULONG64 ListHead;
ULONG64 Link;
ULONG LevelOffset;
ULONG SizeOfLevel;
CHAR FlinkBuff[32];
PCHAR NotifyList[] = {"WaitSleep",
"ReadySleep",
"Pending",
"Complete",
"ReadyS0",
"WaitS0"};
SizeOfLevel = GetTypeSize("nt!_PO_NOTIFY_ORDER_LEVEL");
GdiOff = FALSE;
if (GetFieldOffset("nt!_POP_DEVICE_SYS_STATE",
"Order.OrderLevel",
&LevelOffset)) {
dprintf("Couldn't get field offset for Order.OrderLevel.");
return;
}
for (i=PO_ORDER_MAXIMUM;i>=0;i--) {
if (CheckControlC()) {return;}
Level = DevState + LevelOffset + i*SizeOfLevel;
InitTypeRead(Level, nt!_PO_NOTIFY_ORDER_LEVEL);
if (ReadField(DeviceCount)) {
dprintf("Level %d (%08p) %d/%d\t%s\n",
i,
Level,
(ULONG)ReadField(ActiveCount),
(ULONG)ReadField(DeviceCount),
rgPowerNotifyOrder[i]);
for (j=0;j<sizeof(NotifyList)/sizeof(PCHAR);j++) {
if (CheckControlC()) {return;}
sprintf(FlinkBuff, "%s.Flink",NotifyList[j]);
if (GetFieldValue(Level,
"nt!_PO_NOTIFY_ORDER_LEVEL",
FlinkBuff,
Link)) {
dprintf("couldn't get field value for PO_NOTIFY_ORDER_LEVEL.%s\n",FlinkBuff);
return;
}
if (Link != GetAddress(Level, "nt!_PO_NOTIFY_ORDER_LEVEL", FlinkBuff)) {
dprintf(" %s:\n",NotifyList[j]);
ListType("_PO_DEVICE_NOTIFY",
Link,
1,
"Link.Flink",
NULL,
DumpNotifyCallback);
}
}
}
}
}
VOID
PoDevState (
VOID
)
/*++
Routine Description:
Dumps the current power action structure
Arguments:
args - the location of the device object of interest
Return Value:
None
--*/
{
ULONG64 addr;
LONG i;
ULONG64 ListHead;
ULONG64 Link;
ULONG64 DevState, Notify;
BOOLEAN GdiOff;
UCHAR IrpMinor;
ULONG PartOffset, NoLists, SizeOfLE, Off, HeadOff;
addr = GetExpression( "nt!PopAction" );
if (!addr) {
dprintf("Error retrieving address of PopAction\n");
return;
}
if (GetFieldValue(addr, "nt!POP_POWER_ACTION", "DevState", DevState)) {
dprintf("Error reading PopAction\n");
return;
}
if (!DevState) {
dprintf("No Device State allocated on PopAction\n");
return;
}
if (GetFieldValue(DevState, "nt!_POP_DEVICE_SYS_STATE", "IrpMinor", IrpMinor)) {
dprintf("Error reading device state structure\n");
return;
}
GetFieldOffset("nt!_POP_DEVICE_SYS_STATE","PresentIrpQueue", &Off);
InitTypeRead(DevState, nt!_POP_DEVICE_SYS_STATE);
dprintf ("PopAction.DevState %08x\n", DevState);
dprintf(" Irp minor......: %s\n", PoIrpMinor (IrpMinor));
dprintf(" System State...: %s\n", SystemState((ULONG) ReadField(SystemState)));
dprintf(" Worker thread..: %08p\n", ReadField(Thread));
dprintf(" Status.........: %x\n", (ULONG) ReadField(Status));
dprintf(" Waking.........: %s\n", TF (((UCHAR) ReadField(Waking))) );
dprintf(" Cancelled......: %s\n", TF (((UCHAR) ReadField(Cancelled))) );
dprintf(" Ignore errors..: %s\n", TF (((UCHAR) ReadField(IgnoreErrors))) );
dprintf(" Ignore not imp.: %s\n", TF (((UCHAR) ReadField(IgnoreNotImplemented))) );
dprintf(" Wait any.......: %s\n", TF (((UCHAR) ReadField(WaitAny))) );
dprintf(" Wait all.......: %s\n", TF (((UCHAR) ReadField(WaitAll))) );
dprintf(" Present Irp Q..: %s\n",
DumpQueueHead (DevState, DevState, Off)
);
dprintf("\n");
dprintf("Order:\n");
dprintf(" DevNode Seq....: %x\n", (ULONG) ReadField(Order.DevNodeSequence));
if (ReadField(Order.NoLists)) {
poDumpOldNotifyList();
} else {
poDumpNewNotifyList(DevState);
}
//
// Dump device notification list order
//
//
// Dump device power irps
//
GetFieldOffset("nt!_POP_DEVICE_SYS_STATE","Head", &HeadOff);
GetFieldOffset("nt!_POP_DEVICE_POWER_IRP", "Pending", &Off);
DumpDevicePowerIrp ("Pending irps", DevState, DevState+HeadOff, Off);
GetFieldOffset("nt!_POP_DEVICE_POWER_IRP", "Complete", &Off);
DumpDevicePowerIrp ("Completed irps", DevState, DevState+HeadOff, Off);
GetFieldOffset("nt!_POP_DEVICE_POWER_IRP", "Abort", &Off);
DumpDevicePowerIrp ("Abort irps", DevState, DevState+HeadOff, Off);
GetFieldOffset("nt!_POP_DEVICE_POWER_IRP", "Failed", &Off);
DumpDevicePowerIrp ("Failed irps", DevState, DevState+HeadOff, Off);
dprintf("\n");
}
DECLARE_API( poaction )
/*++
Routine Description:
Dumps the current power action structure
Arguments:
args - the location of the device object of interest
Return Value:
None
--*/
{
ULONG64 addr;
ULONG i;
UCHAR c, State, Updates;
ULONG Flags;
addr = GetExpression( "nt!PopAction" );
if (!addr) {
dprintf("Error retrieving address of PopAction\n");
return E_INVALIDARG;
}
if (GetFieldValue(addr, "nt!POP_POWER_ACTION", "State", State)) {
dprintf("Error reading PopAction\n");
return E_INVALIDARG;
}
InitTypeRead(addr, nt!POP_POWER_ACTION);
dprintf("PopAction: %08x\n", addr);
dprintf(" State..........: %x ", State);
switch (State) {
case PO_ACT_IDLE: dprintf ("- Idle\n"); break;
case PO_ACT_NEW_REQUEST: dprintf ("- New request\n"); break;
case PO_ACT_CALLOUT: dprintf ("- Winlogon callout\n"); break;
case PO_ACT_SET_SYSTEM_STATE: dprintf ("- Set System State\n"); break;
default: dprintf ("\n"); break;
}
dprintf(" Updates........: %x ", (Updates = (UCHAR) ReadField(Updates)));
if (Updates & PO_PM_USER) dprintf(" user ");
if (Updates & PO_PM_REISSUE) dprintf(" reissue ");
if (Updates & PO_PM_SETSTATE) dprintf(" setstate ");
if (ReadField(Shutdown)) dprintf(" SHUTDOWN-set ");
dprintf("\n");
dprintf(" Action.........: %s\n", PowerAction((ULONG) ReadField(Action)));
dprintf(" Lightest State.: %s\n", SystemState((ULONG) ReadField(LightestState)));
dprintf(" Flags..........: %x", (Flags = (ULONG) ReadField(Flags)));
c = ' ';
for (i=0; ActFlags[i].Flags; i++) {
if (Flags & ActFlags[i].Flags) {
dprintf ("%c%s", c, ActFlags[i].String);
c = '|';
}
}
dprintf("\n");
dprintf(" Irp minor......: %s\n", PoIrpMinor ((UCHAR)ReadField(IrpMinor)));
dprintf(" System State...: %s\n", SystemState((ULONG) ReadField(SystemState)));
dprintf(" Hiber Context..: %08p\n", ReadField(HiberContext));
if (ReadField(DevState)) {
dprintf ("\n");
PoDevState ();
}
dprintf("\n");
return S_OK;
}
Reference in a new issue Copy permalink