-/* $Id: pnpmgr.c,v 1.24 2004/03/14 17:10:48 navaraf Exp $
+/* $Id$
*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
- * FILE: ntoskrnl/io/pnpmgr/pnpmgr.c
- * PURPOSE: Initializes the PnP manager
- * PROGRAMMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
- * UPDATE HISTORY:
- * 16/04/2001 CSH Created
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS kernel
+ * FILE: ntoskrnl/io/pnpmgr.c
+ * PURPOSE: Initializes the PnP manager
+ *
+ * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
*/
/* INCLUDES ******************************************************************/
-#include <ddk/ntddk.h>
-#include <reactos/bugcodes.h>
-#include <internal/io.h>
-#include <internal/po.h>
-#include <internal/ldr.h>
-#include <internal/module.h>
-
-#include <ole32/guiddef.h>
-//#include <ddk/pnpfuncs.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
+#include <ntoskrnl.h>
+#include <ddk/wdmguid.h>
#define NDEBUG
#include <internal/debug.h>
-
/* GLOBALS *******************************************************************/
PDEVICE_NODE IopRootDeviceNode;
/* FUNCTIONS *****************************************************************/
-/*
- * @unimplemented
- */
-VOID
-STDCALL
-IoAdjustPagingPathCount(
- IN PLONG Count,
- IN BOOLEAN Increment)
-{
-}
-
/*
* @unimplemented
*/
IN PDEVICE_OBJECT DeviceObject,
IN DEVICE_RELATION_TYPE Type)
{
+ CHECKPOINT1;
}
PDEVICE_NODE FASTCALL
PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
ULONG Length;
PVOID Data;
+ PWSTR Ptr;
- DPRINT("IoGetDeviceProperty called\n");
+ DPRINT("IoGetDeviceProperty(%x %d)\n", DeviceObject, DeviceProperty);
- if (DeviceNode == NULL ||
- DeviceNode->BusInformation == NULL ||
- DeviceNode->CapabilityFlags == NULL)
- {
+ if (DeviceNode == NULL)
return STATUS_INVALID_DEVICE_REQUEST;
- }
- /*
- * Used IRPs:
- * IRP_MN_QUERY_ID
- * IRP_MN_QUERY_BUS_INFORMATION
- */
switch (DeviceProperty)
{
case DevicePropertyBusNumber:
Length = sizeof(ULONG);
- Data = &DeviceNode->BusInformation->BusNumber;
+ Data = &DeviceNode->ChildBusNumber;
break;
/* Complete, untested */
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]);
+ DeviceNode->BusTypeGuid.Data1,
+ DeviceNode->BusTypeGuid.Data2,
+ DeviceNode->BusTypeGuid.Data3,
+ DeviceNode->BusTypeGuid.Data4[0],
+ DeviceNode->BusTypeGuid.Data4[1],
+ DeviceNode->BusTypeGuid.Data4[2],
+ DeviceNode->BusTypeGuid.Data4[3],
+ DeviceNode->BusTypeGuid.Data4[4],
+ DeviceNode->BusTypeGuid.Data4[5],
+ DeviceNode->BusTypeGuid.Data4[6],
+ DeviceNode->BusTypeGuid.Data4[7]);
return STATUS_SUCCESS;
case DevicePropertyLegacyBusType:
Length = sizeof(INTERFACE_TYPE);
- Data = &DeviceNode->BusInformation->LegacyBusType;
+ Data = &DeviceNode->ChildInterfaceType;
break;
case DevicePropertyAddress:
Length = sizeof(ULONG);
- Data = &DeviceNode->CapabilityFlags->Address;
+ Data = &DeviceNode->Address;
break;
- case DevicePropertyUINumber:
- Length = sizeof(ULONG);
- Data = &DeviceNode->CapabilityFlags->UINumber;
- break;
+// case DevicePropertyUINumber:
+// if (DeviceNode->CapabilityFlags == NULL)
+// return STATUS_INVALID_DEVICE_REQUEST;
+// Length = sizeof(ULONG);
+// Data = &DeviceNode->CapabilityFlags->UINumber;
+// break;
- case DevicePropertyBootConfiguration:
- case DevicePropertyBootConfigurationTranslated:
- case DevicePropertyClassGuid:
case DevicePropertyClassName:
- case DevicePropertyCompatibleIDs:
- case DevicePropertyDeviceDescription:
+ case DevicePropertyClassGuid:
case DevicePropertyDriverKeyName:
- case DevicePropertyEnumeratorName:
+ case DevicePropertyManufacturer:
case DevicePropertyFriendlyName:
case DevicePropertyHardwareID:
+ case DevicePropertyCompatibleIDs:
+ case DevicePropertyDeviceDescription:
case DevicePropertyLocationInformation:
- case DevicePropertyManufacturer:
+ case DevicePropertyUINumber:
+ {
+ 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;
+ case DevicePropertyUINumber:
+ RegistryPropertyName = L"UINumber"; break;
+ default:
+ RegistryPropertyName = NULL; break;
+ }
+
+ KeyNameBuffer = ExAllocatePool(PagedPool,
+ (49 * sizeof(WCHAR)) + DeviceNode->InstancePath.Length);
+
+ DPRINT("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->BootResources->Count != 0)
+ {
+ Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
+ }
+ Data = &DeviceNode->BootResources;
+ break;
+
+ /* FIXME: use a translated boot configuration instead */
+ case DevicePropertyBootConfigurationTranslated:
+ Length = 0;
+ if (DeviceNode->BootResources->Count != 0)
+ {
+ Length = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
+ }
+ Data = &DeviceNode->BootResources;
+ 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;
return STATUS_BUFFER_TOO_SMALL;
RtlCopyMemory(PropertyBuffer, Data, Length);
- return STATUS_NOT_IMPLEMENTED;
+ /* Terminate the string */
+ if (DeviceProperty == DevicePropertyEnumeratorName)
+ {
+ Ptr = (PWSTR)PropertyBuffer;
+ Ptr[(Length / sizeof(WCHAR)) - 1] = 0;
+ }
+
+ return STATUS_SUCCESS;
}
/*
{
}
-/*
- * @unimplemented
+/**
+ * @name IoOpenDeviceRegistryKey
+ *
+ * Open a registry key unique for a specified driver or device instance.
+ *
+ * @param DeviceObject Device to get the registry key for.
+ * @param DevInstKeyType Type of the key to return.
+ * @param DesiredAccess Access mask (eg. KEY_READ | KEY_WRITE).
+ * @param DevInstRegKey Handle to the opened registry key on
+ * successful return.
+ *
+ * @return Status.
+ *
+ * @implemented
*/
NTSTATUS
STDCALL
IoOpenDeviceRegistryKey(
- IN PDEVICE_OBJECT DeviceObject,
- IN ULONG DevInstKeyType,
- IN ACCESS_MASK DesiredAccess,
- OUT PHANDLE DevInstRegKey)
+ IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG DevInstKeyType,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE DevInstRegKey)
{
- return STATUS_NOT_IMPLEMENTED;
+ static WCHAR RootKeyName[] =
+ L"\\Registry\\Machine\\System\\CurrentControlSet\\";
+ static WCHAR ProfileKeyName[] =
+ L"Hardware Profiles\\Current\\System\\CurrentControlSet\\";
+ static WCHAR ClassKeyName[] = L"Control\\Class\\";
+ static WCHAR EnumKeyName[] = L"Enum\\";
+ static WCHAR DeviceParametersKeyName[] = L"Device Parameters\\";
+ ULONG KeyNameLength;
+ LPWSTR KeyNameBuffer;
+ UNICODE_STRING KeyName;
+ ULONG DriverKeyLength;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ PDEVICE_NODE DeviceNode = NULL;
+ NTSTATUS Status;
+
+ if ((DevInstKeyType & (PLUGPLAY_REGKEY_DEVICE | PLUGPLAY_REGKEY_DRIVER)) == 0)
+ return STATUS_INVALID_PARAMETER;
+
+ /*
+ * Calculate the length of the base key name. This is the full
+ * name for driver key or the name excluding "Device Parameters"
+ * subkey for device key.
+ */
+
+ KeyNameLength = sizeof(RootKeyName);
+ if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
+ KeyNameLength += sizeof(ProfileKeyName) - sizeof(UNICODE_NULL);
+ if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
+ {
+ KeyNameLength += sizeof(ClassKeyName) - sizeof(UNICODE_NULL);
+ Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
+ 0, NULL, &DriverKeyLength);
+ if (Status != STATUS_BUFFER_TOO_SMALL)
+ return Status;
+ KeyNameLength += DriverKeyLength;
+ }
+ else
+ {
+ DeviceNode = IopGetDeviceNode(DeviceObject);
+ KeyNameLength += sizeof(EnumKeyName) - sizeof(UNICODE_NULL) +
+ DeviceNode->InstancePath.Length;
+ }
+
+ /*
+ * Now allocate the buffer for the key name...
+ */
+
+ KeyNameBuffer = ExAllocatePool(PagedPool, KeyNameLength);
+ if (KeyNameBuffer == NULL)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ KeyName.Length = 0;
+ KeyName.MaximumLength = KeyNameLength;
+ KeyName.Buffer = KeyNameBuffer;
+
+ /*
+ * ...and build the key name.
+ */
+
+ KeyName.Length += sizeof(RootKeyName) - sizeof(UNICODE_NULL);
+ RtlCopyMemory(KeyNameBuffer, RootKeyName, KeyName.Length);
+
+ if (DevInstKeyType & PLUGPLAY_REGKEY_CURRENT_HWPROFILE)
+ RtlAppendUnicodeToString(&KeyName, ProfileKeyName);
+
+ if (DevInstKeyType & PLUGPLAY_REGKEY_DRIVER)
+ {
+ RtlAppendUnicodeToString(&KeyName, ClassKeyName);
+ Status = IoGetDeviceProperty(DeviceObject, DevicePropertyDriverKeyName,
+ DriverKeyLength, KeyNameBuffer +
+ (KeyName.Length / sizeof(WCHAR)),
+ &DriverKeyLength);
+ if (!NT_SUCCESS(Status))
+ {
+ ExFreePool(KeyNameBuffer);
+ return Status;
+ }
+ KeyName.Length += DriverKeyLength - sizeof(UNICODE_NULL);
+ }
+ else
+ {
+ RtlAppendUnicodeToString(&KeyName, EnumKeyName);
+ Status = RtlAppendUnicodeStringToString(&KeyName, &DeviceNode->InstancePath);
+ if (DeviceNode->InstancePath.Length == 0)
+ {
+ ExFreePool(KeyNameBuffer);
+ return Status;
+ }
+ }
+
+ /*
+ * Open the base key.
+ */
+
+ InitializeObjectAttributes(&ObjectAttributes, &KeyName,
+ OBJ_CASE_INSENSITIVE, NULL, NULL);
+ Status = ZwOpenKey(DevInstRegKey, DesiredAccess, &ObjectAttributes);
+ ExFreePool(KeyNameBuffer);
+
+ /*
+ * For driver key we're done now. Also if the base key doesn't
+ * exist we can bail out with error...
+ */
+
+ if ((DevInstKeyType & PLUGPLAY_REGKEY_DRIVER) || !NT_SUCCESS(Status))
+ return Status;
+
+ /*
+ * Let's go further. For device key we must open "Device Parameters"
+ * subkey and create it if it doesn't exist yet.
+ */
+
+ RtlInitUnicodeString(&KeyName, DeviceParametersKeyName);
+ InitializeObjectAttributes(&ObjectAttributes, &KeyName,
+ OBJ_CASE_INSENSITIVE, *DevInstRegKey, NULL);
+ Status = ZwCreateKey(DevInstRegKey, DesiredAccess, &ObjectAttributes,
+ 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
+ ZwClose(ObjectAttributes.RootDirectory);
+
+ return Status;
}
/*
VOID
STDCALL
IoRequestDeviceEject(
- IN PDEVICE_OBJECT PhysicalDeviceObject)
+ IN PDEVICE_OBJECT PhysicalDeviceObject
+ )
{
+ UNIMPLEMENTED;
}
BOOLEAN
IopCreateUnicodeString(
- PUNICODE_STRING Destination,
+ PUNICODE_STRING Destination,
PWSTR Source,
POOL_TYPE PoolType)
{
{
KIRQL OldIrql;
- assert(PopSystemPowerDeviceNode);
+ if (PopSystemPowerDeviceNode)
+ {
+ KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
+ *DeviceObject = PopSystemPowerDeviceNode->PhysicalDeviceObject;
+ KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
- KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
- *DeviceObject = PopSystemPowerDeviceNode->Pdo;
- KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
+ return STATUS_SUCCESS;
+ }
- return STATUS_SUCCESS;
+ return STATUS_UNSUCCESSFUL;
}
-/**********************************************************************
+/*
* DESCRIPTION
* Creates a device node
*
DPRINT("ParentNode %x PhysicalDeviceObject %x\n",
ParentNode, PhysicalDeviceObject);
- Node = (PDEVICE_NODE)ExAllocatePool(PagedPool, sizeof(DEVICE_NODE));
+ Node = (PDEVICE_NODE)ExAllocatePool(NonPagedPool, sizeof(DEVICE_NODE));
if (!Node)
{
return STATUS_INSUFFICIENT_RESOURCES;
IopDeviceNodeSetFlag(Node, DNF_LEGACY_DRIVER);
}
- Node->Pdo = PhysicalDeviceObject;
+ Node->PhysicalDeviceObject = PhysicalDeviceObject;
PhysicalDeviceObject->DeviceObjectExtension->DeviceNode = Node;
Node->NextSibling = ParentNode->Child;
if (ParentNode->Child != NULL)
{
- ParentNode->Child->PrevSibling = Node;
+ ParentNode->Child->PrevSibling = Node;
}
ParentNode->Child = Node;
KeReleaseSpinLock(&IopDeviceTreeLock, OldIrql);
KIRQL OldIrql;
/* All children must be deleted before a parent is deleted */
- assert(!DeviceNode->Child);
+ ASSERT(!DeviceNode->Child);
KeAcquireSpinLock(&IopDeviceTreeLock, &OldIrql);
- assert(DeviceNode->Pdo);
+ ASSERT(DeviceNode->PhysicalDeviceObject);
- ObDereferenceObject(DeviceNode->Pdo);
+ ObDereferenceObject(DeviceNode->PhysicalDeviceObject);
/* 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);
- }
-
- if (DeviceNode->CmResourceList)
- {
- ExFreePool(DeviceNode->CmResourceList);
- }
-
- if (DeviceNode->BootResourcesList)
- {
- ExFreePool(DeviceNode->BootResourcesList);
- }
-
- if (DeviceNode->ResourceRequirementsList)
- {
- ExFreePool(DeviceNode->ResourceRequirementsList);
- }
-
- RtlFreeUnicodeString(&DeviceNode->DeviceID);
-
- RtlFreeUnicodeString(&DeviceNode->InstanceID);
-
- RtlFreeUnicodeString(&DeviceNode->HardwareIDs);
-
- RtlFreeUnicodeString(&DeviceNode->CompatibleIDs);
+ if (DeviceNode->ResourceList)
+ {
+ ExFreePool(DeviceNode->ResourceList);
+ }
- RtlFreeUnicodeString(&DeviceNode->DeviceText);
+ if (DeviceNode->ResourceListTranslated)
+ {
+ ExFreePool(DeviceNode->ResourceListTranslated);
+ }
- RtlFreeUnicodeString(&DeviceNode->DeviceTextLocation);
+ if (DeviceNode->ResourceRequirements)
+ {
+ ExFreePool(DeviceNode->ResourceRequirements);
+ }
- if (DeviceNode->BusInformation)
- {
- ExFreePool(DeviceNode->BusInformation);
- }
+ if (DeviceNode->BootResources)
+ {
+ ExFreePool(DeviceNode->BootResources);
+ }
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;
}
}
-NTSTATUS
-IopQueryCapabilities(
- PDEVICE_OBJECT Pdo,
- PDEVICE_CAPABILITIES *Capabilities)
-{
- IO_STATUS_BLOCK IoStatusBlock;
- PDEVICE_CAPABILITIES Caps;
- IO_STACK_LOCATION Stack;
- NTSTATUS Status;
-
- DPRINT("Sending IRP_MN_QUERY_CAPABILITIES to device stack\n");
-
- *Capabilities = NULL;
-
- Caps = ExAllocatePool(PagedPool, sizeof(DEVICE_CAPABILITIES));
- if (!Caps)
- {
- return STATUS_INSUFFICIENT_RESOURCES;
- }
-
- RtlZeroMemory(Caps, sizeof(DEVICE_CAPABILITIES));
- Caps->Size = sizeof(DEVICE_CAPABILITIES);
- Caps->Version = 1;
- Caps->Address = -1;
- Caps->UINumber = -1;
-
- Stack.Parameters.DeviceCapabilities.Capabilities = Caps;
-
- Status = IopInitiatePnpIrp(
- Pdo,
- &IoStatusBlock,
- IRP_MN_QUERY_CAPABILITIES,
- &Stack);
- if (NT_SUCCESS(Status))
- {
- *Capabilities = Caps;
- }
- else
- {
- DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- }
-
- return Status;
-}
-
-
NTSTATUS
IopTraverseDeviceTreeNode(
PDEVICETREE_TRAVERSE_CONTEXT Context)
static NTSTATUS
-IopCreateDeviceKeyPath(PWSTR Path)
+IopCreateDeviceKeyPath(PWSTR Path,
+ PHANDLE Handle)
{
OBJECT_ATTRIBUTES ObjectAttributes;
WCHAR KeyBuffer[MAX_PATH];
PWCHAR Current;
PWCHAR Next;
+ *Handle = NULL;
+
if (_wcsnicmp(Path, L"\\Registry\\", 10) != 0)
{
return STATUS_INVALID_PARAMETER;
}
wcsncpy (KeyBuffer, Path, MAX_PATH-1);
- RtlInitUnicodeString (&KeyName, KeyBuffer);
/* Skip \\Registry\\ */
- Current = KeyName.Buffer;
- Current = wcschr (Current, '\\') + 1;
- Current = wcschr (Current, '\\') + 1;
+ Current = KeyBuffer;
+ Current = wcschr (Current, L'\\') + 1;
+ Current = wcschr (Current, L'\\') + 1;
- do
- {
- Next = wcschr (Current, '\\');
+ while (TRUE)
+ {
+ Next = wcschr (Current, L'\\');
if (Next == NULL)
{
/* The end */
*Next = 0;
}
+ RtlInitUnicodeString (&KeyName, KeyBuffer);
InitializeObjectAttributes (&ObjectAttributes,
&KeyName,
OBJ_CASE_INSENSITIVE,
DPRINT("Create '%S'\n", KeyName.Buffer);
- Status = NtCreateKey (&KeyHandle,
+ Status = ZwCreateKey (&KeyHandle,
KEY_ALL_ACCESS,
&ObjectAttributes,
0,
NULL);
if (!NT_SUCCESS (Status))
{
- DPRINT ("NtCreateKey() failed with status %x\n", Status);
+ DPRINT ("ZwCreateKey() failed with status %x\n", Status);
return Status;
}
- NtClose (KeyHandle);
-
- if (Next != NULL)
+ if (Next == NULL)
{
+ *Handle = KeyHandle;
+ return STATUS_SUCCESS;
+ }
+ else
+ {
+ ZwClose (KeyHandle);
*Next = L'\\';
}
Current = Next + 1;
}
- while (Next != NULL);
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+
+static NTSTATUS
+IopSetDeviceInstanceData(HANDLE InstanceKey,
+ PDEVICE_NODE DeviceNode)
+{
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ UNICODE_STRING KeyName;
+ HANDLE LogConfKey;
+ ULONG ResCount;
+ ULONG ListSize;
+ NTSTATUS Status;
+
+ DPRINT("IopSetDeviceInstanceData() called\n");
+
+ /* Create the 'LogConf' key */
+ RtlInitUnicodeString(&KeyName,
+ L"LogConf");
+ InitializeObjectAttributes(&ObjectAttributes,
+ &KeyName,
+ OBJ_CASE_INSENSITIVE,
+ InstanceKey,
+ NULL);
+ Status = ZwCreateKey(&LogConfKey,
+ KEY_ALL_ACCESS,
+ &ObjectAttributes,
+ 0,
+ NULL,
+ 0,
+ NULL);
+ if (NT_SUCCESS(Status))
+ {
+ /* Set 'BootConfig' value */
+ if (DeviceNode->BootResources != NULL)
+ {
+ ResCount = DeviceNode->BootResources->Count;
+ if (ResCount != 0)
+ {
+ ListSize = CM_RESOURCE_LIST_SIZE(DeviceNode->BootResources);
+
+ RtlInitUnicodeString(&KeyName,
+ L"BootConfig");
+ Status = ZwSetValueKey(LogConfKey,
+ &KeyName,
+ 0,
+ REG_RESOURCE_LIST,
+ &DeviceNode->BootResources,
+ ListSize);
+ }
+ }
+
+ /* Set 'BasicConfigVector' value */
+ if (DeviceNode->ResourceRequirements != NULL &&
+ DeviceNode->ResourceRequirements->ListSize != 0)
+ {
+ RtlInitUnicodeString(&KeyName,
+ L"BasicConfigVector");
+ Status = ZwSetValueKey(LogConfKey,
+ &KeyName,
+ 0,
+ REG_RESOURCE_REQUIREMENTS_LIST,
+ &DeviceNode->ResourceRequirements,
+ DeviceNode->ResourceRequirements->ListSize);
+ }
+
+ ZwClose(LogConfKey);
+ }
+
+ DPRINT("IopSetDeviceInstanceData() done\n");
return STATUS_SUCCESS;
}
IO_STACK_LOCATION Stack;
NTSTATUS Status;
PWSTR KeyBuffer;
+ PWSTR Ptr;
+ USHORT Length;
+ USHORT TotalLength;
+ HANDLE InstanceKey = NULL;
+ UNICODE_STRING ValueName;
+ DEVICE_CAPABILITIES DeviceCapabilities;
DPRINT("IopActionInterrogateDeviceStack(%p, %p)\n", DeviceNode, Context);
- DPRINT("PDO %x\n", DeviceNode->Pdo);
+ DPRINT("PDO %x\n", DeviceNode->PhysicalDeviceObject);
ParentDeviceNode = (PDEVICE_NODE)Context;
Stack.Parameters.QueryId.IdType = BusQueryDeviceID;
Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
+ DeviceNode->PhysicalDeviceObject,
&IoStatusBlock,
IRP_MN_QUERY_ID,
&Stack);
if (NT_SUCCESS(Status))
{
- RtlInitUnicodeString(
- &DeviceNode->DeviceID,
- (LPWSTR)IoStatusBlock.Information);
+ /* Copy the device id string */
+ wcscpy(InstancePath, (PWSTR)IoStatusBlock.Information);
/*
* FIXME: Check for valid characters, if there is invalid characters
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;
Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
+ DeviceNode->PhysicalDeviceObject,
&IoStatusBlock,
IRP_MN_QUERY_ID,
&Stack);
if (NT_SUCCESS(Status))
{
- RtlInitUnicodeString(
- &DeviceNode->InstanceID,
- (LPWSTR)IoStatusBlock.Information);
+ /* Append the instance id string */
+ wcscat(InstancePath, L"\\");
+ wcscat(InstancePath, (PWSTR)IoStatusBlock.Information);
/*
* FIXME: Check for valid characters, if there is invalid characters
else
{
DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- RtlInitUnicodeString(&DeviceNode->InstanceID, NULL);
}
- /* FIXME: SEND IRP_QUERY_ID.BusQueryHardwareIDs */
- /* FIXME: SEND IRP_QUERY_ID.BusQueryCompatibleIDs */
+ RtlZeroMemory(&DeviceCapabilities, sizeof(DEVICE_CAPABILITIES));
+ DeviceCapabilities.Size = sizeof(DEVICE_CAPABILITIES);
+ DeviceCapabilities.Version = 1;
+ DeviceCapabilities.Address = -1;
+ DeviceCapabilities.UINumber = -1;
- Status = IopQueryCapabilities(DeviceNode->Pdo, &DeviceNode->CapabilityFlags);
+ Stack.Parameters.DeviceCapabilities.Capabilities = &DeviceCapabilities;
+ Status = IopInitiatePnpIrp(
+ DeviceNode->PhysicalDeviceObject,
+ &IoStatusBlock,
+ IRP_MN_QUERY_CAPABILITIES,
+ &Stack);
if (NT_SUCCESS(Status))
{
}
else
{
+ DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
+ }
+
+ DeviceNode->CapabilityFlags = *(PULONG)((ULONG_PTR)&DeviceCapabilities + 4);
+ DeviceNode->Address = DeviceCapabilities.Address;
+
+ if (!DeviceCapabilities.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);
+
+ /*
+ * 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);
+ }
+
+
+ {
+ /* Set 'Capabilities' value */
+ RtlInitUnicodeString(&ValueName,
+ L"Capabilities");
+ Status = ZwSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_DWORD,
+ (PVOID)&DeviceNode->CapabilityFlags,
+ sizeof(ULONG));
+
+ /* Set 'UINumber' value */
+ if (DeviceCapabilities.UINumber != (ULONG)-1)
+ {
+ RtlInitUnicodeString(&ValueName,
+ L"UINumber");
+ Status = ZwSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_DWORD,
+ &DeviceCapabilities.UINumber,
+ sizeof(ULONG));
+ }
+ }
+
+ DPRINT("Sending IRP_MN_QUERY_ID.BusQueryHardwareIDs to device stack\n");
+
+ Stack.Parameters.QueryId.IdType = BusQueryHardwareIDs;
+ Status = IopInitiatePnpIrp(
+ DeviceNode->PhysicalDeviceObject,
+ &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 = ZwSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_MULTI_SZ,
+ (PVOID)IoStatusBlock.Information,
+ (TotalLength + 1) * sizeof(WCHAR));
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("ZwSetValueKey() 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->PhysicalDeviceObject,
+ &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 = ZwSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_MULTI_SZ,
+ (PVOID)IoStatusBlock.Information,
+ (TotalLength + 1) * sizeof(WCHAR));
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("ZwSetValueKey() 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,
+ DeviceNode->PhysicalDeviceObject,
&IoStatusBlock,
IRP_MN_QUERY_DEVICE_TEXT,
&Stack);
if (NT_SUCCESS(Status))
{
- RtlInitUnicodeString(
- &DeviceNode->DeviceText,
- (LPWSTR)IoStatusBlock.Information);
+ RtlInitUnicodeString(&ValueName,
+ L"DeviceDesc");
+ Status = ZwSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_SZ,
+ (PVOID)IoStatusBlock.Information,
+ (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
+ }
}
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,
+ DeviceNode->PhysicalDeviceObject,
&IoStatusBlock,
IRP_MN_QUERY_DEVICE_TEXT,
&Stack);
if (NT_SUCCESS(Status))
{
- RtlInitUnicodeString(
- &DeviceNode->DeviceTextLocation,
- (LPWSTR)IoStatusBlock.Information);
+ DPRINT("LocationInformation: %S\n", (PWSTR)IoStatusBlock.Information);
+ RtlInitUnicodeString(&ValueName,
+ L"LocationInformation");
+ Status = ZwSetValueKey(InstanceKey,
+ &ValueName,
+ 0,
+ REG_SZ,
+ (PVOID)IoStatusBlock.Information,
+ (wcslen((PWSTR)IoStatusBlock.Information) + 1) * sizeof(WCHAR));
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("ZwSetValueKey() failed (Status %lx)\n", Status);
+ }
}
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,
+ DeviceNode->PhysicalDeviceObject,
&IoStatusBlock,
IRP_MN_QUERY_BUS_INFORMATION,
NULL);
if (NT_SUCCESS(Status))
{
- DeviceNode->BusInformation =
+ PPNP_BUS_INFORMATION BusInformation =
(PPNP_BUS_INFORMATION)IoStatusBlock.Information;
+
+ DeviceNode->ChildBusNumber = BusInformation->BusNumber;
+ DeviceNode->ChildInterfaceType = BusInformation->LegacyBusType;
+ memcpy(&DeviceNode->BusTypeGuid,
+ &BusInformation->BusTypeGuid,
+ sizeof(GUID));
+ ExFreePool(BusInformation);
}
else
{
DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- DeviceNode->BusInformation = NULL;
+
+ DeviceNode->ChildBusNumber = -1;
+ DeviceNode->ChildInterfaceType = -1;
+ memset(&DeviceNode->BusTypeGuid,
+ 0,
+ sizeof(GUID));
}
DPRINT("Sending IRP_MN_QUERY_RESOURCES to device stack\n");
Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
+ DeviceNode->PhysicalDeviceObject,
&IoStatusBlock,
IRP_MN_QUERY_RESOURCES,
NULL);
if (NT_SUCCESS(Status))
{
- DeviceNode->BootResourcesList =
+ DeviceNode->BootResources =
(PCM_RESOURCE_LIST)IoStatusBlock.Information;
DeviceNode->Flags |= DNF_HAS_BOOT_CONFIG;
}
else
{
DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- DeviceNode->BootResourcesList = NULL;
+ DeviceNode->BootResources = NULL;
}
DPRINT("Sending IRP_MN_QUERY_RESOURCE_REQUIREMENTS to device stack\n");
Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
+ DeviceNode->PhysicalDeviceObject,
&IoStatusBlock,
IRP_MN_QUERY_RESOURCE_REQUIREMENTS,
NULL);
if (NT_SUCCESS(Status))
{
- DeviceNode->ResourceRequirementsList =
+ DeviceNode->ResourceRequirements =
(PIO_RESOURCE_REQUIREMENTS_LIST)IoStatusBlock.Information;
}
else
{
DPRINT("IopInitiatePnpIrp() failed (Status %x)\n", Status);
- DeviceNode->ResourceRequirementsList = NULL;
+ DeviceNode->ResourceRequirements = 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))
+ if (InstanceKey != NULL)
{
- DPRINT("No resources\n");
- /* FIXME: Cleanup and disable device */
+ IopSetDeviceInstanceData(InstanceKey, DeviceNode);
}
- DPRINT("InstancePath is %S\n", DeviceNode->InstancePath.Buffer);
-
- /*
- * Create registry key for the instance id, if it doesn't exist yet
- */
+ ZwClose(InstanceKey);
- KeyBuffer = ExAllocatePool(PagedPool, (49 + DeviceNode->InstancePath.Length) * sizeof(WCHAR));
- wcscpy(KeyBuffer, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
- wcscat(KeyBuffer, DeviceNode->InstancePath.Buffer);
- IopCreateDeviceKeyPath(KeyBuffer);
- ExFreePool(KeyBuffer);
DeviceNode->Flags |= DNF_PROCESSED;
+ /* Report the device to the user-mode pnp manager */
+ IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
+ &DeviceNode->InstancePath);
+
return STATUS_SUCCESS;
}
if (!IopDeviceNodeHasFlag(DeviceNode, DNF_DISABLED))
{
+ WCHAR RegKeyBuffer[MAX_PATH];
+ UNICODE_STRING RegKey;
+
+ RegKey.Length = 0;
+ RegKey.MaximumLength = sizeof(RegKeyBuffer);
+ RegKey.Buffer = RegKeyBuffer;
+
/*
* Retrieve configuration from Enum key
*/
QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
QueryTable[0].EntryContext = Service;
- Status = RtlQueryRegistryValues(RTL_REGISTRY_ENUM,
- DeviceNode->InstancePath.Buffer, QueryTable, NULL, NULL);
+ RtlAppendUnicodeToString(&RegKey, L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum\\");
+ RtlAppendUnicodeStringToString(&RegKey, &DeviceNode->InstancePath);
+
+ Status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
+ RegKey.Buffer, QueryTable, NULL, NULL);
if (!NT_SUCCESS(Status))
{
!IopDeviceNodeHasFlag(DeviceNode, DNF_ADDED) &&
!IopDeviceNodeHasFlag(DeviceNode, DNF_STARTED))
{
- Status = IopInitializeDeviceNodeService(DeviceNode, BootDrivers);
+ PMODULE_OBJECT ModuleObject;
+ PDRIVER_OBJECT DriverObject;
+
+ Status = IopLoadServiceModule(&DeviceNode->ServiceName, &ModuleObject);
if (NT_SUCCESS(Status))
{
- IopDeviceNodeSetFlag(DeviceNode, DNF_STARTED);
- } else
+ 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
* parent node. This function just calls IopActionInitChildServices with
* BootDrivers = TRUE.
*/
-
NTSTATUS
IopActionInitBootServices(
PDEVICE_NODE DeviceNode,
* 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,
NTSTATUS
IopInvalidateDeviceRelations(
- IN PDEVICE_NODE DeviceNode,
- IN DEVICE_RELATION_TYPE Type,
- IN BOOLEAN BootDriver)
+ 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;
Stack.Parameters.QueryDeviceRelations.Type = Type/*BusRelations*/;
Status = IopInitiatePnpIrp(
- DeviceNode->Pdo,
+ DeviceNode->PhysicalDeviceObject,
&IoStatusBlock,
IRP_MN_QUERY_DEVICE_RELATIONS,
&Stack);
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 = ZwOpenFile(
+ &Handle,
+ FILE_ALL_ACCESS,
+ &ObjectAttributes,
+ &IoStatusBlock,
+ 0,
+ 0);
+ if(NT_SUCCESS(Status))
+ {
+ BootDrivers = FALSE;
+ ZwClose(Handle);
+ }
+ else
+ BootDrivers = TRUE;
+
/*
* Initialize services for discovered children. Only boot drivers will
* be loaded from boot driver!
*/
- Status = IopInitializePnpServices(DeviceNode, BootDriver);
+ Status = IopInitializePnpServices(DeviceNode, BootDrivers);
if (!NT_SUCCESS(Status))
{
DPRINT("IopInitializePnpServices() failed with status (%x)\n", Status);
return STATUS_SUCCESS;
}
+
VOID INIT_FUNCTION
PnpInit(VOID)
{
KeInitializeSpinLock(&IopDeviceTreeLock);
+ /* Initialize PnP-Event notification support */
+ Status = IopInitPlugPlayEvents();
+ if (!NT_SUCCESS(Status))
+ {
+ CPRINT("IopInitPlugPlayEvents() failed\n");
+ KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
+ }
+
/*
* Create root device node
*/
if (!NT_SUCCESS(Status))
{
CPRINT("IoCreateDriverObject() failed\n");
- KEBUGCHECK(PHASE1_INITIALIZATION_FAILED);
+ KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
}
Status = IoCreateDevice(IopRootDriverObject, 0, NULL, FILE_DEVICE_CONTROLLER,
if (!NT_SUCCESS(Status))
{
CPRINT("IoCreateDevice() failed\n");
- KEBUGCHECK(PHASE1_INITIALIZATION_FAILED);
+ KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
}
Status = IopCreateDeviceNode(NULL, Pdo, &IopRootDeviceNode);
if (!NT_SUCCESS(Status))
{
CPRINT("Insufficient resources\n");
- KEBUGCHECK(PHASE1_INITIALIZATION_FAILED);
+ KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
}
- IopRootDeviceNode->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
- IopRootDeviceNode->DriverObject = IopRootDriverObject;
+
+ if (!IopCreateUnicodeString(&IopRootDeviceNode->InstancePath,
+ L"HTREE\\Root\\0",
+ PagedPool))
+ {
+ CPRINT("Failed to create the instance path!\n");
+ KEBUGCHECKEX(PHASE1_INITIALIZATION_FAILED, STATUS_UNSUCCESSFUL, 0, 0, 0);
+ }
+
+ /* Report the device to the user-mode pnp manager */
+ IopQueueTargetDeviceEvent(&GUID_DEVICE_ARRIVAL,
+ &IopRootDeviceNode->InstancePath);
+
+ IopRootDeviceNode->PhysicalDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE;
PnpRootDriverEntry(IopRootDriverObject, NULL);
IopRootDriverObject->DriverExtension->AddDevice(
IopRootDriverObject,
- IopRootDeviceNode->Pdo);
+ IopRootDeviceNode->PhysicalDeviceObject);
}
/* EOF */
projects / reactos.git / blobdiff