devnode.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for devnode.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
PDEVICE_NODE FASTCALL	IopGetDeviceNode (_In_ PDEVICE_OBJECT DeviceObject)
PDEVICE_NODE	PipAllocateDeviceNode (_In_opt_ PDEVICE_OBJECT PhysicalDeviceObject)
VOID	PiInsertDevNode (_In_ PDEVICE_NODE DeviceNode, _In_ PDEVICE_NODE ParentNode)
PNP_DEVNODE_STATE	PiSetDevNodeState (_In_ PDEVICE_NODE DeviceNode, _In_ PNP_DEVNODE_STATE NewState)
VOID	PiSetDevNodeProblem (_In_ PDEVICE_NODE DeviceNode, _In_ UINT32 Problem)
VOID	PiClearDevNodeProblem (_In_ PDEVICE_NODE DeviceNode)
NTSTATUS	IopFreeDeviceNode (_In_ PDEVICE_NODE DeviceNode)
	Creates a device node.
static NTSTATUS	IopFindNextDeviceNodeForTraversal (_In_ PDEVICETREE_TRAVERSE_CONTEXT Context)
NTSTATUS	IopTraverseDeviceTree (_In_ PDEVICETREE_TRAVERSE_CONTEXT Context)

Variables
PDEVICE_NODE	IopRootDeviceNode
KSPIN_LOCK	IopDeviceTreeLock
LONG	IopNumberDeviceNodes

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file devnode.c.

Function Documentation

IopFindNextDeviceNodeForTraversal()

static NTSTATUS IopFindNextDeviceNodeForTraversal ( _In_ PDEVICETREE_TRAVERSE_CONTEXT  Context )

static

Definition at line 402 of file devnode.c.

{
    /* If we have a child, simply go down the tree */
    if (Context->DeviceNode->Child != NULL)
    {
        ASSERT(Context->DeviceNode->Child->Parent == Context->DeviceNode);
        Context->DeviceNode = Context->DeviceNode->Child;
        return STATUS_SUCCESS;
    }
 
    while (Context->DeviceNode != Context->FirstDeviceNode)
    {
        /* All children processed -- go sideways */
        if (Context->DeviceNode->Sibling != NULL)
        {
            ASSERT(Context->DeviceNode->Sibling->Parent == Context->DeviceNode->Parent);
            Context->DeviceNode = Context->DeviceNode->Sibling;
            return STATUS_SUCCESS;
        }
 
        /* We're the last sibling -- go back up */
        ASSERT(Context->DeviceNode->Parent->LastChild == Context->DeviceNode);
        Context->DeviceNode = Context->DeviceNode->Parent;
 
        /* We already visited the parent and all its children, so keep looking */
    }
 
    /* Done with all children of the start node -- stop enumeration */
    return STATUS_UNSUCCESSFUL;
}

Referenced by IopTraverseDeviceTree().

IopFreeDeviceNode()

NTSTATUS IopFreeDeviceNode

(

_In_ PDEVICE_NODE

DeviceNode

)

Creates a device node.

Parameters

[in]	ParentNode	Pointer to parent device node
[in]	PhysicalDeviceObject	Pointer to PDO for device object. Pass NULL to have the root device node create one (eg. for legacy drivers)
[in]	ServiceName	The service (driver) name for a node. Pass NULL to set UNKNOWN as a service
[out]	DeviceNode	Pointer to storage for created device node

Returns

Status, indicating the result of an operation

Definition at line 327 of file devnode.c.

{
    KIRQL OldIrql;
    PDEVICE_NODE PrevSibling = NULL;
 
    ASSERT(DeviceNode->PhysicalDeviceObject);
    /* All children must be deleted before a parent is deleted */
    ASSERT(DeviceNode->Child == NULL);
    /* This is the only state where we are allowed to remove the node */
    ASSERT(DeviceNode->State == DeviceNodeRemoved);
    /* No notifications should be registered for this device */
    ASSERT(IsListEmpty(&DeviceNode->TargetDeviceNotify));
 
    KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
 
    /* Get previous sibling */
    if (DeviceNode->Parent && DeviceNode->Parent->Child != DeviceNode)
    {
        PrevSibling = DeviceNode->Parent->Child;
        while (PrevSibling->Sibling != DeviceNode)
            PrevSibling = PrevSibling->Sibling;
    }
 
    /* Unlink from parent if it exists */
    if (DeviceNode->Parent)
    {
        if (DeviceNode->Parent->LastChild == DeviceNode)
        {
            DeviceNode->Parent->LastChild = PrevSibling;
            if (PrevSibling)
                PrevSibling->Sibling = NULL;
        }
        if (DeviceNode->Parent->Child == DeviceNode)
            DeviceNode->Parent->Child = DeviceNode->Sibling;
    }
 
    /* Unlink from sibling list */
    if (PrevSibling)
        PrevSibling->Sibling = DeviceNode->Sibling;
 
    KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
 
    RtlFreeUnicodeString(&DeviceNode->InstancePath);
 
    RtlFreeUnicodeString(&DeviceNode->ServiceName);
 
    if (DeviceNode->ResourceList)
    {
        ExFreePool(DeviceNode->ResourceList);
    }
 
    if (DeviceNode->ResourceListTranslated)
    {
        ExFreePool(DeviceNode->ResourceListTranslated);
    }
 
    if (DeviceNode->ResourceRequirements)
    {
        ExFreePool(DeviceNode->ResourceRequirements);
    }
 
    if (DeviceNode->BootResources)
    {
        ExFreePool(DeviceNode->BootResources);
    }
 
    ((PEXTENDED_DEVOBJ_EXTENSION)DeviceNode->PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode = NULL;
    ExFreePoolWithTag(DeviceNode, TAG_IO_DEVNODE);
 
    return STATUS_SUCCESS;
}

IopGetDeviceNode()

PDEVICE_NODE FASTCALL IopGetDeviceNode

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 27 of file devnode.c.

{
    return ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
}

IopTraverseDeviceTree()

NTSTATUS IopTraverseDeviceTree

(

_In_ PDEVICETREE_TRAVERSE_CONTEXT

Context

)

Definition at line 435 of file devnode.c.

{
    NTSTATUS Status;
    PDEVICE_NODE DeviceNode;
 
    DPRINT("Context 0x%p\n", Context);
 
    DPRINT("IopTraverseDeviceTree(DeviceNode 0x%p  FirstDeviceNode 0x%p  Action %p  Context 0x%p)\n",
           Context->DeviceNode, Context->FirstDeviceNode, Context->Action, Context->Context);
 
    /* Start from the specified device node */
    Context->DeviceNode = Context->FirstDeviceNode;
 
    /* Traverse the device tree */
    do
    {
        DeviceNode = Context->DeviceNode;
 
        /* HACK: Keep a reference to the PDO so we can keep traversing the tree
         * if the device is deleted. In a perfect world, children would have to be
         * deleted before their parents, and we'd restart the traversal after
         * deleting a device node. */
        ObReferenceObject(DeviceNode->PhysicalDeviceObject);
 
        /* Call the action routine */
        Status = (Context->Action)(DeviceNode, Context->Context);
        if (NT_SUCCESS(Status))
        {
            /* Find next device node */
            ASSERT(Context->DeviceNode == DeviceNode);
            Status = IopFindNextDeviceNodeForTraversal(Context);
        }
 
        /* We need to either abort or make progress */
        ASSERT(!NT_SUCCESS(Status) || Context->DeviceNode != DeviceNode);
 
        ObDereferenceObject(DeviceNode->PhysicalDeviceObject);
    } while (NT_SUCCESS(Status));
 
    if (Status == STATUS_UNSUCCESSFUL)
    {
        /* The action routine just wanted to terminate the traversal with status
        code STATUS_SUCCESS */
        Status = STATUS_SUCCESS;
    }
 
    return Status;
}

PiClearDevNodeProblem()

VOID PiClearDevNodeProblem

(

_In_ PDEVICE_NODE

DeviceNode

)

Definition at line 141 of file devnode.c.

{
    DeviceNode->Flags &= ~DNF_HAS_PROBLEM;
    DeviceNode->Problem = 0;
}

PiInsertDevNode()

VOID PiInsertDevNode	(	_In_ PDEVICE_NODE	DeviceNode,
		_In_ PDEVICE_NODE	ParentNode
	)

Definition at line 80 of file devnode.c.

{
    KIRQL oldIrql;
 
    ASSERT(DeviceNode->Parent == NULL);
 
    KeAcquireSpinLock(&IopDeviceTreeLock, &oldIrql);
    DeviceNode->Parent = ParentNode;
    DeviceNode->Sibling = NULL;
    if (ParentNode->LastChild == NULL)
    {
        ParentNode->Child = DeviceNode;
        ParentNode->LastChild = DeviceNode;
    }
    else
    {
        ParentNode->LastChild->Sibling = DeviceNode;
        ParentNode->LastChild = DeviceNode;
    }
    KeReleaseSpinLock(&IopDeviceTreeLock, oldIrql);
    DeviceNode->Level = ParentNode->Level + 1;
 
    DPRINT("Inserted devnode 0x%p to parent 0x%p\n", DeviceNode, ParentNode);
}

Referenced by IoReportDetectedDevice(), PiControlInitializeDevice(), and PiEnumerateDevice().

PipAllocateDeviceNode()

PDEVICE_NODE PipAllocateDeviceNode

(

_In_opt_ PDEVICE_OBJECT

PhysicalDeviceObject

)

Definition at line 34 of file devnode.c.

{
    PDEVICE_NODE DeviceNode;
    PAGED_CODE();
 
    /* Allocate it */
    DeviceNode = ExAllocatePoolZero(NonPagedPool, sizeof(DEVICE_NODE), TAG_IO_DEVNODE);
    if (!DeviceNode)
    {
        return NULL;
    }
 
    /* Statistics */
    InterlockedIncrement(&IopNumberDeviceNodes);
 
    /* Set it up */
    DeviceNode->InterfaceType = InterfaceTypeUndefined;
    DeviceNode->BusNumber = -1;
    DeviceNode->ChildInterfaceType = InterfaceTypeUndefined;
    DeviceNode->ChildBusNumber = -1;
    DeviceNode->ChildBusTypeIndex = -1;
    DeviceNode->State = DeviceNodeUninitialized;
//    KeInitializeEvent(&DeviceNode->EnumerationMutex, SynchronizationEvent, TRUE);
    InitializeListHead(&DeviceNode->DeviceArbiterList);
    InitializeListHead(&DeviceNode->DeviceTranslatorList);
    InitializeListHead(&DeviceNode->TargetDeviceNotify);
    InitializeListHead(&DeviceNode->DockInfo.ListEntry);
    InitializeListHead(&DeviceNode->PendedSetInterfaceState);
 
    /* Check if there is a PDO */
    if (PhysicalDeviceObject)
    {
        /* Link it and remove the init flag */
        DeviceNode->PhysicalDeviceObject = PhysicalDeviceObject;
        ((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode = DeviceNode;
        PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
    }
 
    DPRINT("Allocated devnode 0x%p\n", DeviceNode);
 
    /* Return the node */
    return DeviceNode;
}

PiSetDevNodeProblem()

VOID PiSetDevNodeProblem	(	_In_ PDEVICE_NODE	DeviceNode,
		_In_ UINT32	Problem
	)

Definition at line 132 of file devnode.c.

{
    DeviceNode->Flags |= DNF_HAS_PROBLEM;
    DeviceNode->Problem = Problem;
}

Referenced by PiAttachFilterDriversCallback(), PiCallDriverAddDevice(), PiDevNodeStateMachine(), and PiUpdateDeviceState().

PiSetDevNodeState()

PNP_DEVNODE_STATE PiSetDevNodeState	(	_In_ PDEVICE_NODE	DeviceNode,
		_In_ PNP_DEVNODE_STATE	NewState
	)

Definition at line 108 of file devnode.c.

{
    KIRQL oldIrql;
 
    KeAcquireSpinLock(&IopDeviceTreeLock, &oldIrql);
 
    PNP_DEVNODE_STATE prevState = DeviceNode->State;
    if (prevState != NewState)
    {
        DeviceNode->State = NewState;
        DeviceNode->PreviousState = prevState;
        DeviceNode->StateHistory[DeviceNode->StateHistoryEntry++] = prevState;
        DeviceNode->StateHistoryEntry %= DEVNODE_HISTORY_SIZE;
    }
 
    KeReleaseSpinLock(&IopDeviceTreeLock, oldIrql);
 
    DPRINT("%wZ Changed state 0x%x => 0x%x\n", &DeviceNode->InstancePath, prevState, NewState);
    return prevState;
}

Referenced by IopAssignDeviceResources(), IopInitializePlugPlayServices(), IopQueryRemoveChildDevices(), IopSendRemoveDevice(), IoReportDetectedDevice(), PiCallDriverAddDevice(), PiControlInitializeDevice(), PiDevNodeStateMachine(), PiEnumerateDevice(), PiInitializeDevNode(), PiStartDeviceFinal(), and PiUpdateDeviceState().

Variable Documentation

IopDeviceTreeLock

KSPIN_LOCK IopDeviceTreeLock

Definition at line 19 of file devnode.c.

Referenced by IopCancelRemoveChildDevices(), IopFreeDeviceNode(), IopGetSystemPowerDeviceObject(), IopInitializePlugPlayServices(), IopQueryRemoveChildDevices(), IopSendRemoveChildDevices(), PiDevNodeStateMachine(), PiInsertDevNode(), and PiSetDevNodeState().

IopNumberDeviceNodes

LONG IopNumberDeviceNodes

Definition at line 21 of file devnode.c.

Referenced by PipAllocateDeviceNode().

IopRootDeviceNode

PDEVICE_NODE IopRootDeviceNode

Definition at line 18 of file devnode.c.

Referenced by IoInitSystem(), IopGetDeviceNodeStatus(), IopGetDeviceObjectFromDeviceInstance(), IopGetRelatedDevice(), IopInitializeBootDrivers(), IopInitializePlugPlayServices(), IopInitializeSystemDrivers(), IoReportDetectedDevice(), PiControlInitializeDevice(), PipDumpDeviceNodes(), PnpRootPnpControl(), PoInitSystem(), PopQuerySystemPowerStateTraverse(), PopSetSystemPowerState(), and PopSetSystemPowerStateTraverse().