io.h File Reference

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

Include dependency graph for io.h:

Go to the source code of this file.

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	_BOOT_DRIVER_NODE
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 _BOOT_DRIVER_NODE	BOOT_DRIVER_NODE
typedef struct _BOOT_DRIVER_NODE *	PBOOT_DRIVER_NODE
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 }

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. More...
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	PnpRootCreateDevice (IN PUNICODE_STRING ServiceName, IN OPTIONAL PDRIVER_OBJECT DriverObject, OUT PDEVICE_OBJECT *PhysicalDeviceObject, OUT OPTIONAL PUNICODE_STRING FullInstancePath)
NTSTATUS	PnpRootRegisterDevice (IN PDEVICE_OBJECT DeviceObject)
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. More...
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 NTAPI	IopFetchConfigurationInformation (OUT PWSTR *SymbolicLinkList, IN GUID Guid, IN ULONG ExpectedInterfaces, IN PULONG Interfaces)
VOID NTAPI	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. More...
NTSTATUS	PiPerformSyncDeviceAction (_In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_ACTION Action)
	Perfom a device operation synchronously via PiQueueDeviceAction. More...
VOID	PiNotifyDeviceInterfaceChange (_In_ LPCGUID Event, _In_ LPCGUID InterfaceClassGuid, _In_ PUNICODE_STRING SymbolicLinkName)
	Delivers the event to all drivers subscribed to EventCategoryDeviceInterfaceChange. More...
VOID	PiNotifyHardwareProfileChange (_In_ LPCGUID Event)
	Delivers the event to all drivers subscribed to EventCategoryHardwareProfileChange PnP event. More...
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. More...
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	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)

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

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

Definition at line 129 of file io.h.

IoGetDrvObjExtension

#define IoGetDrvObjExtension

(

DriverObject

)

Value:

((PEXTENDED_DRIVER_EXTENSION)                       \
     (DriverObject->DriverExtension))                   \

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

BOOT_DRIVER_NODE

typedef struct _BOOT_DRIVER_NODE BOOT_DRIVER_NODE

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

PBOOT_DRIVER_NODE

typedef struct _BOOT_DRIVER_NODE * PBOOT_DRIVER_NODE

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

Definition at line 536 of file io.h.

{
    PiActionEnumDeviceTree,
    PiActionEnumRootDevices,
    PiActionResetDevice,
    PiActionAddBootDevices,
    PiActionStartDevice
} 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 524 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 2510 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 2495 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 657 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;

#if !defined(_WINKD_) && defined(KDBG)
    /* Read KDB Data */
    KdbInit();

    /* I/O is now setup for disk access, so phase 3 */
    KdInitSystem(3, LoaderBlock);
#endif

    /* 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 2449 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 1106 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 2177 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(), 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 79 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 1354 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 1245 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 = 0, ChildKeyIndex3 = 0;
   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;

      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;

          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);
}