pnppower.c File Reference

#include "iop.h"

Go to the source code of this file.

Functions
PWCHAR	IopCaptureObjectName (IN PVOID Object)
VOID	IopFreePoDeviceNotifyListHead (PLIST_ENTRY ListHead)
NTSTATUS	IoBuildPoDeviceNotifyList (IN OUT PPO_DEVICE_NOTIFY_ORDER Order)
VOID	IoFreePoDeviceNotifyList (IN OUT PPO_DEVICE_NOTIFY_ORDER Order)
NTSTATUS	IopWarmEjectDevice (IN PDEVICE_OBJECT DeviceToEject, IN SYSTEM_POWER_STATE LightestSleepState)

---

Function Documentation

NTSTATUS IoBuildPoDeviceNotifyList (  IN OUT PPO_DEVICE_NOTIFY_ORDER  Order  )

Definition at line 48 of file pnppower.c. References ASSERT, _DEVICE_NODE::Child, _PO_DEVICE_NOTIFY::DeviceName, _PO_DEVICE_NOTIFY::DeviceObject, _DEVICE_OBJECT::DeviceType, DNF_HAL_NODE, DO_POWER_PAGABLE, _PO_DEVICE_NOTIFY::DriverName, _DEVICE_OBJECT::DriverObject, ExAllocatePoolWithTag, _DEVICE_NODE::Flags, _DEVICE_OBJECT::Flags, _DEVICE_NODE::InterfaceType, IoDeviceNodeTreeSequence, IoGetAttachedDevice(), IOP_DPWR_TAG, IopAcquireDeviceTreeLock, IopCaptureObjectName(), IopRootDeviceNode, IopWarmEjectPdo, KeBugCheckEx(), _PO_DEVICE_NOTIFY::Link, _PO_DEVICE_NOTIFY::Node, _PO_DEVICE_NOTIFY::NodeLevel, NonPagedPool, _DEVICE_NODE::Notify, NULL, ObReferenceObject, _PO_DEVICE_NOTIFY::OrderLevel, _DEVICE_NODE::Parent, _DEVICE_NODE::PhysicalDeviceObject, PO_DEVICE_NOTIFY, PO_ORDER_MAXIMUM, PO_ORDER_NOT_VIDEO, PO_ORDER_PAGABLE, PO_ORDER_ROOT_ENUM, PPO_DEVICE_NOTIFY, PPO_DEVICE_NOTIFY_ORDER, _DEVICE_NODE::Sibling, and _PO_DEVICE_NOTIFY::TargetDevice. { PLIST_ENTRY link; PPO_DEVICE_NOTIFY notify; PDEVICE_NODE node; PDEVICE_NODE parent; ULONG noLists, listIndex; PLIST_ENTRY notifyLists; LONG maxLevel, level; UCHAR orderLevel; PDEVICE_OBJECT nonPaged; // // Acquire device node lock // IopAcquireDeviceTreeLock(); RtlZeroMemory (Order, sizeof (*Order)); Order->DevNodeSequence = IoDeviceNodeTreeSequence; InitializeListHead (&Order->Partial); InitializeListHead (&Order->Rebase); // // Allocate notification structures for all nodes, and determine // maximum depth. // level = -1; node = IopRootDeviceNode; while (node->Child) { node = node->Child; level += 1; } // // ADRIAO 01/12/1999 N.B. - // // Note that we include devices without the started flag. Now, we acquire // the tree lock exclusively, which prevents people from being in the middle // of a rebalance (actually it doesn't today - this is a bug!). However, two // things prevent us from excluding devices that aren't started: // 1) We must be able to send power messages to a device we are warm // undocking. // 2) Many devices may not be started, that is no guarentee they are in D3! // For example, they could easily have a boot config, and PNP still // relies heavily on BIOS boot configs to keep us from placing hardware // ontop of other devices with boot configs we haven't found or started // yet! // maxLevel = level; while (node != IopRootDeviceNode) { notify = ExAllocatePoolWithTag ( NonPagedPool, sizeof(PO_DEVICE_NOTIFY), IOP_DPWR_TAG ); if (!notify) { return STATUS_INSUFFICIENT_RESOURCES; } RtlZeroMemory (notify, sizeof(PO_DEVICE_NOTIFY)); ASSERT(node->Notify == NULL) ; node->Notify = notify; notify->Node = node; notify->DeviceObject = node->PhysicalDeviceObject; notify->TargetDevice = IoGetAttachedDevice(node->PhysicalDeviceObject); notify->DriverName = IopCaptureObjectName(notify->TargetDevice->DriverObject); notify->DeviceName = IopCaptureObjectName(notify->TargetDevice); ObReferenceObject (notify->DeviceObject); ObReferenceObject (notify->TargetDevice); orderLevel = 0; if (notify->TargetDevice->DeviceType != FILE_DEVICE_SCREEN && notify->TargetDevice->DeviceType != FILE_DEVICE_VIDEO) { orderLevel |= PO_ORDER_NOT_VIDEO; } if (notify->TargetDevice->Flags & DO_POWER_PAGABLE) { orderLevel |= PO_ORDER_PAGABLE; } notify->OrderLevel = orderLevel; notify->NodeLevel = level; // // If this is a level 0 node it's in the root. Look for // non-bus stuff in the root as those guys need to be re-based // below everything else // if (level == 0 && node->InterfaceType != Internal && !(node->Flags & DNF_HAL_NODE)) { InsertTailList (&Order->Rebase, &notify->Link); } else { InsertTailList (&Order->Partial, &notify->Link); } // // Next node // if (node->Sibling) { node = node->Sibling; while (node->Child) { node = node->Child; level += 1; if (level > maxLevel) { maxLevel = level; } } } else { node = node->Parent; level -= 1; } } // // Rebase anything on the rebase list to be after the normal pnp stuff // while (!IsListEmpty(&Order->Rebase)) { link = Order->Rebase.Flink; notify = CONTAINING_RECORD (link, PO_DEVICE_NOTIFY, Link); RemoveEntryList (&notify->Link); InsertTailList (&Order->Partial, &notify->Link); // // Rebase this node // node = notify->Node; notify->OrderLevel |= PO_ORDER_ROOT_ENUM; // // Now rebase all the node's children // parent = node; while (node->Child) { node = node->Child; } while (node != parent) { notify = node->Notify; if (notify) { notify->OrderLevel |= PO_ORDER_ROOT_ENUM; } // next node if (node->Sibling) { node = node->Sibling; while (node->Child) { node = node->Child; } } else { node = node->Parent; } } } // // Allocate ordered notifcation lists // maxLevel = maxLevel + 1; noLists = maxLevel * (PO_ORDER_MAXIMUM + 1); notifyLists = ExAllocatePoolWithTag ( NonPagedPool, sizeof(LIST_ENTRY) * noLists, IOP_DPWR_TAG ); if (!notifyLists) { return STATUS_INSUFFICIENT_RESOURCES; } for (listIndex=0; listIndex < noLists; listIndex++) { InitializeListHead (&notifyLists[listIndex]); } Order->Notify = notifyLists; Order->MaxLevel = maxLevel; Order->NoLists = noLists; // // Build ordered list // while (!IsListEmpty(&Order->Partial)) { link = Order->Partial.Flink; notify = CONTAINING_RECORD (link, PO_DEVICE_NOTIFY, Link); RemoveEntryList (&notify->Link); orderLevel = notify->OrderLevel; listIndex = orderLevel * maxLevel + notify->NodeLevel; InsertTailList (&notifyLists[listIndex], &notify->Link); // // Sanity check that the pagable bit is set the same on the top // of the PDO stack and the bottom of it // nonPaged = NULL; if (!(notify->TargetDevice->Flags & DO_POWER_PAGABLE)) { nonPaged = notify->TargetDevice; } if (nonPaged && (notify->DeviceObject->Flags & DO_POWER_PAGABLE)) { KeBugCheckEx ( DRIVER_POWER_STATE_FAILURE, 0x100, (ULONG_PTR) nonPaged, (ULONG_PTR) notify->TargetDevice, (ULONG_PTR) notify->DeviceObject ); } // // Make sure all parents are at least the level of this child // node or better // node = notify->Node; for (parent = node->Parent; parent != IopRootDeviceNode; parent = parent->Parent) { notify = parent->Notify; ASSERT (notify != NULL); if (notify->OrderLevel <= orderLevel) { break; } if (nonPaged && ( (notify->DeviceObject->Flags & DO_POWER_PAGABLE) || (notify->TargetDevice->Flags & DO_POWER_PAGABLE) )) { KeBugCheckEx ( DRIVER_POWER_STATE_FAILURE, 0x100, (ULONG_PTR) nonPaged, (ULONG_PTR) notify->TargetDevice, (ULONG_PTR) notify->DeviceObject ); } RemoveEntryList (&notify->Link); notify->OrderLevel = orderLevel; listIndex = orderLevel * maxLevel + notify->NodeLevel; InsertTailList (&notifyLists[listIndex], &notify->Link); } } Order->WarmEjectPdoPointer = &IopWarmEjectPdo; // // The device tree lock is release when the notify list is freed // return STATUS_SUCCESS; }

VOID IoFreePoDeviceNotifyList (  IN OUT PPO_DEVICE_NOTIFY_ORDER  Order  )

Definition at line 352 of file pnppower.c. References ExFreePool(), IopFreePoDeviceNotifyListHead(), IopReleaseDeviceTreeLock, and PO_DEVICE_NOTIFY_ORDER. { ULONG i; if (Order->DevNodeSequence) { // // Release the device tree lock // IopReleaseDeviceTreeLock(); Order->DevNodeSequence = 0; } // // Free the resources from the notify list // IopFreePoDeviceNotifyListHead (&Order->Partial); IopFreePoDeviceNotifyListHead (&Order->Rebase); if (Order->Notify) { for (i=0; i < Order->NoLists; i++) { IopFreePoDeviceNotifyListHead (&Order->Notify[i]); } ExFreePool (Order->Notify); } RtlZeroMemory (Order, sizeof (PO_DEVICE_NOTIFY_ORDER)); }

PWCHAR IopCaptureObjectName (  IN PVOID  Object  )

Definition at line 386 of file pnppower.c. References Buffer, ExAllocatePoolWithTag, IOP_DPWR_TAG, Name, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, ObQueryNameString(), and Status. Referenced by IoBuildPoDeviceNotifyList(). { NTSTATUS Status; UCHAR Buffer[512]; POBJECT_NAME_INFORMATION ObName; ULONG len; PWCHAR Name; ObName = (POBJECT_NAME_INFORMATION) Buffer; Status = ObQueryNameString ( Object, ObName, sizeof (Buffer), &len ); Name = NULL; if (NT_SUCCESS(Status) && ObName->Name.Buffer) { Name = ExAllocatePoolWithTag ( NonPagedPool, ObName->Name.Length + sizeof(WCHAR), IOP_DPWR_TAG ); if (Name) { memcpy (Name, ObName->Name.Buffer, ObName->Name.Length); Name[ObName->Name.Length/sizeof(WCHAR)] = 0; } } return Name; }

VOID IopFreePoDeviceNotifyListHead (  PLIST_ENTRY  ListHead  )

Definition at line 321 of file pnppower.c. References _PO_DEVICE_NOTIFY::DeviceName, _PO_DEVICE_NOTIFY::DeviceObject, _PO_DEVICE_NOTIFY::DriverName, ExFreePool(), _PO_DEVICE_NOTIFY::Link, _PO_DEVICE_NOTIFY::Node, _DEVICE_NODE::Notify, NULL, ObDereferenceObject, and _PO_DEVICE_NOTIFY::TargetDevice. Referenced by IoFreePoDeviceNotifyList(). { PLIST_ENTRY Link; PPO_DEVICE_NOTIFY Notify; PDEVICE_NODE Node; if (ListHead->Flink) { while (!IsListEmpty(ListHead)) { Link = ListHead->Flink; Notify = CONTAINING_RECORD (Link, PO_DEVICE_NOTIFY, Link); RemoveEntryList(&Notify->Link); Node = (PDEVICE_NODE) Notify->Node; Node->Notify = NULL; ObDereferenceObject (Notify->DeviceObject); ObDereferenceObject (Notify->TargetDevice); if (Notify->DeviceName) { ExFreePool (Notify->DeviceName); } if (Notify->DriverName) { ExFreePool (Notify->DriverName); } ExFreePool(Notify); } } }

NTSTATUS IopWarmEjectDevice (  IN PDEVICE_OBJECT  DeviceToEject, IN SYSTEM_POWER_STATE  LightestSleepState )

Definition at line 422 of file pnppower.c. References ASSERT, Executive, FALSE, IO_NO_INCREMENT, IoDeviceNodeTreeSequence, IopAcquireDeviceTreeLock, IopReleaseDeviceTreeLock, IopWarmEjectLock, IopWarmEjectPdo, KernelMode, KeSetEvent(), KeWaitForSingleObject(), NT_SUCCESS, NTSTATUS(), NULL, and PAGED_CODE. Referenced by IopProcessCompletedEject(). : This function is invoked to initiate a warm eject. The eject progresses from S1 to the passed in lightest sleep state. Arguments: DeviceToEject - The device to eject LightestSleepState - The lightest S state (at least S1) that the device may be ejected in. This might be S4 if we are truely low on power. Return Value: NTSTATUS value. --*/ { NTSTATUS status; PAGED_CODE(); // // Acquire the warm eject device lock. A warm eject requires we enter a // specific S-state, and two different devices may have conflicting options. // Therefore only one is allowed to occur at once. // status = KeWaitForSingleObject( &IopWarmEjectLock, Executive, KernelMode, FALSE, NULL ); ASSERT(status == STATUS_SUCCESS) ; // // Acquire device node lock. We are not allowed to set or clear this field // unless we are under this lock. // IopAcquireDeviceTreeLock(); // // Set the current Pdo to eject. // ASSERT(IopWarmEjectPdo == NULL); IopWarmEjectPdo = DeviceToEject; // // Release the tree lock. // IopReleaseDeviceTreeLock(); // // Attempt to invalidate Po's cached notification list. This should cause // IoBuildPoDeviceNotifyList to be called at which time it will in theory // pickup the above placed warm eject Pdo. // // ADRIAO NOTE 01/07/1999 - // Actually, this whole IoDeviceNodeTreeSequence stuff isn't neccessary. // PnP will make no changes to the tree while the device tree lock is owned, // and it's owned for the duration of a power notification. // IoDeviceNodeTreeSequence++; // // Sleep... // status = NtInitiatePowerAction( PowerActionWarmEject, LightestSleepState, POWER_ACTION_QUERY_ALLOWED | POWER_ACTION_UI_ALLOWED, FALSE // Asynchronous == FALSE ); // // Acquire device node lock. We are not allowed to set or clear this field // unless we are under this lock. // IopAcquireDeviceTreeLock(); // // Clear the current PDO to eject, and see if the Pdo was actually picked // up. // if (IopWarmEjectPdo) { if (NT_SUCCESS(status)) { // // If our device wasn't picked up, the return of // NtInitiatePowerAction should *not* be successful! // ASSERT(0); status = STATUS_UNSUCCESSFUL; } IopWarmEjectPdo = NULL; } // // Release the tree lock. // IopReleaseDeviceTreeLock(); // // Release the warm eject device lock // KeSetEvent( &IopWarmEjectLock, IO_NO_INCREMENT, FALSE ); return status; }

---