#include "ntdddisk.h"
#include "io_x.h"

Include dependency graph for io.h:

Classes
struct	_FILE_OBJECT_EXTENSION

struct	_IOP_MINI_COMPLETION_PACKET

struct	_IO_UNLOAD_SAFE_COMPLETION_CONTEXT

struct	_IO_WORKITEM

struct	_IO_INTERRUPT

struct	_ERROR_LOG_ENTRY

struct	_EXTENDED_IO_REMOVE_LOCK

struct	_DUMMY_FILE_OBJECT

struct	_OPEN_PACKET

struct	_DRIVER_INFORMATION

struct	_IO_BUS_TYPE_GUID_LIST

struct	_SHUTDOWN_ENTRY

struct	_FS_CHANGE_NOTIFY_ENTRY

struct	_DRIVER_REINIT_ITEM

struct	_DEVICETREE_TRAVERSE_CONTEXT

struct	_RESERVE_IRP_ALLOCATOR

Macros
#define	_IO_DEBUG_ 0x00

#define	IO_IRP_DEBUG 0x01

#define	IO_FILE_DEBUG 0x02

#define	IO_API_DEBUG 0x04

#define	IO_CTL_DEBUG 0x08

#define	IOTRACE(x, fmt, ...) DPRINT(fmt, ##__VA_ARGS__)

#define	ENUM_ROOT L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum"

#define	IO_METHOD_FROM_CTL_CODE(c) (c & 0x00000003)

#define	RD_NO_XIPROM_DESCRIPTOR 1

#define	RD_NO_RAMDISK_DRIVER 2

#define	RD_FSCTL_FAILED 3

#define	RD_GUID_CONVERT_FAILED 4

#define	RD_SYMLINK_CREATE_FAILED 5

#define	RD_SYSROOT_INIT_FAILED 6

#define	IOP_MAX_REPARSE_TRAVERSAL 0x20

#define	IOP_USE_TOP_LEVEL_DEVICE_HINT 0x01

#define	IOP_CREATE_FILE_OBJECT_EXTENSION 0x02

#define	IopAllocateMdlFromLookaside ObpAllocateObjectCreateInfoBuffer

#define	IopFreeMdlFromLookaside ObpFreeCapturedAttributes

#define	IsIrpSynchronous(Irp, FileObject)

#define	IoGetDevObjExtension(DeviceObject)

#define	IoGetDrvObjExtension(DriverObject)

#define	IopDeviceNodeSetFlag(DeviceNode, Flag) ((DeviceNode)->Flags \|= (Flag))

#define	IopDeviceNodeClearFlag(DeviceNode, Flag) ((DeviceNode)->Flags &= ~(Flag))

#define	IopDeviceNodeHasFlag(DeviceNode, Flag) (((DeviceNode)->Flags & (Flag)) > 0)

#define	IopDeviceNodeSetUserFlag(DeviceNode, UserFlag) ((DeviceNode)->UserFlags \|= (UserFlag))

#define	IopDeviceNodeClearUserFlag(DeviceNode, UserFlag) ((DeviceNode)->UserFlags &= ~(UserFlag))

#define	IopDeviceNodeHasUserFlag(DeviceNode, UserFlag) (((DeviceNode)->UserFlags & (UserFlag)) > 0)

#define	IopDeviceNodeSetProblem(DeviceNode, Problem) ((DeviceNode)->Problem \|= (Problem))

#define	IopDeviceNodeClearProblem(DeviceNode, Problem) ((DeviceNode)->Problem &= ~(Problem))

#define	IopDeviceNodeHasProblem(DeviceNode, Problem) (((DeviceNode)->Problem & (Problem)) > 0)

#define	IopInitDeviceTreeTraverseContext( _DeviceTreeTraverseContext, _DeviceNode, _Action, _Context)

#define	IopIsValidPhysicalDeviceObject(PhysicalDeviceObject)

Typedefs
typedef struct _FILE_OBJECT_EXTENSION	FILE_OBJECT_EXTENSION

typedef struct _FILE_OBJECT_EXTENSION *	PFILE_OBJECT_EXTENSION

typedef enum _IOP_DEVICE_LIST_OPERATION	IOP_DEVICE_LIST_OPERATION

typedef enum _IOP_DEVICE_LIST_OPERATION *	PIOP_DEVICE_LIST_OPERATION

typedef enum _IOP_TRANSFER_TYPE	IOP_TRANSFER_TYPE

typedef enum _IOP_TRANSFER_TYPE *	PIOP_TRANSFER_TYPE

typedef enum _COMPLETION_PACKET_TYPE	COMPLETION_PACKET_TYPE

typedef enum _COMPLETION_PACKET_TYPE *	PCOMPLETION_PACKET_TYPE

typedef struct _IOP_MINI_COMPLETION_PACKET	IOP_MINI_COMPLETION_PACKET

typedef struct _IOP_MINI_COMPLETION_PACKET *	PIOP_MINI_COMPLETION_PACKET

typedef struct _IO_UNLOAD_SAFE_COMPLETION_CONTEXT	IO_UNLOAD_SAFE_COMPLETION_CONTEXT

typedef struct _IO_UNLOAD_SAFE_COMPLETION_CONTEXT *	PIO_UNLOAD_SAFE_COMPLETION_CONTEXT

typedef struct _IO_WORKITEM	IO_WORKITEM

typedef struct _IO_INTERRUPT	IO_INTERRUPT

typedef struct _IO_INTERRUPT *	PIO_INTERRUPT

typedef struct _ERROR_LOG_ENTRY	ERROR_LOG_ENTRY

typedef struct _ERROR_LOG_ENTRY *	PERROR_LOG_ENTRY

typedef struct _EXTENDED_IO_REMOVE_LOCK	EXTENDED_IO_REMOVE_LOCK

typedef struct _EXTENDED_IO_REMOVE_LOCK *	PEXTENDED_IO_REMOVE_LOCK

typedef struct _DUMMY_FILE_OBJECT	DUMMY_FILE_OBJECT

typedef struct _DUMMY_FILE_OBJECT *	PDUMMY_FILE_OBJECT

typedef struct _OPEN_PACKET	OPEN_PACKET

typedef struct _OPEN_PACKET *	POPEN_PACKET

typedef struct _DRIVER_INFORMATION	DRIVER_INFORMATION

typedef struct _DRIVER_INFORMATION *	PDRIVER_INFORMATION

typedef struct _IO_BUS_TYPE_GUID_LIST	IO_BUS_TYPE_GUID_LIST

typedef struct _IO_BUS_TYPE_GUID_LIST *	PIO_BUS_TYPE_GUID_LIST

typedef struct _SHUTDOWN_ENTRY	SHUTDOWN_ENTRY

typedef struct _SHUTDOWN_ENTRY *	PSHUTDOWN_ENTRY

typedef struct _FS_CHANGE_NOTIFY_ENTRY	FS_CHANGE_NOTIFY_ENTRY

typedef struct _FS_CHANGE_NOTIFY_ENTRY *	PFS_CHANGE_NOTIFY_ENTRY

typedef struct _DRIVER_REINIT_ITEM	DRIVER_REINIT_ITEM

typedef struct _DRIVER_REINIT_ITEM *	PDRIVER_REINIT_ITEM

typedef NTSTATUS(*	DEVICETREE_TRAVERSE_ROUTINE) (IN PDEVICE_NODE DeviceNode, IN PVOID Context)

typedef struct _DEVICETREE_TRAVERSE_CONTEXT	DEVICETREE_TRAVERSE_CONTEXT

typedef struct _DEVICETREE_TRAVERSE_CONTEXT *	PDEVICETREE_TRAVERSE_CONTEXT

typedef struct _RESERVE_IRP_ALLOCATOR	RESERVE_IRP_ALLOCATOR

typedef struct _RESERVE_IRP_ALLOCATOR *	PRESERVE_IRP_ALLOCATOR

typedef enum _SECURITY_DESCRIPTOR_TYPE	SECURITY_DESCRIPTOR_TYPE

typedef enum _SECURITY_DESCRIPTOR_TYPE *	PSECURITY_DESCRIPTOR_TYPE

typedef enum _DEVICE_ACTION	DEVICE_ACTION

Enumerations
enum	_IOP_DEVICE_LIST_OPERATION { IopRemove , IopAdd }

enum	_IOP_TRANSFER_TYPE { IopReadTransfer , IopWriteTransfer , IopOtherTransfer }

enum	_COMPLETION_PACKET_TYPE { IopCompletionPacketIrp , IopCompletionPacketMini , IopCompletionPacketQuota }

enum	_SECURITY_DESCRIPTOR_TYPE { RestrictedPublic = 1 , UnrestrictedPublic , RestrictedPublicOpen , UnrestrictedPublicOpen , SystemDefault }

enum	_DEVICE_ACTION { PiActionEnumDeviceTree , PiActionEnumRootDevices , PiActionResetDevice , PiActionAddBootDevices , PiActionStartDevice , PiActionQueryState }

Functions
ULONG NTAPI	PnpDetermineResourceListSize (IN PCM_RESOURCE_LIST ResourceList)

NTSTATUS NTAPI	IopAssignDeviceResources (IN PDEVICE_NODE DeviceNode)

NTSTATUS NTAPI	IopFixupResourceListWithRequirements (IN PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList, OUT PCM_RESOURCE_LIST *ResourceList)

NTSTATUS NTAPI	IopDetectResourceConflict (IN PCM_RESOURCE_LIST ResourceList, IN BOOLEAN Silent, OUT OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDescriptor)

NTSTATUS NTAPI	PipCallDriverAddDevice (IN PDEVICE_NODE DeviceNode, IN BOOLEAN LoadDriver, IN PDRIVER_OBJECT DriverObject)

NTSTATUS NTAPI	IopInitializePlugPlayServices (VOID)

BOOLEAN NTAPI	PpInitSystem (VOID)

VOID	PnpInit2 (VOID)

VOID	IopInitDriverImplementation (VOID)

NTSTATUS	IopGetSystemPowerDeviceObject (IN PDEVICE_OBJECT *DeviceObject)

PDEVICE_NODE	PipAllocateDeviceNode (IN PDEVICE_OBJECT PhysicalDeviceObject)

VOID	PiInsertDevNode (_In_ PDEVICE_NODE DeviceNode, _In_ PDEVICE_NODE ParentNode)

PNP_DEVNODE_STATE	PiSetDevNodeState (_In_ PDEVICE_NODE DeviceNode, _In_ PNP_DEVNODE_STATE NewState)

VOID	PiSetDevNodeProblem (_In_ PDEVICE_NODE DeviceNode, _In_ UINT32 Problem)

VOID	PiClearDevNodeProblem (_In_ PDEVICE_NODE DeviceNode)

NTSTATUS	IopFreeDeviceNode (IN PDEVICE_NODE DeviceNode)

NTSTATUS NTAPI	IopQueryDeviceCapabilities (PDEVICE_NODE DeviceNode, PDEVICE_CAPABILITIES DeviceCaps)

NTSTATUS	IopSynchronousCall (IN PDEVICE_OBJECT DeviceObject, IN PIO_STACK_LOCATION IoStackLocation, OUT PVOID *Information)

NTSTATUS NTAPI	IopInitiatePnpIrp (IN PDEVICE_OBJECT DeviceObject, IN PIO_STATUS_BLOCK IoStatusBlock, IN UCHAR MinorFunction, IN PIO_STACK_LOCATION Stack)

PDEVICE_NODE FASTCALL	IopGetDeviceNode (IN PDEVICE_OBJECT DeviceObject)

NTSTATUS	IoCreateDriverList (VOID)

NTSTATUS	IoDestroyDriverList (VOID)

NTSTATUS	IopInitPlugPlayEvents (VOID)

NTSTATUS	IopQueueDeviceChangeEvent (_In_ const GUID EventGuid, _In_ const GUID InterfaceClassGuid, _In_ PUNICODE_STRING SymbolicLinkName)

NTSTATUS	IopQueueTargetDeviceEvent (_In_ const GUID *Guid, _In_ PUNICODE_STRING DeviceIds)

NTSTATUS	IopQueueDeviceInstallEvent (_In_ const GUID *Guid, _In_ PUNICODE_STRING DeviceId)

NTSTATUS NTAPI	IopOpenRegistryKeyEx (PHANDLE KeyHandle, HANDLE ParentKey, PUNICODE_STRING Name, ACCESS_MASK DesiredAccess)

NTSTATUS NTAPI	IopGetRegistryValue (IN HANDLE Handle, IN PWSTR ValueName, OUT PKEY_VALUE_FULL_INFORMATION *Information)

NTSTATUS NTAPI	IopCreateRegistryKeyEx (OUT PHANDLE Handle, IN HANDLE BaseHandle OPTIONAL, IN PUNICODE_STRING KeyName, IN ACCESS_MASK DesiredAccess, IN ULONG CreateOptions, OUT PULONG Disposition OPTIONAL)

NTSTATUS	IopTraverseDeviceTree (PDEVICETREE_TRAVERSE_CONTEXT Context)

NTSTATUS NTAPI	IopCreateDeviceKeyPath (IN PCUNICODE_STRING RegistryPath, IN ULONG CreateOptions, OUT PHANDLE Handle)

NTSTATUS NTAPI	IopUpdateRootKey (VOID)

NTSTATUS NTAPI	PiInitCacheGroupInformation (VOID)

USHORT NTAPI	PpInitGetGroupOrderIndex (IN HANDLE ServiceHandle)

USHORT NTAPI	PipGetDriverTagPriority (IN HANDLE ServiceHandle)

NTSTATUS NTAPI	PnpRegMultiSzToUnicodeStrings (IN PKEY_VALUE_FULL_INFORMATION KeyValueInformation, OUT PUNICODE_STRING *UnicodeStringList, OUT PULONG UnicodeStringCount)

BOOLEAN NTAPI	PnpRegSzToString (IN PWCHAR RegSzData, IN ULONG RegSzLength, OUT PUSHORT StringLength OPTIONAL)

VOID	PiSetDevNodeText (_In_ PDEVICE_NODE DeviceNode, _In_ HANDLE InstanceKey)
	Sets the DeviceNode's DeviceDesc and LocationInformation registry values.

NTSTATUS NTAPI	IopCreateArcNames (IN PLOADER_PARAMETER_BLOCK LoaderBlock)

NTSTATUS NTAPI	IopReassignSystemRoot (IN PLOADER_PARAMETER_BLOCK LoaderBlock, OUT PANSI_STRING NtBootPath)

BOOLEAN NTAPI	IoInitSystem (IN PLOADER_PARAMETER_BLOCK LoaderBlock)

BOOLEAN	IopVerifyDiskSignature (_In_ PDRIVE_LAYOUT_INFORMATION_EX DriveLayout, _In_ PARC_DISK_SIGNATURE ArcDiskSignature, _Out_ PULONG Signature)

BOOLEAN NTAPI	IoInitializeCrashDump (IN HANDLE PageFileHandle)

VOID	PiInitializeNotifications (VOID)

VOID NTAPI	IopReadyDeviceObjects (IN PDRIVER_OBJECT Driver)

PVPB NTAPI	IopCheckVpbMounted (IN POPEN_PACKET OpenPacket, IN PDEVICE_OBJECT DeviceObject, IN PUNICODE_STRING RemainingName, OUT PNTSTATUS Status)

NTSTATUS NTAPI	IopMountVolume (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN AllowRawMount, IN BOOLEAN DeviceIsLocked, IN BOOLEAN Alertable, OUT PVPB *Vpb)

PVOID	IoOpenSymlink (IN PVOID SymbolicLink)

PVOID	IoOpenFileOnDevice (IN PVOID SymbolicLink, IN PWCHAR Name)

NTSTATUS NTAPI	IopCreateVpb (IN PDEVICE_OBJECT DeviceObject)

VOID NTAPI	IopDereferenceVpbAndFree (IN PVPB Vpb)

VOID NTAPI	IoInitFileSystemImplementation (VOID)

VOID NTAPI	IoInitVpbImplementation (VOID)

NTSTATUS NTAPI	IopReferenceDeviceObject (IN PDEVICE_OBJECT DeviceObject)

VOID NTAPI	IopDereferenceDeviceObject (IN PDEVICE_OBJECT DeviceObject, IN BOOLEAN ForceUnload)

NTSTATUS NTAPI	IopGetRelatedTargetDevice (IN PFILE_OBJECT FileObject, OUT PDEVICE_NODE *DeviceNode)

NTSTATUS NTAPI	IoGetRelatedTargetDevice (IN PFILE_OBJECT FileObject, OUT PDEVICE_OBJECT *DeviceObject)

VOID NTAPI	IopUnloadDevice (IN PDEVICE_OBJECT DeviceObject)

PDEVICE_OBJECT NTAPI	IopGetDeviceAttachmentBase (IN PDEVICE_OBJECT DeviceObject)

NTSTATUS NTAPI	IopCleanupFailedIrp (IN PFILE_OBJECT FileObject, IN PKEVENT EventObject, IN PVOID Buffer OPTIONAL)

VOID NTAPI	IopAbortInterruptedIrp (IN PKEVENT EventObject, IN PIRP Irp)

PIRP NTAPI	IopAllocateIrpMustSucceed (IN CCHAR StackSize)

BOOLEAN NTAPI	IopInitializeReserveIrp (IN PRESERVE_IRP_ALLOCATOR ReserveIrpAllocator)

PIRP NTAPI	IopAllocateReserveIrp (IN CCHAR StackSize)

VOID	IoInitShutdownNotification (VOID)

VOID NTAPI	IoShutdownSystem (IN ULONG Phase)

VOID NTAPI	IopShutdownBaseFileSystems (IN PLIST_ENTRY ListHead)

VOID	IopInitBootLog (IN BOOLEAN StartBootLog)

VOID	IopStartBootLog (VOID)

VOID	IopStopBootLog (VOID)

VOID	IopBootLog (IN PUNICODE_STRING DriverName, IN BOOLEAN Success)

VOID	IopSaveBootLogToFile (VOID)

VOID NTAPI	IoCancelThreadIo (IN PETHREAD Thread)

VOID	IoInitCancelHandling (VOID)

VOID NTAPI	IopCompleteRequest (IN PKAPC Apc, IN PKNORMAL_ROUTINE NormalRoutine, IN PVOID NormalContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)

VOID NTAPI	IopInitErrorLog (VOID)

VOID NTAPI	IopLogWorker (IN PVOID Parameter)

BOOLEAN	RawFsIsRawFileSystemDeviceObject (IN PDEVICE_OBJECT DeviceObject)

NTSTATUS NTAPI	RawFsDriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)

NTSTATUS NTAPI	PnpRootDriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)

NTSTATUS	PnpRootCreateDeviceObject (OUT PDEVICE_OBJECT *DeviceObject)

NTSTATUS	PnpRootCreateDevice (IN PUNICODE_STRING ServiceName, OUT PDEVICE_OBJECT *PhysicalDeviceObject, OUT PUNICODE_STRING FullInstancePath)

NTSTATUS	PnpRootRegisterDevice (IN PDEVICE_OBJECT DeviceObject)

VOID	PnpRootInitializeDevExtension (VOID)

VOID FASTCALL	IopInitializeBootDrivers (VOID)

VOID FASTCALL	IopInitializeSystemDrivers (VOID)

VOID NTAPI	IopDeleteDriver (IN PVOID ObjectBody)

NTSTATUS	IopLoadDriver (_In_ HANDLE ServiceHandle, _Out_ PDRIVER_OBJECT *DriverObject)

NTSTATUS	IopGetDriverNames (_In_ HANDLE ServiceHandle, _Out_ PUNICODE_STRING DriverName, _Out_opt_ PUNICODE_STRING ServiceName)

NTSTATUS	IopInitializeDriverModule (_In_ PLDR_DATA_TABLE_ENTRY ModuleObject, _In_ HANDLE ServiceHandle, _Out_ PDRIVER_OBJECT DriverObject, _Out_ NTSTATUS DriverEntryStatus)
	Initialize a loaded driver.

NTSTATUS FASTCALL	IopAttachFilterDrivers (IN PDEVICE_NODE DeviceNode, IN HANDLE EnumSubKey, IN HANDLE ClassKey, IN BOOLEAN Lower)

VOID NTAPI	IopReinitializeDrivers (VOID)

VOID NTAPI	IopReinitializeBootDrivers (VOID)

VOID NTAPI	IopDeleteDevice (IN PVOID ObjectBody)

NTSTATUS NTAPI	IopParseDevice (IN PVOID ParseObject, IN PVOID ObjectType, IN OUT PACCESS_STATE AccessState, IN KPROCESSOR_MODE AccessMode, IN ULONG Attributes, IN OUT PUNICODE_STRING CompleteName, IN OUT PUNICODE_STRING RemainingName, IN OUT PVOID Context, IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL, OUT PVOID *Object)

NTSTATUS NTAPI	IopParseFile (IN PVOID ParseObject, IN PVOID ObjectType, IN OUT PACCESS_STATE AccessState, IN KPROCESSOR_MODE AccessMode, IN ULONG Attributes, IN OUT PUNICODE_STRING CompleteName, IN OUT PUNICODE_STRING RemainingName, IN OUT PVOID Context OPTIONAL, IN PSECURITY_QUALITY_OF_SERVICE SecurityQos OPTIONAL, OUT PVOID *Object)

VOID NTAPI	IopDeleteFile (IN PVOID ObjectBody)

NTSTATUS NTAPI	IopGetSetSecurityObject (IN PVOID ObjectBody, IN SECURITY_OPERATION_CODE OperationCode, IN PSECURITY_INFORMATION SecurityInformation, IN OUT PSECURITY_DESCRIPTOR SecurityDescriptor, IN OUT PULONG BufferLength, OUT PSECURITY_DESCRIPTOR *OldSecurityDescriptor, IN POOL_TYPE PoolType, IN OUT PGENERIC_MAPPING GenericMapping)

NTSTATUS NTAPI	IopQueryName (IN PVOID ObjectBody, IN BOOLEAN HasName, OUT POBJECT_NAME_INFORMATION ObjectNameInfo, IN ULONG Length, OUT PULONG ReturnLength, IN KPROCESSOR_MODE PreviousMode)

NTSTATUS NTAPI	IopQueryNameInternal (IN PVOID ObjectBody, IN BOOLEAN HasName, IN BOOLEAN QueryDosName, OUT POBJECT_NAME_INFORMATION ObjectNameInfo, IN ULONG Length, OUT PULONG ReturnLength, IN KPROCESSOR_MODE PreviousMode)

VOID NTAPI	IopCloseFile (IN PEPROCESS Process OPTIONAL, IN PVOID Object, IN ACCESS_MASK GrantedAccess, IN ULONG ProcessHandleCount, IN ULONG SystemHandleCount)

NTSTATUS NTAPI	IopAcquireFileObjectLock (_In_ PFILE_OBJECT FileObject, _In_ KPROCESSOR_MODE AccessMode, _In_ BOOLEAN Alertable, _Out_ PBOOLEAN LockFailed)

PVOID NTAPI	IoGetFileObjectFilterContext (IN PFILE_OBJECT FileObject)

NTSTATUS NTAPI	IoChangeFileObjectFilterContext (IN PFILE_OBJECT FileObject, IN PVOID FilterContext, IN BOOLEAN Define)

VOID NTAPI	IopDoNameTransmogrify (IN PIRP Irp, IN PFILE_OBJECT FileObject, IN PREPARSE_DATA_BUFFER DataBuffer)

NTSTATUS NTAPI	IoComputeDesiredAccessFileObject (IN PFILE_OBJECT FileObject, IN PACCESS_MASK DesiredAccess)

NTSTATUS NTAPI	IopGetFileInformation (IN PFILE_OBJECT FileObject, IN ULONG Length, IN FILE_INFORMATION_CLASS FileInfoClass, OUT PVOID Buffer, OUT PULONG ReturnedLength)

BOOLEAN NTAPI	IopVerifyDeviceObjectOnStack (IN PDEVICE_OBJECT BaseDeviceObject, IN PDEVICE_OBJECT TopDeviceObjectHint)

VOID FASTCALL	IopInitTimerImplementation (VOID)

VOID NTAPI	IopRemoveTimerFromTimerList (IN PIO_TIMER Timer)

VOID NTAPI	IopDeleteIoCompletion (PVOID ObjectBody)

NTSTATUS NTAPI	IoSetIoCompletion (IN PVOID IoCompletion, IN PVOID KeyContext, IN PVOID ApcContext, IN NTSTATUS IoStatus, IN ULONG_PTR IoStatusInformation, IN BOOLEAN Quota)

NTSTATUS NTAPI	IopStartRamdisk (IN PLOADER_PARAMETER_BLOCK LoaderBlock)

NTSTATUS	IopFetchConfigurationInformation (_Out_ PWSTR *SymbolicLinkList, _In_ GUID Guid, _In_ ULONG ExpectedInterfaces, _Out_ PULONG Interfaces)

VOID	IopStoreSystemPartitionInformation (_In_ PUNICODE_STRING NtSystemPartitionDeviceName, _In_ PUNICODE_STRING OsLoaderPathName)

VOID	PiQueueDeviceAction (_In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_ACTION Action, _In_opt_ PKEVENT CompletionEvent, _Out_opt_ NTSTATUS *CompletionStatus)
	Queue a device operation to a worker thread.

NTSTATUS	PiPerformSyncDeviceAction (_In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_ACTION Action)
	Perfom a device operation synchronously via PiQueueDeviceAction.

VOID	PiNotifyDeviceInterfaceChange (_In_ LPCGUID Event, _In_ LPCGUID InterfaceClassGuid, _In_ PUNICODE_STRING SymbolicLinkName)
	Delivers the event to all drivers subscribed to EventCategoryDeviceInterfaceChange.

VOID	PiNotifyHardwareProfileChange (_In_ LPCGUID Event)
	Delivers the event to all drivers subscribed to EventCategoryHardwareProfileChange PnP event.

VOID	PiNotifyTargetDeviceChange (_In_ LPCGUID Event, _In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PTARGET_DEVICE_CUSTOM_NOTIFICATION CustomNotification)
	Delivers the event to all drivers subscribed to EventCategoryTargetDeviceChange PnP event.

NTSTATUS	PiIrpStartDevice (_In_ PDEVICE_NODE DeviceNode)

NTSTATUS	PiIrpStopDevice (_In_ PDEVICE_NODE DeviceNode)

NTSTATUS	PiIrpQueryStopDevice (_In_ PDEVICE_NODE DeviceNode)

NTSTATUS	PiIrpCancelStopDevice (_In_ PDEVICE_NODE DeviceNode)

NTSTATUS	PiIrpQueryDeviceRelations (_In_ PDEVICE_NODE DeviceNode, _In_ DEVICE_RELATION_TYPE Type)

NTSTATUS	PiIrpQueryResources (_In_ PDEVICE_NODE DeviceNode, _Out_ PCM_RESOURCE_LIST *Resources)

NTSTATUS	PiIrpQueryResourceRequirements (_In_ PDEVICE_NODE DeviceNode, _Out_ PIO_RESOURCE_REQUIREMENTS_LIST *Resources)

NTSTATUS	PiIrpQueryDeviceText (_In_ PDEVICE_NODE DeviceNode, _In_ LCID LocaleId, _In_ DEVICE_TEXT_TYPE Type, _Out_ PWSTR *DeviceText)

NTSTATUS	PiIrpQueryPnPDeviceState (_In_ PDEVICE_NODE DeviceNode, _Out_ PPNP_DEVICE_STATE DeviceState)

Macro Definition Documentation

◆ _IO_DEBUG_

#define _IO_DEBUG_ 0x00

Definition at line 14 of file io.h.

◆ ENUM_ROOT

#define ENUM_ROOT L"\\Registry\\Machine\\System\\CurrentControlSet\\Enum"

Definition at line 53 of file io.h.

◆ IO_API_DEBUG

#define IO_API_DEBUG 0x04

Definition at line 21 of file io.h.

◆ IO_CTL_DEBUG

#define IO_CTL_DEBUG 0x08

Definition at line 22 of file io.h.

◆ IO_FILE_DEBUG

#define IO_FILE_DEBUG 0x02

Definition at line 20 of file io.h.

◆ IO_IRP_DEBUG

#define IO_IRP_DEBUG 0x01

Definition at line 19 of file io.h.

◆ IO_METHOD_FROM_CTL_CODE

#define IO_METHOD_FROM_CTL_CODE ( c ) (c & 0x00000003)

Definition at line 58 of file io.h.

◆ IoGetDevObjExtension

#define IoGetDevObjExtension ( DeviceObject )

Value:

((PEXTENDED_DEVOBJ_EXTENSION) \

(DeviceObject->DeviceObjectExtension)) \

PEXTENDED_DEVOBJ_EXTENSION

struct _EXTENDED_DEVOBJ_EXTENSION * PEXTENDED_DEVOBJ_EXTENSION

DeviceObject

_In_ PDEVICE_OBJECT DeviceObject

Definition: wdfdevice.h:2055

Definition at line 129 of file io.h.

◆ IoGetDrvObjExtension

#define IoGetDrvObjExtension ( DriverObject )

Value:

((PEXTENDED_DRIVER_EXTENSION) \

(DriverObject->DriverExtension)) \

PEXTENDED_DRIVER_EXTENSION

struct _EXTENDED_DRIVER_EXTENSION * PEXTENDED_DRIVER_EXTENSION

DriverObject

_Must_inspect_result_ _In_ PDRIVER_OBJECT DriverObject

Definition: wdfdriver.h:213

Definition at line 136 of file io.h.

◆ IOP_CREATE_FILE_OBJECT_EXTENSION

#define IOP_CREATE_FILE_OBJECT_EXTENSION 0x02

Definition at line 97 of file io.h.

◆ IOP_MAX_REPARSE_TRAVERSAL

#define IOP_MAX_REPARSE_TRAVERSAL 0x20

Definition at line 91 of file io.h.

◆ IOP_USE_TOP_LEVEL_DEVICE_HINT

#define IOP_USE_TOP_LEVEL_DEVICE_HINT 0x01

Definition at line 96 of file io.h.

◆ IopAllocateMdlFromLookaside

#define IopAllocateMdlFromLookaside ObpAllocateObjectCreateInfoBuffer

Definition at line 112 of file io.h.

◆ IopDeviceNodeClearFlag

#define IopDeviceNodeClearFlag	(	DeviceNode,
		Flag
	)	((DeviceNode)->Flags &= ~(Flag))

Definition at line 155 of file io.h.

◆ IopDeviceNodeClearProblem

#define IopDeviceNodeClearProblem	(	DeviceNode,
		Problem
	)	((DeviceNode)->Problem &= ~(Problem))

Definition at line 209 of file io.h.

◆ IopDeviceNodeClearUserFlag

#define IopDeviceNodeClearUserFlag	(	DeviceNode,
		UserFlag
	)	((DeviceNode)->UserFlags &= ~(UserFlag))

Definition at line 182 of file io.h.

◆ IopDeviceNodeHasFlag

#define IopDeviceNodeHasFlag	(	DeviceNode,
		Flag
	)	(((DeviceNode)->Flags & (Flag)) > 0)

Definition at line 164 of file io.h.

◆ IopDeviceNodeHasProblem

#define IopDeviceNodeHasProblem	(	DeviceNode,
		Problem
	)	(((DeviceNode)->Problem & (Problem)) > 0)

Definition at line 218 of file io.h.

◆ IopDeviceNodeHasUserFlag

#define IopDeviceNodeHasUserFlag	(	DeviceNode,
		UserFlag
	)	(((DeviceNode)->UserFlags & (UserFlag)) > 0)

Definition at line 191 of file io.h.

◆ IopDeviceNodeSetFlag

#define IopDeviceNodeSetFlag	(	DeviceNode,
		Flag
	)	((DeviceNode)->Flags \|= (Flag))

Definition at line 146 of file io.h.

◆ IopDeviceNodeSetProblem

#define IopDeviceNodeSetProblem	(	DeviceNode,
		Problem
	)	((DeviceNode)->Problem \|= (Problem))

Definition at line 200 of file io.h.

◆ IopDeviceNodeSetUserFlag

#define IopDeviceNodeSetUserFlag	(	DeviceNode,
		UserFlag
	)	((DeviceNode)->UserFlags \|= (UserFlag))

Definition at line 173 of file io.h.

◆ IopFreeMdlFromLookaside

#define IopFreeMdlFromLookaside ObpFreeCapturedAttributes

Definition at line 114 of file io.h.

◆ IopInitDeviceTreeTraverseContext

#define IopInitDeviceTreeTraverseContext	(	_DeviceTreeTraverseContext,
		_DeviceNode,
		_Action,
		_Context
	)

Value:

    {                                         \
    (_DeviceTreeTraverseContext)->FirstDeviceNode =     \
        (_DeviceNode);                                  \
    (_DeviceTreeTraverseContext)->Action = (_Action);   \
    (_DeviceTreeTraverseContext)->Context = (_Context); }

Definition at line 229 of file io.h.

◆ IopIsValidPhysicalDeviceObject

#define IopIsValidPhysicalDeviceObject ( PhysicalDeviceObject )

Value:

        (((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject) &&                                                          \
        (((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode) &&                      \
        (((PEXTENDED_DEVOBJ_EXTENSION)PhysicalDeviceObject->DeviceObjectExtension)->DeviceNode->Flags & DNF_ENUMERATED))

Definition at line 242 of file io.h.

◆ IOTRACE

#define IOTRACE	(	x,
		fmt,
		...
	)	DPRINT(fmt, ##__VA_ARGS__)

Definition at line 47 of file io.h.

◆ IsIrpSynchronous

#define IsIrpSynchronous	(	Irp,
		FileObject
	)

Value:

    ((Irp->Flags & IRP_SYNCHRONOUS_API)  ||             \
     (!(FileObject) ?                                   \
        FALSE :                                         \
        FileObject->Flags & FO_SYNCHRONOUS_IO))         \

Definition at line 120 of file io.h.

◆ RD_FSCTL_FAILED

#define RD_FSCTL_FAILED 3

Definition at line 74 of file io.h.

◆ RD_GUID_CONVERT_FAILED

#define RD_GUID_CONVERT_FAILED 4

Definition at line 78 of file io.h.

◆ RD_NO_RAMDISK_DRIVER

#define RD_NO_RAMDISK_DRIVER 2

Definition at line 70 of file io.h.

◆ RD_NO_XIPROM_DESCRIPTOR

#define RD_NO_XIPROM_DESCRIPTOR 1

Definition at line 66 of file io.h.

◆ RD_SYMLINK_CREATE_FAILED

#define RD_SYMLINK_CREATE_FAILED 5

Definition at line 82 of file io.h.

◆ RD_SYSROOT_INIT_FAILED

#define RD_SYSROOT_INIT_FAILED 6

Definition at line 86 of file io.h.

Typedef Documentation

◆ COMPLETION_PACKET_TYPE

typedef enum _COMPLETION_PACKET_TYPE COMPLETION_PACKET_TYPE

◆ DEVICE_ACTION

typedef enum _DEVICE_ACTION DEVICE_ACTION

◆ DEVICETREE_TRAVERSE_CONTEXT

typedef struct _DEVICETREE_TRAVERSE_CONTEXT DEVICETREE_TRAVERSE_CONTEXT

◆ DEVICETREE_TRAVERSE_ROUTINE

typedef NTSTATUS(* DEVICETREE_TRAVERSE_ROUTINE) (IN PDEVICE_NODE DeviceNode, IN PVOID Context)

Definition at line 465 of file io.h.

◆ DRIVER_INFORMATION

typedef struct _DRIVER_INFORMATION DRIVER_INFORMATION

◆ DRIVER_REINIT_ITEM

typedef struct _DRIVER_REINIT_ITEM DRIVER_REINIT_ITEM

◆ DUMMY_FILE_OBJECT

typedef struct _DUMMY_FILE_OBJECT DUMMY_FILE_OBJECT

◆ ERROR_LOG_ENTRY

typedef struct _ERROR_LOG_ENTRY ERROR_LOG_ENTRY

◆ EXTENDED_IO_REMOVE_LOCK

typedef struct _EXTENDED_IO_REMOVE_LOCK EXTENDED_IO_REMOVE_LOCK

◆ FILE_OBJECT_EXTENSION

typedef struct _FILE_OBJECT_EXTENSION FILE_OBJECT_EXTENSION

◆ FS_CHANGE_NOTIFY_ENTRY

typedef struct _FS_CHANGE_NOTIFY_ENTRY FS_CHANGE_NOTIFY_ENTRY

◆ IO_BUS_TYPE_GUID_LIST

typedef struct _IO_BUS_TYPE_GUID_LIST IO_BUS_TYPE_GUID_LIST

◆ IO_INTERRUPT

typedef struct _IO_INTERRUPT IO_INTERRUPT

◆ IO_UNLOAD_SAFE_COMPLETION_CONTEXT

typedef struct _IO_UNLOAD_SAFE_COMPLETION_CONTEXT IO_UNLOAD_SAFE_COMPLETION_CONTEXT

◆ IO_WORKITEM

typedef struct _IO_WORKITEM IO_WORKITEM

◆ IOP_DEVICE_LIST_OPERATION

typedef enum _IOP_DEVICE_LIST_OPERATION IOP_DEVICE_LIST_OPERATION

◆ IOP_MINI_COMPLETION_PACKET

typedef struct _IOP_MINI_COMPLETION_PACKET IOP_MINI_COMPLETION_PACKET

◆ IOP_TRANSFER_TYPE

typedef enum _IOP_TRANSFER_TYPE IOP_TRANSFER_TYPE

◆ OPEN_PACKET

typedef struct _OPEN_PACKET OPEN_PACKET

◆ PCOMPLETION_PACKET_TYPE

typedef enum _COMPLETION_PACKET_TYPE * PCOMPLETION_PACKET_TYPE

◆ PDEVICETREE_TRAVERSE_CONTEXT

typedef struct _DEVICETREE_TRAVERSE_CONTEXT * PDEVICETREE_TRAVERSE_CONTEXT

◆ PDRIVER_INFORMATION

typedef struct _DRIVER_INFORMATION * PDRIVER_INFORMATION

◆ PDRIVER_REINIT_ITEM

typedef struct _DRIVER_REINIT_ITEM * PDRIVER_REINIT_ITEM

◆ PDUMMY_FILE_OBJECT

typedef struct _DUMMY_FILE_OBJECT * PDUMMY_FILE_OBJECT

◆ PERROR_LOG_ENTRY

typedef struct _ERROR_LOG_ENTRY * PERROR_LOG_ENTRY

◆ PEXTENDED_IO_REMOVE_LOCK

typedef struct _EXTENDED_IO_REMOVE_LOCK * PEXTENDED_IO_REMOVE_LOCK

◆ PFILE_OBJECT_EXTENSION

typedef struct _FILE_OBJECT_EXTENSION * PFILE_OBJECT_EXTENSION

◆ PFS_CHANGE_NOTIFY_ENTRY

typedef struct _FS_CHANGE_NOTIFY_ENTRY * PFS_CHANGE_NOTIFY_ENTRY

◆ PIO_BUS_TYPE_GUID_LIST

typedef struct _IO_BUS_TYPE_GUID_LIST * PIO_BUS_TYPE_GUID_LIST

◆ PIO_INTERRUPT

typedef struct _IO_INTERRUPT * PIO_INTERRUPT

◆ PIO_UNLOAD_SAFE_COMPLETION_CONTEXT

typedef struct _IO_UNLOAD_SAFE_COMPLETION_CONTEXT * PIO_UNLOAD_SAFE_COMPLETION_CONTEXT

◆ PIOP_DEVICE_LIST_OPERATION

typedef enum _IOP_DEVICE_LIST_OPERATION * PIOP_DEVICE_LIST_OPERATION

◆ PIOP_MINI_COMPLETION_PACKET

typedef struct _IOP_MINI_COMPLETION_PACKET * PIOP_MINI_COMPLETION_PACKET

◆ PIOP_TRANSFER_TYPE

typedef enum _IOP_TRANSFER_TYPE * PIOP_TRANSFER_TYPE

◆ POPEN_PACKET

typedef struct _OPEN_PACKET * POPEN_PACKET

◆ PRESERVE_IRP_ALLOCATOR

typedef struct _RESERVE_IRP_ALLOCATOR * PRESERVE_IRP_ALLOCATOR

◆ PSECURITY_DESCRIPTOR_TYPE

typedef enum _SECURITY_DESCRIPTOR_TYPE * PSECURITY_DESCRIPTOR_TYPE

◆ PSHUTDOWN_ENTRY

typedef struct _SHUTDOWN_ENTRY * PSHUTDOWN_ENTRY

◆ RESERVE_IRP_ALLOCATOR

typedef struct _RESERVE_IRP_ALLOCATOR RESERVE_IRP_ALLOCATOR

◆ SECURITY_DESCRIPTOR_TYPE

typedef enum _SECURITY_DESCRIPTOR_TYPE SECURITY_DESCRIPTOR_TYPE

◆ SHUTDOWN_ENTRY

typedef struct _SHUTDOWN_ENTRY SHUTDOWN_ENTRY

Enumeration Type Documentation

◆ _COMPLETION_PACKET_TYPE

enum _COMPLETION_PACKET_TYPE

Enumerator
IopCompletionPacketIrp
IopCompletionPacketMini
IopCompletionPacketQuota

Definition at line 269 of file io.h.

    {
    IopCompletionPacketIrp,
    IopCompletionPacketMini,
    IopCompletionPacketQuota
} COMPLETION_PACKET_TYPE, *PCOMPLETION_PACKET_TYPE;

◆ _DEVICE_ACTION

enum _DEVICE_ACTION

Enumerator
PiActionEnumDeviceTree
PiActionEnumRootDevices
PiActionResetDevice
PiActionAddBootDevices
PiActionStartDevice
PiActionQueryState

Definition at line 524 of file io.h.

{
    PiActionEnumDeviceTree,
    PiActionEnumRootDevices,
    PiActionResetDevice,
    PiActionAddBootDevices,
    PiActionStartDevice,
    PiActionQueryState,
} DEVICE_ACTION;

◆ _IOP_DEVICE_LIST_OPERATION

enum _IOP_DEVICE_LIST_OPERATION

Enumerator
IopRemove
IopAdd

Definition at line 250 of file io.h.

{
    IopRemove,
    IopAdd
} IOP_DEVICE_LIST_OPERATION, *PIOP_DEVICE_LIST_OPERATION;

◆ _IOP_TRANSFER_TYPE

enum _IOP_TRANSFER_TYPE

Enumerator
IopReadTransfer
IopWriteTransfer
IopOtherTransfer

Definition at line 259 of file io.h.

{
    IopReadTransfer,
    IopWriteTransfer,
    IopOtherTransfer
} IOP_TRANSFER_TYPE, *PIOP_TRANSFER_TYPE;

◆ _SECURITY_DESCRIPTOR_TYPE

enum _SECURITY_DESCRIPTOR_TYPE

Enumerator
RestrictedPublic
UnrestrictedPublic
RestrictedPublicOpen
UnrestrictedPublicOpen
SystemDefault

Definition at line 512 of file io.h.

{
    RestrictedPublic = 1,
    UnrestrictedPublic,
    RestrictedPublicOpen,
    UnrestrictedPublicOpen,
    SystemDefault,
} SECURITY_DESCRIPTOR_TYPE, *PSECURITY_DESCRIPTOR_TYPE;

Function Documentation

◆ IoCancelThreadIo()

VOID NTAPI IoCancelThreadIo ( IN PETHREAD Thread )

Definition at line 1146 of file irp.c.

{
    KIRQL OldIrql;
    ULONG Retries = 3000;
    LARGE_INTEGER Interval;
    PLIST_ENTRY ListHead, NextEntry;
    PIRP Irp;
    PAGED_CODE();
 
    /* Windows isn't using given thread, but using current. */
    Thread = PsGetCurrentThread();
 
    IOTRACE(IO_IRP_DEBUG,
            "%s - Canceling IRPs for Thread %p\n",
            __FUNCTION__,
            Thread);
 
    /* Raise to APC to protect the IrpList */
    KeRaiseIrql(APC_LEVEL, &OldIrql);
 
    /* Start by cancelling all the IRPs in the current thread queue. */
    ListHead = &Thread->IrpList;
    NextEntry = ListHead->Flink;
    while (ListHead != NextEntry)
    {
        /* Get the IRP */
        Irp = CONTAINING_RECORD(NextEntry, IRP, ThreadListEntry);
 
        /* Cancel it */
        IoCancelIrp(Irp);
 
        /* Move to the next entry */
        NextEntry = NextEntry->Flink;
    }
 
     /* Wait 100 milliseconds */
    Interval.QuadPart = -1000000;
 
    /* Wait till all the IRPs are completed or cancelled. */
    while (!IsListEmpty(&Thread->IrpList))
    {
        /* Now we can lower */
        KeLowerIrql(OldIrql);
 
        /* Wait a short while and then look if all our IRPs were completed. */
        KeDelayExecutionThread(KernelMode, FALSE, &Interval);
 
        /*
         * Don't stay here forever if some broken driver doesn't complete
         * the IRP.
         */
        if (!(Retries--))
        {
            /* Print out a message and remove the IRP */
            DPRINT1("Broken driver did not complete!\n");
            IopDisassociateThreadIrp();
        }
 
        /* Raise the IRQL Again */
        KeRaiseIrql(APC_LEVEL, &OldIrql);
    }
 
    /* We're done, lower the IRQL */
    KeLowerIrql(OldIrql);
}

Referenced by PspExitThread().

◆ IoChangeFileObjectFilterContext()

NTSTATUS NTAPI IoChangeFileObjectFilterContext	(	IN PFILE_OBJECT	FileObject,
		IN PVOID	FilterContext,
		IN BOOLEAN	Define
	)

Definition at line 2512 of file file.c.

{
    ULONG_PTR Success;
    PFILE_OBJECT_EXTENSION FileObjectExtension;
 
    if (!BooleanFlagOn(FileObject->Flags, FO_FILE_OBJECT_HAS_EXTENSION))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    FileObjectExtension = FileObject->FileObjectExtension;
    if (Define)
    {
        /* If define, just set the new value if not value is set
         * Success will only contain old value. It is valid if it is NULL
         */
        Success = (ULONG_PTR)InterlockedCompareExchangePointer(&FileObjectExtension->FilterContext, FilterContext, NULL);
    }
    else
    {
        /* If not define, we want to reset filter context.
         * We will remove value (provided by the caller) and set NULL instead.
         * This will only success if caller provides correct previous value.
         * To catch whether it worked, we substract previous value to expect value:
         * If it matches (and thus, we reset), Success will contain 0
         * Otherwise, it will contain a non-zero value.
         */
        Success = (ULONG_PTR)InterlockedCompareExchangePointer(&FileObjectExtension->FilterContext, NULL, FilterContext) - (ULONG_PTR)FilterContext;
    }
 
    /* If success isn't 0, it means we failed somewhere (set or unset) */
    if (Success != 0)
    {
        return STATUS_ALREADY_COMMITTED;
    }
 
    return STATUS_SUCCESS;
}

Referenced by FsRtlInsertPerFileObjectContext(), and FsRtlPTeardownPerFileObjectContexts().

◆ IoComputeDesiredAccessFileObject()

NTSTATUS NTAPI IoComputeDesiredAccessFileObject	(	IN PFILE_OBJECT	FileObject,
		IN PACCESS_MASK	DesiredAccess
	)

Definition at line 26 of file util.c.

{
    /* Assume failure */
    *DesiredAccess = 0;
 
    /* First check we really have a FileObject */
    if (OBJECT_TO_OBJECT_HEADER(FileObject)->Type != IoFileObjectType)
    {
        return STATUS_OBJECT_TYPE_MISMATCH;
    }
 
    /* Then compute desired access:
     * Check if the handle has either FILE_WRITE_DATA or FILE_APPEND_DATA was
     * granted. However, if this is a named pipe, make sure we don't ask for
     * FILE_APPEND_DATA as it interferes with the FILE_CREATE_PIPE_INSTANCE
     * access right!
     */
    *DesiredAccess = ((!(FileObject->Flags & FO_NAMED_PIPE) ? FILE_APPEND_DATA : 0) | FILE_WRITE_DATA);
 
    return STATUS_SUCCESS;
}

Referenced by ObReferenceFileObjectForWrite().

◆ IoCreateDriverList()

NTSTATUS IoCreateDriverList ( VOID )

◆ IoDestroyDriverList()

NTSTATUS IoDestroyDriverList ( VOID )

◆ IoGetFileObjectFilterContext()

PVOID NTAPI IoGetFileObjectFilterContext ( IN PFILE_OBJECT FileObject )

Definition at line 2497 of file file.c.

{
    if (BooleanFlagOn(FileObject->Flags, FO_FILE_OBJECT_HAS_EXTENSION))
    {
        PFILE_OBJECT_EXTENSION FileObjectExtension;
 
        FileObjectExtension = FileObject->FileObjectExtension;
        return FileObjectExtension->FilterContext;
    }
 
    return NULL;
}

Referenced by FsRtlInsertPerFileObjectContext(), FsRtlLookupPerFileObjectContext(), FsRtlPTeardownPerFileObjectContexts(), and FsRtlRemovePerFileObjectContext().

◆ IoGetRelatedTargetDevice()

NTSTATUS NTAPI IoGetRelatedTargetDevice	(	IN PFILE_OBJECT	FileObject,
		OUT PDEVICE_OBJECT *	DeviceObject
	)

Definition at line 1607 of file device.c.

{
    NTSTATUS Status;
    PDEVICE_NODE DeviceNode = NULL;
 
    /* Call the internal helper function */
    Status = IopGetRelatedTargetDevice(FileObject, &DeviceNode);
    if (NT_SUCCESS(Status) && DeviceNode)
    {
        *DeviceObject = DeviceNode->PhysicalDeviceObject;
    }
    return Status;
}

Referenced by FsRtlNotifyVolumeEvent(), and NtSetVolumeInformationFile().

◆ IoInitCancelHandling()

VOID IoInitCancelHandling ( VOID )

◆ IoInitFileSystemImplementation()

VOID NTAPI IoInitFileSystemImplementation ( VOID )

◆ IoInitializeCrashDump()

BOOLEAN NTAPI IoInitializeCrashDump ( IN HANDLE PageFileHandle )

Definition at line 650 of file iomgr.c.

{
    UNIMPLEMENTED;
    return FALSE;
}

Referenced by NtCreatePagingFile().

◆ IoInitShutdownNotification()

VOID IoInitShutdownNotification ( VOID )

◆ IoInitSystem()

BOOLEAN NTAPI IoInitSystem ( IN PLOADER_PARAMETER_BLOCK LoaderBlock )

Definition at line 466 of file iomgr.c.

{
    LARGE_INTEGER ExpireTime;
    NTSTATUS Status;
    CHAR Buffer[256];
    ANSI_STRING NtBootPath, RootString;
 
    /* Initialize empty NT Boot Path */
    RtlInitEmptyAnsiString(&NtBootPath, Buffer, sizeof(Buffer));
 
    /* Initialize the lookaside lists */
    IopInitLookasideLists();
 
    /* Initialize all locks and lists */
    ExInitializeResourceLite(&IopDatabaseResource);
    ExInitializeResourceLite(&IopSecurityResource);
    ExInitializeResourceLite(&IopDriverLoadResource);
    InitializeListHead(&IopDiskFileSystemQueueHead);
    InitializeListHead(&IopCdRomFileSystemQueueHead);
    InitializeListHead(&IopTapeFileSystemQueueHead);
    InitializeListHead(&IopNetworkFileSystemQueueHead);
    InitializeListHead(&DriverBootReinitListHead);
    InitializeListHead(&DriverReinitListHead);
    InitializeListHead(&ShutdownListHead);
    InitializeListHead(&LastChanceShutdownListHead);
    InitializeListHead(&IopFsNotifyChangeQueueHead);
    InitializeListHead(&IopErrorLogListHead);
    KeInitializeSpinLock(&IoStatisticsLock);
    KeInitializeSpinLock(&DriverReinitListLock);
    KeInitializeSpinLock(&DriverBootReinitListLock);
    KeInitializeSpinLock(&ShutdownListLock);
    KeInitializeSpinLock(&IopLogListLock);
 
    /* Initialize PnP notifications */
    PiInitializeNotifications();
 
    /* Initialize the reserve IRP */
    if (!IopInitializeReserveIrp(&IopReserveIrpAllocator))
    {
        DPRINT1("IopInitializeReserveIrp failed!\n");
        return FALSE;
    }
 
    /* Initialize Timer List Lock */
    KeInitializeSpinLock(&IopTimerLock);
 
    /* Initialize Timer List */
    InitializeListHead(&IopTimerQueueHead);
 
    /* Initialize the DPC/Timer which will call the other Timer Routines */
    ExpireTime.QuadPart = -10000000;
    KeInitializeDpc(&IopTimerDpc, IopTimerDispatch, NULL);
    KeInitializeTimerEx(&IopTimer, SynchronizationTimer);
    KeSetTimerEx(&IopTimer, ExpireTime, 1000, &IopTimerDpc);
 
    /* Create Object Types */
    if (!IopCreateObjectTypes())
    {
        DPRINT1("IopCreateObjectTypes failed!\n");
        return FALSE;
    }
 
    /* Create Object Directories */
    if (!IopCreateRootDirectories())
    {
        DPRINT1("IopCreateRootDirectories failed!\n");
        return FALSE;
    }
 
    /* Initialize PnP manager */
    IopInitializePlugPlayServices();
 
    /* Initialize SHIM engine */
    ApphelpCacheInitialize();
 
    /* Initialize WMI */
    WmiInitialize();
 
    /* Initialize HAL Root Bus Driver */
    HalInitPnpDriver();
 
    /* Reenumerate what HAL has added (synchronously)
     * This function call should eventually become a 2nd stage of the PnP initialization */
    PiQueueDeviceAction(IopRootDeviceNode->PhysicalDeviceObject,
                        PiActionEnumRootDevices,
                        NULL,
                        NULL);
 
    /* Make loader block available for the whole kernel */
    IopLoaderBlock = LoaderBlock;
 
    /* Load boot start drivers */
    IopInitializeBootDrivers();
 
    /* Call back drivers that asked for */
    IopReinitializeBootDrivers();
 
    /* Check if this was a ramdisk boot */
    if (!_strnicmp(LoaderBlock->ArcBootDeviceName, "ramdisk(0)", 10))
    {
        /* Initialize the ramdisk driver */
        IopStartRamdisk(LoaderBlock);
    }
 
    /* No one should need loader block any longer */
    IopLoaderBlock = NULL;
 
    /* Create ARC names for boot devices */
    Status = IopCreateArcNames(LoaderBlock);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopCreateArcNames failed: %lx\n", Status);
        return FALSE;
    }
 
    /* Mark the system boot partition */
    if (!IopMarkBootPartition(LoaderBlock))
    {
        DPRINT1("IopMarkBootPartition failed!\n");
        return FALSE;
    }
 
    /* The disk subsystem is initialized here and the SystemRoot is set too.
     * We can finally load other drivers from the boot volume. */
    PnPBootDriversInitialized = TRUE;
 
    /* Load system start drivers */
    IopInitializeSystemDrivers();
    PnpSystemInit = TRUE;
 
    /* Reinitialize drivers that requested it */
    IopReinitializeDrivers();
 
    /* Convert SystemRoot from ARC to NT path */
    Status = IopReassignSystemRoot(LoaderBlock, &NtBootPath);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopReassignSystemRoot failed: %lx\n", Status);
        return FALSE;
    }
 
    /* Set the ANSI_STRING for the root path */
    RootString.MaximumLength = NtSystemRoot.MaximumLength / sizeof(WCHAR);
    RootString.Length = 0;
    RootString.Buffer = ExAllocatePoolWithTag(PagedPool,
                                              RootString.MaximumLength,
                                              TAG_IO);
 
    /* Convert the path into the ANSI_STRING */
    Status = RtlUnicodeStringToAnsiString(&RootString, &NtSystemRoot, FALSE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("RtlUnicodeStringToAnsiString failed: %lx\n", Status);
        return FALSE;
    }
 
    /* Assign drive letters */
    IoAssignDriveLetters(LoaderBlock,
                         &NtBootPath,
                         (PUCHAR)RootString.Buffer,
                         &RootString);
 
    /* Update system root */
    Status = RtlAnsiStringToUnicodeString(&NtSystemRoot, &RootString, FALSE);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("RtlAnsiStringToUnicodeString failed: %lx\n", Status);
        return FALSE;
    }
 
    /* Load the System DLL and its entrypoints */
    Status = PsLocateSystemDll();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("PsLocateSystemDll failed: %lx\n", Status);
        return FALSE;
    }
 
    /* Return success */
    return TRUE;
}

Referenced by Phase1InitializationDiscard().

◆ IoInitVpbImplementation()

VOID NTAPI IoInitVpbImplementation ( VOID )

◆ IoOpenFileOnDevice()

PVOID IoOpenFileOnDevice	(	IN PVOID	SymbolicLink,
		IN PWCHAR	Name
	)

◆ IoOpenSymlink()

PVOID IoOpenSymlink ( IN PVOID SymbolicLink )

◆ IopAbortInterruptedIrp()

VOID NTAPI IopAbortInterruptedIrp	(	IN PKEVENT	EventObject,
		IN PIRP	Irp
	)

Definition at line 67 of file irp.c.

{
    KIRQL OldIrql;
    BOOLEAN CancelResult;
    LARGE_INTEGER Wait;
    PAGED_CODE();
 
    /* Raise IRQL to APC */
    KeRaiseIrql(APC_LEVEL, &OldIrql);
 
    /* Check if nobody completed it yet */
    if (!KeReadStateEvent(EventObject))
    {
        /* First, cancel it */
        CancelResult = IoCancelIrp(Irp);
        KeLowerIrql(OldIrql);
 
        /* Check if we cancelled it */
        if (CancelResult)
        {
            /* Wait for the IRP to be cancelled */
            Wait.QuadPart = -100000;
            while (!KeReadStateEvent(EventObject))
            {
                /* Delay indefintely */
                KeDelayExecutionThread(KernelMode, FALSE, &Wait);
            }
        }
        else
        {
            /* No cancellation done, so wait for the I/O system to kill it */
            KeWaitForSingleObject(EventObject,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
        }
    }
    else
    {
        /* We got preempted, so give up */
        KeLowerIrql(OldIrql);
    }
}

Referenced by IopFinalizeAsynchronousIo(), IopPerformSynchronousRequest(), IopQueryDeviceInformation(), IoSetInformation(), NtQueryInformationFile(), and NtSetInformationFile().

◆ IopAcquireFileObjectLock()

NTSTATUS NTAPI IopAcquireFileObjectLock	(	_In_ PFILE_OBJECT	FileObject,
		_In_ KPROCESSOR_MODE	AccessMode,
		_In_ BOOLEAN	Alertable,
		_Out_ PBOOLEAN	LockFailed
	)

Definition at line 2451 of file file.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    InterlockedIncrement((PLONG)&FileObject->Waiters);
 
    Status = STATUS_SUCCESS;
    do
    {
        if (!InterlockedExchange((PLONG)&FileObject->Busy, TRUE))
        {
            break;
        }
        Status = KeWaitForSingleObject(&FileObject->Lock,
                                       Executive,
                                       WaitMode,
                                       Alertable,
                                       NULL);
    } while (Status == STATUS_SUCCESS);
 
    InterlockedDecrement((PLONG)&FileObject->Waiters);
    if (Status == STATUS_SUCCESS)
    {
        ObReferenceObject(FileObject);
        *LockFailed = FALSE;
    }
    else
    {
        if (!FileObject->Busy && FileObject->Waiters)
        {
            KeSetEvent(&FileObject->Lock, IO_NO_INCREMENT, FALSE);
        }
        *LockFailed = TRUE;
    }
 
    return Status;
}

Referenced by IopLockFileObject().

◆ IopAllocateIrpMustSucceed()

PIRP NTAPI IopAllocateIrpMustSucceed ( IN CCHAR StackSize )

Definition at line 716 of file irp.c.

{
    LONG i;
    PIRP Irp;
    LARGE_INTEGER Sleep;
 
    /* Try to get an IRP */
    Irp = IoAllocateIrp(StackSize, FALSE);
    if (Irp)
        return Irp;
 
    /* If we fail, start looping till we may get one */
    i = LONG_MAX;
    do {
        i--;
 
        /* First, sleep for 10ms */
        Sleep.QuadPart = -10 * 1000 * 10;
        KeDelayExecutionThread(KernelMode, FALSE, &Sleep);
 
        /* Then, retry allocation */
        Irp = IoAllocateIrp(StackSize, FALSE);
        if (Irp)
            return Irp;
    } while (i > 0);
 
    return Irp;
}

Referenced by IoCancelFileOpen(), IopCloseFile(), and IopDeleteFile().

◆ IopAllocateReserveIrp()

PIRP NTAPI IopAllocateReserveIrp ( IN CCHAR StackSize )

Definition at line 573 of file irp.c.

{
    /* If we need a stack size higher than what was allocated, then fail */
    if (StackSize > IopReserveIrpAllocator.StackSize)
    {
        return NULL;
    }
 
    /* Now, wait until the IRP becomes available and reserve it immediately */
    while (InterlockedExchange(&IopReserveIrpAllocator.ReserveIrpInUse, 1) == 1)
    {
        KeWaitForSingleObject(&IopReserveIrpAllocator.WaitEvent,
                              Executive,
                              KernelMode,
                              FALSE,
                              NULL);
    }
 
    /* It's ours! Initialize it */
    IoInitializeIrp(IopReserveIrpAllocator.ReserveIrp, IoSizeOfIrp(StackSize), StackSize);
 
    /* And return it to the caller */
    return IopReserveIrpAllocator.ReserveIrp;
}

Referenced by IoPageRead().

◆ IopAssignDeviceResources()

NTSTATUS NTAPI IopAssignDeviceResources ( IN PDEVICE_NODE DeviceNode )

Definition at line 1116 of file pnpres.c.

{
   NTSTATUS Status;
   ULONG ListSize;
 
   Status = IopFilterResourceRequirements(DeviceNode);
   if (!NT_SUCCESS(Status))
       goto ByeBye;
 
   if (!DeviceNode->BootResources && !DeviceNode->ResourceRequirements)
   {
      /* No resource needed for this device */
      DeviceNode->ResourceList = NULL;
      DeviceNode->ResourceListTranslated = NULL;
      PiSetDevNodeState(DeviceNode, DeviceNodeResourcesAssigned);
      DeviceNode->Flags |= DNF_NO_RESOURCE_REQUIRED;
 
      return STATUS_SUCCESS;
   }
 
   if (DeviceNode->BootResources)
   {
       ListSize = PnpDetermineResourceListSize(DeviceNode->BootResources);
 
       DeviceNode->ResourceList = ExAllocatePool(PagedPool, ListSize);
       if (!DeviceNode->ResourceList)
       {
           Status = STATUS_NO_MEMORY;
           goto ByeBye;
       }
 
       RtlCopyMemory(DeviceNode->ResourceList, DeviceNode->BootResources, ListSize);
 
       Status = IopDetectResourceConflict(DeviceNode->ResourceList, FALSE, NULL);
       if (!NT_SUCCESS(Status))
       {
           DPRINT1("Boot resources for %wZ cause a resource conflict!\n", &DeviceNode->InstancePath);
           ExFreePool(DeviceNode->ResourceList);
           DeviceNode->ResourceList = NULL;
       }
   }
   else
   {
       /* We'll make this from the requirements */
       DeviceNode->ResourceList = NULL;
   }
 
   /* No resources requirements */
   if (!DeviceNode->ResourceRequirements)
       goto Finish;
 
   /* Call HAL to fixup our resource requirements list */
   HalAdjustResourceList(&DeviceNode->ResourceRequirements);
 
   /* Add resource requirements that aren't in the list we already got */
   Status = IopFixupResourceListWithRequirements(DeviceNode->ResourceRequirements,
                                                 &DeviceNode->ResourceList);
   if (!NT_SUCCESS(Status))
   {
       DPRINT1("Failed to fixup a resource list from supplied resources for %wZ\n", &DeviceNode->InstancePath);
       DeviceNode->Problem = CM_PROB_NORMAL_CONFLICT;
       goto ByeBye;
   }
 
   /* IopFixupResourceListWithRequirements should NEVER give us a conflicting list */
   ASSERT(IopDetectResourceConflict(DeviceNode->ResourceList, FALSE, NULL) != STATUS_CONFLICTING_ADDRESSES);
 
Finish:
   Status = IopTranslateDeviceResources(DeviceNode);
   if (!NT_SUCCESS(Status))
   {
       DeviceNode->Problem = CM_PROB_TRANSLATION_FAILED;
       DPRINT1("Failed to translate resources for %wZ\n", &DeviceNode->InstancePath);
       goto ByeBye;
   }
 
   Status = IopUpdateResourceMapForPnPDevice(DeviceNode);
   if (!NT_SUCCESS(Status))
       goto ByeBye;
 
   Status = IopUpdateControlKeyWithResources(DeviceNode);
   if (!NT_SUCCESS(Status))
       goto ByeBye;
 
   PiSetDevNodeState(DeviceNode, DeviceNodeResourcesAssigned);
 
   return STATUS_SUCCESS;
 
ByeBye:
   if (DeviceNode->ResourceList)
   {
      ExFreePool(DeviceNode->ResourceList);
      DeviceNode->ResourceList = NULL;
   }
 
   DeviceNode->ResourceListTranslated = NULL;
 
   return Status;
}

Referenced by IoReportDetectedDevice(), and PiDevNodeStateMachine().

◆ IopAttachFilterDrivers()

NTSTATUS FASTCALL IopAttachFilterDrivers	(	IN PDEVICE_NODE	DeviceNode,
		IN HANDLE	EnumSubKey,
		IN HANDLE	ClassKey,
		IN BOOLEAN	Lower
	)

◆ IopBootLog()

VOID IopBootLog	(	IN PUNICODE_STRING	DriverName,
		IN BOOLEAN	Success
	)

◆ IopCheckVpbMounted()

PVPB NTAPI IopCheckVpbMounted	(	IN POPEN_PACKET	OpenPacket,
		IN PDEVICE_OBJECT	DeviceObject,
		IN PUNICODE_STRING	RemainingName,
		OUT PNTSTATUS	Status
	)

Definition at line 76 of file volume.c.

{
    BOOLEAN Alertable, Raw;
    KIRQL OldIrql;
    PVPB Vpb = NULL;
 
    /* Lock the VPBs */
    IoAcquireVpbSpinLock(&OldIrql);
 
    /* Set VPB mount settings */
    Raw = !RemainingName->Length && !OpenPacket->RelatedFileObject;
    Alertable = (OpenPacket->CreateOptions & FILE_SYNCHRONOUS_IO_ALERT) ?
                TRUE: FALSE;
 
    /* Start looping until the VPB is mounted */
    while (!(DeviceObject->Vpb->Flags & VPB_MOUNTED))
    {
        /* Release the lock */
        IoReleaseVpbSpinLock(OldIrql);
 
        /* Mount the volume */
        *Status = IopMountVolume(DeviceObject,
                                 Raw,
                                 FALSE,
                                 Alertable,
                                 &Vpb);
 
        /* Check if we failed or if we were alerted */
        if (!(NT_SUCCESS(*Status)) ||
            (*Status == STATUS_USER_APC) ||
            (*Status == STATUS_ALERTED))
        {
            /* Dereference the device, since IopParseDevice referenced it */
            IopDereferenceDeviceObject(DeviceObject, FALSE);
 
            /* Check if it was a total failure */
            if (!NT_SUCCESS(*Status)) return NULL;
 
            /* Otherwise we were alerted */
            *Status = STATUS_WRONG_VOLUME;
            return NULL;
        }
        /*
         * In case IopMountVolume returns a valid VPB
         * Then, the volume is mounted, return it
         */
        else if (Vpb != NULL)
        {
            return Vpb;
        }
 
        /* Re-acquire the lock */
        IoAcquireVpbSpinLock(&OldIrql);
    }
 
    /* Make sure the VPB isn't locked */
    Vpb = DeviceObject->Vpb;
    if (Vpb->Flags & VPB_LOCKED)
    {
        /* We're locked, so fail */
        *Status = STATUS_ACCESS_DENIED;
        Vpb = NULL;
    }
    else
    {
        /* Success! Reference the VPB */
        Vpb->ReferenceCount++;
    }
 
    /* Release the lock and return the VPB */
    IoReleaseVpbSpinLock(OldIrql);
    return Vpb;
}

Referenced by IopParseDevice().

◆ IopCleanupFailedIrp()

NTSTATUS NTAPI IopCleanupFailedIrp	(	IN PFILE_OBJECT	FileObject,
		IN PKEVENT	EventObject,
		IN PVOID Buffer	OPTIONAL
	)

Definition at line 45 of file irp.c.

{
    PAGED_CODE();
 
    /* Dereference the event */
    if (EventObject) ObDereferenceObject(EventObject);
 
    /* Free a buffer, if any */
    if (Buffer) ExFreePool(Buffer);
 
    /* If this was a file opened for synch I/O, then unlock it */
    if (FileObject->Flags & FO_SYNCHRONOUS_IO) IopUnlockFileObject(FileObject);
 
    /* Now dereference it and return */
    ObDereferenceObject(FileObject);
    return STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by IopDeviceFsIoControl(), IopGetSetSecurityObject(), IopQueryDeviceInformation(), IoSetInformation(), NtFlushBuffersFile(), NtLockFile(), NtNotifyChangeDirectoryFile(), NtQueryDirectoryFile(), NtQueryInformationFile(), NtQueryVolumeInformationFile(), NtReadFile(), NtSetInformationFile(), NtSetVolumeInformationFile(), NtUnlockFile(), and NtWriteFile().

◆ IopCloseFile()

VOID NTAPI IopCloseFile	(	IN PEPROCESS Process	OPTIONAL,
		IN PVOID	Object,
		IN ACCESS_MASK	GrantedAccess,
		IN ULONG	ProcessHandleCount,
		IN ULONG	SystemHandleCount
	)

Definition at line 2179 of file file.c.

{
    PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
    KEVENT Event;
    PIRP Irp;
    PIO_STACK_LOCATION StackPtr;
    NTSTATUS Status;
    PDEVICE_OBJECT DeviceObject;
    KIRQL OldIrql;
    IO_STATUS_BLOCK IoStatusBlock;
    IOTRACE(IO_FILE_DEBUG, "ObjectBody: %p\n", ObjectBody);
 
    /* If this isn't the last handle for the current process, quit */
    if (HandleCount != 1) return;
 
    /* Check if the file is locked and has more then one handle opened */
    if ((FileObject->LockOperation) && (SystemHandleCount != 1))
    {
        /* Check if this is a direct open or not */
        if (BooleanFlagOn(FileObject->Flags, FO_DIRECT_DEVICE_OPEN))
        {
            /* Get the attached device */
            DeviceObject = IoGetAttachedDevice(FileObject->DeviceObject);
        }
        else
        {
            /* Get the FO's device */
            DeviceObject = IoGetRelatedDeviceObject(FileObject);
        }
 
        /* Check if this is a sync FO and lock it */
        if (BooleanFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO))
        {
            (VOID)IopLockFileObject(FileObject, KernelMode);
        }
 
        /* Go the FastIO path if possible, otherwise fall back to IRP */
        if (DeviceObject->DriverObject->FastIoDispatch == NULL ||
            DeviceObject->DriverObject->FastIoDispatch->FastIoUnlockAll == NULL ||
            !DeviceObject->DriverObject->FastIoDispatch->FastIoUnlockAll(FileObject, PsGetCurrentProcess(), &IoStatusBlock, DeviceObject))
        {
            /* Clear and set up Events */
            KeClearEvent(&FileObject->Event);
            KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
 
            /* Allocate an IRP */
            Irp = IopAllocateIrpMustSucceed(DeviceObject->StackSize);
 
            /* Set it up */
            Irp->UserEvent = &Event;
            Irp->UserIosb = &Irp->IoStatus;
            Irp->Tail.Overlay.Thread = PsGetCurrentThread();
            Irp->Tail.Overlay.OriginalFileObject = FileObject;
            Irp->RequestorMode = KernelMode;
            Irp->Flags = IRP_SYNCHRONOUS_API;
            Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
            ObReferenceObject(FileObject);
 
            /* Set up Stack Pointer Data */
            StackPtr = IoGetNextIrpStackLocation(Irp);
            StackPtr->MajorFunction = IRP_MJ_LOCK_CONTROL;
            StackPtr->MinorFunction = IRP_MN_UNLOCK_ALL;
            StackPtr->FileObject = FileObject;
 
            /* Queue the IRP */
            IopQueueIrpToThread(Irp);
 
            /* Call the FS Driver */
            Status = IoCallDriver(DeviceObject, Irp);
            if (Status == STATUS_PENDING)
            {
                /* Wait for completion */
                KeWaitForSingleObject(&Event, UserRequest, KernelMode, FALSE, NULL);
            }
 
            /* IO will unqueue & free for us */
        }
 
        /* Release the lock if we were holding it */
        if (BooleanFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO))
        {
            IopUnlockFileObject(FileObject);
        }
    }
 
    /* Make sure this is the last handle */
    if (SystemHandleCount != 1) return;
 
    /* Check if this is a direct open or not */
    if (FileObject->Flags & FO_DIRECT_DEVICE_OPEN)
    {
        /* Get the attached device */
        DeviceObject = IoGetAttachedDevice(FileObject->DeviceObject);
    }
    else
    {
        /* Get the FO's device */
        DeviceObject = IoGetRelatedDeviceObject(FileObject);
    }
 
    /* Set the handle created flag */
    FileObject->Flags |= FO_HANDLE_CREATED;
 
    /* Check if this is a sync FO and lock it */
    if (Process != NULL &&
        BooleanFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO))
    {
        (VOID)IopLockFileObject(FileObject, KernelMode);
    }
 
    /* Clear and set up Events */
    KeClearEvent(&FileObject->Event);
    KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
 
    /* Allocate an IRP */
    Irp = IopAllocateIrpMustSucceed(DeviceObject->StackSize);
 
    /* Set it up */
    Irp->UserEvent = &Event;
    Irp->UserIosb = &Irp->IoStatus;
    Irp->Tail.Overlay.Thread = PsGetCurrentThread();
    Irp->Tail.Overlay.OriginalFileObject = FileObject;
    Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
    Irp->Flags = IRP_CLOSE_OPERATION | IRP_SYNCHRONOUS_API;
 
    /* Set up Stack Pointer Data */
    StackPtr = IoGetNextIrpStackLocation(Irp);
    StackPtr->MajorFunction = IRP_MJ_CLEANUP;
    StackPtr->FileObject = FileObject;
 
    /* Queue the IRP */
    IopQueueIrpToThread(Irp);
 
    /* Update operation counts */
    IopUpdateOperationCount(IopOtherTransfer);
 
    /* Call the FS Driver */
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        /* Wait for completion */
        KeWaitForSingleObject(&Event, UserRequest, KernelMode, FALSE, NULL);
    }
 
    /* Unqueue the IRP */
    KeRaiseIrql(APC_LEVEL, &OldIrql);
    IopUnQueueIrpFromThread(Irp);
    KeLowerIrql(OldIrql);
 
    /* Free the IRP */
    IoFreeIrp(Irp);
 
    /* Release the lock if we were holding it */
    if (Process != NULL &&
        BooleanFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO))
    {
        IopUnlockFileObject(FileObject);
    }
}

Referenced by IopCreateObjectTypes(), and IopDeleteFile().

◆ IopCompleteRequest()

VOID NTAPI IopCompleteRequest	(	IN PKAPC	Apc,
		IN PKNORMAL_ROUTINE *	NormalRoutine,
		IN PVOID *	NormalContext,
		IN PVOID *	SystemArgument1,
		IN PVOID *	SystemArgument2
	)

Definition at line 238 of file irp.c.

{
    PFILE_OBJECT FileObject;
    PIRP Irp;
    PMDL Mdl, NextMdl;
    PVOID Port = NULL, Key = NULL;
    BOOLEAN SignaledCreateRequest = FALSE;
 
    /* Get data from the APC */
    FileObject = (PFILE_OBJECT)*SystemArgument1;
    Irp = CONTAINING_RECORD(Apc, IRP, Tail.Apc);
    IOTRACE(IO_IRP_DEBUG,
            "%s - Completing IRP %p for %p\n",
            __FUNCTION__,
            Irp,
            FileObject);
 
    /* Sanity check */
    ASSERT(Irp->IoStatus.Status != (NTSTATUS)0xFFFFFFFF);
 
    /* Check if we have a file object */
    if (*SystemArgument2)
    {
        /* Check if we're reparsing */
        if ((Irp->IoStatus.Status == STATUS_REPARSE) &&
            (Irp->IoStatus.Information == IO_REPARSE_TAG_MOUNT_POINT))
        {
            PREPARSE_DATA_BUFFER ReparseData;
 
            ReparseData = (PREPARSE_DATA_BUFFER)*SystemArgument2;
 
            ASSERT(ReparseData->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT);
            ASSERT(ReparseData->ReparseDataLength < MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
            ASSERT(ReparseData->Reserved < MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
 
            IopDoNameTransmogrify(Irp, FileObject, ReparseData);
        }
    }
 
    /* Handle Buffered case first */
    if (Irp->Flags & IRP_BUFFERED_IO)
    {
        /* Check if we have an input buffer and if we succeeded */
        if ((Irp->Flags & IRP_INPUT_OPERATION) &&
            (Irp->IoStatus.Status != STATUS_VERIFY_REQUIRED) &&
            !(NT_ERROR(Irp->IoStatus.Status)))
        {
            _SEH2_TRY
            {
                /* Copy the buffer back to the user */
                RtlCopyMemory(Irp->UserBuffer,
                              Irp->AssociatedIrp.SystemBuffer,
                              Irp->IoStatus.Information);
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                /* Fail the IRP */
                Irp->IoStatus.Status = _SEH2_GetExceptionCode();
            }
            _SEH2_END;
        }
 
        /* Also check if we should de-allocate it */
        if (Irp->Flags & IRP_DEALLOCATE_BUFFER)
        {
            /* Deallocate it */
            ExFreePool(Irp->AssociatedIrp.SystemBuffer);
        }
    }
 
    /* Now we got rid of these two... */
    Irp->Flags &= ~(IRP_BUFFERED_IO | IRP_DEALLOCATE_BUFFER);
 
    /* Check if there's an MDL */
    for (Mdl = Irp->MdlAddress; Mdl; Mdl = NextMdl)
    {
        /* Free it */
        NextMdl = Mdl->Next;
        IoFreeMdl(Mdl);
    }
 
    /* No MDLs left */
    Irp->MdlAddress = NULL;
 
    /*
     * Check if either the request was completed without any errors
     * (but warnings are OK!), or if it was completed with an error, but
     * did return from a pending I/O Operation and is not synchronous.
     */
    if (!NT_ERROR(Irp->IoStatus.Status) ||
        (Irp->PendingReturned &&
         !IsIrpSynchronous(Irp, FileObject)))
    {
        /* Get any information we need from the FO before we kill it */
        if ((FileObject) && (FileObject->CompletionContext))
        {
            /* Save Completion Data */
            Port = FileObject->CompletionContext->Port;
            Key = FileObject->CompletionContext->Key;
        }
 
        /* Check for UserIos */
        if (Irp->UserIosb != NULL)
        {
            /* Use SEH to make sure we don't write somewhere invalid */
            _SEH2_TRY
            {
                /*  Save the IOSB Information */
                *Irp->UserIosb = Irp->IoStatus;
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                /* Ignore any error */
            }
            _SEH2_END;
        }
 
        /* Check if we have an event or a file object */
        if (Irp->UserEvent)
        {
            /* At the very least, this is a PKEVENT, so signal it always */
            KeSetEvent(Irp->UserEvent, 0, FALSE);
 
            /* Check if we also have a File Object */
            if (FileObject)
            {
                /* Check if this is an Asynch API */
                if (!(Irp->Flags & IRP_SYNCHRONOUS_API))
                {
                    /* Dereference the event */
                    ObDereferenceObject(Irp->UserEvent);
                }
 
                /*
                 * Now, if this is a Synch I/O File Object, then this event is
                 * NOT an actual Executive Event, so we won't dereference it,
                 * and instead, we will signal the File Object
                 */
                if ((FileObject->Flags & FO_SYNCHRONOUS_IO) &&
                    !(Irp->Flags & IRP_OB_QUERY_NAME))
                {
                    /* Signal the file object and set the status */
                    KeSetEvent(&FileObject->Event, 0, FALSE);
                    FileObject->FinalStatus = Irp->IoStatus.Status;
                }
 
                /*
                 * This could also be a create operation, in which case we want
                 * to make sure there's no APC fired.
                 */
                if (Irp->Flags & IRP_CREATE_OPERATION)
                {
                    /* Clear the APC Routine and remember this */
                    Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
                    SignaledCreateRequest = TRUE;
                }
            }
        }
        else if (FileObject)
        {
            /* Signal the file object and set the status */
            KeSetEvent(&FileObject->Event, 0, FALSE);
            FileObject->FinalStatus = Irp->IoStatus.Status;
 
            /*
            * This could also be a create operation, in which case we want
            * to make sure there's no APC fired.
            */
            if (Irp->Flags & IRP_CREATE_OPERATION)
            {
                /* Clear the APC Routine and remember this */
                Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
                SignaledCreateRequest = TRUE;
            }
        }
 
        /* Update transfer count for everything but create operation */
        if (!(Irp->Flags & IRP_CREATE_OPERATION))
        {
            if (Irp->Flags & IRP_WRITE_OPERATION)
            {
                /* Update write transfer count */
                IopUpdateTransferCount(IopWriteTransfer,
                                       (ULONG)Irp->IoStatus.Information);
            }
            else if (Irp->Flags & IRP_READ_OPERATION)
            {
                /* Update read transfer count */
                IopUpdateTransferCount(IopReadTransfer,
                                       (ULONG)Irp->IoStatus.Information);
            }
            else
            {
                /* Update other transfer count */
                IopUpdateTransferCount(IopOtherTransfer,
                                       (ULONG)Irp->IoStatus.Information);
            }
        }
 
        /* Now that we've signaled the events, de-associate the IRP */
        IopUnQueueIrpFromThread(Irp);
 
        /* Now check if a User APC Routine was requested */
        if (Irp->Overlay.AsynchronousParameters.UserApcRoutine)
        {
            /* Initialize it */
            KeInitializeApc(&Irp->Tail.Apc,
                            KeGetCurrentThread(),
                            CurrentApcEnvironment,
                            IopFreeIrpKernelApc,
                            IopAbortIrpKernelApc,
                            (PKNORMAL_ROUTINE)Irp->
                            Overlay.AsynchronousParameters.UserApcRoutine,
                            Irp->RequestorMode,
                            Irp->
                            Overlay.AsynchronousParameters.UserApcContext);
 
            /* Queue it */
            KeInsertQueueApc(&Irp->Tail.Apc, Irp->UserIosb, NULL, 2);
        }
        else if ((Port) &&
                 (Irp->Overlay.AsynchronousParameters.UserApcContext))
        {
            /* We have an I/O Completion setup... create the special Overlay */
            Irp->Tail.CompletionKey = Key;
            Irp->Tail.Overlay.PacketType = IopCompletionPacketIrp;
            KeInsertQueue(Port, &Irp->Tail.Overlay.ListEntry);
        }
        else
        {
            /* Free the IRP since we don't need it anymore */
            IoFreeIrp(Irp);
        }
 
        /* Check if we have a file object that wasn't part of a create */
        if ((FileObject) && !(SignaledCreateRequest))
        {
            /* Dereference it, since it's not needed anymore either */
            ObDereferenceObjectDeferDelete(FileObject);
        }
    }
    else
    {
        /*
         * Either we didn't return from the request, or we did return but this
         * request was synchronous.
         */
        if ((Irp->PendingReturned) && (FileObject))
        {
            /* So we did return with a synch operation, was it the IRP? */
            if (Irp->Flags & IRP_SYNCHRONOUS_API)
            {
                /* Yes, this IRP was synchronous, so return the I/O Status */
                *Irp->UserIosb = Irp->IoStatus;
 
                /* Now check if the user gave an event */
                if (Irp->UserEvent)
                {
                    /* Signal it */
                    KeSetEvent(Irp->UserEvent, 0, FALSE);
                }
                else
                {
                    /* No event was given, so signal the FO instead */
                    KeSetEvent(&FileObject->Event, 0, FALSE);
                }
            }
            else
            {
                /*
                 * It's not the IRP that was synchronous, it was the FO
                 * that was opened this way. Signal its event.
                 */
                FileObject->FinalStatus = Irp->IoStatus.Status;
                KeSetEvent(&FileObject->Event, 0, FALSE);
            }
        }
 
        /* Now that we got here, we do this for incomplete I/Os as well */
        if ((FileObject) && !(Irp->Flags & IRP_CREATE_OPERATION))
        {
            /* Dereference the File Object unless this was a create */
            ObDereferenceObjectDeferDelete(FileObject);
        }
 
        /*
         * Check if this was an Executive Event (remember that we know this
         * by checking if the IRP is synchronous)
         */
        if ((Irp->UserEvent) &&
            (FileObject) &&
            !(Irp->Flags & IRP_SYNCHRONOUS_API))
        {
            /* This isn't a PKEVENT, so dereference it */
            ObDereferenceObject(Irp->UserEvent);
        }
 
        /* Now that we've signaled the events, de-associate the IRP */
        IopUnQueueIrpFromThread(Irp);
 
        /* Free the IRP as well */
        IoFreeIrp(Irp);
    }
}

Referenced by IofCompleteRequest(), IopPerformSynchronousRequest(), NtQueryInformationFile(), and NtSetInformationFile().

◆ IopCreateArcNames()

NTSTATUS NTAPI IopCreateArcNames ( IN PLOADER_PARAMETER_BLOCK LoaderBlock )

Definition at line 39 of file arcname.c.

{
    SIZE_T Length;
    NTSTATUS Status;
    CHAR Buffer[128];
    BOOLEAN SingleDisk;
    BOOLEAN FoundBoot = FALSE;
    UNICODE_STRING SystemDevice, LoaderPathNameW, BootDeviceName;
    PARC_DISK_INFORMATION ArcDiskInfo = LoaderBlock->ArcDiskInformation;
    ANSI_STRING ArcSystemString, ArcString, LanmanRedirector, LoaderPathNameA;
 
    /* Check if we only have one disk on the machine */
    SingleDisk = (ArcDiskInfo->DiskSignatureListHead.Flink->Flink ==
                 &ArcDiskInfo->DiskSignatureListHead);
 
    /* Create the global HAL partition name */
    sprintf(Buffer, "\\ArcName\\%s", LoaderBlock->ArcHalDeviceName);
    RtlInitAnsiString(&ArcString, Buffer);
    Status = RtlAnsiStringToUnicodeString(&IoArcHalDeviceName, &ArcString, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Create the global system partition name */
    sprintf(Buffer, "\\ArcName\\%s", LoaderBlock->ArcBootDeviceName);
    RtlInitAnsiString(&ArcString, Buffer);
    Status = RtlAnsiStringToUnicodeString(&IoArcBootDeviceName, &ArcString, TRUE);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Allocate memory for the string */
    Length = strlen(LoaderBlock->ArcBootDeviceName) + sizeof(ANSI_NULL);
    IoLoaderArcBootDeviceName = ExAllocatePoolWithTag(PagedPool,
                                                      Length,
                                                      TAG_IO);
    if (IoLoaderArcBootDeviceName)
    {
        /* Copy the name */
        RtlCopyMemory(IoLoaderArcBootDeviceName,
                      LoaderBlock->ArcBootDeviceName,
                      Length);
    }
 
    /* Check if we only found a disk, but we're booting from CD-ROM */
    if ((SingleDisk) && strstr(LoaderBlock->ArcBootDeviceName, "cdrom"))
    {
        /* Then disable single-disk mode, since there's a CD drive out there */
        SingleDisk = FALSE;
    }
 
    /* Build the boot strings */
    RtlInitAnsiString(&ArcSystemString, LoaderBlock->ArcHalDeviceName);
 
    /* If we are doing remote booting */
    if (IoRemoteBootClient)
    {
        /* Yes, we have found boot device */
        FoundBoot = TRUE;
 
        /* Get NT device name */
        RtlInitAnsiString(&LanmanRedirector, "\\Device\\LanmanRedirector");
        Status = RtlAnsiStringToUnicodeString(&SystemDevice, &LanmanRedirector, TRUE);
        if (!NT_SUCCESS(Status))
        {
            return Status;
        }
 
        /* Get ARC booting device name (in net(0) something) */
        sprintf(Buffer, "\\ArcName\\%s", LoaderBlock->ArcBootDeviceName);
        RtlInitAnsiString(&ArcString, Buffer);
        Status = RtlAnsiStringToUnicodeString(&BootDeviceName, &ArcString, TRUE);
        if (NT_SUCCESS(Status))
        {
            /* Map ARC to NT name */
            IoAssignArcName(&BootDeviceName, &SystemDevice);
            RtlFreeUnicodeString(&BootDeviceName);
 
            /* Now, get loader path name */
            RtlInitAnsiString(&LoaderPathNameA, LoaderBlock->NtHalPathName);
            Status = RtlAnsiStringToUnicodeString(&LoaderPathNameW, &LoaderPathNameA, TRUE);
            if (!NT_SUCCESS(Status))
            {
                RtlFreeUnicodeString(&SystemDevice);
                return Status;
            }
 
            /* And set it has system partition */
            IopStoreSystemPartitionInformation(&SystemDevice, &LoaderPathNameW);
        }
 
        RtlFreeUnicodeString(&SystemDevice);
 
        /* Don't quit here, even if everything went fine!
         * We need IopCreateArcNamesDisk to properly map
         * devices with symlinks.
         * It will return success if the mapping process went fine
         * even if it didn't find boot device.
         * It won't reset boot device finding status as well.
         */
    }
 
    /* Loop every disk and try to find boot disk */
    Status = IopCreateArcNamesDisk(LoaderBlock, SingleDisk, &FoundBoot);
    /* If it succeeded but we didn't find boot device, try to browse Cds */
    if (NT_SUCCESS(Status) && !FoundBoot)
    {
        Status = IopCreateArcNamesCd(LoaderBlock);
    }
 
    /* Return success */
    return Status;
}

Referenced by IoInitSystem().

◆ IopCreateDeviceKeyPath()

NTSTATUS NTAPI IopCreateDeviceKeyPath	(	IN PCUNICODE_STRING	RegistryPath,
		IN ULONG	CreateOptions,
		OUT PHANDLE	Handle
	)

Definition at line 522 of file pnpmgr.c.

{
    UNICODE_STRING EnumU = RTL_CONSTANT_STRING(ENUM_ROOT);
    HANDLE hParent = NULL, hKey;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName;
    PCWSTR Current, Last;
    USHORT Length;
    NTSTATUS Status;
 
    /* Assume failure */
    *Handle = NULL;
 
    /* Open root key for device instances */
    Status = IopOpenRegistryKeyEx(&hParent, NULL, &EnumU, KEY_CREATE_SUB_KEY);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwOpenKey('%wZ') failed with status 0x%08lx\n", &EnumU, Status);
        return Status;
    }
 
    Current = KeyName.Buffer = RegistryPath->Buffer;
    Last = &RegistryPath->Buffer[RegistryPath->Length / sizeof(WCHAR)];
 
    /* Go up to the end of the string */
    while (Current <= Last)
    {
        if (Current != Last && *Current != L'\\')
        {
            /* Not the end of the string and not a separator */
            Current++;
            continue;
        }
 
        /* Prepare relative key name */
        Length = (USHORT)((ULONG_PTR)Current - (ULONG_PTR)KeyName.Buffer);
        KeyName.MaximumLength = KeyName.Length = Length;
        DPRINT("Create '%wZ'\n", &KeyName);
 
        /* Open key */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &KeyName,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   hParent,
                                   NULL);
        Status = ZwCreateKey(&hKey,
                             Current == Last ? KEY_ALL_ACCESS : KEY_CREATE_SUB_KEY,
                             &ObjectAttributes,
                             0,
                             NULL,
                             CreateOptions,
                             NULL);
 
        /* Close parent key handle, we don't need it anymore */
        if (hParent)
            ZwClose(hParent);
 
        /* Key opening/creating failed? */
        if (!NT_SUCCESS(Status))
        {
            DPRINT1("ZwCreateKey('%wZ') failed with status 0x%08lx\n", &KeyName, Status);
            return Status;
        }
 
        /* Check if it is the end of the string */
        if (Current == Last)
        {
            /* Yes, return success */
            *Handle = hKey;
            return STATUS_SUCCESS;
        }
 
        /* Start with this new parent key */
        hParent = hKey;
        Current++;
        KeyName.Buffer = (PWSTR)Current;
    }
 
    return STATUS_UNSUCCESSFUL;
}

Referenced by IopInstallCriticalDevice(), IopQueryDeviceCapabilities(), IoReportDetectedDevice(), PiControlInitializeDevice(), and PiInitializeDevNode().

◆ IopCreateRegistryKeyEx()

NTSTATUS NTAPI IopCreateRegistryKeyEx	(	OUT PHANDLE	Handle,
		IN HANDLE BaseHandle	OPTIONAL,
		IN PUNICODE_STRING	KeyName,
		IN ACCESS_MASK	DesiredAccess,
		IN ULONG	CreateOptions,
		OUT PULONG Disposition	OPTIONAL
	)

Referenced by IopInitializePlugPlayServices(), IopOpenOrCreateSymbolicLinkSubKeys(), IopSetServiceEnumData(), IopStoreSystemPartitionInformation(), and IoSetSystemPartition().

◆ IopCreateVpb()

NTSTATUS NTAPI IopCreateVpb ( IN PDEVICE_OBJECT DeviceObject )

Definition at line 158 of file volume.c.

{
    PVPB Vpb;
 
    /* Allocate the Vpb */
    Vpb = ExAllocatePoolWithTag(NonPagedPool,
                                sizeof(VPB),
                                TAG_VPB);
    if (!Vpb) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Clear it so we don't waste time manually */
    RtlZeroMemory(Vpb, sizeof(VPB));
 
    /* Set the Header and Device Field */
    Vpb->Type = IO_TYPE_VPB;
    Vpb->Size = sizeof(VPB);
    Vpb->RealDevice = DeviceObject;
 
    /* Link it to the Device Object */
    DeviceObject->Vpb = Vpb;
    return STATUS_SUCCESS;
}

Referenced by IoCreateDevice(), and IoVerifyVolume().

◆ IopDeleteDevice()

VOID NTAPI IopDeleteDevice ( IN PVOID ObjectBody )

Definition at line 52 of file device.c.

{
    PDEVICE_OBJECT DeviceObject = ObjectBody;
    PDEVICE_NODE DeviceNode = IopGetDeviceNode(DeviceObject);
    PAGED_CODE();
 
    /* Cleanup and free the device node */
    if (DeviceNode)
        IopFreeDeviceNode(DeviceNode);
 
    /* Dereference the driver object, referenced in IoCreateDevice */
    if (DeviceObject->DriverObject)
        ObDereferenceObject(DeviceObject->DriverObject);
}

Referenced by IopCreateObjectTypes().

◆ IopDeleteDriver()

VOID NTAPI IopDeleteDriver ( IN PVOID ObjectBody )

Definition at line 77 of file driver.c.

{
    PDRIVER_OBJECT DriverObject = ObjectBody;
    PIO_CLIENT_EXTENSION DriverExtension, NextDriverExtension;
    PAGED_CODE();
 
    DPRINT1("Deleting driver object '%wZ'\n", &DriverObject->DriverName);
 
    /* There must be no device objects remaining at this point */
    ASSERT(!DriverObject->DeviceObject);
 
    /* Get the extension and loop them */
    DriverExtension = IoGetDrvObjExtension(DriverObject)->ClientDriverExtension;
    while (DriverExtension)
    {
        /* Get the next one */
        NextDriverExtension = DriverExtension->NextExtension;
        ExFreePoolWithTag(DriverExtension, TAG_DRIVER_EXTENSION);
 
        /* Move on */
        DriverExtension = NextDriverExtension;
    }
 
    /* Check if the driver image is still loaded */
    if (DriverObject->DriverSection)
    {
        /* Unload it */
        MmUnloadSystemImage(DriverObject->DriverSection);
    }
 
    /* Check if it has a name */
    if (DriverObject->DriverName.Buffer)
    {
        /* Free it */
        ExFreePool(DriverObject->DriverName.Buffer);
    }
 
    /* Check if it has a service key name */
    if (DriverObject->DriverExtension->ServiceKeyName.Buffer)
    {
        /* Free it */
        ExFreePool(DriverObject->DriverExtension->ServiceKeyName.Buffer);
    }
}

Referenced by IopCreateObjectTypes().

◆ IopDeleteFile()

VOID NTAPI IopDeleteFile ( IN PVOID ObjectBody )

Definition at line 1355 of file file.c.

{
    PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
    PIRP Irp;
    PIO_STACK_LOCATION StackPtr;
    NTSTATUS Status;
    KEVENT Event;
    PDEVICE_OBJECT DeviceObject;
    BOOLEAN DereferenceDone = FALSE;
    PVPB Vpb;
    KIRQL OldIrql;
    IOTRACE(IO_FILE_DEBUG, "ObjectBody: %p\n", ObjectBody);
 
    /* Check if the file has a device object */
    if (FileObject->DeviceObject)
    {
        /* Check if this is a direct open or not */
        if (FileObject->Flags & FO_DIRECT_DEVICE_OPEN)
        {
            /* Get the attached device */
            DeviceObject = IoGetAttachedDevice(FileObject->DeviceObject);
        }
        else
        {
            /* Use the file object's device object */
            DeviceObject = IoGetRelatedDeviceObject(FileObject);
        }
 
        /* Sanity check */
        ASSERT(!(FileObject->Flags & FO_SYNCHRONOUS_IO) ||
               (InterlockedExchange((PLONG)&FileObject->Busy, TRUE) == FALSE));
 
        /* Check if the handle wasn't created yet */
        if (!(FileObject->Flags & FO_HANDLE_CREATED))
        {
            /* Send the cleanup IRP */
            IopCloseFile(NULL, ObjectBody, 0, 1, 1);
        }
 
        /* Clear and set up Events */
        KeClearEvent(&FileObject->Event);
        KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
 
        /* Allocate an IRP */
        Irp = IopAllocateIrpMustSucceed(DeviceObject->StackSize);
 
        /* Set it up */
        Irp->UserEvent = &Event;
        Irp->UserIosb = &Irp->IoStatus;
        Irp->Tail.Overlay.Thread = PsGetCurrentThread();
        Irp->Tail.Overlay.OriginalFileObject = FileObject;
        Irp->Flags = IRP_CLOSE_OPERATION | IRP_SYNCHRONOUS_API;
 
        /* Set up Stack Pointer Data */
        StackPtr = IoGetNextIrpStackLocation(Irp);
        StackPtr->MajorFunction = IRP_MJ_CLOSE;
        StackPtr->FileObject = FileObject;
 
        /* Queue the IRP */
        IopQueueIrpToThread(Irp);
 
        /* Get the VPB and check if this isn't a direct open */
        Vpb = FileObject->Vpb;
        if ((Vpb) && !(FileObject->Flags & FO_DIRECT_DEVICE_OPEN))
        {
            /* Dereference the VPB before the close */
            InterlockedDecrement((PLONG)&Vpb->ReferenceCount);
        }
 
        /* Check if the FS will never disappear by itself */
        if (FileObject->DeviceObject->Flags & DO_NEVER_LAST_DEVICE)
        {
            /* Dereference it */
            InterlockedDecrement(&FileObject->DeviceObject->ReferenceCount);
            DereferenceDone = TRUE;
        }
 
        /* Call the FS Driver */
        Status = IoCallDriver(DeviceObject, Irp);
        if (Status == STATUS_PENDING)
        {
            /* Wait for completion */
            KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        }
 
        /* De-queue the IRP */
        KeRaiseIrql(APC_LEVEL, &OldIrql);
        IopUnQueueIrpFromThread(Irp);
        KeLowerIrql(OldIrql);
 
        /* Free the IRP */
        IoFreeIrp(Irp);
 
        /* Clear the file name */
        if (FileObject->FileName.Buffer)
        {
            /*
             * Don't use TAG_IO_NAME since the FileObject's FileName
             * may have been re-allocated using a different tag
             * by a filesystem.
             */
            ExFreePoolWithTag(FileObject->FileName.Buffer, 0);
            FileObject->FileName.Buffer = NULL;
        }
 
        /* Check if the FO had a completion port */
        if (FileObject->CompletionContext)
        {
            /* Free it */
            ObDereferenceObject(FileObject->CompletionContext->Port);
            ExFreePool(FileObject->CompletionContext);
        }
 
        /* Check if the FO had extension */
        if (FileObject->Flags & FO_FILE_OBJECT_HAS_EXTENSION)
        {
            /* Release filter context structure if any */
            FsRtlPTeardownPerFileObjectContexts(FileObject);
        }
 
        /* Check if dereference has been done yet */
        if (!DereferenceDone)
        {
            /* Dereference device object */
            IopDereferenceDeviceObject(FileObject->DeviceObject, FALSE);
        }
    }
}

Referenced by IopCreateObjectTypes(), and IopParseDevice().

◆ IopDeleteIoCompletion()

VOID NTAPI IopDeleteIoCompletion ( PVOID ObjectBody )

Definition at line 100 of file iocomp.c.

{
    PKQUEUE Queue = ObjectBody;
    PLIST_ENTRY FirstEntry;
    PLIST_ENTRY CurrentEntry;
    PIRP Irp;
    PIOP_MINI_COMPLETION_PACKET Packet;
 
    /* Rundown the Queue */
    FirstEntry = KeRundownQueue(Queue);
    if (FirstEntry)
    {
        /* Loop the packets */
        CurrentEntry = FirstEntry;
        do
        {
            /* Get the Packet */
            Packet = CONTAINING_RECORD(CurrentEntry,
                                       IOP_MINI_COMPLETION_PACKET,
                                       ListEntry);
 
            /* Go to next Entry */
            CurrentEntry = CurrentEntry->Flink;
 
            /* Check if it's part of an IRP, or a separate packet */
            if (Packet->PacketType == IopCompletionPacketIrp)
            {
                /* Get the IRP and free it */
                Irp = CONTAINING_RECORD(Packet, IRP, Tail.Overlay.ListEntry);
                IoFreeIrp(Irp);
            }
            else
            {
                /* Use common routine */
                IopFreeMiniPacket(Packet);
            }
        } while (FirstEntry != CurrentEntry);
    }
}

Referenced by IopCreateObjectTypes().

◆ IopDereferenceDeviceObject()

VOID NTAPI IopDereferenceDeviceObject	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOLEAN	ForceUnload
	)

Definition at line 462 of file device.c.

{
    /* Sanity check */
    ASSERT(DeviceObject->ReferenceCount);
 
    /* Dereference the device */
    InterlockedDecrement(&DeviceObject->ReferenceCount);
 
    /*
     * Check if we can unload it and it's safe to unload (or if we're forcing
     * an unload, which is OK too).
     */
    ASSERT(!ForceUnload);
    if (!(DeviceObject->ReferenceCount) &&
        (IoGetDevObjExtension(DeviceObject)->ExtensionFlags & DOE_DELETE_PENDING))
    {
        /* Unload it */
        IopUnloadDevice(DeviceObject);
    }
}

Referenced by IoCreateStreamFileObjectEx(), IoCreateStreamFileObjectLite(), IopCheckVpbMounted(), IopDeleteFile(), and IopParseDevice().

◆ IopDereferenceVpbAndFree()

VOID NTAPI IopDereferenceVpbAndFree ( IN PVPB Vpb )

Definition at line 186 of file volume.c.

{
    KIRQL OldIrql;
 
    /* Lock the VPBs and decrease references */
    IoAcquireVpbSpinLock(&OldIrql);
    Vpb->ReferenceCount--;
 
    /* Check if we're out of references */
    if (!Vpb->ReferenceCount && Vpb->RealDevice->Vpb == Vpb &&
        !(Vpb->Flags & VPB_PERSISTENT))
    {
        /* Release VPB lock */
        IoReleaseVpbSpinLock(OldIrql);
 
        /* And free VPB */
        ExFreePoolWithTag(Vpb, TAG_VPB);
    }
    else
    {
        /* Release VPB lock */
        IoReleaseVpbSpinLock(OldIrql);
    }
}

Referenced by IopParseDevice(), and IoVerifyVolume().

◆ IopDetectResourceConflict()

NTSTATUS NTAPI IopDetectResourceConflict	(	IN PCM_RESOURCE_LIST	ResourceList,
		IN BOOLEAN	Silent,
		OUT OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR	ConflictingDescriptor
	)

Definition at line 1255 of file pnpres.c.

{
   OBJECT_ATTRIBUTES ObjectAttributes;
   UNICODE_STRING KeyName;
   HANDLE ResourceMapKey = NULL, ChildKey2 = NULL, ChildKey3 = NULL;
   ULONG KeyInformationLength, RequiredLength, KeyValueInformationLength, KeyNameInformationLength;
   PKEY_BASIC_INFORMATION KeyInformation;
   PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
   PKEY_VALUE_BASIC_INFORMATION KeyNameInformation;
   ULONG ChildKeyIndex1 = 0, ChildKeyIndex2, ChildKeyIndex3;
   NTSTATUS Status;
 
   RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\HARDWARE\\RESOURCEMAP");
   InitializeObjectAttributes(&ObjectAttributes,
                              &KeyName,
                              OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                              NULL,
                              NULL);
   Status = ZwOpenKey(&ResourceMapKey, KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &ObjectAttributes);
   if (!NT_SUCCESS(Status))
   {
      /* The key is missing which means we are the first device */
      return STATUS_SUCCESS;
   }
 
   while (TRUE)
   {
      Status = ZwEnumerateKey(ResourceMapKey,
                              ChildKeyIndex1,
                              KeyBasicInformation,
                              NULL,
                              0,
                              &RequiredLength);
      if (Status == STATUS_NO_MORE_ENTRIES)
          break;
      else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
      {
          KeyInformationLength = RequiredLength;
          KeyInformation = ExAllocatePoolWithTag(PagedPool,
                                                 KeyInformationLength,
                                                 TAG_IO);
          if (!KeyInformation)
          {
              Status = STATUS_INSUFFICIENT_RESOURCES;
              goto cleanup;
          }
 
          Status = ZwEnumerateKey(ResourceMapKey,
                                  ChildKeyIndex1,
                                  KeyBasicInformation,
                                  KeyInformation,
                                  KeyInformationLength,
                                  &RequiredLength);
      }
      else
         goto cleanup;
      ChildKeyIndex1++;
      if (!NT_SUCCESS(Status))
      {
          ExFreePoolWithTag(KeyInformation, TAG_IO);
          goto cleanup;
      }
 
      KeyName.Buffer = KeyInformation->Name;
      KeyName.MaximumLength = KeyName.Length = (USHORT)KeyInformation->NameLength;
      InitializeObjectAttributes(&ObjectAttributes,
                                 &KeyName,
                                 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                 ResourceMapKey,
                                 NULL);
      Status = ZwOpenKey(&ChildKey2,
                         KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
                         &ObjectAttributes);
      ExFreePoolWithTag(KeyInformation, TAG_IO);
      if (!NT_SUCCESS(Status))
          goto cleanup;
 
      ChildKeyIndex2 = 0;
      while (TRUE)
      {
          Status = ZwEnumerateKey(ChildKey2,
                                  ChildKeyIndex2,
                                  KeyBasicInformation,
                                  NULL,
                                  0,
                                  &RequiredLength);
          if (Status == STATUS_NO_MORE_ENTRIES)
              break;
          else if (Status == STATUS_BUFFER_TOO_SMALL)
          {
              KeyInformationLength = RequiredLength;
              KeyInformation = ExAllocatePoolWithTag(PagedPool,
                                                     KeyInformationLength,
                                                     TAG_IO);
              if (!KeyInformation)
              {
                  Status = STATUS_INSUFFICIENT_RESOURCES;
                  goto cleanup;
              }
 
              Status = ZwEnumerateKey(ChildKey2,
                                      ChildKeyIndex2,
                                      KeyBasicInformation,
                                      KeyInformation,
                                      KeyInformationLength,
                                      &RequiredLength);
          }
          else
              goto cleanup;
          ChildKeyIndex2++;
          if (!NT_SUCCESS(Status))
          {
              ExFreePoolWithTag(KeyInformation, TAG_IO);
              goto cleanup;
          }
 
          KeyName.Buffer = KeyInformation->Name;
          KeyName.MaximumLength = KeyName.Length = (USHORT)KeyInformation->NameLength;
          InitializeObjectAttributes(&ObjectAttributes,
                                     &KeyName,
                                     OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                     ChildKey2,
                                     NULL);
          Status = ZwOpenKey(&ChildKey3, KEY_QUERY_VALUE, &ObjectAttributes);
          ExFreePoolWithTag(KeyInformation, TAG_IO);
          if (!NT_SUCCESS(Status))
              goto cleanup;
 
          ChildKeyIndex3 = 0;
          while (TRUE)
          {
              Status = ZwEnumerateValueKey(ChildKey3,
                                           ChildKeyIndex3,
                                           KeyValuePartialInformation,
                                           NULL,
                                           0,
                                           &RequiredLength);
              if (Status == STATUS_NO_MORE_ENTRIES)
                  break;
              else if (Status == STATUS_BUFFER_TOO_SMALL)
              {
                  KeyValueInformationLength = RequiredLength;
                  KeyValueInformation = ExAllocatePoolWithTag(PagedPool,
                                                              KeyValueInformationLength,
                                                              TAG_IO);
                  if (!KeyValueInformation)
                  {
                      Status = STATUS_INSUFFICIENT_RESOURCES;
                      goto cleanup;
                  }
 
                  Status = ZwEnumerateValueKey(ChildKey3,
                                               ChildKeyIndex3,
                                               KeyValuePartialInformation,
                                               KeyValueInformation,
                                               KeyValueInformationLength,
                                               &RequiredLength);
              }
              else
                  goto cleanup;
              if (!NT_SUCCESS(Status))
              {
                  ExFreePoolWithTag(KeyValueInformation, TAG_IO);
                  goto cleanup;
              }
 
              Status = ZwEnumerateValueKey(ChildKey3,
                                           ChildKeyIndex3,
                                           KeyValueBasicInformation,
                                           NULL,
                                           0,
                                           &RequiredLength);
              if (Status == STATUS_BUFFER_TOO_SMALL)
              {
                  KeyNameInformationLength = RequiredLength;
                  KeyNameInformation = ExAllocatePoolWithTag(PagedPool,
                                                             KeyNameInformationLength + sizeof(WCHAR),
                                                             TAG_IO);
                  if (!KeyNameInformation)
                  {
                      Status = STATUS_INSUFFICIENT_RESOURCES;
                      goto cleanup;
                  }
 
                  Status = ZwEnumerateValueKey(ChildKey3,
                                               ChildKeyIndex3,
                                               KeyValueBasicInformation,
                                               KeyNameInformation,
                                               KeyNameInformationLength,
                                               &RequiredLength);
              }
              else
                  goto cleanup;
              ChildKeyIndex3++;
              if (!NT_SUCCESS(Status))
              {
                  ExFreePoolWithTag(KeyNameInformation, TAG_IO);
                  goto cleanup;
              }
 
              KeyNameInformation->Name[KeyNameInformation->NameLength / sizeof(WCHAR)] = UNICODE_NULL;
 
              /* Skip translated entries */
              if (wcsstr(KeyNameInformation->Name, L".Translated"))
              {
                  ExFreePoolWithTag(KeyNameInformation, TAG_IO);
                  ExFreePoolWithTag(KeyValueInformation, TAG_IO);
                  continue;
              }
 
              ExFreePoolWithTag(KeyNameInformation, TAG_IO);
 
              if (IopCheckForResourceConflict(ResourceList,
                                              (PCM_RESOURCE_LIST)KeyValueInformation->Data,
                                              Silent,
                                              ConflictingDescriptor))
              {
                  ExFreePoolWithTag(KeyValueInformation, TAG_IO);
                  Status = STATUS_CONFLICTING_ADDRESSES;
                  goto cleanup;
              }
 
              ExFreePoolWithTag(KeyValueInformation, TAG_IO);
          }
      }
   }
 
cleanup:
   if (ResourceMapKey != NULL)
       ObCloseHandle(ResourceMapKey, KernelMode);
   if (ChildKey2 != NULL)
       ObCloseHandle(ChildKey2, KernelMode);
   if (ChildKey3 != NULL)
       ObCloseHandle(ChildKey3, KernelMode);
 
   if (Status == STATUS_NO_MORE_ENTRIES)
       Status = STATUS_SUCCESS;
 
   return Status;
}

Referenced by IopAssignDeviceResources(), IopCheckDescriptorForConflict(), IoReportResourceForDetection(), and IoReportResourceUsage().

◆ IopDoNameTransmogrify()

VOID NTAPI IopDoNameTransmogrify	(	IN PIRP	Irp,
		IN PFILE_OBJECT	FileObject,
		IN PREPARSE_DATA_BUFFER	DataBuffer
	)

Definition at line 170 of file file.c.

{
    PWSTR Buffer;
    USHORT Length;
    USHORT RequiredLength;
    PWSTR NewBuffer;
 
    PAGED_CODE();
 
    ASSERT(Irp->IoStatus.Status == STATUS_REPARSE);
    ASSERT(Irp->IoStatus.Information == IO_REPARSE_TAG_MOUNT_POINT);
    ASSERT(Irp->Tail.Overlay.AuxiliaryBuffer != NULL);
    ASSERT(DataBuffer != NULL);
    ASSERT(DataBuffer->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT);
    ASSERT(DataBuffer->ReparseDataLength < MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
    ASSERT(DataBuffer->Reserved < MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
 
    /* First of all, validate data */
    if (DataBuffer->ReparseDataLength < REPARSE_DATA_BUFFER_HEADER_SIZE ||
        (DataBuffer->SymbolicLinkReparseBuffer.PrintNameLength +
         DataBuffer->SymbolicLinkReparseBuffer.SubstituteNameLength +
         FIELD_OFFSET(REPARSE_DATA_BUFFER, MountPointReparseBuffer.PathBuffer[0])) > MAXIMUM_REPARSE_DATA_BUFFER_SIZE)
    {
        Irp->IoStatus.Status = STATUS_IO_REPARSE_DATA_INVALID;
    }
 
    /* Everything went right */
    if (NT_SUCCESS(Irp->IoStatus.Status))
    {
        /* Compute buffer & length */
        Buffer = (PWSTR)((ULONG_PTR)DataBuffer->MountPointReparseBuffer.PathBuffer +
                                    DataBuffer->MountPointReparseBuffer.SubstituteNameOffset);
        Length = DataBuffer->MountPointReparseBuffer.SubstituteNameLength;
 
        /* Check we don't overflow */
        if (((ULONG)MAXUSHORT - DataBuffer->Reserved) <= (Length + sizeof(UNICODE_NULL)))
        {
            Irp->IoStatus.Status = STATUS_IO_REPARSE_DATA_INVALID;
        }
        else
        {
            /* Compute how much memory we'll need */
            RequiredLength = DataBuffer->Reserved + Length + sizeof(UNICODE_NULL);
 
            /* Check if FileObject can already hold what we need */
            if (FileObject->FileName.MaximumLength >= RequiredLength)
            {
                NewBuffer = FileObject->FileName.Buffer;
            }
            else
            {
                /* Allocate otherwise */
                NewBuffer = ExAllocatePoolWithTag(PagedPool, RequiredLength, TAG_IO_NAME);
                if (NewBuffer == NULL)
                {
                    Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
                }
            }
        }
    }
 
    /* Everything went right */
    if (NT_SUCCESS(Irp->IoStatus.Status))
    {
        /* Copy the reserved data */
        if (DataBuffer->Reserved)
        {
            RtlMoveMemory((PWSTR)((ULONG_PTR)NewBuffer + Length),
                          (PWSTR)((ULONG_PTR)FileObject->FileName.Buffer + FileObject->FileName.Length - DataBuffer->Reserved),
                          DataBuffer->Reserved);
        }
 
        /* Then the buffer */
        if (Length)
        {
            RtlCopyMemory(NewBuffer, Buffer, Length);
        }
 
        /* And finally replace buffer if new one was allocated */
        FileObject->FileName.Length = RequiredLength - sizeof(UNICODE_NULL);
        if (NewBuffer != FileObject->FileName.Buffer)
        {
            if (FileObject->FileName.Buffer)
            {
                /*
                 * Don't use TAG_IO_NAME since the FileObject's FileName
                 * may have been re-allocated using a different tag
                 * by a filesystem.
                 */
                ExFreePoolWithTag(FileObject->FileName.Buffer, 0);
            }
 
            FileObject->FileName.Buffer = NewBuffer;
            FileObject->FileName.MaximumLength = RequiredLength;
            FileObject->FileName.Buffer[RequiredLength / sizeof(WCHAR) - 1] = UNICODE_NULL;
        }
    }
 
    /* We don't need them anymore - it was allocated by the driver */
    ExFreePool(DataBuffer);
}

Referenced by IopCompleteRequest(), and IopParseDevice().

◆ IopFetchConfigurationInformation()

NTSTATUS IopFetchConfigurationInformation	(	_Out_ PWSTR *	SymbolicLinkList,
		_In_ GUID	Guid,
		_In_ ULONG	ExpectedInterfaces,
		_Out_ PULONG	Interfaces
	)

Definition at line 821 of file iorsrce.c.

{
    NTSTATUS Status;
    ULONG interfaces = 0;
    PWSTR symbolicLinkList;
 
    /* Get the associated enabled interfaces with the given GUID */
    Status = IoGetDeviceInterfaces(&Guid, NULL, 0, SymbolicLinkList);
    if (!NT_SUCCESS(Status))
    {
        /* Zero output and leave */
        if (SymbolicLinkList)
            *SymbolicLinkList = NULL;
 
        return STATUS_UNSUCCESSFUL;
    }
 
    symbolicLinkList = *SymbolicLinkList;
 
    /* Count the number of enabled interfaces by counting the number of symbolic links */
    while (*symbolicLinkList != UNICODE_NULL)
    {
        interfaces++;
        symbolicLinkList += (wcslen(symbolicLinkList) + 1);
    }
 
    /* Matching result will define the result */
    Status = (interfaces >= ExpectedInterfaces) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
    /* Finally, give back to the caller the number of found interfaces */
    *Interfaces = interfaces;
 
    return Status;
}

Referenced by IopCreateArcNamesCd(), and IopCreateArcNamesDisk().

◆ IopFixupResourceListWithRequirements()

NTSTATUS NTAPI IopFixupResourceListWithRequirements	(	IN PIO_RESOURCE_REQUIREMENTS_LIST	RequirementsList,
		OUT PCM_RESOURCE_LIST *	ResourceList
	)

Definition at line 219 of file pnpres.c.

{
    ULONG i, OldCount;
    BOOLEAN AlternateRequired = FALSE;
    PIO_RESOURCE_LIST ResList;
 
    /* Save the initial resource count when we got here so we can restore if an alternate fails */
    if (*ResourceList != NULL)
        OldCount = (*ResourceList)->List[0].PartialResourceList.Count;
    else
        OldCount = 0;
 
    ResList = &RequirementsList->List[0];
    for (i = 0; i < RequirementsList->AlternativeLists; i++, ResList = IopGetNextResourceList(ResList))
    {
        ULONG ii;
 
        /* We need to get back to where we were before processing the last alternative list */
        if (OldCount == 0 && *ResourceList != NULL)
        {
            /* Just free it and kill the pointer */
            ExFreePool(*ResourceList);
            *ResourceList = NULL;
        }
        else if (OldCount != 0)
        {
            PCM_RESOURCE_LIST NewList;
 
            /* Let's resize it */
            (*ResourceList)->List[0].PartialResourceList.Count = OldCount;
 
            /* Allocate the new smaller list */
            NewList = ExAllocatePool(PagedPool, PnpDetermineResourceListSize(*ResourceList));
            if (!NewList)
                return STATUS_NO_MEMORY;
 
            /* Copy the old stuff back */
            RtlCopyMemory(NewList, *ResourceList, PnpDetermineResourceListSize(*ResourceList));
 
            /* Free the old one */
            ExFreePool(*ResourceList);
 
            /* Store the pointer to the new one */
            *ResourceList = NewList;
        }
 
        for (ii = 0; ii < ResList->Count; ii++)
        {
            ULONG iii;
            PCM_PARTIAL_RESOURCE_LIST PartialList = (*ResourceList) ? &(*ResourceList)->List[0].PartialResourceList : NULL;
            PIO_RESOURCE_DESCRIPTOR IoDesc = &ResList->Descriptors[ii];
            BOOLEAN Matched = FALSE;
 
            /* Skip alternates if we don't need one */
            if (!AlternateRequired && (IoDesc->Option & IO_RESOURCE_ALTERNATIVE))
            {
                DPRINT("Skipping unneeded alternate\n");
                continue;
            }
 
            /* Check if we couldn't satsify a requirement or its alternates */
            if (AlternateRequired && !(IoDesc->Option & IO_RESOURCE_ALTERNATIVE))
            {
                DPRINT1("Unable to satisfy preferred resource or alternates in list %lu\n", i);
 
                /* Break out of this loop and try the next list */
                break;
            }
 
            for (iii = 0; PartialList && iii < PartialList->Count && !Matched; iii++)
            {
                /* Partial resource descriptors can be of variable size (CmResourceTypeDeviceSpecific),
                   but only one is allowed and it must be the last one in the list! */
                PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc = &PartialList->PartialDescriptors[iii];
 
                /* First check types */
                if (IoDesc->Type != CmDesc->Type)
                    continue;
 
                switch (IoDesc->Type)
                {
                    case CmResourceTypeInterrupt:
                        /* Make sure it satisfies our vector range */
                        if (CmDesc->u.Interrupt.Vector >= IoDesc->u.Interrupt.MinimumVector &&
                            CmDesc->u.Interrupt.Vector <= IoDesc->u.Interrupt.MaximumVector)
                        {
                            /* Found it */
                            Matched = TRUE;
                        }
                        else
                        {
                            DPRINT("Interrupt - Not a match! 0x%x not inside 0x%x to 0x%x\n",
                                   CmDesc->u.Interrupt.Vector,
                                   IoDesc->u.Interrupt.MinimumVector,
                                   IoDesc->u.Interrupt.MaximumVector);
                        }
                        break;
 
                    case CmResourceTypeMemory:
                    case CmResourceTypePort:
                        /* Make sure the length matches and it satisfies our address range */
                        if (CmDesc->u.Memory.Length == IoDesc->u.Memory.Length &&
                            (ULONGLONG)CmDesc->u.Memory.Start.QuadPart >= (ULONGLONG)IoDesc->u.Memory.MinimumAddress.QuadPart &&
                            (ULONGLONG)CmDesc->u.Memory.Start.QuadPart + CmDesc->u.Memory.Length - 1 <= (ULONGLONG)IoDesc->u.Memory.MaximumAddress.QuadPart)
                        {
                            /* Found it */
                            Matched = TRUE;
                        }
                        else
                        {
                            DPRINT("Memory/Port - Not a match! 0x%I64x with length 0x%x not inside 0x%I64x to 0x%I64x with length 0x%x\n",
                                   CmDesc->u.Memory.Start.QuadPart,
                                   CmDesc->u.Memory.Length,
                                   IoDesc->u.Memory.MinimumAddress.QuadPart,
                                   IoDesc->u.Memory.MaximumAddress.QuadPart,
                                   IoDesc->u.Memory.Length);
                        }
                        break;
 
                    case CmResourceTypeBusNumber:
                        /* Make sure the length matches and it satisfies our bus number range */
                        if (CmDesc->u.BusNumber.Length == IoDesc->u.BusNumber.Length &&
                            CmDesc->u.BusNumber.Start >= IoDesc->u.BusNumber.MinBusNumber &&
                            CmDesc->u.BusNumber.Start + CmDesc->u.BusNumber.Length - 1 <= IoDesc->u.BusNumber.MaxBusNumber)
                        {
                            /* Found it */
                            Matched = TRUE;
                        }
                        else
                        {
                            DPRINT("Bus Number - Not a match! 0x%x with length 0x%x not inside 0x%x to 0x%x with length 0x%x\n",
                                   CmDesc->u.BusNumber.Start,
                                   CmDesc->u.BusNumber.Length,
                                   IoDesc->u.BusNumber.MinBusNumber,
                                   IoDesc->u.BusNumber.MaxBusNumber,
                                   IoDesc->u.BusNumber.Length);
                        }
                        break;
 
                    case CmResourceTypeDma:
                        /* Make sure it fits in our channel range */
                        if (CmDesc->u.Dma.Channel >= IoDesc->u.Dma.MinimumChannel &&
                            CmDesc->u.Dma.Channel <= IoDesc->u.Dma.MaximumChannel)
                        {
                            /* Found it */
                            Matched = TRUE;
                        }
                        else
                        {
                            DPRINT("DMA - Not a match! 0x%x not inside 0x%x to 0x%x\n",
                                   CmDesc->u.Dma.Channel,
                                   IoDesc->u.Dma.MinimumChannel,
                                   IoDesc->u.Dma.MaximumChannel);
                        }
                        break;
 
                    default:
                        /* Other stuff is fine */
                        Matched = TRUE;
                        break;
                }
            }
 
            /* Check if we found a matching descriptor */
            if (!Matched)
            {
                PCM_RESOURCE_LIST NewList;
                CM_PARTIAL_RESOURCE_DESCRIPTOR NewDesc;
                PCM_PARTIAL_RESOURCE_DESCRIPTOR DescPtr;
                BOOLEAN FoundResource = TRUE;
 
                /* Setup the new CM descriptor */
                NewDesc.Type = IoDesc->Type;
                NewDesc.Flags = IoDesc->Flags;
                NewDesc.ShareDisposition = IoDesc->ShareDisposition;
 
                /* Let'se see if we can find a resource to satisfy this */
                switch (IoDesc->Type)
                {
                    case CmResourceTypeInterrupt:
                        /* Find an available interrupt */
                        if (!IopFindInterruptResource(IoDesc, &NewDesc))
                        {
                            DPRINT1("Failed to find an available interrupt resource (0x%x to 0x%x)\n",
                                    IoDesc->u.Interrupt.MinimumVector, IoDesc->u.Interrupt.MaximumVector);
 
                            FoundResource = FALSE;
                        }
                        break;
 
                    case CmResourceTypePort:
                        /* Find an available port range */
                        if (!IopFindPortResource(IoDesc, &NewDesc))
                        {
                            DPRINT1("Failed to find an available port resource (0x%I64x to 0x%I64x length: 0x%x)\n",
                                    IoDesc->u.Port.MinimumAddress.QuadPart, IoDesc->u.Port.MaximumAddress.QuadPart,
                                    IoDesc->u.Port.Length);
 
                            FoundResource = FALSE;
                        }
                        break;
 
                    case CmResourceTypeMemory:
                        /* Find an available memory range */
                        if (!IopFindMemoryResource(IoDesc, &NewDesc))
                        {
                            DPRINT1("Failed to find an available memory resource (0x%I64x to 0x%I64x length: 0x%x)\n",
                                    IoDesc->u.Memory.MinimumAddress.QuadPart, IoDesc->u.Memory.MaximumAddress.QuadPart,
                                    IoDesc->u.Memory.Length);
 
                            FoundResource = FALSE;
                        }
                        break;
 
                    case CmResourceTypeBusNumber:
                        /* Find an available bus address range */
                        if (!IopFindBusNumberResource(IoDesc, &NewDesc))
                        {
                            DPRINT1("Failed to find an available bus number resource (0x%x to 0x%x length: 0x%x)\n",
                                    IoDesc->u.BusNumber.MinBusNumber, IoDesc->u.BusNumber.MaxBusNumber,
                                    IoDesc->u.BusNumber.Length);
 
                            FoundResource = FALSE;
                        }
                        break;
 
                    case CmResourceTypeDma:
                        /* Find an available DMA channel */
                        if (!IopFindDmaResource(IoDesc, &NewDesc))
                        {
                            DPRINT1("Failed to find an available dma resource (0x%x to 0x%x)\n",
                                    IoDesc->u.Dma.MinimumChannel, IoDesc->u.Dma.MaximumChannel);
 
                            FoundResource = FALSE;
                        }
                        break;
 
                    default:
                        DPRINT1("Unsupported resource type: %x\n", IoDesc->Type);
                        FoundResource = FALSE;
                        break;
                }
 
                /* Check if it's missing and required */
                if (!FoundResource && IoDesc->Option == 0)
                {
                    /* Break out of this loop and try the next list */
                    DPRINT1("Unable to satisfy required resource in list %lu\n", i);
                    break;
                }
                else if (!FoundResource)
                {
                    /* Try an alternate for this preferred descriptor */
                    AlternateRequired = TRUE;
                    continue;
                }
                else
                {
                    /* Move on to the next preferred or required descriptor after this one */
                    AlternateRequired = FALSE;
                }
 
                /* Figure out what we need */
                if (PartialList == NULL)
                {
                    /* We need a new list */
                    NewList = ExAllocatePool(PagedPool, sizeof(CM_RESOURCE_LIST));
                    if (!NewList)
                        return STATUS_NO_MEMORY;
 
                    /* Set it up */
                    NewList->Count = 1;
                    NewList->List[0].InterfaceType = RequirementsList->InterfaceType;
                    NewList->List[0].BusNumber = RequirementsList->BusNumber;
                    NewList->List[0].PartialResourceList.Version = 1;
                    NewList->List[0].PartialResourceList.Revision = 1;
                    NewList->List[0].PartialResourceList.Count = 1;
 
                    /* Set our pointer */
                    DescPtr = &NewList->List[0].PartialResourceList.PartialDescriptors[0];
                }
                else
                {
                    /* Allocate the new larger list */
                    NewList = ExAllocatePool(PagedPool, PnpDetermineResourceListSize(*ResourceList) + sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
                    if (!NewList)
                        return STATUS_NO_MEMORY;
 
                    /* Copy the old stuff back */
                    RtlCopyMemory(NewList, *ResourceList, PnpDetermineResourceListSize(*ResourceList));
 
                    /* Set our pointer */
                    DescPtr = &NewList->List[0].PartialResourceList.PartialDescriptors[NewList->List[0].PartialResourceList.Count];
 
                    /* Increment the descriptor count */
                    NewList->List[0].PartialResourceList.Count++;
 
                    /* Free the old list */
                    ExFreePool(*ResourceList);
                }
 
                /* Copy the descriptor in */
                *DescPtr = NewDesc;
 
                /* Store the new list */
                *ResourceList = NewList;
            }
        }
 
        /* Check if we need an alternate with no resources left */
        if (AlternateRequired)
        {
            DPRINT1("Unable to satisfy preferred resource or alternates in list %lu\n", i);
 
            /* Try the next alternate list */
            continue;
        }
 
        /* We're done because we satisfied one of the alternate lists */
        return STATUS_SUCCESS;
    }
 
    /* We ran out of alternates */
    DPRINT1("Out of alternate lists!\n");
 
    /* Free the list */
    if (*ResourceList)
    {
        ExFreePool(*ResourceList);
        *ResourceList = NULL;
    }
 
    /* Fail */
    return STATUS_CONFLICTING_ADDRESSES;
}

Referenced by IopAssignDeviceResources(), and IopLegacyResourceAllocation().

◆ IopFreeDeviceNode()

NTSTATUS IopFreeDeviceNode ( IN PDEVICE_NODE DeviceNode )

Referenced by IopDeleteDevice(), and PiControlInitializeDevice().

◆ IopGetDeviceAttachmentBase()

PDEVICE_OBJECT NTAPI IopGetDeviceAttachmentBase ( IN PDEVICE_OBJECT DeviceObject )

Definition at line 1486 of file file.c.

{
    PDEVICE_OBJECT PDO = DeviceObject;
 
    /* Go down the stack to attempt to get the PDO */
    for (; ((PEXTENDED_DEVOBJ_EXTENSION)PDO->DeviceObjectExtension)->AttachedTo != NULL;
           PDO = ((PEXTENDED_DEVOBJ_EXTENSION)PDO->DeviceObjectExtension)->AttachedTo);
 
    return PDO;
}

Referenced by IopGetDevicePDO(), and IopVerifyDriverObjectOnStack().

◆ IopGetDeviceNode()

◆ IopGetDriverNames()

NTSTATUS IopGetDriverNames	(	_In_ HANDLE	ServiceHandle,
		_Out_ PUNICODE_STRING	DriverName,
		_Out_opt_ PUNICODE_STRING	ServiceName
	)

Definition at line 123 of file driver.c.

{
    UNICODE_STRING driverName = {.Buffer = NULL}, serviceName;
    PKEY_VALUE_FULL_INFORMATION kvInfo;
    NTSTATUS status;
 
    PAGED_CODE();
 
    /* 1. Check the "ObjectName" field in the driver's registry key (it has priority) */
    status = IopGetRegistryValue(ServiceHandle, L"ObjectName", &kvInfo);
    if (NT_SUCCESS(status))
    {
        /* We've got the ObjectName, use it as the driver name */
        if (kvInfo->Type != REG_SZ || kvInfo->DataLength == 0)
        {
            ExFreePool(kvInfo);
            return STATUS_ILL_FORMED_SERVICE_ENTRY;
        }
 
        driverName.Length = kvInfo->DataLength - sizeof(UNICODE_NULL);
        driverName.MaximumLength = kvInfo->DataLength;
        driverName.Buffer = ExAllocatePoolWithTag(NonPagedPool, driverName.MaximumLength, TAG_IO);
        if (!driverName.Buffer)
        {
            ExFreePool(kvInfo);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlMoveMemory(driverName.Buffer,
                      (PVOID)((ULONG_PTR)kvInfo + kvInfo->DataOffset),
                      driverName.Length);
        driverName.Buffer[driverName.Length / sizeof(WCHAR)] = UNICODE_NULL;
        ExFreePool(kvInfo);
    }
 
    /* Check whether we need to get ServiceName as well, either to construct
     * the driver name (because we could not use "ObjectName"), or because
     * it is requested by the caller. */
    PKEY_BASIC_INFORMATION basicInfo = NULL;
    if (!NT_SUCCESS(status) || ServiceName != NULL)
    {
        /* Retrieve the necessary buffer size */
        ULONG infoLength;
        status = ZwQueryKey(ServiceHandle, KeyBasicInformation, NULL, 0, &infoLength);
        if (status != STATUS_BUFFER_TOO_SMALL)
        {
            status = (NT_SUCCESS(status) ? STATUS_UNSUCCESSFUL : status);
            goto Cleanup;
        }
 
        /* Allocate the buffer and retrieve the data */
        basicInfo = ExAllocatePoolWithTag(PagedPool, infoLength, TAG_IO);
        if (!basicInfo)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Cleanup;
        }
 
        status = ZwQueryKey(ServiceHandle, KeyBasicInformation, basicInfo, infoLength, &infoLength);
        if (!NT_SUCCESS(status))
        {
            goto Cleanup;
        }
 
        serviceName.Length = basicInfo->NameLength;
        serviceName.MaximumLength = basicInfo->NameLength;
        serviceName.Buffer = basicInfo->Name;
    }
 
    /* 2. There is no "ObjectName" - construct it ourselves. Depending on the driver type,
     * it will be either "\Driver<ServiceName>" or "\FileSystem<ServiceName>" */
    if (driverName.Buffer == NULL)
    {
        ASSERT(basicInfo); // Container for serviceName
 
        /* Retrieve the driver type */
        ULONG driverType;
        status = IopGetRegistryValue(ServiceHandle, L"Type", &kvInfo);
        if (!NT_SUCCESS(status))
        {
            goto Cleanup;
        }
        if (kvInfo->Type != REG_DWORD || kvInfo->DataLength != sizeof(ULONG))
        {
            ExFreePool(kvInfo);
            status = STATUS_ILL_FORMED_SERVICE_ENTRY;
            goto Cleanup;
        }
 
        RtlMoveMemory(&driverType,
                      (PVOID)((ULONG_PTR)kvInfo + kvInfo->DataOffset),
                      sizeof(ULONG));
        ExFreePool(kvInfo);
 
        /* Compute the necessary driver name string size */
        if (driverType == SERVICE_RECOGNIZER_DRIVER || driverType == SERVICE_FILE_SYSTEM_DRIVER)
            driverName.MaximumLength = sizeof(FILESYSTEM_ROOT_NAME);
        else
            driverName.MaximumLength = sizeof(DRIVER_ROOT_NAME);
 
        driverName.MaximumLength += serviceName.Length;
        driverName.Length = 0;
 
        /* Allocate and build it */
        driverName.Buffer = ExAllocatePoolWithTag(NonPagedPool, driverName.MaximumLength, TAG_IO);
        if (!driverName.Buffer)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Cleanup;
        }
 
        if (driverType == SERVICE_RECOGNIZER_DRIVER || driverType == SERVICE_FILE_SYSTEM_DRIVER)
            RtlAppendUnicodeToString(&driverName, FILESYSTEM_ROOT_NAME);
        else
            RtlAppendUnicodeToString(&driverName, DRIVER_ROOT_NAME);
 
        RtlAppendUnicodeStringToString(&driverName, &serviceName);
    }
 
    if (ServiceName != NULL)
    {
        ASSERT(basicInfo); // Container for serviceName
 
        /* Allocate a copy for the caller */
        PWCHAR buf = ExAllocatePoolWithTag(PagedPool, serviceName.Length, TAG_IO);
        if (!buf)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Cleanup;
        }
        RtlMoveMemory(buf, serviceName.Buffer, serviceName.Length);
        ServiceName->MaximumLength = serviceName.Length;
        ServiceName->Length = serviceName.Length;
        ServiceName->Buffer = buf;
    }
 
    *DriverName = driverName;
    status = STATUS_SUCCESS;
 
Cleanup:
    if (basicInfo)
        ExFreePoolWithTag(basicInfo, TAG_IO);
 
    if (!NT_SUCCESS(status) && driverName.Buffer)
        ExFreePoolWithTag(driverName.Buffer, TAG_IO);
 
    return status;
}

Referenced by IopInitializeDriverModule(), and PiAttachFilterDriversCallback().

◆ IopGetFileInformation()

NTSTATUS NTAPI IopGetFileInformation	(	IN PFILE_OBJECT	FileObject,
		IN ULONG	Length,
		IN FILE_INFORMATION_CLASS	FileInfoClass,
		OUT PVOID	Buffer,
		OUT PULONG	ReturnedLength
	)

Definition at line 777 of file iofunc.c.

{
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
    PIO_STACK_LOCATION Stack;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK IoStatusBlock;
 
    PAGED_CODE();
 
    /* Allocate an IRP */
    ObReferenceObject(FileObject);
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
    if (Irp == NULL)
    {
        ObDereferenceObject(FileObject);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Init event */
    KeInitializeEvent(&Event, SynchronizationEvent, FALSE);
 
    /* Setup the IRP */
    Irp->UserIosb = &IoStatusBlock;
    Irp->UserEvent = &Event;
    Irp->Overlay.AsynchronousParameters.UserApcRoutine = NULL;
    Irp->RequestorMode = KernelMode;
    Irp->AssociatedIrp.SystemBuffer = Buffer;
    Irp->Flags = IRP_SYNCHRONOUS_API | IRP_BUFFERED_IO | IRP_OB_QUERY_NAME;
    Irp->Tail.Overlay.OriginalFileObject = FileObject;
    Irp->Tail.Overlay.Thread = PsGetCurrentThread();
 
    Stack = IoGetNextIrpStackLocation(Irp);
    Stack->MajorFunction = IRP_MJ_QUERY_INFORMATION;
    Stack->FileObject = FileObject;
    Stack->Parameters.QueryFile.FileInformationClass = FileInfoClass;
    Stack->Parameters.QueryFile.Length = Length;
 
 
    /* Queue the IRP */
    IopQueueIrpToThread(Irp);
 
    /* Call the driver */
    Status = IoCallDriver(DeviceObject, Irp);
    if (Status == STATUS_PENDING)
    {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatusBlock.Status;
    }
 
    *ReturnedLength = IoStatusBlock.Information;
    return Status;
}

Referenced by IopGetBasicInformationFile(), and IopQueryNameInternal().

◆ IopGetRegistryValue()

NTSTATUS NTAPI IopGetRegistryValue	(	IN HANDLE	Handle,
		IN PWSTR	ValueName,
		OUT PKEY_VALUE_FULL_INFORMATION *	Information
	)

Definition at line 1036 of file pnpmgr.c.

{
    UNICODE_STRING ValueString;
    NTSTATUS Status;
    PKEY_VALUE_FULL_INFORMATION FullInformation;
    ULONG Size;
    PAGED_CODE();
 
    RtlInitUnicodeString(&ValueString, ValueName);
 
    Status = ZwQueryValueKey(Handle,
                             &ValueString,
                             KeyValueFullInformation,
                             NULL,
                             0,
                             &Size);
    if ((Status != STATUS_BUFFER_OVERFLOW) &&
        (Status != STATUS_BUFFER_TOO_SMALL))
    {
        return Status;
    }
 
    FullInformation = ExAllocatePool(NonPagedPool, Size);
    if (!FullInformation) return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = ZwQueryValueKey(Handle,
                             &ValueString,
                             KeyValueFullInformation,
                             FullInformation,
                             Size,
                             &Size);
    if (!NT_SUCCESS(Status))
    {
        ExFreePool(FullInformation);
        return Status;
    }
 
    *Information = FullInformation;
    return STATUS_SUCCESS;
}

Referenced by IoGetDeviceInterfaceAlias(), IopGetDriverNames(), IopInitializeBuiltinDriver(), IopLoadDriver(), IopSetServiceEnumData(), PiAttachFilterDriversCallback(), PiCallDriverAddDevice(), PiGetDeviceRegistryProperty(), PiInitCacheGroupInformation(), PipGetDriverTagPriority(), and PpInitGetGroupOrderIndex().

◆ IopGetRelatedTargetDevice()

NTSTATUS NTAPI IopGetRelatedTargetDevice	(	IN PFILE_OBJECT	FileObject,
		OUT PDEVICE_NODE *	DeviceNode
	)

Definition at line 653 of file device.c.

{
    NTSTATUS Status;
    IO_STACK_LOCATION Stack = {0};
    PDEVICE_RELATIONS DeviceRelations;
    PDEVICE_OBJECT DeviceObject = NULL;
 
    ASSERT(FileObject);
 
    /* Get DeviceObject related to given FileObject */
    DeviceObject = IoGetRelatedDeviceObject(FileObject);
    if (!DeviceObject) return STATUS_NO_SUCH_DEVICE;
 
    /* Define input parameters */
    Stack.MajorFunction = IRP_MJ_PNP;
    Stack.MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS;
    Stack.Parameters.QueryDeviceRelations.Type = TargetDeviceRelation;
    Stack.FileObject = FileObject;
 
    /* Call the driver to query all relations (IRP_MJ_PNP) */
    Status = IopSynchronousCall(DeviceObject,
                                &Stack,
                                (PVOID)&DeviceRelations);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Make sure it's not NULL and contains only one object */
    ASSERT(DeviceRelations);
    ASSERT(DeviceRelations->Count == 1);
 
    /* Finally get the device node */
    *DeviceNode = IopGetDeviceNode(DeviceRelations->Objects[0]);
    if (!*DeviceNode) Status = STATUS_NO_SUCH_DEVICE;
 
    /* Free the DEVICE_RELATIONS structure, it's not needed anymore */
    ExFreePool(DeviceRelations);
 
    return Status;
}

Referenced by IoGetRelatedTargetDevice(), and IoRegisterPlugPlayNotification().

◆ IopGetSetSecurityObject()

NTSTATUS NTAPI IopGetSetSecurityObject	(	IN PVOID	ObjectBody,
		IN SECURITY_OPERATION_CODE	OperationCode,
		IN PSECURITY_INFORMATION	SecurityInformation,
		IN OUT PSECURITY_DESCRIPTOR	SecurityDescriptor,
		IN OUT PULONG	BufferLength,
		OUT PSECURITY_DESCRIPTOR *	OldSecurityDescriptor,
		IN POOL_TYPE	PoolType,
		IN OUT PGENERIC_MAPPING	GenericMapping
	)

Referenced by IopCreateObjectTypes().

◆ IopGetSystemPowerDeviceObject()

NTSTATUS IopGetSystemPowerDeviceObject ( IN PDEVICE_OBJECT * DeviceObject )

Referenced by PopSetSystemPowerState().

◆ IopInitBootLog()

VOID IopInitBootLog ( IN BOOLEAN StartBootLog )

◆ IopInitDriverImplementation()

VOID IopInitDriverImplementation ( VOID )

◆ IopInitErrorLog()

VOID NTAPI IopInitErrorLog ( VOID )

◆ IopInitializeBootDrivers()

VOID FASTCALL IopInitializeBootDrivers ( VOID )

Definition at line 1023 of file driver.c.

{
    PLIST_ENTRY ListHead, NextEntry, NextEntry2;
    PLDR_DATA_TABLE_ENTRY LdrEntry;
    NTSTATUS Status;
    UNICODE_STRING DriverName;
    ULONG i, Index;
    PDRIVER_INFORMATION DriverInfo, DriverInfoTag;
    HANDLE KeyHandle;
    PBOOT_DRIVER_LIST_ENTRY BootEntry;
    DPRINT("IopInitializeBootDrivers()\n");
 
    /* Create the RAW FS built-in driver */
    RtlInitUnicodeString(&DriverName, L"\\FileSystem\\RAW");
 
    Status = IoCreateDriver(&DriverName, RawFsDriverEntry);
    if (!NT_SUCCESS(Status))
    {
        /* Fail */
        return;
    }
 
    /* Get highest group order index */
    IopGroupIndex = PpInitGetGroupOrderIndex(NULL);
    if (IopGroupIndex == 0xFFFF)
    {
        UNIMPLEMENTED_DBGBREAK();
    }
 
    /* Allocate the group table */
    IopGroupTable = ExAllocatePoolWithTag(PagedPool,
                                          IopGroupIndex * sizeof(LIST_ENTRY),
                                          TAG_IO);
    if (IopGroupTable == NULL)
    {
        UNIMPLEMENTED_DBGBREAK();
    }
 
    /* Initialize the group table lists */
    for (i = 0; i < IopGroupIndex; i++) InitializeListHead(&IopGroupTable[i]);
 
    /* Loop the boot modules */
    ListHead = &KeLoaderBlock->LoadOrderListHead;
    for (NextEntry = ListHead->Flink;
         NextEntry != ListHead;
         NextEntry = NextEntry->Flink)
    {
        /* Get the entry */
        LdrEntry = CONTAINING_RECORD(NextEntry,
                                     LDR_DATA_TABLE_ENTRY,
                                     InLoadOrderLinks);
 
        /* Check if the DLL needs to be initialized */
        if (LdrEntry->Flags & LDRP_DRIVER_DEPENDENT_DLL)
        {
            /* Call its entrypoint */
            MmCallDllInitialize(LdrEntry, NULL);
        }
    }
 
    /* Loop the boot drivers */
    ListHead = &KeLoaderBlock->BootDriverListHead;
    for (NextEntry = ListHead->Flink;
         NextEntry != ListHead;
         NextEntry = NextEntry->Flink)
    {
        /* Get the entry */
        BootEntry = CONTAINING_RECORD(NextEntry,
                                      BOOT_DRIVER_LIST_ENTRY,
                                      Link);
 
        // FIXME: TODO: This LdrEntry is to be used in a special handling
        // for SETUPLDR (a similar procedure is done on Windows), where
        // the loader would, under certain conditions, be loaded in the
        // SETUPLDR-specific code block below...
#if 0
        /* Get the driver loader entry */
        LdrEntry = BootEntry->LdrEntry;
#endif
 
        /* Allocate our internal accounting structure */
        DriverInfo = ExAllocatePoolWithTag(PagedPool,
                                           sizeof(DRIVER_INFORMATION),
                                           TAG_IO);
        if (DriverInfo)
        {
            /* Zero it and initialize it */
            RtlZeroMemory(DriverInfo, sizeof(DRIVER_INFORMATION));
            InitializeListHead(&DriverInfo->Link);
            DriverInfo->DataTableEntry = BootEntry;
 
            /* Open the registry key */
            Status = IopOpenRegistryKeyEx(&KeyHandle,
                                          NULL,
                                          &BootEntry->RegistryPath,
                                          KEY_READ);
            DPRINT("IopOpenRegistryKeyEx(%wZ) returned 0x%08lx\n", &BootEntry->RegistryPath, Status);
#if 0
            if (NT_SUCCESS(Status))
#else // Hack still needed...
            if ((NT_SUCCESS(Status)) || /* ReactOS HACK for SETUPLDR */
                ((KeLoaderBlock->SetupLdrBlock) && ((KeyHandle = (PVOID)1)))) // yes, it's an assignment!
#endif
            {
                /* Save the handle */
                DriverInfo->ServiceHandle = KeyHandle;
 
                /* Get the group oder index */
                Index = PpInitGetGroupOrderIndex(KeyHandle);
 
                /* Get the tag position */
                DriverInfo->TagPosition = PipGetDriverTagPriority(KeyHandle);
 
                /* Insert it into the list, at the right place */
                ASSERT(Index < IopGroupIndex);
                NextEntry2 = IopGroupTable[Index].Flink;
                while (NextEntry2 != &IopGroupTable[Index])
                {
                    /* Get the driver info */
                    DriverInfoTag = CONTAINING_RECORD(NextEntry2,
                                                      DRIVER_INFORMATION,
                                                      Link);
 
                    /* Check if we found the right tag position */
                    if (DriverInfoTag->TagPosition > DriverInfo->TagPosition)
                    {
                        /* We're done */
                        break;
                    }
 
                    /* Next entry */
                    NextEntry2 = NextEntry2->Flink;
                }
 
                /* Insert us right before the next entry */
                NextEntry2 = NextEntry2->Blink;
                InsertHeadList(NextEntry2, &DriverInfo->Link);
            }
        }
    }
 
    /* Loop each group index */
    for (i = 0; i < IopGroupIndex; i++)
    {
        /* Loop each group table */
        for (NextEntry = IopGroupTable[i].Flink;
             NextEntry != &IopGroupTable[i];
             NextEntry = NextEntry->Flink)
        {
            /* Get the entry */
            DriverInfo = CONTAINING_RECORD(NextEntry,
                                           DRIVER_INFORMATION,
                                           Link);
 
            /* Get the driver loader entry */
            LdrEntry = DriverInfo->DataTableEntry->LdrEntry;
 
            /* Initialize it */
            if (IopInitializeBuiltinDriver(LdrEntry))
            {
                // it does not make sense to enumerate the tree if there are no new devices added
                PiQueueDeviceAction(IopRootDeviceNode->PhysicalDeviceObject,
                                    PiActionEnumRootDevices,
                                    NULL,
                                    NULL);
            }
        }
    }
 
    /* HAL Root Bus is being initialized before loading the boot drivers so this may cause issues
     * when some devices are not being initialized with their drivers. This flag is used to delay
     * all actions with devices (except PnP root device) until boot drivers are loaded.
     * See PiQueueDeviceAction function
     */
    PnPBootDriversLoaded = TRUE;
 
    DbgPrint("BOOT DRIVERS LOADED\n");
 
    PiQueueDeviceAction(IopRootDeviceNode->PhysicalDeviceObject,
                        PiActionEnumDeviceTree,
                        NULL,
                        NULL);
}

Referenced by IoInitSystem().

◆ IopInitializeDriverModule()

NTSTATUS IopInitializeDriverModule	(	_In_ PLDR_DATA_TABLE_ENTRY	ModuleObject,
		_In_ HANDLE	ServiceHandle,
		_Out_ PDRIVER_OBJECT *	OutDriverObject,
		_Out_ NTSTATUS *	DriverEntryStatus
	)

Initialize a loaded driver.

Parameters

[in]	ModuleObject	Module object representing the driver. It can be retrieved by IopLoadServiceModule. Freed on failure, so in a such case this should not be accessed anymore
[in]	ServiceHandle	Handle to a driver's CCS/Services/<ServiceName> key
[out]	DriverObject	This contains the driver object if it was created (even with unsuccessfull result)
[out]	DriverEntryStatus	This contains the status value returned by the driver's DriverEntry routine (will not be valid of the return value is not STATUS_SUCCESS or STATUS_FAILED_DRIVER_ENTRY)

Returns: Status of the operation

Definition at line 443 of file driver.c.

{
    UNICODE_STRING DriverName, RegistryPath, ServiceName;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    Status = IopGetDriverNames(ServiceHandle, &DriverName, &ServiceName);
    if (!NT_SUCCESS(Status))
    {
        MmUnloadSystemImage(ModuleObject);
        return Status;
    }
 
    DPRINT("Driver name: '%wZ'\n", &DriverName);
 
    /*
     * Retrieve the driver's PE image NT header and perform some sanity checks.
     * NOTE: We suppose that since the driver has been successfully loaded,
     * its NT and optional headers are all valid and have expected sizes.
     */
    PIMAGE_NT_HEADERS NtHeaders = RtlImageNtHeader(ModuleObject->DllBase);
    ASSERT(NtHeaders);
    // NOTE: ModuleObject->SizeOfImage is actually (number of PTEs)*PAGE_SIZE.
    ASSERT(ModuleObject->SizeOfImage == ROUND_TO_PAGES(NtHeaders->OptionalHeader.SizeOfImage));
    ASSERT(ModuleObject->EntryPoint == RVA(ModuleObject->DllBase, NtHeaders->OptionalHeader.AddressOfEntryPoint));
 
    /* Obtain the registry path for the DriverInit routine */
    PKEY_NAME_INFORMATION nameInfo;
    ULONG infoLength;
    Status = ZwQueryKey(ServiceHandle, KeyNameInformation, NULL, 0, &infoLength);
    if (Status == STATUS_BUFFER_TOO_SMALL)
    {
        nameInfo = ExAllocatePoolWithTag(NonPagedPool, infoLength, TAG_IO);
        if (nameInfo)
        {
            Status = ZwQueryKey(ServiceHandle,
                                KeyNameInformation,
                                nameInfo,
                                infoLength,
                                &infoLength);
            if (NT_SUCCESS(Status))
            {
                RegistryPath.Length = nameInfo->NameLength;
                RegistryPath.MaximumLength = nameInfo->NameLength;
                RegistryPath.Buffer = nameInfo->Name;
            }
            else
            {
                ExFreePoolWithTag(nameInfo, TAG_IO);
            }
        }
        else
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
    else
    {
        Status = NT_SUCCESS(Status) ? STATUS_UNSUCCESSFUL : Status;
    }
 
    if (!NT_SUCCESS(Status))
    {
        RtlFreeUnicodeString(&ServiceName);
        RtlFreeUnicodeString(&DriverName);
        MmUnloadSystemImage(ModuleObject);
        return Status;
    }
 
    /* Create the driver object */
    ULONG ObjectSize = sizeof(DRIVER_OBJECT) + sizeof(EXTENDED_DRIVER_EXTENSION);
    OBJECT_ATTRIBUTES objAttrs;
    PDRIVER_OBJECT driverObject;
    InitializeObjectAttributes(&objAttrs,
                               &DriverName,
                               OBJ_PERMANENT | OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    Status = ObCreateObject(KernelMode,
                            IoDriverObjectType,
                            &objAttrs,
                            KernelMode,
                            NULL,
                            ObjectSize,
                            0,
                            0,
                            (PVOID*)&driverObject);
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(nameInfo, TAG_IO); // container for RegistryPath
        RtlFreeUnicodeString(&ServiceName);
        RtlFreeUnicodeString(&DriverName);
        MmUnloadSystemImage(ModuleObject);
        DPRINT1("Error while creating driver object \"%wZ\" status %x\n", &DriverName, Status);
        return Status;
    }
 
    DPRINT("Created driver object 0x%p for \"%wZ\"\n", driverObject, &DriverName);
 
    RtlZeroMemory(driverObject, ObjectSize);
    driverObject->Type = IO_TYPE_DRIVER;
    driverObject->Size = sizeof(DRIVER_OBJECT);
 
    /* Set the legacy flag if this is not a WDM driver */
    if (!(NtHeaders->OptionalHeader.DllCharacteristics & IMAGE_DLLCHARACTERISTICS_WDM_DRIVER))
        driverObject->Flags |= DRVO_LEGACY_DRIVER;
 
    driverObject->DriverSection = ModuleObject;
    driverObject->DriverStart = ModuleObject->DllBase;
    driverObject->DriverSize = ModuleObject->SizeOfImage;
    driverObject->DriverInit = ModuleObject->EntryPoint;
    driverObject->HardwareDatabase = &IopHardwareDatabaseKey;
    driverObject->DriverExtension = (PDRIVER_EXTENSION)(driverObject + 1);
    driverObject->DriverExtension->DriverObject = driverObject;
 
    /* Loop all Major Functions */
    for (INT i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
    {
        /* Invalidate each function */
        driverObject->MajorFunction[i] = IopInvalidDeviceRequest;
    }
 
    /* Add the Object and get its handle */
    HANDLE hDriver;
    Status = ObInsertObject(driverObject, NULL, FILE_READ_DATA, 0, NULL, &hDriver);
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(nameInfo, TAG_IO);
        RtlFreeUnicodeString(&ServiceName);
        RtlFreeUnicodeString(&DriverName);
        return Status;
    }
 
    /* Now reference it */
    Status = ObReferenceObjectByHandle(hDriver,
                                       0,
                                       IoDriverObjectType,
                                       KernelMode,
                                       (PVOID*)&driverObject,
                                       NULL);
 
    /* Close the extra handle */
    ZwClose(hDriver);
 
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(nameInfo, TAG_IO); // container for RegistryPath
        RtlFreeUnicodeString(&ServiceName);
        RtlFreeUnicodeString(&DriverName);
        return Status;
    }
 
    /* Set up the service key name buffer */
    UNICODE_STRING serviceKeyName;
    serviceKeyName.Length = 0;
    // NULL-terminate for Windows compatibility
    serviceKeyName.MaximumLength = ServiceName.MaximumLength + sizeof(UNICODE_NULL);
    serviceKeyName.Buffer = ExAllocatePoolWithTag(NonPagedPool,
                                                  serviceKeyName.MaximumLength,
                                                  TAG_IO);
    if (!serviceKeyName.Buffer)
    {
        ObMakeTemporaryObject(driverObject);
        ObDereferenceObject(driverObject);
        ExFreePoolWithTag(nameInfo, TAG_IO); // container for RegistryPath
        RtlFreeUnicodeString(&ServiceName);
        RtlFreeUnicodeString(&DriverName);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Copy the name and set it in the driver extension */
    RtlCopyUnicodeString(&serviceKeyName, &ServiceName);
    RtlFreeUnicodeString(&ServiceName);
    driverObject->DriverExtension->ServiceKeyName = serviceKeyName;
 
    /* Make a copy of the driver name to store in the driver object */
    UNICODE_STRING driverNamePaged;
    driverNamePaged.Length = 0;
    // NULL-terminate for Windows compatibility
    driverNamePaged.MaximumLength = DriverName.MaximumLength + sizeof(UNICODE_NULL);
    driverNamePaged.Buffer = ExAllocatePoolWithTag(PagedPool,
                                                   driverNamePaged.MaximumLength,
                                                   TAG_IO);
    if (!driverNamePaged.Buffer)
    {
        ObMakeTemporaryObject(driverObject);
        ObDereferenceObject(driverObject);
        ExFreePoolWithTag(nameInfo, TAG_IO); // container for RegistryPath
        RtlFreeUnicodeString(&DriverName);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlCopyUnicodeString(&driverNamePaged, &DriverName);
    driverObject->DriverName = driverNamePaged;
 
    /* Finally, call its init function */
    Status = driverObject->DriverInit(driverObject, &RegistryPath);
    *DriverEntryStatus = Status;
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("'%wZ' initialization failed, status (0x%08lx)\n", &DriverName, Status);
        // return a special status value in case of failure
        Status = STATUS_FAILED_DRIVER_ENTRY;
    }
 
    /* HACK: We're going to say if we don't have any DOs from DriverEntry, then we're not legacy.
     * Other parts of the I/O manager depend on this behavior */
    if (!driverObject->DeviceObject)
    {
        driverObject->Flags &= ~DRVO_LEGACY_DRIVER;
    }
 
    /* Windows does this fixup, keep it for compatibility */
    for (INT i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
    {
        /*
         * Make sure the driver didn't set any dispatch entry point to NULL!
         * Doing so is illegal; drivers shouldn't touch entry points they
         * do not implement.
         */
 
        /* Check if it did so anyway */
        if (!driverObject->MajorFunction[i])
        {
            /* Print a warning in the debug log */
            DPRINT1("Driver <%wZ> set DriverObject->MajorFunction[%lu] to NULL!\n",
                    &driverObject->DriverName, i);
 
            /* Fix it up */
            driverObject->MajorFunction[i] = IopInvalidDeviceRequest;
        }
    }
 
    // TODO: for legacy drivers, unload the driver if it didn't create any DO
 
    ExFreePoolWithTag(nameInfo, TAG_IO); // container for RegistryPath
    RtlFreeUnicodeString(&DriverName);
 
    if (!NT_SUCCESS(Status))
    {
        // if the driver entry has been failed, clear the object
        ObMakeTemporaryObject(driverObject);
        ObDereferenceObject(driverObject);
        return Status;
    }
 
    *OutDriverObject = driverObject;
 
    MmFreeDriverInitialization((PLDR_DATA_TABLE_ENTRY)driverObject->DriverSection);
 
    /* Set the driver as initialized */
    IopReadyDeviceObjects(driverObject);
 
    if (PnpSystemInit) IopReinitializeDrivers();
 
    return STATUS_SUCCESS;
}

Referenced by IopInitializeBuiltinDriver(), and IopLoadDriver().

◆ IopInitializePlugPlayServices()

NTSTATUS NTAPI IopInitializePlugPlayServices ( VOID )

Definition at line 287 of file pnpinit.c.

{
    NTSTATUS Status;
    ULONG Disposition;
    HANDLE KeyHandle, EnumHandle, ParentHandle, TreeHandle, ControlHandle;
    UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET");
    UNICODE_STRING PnpManagerDriverName = RTL_CONSTANT_STRING(DRIVER_ROOT_NAME L"PnpManager");
    PDEVICE_OBJECT Pdo;
 
    /* Initialize locks and such */
    KeInitializeSpinLock(&IopDeviceTreeLock);
    KeInitializeSpinLock(&IopDeviceActionLock);
    InitializeListHead(&IopDeviceActionRequestList);
    KeInitializeEvent(&PiEnumerationFinished, NotificationEvent, TRUE);
 
    /* Get the default interface */
    PnpDefaultInterfaceType = IopDetermineDefaultInterfaceType();
 
    /* Initialize arbiters */
    Status = IopInitializeArbiters();
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Setup the group cache */
    Status = PiInitCacheGroupInformation();
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Open the current control set */
    Status = IopOpenRegistryKeyEx(&KeyHandle,
                                  NULL,
                                  &KeyName,
                                  KEY_ALL_ACCESS);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Create the control key */
    RtlInitUnicodeString(&KeyName, L"Control");
    Status = IopCreateRegistryKeyEx(&ControlHandle,
                                    KeyHandle,
                                    &KeyName,
                                    KEY_ALL_ACCESS,
                                    REG_OPTION_NON_VOLATILE,
                                    &Disposition);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check if it's a new key */
    if (Disposition == REG_CREATED_NEW_KEY)
    {
        HANDLE DeviceClassesHandle;
 
        /* Create the device classes key */
        RtlInitUnicodeString(&KeyName, L"DeviceClasses");
        Status = IopCreateRegistryKeyEx(&DeviceClassesHandle,
                                        ControlHandle,
                                        &KeyName,
                                        KEY_ALL_ACCESS,
                                        REG_OPTION_NON_VOLATILE,
                                        &Disposition);
        if (!NT_SUCCESS(Status)) return Status;
 
        ZwClose(DeviceClassesHandle);
    }
 
    ZwClose(ControlHandle);
 
    /* Create the enum key */
    RtlInitUnicodeString(&KeyName, REGSTR_KEY_ENUM);
    Status = IopCreateRegistryKeyEx(&EnumHandle,
                                    KeyHandle,
                                    &KeyName,
                                    KEY_ALL_ACCESS,
                                    REG_OPTION_NON_VOLATILE,
                                    &Disposition);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check if it's a new key */
    if (Disposition == REG_CREATED_NEW_KEY)
    {
        /* FIXME: DACLs */
    }
 
    /* Create the root key */
    ParentHandle = EnumHandle;
    RtlInitUnicodeString(&KeyName, REGSTR_KEY_ROOTENUM);
    Status = IopCreateRegistryKeyEx(&EnumHandle,
                                    ParentHandle,
                                    &KeyName,
                                    KEY_ALL_ACCESS,
                                    REG_OPTION_NON_VOLATILE,
                                    &Disposition);
    NtClose(ParentHandle);
    if (!NT_SUCCESS(Status)) return Status;
    NtClose(EnumHandle);
 
    /* Open the root key now */
    RtlInitUnicodeString(&KeyName, L"\\REGISTRY\\MACHINE\\SYSTEM\\CURRENTCONTROLSET\\ENUM");
    Status = IopOpenRegistryKeyEx(&EnumHandle,
                                  NULL,
                                  &KeyName,
                                  KEY_ALL_ACCESS);
    if (NT_SUCCESS(Status))
    {
        /* Create the root dev node */
        RtlInitUnicodeString(&KeyName, REGSTR_VAL_ROOT_DEVNODE);
        Status = IopCreateRegistryKeyEx(&TreeHandle,
                                        EnumHandle,
                                        &KeyName,
                                        KEY_ALL_ACCESS,
                                        REG_OPTION_NON_VOLATILE,
                                        NULL);
        NtClose(EnumHandle);
        if (NT_SUCCESS(Status)) NtClose(TreeHandle);
    }
 
    /* Create the root driver */
    Status = IoCreateDriver(&PnpManagerDriverName, PnpRootDriverEntry);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IoCreateDriverObject() failed\n");
        KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
    }
 
    /* Create the root PDO */
    Status = IoCreateDevice(IopRootDriverObject,
                            0,
                            NULL,
                            FILE_DEVICE_CONTROLLER,
                            0,
                            FALSE,
                            &Pdo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IoCreateDevice() failed\n");
        KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
    }
 
    /* This is a bus enumerated device */
    Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
 
    /* Create the root device node */
    IopRootDeviceNode = PipAllocateDeviceNode(Pdo);
 
    /* Set flags */
    IopRootDeviceNode->Flags |= DNF_MADEUP | DNF_ENUMERATED |
                                DNF_IDS_QUERIED | DNF_NO_RESOURCE_REQUIRED;
 
    /* Create instance path */
    if (!RtlCreateUnicodeString(&IopRootDeviceNode->InstancePath, REGSTR_VAL_ROOT_DEVNODE))
    {
        DPRINT1("RtlCreateUnicodeString() failed\n");
        KeBugCheckEx(PHASE1_INITIALIZATION_FAILED, Status, 0, 0, 0);
    }
 
    PnpRootInitializeDevExtension();
 
    PiSetDevNodeState(IopRootDeviceNode, DeviceNodeStarted);
 
    /* Initialize PnP-Event notification support */
    Status = IopInitPlugPlayEvents();
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Initialize the Bus Type GUID List */
    PnpBusTypeGuidList = ExAllocatePool(PagedPool, sizeof(IO_BUS_TYPE_GUID_LIST));
    RtlZeroMemory(PnpBusTypeGuidList, sizeof(IO_BUS_TYPE_GUID_LIST));
    ExInitializeFastMutex(&PnpBusTypeGuidList->Lock);
 
    /* Initialize PnP root relations (this is a syncronous operation) */
    PiQueueDeviceAction(Pdo, PiActionEnumRootDevices, NULL, NULL);
 
    /* Launch the firmware mapper */
    Status = IopUpdateRootKey();
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Close the handle to the control set */
    NtClose(KeyHandle);
 
    /* Initialize PnP root relations (this is a syncronous operation) */
    PiQueueDeviceAction(Pdo, PiActionEnumRootDevices, NULL, NULL);
 
    /* We made it */
    return STATUS_SUCCESS;
}

Referenced by IoInitSystem().

◆ IopInitializeReserveIrp()

BOOLEAN NTAPI IopInitializeReserveIrp ( IN PRESERVE_IRP_ALLOCATOR ReserveIrpAllocator )

Definition at line 549 of file irp.c.

{
    /* Our allocated stack size */
    ReserveIrpAllocator->StackSize = 20;
 
    /* Allocate the IRP now */
    ReserveIrpAllocator->ReserveIrp = IoAllocateIrp(ReserveIrpAllocator->StackSize, FALSE);
    /* If we cannot, abort system boot */
    if (ReserveIrpAllocator->ReserveIrp == NULL)
    {
        return FALSE;
    }
 
    /* It's not in use */
    ReserveIrpAllocator->ReserveIrpInUse = 0;
    /* And init the event */
    KeInitializeEvent(&ReserveIrpAllocator->WaitEvent, SynchronizationEvent, FALSE);
 
    /* All good, keep booting */
    return TRUE;
}

Referenced by IoInitSystem().

◆ IopInitializeSystemDrivers()

VOID FASTCALL IopInitializeSystemDrivers ( VOID )

Definition at line 1210 of file driver.c.

{
    PUNICODE_STRING *DriverList, *SavedList;
 
    PiPerformSyncDeviceAction(IopRootDeviceNode->PhysicalDeviceObject, PiActionEnumDeviceTree);
 
    /* HACK: No system drivers on the BootCD */
    if (KeLoaderBlock->SetupLdrBlock) return;
 
    /* Get the driver list */
    SavedList = DriverList = CmGetSystemDriverList();
    ASSERT(DriverList);
 
    /* Loop it */
    while (*DriverList)
    {
        /* Load the driver */
        ZwLoadDriver(*DriverList);
 
        /* Free the entry */
        RtlFreeUnicodeString(*DriverList);
        ExFreePool(*DriverList);
 
        /* Next entry */
        InbvIndicateProgress();
        DriverList++;
    }
 
    /* Free the list */
    ExFreePool(SavedList);
 
    PiQueueDeviceAction(IopRootDeviceNode->PhysicalDeviceObject,
                        PiActionEnumDeviceTree,
                        NULL,
                        NULL);
}

Referenced by IoInitSystem().

◆ IopInitiatePnpIrp()

NTSTATUS NTAPI IopInitiatePnpIrp	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIO_STATUS_BLOCK	IoStatusBlock,
		IN UCHAR	MinorFunction,
		IN PIO_STACK_LOCATION	Stack
	)

Referenced by IoGetDmaAdapter(), IopCancelPrepareDeviceForRemoval(), IopCreateDeviceInstancePath(), IopFilterResourceRequirements(), IopGetDeviceProperty(), IopGetDeviceRelations(), IopPrepareDeviceForRemoval(), IopQueryCompatibleIds(), IopQueryDeviceCapabilities(), IopQueryHardwareIds(), IoRequestDeviceEject(), PiInitializeDevNode(), and VideoPortCheckForDeviceExistence().

◆ IopInitPlugPlayEvents()

NTSTATUS IopInitPlugPlayEvents ( VOID )

Definition at line 40 of file plugplay.c.

{
    InitializeListHead(&IopPnpEventQueueHead);
 
    KeInitializeEvent(&IopPnpNotifyEvent,
                      SynchronizationEvent,
                      FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by IopInitializePlugPlayServices().

◆ IopInitTimerImplementation()

VOID FASTCALL IopInitTimerImplementation ( VOID )

◆ IopLoadDriver()

NTSTATUS IopLoadDriver	(	_In_ HANDLE	ServiceHandle,
		_Out_ PDRIVER_OBJECT *	DriverObject
	)

Definition at line 1938 of file driver.c.

{
    UNICODE_STRING ImagePath;
    NTSTATUS Status;
    PLDR_DATA_TABLE_ENTRY ModuleObject;
    PVOID BaseAddress;
 
    PKEY_VALUE_FULL_INFORMATION kvInfo;
    Status = IopGetRegistryValue(ServiceHandle, L"ImagePath", &kvInfo);
    if (NT_SUCCESS(Status))
    {
        if ((kvInfo->Type != REG_EXPAND_SZ && kvInfo->Type != REG_SZ) || kvInfo->DataLength == 0)
        {
            ExFreePool(kvInfo);
            return STATUS_ILL_FORMED_SERVICE_ENTRY;
        }
 
        ImagePath.Length = kvInfo->DataLength - sizeof(UNICODE_NULL);
        ImagePath.MaximumLength = kvInfo->DataLength;
        ImagePath.Buffer = ExAllocatePoolWithTag(PagedPool, ImagePath.MaximumLength, TAG_RTLREGISTRY);
        if (!ImagePath.Buffer)
        {
            ExFreePool(kvInfo);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlMoveMemory(ImagePath.Buffer,
                      (PVOID)((ULONG_PTR)kvInfo + kvInfo->DataOffset),
                      ImagePath.Length);
        ImagePath.Buffer[ImagePath.Length / sizeof(WCHAR)] = UNICODE_NULL;
        ExFreePool(kvInfo);
    }
    else
    {
        return Status;
    }
 
    /*
     * Normalize the image path for all later processing.
     */
    Status = IopNormalizeImagePath(&ImagePath, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("IopNormalizeImagePath() failed (Status %x)\n", Status);
        return Status;
    }
 
    DPRINT("FullImagePath: '%wZ'\n", &ImagePath);
 
    KeEnterCriticalRegion();
    ExAcquireResourceExclusiveLite(&IopDriverLoadResource, TRUE);
 
    /*
     * Load the driver module
     */
    DPRINT("Loading module from %wZ\n", &ImagePath);
    Status = MmLoadSystemImage(&ImagePath, NULL, NULL, 0, (PVOID)&ModuleObject, &BaseAddress);
    RtlFreeUnicodeString(&ImagePath);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("MmLoadSystemImage() failed (Status %lx)\n", Status);
        ExReleaseResourceLite(&IopDriverLoadResource);
        KeLeaveCriticalRegion();
        return Status;
    }
 
    // Display the loading message
    ULONG infoLength;
    Status = ZwQueryKey(ServiceHandle, KeyBasicInformation, NULL, 0, &infoLength);
    if (Status == STATUS_BUFFER_TOO_SMALL)
    {
        PKEY_BASIC_INFORMATION servName = ExAllocatePoolWithTag(PagedPool, infoLength, TAG_IO);
        if (servName)
        {
            Status = ZwQueryKey(ServiceHandle,
                                KeyBasicInformation,
                                servName,
                                infoLength,
                                &infoLength);
            if (NT_SUCCESS(Status))
            {
                UNICODE_STRING serviceName = {
                    .Length = servName->NameLength,
                    .MaximumLength = servName->NameLength,
                    .Buffer = servName->Name
                };
 
                IopDisplayLoadingMessage(&serviceName);
            }
            ExFreePoolWithTag(servName, TAG_IO);
        }
    }
 
    NTSTATUS driverEntryStatus;
    Status = IopInitializeDriverModule(ModuleObject,
                                       ServiceHandle,
                                       DriverObject,
                                       &driverEntryStatus);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopInitializeDriverModule() failed (Status %lx)\n", Status);
    }
 
    ExReleaseResourceLite(&IopDriverLoadResource);
    KeLeaveCriticalRegion();
 
    return Status;
}

Referenced by IopLoadUnloadDriverWorker(), and PiAttachFilterDriversCallback().

◆ IopLogWorker()

VOID NTAPI IopLogWorker ( IN PVOID Parameter )

Definition at line 148 of file error.c.

{
#define IO_ERROR_OBJECT_NAMES_LENGTH    100
 
    NTSTATUS Status;
    PELF_API_MSG Message;
    PIO_ERROR_LOG_MESSAGE ErrorMessage;
    PLIST_ENTRY ListEntry;
    PERROR_LOG_ENTRY LogEntry;
    PIO_ERROR_LOG_PACKET Packet;
    PCHAR StringBuffer;
    ULONG RemainingLength;
    PDRIVER_OBJECT DriverObject;
    PWCHAR NameString;
    ULONG DriverNameLength, DeviceNameLength;
    UCHAR Buffer[sizeof(OBJECT_NAME_INFORMATION) + IO_ERROR_OBJECT_NAMES_LENGTH];
    POBJECT_NAME_INFORMATION ObjectNameInfo = (POBJECT_NAME_INFORMATION)&Buffer;
    POBJECT_NAME_INFORMATION PoolObjectNameInfo;
    ULONG ReturnedLength, MessageLength;
    ULONG ExtraStringLength;
    PWCHAR p;
 
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(Parameter);
 
    /* Connect to the port */
    if (!IopConnectLogPort()) return;
 
    /* Allocate the message */
    Message = ExAllocatePoolWithTag(PagedPool, IO_ERROR_LOG_MESSAGE_LENGTH, TAG_IO);
    if (!Message)
    {
        /* Couldn't allocate, try again */
        IopRestartLogWorker();
        return;
    }
 
    /* Zero out the message and get the actual I/O structure */
    RtlZeroMemory(Message, sizeof(*Message));
    ErrorMessage = &Message->IoErrorMessage;
 
    /* Start loop */
    while (TRUE)
    {
        /* Get an entry */
        ListEntry = IopGetErrorLogEntry();
        if (!ListEntry) break;
        LogEntry = CONTAINING_RECORD(ListEntry, ERROR_LOG_ENTRY, ListEntry);
 
        /* Get pointer to the log packet */
        Packet = (PIO_ERROR_LOG_PACKET)((ULONG_PTR)LogEntry +
                                        sizeof(ERROR_LOG_ENTRY));
 
        /* Calculate the total length of the message only */
        MessageLength = sizeof(IO_ERROR_LOG_MESSAGE) -
                        sizeof(ERROR_LOG_ENTRY) -
                        sizeof(IO_ERROR_LOG_PACKET) +
                        LogEntry->Size;
 
        /* Copy the packet */
        RtlCopyMemory(&ErrorMessage->EntryData,
                      Packet,
                      LogEntry->Size - sizeof(ERROR_LOG_ENTRY));
 
        /* Set the timestamp and time */
        ErrorMessage->TimeStamp = LogEntry->TimeStamp;
        ErrorMessage->Type = IO_TYPE_ERROR_MESSAGE;
 
        /* Check if this message has any strings */
        if (Packet->NumberOfStrings)
        {
            /* String buffer is after the current strings */
            StringBuffer = (PCHAR)&ErrorMessage->EntryData +
                            Packet->StringOffset;
        }
        else
        {
            /* Otherwise, string buffer is at the end */
            StringBuffer = (PCHAR)ErrorMessage + MessageLength;
        }
 
        /* Align the buffer */
        StringBuffer = ALIGN_UP_POINTER(StringBuffer, WCHAR);
 
        /* Set the offset for the driver's name to the current buffer */
        ErrorMessage->DriverNameOffset = (ULONG)(StringBuffer -
                                                (PCHAR)ErrorMessage);
 
        /* Check how much space we have left for the device string */
        RemainingLength = (ULONG)((ULONG_PTR)Message +
                                  IO_ERROR_LOG_MESSAGE_LENGTH -
                                  (ULONG_PTR)StringBuffer);
 
        NameString = NULL;
        DriverNameLength = 0; DeviceNameLength = 0;
        PoolObjectNameInfo = NULL;
        ObjectNameInfo = (POBJECT_NAME_INFORMATION)&Buffer;
 
        /* Now check if there is a driver object */
        DriverObject = LogEntry->DriverObject;
        if (DriverObject)
        {
            /* Check if the driver has a name, and use it if so */
            if (DriverObject->DriverName.Buffer)
            {
                NameString = DriverObject->DriverName.Buffer;
                DriverNameLength = DriverObject->DriverName.Length;
            }
            else
            {
                NameString = NULL;
                DriverNameLength = 0;
            }
 
            /* Check if there isn't a valid name */
            if (!DriverNameLength)
            {
                /* Query the name directly */
                Status = ObQueryNameString(DriverObject,
                                           ObjectNameInfo,
                                           sizeof(Buffer),
                                           &ReturnedLength);
                if (!NT_SUCCESS(Status) || (ObjectNameInfo->Name.Length == 0))
                {
                    /* We don't have a name */
                    DriverNameLength = 0;
                }
                else
                {
                    NameString = ObjectNameInfo->Name.Buffer;
                    DriverNameLength = ObjectNameInfo->Name.Length;
                }
            }
        }
        else
        {
            /* Use default name */
            NameString = L"Application Popup";
            DriverNameLength = (ULONG)wcslen(NameString) * sizeof(WCHAR);
        }
 
        /* Check if we have a driver name */
        if (DriverNameLength)
        {
            /* Skip to the end of the driver's name */
            p = &NameString[DriverNameLength / sizeof(WCHAR)];
 
            /* Now we'll walk backwards and assume the minimum size */
            DriverNameLength = sizeof(WCHAR);
            p--;
            while ((*p != L'\\') && (p != NameString))
            {
                /* No backslash found, keep going */
                p--;
                DriverNameLength += sizeof(WCHAR);
            }
 
            /* Now we probably hit the backslash itself, skip past it */
            if (*p == L'\\')
            {
                p++;
                DriverNameLength -= sizeof(WCHAR);
            }
 
            /*
             * Now make sure that the driver name fits in the buffer, minus
             * 3 NULL chars (driver name, device name, and remaining strings),
             * and copy the driver name in the string buffer.
             */
            DriverNameLength = min(DriverNameLength,
                                   RemainingLength - 3 * sizeof(UNICODE_NULL));
            RtlCopyMemory(StringBuffer, p, DriverNameLength);
        }
 
        /* Null-terminate the driver name */
        *((PWSTR)(StringBuffer + DriverNameLength)) = UNICODE_NULL;
        DriverNameLength += sizeof(WCHAR);
 
        /* Go to the next string buffer position */
        StringBuffer += DriverNameLength;
        RemainingLength -= DriverNameLength;
 
        /* Update the string offset */
        ErrorMessage->EntryData.StringOffset =
            (USHORT)((ULONG_PTR)StringBuffer - (ULONG_PTR)ErrorMessage);
 
        /* Check if we have a device object */
        if (LogEntry->DeviceObject)
        {
            /* We do, query its name */
            Status = ObQueryNameString(LogEntry->DeviceObject,
                                       ObjectNameInfo,
                                       sizeof(Buffer) - DriverNameLength,
                                       &ReturnedLength);
            if (!NT_SUCCESS(Status) || (ObjectNameInfo->Name.Length == 0))
            {
                /* Setup an empty name */
                RtlInitEmptyUnicodeString(&ObjectNameInfo->Name, L"", 0);
 
                /* Check if we failed because our buffer wasn't large enough */
                if (Status == STATUS_INFO_LENGTH_MISMATCH)
                {
                    /* Then we'll allocate one... we really want this name! */
                    PoolObjectNameInfo = ExAllocatePoolWithTag(PagedPool,
                                                               ReturnedLength,
                                                               TAG_IO);
                    if (PoolObjectNameInfo)
                    {
                        /* Query it again */
                        ObjectNameInfo = PoolObjectNameInfo;
                        Status = ObQueryNameString(LogEntry->DeviceObject,
                                                   ObjectNameInfo,
                                                   ReturnedLength,
                                                   &ReturnedLength);
                        if (NT_SUCCESS(Status))
                        {
                            /* Success, update the information */
                            ObjectNameInfo->Name.Length =
                                IO_ERROR_OBJECT_NAMES_LENGTH - (USHORT)DriverNameLength;
                        }
                    }
                }
            }
 
            NameString = ObjectNameInfo->Name.Buffer;
            DeviceNameLength = ObjectNameInfo->Name.Length;
        }
        else
        {
            /* No device object, setup an empty name */
            NameString = L"";
            DeviceNameLength = 0;
        }
 
        /*
         * Now make sure that the device name fits in the buffer, minus
         * 2 NULL chars (device name, and remaining strings), and copy
         * the device name in the string buffer.
         */
        DeviceNameLength = min(DeviceNameLength,
                               RemainingLength - 2 * sizeof(UNICODE_NULL));
        RtlCopyMemory(StringBuffer, NameString, DeviceNameLength);
 
        /* Null-terminate the device name */
        *((PWSTR)(StringBuffer + DeviceNameLength)) = UNICODE_NULL;
        DeviceNameLength += sizeof(WCHAR);
 
        /* Free the buffer if we had one */
        if (PoolObjectNameInfo)
        {
            ExFreePoolWithTag(PoolObjectNameInfo, TAG_IO);
            PoolObjectNameInfo = NULL;
        }
 
        /* Go to the next string buffer position */
        ErrorMessage->EntryData.NumberOfStrings++;
        StringBuffer += DeviceNameLength;
        RemainingLength -= DeviceNameLength;
 
        /* Check if we have any extra strings */
        if (Packet->NumberOfStrings)
        {
            /* Find out the size of the extra strings */
            ExtraStringLength = LogEntry->Size -
                                sizeof(ERROR_LOG_ENTRY) -
                                Packet->StringOffset;
 
            /* Round up the length */
            ExtraStringLength = ROUND_UP(ExtraStringLength, sizeof(WCHAR));
 
            /* Make sure that the extra strings fit in our buffer */
            if (ExtraStringLength > (RemainingLength - sizeof(UNICODE_NULL)))
            {
                /* They wouldn't, so set normalize the length */
                MessageLength -= ExtraStringLength - RemainingLength;
                ExtraStringLength = RemainingLength - sizeof(UNICODE_NULL);
            }
 
            /* Now copy the extra strings */
            RtlCopyMemory(StringBuffer,
                          (PCHAR)Packet + Packet->StringOffset,
                          ExtraStringLength);
 
            /* Null-terminate them */
            *((PWSTR)(StringBuffer + ExtraStringLength)) = UNICODE_NULL;
        }
 
        /* Set the driver name length */
        ErrorMessage->DriverNameLength = (USHORT)DriverNameLength;
 
        /* Update the message length to include the driver and device names */
        MessageLength += DriverNameLength + DeviceNameLength;
        ErrorMessage->Size = (USHORT)MessageLength;
 
        /* Now update it again for the size of the actual LPC */
        MessageLength += (FIELD_OFFSET(ELF_API_MSG, IoErrorMessage) -
                          FIELD_OFFSET(ELF_API_MSG, Unknown[0]));
 
        /* Set the total and data lengths */
        Message->Header.u1.s1.TotalLength =
            (USHORT)(sizeof(PORT_MESSAGE) + MessageLength);
        Message->Header.u1.s1.DataLength = (USHORT)MessageLength;
 
        /* Send the message */
        Status = ZwRequestPort(IopLogPort, &Message->Header);
        if (!NT_SUCCESS(Status))
        {
            /*
             * An error happened while sending the message on the port.
             * Close the port, requeue the log message on top of the list
             * and restart the worker.
             */
            ZwClose(IopLogPort);
            IopLogPortConnected = FALSE;
 
            ExInterlockedInsertHeadList(&IopErrorLogListHead,
                                        &LogEntry->ListEntry,
                                        &IopLogListLock);
 
            IopRestartLogWorker();
            break;
        }
 
        /* NOTE: The following is basically 'IoFreeErrorLogEntry(Packet)' */
 
        /* Dereference both objects */
        if (LogEntry->DeviceObject) ObDereferenceObject(LogEntry->DeviceObject);
        if (LogEntry->DriverObject) ObDereferenceObject(LogEntry->DriverObject);
 
        /* Decrease the total allocation size and free the entry */
        InterlockedExchangeAdd(&IopTotalLogSize, -(LONG)LogEntry->Size);
        ExFreePoolWithTag(LogEntry, TAG_ERROR_LOG);
    }
 
    /* Free the LPC Message */
    ExFreePoolWithTag(Message, TAG_IO);
}

Referenced by IopLogDpcRoutine(), and IoWriteErrorLogEntry().

◆ IopMountVolume()

NTSTATUS NTAPI IopMountVolume	(	IN PDEVICE_OBJECT	DeviceObject,
		IN BOOLEAN	AllowRawMount,
		IN BOOLEAN	DeviceIsLocked,
		IN BOOLEAN	Alertable,
		OUT PVPB *	Vpb
	)

Definition at line 462 of file volume.c.

{
    KEVENT Event;
    NTSTATUS Status;
    IO_STATUS_BLOCK IoStatusBlock;
    PIRP Irp;
    PIO_STACK_LOCATION StackPtr;
    PLIST_ENTRY FsList, ListEntry;
    LIST_ENTRY LocalList;
    PDEVICE_OBJECT AttachedDeviceObject = DeviceObject;
    PDEVICE_OBJECT FileSystemDeviceObject, ParentFsDeviceObject;
    ULONG FsStackOverhead, RegistrationOps;
    PAGED_CODE();
 
    /* Check if the device isn't already locked */
    if (!DeviceIsLocked)
    {
        /* Lock it ourselves */
        Status = KeWaitForSingleObject(&DeviceObject->DeviceLock,
                                       Executive,
                                       KeGetPreviousMode(),
                                       Alertable,
                                       NULL);
        if ((Status == STATUS_ALERTED) || (Status == STATUS_USER_APC))
        {
            /* Don't mount if we were interrupted */
            return Status;
        }
    }
 
    /* Acquire the FS Lock*/
    KeEnterCriticalRegion();
    ExAcquireResourceSharedLite(&IopDatabaseResource, TRUE);
 
    /* Make sure we weren't already mounted */
    if (!(DeviceObject->Vpb->Flags & (VPB_MOUNTED | VPB_REMOVE_PENDING)))
    {
        /* Initialize the event to wait on */
        KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
        /* Remove the verify flag and get the actual device to mount */
        DeviceObject->Flags &= ~DO_VERIFY_VOLUME;
        while (AttachedDeviceObject->AttachedDevice)
        {
            /* Get the next one */
            AttachedDeviceObject = AttachedDeviceObject->AttachedDevice;
        }
 
        /* Reference it */
        ObReferenceObject(AttachedDeviceObject);
 
        /* For a mount operation, this can only be a Disk, CD-ROM or tape */
        if ((DeviceObject->DeviceType == FILE_DEVICE_DISK) ||
            (DeviceObject->DeviceType == FILE_DEVICE_VIRTUAL_DISK))
        {
            /* Use the disk list */
            FsList = &IopDiskFileSystemQueueHead;
        }
        else if (DeviceObject->DeviceType == FILE_DEVICE_CD_ROM)
        {
            /* Use the CD-ROM list */
            FsList = &IopCdRomFileSystemQueueHead;
        }
        else
        {
            /* It's gotta be a tape... */
            FsList = &IopTapeFileSystemQueueHead;
        }
 
        /* Now loop the fs list until one of the file systems accepts us */
        Status = STATUS_UNSUCCESSFUL;
        ListEntry = FsList->Flink;
        while ((ListEntry != FsList) && !(NT_SUCCESS(Status)))
        {
            /*
             * If we're not allowed to mount this volume and this is our last
             * (but not only) chance to mount it...
             */
            if (!(AllowRawMount) &&
                (ListEntry->Flink == FsList) &&
                (ListEntry != FsList->Flink))
            {
                /* Then fail this mount request */
                break;
            }
 
            /*
             * Also check if this is a raw mount and there are other file
             * systems on the list.
             */
            if ((DeviceObject->Vpb->Flags & VPB_RAW_MOUNT) &&
                (ListEntry->Flink != FsList))
            {
                /* Then skip this entry */
                ListEntry = ListEntry->Flink;
                continue;
            }
 
            /* Get the Device Object for this FS */
            FileSystemDeviceObject = CONTAINING_RECORD(ListEntry,
                                                       DEVICE_OBJECT,
                                                       Queue.ListEntry);
            ParentFsDeviceObject = FileSystemDeviceObject;
 
            /*
             * If this file system device is attached to some other device,
             * then we must make sure to increase the stack size for the IRP.
             * The default is +1, for the FS device itself.
             */
            FsStackOverhead = 1;
            while (FileSystemDeviceObject->AttachedDevice)
            {
                /* Get the next attached device and increase overhead */
                FileSystemDeviceObject = FileSystemDeviceObject->
                                         AttachedDevice;
                FsStackOverhead++;
            }
 
            /* Clear the event */
            KeClearEvent(&Event);
 
            /* Allocate the IRP */
            Irp = IoAllocateIrp(AttachedDeviceObject->StackSize +
                                (UCHAR)FsStackOverhead,
                                TRUE);
            if (!Irp)
            {
                /* Fail */
                Status =  STATUS_INSUFFICIENT_RESOURCES;
                break;
            }
 
            /* Setup the IRP */
            Irp->UserIosb = &IoStatusBlock;
            Irp->UserEvent = &Event;
            Irp->Tail.Overlay.Thread = PsGetCurrentThread();
            Irp->Flags = IRP_MOUNT_COMPLETION | IRP_SYNCHRONOUS_PAGING_IO;
            Irp->RequestorMode = KernelMode;
 
            /* Get the I/O Stack location and set it up */
            StackPtr = IoGetNextIrpStackLocation(Irp);
            StackPtr->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL;
            StackPtr->MinorFunction = IRP_MN_MOUNT_VOLUME;
            StackPtr->Flags = AllowRawMount;
            StackPtr->Parameters.MountVolume.Vpb = DeviceObject->Vpb;
            StackPtr->Parameters.MountVolume.DeviceObject =
                AttachedDeviceObject;
 
            /* Save registration operations */
            RegistrationOps = IopFsRegistrationOps;
 
            /* Release locks */
            IopInterlockedIncrementUlong(LockQueueIoDatabaseLock, (PULONG)&DeviceObject->ReferenceCount);
            ExReleaseResourceLite(&IopDatabaseResource);
 
            /* Call the driver */
            Status = IoCallDriver(FileSystemDeviceObject, Irp);
            if (Status == STATUS_PENDING)
            {
                /* Wait on it */
                KeWaitForSingleObject(&Event,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      NULL);
                Status = IoStatusBlock.Status;
            }
 
            ExAcquireResourceSharedLite(&IopDatabaseResource, TRUE);
            IopInterlockedDecrementUlong(LockQueueIoDatabaseLock, (PULONG)&DeviceObject->ReferenceCount);
 
            /* Check if mounting was successful */
            if (NT_SUCCESS(Status))
            {
                /* Mount the VPB */
                *Vpb = IopMountInitializeVpb(DeviceObject,
                                             AttachedDeviceObject,
                                             (DeviceObject->Vpb->Flags &
                                              VPB_RAW_MOUNT));
            }
            else
            {
                /* Check if we failed because of the user */
                if ((IoIsErrorUserInduced(Status)) &&
                    (IoStatusBlock.Information == 1))
                {
                    /* Break out and fail */
                    break;
                }
 
                /* If there were registration operations in the meanwhile */
                if (RegistrationOps != IopFsRegistrationOps)
                {
                    /* We need to setup a local list to pickup where we left */
                    LocalList.Flink = FsList->Flink;
                    ListEntry = &LocalList;
 
                    Status = STATUS_UNRECOGNIZED_VOLUME;
                }
 
                /* Otherwise, check if we need to load the FS driver */
                if (Status == STATUS_FS_DRIVER_REQUIRED)
                {
                    /* We need to release the lock */
                    IopInterlockedIncrementUlong(LockQueueIoDatabaseLock, (PULONG)&DeviceObject->ReferenceCount);
                    ExReleaseResourceLite(&IopDatabaseResource);
 
                    /* Release the device lock if we're holding it */
                    if (!DeviceIsLocked)
                    {
                        KeSetEvent(&DeviceObject->DeviceLock, 0, FALSE);
                    }
 
                    /* Leave critical section */
                    KeLeaveCriticalRegion();
 
                    /* Load the FS */
                    IopLoadFileSystemDriver(ParentFsDeviceObject);
 
                    /* Check if the device isn't already locked */
                    if (!DeviceIsLocked)
                    {
                        /* Lock it ourselves */
                        Status = KeWaitForSingleObject(&DeviceObject->
                                                       DeviceLock,
                                                       Executive,
                                                       KeGetPreviousMode(),
                                                       Alertable,
                                                       NULL);
                        if ((Status == STATUS_ALERTED) ||
                            (Status == STATUS_USER_APC))
                        {
                            /* Don't mount if we were interrupted */
                            ObDereferenceObject(AttachedDeviceObject);
                            return Status;
                        }
                    }
 
                    /* Reacquire the lock */
                    KeEnterCriticalRegion();
                    ExAcquireResourceSharedLite(&IopDatabaseResource, TRUE);
 
                    /* When we released the lock, make sure nobody beat us */
                    if (DeviceObject->Vpb->Flags & VPB_MOUNTED)
                    {
                        /* Someone did, break out */
                        Status = STATUS_SUCCESS;
                        break;
                    }
 
                    /* Start over by setting a failure */
                    Status = STATUS_UNRECOGNIZED_VOLUME;
 
                    /* We need to setup a local list to pickup where we left */
                    LocalList.Flink = FsList->Flink;
                    ListEntry = &LocalList;
                }
 
                /*
                 * Check if we failed with any other error then an unrecognized
                 * volume, and if this request doesn't allow mounting the raw
                 * file system.
                 */
                if (!(AllowRawMount) &&
                    (Status != STATUS_UNRECOGNIZED_VOLUME) &&
                    (FsRtlIsTotalDeviceFailure(Status)))
                {
                    /* Break out and give up */
                    break;
                }
            }
 
            /* Go to the next FS entry */
            ListEntry = ListEntry->Flink;
        }
 
        /* Dereference the device if we failed */
        if (!NT_SUCCESS(Status)) ObDereferenceObject(AttachedDeviceObject);
    }
    else if (DeviceObject->Vpb->Flags & VPB_REMOVE_PENDING)
    {
        /* Someone wants to remove us */
        Status = STATUS_DEVICE_DOES_NOT_EXIST;
    }
    else
    {
        /* Someone already mounted us */
        Status = STATUS_SUCCESS;
    }
 
    /* Release the FS lock */
    ExReleaseResourceLite(&IopDatabaseResource);
    KeLeaveCriticalRegion();
 
    /* Release the device lock if we're holding it */
    if (!DeviceIsLocked) KeSetEvent(&DeviceObject->DeviceLock, 0, FALSE);
 
    /* Check if we failed to mount the boot partition */
    if ((!NT_SUCCESS(Status)) &&
        (DeviceObject->Flags & DO_SYSTEM_BOOT_PARTITION) &&
        ExpInitializationPhase < 2)
    {
        /* Bugcheck the system */
        KeBugCheckEx(INACCESSIBLE_BOOT_DEVICE,
                     (ULONG_PTR)DeviceObject,
                     Status,
                     0,
                     0);
    }
 
    /* Return the mount status */
    return Status;
}

Referenced by IopCheckVpbMounted(), and IoVerifyVolume().

◆ IopOpenRegistryKeyEx()

NTSTATUS NTAPI IopOpenRegistryKeyEx	(	PHANDLE	KeyHandle,
		HANDLE	ParentKey,
		PUNICODE_STRING	Name,
		ACCESS_MASK	DesiredAccess
	)

Definition at line 885 of file pnpmgr.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    *KeyHandle = NULL;
 
    InitializeObjectAttributes(&ObjectAttributes,
        Name,
        OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
        ParentKey,
        NULL);
 
    Status = ZwOpenKey(KeyHandle, DesiredAccess, &ObjectAttributes);
 
    return Status;
}

Referenced by CreateDeviceFromRegistry(), EnumerateDevices(), IoOpenDeviceRegistryKey(), IopCreateDeviceKeyPath(), IopEnumerateDetectedDevices(), IopGetParentIdPrefix(), IopInitializeBootDrivers(), IopInitializeBuiltinDriver(), IopInitializePlugPlayServices(), IopLoadUnloadDriverWorker(), IopOpenOrCreateSymbolicLinkSubKeys(), IopSetServiceEnumData(), IopStoreSystemPartitionInformation(), IopUpdateControlKeyWithResources(), IopUpdateRootKey(), IoSetSystemPartition(), OpenRegistryHandlesFromSymbolicLink(), PiAttachFilterDriversCallback(), PiCallDriverAddDevice(), PiGetDeviceRegistryProperty(), PiInitCacheGroupInformation(), PipGetDriverTagPriority(), PiStartDeviceFinal(), PnpDeviceObjectToDeviceInstance(), and PnpRootCreateDevice().

◆ IopParseDevice()

NTSTATUS NTAPI IopParseDevice	(	IN PVOID	ParseObject,
		IN PVOID	ObjectType,
		IN OUT PACCESS_STATE	AccessState,
		IN KPROCESSOR_MODE	AccessMode,
		IN ULONG	Attributes,
		IN OUT PUNICODE_STRING	CompleteName,
		IN OUT PUNICODE_STRING	RemainingName,
		IN OUT PVOID	Context,
		IN PSECURITY_QUALITY_OF_SERVICE SecurityQos	OPTIONAL,
		OUT PVOID *	Object
	)

Definition at line 324 of file file.c.

{
    POPEN_PACKET OpenPacket = (POPEN_PACKET)Context;
    PDEVICE_OBJECT OriginalDeviceObject = (PDEVICE_OBJECT)ParseObject;
    PDEVICE_OBJECT DeviceObject, OwnerDevice;
    NTSTATUS Status;
    PFILE_OBJECT FileObject;
    PVPB Vpb = NULL;
    PIRP Irp;
    PIO_STACK_LOCATION StackLoc;
    IO_SECURITY_CONTEXT SecurityContext;
    IO_STATUS_BLOCK IoStatusBlock;
    BOOLEAN DirectOpen = FALSE, OpenCancelled, UseDummyFile;
    OBJECT_ATTRIBUTES ObjectAttributes;
    KIRQL OldIrql;
    PDUMMY_FILE_OBJECT LocalFileObject;
    PFILE_BASIC_INFORMATION FileBasicInfo;
    ULONG ReturnLength;
    KPROCESSOR_MODE CheckMode;
    BOOLEAN VolumeOpen = FALSE;
    ACCESS_MASK DesiredAccess, GrantedAccess;
    BOOLEAN AccessGranted, LockHeld = FALSE;
    PPRIVILEGE_SET Privileges = NULL;
    UNICODE_STRING FileString;
    USHORT Attempt;
    IOTRACE(IO_FILE_DEBUG, "ParseObject: %p. RemainingName: %wZ\n",
            ParseObject, RemainingName);
 
    for (Attempt = 0; Attempt < IOP_MAX_REPARSE_TRAVERSAL; ++Attempt)
    {
        /* Assume failure */
        *Object = NULL;
 
        /* Validate the open packet */
        if (!IopValidateOpenPacket(OpenPacket)) return STATUS_OBJECT_TYPE_MISMATCH;
 
        /* Valide reparse point in case we traversed a mountpoint */
        if (OpenPacket->TraversedMountPoint)
        {
            /* This is a reparse point we understand */
            ASSERT(OpenPacket->Information == IO_REPARSE_TAG_MOUNT_POINT);
 
            /* Make sure we're dealing with correct DO */
            if (OriginalDeviceObject->DeviceType != FILE_DEVICE_DISK &&
                OriginalDeviceObject->DeviceType != FILE_DEVICE_CD_ROM &&
                OriginalDeviceObject->DeviceType != FILE_DEVICE_VIRTUAL_DISK &&
                OriginalDeviceObject->DeviceType != FILE_DEVICE_TAPE)
            {
                OpenPacket->FinalStatus = STATUS_IO_REPARSE_DATA_INVALID;
                return STATUS_IO_REPARSE_DATA_INVALID;
            }
        }
 
        /* Check if we have a related file object */
        if (OpenPacket->RelatedFileObject)
        {
            /* Use the related file object's device object */
            OriginalDeviceObject = OpenPacket->RelatedFileObject->DeviceObject;
        }
 
        /* Validate device status */
        Status = IopCheckDeviceAndDriver(OpenPacket, OriginalDeviceObject);
        if (!NT_SUCCESS(Status))
        {
            /* We failed, return status */
            OpenPacket->FinalStatus = Status;
            return Status;
        }
 
        /* Map the generic mask and set the new mapping in the access state */
        RtlMapGenericMask(&AccessState->RemainingDesiredAccess,
                          &IoFileObjectType->TypeInfo.GenericMapping);
        RtlMapGenericMask(&AccessState->OriginalDesiredAccess,
                          &IoFileObjectType->TypeInfo.GenericMapping);
        SeSetAccessStateGenericMapping(AccessState,
                                       &IoFileObjectType->TypeInfo.GenericMapping);
        DesiredAccess = AccessState->RemainingDesiredAccess;
 
        /* Check what kind of access checks to do */
        if ((AccessMode != KernelMode) ||
            (OpenPacket->Options & IO_FORCE_ACCESS_CHECK))
        {
            /* Call is from user-mode or kernel is forcing checks */
            CheckMode = UserMode;
        }
        else
        {
            /* Call is from the kernel */
            CheckMode = KernelMode;
        }
 
        /* Check privilege for backup or restore operation */
        IopCheckBackupRestorePrivilege(AccessState,
                                       &OpenPacket->CreateOptions,
                                       CheckMode,
                                       OpenPacket->Disposition);
 
        /* Check if we are re-parsing */
        if (((OpenPacket->Override) && !(RemainingName->Length)) ||
            (AccessState->Flags & SE_BACKUP_PRIVILEGES_CHECKED))
        {
            /* Get granted access from the last call */
            DesiredAccess |= AccessState->PreviouslyGrantedAccess;
        }
 
        /* Check if this is a volume open */
        if ((OpenPacket->RelatedFileObject) &&
            (OpenPacket->RelatedFileObject->Flags & FO_VOLUME_OPEN) &&
            !(RemainingName->Length))
        {
            /* It is */
            VolumeOpen = TRUE;
        }
 
        /* Now check if we need access checks */
        if (((AccessMode != KernelMode) ||
             (OpenPacket->Options & IO_FORCE_ACCESS_CHECK)) &&
            (!(OpenPacket->RelatedFileObject) || (VolumeOpen)) &&
            !(OpenPacket->Override))
        {
            KeEnterCriticalRegion();
            ExAcquireResourceSharedLite(&IopSecurityResource, TRUE);
 
            /* Check if a device object is being parsed  */
            if (!RemainingName->Length)
            {
                /* Lock the subject context */
                SeLockSubjectContext(&AccessState->SubjectSecurityContext);
                LockHeld = TRUE;
 
                /* Do access check */
                AccessGranted = SeAccessCheck(OriginalDeviceObject->
                                              SecurityDescriptor,
                                              &AccessState->SubjectSecurityContext,
                                              LockHeld,
                                              DesiredAccess,
                                              0,
                                              &Privileges,
                                              &IoFileObjectType->
                                              TypeInfo.GenericMapping,
                                              UserMode,
                                              &GrantedAccess,
                                              &Status);
                if (Privileges)
                {
                    /* Append and free the privileges */
                    SeAppendPrivileges(AccessState, Privileges);
                    SeFreePrivileges(Privileges);
                }
 
                /* Check if we got access */
                if (AccessGranted)
                {
                    /* Update access state */
                    AccessState->PreviouslyGrantedAccess |= GrantedAccess;
                    AccessState->RemainingDesiredAccess &= ~(GrantedAccess |
                                                             MAXIMUM_ALLOWED);
                    OpenPacket->Override= TRUE;
                }
 
                FileString.Length = 8;
                FileString.MaximumLength = 8;
                FileString.Buffer = L"File";
 
                /* Do Audit/Alarm for open operation */
                SeOpenObjectAuditAlarm(&FileString,
                                       OriginalDeviceObject,
                                       CompleteName,
                                       OriginalDeviceObject->SecurityDescriptor,
                                       AccessState,
                                       FALSE,
                                       AccessGranted,
                                       UserMode,
                                       &AccessState->GenerateOnClose);
            }
            else
            {
                /* Check if we need to do traverse validation */
                if (!(AccessState->Flags & TOKEN_HAS_TRAVERSE_PRIVILEGE) ||
                    ((OriginalDeviceObject->DeviceType == FILE_DEVICE_DISK) ||
                     (OriginalDeviceObject->DeviceType == FILE_DEVICE_CD_ROM)))
                {
                    /* Check if this is a restricted token */
                    if (!(AccessState->Flags & TOKEN_IS_RESTRICTED))
                    {
                        /* Do the FAST traverse check */
                        AccessGranted = SeFastTraverseCheck(OriginalDeviceObject->SecurityDescriptor,
                                                            AccessState,
                                                            FILE_TRAVERSE,
                                                            UserMode);
                    }
                    else
                    {
                        /* Fail */
                        AccessGranted = FALSE;
                    }
 
                    /* Check if we failed to get access */
                    if (!AccessGranted)
                    {
                        /* Lock the subject context */
                        SeLockSubjectContext(&AccessState->SubjectSecurityContext);
                        LockHeld = TRUE;
 
                        /* Do access check */
                        AccessGranted = SeAccessCheck(OriginalDeviceObject->
                                                      SecurityDescriptor,
                                                      &AccessState->SubjectSecurityContext,
                                                      LockHeld,
                                                      FILE_TRAVERSE,
                                                      0,
                                                      &Privileges,
                                                      &IoFileObjectType->
                                                      TypeInfo.GenericMapping,
                                                      UserMode,
                                                      &GrantedAccess,
                                                      &Status);
                        if (Privileges)
                        {
                            /* Append and free the privileges */
                            SeAppendPrivileges(AccessState, Privileges);
                            SeFreePrivileges(Privileges);
                        }
                    }
 
                    /* FIXME: Do Audit/Alarm for traverse check */
                }
                else
                {
                    /* Access automatically granted */
                    AccessGranted = TRUE;
                }
            }
 
            ExReleaseResourceLite(&IopSecurityResource);
            KeLeaveCriticalRegion();
 
            /* Check if we hold the lock */
            if (LockHeld)
            {
                /* Release it */
                SeUnlockSubjectContext(&AccessState->SubjectSecurityContext);
            }
 
            /* Check if access failed */
            if (!AccessGranted)
            {
                /* Dereference the device and fail */
                DPRINT1("Traverse access failed!\n");
                IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
                return STATUS_ACCESS_DENIED;
            }
        }
 
        /* Check if we can simply use a dummy file */
        UseDummyFile = ((OpenPacket->QueryOnly) || (OpenPacket->DeleteOnly));
 
        /* Check if this is a direct open */
        if (!(RemainingName->Length) &&
            !(OpenPacket->RelatedFileObject) &&
            ((DesiredAccess & ~(SYNCHRONIZE |
                                FILE_READ_ATTRIBUTES |
                                READ_CONTROL |
                                ACCESS_SYSTEM_SECURITY |
                                WRITE_OWNER |
                                WRITE_DAC)) == 0) &&
            !(UseDummyFile))
        {
            /* Remember this for later */
            DirectOpen = TRUE;
        }
 
        /* Check if we have a related FO that wasn't a direct open */
        if ((OpenPacket->RelatedFileObject) &&
            !(OpenPacket->RelatedFileObject->Flags & FO_DIRECT_DEVICE_OPEN))
        {
            /* The device object is the one we were given */
            DeviceObject = ParseObject;
 
            /* Check if the related FO had a VPB */
            if (OpenPacket->RelatedFileObject->Vpb)
            {
                /* Yes, remember it */
                Vpb = OpenPacket->RelatedFileObject->Vpb;
 
                /* Reference it */
                InterlockedIncrement((PLONG)&Vpb->ReferenceCount);
 
                /* Check if we were given a specific top level device to use */
                if (OpenPacket->InternalFlags & IOP_USE_TOP_LEVEL_DEVICE_HINT)
                {
                    DeviceObject = Vpb->DeviceObject;
                }
            }
        }
        else
        {
            /* Check if it has a VPB */
            if ((OriginalDeviceObject->Vpb) && !(DirectOpen))
            {
                /* Check if the VPB is mounted, and mount it */
                Vpb = IopCheckVpbMounted(OpenPacket,
                                         OriginalDeviceObject,
                                         RemainingName,
                                         &Status);
                if (!Vpb) return Status;
 
                /* Get the VPB's device object */
                DeviceObject = Vpb->DeviceObject;
            }
            else
            {
                /* The device object is the one we were given */
                DeviceObject = OriginalDeviceObject;
            }
 
            /* If we weren't given a specific top level device, look for an attached device */
            if (!(OpenPacket->InternalFlags & IOP_USE_TOP_LEVEL_DEVICE_HINT) &&
                DeviceObject->AttachedDevice)
            {
                /* Get the attached device */
                DeviceObject = IoGetAttachedDevice(DeviceObject);
            }
        }
 
        /* If we have a top level device hint, verify it */
        if (OpenPacket->InternalFlags & IOP_USE_TOP_LEVEL_DEVICE_HINT)
        {
            Status = IopCheckTopDeviceHint(&DeviceObject, OpenPacket, DirectOpen);
            if (!NT_SUCCESS(Status))
            {
                IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
                if (Vpb) IopDereferenceVpbAndFree(Vpb);
                return Status;
            }
        }
 
        /* If we traversed a mount point, reset the information */
        if (OpenPacket->TraversedMountPoint)
        {
            OpenPacket->TraversedMountPoint = FALSE;
        }
 
        /* Check if this is a secure FSD */
        if ((DeviceObject->Characteristics & FILE_DEVICE_SECURE_OPEN) &&
            ((OpenPacket->RelatedFileObject) || (RemainingName->Length)) &&
            (!VolumeOpen))
        {
            Privileges = NULL;
            GrantedAccess = 0;
 
            KeEnterCriticalRegion();
            ExAcquireResourceSharedLite(&IopSecurityResource, TRUE);
 
            /* Lock the subject context */
            SeLockSubjectContext(&AccessState->SubjectSecurityContext);
 
            /* Do access check */
            AccessGranted = SeAccessCheck(OriginalDeviceObject->SecurityDescriptor,
                                          &AccessState->SubjectSecurityContext,
                                          TRUE,
                                          DesiredAccess,
                                          0,
                                          &Privileges,
                                          &IoFileObjectType->TypeInfo.GenericMapping,
                                          UserMode,
                                          &GrantedAccess,
                                          &Status);
            if (Privileges != NULL)
            {
                /* Append and free the privileges */
                SeAppendPrivileges(AccessState, Privileges);
                SeFreePrivileges(Privileges);
            }
 
            /* Check if we got access */
            if (GrantedAccess)
            {
                AccessState->PreviouslyGrantedAccess |= GrantedAccess;
                AccessState->RemainingDesiredAccess &= ~(GrantedAccess | MAXIMUM_ALLOWED);
            }
 
            FileString.Length = 8;
            FileString.MaximumLength = 8;
            FileString.Buffer = L"File";
 
            /* Do Audit/Alarm for open operation
             * NOTA: we audit target device object
             */
            SeOpenObjectAuditAlarm(&FileString,
                                   DeviceObject,
                                   CompleteName,
                                   OriginalDeviceObject->SecurityDescriptor,
                                   AccessState,
                                   FALSE,
                                   AccessGranted,
                                   UserMode,
                                   &AccessState->GenerateOnClose);
 
            SeUnlockSubjectContext(&AccessState->SubjectSecurityContext);
 
            ExReleaseResourceLite(&IopSecurityResource);
            KeLeaveCriticalRegion();
 
            /* Check if access failed */
            if (!AccessGranted)
            {
                /* Dereference the device and fail */
                IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
                if (Vpb) IopDereferenceVpbAndFree(Vpb);
                return STATUS_ACCESS_DENIED;
            }
        }
 
        /* Allocate the IRP */
        Irp = IoAllocateIrp(DeviceObject->StackSize, TRUE);
        if (!Irp)
        {
            /* Dereference the device and VPB, then fail */
            IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
            if (Vpb) IopDereferenceVpbAndFree(Vpb);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* Now set the IRP data */
        Irp->RequestorMode = AccessMode;
        Irp->Flags = IRP_CREATE_OPERATION | IRP_SYNCHRONOUS_API | IRP_DEFER_IO_COMPLETION;
        Irp->Tail.Overlay.Thread = PsGetCurrentThread();
        Irp->UserIosb = &IoStatusBlock;
        Irp->MdlAddress = NULL;
        Irp->PendingReturned = FALSE;
        Irp->UserEvent = NULL;
        Irp->Cancel = FALSE;
        Irp->CancelRoutine = NULL;
        Irp->Tail.Overlay.AuxiliaryBuffer = NULL;
 
        /* Setup the security context */
        SecurityContext.SecurityQos = SecurityQos;
        SecurityContext.AccessState = AccessState;
        SecurityContext.DesiredAccess = AccessState->RemainingDesiredAccess;
        SecurityContext.FullCreateOptions = OpenPacket->CreateOptions;
 
        /* Get the I/O Stack location */
        StackLoc = IoGetNextIrpStackLocation(Irp);
        StackLoc->Control = 0;
 
        /* Check what kind of file this is */
        switch (OpenPacket->CreateFileType)
        {
            /* Normal file */
            case CreateFileTypeNone:
 
                /* Set the major function and EA Length */
                StackLoc->MajorFunction = IRP_MJ_CREATE;
                StackLoc->Parameters.Create.EaLength = OpenPacket->EaLength;
 
                /* Set the flags */
                StackLoc->Flags = (UCHAR)OpenPacket->Options;
                StackLoc->Flags |= !(Attributes & OBJ_CASE_INSENSITIVE) ? SL_CASE_SENSITIVE: 0;
                break;
 
            /* Named pipe */
            case CreateFileTypeNamedPipe:
 
                /* Set the named pipe MJ and set the parameters */
                StackLoc->MajorFunction = IRP_MJ_CREATE_NAMED_PIPE;
                StackLoc->Parameters.CreatePipe.Parameters = OpenPacket->ExtraCreateParameters;
                break;
 
            /* Mailslot */
            case CreateFileTypeMailslot:
 
                /* Set the mailslot MJ and set the parameters */
                StackLoc->MajorFunction = IRP_MJ_CREATE_MAILSLOT;
                StackLoc->Parameters.CreateMailslot.Parameters = OpenPacket->ExtraCreateParameters;
                break;
        }
 
        /* Set the common data */
        Irp->Overlay.AllocationSize = OpenPacket->AllocationSize;
        Irp->AssociatedIrp.SystemBuffer = OpenPacket->EaBuffer;
        StackLoc->Parameters.Create.Options = (OpenPacket->Disposition << 24) |
                                              (OpenPacket->CreateOptions &
                                               0xFFFFFF);
        StackLoc->Parameters.Create.FileAttributes = OpenPacket->FileAttributes;
        StackLoc->Parameters.Create.ShareAccess = OpenPacket->ShareAccess;
        StackLoc->Parameters.Create.SecurityContext = &SecurityContext;
 
        /* Check if we really need to create an object */
        if (!UseDummyFile)
        {
            ULONG ObjectSize = sizeof(FILE_OBJECT);
 
            /* Tag on space for a file object extension */
            if (OpenPacket->InternalFlags & IOP_CREATE_FILE_OBJECT_EXTENSION)
                ObjectSize += sizeof(FILE_OBJECT_EXTENSION);
 
            /* Create the actual file object */
            InitializeObjectAttributes(&ObjectAttributes,
                                       NULL,
                                       Attributes,
                                       NULL,
                                       NULL);
            Status = ObCreateObject(KernelMode,
                                    IoFileObjectType,
                                    &ObjectAttributes,
                                    AccessMode,
                                    NULL,
                                    ObjectSize,
                                    0,
                                    0,
                                    (PVOID*)&FileObject);
            if (!NT_SUCCESS(Status))
            {
                /* Create failed, free the IRP */
                IoFreeIrp(Irp);
 
                /* Dereference the device and VPB */
                IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
                if (Vpb) IopDereferenceVpbAndFree(Vpb);
 
                /* We failed, return status */
                OpenPacket->FinalStatus = Status;
                return Status;
            }
 
            /* Clear the file object */
            RtlZeroMemory(FileObject, ObjectSize);
 
            /* Check if this is Synch I/O */
            if (OpenPacket->CreateOptions &
                (FILE_SYNCHRONOUS_IO_ALERT | FILE_SYNCHRONOUS_IO_NONALERT))
            {
                /* Set the synch flag */
                FileObject->Flags |= FO_SYNCHRONOUS_IO;
 
                /* Check if it's also alertable */
                if (OpenPacket->CreateOptions & FILE_SYNCHRONOUS_IO_ALERT)
                {
                    /* It is, set the alertable flag */
                    FileObject->Flags |= FO_ALERTABLE_IO;
                }
            }
 
            /* Check if this is synch I/O */
            if (FileObject->Flags & FO_SYNCHRONOUS_IO)
            {
                /* Initialize the event */
                KeInitializeEvent(&FileObject->Lock, SynchronizationEvent, FALSE);
            }
 
            /* Check if the caller requested no intermediate buffering */
            if (OpenPacket->CreateOptions & FILE_NO_INTERMEDIATE_BUFFERING)
            {
                /* Set the correct flag for the FSD to read */
                FileObject->Flags |= FO_NO_INTERMEDIATE_BUFFERING;
            }
 
            /* Check if the caller requested write through support */
            if (OpenPacket->CreateOptions & FILE_WRITE_THROUGH)
            {
                /* Set the correct flag for the FSD to read */
                FileObject->Flags |= FO_WRITE_THROUGH;
            }
 
            /* Check if the caller says the file will be only read sequentially */
            if (OpenPacket->CreateOptions & FILE_SEQUENTIAL_ONLY)
            {
                /* Set the correct flag for the FSD to read */
                FileObject->Flags |= FO_SEQUENTIAL_ONLY;
            }
 
            /* Check if the caller believes the file will be only read randomly */
            if (OpenPacket->CreateOptions & FILE_RANDOM_ACCESS)
            {
                /* Set the correct flag for the FSD to read */
                FileObject->Flags |= FO_RANDOM_ACCESS;
            }
 
            /* Check if we were asked to setup a file object extension */
            if (OpenPacket->InternalFlags & IOP_CREATE_FILE_OBJECT_EXTENSION)
            {
                PFILE_OBJECT_EXTENSION FileObjectExtension;
 
                /* Make sure the file object knows it has an extension */
                FileObject->Flags |= FO_FILE_OBJECT_HAS_EXTENSION;
 
                /* Initialize file object extension */
                FileObjectExtension = (PFILE_OBJECT_EXTENSION)(FileObject + 1);
                FileObject->FileObjectExtension = FileObjectExtension;
 
                /* Add the top level device which we'll send the request to */
                if (OpenPacket->InternalFlags & IOP_USE_TOP_LEVEL_DEVICE_HINT)
                {
                    FileObjectExtension->TopDeviceObjectHint = DeviceObject;
                }
            }
        }
        else
        {
            /* Use the dummy object instead */
            LocalFileObject = OpenPacket->LocalFileObject;
            RtlZeroMemory(LocalFileObject, sizeof(DUMMY_FILE_OBJECT));
 
            /* Set it up */
            FileObject = (PFILE_OBJECT)&LocalFileObject->ObjectHeader.Body;
            LocalFileObject->ObjectHeader.Type = IoFileObjectType;
            LocalFileObject->ObjectHeader.PointerCount = 1;
        }
 
        /* Setup the file header */
        FileObject->Type = IO_TYPE_FILE;
        FileObject->Size = sizeof(FILE_OBJECT);
        FileObject->RelatedFileObject = OpenPacket->RelatedFileObject;
        FileObject->DeviceObject = OriginalDeviceObject;
 
        /* Check if this is a direct device open */
        if (DirectOpen) FileObject->Flags |= FO_DIRECT_DEVICE_OPEN;
 
        /* Check if the caller wants case sensitivity */
        if (!(Attributes & OBJ_CASE_INSENSITIVE))
        {
            /* Tell the driver about it */
            FileObject->Flags |= FO_OPENED_CASE_SENSITIVE;
        }
 
        /* Now set the file object */
        Irp->Tail.Overlay.OriginalFileObject = FileObject;
        StackLoc->FileObject = FileObject;
 
        /* Check if the file object has a name */
        if (RemainingName->Length)
        {
            /* Setup the unicode string */
            FileObject->FileName.MaximumLength = RemainingName->Length + sizeof(WCHAR);
            FileObject->FileName.Buffer = ExAllocatePoolWithTag(PagedPool,
                                                                FileObject->FileName.MaximumLength,
                                                                TAG_IO_NAME);
            if (!FileObject->FileName.Buffer)
            {
                /* Failed to allocate the name, free the IRP */
                IoFreeIrp(Irp);
 
                /* Dereference the device object and VPB */
                IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
                if (Vpb) IopDereferenceVpbAndFree(Vpb);
 
                /* Clear the FO and dereference it */
                FileObject->DeviceObject = NULL;
                if (!UseDummyFile) ObDereferenceObject(FileObject);
 
                /* Fail */
                return STATUS_INSUFFICIENT_RESOURCES;
            }
        }
 
        /* Copy the name */
        RtlCopyUnicodeString(&FileObject->FileName, RemainingName);
 
        /* Initialize the File Object event and set the FO */
        KeInitializeEvent(&FileObject->Event, NotificationEvent, FALSE);
        OpenPacket->FileObject = FileObject;
 
        /* Queue the IRP and call the driver */
        IopQueueIrpToThread(Irp);
        Status = IoCallDriver(DeviceObject, Irp);
        if (Status == STATUS_PENDING)
        {
            /* Wait for the driver to complete the create */
            KeWaitForSingleObject(&FileObject->Event,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
 
            /* Get the new status */
            Status = IoStatusBlock.Status;
        }
        else
        {
            /* We'll have to complete it ourselves */
            ASSERT(!Irp->PendingReturned);
            ASSERT(!Irp->MdlAddress);
 
            /* Handle name change if required */
            if (Status == STATUS_REPARSE)
            {
                /* Check this is a mount point */
                if (Irp->IoStatus.Information == IO_REPARSE_TAG_MOUNT_POINT)
                {
                    PREPARSE_DATA_BUFFER ReparseData;
 
                    /* Reparse point attributes were passed by the driver in the auxiliary buffer */
                    ASSERT(Irp->Tail.Overlay.AuxiliaryBuffer != NULL);
                    ReparseData = (PREPARSE_DATA_BUFFER)Irp->Tail.Overlay.AuxiliaryBuffer;
 
                    ASSERT(ReparseData->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT);
                    ASSERT(ReparseData->ReparseDataLength < MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
                    ASSERT(ReparseData->Reserved < MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
 
                    IopDoNameTransmogrify(Irp, FileObject, ReparseData);
                }
            }
 
            /* Completion happens at APC_LEVEL */
            KeRaiseIrql(APC_LEVEL, &OldIrql);
 
            /* Get the new I/O Status block ourselves */
            IoStatusBlock = Irp->IoStatus;
            Status = IoStatusBlock.Status;
 
            /* Manually signal the even, we can't have any waiters */
            FileObject->Event.Header.SignalState = 1;
 
            /* Now that we've signaled the events, de-associate the IRP */
            IopUnQueueIrpFromThread(Irp);
 
            /* Check if the IRP had an input buffer */
            if ((Irp->Flags & IRP_BUFFERED_IO) &&
                (Irp->Flags & IRP_DEALLOCATE_BUFFER))
            {
                /* Free it. A driver might've tacked one on */
                ExFreePool(Irp->AssociatedIrp.SystemBuffer);
            }
 
            /* Free the IRP and bring the IRQL back down */
            IoFreeIrp(Irp);
            KeLowerIrql(OldIrql);
        }
 
        /* Copy the I/O Status */
        OpenPacket->Information = IoStatusBlock.Information;
 
        /* The driver failed to create the file */
        if (!NT_SUCCESS(Status))
        {
            /* Check if we have a name and if so, free it */
            if (FileObject->FileName.Length)
            {
                /*
                 * Don't use TAG_IO_NAME since the FileObject's FileName
                 * may have been re-allocated using a different tag
                 * by a filesystem.
                 */
                ExFreePoolWithTag(FileObject->FileName.Buffer, 0);
                FileObject->FileName.Buffer = NULL;
                FileObject->FileName.Length = 0;
            }
 
            /* Clear its device object */
            FileObject->DeviceObject = NULL;
 
            /* Save this now because the FO might go away */
            OpenCancelled = FileObject->Flags & FO_FILE_OPEN_CANCELLED ?
                            TRUE : FALSE;
 
            /* Clear the file object in the open packet */
            OpenPacket->FileObject = NULL;
 
            /* Dereference the file object */
            if (!UseDummyFile) ObDereferenceObject(FileObject);
 
            /* Dereference the device object */
            IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
 
            /* Unless the driver cancelled the open, dereference the VPB */
            if (!(OpenCancelled) && (Vpb)) IopDereferenceVpbAndFree(Vpb);
 
            /* Set the status and return */
            OpenPacket->FinalStatus = Status;
            return Status;
        }
        else if (Status == STATUS_REPARSE)
        {
            if (OpenPacket->Information == IO_REPARSE ||
                OpenPacket->Information == IO_REPARSE_TAG_MOUNT_POINT)
            {
                /* Update CompleteName with reparse info which got updated in IopDoNameTransmogrify() */
                if (CompleteName->MaximumLength < FileObject->FileName.Length)
                {
                    PWSTR NewCompleteName;
 
                    /* Allocate a new buffer for the string */
                    NewCompleteName = ExAllocatePoolWithTag(PagedPool, FileObject->FileName.Length, TAG_IO_NAME);
                    if (NewCompleteName == NULL)
                    {
                        OpenPacket->FinalStatus = STATUS_INSUFFICIENT_RESOURCES;
                        return STATUS_INSUFFICIENT_RESOURCES;
                    }
 
                    /* Release the old one */
                    if (CompleteName->Buffer != NULL)
                    {
                        /*
                         * Don't use TAG_IO_NAME since the FileObject's FileName
                         * may have been re-allocated using a different tag
                         * by a filesystem.
                         */
                        ExFreePoolWithTag(CompleteName->Buffer, 0);
                    }
 
                    /* And setup the new one */
                    CompleteName->Buffer = NewCompleteName;
                    CompleteName->MaximumLength = FileObject->FileName.Length;
                }
 
                /* Copy our new complete name */
                RtlCopyUnicodeString(CompleteName, &FileObject->FileName);
 
                if (OpenPacket->Information == IO_REPARSE_TAG_MOUNT_POINT)
                {
                    OpenPacket->RelatedFileObject = NULL;
                }
            }
 
            /* Check if we have a name and if so, free it */
            if (FileObject->FileName.Length)
            {
                /*
                 * Don't use TAG_IO_NAME since the FileObject's FileName
                 * may have been re-allocated using a different tag
                 * by a filesystem.
                 */
                ExFreePoolWithTag(FileObject->FileName.Buffer, 0);
                FileObject->FileName.Buffer = NULL;
                FileObject->FileName.Length = 0;
            }
 
            /* Clear its device object */
            FileObject->DeviceObject = NULL;
 
            /* Clear the file object in the open packet */
            OpenPacket->FileObject = NULL;
 
            /* Dereference the file object */
            if (!UseDummyFile) ObDereferenceObject(FileObject);
 
            /* Dereference the device object */
            IopDereferenceDeviceObject(OriginalDeviceObject, FALSE);
 
            /* Unless the driver cancelled the open, dereference the VPB */
            if (Vpb != NULL) IopDereferenceVpbAndFree(Vpb);
 
            if (OpenPacket->Information != IO_REMOUNT)
            {
                OpenPacket->RelatedFileObject = NULL;
 
                /* Inform we traversed a mount point for later attempt */
                if (OpenPacket->Information == IO_REPARSE_TAG_MOUNT_POINT)
                {
                    OpenPacket->TraversedMountPoint = 1;
                }
 
                /* In case we override checks, but got this on volume open, fail hard */
                if (OpenPacket->Override)
                {
                    KeBugCheckEx(DRIVER_RETURNED_STATUS_REPARSE_FOR_VOLUME_OPEN,
                                 (ULONG_PTR)OriginalDeviceObject,
                                 (ULONG_PTR)DeviceObject,
                                 (ULONG_PTR)CompleteName,
                                 OpenPacket->Information);
                }
 
                /* Return to IO/OB so that information can be upgraded */
                return STATUS_REPARSE;
            }
 
            /* Loop again and reattempt an opening */
            continue;
        }
 
        break;
    }
 
    if (Attempt == IOP_MAX_REPARSE_TRAVERSAL)
        return STATUS_UNSUCCESSFUL;
 
    /* Get the owner of the File Object */
    OwnerDevice = IoGetRelatedDeviceObject(FileObject);
 
    /*
     * It's possible that the device to whom we sent the IRP to
     * isn't actually the device that ended opening the file object
     * internally.
     */
    if (OwnerDevice != DeviceObject)
    {
        /* We have to de-reference the VPB we had associated */
        if (Vpb) IopDereferenceVpbAndFree(Vpb);
 
        /* And re-associate with the actual one */
        Vpb = FileObject->Vpb;
        if (Vpb) InterlockedIncrement((PLONG)&Vpb->ReferenceCount);
    }
 
    /* Make sure we are not using a dummy */
    if (!UseDummyFile)
    {
        /* Check if this was a volume open */
        if ((!(FileObject->RelatedFileObject) ||
              (FileObject->RelatedFileObject->Flags & FO_VOLUME_OPEN)) &&
            !(FileObject->FileName.Length))
        {
            /* All signs point to it, but make sure it was actually an FSD */
            if ((OwnerDevice->DeviceType == FILE_DEVICE_DISK_FILE_SYSTEM) ||
                (OwnerDevice->DeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM) ||
                (OwnerDevice->DeviceType == FILE_DEVICE_TAPE_FILE_SYSTEM) ||
                (OwnerDevice->DeviceType == FILE_DEVICE_FILE_SYSTEM))
            {
                /* The owner device is an FSD, so this is a volume open for real */
                FileObject->Flags |= FO_VOLUME_OPEN;
            }
        }
 
        /* Reference the object and set the parse check */
        ObReferenceObject(FileObject);
        *Object = FileObject;
        OpenPacket->FinalStatus = IoStatusBlock.Status;
        OpenPacket->ParseCheck = TRUE;
        return OpenPacket->FinalStatus;
    }
    else
    {
        /* Check if this was a query */
        if (OpenPacket->QueryOnly)
        {
            /* Check if the caller wants basic info only */
            if (!OpenPacket->FullAttributes)
            {
                /* Allocate the buffer */
                FileBasicInfo = ExAllocatePoolWithTag(NonPagedPool,
                                                      sizeof(*FileBasicInfo),
                                                      TAG_IO);
                if (FileBasicInfo)
                {
                    /* Do the query */
                    Status = IoQueryFileInformation(FileObject,
                                                    FileBasicInformation,
                                                    sizeof(*FileBasicInfo),
                                                    FileBasicInfo,
                                                    &ReturnLength);
                    if (NT_SUCCESS(Status))
                    {
                        /* Copy the data */
                        RtlCopyMemory(OpenPacket->BasicInformation,
                                      FileBasicInfo,
                                      ReturnLength);
                    }
 
                    /* Free our buffer */
                    ExFreePoolWithTag(FileBasicInfo, TAG_IO);
                }
                else
                {
                    /* Fail */
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                }
            }
            else
            {
                /* This is a full query */
                Status = IoQueryFileInformation(
                    FileObject,
                    FileNetworkOpenInformation,
                    sizeof(FILE_NETWORK_OPEN_INFORMATION),
                    OpenPacket->NetworkInformation,
                    &ReturnLength);
                if (!NT_SUCCESS(Status)) ASSERT(Status != STATUS_NOT_IMPLEMENTED);
            }
        }
 
        /* Delete the file object */
        IopDeleteFile(FileObject);
 
        /* Clear out the file */
        OpenPacket->FileObject = NULL;
 
        /* Set and return status */
        OpenPacket->FinalStatus = Status;
        OpenPacket->ParseCheck = TRUE;
        return Status;
    }
}

Referenced by IopCreateObjectTypes(), and IopParseFile().

◆ IopParseFile()

NTSTATUS NTAPI IopParseFile	(	IN PVOID	ParseObject,
		IN PVOID	ObjectType,
		IN OUT PACCESS_STATE	AccessState,
		IN KPROCESSOR_MODE	AccessMode,
		IN ULONG	Attributes,
		IN OUT PUNICODE_STRING	CompleteName,
		IN OUT PUNICODE_STRING	RemainingName,
		IN OUT PVOID Context	OPTIONAL,
		IN PSECURITY_QUALITY_OF_SERVICE SecurityQos	OPTIONAL,
		OUT PVOID *	Object
	)

Definition at line 1319 of file file.c.

{
    PVOID DeviceObject;
    POPEN_PACKET OpenPacket = (POPEN_PACKET)Context;
 
    /* Validate the open packet */
    if (!IopValidateOpenPacket(OpenPacket)) return STATUS_OBJECT_TYPE_MISMATCH;
 
    /* Get the device object */
    DeviceObject = IoGetRelatedDeviceObject(ParseObject);
    OpenPacket->RelatedFileObject = ParseObject;
 
    /* Call the main routine */
    return IopParseDevice(DeviceObject,
                          ObjectType,
                          AccessState,
                          AccessMode,
                          Attributes,
                          CompleteName,
                          RemainingName,
                          OpenPacket,
                          SecurityQos,
                          Object);
}

Referenced by IopCreateObjectTypes().

◆ IopQueryDeviceCapabilities()

NTSTATUS NTAPI IopQueryDeviceCapabilities	(	PDEVICE_NODE	DeviceNode,
		PDEVICE_CAPABILITIES	DeviceCaps
	)

Definition at line 854 of file devaction.c.

{
    IO_STATUS_BLOCK StatusBlock;
    IO_STACK_LOCATION Stack;
    NTSTATUS Status;
    HANDLE InstanceKey;
    UNICODE_STRING ValueName;
 
    /* Set up the Header */
    RtlZeroMemory(DeviceCaps, sizeof(DEVICE_CAPABILITIES));
    DeviceCaps->Size = sizeof(DEVICE_CAPABILITIES);
    DeviceCaps->Version = 1;
    DeviceCaps->Address = -1;
    DeviceCaps->UINumber = -1;
 
    /* Set up the Stack */
    RtlZeroMemory(&Stack, sizeof(IO_STACK_LOCATION));
    Stack.Parameters.DeviceCapabilities.Capabilities = DeviceCaps;
 
    /* Send the IRP */
    Status = IopInitiatePnpIrp(DeviceNode->PhysicalDeviceObject,
                               &StatusBlock,
                               IRP_MN_QUERY_CAPABILITIES,
                               &Stack);
    if (!NT_SUCCESS(Status))
    {
        if (Status != STATUS_NOT_SUPPORTED)
        {
            DPRINT1("IRP_MN_QUERY_CAPABILITIES failed with status 0x%lx\n", Status);
        }
        return Status;
    }
 
    /* Map device capabilities to capability flags */
    DeviceNode->CapabilityFlags = 0;
    if (DeviceCaps->LockSupported)
        DeviceNode->CapabilityFlags |= 0x00000001;    // CM_DEVCAP_LOCKSUPPORTED
 
    if (DeviceCaps->EjectSupported)
        DeviceNode->CapabilityFlags |= 0x00000002;    // CM_DEVCAP_EJECTSUPPORTED
 
    if (DeviceCaps->Removable)
        DeviceNode->CapabilityFlags |= 0x00000004;    // CM_DEVCAP_REMOVABLE
 
    if (DeviceCaps->DockDevice)
        DeviceNode->CapabilityFlags |= 0x00000008;    // CM_DEVCAP_DOCKDEVICE
 
    if (DeviceCaps->UniqueID)
        DeviceNode->CapabilityFlags |= 0x00000010;    // CM_DEVCAP_UNIQUEID
 
    if (DeviceCaps->SilentInstall)
        DeviceNode->CapabilityFlags |= 0x00000020;    // CM_DEVCAP_SILENTINSTALL
 
    if (DeviceCaps->RawDeviceOK)
        DeviceNode->CapabilityFlags |= 0x00000040;    // CM_DEVCAP_RAWDEVICEOK
 
    if (DeviceCaps->SurpriseRemovalOK)
        DeviceNode->CapabilityFlags |= 0x00000080;    // CM_DEVCAP_SURPRISEREMOVALOK
 
    if (DeviceCaps->HardwareDisabled)
        DeviceNode->CapabilityFlags |= 0x00000100;    // CM_DEVCAP_HARDWAREDISABLED
 
    if (DeviceCaps->NonDynamic)
        DeviceNode->CapabilityFlags |= 0x00000200;    // CM_DEVCAP_NONDYNAMIC
 
    if (DeviceCaps->NoDisplayInUI)
        DeviceNode->UserFlags |= DNUF_DONT_SHOW_IN_UI;
    else
        DeviceNode->UserFlags &= ~DNUF_DONT_SHOW_IN_UI;
 
    Status = IopCreateDeviceKeyPath(&DeviceNode->InstancePath, REG_OPTION_NON_VOLATILE, &InstanceKey);
    if (NT_SUCCESS(Status))
    {
        /* Set 'Capabilities' value */
        RtlInitUnicodeString(&ValueName, L"Capabilities");
        Status = ZwSetValueKey(InstanceKey,
                               &ValueName,
                               0,
                               REG_DWORD,
                               &DeviceNode->CapabilityFlags,
                               sizeof(ULONG));
 
        /* Set 'UINumber' value */
        if (DeviceCaps->UINumber != MAXULONG)
        {
            RtlInitUnicodeString(&ValueName, L"UINumber");
            Status = ZwSetValueKey(InstanceKey,
                                   &ValueName,
                                   0,
                                   REG_DWORD,
                                   &DeviceCaps->UINumber,
                                   sizeof(ULONG));
        }
 
        ZwClose(InstanceKey);
    }
 
    return Status;
}

Referenced by IoGetDeviceProperty(), IopCreateDeviceInstancePath(), IoRequestDeviceEject(), and PiStartDeviceFinal().

◆ IopQueryName()

NTSTATUS NTAPI IopQueryName	(	IN PVOID	ObjectBody,
		IN BOOLEAN	HasName,
		OUT POBJECT_NAME_INFORMATION	ObjectNameInfo,
		IN ULONG	Length,
		OUT PULONG	ReturnLength,
		IN KPROCESSOR_MODE	PreviousMode
	)

Definition at line 1926 of file file.c.

{
    return IopQueryNameInternal(ObjectBody,
                                HasName,
                                FALSE,
                                ObjectNameInfo,
                                Length,
                                ReturnLength,
                                PreviousMode);
}

Referenced by IopCreateObjectTypes().

◆ IopQueryNameInternal()

NTSTATUS NTAPI IopQueryNameInternal	(	IN PVOID	ObjectBody,
		IN BOOLEAN	HasName,
		IN BOOLEAN	QueryDosName,
		OUT POBJECT_NAME_INFORMATION	ObjectNameInfo,
		IN ULONG	Length,
		OUT PULONG	ReturnLength,
		IN KPROCESSOR_MODE	PreviousMode
	)

Definition at line 1944 of file file.c.

{
    POBJECT_NAME_INFORMATION LocalInfo;
    PFILE_NAME_INFORMATION LocalFileInfo;
    PFILE_OBJECT FileObject = (PFILE_OBJECT)ObjectBody;
    ULONG LocalReturnLength, FileLength;
    BOOLEAN LengthMismatch = FALSE;
    NTSTATUS Status;
    PWCHAR p;
    PDEVICE_OBJECT DeviceObject;
    BOOLEAN NoObCall;
 
    IOTRACE(IO_FILE_DEBUG, "ObjectBody: %p\n", ObjectBody);
 
    /* Validate length */
    if (Length < sizeof(OBJECT_NAME_INFORMATION))
    {
        /* Wrong length, fail */
        *ReturnLength = sizeof(OBJECT_NAME_INFORMATION);
        return STATUS_INFO_LENGTH_MISMATCH;
    }
 
    /* Allocate Buffer */
    LocalInfo = ExAllocatePoolWithTag(PagedPool, Length, TAG_IO);
    if (!LocalInfo) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Query DOS name if the caller asked to */
    NoObCall = FALSE;
    if (QueryDosName)
    {
        DeviceObject = FileObject->DeviceObject;
 
        /* In case of a network file system, don't call mountmgr */
        if (DeviceObject->DeviceType == FILE_DEVICE_NETWORK_FILE_SYSTEM)
        {
            /* We'll store separator and terminator */
            LocalReturnLength = sizeof(OBJECT_NAME_INFORMATION) + 2 * sizeof(WCHAR);
            if (Length < LocalReturnLength)
            {
                Status = STATUS_BUFFER_OVERFLOW;
            }
            else
            {
                LocalInfo->Name.Length = sizeof(WCHAR);
                LocalInfo->Name.MaximumLength = sizeof(WCHAR);
                LocalInfo->Name.Buffer = (PVOID)((ULONG_PTR)LocalInfo + sizeof(OBJECT_NAME_INFORMATION));
                LocalInfo->Name.Buffer[0] = OBJ_NAME_PATH_SEPARATOR;
                Status = STATUS_SUCCESS;
            }
        }
        /* Otherwise, call mountmgr to get DOS name */
        else
        {
            Status = IoVolumeDeviceToDosName(DeviceObject, &LocalInfo->Name);
            LocalReturnLength = LocalInfo->Name.Length + sizeof(OBJECT_NAME_INFORMATION) + sizeof(WCHAR);
        }
    }
 
    /* Fall back if querying DOS name failed or if caller never wanted it ;-) */
    if (!QueryDosName || !NT_SUCCESS(Status))
    {
        /* Query the name */
        Status = ObQueryNameString(FileObject->DeviceObject,
                                   LocalInfo,
                                   Length,
                                   &LocalReturnLength);
    }
    else
    {
        NoObCall = TRUE;
    }
 
    if (!NT_SUCCESS(Status) && (Status != STATUS_INFO_LENGTH_MISMATCH))
    {
        /* Free the buffer and fail */
        ExFreePoolWithTag(LocalInfo, TAG_IO);
        return Status;
    }
 
    /* Get buffer pointer */
    p = (PWCHAR)(ObjectNameInfo + 1);
 
    _SEH2_TRY
    {
        /* Copy the information */
        if (QueryDosName && NoObCall)
        {
            ASSERT(PreviousMode == KernelMode);
 
            /* Copy structure first */
            RtlCopyMemory(ObjectNameInfo,
                          LocalInfo,
                          (Length >= LocalReturnLength ? sizeof(OBJECT_NAME_INFORMATION) : Length));
            /* Name then */
            RtlCopyMemory(p, LocalInfo->Name.Buffer,
                          (Length >= LocalReturnLength ? LocalInfo->Name.Length : Length - sizeof(OBJECT_NAME_INFORMATION)));
 
            if (FileObject->DeviceObject->DeviceType != FILE_DEVICE_NETWORK_FILE_SYSTEM)
            {
                ExFreePool(LocalInfo->Name.Buffer);
            }
        }
        else
        {
            RtlCopyMemory(ObjectNameInfo,
                          LocalInfo,
                          (LocalReturnLength > Length) ?
                          Length : LocalReturnLength);
        }
 
        /* Set buffer pointer */
        ObjectNameInfo->Name.Buffer = p;
 
        /* Advance in buffer */
        p += (LocalInfo->Name.Length / sizeof(WCHAR));
 
        /* Check if this already filled our buffer */
        if (LocalReturnLength > Length)
        {
            /* Set the length mismatch to true, so that we can return
             * the proper buffer size to the caller later
             */
            LengthMismatch = TRUE;
 
            /* Save the initial buffer length value */
            *ReturnLength = LocalReturnLength;
        }
 
        /* Now get the file name buffer and check the length needed */
        LocalFileInfo = (PFILE_NAME_INFORMATION)LocalInfo;
        FileLength = Length -
                     LocalReturnLength +
                     FIELD_OFFSET(FILE_NAME_INFORMATION, FileName);
 
        /* Query the File name */
        if (PreviousMode == KernelMode &&
            BooleanFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO))
        {
            Status = IopGetFileInformation(FileObject,
                                           LengthMismatch ? Length : FileLength,
                                           FileNameInformation,
                                           LocalFileInfo,
                                           &LocalReturnLength);
        }
        else
        {
            Status = IoQueryFileInformation(FileObject,
                                            FileNameInformation,
                                            LengthMismatch ? Length : FileLength,
                                            LocalFileInfo,
                                            &LocalReturnLength);
        }
        if (NT_ERROR(Status))
        {
            /* Allow status that would mean it's not implemented in the storage stack */
            if (Status != STATUS_INVALID_PARAMETER && Status != STATUS_INVALID_DEVICE_REQUEST &&
                Status != STATUS_NOT_IMPLEMENTED && Status != STATUS_INVALID_INFO_CLASS)
            {
                _SEH2_LEAVE;
            }
 
            /* In such case, zero the output and reset the status */
            LocalReturnLength = FIELD_OFFSET(FILE_NAME_INFORMATION, FileName);
            LocalFileInfo->FileNameLength = 0;
            LocalFileInfo->FileName[0] = OBJ_NAME_PATH_SEPARATOR;
            Status = STATUS_SUCCESS;
        }
        else
        {
            /* We'll at least return the name length */
            if (LocalReturnLength < FIELD_OFFSET(FILE_NAME_INFORMATION, FileName))
            {
                LocalReturnLength = FIELD_OFFSET(FILE_NAME_INFORMATION, FileName);
            }
        }
 
        /* If the provided buffer is too small, return the required size */
        if (LengthMismatch)
        {
            /* Add the required length */
            *ReturnLength += LocalFileInfo->FileNameLength;
 
            /* Free the allocated buffer and return failure */
            Status = STATUS_BUFFER_OVERFLOW;
            _SEH2_LEAVE;
        }
 
        /* Now calculate the new lengths left */
        FileLength = LocalReturnLength -
                     FIELD_OFFSET(FILE_NAME_INFORMATION, FileName);
        LocalReturnLength = (ULONG)((ULONG_PTR)p -
                                    (ULONG_PTR)ObjectNameInfo +
                                    LocalFileInfo->FileNameLength);
 
        /* Don't copy the name if it's not valid */
        if (LocalFileInfo->FileName[0] != OBJ_NAME_PATH_SEPARATOR)
        {
            /* Free the allocated buffer and return failure */
            Status = STATUS_OBJECT_PATH_INVALID;
            _SEH2_LEAVE;
        }
 
        /* Write the Name and null-terminate it */
        RtlCopyMemory(p, LocalFileInfo->FileName, FileLength);
        p += (FileLength / sizeof(WCHAR));
        *p = UNICODE_NULL;
        LocalReturnLength += sizeof(UNICODE_NULL);
 
        /* Return the length needed */
        *ReturnLength = LocalReturnLength;
 
        /* Setup the length and maximum length */
        FileLength = (ULONG)((ULONG_PTR)p - (ULONG_PTR)ObjectNameInfo);
        ObjectNameInfo->Name.Length = (USHORT)FileLength -
                                              sizeof(OBJECT_NAME_INFORMATION);
        ObjectNameInfo->Name.MaximumLength = (USHORT)ObjectNameInfo->Name.Length +
                                                     sizeof(UNICODE_NULL);
    }
    _SEH2_FINALLY
    {
        /* Free buffer and return */
        ExFreePoolWithTag(LocalInfo, TAG_IO);
    } _SEH2_END;
 
    return Status;
}

Referenced by IopQueryName(), and IoQueryFileDosDeviceName().

◆ IopQueueDeviceChangeEvent()

NTSTATUS IopQueueDeviceChangeEvent	(	_In_ const GUID *	EventGuid,
		_In_ const GUID *	InterfaceClassGuid,
		_In_ PUNICODE_STRING	SymbolicLinkName
	)

Definition at line 52 of file plugplay.c.

{
    PPNP_EVENT_ENTRY EventEntry;
    UNICODE_STRING Copy;
    ULONG TotalSize;
 
    /* Allocate a big enough buffer */
    Copy.Length = 0;
    Copy.MaximumLength = SymbolicLinkName->Length + sizeof(UNICODE_NULL);
    TotalSize =
        FIELD_OFFSET(PLUGPLAY_EVENT_BLOCK, DeviceClass.SymbolicLinkName) +
        Copy.MaximumLength;
 
    EventEntry = ExAllocatePool(NonPagedPool,
                                TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
    if (!EventEntry)
        return STATUS_INSUFFICIENT_RESOURCES;
    RtlZeroMemory(EventEntry, TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
 
    /* Fill the buffer with the event GUID */
    RtlCopyMemory(&EventEntry->Event.EventGuid, EventGuid, sizeof(GUID));
    EventEntry->Event.EventCategory = DeviceClassChangeEvent;
    EventEntry->Event.TotalSize = TotalSize;
 
    /* Fill the interface class GUID */
    RtlCopyMemory(&EventEntry->Event.DeviceClass.ClassGuid, InterfaceClassGuid, sizeof(GUID));
 
    /* Fill the symbolic link name */
    RtlCopyMemory(&EventEntry->Event.DeviceClass.SymbolicLinkName,
                  SymbolicLinkName->Buffer, SymbolicLinkName->Length);
    EventEntry->Event.DeviceClass.SymbolicLinkName[SymbolicLinkName->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    InsertHeadList(&IopPnpEventQueueHead,
                   &EventEntry->ListEntry);
    KeSetEvent(&IopPnpNotifyEvent,
               0,
               FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by IoSetDeviceInterfaceState().

◆ IopQueueDeviceInstallEvent()

NTSTATUS IopQueueDeviceInstallEvent	(	_In_ const GUID *	Guid,
		_In_ PUNICODE_STRING	DeviceId
	)

Definition at line 97 of file plugplay.c.

{
    PPNP_EVENT_ENTRY EventEntry;
    UNICODE_STRING Copy;
    ULONG TotalSize;
 
    /* Allocate a big enough buffer */
    Copy.Length = 0;
    Copy.MaximumLength = DeviceId->Length + sizeof(UNICODE_NULL);
    TotalSize =
        FIELD_OFFSET(PLUGPLAY_EVENT_BLOCK, InstallDevice.DeviceId) +
        Copy.MaximumLength;
 
    EventEntry = ExAllocatePool(NonPagedPool,
                                TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
    if (!EventEntry)
        return STATUS_INSUFFICIENT_RESOURCES;
    RtlZeroMemory(EventEntry, TotalSize + FIELD_OFFSET(PNP_EVENT_ENTRY, Event));
 
    /* Fill the buffer with the event GUID */
    RtlCopyMemory(&EventEntry->Event.EventGuid, EventGuid, sizeof(GUID));
    EventEntry->Event.EventCategory = DeviceInstallEvent;
    EventEntry->Event.TotalSize = TotalSize;
 
    /* Fill the symbolic link name */
    RtlCopyMemory(&EventEntry->Event.InstallDevice.DeviceId,
                  DeviceId->Buffer, DeviceId->Length);
    EventEntry->Event.InstallDevice.DeviceId[DeviceId->Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    InsertHeadList(&IopPnpEventQueueHead, &EventEntry->ListEntry);
 
    KeSetEvent(&IopPnpNotifyEvent, 0, FALSE);
 
    return STATUS_SUCCESS;
}

Referenced by PiControlInitializeDevice(), and PiInitializeDevNode().

◆ IopQueueTargetDeviceEvent()

NTSTATUS IopQueueTargetDeviceEvent	(	_In_ const GUID *	Guid,
		_In_ PUNICODE_STRING	DeviceIds
	)

Referenced by IopQueryRemoveDevice(), IopRemoveDevice(), IoRequestDeviceEject(), and PiStartDeviceFinal().

◆ IopReadyDeviceObjects()

VOID NTAPI IopReadyDeviceObjects ( IN PDRIVER_OBJECT Driver )

Definition at line 34 of file device.c.

{
    PDEVICE_OBJECT DeviceObject;
    PAGED_CODE();
 
    /* Set the driver as initialized */
    Driver->Flags |= DRVO_INITIALIZED;
    DeviceObject = Driver->DeviceObject;
    while (DeviceObject)
    {
        /* Set every device as initialized too */
        DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
        DeviceObject = DeviceObject->NextDevice;
    }
}

Referenced by IopInitializeDriverModule().

◆ IopReassignSystemRoot()

NTSTATUS NTAPI IopReassignSystemRoot	(	IN PLOADER_PARAMETER_BLOCK	LoaderBlock,
		OUT PANSI_STRING	NtBootPath
	)

Definition at line 842 of file arcname.c.

{
    OBJECT_ATTRIBUTES ObjectAttributes;
    NTSTATUS Status;
    CHAR Buffer[256], AnsiBuffer[256];
    WCHAR ArcNameBuffer[64];
    ANSI_STRING TargetString, ArcString, TempString;
    UNICODE_STRING LinkName, TargetName, ArcName;
    HANDLE LinkHandle;
 
    /* Create the Unicode name for the current ARC boot device */
    sprintf(Buffer, "\\ArcName\\%s", LoaderBlock->ArcBootDeviceName);
    RtlInitAnsiString(&TargetString, Buffer);
    Status = RtlAnsiStringToUnicodeString(&TargetName, &TargetString, TRUE);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Initialize the attributes and open the link */
    InitializeObjectAttributes(&ObjectAttributes,
                               &TargetName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = NtOpenSymbolicLinkObject(&LinkHandle,
                                      SYMBOLIC_LINK_ALL_ACCESS,
                                      &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        /* We failed, free the string */
        RtlFreeUnicodeString(&TargetName);
        return FALSE;
    }
 
    /* Query the current \\SystemRoot */
    ArcName.Buffer = ArcNameBuffer;
    ArcName.Length = 0;
    ArcName.MaximumLength = sizeof(ArcNameBuffer);
    Status = NtQuerySymbolicLinkObject(LinkHandle, &ArcName, NULL);
    if (!NT_SUCCESS(Status))
    {
        /* We failed, free the string */
        RtlFreeUnicodeString(&TargetName);
        return FALSE;
    }
 
    /* Convert it to Ansi */
    ArcString.Buffer = AnsiBuffer;
    ArcString.Length = 0;
    ArcString.MaximumLength = sizeof(AnsiBuffer);
    Status = RtlUnicodeStringToAnsiString(&ArcString, &ArcName, FALSE);
    AnsiBuffer[ArcString.Length] = ANSI_NULL;
 
    /* Close the link handle and free the name */
    ObCloseHandle(LinkHandle, KernelMode);
    RtlFreeUnicodeString(&TargetName);
 
    /* Setup the system root name again */
    RtlInitAnsiString(&TempString, "\\SystemRoot");
    Status = RtlAnsiStringToUnicodeString(&LinkName, &TempString, TRUE);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Open the symbolic link for it */
    InitializeObjectAttributes(&ObjectAttributes,
                               &LinkName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = NtOpenSymbolicLinkObject(&LinkHandle,
                                      SYMBOLIC_LINK_ALL_ACCESS,
                                      &ObjectAttributes);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Destroy it */
    NtMakeTemporaryObject(LinkHandle);
    ObCloseHandle(LinkHandle, KernelMode);
 
    /* Now create the new name for it */
    sprintf(Buffer, "%s%s", ArcString.Buffer, LoaderBlock->NtBootPathName);
 
    /* Copy it into the passed parameter and null-terminate it */
    RtlCopyString(NtBootPath, &ArcString);
    Buffer[strlen(Buffer) - 1] = ANSI_NULL;
 
    /* Setup the Unicode-name for the new symbolic link value */
    RtlInitAnsiString(&TargetString, Buffer);
    InitializeObjectAttributes(&ObjectAttributes,
                               &LinkName,
                               OBJ_CASE_INSENSITIVE | OBJ_PERMANENT,
                               NULL,
                               NULL);
    Status = RtlAnsiStringToUnicodeString(&ArcName, &TargetString, TRUE);
    if (!NT_SUCCESS(Status)) return FALSE;
 
    /* Create it */
    Status = NtCreateSymbolicLinkObject(&LinkHandle,
                                        SYMBOLIC_LINK_ALL_ACCESS,
                                        &ObjectAttributes,
                                        &ArcName);
 
    /* Free all the strings and close the handle and return success */
    RtlFreeUnicodeString(&ArcName);
    RtlFreeUnicodeString(&LinkName);
    ObCloseHandle(LinkHandle, KernelMode);
    return TRUE;
}

Referenced by IoInitSystem().

◆ IopReferenceDeviceObject()

NTSTATUS NTAPI IopReferenceDeviceObject ( IN PDEVICE_OBJECT DeviceObject )

◆ IopReinitializeBootDrivers()

VOID NTAPI IopReinitializeBootDrivers ( VOID )

Definition at line 1532 of file driver.c.

{
    PDRIVER_REINIT_ITEM ReinitItem;
    PLIST_ENTRY Entry;
 
    /* Get the first entry and start looping */
    Entry = ExInterlockedRemoveHeadList(&DriverBootReinitListHead,
                                        &DriverBootReinitListLock);
    while (Entry)
    {
        /* Get the item */
        ReinitItem = CONTAINING_RECORD(Entry, DRIVER_REINIT_ITEM, ItemEntry);
 
        /* Increment reinitialization counter */
        ReinitItem->DriverObject->DriverExtension->Count++;
 
        /* Remove the device object flag */
        ReinitItem->DriverObject->Flags &= ~DRVO_BOOTREINIT_REGISTERED;
 
        /* Call the routine */
        ReinitItem->ReinitRoutine(ReinitItem->DriverObject,
                                  ReinitItem->Context,
                                  ReinitItem->DriverObject->
                                  DriverExtension->Count);
 
        /* Free the entry */
        ExFreePool(Entry);
 
        /* Move to the next one */
        Entry = ExInterlockedRemoveHeadList(&DriverBootReinitListHead,
                                            &DriverBootReinitListLock);
    }
 
    /* Wait for all device actions being finished*/
    KeWaitForSingleObject(&PiEnumerationFinished, Executive, KernelMode, FALSE, NULL);
}

Referenced by IoInitSystem().

◆ IopReinitializeDrivers()

VOID NTAPI IopReinitializeDrivers ( VOID )

Definition at line 1496 of file driver.c.

{
    PDRIVER_REINIT_ITEM ReinitItem;
    PLIST_ENTRY Entry;
 
    /* Get the first entry and start looping */
    Entry = ExInterlockedRemoveHeadList(&DriverReinitListHead,
                                        &DriverReinitListLock);
    while (Entry)
    {
        /* Get the item */
        ReinitItem = CONTAINING_RECORD(Entry, DRIVER_REINIT_ITEM, ItemEntry);
 
        /* Increment reinitialization counter */
        ReinitItem->DriverObject->DriverExtension->Count++;
 
        /* Remove the device object flag */
        ReinitItem->DriverObject->Flags &= ~DRVO_REINIT_REGISTERED;
 
        /* Call the routine */
        ReinitItem->ReinitRoutine(ReinitItem->DriverObject,
                                  ReinitItem->Context,
                                  ReinitItem->DriverObject->
                                  DriverExtension->Count);
 
        /* Free the entry */
        ExFreePool(Entry);
 
        /* Move to the next one */
        Entry = ExInterlockedRemoveHeadList(&DriverReinitListHead,
                                            &DriverReinitListLock);
    }
}

Referenced by IoInitSystem(), and IopInitializeDriverModule().

◆ IopRemoveTimerFromTimerList()

VOID NTAPI IopRemoveTimerFromTimerList ( IN PIO_TIMER Timer )

Definition at line 70 of file iotimer.c.

{
    KIRQL OldIrql;
 
    /* Lock Timers */
    KeAcquireSpinLock(&IopTimerLock, &OldIrql);
 
    /* Remove Timer from the List and Drop the Timer Count if Enabled */
    RemoveEntryList(&Timer->IoTimerList);
    if (Timer->TimerEnabled) IopTimerCount--;
 
    /* Unlock the Timers */
    KeReleaseSpinLock(&IopTimerLock, OldIrql);
}

Referenced by IoDeleteDevice().

◆ IopSaveBootLogToFile()

VOID IopSaveBootLogToFile ( VOID )

Definition at line 288 of file bootlog.c.

{
    PKEY_VALUE_PARTIAL_INFORMATION KeyInfo;
    WCHAR ValueNameBuffer[8];
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING KeyName;
    UNICODE_STRING ValueName;
    HANDLE KeyHandle;
    ULONG BufferSize;
    ULONG ResultLength;
    ULONG i;
    NTSTATUS Status;
 
    if (IopBootLogCreate == FALSE)
        return;
 
    DPRINT("IopSaveBootLogToFile() called\n");
 
    ExAcquireResourceExclusiveLite(&IopBootLogResource, TRUE);
 
    Status = IopCreateLogFile();
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopCreateLogFile() failed (Status %lx)\n", Status);
        ExReleaseResourceLite(&IopBootLogResource);
        return;
    }
 
    //Status = IopWriteLogFile(L"ReactOS "KERNEL_VERSION_STR);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopWriteLogFile() failed (Status %lx)\n", Status);
        ExReleaseResourceLite(&IopBootLogResource);
        return;
    }
 
    Status = IopWriteLogFile(NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopWriteLogFile() failed (Status %lx)\n", Status);
        ExReleaseResourceLite(&IopBootLogResource);
        return;
    }
 
 
    BufferSize = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 256 * sizeof(WCHAR);
    KeyInfo = ExAllocatePool(PagedPool,
                             BufferSize);
    if (KeyInfo == NULL)
    {
        ExReleaseResourceLite(&IopBootLogResource);
        return;
    }
 
    RtlInitUnicodeString(&KeyName,
                         L"\\Registry\\Machine\\System\\CurrentControlSet\\BootLog");
    InitializeObjectAttributes(&ObjectAttributes,
                               &KeyName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = ZwOpenKey(&KeyHandle,
                       KEY_ALL_ACCESS,
                       &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        ExFreePool(KeyInfo);
        ExReleaseResourceLite(&IopBootLogResource);
        return;
    }
 
    for (i = 0; ; i++)
    {
        swprintf(ValueNameBuffer,
                 L"%lu", i);
 
        RtlInitUnicodeString(&ValueName,
                             ValueNameBuffer);
 
        Status = ZwQueryValueKey(KeyHandle,
                                 &ValueName,
                                 KeyValuePartialInformation,
                                 KeyInfo,
                                 BufferSize,
                                 &ResultLength);
        if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
        {
            break;
        }
 
        if (!NT_SUCCESS(Status))
        {
            ZwClose(KeyHandle);
            ExFreePool(KeyInfo);
            ExReleaseResourceLite(&IopBootLogResource);
            return;
        }
 
        Status = IopWriteLogFile((PWSTR)&KeyInfo->Data);
        if (!NT_SUCCESS(Status))
        {
            ZwClose(KeyHandle);
            ExFreePool(KeyInfo);
            ExReleaseResourceLite(&IopBootLogResource);
            return;
        }
 
        /* Delete keys */
        ZwDeleteValueKey(KeyHandle,
                         &ValueName);
    }
 
    ZwClose(KeyHandle);
 
    ExFreePool(KeyInfo);
 
    IopLogFileEnabled = TRUE;
    ExReleaseResourceLite(&IopBootLogResource);
 
    DPRINT("IopSaveBootLogToFile() done\n");
}

◆ IopShutdownBaseFileSystems()

VOID NTAPI IopShutdownBaseFileSystems ( IN PLIST_ENTRY ListHead )

Definition at line 349 of file volume.c.

{
    PLIST_ENTRY ListEntry;
    PDEVICE_OBJECT DeviceObject;
    IO_STATUS_BLOCK StatusBlock;
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    /* Get the first entry and start looping */
    ListEntry = ListHead->Flink;
    while (ListEntry != ListHead)
    {
        /* Get the device object */
        DeviceObject = CONTAINING_RECORD(ListEntry,
                                         DEVICE_OBJECT,
                                         Queue.ListEntry);
 
        /* Go to the next entry */
        ListEntry = ListEntry->Flink;
 
        /* Get the attached device */
        DeviceObject = IoGetAttachedDevice(DeviceObject);
 
        ObReferenceObject(DeviceObject);
        IopInterlockedIncrementUlong(LockQueueIoDatabaseLock, (PULONG)&DeviceObject->ReferenceCount);
 
        /* Build the shutdown IRP and call the driver */
        Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SHUTDOWN,
                                           DeviceObject,
                                           NULL,
                                           0,
                                           NULL,
                                           &Event,
                                           &StatusBlock);
        if (Irp)
        {
            Status = IoCallDriver(DeviceObject, Irp);
            if (Status == STATUS_PENDING)
            {
                /* Wait on the driver */
                KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
            }
        }
 
        /* Reset the event */
        KeClearEvent(&Event);
 
        IopDecrementDeviceObjectRef(DeviceObject, FALSE);
        ObDereferenceObject(DeviceObject);
    }
}

Referenced by IoShutdownSystem().

◆ IopStartBootLog()

VOID IopStartBootLog ( VOID )

Definition at line 38 of file bootlog.c.

{
    IopBootLogCreate = TRUE;
    IopBootLogEnabled = TRUE;
}

Referenced by IopInitBootLog().

◆ IopStartRamdisk()

NTSTATUS NTAPI IopStartRamdisk ( IN PLOADER_PARAMETER_BLOCK LoaderBlock )

Definition at line 26 of file ramdisk.c.

{
    PMEMORY_ALLOCATION_DESCRIPTOR MemoryDescriptor;
    NTSTATUS Status;
    PCHAR CommandLine, Offset, OffsetValue, Length, LengthValue;
    HANDLE DriverHandle;
    RAMDISK_CREATE_INPUT RamdiskCreate;
    IO_STATUS_BLOCK IoStatusBlock;
    UNICODE_STRING GuidString, SymbolicLinkName, ObjectName, DeviceString;
    PLIST_ENTRY ListHead, NextEntry;
    OBJECT_ATTRIBUTES ObjectAttributes;
    WCHAR SourceString[54];
 
    //
    // Scan memory descriptors
    //
    MemoryDescriptor = NULL;
    ListHead = &LoaderBlock->MemoryDescriptorListHead;
    NextEntry = ListHead->Flink;
    while (NextEntry != ListHead)
    {
        //
        // Get the descriptor
        //
        MemoryDescriptor = CONTAINING_RECORD(NextEntry,
                                             MEMORY_ALLOCATION_DESCRIPTOR,
                                             ListEntry);
 
        //
        // Needs to be a ROM/RAM descriptor
        //
        if (MemoryDescriptor->MemoryType == LoaderXIPRom) break;
 
        //
        // Keep trying
        //
        NextEntry = NextEntry->Flink;
    }
 
    //
    // Nothing found?
    //
    if (NextEntry == ListHead)
    {
        //
        // Bugcheck -- no data
        //
        KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
                     RD_NO_XIPROM_DESCRIPTOR,
                     STATUS_INVALID_PARAMETER,
                     0,
                     0);
    }
 
    //
    // Setup the input buffer
    //
    RtlZeroMemory(&RamdiskCreate, sizeof(RamdiskCreate));
    RamdiskCreate.Version = sizeof(RamdiskCreate);
    RamdiskCreate.DiskType = RAMDISK_BOOT_DISK;
    RamdiskCreate.BasePage = MemoryDescriptor->BasePage;
    RamdiskCreate.DiskOffset = 0;
    RamdiskCreate.DiskLength.QuadPart = MemoryDescriptor->PageCount << PAGE_SHIFT;
    RamdiskCreate.DiskGuid = RAMDISK_BOOTDISK_GUID;
    RamdiskCreate.DriveLetter = L'C';
    RamdiskCreate.Options.Fixed = TRUE;
 
    //
    // Check for commandline parameters
    //
    CommandLine = LoaderBlock->LoadOptions;
    if (CommandLine)
    {
        //
        // Make everything upper case
        //
        _strupr(CommandLine);
 
        //
        // Check for offset parameter
        //
        Offset = strstr(CommandLine, "RDIMAGEOFFSET");
        if (Offset)
        {
            //
            // Get to the actual value
            //
            OffsetValue = strstr(Offset, "=");
            if (OffsetValue)
            {
                //
                // Set the offset
                //
                RamdiskCreate.DiskOffset = atol(OffsetValue + 1);
            }
        }
 
        //
        // Reduce the disk length
        //
        RamdiskCreate.DiskLength.QuadPart -= RamdiskCreate.DiskOffset;
 
        //
        // Check for length parameter
        //
        Length = strstr(CommandLine, "RDIMAGELENGTH");
        if (Length)
        {
            //
            // Get to the actual value
            //
            LengthValue = strstr(Length, "=");
            if (LengthValue)
            {
                //
                // Set the offset
                //
                RamdiskCreate.DiskLength.QuadPart = _atoi64(LengthValue + 1);
            }
        }
    }
 
    //
    // Setup object attributes
    //
    RtlInitUnicodeString(&ObjectName, L"\\Device\\Ramdisk");
    InitializeObjectAttributes(&ObjectAttributes,
                               &ObjectName,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    //
    // Open a handle to the driver
    //
    Status = ZwOpenFile(&DriverHandle,
                        GENERIC_ALL | SYNCHRONIZE,
                        &ObjectAttributes,
                        &IoStatusBlock,
                        FILE_SHARE_READ | FILE_SHARE_WRITE,
                        FILE_SYNCHRONOUS_IO_NONALERT);
    if (!(NT_SUCCESS(Status)) || !(NT_SUCCESS(IoStatusBlock.Status)))
    {
        //
        // Bugcheck -- no driver
        //
        KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
                     RD_NO_RAMDISK_DRIVER,
                     IoStatusBlock.Status,
                     0,
                     0);
    }
 
    //
    // Send create command
    //
    Status = ZwDeviceIoControlFile(DriverHandle,
                                   NULL,
                                   NULL,
                                   NULL,
                                   &IoStatusBlock,
                                   FSCTL_CREATE_RAM_DISK,
                                   &RamdiskCreate,
                                   sizeof(RamdiskCreate),
                                   NULL,
                                   0);
    ZwClose(DriverHandle);
    if (!(NT_SUCCESS(Status)) || !(NT_SUCCESS(IoStatusBlock.Status)))
    {
        //
        // Bugcheck -- driver failed
        //
        KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
                     RD_FSCTL_FAILED,
                     IoStatusBlock.Status,
                     0,
                     0);
    }
 
    //
    // Convert the GUID
    //
    Status = RtlStringFromGUID(&RamdiskCreate.DiskGuid, &GuidString);
    if (!NT_SUCCESS(Status))
    {
        //
        // Bugcheck -- GUID convert failed
        //
        KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
                     RD_GUID_CONVERT_FAILED,
                     Status,
                     0,
                     0);
    }
 
    //
    // Build the symbolic link name and target
    //
    _snwprintf(SourceString,
               sizeof(SourceString)/sizeof(WCHAR),
               L"\\Device\\Ramdisk%wZ",
               &GuidString);
    SymbolicLinkName.Length = 38;
    SymbolicLinkName.MaximumLength = 38 + sizeof(UNICODE_NULL);
    SymbolicLinkName.Buffer = L"\\ArcName\\ramdisk(0)";
 
    //
    // Create the symbolic link
    //
    RtlInitUnicodeString(&DeviceString, SourceString);
    Status = IoCreateSymbolicLink(&SymbolicLinkName, &DeviceString);
    RtlFreeUnicodeString(&GuidString);
    if (!NT_SUCCESS(Status))
    {
        //
        // Bugcheck -- symlink create failed
        //
        KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
                     RD_SYMLINK_CREATE_FAILED,
                     Status,
                     0,
                     0);
    }
 
    //
    // ReactOS hack (drive letter should not be hardcoded, and maybe set by mountmgr.sys)
    //
    {
        ANSI_STRING AnsiPath;
        CHAR Buffer[256];
        UNICODE_STRING NtSystemRoot;
        UNICODE_STRING DriveLetter = RTL_CONSTANT_STRING(L"\\??\\X:");
 
        AnsiPath.Length = sprintf(Buffer, "X:%s", LoaderBlock->NtBootPathName);
        AnsiPath.MaximumLength = AnsiPath.Length + 1;
        AnsiPath.Buffer = Buffer;
        RtlInitEmptyUnicodeString(&NtSystemRoot,
                                  SharedUserData->NtSystemRoot,
                                  sizeof(SharedUserData->NtSystemRoot));
        Status = RtlAnsiStringToUnicodeString(&NtSystemRoot, &AnsiPath, FALSE);
        if (!NT_SUCCESS(Status))
        {
            KeBugCheckEx(RAMDISK_BOOT_INITIALIZATION_FAILED,
                         RD_SYSROOT_INIT_FAILED,
                         Status,
                         0,
                         0);
        }
        IoCreateSymbolicLink(&DriveLetter, &DeviceString);
    }
 
    //
    // Wait for ramdisk relations being initialized
    //
 
    KeWaitForSingleObject(&PiEnumerationFinished, Executive, KernelMode, FALSE, NULL);
 
    //
    // We made it
    //
    return STATUS_SUCCESS;
}

Referenced by IoInitSystem().

◆ IopStopBootLog()

VOID IopStopBootLog ( VOID )

Definition at line 46 of file bootlog.c.

{
    IopBootLogEnabled = FALSE;
}

◆ IopStoreSystemPartitionInformation()

VOID IopStoreSystemPartitionInformation	(	_In_ PUNICODE_STRING	NtSystemPartitionDeviceName,
		_In_ PUNICODE_STRING	OsLoaderPathName
	)

Definition at line 860 of file iorsrce.c.

{
    NTSTATUS Status;
    UNICODE_STRING LinkTarget, KeyName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE LinkHandle, RegistryHandle, KeyHandle;
    WCHAR LinkTargetBuffer[256];
    UNICODE_STRING CmRegistryMachineSystemName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM");
 
    ASSERT(NtSystemPartitionDeviceName->MaximumLength >= NtSystemPartitionDeviceName->Length + sizeof(WCHAR));
    ASSERT(NtSystemPartitionDeviceName->Buffer[NtSystemPartitionDeviceName->Length / sizeof(WCHAR)] == UNICODE_NULL);
    ASSERT(OsLoaderPathName->MaximumLength >= OsLoaderPathName->Length + sizeof(WCHAR));
    ASSERT(OsLoaderPathName->Buffer[OsLoaderPathName->Length / sizeof(WCHAR)] == UNICODE_NULL);
 
    /* First define needed stuff to open NtSystemPartitionDeviceName symbolic link */
    InitializeObjectAttributes(&ObjectAttributes,
                               NtSystemPartitionDeviceName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    /* Open NtSystemPartitionDeviceName symbolic link */
    Status = ZwOpenSymbolicLinkObject(&LinkHandle,
                                      SYMBOLIC_LINK_QUERY,
                                      &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed to open symlink %wZ, Status=%lx\n", NtSystemPartitionDeviceName, Status);
        return;
    }
 
    /* Prepare the string that will receive where symbolic link points to.
     * We will zero the end of the string after having received it */
    RtlInitEmptyUnicodeString(&LinkTarget, LinkTargetBuffer,
                              sizeof(LinkTargetBuffer) - sizeof(UNICODE_NULL));
 
    /* Query target */
    Status = ZwQuerySymbolicLinkObject(LinkHandle, &LinkTarget, NULL);
 
    /* We are done with symbolic link */
    ObCloseHandle(LinkHandle, KernelMode);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed querying symlink %wZ, Status=%lx\n", NtSystemPartitionDeviceName, Status);
        return;
    }
 
    /* As promised, we zero the end */
    LinkTarget.Buffer[LinkTarget.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    /* Open registry to save data (HKLM\SYSTEM) */
    Status = IopOpenRegistryKeyEx(&RegistryHandle,
                                  NULL,
                                  &CmRegistryMachineSystemName,
                                  KEY_ALL_ACCESS);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed to open HKLM\\SYSTEM, Status=%lx\n", Status);
        return;
    }
 
    /* Open or create the Setup subkey where we'll store in */
    RtlInitUnicodeString(&KeyName, L"Setup");
 
    Status = IopCreateRegistryKeyEx(&KeyHandle,
                                    RegistryHandle,
                                    &KeyName,
                                    KEY_ALL_ACCESS,
                                    REG_OPTION_NON_VOLATILE,
                                    NULL);
 
    /* We're done with HKLM\SYSTEM */
    ObCloseHandle(RegistryHandle, KernelMode);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed opening/creating Setup key, Status=%lx\n", Status);
        return;
    }
 
    /* Prepare first data writing */
    RtlInitUnicodeString(&KeyName, L"SystemPartition");
 
    /* Write SystemPartition value which is the target of the symbolic link */
    Status = ZwSetValueKey(KeyHandle,
                           &KeyName,
                           0,
                           REG_SZ,
                           LinkTarget.Buffer,
                           LinkTarget.Length + sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed writing SystemPartition value, Status=%lx\n", Status);
    }
 
    /* Prepare for second data writing */
    RtlInitUnicodeString(&KeyName, L"OsLoaderPath");
 
    /* Remove trailing slash if any (one slash only excepted) */
    if (OsLoaderPathName->Length > sizeof(WCHAR) &&
        OsLoaderPathName->Buffer[(OsLoaderPathName->Length / sizeof(WCHAR)) - 1] == OBJ_NAME_PATH_SEPARATOR)
    {
        OsLoaderPathName->Length -= sizeof(WCHAR);
        OsLoaderPathName->Buffer[OsLoaderPathName->Length / sizeof(WCHAR)] = UNICODE_NULL;
    }
 
    /* Then, write down data */
    Status = ZwSetValueKey(KeyHandle,
                           &KeyName,
                           0,
                           REG_SZ,
                           OsLoaderPathName->Buffer,
                           OsLoaderPathName->Length + sizeof(UNICODE_NULL));
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed writing OsLoaderPath value, Status=%lx\n", Status);
    }
 
    /* We're finally done! */
    ObCloseHandle(KeyHandle, KernelMode);
}

Referenced by IopCreateArcNames(), and IopCreateArcNamesDisk().

◆ IopSynchronousCall()

NTSTATUS IopSynchronousCall	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIO_STACK_LOCATION	IoStackLocation,
		OUT PVOID *	Information
	)

Referenced by IopGetRelatedTargetDevice(), IopInitiatePnpIrp(), IopSendEject(), and PiIrpSendRemoveCheckVpb().

◆ IopTraverseDeviceTree()

NTSTATUS IopTraverseDeviceTree ( PDEVICETREE_TRAVERSE_CONTEXT Context )

Referenced by IopGetDeviceObjectFromDeviceInstance(), and PopSetSystemPowerState().

◆ IopUnloadDevice()

VOID NTAPI IopUnloadDevice ( IN PDEVICE_OBJECT DeviceObject )

Definition at line 390 of file device.c.

{
    PDRIVER_OBJECT DriverObject = DeviceObject->DriverObject;
    PEXTENDED_DEVOBJ_EXTENSION ThisExtension = IoGetDevObjExtension(DeviceObject);
 
    /* Check if deletion is pending */
    if (ThisExtension->ExtensionFlags & DOE_DELETE_PENDING)
    {
        if (DeviceObject->AttachedDevice)
        {
            DPRINT("Device object is in the middle of a device stack\n");
            return;
        }
 
        if (DeviceObject->ReferenceCount)
        {
            DPRINT("Device object still has %d references\n", DeviceObject->ReferenceCount);
            return;
        }
 
        /* Check if we have a Security Descriptor */
        if (DeviceObject->SecurityDescriptor)
        {
            /* Dereference it */
            ObDereferenceSecurityDescriptor(DeviceObject->SecurityDescriptor, 1);
        }
 
        /* Remove the device from the list */
        IopEditDeviceList(DeviceObject->DriverObject, DeviceObject, IopRemove);
 
        /* Dereference the keep-alive */
        ObDereferenceObject(DeviceObject);
    }
 
    /* We can't unload a non-PnP driver here */
    if (DriverObject->Flags & DRVO_LEGACY_DRIVER)
    {
        DPRINT("Not a PnP driver! '%wZ' will not be unloaded!\n", &DriverObject->DriverName);
        return;
    }
 
    /* Return if we've already called unload (maybe we're in it?) */
    if (DriverObject->Flags & DRVO_UNLOAD_INVOKED) return;
 
    /* We can't unload unless there's an unload handler */
    if (!DriverObject->DriverUnload)
    {
        DPRINT1("No DriverUnload function on PnP driver! '%wZ' will not be unloaded!\n", &DriverObject->DriverName);
        return;
    }
 
    /* Bail if there are still devices present */
    if (DriverObject->DeviceObject)
    {
        DPRINT("Devices still present! '%wZ' will not be unloaded!\n", &DriverObject->DriverName);
        return;
    }
 
    DPRINT1("Unloading driver '%wZ' (automatic)\n", &DriverObject->DriverName);
 
    /* Set the unload invoked flag */
    DriverObject->Flags |= DRVO_UNLOAD_INVOKED;
 
    /* Unload it */
    DriverObject->DriverUnload(DriverObject);
 
    /* Make object temporary so it can be deleted */
    ObMakeTemporaryObject(DriverObject);
}

Referenced by IoDeleteDevice(), IoDetachDevice(), IopDecrementDeviceObjectRef(), and IopDereferenceDeviceObject().

◆ IopUpdateRootKey()

NTSTATUS NTAPI IopUpdateRootKey ( VOID )

Definition at line 670 of file pnpmap.c.

{
    UNICODE_STRING EnumU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Enum");
    UNICODE_STRING RootPathU = RTL_CONSTANT_STRING(L"Root");
    UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE hEnum, hRoot;
    NTSTATUS Status;
 
    InitializeObjectAttributes(&ObjectAttributes, &EnumU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
    Status = ZwCreateKey(&hEnum, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwCreateKey() failed with status 0x%08lx\n", Status);
        return Status;
    }
 
    InitializeObjectAttributes(&ObjectAttributes, &RootPathU, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, hEnum, NULL);
    Status = ZwCreateKey(&hRoot, KEY_CREATE_SUB_KEY, &ObjectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
    ZwClose(hEnum);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ZwOpenKey() failed with status 0x%08lx\n", Status);
        return Status;
    }
 
    if (!IopIsFirmwareMapperDisabled())
    {
        Status = IopOpenRegistryKeyEx(&hEnum, NULL, &MultiKeyPathU, KEY_ENUMERATE_SUB_KEYS);
        if (!NT_SUCCESS(Status))
        {
            /* Nothing to do, don't return with an error status */
            DPRINT("ZwOpenKey() failed with status 0x%08lx\n", Status);
            ZwClose(hRoot);
            return STATUS_SUCCESS;
        }
        Status = IopEnumerateDetectedDevices(
            hEnum,
            NULL,
            hRoot,
            TRUE,
            NULL,
            0,
            NULL,
            0);
        ZwClose(hEnum);
    }
    else
    {
        /* Enumeration is disabled */
        Status = STATUS_SUCCESS;
    }
 
    ZwClose(hRoot);
 
    return Status;
}

Referenced by IopInitializePlugPlayServices().

◆ IopVerifyDeviceObjectOnStack()

BOOLEAN NTAPI IopVerifyDeviceObjectOnStack	(	IN PDEVICE_OBJECT	BaseDeviceObject,
		IN PDEVICE_OBJECT	TopDeviceObjectHint
	)

Definition at line 695 of file device.c.

{
    KIRQL OldIrql;
    BOOLEAN Result;
    PDEVICE_OBJECT LoopObject;
 
    ASSERT(BaseDeviceObject != NULL);
 
    Result = FALSE;
    /* Simply loop on the device stack and try to find our hint */
    OldIrql = KeAcquireQueuedSpinLock(LockQueueIoDatabaseLock);
    for (LoopObject = BaseDeviceObject; ; LoopObject = LoopObject->AttachedDevice)
    {
        /* It was found, it's a success */
        if (LoopObject == TopDeviceObjectHint)
        {
            Result = TRUE;
            break;
        }
 
        /* End of the stack, that's a failure - default */
        if (LoopObject == NULL)
        {
            break;
        }
    }
    KeReleaseQueuedSpinLock(LockQueueIoDatabaseLock, OldIrql);
 
    return Result;
}

Referenced by IoGetRelatedDeviceObject(), and IopCheckTopDeviceHint().

◆ IopVerifyDiskSignature()

BOOLEAN IopVerifyDiskSignature	(	_In_ PDRIVE_LAYOUT_INFORMATION_EX	DriveLayout,
		_In_ PARC_DISK_SIGNATURE	ArcDiskSignature,
		_Out_ PULONG	Signature
	)

Definition at line 949 of file arcname.c.

{
    /* Fail if the partition table is invalid */
    if (!ArcDiskSignature->ValidPartitionTable)
        return FALSE;
 
    /* If the partition style is MBR */
    if (DriveLayout->PartitionStyle == PARTITION_STYLE_MBR)
    {
        /* Check the MBR signature */
        if (DriveLayout->Mbr.Signature == ArcDiskSignature->Signature)
        {
            /* And return it */
            if (Signature)
                *Signature = DriveLayout->Mbr.Signature;
            return TRUE;
        }
    }
    /* If the partition style is GPT */
    else if (DriveLayout->PartitionStyle == PARTITION_STYLE_GPT)
    {
        /* Verify whether the signature is GPT and compare the GUID */
        if (ArcDiskSignature->IsGpt &&
            IsEqualGUID((PGUID)&ArcDiskSignature->GptSignature, &DriveLayout->Gpt.DiskId))
        {
            /* There is no signature to return, just zero it */
            if (Signature)
                *Signature = 0;
            return TRUE;
        }
    }
 
    /* If we get there, something went wrong, so fail */
    return FALSE;
}

Referenced by IoGetBootDiskInformation(), and IopCreateArcNamesDisk().

◆ IoSetIoCompletion()

NTSTATUS NTAPI IoSetIoCompletion	(	IN PVOID	IoCompletion,
		IN PVOID	KeyContext,
		IN PVOID	ApcContext,
		IN NTSTATUS	IoStatus,
		IN ULONG_PTR	IoStatusInformation,
		IN BOOLEAN	Quota
	)

Definition at line 147 of file iocomp.c.

{
    PKQUEUE Queue = (PKQUEUE)IoCompletion;
    PNPAGED_LOOKASIDE_LIST List;
    PKPRCB Prcb = KeGetCurrentPrcb();
    PIOP_MINI_COMPLETION_PACKET Packet;
 
    /* Get the P List */
    List = (PNPAGED_LOOKASIDE_LIST)Prcb->
            PPLookasideList[LookasideCompletionList].P;
 
    /* Try to allocate the Packet */
    List->L.TotalAllocates++;
    Packet = (PVOID)InterlockedPopEntrySList(&List->L.ListHead);
 
    /* Check if that failed, use the L list if it did */
    if (!Packet)
    {
        /* Let the balancer know */
        List->L.AllocateMisses++;
 
        /* Get L List */
        List = (PNPAGED_LOOKASIDE_LIST)Prcb->
                PPLookasideList[LookasideCompletionList].L;
 
        /* Try to allocate the Packet */
        List->L.TotalAllocates++;
        Packet = (PVOID)InterlockedPopEntrySList(&List->L.ListHead);
    }
 
    /* Still failed, use pool */
    if (!Packet)
    {
        /* Let the balancer know */
        List->L.AllocateMisses++;
 
        /* Allocate from Nonpaged Pool */
        Packet = ExAllocatePoolWithTag(NonPagedPool, sizeof(*Packet), IOC_TAG);
    }
 
    /* Make sure we have one by now... */
    if (Packet)
    {
        /* Set up the Packet */
        Packet->PacketType = IopCompletionPacketMini;
        Packet->KeyContext = KeyContext;
        Packet->ApcContext = ApcContext;
        Packet->IoStatus = IoStatus;
        Packet->IoStatusInformation = IoStatusInformation;
 
        /* Insert the Queue */
        KeInsertQueue(Queue, &Packet->ListEntry);
    }
    else
    {
        /* Out of memory, fail */
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Return Success */
    return STATUS_SUCCESS;
}

Referenced by IopDeviceFsIoControl(), NtLockFile(), and NtSetIoCompletion().

◆ IoShutdownSystem()

VOID NTAPI IoShutdownSystem ( IN ULONG Phase )

Definition at line 133 of file device.c.

{
    PLIST_ENTRY ListEntry;
    PDEVICE_OBJECT DeviceObject;
    PSHUTDOWN_ENTRY ShutdownEntry;
    IO_STATUS_BLOCK StatusBlock;
    PIRP Irp;
    KEVENT Event;
    NTSTATUS Status;
 
    /* Initialize an event to wait on */
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    /* What phase? */
    if (Phase == 0)
    {
        /* Shutdown PnP */
        IoShutdownPnpDevices();
 
        /* Loop first-chance shutdown notifications */
        ListEntry = ExInterlockedRemoveHeadList(&ShutdownListHead,
                                                &ShutdownListLock);
        while (ListEntry)
        {
            /* Get the shutdown entry */
            ShutdownEntry = CONTAINING_RECORD(ListEntry,
                                              SHUTDOWN_ENTRY,
                                              ShutdownList);
 
            /* Get the attached device */
            DeviceObject = IoGetAttachedDevice(ShutdownEntry->DeviceObject);
 
            /* Build the shutdown IRP and call the driver */
            Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SHUTDOWN,
                                               DeviceObject,
                                               NULL,
                                               0,
                                               NULL,
                                               &Event,
                                               &StatusBlock);
            if (Irp)
            {
                Status = IoCallDriver(DeviceObject, Irp);
                if (Status == STATUS_PENDING)
                {
                    /* Wait on the driver */
                    KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
                }
            }
 
            /* Remove the flag */
            ShutdownEntry->DeviceObject->Flags &= ~DO_SHUTDOWN_REGISTERED;
 
            /* Get rid of our reference to it */
            ObDereferenceObject(ShutdownEntry->DeviceObject);
 
            /* Free the shutdown entry and reset the event */
            ExFreePoolWithTag(ShutdownEntry, TAG_SHUTDOWN_ENTRY);
            KeClearEvent(&Event);
 
            /* Go to the next entry */
            ListEntry = ExInterlockedRemoveHeadList(&ShutdownListHead,
                                                    &ShutdownListLock);
         }
    }
    else if (Phase == 1)
    {
        /* Acquire resource forever */
        ExAcquireResourceExclusiveLite(&IopDatabaseResource, TRUE);
 
        /* Shutdown disk file systems */
        IopShutdownBaseFileSystems(&IopDiskFileSystemQueueHead);
 
        /* Shutdown cdrom file systems */
        IopShutdownBaseFileSystems(&IopCdRomFileSystemQueueHead);
 
        /* Shutdown tape filesystems */
        IopShutdownBaseFileSystems(&IopTapeFileSystemQueueHead);
 
        /* Loop last-chance shutdown notifications */
        ListEntry = ExInterlockedRemoveHeadList(&LastChanceShutdownListHead,
                                                &ShutdownListLock);
        while (ListEntry)
        {
            /* Get the shutdown entry */
            ShutdownEntry = CONTAINING_RECORD(ListEntry,
                                              SHUTDOWN_ENTRY,
                                              ShutdownList);
 
            /* Get the attached device */
            DeviceObject = IoGetAttachedDevice(ShutdownEntry->DeviceObject);
 
            /* Build the shutdown IRP and call the driver */
            Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SHUTDOWN,
                                               DeviceObject,
                                               NULL,
                                               0,
                                               NULL,
                                               &Event,
                                               &StatusBlock);
            if (Irp)
            {
                Status = IoCallDriver(DeviceObject, Irp);
                if (Status == STATUS_PENDING)
                {
                    /* Wait on the driver */
                    KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
                }
            }
 
            /* Remove the flag */
            ShutdownEntry->DeviceObject->Flags &= ~DO_SHUTDOWN_REGISTERED;
 
            /* Get rid of our reference to it */
            ObDereferenceObject(ShutdownEntry->DeviceObject);
 
            /* Free the shutdown entry and reset the event */
            ExFreePoolWithTag(ShutdownEntry, TAG_SHUTDOWN_ENTRY);
            KeClearEvent(&Event);
 
            /* Go to the next entry */
            ListEntry = ExInterlockedRemoveHeadList(&LastChanceShutdownListHead,
                                                    &ShutdownListLock);
         }
 
    }
}

Referenced by PopGracefulShutdown().

◆ PiClearDevNodeProblem()

VOID PiClearDevNodeProblem ( _In_ PDEVICE_NODE DeviceNode )

Definition at line 141 of file devnode.c.

{
    DeviceNode->Flags &= ~DNF_HAS_PROBLEM;
    DeviceNode->Problem = 0;
}

◆ PiInitCacheGroupInformation()

NTSTATUS NTAPI PiInitCacheGroupInformation ( VOID )

Definition at line 94 of file pnpinit.c.

{
    HANDLE KeyHandle;
    NTSTATUS Status;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
    PUNICODE_STRING GroupTable;
    ULONG Count;
    UNICODE_STRING GroupString =
        RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet"
                            L"\\Control\\ServiceGroupOrder");
 
    /* Open the registry key */
    Status = IopOpenRegistryKeyEx(&KeyHandle,
                                  NULL,
                                  &GroupString,
                                  KEY_READ);
    if (NT_SUCCESS(Status))
    {
        /* Get the list */
        Status = IopGetRegistryValue(KeyHandle, L"List", &KeyValueInformation);
        ZwClose(KeyHandle);
 
        /* Make sure we got it */
        if (NT_SUCCESS(Status))
        {
            /* Make sure it's valid */
            if ((KeyValueInformation->Type == REG_MULTI_SZ) &&
                (KeyValueInformation->DataLength))
            {
                /* Convert it to unicode strings */
                Status = PnpRegMultiSzToUnicodeStrings(KeyValueInformation,
                                                       &GroupTable,
                                                       &Count);
 
                /* Cache it for later */
                PiInitGroupOrderTable = GroupTable;
                PiInitGroupOrderTableCount = (USHORT)Count;
            }
            else
            {
                /* Fail */
                Status = STATUS_UNSUCCESSFUL;
            }
 
            /* Free the information */
            ExFreePool(KeyValueInformation);
        }
    }
 
    /* Return status */
    return Status;
}

Referenced by IopInitializePlugPlayServices().

◆ PiInitializeNotifications()

VOID PiInitializeNotifications ( VOID )

Definition at line 55 of file pnpnotify.c.

{
    KeInitializeGuardedMutex(&PiNotifyTargetDeviceLock);
    KeInitializeGuardedMutex(&PiNotifyHwProfileLock);
    KeInitializeGuardedMutex(&PiNotifyDeviceInterfaceLock);
    InitializeListHead(&PiNotifyHwProfileListHead);
    InitializeListHead(&PiNotifyDeviceInterfaceListHead);
}

Referenced by IoInitSystem().

◆ PiInsertDevNode()

VOID PiInsertDevNode	(	_In_ PDEVICE_NODE	DeviceNode,
		_In_ PDEVICE_NODE	ParentNode
	)

Definition at line 80 of file devnode.c.

{
    KIRQL oldIrql;
 
    ASSERT(DeviceNode->Parent == NULL);
 
    KeAcquireSpinLock(&IopDeviceTreeLock, &oldIrql);
    DeviceNode->Parent = ParentNode;
    DeviceNode->Sibling = NULL;
    if (ParentNode->LastChild == NULL)
    {
        ParentNode->Child = DeviceNode;
        ParentNode->LastChild = DeviceNode;
    }
    else
    {
        ParentNode->LastChild->Sibling = DeviceNode;
        ParentNode->LastChild = DeviceNode;
    }
    KeReleaseSpinLock(&IopDeviceTreeLock, oldIrql);
    DeviceNode->Level = ParentNode->Level + 1;
 
    DPRINT("Inserted devnode 0x%p to parent 0x%p\n", DeviceNode, ParentNode);
}

Referenced by IoReportDetectedDevice(), PiControlInitializeDevice(), and PiEnumerateDevice().

◆ PiIrpCancelStopDevice()

NTSTATUS PiIrpCancelStopDevice ( _In_ PDEVICE_NODE DeviceNode )

Definition at line 154 of file pnpirp.c.

{
    PAGED_CODE();
 
    ASSERT(DeviceNode);
    ASSERT(DeviceNode->State == DeviceNodeQueryStopped);
 
    PVOID info;
    IO_STACK_LOCATION stack = {
        .MajorFunction = IRP_MJ_PNP,
        .MinorFunction = IRP_MN_CANCEL_STOP_DEVICE
    };
 
    // in fact we don't care which status is returned here
    NTSTATUS status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject, &stack, &info);
    ASSERT(NT_SUCCESS(status));
    return status;
}

Referenced by PiDevNodeStateMachine().

◆ PiIrpQueryDeviceRelations()

NTSTATUS PiIrpQueryDeviceRelations	(	_In_ PDEVICE_NODE	DeviceNode,
		_In_ DEVICE_RELATION_TYPE	Type
	)

Definition at line 176 of file pnpirp.c.

{
    PAGED_CODE();
 
    ASSERT(DeviceNode);
    ASSERT(DeviceNode->State == DeviceNodeStarted);
 
    IO_STACK_LOCATION stack = {
        .MajorFunction = IRP_MJ_PNP,
        .MinorFunction = IRP_MN_QUERY_DEVICE_RELATIONS,
        .Parameters.QueryDeviceRelations.Type = Type
    };
 
    // Vista+ does an asynchronous call
    NTSTATUS status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject,
                                         &stack,
                                         (PVOID)&DeviceNode->OverUsed1.PendingDeviceRelations);
    DeviceNode->CompletionStatus = status;
    return status;
}

Referenced by PiDevNodeStateMachine().

◆ PiIrpQueryDeviceText()

NTSTATUS PiIrpQueryDeviceText	(	_In_ PDEVICE_NODE	DeviceNode,
		_In_ LCID	LocaleId,
		_In_ DEVICE_TEXT_TYPE	Type,
		_Out_ PWSTR *	DeviceText
	)

Definition at line 253 of file pnpirp.c.

{
    PAGED_CODE();
 
    ASSERT(DeviceNode);
    ASSERT(DeviceNode->State == DeviceNodeUninitialized);
 
    ULONG_PTR longText;
    IO_STACK_LOCATION stack = {
        .MajorFunction = IRP_MJ_PNP,
        .MinorFunction = IRP_MN_QUERY_DEVICE_TEXT,
        .Parameters.QueryDeviceText.DeviceTextType = Type,
        .Parameters.QueryDeviceText.LocaleId = LocaleId
    };
 
    NTSTATUS status;
    status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject, &stack, (PVOID)&longText);
    if (NT_SUCCESS(status))
    {
        *DeviceText = (PVOID)longText;
    }
 
    return status;
}

Referenced by PiSetDevNodeText().

◆ PiIrpQueryPnPDeviceState()

NTSTATUS PiIrpQueryPnPDeviceState	(	_In_ PDEVICE_NODE	DeviceNode,
		_Out_ PPNP_DEVICE_STATE	DeviceState
	)

Definition at line 284 of file pnpirp.c.

{
    PAGED_CODE();
 
    ASSERT(DeviceNode);
    ASSERT(DeviceNode->State == DeviceNodeStartPostWork ||
           DeviceNode->State == DeviceNodeStarted);
 
    ULONG_PTR longState;
    IO_STACK_LOCATION stack = {
        .MajorFunction = IRP_MJ_PNP,
        .MinorFunction = IRP_MN_QUERY_PNP_DEVICE_STATE
    };
 
    NTSTATUS status;
    status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject, &stack, (PVOID)&longState);
    if (NT_SUCCESS(status))
    {
        *DeviceState = longState;
    }
 
    return status;
}

Referenced by PiUpdateDeviceState().

◆ PiIrpQueryResourceRequirements()

NTSTATUS PiIrpQueryResourceRequirements	(	_In_ PDEVICE_NODE	DeviceNode,
		_Out_ PIO_RESOURCE_REQUIREMENTS_LIST *	Resources
	)

Definition at line 227 of file pnpirp.c.

{
    PAGED_CODE();
 
    ASSERT(DeviceNode);
 
    ULONG_PTR longRes;
    IO_STACK_LOCATION stack = {
        .MajorFunction = IRP_MJ_PNP,
        .MinorFunction = IRP_MN_QUERY_RESOURCE_REQUIREMENTS
    };
 
    NTSTATUS status;
    status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject, &stack, (PVOID)&longRes);
    if (NT_SUCCESS(status))
    {
        *Resources = (PVOID)longRes;
    }
 
    return status;
}

Referenced by PiFakeResourceRebalance().

◆ PiIrpQueryResources()

NTSTATUS PiIrpQueryResources	(	_In_ PDEVICE_NODE	DeviceNode,
		_Out_ PCM_RESOURCE_LIST *	Resources
	)

Definition at line 201 of file pnpirp.c.

{
    PAGED_CODE();
 
    ASSERT(DeviceNode);
 
    ULONG_PTR longRes;
    IO_STACK_LOCATION stack = {
        .MajorFunction = IRP_MJ_PNP,
        .MinorFunction = IRP_MN_QUERY_RESOURCES
    };
 
    NTSTATUS status;
    status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject, &stack, (PVOID)&longRes);
    if (NT_SUCCESS(status))
    {
        *Resources = (PVOID)longRes;
    }
 
    return status;
}

Referenced by PiFakeResourceRebalance().

◆ PiIrpQueryStopDevice()

NTSTATUS PiIrpQueryStopDevice ( _In_ PDEVICE_NODE DeviceNode )

Definition at line 133 of file pnpirp.c.

{
    PAGED_CODE();
 
    ASSERT(DeviceNode);
    ASSERT(DeviceNode->State == DeviceNodeStarted);
 
    PVOID info;
    IO_STACK_LOCATION stack = {
        .MajorFunction = IRP_MJ_PNP,
        .MinorFunction = IRP_MN_QUERY_STOP_DEVICE
    };
 
    NTSTATUS status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject, &stack, &info);
    DeviceNode->CompletionStatus = status;
    return status;
}

Referenced by PiDevNodeStateMachine().

◆ PiIrpStartDevice()

NTSTATUS PiIrpStartDevice ( _In_ PDEVICE_NODE DeviceNode )

Definition at line 87 of file pnpirp.c.

{
    PAGED_CODE();
 
    ASSERT(DeviceNode);
    ASSERT(DeviceNode->State == DeviceNodeResourcesAssigned);
 
    PVOID info;
    IO_STACK_LOCATION stack = {
        .MajorFunction = IRP_MJ_PNP,
        .MinorFunction = IRP_MN_START_DEVICE,
        .Parameters.StartDevice.AllocatedResources = DeviceNode->ResourceList,
        .Parameters.StartDevice.AllocatedResourcesTranslated = DeviceNode->ResourceListTranslated
    };
 
    // Vista+ does an asynchronous call
    NTSTATUS status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject, &stack, &info);
    DeviceNode->CompletionStatus = status;
    return status;
}

Referenced by PiDevNodeStateMachine().

◆ PiIrpStopDevice()

NTSTATUS PiIrpStopDevice ( _In_ PDEVICE_NODE DeviceNode )

Definition at line 111 of file pnpirp.c.

{
    PAGED_CODE();
 
    ASSERT(DeviceNode);
    ASSERT(DeviceNode->State == DeviceNodeQueryStopped);
 
    PVOID info;
    IO_STACK_LOCATION stack = {
        .MajorFunction = IRP_MJ_PNP,
        .MinorFunction = IRP_MN_STOP_DEVICE
    };
 
    // Drivers should never fail a IRP_MN_STOP_DEVICE request
    NTSTATUS status = IopSynchronousCall(DeviceNode->PhysicalDeviceObject, &stack, &info);
    ASSERT(NT_SUCCESS(status));
    return status;
}

Referenced by PiDevNodeStateMachine().

◆ PiNotifyDeviceInterfaceChange()

VOID PiNotifyDeviceInterfaceChange	(	_In_ LPCGUID	Event,
		_In_ LPCGUID	InterfaceClassGuid,
		_In_ PUNICODE_STRING	SymbolicLinkName
	)

Delivers the event to all drivers subscribed to EventCategoryDeviceInterfaceChange.

Parameters

[in]	Event	The PnP event GUID
[in]	InterfaceClassGuid	The GUID of an interface class
[in]	SymbolicLinkName	Pointer to a string identifying the device interface name

Definition at line 161 of file pnpnotify.c.

{
    PAGED_CODE();
 
    PDEVICE_INTERFACE_CHANGE_NOTIFICATION notifyStruct;
    notifyStruct = ExAllocatePoolWithTag(PagedPool, sizeof(*notifyStruct), TAG_PNP_NOTIFY);
    if (!notifyStruct)
    {
        return;
    }
 
    *notifyStruct = (DEVICE_INTERFACE_CHANGE_NOTIFICATION) {
        .Version = 1,
        .Size = sizeof(DEVICE_INTERFACE_CHANGE_NOTIFICATION),
        .Event = *Event,
        .InterfaceClassGuid = *InterfaceClassGuid,
        .SymbolicLinkName = SymbolicLinkName
    };
 
    DPRINT("Delivering a DeviceInterfaceChange PnP event\n");
 
    KeAcquireGuardedMutex(&PiNotifyDeviceInterfaceLock);
 
    PLIST_ENTRY entry = PiNotifyDeviceInterfaceListHead.Flink;
    while (entry != &PiNotifyDeviceInterfaceListHead)
    {
        PPNP_NOTIFY_ENTRY nEntry = CONTAINING_RECORD(entry, PNP_NOTIFY_ENTRY, PnpNotifyList);
 
        if (!IsEqualGUID(&notifyStruct->InterfaceClassGuid, &nEntry->Guid))
        {
            entry = entry->Flink;
            continue;
        }
 
        PiProcessSingleNotification(nEntry, notifyStruct, &PiNotifyDeviceInterfaceLock, &entry);
    }
 
    KeReleaseGuardedMutex(&PiNotifyDeviceInterfaceLock);
    ExFreePoolWithTag(notifyStruct, TAG_PNP_NOTIFY);
}

Referenced by IoSetDeviceInterfaceState().

◆ PiNotifyHardwareProfileChange()

VOID PiNotifyHardwareProfileChange ( _In_ LPCGUID Event )

Delivers the event to all drivers subscribed to EventCategoryHardwareProfileChange PnP event.

Parameters

[in] Event The PnP event GUID

Definition at line 214 of file pnpnotify.c.

{
    PAGED_CODE();
 
    PHWPROFILE_CHANGE_NOTIFICATION notifyStruct;
    notifyStruct = ExAllocatePoolWithTag(PagedPool, sizeof(*notifyStruct), TAG_PNP_NOTIFY);
    if (!notifyStruct)
    {
        return;
    }
 
    *notifyStruct = (HWPROFILE_CHANGE_NOTIFICATION) {
        .Version = 1,
        .Size = sizeof(HWPROFILE_CHANGE_NOTIFICATION),
        .Event = *Event
    };
 
    DPRINT("Delivering a HardwareProfileChange PnP event\n");
 
    KeAcquireGuardedMutex(&PiNotifyHwProfileLock);
 
    PLIST_ENTRY entry = PiNotifyHwProfileListHead.Flink;
    while (entry != &PiNotifyHwProfileListHead)
    {
        PPNP_NOTIFY_ENTRY nEntry = CONTAINING_RECORD(entry, PNP_NOTIFY_ENTRY, PnpNotifyList);
 
        PiProcessSingleNotification(nEntry, notifyStruct, &PiNotifyHwProfileLock, &entry);
    }
 
    KeReleaseGuardedMutex(&PiNotifyHwProfileLock);
    ExFreePoolWithTag(notifyStruct, TAG_PNP_NOTIFY);
}

◆ PiNotifyTargetDeviceChange()

VOID PiNotifyTargetDeviceChange	(	_In_ LPCGUID	Event,
		_In_ PDEVICE_OBJECT	DeviceObject,
		_In_opt_ PTARGET_DEVICE_CUSTOM_NOTIFICATION	CustomNotification
	)

Delivers the event to all drivers subscribed to EventCategoryTargetDeviceChange PnP event.

Parameters

[in]	Event	The PnP event GUID
[in]	DeviceObject	The (target) device object
[in]	CustomNotification	Pointer to a custom notification for GUID_PNP_CUSTOM_NOTIFICATION

Definition at line 258 of file pnpnotify.c.

{
    PAGED_CODE();
 
    PVOID notificationStruct;
    // just in case our device is removed during the operation
    ObReferenceObject(DeviceObject);
 
    PDEVICE_NODE deviceNode = IopGetDeviceNode(DeviceObject);
    ASSERT(deviceNode);
 
    if (!IsEqualGUID(Event, &GUID_PNP_CUSTOM_NOTIFICATION))
    {
        PTARGET_DEVICE_REMOVAL_NOTIFICATION notifStruct;
        notifStruct = ExAllocatePoolWithTag(PagedPool, sizeof(*notifStruct), TAG_PNP_NOTIFY);
        if (!notifStruct)
        {
            return;
        }
 
        *notifStruct = (TARGET_DEVICE_REMOVAL_NOTIFICATION) {
            .Version = 1,
            .Size = sizeof(TARGET_DEVICE_REMOVAL_NOTIFICATION),
            .Event = *Event
        };
 
        notificationStruct = notifStruct;
 
        DPRINT("Delivering a (non-custom) TargetDeviceChange PnP event\n");
    }
    else
    {
        ASSERT(CustomNotification);
        // assuming everythng else is correct
 
        notificationStruct = CustomNotification;
 
        DPRINT("Delivering a (custom) TargetDeviceChange PnP event\n");
    }
 
    KeAcquireGuardedMutex(&PiNotifyTargetDeviceLock);
 
    PLIST_ENTRY entry = deviceNode->TargetDeviceNotify.Flink;
    while (entry != &deviceNode->TargetDeviceNotify)
    {
        PPNP_NOTIFY_ENTRY nEntry = CONTAINING_RECORD(entry, PNP_NOTIFY_ENTRY, PnpNotifyList);
 
        // put the file object from our saved entry to this particular notification's struct
        ((PTARGET_DEVICE_REMOVAL_NOTIFICATION)notificationStruct)->FileObject = nEntry->FileObject;
        // so you don't need to look at the definition ;)
        C_ASSERT(FIELD_OFFSET(TARGET_DEVICE_REMOVAL_NOTIFICATION, FileObject)
                 == FIELD_OFFSET(TARGET_DEVICE_CUSTOM_NOTIFICATION, FileObject));
 
        PiProcessSingleNotification(nEntry, notificationStruct, &PiNotifyTargetDeviceLock, &entry);
    }
 
    KeReleaseGuardedMutex(&PiNotifyTargetDeviceLock);
    if (notificationStruct != CustomNotification)
        ExFreePoolWithTag(notificationStruct, TAG_PNP_NOTIFY);
    ObDereferenceObject(DeviceObject);
}

Referenced by IopCancelRemoveDevice(), IopQueryRemoveDevice(), IopSendRemoveDevice(), and PpSetCustomTargetEvent().

◆ PipAllocateDeviceNode()

PDEVICE_NODE PipAllocateDeviceNode ( IN PDEVICE_OBJECT PhysicalDeviceObject )

Referenced by IopInitializePlugPlayServices(), IoReportDetectedDevice(), PiControlInitializeDevice(), and PiEnumerateDevice().

◆ PipCallDriverAddDevice()

NTSTATUS NTAPI PipCallDriverAddDevice	(	IN PDEVICE_NODE	DeviceNode,
		IN BOOLEAN	LoadDriver,
		IN PDRIVER_OBJECT	DriverObject
	)

◆ PiPerformSyncDeviceAction()

NTSTATUS PiPerformSyncDeviceAction	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ DEVICE_ACTION	Action
	)

Perfom a device operation synchronously via PiQueueDeviceAction.

Parameters

[in]	DeviceObject	The device object
[in]	Action	The action

Returns: Status of the operation

Definition at line 2718 of file devaction.c.

{
    KEVENT opFinished;
    NTSTATUS status;
 
    KeInitializeEvent(&opFinished, SynchronizationEvent, FALSE);
    PiQueueDeviceAction(DeviceObject, Action, &opFinished, &status);
    KeWaitForSingleObject(&opFinished, Executive, KernelMode, FALSE, NULL);
 
    return status;
}

Referenced by IopInitializeSystemDrivers(), IoSynchronousInvalidateDeviceRelations(), and PiControlSyncDeviceAction().

◆ PipGetDriverTagPriority()

USHORT NTAPI PipGetDriverTagPriority ( IN HANDLE ServiceHandle )

Definition at line 192 of file pnpinit.c.

{
    NTSTATUS Status;
    HANDLE KeyHandle = NULL;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformation = NULL;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformationTag;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformationGroupOrderList;
    PVOID Buffer;
    UNICODE_STRING Group;
    PULONG GroupOrder;
    ULONG Count, Tag = 0;
    USHORT i = -1;
    UNICODE_STRING GroupString =
    RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet"
                        L"\\Control\\ServiceGroupOrder");
 
    /* Open the key */
    Status = IopOpenRegistryKeyEx(&KeyHandle, NULL, &GroupString, KEY_READ);
    if (!NT_SUCCESS(Status)) goto Quickie;
 
    /* Read the group */
    Status = IopGetRegistryValue(ServiceHandle, L"Group", &KeyValueInformation);
    if (!NT_SUCCESS(Status)) goto Quickie;
 
    /* Make sure we have a group */
    if ((KeyValueInformation->Type == REG_SZ) &&
        (KeyValueInformation->DataLength))
    {
        /* Convert to unicode string */
        Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
        PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &Group.Length);
        Group.MaximumLength = (USHORT)KeyValueInformation->DataLength;
        Group.Buffer = Buffer;
    }
 
    /* Now read the tag */
    Status = IopGetRegistryValue(ServiceHandle, L"Tag", &KeyValueInformationTag);
    if (!NT_SUCCESS(Status)) goto Quickie;
 
    /* Make sure we have a tag */
    if ((KeyValueInformationTag->Type == REG_DWORD) &&
        (KeyValueInformationTag->DataLength))
    {
        /* Read it */
        Tag = *(PULONG)((ULONG_PTR)KeyValueInformationTag +
                        KeyValueInformationTag->DataOffset);
    }
 
    /* We can get rid of this now */
    ExFreePool(KeyValueInformationTag);
 
    /* Now let's read the group's tag order */
    Status = IopGetRegistryValue(KeyHandle,
                                 Group.Buffer,
                                 &KeyValueInformationGroupOrderList);
 
    /* We can get rid of this now */
Quickie:
    if (KeyValueInformation) ExFreePool(KeyValueInformation);
    if (KeyHandle) NtClose(KeyHandle);
    if (!NT_SUCCESS(Status)) return -1;
 
    /* We're on the success path -- validate the tag order*/
    if ((KeyValueInformationGroupOrderList->Type == REG_BINARY) &&
        (KeyValueInformationGroupOrderList->DataLength))
    {
        /* Get the order array */
        GroupOrder = (PULONG)((ULONG_PTR)KeyValueInformationGroupOrderList +
                              KeyValueInformationGroupOrderList->DataOffset);
 
        /* Get the count */
        Count = *GroupOrder;
        ASSERT(((Count + 1) * sizeof(ULONG)) <=
               KeyValueInformationGroupOrderList->DataLength);
 
        /* Now loop each tag */
        GroupOrder++;
        for (i = 1; i <= Count; i++)
        {
            /* If we found it, we're out */
            if (Tag == *GroupOrder) break;
 
            /* Try the next one */
            GroupOrder++;
        }
    }
 
    /* Last buffer to free */
    ExFreePool(KeyValueInformationGroupOrderList);
    return i;
}

Referenced by IopInitializeBootDrivers().

◆ PiQueueDeviceAction()

VOID PiQueueDeviceAction	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ DEVICE_ACTION	Action,
		_In_opt_ PKEVENT	CompletionEvent,
		_Out_opt_ NTSTATUS *	CompletionStatus
	)

Queue a device operation to a worker thread.

Parameters

[in]	DeviceObject	The device object
[in]	Action	The action
[in]	CompletionEvent	The completion event object (optional)
[out]	CompletionStatus	Status returned be the action will be written here

Definition at line 2659 of file devaction.c.

{
    PDEVICE_ACTION_REQUEST Request;
    KIRQL OldIrql;
 
    Request = ExAllocatePoolWithTag(NonPagedPoolMustSucceed, sizeof(*Request), TAG_IO);
 
    DPRINT("PiQueueDeviceAction: DeviceObject - %p, Request - %p, Action - %s\n",
        DeviceObject, Request, ActionToStr(Action));
 
    ObReferenceObject(DeviceObject);
 
    Request->DeviceObject = DeviceObject;
    Request->Action = Action;
    Request->CompletionEvent = CompletionEvent;
    Request->CompletionStatus = CompletionStatus;
 
    KeAcquireSpinLock(&IopDeviceActionLock, &OldIrql);
    InsertTailList(&IopDeviceActionRequestList, &Request->RequestListEntry);
 
    if (Action == PiActionEnumRootDevices || Action == PiActionAddBootDevices)
    {
        ASSERT(!IopDeviceActionInProgress);
 
        IopDeviceActionInProgress = TRUE;
        KeClearEvent(&PiEnumerationFinished);
        KeReleaseSpinLock(&IopDeviceActionLock, OldIrql);
 
        PipDeviceActionWorker(NULL);
        return;
    }
 
    if (IopDeviceActionInProgress || !PnPBootDriversLoaded)
    {
        KeReleaseSpinLock(&IopDeviceActionLock, OldIrql);
        return;
    }
    IopDeviceActionInProgress = TRUE;
    KeClearEvent(&PiEnumerationFinished);
    KeReleaseSpinLock(&IopDeviceActionLock, OldIrql);
 
    ExInitializeWorkItem(&IopDeviceActionWorkItem, PipDeviceActionWorker, NULL);
    ExQueueWorkItem(&IopDeviceActionWorkItem, DelayedWorkQueue);
}

Referenced by IoInitSystem(), IoInvalidateDeviceRelations(), IoInvalidateDeviceState(), IopInitializeBootDrivers(), IopInitializeBuiltinDriver(), IopInitializePlugPlayServices(), IopInitializeSystemDrivers(), IoReportDetectedDevice(), and PiPerformSyncDeviceAction().

◆ PiSetDevNodeProblem()

VOID PiSetDevNodeProblem	(	_In_ PDEVICE_NODE	DeviceNode,
		_In_ UINT32	Problem
	)

Definition at line 132 of file devnode.c.

{
    DeviceNode->Flags |= DNF_HAS_PROBLEM;
    DeviceNode->Problem = Problem;
}

Referenced by PiAttachFilterDriversCallback(), PiCallDriverAddDevice(), PiDevNodeStateMachine(), and PiUpdateDeviceState().

◆ PiSetDevNodeState()

PNP_DEVNODE_STATE PiSetDevNodeState	(	_In_ PDEVICE_NODE	DeviceNode,
		_In_ PNP_DEVNODE_STATE	NewState
	)

Definition at line 108 of file devnode.c.

{
    KIRQL oldIrql;
 
    KeAcquireSpinLock(&IopDeviceTreeLock, &oldIrql);
 
    PNP_DEVNODE_STATE prevState = DeviceNode->State;
    if (prevState != NewState)
    {
        DeviceNode->State = NewState;
        DeviceNode->PreviousState = prevState;
        DeviceNode->StateHistory[DeviceNode->StateHistoryEntry++] = prevState;
        DeviceNode->StateHistoryEntry %= DEVNODE_HISTORY_SIZE;
    }
 
    KeReleaseSpinLock(&IopDeviceTreeLock, oldIrql);
 
    DPRINT("%wZ Changed state 0x%x => 0x%x\n", &DeviceNode->InstancePath, prevState, NewState);
    return prevState;
}

Referenced by IopAssignDeviceResources(), IopInitializePlugPlayServices(), IopQueryRemoveChildDevices(), IopSendRemoveDevice(), IoReportDetectedDevice(), PiCallDriverAddDevice(), PiControlInitializeDevice(), PiDevNodeStateMachine(), PiEnumerateDevice(), PiInitializeDevNode(), PiStartDeviceFinal(), and PiUpdateDeviceState().

◆ PiSetDevNodeText()

VOID PiSetDevNodeText	(	_In_ PDEVICE_NODE	DeviceNode,
		_In_ HANDLE	InstanceKey
	)

Sets the DeviceNode's DeviceDesc and LocationInformation registry values.

Definition at line 1089 of file devaction.c.

{
    PAGED_CODE();
 
    LCID localeId;
 
    // Get the Locale ID
    NTSTATUS status = ZwQueryDefaultLocale(FALSE, &localeId);
    if (!NT_SUCCESS(status))
    {
        DPRINT1("ZwQueryDefaultLocale() failed with status %x\n", status);
        return;
    }
 
    // Step 1: Write the DeviceDesc value if does not exist
 
    UNICODE_STRING valDeviceDesc = RTL_CONSTANT_STRING(L"DeviceDesc");
    ULONG len;
 
    status = ZwQueryValueKey(InstanceKey, &valDeviceDesc, KeyValueBasicInformation, NULL, 0, &len);
    if (status == STATUS_OBJECT_NAME_NOT_FOUND)
    {
        PWSTR deviceDesc = NULL;
        status = PiIrpQueryDeviceText(DeviceNode, localeId, DeviceTextDescription, &deviceDesc);
 
        if (deviceDesc && deviceDesc[0] != UNICODE_NULL)
        {
            status = ZwSetValueKey(InstanceKey,
                                   &valDeviceDesc,
                                   0,
                                   REG_SZ,
                                   deviceDesc,
                                   ((ULONG)wcslen(deviceDesc) + 1) * sizeof(WCHAR));
 
            if (!NT_SUCCESS(status))
            {
                DPRINT1("ZwSetValueKey() failed (Status %x)\n", status);
            }
        }
        else
        {
            // This key is mandatory, so even if the Irp fails, we still write it
            UNICODE_STRING unknownDeviceDesc = RTL_CONSTANT_STRING(L"Unknown device");
            DPRINT("Driver didn't return DeviceDesc (status %x)\n", status);
 
            status = ZwSetValueKey(InstanceKey,
                                   &valDeviceDesc,
                                   0,
                                   REG_SZ,
                                   unknownDeviceDesc.Buffer,
                                   unknownDeviceDesc.MaximumLength);
            if (!NT_SUCCESS(status))
            {
                DPRINT1("ZwSetValueKey() failed (Status %x)\n", status);
            }
        }
 
        if (deviceDesc)
        {
            ExFreePoolWithTag(deviceDesc, 0);
        }
    }
 
    // Step 2: LocaltionInformation is overwritten unconditionally
 
    PWSTR deviceLocationInfo = NULL;
    status = PiIrpQueryDeviceText(DeviceNode,
                                  localeId,
                                  DeviceTextLocationInformation,
                                  &deviceLocationInfo);
 
    if (deviceLocationInfo && deviceLocationInfo[0] != UNICODE_NULL)
    {
        UNICODE_STRING valLocationInfo = RTL_CONSTANT_STRING(L"LocationInformation");
 
        status = ZwSetValueKey(InstanceKey,
                               &valLocationInfo,
                               0,
                               REG_SZ,
                               deviceLocationInfo,
                               ((ULONG)wcslen(deviceLocationInfo) + 1) * sizeof(WCHAR));
        if (!NT_SUCCESS(status))
        {
            DPRINT1("ZwSetValueKey() failed (Status %x)\n", status);
        }
    }
 
    if (deviceLocationInfo)
    {
        ExFreePoolWithTag(deviceLocationInfo, 0);
    }
    else
    {
        DPRINT("Driver didn't return LocationInformation (status %x)\n", status);
    }
}

Referenced by IoReportDetectedDevice(), and PiInitializeDevNode().

◆ PnpDetermineResourceListSize()

ULONG NTAPI PnpDetermineResourceListSize ( IN PCM_RESOURCE_LIST ResourceList )

Definition at line 1237 of file pnpmgr.c.

{
    ULONG FinalSize, PartialSize, EntrySize, i, j;
    PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
    PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
 
    /* If we don't have one, that's easy */
    if (!ResourceList) return 0;
 
    /* Start with the minimum size possible */
    FinalSize = FIELD_OFFSET(CM_RESOURCE_LIST, List);
 
    /* Loop each full descriptor */
    FullDescriptor = ResourceList->List;
    for (i = 0; i < ResourceList->Count; i++)
    {
        /* Start with the minimum size possible */
        PartialSize = FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList) +
        FIELD_OFFSET(CM_PARTIAL_RESOURCE_LIST, PartialDescriptors);
 
        /* Loop each partial descriptor */
        PartialDescriptor = FullDescriptor->PartialResourceList.PartialDescriptors;
        for (j = 0; j < FullDescriptor->PartialResourceList.Count; j++)
        {
            /* Start with the minimum size possible */
            EntrySize = sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
 
            /* Check if there is extra data */
            if (PartialDescriptor->Type == CmResourceTypeDeviceSpecific)
            {
                /* Add that data */
                EntrySize += PartialDescriptor->u.DeviceSpecificData.DataSize;
            }
 
            /* The size of partial descriptors is bigger */
            PartialSize += EntrySize;
 
            /* Go to the next partial descriptor */
            PartialDescriptor = (PVOID)((ULONG_PTR)PartialDescriptor + EntrySize);
        }
 
        /* The size of full descriptors is bigger */
        FinalSize += PartialSize;
 
        /* Go to the next full descriptor */
        FullDescriptor = (PVOID)((ULONG_PTR)FullDescriptor + PartialSize);
    }
 
    /* Return the final size */
    return FinalSize;
}

Referenced by IoGetDeviceProperty(), IopAssignDeviceResources(), IopFixupResourceListWithRequirements(), IopSetDeviceInstanceData(), IopTranslateDeviceResources(), IopUpdateControlKeyWithResources(), and IopUpdateResourceMap().

◆ PnpInit2()

VOID PnpInit2 ( VOID )

◆ PnpRegMultiSzToUnicodeStrings()

NTSTATUS NTAPI PnpRegMultiSzToUnicodeStrings	(	IN PKEY_VALUE_FULL_INFORMATION	KeyValueInformation,
		OUT PUNICODE_STRING *	UnicodeStringList,
		OUT PULONG	UnicodeStringCount
	)

Definition at line 47 of file pnputil.c.

{
    PWCHAR p, pp, ps;
    ULONG i = 0;
    SIZE_T n;
    ULONG Count = 0;
 
    /* Validate the key information */
    if (KeyValueInformation->Type != REG_MULTI_SZ) return STATUS_INVALID_PARAMETER;
 
    /* Set the pointers */
    p = (PWCHAR)((ULONG_PTR)KeyValueInformation +
                 KeyValueInformation->DataOffset);
    pp = (PWCHAR)((ULONG_PTR)p + KeyValueInformation->DataLength);
 
    /* Loop the data */
    while (p != pp)
    {
        /* If we find a NULL, that means one string is done */
        if (!*p)
        {
            /* Add to our string count */
            Count++;
 
            /* Check for a double-NULL, which means we're done */
            if (((p + 1) == pp) || !(*(p + 1))) break;
        }
 
        /* Go to the next character */
        p++;
    }
 
    /* If we looped the whole list over, we missed increment a string, do it */
    if (p == pp) Count++;
 
    /* Allocate the list now that we know how big it is */
    *UnicodeStringList = ExAllocatePoolWithTag(PagedPool,
                                               sizeof(UNICODE_STRING) * Count,
                                               'sUpP');
    if (!(*UnicodeStringList)) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Set pointers for second loop */
    ps = p = (PWCHAR)((ULONG_PTR)KeyValueInformation +
                     KeyValueInformation->DataOffset);
 
    /* Loop again, to do the copy this time */
    while (p != pp)
    {
        /* If we find a NULL, that means one string is done */
        if (!*p)
        {
            /* Check how long this string is */
            n = (ULONG_PTR)p - (ULONG_PTR)ps + sizeof(UNICODE_NULL);
 
            /* Allocate the buffer */
            (*UnicodeStringList)[i].Buffer = ExAllocatePoolWithTag(PagedPool,
                                                                   n,
                                                                   'sUpP');
            if (!(*UnicodeStringList)[i].Buffer)
            {
                /* Back out of everything */
                PnpFreeUnicodeStringList(*UnicodeStringList, i);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            /* Copy the string into the buffer */
            RtlCopyMemory((*UnicodeStringList)[i].Buffer, ps, n);
 
            /* Set the lengths */
            (*UnicodeStringList)[i].MaximumLength = (USHORT)n;
            (*UnicodeStringList)[i].Length = (USHORT)(n - sizeof(UNICODE_NULL));
 
            /* One more entry done */
            i++;
 
            /* Check for a double-NULL, which means we're done */
            if (((p + 1) == pp) || !(*(p + 1))) break;
 
            /* New string */
            ps = p + 1;
        }
 
        /* New string */
        p++;
    }
 
    /* Check if we've reached the last string */
    if (p == pp)
    {
        /* Calculate the string length */
        n = (ULONG_PTR)p - (ULONG_PTR)ps;
 
        /* Allocate the buffer for it */
        (*UnicodeStringList)[i].Buffer = ExAllocatePoolWithTag(PagedPool,
                                                               n +
                                                               sizeof(UNICODE_NULL),
                                                               'sUpP');
        if (!(*UnicodeStringList)[i].Buffer)
        {
            /* Back out of everything */
            PnpFreeUnicodeStringList(*UnicodeStringList, i);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        /* Make sure there's an actual string here */
        if (n) RtlCopyMemory((*UnicodeStringList)[i].Buffer, ps, n);
 
        /* Null-terminate the string ourselves */
        (*UnicodeStringList)[i].Buffer[n / sizeof(WCHAR)] = UNICODE_NULL;
 
        /* Set the lengths */
        (*UnicodeStringList)[i].Length = (USHORT)n;
        (*UnicodeStringList)[i].MaximumLength = (USHORT)(n + sizeof(UNICODE_NULL));
    }
 
    /* And we're done */
    *UnicodeStringCount = Count;
    return STATUS_SUCCESS;
}

Referenced by PiInitCacheGroupInformation().

◆ PnpRegSzToString()

BOOLEAN NTAPI PnpRegSzToString	(	IN PWCHAR	RegSzData,
		IN ULONG	RegSzLength,
		OUT PUSHORT StringLength	OPTIONAL
	)

Definition at line 171 of file pnputil.c.

{
    PWCHAR p, pp;
 
    /* Find the end */
    pp = RegSzData + RegSzLength / sizeof(WCHAR);
    for (p = RegSzData; p < pp; p++)
    {
        if (!*p)
        {
            break;
        }
    }
 
    /* Return the length. Truncation can happen but is of no consequence. */
    if (StringLength)
    {
        *StringLength = (USHORT)(p - RegSzData) * sizeof(WCHAR);
    }
    return TRUE;
}

Referenced by IoGetDeviceInterfaceAlias(), PipGetDriverTagPriority(), and PpInitGetGroupOrderIndex().

◆ PnpRootCreateDevice()

NTSTATUS PnpRootCreateDevice	(	IN PUNICODE_STRING	ServiceName,
		OUT PDEVICE_OBJECT *	PhysicalDeviceObject,
		OUT PUNICODE_STRING	FullInstancePath
	)

Definition at line 184 of file pnproot.c.

{
    PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension;
    PPNPROOT_PDO_DEVICE_EXTENSION PdoDeviceExtension;
    UNICODE_STRING DevicePath;
    WCHAR InstancePath[5];
    PPNPROOT_DEVICE Device = NULL;
    NTSTATUS Status;
    ULONG NextInstance;
    UNICODE_STRING EnumKeyName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\" REGSTR_PATH_SYSTEMENUM);
    HANDLE EnumHandle, DeviceKeyHandle = NULL, InstanceKeyHandle;
    RTL_QUERY_REGISTRY_TABLE QueryTable[2];
    OBJECT_ATTRIBUTES ObjectAttributes;
 
    DeviceExtension = &PnpRootDOExtension;
    KeAcquireGuardedMutex(&DeviceExtension->DeviceListLock);
 
    DPRINT("Creating a PnP root device for service '%wZ'\n", ServiceName);
 
    DevicePath.Length = 0;
    DevicePath.MaximumLength = sizeof(REGSTR_KEY_ROOTENUM) + sizeof(L'\\') + ServiceName->Length;
    DevicePath.Buffer = ExAllocatePoolWithTag(PagedPool,
                                              DevicePath.MaximumLength,
                                              TAG_PNP_ROOT);
    if (DevicePath.Buffer == NULL)
    {
        DPRINT1("ExAllocatePoolWithTag() failed\n");
        Status = STATUS_NO_MEMORY;
        goto cleanup;
    }
    RtlAppendUnicodeToString(&DevicePath, REGSTR_KEY_ROOTENUM L"\\");
    RtlAppendUnicodeStringToString(&DevicePath, ServiceName);
 
    /* Initialize a PNPROOT_DEVICE structure */
    Device = ExAllocatePoolWithTag(PagedPool, sizeof(PNPROOT_DEVICE), TAG_PNP_ROOT);
    if (!Device)
    {
        DPRINT("ExAllocatePoolWithTag() failed\n");
        Status = STATUS_NO_MEMORY;
        goto cleanup;
    }
    RtlZeroMemory(Device, sizeof(PNPROOT_DEVICE));
    Device->DeviceID = DevicePath; // "Root<service_name>"
    RtlInitEmptyUnicodeString(&DevicePath, NULL, 0);
 
    Status = IopOpenRegistryKeyEx(&EnumHandle, NULL, &EnumKeyName, KEY_READ);
    if (NT_SUCCESS(Status))
    {
        InitializeObjectAttributes(&ObjectAttributes,
                                   &Device->DeviceID,
                                   OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                                   EnumHandle,
                                   NULL);
        Status = ZwCreateKey(&DeviceKeyHandle, KEY_SET_VALUE, &ObjectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
        ObCloseHandle(EnumHandle, KernelMode);
    }
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to open registry key\n");
        goto cleanup;
    }
 
tryagain:
    RtlZeroMemory(QueryTable, sizeof(QueryTable));
    QueryTable[0].Name = L"NextInstance";
    QueryTable[0].EntryContext = &NextInstance;
    QueryTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED;
 
    Status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
                                    (PWSTR)DeviceKeyHandle,
                                    QueryTable,
                                    NULL,
                                    NULL);
    for (NextInstance = 0; NextInstance <= 9999; NextInstance++)
    {
        _snwprintf(InstancePath, sizeof(InstancePath) / sizeof(WCHAR), L"%04lu", NextInstance);
        Status = LocateChildDevice(DeviceExtension, &Device->DeviceID, InstancePath, NULL);
        if (Status == STATUS_NO_SUCH_DEVICE)
            break;
    }
 
    if (NextInstance > 9999)
    {
        DPRINT1("Too many legacy devices reported for service '%wZ'\n", ServiceName);
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto cleanup;
    }
 
    _snwprintf(InstancePath, sizeof(InstancePath) / sizeof(WCHAR), L"%04lu", NextInstance);
    Status = LocateChildDevice(DeviceExtension, &Device->DeviceID, InstancePath, NULL);
    if (Status != STATUS_NO_SUCH_DEVICE || NextInstance > 9999)
    {
        DPRINT1("NextInstance value is corrupt! (%lu)\n", NextInstance);
        RtlDeleteRegistryValue(RTL_REGISTRY_HANDLE,
                               (PWSTR)DeviceKeyHandle,
                               L"NextInstance");
        goto tryagain;
    }
 
    NextInstance++;
    Status = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE,
                                   (PWSTR)DeviceKeyHandle,
                                   L"NextInstance",
                                   REG_DWORD,
                                   &NextInstance,
                                   sizeof(NextInstance));
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to write new NextInstance value! (0x%x)\n", Status);
        goto cleanup;
    }
 
    // "0000" or higher
    if (!RtlCreateUnicodeString(&Device->InstanceID, InstancePath))
    {
        Status = STATUS_NO_MEMORY;
        goto cleanup;
    }
 
    /* Finish creating the instance path in the registry */
    InitializeObjectAttributes(&ObjectAttributes,
                               &Device->InstanceID,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               DeviceKeyHandle,
                               NULL);
    Status = ZwCreateKey(&InstanceKeyHandle, KEY_QUERY_VALUE, &ObjectAttributes, 0, NULL, REG_OPTION_NON_VOLATILE, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Failed to create instance path (0x%x)\n", Status);
        goto cleanup;
    }
 
    /* Just close the handle */
    ObCloseHandle(InstanceKeyHandle, KernelMode);
 
    // generate the full device instance path
    FullInstancePath->MaximumLength = Device->DeviceID.Length + sizeof(L'\\') + Device->InstanceID.Length;
    FullInstancePath->Length = 0;
    FullInstancePath->Buffer = ExAllocatePool(PagedPool, FullInstancePath->MaximumLength);
    if (!FullInstancePath->Buffer)
    {
        Status = STATUS_NO_MEMORY;
        goto cleanup;
    }
 
    RtlAppendUnicodeStringToString(FullInstancePath, &Device->DeviceID);
    RtlAppendUnicodeToString(FullInstancePath, L"\\");
    RtlAppendUnicodeStringToString(FullInstancePath, &Device->InstanceID);
 
    /* Initialize a device object */
    Status = PnpRootCreateDeviceObject(&Device->Pdo);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("IoCreateDevice() failed with status 0x%08lx\n", Status);
        Status = STATUS_NO_MEMORY;
        goto cleanup;
    }
 
    PdoDeviceExtension = (PPNPROOT_PDO_DEVICE_EXTENSION)Device->Pdo->DeviceExtension;
    RtlZeroMemory(PdoDeviceExtension, sizeof(PNPROOT_PDO_DEVICE_EXTENSION));
    PdoDeviceExtension->DeviceInfo = Device;
 
    Device->Pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
    Device->Pdo->Flags &= ~DO_DEVICE_INITIALIZING;
 
    InsertTailList(
        &DeviceExtension->DeviceListHead,
        &Device->ListEntry);
    DeviceExtension->DeviceListCount++;
 
    *PhysicalDeviceObject = Device->Pdo;
    DPRINT("Created PDO %p (%wZ\\%wZ)\n", *PhysicalDeviceObject, &Device->DeviceID, &Device->InstanceID);
    Device = NULL;
    Status = STATUS_SUCCESS;
 
cleanup:
    KeReleaseGuardedMutex(&DeviceExtension->DeviceListLock);
    if (Device)
    {
        if (Device->Pdo)
            IoDeleteDevice(Device->Pdo);
        RtlFreeUnicodeString(&Device->DeviceID);
        RtlFreeUnicodeString(&Device->InstanceID);
        ExFreePoolWithTag(Device, TAG_PNP_ROOT);
    }
    RtlFreeUnicodeString(&DevicePath);
    if (DeviceKeyHandle != NULL)
        ObCloseHandle(DeviceKeyHandle, KernelMode);
    return Status;
}

Referenced by IoReportDetectedDevice().

◆ PnpRootCreateDeviceObject()

NTSTATUS PnpRootCreateDeviceObject ( OUT PDEVICE_OBJECT * DeviceObject )

Definition at line 167 of file pnproot.c.

{
    NTSTATUS status = IoCreateDevice(
        IopRootDriverObject,
        sizeof(PNPROOT_PDO_DEVICE_EXTENSION),
        NULL,
        FILE_DEVICE_CONTROLLER,
        FILE_AUTOGENERATED_DEVICE_NAME,
        FALSE,
        DeviceObject);
 
    return status;
}

Referenced by PiControlInitializeDevice(), PnpRootCreateDevice(), and PnpRootQueryDeviceRelations().

◆ PnpRootDriverEntry()

NTSTATUS NTAPI PnpRootDriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 1488 of file pnproot.c.

{
#if MI_TRACE_PFNS
    NTSTATUS Status;
    UNICODE_STRING PfnDumpDeviceName = RTL_CONSTANT_STRING(L"\\Device\\PfnDump");
#endif
 
    DPRINT("PnpRootDriverEntry(%p %wZ)\n", DriverObject, RegistryPath);
 
    IopRootDriverObject = DriverObject;
 
    DriverObject->DriverExtension->AddDevice = PnpRootAddDevice;
 
#if MI_TRACE_PFNS
    DriverObject->MajorFunction[IRP_MJ_CREATE] = PnpRootCreateClose;
    DriverObject->MajorFunction[IRP_MJ_CLOSE] = PnpRootCreateClose;
#endif
    DriverObject->MajorFunction[IRP_MJ_PNP] = PnpRootPnpControl;
    DriverObject->MajorFunction[IRP_MJ_POWER] = PnpRootPowerControl;
 
#if MI_TRACE_PFNS
    Status = IoCreateDevice(DriverObject,
                            0,
                            &PfnDumpDeviceName,
                            FILE_DEVICE_UNKNOWN,
                            0,
                            FALSE,
                            &IopPfnDumpDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("Creating PFN Dump device failed with %lx\n", Status);
    }
    else
    {
        IopPfnDumpDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
    }
#endif
 
    return STATUS_SUCCESS;
}

Referenced by IopInitializePlugPlayServices().

◆ PnpRootInitializeDevExtension()

VOID PnpRootInitializeDevExtension ( VOID )

Definition at line 1440 of file pnproot.c.

{
    PnpRootDOExtension.DeviceListCount = 0;
    InitializeListHead(&PnpRootDOExtension.DeviceListHead);
    KeInitializeGuardedMutex(&PnpRootDOExtension.DeviceListLock);
}

Referenced by IopInitializePlugPlayServices().

◆ PnpRootRegisterDevice()

NTSTATUS PnpRootRegisterDevice ( IN PDEVICE_OBJECT DeviceObject )

Definition at line 107 of file pnproot.c.

{
    PPNPROOT_FDO_DEVICE_EXTENSION DeviceExtension = &PnpRootDOExtension;
    PPNPROOT_PDO_DEVICE_EXTENSION PdoDeviceExtension;
    PPNPROOT_DEVICE Device;
    PDEVICE_NODE DeviceNode;
    PWSTR InstancePath;
    UNICODE_STRING InstancePathCopy;
 
    Device = ExAllocatePoolWithTag(PagedPool, sizeof(PNPROOT_DEVICE), TAG_PNP_ROOT);
    if (!Device) return STATUS_NO_MEMORY;
 
    DeviceNode = IopGetDeviceNode(DeviceObject);
    if (!RtlCreateUnicodeString(&InstancePathCopy, DeviceNode->InstancePath.Buffer))
    {
        ExFreePoolWithTag(Device, TAG_PNP_ROOT);
        return STATUS_NO_MEMORY;
    }
 
    InstancePath = wcsrchr(InstancePathCopy.Buffer, L'\\');
    ASSERT(InstancePath);
 
    if (!RtlCreateUnicodeString(&Device->InstanceID, InstancePath + 1))
    {
        RtlFreeUnicodeString(&InstancePathCopy);
        ExFreePoolWithTag(Device, TAG_PNP_ROOT);
        return STATUS_NO_MEMORY;
    }
 
    InstancePath[0] = UNICODE_NULL;
 
    if (!RtlCreateUnicodeString(&Device->DeviceID, InstancePathCopy.Buffer))
    {
        RtlFreeUnicodeString(&InstancePathCopy);
        RtlFreeUnicodeString(&Device->InstanceID);
        ExFreePoolWithTag(Device, TAG_PNP_ROOT);
        return STATUS_NO_MEMORY;
    }
 
    InstancePath[0] = L'\\';
 
    Device->Pdo = DeviceObject;
 
    PdoDeviceExtension = DeviceObject->DeviceExtension;
    RtlZeroMemory(PdoDeviceExtension, sizeof(PNPROOT_PDO_DEVICE_EXTENSION));
    PdoDeviceExtension->DeviceInfo = Device;
 
    KeAcquireGuardedMutex(&DeviceExtension->DeviceListLock);
    InsertTailList(&DeviceExtension->DeviceListHead,
                   &Device->ListEntry);
    DeviceExtension->DeviceListCount++;
    KeReleaseGuardedMutex(&DeviceExtension->DeviceListLock);
 
    RtlFreeUnicodeString(&InstancePathCopy);
 
    return STATUS_SUCCESS;
}

Referenced by IoReportDetectedDevice(), and PiControlInitializeDevice().

◆ PpInitGetGroupOrderIndex()

USHORT NTAPI PpInitGetGroupOrderIndex ( IN HANDLE ServiceHandle )

Definition at line 149 of file pnpinit.c.

{
    NTSTATUS Status;
    PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
    USHORT i;
    PVOID Buffer;
    UNICODE_STRING Group;
    PAGED_CODE();
 
    /* Make sure we have a cache */
    if (!PiInitGroupOrderTable) return -1;
 
    /* If we don't have a handle, the rest is easy -- return the count */
    if (!ServiceHandle) return PiInitGroupOrderTableCount + 1;
 
    /* Otherwise, get the group value */
    Status = IopGetRegistryValue(ServiceHandle, L"Group", &KeyValueInformation);
    if (!NT_SUCCESS(Status)) return PiInitGroupOrderTableCount;
 
    /* Make sure we have a valid string */
    ASSERT(KeyValueInformation->Type == REG_SZ);
    ASSERT(KeyValueInformation->DataLength);
 
    /* Convert to unicode string */
    Buffer = (PVOID)((ULONG_PTR)KeyValueInformation + KeyValueInformation->DataOffset);
    PnpRegSzToString(Buffer, KeyValueInformation->DataLength, &Group.Length);
    Group.MaximumLength = (USHORT)KeyValueInformation->DataLength;
    Group.Buffer = Buffer;
 
    /* Loop the groups */
    for (i = 0; i < PiInitGroupOrderTableCount; i++)
    {
        /* Try to find a match */
        if (RtlEqualUnicodeString(&Group, &PiInitGroupOrderTable[i], TRUE)) break;
    }
 
    /* We're done */
    ExFreePool(KeyValueInformation);
    return i;
}

Referenced by IopInitializeBootDrivers().

◆ PpInitSystem()

BOOLEAN NTAPI PpInitSystem ( VOID )

Definition at line 1142 of file pnpmgr.c.

{
    /* Check the initialization phase */
    switch (ExpInitializationPhase)
    {
    case 0:
 
        /* Do Phase 0 */
        return PiInitPhase0();
 
    case 1:
 
        /* Do Phase 1 */
        return TRUE;
        //return PiInitPhase1();
 
    default:
 
        /* Don't know any other phase! Bugcheck! */
        KeBugCheck(UNEXPECTED_INITIALIZATION_CALL);
        return FALSE;
    }
}

Referenced by ExpInitializeExecutive(), and Phase1InitializationDiscard().

◆ RawFsDriverEntry()

NTSTATUS NTAPI RawFsDriverEntry	(	IN PDRIVER_OBJECT	DriverObject,
		IN PUNICODE_STRING	RegistryPath
	)

Definition at line 1193 of file rawfs.c.

{
    NTSTATUS Status;
    UNICODE_STRING DeviceName;
 
    UNREFERENCED_PARAMETER(RegistryPath);
 
    /* Create the raw disk device */
    RtlInitUnicodeString(&DeviceName, L"\\Device\\RawDisk");
    Status = IoCreateDevice(DriverObject,
                            0,
                            &DeviceName,
                            FILE_DEVICE_DISK_FILE_SYSTEM,
                            0,
                            FALSE,
                            &RawDiskDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Create the raw CDROM device */
    RtlInitUnicodeString(&DeviceName, L"\\Device\\RawCdRom");
    Status = IoCreateDevice(DriverObject,
                            0,
                            &DeviceName,
                            FILE_DEVICE_CD_ROM_FILE_SYSTEM,
                            0,
                            FALSE,
                            &RawCdromDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        IoDeleteDevice(RawDiskDeviceObject);
        return Status;
    }
 
    /* Create the raw tape device */
    RtlInitUnicodeString(&DeviceName, L"\\Device\\RawTape");
    Status = IoCreateDevice(DriverObject,
                            0,
                            &DeviceName,
                            FILE_DEVICE_TAPE_FILE_SYSTEM,
                            0,
                            FALSE,
                            &RawTapeDeviceObject);
    if (!NT_SUCCESS(Status))
    {
        IoDeleteDevice(RawDiskDeviceObject);
        IoDeleteDevice(RawCdromDeviceObject);
        return Status;
    }
 
    /* Set Direct I/O for all devices */
    RawDiskDeviceObject->Flags |= DO_DIRECT_IO;
    RawCdromDeviceObject->Flags |= DO_DIRECT_IO;
    RawTapeDeviceObject->Flags |= DO_DIRECT_IO;
 
    /* Set generic stubs */
    DriverObject->MajorFunction[IRP_MJ_CREATE] =
    DriverObject->MajorFunction[IRP_MJ_CLEANUP] =
    DriverObject->MajorFunction[IRP_MJ_CLOSE] =
    DriverObject->MajorFunction[IRP_MJ_READ] =
    DriverObject->MajorFunction[IRP_MJ_WRITE] =
    DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
    DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
    DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] =
    DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = RawDispatch;
 
    /* Shutdown and unload */
    DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = RawShutdown;
    DriverObject->DriverUnload = RawUnload;
 
    /* Register the file systems */
    IoRegisterFileSystem(RawDiskDeviceObject);
    IoRegisterFileSystem(RawCdromDeviceObject);
    IoRegisterFileSystem(RawTapeDeviceObject);
 
#if 0 // FIXME: DriverUnload is never called
    /* Reference device objects */
    ObReferenceObject(RawDiskDeviceObject);
    ObReferenceObject(RawCdromDeviceObject);
    ObReferenceObject(RawTapeDeviceObject);
#endif
    return STATUS_SUCCESS;
}

Referenced by IopInitializeBootDrivers().

◆ RawFsIsRawFileSystemDeviceObject()

BOOLEAN RawFsIsRawFileSystemDeviceObject ( IN PDEVICE_OBJECT DeviceObject )

Variable Documentation

◆ _HalDispatchTable

HAL_DISPATCH _HalDispatchTable

extern

◆ _IoFileObjectType

POBJECT_TYPE _IoFileObjectType

extern

◆ IoCompletionType

POBJECT_TYPE IoCompletionType

extern

Definition at line 16 of file iocomp.c.

Referenced by IopCreateObjectTypes(), NtCreateIoCompletion(), NtOpenIoCompletion(), NtQueryIoCompletion(), NtRemoveIoCompletion(), NtSetInformationFile(), and NtSetIoCompletion().

◆ IopAutoReboot

ULONG IopAutoReboot

extern

Definition at line 46 of file iomgr.c.

Referenced by KeBugCheckWithTf().

◆ IopBusTypeGuidList

PIO_BUS_TYPE_GUID_LIST IopBusTypeGuidList

extern

◆ IopCompletionMapping

GENERIC_MAPPING IopCompletionMapping

extern

Definition at line 20 of file iocomp.c.

Referenced by IopCreateObjectTypes().

◆ IopDeviceActionLock

KSPIN_LOCK IopDeviceActionLock

extern

Definition at line 49 of file devaction.c.

Referenced by IopInitializePlugPlayServices(), PipDeviceActionWorker(), and PiQueueDeviceAction().

◆ IopDeviceActionRequestList

LIST_ENTRY IopDeviceActionRequestList

extern

Definition at line 46 of file devaction.c.

Referenced by IopInitializePlugPlayServices(), PipDeviceActionWorker(), and PiQueueDeviceAction().

◆ IopDeviceTreeLock

KSPIN_LOCK IopDeviceTreeLock

extern

Definition at line 19 of file devnode.c.

Referenced by IopCancelRemoveChildDevices(), IopFreeDeviceNode(), IopGetSystemPowerDeviceObject(), IopInitializePlugPlayServices(), IopQueryRemoveChildDevices(), IopSendRemoveChildDevices(), PiDevNodeStateMachine(), PiInsertDevNode(), and PiSetDevNodeState().

◆ IopErrorLogListHead

LIST_ENTRY IopErrorLogListHead

extern

Definition at line 30 of file error.c.

◆ IopFileMapping

GENERIC_MAPPING IopFileMapping

extern

Definition at line 50 of file iomgr.c.

Referenced by IoGetFileObjectGenericMapping(), and IopCreateObjectTypes().

◆ IopMdlLookasideList

GENERAL_LOOKASIDE IopMdlLookasideList

extern

Definition at line 85 of file iomgr.c.

Referenced by IopInitLookasideLists().

◆ IopNumTriageDumpDataBlocks

ULONG IopNumTriageDumpDataBlocks

extern

Definition at line 47 of file iomgr.c.

◆ IopReserveIrpAllocator

RESERVE_IRP_ALLOCATOR IopReserveIrpAllocator

extern

Definition at line 19 of file irp.c.

Referenced by IofCompleteRequest(), IoInitSystem(), IopAllocateReserveIrp(), and IopFreeReserveIrp().

◆ IopRootDeviceNode

PDEVICE_NODE IopRootDeviceNode

extern

Definition at line 18 of file devnode.c.

Referenced by IoInitSystem(), IopGetDeviceNodeStatus(), IopGetDeviceObjectFromDeviceInstance(), IopGetRelatedDevice(), IopInitializeBootDrivers(), IopInitializePlugPlayServices(), IopInitializeSystemDrivers(), IoReportDetectedDevice(), PiControlInitializeDevice(), PnpRootPnpControl(), PoInitSystem(), PopQuerySystemPowerStateTraverse(), PopSetSystemPowerState(), and PopSetSystemPowerStateTraverse().

◆ IopRootDriverObject

PDRIVER_OBJECT IopRootDriverObject

extern

Definition at line 26 of file pnpmgr.c.

Referenced by IopInitializePlugPlayServices(), PnpRootCreateDeviceObject(), and PnpRootDriverEntry().

◆ IopTraceLevel

ULONG IopTraceLevel

extern

Definition at line 16 of file iomgr.c.

◆ IopTriageDumpDataBlocks

PVOID IopTriageDumpDataBlocks[64]

extern

Definition at line 48 of file iomgr.c.

◆ IoRemoteBootClient

BOOLEAN IoRemoteBootClient

extern

Definition at line 70 of file init.c.

Referenced by ExpInitializeExecutive(), IopCreateArcNames(), and xHalIoAssignDriveLetters().

◆ PnpBusTypeGuidList

PIO_BUS_TYPE_GUID_LIST PnpBusTypeGuidList

extern

Definition at line 27 of file pnpmgr.c.

Referenced by IopGetBusTypeGuidIndex(), IopInitializePlugPlayServices(), and PnpBusTypeGuidGet().

Variables
PIO_BUS_TYPE_GUID_LIST	IopBusTypeGuidList

POBJECT_TYPE	IoCompletionType

PDEVICE_NODE	IopRootDeviceNode

KSPIN_LOCK	IopDeviceTreeLock

ULONG	IopTraceLevel

GENERAL_LOOKASIDE	IopMdlLookasideList

GENERIC_MAPPING	IopCompletionMapping

GENERIC_MAPPING	IopFileMapping

POBJECT_TYPE	_IoFileObjectType

HAL_DISPATCH	_HalDispatchTable

LIST_ENTRY	IopErrorLogListHead

ULONG	IopAutoReboot

ULONG	IopNumTriageDumpDataBlocks

PVOID	IopTriageDumpDataBlocks [64]

PIO_BUS_TYPE_GUID_LIST	PnpBusTypeGuidList

PDRIVER_OBJECT	IopRootDriverObject

KSPIN_LOCK	IopDeviceActionLock

LIST_ENTRY	IopDeviceActionRequestList

RESERVE_IRP_ALLOCATOR	IopReserveIrpAllocator

BOOLEAN	IoRemoteBootClient

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ _IO_DEBUG_

◆ ENUM_ROOT

◆ IO_API_DEBUG

◆ IO_CTL_DEBUG

◆ IO_FILE_DEBUG

◆ IO_IRP_DEBUG

◆ IO_METHOD_FROM_CTL_CODE

◆ IoGetDevObjExtension

◆ IoGetDrvObjExtension

◆ IOP_CREATE_FILE_OBJECT_EXTENSION

◆ IOP_MAX_REPARSE_TRAVERSAL

◆ IOP_USE_TOP_LEVEL_DEVICE_HINT

◆ IopAllocateMdlFromLookaside

◆ IopDeviceNodeClearFlag

◆ IopDeviceNodeClearProblem

◆ IopDeviceNodeClearUserFlag

◆ IopDeviceNodeHasFlag

◆ IopDeviceNodeHasProblem

◆ IopDeviceNodeHasUserFlag

◆ IopDeviceNodeSetFlag

◆ IopDeviceNodeSetProblem

◆ IopDeviceNodeSetUserFlag

◆ IopFreeMdlFromLookaside

◆ IopInitDeviceTreeTraverseContext

◆ IopIsValidPhysicalDeviceObject

◆ IOTRACE

◆ IsIrpSynchronous

◆ RD_FSCTL_FAILED

◆ RD_GUID_CONVERT_FAILED

◆ RD_NO_RAMDISK_DRIVER

◆ RD_NO_XIPROM_DESCRIPTOR

◆ RD_SYMLINK_CREATE_FAILED

◆ RD_SYSROOT_INIT_FAILED

Typedef Documentation

◆ COMPLETION_PACKET_TYPE

◆ DEVICE_ACTION

◆ DEVICETREE_TRAVERSE_CONTEXT

◆ DEVICETREE_TRAVERSE_ROUTINE

◆ DRIVER_INFORMATION

◆ DRIVER_REINIT_ITEM

◆ DUMMY_FILE_OBJECT

◆ ERROR_LOG_ENTRY

◆ EXTENDED_IO_REMOVE_LOCK

◆ FILE_OBJECT_EXTENSION

◆ FS_CHANGE_NOTIFY_ENTRY

◆ IO_BUS_TYPE_GUID_LIST

◆ IO_INTERRUPT

◆ IO_UNLOAD_SAFE_COMPLETION_CONTEXT

◆ IO_WORKITEM

◆ IOP_DEVICE_LIST_OPERATION

◆ IOP_MINI_COMPLETION_PACKET

◆ IOP_TRANSFER_TYPE

◆ OPEN_PACKET

◆ PCOMPLETION_PACKET_TYPE

◆ PDEVICETREE_TRAVERSE_CONTEXT

◆ PDRIVER_INFORMATION

◆ PDRIVER_REINIT_ITEM

◆ PDUMMY_FILE_OBJECT

◆ PERROR_LOG_ENTRY

◆ PEXTENDED_IO_REMOVE_LOCK

◆ PFILE_OBJECT_EXTENSION

◆ PFS_CHANGE_NOTIFY_ENTRY

◆ PIO_BUS_TYPE_GUID_LIST

◆ PIO_INTERRUPT

◆ PIO_UNLOAD_SAFE_COMPLETION_CONTEXT

◆ PIOP_DEVICE_LIST_OPERATION

◆ PIOP_MINI_COMPLETION_PACKET

◆ PIOP_TRANSFER_TYPE

◆ POPEN_PACKET

◆ PRESERVE_IRP_ALLOCATOR

◆ PSECURITY_DESCRIPTOR_TYPE

◆ PSHUTDOWN_ENTRY

◆ RESERVE_IRP_ALLOCATOR