mirror of
https://github.com/reactos/reactos.git
synced 2024-08-29 14:48:37 +00:00
1158 lines
36 KiB
C
1158 lines
36 KiB
C
/*
|
|
* PROJECT: ReactOS Kernel
|
|
* COPYRIGHT: GPL - See COPYING in the top level directory
|
|
* FILE: ntoskrnl/io/pnpmgr/pnproot.c
|
|
* PURPOSE: PnP manager root device
|
|
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
|
|
* Copyright 2007 Herv? Poussineau (hpoussin@reactos.org)
|
|
*/
|
|
|
|
/* INCLUDES ******************************************************************/
|
|
|
|
#include <ntoskrnl.h>
|
|
#define NDEBUG
|
|
#include <debug.h>
|
|
|
|
/* GLOBALS *******************************************************************/
|
|
|
|
#define ENUM_NAME_ROOT L"Root"
|
|
|
|
/* DATA **********************************************************************/
|
|
|
|
typedef struct _PNPROOT_DEVICE
|
|
{
|
|
// Entry on device list
|
|
LIST_ENTRY ListEntry;
|
|
// Physical Device Object of device
|
|
PDEVICE_OBJECT Pdo;
|
|
// Device ID
|
|
UNICODE_STRING DeviceID;
|
|
// Instance ID
|
|
UNICODE_STRING InstanceID;
|
|
// Device description
|
|
UNICODE_STRING DeviceDescription;
|
|
// Resource requirement list
|
|
PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirementsList;
|
|
ULONG ResourceRequirementsListSize;
|
|
// Associated resource list
|
|
PCM_RESOURCE_LIST ResourceList;
|
|
ULONG ResourceListSize;
|
|
} PNPROOT_DEVICE, *PPNPROOT_DEVICE;
|
|
|
|
typedef enum
|
|
{
|
|
dsStopped,
|
|
dsStarted,
|
|
dsPaused,
|
|
dsRemoved,
|
|
dsSurpriseRemoved
|
|
} PNPROOT_DEVICE_STATE;
|
|
|
|
typedef struct _PNPROOT_COMMON_DEVICE_EXTENSION
|
|
{
|
|
// Wether this device extension is for an FDO or PDO
|
|
BOOLEAN IsFDO;
|
|
} PNPROOT_COMMON_DEVICE_EXTENSION, *PPNPROOT_COMMON_DEVICE_EXTENSION;
|
|
|
|
/* Physical Device Object device extension for a child device */
|
|
typedef struct _PNPROOT_PDO_DEVICE_EXTENSION
|
|
{
|
|
// Common device data
|
|
PNPROOT_COMMON_DEVICE_EXTENSION Common;
|
|
// Informations about the device
|
|
PPNPROOT_DEVICE DeviceInfo;
|
|
} PNPROOT_PDO_DEVICE_EXTENSION, *PPNPROOT_PDO_DEVICE_EXTENSION;
|
|
|
|
/* Physical Device Object device extension for the Root bus device object */
|
|
typedef struct _PNPROOT_FDO_DEVICE_EXTENSION
|
|
{
|
|
// Common device data
|
|
PNPROOT_COMMON_DEVICE_EXTENSION Common;
|
|
// Lower device object
|
|
PDEVICE_OBJECT Ldo;
|
|
// Current state of the driver
|
|
PNPROOT_DEVICE_STATE State;
|
|
// Namespace device list
|
|
LIST_ENTRY DeviceListHead;
|
|
// Number of (not removed) devices in device list
|
|
ULONG DeviceListCount;
|
|
// Lock for namespace device list
|
|
KGUARDED_MUTEX DeviceListLock;
|
|
} PNPROOT_FDO_DEVICE_EXTENSION, *PPNPROOT_FDO_DEVICE_EXTENSION;
|
|
|
|
typedef struct _BUFFER
|
|
{
|
|
PVOID *Data;
|
|
PULONG Length;
|
|
} BUFFER, *PBUFFER;
|
|
|
|
static PDEVICE_OBJECT PnpRootDeviceObject = NULL;
|
|
|
|
/* FUNCTIONS *****************************************************************/
|
|
|
|
static NTSTATUS
|
|
LocateChildDevice(
|
|
IN PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension,
|
|
IN PCWSTR DeviceId,
|
|
IN PCWSTR InstanceId,
|
|
OUT PPNPROOT_DEVICE* ChildDevice)
|
|
{
|
|
PPNPROOT_DEVICE Device;
|
|
UNICODE_STRING DeviceIdU, InstanceIdU;
|
|
PLIST_ENTRY NextEntry;
|
|
|
|
/* Initialize the strings to compare */
|
|
RtlInitUnicodeString(&DeviceIdU, DeviceId);
|
|
RtlInitUnicodeString(&InstanceIdU, InstanceId);
|
|
|
|
/* Start looping */
|
|
for (NextEntry = DeviceExtension->DeviceListHead.Flink;
|
|
NextEntry != &DeviceExtension->DeviceListHead;
|
|
NextEntry = NextEntry->Flink)
|
|
{
|
|
/* Get the entry */
|
|
Device = CONTAINING_RECORD(NextEntry, PNPROOT_DEVICE, ListEntry);
|
|
|
|
/* See if the strings match */
|
|
if (RtlEqualUnicodeString(&DeviceIdU, &Device->DeviceID, TRUE) &&
|
|
RtlEqualUnicodeString(&InstanceIdU, &Device->InstanceID, TRUE))
|
|
{
|
|
/* They do, so set the pointer and return success */
|
|
*ChildDevice = Device;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
}
|
|
|
|
/* No device found */
|
|
return STATUS_NO_SUCH_DEVICE;
|
|
}
|
|
|
|
/* Creates a new PnP device for a legacy driver */
|
|
NTSTATUS
|
|
PnpRootCreateDevice(
|
|
IN PUNICODE_STRING ServiceName,
|
|
IN PDEVICE_OBJECT *PhysicalDeviceObject)
|
|
{
|
|
PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension;
|
|
UNICODE_STRING UnknownServiceName = RTL_CONSTANT_STRING(L"UNKNOWN");
|
|
PUNICODE_STRING LocalServiceName;
|
|
PPNPROOT_PDO_DEVICE_EXTENSION PdoDeviceExtension;
|
|
WCHAR DevicePath[MAX_PATH + 1];
|
|
WCHAR InstancePath[5];
|
|
PPNPROOT_DEVICE Device = NULL;
|
|
NTSTATUS Status;
|
|
ULONG i;
|
|
|
|
DeviceExtension = PnpRootDeviceObject->DeviceExtension;
|
|
KeAcquireGuardedMutex(&DeviceExtension->DeviceListLock);
|
|
|
|
if (ServiceName)
|
|
LocalServiceName = ServiceName;
|
|
else
|
|
LocalServiceName = &UnknownServiceName;
|
|
|
|
DPRINT("Creating a PnP root device for service '%wZ'\n", LocalServiceName);
|
|
|
|
/* Search for a free instance ID */
|
|
_snwprintf(DevicePath, sizeof(DevicePath) / sizeof(WCHAR), L"%s\\LEGACY_%wZ", REGSTR_KEY_ROOTENUM, LocalServiceName);
|
|
for (i = 0; i < 9999; i++)
|
|
{
|
|
_snwprintf(InstancePath, sizeof(InstancePath) / sizeof(WCHAR), L"%04lu", i);
|
|
Status = LocateChildDevice(DeviceExtension, DevicePath, InstancePath, &Device);
|
|
if (Status == STATUS_NO_SUCH_DEVICE)
|
|
break;
|
|
}
|
|
if (i == 9999)
|
|
{
|
|
DPRINT1("Too much legacy devices reported for service '%wZ'\n", &LocalServiceName);
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Initialize a PNPROOT_DEVICE structure */
|
|
Device = ExAllocatePoolWithTag(PagedPool, sizeof(PNPROOT_DEVICE), TAG_PNP_ROOT);
|
|
if (!Device)
|
|
{
|
|
DPRINT("ExAllocatePoolWithTag() failed\n");
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
RtlZeroMemory(Device, sizeof(PNPROOT_DEVICE));
|
|
if (!RtlCreateUnicodeString(&Device->DeviceID, DevicePath))
|
|
{
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
if (!RtlCreateUnicodeString(&Device->InstanceID, InstancePath))
|
|
{
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Initialize a device object */
|
|
Status = IoCreateDevice(
|
|
PnpRootDeviceObject->DriverObject,
|
|
sizeof(PNPROOT_PDO_DEVICE_EXTENSION),
|
|
NULL,
|
|
FILE_DEVICE_CONTROLLER,
|
|
FILE_AUTOGENERATED_DEVICE_NAME,
|
|
FALSE,
|
|
&Device->Pdo);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("IoCreateDevice() failed with status 0x%08lx\n", Status);
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
|
|
PdoDeviceExtension = (PPNPROOT_PDO_DEVICE_EXTENSION)Device->Pdo->DeviceExtension;
|
|
RtlZeroMemory(PdoDeviceExtension, sizeof(PNPROOT_PDO_DEVICE_EXTENSION));
|
|
PdoDeviceExtension->Common.IsFDO = FALSE;
|
|
PdoDeviceExtension->DeviceInfo = Device;
|
|
|
|
Device->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
|
|
Device->Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
|
|
|
|
InsertTailList(
|
|
&DeviceExtension->DeviceListHead,
|
|
&Device->ListEntry);
|
|
DeviceExtension->DeviceListCount++;
|
|
|
|
*PhysicalDeviceObject = Device->Pdo;
|
|
DPRINT("Created PDO %p (%wZ\\%wZ)\n", *PhysicalDeviceObject, &Device->DeviceID, &Device->InstanceID);
|
|
Device = NULL;
|
|
Status = STATUS_SUCCESS;
|
|
|
|
cleanup:
|
|
KeReleaseGuardedMutex(&DeviceExtension->DeviceListLock);
|
|
if (Device)
|
|
{
|
|
if (Device->Pdo)
|
|
IoDeleteDevice(Device->Pdo);
|
|
RtlFreeUnicodeString(&Device->DeviceID);
|
|
RtlFreeUnicodeString(&Device->InstanceID);
|
|
ExFreePoolWithTag(Device, TAG_PNP_ROOT);
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
static NTSTATUS NTAPI
|
|
QueryStringCallback(
|
|
IN PWSTR ValueName,
|
|
IN ULONG ValueType,
|
|
IN PVOID ValueData,
|
|
IN ULONG ValueLength,
|
|
IN PVOID Context,
|
|
IN PVOID EntryContext)
|
|
{
|
|
PUNICODE_STRING Destination = (PUNICODE_STRING)EntryContext;
|
|
UNICODE_STRING Source;
|
|
|
|
if (ValueType != REG_SZ || ValueLength == 0 || ValueLength % sizeof(WCHAR) != 0)
|
|
return STATUS_SUCCESS;
|
|
|
|
Source.MaximumLength = Source.Length = ValueLength;
|
|
Source.Buffer = ValueData;
|
|
if (Source.Length > 0 && Source.Buffer[Source.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
|
|
Source.Length -= sizeof(WCHAR);
|
|
return RtlDuplicateUnicodeString(RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE, &Source, Destination);
|
|
}
|
|
|
|
static NTSTATUS NTAPI
|
|
QueryBinaryValueCallback(
|
|
IN PWSTR ValueName,
|
|
IN ULONG ValueType,
|
|
IN PVOID ValueData,
|
|
IN ULONG ValueLength,
|
|
IN PVOID Context,
|
|
IN PVOID EntryContext)
|
|
{
|
|
PBUFFER Buffer = (PBUFFER)EntryContext;
|
|
PVOID BinaryValue;
|
|
|
|
if (ValueLength == 0)
|
|
{
|
|
*Buffer->Data = NULL;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
BinaryValue = ExAllocatePoolWithTag(PagedPool, ValueLength, TAG_PNP_ROOT);
|
|
if (BinaryValue == NULL)
|
|
return STATUS_NO_MEMORY;
|
|
RtlCopyMemory(BinaryValue, ValueData, ValueLength);
|
|
*Buffer->Data = BinaryValue;
|
|
if (Buffer->Length) *Buffer->Length = ValueLength;
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
static NTSTATUS
|
|
EnumerateDevices(
|
|
IN PDEVICE_OBJECT DeviceObject)
|
|
{
|
|
PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension;
|
|
PKEY_BASIC_INFORMATION KeyInfo = NULL, SubKeyInfo = NULL;
|
|
UNICODE_STRING LegacyU = RTL_CONSTANT_STRING(L"LEGACY_");
|
|
UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\" REGSTR_PATH_SYSTEMENUM L"\\" REGSTR_KEY_ROOTENUM);
|
|
UNICODE_STRING SubKeyName;
|
|
WCHAR DevicePath[MAX_PATH + 1];
|
|
RTL_QUERY_REGISTRY_TABLE QueryTable[5];
|
|
PPNPROOT_DEVICE Device = NULL;
|
|
HANDLE KeyHandle = INVALID_HANDLE_VALUE;
|
|
HANDLE SubKeyHandle = INVALID_HANDLE_VALUE;
|
|
HANDLE DeviceKeyHandle = INVALID_HANDLE_VALUE;
|
|
ULONG BufferSize;
|
|
ULONG ResultSize;
|
|
ULONG Index1, Index2;
|
|
BUFFER Buffer1, Buffer2;
|
|
NTSTATUS Status = STATUS_UNSUCCESSFUL;
|
|
|
|
DPRINT("EnumerateDevices(FDO %p)\n", DeviceObject);
|
|
|
|
DeviceExtension = (PPNPROOT_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
KeAcquireGuardedMutex(&DeviceExtension->DeviceListLock);
|
|
|
|
BufferSize = sizeof(KEY_BASIC_INFORMATION) + (MAX_PATH + 1) * sizeof(WCHAR);
|
|
KeyInfo = ExAllocatePoolWithTag(PagedPool, BufferSize, TAG_PNP_ROOT);
|
|
if (!KeyInfo)
|
|
{
|
|
DPRINT("ExAllocatePoolWithTag() failed\n");
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
SubKeyInfo = ExAllocatePoolWithTag(PagedPool, BufferSize, TAG_PNP_ROOT);
|
|
if (!SubKeyInfo)
|
|
{
|
|
DPRINT("ExAllocatePoolWithTag() failed\n");
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
|
|
Status = IopOpenRegistryKeyEx(&KeyHandle, NULL, &KeyName, KEY_ENUMERATE_SUB_KEYS);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("IopOpenRegistryKeyEx(%wZ) failed with status 0x%08lx\n", &KeyName, Status);
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Devices are sub-sub-keys of 'KeyName'. KeyName is already opened as
|
|
* KeyHandle. We'll first do a first enumeration to have first level keys,
|
|
* and an inner one to have the real devices list.
|
|
*/
|
|
Index1 = 0;
|
|
while (TRUE)
|
|
{
|
|
Status = ZwEnumerateKey(
|
|
KeyHandle,
|
|
Index1,
|
|
KeyBasicInformation,
|
|
KeyInfo,
|
|
BufferSize,
|
|
&ResultSize);
|
|
if (Status == STATUS_NO_MORE_ENTRIES)
|
|
{
|
|
Status = STATUS_SUCCESS;
|
|
break;
|
|
}
|
|
else if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Terminate the string */
|
|
KeyInfo->Name[KeyInfo->NameLength / sizeof(WCHAR)] = 0;
|
|
|
|
/* Check if it is a legacy driver */
|
|
RtlInitUnicodeString(&SubKeyName, KeyInfo->Name);
|
|
if (RtlPrefixUnicodeString(&LegacyU, &SubKeyName, FALSE))
|
|
{
|
|
DPRINT("Ignoring legacy driver '%wZ'\n", &SubKeyName);
|
|
Index1++;
|
|
continue;
|
|
}
|
|
|
|
/* Open the key */
|
|
Status = IopOpenRegistryKeyEx(&SubKeyHandle, KeyHandle, &SubKeyName, KEY_ENUMERATE_SUB_KEYS);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("IopOpenRegistryKeyEx() failed with status 0x%08lx\n", Status);
|
|
break;
|
|
}
|
|
|
|
/* Enumerate the sub-keys */
|
|
Index2 = 0;
|
|
while (TRUE)
|
|
{
|
|
Status = ZwEnumerateKey(
|
|
SubKeyHandle,
|
|
Index2,
|
|
KeyBasicInformation,
|
|
SubKeyInfo,
|
|
BufferSize,
|
|
&ResultSize);
|
|
if (Status == STATUS_NO_MORE_ENTRIES)
|
|
break;
|
|
else if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("ZwEnumerateKey() failed with status 0x%08lx\n", Status);
|
|
break;
|
|
}
|
|
|
|
/* Terminate the string */
|
|
SubKeyInfo->Name[SubKeyInfo->NameLength / sizeof(WCHAR)] = 0;
|
|
|
|
_snwprintf(
|
|
DevicePath,
|
|
sizeof(DevicePath) / sizeof(WCHAR),
|
|
L"%s\\%s", REGSTR_KEY_ROOTENUM, KeyInfo->Name);
|
|
DPRINT("Found device %S\\%s!\n", DevicePath, SubKeyInfo->Name);
|
|
if (LocateChildDevice(DeviceExtension, DevicePath, SubKeyInfo->Name, &Device) == STATUS_NO_SUCH_DEVICE)
|
|
{
|
|
/* Create a PPNPROOT_DEVICE object, and add if in the list of known devices */
|
|
Device = (PPNPROOT_DEVICE)ExAllocatePoolWithTag(PagedPool, sizeof(PNPROOT_DEVICE), TAG_PNP_ROOT);
|
|
if (!Device)
|
|
{
|
|
DPRINT("ExAllocatePoolWithTag() failed\n");
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
RtlZeroMemory(Device, sizeof(PNPROOT_DEVICE));
|
|
|
|
/* Fill device ID and instance ID */
|
|
if (!RtlCreateUnicodeString(&Device->DeviceID, DevicePath))
|
|
{
|
|
DPRINT("RtlCreateUnicodeString() failed\n");
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!RtlCreateUnicodeString(&Device->InstanceID, SubKeyInfo->Name))
|
|
{
|
|
DPRINT("RtlCreateUnicodeString() failed\n");
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
|
|
/* Open registry key to fill other informations */
|
|
Status = IopOpenRegistryKeyEx(&DeviceKeyHandle, SubKeyHandle, &Device->InstanceID, KEY_READ);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("IopOpenRegistryKeyEx() failed with status 0x%08lx\n", Status);
|
|
break;
|
|
}
|
|
|
|
/* Fill other informations */
|
|
Buffer1.Data = (PVOID *)&Device->ResourceRequirementsList;
|
|
Buffer1.Length = NULL;
|
|
Buffer2.Data = (PVOID *)&Device->ResourceList;
|
|
Buffer2.Length = &Device->ResourceListSize;
|
|
RtlZeroMemory(QueryTable, sizeof(QueryTable));
|
|
QueryTable[0].QueryRoutine = QueryStringCallback;
|
|
QueryTable[0].Name = L"DeviceDesc";
|
|
QueryTable[0].EntryContext = &Device->DeviceDescription;
|
|
QueryTable[1].Flags = RTL_QUERY_REGISTRY_SUBKEY;
|
|
QueryTable[1].Name = L"LogConf";
|
|
QueryTable[2].QueryRoutine = QueryBinaryValueCallback;
|
|
QueryTable[2].Name = L"BasicConfigVector";
|
|
QueryTable[2].EntryContext = &Buffer1;
|
|
QueryTable[3].QueryRoutine = QueryBinaryValueCallback;
|
|
QueryTable[3].Name = L"BootConfig";
|
|
QueryTable[3].EntryContext = &Buffer2;
|
|
|
|
Status = RtlQueryRegistryValues(
|
|
RTL_REGISTRY_HANDLE,
|
|
(PCWSTR)DeviceKeyHandle,
|
|
QueryTable,
|
|
NULL,
|
|
NULL);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("RtlQueryRegistryValues() failed with status 0x%08lx\n", Status);
|
|
break;
|
|
}
|
|
|
|
ZwClose(DeviceKeyHandle);
|
|
DeviceKeyHandle = INVALID_HANDLE_VALUE;
|
|
|
|
/* Insert the newly created device into the list */
|
|
InsertTailList(
|
|
&DeviceExtension->DeviceListHead,
|
|
&Device->ListEntry);
|
|
DeviceExtension->DeviceListCount++;
|
|
}
|
|
Device = NULL;
|
|
|
|
Index2++;
|
|
}
|
|
|
|
ZwClose(SubKeyHandle);
|
|
SubKeyHandle = INVALID_HANDLE_VALUE;
|
|
Index1++;
|
|
}
|
|
|
|
cleanup:
|
|
if (Device)
|
|
{
|
|
/* We have a device that has not been added to device list. We need to clean it up */
|
|
/* FIXME */
|
|
ExFreePoolWithTag(Device, TAG_PNP_ROOT);
|
|
}
|
|
if (DeviceKeyHandle != INVALID_HANDLE_VALUE)
|
|
ZwClose(DeviceKeyHandle);
|
|
if (SubKeyHandle != INVALID_HANDLE_VALUE)
|
|
ZwClose(SubKeyHandle);
|
|
if (KeyHandle != INVALID_HANDLE_VALUE)
|
|
ZwClose(KeyHandle);
|
|
if (KeyInfo)
|
|
ExFreePoolWithTag(KeyInfo, TAG_PNP_ROOT);
|
|
if (SubKeyInfo)
|
|
ExFreePoolWithTag(SubKeyInfo, TAG_PNP_ROOT);
|
|
KeReleaseGuardedMutex(&DeviceExtension->DeviceListLock);
|
|
return Status;
|
|
}
|
|
|
|
/* FUNCTION: Handle IRP_MN_QUERY_DEVICE_RELATIONS IRPs for the root bus device object
|
|
* ARGUMENTS:
|
|
* DeviceObject = Pointer to functional device object of the root bus driver
|
|
* Irp = Pointer to IRP that should be handled
|
|
* RETURNS:
|
|
* Status
|
|
*/
|
|
static NTSTATUS
|
|
PnpRootQueryDeviceRelations(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp)
|
|
{
|
|
PPNPROOT_PDO_DEVICE_EXTENSION PdoDeviceExtension;
|
|
PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension;
|
|
PDEVICE_RELATIONS Relations = NULL, OtherRelations = (PDEVICE_RELATIONS)Irp->IoStatus.Information;
|
|
PPNPROOT_DEVICE Device = NULL;
|
|
ULONG Size;
|
|
NTSTATUS Status;
|
|
PLIST_ENTRY NextEntry;
|
|
|
|
DPRINT("PnpRootQueryDeviceRelations(FDO %p, Irp %p)\n", DeviceObject, Irp);
|
|
|
|
Status = EnumerateDevices(DeviceObject);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("EnumerateDevices() failed with status 0x%08lx\n", Status);
|
|
return Status;
|
|
}
|
|
|
|
DeviceExtension = (PPNPROOT_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
|
|
Size = FIELD_OFFSET(DEVICE_RELATIONS, Objects) + sizeof(PDEVICE_OBJECT) * DeviceExtension->DeviceListCount;
|
|
if (OtherRelations)
|
|
{
|
|
/* Another bus driver has already created a DEVICE_RELATIONS
|
|
* structure so we must merge this structure with our own */
|
|
|
|
Size += sizeof(PDEVICE_OBJECT) * OtherRelations->Count;
|
|
}
|
|
Relations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool, Size);
|
|
if (!Relations)
|
|
{
|
|
DPRINT("ExAllocatePoolWithTag() failed\n");
|
|
Status = STATUS_NO_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
RtlZeroMemory(Relations, Size);
|
|
if (OtherRelations)
|
|
{
|
|
Relations->Count = OtherRelations->Count;
|
|
RtlCopyMemory(Relations->Objects, OtherRelations->Objects, sizeof(PDEVICE_OBJECT) * OtherRelations->Count);
|
|
}
|
|
|
|
KeAcquireGuardedMutex(&DeviceExtension->DeviceListLock);
|
|
|
|
/* Start looping */
|
|
for (NextEntry = DeviceExtension->DeviceListHead.Flink;
|
|
NextEntry != &DeviceExtension->DeviceListHead;
|
|
NextEntry = NextEntry->Flink)
|
|
{
|
|
/* Get the entry */
|
|
Device = CONTAINING_RECORD(NextEntry, PNPROOT_DEVICE, ListEntry);
|
|
|
|
if (!Device->Pdo)
|
|
{
|
|
/* Create a physical device object for the
|
|
* device as it does not already have one */
|
|
Status = IoCreateDevice(
|
|
DeviceObject->DriverObject,
|
|
sizeof(PNPROOT_PDO_DEVICE_EXTENSION),
|
|
NULL,
|
|
FILE_DEVICE_CONTROLLER,
|
|
FILE_AUTOGENERATED_DEVICE_NAME,
|
|
FALSE,
|
|
&Device->Pdo);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("IoCreateDevice() failed with status 0x%08lx\n", Status);
|
|
break;
|
|
}
|
|
|
|
PdoDeviceExtension = (PPNPROOT_PDO_DEVICE_EXTENSION)Device->Pdo->DeviceExtension;
|
|
RtlZeroMemory(PdoDeviceExtension, sizeof(PNPROOT_PDO_DEVICE_EXTENSION));
|
|
PdoDeviceExtension->Common.IsFDO = FALSE;
|
|
PdoDeviceExtension->DeviceInfo = Device;
|
|
|
|
Device->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
|
|
Device->Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
|
|
}
|
|
|
|
/* Reference the physical device object. The PnP manager
|
|
will dereference it again when it is no longer needed */
|
|
ObReferenceObject(Device->Pdo);
|
|
|
|
Relations->Objects[Relations->Count++] = Device->Pdo;
|
|
}
|
|
KeReleaseGuardedMutex(&DeviceExtension->DeviceListLock);
|
|
|
|
Irp->IoStatus.Information = (ULONG_PTR)Relations;
|
|
|
|
cleanup:
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
if (OtherRelations)
|
|
ExFreePool(OtherRelations);
|
|
if (Relations)
|
|
ExFreePool(Relations);
|
|
if (Device && Device->Pdo)
|
|
{
|
|
IoDeleteDevice(Device->Pdo);
|
|
Device->Pdo = NULL;
|
|
}
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: Handle Plug and Play IRPs for the root bus device object
|
|
* ARGUMENTS:
|
|
* DeviceObject = Pointer to functional device object of the root bus driver
|
|
* Irp = Pointer to IRP that should be handled
|
|
* RETURNS:
|
|
* Status
|
|
*/
|
|
static NTSTATUS
|
|
PnpRootFdoPnpControl(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp)
|
|
{
|
|
PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension;
|
|
PIO_STACK_LOCATION IrpSp;
|
|
NTSTATUS Status;
|
|
|
|
DeviceExtension = (PPNPROOT_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
Status = Irp->IoStatus.Status;
|
|
IrpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
switch (IrpSp->MinorFunction)
|
|
{
|
|
case IRP_MN_QUERY_DEVICE_RELATIONS:
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS\n");
|
|
Status = PnpRootQueryDeviceRelations(DeviceObject, Irp);
|
|
break;
|
|
|
|
case IRP_MN_START_DEVICE:
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
|
|
if (!IoForwardIrpSynchronously(DeviceExtension->Ldo, Irp))
|
|
Status = STATUS_UNSUCCESSFUL;
|
|
else
|
|
{
|
|
Status = Irp->IoStatus.Status;
|
|
if (NT_SUCCESS(Status))
|
|
DeviceExtension->State = dsStarted;
|
|
}
|
|
break;
|
|
|
|
case IRP_MN_STOP_DEVICE:
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_STOP_DEVICE\n");
|
|
/* Root device cannot be stopped */
|
|
Status = STATUS_NOT_SUPPORTED;
|
|
break;
|
|
|
|
default:
|
|
DPRINT("IRP_MJ_PNP / Unknown minor function 0x%lx\n", IrpSp->MinorFunction);
|
|
Status = STATUS_NOT_IMPLEMENTED;
|
|
break;
|
|
}
|
|
|
|
if (Status != STATUS_PENDING)
|
|
{
|
|
Irp->IoStatus.Status = Status;
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
static NTSTATUS
|
|
PdoQueryDeviceRelations(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp)
|
|
{
|
|
PDEVICE_RELATIONS Relations;
|
|
DEVICE_RELATION_TYPE RelationType;
|
|
NTSTATUS Status = Irp->IoStatus.Status;
|
|
|
|
RelationType = IrpSp->Parameters.QueryDeviceRelations.Type;
|
|
|
|
switch (RelationType)
|
|
{
|
|
/* FIXME: remove */
|
|
case BusRelations:
|
|
{
|
|
if (IoGetAttachedDevice(DeviceObject) != DeviceObject)
|
|
{
|
|
/* We're not alone in the stack */
|
|
DPRINT1("PnP is misbehaving ; don't know how to handle IRP_MN_QUERY_DEVICE_RELATIONS / BusRelations\n");
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TargetDeviceRelation:
|
|
{
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / TargetDeviceRelation\n");
|
|
Relations = (PDEVICE_RELATIONS)ExAllocatePool(PagedPool, sizeof(DEVICE_RELATIONS));
|
|
if (!Relations)
|
|
{
|
|
DPRINT("ExAllocatePoolWithTag() failed\n");
|
|
Status = STATUS_NO_MEMORY;
|
|
}
|
|
else
|
|
{
|
|
ObReferenceObject(DeviceObject);
|
|
Relations->Count = 1;
|
|
Relations->Objects[0] = DeviceObject;
|
|
Status = STATUS_SUCCESS;
|
|
Irp->IoStatus.Information = (ULONG_PTR)Relations;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_RELATIONS / unknown relation type 0x%lx\n", RelationType);
|
|
}
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
static NTSTATUS
|
|
PdoQueryCapabilities(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp)
|
|
{
|
|
PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension;
|
|
PDEVICE_CAPABILITIES DeviceCapabilities;
|
|
|
|
DeviceExtension = (PPNPROOT_FDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
DeviceCapabilities = IrpSp->Parameters.DeviceCapabilities.Capabilities;
|
|
|
|
if (DeviceCapabilities->Version != 1)
|
|
return STATUS_REVISION_MISMATCH;
|
|
|
|
DeviceCapabilities->UniqueID = TRUE;
|
|
/* FIXME: Fill other fields */
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
static NTSTATUS
|
|
PdoQueryResources(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp)
|
|
{
|
|
PPNPROOT_PDO_DEVICE_EXTENSION DeviceExtension;
|
|
PCM_RESOURCE_LIST ResourceList;
|
|
|
|
DeviceExtension = (PPNPROOT_PDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
|
|
if (DeviceExtension->DeviceInfo->ResourceList == NULL)
|
|
{
|
|
/* Create an empty resource list */
|
|
ResourceList = ExAllocatePool(PagedPool, sizeof(CM_RESOURCE_LIST));
|
|
if (!ResourceList)
|
|
return STATUS_NO_MEMORY;
|
|
|
|
ResourceList->Count = 0;
|
|
|
|
Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
|
|
}
|
|
else
|
|
{
|
|
/* Copy existing resource requirement list */
|
|
ResourceList = ExAllocatePool(
|
|
PagedPool,
|
|
FIELD_OFFSET(CM_RESOURCE_LIST, List) + DeviceExtension->DeviceInfo->ResourceListSize);
|
|
if (!ResourceList)
|
|
return STATUS_NO_MEMORY;
|
|
|
|
ResourceList->Count = 1;
|
|
RtlCopyMemory(
|
|
&ResourceList->List,
|
|
DeviceExtension->DeviceInfo->ResourceList,
|
|
DeviceExtension->DeviceInfo->ResourceListSize);
|
|
Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
static NTSTATUS
|
|
PdoQueryResourceRequirements(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp)
|
|
{
|
|
PPNPROOT_PDO_DEVICE_EXTENSION DeviceExtension;
|
|
PIO_RESOURCE_REQUIREMENTS_LIST ResourceList;
|
|
ULONG ResourceListSize = FIELD_OFFSET(IO_RESOURCE_REQUIREMENTS_LIST, List);
|
|
|
|
DeviceExtension = (PPNPROOT_PDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
|
|
if (DeviceExtension->DeviceInfo->ResourceRequirementsList == NULL)
|
|
{
|
|
/* Create an empty resource list */
|
|
ResourceList = ExAllocatePool(PagedPool, ResourceListSize);
|
|
if (!ResourceList)
|
|
return STATUS_NO_MEMORY;
|
|
|
|
RtlZeroMemory(ResourceList, ResourceListSize);
|
|
ResourceList->ListSize = ResourceListSize;
|
|
|
|
Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
|
|
}
|
|
else
|
|
{
|
|
/* Copy existing resource requirement list */
|
|
ResourceList = ExAllocatePool(PagedPool, DeviceExtension->DeviceInfo->ResourceRequirementsList->ListSize);
|
|
if (!ResourceList)
|
|
return STATUS_NO_MEMORY;
|
|
|
|
RtlCopyMemory(
|
|
ResourceList,
|
|
DeviceExtension->DeviceInfo->ResourceRequirementsList,
|
|
DeviceExtension->DeviceInfo->ResourceRequirementsList->ListSize);
|
|
Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
|
|
}
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
static NTSTATUS
|
|
PdoQueryDeviceText(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp)
|
|
{
|
|
PPNPROOT_PDO_DEVICE_EXTENSION DeviceExtension;
|
|
DEVICE_TEXT_TYPE DeviceTextType;
|
|
NTSTATUS Status = Irp->IoStatus.Status;
|
|
|
|
DeviceExtension = (PPNPROOT_PDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
DeviceTextType = IrpSp->Parameters.QueryDeviceText.DeviceTextType;
|
|
|
|
switch (DeviceTextType)
|
|
{
|
|
case DeviceTextDescription:
|
|
{
|
|
UNICODE_STRING String;
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT / DeviceTextDescription\n");
|
|
|
|
Status = RtlDuplicateUnicodeString(
|
|
RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
|
|
&DeviceExtension->DeviceInfo->DeviceDescription,
|
|
&String);
|
|
Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
|
|
break;
|
|
}
|
|
|
|
case DeviceTextLocationInformation:
|
|
{
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT / DeviceTextLocationInformation\n");
|
|
Status = STATUS_NOT_SUPPORTED;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_DEVICE_TEXT / unknown query id type 0x%lx\n", DeviceTextType);
|
|
}
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
static NTSTATUS
|
|
PdoQueryId(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp)
|
|
{
|
|
PPNPROOT_PDO_DEVICE_EXTENSION DeviceExtension;
|
|
BUS_QUERY_ID_TYPE IdType;
|
|
NTSTATUS Status = Irp->IoStatus.Status;
|
|
|
|
DeviceExtension = (PPNPROOT_PDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
IdType = IrpSp->Parameters.QueryId.IdType;
|
|
|
|
switch (IdType)
|
|
{
|
|
case BusQueryDeviceID:
|
|
{
|
|
UNICODE_STRING String;
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryDeviceID\n");
|
|
|
|
Status = RtlDuplicateUnicodeString(
|
|
RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
|
|
&DeviceExtension->DeviceInfo->DeviceID,
|
|
&String);
|
|
Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
|
|
break;
|
|
}
|
|
|
|
case BusQueryHardwareIDs:
|
|
case BusQueryCompatibleIDs:
|
|
{
|
|
/* Optional, do nothing */
|
|
break;
|
|
}
|
|
|
|
case BusQueryInstanceID:
|
|
{
|
|
UNICODE_STRING String;
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_ID / BusQueryInstanceID\n");
|
|
|
|
Status = RtlDuplicateUnicodeString(
|
|
RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE,
|
|
&DeviceExtension->DeviceInfo->InstanceID,
|
|
&String);
|
|
Irp->IoStatus.Information = (ULONG_PTR)String.Buffer;
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
DPRINT1("IRP_MJ_PNP / IRP_MN_QUERY_ID / unknown query id type 0x%lx\n", IdType);
|
|
}
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
static NTSTATUS
|
|
PdoQueryBusInformation(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp,
|
|
IN PIO_STACK_LOCATION IrpSp)
|
|
{
|
|
PPNP_BUS_INFORMATION BusInfo;
|
|
NTSTATUS Status;
|
|
|
|
BusInfo = (PPNP_BUS_INFORMATION)ExAllocatePoolWithTag(PagedPool, sizeof(PNP_BUS_INFORMATION), TAG_PNP_ROOT);
|
|
if (!BusInfo)
|
|
Status = STATUS_NO_MEMORY;
|
|
else
|
|
{
|
|
RtlCopyMemory(
|
|
&BusInfo->BusTypeGuid,
|
|
&GUID_BUS_TYPE_INTERNAL,
|
|
sizeof(BusInfo->BusTypeGuid));
|
|
BusInfo->LegacyBusType = PNPBus;
|
|
/* We're the only root bus enumerator on the computer */
|
|
BusInfo->BusNumber = 0;
|
|
Irp->IoStatus.Information = (ULONG_PTR)BusInfo;
|
|
Status = STATUS_SUCCESS;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: Handle Plug and Play IRPs for the child device
|
|
* ARGUMENTS:
|
|
* DeviceObject = Pointer to physical device object of the child device
|
|
* Irp = Pointer to IRP that should be handled
|
|
* RETURNS:
|
|
* Status
|
|
*/
|
|
static NTSTATUS
|
|
PnpRootPdoPnpControl(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp)
|
|
{
|
|
PPNPROOT_PDO_DEVICE_EXTENSION DeviceExtension;
|
|
PIO_STACK_LOCATION IrpSp;
|
|
NTSTATUS Status;
|
|
|
|
DeviceExtension = (PPNPROOT_PDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
Status = Irp->IoStatus.Status;
|
|
IrpSp = IoGetCurrentIrpStackLocation(Irp);
|
|
|
|
switch (IrpSp->MinorFunction)
|
|
{
|
|
case IRP_MN_START_DEVICE: /* 0x00 */
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_START_DEVICE\n");
|
|
Status = STATUS_SUCCESS;
|
|
break;
|
|
|
|
case IRP_MN_QUERY_DEVICE_RELATIONS: /* 0x07 */
|
|
Status = PdoQueryDeviceRelations(DeviceObject, Irp, IrpSp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_CAPABILITIES: /* 0x09 */
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_CAPABILITIES\n");
|
|
Status = PdoQueryCapabilities(DeviceObject, Irp, IrpSp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_RESOURCES: /* 0x0a */
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCES\n");
|
|
Status = PdoQueryResources(DeviceObject, Irp, IrpSp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_RESOURCE_REQUIREMENTS: /* 0x0b */
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
|
|
Status = PdoQueryResourceRequirements(DeviceObject, Irp, IrpSp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_DEVICE_TEXT: /* 0x0c */
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_RESOURCE_REQUIREMENTS\n");
|
|
Status = PdoQueryDeviceText(DeviceObject, Irp, IrpSp);
|
|
break;
|
|
|
|
case IRP_MN_FILTER_RESOURCE_REQUIREMENTS: /* 0x0d */
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_FILTER_RESOURCE_REQUIREMENTS\n");
|
|
break;
|
|
|
|
case IRP_MN_QUERY_ID: /* 0x13 */
|
|
Status = PdoQueryId(DeviceObject, Irp, IrpSp);
|
|
break;
|
|
|
|
case IRP_MN_QUERY_BUS_INFORMATION: /* 0x15 */
|
|
DPRINT("IRP_MJ_PNP / IRP_MN_QUERY_BUS_INFORMATION\n");
|
|
Status = PdoQueryBusInformation(DeviceObject, Irp, IrpSp);
|
|
break;
|
|
|
|
default:
|
|
DPRINT1("IRP_MJ_PNP / Unknown minor function 0x%lx\n", IrpSp->MinorFunction);
|
|
Status = STATUS_NOT_IMPLEMENTED;
|
|
break;
|
|
}
|
|
|
|
if (Status != STATUS_PENDING)
|
|
{
|
|
Irp->IoStatus.Status = Status;
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: Handle Plug and Play IRPs
|
|
* ARGUMENTS:
|
|
* DeviceObject = Pointer to PDO or FDO
|
|
* Irp = Pointer to IRP that should be handled
|
|
* RETURNS:
|
|
* Status
|
|
*/
|
|
static NTSTATUS NTAPI
|
|
PnpRootPnpControl(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp)
|
|
{
|
|
PPNPROOT_COMMON_DEVICE_EXTENSION DeviceExtension;
|
|
NTSTATUS Status;
|
|
|
|
DeviceExtension = (PPNPROOT_COMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
|
|
|
|
if (DeviceExtension->IsFDO)
|
|
Status = PnpRootFdoPnpControl(DeviceObject, Irp);
|
|
else
|
|
Status = PnpRootPdoPnpControl(DeviceObject, Irp);
|
|
|
|
return Status;
|
|
}
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
PnpRootAddDevice(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PDEVICE_OBJECT PhysicalDeviceObject)
|
|
{
|
|
PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension;
|
|
NTSTATUS Status;
|
|
|
|
DPRINT("PnpRootAddDevice(DriverObject %p, Pdo %p)\n", DriverObject, PhysicalDeviceObject);
|
|
|
|
if (!PhysicalDeviceObject)
|
|
{
|
|
DPRINT("PhysicalDeviceObject 0x%p\n", PhysicalDeviceObject);
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
|
|
}
|
|
|
|
Status = IoCreateDevice(
|
|
DriverObject,
|
|
sizeof(PNPROOT_FDO_DEVICE_EXTENSION),
|
|
NULL,
|
|
FILE_DEVICE_BUS_EXTENDER,
|
|
FILE_DEVICE_SECURE_OPEN,
|
|
TRUE,
|
|
&PnpRootDeviceObject);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("IoCreateDevice() failed with status 0x%08lx\n", Status);
|
|
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
|
|
}
|
|
DPRINT("Created FDO %p\n", PnpRootDeviceObject);
|
|
|
|
DeviceExtension = (PPNPROOT_FDO_DEVICE_EXTENSION)PnpRootDeviceObject->DeviceExtension;
|
|
RtlZeroMemory(DeviceExtension, sizeof(PNPROOT_FDO_DEVICE_EXTENSION));
|
|
|
|
DeviceExtension->Common.IsFDO = TRUE;
|
|
DeviceExtension->State = dsStopped;
|
|
InitializeListHead(&DeviceExtension->DeviceListHead);
|
|
DeviceExtension->DeviceListCount = 0;
|
|
KeInitializeGuardedMutex(&DeviceExtension->DeviceListLock);
|
|
|
|
Status = IoAttachDeviceToDeviceStackSafe(
|
|
PnpRootDeviceObject,
|
|
PhysicalDeviceObject,
|
|
&DeviceExtension->Ldo);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DPRINT("IoAttachDeviceToDeviceStackSafe() failed with status 0x%08lx\n", Status);
|
|
KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
|
|
}
|
|
|
|
PnpRootDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
|
|
|
|
DPRINT("Done AddDevice()\n");
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
NTSTATUS NTAPI
|
|
PnpRootDriverEntry(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PUNICODE_STRING RegistryPath)
|
|
{
|
|
DPRINT("PnpRootDriverEntry(%p %wZ)\n", DriverObject, RegistryPath);
|
|
|
|
DriverObject->DriverExtension->AddDevice = PnpRootAddDevice;
|
|
|
|
DriverObject->MajorFunction[IRP_MJ_PNP] = PnpRootPnpControl;
|
|
//DriverObject->MajorFunction[IRP_MJ_POWER] = PnpRootPowerControl;
|
|
|
|
return STATUS_SUCCESS;
|
|
}
|