devnode.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Kernel
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     PnP manager device tree functions
 * COPYRIGHT:   Casper S. Hornstrup (chorns@users.sourceforge.net)
 *              2007 Hervé Poussineau (hpoussin@reactos.org)
 *              2010-2012 Cameron Gutman (cameron.gutman@reactos.org)
 */
 
/* INCLUDES ******************************************************************/
 
#include <ntoskrnl.h>
#define NDEBUG
#include <debug.h>
 
/* GLOBALS *******************************************************************/
 
PDEVICE_NODE IopRootDeviceNode;
KSPIN_LOCK IopDeviceTreeLock;
 
LONG IopNumberDeviceNodes;
 
/* FUNCTIONS *****************************************************************/
 
PDEVICE_NODE
FASTCALL
IopGetDeviceNode(
    _In_ PDEVICE_OBJECT DeviceObject)
{
    return ((PEXTENDED_DEVOBJ_EXTENSION)DeviceObject->DeviceObjectExtension)->DeviceNode;
}
 
PDEVICE_NODE
PipAllocateDeviceNode(
    _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject)
{
    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;
}
 
VOID
PiInsertDevNode(
    _In_ PDEVICE_NODE DeviceNode,
    _In_ PDEVICE_NODE ParentNode)
{
    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);
}
 
PNP_DEVNODE_STATE
PiSetDevNodeState(
    _In_ PDEVICE_NODE DeviceNode,
    _In_ PNP_DEVNODE_STATE NewState)
{
    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;
}
 
VOID
PiSetDevNodeProblem(
    _In_ PDEVICE_NODE DeviceNode,
    _In_ UINT32 Problem)
{
    DeviceNode->Flags |= DNF_HAS_PROBLEM;
    DeviceNode->Problem = Problem;
}
 
VOID
PiClearDevNodeProblem(
    _In_ PDEVICE_NODE DeviceNode)
{
    DeviceNode->Flags &= ~DNF_HAS_PROBLEM;
    DeviceNode->Problem = 0;
}
 
#if 0
NTSTATUS
IopCreateDeviceNode(
    _In_ PDEVICE_NODE ParentNode,
    _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject,
    _In_opt_ PUNICODE_STRING ServiceName,
    _Out_ PDEVICE_NODE *DeviceNode)
{
    PDEVICE_NODE Node;
    NTSTATUS Status;
    UNICODE_STRING FullServiceName;
    UNICODE_STRING LegacyPrefix = RTL_CONSTANT_STRING(L"LEGACY_");
    UNICODE_STRING UnknownDeviceName = RTL_CONSTANT_STRING(L"UNKNOWN");
    UNICODE_STRING KeyName, ClassName;
    PUNICODE_STRING ServiceName1;
    ULONG LegacyValue;
    UNICODE_STRING ClassGUID;
    HANDLE InstanceHandle;
 
    DPRINT("ParentNode 0x%p PhysicalDeviceObject 0x%p ServiceName %wZ\n",
           ParentNode, PhysicalDeviceObject, ServiceName);
 
    Node = ExAllocatePoolWithTag(NonPagedPool, sizeof(DEVICE_NODE), TAG_IO_DEVNODE);
    if (!Node)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(Node, sizeof(DEVICE_NODE));
    InitializeListHead(&Node->TargetDeviceNotify);
 
    if (!ServiceName)
        ServiceName1 = &UnknownDeviceName;
    else
        ServiceName1 = ServiceName;
 
    if (!PhysicalDeviceObject)
    {
        FullServiceName.MaximumLength = LegacyPrefix.Length + ServiceName1->Length + sizeof(UNICODE_NULL);
        FullServiceName.Length = 0;
        FullServiceName.Buffer = ExAllocatePool(PagedPool, FullServiceName.MaximumLength);
        if (!FullServiceName.Buffer)
        {
            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlAppendUnicodeStringToString(&FullServiceName, &LegacyPrefix);
        RtlAppendUnicodeStringToString(&FullServiceName, ServiceName1);
        RtlUpcaseUnicodeString(&FullServiceName, &FullServiceName, FALSE);
 
        Status = PnpRootCreateDevice(&FullServiceName, NULL, &PhysicalDeviceObject, &Node->InstancePath);
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("PnpRootCreateDevice() failed with status 0x%08X\n", Status);
            ExFreePool(FullServiceName.Buffer);
            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
            return Status;
        }
 
        /* Create the device key for legacy drivers */
        Status = IopCreateDeviceKeyPath(&Node->InstancePath, REG_OPTION_VOLATILE, &InstanceHandle);
        if (!NT_SUCCESS(Status))
        {
            ExFreePool(FullServiceName.Buffer);
            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
            return Status;
        }
 
        Node->ServiceName.MaximumLength = ServiceName1->Length + sizeof(UNICODE_NULL);
        Node->ServiceName.Length = 0;
        Node->ServiceName.Buffer = ExAllocatePool(PagedPool, Node->ServiceName.MaximumLength);
        if (!Node->ServiceName.Buffer)
        {
            ZwClose(InstanceHandle);
            ExFreePool(FullServiceName.Buffer);
            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
            return Status;
        }
 
        RtlCopyUnicodeString(&Node->ServiceName, ServiceName1);
 
        if (ServiceName)
        {
            RtlInitUnicodeString(&KeyName, L"Service");
            Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ServiceName->Buffer, ServiceName->Length + sizeof(UNICODE_NULL));
        }
 
        if (NT_SUCCESS(Status))
        {
            RtlInitUnicodeString(&KeyName, L"Legacy");
            LegacyValue = 1;
            Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_DWORD, &LegacyValue, sizeof(LegacyValue));
 
            RtlInitUnicodeString(&KeyName, L"ConfigFlags");
            LegacyValue = 0;
            ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_DWORD, &LegacyValue, sizeof(LegacyValue));
 
            if (NT_SUCCESS(Status))
            {
                RtlInitUnicodeString(&KeyName, L"Class");
                RtlInitUnicodeString(&ClassName, L"LegacyDriver");
                Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ClassName.Buffer, ClassName.Length + sizeof(UNICODE_NULL));
                if (NT_SUCCESS(Status))
                {
                    RtlInitUnicodeString(&KeyName, L"ClassGUID");
                    RtlInitUnicodeString(&ClassGUID, L"{8ECC055D-047F-11D1-A537-0000F8753ED1}");
                    Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ClassGUID.Buffer, ClassGUID.Length + sizeof(UNICODE_NULL));
                    if (NT_SUCCESS(Status))
                    {
                        // FIXME: Retrieve the real "description" by looking at the "DisplayName" string
                        // of the corresponding CurrentControlSet\Services\xxx entry for this driver.
                        RtlInitUnicodeString(&KeyName, L"DeviceDesc");
                        Status = ZwSetValueKey(InstanceHandle, &KeyName, 0, REG_SZ, ServiceName1->Buffer, ServiceName1->Length + sizeof(UNICODE_NULL));
                    }
                }
            }
        }
 
        ZwClose(InstanceHandle);
        ExFreePool(FullServiceName.Buffer);
 
        if (!NT_SUCCESS(Status))
        {
            ExFreePool(Node->ServiceName.Buffer);
            ExFreePoolWithTag(Node, TAG_IO_DEVNODE);
            return Status;
        }
 
        IopDeviceNodeSetFlag(Node, DNF_LEGACY_DRIVER);
        IopDeviceNodeSetFlag(Node, DNF_PROCESSED);
        IopDeviceNodeSetFlag(Node, DNF_ADDED);
        IopDeviceNodeSetFlag(Node, DNF_STARTED);
    }
 
    Node->PhysicalDeviceObject = PhysicalDeviceObject;
 
    ((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode = Node;
 
    if (ParentNode)
    {
        KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
        Node->Parent = ParentNode;
        Node->Sibling = NULL;
        if (ParentNode->LastChild == NULL)
        {
            ParentNode->Child = Node;
            ParentNode->LastChild = Node;
        }
        else
        {
            ParentNode->LastChild->Sibling = Node;
            ParentNode->LastChild = Node;
        }
        KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
        Node->Level = ParentNode->Level + 1;
    }
 
    PhysicalDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
    *DeviceNode = Node;
 
    return STATUS_SUCCESS;
}
#endif
 
NTSTATUS
IopFreeDeviceNode(
    _In_ PDEVICE_NODE DeviceNode)
{
    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;
}
 
static
NTSTATUS
IopFindNextDeviceNodeForTraversal(
    _In_ PDEVICETREE_TRAVERSE_CONTEXT Context)
{
    /* 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;
}
 
NTSTATUS
IopTraverseDeviceTree(
    _In_ PDEVICETREE_TRAVERSE_CONTEXT Context)
{
    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;
}