-/* $Id: pnpmgr.c,v 1.8 2002/09/08 10:23:25 chorns Exp $
+/* $Id: pnpmgr.c,v 1.42 2004/10/22 18:34:11 ekohl Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: ntoskrnl/io/pnpmgr.c
+ * FILE: ntoskrnl/io/pnpmgr/pnpmgr.c
* PURPOSE: Initializes the PnP manager
* PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
* UPDATE HISTORY:
/* INCLUDES ******************************************************************/
-#include <ddk/ntddk.h>
-#include <internal/io.h>
-#include <internal/po.h>
-#include <internal/ldr.h>
-#include <internal/registry.h>
-#include <internal/module.h>
+#include <ntoskrnl.h>
+#include <ole32/guiddef.h>
+#ifdef DEFINE_GUID
+DEFINE_GUID(GUID_CLASS_COMPORT, 0x86e0d1e0L, 0x8089, 0x11d0, 0x9c, 0xe4, 0x08, 0x00, 0x3e, 0x30, 0x1f, 0x73);
+DEFINE_GUID(GUID_SERENUM_BUS_ENUMERATOR, 0x4D36E978L, 0xE325, 0x11CE, 0xBF, 0xC1, 0x08, 0x00, 0x2B, 0xE1, 0x03, 0x18);
+#endif // DEFINE_GUID
-#define NDEBUG
+//#define NDEBUG
#include <internal/debug.h>
+
/* GLOBALS *******************************************************************/
PDEVICE_NODE IopRootDeviceNode;
/* FUNCTIONS *****************************************************************/
-VOID
-STDCALL
-IoInitializeRemoveLockEx(
- IN PIO_REMOVE_LOCK Lock,
- IN ULONG AllocateTag,
- IN ULONG MaxLockedMinutes,
- IN ULONG HighWatermark,
- IN ULONG RemlockSize)
-{
-}
-
-NTSTATUS
-STDCALL
-IoAcquireRemoveLockEx(
- IN PIO_REMOVE_LOCK RemoveLock,
- IN OPTIONAL PVOID Tag,
- IN LPCSTR File,
- IN ULONG Line,
- IN ULONG RemlockSize)
-{
- return STATUS_NOT_IMPLEMENTED;
-}
-
-VOID
-STDCALL
-IoReleaseRemoveLockEx(
- IN PIO_REMOVE_LOCK RemoveLock,
- IN PVOID Tag,
- IN ULONG RemlockSize)
-{
-}
-
-VOID
-STDCALL
-IoReleaseRemoveLockAndWaitEx(
- IN PIO_REMOVE_LOCK RemoveLock,
- IN PVOID Tag,
- IN ULONG RemlockSize)
-{
-}
-
+/*
+ * @unimplemented
+ */
VOID
STDCALL
IoAdjustPagingPathCount(
{
}
-NTSTATUS
+/*
+ * @unimplemented
+ */
+VOID
STDCALL
-IoGetDeviceInterfaceAlias(
- IN PUNICODE_STRING SymbolicLinkName,
- IN CONST GUID *AliasInterfaceClassGuid,
- OUT PUNICODE_STRING AliasSymbolicLinkName)
+IoInvalidateDeviceRelations(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN DEVICE_RELATION_TYPE Type)
{
- return STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS
-STDCALL
-IoGetDeviceInterfaces(
- IN CONST GUID *InterfaceClassGuid,
- IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
- IN ULONG Flags,
- OUT PWSTR *SymbolicLinkList)
+PDEVICE_NODE FASTCALL
+IopGetDeviceNode(
+ PDEVICE_OBJECT DeviceObject)
{
- return STATUS_NOT_IMPLEMENTED;
+ return DeviceObject->DeviceObjectExtension->DeviceNode;
}
+/*
+ * @unimplemented
+ */
NTSTATUS
STDCALL
IoGetDeviceProperty(
OUT PVOID PropertyBuffer,
OUT PULONG ResultLength)
{
- return STATUS_NOT_IMPLEMENTED;
-}
+ PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
+ ULONG Length;
+ PVOID Data;
+ PWSTR Ptr;
-VOID
-STDCALL
-IoInvalidateDeviceRelations(
- IN PDEVICE_OBJECT DeviceObject,
- IN DEVICE_RELATION_TYPE Type)
-{
+ DPRINT("IoGetDeviceProperty(%x %d)\n", DeviceObject, DeviceProperty);
+
+ if (DeviceNode == NULL)
+ return STATUS_INVALID_DEVICE_REQUEST;
+
+ switch (DeviceProperty)
+ {
+ case DevicePropertyBusNumber:
+ if (DeviceNode->BusInformation == NULL)
+ return STATUS_INVALID_DEVICE_REQUEST;
+ Length = sizeof(ULONG);
+ Data = &DeviceNode->BusInformation->BusNumber;
+ break;
+
+ /* Complete, untested */
+ case DevicePropertyBusTypeGuid:
+ if (DeviceNode->BusInformation == NULL)
+ return STATUS_INVALID_DEVICE_REQUEST;
+ *ResultLength = 39 * sizeof(WCHAR);
+ if (BufferLength < (39 * sizeof(WCHAR)))
+ return STATUS_BUFFER_TOO_SMALL;
+ swprintf((PWSTR)PropertyBuffer,
+ L"{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
+ DeviceNode->BusInformation->BusTypeGuid.Data1,
+ DeviceNode->BusInformation->BusTypeGuid.Data2,
+ DeviceNode->BusInformation->BusTypeGuid.Data3,
+ DeviceNode->BusInformation->BusTypeGuid.Data4[0],
+ DeviceNode->BusInformation->BusTypeGuid.Data4[1],
+ DeviceNode->BusInformation->BusTypeGuid.Data4[2],
+ DeviceNode->BusInformation->BusTypeGuid.Data4[3],
+ DeviceNode->BusInformation->BusTypeGuid.Data4[4],
+ DeviceNode->BusInformation->BusTypeGuid.Data4[5],
+ DeviceNode->BusInformation->BusTypeGuid.Data4[6],
+ DeviceNode->BusInformation->BusTypeGuid.Data4[7]);
+ return STATUS_SUCCESS;
+
+ case DevicePropertyLegacyBusType:
+ if (DeviceNode->BusInformation == NULL)
+ return STATUS_INVALID_DEVICE_REQUEST;
+ Length = sizeof(INTERFACE_TYPE);
+ Data = &DeviceNode->BusInformation->LegacyBusType;
+ break;
+
+ case DevicePropertyAddress:
+ if (DeviceNode->CapabilityFlags == NULL)
+ return STATUS_INVALID_DEVICE_REQUEST;
+ Length = sizeof(ULONG);
+ Data = &DeviceNode->CapabilityFlags->Address;
+ break;
+
+ case DevicePropertyUINumber:
+ if (DeviceNode->CapabilityFlags == NULL)
+ return STATUS_INVALID_DEVICE_REQUEST;
+ Length = sizeof(ULONG);
+ Data = &DeviceNode->CapabilityFlags->UINumber;
+ break;
+
+ case DevicePropertyClassName:
+ case DevicePropertyClassGuid:
+ case DevicePropertyDriverKeyName:
+ case DevicePropertyManufacturer:
+ case DevicePropertyFriendlyName:
+ case DevicePropertyHardwareID:
+ case DevicePropertyCompatibleIDs:
+ case DevicePropertyDeviceDescription:
+ case DevicePropertyLocationInformation:
+ {
+ LPWSTR RegistryPropertyName, KeyNameBuffer;
+ UNICODE_STRING KeyName, ValueName;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ KEY_VALUE_PARTIAL_INFORMATION *ValueInformation;
+ ULONG ValueInformationLength;
+ HANDLE KeyHandle;
+ NTSTATUS Status;
+
+ switch (DeviceProperty)
+ {
+ case DevicePropertyClassName:
+ RegistryPropertyName = L"Class"; break;
+ case DevicePropertyClassGuid:
+ RegistryPropertyName = L"ClassGuid"; break;
+ case DevicePropertyDriverKeyName:
+ RegistryPropertyName = L"Driver"; break;
+ case DevicePropertyManufacturer:
+ RegistryPropertyName = L"Mfg"; break;
+ case DevicePropertyFriendlyName:
+ RegistryPropertyName = L"FriendlyName"; break;
+ case DevicePropertyHardwareID:
+ RegistryPropertyName = L"HardwareID"; break;
+ case DevicePropertyCompatibleIDs:
+ RegistryPropertyName = L"CompatibleIDs"; break;
+ case DevicePropertyDeviceDescription:
+ RegistryPropertyName = L"DeviceDesc"; break;
+ case DevicePropertyLocationInformation:
+ RegistryPropertyName = L"LocationInformation"; break;
+ default:
+ RegistryPropertyName = NULL; break;
+ }
+
+ KeyNameBuffer = ExAllocatePool(PagedPool,
+ (49 * sizeof(WCHAR)) + DeviceNode->InstancePath.Length);
+
+ DPRINT1("KeyNameBuffer: %x, value %S\n",
+ KeyNameBuffer, RegistryPropertyName);
+
+ if (KeyNameBuffer == NULL)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ wcscpy(KeyNameBuffer, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
+ wcscat(KeyNameBuffer, DeviceNode->InstancePath.Buffer);
+ RtlInitUnicodeString(&KeyName, KeyNameBuffer);
+ InitializeObjectAttributes(&ObjectAttributes, &KeyName,
+ OBJ_CASE_INSENSITIVE, NULL, NULL);
+
+ Status = ZwOpenKey(&KeyHandle, KEY_READ, &ObjectAttributes);
+ ExFreePool(KeyNameBuffer);
+ if (!NT_SUCCESS(Status))
+ return Status;
+
+ RtlInitUnicodeString(&ValueName, RegistryPropertyName);
+ ValueInformationLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION,
+ Data[0]) + BufferLength;
+ ValueInformation = ExAllocatePool(PagedPool, ValueInformationLength);
+ if (ValueInformation == NULL)
+ {
+ ZwClose(KeyHandle);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ Status = ZwQueryValueKey(KeyHandle, &ValueName,
+ KeyValuePartialInformation, ValueInformation,
+ ValueInformationLength,
+ &ValueInformationLength);
+ *ResultLength = ValueInformation->DataLength;
+ ZwClose(KeyHandle);
+
+ if (ValueInformation->DataLength > BufferLength)
+ Status = STATUS_BUFFER_TOO_SMALL;
+
+ if (!NT_SUCCESS(Status))
+ {
+ ExFreePool(ValueInformation);
+ return Status;
+ }
+
+ /* FIXME: Verify the value (NULL-terminated, correct format). */
+
+ RtlCopyMemory(PropertyBuffer, ValueInformation->Data,
+ ValueInformation->DataLength);
+ ExFreePool(ValueInformation);
+
+ return STATUS_SUCCESS;
+ }
+
+ case DevicePropertyBootConfiguration:
+ Length = 0;
+ if (DeviceNode->BootResourceList->Count != 0)
+ {
+ Length = sizeof(CM_RESOURCE_LIST) +
+ ((DeviceNode->BootResourceList->Count - 1) * sizeof(CM_FULL_RESOURCE_DESCRIPTOR));
+ }
+ Data = &DeviceNode->BootResourceList;
+ break;
+
+ /* FIXME: use a translated boot configuration instead */
+ case DevicePropertyBootConfigurationTranslated:
+ Length = 0;
+ if (DeviceNode->BootResourceList->Count != 0)
+ {
+ Length = sizeof(CM_RESOURCE_LIST) +
+ ((DeviceNode->BootResourceList->Count - 1) * sizeof(CM_FULL_RESOURCE_DESCRIPTOR));
+ }
+ Data = &DeviceNode->BootResourceList;
+ break;
+
+ case DevicePropertyEnumeratorName:
+ Ptr = wcschr(DeviceNode->InstancePath.Buffer, L'\\');
+ if (Ptr != NULL)
+ {
+ Length = (ULONG)((ULONG_PTR)Ptr - (ULONG_PTR)DeviceNode->InstancePath.Buffer) + sizeof(WCHAR);
+ }
+ else
+ {
+ Length = 0;
+ Data = NULL;
+ }
+
+ case DevicePropertyPhysicalDeviceObjectName:
+ return STATUS_NOT_IMPLEMENTED;
+
+ default:
+ return STATUS_INVALID_PARAMETER_2;
+ }
+
+ *ResultLength = Length;
+ if (BufferLength < Length)
+ return STATUS_BUFFER_TOO_SMALL;
+ RtlCopyMemory(PropertyBuffer, Data, Length);
+
+ /* Terminate the string */
+ if (DeviceProperty == DevicePropertyEnumeratorName)
+ {
+ Ptr = (PWSTR)PropertyBuffer;
+ Ptr[(Length / sizeof(WCHAR)) - 1] = 0;
+ }
+
+ return STATUS_SUCCESS;
}
+/*
+ * @unimplemented
+ */
VOID
STDCALL
IoInvalidateDeviceState(
{
}
-NTSTATUS
-STDCALL
-IoOpenDeviceInterfaceRegistryKey(
- IN PUNICODE_STRING SymbolicLinkName,
- IN ACCESS_MASK DesiredAccess,
- OUT PHANDLE DeviceInterfaceKey)
-{
- return STATUS_NOT_IMPLEMENTED;
-}
-
+/*
+ * @unimplemented
+ */
NTSTATUS
STDCALL
IoOpenDeviceRegistryKey(
IN ACCESS_MASK DesiredAccess,
OUT PHANDLE DevInstRegKey)
{
- return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-STDCALL
-IoRegisterDeviceInterface(
- IN PDEVICE_OBJECT PhysicalDeviceObject,
- IN CONST GUID *InterfaceClassGuid,
- IN PUNICODE_STRING ReferenceString OPTIONAL,
- OUT PUNICODE_STRING SymbolicLinkName)
-{
- return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-STDCALL
-IoRegisterPlugPlayNotification(
- IN IO_NOTIFICATION_EVENT_CATEGORY EventCategory,
- IN ULONG EventCategoryFlags,
- IN PVOID EventCategoryData OPTIONAL,
- IN PDRIVER_OBJECT DriverObject,
- IN PDRIVER_NOTIFICATION_CALLBACK_ROUTINE CallbackRoutine,
- IN PVOID Context,
- OUT PVOID *NotificationEntry)
-{
- return STATUS_NOT_IMPLEMENTED;
-}
+ static const WCHAR ClassKeyName[] = {
+ '\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e','\\',
+ 'S','y','s','t','e','m','\\','C','u','r','r','e','n','t','C','o','n','t',
+ 'r','o','l','S','e','t','\\','C','o','n','t','r','o','l','\\',
+ 'C','l','a','s','s','\\'};
+ LPWSTR KeyNameBuffer;
+ UNICODE_STRING KeyName;
+ ULONG DriverKeyLength;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ NTSTATUS Status;
-NTSTATUS
-STDCALL
-IoReportDetectedDevice(
- IN PDRIVER_OBJECT DriverObject,
- IN INTERFACE_TYPE LegacyBusType,
- IN ULONG BusNumber,
- IN ULONG SlotNumber,
- IN PCM_RESOURCE_LIST ResourceList,
- IN PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirements OPTIONAL,
- IN BOOLEAN ResourceAssigned,
- IN OUT PDEVICE_OBJECT *DeviceObject)
-{
- return STATUS_NOT_IMPLEMENTED;
-}
+ if (DevInstKeyType == PLUGPLAY_REGKEY_DRIVER)
+ {
+ Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
+ 0, NULL, &DriverKeyLength);
+ if (Status != STATUS_BUFFER_TOO_SMALL)
+ return Status;
+
+ KeyNameBuffer = ExAllocatePool(PagedPool, DriverKeyLength + sizeof(ClassKeyName));
+ if (KeyNameBuffer == NULL)
+ return STATUS_INSUFFICIENT_RESOURCES;
-NTSTATUS
-STDCALL
-IoReportResourceForDetection(
- IN PDRIVER_OBJECT DriverObject,
- IN PCM_RESOURCE_LIST DriverList OPTIONAL,
- IN ULONG DriverListSize OPTIONAL,
- IN PDEVICE_OBJECT DeviceObject OPTIONAL,
- IN PCM_RESOURCE_LIST DeviceList OPTIONAL,
- IN ULONG DeviceListSize OPTIONAL,
- OUT PBOOLEAN ConflictDetected)
-{
- return STATUS_NOT_IMPLEMENTED;
-}
+ RtlCopyMemory(KeyNameBuffer, ClassKeyName, sizeof(ClassKeyName));
+ Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
+ DriverKeyLength, KeyNameBuffer +
+ (sizeof(ClassKeyName) / sizeof(WCHAR)),
+ &DriverKeyLength);
+ if (!NT_SUCCESS(Status))
+ {
+ ExFreePool(KeyNameBuffer);
+ return Status;
+ }
-NTSTATUS
-STDCALL
-IoReportTargetDeviceChange(
- IN PDEVICE_OBJECT PhysicalDeviceObject,
- IN PVOID NotificationStructure)
-{
- return STATUS_NOT_IMPLEMENTED;
-}
+ RtlInitUnicodeString(&KeyName, KeyNameBuffer);
+ InitializeObjectAttributes(&ObjectAttributes, &KeyName,
+ OBJ_CASE_INSENSITIVE, NULL, NULL);
+ Status = ZwOpenKey(DevInstRegKey, DesiredAccess, &ObjectAttributes);
+ ExFreePool(KeyNameBuffer);
+ return Status;
+ }
-NTSTATUS
-STDCALL
-IoReportTargetDeviceChangeAsynchronous(
- IN PDEVICE_OBJECT PhysicalDeviceObject,
- IN PVOID NotificationStructure,
- IN PDEVICE_CHANGE_COMPLETE_CALLBACK Callback OPTIONAL,
- IN PVOID Context OPTIONAL)
-{
return STATUS_NOT_IMPLEMENTED;
}
+/*
+ * @unimplemented
+ */
VOID
STDCALL
IoRequestDeviceEject(
- IN PDEVICE_OBJECT PhysicalDeviceObject)
-{
-}
-
-NTSTATUS
-STDCALL
-IoSetDeviceInterfaceState(
- IN PUNICODE_STRING SymbolicLinkName,
- IN BOOLEAN Enable)
-{
- return STATUS_NOT_IMPLEMENTED;
-}
-
-NTSTATUS
-STDCALL
-IoUnregisterPlugPlayNotification(
- IN PVOID NotificationEntry)
+ IN PDEVICE_OBJECT PhysicalDeviceObject
+ )
{
- return STATUS_NOT_IMPLEMENTED;
+ UNIMPLEMENTED;
}
{
KIRQL OldIrql;
- assert(PopSystemPowerDeviceNode);
+ if (PopSystemPowerDeviceNode)
+ {
+ KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
+ *DeviceObject = PopSystemPowerDeviceNode->Pdo;
+ KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
- KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
- *DeviceObject = PopSystemPowerDeviceNode->Pdo;
- KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
+ return STATUS_SUCCESS;
+ }
- return STATUS_SUCCESS;
+ return STATUS_UNSUCCESSFUL;
}
/**********************************************************************
Node->Pdo = PhysicalDeviceObject;
+ PhysicalDeviceObject->DeviceObjectExtension->DeviceNode = Node;
+
if (ParentNode)
{
KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
Node->NextSibling = ParentNode->Child;
if (ParentNode->Child != NULL)
{
- ParentNode->Child->PrevSibling = Node;
+ ParentNode->Child->PrevSibling = Node;
}
ParentNode->Child = Node;
KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
/* Unlink from parent if it exists */
if ((DeviceNode->Parent) && (DeviceNode->Parent->Child == DeviceNode))
- {
- DeviceNode->Parent->Child = DeviceNode->NextSibling;
- }
+ {
+ DeviceNode->Parent->Child = DeviceNode->NextSibling;
+ }
/* Unlink from sibling list */
if (DeviceNode->PrevSibling)
- {
- DeviceNode->PrevSibling->NextSibling = DeviceNode->NextSibling;
- }
+ {
+ DeviceNode->PrevSibling->NextSibling = DeviceNode->NextSibling;
+ }
if (DeviceNode->NextSibling)
- {
- DeviceNode->NextSibling->PrevSibling = DeviceNode->PrevSibling;
- }
+ {
+ DeviceNode->NextSibling->PrevSibling = DeviceNode->PrevSibling;
+ }
KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
RtlFreeUnicodeString(&DeviceNode->ServiceName);
if (DeviceNode->CapabilityFlags)
- {
- ExFreePool(DeviceNode->CapabilityFlags);
- }
+ {
+ ExFreePool(DeviceNode->CapabilityFlags);
+ }
if (DeviceNode->CmResourceList)
- {
- ExFreePool(DeviceNode->CmResourceList);
- }
+ {
+ ExFreePool(DeviceNode->CmResourceList);
+ }
- if (DeviceNode->BootResourcesList)
- {
- ExFreePool(DeviceNode->BootResourcesList);
- }
+ if (DeviceNode->BootResourceList)
+ {
+ ExFreePool(DeviceNode->BootResourceList);
+ }
if (DeviceNode->ResourceRequirementsList)
- {
- ExFreePool(DeviceNode->ResourceRequirementsList);
- }
-
- RtlFreeUnicodeString(&DeviceNode->DeviceID);
-
- RtlFreeUnicodeString(&DeviceNode->InstanceID);
-
- RtlFreeUnicodeString(&DeviceNode->HardwareIDs);
-
- RtlFreeUnicodeString(&DeviceNode->CompatibleIDs);
-
- RtlFreeUnicodeString(&DeviceNode->DeviceText);
-
- RtlFreeUnicodeString(&DeviceNode->DeviceTextLocation);
+ {
+ ExFreePool(DeviceNode->ResourceRequirementsList);
+ }
if (DeviceNode->BusInformation)
- {
- ExFreePool(DeviceNode->BusInformation);
- }
+ {
+ ExFreePool(DeviceNode->BusInformation);
+ }
ExFreePool(DeviceNode);
KeInitializeEvent(
&Event,
- NotificationEvent,
- FALSE);
-
- /* PNP IRPs are always initialized with a status code of
- STATUS_NOT_IMPLEMENTED */
- IoStatusBlock->Status = STATUS_NOT_IMPLEMENTED;
- IoStatusBlock->Information = 0;
+ NotificationEvent,
+ FALSE);
Irp = IoBuildSynchronousFsdRequest(
IRP_MJ_PNP,
TopDeviceObject,
- NULL,
- 0,
- NULL,
- &Event,
- IoStatusBlock);
+ NULL,
+ 0,
+ NULL,
+ &Event,
+ IoStatusBlock);
+
+ /* PNP IRPs are always initialized with a status code of
+ STATUS_NOT_IMPLEMENTED */
+ Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
+ Irp->IoStatus.Information = 0;
IrpSp = IoGetNextIrpStackLocation(Irp);
IrpSp->MinorFunction = MinorFunction;
sizeof(Stack->Parameters));
}
- Status = IoCallDriver(TopDeviceObject, Irp);
- if (Status == STATUS_PENDING)
- {
- KeWaitForSingleObject(
+ Status = IoCallDriver(TopDeviceObject, Irp);
+ if (Status == STATUS_PENDING)
+ {
+ KeWaitForSingleObject(
&Event,
Executive,
- KernelMode,
- FALSE,
- NULL);
+ KernelMode,
+ FALSE,
+ NULL);
Status = IoStatusBlock->Status;
}
PDEVICE_OBJECT Pdo,
PDEVICE_CAPABILITIES *Capabilities)
{
- IO_STATUS_BLOCK IoStatusBlock;
+ IO_STATUS_BLOCK IoStatusBlock;
PDEVICE_CAPABILITIES Caps;
IO_STACK_LOCATION Stack;
NTSTATUS Status;
}
-NTSTATUS
-IopActionInterrogateDeviceStack(
- PDEVICE_NODE DeviceNode,
- PVOID Context)
-/*
- * FUNCTION: Retrieve information for all (direct) child nodes of a parent node
- * ARGUMENTS:
- * DeviceNode = Pointer to device node
- * Context = Pointer to parent node to retrieve child node information for
- * NOTES:
- * We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
- * when we reach a device node which is not a direct child of the device node
- * for which we retrieve information of child nodes for. Any errors that occur
- * is logged instead so that all child services have a chance of beeing
- * interrogated.
- */
+static NTSTATUS
+IopCreateDeviceKeyPath(PWSTR Path,
+ PHANDLE Handle)
{
- IO_STATUS_BLOCK IoStatusBlock;
- PDEVICE_NODE ParentDeviceNode;
- WCHAR InstancePath[MAX_PATH];
- IO_STACK_LOCATION Stack;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ WCHAR KeyBuffer[MAX_PATH];
+ UNICODE_STRING KeyName;
+ HANDLE KeyHandle;
NTSTATUS Status;
+ PWCHAR Current;
+ PWCHAR Next;
- DPRINT("DeviceNode %x Context %x\n", DeviceNode, Context);
+ *Handle = NULL;
- DPRINT("PDO %x\n", DeviceNode->Pdo);
+ if (_wcsnicmp(Path, L"\\Registry\\", 10) != 0)
+ {
+ return STATUS_INVALID_PARAMETER;
+ }
+ wcsncpy (KeyBuffer, Path, MAX_PATH-1);
+ RtlInitUnicodeString (&KeyName, KeyBuffer);
- ParentDeviceNode = (PDEVICE_NODE)Context;
+ /* Skip \\Registry\\ */
+ Current = KeyName.Buffer;
+ Current = wcschr (Current, '\\') + 1;
+ Current = wcschr (Current, '\\') + 1;
- /* We are called for the parent too, but we don't need to do special
- handling for this node */
- if (DeviceNode == ParentDeviceNode)
- {
- DPRINT("Success\n");
- return STATUS_SUCCESS;
- }
+ while (TRUE)
+ {
+ Next = wcschr (Current, '\\');
+ if (Next == NULL)
+ {
+ /* The end */
+ }
+ else
+ {
+ *Next = 0;
+ }
- /* Make sure this device node is a direct child of the parent device node
- that is given as an argument */
- if (DeviceNode->Parent != ParentDeviceNode)
- {
- /* Stop the traversal immediately and indicate successful operation */
- DPRINT("Stop\n");
- return STATUS_UNSUCCESSFUL;
- }
+ InitializeObjectAttributes (&ObjectAttributes,
+ &KeyName,
+ OBJ_CASE_INSENSITIVE,
+ NULL,
+ NULL);
+
+ DPRINT("Create '%S'\n", KeyName.Buffer);
+
+ Status = NtCreateKey (&KeyHandle,
+ KEY_ALL_ACCESS,
+ &ObjectAttributes,
+ 0,
+ NULL,
+ 0,
+ NULL);
+ if (!NT_SUCCESS (Status))
+ {
+ DPRINT ("NtCreateKey() failed with status %x\n", Status);
+ return Status;
+ }
+ if (Next == NULL)
+ {
+ *Handle = KeyHandle;
+ return STATUS_SUCCESS;
+ }
+ else
+ {
+ NtClose (KeyHandle);
+ *Next = L'\\';
+ }
- /* FIXME: For critical errors, cleanup and disable device, but always return STATUS_SUCCESS */
+ Current = Next + 1;
+ }
+ return STATUS_UNSUCCESSFUL;
+}
- DPRINT("Sending IRP_MN_QUERY_ID.BusQueryDeviceID to device stack\n");
- Stack.Parameters.QueryId.IdType = BusQueryDeviceID;
+static NTSTATUS
+IopSetDeviceInstanceData(HANDLE InstanceKey,
+ PDEVICE_NODE DeviceNode)
+{
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ UNICODE_STRING KeyName;
+ HANDLE LogConfKey;
+ ULONG ResCount;
+ ULONG ListSize;
+ NTSTATUS Status;
- Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
- &IoStatusBlock,
- IRP_MN_QUERY_ID,
- &Stack);
+ DPRINT("IopSetDeviceInstanceData() called\n");
+
+ /* Create the 'LogConf' key */
+ RtlInitUnicodeString(&KeyName,
+ L"LogConf");
+ InitializeObjectAttributes(&ObjectAttributes,
+ &KeyName,
+ OBJ_CASE_INSENSITIVE,
+ InstanceKey,
+ NULL);
+ Status = NtCreateKey(&LogConfKey,
+ KEY_ALL_ACCESS,
+ &ObjectAttributes,
+ 0,
+ NULL,
+ 0,
+ NULL);
if (NT_SUCCESS(Status))
{
- RtlInitUnicodeString(
- &DeviceNode->DeviceID,
- (LPWSTR)IoStatusBlock.Information);
-
- /* FIXME: Check for valid characters, if there is invalid characters then bugcheck */
- }
- else
- {
- DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- RtlInitUnicodeString(&DeviceNode->DeviceID, NULL);
- }
-
-
- DPRINT("Sending IRP_MN_QUERY_ID.BusQueryInstanceID to device stack\n");
-
- Stack.Parameters.QueryId.IdType = BusQueryInstanceID;
+ /* Set 'BootConfig' value */
+ if (DeviceNode->BootResourceList != NULL)
+ {
+ ResCount = DeviceNode->BootResourceList->Count;
+ if (ResCount != 0)
+ {
+ ListSize = sizeof(CM_RESOURCE_LIST) +
+ ((ResCount - 1) * sizeof(CM_FULL_RESOURCE_DESCRIPTOR));
+
+ RtlInitUnicodeString(&KeyName,
+ L"BootConfig");
+ Status = NtSetValueKey(LogConfKey,
+ &KeyName,
+ 0,
+ REG_RESOURCE_LIST,
+ &DeviceNode->BootResourceList,
+ ListSize);
+ }
+ }
- Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
- &IoStatusBlock,
- IRP_MN_QUERY_ID,
- &Stack);
- if (NT_SUCCESS(Status))
- {
- RtlInitUnicodeString(
- &DeviceNode->InstanceID,
- (LPWSTR)IoStatusBlock.Information);
+ /* Set 'BasicConfigVector' value */
+ if (DeviceNode->ResourceRequirementsList != NULL &&
+ DeviceNode->ResourceRequirementsList->ListSize != 0)
+ {
+ RtlInitUnicodeString(&KeyName,
+ L"BasicConfigVector");
+ Status = NtSetValueKey(LogConfKey,
+ &KeyName,
+ 0,
+ REG_RESOURCE_REQUIREMENTS_LIST,
+ &DeviceNode->ResourceRequirementsList,
+ DeviceNode->ResourceRequirementsList->ListSize);
+ }
- /* FIXME: Check for valid characters, if there is invalid characters then bugcheck */
- }
- else
- {
- DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- RtlInitUnicodeString(&DeviceNode->InstanceID, NULL);
+ NtClose(LogConfKey);
}
+ DPRINT("IopSetDeviceInstanceData() done\n");
- /* FIXME: SEND IRP_QUERY_ID.BusQueryHardwareIDs */
- /* FIXME: SEND IRP_QUERY_ID.BusQueryCompatibleIDs */
+ return STATUS_SUCCESS;
+}
- Status = IopQueryCapabilities(DeviceNode->Pdo, &DeviceNode->CapabilityFlags);
- if (NT_SUCCESS(Status))
- {
- }
- else
- {
- }
-
-
- DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextDescription to device stack\n");
-
- Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextDescription;
- Stack.Parameters.QueryDeviceText.LocaleId = 0; // FIXME
-
- Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
- &IoStatusBlock,
- IRP_MN_QUERY_DEVICE_TEXT,
- &Stack);
- if (NT_SUCCESS(Status))
- {
- RtlInitUnicodeString(
- &DeviceNode->DeviceText,
- (LPWSTR)IoStatusBlock.Information);
- }
- else
- {
- DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- RtlInitUnicodeString(&DeviceNode->DeviceText, NULL);
- }
-
-
- DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextLocation to device stack\n");
-
- Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextLocationInformation;
- Stack.Parameters.QueryDeviceText.LocaleId = 0; // FIXME
-
- Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
- &IoStatusBlock,
- IRP_MN_QUERY_DEVICE_TEXT,
- &Stack);
- if (NT_SUCCESS(Status))
- {
- RtlInitUnicodeString(
- &DeviceNode->DeviceTextLocation,
- (LPWSTR)IoStatusBlock.Information);
- }
- else
- {
- DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- RtlInitUnicodeString(&DeviceNode->DeviceTextLocation, NULL);
- }
-
-
- DPRINT("Sending IRP_MN_QUERY_BUS_INFORMATION to device stack\n");
-
- Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
- &IoStatusBlock,
- IRP_MN_QUERY_BUS_INFORMATION,
- NULL);
- if (NT_SUCCESS(Status))
- {
- DeviceNode->BusInformation =
- (PPNP_BUS_INFORMATION)IoStatusBlock.Information;
- }
- else
- {
- DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- DeviceNode->BusInformation = NULL;
- }
-
-
- DPRINT("Sending IRP_MN_QUERY_RESOURCES to device stack\n");
-
- Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
- &IoStatusBlock,
- IRP_MN_QUERY_RESOURCES,
- NULL);
- if (NT_SUCCESS(Status))
- {
- DeviceNode->BootResourcesList =
- (PCM_RESOURCE_LIST)IoStatusBlock.Information;
- }
- else
- {
- DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- DeviceNode->BootResourcesList = NULL;
- }
-
-
- DPRINT("Sending IRP_MN_QUERY_RESOURCE_REQUIREMENTS to device stack\n");
-
- Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
- &IoStatusBlock,
- IRP_MN_QUERY_RESOURCE_REQUIREMENTS,
- NULL);
- if (NT_SUCCESS(Status))
- {
- DeviceNode->ResourceRequirementsList =
- (PIO_RESOURCE_REQUIREMENTS_LIST)IoStatusBlock.Information;
- }
- else
- {
- DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- DeviceNode->ResourceRequirementsList = NULL;
- }
-
-
- /* Assemble the instance path for the device */
-
- wcscpy(InstancePath, DeviceNode->DeviceID.Buffer);
- wcscat(InstancePath, L"\\");
- wcscat(InstancePath, DeviceNode->InstanceID.Buffer);
-
- if (!DeviceNode->CapabilityFlags->UniqueID)
- {
- DPRINT("Instance ID is not unique\n");
- /* FIXME: Add information from parent bus driver to InstancePath */
- }
-
- if (!IopCreateUnicodeString(&DeviceNode->InstancePath, InstancePath, PagedPool)) {
- DPRINT("No resources\n");
- /* FIXME: Cleanup and disable device */
- }
-
- DPRINT("InstancePath is %S\n", DeviceNode->InstancePath.Buffer);
+/*
+ * IopActionInterrogateDeviceStack
+ *
+ * Retrieve information for all (direct) child nodes of a parent node.
+ *
+ * Parameters
+ * DeviceNode
+ * Pointer to device node.
+ * Context
+ * Pointer to parent node to retrieve child node information for.
+ *
+ * Remarks
+ * We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
+ * when we reach a device node which is not a direct child of the device
+ * node for which we retrieve information of child nodes for. Any errors
+ * that occur is logged instead so that all child services have a chance
+ * of being interrogated.
+ */
- return STATUS_SUCCESS;
+NTSTATUS
+IopActionInterrogateDeviceStack(
+ PDEVICE_NODE DeviceNode,
+ PVOID Context)
+{
+ IO_STATUS_BLOCK IoStatusBlock;
+ PDEVICE_NODE ParentDeviceNode;
+ WCHAR InstancePath[MAX_PATH];
+ IO_STACK_LOCATION Stack;
+ NTSTATUS Status;
+ PWSTR KeyBuffer;
+ PWSTR Ptr;
+ USHORT Length;
+ USHORT TotalLength;
+ HANDLE InstanceKey = NULL;
+ UNICODE_STRING ValueName;
+
+ DPRINT("IopActionInterrogateDeviceStack(%p, %p)\n", DeviceNode, Context);
+ DPRINT("PDO %x\n", DeviceNode->Pdo);
+
+ ParentDeviceNode = (PDEVICE_NODE)Context;
+
+ /*
+ * We are called for the parent too, but we don't need to do special
+ * handling for this node
+ */
+
+ if (DeviceNode == ParentDeviceNode)
+ {
+ DPRINT("Success\n");
+ return STATUS_SUCCESS;
+ }
+
+ /*
+ * Make sure this device node is a direct child of the parent device node
+ * that is given as an argument
+ */
+
+ if (DeviceNode->Parent != ParentDeviceNode)
+ {
+ /* Stop the traversal immediately and indicate successful operation */
+ DPRINT("Stop\n");
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ /*
+ * FIXME: For critical errors, cleanup and disable device, but always
+ * return STATUS_SUCCESS.
+ */
+
+ DPRINT("Sending IRP_MN_QUERY_ID.BusQueryDeviceID to device stack\n");
+
+ Stack.Parameters.QueryId.IdType = BusQueryDeviceID;
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_ID,
+ &Stack);
+ if (NT_SUCCESS(Status))
+ {
+ /* Copy the device id string */
+ wcscpy(InstancePath, (PWSTR)IoStatusBlock.Information);
+
+ /*
+ * FIXME: Check for valid characters, if there is invalid characters
+ * then bugcheck.
+ */
+ }
+ else
+ {
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ }
+
+ DPRINT("Sending IRP_MN_QUERY_ID.BusQueryInstanceID to device stack\n");
+
+ Stack.Parameters.QueryId.IdType = BusQueryInstanceID;
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_ID,
+ &Stack);
+ if (NT_SUCCESS(Status))
+ {
+ /* Append the instance id string */
+ wcscat(InstancePath, L"\\");
+ wcscat(InstancePath, (PWSTR)IoStatusBlock.Information);
+
+ /*
+ * FIXME: Check for valid characters, if there is invalid characters
+ * then bugcheck
+ */
+ }
+ else
+ {
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ }
+
+ Status = IopQueryCapabilities(DeviceNode->Pdo, &DeviceNode->CapabilityFlags);
+ if (NT_SUCCESS(Status))
+ {
+ }
+ else
+ {
+ }
+
+ if (!DeviceNode->CapabilityFlags->UniqueID)
+ {
+ DPRINT("Instance ID is not unique\n");
+ /* FIXME: Add information from parent bus driver to InstancePath */
+ }
+
+ if (!IopCreateUnicodeString(&DeviceNode->InstancePath, InstancePath, PagedPool))
+ {
+ DPRINT("No resources\n");
+ /* FIXME: Cleanup and disable device */
+ }
+
+ DPRINT1("InstancePath is %S\n", DeviceNode->InstancePath.Buffer);
+
+ /*
+ * Create registry key for the instance id, if it doesn't exist yet
+ */
+ KeyBuffer = ExAllocatePool(
+ PagedPool,
+ (49 * sizeof(WCHAR)) + DeviceNode->InstancePath.Length);
+ wcscpy(KeyBuffer, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
+ wcscat(KeyBuffer, DeviceNode->InstancePath.Buffer);
+ Status = IopCreateDeviceKeyPath(KeyBuffer,
+ &InstanceKey);
+ ExFreePool(KeyBuffer);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("Failed to create the instance key! (Status %lx)\n", Status);
+ }
+
+
+ if (DeviceNode->CapabilityFlags != NULL)
+ {
+ /* Set 'Capabilities' value */
+ RtlInitUnicodeString(&ValueName,
+ L"Capabilities");
+ Status = NtSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_DWORD,
+ (PVOID)((ULONG_PTR)&DeviceNode->CapabilityFlags + 4),
+ sizeof(ULONG));
+
+ /* Set 'UINumber' value */
+ if (DeviceNode->CapabilityFlags->UINumber != (ULONG)-1)
+ {
+ RtlInitUnicodeString(&ValueName,
+ L"UINumber");
+ Status = NtSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_DWORD,
+ &DeviceNode->CapabilityFlags->UINumber,
+ sizeof(ULONG));
+ }
+ }
+
+ DPRINT("Sending IRP_MN_QUERY_ID.BusQueryHardwareIDs to device stack\n");
+
+ Stack.Parameters.QueryId.IdType = BusQueryHardwareIDs;
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_ID,
+ &Stack);
+ if (NT_SUCCESS(Status))
+ {
+ /*
+ * FIXME: Check for valid characters, if there is invalid characters
+ * then bugcheck.
+ */
+ TotalLength = 0;
+ Ptr = (PWSTR)IoStatusBlock.Information;
+ DPRINT("Hardware IDs:\n");
+ while (*Ptr)
+ {
+ DPRINT(" %S\n", Ptr);
+ Length = wcslen(Ptr) + 1;
+
+ Ptr += Length;
+ TotalLength += Length;
+ }
+ DPRINT("TotalLength: %hu\n", TotalLength);
+ DPRINT("\n");
+
+ RtlInitUnicodeString(&ValueName,
+ L"HardwareID");
+ Status = NtSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_MULTI_SZ,
+ (PVOID)IoStatusBlock.Information,
+ (TotalLength + 1) * sizeof(WCHAR));
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
+ }
+ }
+ else
+ {
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ }
+
+ DPRINT("Sending IRP_MN_QUERY_ID.BusQueryCompatibleIDs to device stack\n");
+
+ Stack.Parameters.QueryId.IdType = BusQueryCompatibleIDs;
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_ID,
+ &Stack);
+ if (NT_SUCCESS(Status))
+ {
+ /*
+ * FIXME: Check for valid characters, if there is invalid characters
+ * then bugcheck.
+ */
+ TotalLength = 0;
+ Ptr = (PWSTR)IoStatusBlock.Information;
+ DPRINT("Compatible IDs:\n");
+ while (*Ptr)
+ {
+ DPRINT(" %S\n", Ptr);
+ Length = wcslen(Ptr) + 1;
+
+ Ptr += Length;
+ TotalLength += Length;
+ }
+ DPRINT("TotalLength: %hu\n", TotalLength);
+ DPRINT("\n");
+
+ RtlInitUnicodeString(&ValueName,
+ L"CompatibleIDs");
+ Status = NtSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_MULTI_SZ,
+ (PVOID)IoStatusBlock.Information,
+ (TotalLength + 1) * sizeof(WCHAR));
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
+ }
+ }
+ else
+ {
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ }
+
+
+ DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextDescription to device stack\n");
+
+ Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextDescription;
+ Stack.Parameters.QueryDeviceText.LocaleId = 0; /* FIXME */
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_DEVICE_TEXT,
+ &Stack);
+ if (NT_SUCCESS(Status))
+ {
+ RtlInitUnicodeString(&ValueName,
+ L"DeviceDesc");
+ Status = NtSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_SZ,
+ (PVOID)IoStatusBlock.Information,
+ (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
+ }
+ }
+ else
+ {
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ }
+
+ DPRINT("Sending IRP_MN_QUERY_DEVICE_TEXT.DeviceTextLocation to device stack\n");
+
+ Stack.Parameters.QueryDeviceText.DeviceTextType = DeviceTextLocationInformation;
+ Stack.Parameters.QueryDeviceText.LocaleId = 0; // FIXME
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_DEVICE_TEXT,
+ &Stack);
+ if (NT_SUCCESS(Status))
+ {
+ DPRINT("LocationInformation: %S\n", (PWSTR)IoStatusBlock.Information);
+ RtlInitUnicodeString(&ValueName,
+ L"LocationInformation");
+ Status = NtSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_SZ,
+ (PVOID)IoStatusBlock.Information,
+ (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
+ }
+ }
+ else
+ {
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ }
+
+ DPRINT("Sending IRP_MN_QUERY_BUS_INFORMATION to device stack\n");
+
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_BUS_INFORMATION,
+ NULL);
+ if (NT_SUCCESS(Status))
+ {
+ DeviceNode->BusInformation =
+ (PPNP_BUS_INFORMATION)IoStatusBlock.Information;
+ }
+ else
+ {
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ DeviceNode->BusInformation = NULL;
+ }
+
+ DPRINT("Sending IRP_MN_QUERY_RESOURCES to device stack\n");
+
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_RESOURCES,
+ NULL);
+ if (NT_SUCCESS(Status))
+ {
+ DeviceNode->BootResourceList =
+ (PCM_RESOURCE_LIST)IoStatusBlock.Information;
+ DeviceNode->Flags |= DNF_HAS_BOOT_CONFIG;
+ }
+ else
+ {
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ DeviceNode->BootResourceList = NULL;
+ }
+
+ DPRINT("Sending IRP_MN_QUERY_RESOURCE_REQUIREMENTS to device stack\n");
+
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_RESOURCE_REQUIREMENTS,
+ NULL);
+ if (NT_SUCCESS(Status))
+ {
+ DeviceNode->ResourceRequirementsList =
+ (PIO_RESOURCE_REQUIREMENTS_LIST)IoStatusBlock.Information;
+ }
+ else
+ {
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ DeviceNode->ResourceRequirementsList = NULL;
+ }
+
+
+ if (InstanceKey != NULL)
+ {
+ IopSetDeviceInstanceData(InstanceKey, DeviceNode);
+ }
+
+ NtClose(InstanceKey);
+
+ DeviceNode->Flags |= DNF_PROCESSED;
+
+ return STATUS_SUCCESS;
}
+/*
+ * IopActionConfigureChildServices
+ *
+ * Retrieve configuration for all (direct) child nodes of a parent node.
+ *
+ * Parameters
+ * DeviceNode
+ * Pointer to device node.
+ * Context
+ * Pointer to parent node to retrieve child node configuration for.
+ *
+ * Remarks
+ * We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
+ * when we reach a device node which is not a direct child of the device
+ * node for which we configure child services for. Any errors that occur is
+ * logged instead so that all child services have a chance of beeing
+ * configured.
+ */
NTSTATUS
IopActionConfigureChildServices(
PDEVICE_NODE DeviceNode,
PVOID Context)
-/*
- * FUNCTION: Retrieve configuration for all (direct) child nodes of a parent node
- * ARGUMENTS:
- * DeviceNode = Pointer to device node
- * Context = Pointer to parent node to retrieve child node configuration for
- * NOTES:
- * We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
- * when we reach a device node which is not a direct child of the device
- * node for which we configure child services for. Any errors that occur is
- * logged instead so that all child services have a chance of beeing
- * configured.
- */
{
- RTL_QUERY_REGISTRY_TABLE QueryTable[2];
- PDEVICE_NODE ParentDeviceNode;
- PUNICODE_STRING Service;
- HANDLE KeyHandle;
- NTSTATUS Status;
-
- DPRINT("DeviceNode %x Context %x\n", DeviceNode, Context);
-
- ParentDeviceNode = (PDEVICE_NODE)Context;
-
- /* We are called for the parent too, but we don't need to do special
- handling for this node */
- if (DeviceNode == ParentDeviceNode)
- {
- DPRINT("Success\n");
- return STATUS_SUCCESS;
- }
-
- /* Make sure this device node is a direct child of the parent device node
- that is given as an argument */
- if (DeviceNode->Parent != ParentDeviceNode)
- {
- /* Stop the traversal immediately and indicate successful operation */
- DPRINT("Stop\n");
- return STATUS_UNSUCCESSFUL;
- }
-
- /* Retrieve configuration from Enum key */
-
- Service = &DeviceNode->ServiceName;
+ RTL_QUERY_REGISTRY_TABLE QueryTable[2];
+ PDEVICE_NODE ParentDeviceNode;
+ PUNICODE_STRING Service;
+ NTSTATUS Status;
+
+ DPRINT("IopActionConfigureChildServices(%p, %p)\n", DeviceNode, Context);
+
+ ParentDeviceNode = (PDEVICE_NODE)Context;
+
+ /*
+ * We are called for the parent too, but we don't need to do special
+ * handling for this node
+ */
+ if (DeviceNode == ParentDeviceNode)
+ {
+ DPRINT("Success\n");
+ return STATUS_SUCCESS;
+ }
+
+ /*
+ * Make sure this device node is a direct child of the parent device node
+ * that is given as an argument
+ */
+ if (DeviceNode->Parent != ParentDeviceNode)
+ {
+ /* Stop the traversal immediately and indicate successful operation */
+ DPRINT("Stop\n");
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED))
+ {
+ /*
+ * Retrieve configuration from Enum key
+ */
+
+ Service = &DeviceNode->ServiceName;
+
+ RtlZeroMemory(QueryTable, sizeof(QueryTable));
+ RtlInitUnicodeString(Service, NULL);
+
+ QueryTable[0].Name = L"Service";
+ QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
+ QueryTable[0].EntryContext = Service;
+
+ Status = RtlQueryRegistryValues(RTL_REGISTRY_ENUM,
+ DeviceNode->InstancePath.Buffer, QueryTable, NULL, NULL);
- Status = RtlpGetRegistryHandle(
- RTL_REGISTRY_ENUM,
- DeviceNode->InstancePath.Buffer,
- TRUE,
- &KeyHandle);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("RtlpGetRegistryHandle() failed (Status %x)\n", Status);
- return Status;
- }
-
- RtlZeroMemory(QueryTable, sizeof(QueryTable));
-
- RtlInitUnicodeString(Service, NULL);
-
- QueryTable[0].Name = L"Service";
- QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
- QueryTable[0].EntryContext = Service;
-
- Status = RtlQueryRegistryValues(
- RTL_REGISTRY_HANDLE,
- (PWSTR)KeyHandle,
- QueryTable,
- NULL,
- NULL);
- NtClose(KeyHandle);
-
- DPRINT("RtlQueryRegistryValues() returned status %x\n", Status);
-
- if (!NT_SUCCESS(Status))
- {
- /* FIXME: Log the error */
- CPRINT("Could not retrieve configuration for device %S (Status %x)\n",
- DeviceNode->InstancePath.Buffer, Status);
- IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
- return STATUS_SUCCESS;
- }
-
- DPRINT("Got Service %S\n", Service->Buffer);
-
- return STATUS_SUCCESS;
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("RtlQueryRegistryValues() failed (Status %x)\n", Status);
+ /* FIXME: Log the error */
+ CPRINT("Could not retrieve configuration for device %S (Status %x)\n",
+ DeviceNode->InstancePath.Buffer, Status);
+ IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
+ return STATUS_SUCCESS;
+ }
+
+ if (Service->Buffer == NULL)
+ {
+ IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
+ return STATUS_SUCCESS;
+ }
+
+ DPRINT("Got Service %S\n", Service->Buffer);
+ }
+
+ return STATUS_SUCCESS;
}
+/*
+ * IopActionInitChildServices
+ *
+ * Initialize the service for all (direct) child nodes of a parent node
+ *
+ * Parameters
+ * DeviceNode
+ * Pointer to device node.
+ * Context
+ * Pointer to parent node to initialize child node services for.
+ * BootDrivers
+ * Load only driver marked as boot start.
+ *
+ * Remarks
+ * If the driver image for a service is not loaded and initialized
+ * it is done here too. We only return a status code indicating an
+ * error (STATUS_UNSUCCESSFUL) when we reach a device node which is
+ * not a direct child of the device node for which we initialize
+ * child services for. Any errors that occur is logged instead so
+ * that all child services have a chance of being initialized.
+ */
NTSTATUS
IopActionInitChildServices(
- PDEVICE_NODE DeviceNode,
- PVOID Context)
-/*
- * FUNCTION: Initialize the service for all (direct) child nodes of a parent node
- * ARGUMENTS:
- * DeviceNode = Pointer to device node
- * Context = Pointer to parent node to initialize child node services for
- * NOTES:
- * If the driver image for a service is not loaded and initialized
- * it is done here too.
- * We only return a status code indicating an error (STATUS_UNSUCCESSFUL)
- * when we reach a device node which is not a direct child of the device
- * node for which we initialize child services for. Any errors that occur is
- * logged instead so that all child services have a chance of beeing
- * initialized.
- */
+ PDEVICE_NODE DeviceNode,
+ PVOID Context,
+ BOOLEAN BootDrivers)
{
- PDEVICE_NODE ParentDeviceNode;
- NTSTATUS Status;
-
- DPRINT("DeviceNode %x Context %x\n", DeviceNode, Context);
-
- ParentDeviceNode = (PDEVICE_NODE)Context;
-
- /* We are called for the parent too, but we don't need to do special
- handling for this node */
- if (DeviceNode == ParentDeviceNode)
- {
- DPRINT("Success\n");
- return STATUS_SUCCESS;
- }
-
- /* Make sure this device node is a direct child of the parent device node
- that is given as an argument */
- if (DeviceNode->Parent != ParentDeviceNode)
- {
- /* Stop the traversal immediately and indicate successful operation */
- DPRINT("Stop\n");
- return STATUS_UNSUCCESSFUL;
- }
-
- if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED) &&
- !IopDeviceNodeHasFlag(DeviceNode, DNF_ADDED) &&
- !IopDeviceNodeHasFlag(DeviceNode, DNF_STARTED))
- {
- Status = IopInitializeDeviceNodeService(DeviceNode);
- if (NT_SUCCESS(Status))
- {
- IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
- }
- else
- {
- IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
-
- /* FIXME: Log the error (possibly in IopInitializeDeviceNodeService) */
- CPRINT("Initialization of service %S failed (Status %x)\n",
- DeviceNode->ServiceName.Buffer, Status);
- }
- }
- else
- {
- DPRINT("Service %S is disabled or already initialized\n",
- DeviceNode->ServiceName.Buffer);
- }
-
- return STATUS_SUCCESS;
+ PDEVICE_NODE ParentDeviceNode;
+ NTSTATUS Status;
+
+ DPRINT("IopActionInitChildServices(%p, %p, %d)\n", DeviceNode, Context,
+ BootDrivers);
+
+ ParentDeviceNode = (PDEVICE_NODE)Context;
+
+ /*
+ * We are called for the parent too, but we don't need to do special
+ * handling for this node
+ */
+ if (DeviceNode == ParentDeviceNode)
+ {
+ DPRINT("Success\n");
+ return STATUS_SUCCESS;
+ }
+
+ /*
+ * Make sure this device node is a direct child of the parent device node
+ * that is given as an argument
+ */
+#if 0
+ if (DeviceNode->Parent != ParentDeviceNode)
+ {
+ /*
+ * Stop the traversal immediately and indicate unsuccessful operation
+ */
+ DPRINT("Stop\n");
+ return STATUS_UNSUCCESSFUL;
+ }
+#endif
+
+ if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED) &&
+ !IopDeviceNodeHasFlag(DeviceNode, DNF_ADDED) &&
+ !IopDeviceNodeHasFlag(DeviceNode, DNF_STARTED))
+ {
+ PMODULE_OBJECT ModuleObject;
+ PDRIVER_OBJECT DriverObject;
+
+ Status = IopLoadServiceModule(&DeviceNode->ServiceName, &ModuleObject);
+ if (NT_SUCCESS(Status))
+ {
+ Status = IopInitializeDriverModule(DeviceNode, ModuleObject, FALSE, &DriverObject);
+ if (NT_SUCCESS(Status))
+ {
+ /* Attach lower level filter drivers. */
+ IopAttachFilterDrivers(DeviceNode, TRUE);
+ /* Initialize the function driver for the device node */
+ Status = IopInitializeDevice(DeviceNode, DriverObject);
+ if (NT_SUCCESS(Status))
+ {
+ IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
+ /* Attach upper level filter drivers. */
+ IopAttachFilterDrivers(DeviceNode, FALSE);
+ }
+ }
+ }
+ else
+ {
+ /*
+ * Don't disable when trying to load only boot drivers
+ */
+ if (!BootDrivers)
+ {
+ IopDeviceNodeSetFlag(DeviceNode, DNF_DISABLED);
+ IopDeviceNodeSetFlag(DeviceNode, DNF_START_FAILED);
+ }
+ /* FIXME: Log the error (possibly in IopInitializeDeviceNodeService) */
+ CPRINT("Initialization of service %S failed (Status %x)\n",
+ DeviceNode->ServiceName.Buffer, Status);
+ }
+ } else
+ {
+ DPRINT("Service %S is disabled or already initialized\n",
+ DeviceNode->ServiceName.Buffer);
+ }
+
+ return STATUS_SUCCESS;
}
+/*
+ * IopActionInitAllServices
+ *
+ * Initialize the service for all (direct) child nodes of a parent node. This
+ * function just calls IopActionInitChildServices with BootDrivers = FALSE.
+ */
NTSTATUS
-IopInterrogateBusExtender(
+IopActionInitAllServices(
PDEVICE_NODE DeviceNode,
- PDEVICE_OBJECT Pdo,
- BOOLEAN BootDriversOnly)
+ PVOID Context)
{
- DEVICETREE_TRAVERSE_CONTEXT Context;
- PDEVICE_RELATIONS DeviceRelations;
- IO_STATUS_BLOCK IoStatusBlock;
- PDEVICE_NODE ChildDeviceNode;
- IO_STACK_LOCATION Stack;
- NTSTATUS Status;
- ULONG i;
-
- DPRINT("DeviceNode %x Pdo %x BootDriversOnly %d\n", DeviceNode, Pdo, BootDriversOnly);
-
- DPRINT("Sending IRP_MN_QUERY_DEVICE_RELATIONS to device stack\n");
-
- Stack.Parameters.QueryDeviceRelations.Type = BusRelations;
-
- Status = IopInitiatePnpIrp(
- Pdo,
- &IoStatusBlock,
- IRP_MN_QUERY_DEVICE_RELATIONS,
- &Stack);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("IopInitiatePnpIrp() failed\n");
- return Status;
- }
-
- DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
-
- if ((!DeviceRelations) || (DeviceRelations->Count <= 0))
- {
- DPRINT("No PDOs\n");
- if (DeviceRelations)
- {
- ExFreePool(DeviceRelations);
- }
- return STATUS_SUCCESS;
- }
-
- DPRINT("Got %d PDOs\n", DeviceRelations->Count);
-
- /* Create device nodes for all discovered devices */
- for (i = 0; i < DeviceRelations->Count; i++)
- {
- Status = IopCreateDeviceNode(
- DeviceNode,
- DeviceRelations->Objects[i],
- &ChildDeviceNode);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("No resources\n");
- for (i = 0; i < DeviceRelations->Count; i++)
- ObDereferenceObject(DeviceRelations->Objects[i]);
- ExFreePool(DeviceRelations);
- return STATUS_INSUFFICIENT_RESOURCES;
- }
- }
-
- ExFreePool(DeviceRelations);
-
-
- /* Retrieve information about all discovered children from the bus driver */
-
- IopInitDeviceTreeTraverseContext(
- &Context,
- DeviceNode,
- IopActionInterrogateDeviceStack,
- DeviceNode);
-
- Status = IopTraverseDeviceTree(&Context);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("IopTraverseDeviceTree() failed with status (%x)\n", Status);
- return Status;
- }
-
-
- /* Retrieve configuration from the registry for discovered children */
-
- IopInitDeviceTreeTraverseContext(
- &Context,
- DeviceNode,
- IopActionConfigureChildServices,
- DeviceNode);
-
- Status = IopTraverseDeviceTree(&Context);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("IopTraverseDeviceTree() failed with status (%x)\n", Status);
- return Status;
- }
-
-
- /* Initialize services for discovered children */
-
- IopInitDeviceTreeTraverseContext(
- &Context,
- DeviceNode,
- IopActionInitChildServices,
- DeviceNode);
-
- Status = IopTraverseDeviceTree(&Context);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("IopTraverseDeviceTree() failed with status (%x)\n", Status);
- return Status;
- }
-
- return Status;
+ return IopActionInitChildServices(DeviceNode, Context, FALSE);
}
+/*
+ * IopActionInitBootServices
+ *
+ * Initialize the boot start services for all (direct) child nodes of a
+ * parent node. This function just calls IopActionInitChildServices with
+ * BootDrivers = TRUE.
+ */
-VOID IopLoadBootStartDrivers(VOID)
+NTSTATUS
+IopActionInitBootServices(
+ PDEVICE_NODE DeviceNode,
+ PVOID Context)
{
- IopInterrogateBusExtender(
- IopRootDeviceNode,
- IopRootDeviceNode->Pdo,
- TRUE);
+ return IopActionInitChildServices(DeviceNode, Context, TRUE);
}
-VOID PnpInit(VOID)
+/*
+ * IopInitializePnpServices
+ *
+ * Initialize services for discovered children
+ *
+ * Parameters
+ * DeviceNode
+ * Top device node to start initializing services.
+ *
+ * BootDrivers
+ * When set to TRUE, only drivers marked as boot start will
+ * be loaded. Otherwise, all drivers will be loaded.
+ *
+ * Return Value
+ * Status
+ */
+
+NTSTATUS
+IopInitializePnpServices(
+ IN PDEVICE_NODE DeviceNode,
+ IN BOOLEAN BootDrivers)
{
- PDEVICE_OBJECT Pdo;
- NTSTATUS Status;
+ DEVICETREE_TRAVERSE_CONTEXT Context;
+
+ DPRINT("IopInitializePnpServices(%p, %d)\n", DeviceNode, BootDrivers);
+
+ if (BootDrivers)
+ {
+ IopInitDeviceTreeTraverseContext(
+ &Context,
+ DeviceNode,
+ IopActionInitBootServices,
+ DeviceNode);
+ } else
+ {
+ IopInitDeviceTreeTraverseContext(
+ &Context,
+ DeviceNode,
+ IopActionInitAllServices,
+ DeviceNode);
+ }
+
+ return IopTraverseDeviceTree(&Context);
+}
- DPRINT("Called\n");
- KeInitializeSpinLock(&IopDeviceTreeLock);
+NTSTATUS
+IopInvalidateDeviceRelations(
+ IN PDEVICE_NODE DeviceNode,
+ IN DEVICE_RELATION_TYPE Type)
+{
+ DEVICETREE_TRAVERSE_CONTEXT Context;
+ PDEVICE_RELATIONS DeviceRelations;
+ IO_STATUS_BLOCK IoStatusBlock;
+ PDEVICE_NODE ChildDeviceNode;
+ IO_STACK_LOCATION Stack;
+ BOOL BootDrivers;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ UNICODE_STRING LinkName;
+ HANDLE Handle;
+ NTSTATUS Status;
+ ULONG i;
+
+ DPRINT("DeviceNode %x\n", DeviceNode);
+
+ DPRINT("Sending IRP_MN_QUERY_DEVICE_RELATIONS to device stack\n");
+
+ Stack.Parameters.QueryDeviceRelations.Type = Type/*BusRelations*/;
+
+ Status = IopInitiatePnpIrp(
+ DeviceNode->Pdo,
+ &IoStatusBlock,
+ IRP_MN_QUERY_DEVICE_RELATIONS,
+ &Stack);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("IopInitiatePnpIrp() failed\n");
+ return Status;
+ }
+
+ DeviceRelations = (PDEVICE_RELATIONS)IoStatusBlock.Information;
+
+ if ((!DeviceRelations) || (DeviceRelations->Count <= 0))
+ {
+ DPRINT("No PDOs\n");
+ if (DeviceRelations)
+ {
+ ExFreePool(DeviceRelations);
+ }
+ return STATUS_SUCCESS;
+ }
+
+ DPRINT("Got %d PDOs\n", DeviceRelations->Count);
+
+ /*
+ * Create device nodes for all discovered devices
+ */
+
+ for (i = 0; i < DeviceRelations->Count; i++)
+ {
+ Status = IopCreateDeviceNode(
+ DeviceNode,
+ DeviceRelations->Objects[i],
+ &ChildDeviceNode);
+ DeviceNode->Flags |= DNF_ENUMERATED;
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("No resources\n");
+ for (i = 0; i < DeviceRelations->Count; i++)
+ ObDereferenceObject(DeviceRelations->Objects[i]);
+ ExFreePool(DeviceRelations);
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+ }
+ ExFreePool(DeviceRelations);
+
+ /*
+ * Retrieve information about all discovered children from the bus driver
+ */
+
+ IopInitDeviceTreeTraverseContext(
+ &Context,
+ DeviceNode,
+ IopActionInterrogateDeviceStack,
+ DeviceNode);
- Status = IopCreateDriverObject(&IopRootDriverObject, NULL, FALSE);
- if (!NT_SUCCESS(Status))
- {
- CPRINT("IoCreateDriverObject() failed\n");
- KeBugCheck(PHASE1_INITIALIZATION_FAILED);
- }
+ Status = IopTraverseDeviceTree(&Context);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("IopTraverseDeviceTree() failed with status (%x)\n", Status);
+ return Status;
+ }
- Status = IoCreateDevice(
- IopRootDriverObject,
- 0,
- NULL,
- FILE_DEVICE_CONTROLLER,
- 0,
- FALSE,
- &Pdo);
- if (!NT_SUCCESS(Status))
- {
- CPRINT("IoCreateDevice() failed\n");
- KeBugCheck(PHASE1_INITIALIZATION_FAILED);
- }
+ /*
+ * Retrieve configuration from the registry for discovered children
+ */
- Status = IopCreateDeviceNode(
- NULL,
- Pdo,
- &IopRootDeviceNode);
- if (!NT_SUCCESS(Status))
- {
- CPRINT("Insufficient resources\n");
- KeBugCheck(PHASE1_INITIALIZATION_FAILED);
- }
+ IopInitDeviceTreeTraverseContext(
+ &Context,
+ DeviceNode,
+ IopActionConfigureChildServices,
+ DeviceNode);
- IopRootDeviceNode->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
+ Status = IopTraverseDeviceTree(&Context);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("IopTraverseDeviceTree() failed with status (%x)\n", Status);
+ return Status;
+ }
+
+ /*
+ * Get the state of the system boot. If the \\SystemRoot link isn't
+ * created yet, we will assume that it's possible to load only boot
+ * drivers.
+ */
+
+ RtlInitUnicodeString(&LinkName, L"\\SystemRoot");
+
+ InitializeObjectAttributes(
+ &ObjectAttributes,
+ &LinkName,
+ 0,
+ NULL,
+ NULL);
+
+ Status = NtOpenFile(
+ &Handle,
+ FILE_ALL_ACCESS,
+ &ObjectAttributes,
+ &IoStatusBlock,
+ 0,
+ 0);
+
+ BootDrivers = NT_SUCCESS(Status) ? FALSE : TRUE;
+
+ NtClose(Handle);
+
+ /*
+ * Initialize services for discovered children. Only boot drivers will
+ * be loaded from boot driver!
+ */
+
+ Status = IopInitializePnpServices(DeviceNode, BootDrivers);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT("IopInitializePnpServices() failed with status (%x)\n", Status);
+ return Status;
+ }
- IopRootDeviceNode->DriverObject = IopRootDriverObject;
+ return STATUS_SUCCESS;
+}
- PnpRootDriverEntry(IopRootDriverObject, NULL);
- IopRootDriverObject->DriverExtension->AddDevice(
- IopRootDriverObject,
- IopRootDeviceNode->Pdo);
+VOID INIT_FUNCTION
+PnpInit(VOID)
+{
+ PDEVICE_OBJECT Pdo;
+ NTSTATUS Status;
+
+ DPRINT("PnpInit()\n");
+
+ KeInitializeSpinLock(&IopDeviceTreeLock);
+
+ /*
+ * Create root device node
+ */
+
+ Status = IopCreateDriverObject(&IopRootDriverObject, NULL, FALSE, NULL, 0);
+ if (!NT_SUCCESS(Status))
+ {
+ CPRINT("IoCreateDriverObject() failed\n");
+ KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ }
+
+ Status = IoCreateDevice(IopRootDriverObject, 0, NULL, FILE_DEVICE_CONTROLLER,
+ 0, FALSE, &Pdo);
+ if (!NT_SUCCESS(Status))
+ {
+ CPRINT("IoCreateDevice() failed\n");
+ KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ }
+
+ Status = IopCreateDeviceNode(NULL, Pdo, &IopRootDeviceNode);
+ if (!NT_SUCCESS(Status))
+ {
+ CPRINT("Insufficient resources\n");
+ KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ }
+
+ IopRootDeviceNode->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
+ PnpRootDriverEntry(IopRootDriverObject, NULL);
+ IopRootDriverObject->DriverExtension->AddDevice(
+ IopRootDriverObject,
+ IopRootDeviceNode->Pdo);
}
/* EOF */
projects / reactos.git / blobdiff