pnpenum.c File Reference

#include "iop.h"
#include <setupblk.h>

Go to the source code of this file.

Classes
struct	_DRIVER_LIST_ENTRY
struct	QUERY_CONTEXT
Defines
#define	ASSERT_INITED(x)   /* nothing */
#define	DebugPrint(level, x)
#define	DEVICE_PREFIX_STRING   TEXT("\\Device\\")
#define	DOSDEVICES_PREFIX_STRING   TEXT("\\DosDevices\\")
#define	INITIAL_INFOBUFFER_SIZE   sizeof(KEY_VALUE_FULL_INFORMATION) + 8*sizeof(WCHAR) + 255*sizeof(WCHAR)
#define	NUM_QUERIES   4
Typedefs
typedef _DRIVER_LIST_ENTRY DRIVER_LIST_ENTRY *	PDRIVER_LIST_ENTRY
typedef enum _ADD_DRIVER_STAGE	ADD_DRIVER_STAGE
typedef *	PQUERY_CONTEXT
Enumerations
enum	_ADD_DRIVER_STAGE {   LowerDeviceFilters, LowerClassFilters, DeviceService, UpperDeviceFilters,   UpperClassFilters, MaximumAddStage }
Functions
NTSTATUS	IopBusCheck (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN LoadDriver, IN BOOLEAN AsyncOk)
VOID	IopDeviceActionWorker (PVOID Context)
NTSTATUS	IopEnumerateDevice (IN PDEVICE_OBJECT DeviceObject, IN PSTART_CONTEXT StartContext, IN BOOLEAN AsyncOk)
NTSTATUS	IopCallDriverAddDeviceQueryRoutine (IN PWSTR ValueName, IN ULONG ValueType, IN PWCHAR ValueData, IN ULONG ValueLength, IN PQUERY_CONTEXT Context, IN ULONG ServiceType)
NTSTATUS	IopProcessCriticalDeviceRoutine (IN HANDLE hDevInstance, IN PBOOLEAN FoundMatch, IN PUNICODE_STRING ServiceName, IN PUNICODE_STRING ClassGuid, IN PUNICODE_STRING LowerFilters, IN PUNICODE_STRING UpperFilters)
BOOLEAN	IopProcessCriticalDevice (IN PDEVICE_NODE DeviceNode)
NTSTATUS	IopProcessNewChildren (IN PDEVICE_NODE DeviceNode, IN PSTART_CONTEXT StartContext)
NTSTATUS	IopProcessStartDevicesWorker (IN PDEVICE_NODE DeviceNode, OUT PVOID Context)
USHORT	IopGetBusTypeGuidIndex (IN LPGUID busTypeGuid)
BOOLEAN	IopFixupDeviceId (PWCHAR DeviceId)
BOOLEAN	IopFixupIds (IN PWCHAR Ids, IN ULONG Length)
BOOLEAN	IopGetRegistryDwordWithFallback (IN PUNICODE_STRING valueName, IN HANDLE PrimaryKey, IN HANDLE SecondaryKey, IN OUT PULONG Value)
PSECURITY_DESCRIPTOR	IopGetRegistrySecurityWithFallback (IN PUNICODE_STRING valueName, IN HANDLE PrimaryKey, IN HANDLE SecondaryKey)
NTSTATUS	IopChangeDeviceObjectFromRegistryProperties (IN PDEVICE_OBJECT PhysicalDeviceObject, IN HANDLE DeviceClassPropKey, IN HANDLE DevicePropKey, IN BOOLEAN UsePdoCharacteristics)
NTSTATUS	IopRequestDeviceAction (IN PDEVICE_OBJECT DeviceObject OPTIONAL, IN DEVICE_REQUEST_TYPE RequestType, IN PKEVENT CompletionEvent OPTIONAL, IN PNTSTATUS CompletionStatus OPTIONAL)
VOID	IopProcessStartDevices (IN PDEVICE_NODE DeviceNode, IN PSTART_CONTEXT StartContext)
NTSTATUS	IopStartAndEnumerateDevice (IN PDEVICE_NODE DeviceNode, IN PSTART_CONTEXT StartContext)
NTSTATUS	IopProcessNewDeviceNode (IN OUT PDEVICE_NODE DeviceNode)
NTSTATUS	IopCallDriverAddDevice (IN PDEVICE_NODE DeviceNode, IN BOOLEAN LoadDriver, IN PADD_CONTEXT Context)
NTSTATUS	IopQueryDeviceCapabilities (IN PDEVICE_NODE DeviceNode, OUT PDEVICE_CAPABILITIES Capabilities)
NTSTATUS	IopProcessNewProfile (VOID)
VOID	IopProcessNewProfileWorker (IN PVOID Context)
NTSTATUS	IopProcessNewProfileStateCallback (IN PDEVICE_NODE DeviceNode, IN PVOID Context)
Variables
ULONG	PnpEnumDebugLevel = 0
BOOLEAN	IopEnumerationInProgress = FALSE
WORK_QUEUE_ITEM	IopDeviceEnumerationWorkItem

---

Define Documentation

#define ASSERT_INITED (  x   )     /* nothing */

Definition at line 69 of file pnpenum.c. Referenced by IopCallDriverAddDevice(), and IopEnumerateDevice().

#define DebugPrint (  level, x   )

Value: if (level <= PnpEnumDebugLevel) { \ DbgPrint x; \ } Definition at line 169 of file pnpenum.c.

#define DEVICE_PREFIX_STRING   TEXT("\\Device\\")

Definition at line 203 of file pnpenum.c.

#define DOSDEVICES_PREFIX_STRING   TEXT("\\DosDevices\\")

Definition at line 204 of file pnpenum.c.

#define INITIAL_INFOBUFFER_SIZE   sizeof(KEY_VALUE_FULL_INFORMATION) + 8*sizeof(WCHAR) + 255*sizeof(WCHAR)

Referenced by IopProcessCriticalDeviceRoutine().

#define NUM_QUERIES   4

Referenced by IopProcessCriticalDeviceRoutine().

---

Typedef Documentation

typedef enum _ADD_DRIVER_STAGE ADD_DRIVER_STAGE

typedef struct _DRIVER_LIST_ENTRY DRIVER_LIST_ENTRY* PDRIVER_LIST_ENTRY

Definition at line 33 of file pnpenum.c. Referenced by IopCallDriverAddDevice(), and IopCallDriverAddDeviceQueryRoutine().

typedef * PQUERY_CONTEXT

---

Enumeration Type Documentation

enum _ADD_DRIVER_STAGE

Enumeration values: LowerDeviceFilters  LowerClassFilters  DeviceService  UpperDeviceFilters  UpperClassFilters  MaximumAddStage  Definition at line 40 of file pnpenum.c. { LowerDeviceFilters, LowerClassFilters, DeviceService, UpperDeviceFilters, UpperClassFilters, MaximumAddStage } ADD_DRIVER_STAGE;

---

Function Documentation

NTSTATUS IopBusCheck (  IN PDEVICE_OBJECT  DeviceObject, IN BOOLEAN  LoadDriver, IN BOOLEAN  AsyncOk )

Definition at line 728 of file pnpenum.c. References _START_CONTEXT::AddContext, _ADD_CONTEXT::DriverStartType, FALSE, _ADD_CONTEXT::GroupsToStart, _ADD_CONTEXT::GroupToStartNext, IopEnumerateDevice(), IopProcessAssignResources(), IopProcessStartDevices(), _START_CONTEXT::LoadDriver, _START_CONTEXT::NewDevice, NO_MORE_GROUP, NTSTATUS(), NULL, ObDereferenceObject, ObReferenceObject, PAGED_CODE, _DEVICE_NODE::PhysicalDeviceObject, and TRUE. Referenced by IopDeviceActionWorker(). 00736 : 00737 00738 This routine performs bus check operation on the specified device/bus. 00739 00740 Arguments: 00741 00742 DeviceObject - Supplies a pointer to a device object which will be enumerated. 00743 00744 LoadDriver - Supplies a BOOLEAN value to indicate should a driver be loaded 00745 to complete a enumeration. If false, the enumeration will stop 00746 once the device's controlling service is not loaded yet. This is 00747 mainly for boot device driver initialization. 00748 00749 ParentLockOwned - Specifies if caller already owns the device's parent's lock. 00750 00751 AsyncOk - Specifies can QueryDeviceRelation be done at Async way. 00752 00753 Return Value: 00754 00755 None. 00756 00757 --*/ 00758 00759 { 00760 BOOLEAN newDevice; 00761 PDEVICE_NODE deviceNode, parent = NULL; 00762 NTSTATUS status; 00763 START_CONTEXT startContext; 00764 00765 PAGED_CODE(); 00766 00767 // 00768 // First get a reference to the PDO to make sure it won't go away. 00769 // 00770 00771 ObReferenceObject(DeviceObject); 00772 deviceNode = (PDEVICE_NODE)DeviceObject->DeviceObjectExtension->DeviceNode; 00773 00774 // 00775 // Enumerate the specified device node. 00776 // If any new device node is found, its controlling driver is loaded and 00777 // its AddDevice entry is called. 00778 // 00779 00780 startContext.LoadDriver = LoadDriver; 00781 startContext.NewDevice = FALSE; 00782 startContext.AddContext.GroupsToStart = NO_MORE_GROUP; 00783 startContext.AddContext.GroupToStartNext = NO_MORE_GROUP; 00784 startContext.AddContext.DriverStartType = SERVICE_DEMAND_START; 00785 00786 status = IopEnumerateDevice( deviceNode->PhysicalDeviceObject, 00787 &startContext, 00788 AsyncOk); 00789 00790 if (status != STATUS_PNP_RESTART_ENUMERATION) { 00791 00792 do { 00793 00794 startContext.NewDevice = FALSE; 00795 00796 // 00797 // Process the whole device tree to assign resources to those devices who 00798 // have been successfully added to their drivers. 00799 // 00800 00801 newDevice = IopProcessAssignResources(deviceNode, FALSE, TRUE); 00802 00803 // 00804 // Process the device subtree to start those devices who have been allocated 00805 // resources and waiting to be started. 00806 // Note, the IopProcessStartDevices routine may enumerate new devices. 00807 // 00808 00809 IopProcessStartDevices(deviceNode, &startContext); 00810 newDevice |= startContext.NewDevice; 00811 00812 } while (newDevice); 00813 } 00814 00815 ObDereferenceObject(DeviceObject); 00816 00817 return status; 00818 }

NTSTATUS IopCallDriverAddDevice (  IN PDEVICE_NODE  DeviceNode, IN BOOLEAN  LoadDriver, IN PADD_CONTEXT  Context )

Definition at line 2525 of file pnpenum.c. References ASSERT, ASSERT_INITED, ASSERTMSG, _DEVICE_OBJECT::AttachedDevice, CmRegistryMachineSystemCurrentControlSetControlClass, CmRegistryMachineSystemCurrentControlSetEnumName, DbgPrint, DebugPrint, _DEVICE_OBJECT::DeviceObjectExtension, DeviceService, DNF_ADDED, DNF_LEGACY_DRIVER, DO_DEVICE_INITIALIZING, DOE_BOTTOM_OF_FDO_STACK, DOE_DESIGNATED_FDO, DOE_RAW_FDO, ExFreePool(), _DEVOBJ_EXTENSION::ExtensionFlags, FALSE, _DEVICE_OBJECT::Flags, InitSafeBootMode, IoGetAttachedDevice(), IopBootLog(), IopCallDriverAddDeviceQueryRoutine(), IopChangeDeviceObjectFromRegistryProperties(), IopClearDevNodeProblem, IopDeviceNodeFlagsToCapabilities, IopGetRegistryValue(), IopOpenRegistryKeyEx(), IopQueryLegacyBusInformation(), IopRegistryDataToUnicodeString, IopRequestDeviceRemoval(), IopSafebootDriverLoad(), IopSetDevNodeProblem, KEY_VALUE_DATA, LowerClassFilters, LowerDeviceFilters, MaximumAddStage, _DRIVER_LIST_ENTRY::NextEntry, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, OK_TO_ADD_DEVICE, PDRIVER_ADD_DEVICE, PDRIVER_LIST_ENTRY, RtlInitUnicodeString(), RtlQueryRegistryValues(), TRUE, UpperClassFilters, and UpperDeviceFilters. Referenced by IopAddDevicesToBootDriverWorker(), IopNewDevice(), IopProcessAddDevicesWorker(), and IopProcessNewChildren(). : This function checks if the driver for the DeviceNode is present and loads the driver if necessary. Arguments: DeviceNode - Supplies a pointer to the device node to be enumerated. LoadDriver - Supplies a BOOLEAN value to indicate should a driver be loaded to complete enumeration. Context - Supplies a pointer to ADD_CONTEXT to control how the device be added. Return Value: NTSTATUS code. --*/ { HANDLE enumKey; HANDLE instanceKey; HANDLE classKey = NULL; HANDLE classPropsKey = NULL; PKEY_VALUE_FULL_INFORMATION keyValueInformation = NULL; RTL_QUERY_REGISTRY_TABLE queryTable[3]; QUERY_CONTEXT queryContext; BOOLEAN deviceRaw = FALSE; BOOLEAN usePdoCharacteristics = TRUE; NTSTATUS status; DEVICE_CAPABILITIES capabilities; ULONG index; PDEVICE_OBJECT deviceObject; #ifndef NO_SPECIAL_IRP PDEVICE_OBJECT fdoDeviceObject, topOfPdoStack, topOfLowerFilterStack; BOOLEAN deviceObjectHasBeenAttached = FALSE; #endif DebugPrint(1, ("IopCallDriverAddDevice: Processing devnode %#08lx\n", DeviceNode)); DebugPrint(1, ("IopCallDriverAddDevice: DevNode flags going in = %#08lx\n", DeviceNode->Flags)); // // The device node may have been started at this point. This is because // some ill-behaved miniport drivers call IopReportedDetectedDevice at // DriverEntry for the devices which we already know about. // if (!OK_TO_ADD_DEVICE(DeviceNode)) { return STATUS_SUCCESS; } ASSERT_INITED(DeviceNode->PhysicalDeviceObject); DebugPrint(1, ("IopCallDriverAddDevice:\t%s load driver\n", (LoadDriver ? "Will" : "Won't"))); DebugPrint(1, ("IopCallDriverAddDevice:\tOpening registry key %wZ\n", &DeviceNode->InstancePath)); // // Open the HKLM\System\CCS\Enum key. // status = IopOpenRegistryKeyEx( &enumKey, NULL, &CmRegistryMachineSystemCurrentControlSetEnumName, KEY_READ ); if (!NT_SUCCESS(status)) { DebugPrint(1, ("IopCallDriverAddDevice:\tUnable to open " "HKLM\\SYSTEM\\CCS\\ENUM\n")); return status; } // // Open the instance key for this devnode // status = IopOpenRegistryKeyEx( &instanceKey, enumKey, &DeviceNode->InstancePath, KEY_READ ); ZwClose(enumKey); if (!NT_SUCCESS(status)) { DebugPrint(1, ("IopCallDriverAddDevice:\t\tError %#08lx opening enum key\n", status)); return status; } // // Get the class value to locate the class key for this devnode // status = IopGetRegistryValue(instanceKey, REGSTR_VALUE_CLASSGUID, &keyValueInformation); if (NT_SUCCESS(status) && ((keyValueInformation->Type == REG_SZ) && (keyValueInformation->DataLength != 0))) { HANDLE controlKey; UNICODE_STRING unicodeClassGuid; IopRegistryDataToUnicodeString( &unicodeClassGuid, (PWSTR) KEY_VALUE_DATA(keyValueInformation), keyValueInformation->DataLength); DebugPrint(1, ("IopCallDriverAddDevice:\t\tClass GUID is %wZ\n", &unicodeClassGuid)); if (InitSafeBootMode) { if (!IopSafebootDriverLoad(&unicodeClassGuid)) { PKEY_VALUE_FULL_INFORMATION ClassValueInformation = NULL; NTSTATUS s; // // don't load the driver // DbgPrint("SAFEBOOT: skipping device = %wZ\n",&unicodeClassGuid); s = IopGetRegistryValue(instanceKey, REGSTR_VAL_DEVDESC, &ClassValueInformation); if (NT_SUCCESS(s)) { UNICODE_STRING ClassString; RtlInitUnicodeString(&ClassString, (PCWSTR) KEY_VALUE_DATA(ClassValueInformation)); IopBootLog(&ClassString, FALSE); } else { IopBootLog(&unicodeClassGuid, FALSE); } return STATUS_UNSUCCESSFUL; } } // // Open the class key // status = IopOpenRegistryKeyEx( &controlKey, NULL, &CmRegistryMachineSystemCurrentControlSetControlClass, KEY_READ ); if (!NT_SUCCESS(status)) { DebugPrint(1, ("IopCallDriverAddDevice:\tUnable to open " "HKLM\\SYSTEM\\CCS\\CONTROL\\CLASS - %#08lx\n", status)); classKey = NULL; } else { status = IopOpenRegistryKeyEx( &classKey, controlKey, &unicodeClassGuid, KEY_READ ); ZwClose(controlKey); if (!NT_SUCCESS(status)) { DebugPrint(1, ("IopCallDriverAddDevice:\tUnable to open GUID key " "%wZ - %#08lx\n", &unicodeClassGuid, status)); classKey = NULL; } } if (classKey != NULL) { UNICODE_STRING unicodeProperties; RtlInitUnicodeString(&unicodeProperties, REGSTR_KEY_DEVICE_PROPERTIES ); status = IopOpenRegistryKeyEx( &classPropsKey, classKey, &unicodeProperties, KEY_READ ); if (!NT_SUCCESS(status)) { DebugPrint(2, ("IopCallDriverAddDevice:\tUnable to open GUID\\Properties key " "%wZ - %#08lx\n", &unicodeClassGuid, status)); classPropsKey = NULL; } } ExFreePool(keyValueInformation); keyValueInformation = NULL; } // // Check to see if there's a service assigned to this device node. If // there's not then we can bail out without wasting too much time. // RtlZeroMemory(&queryContext, sizeof(queryContext)); queryContext.DeviceNode = DeviceNode; queryContext.LoadDriver = LoadDriver; queryContext.AddContext = Context; RtlZeroMemory(queryTable, sizeof(queryTable)); queryTable[0].QueryRoutine = (PRTL_QUERY_REGISTRY_ROUTINE) IopCallDriverAddDeviceQueryRoutine; queryTable[0].Name = REGSTR_VAL_LOWERFILTERS; queryTable[0].EntryContext = (PVOID) UIntToPtr(LowerDeviceFilters); status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE, (PWSTR) instanceKey, queryTable, &queryContext, NULL); if (NT_SUCCESS(status)) { if (classKey != NULL) { queryTable[0].QueryRoutine = (PRTL_QUERY_REGISTRY_ROUTINE) IopCallDriverAddDeviceQueryRoutine; queryTable[0].Name = REGSTR_VAL_LOWERFILTERS; queryTable[0].EntryContext = (PVOID) UIntToPtr(LowerClassFilters); status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE, (PWSTR) classKey, queryTable, &queryContext, NULL); } if (NT_SUCCESS(status)) { queryTable[0].QueryRoutine = (PRTL_QUERY_REGISTRY_ROUTINE) IopCallDriverAddDeviceQueryRoutine; queryTable[0].Name = REGSTR_VALUE_SERVICE; queryTable[0].EntryContext = (PVOID) UIntToPtr(DeviceService); queryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED; status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE, (PWSTR) instanceKey, queryTable, &queryContext, NULL); } } if (DeviceNode->Flags & DNF_LEGACY_DRIVER) { // // One of the services for this device is a legacy driver. Don't try // to add any filters since we'll just screw up the device stack. // status = STATUS_SUCCESS; goto Cleanup; } else if (NT_SUCCESS(status)) { // // Call was successful so we must have been able to reference the // driver object. // ASSERT(queryContext.DriverLists[DeviceService] != NULL); if (queryContext.DriverLists[DeviceService]->NextEntry != NULL) { // // There's more than one service assigned to this device. Configuration // error DebugPrint(1, ("IopCallDriverAddDevice: Configuration Error - more " "than one service in driver list\n")); IopSetDevNodeProblem(DeviceNode, CM_PROB_REGISTRY); status = STATUS_UNSUCCESSFUL; goto Cleanup; } // // this is the only case (FDO specified) where we can ignore PDO's characteristics // usePdoCharacteristics = FALSE; } else if (status == STATUS_OBJECT_NAME_NOT_FOUND) { DebugPrint(1, ("IopCallDriverAddDevice\t\tError %#08lx reading service " "value for devnode %#08lx\n", status, DeviceNode)); if (!IopDeviceNodeFlagsToCapabilities(DeviceNode)->RawDeviceOK) { // // The device cannot be used raw. Bail out now. // status = STATUS_UNSUCCESSFUL; goto Cleanup; } else { // // Raw device access is okay. // IopClearDevNodeProblem(DeviceNode); usePdoCharacteristics = TRUE; // shouldn't need to do this, but better be safe than sorry deviceRaw = TRUE; status = STATUS_SUCCESS; } } else { // // something else went wrong while parsing the service key. The // query routine will have set the flags appropriately so we can // just bail out. // goto Cleanup; } // // For each type of filter driver we want to build a list of the driver // objects to be loaded. We'll build all the driver lists if we can // and deal with error conditions afterwards. // // // First get all the information we have to out of the instance key and // the device node. // RtlZeroMemory(queryTable, sizeof(queryTable)); queryTable[0].QueryRoutine = (PRTL_QUERY_REGISTRY_ROUTINE) IopCallDriverAddDeviceQueryRoutine; queryTable[0].Name = REGSTR_VAL_UPPERFILTERS; queryTable[0].EntryContext = (PVOID) UIntToPtr(UpperDeviceFilters); status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE, (PWSTR) instanceKey, queryTable, &queryContext, NULL); if (NT_SUCCESS(status) && classKey) { queryTable[0].QueryRoutine = (PRTL_QUERY_REGISTRY_ROUTINE) IopCallDriverAddDeviceQueryRoutine; queryTable[0].Name = REGSTR_VAL_UPPERFILTERS; queryTable[0].EntryContext = (PVOID) UIntToPtr(UpperClassFilters); status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE, (PWSTR) classKey, queryTable, &queryContext, NULL); } if (NT_SUCCESS(status)) { UCHAR serviceType = 0; PDRIVER_LIST_ENTRY listEntry = queryContext.DriverLists[serviceType]; // // Make sure there's no more than one device service. Anything else is // a configuration error. // ASSERT(!(DeviceNode->Flags & DNF_LEGACY_DRIVER)); ASSERT(!(DeviceNode->Flags & DNF_ADDED)); ASSERTMSG( "Error - Device has no service but cannot be run RAW\n", ((queryContext.DriverLists[DeviceService] != NULL) || (deviceRaw))); #ifndef NO_SPECIAL_IRP // // Grab the top of PDO stack // topOfPdoStack = IoGetAttachedDevice(DeviceNode->PhysicalDeviceObject); #endif // // It's okay to try adding all the drivers. // for (serviceType = 0; serviceType < MaximumAddStage; serviceType++) { DebugPrint(1, ("IopCallDriverAddDevice: Adding Services (type %d)\n", serviceType)); if (serviceType == DeviceService) { if (deviceRaw&&(queryContext.DriverLists[serviceType]==NULL)) { // // Mark the devnode as added, as it has no service. // ASSERT(queryContext.DriverLists[serviceType] == NULL); DeviceNode->Flags |= DNF_ADDED; #ifndef NO_SPECIAL_IRP // // For the purpose of asserting IRPs, we mark the FDO. We // don't mark a raw PDO as the BOTTOM of the FDO stack as // that would be the lower filter in this case. // DeviceNode->PhysicalDeviceObject->DeviceObjectExtension->ExtensionFlags |= DOE_DESIGNATED_FDO | DOE_RAW_FDO; } else { // // Since we are going to see a service, grab a pointer to // the current top of the stack. While here, assert there // is exactly one service driver to load... // ASSERT(queryContext.DriverLists[serviceType]); ASSERT(!queryContext.DriverLists[serviceType]->NextEntry); topOfLowerFilterStack = IoGetAttachedDevice(DeviceNode->PhysicalDeviceObject); #endif } } for (listEntry = queryContext.DriverLists[serviceType]; listEntry != NULL; listEntry = listEntry->NextEntry) { PDRIVER_ADD_DEVICE addDeviceRoutine; DebugPrint(1, ("IopCallDriverAddDevice:\tAdding driver %#08lx\n", listEntry->DriverObject)); ASSERT(listEntry->DriverObject); ASSERT(listEntry->DriverObject->DriverExtension); ASSERT(listEntry->DriverObject->DriverExtension->AddDevice); // // Invoke the driver's AddDevice() entry point. // addDeviceRoutine = listEntry->DriverObject->DriverExtension->AddDevice; status = (addDeviceRoutine)(listEntry->DriverObject, DeviceNode->PhysicalDeviceObject); DebugPrint(1, ("IopCallDriverAddDevice:\t\tRoutine returned " "%#08lx\n", status)); if (NT_SUCCESS(status)) { #ifndef NO_SPECIAL_IRP if (!deviceObjectHasBeenAttached) { // // Mark the first driver loaded by this routine as the // bottom of the FDO stack. These must detach on a remove. // Note we can't simply flag the top of the stack, as // someone might attach in AddDevice... // fdoDeviceObject = topOfPdoStack->AttachedDevice; if (fdoDeviceObject) { fdoDeviceObject->DeviceObjectExtension->ExtensionFlags |= DOE_BOTTOM_OF_FDO_STACK; deviceObjectHasBeenAttached = TRUE; } } // // Also note it is legal for a filter to succeed AddDevice // but fail to attach anything to the top of the stack. // if (serviceType == DeviceService) { // // ADRIAO BUGBUG 10/07/98 - Since we are temporarily // letting successful but Noop'd AddDevice's through, // mark the stack appropriately. We will make it look // like a RAW FDO // fdoDeviceObject = topOfLowerFilterStack->AttachedDevice; //ASSERT(fdoDeviceObject != NULL); if (!fdoDeviceObject) { // // Nope, didn't get an FDO. Mark the PDO raw. // ADRIAO BUGBUG 10/07/98 - // Another reason to complain about the legality // of succeeding a FDO AddDevice without attaching // anything - how does the PDO know he also has to // respond as an FDO???? // fdoDeviceObject = DeviceNode->PhysicalDeviceObject; fdoDeviceObject->DeviceObjectExtension->ExtensionFlags |= DOE_RAW_FDO; } // // Mark appropriate node "FDO". // fdoDeviceObject->DeviceObjectExtension->ExtensionFlags |= DOE_DESIGNATED_FDO; } #endif DeviceNode->Flags |= DNF_ADDED; } else if (serviceType == DeviceService) { // // If filter drivers return failure, keep going. // DeviceNode->Flags &= ~DNF_ADDED; IopSetDevNodeProblem(DeviceNode, CM_PROB_FAILED_ADD); IopRequestDeviceRemoval(DeviceNode->PhysicalDeviceObject, CM_PROB_FAILED_ADD); goto Cleanup; } if (IoGetAttachedDevice(DeviceNode->PhysicalDeviceObject)->Flags & DO_DEVICE_INITIALIZING) { DebugPrint(1, ("***************** DO_DEVICE_INITIALIZING not cleared on %#08lx\n", IoGetAttachedDevice(DeviceNode->PhysicalDeviceObject))); } ASSERT_INITED(IoGetAttachedDevice(DeviceNode->PhysicalDeviceObject)); } } // // change PDO and all attached objects // to have properties specified in the registry // IopChangeDeviceObjectFromRegistryProperties(DeviceNode->PhysicalDeviceObject, classPropsKey, instanceKey, usePdoCharacteristics); // // CapabilityFlags are refreshed with call to IopDeviceCapabilitiesToRegistry after device is started // } else { DebugPrint(1, ("IopCallDriverAddDevice: Error %#08lx while building " "driver load list\n", status)); } deviceObject = DeviceNode->PhysicalDeviceObject; status = IopQueryLegacyBusInformation( deviceObject, NULL, &DeviceNode->InterfaceType, &DeviceNode->BusNumber ); if (!NT_SUCCESS(status)) { DeviceNode->InterfaceType = InterfaceTypeUndefined; DeviceNode->BusNumber = 0xfffffff0; } status = STATUS_SUCCESS; Cleanup: { UCHAR i; DebugPrint(1, ("IopCallDriverAddDevice: DevNode flags leaving = %#08lx\n", DeviceNode->Flags)); DebugPrint(1, ("IopCallDriverAddDevice: Cleaning up\n")); // // Free the entries in the driver load list & release the references on // their driver objects. // for (i = 0; i < MaximumAddStage; i++) { PDRIVER_LIST_ENTRY listHead = queryContext.DriverLists[i]; while(listHead != NULL) { PDRIVER_LIST_ENTRY tmp = listHead; listHead = listHead->NextEntry; ASSERT(tmp->DriverObject != NULL); ObDereferenceObject(tmp->DriverObject); ExFreePool(tmp); } } } ZwClose(instanceKey); if (classKey != NULL) { ZwClose(classKey); } if (classPropsKey != NULL) { ZwClose(classPropsKey); } DebugPrint(1, ("IopCallDriverAddDevice: Returning status %#08lx\n", status)); return status; }

NTSTATUS IopCallDriverAddDeviceQueryRoutine (  IN PWSTR  ValueName, IN ULONG  ValueType, IN PWCHAR  ValueData, IN ULONG  ValueLength, IN PQUERY_CONTEXT  Context, IN ULONG  ServiceType )

Definition at line 3165 of file pnpenum.c. References _REINIT_PACKET::Context, _DRIVER_EXTENSION::Count, DebugPrint, DeviceService, DNF_ADDED, DNF_LEGACY_DRIVER, DNF_STARTED, _DRIVER_OBJECT::DriverExtension, _REINIT_PACKET::DriverObject, _REINIT_PACKET::DriverReinitializationRoutine, DRVO_INITIALIZED, DRVO_REINIT_REGISTERED, ExAllocatePool, ExFreePool(), ExInterlockedRemoveHeadList(), FALSE, _DRIVER_OBJECT::Flags, IopDatabaseLock, IopDoesDevNodeHaveProblem, IopDriverReinitializeQueueHead, IopGetDriverNameFromKeyNode(), IopGetGroupOrderIndex(), IopGetRegistryValue(), IopIsLegacyDriver(), IopLoadBootFilterDriver(), IopLoadDriver(), IopOpenServiceEnumKeys(), IopReferenceDriverObjectByName(), IopSetDevNodeProblem, KEY_VALUE_DATA, L, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, OK_TO_ADD_DEVICE, PagedPool, PDRIVER_LIST_ENTRY, PnPBootDriversInitialized, PnPInitialized, RtlFreeUnicodeString(), RtlInitUnicodeString(), TRUE, USHORT, and ValueName. Referenced by IopCallDriverAddDevice(). : This routine is called to build a list of driver objects which need to be Added to a physical device object. Each time it is called with a service name it will locate a driver object for that device and append it to the proper driver list for the device node. In the event a driver object cannot be located or that it cannot be loaded at this time, this routine will return an error and will set the flags in the device node in the context appropriately. Arguments: ValueName - the name of the value ValueType - the type of the value ValueData - the data in the value (unicode string data) ValueLength - the number of bytes in the value data Context - a structure which contains the device node, the context passed to IopCallDriverAddDevice and the driver lists for the device node. EntryContext - the index of the driver list the routine should append nodes to. Return Value: STATUS_SUCCESS if the driver was located and added to the list successfully or if there was a non-fatal error while handling the driver. an error value indicating why the driver could not be added to the list. --*/ { UNICODE_STRING unicodeServiceName; UNICODE_STRING unicodeDriverName; PKEY_VALUE_FULL_INFORMATION keyValueInformation; ULONG i; ULONG loadType; PWSTR prefixString = L"\\Driver\\"; BOOLEAN madeupService; USHORT groupIndex; PDRIVER_OBJECT driverObject = NULL; NTSTATUS status = STATUS_SUCCESS; BOOLEAN freeDriverName = FALSE; DebugPrint(1, ("IopCallDriverAddDevice:\t\tValue %ws [Type %d, Len %d] @ " "%#08lx\n", ValueName, ValueType, ValueLength, ValueData)); // // First check and make sure that the value type is okay. An invalid type // is not a fatal error. // if (ValueType != REG_SZ) { DebugPrint(1, ("IopCallDriverAddDevice:\t\tValueType %d invalid for " "ServiceType %d\n", ValueType, ServiceType)); return STATUS_SUCCESS; } // // Make sure the string is a reasonable length. // if (ValueLength <= sizeof(WCHAR)) { DebugPrint(1, ("IopCallDriverAddDevice:\t\tValueLength %d is too short\n", ValueLength)); return STATUS_SUCCESS; } RtlInitUnicodeString(&unicodeServiceName, ValueData); DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tService Name %wZ\n", &unicodeServiceName)); // // Check the service name to see if it should be used directly to reference // the driver object. If the string begins with "\Driver", make sure the // madeupService flag is set. // madeupService = TRUE; i = 0; while(*prefixString != L'\0') { if (unicodeServiceName.Buffer[i] != *prefixString) { madeupService = FALSE; break; } i++; prefixString++; } if (madeupService) { RtlInitUnicodeString(&unicodeDriverName, unicodeServiceName.Buffer); groupIndex = 0; loadType = SERVICE_BOOT_START; } else { HANDLE serviceKey; // // BUGBUG - (RBN) Hack to set the service name in the devnode if it // isn't already set. // // This probably should be done earlier somewhere else after the // INF is run, but if we don't do it now we'll blow up when we // call IopGetDriverLoadType below. // if (Context->DeviceNode->ServiceName.Length == 0) { Context->DeviceNode->ServiceName = unicodeServiceName; Context->DeviceNode->ServiceName.Buffer = ExAllocatePool( NonPagedPool, unicodeServiceName.MaximumLength ); if (Context->DeviceNode->ServiceName.Buffer != NULL) { RtlCopyMemory( Context->DeviceNode->ServiceName.Buffer, unicodeServiceName.Buffer, unicodeServiceName.MaximumLength ); } else { RtlInitUnicodeString( &Context->DeviceNode->ServiceName, NULL ); DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tCannot allocate memory for service name in devnode\n")); status = STATUS_UNSUCCESSFUL; goto Cleanup; } } // // Check in the registry to find the name of the driver object // for this device. // status = IopOpenServiceEnumKeys(&unicodeServiceName, KEY_READ, &serviceKey, NULL, FALSE); if (!NT_SUCCESS(status)) { // // Cannot open the service key for this driver. This is a // fatal error. // DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tStatus %#08lx " "opening service key\n", status)); IopSetDevNodeProblem(Context->DeviceNode, CM_PROB_REGISTRY); goto Cleanup; } groupIndex = IopGetGroupOrderIndex(serviceKey); status = IopGetDriverNameFromKeyNode(serviceKey, &unicodeDriverName); if (!NT_SUCCESS(status)) { ZwClose(serviceKey); // // Can't get the driver name from the service key. This is a // fatal error. // DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tStatus %#08lx " "getting driver name\n", status)); IopSetDevNodeProblem(Context->DeviceNode, CM_PROB_REGISTRY); goto Cleanup; } else { freeDriverName = TRUE; } loadType = SERVICE_DISABLED; status = IopGetRegistryValue(serviceKey, L"Start", &keyValueInformation); if (NT_SUCCESS(status)) { if (keyValueInformation->Type == REG_DWORD) { if (keyValueInformation->DataLength == sizeof(ULONG)) { loadType = *(PULONG)KEY_VALUE_DATA(keyValueInformation); } } ExFreePool(keyValueInformation); } ZwClose(serviceKey); } DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tDriverName is %wZ\n", &unicodeDriverName)); driverObject = IopReferenceDriverObjectByName(&unicodeDriverName); if (driverObject == NULL) { PWCHAR buffer; UNICODE_STRING unicodeServicePath; // // We couldn't find a driver object. It's possible the driver isn't // loaded & initialized so check to see if we can try to load it // now. // if (madeupService) { // // The madeup service's driver doesn't seem to exist yet. // We will fail the request without setting DNF_ADD_FAILED such that // we will try it again later. (Root Enumerated devices...) // DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tCannot find driver " "object for madeup service\n")); status = STATUS_UNSUCCESSFUL; goto Cleanup; } if (ServiceType != DeviceService && !PnPBootDriversInitialized) { // // If we are in BootDriverInitialization phase and trying to load a filter driver // driverObject = IopLoadBootFilterDriver(&unicodeDriverName, groupIndex); if (driverObject == NULL) { status = STATUS_UNSUCCESSFUL; goto Cleanup; } } else { if (!Context->LoadDriver) { // // We're not supposed to try and load a driver - most likely our // disk drivers aren't initialized yet. We need to stop the add // process but we can't mark the devnode as failed or we won't // be called again when we can load the drivers. // DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tNot allowed to load " "drivers yet\n")); status = STATUS_UNSUCCESSFUL; goto Cleanup; } if (groupIndex > Context->AddContext->GroupsToStart) { // // We're not allowed to initialize this driver until drivers in // previous groups are loaded. Leave the devnode flags untouched // so we get called again, but stop the add process now. // DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tLower group drivers " "have not been initialized yet\n")); if (groupIndex < Context->AddContext->GroupToStartNext) { Context->AddContext->GroupToStartNext = groupIndex; } DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tGroup = %d, To Start = " "Start Next = %d\n", groupIndex, Context->AddContext->GroupsToStart, Context->AddContext->GroupToStartNext)); status = STATUS_UNSUCCESSFUL; goto Cleanup; } if (loadType > Context->AddContext->DriverStartType) { if (loadType == SERVICE_DISABLED && !IopDoesDevNodeHaveProblem(Context->DeviceNode)) { IopSetDevNodeProblem(Context->DeviceNode, CM_PROB_DISABLED_SERVICE); } // // The service is either disabled or we are not at the right // time to load it. Don't load it, but make sure we can get // called again. If a service is marked as demand start, we // always load it. // DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tService is disabled or not at right time to load it\n")); status = STATUS_UNSUCCESSFUL; goto Cleanup; } { HANDLE handle; // // Check in the registry to find the name of the driver object // for this device. // status = IopOpenServiceEnumKeys(&unicodeServiceName, KEY_READ, &handle, NULL, FALSE); if (!NT_SUCCESS(status)) { // // Cannot open the service key for this driver. This is a // fatal error. // DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tStatus %#08lx " "opening service key\n", status)); } else { status = IopLoadDriver(handle,FALSE); // handle will be closed by IopLoadDriver if (PnPInitialized) { PLIST_ENTRY entry; PREINIT_PACKET reinitEntry; // // Walk the list reinitialization list in case this driver, or // some other driver, has requested to be invoked at a re- // initialization entry point. // while (entry = ExInterlockedRemoveHeadList( &IopDriverReinitializeQueueHead, &IopDatabaseLock )) { reinitEntry = CONTAINING_RECORD( entry, REINIT_PACKET, ListEntry ); reinitEntry->DriverObject->DriverExtension->Count++; reinitEntry->DriverObject->Flags &= ~DRVO_REINIT_REGISTERED; reinitEntry->DriverReinitializationRoutine( reinitEntry->DriverObject, reinitEntry->Context, reinitEntry->DriverObject->DriverExtension->Count ); ExFreePool( reinitEntry ); } } } } if (!NT_SUCCESS(status)) { if (PnPBootDriversInitialized) { DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tStatus %#08lx " "from loading driver\n", status)); } } } } else { ObDereferenceObject(driverObject); if (!(driverObject->Flags & DRVO_INITIALIZED)) { status = STATUS_UNSUCCESSFUL; goto Cleanup; } } // // Ignore the return value from the driver load - just try and get a // pointer to the driver object for the service. // driverObject = IopReferenceDriverObjectByName(&unicodeDriverName); if (driverObject == NULL) { if (PnPBootDriversInitialized) { // // Apparently the load didn't work out very well. This is a // fatal error. // DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tUnable to reference " "driver %wZ\n", &unicodeDriverName)); if (!IopDoesDevNodeHaveProblem(Context->DeviceNode)) { IopSetDevNodeProblem(Context->DeviceNode, CM_PROB_FAILED_ADD); } } status = STATUS_UNSUCCESSFUL; goto Cleanup; } else if (!(driverObject->Flags & DRVO_INITIALIZED)) { ObDereferenceObject(driverObject); status = STATUS_UNSUCCESSFUL; goto Cleanup; } DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tDriver Reference %#08lx\n", driverObject)); // // Check to see if the driver is a legacy driver rather than a Pnp one. // if (IopIsLegacyDriver(driverObject)) { // // It is. Since the legacy driver may have already obtained a // handle to the device object, we need to assume this device // has been added and started. // DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tDriver is a legacy " "driver\n")); if (ServiceType == DeviceService) { Context->DeviceNode->Flags |= DNF_ADDED + DNF_STARTED + DNF_LEGACY_DRIVER; status = STATUS_UNSUCCESSFUL; } else { // // We allow someone to plug in a legacy driver as a filter driver. // In this case, the legacy driver will be loaded but will not be part // of our pnp driver stack. // status = STATUS_SUCCESS; } goto Cleanup; } // // There's a chance the driver detected this PDO during it's driver entry // routine. If it did then just bail out. // if (!OK_TO_ADD_DEVICE(Context->DeviceNode)) { DebugPrint(1, ("IopCallDriverAddDevice\t\t\tDevNode was reported " "as detected during driver entry\n")); status = STATUS_UNSUCCESSFUL; goto Cleanup; } // // Add the driver to the list. // { PDRIVER_LIST_ENTRY listEntry; PDRIVER_LIST_ENTRY *runner = &(Context->DriverLists[ServiceType]); status = STATUS_SUCCESS; // // Allocate a new list entry to queue this driver object for the caller // listEntry = ExAllocatePool(PagedPool, sizeof(DRIVER_LIST_ENTRY)); if (listEntry == NULL) { DebugPrint(1, ("IopCallDriverAddDevice:\t\t\tUnable to allocate list " "entry\n")); status = STATUS_INSUFFICIENT_RESOURCES; goto Cleanup; } listEntry->DriverObject = driverObject; listEntry->NextEntry = NULL; while(*runner != NULL) { runner = &((*runner)->NextEntry); } *runner = listEntry; } Cleanup: if (freeDriverName) { RtlFreeUnicodeString(&unicodeDriverName); } return status; }

NTSTATUS IopChangeDeviceObjectFromRegistryProperties (  IN PDEVICE_OBJECT  PhysicalDeviceObject, IN HANDLE  DeviceClassPropKey, IN HANDLE  DevicePropKey, IN BOOLEAN  UsePdoCharacteristics )

Definition at line 4759 of file pnpenum.c. References ASSERT, _DEVICE_OBJECT::AttachedDevice, CHAR, _DEVICE_OBJECT::Characteristics, DebugPrint, DO_DEVICE_HAS_NAME, DO_EXCLUSIVE, ExFreePool(), FALSE, _DEVICE_OBJECT::Flags, IopCreateDefaultDeviceSecurityDescriptor(), IopGetRegistryDwordWithFallback(), IopGetRegistrySecurityWithFallback(), NT_SUCCESS, NTSTATUS(), NULL, ObSetSecurityObjectByPointer(), RtlGetDaclSecurityDescriptor(), RtlGetGroupSecurityDescriptor(), RtlGetOwnerSecurityDescriptor(), RtlGetSaclSecurityDescriptor(), RtlInitUnicodeString(), and TRUE. Referenced by IopCallDriverAddDevice(). 04767 : 04768 04769 This routine will obtain settings from either 04770 (1) DevNode settings (via DevicePropKey) or 04771 (2) Class settings (via DeviceClassPropKey) 04772 applying to PDO and all attached device objects 04773 04774 Properties set/ changed are: 04775 04776 * DeviceType - the I/O system type for the device object 04777 * DeviceCharacteristics - the I/O system characteristic flags to be 04778 set for the device object 04779 * Exclusive - the device can only be accessed exclusively 04780 * Security - security for the device 04781 04782 The routine will then use the DeviceType and DeviceCharacteristics specified 04783 to determine whether a VPB should be allocated as well as to set default 04784 security if none is specified in the registry. 04785 04786 Arguments: 04787 04788 PhysicalDeviceObject - the PDO we are to configure 04789 04790 DeviceClassPropKey - a handle to Control\<Class>\Properties protected key 04791 DevicePropKey - a handle to Enum\<Instance> protected key 04792 04793 Return Value: 04794 04795 status 04796 04797 --*/ 04798 04799 { 04800 UNICODE_STRING valueName; 04801 PKEY_VALUE_FULL_INFORMATION info; 04802 PUCHAR data; 04803 NTSTATUS status; 04804 04805 BOOLEAN deviceTypeSpec = FALSE; 04806 BOOLEAN characteristicsSpec = FALSE; 04807 BOOLEAN exclusiveSpec = FALSE; 04808 BOOLEAN securityForce = FALSE; 04809 CHAR buffer[SECURITY_DESCRIPTOR_MIN_LENGTH]; 04810 SECURITY_INFORMATION securityInformation = 0; 04811 04812 PSECURITY_DESCRIPTOR securityDescriptor = NULL; 04813 PACL allocatedAcl = NULL; 04814 ULONG deviceType = 0; 04815 ULONG characteristics = 0; 04816 ULONG exclusive = 0; 04817 ULONG prevCharacteristics = 0; 04818 ULONG prevExclusive = 0; 04819 PDEVICE_OBJECT StackIterator = NULL; 04820 PDEVICE_NODE deviceNode = NULL; 04821 04822 ASSERT(PhysicalDeviceObject); 04823 deviceNode = PhysicalDeviceObject->DeviceObjectExtension->DeviceNode; 04824 ASSERT(deviceNode); 04825 04826 DebugPrint(2, ("IopChangeDeviceObjectFromRegistryProperties: Modifying device stack for PDO: %08x\n",PhysicalDeviceObject)); 04827 04828 // 04829 // Iterate through all device objects to get our starting settings (OR everyone together) 04830 // generally, a PDO should take on the characteristics of whoever is above the PDO, and not used in the equation 04831 // the exception being if it's being used RAW 04832 // we detect this by absense of service name, or it's the only Device Object. 04833 // 04834 StackIterator = PhysicalDeviceObject; 04835 if (UsePdoCharacteristics || StackIterator->AttachedDevice == NULL) { 04836 DebugPrint(2, ("IopChangeDeviceObjectFromRegistryProperties: Assuming PDO is being used RAW\n")); 04837 } else { 04838 StackIterator = StackIterator->AttachedDevice; 04839 DebugPrint(2, ("IopChangeDeviceObjectFromRegistryProperties: Ignoring PDO's settings\n")); 04840 } 04841 for ( ; StackIterator != NULL; StackIterator = StackIterator->AttachedDevice) { 04842 #if 0 // BUGBUG (jamiehun) we were breaking serial, I'd like to put this back in though... 04843 prevExclusive |= StackIterator->Flags & DO_EXCLUSIVE; 04844 #endif 04845 prevCharacteristics |= StackIterator->Characteristics; 04846 } 04847 04848 // 04849 // 1) Get Device type, DevicePropKey preferred over DeviceClassPropKey 04850 // 04851 RtlInitUnicodeString(&valueName, REGSTR_VAL_DEVICE_TYPE); 04852 deviceTypeSpec = IopGetRegistryDwordWithFallback(&valueName,DevicePropKey,DeviceClassPropKey,&deviceType); 04853 RtlInitUnicodeString(&valueName, REGSTR_VAL_DEVICE_CHARACTERISTICS); 04854 characteristicsSpec = IopGetRegistryDwordWithFallback(&valueName,DevicePropKey,DeviceClassPropKey,&characteristics); 04855 RtlInitUnicodeString(&valueName, REGSTR_VAL_DEVICE_EXCLUSIVE); 04856 exclusiveSpec = IopGetRegistryDwordWithFallback(&valueName,DevicePropKey,DeviceClassPropKey,&exclusive); 04857 04858 if (exclusive) { 04859 // 04860 // make sure a TRUE maps to a bit-mask 04861 // 04862 exclusive = DO_EXCLUSIVE; 04863 } 04864 04865 if (exclusiveSpec) { 04866 exclusive |= prevExclusive; 04867 } else { 04868 exclusive = prevExclusive; 04869 } 04870 if (!characteristicsSpec) { 04871 characteristics = 0; 04872 } 04873 characteristics = (characteristics | prevCharacteristics) & FILE_CHARACTERISTICS_PROPAGATED; // mask only applicable characteristics 04874 04875 RtlInitUnicodeString(&valueName, REGSTR_VAL_DEVICE_SECURITY_DESCRIPTOR); 04876 securityDescriptor = IopGetRegistrySecurityWithFallback(&valueName,DevicePropKey,DeviceClassPropKey); 04877 04878 if (securityDescriptor == NULL) { 04879 // 04880 // determine if we should create internal default 04881 // 04882 if (deviceTypeSpec) { 04883 BOOLEAN hasName = (PhysicalDeviceObject->Flags & DO_DEVICE_HAS_NAME) ? TRUE : FALSE; 04884 04885 securityDescriptor = IopCreateDefaultDeviceSecurityDescriptor( 04886 (DEVICE_TYPE)deviceType, 04887 characteristics, 04888 hasName, 04889 buffer, 04890 &allocatedAcl, 04891 &securityInformation 04892 ); 04893 if (securityDescriptor) { 04894 securityForce = TRUE; // forced default security descriptor 04895 } else { 04896 DebugPrint(1, ("IopChangeDeviceObjectFromRegistryProperties: Was not able to get default security descriptor\n")); 04897 } 04898 } 04899 } else { 04900 // 04901 // further process the security information we're given to set "securityInformation" 04902 // 04903 PSID sid; 04904 PACL acl; 04905 BOOLEAN present, tmp; 04906 04907 securityInformation = 0; 04908 04909 // 04910 // See what information is in the captured descriptor so we can build 04911 // up a securityInformation block to go with it. 04912 // 04913 04914 status = RtlGetOwnerSecurityDescriptor(securityDescriptor, &sid, &tmp); 04915 04916 if (NT_SUCCESS(status) && (sid != NULL)) { 04917 securityInformation |= OWNER_SECURITY_INFORMATION; 04918 } 04919 04920 status = RtlGetGroupSecurityDescriptor(securityDescriptor, &sid, &tmp); 04921 04922 if (NT_SUCCESS(status) && (sid != NULL)) { 04923 securityInformation |= GROUP_SECURITY_INFORMATION; 04924 } 04925 04926 status = RtlGetSaclSecurityDescriptor(securityDescriptor, 04927 &present, 04928 &acl, 04929 &tmp); 04930 04931 if (NT_SUCCESS(status) && (present)) { 04932 securityInformation |= SACL_SECURITY_INFORMATION; 04933 } 04934 04935 status = RtlGetDaclSecurityDescriptor(securityDescriptor, 04936 &present, 04937 &acl, 04938 &tmp); 04939 04940 if (NT_SUCCESS(status) && (present)) { 04941 securityInformation |= DACL_SECURITY_INFORMATION; 04942 } 04943 04944 } 04945 04946 #if DBG 04947 if (deviceTypeSpec == FALSE && characteristicsSpec == FALSE && exclusiveSpec == FALSE && securityDescriptor == NULL) { 04948 DebugPrint(2, ("IopChangeDeviceObjectFromRegistryProperties: No property changes\n")); 04949 } else { 04950 if (deviceTypeSpec) { 04951 DebugPrint(2, ("IopChangeDeviceObjectFromRegistryProperties: Overide DeviceType=%08x\n", 04952 deviceType)); 04953 } 04954 if (characteristicsSpec) { 04955 DebugPrint(2, ("IopChangeDeviceObjectFromRegistryProperties: Overide DeviceCharacteristics=%08x\n", 04956 characteristics)); 04957 } 04958 if (exclusiveSpec) { 04959 DebugPrint(2, ("IopChangeDeviceObjectFromRegistryProperties: Overide Exclusive=%d\n",(exclusive?1:0))); 04960 } 04961 if (securityForce) { 04962 DebugPrint(2, ("IopChangeDeviceObjectFromRegistryProperties: Overide Security based on DeviceType & DeviceCharacteristics\n")); 04963 } 04964 if (securityDescriptor == NULL) { 04965 DebugPrint(2, ("IopChangeDeviceObjectFromRegistryProperties: Overide Security\n")); 04966 } 04967 } 04968 #endif 04969 // 04970 // modify apropriate characteristics of PDO to be the same as those of rest of stack 04971 // eg, PDO may be initialized as Raw-Capable Secure Open, but then be modified to be more lax 04972 // 04973 PhysicalDeviceObject->Characteristics = (PhysicalDeviceObject->Characteristics & ~FILE_CHARACTERISTICS_PROPAGATED) | characteristics; 04974 ASSERT((PhysicalDeviceObject->Characteristics & FILE_CHARACTERISTICS_PROPAGATED) == characteristics); // sanity (checks bit bounds) 04975 // 04976 // modify exclusivity of PDO to be the same as those of rest of stack 04977 // eg, PDO may be initialized as Exclusive open, but be modified to be more lax 04978 // 04979 #if 0 // BUGBUG (jamiehun) we were breaking serial, I'd like to put this back in though... 04980 PhysicalDeviceObject->Flags = (PhysicalDeviceObject->Flags & ~DO_EXCLUSIVE) | exclusive; 04981 ASSERT((PhysicalDeviceObject->Flags & DO_EXCLUSIVE) == exclusive); // sanity (checks bit bounds) 04982 #endif 04983 04984 // 04985 // iterate through rest of objects 04986 // these flags were used to create characteristics & deviceType, so 04987 // we will only end up setting flags, not clearing them 04988 // 04989 for ( StackIterator = PhysicalDeviceObject->AttachedDevice ; StackIterator != NULL ; StackIterator = StackIterator->AttachedDevice) { 04990 // 04991 // modify characteristics (set only) 04992 // 04993 StackIterator->Characteristics |= characteristics; 04994 ASSERT((StackIterator->Characteristics & FILE_CHARACTERISTICS_PROPAGATED) == characteristics); // sanity (checks we only needed to set) 04995 // 04996 // modify exclusivity flag (set only) 04997 // 04998 StackIterator->Flags |= exclusive; 04999 #if 0 // BUGBUG (jamiehun) we were breaking serial, I'd like to put this back in though... 05000 ASSERT((StackIterator->Flags & DO_EXCLUSIVE) == exclusive); // sanity (checks we only needed to set) 05001 #endif 05002 } 05003 if (deviceTypeSpec) { 05004 // 05005 // modify device type - PDO only 05006 // 05007 PhysicalDeviceObject->DeviceType = deviceType; 05008 } 05009 if (securityDescriptor != NULL) { 05010 // 05011 // modify security (applied to whole stack) 05012 // 05013 status = ObSetSecurityObjectByPointer(PhysicalDeviceObject, 05014 securityInformation, 05015 securityDescriptor); 05016 if (NT_SUCCESS(status) == FALSE) { 05017 DebugPrint(1, ("IopChangeDeviceObjectFromRegistryProperties: Set security failed (%08x)\n",status)); 05018 } 05019 } 05020 // 05021 // cleanup 05022 // 05023 if ((securityDescriptor != NULL) && !securityForce) { 05024 ExFreePool(securityDescriptor); 05025 } 05026 if (allocatedAcl) { 05027 ExFreePool(allocatedAcl); 05028 } 05029 05030 return STATUS_SUCCESS; 05031 }

VOID IopDeviceActionWorker (  PVOID  Context  )

Definition at line 307 of file pnpenum.c. References _START_CONTEXT::AddContext, ASSERT, _DEVICE_NODE::Child, _PI_DEVICE_REQUEST::CompletionEvent, _PI_DEVICE_REQUEST::CompletionStatus, _DEVOBJ_EXTENSION::DeviceNode, _PI_DEVICE_REQUEST::DeviceObject, _DEVICE_OBJECT::DeviceObjectExtension, DNF_ADDED, DNF_ENUMERATED, DNF_STARTED, _ADD_CONTEXT::DriverStartType, _DEVICE_NODE::EnumerationMutex, ExAcquireResourceShared, ExFreePool(), ExReleaseResource, FALSE, _DEVICE_NODE::Flags, _ADD_CONTEXT::GroupsToStart, _ADD_CONTEXT::GroupToStartNext, IopAcquireDeviceTreeLock, IopAcquireEnumerationLock, IopBusCheck(), IopDeviceTreeLock, IopDoesDevNodeHaveProblem, IopEnumerationInProgress, IopNewDevice(), IopPnpEnumerationRequestList, IopPnPSpinLock, IopProcessAssignResources(), IopProcessNewDeviceNode(), IopProcessStartDevices(), IopReallocateResources(), IopReleaseDeviceTreeLock, IopReleaseEnumerationLock, IopResourcesReleased, IopRestartDeviceNode(), IopRootDeviceNode, KeEnterCriticalRegion, KeLeaveCriticalRegion, KeSetEvent(), _START_CONTEXT::LoadDriver, _DEVICE_NODE::LockCount, _START_CONTEXT::NewDevice, NO_MORE_GROUP, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, ObReferenceObject, PAGED_CODE, _DEVICE_NODE::Parent, _DEVICE_NODE::PhysicalDeviceObject, PiEnumerationLock, PNEW_DEVICE_WORK_ITEM, PnpAsyncOk, PnPBootDriversInitialized, PpRegistryDeviceResource, PpSynchronizeDeviceEventQueue(), ReenumerateBootDevices, ReenumerateDeviceOnly, _PI_DEVICE_REQUEST::RequestType, ResourceRequirementsChanged, _DEVICE_NODE::Sibling, StartDevice, and TRUE. Referenced by IopRequestDeviceAction(). 00313 : 00314 00315 This routine is the worker routine of ZwLoadDriver. 00316 Its main purpose is to start and enumerate the device controlled by the newly 00317 loaded drivers. 00318 00319 Caller must obtain a reference of the *new* device object. 00320 00321 Parameters: 00322 00323 Context - Supplies a pointer to the BUS_CHECK_WORK_ITEM. 00324 00325 ReturnValue: 00326 00327 None. 00328 00329 --*/ 00330 00331 { 00332 PPI_DEVICE_REQUEST request; 00333 PDEVICE_OBJECT deviceObject; 00334 PDEVICE_NODE deviceNode; 00335 PLIST_ENTRY entry; 00336 BOOLEAN assignResources = FALSE, allocateResources = FALSE; 00337 BOOLEAN bootConfigsOK = TRUE, bootProcess = FALSE; 00338 BOOLEAN newDevice, moreProcessing; 00339 START_CONTEXT startContext; 00340 KIRQL oldIrql; 00341 NTSTATUS status = STATUS_UNSUCCESSFUL; 00342 00343 PAGED_CODE(); 00344 00345 for (; ;) { 00346 00347 ExAcquireSpinLock(&IopPnPSpinLock, &oldIrql); 00348 entry = RemoveHeadList(&IopPnpEnumerationRequestList); 00349 if (entry == &IopPnpEnumerationRequestList) { 00350 entry = NULL; 00351 } 00352 ExReleaseSpinLock(&IopPnPSpinLock, oldIrql); 00353 00354 if (!entry) { 00355 00356 // 00357 // BUGBUG 00358 // 00359 // This code will get run whenever we remove a device (amongst other 00360 // situations). However, if we are trying to start boot devices, we 00361 // don't want to start other devices. The startContext should 00362 // probably be based on some global state that knows what devices 00363 // should be (and more importantly should not be) started. 00364 // 00365 if ((allocateResources && IopResourcesReleased) || assignResources || bootProcess) { 00366 00367 // 00368 // Retry resource allocation for the DNF_INSUFFICIENT_RESOURCES devices 00369 // if there are new resources become available. 00370 // 00371 00372 newDevice = TRUE; 00373 00374 startContext.LoadDriver = PnPBootDriversInitialized; 00375 startContext.AddContext.GroupsToStart = NO_MORE_GROUP; 00376 startContext.AddContext.GroupToStartNext = NO_MORE_GROUP; 00377 startContext.AddContext.DriverStartType = SERVICE_DEMAND_START; 00378 00379 do { 00380 00381 startContext.NewDevice = FALSE; 00382 00383 // 00384 // Process the whole device tree to assign resources to those devices who 00385 // have been successfully added to their drivers. 00386 // 00387 00388 moreProcessing = IopProcessAssignResources(IopRootDeviceNode, newDevice, bootConfigsOK); 00389 00390 // 00391 // Process the device subtree to start those devices who have been allocated 00392 // resources and waiting to be started. 00393 // Note, the IopProcessStartDevices routine may enumerate new devices. 00394 // 00395 00396 IopProcessStartDevices(IopRootDeviceNode, &startContext); 00397 newDevice = startContext.NewDevice; 00398 00399 } while ((moreProcessing || newDevice) && !bootProcess); 00400 00401 allocateResources = FALSE; 00402 assignResources = FALSE; 00403 bootProcess = FALSE; 00404 IopResourcesReleased = FALSE; // This flag is set on device removal 00405 00406 } else { 00407 00408 ExAcquireSpinLock(&IopPnPSpinLock, &oldIrql); 00409 00410 if (IsListEmpty(&IopPnpEnumerationRequestList)) { 00411 IopEnumerationInProgress = FALSE; 00412 KeSetEvent(&PiEnumerationLock, 0, FALSE); 00413 ExReleaseSpinLock(&IopPnPSpinLock, oldIrql); 00414 return; 00415 } 00416 00417 ExReleaseSpinLock(&IopPnPSpinLock, oldIrql); 00418 } 00419 00420 continue; 00421 } 00422 00423 request = CONTAINING_RECORD(entry, PI_DEVICE_REQUEST, ListEntry); 00424 if (request->DeviceObject == NULL) { 00425 00426 // 00427 // This is a request to retry resource allocation for the 00428 // DNF_INSUFFICIENT_RESOURCES or ResourceRequirementsChanged devices 00429 // 00430 00431 if (request->RequestType == ReenumerateBootDevices) { 00432 00433 // 00434 // Indicate that this is during boot driver initialization phase. 00435 // 00436 00437 bootProcess = TRUE; 00438 00439 // 00440 // Get whether this driver allows BOOT config assignment at its level. 00441 // 00442 00443 if (Context) { 00444 00445 bootConfigsOK = *(PBOOLEAN)Context; 00446 00447 } 00448 00449 } else if (request->RequestType == ResourceRequirementsChanged) { 00450 // 00451 // The device wasn't started when IopResourceRequirementsChanged 00452 // was called. 00453 // 00454 assignResources = TRUE; 00455 } else { 00456 // 00457 // Resources were freed we want to try to satisfy any 00458 // DNF_INSUFFICIENT_RESOURCES devices. 00459 // 00460 allocateResources = TRUE; 00461 } 00462 ExFreePool(request); 00463 00464 // 00465 // We've set the flags, we'll do the actual work once we've 00466 // processed any other requests in the queue. 00467 // 00468 continue; 00469 } 00470 00471 if (request->RequestType == ResourceRequirementsChanged) { 00472 00473 deviceObject = request->DeviceObject; 00474 00475 // 00476 // Enumerate this object 00477 // 00478 00479 IopReallocateResources(deviceObject); 00480 00481 } else if (request->RequestType == StartDevice) { 00482 00483 PNEW_DEVICE_WORK_ITEM newDeviceWorkItem; 00484 PDEVICE_NODE parentNode; 00485 00486 deviceObject = request->DeviceObject; 00487 deviceNode = deviceObject->DeviceObjectExtension->DeviceNode; 00488 00489 // 00490 // Start the specific device (reenumeration of parent not required in 00491 // this case) by first registering it then calling kernel-mode new 00492 // dev routine (note that this routine is normally called via a work 00493 // item but we're already in a work item now so call it directly. 00494 // 00495 00496 ASSERT(deviceNode); 00497 00498 // 00499 // Make sure we don't step on another enumerator's toes 00500 // 00501 00502 IopAcquireDeviceTreeLock(); 00503 00504 KeEnterCriticalRegion(); 00505 ExAcquireResourceShared(&PpRegistryDeviceResource, TRUE); 00506 00507 parentNode = deviceNode->Parent; 00508 if (parentNode != NULL) { 00509 ObReferenceObject(parentNode->PhysicalDeviceObject); 00510 } 00511 00512 ExReleaseResource(&PpRegistryDeviceResource); 00513 KeLeaveCriticalRegion(); 00514 00515 IopReleaseDeviceTreeLock(); 00516 00517 if (parentNode == NULL) { 00518 status = STATUS_UNSUCCESSFUL; 00519 goto Clean0; 00520 } 00521 00522 IopAcquireEnumerationLock(parentNode); 00523 00524 if (deviceNode->Flags & DNF_STARTED) { 00525 00526 IopReleaseEnumerationLock(parentNode); 00527 ObDereferenceObject(parentNode->PhysicalDeviceObject); 00528 status = STATUS_SUCCESS; 00529 goto Clean0; 00530 } 00531 00532 if ((parentNode->Parent == NULL && parentNode != IopRootDeviceNode) || 00533 !(parentNode->Flags & DNF_STARTED) || 00534 !(deviceNode->Flags & DNF_ENUMERATED) || 00535 IopDoesDevNodeHaveProblem(deviceNode) || 00536 (deviceNode->Flags & DNF_ADDED) || 00537 deviceNode->LockCount != 0) { 00538 00539 // 00540 // If the parent or child is going away bail now. 00541 // 00542 IopReleaseEnumerationLock(parentNode); 00543 ObDereferenceObject(parentNode->PhysicalDeviceObject); 00544 status = STATUS_UNSUCCESSFUL; 00545 goto Clean0; 00546 } 00547 00548 IopRestartDeviceNode(deviceNode); 00549 00550 status = IopProcessNewDeviceNode(deviceNode); 00551 00552 KeSetEvent( &parentNode->EnumerationMutex, 0, FALSE ); 00553 00554 if (NT_SUCCESS(status) && !IopDoesDevNodeHaveProblem(deviceNode)) { 00555 PIDBGMSG( PIDBG_EVENTS, 00556 ("IopDeviceActionWorker: START_REQUEST - calling IopNewDevice\n")); 00557 00558 IopNewDevice(deviceObject); 00559 } 00560 00561 IopReleaseDeviceTreeLock(); 00562 00563 ObDereferenceObject(parentNode->PhysicalDeviceObject); 00564 } else { 00565 00566 PDEVICE_NODE RootNode, parentNode; 00567 00568 // 00569 // Acquire the tree lock so no new removals get processed. 00570 // Note that devnodes already locked might still get removed while we hold the tree lock. 00571 // 00572 00573 ExAcquireResourceShared(&IopDeviceTreeLock, TRUE); 00574 00575 // 00576 // Reenumerate the target devnode. 00577 // 00578 00579 deviceNode = RootNode = request->DeviceObject->DeviceObjectExtension->DeviceNode; 00580 while(1) { 00581 00582 // 00583 // Validate that the devnode is not already removed. 00584 // 00585 00586 KeEnterCriticalRegion(); 00587 ExAcquireResourceShared(&PpRegistryDeviceResource, TRUE); 00588 00589 parentNode = deviceNode->Parent; 00590 if (parentNode) { 00591 ObReferenceObject(parentNode->PhysicalDeviceObject); 00592 } 00593 ObReferenceObject(deviceNode->PhysicalDeviceObject); 00594 00595 ExReleaseResource(&PpRegistryDeviceResource); 00596 KeLeaveCriticalRegion(); 00597 00598 if (parentNode) { 00599 00600 PDEVICE_NODE tempNode; 00601 00602 IopAcquireEnumerationLock(parentNode); 00603 tempNode = deviceNode->Parent; 00604 IopReleaseEnumerationLock(parentNode); 00605 if (!tempNode) { 00606 ObDereferenceObject(parentNode->PhysicalDeviceObject); 00607 } 00608 parentNode = tempNode; 00609 } 00610 00611 if (!parentNode && deviceNode != IopRootDeviceNode) { 00612 ObDereferenceObject(deviceNode->PhysicalDeviceObject); 00613 break; 00614 } 00615 00616 // 00617 // Make sure that the devnode is ready for enumeration. 00618 // 00619 00620 if (!IopDoesDevNodeHaveProblem(deviceNode) && 00621 (deviceNode->Flags & (DNF_ENUMERATED | DNF_STARTED)) == (DNF_ENUMERATED | DNF_STARTED)) { 00622 00623 // 00624 // Enumerate this object 00625 // 00626 00627 status = IopBusCheck( deviceNode->PhysicalDeviceObject, 00628 PnPBootDriversInitialized, // LoadDriver 00629 (BOOLEAN)(request->CompletionEvent != NULL ? FALSE : PnpAsyncOk)); 00630 if (status == STATUS_PNP_RESTART_ENUMERATION) { 00631 00632 if (parentNode) { 00633 ObDereferenceObject(parentNode->PhysicalDeviceObject); 00634 } 00635 ObDereferenceObject(deviceNode->PhysicalDeviceObject); 00636 ExReleaseResource(&IopDeviceTreeLock); 00637 PpSynchronizeDeviceEventQueue(); 00638 ExAcquireResourceShared(&IopDeviceTreeLock, TRUE); 00639 deviceNode = RootNode; 00640 continue; 00641 } 00642 } 00643 00644 // 00645 // Process the whole subtree unless specified otherwise. 00646 // 00647 00648 if (request->RequestType != ReenumerateDeviceOnly) { 00649 00650 if (deviceNode->Child) { 00651 00652 PDEVICE_NODE child = deviceNode->Child; 00653 00654 if (parentNode) { 00655 ObDereferenceObject(parentNode->PhysicalDeviceObject); 00656 } 00657 ObDereferenceObject(deviceNode->PhysicalDeviceObject); 00658 deviceNode = child; 00659 00660 } else { 00661 00662 while (deviceNode != RootNode) { 00663 00664 if (deviceNode->Sibling) { 00665 00666 PDEVICE_NODE sibling = deviceNode->Sibling; 00667 00668 if (parentNode) { 00669 ObDereferenceObject(parentNode->PhysicalDeviceObject); 00670 } 00671 ObDereferenceObject(deviceNode->PhysicalDeviceObject); 00672 deviceNode = sibling; 00673 break; 00674 00675 } else { 00676 00677 ObDereferenceObject(deviceNode->PhysicalDeviceObject); 00678 deviceNode = parentNode; 00679 parentNode = deviceNode->Parent; 00680 if (parentNode) { 00681 ObReferenceObject(parentNode->PhysicalDeviceObject); 00682 } 00683 } 00684 } 00685 } 00686 } 00687 00688 // 00689 // We are done if we are back where we started. 00690 // 00691 00692 if (deviceNode == RootNode) { 00693 00694 if (parentNode) { 00695 ObDereferenceObject(parentNode->PhysicalDeviceObject); 00696 } 00697 ObDereferenceObject(deviceNode->PhysicalDeviceObject); 00698 break; 00699 } 00700 } 00701 00702 // 00703 // Unlock the tree so removals can proceed. 00704 // 00705 00706 ExReleaseResource(&IopDeviceTreeLock); 00707 status = STATUS_SUCCESS; 00708 } 00709 00710 Clean0: 00711 // 00712 // Done with this enumeration request 00713 // 00714 00715 if (request->CompletionStatus) { 00716 *request->CompletionStatus = status; 00717 } 00718 00719 if (request->CompletionEvent) { 00720 KeSetEvent(request->CompletionEvent, 0, FALSE); 00721 } 00722 ObDereferenceObject(request->DeviceObject); 00723 ExFreePool(request); 00724 } 00725 }

NTSTATUS IopEnumerateDevice (  IN PDEVICE_OBJECT  DeviceObject, IN PSTART_CONTEXT  StartContext, IN BOOLEAN  AsyncOk )

Definition at line 1163 of file pnpenum.c. References ASSERT, ASSERT_INITED, _DEVICE_NODE::BusNumber, BusRelations, _DEVICE_NODE::Child, _DEVICE_RELATIONS::Count, DbgPrint, _DEVOBJ_EXTENSION::DeviceNode, _DEVICE_OBJECT::DeviceObjectExtension, DNF_BEING_ENUMERATED, DNF_DEVICE_GONE, DNF_ENUMERATED, DNF_ENUMERATION_REQUEST_PENDING, DNF_NEED_ENUMERATION_ONLY, DNF_REMOVE_PENDING_CLOSES, DNF_STARTED, DO_BUS_ENUMERATED_DEVICE, DOCK_EJECTIRP_COMPLETED, _DEVICE_NODE::DockInfo, DOE_DELETE_PENDING, dummy(), ExFreePool(), exit, _DEVOBJ_EXTENSION::ExtensionFlags, FALSE, _DEVICE_OBJECT::Flags, _DEVICE_NODE::Flags, _DEVICE_NODE::InterfaceType, IOP_DIAG_THROW_CHAFF_AT_STARTED_PDO_STACK, IopAcquireEnumerationLock, IopAllocateDeviceNode(), IopBootConfigsReserved, IopHardwareProfileCancelRemovedDock(), IopInsertTreeDeviceNode(), IopProcessNewChildren(), IopQueryDeviceRelations(), IopReleaseEnumerationLock, IopRequestDeviceRemoval(), IopReserveLegacyBootResources(), IopSynchronousCall(), IRP_MJ_PNP, KeBugCheckEx(), _IO_STACK_LOCATION::MajorFunction, _IO_STACK_LOCATION::MinorFunction, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, _DEVICE_RELATIONS::Objects, ObReferenceObject, _DEVICE_NODE::OverUsed1, PAGED_CODE, _DEVICE_NODE::Parent, _DEVICE_NODE::PhysicalDeviceObject, PNP_ERR_PDO_ENUMERATED_AFTER_DELETION, PpSetPlugPlayEvent(), _DEVICE_NODE::ServiceName, _DEVICE_NODE::Sibling, and TRUE. Referenced by IopBusCheck(), and IopStartAndEnumerateDevice(). : This function assumes that the specified physical device object is a bus and will enumerate all of the children PDOs on the bus. Arguments: DeviceObject - Supplies a pointer to the physical device object to be enumerated. StartContext - supplies a pointer to the START_CONTEXT to control how to add/start new devices. AsyncOk - Specifies can QueryDeviceRelation be done at Async way. Return Value: NTSTATUS code. --*/ { NTSTATUS status; PDEVICE_NODE deviceNode; PDEVICE_NODE childDeviceNode, nextChildDeviceNode; PDEVICE_OBJECT childDeviceObject; PDEVICE_RELATIONS deviceRelations; ULONG i; BOOLEAN childRemoved, newChildPostponed; PAGED_CODE(); // // First get a reference to the PDO to make sure it won't go away. // ObReferenceObject(DeviceObject); deviceNode = (PDEVICE_NODE)DeviceObject->DeviceObjectExtension->DeviceNode; if (deviceNode->Flags & DNF_NEED_ENUMERATION_ONLY) { // // This means this device was just started and needed enumeration. // So, we will report the device arrival. // deviceNode->Flags &= ~DNF_NEED_ENUMERATION_ONLY; // // The device has been started, attempt to enumerate the device. // PpSetPlugPlayEvent( &GUID_DEVICE_ARRIVAL, deviceNode->PhysicalDeviceObject); IOP_DIAG_THROW_CHAFF_AT_STARTED_PDO_STACK(DeviceObject); #if DBG { IO_STACK_LOCATION irpSp; ULONG dummy; // // Initialize the stack location to pass to IopSynchronousCall() // RtlZeroMemory(&irpSp, sizeof(IO_STACK_LOCATION)); // // Set the function codes. // irpSp.MajorFunction = IRP_MJ_PNP; irpSp.MinorFunction = 0xff; // // Make the call and return. // status = IopSynchronousCall(DeviceObject, &irpSp, (PVOID)&dummy); if (NT_SUCCESS(status) || dummy != 0) { if (deviceNode->ServiceName.Buffer) { DbgPrint("*** BugBug : Driver %wZ returned status = %lx and Information = %lx\n", &deviceNode->ServiceName, status, dummy); DbgPrint(" for IRP_MN_BOGUS. "); ASSERT(0); } else { DbgPrint("*** BugBug : Driver returned status = %lx and Information = %lx\n", status, dummy); DbgPrint(" for IRP_MN_BOGUS. "); ASSERT(0); } } } #endif } // // Make sure we don't step on another enumerator's toes // IopAcquireEnumerationLock(deviceNode); if ((deviceNode->Flags & (DNF_STARTED | DNF_REMOVE_PENDING_CLOSES)) != DNF_STARTED) { status = STATUS_UNSUCCESSFUL; } else if (deviceNode->Flags & DNF_ENUMERATION_REQUEST_PENDING) { if (!(deviceNode->Flags & DNF_BEING_ENUMERATED)) { // // The enumeration lock of the device must be acquired already // before performing following instructions. // deviceRelations = deviceNode->OverUsed1.PendingDeviceRelations; deviceNode->OverUsed1.PendingDeviceRelations = NULL; deviceNode->Flags &= ~DNF_ENUMERATION_REQUEST_PENDING; status = STATUS_SUCCESS; } else { status = STATUS_UNSUCCESSFUL; } } else { status = IopQueryDeviceRelations(BusRelations, DeviceObject, AsyncOk, &deviceRelations); } if (!NT_SUCCESS(status) || (status == STATUS_PENDING) || !deviceRelations) { status = STATUS_SUCCESS; goto exit; } // // Walk all the child device nodes and mark them as not present // childDeviceNode = deviceNode->Child; while (childDeviceNode) { childDeviceNode->Flags &= ~DNF_ENUMERATED; childDeviceNode = childDeviceNode->Sibling; } // // Check all the PDOs returned see if any new one or any one disappeared. // for (i = 0; i < deviceRelations->Count; i++) { childDeviceObject = deviceRelations->Objects[i]; ASSERT_INITED(childDeviceObject); if (childDeviceObject->DeviceObjectExtension->ExtensionFlags & DOE_DELETE_PENDING) { KeBugCheckEx( PNP_DETECTED_FATAL_ERROR, PNP_ERR_PDO_ENUMERATED_AFTER_DELETION, (ULONG_PTR)childDeviceObject, 0, 0); } // // We've found another physical device, see if there is // already a devnode for it. // childDeviceNode = (PDEVICE_NODE)childDeviceObject->DeviceObjectExtension->DeviceNode; if (childDeviceNode == NULL) { // // Device node doesn't exist, create one. // childDeviceNode = IopAllocateDeviceNode(childDeviceObject); if (childDeviceNode != NULL) { // // We've found or created a devnode for the PDO that the // bus driver just enumerated. // childDeviceNode->Flags |= DNF_ENUMERATED; // // Mark the device object a bus enumerated device // BUGBUG - should be an ASSERT. This should be set by bus drivers. // childDeviceObject->Flags |= DO_BUS_ENUMERATED_DEVICE; // // Put this new device node at the head of the parent's list // of children. // IopInsertTreeDeviceNode ( deviceNode, childDeviceNode ); } else { // // Had a problem creating a devnode. Pretend we've never // seen it. // KdPrint(("IopEnumerateDevice: Failed to allocate device node space\n")); ObDereferenceObject(childDeviceObject); } } else { // // The device is alreay enumerated. Remark it and release the // device object reference. // childDeviceNode->Flags |= DNF_ENUMERATED; if (childDeviceNode->DockInfo.DockStatus == DOCK_EJECTIRP_COMPLETED) { // // A dock that was listed as departing in an eject relation // didn't actually leave. Remove it from the profile transition // list... // IopHardwareProfileCancelRemovedDock(childDeviceNode); } ASSERT(!(childDeviceNode->Flags & DNF_DEVICE_GONE)); ObDereferenceObject(childDeviceObject); } } ExFreePool(deviceRelations); // // If we get here, the enumeration was successful. First process // any missing devnodes. // childRemoved = FALSE; for (childDeviceNode = deviceNode->Child; childDeviceNode != NULL; childDeviceNode = nextChildDeviceNode) { // // First, we need to remember the 'next child' because the 'child' will be // removed and we won't be able to find the 'next child.' // nextChildDeviceNode = childDeviceNode->Sibling; if (!(childDeviceNode->Flags & DNF_ENUMERATED)) { if (!(childDeviceNode->Flags & DNF_DEVICE_GONE)) { childDeviceNode->Flags |= DNF_DEVICE_GONE; IopRequestDeviceRemoval( childDeviceNode->PhysicalDeviceObject, CM_PROB_DEVICE_NOT_THERE); childRemoved = TRUE; } } } // // BUGBUG - currently the root enumerator gets confused if we reenumerate it // before we process newly reported PDOs. Since it can't possibly create // the scenario we are trying to fix, we won't bother waiting for the // removes to complete before processing the new devnodes. // if (deviceNode->Parent != NULL && childRemoved) { status = STATUS_PNP_RESTART_ENUMERATION; goto exit; } // // Reserve legacy resources for the legacy interface and bus number. // if (!IopBootConfigsReserved && deviceNode->InterfaceType != InterfaceTypeUndefined) { // // EISA = ISA. // if (deviceNode->InterfaceType == Isa) { IopReserveLegacyBootResources(Eisa, deviceNode->BusNumber); } IopReserveLegacyBootResources(deviceNode->InterfaceType, deviceNode->BusNumber); } // // Now process new devnodes that have just appeared. // // Walk all of the children to perform driver loading and device addition operations. // IopProcessNewChildren(deviceNode, StartContext); status = STATUS_SUCCESS; exit: IopReleaseEnumerationLock(deviceNode); ObDereferenceObject(DeviceObject); return status; }

BOOLEAN IopFixupDeviceId (  PWCHAR  DeviceId  )

Definition at line 4514 of file pnpenum.c. References FALSE, L, and TRUE. 04520 : 04521 04522 This routine parses the device instance string and replaces any invalid 04523 characters (not allowed in a "device instance") with an underscore 04524 character. 04525 04526 Invalid characters are: 04527 c <= 0x20 (' ') 04528 c > 0x7F 04529 c == 0x2C (',') 04530 04531 Arguments: 04532 04533 DeviceId - specifies a device instance string (or part of one), must be 04534 null-terminated. 04535 04536 Return Value: 04537 04538 None. 04539 04540 --*/ 04541 04542 { 04543 PWCHAR p; 04544 04545 // BUGBUG - do we need to uppercase these!? 04546 04547 for (p = DeviceId; *p; p++) { 04548 if (*p == L' ') { 04549 *p = L'_'; 04550 } else if ((*p < L' ') || (*p > (WCHAR)0x7F) || (*p == L',')) { 04551 return FALSE; 04552 } 04553 } 04554 04555 return TRUE; 04556 }

BOOLEAN IopFixupIds (  IN PWCHAR  Ids, IN ULONG  Length )

Definition at line 4559 of file pnpenum.c. References FALSE, IopFixupDeviceId(), and TRUE. Referenced by IopProcessNewDeviceNode(), and IopStartAndEnumerateDevice(). : This routine parses multiple IDs and replaces any invalid characters (not allowed in a "device instance") with an underscore character. Invalid characters are: c <= 0x20 (' ') c > 0x7F c == 0x2C (',') Arguments: Ids - specifies MULTI_SZ ids. Length - Specifies the lenght of Ids Return Value: None. --*/ { PWCHAR p, end; p = Ids; end = p + Length / sizeof(WCHAR); while ((p < end) && (*p)) { if (!IopFixupDeviceId(p)) { return FALSE; } while (*p) { p++; } p++; } return TRUE; }

USHORT IopGetBusTypeGuidIndex (  IN LPGUID  busTypeGuid  )

Definition at line 4425 of file pnpenum.c. References ASSERT, BUS_TYPE_GUID_LIST, _BUS_TYPE_GUID_LIST::Count, ExAllocatePool, ExFreePool(), _BUS_TYPE_GUID_LIST::Guid, IopBusTypeGuidList, IopCompareGuid, _BUS_TYPE_GUID_LIST::Lock, NULL, PagedPool, and USHORT. Referenced by IopProcessNewDeviceNode(). 04431 : 04432 04433 This routine returns an index into the global table of bus type guids for 04434 guid specified. If this guid is not already in the table, then it will be 04435 added and the index for the new table entry will be returned. This index 04436 is later used by IoGetDeviceProperty to retrieve and return the bus type 04437 guid back to callers but allows us not to bother storing the entire guid 04438 in each devnode (just once per guid in the table). 04439 04440 Arguments: 04441 04442 BusTypeGuid - specifies the guid to retrieve an index for 04443 04444 Return Value: 04445 04446 The index (into the IopBusTypeGuidList table) for the specified guid. 04447 04448 --*/ 04449 04450 { 04451 PCHAR p; 04452 USHORT i, busTypeIndex = 0xffff; // unreported 04453 ULONG size; 04454 04455 ASSERT(IopBusTypeGuidList != NULL); 04456 04457 ExAcquireFastMutex(&IopBusTypeGuidList->Lock); 04458 04459 // 04460 // Search the guid list for a match 04461 // 04462 for (i = 0; i < (USHORT)IopBusTypeGuidList->Count; i++) { 04463 if (IopCompareGuid(BusTypeGuid, &IopBusTypeGuidList->Guid[i])) { 04464 busTypeIndex = i; 04465 goto Clean0; 04466 } 04467 } 04468 04469 // 04470 // Bus type guid doesn't exist in the list. 04471 // 04472 04473 if (IopBusTypeGuidList->Count > 0) { 04474 04475 // 04476 // Reallocate to hold one more guid. 04477 // 04478 04479 size = sizeof(BUS_TYPE_GUID_LIST) + 04480 sizeof(GUID) * (IopBusTypeGuidList->Count); 04481 04482 p = ExAllocatePool(PagedPool, size); 04483 if (!p) { 04484 goto Clean0; // oops, no more room, return unreported 04485 } 04486 04487 size = sizeof(BUS_TYPE_GUID_LIST) + 04488 sizeof(GUID) * (IopBusTypeGuidList->Count - 1); 04489 04490 RtlCopyMemory(p, IopBusTypeGuidList, size); 04491 04492 ExFreePool(IopBusTypeGuidList); 04493 IopBusTypeGuidList = (PBUS_TYPE_GUID_LIST)p; 04494 } 04495 04496 // 04497 // Add the new guid to the list. 04498 // 04499 RtlCopyMemory(&IopBusTypeGuidList->Guid[IopBusTypeGuidList->Count], 04500 BusTypeGuid, 04501 sizeof(GUID)); 04502 04503 busTypeIndex = (USHORT)IopBusTypeGuidList->Count; 04504 IopBusTypeGuidList->Count += 1; 04505 04506 Clean0: 04507 04508 ExReleaseFastMutex(&IopBusTypeGuidList->Lock); 04509 04510 return busTypeIndex; 04511 }

BOOLEAN IopGetRegistryDwordWithFallback (  IN PUNICODE_STRING  valueName, IN HANDLE  PrimaryKey, IN HANDLE  SecondaryKey, IN OUT PULONG  Value )

Definition at line 4610 of file pnpenum.c. References EXCEPTION_EXECUTE_HANDLER, ExFreePool(), FALSE, IopGetRegistryValue(), NT_SUCCESS, NTSTATUS(), NULL, and TRUE. Referenced by IopChangeDeviceObjectFromRegistryProperties(). : If (1) Primary key has a value named "ValueName" that is REG_DWORD, return it Else If (2) Secondary key has a value named "ValueName" that is REG_DWORD, return it Else (3) Leave Value untouched and return error Arguments: ValueName - Unicode name of value to query PrimaryKey - If non-null, check this first SecondaryKey - If non-null, check this second Value - IN = default value, OUT = actual value Return Value: TRUE if value found --*/ { PKEY_VALUE_FULL_INFORMATION info; PUCHAR data; NTSTATUS status; HANDLE Keys[3]; int count = 0; int index; BOOLEAN set = FALSE; if (PrimaryKey != NULL) { Keys[count++] = PrimaryKey; } if (SecondaryKey != NULL) { Keys[count++] = SecondaryKey; } Keys[count] = NULL; for (index = 0; index < count && !set; index ++) { info = NULL; try { status = IopGetRegistryValue(Keys[index], valueName->Buffer, &info); if (NT_SUCCESS(status) && info->Type == REG_DWORD) { data = ((PUCHAR) info) + info->DataOffset; *Value = *((PULONG) data); set = TRUE; } } except(EXCEPTION_EXECUTE_HANDLER) { // // do nothing // } if (info) { ExFreePool(info); } } return set; }

PSECURITY_DESCRIPTOR IopGetRegistrySecurityWithFallback (  IN PUNICODE_STRING  valueName, IN HANDLE  PrimaryKey, IN HANDLE  SecondaryKey )

Definition at line 4679 of file pnpenum.c. References EXCEPTION_EXECUTE_HANDLER, ExFreePool(), FALSE, IopGetRegistryValue(), KernelMode, NT_SUCCESS, NTSTATUS(), NULL, PagedPool, SeCaptureSecurityDescriptor(), and TRUE. Referenced by IopChangeDeviceObjectFromRegistryProperties(). : If (1) Primary key has a binary value named "ValueName" that is REG_BINARY and appears to be a valid security descriptor, return it Else (2) do same for Secondary key Else (3) Return NULL Arguments: ValueName - Unicode name of value to query PrimaryKey - If non-null, check this first SecondaryKey - If non-null, check this second Return Value: Security Descriptor if found, else NULL --*/ { PKEY_VALUE_FULL_INFORMATION info; PUCHAR data; NTSTATUS status; HANDLE Keys[3]; int count = 0; int index; BOOLEAN set = FALSE; PSECURITY_DESCRIPTOR secDesc = NULL; PSECURITY_DESCRIPTOR allocDesc = NULL; if (PrimaryKey != NULL) { Keys[count++] = PrimaryKey; } if (SecondaryKey != NULL) { Keys[count++] = SecondaryKey; } Keys[count] = NULL; for (index = 0; index < count && !set; index ++) { info = NULL; try { status = IopGetRegistryValue(Keys[index], valueName->Buffer, &info); if (NT_SUCCESS(status) && info->Type == REG_BINARY) { data = ((PUCHAR) info) + info->DataOffset; secDesc = (PSECURITY_DESCRIPTOR)data; status = SeCaptureSecurityDescriptor(secDesc, KernelMode, PagedPool, TRUE, &allocDesc); if (NT_SUCCESS(status)) { set = TRUE; } } } except(EXCEPTION_EXECUTE_HANDLER) { // // do nothing // } if (info) { ExFreePool(info); } } if (set) { return allocDesc; } return NULL; }

BOOLEAN IopProcessCriticalDevice (  IN PDEVICE_NODE  DeviceNode  )

Definition at line 3762 of file pnpenum.c. References ASSERT, CmRegistryMachineSystemCurrentControlSetEnumName, DebugPrint, FALSE, IopClearDevNodeProblem, IopDoesDevNodeHaveProblem, IopFreeAllocatedUnicodeString(), IopIsDevNodeProblem, IopOpenRegistryKeyEx(), IopProcessCriticalDeviceRoutine(), L, NT_SUCCESS, NTSTATUS(), NULL, and RtlInitUnicodeString(). : This routine will check whether the device is a "critical" one (see the top of this file for a description of critical). If the device is critical then it will be assigned a service based on the contents of IopCriticalDeviceList. Arguments: DeviceNode - the device node to process Return Value: TRUE if the device is critical FALSE otherwise --*/ { HANDLE enumKey; HANDLE instanceKey; UNICODE_STRING service, classGuid, lowerFilters, upperFilters; BOOLEAN foundMatch = FALSE; RTL_QUERY_REGISTRY_TABLE queryTable[2]; NTSTATUS status; #if DBG_SCOPE PWCHAR str; ULONG length; #endif DebugPrint(1, ("IopIsCriticalPnpDevice called for devnode %#08lx\n", DeviceNode)); // // Open the HKLM\System\CCS\Enum key. // status = IopOpenRegistryKeyEx( &enumKey, NULL, &CmRegistryMachineSystemCurrentControlSetEnumName, KEY_READ ); if (!NT_SUCCESS(status)) { DebugPrint(1, ("IICPD: couldn't open enum key %#08lx\n", status)); return FALSE; } // // Open the instance key for this devnode // status = IopOpenRegistryKeyEx( &instanceKey, enumKey, &DeviceNode->InstancePath, KEY_ALL_ACCESS ); ZwClose(enumKey); // // First determine if this is a critical device type // if (!NT_SUCCESS(status)) { DebugPrint(1, ("IICPD: couldn't open instance path key %wZ [%#08lx]\n", &(DeviceNode->InstancePath))); ZwClose(instanceKey); return FALSE; } else { // // Call IopProcessCriticalDeviceRoutine to // enumerate entries in the CriticalDeviceDatabase // and compare with HardwareId and CompatibleIds // value data from instanceKey. // RtlInitUnicodeString(&service, NULL); RtlInitUnicodeString(&classGuid, NULL); RtlInitUnicodeString(&lowerFilters, NULL); RtlInitUnicodeString(&upperFilters, NULL); status = IopProcessCriticalDeviceRoutine(instanceKey, &foundMatch, &service, &classGuid, &lowerFilters, &upperFilters); if (!NT_SUCCESS(status)) { DebugPrint(1, ("IICPD: IopProcessCriticalDeviceRoutine failed with status %#08lx\n", status)); return FALSE; } } // // If we get here then this is a "critical" device and we know the service // to setup for it. Set the service value in the registry. // if (!foundMatch) { ZwClose(instanceKey); return FALSE; } else { UNICODE_STRING serviceValue, classGuidValue, lowerFiltersValue, upperFiltersValue; DebugPrint(1, ("IopProcessCriticalDevice: Setting up critical service\n")); RtlInitUnicodeString(&serviceValue, REGSTR_VALUE_SERVICE); RtlInitUnicodeString(&classGuidValue, REGSTR_VALUE_CLASSGUID); RtlInitUnicodeString(&lowerFiltersValue, REGSTR_VALUE_LOWERFILTERS); RtlInitUnicodeString(&upperFiltersValue, REGSTR_VALUE_UPPERFILTERS); if (classGuid.Buffer) { DebugPrint(1, ("IopProcessCriticalDevice: classGuid is %wZ\n", &classGuid)); status = ZwSetValueKey(instanceKey, &classGuidValue, 0L, REG_SZ, classGuid.Buffer, classGuid.Length + sizeof(UNICODE_NULL)); } if (lowerFilters.Buffer) { #if DBG_SCOPE str = lowerFilters.Buffer; while ((length = wcslen(str)) != 0) { DebugPrint(1, ("IopProcessCriticalDevice: lower filter is %ws\n", str)); str += (length + 1); } #endif status = ZwSetValueKey(instanceKey, &lowerFiltersValue, 0L, REG_MULTI_SZ, lowerFilters.Buffer, lowerFilters.Length); // + sizeof(UNICODE_NULL)); } if (upperFilters.Buffer) { #if DBG_SCOPE str = upperFilters.Buffer; while ((length = wcslen(str)) != 0) { DebugPrint(1, ("IopProcessCriticalDevice: upper filter is %ws\n", str)); str += (length + 1); } #endif status = ZwSetValueKey(instanceKey, &upperFiltersValue, 0L, REG_MULTI_SZ, upperFilters.Buffer, upperFilters.Length); // + sizeof(UNICODE_NULL)); } DebugPrint(1, ("IopProcessCriticalDevice: service is %wZ\n", &service)); status = ZwSetValueKey(instanceKey, &serviceValue, 0L, REG_SZ, service.Buffer, service.Length + sizeof(UNICODE_NULL)); // // If the service was set properly set the CONFIGFLAG_FINISH_INSTALL so // we will still get a new hw found popup and go through the class // installer. // if (NT_SUCCESS(status)) { UCHAR buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG)]; UNICODE_STRING valueName; PKEY_VALUE_PARTIAL_INFORMATION keyInfo = (PKEY_VALUE_PARTIAL_INFORMATION) buffer; ULONG flags = 0; ULONG length; NTSTATUS tmpStatus; RtlInitUnicodeString(&valueName, REGSTR_VALUE_CONFIG_FLAGS); tmpStatus = ZwQueryValueKey(instanceKey, &valueName, KeyValuePartialInformation, keyInfo, sizeof(buffer), &length); if (NT_SUCCESS(tmpStatus) && (keyInfo->Type == REG_DWORD)) { flags = *(PULONG)keyInfo->Data; } flags &= ~(CONFIGFLAG_REINSTALL | CONFIGFLAG_FAILEDINSTALL); flags |= CONFIGFLAG_FINISH_INSTALL; ZwSetValueKey(instanceKey, &valueName, 0L, REG_DWORD, &flags, sizeof(ULONG)); ASSERT(!IopDoesDevNodeHaveProblem(DeviceNode) || IopIsDevNodeProblem(DeviceNode, CM_PROB_NOT_CONFIGURED) || IopIsDevNodeProblem(DeviceNode, CM_PROB_FAILED_INSTALL) || IopIsDevNodeProblem(DeviceNode, CM_PROB_REINSTALL)); IopClearDevNodeProblem(DeviceNode); } ZwClose(instanceKey); } IopFreeAllocatedUnicodeString(&service); IopFreeAllocatedUnicodeString(&classGuid); IopFreeAllocatedUnicodeString(&lowerFilters); IopFreeAllocatedUnicodeString(&upperFilters); return (NT_SUCCESS(status)); }

NTSTATUS IopProcessCriticalDeviceRoutine (  IN HANDLE  hDevInstance, IN PBOOLEAN  FoundMatch, IN PUNICODE_STRING  ServiceName, IN PUNICODE_STRING  ClassGuid, IN PUNICODE_STRING  LowerFilters, IN PUNICODE_STRING  UpperFilters )

Definition at line 4000 of file pnpenum.c. References _BUFFER_INFO::Buffer, BUFFER_INFO, CmRegistryMachineName, DebugPrint, ExAllocatePool, ExFreePool(), exit, FALSE, INITIAL_INFOBUFFER_SIZE, IopAllocateBuffer(), IopFreeBuffer(), IopGetRegistryValue(), IopOpenRegistryKeyEx(), IopReplaceSeperatorWithPound(), IopResizeBuffer(), KEY_VALUE_DATA, L, _BUFFER_INFO::MaxSize, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, NUM_QUERIES, RtlEqualUnicodeString(), RtlFreeUnicodeString(), RtlQueryRegistryValues(), TRUE, and USHORT. Referenced by IopProcessCriticalDevice(). : This routine will enumerate all values of the CriticalDeviceDatabase registry key, and compare each with entries within the HardwareId and CompatibleIds values of key associated with the current device instance. Arguments: HDevInstance - HANDLE to device instance. FoundMatch - receives TRUE if a match was found. ServiceName - receives name of service to be assigned to the device instance pointed to by HDevInstance. Return Value: NTSTATUS code STATUS_SUCCESS STATUS_INVALID_PARAMETER --*/ { NTSTATUS status; HANDLE hRegistryMachine, hCriticalDeviceKey, hCriticalEntry; PWSTR keyValueInfoTag[2]; PKEY_VALUE_FULL_INFORMATION keyValueInfo[2], matchedKeyValFullInfo; BUFFER_INFO infoBuffer; ULONG enumIndex, idIndex, resultSize, stringLength; UNICODE_STRING tmpUnicodeString, unicodeCriticalEntry, unicodeCriticalDeviceKeyName; PWCHAR stringStart, bufferEnd, ptr; PRTL_QUERY_REGISTRY_TABLE parameters = NULL; #define INITIAL_INFOBUFFER_SIZE sizeof(KEY_VALUE_FULL_INFORMATION) + 8*sizeof(WCHAR) + 255*sizeof(WCHAR) hRegistryMachine = NULL; hCriticalDeviceKey = NULL; infoBuffer.Buffer = NULL; // // Read Key Value Information // from HardwareId and CompatibleIds values // // keyValueInfo[idIndex == 0] == REGSTR_VAL_HARDWAREID == "HardwareId" // keyValueInfo[idIndex == 1] == REGSTR_VAL_COMPATIBLEIDS == "CompatibleIds" // keyValueInfoTag[0] = REGSTR_VAL_HARDWAREID; keyValueInfoTag[1] = REGSTR_VAL_COMPATIBLEIDS; for (idIndex = 0; idIndex < 2; idIndex++) { keyValueInfo[idIndex] = NULL; status = IopGetRegistryValue(HDevInstance, keyValueInfoTag[idIndex], &keyValueInfo[idIndex]); if (!NT_SUCCESS( status )) { DebugPrint(1, ("IopProcessCriticalDeviceRoutine: Unable to get some " "%ws value info, %#08lx. continuing.\n", keyValueInfoTag[idIndex], status)); } else if ((keyValueInfo[idIndex]->Type != REG_MULTI_SZ) || (keyValueInfo[idIndex]->DataLength == 0)) { ExFreePool(keyValueInfo[idIndex]); keyValueInfo[idIndex] = NULL; DebugPrint(1, ("IopProcessCriticalDeviceRoutine: some %ws" "Key Value Info not in expected format\n", keyValueInfoTag[idIndex])); } else { // // It is good, make sure all of the IDs match '\' replacement policy // tmpUnicodeString.Buffer = (PWCHAR) KEY_VALUE_DATA(keyValueInfo[idIndex]); tmpUnicodeString.Length = (USHORT) keyValueInfo[idIndex]->DataLength; tmpUnicodeString.MaximumLength = tmpUnicodeString.Length; IopReplaceSeperatorWithPound(&tmpUnicodeString, &tmpUnicodeString); } } // // Get handle to \REGISTRY\MACHINE registry key. // status = IopOpenRegistryKeyEx( &hRegistryMachine, NULL, &CmRegistryMachineName, KEY_READ ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Open CriticalDeviceDatabase registry key to enumerate through. // // This key contains hardware id's for so called "critical" devices. These // are devices for which, for one reason or another, we cannot wait for // config manager to bring them on line. These are primarily devices which // are necessary in order to bring the system up into user mode so that // config manager can be run (disks, keyboards, video, etc...) // PiWstrToUnicodeString(&unicodeCriticalDeviceKeyName, REGSTR_PATH_CRITICALDEVICEDATABASE); status = IopOpenRegistryKeyEx( &hCriticalDeviceKey, hRegistryMachine, &unicodeCriticalDeviceKeyName, KEY_READ ); // // Close handle to \REGISTRY\MACHINE. // ZwClose(hRegistryMachine); // // Check success in opening CriticalDeviceDatabase key. // if ( !NT_SUCCESS(status) ) { DebugPrint(1, ("IopProcessCriticalDeviceRoutine: Unable to open %wZ key. exiting...\n", &unicodeCriticalDeviceKeyName)); goto cleanup; } DebugPrint(1, ("IopProcessCriticalDeviceRoutine: Successfully opened %wZ key.\n", &unicodeCriticalDeviceKeyName)); // // Allocate a buffer to store KeyValueFullInformation // of values from CriticalDeviceDatabase key. // status = IopAllocateBuffer( &infoBuffer, INITIAL_INFOBUFFER_SIZE ); if (!NT_SUCCESS(status)) { DebugPrint(1, ("IopProcessCriticalDeviceRoutine: Unable to allocate buffer to hold key values. exiting...\n", &unicodeCriticalDeviceKeyName)); goto cleanup; } // // Enumerate through Critical Device entries. // // For each CriticalDeviceDatabase value entry compare with all entries of HardwareId // and CompatibleIds REG_MULTI_SZ for a match // enumIndex = 0; while (((status = ZwEnumerateKey( hCriticalDeviceKey, enumIndex, KeyBasicInformation, (PVOID) infoBuffer.Buffer, infoBuffer.MaxSize, &resultSize)) != STATUS_NO_MORE_ENTRIES)) { if (status == STATUS_BUFFER_OVERFLOW) { // // Buffer allocated to hold value was too small; // resize to specified length, and try again. // status = IopResizeBuffer( &infoBuffer, resultSize, FALSE ); DebugPrint(1, ("IopProcessCriticalDeviceRoutine: ZwEnumerateKey returned STATUS_BUFFER_OVERFLOW, %#08lx\n", status)); DebugPrint(1, ("IopProcessCriticalDeviceRoutine: (resizing buffer...)\n")); continue; } else if (!NT_SUCCESS(status)) { // // ZwEnumerateKey returned failure status other than // STATUS_NO_MORE_ENTRIES or STATUS_BUFFER_OVERFLOW. // DebugPrint(1, ("IopProcessCriticalDeviceRoutine: ZwEnumerateValueKey failed, %#08lx exiting...\n", status)); goto cleanup; } // // Store CriticalDeviceDatabase entry in a unicode string to do // case-insensitive comparisons with HardwareId/CompatibleIds entries // from the new device's instance key. // unicodeCriticalEntry.Buffer = ((PKEY_BASIC_INFORMATION)(infoBuffer.Buffer))->Name; unicodeCriticalEntry.Length = (USHORT) ((PKEY_BASIC_INFORMATION)(infoBuffer.Buffer))->NameLength; unicodeCriticalEntry.MaximumLength = unicodeCriticalEntry.Length; DebugPrint(1, ("IopProcessCriticalDeviceRoutine: \t key (%u) enumerated: %wZ\n", enumIndex, &unicodeCriticalEntry)); // // Look at HardwareId and CompatibleIds of new device... // for ( idIndex=0; idIndex < 2; idIndex++) { if (!keyValueInfo[idIndex]){ // // keyValueInfo[idIndex == 0] == REGSTR_VAL_HARDWAREID // keyValueInfo[idIndex == 1] == REGSTR_VAL_COMPATIBLEIDS // // Corresponding HardwareId or CompatibleIds value entry was invalid or not found. // keyValueInfo[idIndex] set to NULL above when // Type != REG_MULTI_SZ or DataLength == 0 // Just skip, and move on. // DebugPrint(1, ("IopProcessCriticalDeviceRoutine: No %ws value was found, move on to next\n", keyValueInfoTag[idIndex])); continue; } // // Find start and end of this REG_MULTI_SZ // ptr = (PWCHAR)KEY_VALUE_DATA(keyValueInfo[idIndex]); stringStart = ptr; bufferEnd = (PWCHAR)((PUCHAR)ptr + keyValueInfo[idIndex]->DataLength); while(ptr != bufferEnd) { if (!*ptr) { // // Found null-terminated end of a single SZ within the MULTI_SZ. // stringLength = (ULONG)((PUCHAR)ptr - (PUCHAR)stringStart); tmpUnicodeString.Buffer = stringStart; tmpUnicodeString.Length = (USHORT)stringLength; tmpUnicodeString.MaximumLength = (USHORT)stringLength + sizeof(UNICODE_NULL); DebugPrint(2, ("IopProcessCriticalDeviceRoutine: comparing %wZ with %wZ\n", &tmpUnicodeString, &unicodeCriticalEntry)); // // Check for a case-insenitive unicode string match. // if (RtlEqualUnicodeString(&tmpUnicodeString, &unicodeCriticalEntry, TRUE)) { DebugPrint(1, ("IopProcessCriticalDeviceRoutine: ***** Critical Device %wZ: Matched to Device %wZ.\n", &tmpUnicodeString, &unicodeCriticalEntry)); #define NUM_QUERIES 4 status = IopOpenRegistryKeyEx( &hCriticalEntry, hCriticalDeviceKey, &unicodeCriticalEntry, KEY_READ ); if (!NT_SUCCESS(status)) { goto cleanup; } parameters = (PRTL_QUERY_REGISTRY_TABLE) ExAllocatePool(NonPagedPool, sizeof(RTL_QUERY_REGISTRY_TABLE)*(NUM_QUERIES+1)); if (!parameters) { ZwClose(hCriticalEntry); status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } RtlZeroMemory(parameters, sizeof(RTL_QUERY_REGISTRY_TABLE) * (NUM_QUERIES + 1)); parameters[0].Flags = RTL_QUERY_REGISTRY_DIRECT; parameters[0].Name = REGSTR_VALUE_SERVICE; parameters[0].EntryContext = ServiceName; parameters[0].DefaultType = REG_SZ; parameters[0].DefaultData = L""; parameters[0].DefaultLength = 0; parameters[1].Flags = RTL_QUERY_REGISTRY_DIRECT; parameters[1].Name = REGSTR_VALUE_CLASSGUID; parameters[1].EntryContext = ClassGuid; parameters[1].DefaultType = REG_SZ; parameters[1].DefaultData = L""; parameters[1].DefaultLength = 0; parameters[2].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_NOEXPAND; parameters[2].Name = REGSTR_VALUE_LOWERFILTERS; parameters[2].EntryContext = LowerFilters; parameters[2].DefaultType = REG_MULTI_SZ; parameters[2].DefaultData = L""; parameters[2].DefaultLength = 0; parameters[3].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_NOEXPAND; parameters[3].Name = REGSTR_VALUE_UPPERFILTERS; parameters[3].EntryContext = UpperFilters; parameters[3].DefaultType = REG_MULTI_SZ; parameters[3].DefaultData = L""; parameters[3].DefaultLength = 0; status = RtlQueryRegistryValues( RTL_REGISTRY_HANDLE | RTL_REGISTRY_OPTIONAL, (PWSTR) hCriticalEntry, parameters, NULL, NULL ); ExFreePool(parameters); ZwClose(hCriticalEntry); if (NT_SUCCESS(status)) { // // Sanity check all of the values... // 1) There is a service name // 2) If there is a class guid, it is of the proper length // if (!ServiceName->Buffer || !ServiceName->Length || (ClassGuid->Length && (ClassGuid->Length < 38 * sizeof (WCHAR)))) { goto FreeStrings; } // // Caller expects XxxFilters->Buffer == NULL, so make // the default case look like that // if (UpperFilters->Length <= 2 && UpperFilters->Buffer) { RtlFreeUnicodeString(UpperFilters); } if (LowerFilters->Length <= 2 && LowerFilters->Buffer) { RtlFreeUnicodeString(LowerFilters); } if (ClassGuid->Length == 0 && ClassGuid->Buffer) { RtlFreeUnicodeString(ClassGuid); } #if DBG DebugPrint(1, ("IopProcessCriticalDeviceRoutine: ***** Using ServiceName %wZ.\n", ServiceName)); if (ClassGuid->Buffer) { DebugPrint(1, ("IopProcessCriticalDeviceRoutine: ***** Using ClassGuid %wZ.\n", ClassGuid)); } #endif } else { FreeStrings: // // Free any strings that may have been allocated by // RtlQueryRegistryValues // RtlFreeUnicodeString(ServiceName); RtlFreeUnicodeString(ClassGuid); RtlFreeUnicodeString(LowerFilters); RtlFreeUnicodeString(UpperFilters); } if (ServiceName->Buffer != NULL) { *FoundMatch = TRUE; goto exit; } } // // See if we're at the end of the MULTI_SZ // if (((ptr + 1) == bufferEnd) || !*(ptr + 1)) { break; } else { stringStart = ptr + 1; } } // // advance to next character. // ptr++; } } // // enumerate next key value. // enumIndex++; } // // No match found, and no more values to enumerate. // if (status == STATUS_NO_MORE_ENTRIES) { DebugPrint(1, ("IopProcessCriticalDeviceRoutine: No match found for this device.\n")); } exit: status = STATUS_SUCCESS; cleanup: if (infoBuffer.Buffer) { IopFreeBuffer(&infoBuffer); } if (hCriticalDeviceKey) { ZwClose(hCriticalDeviceKey); } if (keyValueInfo[0]) { ExFreePool(keyValueInfo[0]); } if (keyValueInfo[1]) { ExFreePool(keyValueInfo[1]); } return status; }

NTSTATUS IopProcessNewChildren (  IN PDEVICE_NODE  DeviceNode, IN PSTART_CONTEXT  StartContext )

Definition at line 1488 of file pnpenum.c. References ASSERT, _DEVICE_NODE::Child, DNF_DEVICE_GONE, DNF_ENUMERATED, DNF_PROCESSED, _DEVICE_NODE::Flags, IopCallDriverAddDevice(), IopProcessNewDeviceNode(), NT_SUCCESS, NTSTATUS(), NULL, OK_TO_ADD_DEVICE, _DEVICE_NODE::Sibling, and TRUE. Referenced by IopEnumerateDevice(). { NTSTATUS status; PDEVICE_NODE childDeviceNode; for (childDeviceNode = DeviceNode->Child; childDeviceNode != NULL; childDeviceNode = childDeviceNode->Sibling) { if (childDeviceNode->Flags & DNF_ENUMERATED) { // // Make sure they aren't resurrecting dead PDOs. // ASSERT(!(childDeviceNode->Flags & DNF_DEVICE_GONE)); // // If the device is not processed ... // if (!(childDeviceNode->Flags & DNF_PROCESSED)) { // // Setup registry key for the newly enumerated device // IopProcessNewDeviceNode(childDeviceNode); } if (OK_TO_ADD_DEVICE(childDeviceNode)) { status = IopCallDriverAddDevice(childDeviceNode, StartContext->LoadDriver, &StartContext->AddContext); if (NT_SUCCESS(status)) { StartContext->NewDevice = TRUE; } } } } return STATUS_SUCCESS; }

NTSTATUS IopProcessNewDeviceNode (  IN OUT PDEVICE_NODE  DeviceNode  )

Definition at line 1538 of file pnpenum.c. References ArbiterRequestPnpEnumerated, ASSERT, BusQueryCompatibleIDs, BusQueryHardwareIDs, CmRegistryMachineSystemCurrentControlSetEnumName, DebugPrint, _DEVOBJ_EXTENSION::DeviceNode, _DEVICE_OBJECT::DeviceObjectExtension, DeviceTextDescription, DeviceTextLocationInformation, DNF_HAS_BOOT_CONFIG, DNF_PROCESSED, DNF_RESOURCE_REQUIREMENTS_NEED_FILTERED, DNUF_DONT_SHOW_IN_UI, DOCK_NOTDOCKDEVICE, DOCK_QUIESCENT, _DEVICE_CAPABILITIES::DockDevice, DOE_START_PENDING, dummy(), ExAcquireResourceShared, ExAllocatePool, ExFreePool(), exit, ExReleaseResource, _DEVOBJ_EXTENSION::ExtensionFlags, FALSE, _DEVICE_CAPABILITIES::HardwareDisabled, IO_STACK_LOCATION, IopClearDevNodeProblem, IopConcatenateUnicodeStrings(), IopCreateRegistryKeyEx(), IopDeviceCapabilitiesToRegistry(), IopDeviceObjectFromDeviceInstance(), IopDoesDevNodeHaveProblem, IopFixupDeviceId(), IopFixupIds(), IopGetBusTypeGuidIndex(), IopIsDeviceInstanceEnabled(), IopIsDevNodeProblem, IopIsRemoteBootCard(), IopLoaderBlock, IopMakeGloballyUniqueId(), IopNotifySetupDeviceArrival(), IopOpenRegistryKeyEx(), IopProcessCriticalDevice(), IopQueryCompatibleIds(), IopQueryDeviceCapabilities(), IopQueryDeviceId(), IopQueryDeviceResources(), IopQueryPnpBusInformation(), IopQueryUniqueId(), IopRemoveDevice(), IopRequestDeviceRemoval(), IopRootDeviceNode, IopSetDevNodeProblem, IopSetupRemoteBootCard(), IopSynchronousCall(), IoRemoteBootClient, IRP_MJ_PNP, IRP_MN_QUERY_DEVICE_TEXT, IRP_MN_QUERY_RESOURCE_REQUIREMENTS, IRP_MN_REMOVE_DEVICE, KeBugCheckEx(), KeEnterCriticalRegion, KeLeaveCriticalRegion, L, _IO_STACK_LOCATION::MajorFunction, _IO_STACK_LOCATION::MinorFunction, _DEVICE_CAPABILITIES::NoDisplayInUI, NT_SUCCESS, NTSTATUS(), NULL, ObDereferenceObject, PAGED_CODE, PagedPool, _IO_STACK_LOCATION::Parameters, _DEVICE_NODE::Parent, PNP_ERR_BOGUS_ID, PNP_ERR_DUPLICATE_PDO, PpDeviceRegistration(), PpRegistryDeviceResource, PpSetPlugPlayEvent(), PsDefaultSystemLocaleId, QUERY_RESOURCE_LIST, _DEVICE_CAPABILITIES::RawDeviceOK, RtlInitUnicodeString(), TITLE_INDEX_VALUE, TRUE, and _DEVICE_CAPABILITIES::UniqueID. Referenced by IopDeviceActionWorker(), and IopProcessNewChildren(). 01544 : 01545 01546 This function creates a device instance key for the specified device. 01547 If LoadDriver is true and the device driver for the device is installed, 01548 this routine will load the driver to start enumerating its children. 01549 01550 Arguments: 01551 01552 DeviceNode - Supplies a pointer to the device node to be processed. 01553 01554 Return Value: 01555 01556 NTSTATUS code. 01557 01558 --*/ 01559 01560 { 01561 NTSTATUS status; 01562 PWCHAR deviceId, busId, uniqueId, compatibleIds, id, hwIds, deviceText, globallyUniqueId; 01563 HANDLE handle, enumHandle, busIdHandle, deviceIdHandle; 01564 HANDLE uniqueIdHandle, logConfHandle; 01565 UNICODE_STRING unicodeName, unicodeString, unicodeDeviceInstance; 01566 ULONG disposition, tmpValue, length, cmLength, ioLength, hwIdLength, compatibleIdLength; 01567 PCM_RESOURCE_LIST cmResource; 01568 PIO_RESOURCE_REQUIREMENTS_LIST ioResource; 01569 PKEY_VALUE_FULL_INFORMATION keyValueInformation; 01570 PWCHAR buffer = NULL; 01571 PDEVICE_OBJECT deviceObject; 01572 PDEVICE_NODE deviceNode; 01573 IO_STACK_LOCATION irpSp; 01574 DEVICE_CAPABILITIES capabilities; 01575 PVOID dummy = NULL; 01576 BOOLEAN globallyUnique = FALSE; 01577 PWCHAR location = NULL, description = NULL; 01578 PKEY_VALUE_PARTIAL_INFORMATION keyValue; 01579 UCHAR CLSIDBuffer[FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + 128]; 01580 01581 BOOLEAN processCriticalDevice = FALSE; 01582 BOOLEAN isRemoteBootCard = FALSE; 01583 BOOLEAN configuredBySetup; 01584 PWCHAR wp; 01585 GUID busTypeGuid; 01586 01587 PAGED_CODE(); 01588 01589 deviceObject = DeviceNode->PhysicalDeviceObject; 01590 01591 // 01592 // First open HKLM\System\CCS\Enum key. 01593 // 01594 01595 status = IopOpenRegistryKeyEx( &enumHandle, 01596 NULL, 01597 &CmRegistryMachineSystemCurrentControlSetEnumName, 01598 KEY_ALL_ACCESS 01599 ); 01600 if (!NT_SUCCESS(status)) { 01601 KdPrint(("IopProcessNewDeviceNode: Unable to open HKLM\\SYSTEM\\CCS\\ENUM\n")); 01602 return status; 01603 } 01604 01605 // 01606 // First, get the device id and this will be the device key name 01607 // 01608 01609 status = IopQueryDeviceId(deviceObject, &id); 01610 01611 if (!NT_SUCCESS(status) || id == NULL) { 01612 ZwClose(enumHandle); 01613 return status; 01614 } 01615 01616 // 01617 // Fix up the id if necessary 01618 // 01619 if (!IopFixupDeviceId(id)) { 01620 KeBugCheckEx( PNP_DETECTED_FATAL_ERROR, 01621 PNP_ERR_BOGUS_ID, 01622 (ULONG_PTR)deviceObject, 01623 (ULONG_PTR)id, 01624 1); 01625 01626 01627 } 01628 01629 // 01630 // Extract bus id out of the returned id 01631 // 01632 01633 for (wp = id; *wp != UNICODE_NULL; wp++) { 01634 if (*wp == OBJ_NAME_PATH_SEPARATOR) { 01635 deviceId = wp + 1; 01636 busId = id; 01637 break; 01638 } 01639 } 01640 01641 if (*wp != OBJ_NAME_PATH_SEPARATOR) { 01642 ZwClose(enumHandle); 01643 ExFreePool(id); 01644 KdPrint(("IopProcessNewDevice: Invalid device id return by driver (not in bus\\device format)\n")); 01645 return STATUS_UNSUCCESSFUL; 01646 } 01647 01648 *wp = UNICODE_NULL; 01649 01650 KeEnterCriticalRegion(); 01651 ExAcquireResourceShared(&PpRegistryDeviceResource, TRUE); 01652 01653 // 01654 // Open/Create enumerator key under HKLM\CCS\System\Enum 01655 // 01656 01657 RtlInitUnicodeString(&unicodeName, busId); 01658 01659 status = IopCreateRegistryKeyEx( &busIdHandle, 01660 enumHandle, 01661 &unicodeName, 01662 KEY_ALL_ACCESS, 01663 REG_OPTION_NON_VOLATILE, 01664 NULL 01665 ); 01666 01667 if (!NT_SUCCESS(status)) { 01668 ExFreePool(id); 01669 ZwClose(enumHandle); 01670 goto exit; 01671 } 01672 01673 // 01674 // Open/create this registry path under HKLM\CCS\System\Enum<Enumerator> 01675 // 01676 01677 RtlInitUnicodeString(&unicodeName, deviceId); 01678 status = IopCreateRegistryKeyEx( &deviceIdHandle, 01679 busIdHandle, 01680 &unicodeName, 01681 KEY_ALL_ACCESS, 01682 REG_OPTION_NON_VOLATILE, 01683 NULL 01684 ); 01685 01686 ZwClose(busIdHandle); 01687 if (!NT_SUCCESS(status)) { 01688 ExFreePool(id); 01689 ZwClose(enumHandle); 01690 goto exit; 01691 } 01692 01693 ExReleaseResource(&PpRegistryDeviceResource); 01694 KeLeaveCriticalRegion(); 01695 01696 // 01697 // Query the device's capabilities 01698 // we will add this stuff to registry once we've processed it a bit 01699 // 01700 01701 status = IopQueryDeviceCapabilities(DeviceNode, &capabilities); 01702 01703 if (capabilities.NoDisplayInUI) { 01704 01705 DeviceNode->UserFlags |= DNUF_DONT_SHOW_IN_UI; 01706 } 01707 01708 // 01709 // From the query capabilities call, determine if this a globally unique ID? 01710 // 01711 01712 if (NT_SUCCESS(status) && (capabilities.UniqueID)) { 01713 globallyUnique = TRUE; 01714 } 01715 01716 // 01717 // Record, is this a dock? 01718 // 01719 DeviceNode->DockInfo.DockStatus = 01720 capabilities.DockDevice ? DOCK_QUIESCENT : DOCK_NOTDOCKDEVICE; 01721 01722 // 01723 // Initialize the stack location to pass to IopSynchronousCall() 01724 // 01725 01726 RtlZeroMemory(&irpSp, sizeof(IO_STACK_LOCATION)); 01727 01728 // 01729 // Query the device's description. 01730 // 01731 01732 irpSp.MajorFunction = IRP_MJ_PNP; 01733 irpSp.MinorFunction = IRP_MN_QUERY_DEVICE_TEXT; 01734 irpSp.Parameters.QueryDeviceText.DeviceTextType = DeviceTextDescription; 01735 irpSp.Parameters.QueryDeviceText.LocaleId = PsDefaultSystemLocaleId; 01736 status = IopSynchronousCall(deviceObject, &irpSp, &description); 01737 01738 if (!NT_SUCCESS(status)) { 01739 description = NULL; 01740 } 01741 01742 // 01743 // Initialize the stack location to pass to IopSynchronousCall() 01744 // 01745 01746 RtlZeroMemory(&irpSp, sizeof(IO_STACK_LOCATION)); 01747 01748 // 01749 // Query the device's location information. 01750 // 01751 01752 irpSp.MajorFunction = IRP_MJ_PNP; 01753 irpSp.MinorFunction = IRP_MN_QUERY_DEVICE_TEXT; 01754 irpSp.Parameters.QueryDeviceText.DeviceTextType = DeviceTextLocationInformation; 01755 irpSp.Parameters.QueryDeviceText.LocaleId = PsDefaultSystemLocaleId; 01756 status = IopSynchronousCall(deviceObject, &irpSp, &location); 01757 01758 if (!NT_SUCCESS(status)) { 01759 location = NULL; 01760 } 01761 01762 // 01763 // Query the unique id for the device 01764 // 01765 01766 IopQueryUniqueId(deviceObject, &uniqueId); 01767 01768 deviceNode = (PDEVICE_NODE)deviceObject->DeviceObjectExtension->DeviceNode; 01769 01770 if (!globallyUnique && deviceNode->Parent != IopRootDeviceNode) { 01771 globallyUniqueId = NULL; 01772 01773 status = IopMakeGloballyUniqueId(deviceObject, uniqueId, &globallyUniqueId); 01774 01775 if (uniqueId != NULL) { 01776 ExFreePool(uniqueId); 01777 } 01778 01779 uniqueId = globallyUniqueId; 01780 01781 } else { 01782 01783 status = STATUS_SUCCESS; 01784 } 01785 01786 if (!NT_SUCCESS(status) || uniqueId == NULL) { 01787 if (description) { 01788 ExFreePool(description); 01789 } 01790 if (location) { 01791 ExFreePool(location); 01792 } 01793 ZwClose(deviceIdHandle); 01794 ZwClose(enumHandle); 01795 ExFreePool(id); 01796 return status; 01797 } 01798 01799 KeEnterCriticalRegion(); 01800 ExAcquireResourceShared(&PpRegistryDeviceResource, TRUE); 01801 01802 RetryDuplicateId: 01803 01804 // 01805 // Fixup the unique instance id if necessary 01806 // 01807 if (!IopFixupDeviceId(uniqueId)) { 01808 KeBugCheckEx( PNP_DETECTED_FATAL_ERROR, 01809 PNP_ERR_BOGUS_ID, 01810 (ULONG_PTR)deviceObject, 01811 (ULONG_PTR)uniqueId, 01812 2); 01813 } 01814 01815 length = (wcslen(busId) + wcslen(deviceId) + wcslen(uniqueId) + 5) * sizeof(WCHAR); 01816 buffer = (PWCHAR)ExAllocatePool(PagedPool, length); 01817 if (!buffer) { 01818 01819 ExReleaseResource(&PpRegistryDeviceResource); 01820 KeLeaveCriticalRegion(); 01821 01822 if (description) { 01823 ExFreePool(description); 01824 } 01825 if (location) { 01826 ExFreePool(location); 01827 } 01828 ZwClose(deviceIdHandle); 01829 ZwClose(enumHandle); 01830 ExFreePool(id); 01831 return STATUS_INSUFFICIENT_RESOURCES; 01832 } 01833 swprintf(buffer, L"%s\\%s\\%s", busId, deviceId, uniqueId); 01834 RtlInitUnicodeString(&unicodeDeviceInstance, buffer); 01835 01836 if (DeviceNode->InstancePath.Buffer != NULL) { 01837 01838 ExFreePool(DeviceNode->InstancePath.Buffer); 01839 RtlInitUnicodeString(&DeviceNode->InstancePath, NULL); 01840 } 01841 01842 IopConcatenateUnicodeStrings(&DeviceNode->InstancePath, &unicodeDeviceInstance, NULL); 01843 01844 // 01845 // Open/create this registry device instance path under 01846 // HKLM\System\Enum<Enumerator>\deviceId 01847 // 01848 01849 RtlInitUnicodeString(&unicodeName, uniqueId); 01850 status = IopCreateRegistryKeyEx( &uniqueIdHandle, 01851 deviceIdHandle, 01852 &unicodeName, 01853 KEY_ALL_ACCESS, 01854 REG_OPTION_NON_VOLATILE, 01855 &disposition 01856 ); 01857 01858 if (!NT_SUCCESS(status)) { 01859 ZwClose(enumHandle); 01860 ExFreePool(id); 01861 ZwClose(deviceIdHandle); 01862 ExFreePool(uniqueId); 01863 goto exit; 01864 } 01865 01866 deviceObject->DeviceObjectExtension->ExtensionFlags |= DOE_START_PENDING; 01867 01868 DeviceNode->Flags |= DNF_PROCESSED; 01869 01870 // 01871 // Check if the device instance is already reported. If yes fail this request. 01872 // 01873 01874 if (disposition != REG_CREATED_NEW_KEY) { 01875 01876 PDEVICE_OBJECT dupCheckDeviceObject; 01877 01878 // 01879 // Retrieve the device node associated with this device instance name (if 01880 // there is one). If it's different from the device node we're currently 01881 // working with, then we have a duplicate, and we want to remove it. 01882 // 01883 01884 dupCheckDeviceObject = IopDeviceObjectFromDeviceInstance(uniqueIdHandle, NULL); 01885 01886 if (dupCheckDeviceObject) { 01887 01888 // 01889 // Go ahead and dereference the device object now--we only need the 01890 // value for comparison. 01891 // 01892 01893 ObDereferenceObject(dupCheckDeviceObject); 01894 01895 if (dupCheckDeviceObject != deviceObject) { 01896 01897 if (globallyUnique) { 01898 globallyUnique = FALSE; 01899 01900 IopMakeGloballyUniqueId(deviceObject, uniqueId, &globallyUniqueId); 01901 01902 if (uniqueId != NULL) { 01903 ExFreePool(uniqueId); 01904 } 01905 01906 uniqueId = globallyUniqueId; 01907 01908 ExFreePool(buffer); 01909 buffer = NULL; 01910 ZwClose(uniqueIdHandle); 01911 IopSetDevNodeProblem(DeviceNode, CM_PROB_NEED_RESTART); 01912 goto RetryDuplicateId; 01913 } 01914 01915 KeBugCheckEx( PNP_DETECTED_FATAL_ERROR, 01916 PNP_ERR_DUPLICATE_PDO, 01917 (ULONG_PTR)deviceObject, 01918 (ULONG_PTR)dupCheckDeviceObject, 01919 0); 01920 01921 #if 0 01922 ZwClose(enumHandle); 01923 ZwClose(uniqueIdHandle); 01924 01925 if (DeviceNode->InstancePath.Length != 0) { 01926 ExFreePool(DeviceNode->InstancePath.Buffer); 01927 DeviceNode->InstancePath.Length = 0; 01928 DeviceNode->InstancePath.Buffer = NULL; 01929 } 01930 01931 IopRequestDeviceRemoval(deviceObject, CM_PROB_DEVICE_NOT_THERE); 01932 goto exit; 01933 #endif 01934 } 01935 } 01936 } else { 01937 01938 if (description) { 01939 PiWstrToUnicodeString(&unicodeName, REGSTR_VAL_DEVDESC); 01940 ZwSetValueKey(uniqueIdHandle, 01941 &unicodeName, 01942 TITLE_INDEX_VALUE, 01943 REG_SZ, 01944 description, 01945 (wcslen(description)+1) * sizeof(WCHAR) 01946 ); 01947 ExFreePool(description); 01948 description = NULL; 01949 } 01950 } 01951 01952 ExFreePool(id); 01953 ZwClose(deviceIdHandle); 01954 ExFreePool(uniqueId); 01955 01956 if (location) { 01957 PiWstrToUnicodeString(&unicodeName, REGSTR_VAL_LOCATION_INFORMATION); 01958 ZwSetValueKey(uniqueIdHandle, 01959 &unicodeName, 01960 TITLE_INDEX_VALUE, 01961 REG_SZ, 01962 location, 01963 (wcslen(location)+1) * sizeof(WCHAR) 01964 ); 01965 ExFreePool(location); 01966 location = NULL; 01967 } 01968 01969 // 01970 // now add the capabilities and UI_NUMBER into registry 01971 // 01972 status = IopDeviceCapabilitiesToRegistry(DeviceNode, &capabilities); 01973 01974 #if DBG 01975 ASSERT(status == STATUS_SUCCESS); 01976 #endif 01977 01978 PiWstrToUnicodeString(&unicodeName, REGSTR_KEY_LOG_CONF); 01979 status = IopCreateRegistryKeyEx( &logConfHandle, 01980 uniqueIdHandle, 01981 &unicodeName, 01982 KEY_ALL_ACCESS, 01983 REG_OPTION_NON_VOLATILE, 01984 NULL 01985 ); 01986 if (!NT_SUCCESS(status)) { 01987 logConfHandle = NULL; // just to make sure 01988 } 01989 01990 if (disposition == REG_CREATED_NEW_KEY) { // disposition from uniqueId 01991 01992 // 01993 // "new registry key" device installation case 01994 // 01995 // Set flags to control whether device installation needs to 01996 // happen later. This means setting the devnode flag to 01997 // DNF_NOT_CONFIGURED and setting the ConfigFlag ONLY if it's 01998 // raw. 01999 // 02000 02001 if (!IopIsDevNodeProblem(DeviceNode, CM_PROB_NEED_RESTART)) { 02002 if (capabilities.RawDeviceOK) { 02003 PiWstrToUnicodeString(&unicodeName, REGSTR_VALUE_CONFIG_FLAGS); 02004 tmpValue = CONFIGFLAG_FINISH_INSTALL; 02005 ZwSetValueKey(uniqueIdHandle, 02006 &unicodeName, 02007 TITLE_INDEX_VALUE, 02008 REG_DWORD, 02009 &tmpValue, 02010 sizeof(tmpValue) 02011 ); 02012 } else { 02013 IopSetDevNodeProblem(DeviceNode, CM_PROB_NOT_CONFIGURED); 02014 } 02015 02016 // 02017 // Process this as a critical device node. This will setup 02018 // the service, if necessary, so that the system can boot far 02019 // enough to get to the config manager 02020 // 02021 02022 processCriticalDevice = TRUE; 02023 } 02024 02025 } else { 02026 02027 UCHAR buffer[sizeof(KEY_VALUE_PARTIAL_INFORMATION)+sizeof(ULONG)]; 02028 PKEY_VALUE_PARTIAL_INFORMATION keyInfo = 02029 (PKEY_VALUE_PARTIAL_INFORMATION) buffer; 02030 02031 ULONG length; 02032 02033 UNICODE_STRING valueName; 02034 02035 NTSTATUS tmpStatus; 02036 02037 if (!IopIsDevNodeProblem(DeviceNode, CM_PROB_NEED_RESTART)) { 02038 02039 RtlInitUnicodeString(&valueName, REGSTR_VALUE_CONFIG_FLAGS); 02040 tmpStatus = ZwQueryValueKey(uniqueIdHandle, 02041 &valueName, 02042 KeyValuePartialInformation, 02043 keyInfo, 02044 sizeof(buffer), 02045 &length); 02046 02047 if (NT_SUCCESS(tmpStatus)) { 02048 02049 ULONG configFlags = *(PULONG)keyInfo->Data; 02050 02051 // 02052 // The ConfigFlags value exists in the registry 02053 // If DNF_REINSTALL is set. We mark it as DNF_DELETED such that we will not 02054 // start the device. Later when the reinstallation completes, the 02055 // DNF_RESTART_OK bit will be set and DNF_DELETED will be deleted. 02056 // 02057 02058 if (configFlags & CONFIGFLAG_REINSTALL) { 02059 IopSetDevNodeProblem(DeviceNode, CM_PROB_REINSTALL); 02060 processCriticalDevice = TRUE; // to install critical driver 02061 } else if (configFlags & CONFIGFLAG_FAILEDINSTALL) { 02062 IopSetDevNodeProblem(DeviceNode, CM_PROB_FAILED_INSTALL); 02063 processCriticalDevice = TRUE; // to install critical driver 02064 } 02065 } else { 02066 // 02067 // The ConfigFlag value does not exist in the registry 02068 // 02069 IopSetDevNodeProblem(DeviceNode, CM_PROB_NOT_CONFIGURED); 02070 } 02071 } 02072 02073 RtlInitUnicodeString(&valueName, REGSTR_VALUE_SERVICE); 02074 02075 tmpStatus = ZwQueryValueKey(uniqueIdHandle, 02076 &valueName, 02077 KeyValuePartialInformation, 02078 keyInfo, 02079 sizeof(buffer), 02080 &length); 02081 02082 // 02083 // if there's no service setup then check to see if this should 02084 // be processed as a critical device. 02085 // 02086 02087 if (NT_SUCCESS(tmpStatus) && (keyInfo->DataLength <= sizeof(L'\0'))) { 02088 processCriticalDevice = TRUE; 02089 } else if (tmpStatus == STATUS_OBJECT_NAME_NOT_FOUND) { 02090 processCriticalDevice = TRUE; 02091 } 02092 } 02093 02094 if (capabilities.HardwareDisabled && 02095 !IopIsDevNodeProblem(DeviceNode, CM_PROB_NOT_CONFIGURED) && 02096 !IopIsDevNodeProblem(DeviceNode, CM_PROB_NEED_RESTART)) { 02097 // 02098 // mark the node as hardware disabled, if no configuration problems 02099 // 02100 IopClearDevNodeProblem(DeviceNode); 02101 IopSetDevNodeProblem(DeviceNode, CM_PROB_HARDWARE_DISABLED); 02102 // 02103 // Issue a PNP REMOVE_DEVICE Irp so when we query resources 02104 // we have those required after boot 02105 // 02106 status = IopRemoveDevice(deviceObject, IRP_MN_REMOVE_DEVICE); 02107 ASSERT(NT_SUCCESS(status)); 02108 02109 } else { 02110 // 02111 // these are the only problems I expect at this point 02112 // 02113 ASSERT(!IopDoesDevNodeHaveProblem(DeviceNode) || 02114 IopIsDevNodeProblem(DeviceNode, CM_PROB_NOT_CONFIGURED) || 02115 IopIsDevNodeProblem(DeviceNode, CM_PROB_REINSTALL) || 02116 IopIsDevNodeProblem(DeviceNode, CM_PROB_FAILED_INSTALL) || 02117 IopIsDevNodeProblem(DeviceNode, CM_PROB_NEED_RESTART)); 02118 } 02119 02120 // 02121 // Create all the default value entry for the newly created key. 02122 // Configuration = REG_RESOURCE_LIST 02123 // ConfigurationVector = REG_RESOUCE_REQUIREMENTS_LIST 02124 // HardwareID = MULTI_SZ 02125 // CompatibleIDs = MULTI_SZ 02126 // Create "Control" volatile subkey. 02127 // 02128 02129 PiWstrToUnicodeString(&unicodeName, REGSTR_KEY_CONTROL); 02130 status = IopCreateRegistryKeyEx( &handle, 02131 uniqueIdHandle, 02132 &unicodeName, 02133 KEY_ALL_ACCESS, 02134 REG_OPTION_VOLATILE, 02135 NULL 02136 ); 02137 if (NT_SUCCESS(status)) { 02138 02139 // 02140 // Write DeviceObject reference ... 02141 // 02142 02143 PiWstrToUnicodeString(&unicodeName, REGSTR_VALUE_DEVICE_REFERENCE); 02144 status = ZwSetValueKey( handle, 02145 &unicodeName, 02146 TITLE_INDEX_VALUE, 02147 REG_DWORD, 02148 (PULONG_PTR)&deviceObject, 02149 sizeof(ULONG_PTR) 02150 ); 02151 ZwClose(handle); 02152 } 02153 02154 if (!NT_SUCCESS(status)) { 02155 ZwClose(enumHandle); 02156 ZwClose(uniqueIdHandle); 02157 if (logConfHandle) { 02158 ZwClose(logConfHandle); 02159 } 02160 goto exit; 02161 } 02162 02163 ZwClose(enumHandle); 02164 02165 // 02166 // Release registry lock before calling device driver 02167 // 02168 02169 ExReleaseResource(&PpRegistryDeviceResource); 02170 KeLeaveCriticalRegion(); 02171 02172 status = IopQueryCompatibleIds( deviceObject, 02173 BusQueryHardwareIDs, 02174 &hwIds, 02175 &hwIdLength); 02176 02177 if (!NT_SUCCESS(status)) { 02178 hwIds = NULL; 02179 } 02180 02181 status = IopQueryCompatibleIds( deviceObject, 02182 BusQueryCompatibleIDs, 02183 &compatibleIds, 02184 &compatibleIdLength); 02185 if (!NT_SUCCESS(status)) { 02186 compatibleIds = NULL; 02187 } 02188 02189 // 02190 // Query the device's basic config vector. This needs to be done before we check if 02191 // this is a remote BOOT card. 02192 // 02193 02194 RtlZeroMemory(&irpSp, sizeof(IO_STACK_LOCATION)); 02195 irpSp.MajorFunction = IRP_MJ_PNP; 02196 irpSp.MinorFunction = IRP_MN_QUERY_RESOURCE_REQUIREMENTS; 02197 status = IopSynchronousCall(deviceObject, &irpSp, &ioResource); 02198 02199 if (!NT_SUCCESS(status)) { 02200 ioResource = NULL; 02201 } 02202 if (ioResource) { 02203 ioLength = ioResource->ListSize; 02204 } 02205 02206 KeEnterCriticalRegion(); 02207 ExAcquireResourceShared(&PpRegistryDeviceResource, TRUE); 02208 02209 // 02210 // Write resource requirements to registry 02211 // 02212 02213 if (logConfHandle) { 02214 PiWstrToUnicodeString(&unicodeName, REGSTR_VALUE_BASIC_CONFIG_VECTOR); 02215 if (ioResource) { 02216 ZwSetValueKey(logConfHandle, 02217 &unicodeName, 02218 TITLE_INDEX_VALUE, 02219 REG_RESOURCE_REQUIREMENTS_LIST, 02220 ioResource, 02221 ioLength 02222 ); 02223 DeviceNode->ResourceRequirements = ioResource; 02224 DeviceNode->Flags |= DNF_RESOURCE_REQUIREMENTS_NEED_FILTERED; 02225 } else { 02226 ZwDeleteValueKey(logConfHandle, &unicodeName); 02227 } 02228 } 02229 02230 // 02231 // While we have the hwIds, check if this is the device node 02232 // for the remote boot net card. If IopLoaderBlock is NULL 02233 // then we are not initilizing boot drivers so we don't have 02234 // to check for this. 02235 // 02236 02237 if (IoRemoteBootClient && (IopLoaderBlock != NULL)) { 02238 02239 if (hwIds) { 02240 isRemoteBootCard = IopIsRemoteBootCard( 02241 DeviceNode, 02242 (PLOADER_PARAMETER_BLOCK)IopLoaderBlock, 02243 hwIds); 02244 } 02245 if (!isRemoteBootCard && compatibleIds) { 02246 isRemoteBootCard = IopIsRemoteBootCard( 02247 DeviceNode, 02248 (PLOADER_PARAMETER_BLOCK)IopLoaderBlock, 02249 compatibleIds); 02250 } 02251 } 02252 02253 // 02254 // create HardwareId value name. It is a MULTI_SZ, 02255 // 02256 02257 if (hwIds) { 02258 02259 if (!IopFixupIds(hwIds, hwIdLength)) { 02260 KeBugCheckEx( PNP_DETECTED_FATAL_ERROR, 02261 PNP_ERR_BOGUS_ID, 02262 (ULONG_PTR)deviceObject, 02263 (ULONG_PTR)hwIds, 02264 3); 02265 } 02266 PiWstrToUnicodeString(&unicodeName, REGSTR_VAL_HARDWAREID); 02267 ZwSetValueKey(uniqueIdHandle, 02268 &unicodeName, 02269 TITLE_INDEX_VALUE, 02270 REG_MULTI_SZ, 02271 hwIds, 02272 hwIdLength 02273 ); 02274 ExFreePool(hwIds); 02275 } 02276 02277 // 02278 // create CompatibleId value name. It is a MULTI_SZ, 02279 // 02280 02281 if (compatibleIds) { 02282 02283 if (!IopFixupIds(compatibleIds, compatibleIdLength)) { 02284 KeBugCheckEx( PNP_DETECTED_FATAL_ERROR, 02285 PNP_ERR_BOGUS_ID, 02286 (ULONG_PTR)deviceObject, 02287 (ULONG_PTR)compatibleIds, 02288 4); 02289 } 02290 PiWstrToUnicodeString(&unicodeName, REGSTR_VAL_COMPATIBLEIDS); 02291 ZwSetValueKey(uniqueIdHandle, 02292 &unicodeName, 02293 TITLE_INDEX_VALUE, 02294 REG_MULTI_SZ, 02295 compatibleIds, 02296 compatibleIdLength 02297 ); 02298 ExFreePool(compatibleIds); 02299 } 02300 02301 // 02302 // If this is the devnode for the remote boot card, do 02303 // special setup for it. 02304 // 02305 02306 if (isRemoteBootCard) { 02307 02308 status = IopSetupRemoteBootCard( 02309 (PLOADER_PARAMETER_BLOCK)IopLoaderBlock, 02310 uniqueIdHandle, 02311 &unicodeDeviceInstance); 02312 02313 if (status != STATUS_SUCCESS) { 02314 goto exit; 02315 } 02316 02317 // 02318 // HACK BUGBUG: Need to turn this off, or else the device won't 02319 // be allowed to be opened until the PNP start IRP is done. Unfortunately 02320 // that is exactly what NDIS does in the start IRP handler - adamba 3/31/99 02321 // 02322 02323 deviceObject->DeviceObjectExtension->ExtensionFlags &= ~DOE_START_PENDING; 02324 02325 } 02326 02327 ExReleaseResource(&PpRegistryDeviceResource); 02328 KeLeaveCriticalRegion(); 02329 02330 // 02331 // we've pretty much got the PDO information ready, apart from Child bus information 02332 // get that now, because class-installer may want it 02333 // 02334 status = IopQueryPnpBusInformation( 02335 deviceObject, 02336 &busTypeGuid, 02337 &DeviceNode->ChildInterfaceType, 02338 &DeviceNode->ChildBusNumber 02339 ); 02340 02341 if (NT_SUCCESS(status)) { 02342 02343 DeviceNode->ChildBusTypeIndex = IopGetBusTypeGuidIndex(&busTypeGuid); 02344 02345 } else { 02346 02347 DeviceNode->ChildBusTypeIndex = 0xffff; 02348 DeviceNode->ChildInterfaceType = InterfaceTypeUndefined; 02349 DeviceNode->ChildBusNumber = 0xfffffff0; 02350 02351 } 02352 02353 // 02354 // we check HardwareDisabled directly in case it's a new device 02355 // 02356 if (processCriticalDevice && !capabilities.HardwareDisabled && 02357 !IopIsDevNodeProblem(DeviceNode, CM_PROB_NEED_RESTART)) { 02358 02359 IopProcessCriticalDevice(DeviceNode); 02360 } 02361 02362 // 02363 // Set DNF_DISABLED flag if the device instance is disabled. 02364 // 02365 02366 ASSERT(!IopDoesDevNodeHaveProblem(DeviceNode) || 02367 IopIsDevNodeProblem(DeviceNode, CM_PROB_NOT_CONFIGURED) || 02368 IopIsDevNodeProblem(DeviceNode, CM_PROB_REINSTALL) || 02369 IopIsDevNodeProblem(DeviceNode, CM_PROB_FAILED_INSTALL) || 02370 IopIsDevNodeProblem(DeviceNode, CM_PROB_PARTIAL_LOG_CONF) || 02371 IopIsDevNodeProblem(DeviceNode, CM_PROB_HARDWARE_DISABLED) || 02372 IopIsDevNodeProblem(DeviceNode, CM_PROB_NEED_RESTART)); 02373 if (!IopIsDevNodeProblem(DeviceNode, CM_PROB_DISABLED) && 02374 !IopIsDevNodeProblem(DeviceNode, CM_PROB_HARDWARE_DISABLED) && 02375 !IopIsDevNodeProblem(DeviceNode, CM_PROB_NEED_RESTART)) { 02376 02377 IopIsDeviceInstanceEnabled(uniqueIdHandle, &unicodeDeviceInstance, TRUE); 02378 } 02379 02380 // 02381 // This code HAS to be after we have checked for DISABLED device. 02382 // We could end up here from an ENABLE following a DISABLE. 02383 // Query for BOOT config if there is none already present. 02384 // 02385 02386 cmResource = NULL; 02387 if (DeviceNode->BootResources == NULL) { 02388 status = IopQueryDeviceResources( deviceObject, 02389 QUERY_RESOURCE_LIST, 02390 &cmResource, 02391 &cmLength ); 02392 if (!NT_SUCCESS(status)) { 02393 cmResource = NULL; 02394 } 02395 } else { 02396 02397 DebugPrint(1, 02398 ("PNPENUM: %ws already has BOOT config in IopProcessNewDeviceNode!\n", 02399 DeviceNode->InstancePath.Buffer)); 02400 } 02401 02402 KeEnterCriticalRegion(); 02403 ExAcquireResourceShared(&PpRegistryDeviceResource, TRUE); 02404 02405 // 02406 // Write boot resources to registry 02407 // 02408 if (logConfHandle && DeviceNode->BootResources == NULL) { 02409 PiWstrToUnicodeString(&unicodeName, REGSTR_VAL_BOOTCONFIG); 02410 if (cmResource) { 02411 ZwSetValueKey( 02412 logConfHandle, 02413 &unicodeName, 02414 TITLE_INDEX_VALUE, 02415 REG_RESOURCE_LIST, 02416 cmResource, 02417 cmLength 02418 ); 02419 02420 ExReleaseResource(&PpRegistryDeviceResource); 02421 02422 // 02423 // This device consumes BOOT resources. Reserve its boot resources 02424 // 02425 02426 status = (*IopReserveResourcesRoutine)(ArbiterRequestPnpEnumerated, 02427 deviceObject, 02428 cmResource); 02429 02430 ExAcquireResourceShared(&PpRegistryDeviceResource, TRUE); 02431 02432 if (NT_SUCCESS(status)) { 02433 DeviceNode->Flags |= DNF_HAS_BOOT_CONFIG; 02434 } 02435 ExFreePool(cmResource); 02436 } else { 02437 ZwDeleteValueKey(logConfHandle, &unicodeName); 02438 } 02439 } 02440 02441 // 02442 // SurpriseRemovalOK bits may have changed due to DNF_HAS_BOOT_CONFIG. 02443 // 02444 status = IopDeviceCapabilitiesToRegistry(DeviceNode,&capabilities); 02445 02446 #if DBG 02447 ASSERT(status == STATUS_SUCCESS); 02448 #endif 02449 02450 // 02451 // Clean up 02452 // 02453 02454 if (logConfHandle) { 02455 ZwClose(logConfHandle); 02456 } 02457 02458 ExReleaseResource(&PpRegistryDeviceResource); 02459 KeLeaveCriticalRegion(); 02460 02461 // 02462 // Create new value entry under ServiceKeyName\Enum to reflect the newly 02463 // added made-up device instance node. 02464 // 02465 02466 status = IopNotifySetupDeviceArrival( deviceObject, 02467 uniqueIdHandle, 02468 TRUE); 02469 02470 configuredBySetup = NT_SUCCESS(status); 02471 02472 status = PpDeviceRegistration( 02473 &unicodeDeviceInstance, 02474 TRUE, 02475 &DeviceNode->ServiceName 02476 ); 02477 02478 if (NT_SUCCESS(status) && (configuredBySetup || isRemoteBootCard) && 02479 IopIsDevNodeProblem(DeviceNode, CM_PROB_NOT_CONFIGURED)) { 02480 02481 IopClearDevNodeProblem(DeviceNode); 02482 } 02483 02484 // 02485 // Add an event so user-mode will attempt to install this device later. 02486 // 02487 PpSetPlugPlayEvent( &GUID_DEVICE_ENUMERATED, 02488 deviceObject); 02489 02490 ZwClose(uniqueIdHandle); 02491 02492 if (buffer) { 02493 ExFreePool(buffer); 02494 } 02495 if (description) { 02496 ExFreePool(description); 02497 } 02498 if (location) { 02499 ExFreePool(location); 02500 } 02501 return STATUS_SUCCESS; 02502 02503 exit: 02504 02505 // 02506 // In case of failure, we don't set the DNF_PROCESSED flags. So the device 02507 // will be processed again later. 02508 // 02509 02510 ExReleaseResource(&PpRegistryDeviceResource); 02511 KeLeaveCriticalRegion(); 02512 if (buffer) { 02513 ExFreePool(buffer); 02514 } 02515 if (description) { 02516 ExFreePool(description); 02517 } 02518 if (location) { 02519 ExFreePool(location); 02520 } 02521 return status; 02522 }

NTSTATUS IopProcessNewProfile (  VOID   )

Definition at line 5034 of file pnpenum.c. References CriticalWorkQueue, ExAllocatePool, ExInitializeWorkItem, ExQueueWorkItem(), IopProcessNewProfileWorker(), NonPagedPool, and PAGED_CODE. Referenced by IopHardwareProfileCancelRemovedDock(), IopHardwareProfileCommitRemovedDock(), and IopHardwareProfileCommitStartedDock(). 05040 : 05041 05042 This function is called after the system has transitioned into a new 05043 hardware profile. The thread from which it is called may be holding an 05044 enumeration lock. Calling this function does two tasks: 05045 05046 1) If a disabled devnode in the tree should be enabled in this new hardware 05047 profile state, it will be started. 05048 05049 2) If an enabled devnode in the tree should be disabled in this new hardware 05050 profile state, it will be (surprise) removed. 05051 05052 ADRIAO N.B. 02/19/1999 - 05053 Why surprise remove? There are four cases to be handled: 05054 a) Dock disappearing, need to enable device in new profile 05055 b) Dock appearing, need to enable device in new profile 05056 c) Dock disappearing, need to disable device in new profile 05057 d) Dock appearing, need to disable device in new profile 05058 05059 a) and b) are trivial. c) involves treating the appropriate devices as 05060 if they were in the removal relation lists for the dock. d) is another 05061 matter altogether as we need to query-remove/remove devices before 05062 starting another. NT5's PnP state machine cannot handle this, so for 05063 this release we cleanup rather hastily after the profile change. 05064 05065 Parameters: 05066 05067 NONE. 05068 05069 Return Value: 05070 05071 NTSTATUS. 05072 05073 --*/ 05074 { 05075 PWORK_QUEUE_ITEM workQueueItem; 05076 05077 PAGED_CODE(); 05078 05079 workQueueItem = (PWORK_QUEUE_ITEM) ExAllocatePool( 05080 NonPagedPool, 05081 sizeof(WORK_QUEUE_ITEM) 05082 ); 05083 05084 if (workQueueItem) { 05085 05086 // 05087 // Queue this up so we can walk the tree outside of the enumeration lock. 05088 // 05089 ExInitializeWorkItem( 05090 workQueueItem, 05091 IopProcessNewProfileWorker, 05092 workQueueItem 05093 ); 05094 05095 ExQueueWorkItem( 05096 workQueueItem, 05097 CriticalWorkQueue 05098 ); 05099 05100 return STATUS_SUCCESS; 05101 05102 } else { 05103 05104 return STATUS_INSUFFICIENT_RESOURCES; 05105 } 05106 }

NTSTATUS IopProcessNewProfileStateCallback (  IN PDEVICE_NODE  DeviceNode, IN PVOID  Context )

Definition at line 5138 of file pnpenum.c. References BusRelations, DNF_STARTED, FALSE, IoInvalidateDeviceRelations(), IopClearDevNodeProblem, IopIsDeviceInstanceEnabled(), IopIsDevNodeProblem, IopRequestDeviceRemoval(), NULL, PAGED_CODE, _DEVICE_NODE::Parent, and _DEVICE_NODE::PhysicalDeviceObject. Referenced by IopProcessNewProfileWorker(). 05145 : 05146 05147 This function is called for each devnode after the system has transitioned 05148 hardware profile states. 05149 05150 Parameters: 05151 05152 NONE. 05153 05154 Return Value: 05155 05156 NONE. 05157 05158 --*/ 05159 { 05160 PDEVICE_NODE parentDevNode; 05161 05162 PAGED_CODE(); 05163 05164 if (DeviceNode->Flags & DNF_STARTED) { 05165 05166 // 05167 // Calling this function will disable the device if it is appropriate 05168 // to do so. 05169 // 05170 if (!IopIsDeviceInstanceEnabled(NULL, &DeviceNode->InstancePath, FALSE)) { 05171 05172 IopRequestDeviceRemoval( 05173 DeviceNode->PhysicalDeviceObject, 05174 CM_PROB_DISABLED 05175 ); 05176 } 05177 05178 } else if (IopIsDevNodeProblem(DeviceNode, CM_PROB_DISABLED)) { 05179 05180 // 05181 // We might be turning on the device. So we will clear the problem 05182 // flags iff the device problem was CM_PROB_DISABLED. 05183 // 05184 IopClearDevNodeProblem(DeviceNode); 05185 05186 // 05187 // Make sure the device stays down iff appropriate. 05188 // 05189 if (IopIsDeviceInstanceEnabled(NULL, &DeviceNode->InstancePath, FALSE)) { 05190 05191 // 05192 // This device should come back online. Queue up an enumeration 05193 // at the parent level for him. 05194 // 05195 parentDevNode = DeviceNode->Parent; 05196 05197 IoInvalidateDeviceRelations( 05198 parentDevNode->PhysicalDeviceObject, 05199 BusRelations 05200 ); 05201 } 05202 } 05203 05204 return STATUS_SUCCESS; 05205 } }

VOID IopProcessNewProfileWorker (  IN PVOID  Context  )

Definition at line 5109 of file pnpenum.c. References ExFreePool(), IopForAllDeviceNodes(), IopProcessNewProfileStateCallback(), NULL, and PAGED_CODE. Referenced by IopProcessNewProfile(). 05115 : 05116 05117 This function is called for each devnode after the system has transitioned 05118 to a new hardware profile. 05119 05120 Parameters: 05121 05122 NONE. 05123 05124 Return Value: 05125 05126 NONE. 05127 05128 --*/ 05129 { 05130 PAGED_CODE(); 05131 05132 IopForAllDeviceNodes(IopProcessNewProfileStateCallback, NULL); 05133 05134 ExFreePool(Context); 05135 }

VOID IopProcessStartDevices (  IN PDEVICE_NODE  DeviceNode, IN PSTART_CONTEXT  StartContext )

Definition at line 821 of file pnpenum.c. References _DEVICE_NODE::Child, DNF_STARTED, ExAcquireResourceShared, Executive, ExReleaseResource, FALSE, IopDeviceTreeLock, IopProcessStartDevicesWorker(), IopReleaseEnumerationLock, KernelMode, KeSetEvent(), KeWaitForSingleObject(), NTSTATUS(), NULL, PAGED_CODE, PpSynchronizeDeviceEventQueue(), _DEVICE_NODE::Sibling, and TRUE. Referenced by IopBusCheck(), IopDeviceActionWorker(), IopInitializeSystemDrivers(), and IopNewDevice(). 00828 : 00829 00830 This function is used by Pnp manager to start the devices which have been 00831 allocated resources and waiting to be started. 00832 00833 Parameters: 00834 00835 DeviceNode - Specifies the device node whose subtree is to be checked for StartDevice. 00836 00837 StartContext - specifies if new driver should be loaded to complete the enumeration. 00838 00839 Return Value: 00840 00841 NONE. 00842 00843 --*/ 00844 { 00845 NTSTATUS status; 00846 PDEVICE_NODE deviceNode, nextDeviceNode; 00847 00848 PAGED_CODE(); 00849 00850 // 00851 // Parse the device node subtree to determine which devices need to be started 00852 // 00853 00854 ExAcquireResourceShared(&IopDeviceTreeLock, TRUE); 00855 if (DeviceNode->LockCount == 0) { 00856 00857 KeWaitForSingleObject( &DeviceNode->EnumerationMutex, 00858 Executive, 00859 KernelMode, 00860 FALSE, 00861 NULL ); 00862 00863 deviceNode = DeviceNode->Child; 00864 while (deviceNode) { 00865 nextDeviceNode = deviceNode->Sibling; 00866 status = IopProcessStartDevicesWorker(deviceNode, StartContext); 00867 00868 if (status == STATUS_PNP_RESTART_ENUMERATION) { 00869 00870 IopReleaseEnumerationLock(DeviceNode); 00871 00872 PpSynchronizeDeviceEventQueue(); 00873 00874 ExAcquireResourceShared(&IopDeviceTreeLock, TRUE); 00875 if (DeviceNode->LockCount == 0) { 00876 00877 KeWaitForSingleObject( &DeviceNode->EnumerationMutex, 00878 Executive, 00879 KernelMode, 00880 FALSE, 00881 NULL ); 00882 00883 00884 if (!(DeviceNode->Flags & DNF_STARTED)) { 00885 break; 00886 } 00887 00888 deviceNode = DeviceNode->Child; 00889 00890 continue; 00891 00892 } else { 00893 00894 ExReleaseResource(&IopDeviceTreeLock); 00895 return; 00896 00897 } 00898 } 00899 00900 deviceNode = nextDeviceNode; 00901 } 00902 00903 KeSetEvent( &DeviceNode->EnumerationMutex, 00904 0, 00905 FALSE ); 00906 } 00907 00908 ExReleaseResource(&IopDeviceTreeLock); 00909 }

NTSTATUS IopProcessStartDevicesWorker (  IN PDEVICE_NODE  DeviceNode, OUT PVOID  Context )

Definition at line 912 of file pnpenum.c. References DNF_ADDED, DNF_HAS_RESOURCE, DNF_NEED_QUERY_IDS, DNF_START_PHASE, ExAcquireResourceShared, Executive, ExReleaseResource, FALSE, IopDeviceTreeLock, IopForAllChildDeviceNodes(), IopProcessStartDevicesWorker(), IopStartAndEnumerateDevice(), KernelMode, KeSetEvent(), KeWaitForSingleObject(), NTSTATUS(), NULL, PAGED_CODE, and TRUE. Referenced by IopProcessStartDevices(), and IopProcessStartDevicesWorker(). 00919 : 00920 00921 This function is used by Pnp manager to start the devices which have been allocated 00922 resources and waiting to be started. 00923 00924 Parameters: 00925 00926 DeviceNode - Specifies the device node whose subtree is to be checked for StartDevice. 00927 00928 Context - specifies a pointer to START_CONTEXT to pass start device info. 00929 00930 Return Value: 00931 00932 TRUE. 00933 00934 --*/ 00935 { 00936 NTSTATUS status = STATUS_SUCCESS; 00937 00938 PAGED_CODE(); 00939 00940 if ( (DeviceNode->Flags & DNF_NEED_QUERY_IDS) || // Reported devices are Started but not enumerated 00941 ((DeviceNode->Flags & DNF_ADDED) && 00942 !(DeviceNode->Flags & DNF_START_PHASE) && 00943 (DeviceNode->Flags & DNF_HAS_RESOURCE)) ) { 00944 00945 // 00946 // If device has been added and resources acquired, we will start it by 00947 // sending StartDevice irp and enumerate the device. 00948 // 00949 00950 status = IopStartAndEnumerateDevice(DeviceNode, (PSTART_CONTEXT)Context); 00951 00952 } else { 00953 00954 // 00955 // Acquire enumeration mutex to make sure its children won't change by 00956 // someone else. Note, the current device node is protected by its parent's 00957 // Enumeration mutex and it won't disappear either. 00958 // 00959 00960 ExAcquireResourceShared(&IopDeviceTreeLock, TRUE); 00961 00962 if (DeviceNode->LockCount == 0) { 00963 00964 KeWaitForSingleObject( &DeviceNode->EnumerationMutex, 00965 Executive, 00966 KernelMode, 00967 FALSE, 00968 NULL ); 00969 00970 00971 // 00972 // Recursively mark all of our children deleted. 00973 // 00974 00975 IopForAllChildDeviceNodes(DeviceNode, IopProcessStartDevicesWorker, Context); 00976 00977 // 00978 // Release the enumeration mutex of the device node. 00979 // 00980 00981 KeSetEvent( &DeviceNode->EnumerationMutex, 00982 0, 00983 FALSE ); 00984 00985 } 00986 00987 ExReleaseResource(&IopDeviceTreeLock); 00988 } 00989 00990 return status; 00991 }

NTSTATUS IopQueryDeviceCapabilities (  IN PDEVICE_NODE  DeviceNode, OUT PDEVICE_CAPABILITIES  Capabilities )

Definition at line 3694 of file pnpenum.c. References ASSERT, DEVICE_CAPABILITIES, dummy(), IopSynchronousCall(), IRP_MJ_PNP, IRP_MN_QUERY_CAPABILITIES, _IO_STACK_LOCATION::MajorFunction, _IO_STACK_LOCATION::MinorFunction, NTSTATUS(), and _IO_STACK_LOCATION::Parameters. Referenced by IoGetDeviceProperty(), IopDeviceCapabilitiesToRegistry(), IopDeviceNodeCapabilitiesToRegistry(), and IopProcessNewDeviceNode(). : This routine will issue an irp to the DeviceObject to retrieve the pnp device capabilities. Should only be called twice - first from IopProcessNewDeviceNode, and second from IopDeviceNodeCapabilitiesToRegistry, called after device is started. If you consider calling this device, see if DeviceNode->CapabilityFlags does what you need instead (accessed via IopDeviceNodeFlagsToCapabilities(...). Arguments: DeviceNode - the device object the request should be sent to. Capabilities - a capabilities structure to be filled in by the driver. Return Value: status --*/ { IO_STACK_LOCATION irpStack; PVOID dummy; NTSTATUS status; // // Initialize the capabilities structure. // RtlZeroMemory(Capabilities, sizeof(DEVICE_CAPABILITIES)); Capabilities->Size = sizeof(DEVICE_CAPABILITIES); Capabilities->Version = 1; Capabilities->Address = Capabilities->UINumber = (ULONG)-1; // // Initialize the stack location to pass to IopSynchronousCall() // RtlZeroMemory(&irpStack, sizeof(IO_STACK_LOCATION)); // // Query the device's capabilities // irpStack.MajorFunction = IRP_MJ_PNP; irpStack.MinorFunction = IRP_MN_QUERY_CAPABILITIES; irpStack.Parameters.DeviceCapabilities.Capabilities = Capabilities; status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject, &irpStack, &dummy); ASSERT(status != STATUS_PENDING); return status; }

NTSTATUS IopRequestDeviceAction (  IN PDEVICE_OBJECT DeviceObject  OPTIONAL, IN DEVICE_REQUEST_TYPE  RequestType, IN PKEVENT CompletionEvent  OPTIONAL, IN PNTSTATUS CompletionStatus  OPTIONAL )

Definition at line 207 of file pnpenum.c. References _PI_DEVICE_REQUEST::CompletionEvent, _PI_DEVICE_REQUEST::CompletionStatus, DelayedWorkQueue, DEVICE_REQUEST_TYPE, _PI_DEVICE_REQUEST::DeviceObject, ExAllocatePool, ExInitializeWorkItem, ExQueueWorkItem(), IopDeviceActionWorker(), IopDeviceEnumerationWorkItem, IopEnumerationInProgress, IopPnpEnumerationRequestList, IopPnPSpinLock, KeClearEvent, _PI_DEVICE_REQUEST::ListEntry, NonPagedPool, NULL, ObReferenceObject, PI_DEVICE_REQUEST, PiEnumerationLock, PnPBootDriversLoaded, PPI_DEVICE_REQUEST, ReenumerateBootDevices, ReenumerateRootDevices, _PI_DEVICE_REQUEST::RequestType, and TRUE. Referenced by IoInvalidateDeviceRelations(), IopDeleteLockedDeviceNodes(), IopDeviceRelationsComplete(), IopDeviceStartComplete(), IopInitializeBootDrivers(), IopInitializePlugPlayServices(), IopInvalidateRelationsInList(), IopQueryDeviceRelations(), IopResourceRequirementsChanged(), IopStartDriverDevices(), and IoSynchronousInvalidateDeviceRelations(). : This routine queues a work item to enumerate a device. This is for IO internal use only. Arguments: DeviceObject - Supplies a pointer to the device object to be enumerated. if NULL, this is a request to retry resources allocation failed devices. Request - the reason for the enumeration. Return Value: NTSTATUS code. --*/ { PPI_DEVICE_REQUEST request; PDEVICE_NODE deviceNode; KIRQL oldIrql; // // If this node is ready for enumeration, enqueue it // request = ExAllocatePool(NonPagedPool, sizeof(PI_DEVICE_REQUEST)); if (request) { // // Put this request onto the pending list // if (DeviceObject) { ObReferenceObject(DeviceObject); } request->DeviceObject = DeviceObject; request->RequestType = RequestType; request->CompletionEvent = CompletionEvent; request->CompletionStatus = (RequestType == ReenumerateBootDevices)? NULL : CompletionStatus; InitializeListHead(&request->ListEntry); // // Insert the request to the request queue. If the request queue is // not currently being worked on, request a worker thread to start it. // ExAcquireSpinLock(&IopPnPSpinLock, &oldIrql); InsertTailList(&IopPnpEnumerationRequestList, &request->ListEntry); if ( RequestType == ReenumerateBootDevices || RequestType == ReenumerateRootDevices) { // // This is a special request used when booting the system. Instead // of queuing a work item it synchronously calls the work routine. // IopEnumerationInProgress = TRUE; KeClearEvent(&PiEnumerationLock); ExReleaseSpinLock(&IopPnPSpinLock, oldIrql); IopDeviceActionWorker((PVOID)CompletionStatus); } else if (PnPBootDriversLoaded && !IopEnumerationInProgress) { IopEnumerationInProgress = TRUE; KeClearEvent(&PiEnumerationLock); ExReleaseSpinLock(&IopPnPSpinLock, oldIrql); // // Queue a work item to do the enumeration // ExInitializeWorkItem(&IopDeviceEnumerationWorkItem, IopDeviceActionWorker, NULL); ExQueueWorkItem(&IopDeviceEnumerationWorkItem, DelayedWorkQueue); } else { ExReleaseSpinLock(&IopPnPSpinLock, oldIrql); } } else { return STATUS_INSUFFICIENT_RESOURCES; } return STATUS_SUCCESS; }

NTSTATUS IopStartAndEnumerateDevice (  IN PDEVICE_NODE  DeviceNode, IN PSTART_CONTEXT  StartContext )

Definition at line 994 of file pnpenum.c. References ASSERT, BusQueryCompatibleIDs, BusQueryHardwareIDs, DNF_ADDED, DNF_HAS_RESOURCE, DNF_NEED_ENUMERATION_ONLY, DNF_NEED_QUERY_IDS, DNF_NO_RESOURCE_REQUIRED, DNF_START_PHASE, DNF_STARTED, ExAcquireResourceShared, ExFreePool(), ExReleaseResource, IopDeviceNodeCapabilitiesToRegistry(), IopDeviceObjectToDeviceInstance(), IopEnumerateDevice(), IopFixupIds(), IopQueryCompatibleIds(), IopQueryDeviceState(), IopStartDevice(), KeBugCheckEx(), KeEnterCriticalRegion, KeLeaveCriticalRegion, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PNP_ERR_BOGUS_ID, PnpAsyncOk, PpRegistryDeviceResource, TITLE_INDEX_VALUE, and TRUE. Referenced by IopNewDevice(), and IopProcessStartDevicesWorker(). 01001 : 01002 01003 This routine starts the specified device and enumerates it. 01004 01005 NOTE: The resources for the device should already been allocated. 01006 01007 Arguments: 01008 01009 DeviceNode - Supplies a pointer to a device node which will be started and 01010 enumerated. 01011 01012 StartContext - Supplies a pointer to START_CONTEXT structure to control 01013 how the start should be handled. 01014 01015 Return Value: 01016 01017 NTSTATUS code. 01018 01019 --*/ 01020 01021 { 01022 NTSTATUS status; 01023 UNICODE_STRING unicodeName; 01024 PDEVICE_OBJECT deviceObject; 01025 HANDLE handle; 01026 01027 PAGED_CODE(); 01028 01029 // 01030 // If no driver is loaded or add device failed, don't start it. 01031 // 01032 01033 ASSERT((DeviceNode->Flags & DNF_ADDED) && 01034 (DeviceNode->Flags & (DNF_HAS_RESOURCE | DNF_NO_RESOURCE_REQUIRED)) && 01035 (!(DeviceNode->Flags & DNF_START_PHASE) || (DeviceNode->Flags & DNF_NEED_QUERY_IDS)) 01036 ); 01037 01038 deviceObject = DeviceNode->PhysicalDeviceObject; 01039 01040 // 01041 // First start the device, if it hasn't 01042 // 01043 01044 if (!(DeviceNode->Flags & DNF_STARTED)) { 01045 01046 IopStartDevice(deviceObject); 01047 01048 // 01049 // ADRIAO BUGBUG 11/11/98 - 01050 // Everything in this if clause expects the start call to 01051 // returns synchronously. When AsyncOk == TRUE functionality is fixed, 01052 // code in here should be moved into IopStartDevice. 01053 // 01054 if (DeviceNode->Flags & DNF_STARTED) { 01055 01056 IopDeviceNodeCapabilitiesToRegistry(DeviceNode); 01057 IopQueryDeviceState(deviceObject); 01058 } 01059 } 01060 01061 if (DeviceNode->Flags & DNF_NEED_QUERY_IDS) { 01062 01063 PWCHAR compatibleIds, hwIds; 01064 ULONG hwIdLength, compatibleIdLength; 01065 01066 // 01067 // If the DNF_NEED_QUERY_IDS is set, the device is a reported device. 01068 // It should already be started. We need to enumerate its children and ask 01069 // the HardwareId and the Compatible ids of the detected device. 01070 // 01071 01072 DeviceNode->Flags &= ~DNF_NEED_QUERY_IDS; 01073 status = IopDeviceObjectToDeviceInstance (deviceObject, 01074 &handle, 01075 KEY_READ 01076 ); 01077 if (NT_SUCCESS(status)) { 01078 status = IopQueryCompatibleIds(deviceObject, 01079 BusQueryHardwareIDs, 01080 &hwIds, 01081 &hwIdLength); 01082 01083 if (!NT_SUCCESS(status)) { 01084 hwIds = NULL; 01085 } 01086 01087 status = IopQueryCompatibleIds(deviceObject, 01088 BusQueryCompatibleIDs, 01089 &compatibleIds, 01090 &compatibleIdLength); 01091 if (!NT_SUCCESS(status)) { 01092 compatibleIds = NULL; 01093 } 01094 01095 if (hwIds || compatibleIds) { 01096 KeEnterCriticalRegion(); 01097 ExAcquireResourceShared(&PpRegistryDeviceResource, TRUE); 01098 01099 if (hwIds) { 01100 01101 if (!IopFixupIds(hwIds, hwIdLength)) { 01102 KeBugCheckEx( PNP_DETECTED_FATAL_ERROR, 01103 PNP_ERR_BOGUS_ID, 01104 (ULONG_PTR)deviceObject, 01105 (ULONG_PTR)hwIds, 01106 3); 01107 } 01108 PiWstrToUnicodeString(&unicodeName, REGSTR_VAL_HARDWAREID); 01109 ZwSetValueKey(handle, 01110 &unicodeName, 01111 TITLE_INDEX_VALUE, 01112 REG_MULTI_SZ, 01113 hwIds, 01114 hwIdLength 01115 ); 01116 ExFreePool(hwIds); 01117 } 01118 01119 // 01120 // create CompatibleId value name. It is a MULTI_SZ, 01121 // 01122 01123 if (compatibleIds) { 01124 01125 if (!IopFixupIds(compatibleIds, compatibleIdLength)) { 01126 KeBugCheckEx( PNP_DETECTED_FATAL_ERROR, 01127 PNP_ERR_BOGUS_ID, 01128 (ULONG_PTR)deviceObject, 01129 (ULONG_PTR)compatibleIds, 01130 4); 01131 } 01132 01133 PiWstrToUnicodeString(&unicodeName, REGSTR_VAL_COMPATIBLEIDS); 01134 ZwSetValueKey(handle, 01135 &unicodeName, 01136 TITLE_INDEX_VALUE, 01137 REG_MULTI_SZ, 01138 compatibleIds, 01139 compatibleIdLength 01140 ); 01141 ExFreePool(compatibleIds); 01142 } 01143 01144 ExReleaseResource(&PpRegistryDeviceResource); 01145 KeLeaveCriticalRegion(); 01146 } 01147 ZwClose(handle); 01148 } 01149 } 01150 01151 if ((DeviceNode->Flags & DNF_STARTED) && 01152 (DeviceNode->Flags & DNF_NEED_ENUMERATION_ONLY)) { 01153 01154 status = IopEnumerateDevice(deviceObject, StartContext, PnpAsyncOk); 01155 } else { 01156 status = STATUS_SUCCESS; 01157 } 01158 01159 return status; 01160 }

---

Variable Documentation

WORK_QUEUE_ITEM IopDeviceEnumerationWorkItem

Definition at line 196 of file pnpenum.c. Referenced by IopRequestDeviceAction().

BOOLEAN IopEnumerationInProgress = FALSE

Definition at line 195 of file pnpenum.c. Referenced by IopDeviceActionWorker(), and IopRequestDeviceAction().

ULONG PnpEnumDebugLevel = 0

Definition at line 168 of file pnpenum.c.

---