#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	IopQueueTargetDeviceEvent (const GUID *Guid, PUNICODE_STRING DeviceIds)

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 NTAPI	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 2511 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 2496 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 649 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 465 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 2450 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 2178 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(), 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 78 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 124 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, 

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	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