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

Include dependency graph for io.h:

Classes
struct	_FILE_OBJECT_EXTENSION

struct	_IOP_MINI_COMPLETION_PACKET

struct	_IO_UNLOAD_SAFE_COMPLETION_CONTEXT

struct	_IO_WORKITEM

struct	_IO_INTERRUPT

struct	_ERROR_LOG_ENTRY

struct	_EXTENDED_IO_REMOVE_LOCK

struct	_DUMMY_FILE_OBJECT

struct	_OPEN_PACKET

struct	_LOAD_UNLOAD_PARAMS

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

typedef struct _LOAD_UNLOAD_PARAMS *	PLOAD_UNLOAD_PARAMS

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

Enumerations
enum	_IOP_DEVICE_LIST_OPERATION { IopRemove, IopAdd }

enum	_IOP_TRANSFER_TYPE { IopReadTransfer, IopWriteTransfer, IopOtherTransfer }

enum	_COMPLETION_PACKET_TYPE { IopCompletionPacketIrp, IopCompletionPacketMini, IopCompletionPacketQuota }

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)

VOID	IopInitPnpNotificationImplementation (VOID)

VOID	IopNotifyPlugPlayNotification (IN PDEVICE_OBJECT DeviceObject, IN IO_NOTIFICATION_EVENT_CATEGORY EventCategory, IN LPCGUID Event, IN PVOID EventCategoryData1, IN PVOID EventCategoryData2)

NTSTATUS	IopGetSystemPowerDeviceObject (IN PDEVICE_OBJECT *DeviceObject)

PDEVICE_NODE NTAPI	PipAllocateDeviceNode (IN PDEVICE_OBJECT PhysicalDeviceObject)

NTSTATUS	IopCreateDeviceNode (IN PDEVICE_NODE ParentNode, IN PDEVICE_OBJECT PhysicalDeviceObject, IN PUNICODE_STRING ServiceName, OUT PDEVICE_NODE *DeviceNode)

NTSTATUS	IopFreeDeviceNode (IN PDEVICE_NODE DeviceNode)

NTSTATUS NTAPI	IopQueryDeviceCapabilities (PDEVICE_NODE DeviceNode, PDEVICE_CAPABILITIES DeviceCaps)

NTSTATUS NTAPI	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	IopActionConfigureChildServices (IN PDEVICE_NODE DeviceNode, IN PVOID Context)

NTSTATUS	IopActionInitChildServices (IN PDEVICE_NODE DeviceNode, IN PVOID Context)

NTSTATUS	IopEnumerateDevice (IN PDEVICE_OBJECT DeviceObject)

NTSTATUS	IoCreateDriverList (VOID)

NTSTATUS	IoDestroyDriverList (VOID)

NTSTATUS	IopInitPlugPlayEvents (VOID)

NTSTATUS	IopQueueTargetDeviceEvent (const GUID *Guid, PUNICODE_STRING DeviceIds)

NTSTATUS	IopInitializePnpServices (IN PDEVICE_NODE DeviceNode)

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

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 NTAPI	IopReadyDeviceObjects (IN PDRIVER_OBJECT Driver)

NTSTATUS FASTCALL	IopInitializeDevice (IN PDEVICE_NODE DeviceNode, IN PDRIVER_OBJECT DriverObject)

NTSTATUS	IopStartDevice (IN PDEVICE_NODE DeviceNode)

NTSTATUS	IopStopDevice (IN PDEVICE_NODE DeviceNode)

NTSTATUS	IopRemoveDevice (IN PDEVICE_NODE DeviceNode)

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	IoGetRelatedTargetDevice (IN PFILE_OBJECT FileObject, OUT PDEVICE_OBJECT *DeviceObject)

VOID NTAPI	IopUnloadDevice (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)

NTSTATUS NTAPI	IopCreateDriver (IN PUNICODE_STRING DriverName OPTIONAL, IN PDRIVER_INITIALIZE InitializationFunction, IN PUNICODE_STRING RegistryPath OPTIONAL, IN PCUNICODE_STRING ServiceName, IN PLDR_DATA_TABLE_ENTRY ModuleObject OPTIONAL, OUT PDRIVER_OBJECT *pDriverObject)

VOID NTAPI	IopDeleteDriver (IN PVOID ObjectBody)

NTSTATUS FASTCALL	IopGetDriverObject (OUT PDRIVER_OBJECT *DriverObject, IN PUNICODE_STRING ServiceName, IN BOOLEAN FileSystem)

NTSTATUS FASTCALL	IopLoadServiceModule (IN PUNICODE_STRING ServiceName, OUT PLDR_DATA_TABLE_ENTRY *ModuleObject)

NTSTATUS NTAPI	IopLoadUnloadDriver (_In_opt_ PCUNICODE_STRING RegistryPath, _Inout_ PDRIVER_OBJECT *DriverObject)

NTSTATUS FASTCALL	IopInitializeDriverModule (IN PDEVICE_NODE DeviceNode, IN PLDR_DATA_TABLE_ENTRY ModuleObject, IN PUNICODE_STRING ServiceName, IN BOOLEAN FileSystemDriver, OUT PDRIVER_OBJECT *DriverObject)

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)

Macro Definition Documentation

#define _IO_DEBUG_ 0x00

Definition at line 14 of file io.h.

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

Definition at line 53 of file io.h.

Referenced by IopCreateDeviceKeyPath(), IopUpdateControlKeyWithResources(), and PipCallDriverAddDevice().

#define IO_API_DEBUG 0x04

#define IO_CTL_DEBUG 0x08

Definition at line 22 of file io.h.

Referenced by IopDeviceFsIoControl().

#define IO_FILE_DEBUG 0x02

Definition at line 20 of file io.h.

Referenced by IoCreateStreamFileObjectEx(), IoCreateStreamFileObjectLite(), IoFastQueryNetworkAttributes(), IopCloseFile(), IopCreateFile(), IopDeleteFile(), IopGetSetSecurityObject(), IopParseDevice(), IopQueryAttributesFile(), and IopQueryNameInternal().

#define IO_IRP_DEBUG 0x01

Definition at line 19 of file io.h.

Referenced by IoAllocateIrp(), IoBuildAsynchronousFsdRequest(), IoBuildDeviceIoControlRequest(), IoCancelIrp(), IoCancelThreadIo(), IofCompleteRequest(), IoFreeIrp(), IoInitializeIrp(), IoMakeAssociatedIrp(), IopCleanupIrp(), IopCompleteRequest(), IopDisassociateThreadIrp(), IoQueueThreadIrp(), and IoReuseIrp().

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

Definition at line 58 of file io.h.

#define IoGetDevObjExtension ( DeviceObject )

Value:

((PEXTENDED_DEVOBJ_EXTENSION) \

(DeviceObject->DeviceObjectExtension)) \

PEXTENDED_DEVOBJ_EXTENSION

struct _EXTENDED_DEVOBJ_EXTENSION * PEXTENDED_DEVOBJ_EXTENSION

DeviceObject

IN PDEVICE_OBJECT DeviceObject

Definition: fatprocs.h:1560

Definition at line 125 of file io.h.

Referenced by IoDeleteDevice(), IoDetachDevice(), IoGetDiskDeviceObject(), IoGetLowerDeviceObject(), IopAttachDeviceToDeviceStackSafe(), IopCheckDeviceAndDriver(), IopDecrementDeviceObjectRef(), IopDereferenceDeviceObject(), IopGetLowestDevice(), IopMountInitializeVpb(), IopStartNextPacket(), IopStartNextPacketByKey(), IopStartNextPacketByKeyEx(), IopUnloadDevice(), IopUnloadDriver(), IoSetStartIoAttributes(), IoStartNextPacket(), IoStartNextPacketByKey(), IoStartPacket(), PopGetDope(), and PoRemoveVolumeDevice().

#define IoGetDrvObjExtension ( DriverObject )

Value:

((PEXTENDED_DRIVER_EXTENSION) \

(DriverObject->DriverExtension)) \

_DRIVER_OBJECT::DriverExtension

PDRIVER_EXTENSION DriverExtension

Definition: iotypes.h:2173

DriverObject

static PDRIVER_OBJECT DriverObject

Definition: template.c:42

PEXTENDED_DRIVER_EXTENSION

struct _EXTENDED_DRIVER_EXTENSION * PEXTENDED_DRIVER_EXTENSION

Definition at line 132 of file io.h.

Referenced by IoAllocateDriverObjectExtension(), IoGetDriverObjectExtension(), and IopDeleteDriver().

#define IOP_CREATE_FILE_OBJECT_EXTENSION 0x02

Definition at line 93 of file io.h.

Referenced by IoCreateFileSpecifyDeviceObjectHint(), and IopParseDevice().

#define IOP_MAX_REPARSE_TRAVERSAL 0x20

Definition at line 87 of file io.h.

Referenced by IopParseDevice().

#define IOP_USE_TOP_LEVEL_DEVICE_HINT 0x01

Definition at line 92 of file io.h.

Referenced by IoCreateFileSpecifyDeviceObjectHint(), and IopParseDevice().

#define IopAllocateMdlFromLookaside ObpAllocateObjectCreateInfoBuffer

Definition at line 108 of file io.h.

Referenced by IoAllocateMdl().

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

Definition at line 151 of file io.h.

Referenced by IopAssignDeviceResources().

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

Definition at line 205 of file io.h.

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

Definition at line 178 of file io.h.

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

Definition at line 160 of file io.h.

Referenced by IopActionInitChildServices(), and IopActionInterrogateDeviceStack().

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

Definition at line 214 of file io.h.

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

Definition at line 187 of file io.h.

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

Definition at line 142 of file io.h.

Referenced by IoInvalidateDeviceState(), IopActionConfigureChildServices(), IopActionInitChildServices(), IopActionInterrogateDeviceStack(), IopAssignDeviceResources(), IopCreateDeviceNode(), IopInitializeDevice(), and IoReportDetectedDevice().

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

Definition at line 196 of file io.h.

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

Definition at line 169 of file io.h.

#define IopFreeMdlFromLookaside ObpFreeCapturedAttributes

Definition at line 110 of file io.h.

Referenced by IoFreeMdl().

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

Value:

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

Definition at line 225 of file io.h.

Referenced by IopEnumerateDevice(), IopInitializePnpServices(), and PopSetSystemPowerState().

#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 238 of file io.h.

Referenced by IoOpenDeviceRegistryKey(), IoReportTargetDeviceChange(), and IoReportTargetDeviceChangeAsynchronous().

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

Definition at line 47 of file io.h.

Referenced by IoAllocateIrp(), IoBuildAsynchronousFsdRequest(), IoBuildDeviceIoControlRequest(), IoCancelIrp(), IoCancelThreadIo(), IoCreateStreamFileObjectEx(), IoCreateStreamFileObjectLite(), IoFastQueryNetworkAttributes(), IofCompleteRequest(), IoFreeIrp(), IoInitializeIrp(), IoMakeAssociatedIrp(), IoPageRead(), IopCleanupAfterException(), IopCleanupIrp(), IopCloseFile(), IopCompleteRequest(), IopCreateFile(), IopDeleteFile(), IopDeviceFsIoControl(), IopDisassociateThreadIrp(), IopFinalizeAsynchronousIo(), IopGetSetSecurityObject(), IopParseDevice(), IopPerformSynchronousRequest(), IopQueryAttributesFile(), IopQueryDeviceInformation(), IopQueryNameInternal(), IoQueueThreadIrp(), IoReuseIrp(), IoSetInformation(), IoSynchronousPageWrite(), NtCancelIoFile(), NtDeleteFile(), NtFlushBuffersFile(), NtLockFile(), NtNotifyChangeDirectoryFile(), NtQueryDirectoryFile(), NtQueryInformationFile(), NtQueryVolumeInformationFile(), NtReadFile(), NtSetInformationFile(), NtSetVolumeInformationFile(), NtUnlockFile(), and NtWriteFile().

#define IsIrpSynchronous	(	Irp,
		FileObject
	)

Value:

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

Definition at line 116 of file io.h.

Referenced by IopCompleteRequest().

#define RD_FSCTL_FAILED 3

Definition at line 74 of file io.h.

Referenced by IopStartRamdisk().

#define RD_GUID_CONVERT_FAILED 4

Definition at line 78 of file io.h.

Referenced by IopStartRamdisk().

#define RD_NO_RAMDISK_DRIVER 2

Definition at line 70 of file io.h.

Referenced by IopStartRamdisk().

#define RD_NO_XIPROM_DESCRIPTOR 1

Definition at line 66 of file io.h.

Referenced by IopStartRamdisk().

#define RD_SYMLINK_CREATE_FAILED 5

Definition at line 82 of file io.h.

Referenced by IopStartRamdisk().

Typedef Documentation

typedef struct _BOOT_DRIVER_NODE BOOT_DRIVER_NODE

typedef enum _COMPLETION_PACKET_TYPE COMPLETION_PACKET_TYPE

typedef struct _DEVICETREE_TRAVERSE_CONTEXT DEVICETREE_TRAVERSE_CONTEXT

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

Definition at line 486 of file io.h.

typedef struct _DRIVER_INFORMATION DRIVER_INFORMATION

typedef struct _DRIVER_REINIT_ITEM DRIVER_REINIT_ITEM

typedef struct _DUMMY_FILE_OBJECT DUMMY_FILE_OBJECT

typedef struct _ERROR_LOG_ENTRY ERROR_LOG_ENTRY

typedef struct _EXTENDED_IO_REMOVE_LOCK EXTENDED_IO_REMOVE_LOCK

typedef struct _FILE_OBJECT_EXTENSION FILE_OBJECT_EXTENSION

typedef struct _FS_CHANGE_NOTIFY_ENTRY FS_CHANGE_NOTIFY_ENTRY

typedef struct _IO_BUS_TYPE_GUID_LIST IO_BUS_TYPE_GUID_LIST

typedef struct _IO_INTERRUPT IO_INTERRUPT

typedef struct _IO_UNLOAD_SAFE_COMPLETION_CONTEXT IO_UNLOAD_SAFE_COMPLETION_CONTEXT

typedef struct _IO_WORKITEM IO_WORKITEM

typedef enum _IOP_DEVICE_LIST_OPERATION IOP_DEVICE_LIST_OPERATION

typedef struct _IOP_MINI_COMPLETION_PACKET IOP_MINI_COMPLETION_PACKET

typedef enum _IOP_TRANSFER_TYPE IOP_TRANSFER_TYPE

typedef struct _LOAD_UNLOAD_PARAMS LOAD_UNLOAD_PARAMS

typedef struct _OPEN_PACKET OPEN_PACKET

typedef struct _BOOT_DRIVER_NODE * PBOOT_DRIVER_NODE

typedef enum _COMPLETION_PACKET_TYPE * PCOMPLETION_PACKET_TYPE

typedef struct _DEVICETREE_TRAVERSE_CONTEXT * PDEVICETREE_TRAVERSE_CONTEXT

typedef struct _DRIVER_INFORMATION * PDRIVER_INFORMATION

typedef struct _DRIVER_REINIT_ITEM * PDRIVER_REINIT_ITEM

typedef struct _DUMMY_FILE_OBJECT * PDUMMY_FILE_OBJECT

typedef struct _ERROR_LOG_ENTRY * PERROR_LOG_ENTRY

typedef struct _EXTENDED_IO_REMOVE_LOCK * PEXTENDED_IO_REMOVE_LOCK

typedef struct _FILE_OBJECT_EXTENSION * PFILE_OBJECT_EXTENSION

typedef struct _FS_CHANGE_NOTIFY_ENTRY * PFS_CHANGE_NOTIFY_ENTRY

typedef struct _IO_BUS_TYPE_GUID_LIST * PIO_BUS_TYPE_GUID_LIST

typedef struct _IO_INTERRUPT * PIO_INTERRUPT

typedef struct _IO_UNLOAD_SAFE_COMPLETION_CONTEXT * PIO_UNLOAD_SAFE_COMPLETION_CONTEXT

typedef enum _IOP_DEVICE_LIST_OPERATION * PIOP_DEVICE_LIST_OPERATION

typedef struct _IOP_MINI_COMPLETION_PACKET * PIOP_MINI_COMPLETION_PACKET

typedef enum _IOP_TRANSFER_TYPE * PIOP_TRANSFER_TYPE

typedef struct _LOAD_UNLOAD_PARAMS * PLOAD_UNLOAD_PARAMS

typedef struct _OPEN_PACKET * POPEN_PACKET

typedef struct _RESERVE_IRP_ALLOCATOR * PRESERVE_IRP_ALLOCATOR

typedef struct _SHUTDOWN_ENTRY * PSHUTDOWN_ENTRY

typedef struct _RESERVE_IRP_ALLOCATOR RESERVE_IRP_ALLOCATOR

typedef struct _SHUTDOWN_ENTRY SHUTDOWN_ENTRY

Enumeration Type Documentation

enum _COMPLETION_PACKET_TYPE

Enumerator
IopCompletionPacketIrp
IopCompletionPacketMini
IopCompletionPacketQuota

Definition at line 265 of file io.h.

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

enum _IOP_DEVICE_LIST_OPERATION

Enumerator
IopRemove
IopAdd

Definition at line 246 of file io.h.

 {
     IopRemove,
     IopAdd
 } IOP_DEVICE_LIST_OPERATION, *PIOP_DEVICE_LIST_OPERATION;

enum _IOP_TRANSFER_TYPE

Enumerator
IopReadTransfer
IopWriteTransfer
IopOtherTransfer

Definition at line 255 of file io.h.

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

Function Documentation

VOID NTAPI IoCancelThreadIo ( IN PETHREAD Thread )

Definition at line 1146 of file irp.c.

Referenced by PspExitThread().

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

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

Definition at line 2511 of file file.c.

Referenced by FsRtlInsertPerFileObjectContext(), and FsRtlPTeardownPerFileObjectContexts().

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

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

Definition at line 26 of file util.c.

Referenced by ObReferenceFileObjectForWrite().

 {
     /* 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;
 }

NTSTATUS IoCreateDriverList ( VOID )

NTSTATUS IoDestroyDriverList ( VOID )

PVOID NTAPI IoGetFileObjectFilterContext ( IN PFILE_OBJECT FileObject )

Definition at line 2496 of file file.c.

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

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

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

Definition at line 1415 of file device.c.

Referenced by FsRtlNotifyVolumeEvent(), IopNotifyPlugPlayNotification(), and NtSetVolumeInformationFile().

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

VOID IoInitCancelHandling ( VOID )

VOID NTAPI IoInitFileSystemImplementation ( VOID )

BOOLEAN NTAPI IoInitializeCrashDump ( IN HANDLE PageFileHandle )

Definition at line 656 of file iomgr.c.

Referenced by NtCreatePagingFile().

 {
     UNIMPLEMENTED;
     return FALSE;
 }

VOID IoInitShutdownNotification ( VOID )

BOOLEAN NTAPI IoInitSystem ( IN PLOADER_PARAMETER_BLOCK LoaderBlock )

Definition at line 470 of file iomgr.c.

Referenced by Phase1InitializationDiscard().

 {
     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);
     KeInitializeGuardedMutex(&PnpNotifyListLock);
     InitializeListHead(&IopDiskFileSystemQueueHead);
     InitializeListHead(&IopCdRomFileSystemQueueHead);
     InitializeListHead(&IopTapeFileSystemQueueHead);
     InitializeListHead(&IopNetworkFileSystemQueueHead);
     InitializeListHead(&DriverBootReinitListHead);
     InitializeListHead(&DriverReinitListHead);
     InitializeListHead(&PnpNotifyListHead);
     InitializeListHead(&ShutdownListHead);
     InitializeListHead(&LastChanceShutdownListHead);
     InitializeListHead(&IopFsNotifyChangeQueueHead);
     InitializeListHead(&IopErrorLogListHead);
     KeInitializeSpinLock(&IoStatisticsLock);
     KeInitializeSpinLock(&DriverReinitListLock);
     KeInitializeSpinLock(&DriverBootReinitListLock);
     KeInitializeSpinLock(&ShutdownListLock);
     KeInitializeSpinLock(&IopLogListLock);
 
     /* 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();
 
     /* 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;
     }
 
     /* Initialize PnP root relations */
     IopEnumerateDevice(IopRootDeviceNode->PhysicalDeviceObject);
 
 #ifndef _WINKD_
     /* Read KDB Data */
     KdbInit();
 
     /* I/O is now setup for disk access, so phase 3 */
     KdInitSystem(3, LoaderBlock);
 #endif
 
     /* Load services for devices found by PnP manager */
     IopInitializePnpServices(IopRootDeviceNode);
 
     /* 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;
 }

VOID NTAPI IoInitVpbImplementation ( VOID )

PVOID IoOpenFileOnDevice	(	IN PVOID	SymbolicLink,
		IN PWCHAR	Name
	)

PVOID IoOpenSymlink ( IN PVOID SymbolicLink )

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

Definition at line 67 of file irp.c.

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

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

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

Definition at line 2450 of file file.c.

Referenced by IopLockFileObject().

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

NTSTATUS IopActionConfigureChildServices	(	IN PDEVICE_NODE	DeviceNode,
		IN PVOID	Context
	)

Referenced by IopResetDevice(), and IoReportDetectedDevice().

NTSTATUS IopActionInitChildServices	(	IN PDEVICE_NODE	DeviceNode,
		IN PVOID	Context
	)

Referenced by IopResetDevice().

PIRP NTAPI IopAllocateIrpMustSucceed ( IN CCHAR StackSize )

Definition at line 716 of file irp.c.

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

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

PIRP NTAPI IopAllocateReserveIrp ( IN CCHAR StackSize )

Definition at line 573 of file irp.c.

Referenced by IoPageRead().

 {
     /* 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;
 }

NTSTATUS NTAPI IopAssignDeviceResources ( IN PDEVICE_NODE DeviceNode )

Definition at line 1060 of file pnpres.c.

Referenced by IopStartDevice(), and IoReportDetectedDevice().

 {
    NTSTATUS Status;
    ULONG ListSize;
 
    IopDeviceNodeSetFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
 
    Status = IopFilterResourceRequirements(DeviceNode);
    if (!NT_SUCCESS(Status))
        goto ByeBye;
 
    if (!DeviceNode->BootResources && !DeviceNode->ResourceRequirements)
    {
       DeviceNode->Flags |= DNF_NO_RESOURCE_REQUIRED;
       DeviceNode->Flags &= ~DNF_ASSIGNING_RESOURCES;
 
       /* No resource needed for this device */
       DeviceNode->ResourceList = NULL;
       DeviceNode->ResourceListTranslated = NULL;
 
       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;
 
    IopDeviceNodeSetFlag(DeviceNode, DNF_RESOURCE_ASSIGNED);
 
    IopDeviceNodeClearFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
 
    return STATUS_SUCCESS;
 
 ByeBye:
    if (DeviceNode->ResourceList)
    {
       ExFreePool(DeviceNode->ResourceList);
       DeviceNode->ResourceList = NULL;
    }
 
    DeviceNode->ResourceListTranslated = NULL;
 
    IopDeviceNodeClearFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
 
    return Status;
 }

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

Referenced by PipCallDriverAddDevice().

VOID IopBootLog	(	IN PUNICODE_STRING	DriverName,
		IN BOOLEAN	Success
	)

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

Definition at line 81 of file volume.c.

Referenced by IopParseDevice().

 {
     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;
         }
 
         /* 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;
 }

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

Definition at line 45 of file irp.c.

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

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

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

Definition at line 2178 of file file.c.

Referenced by IopCreateObjectTypes(), and IopDeleteFile().

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

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.

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

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

NTSTATUS NTAPI IopCreateArcNames ( IN PLOADER_PARAMETER_BLOCK LoaderBlock )

Definition at line 42 of file arcname.c.

Referenced by IoInitSystem().

 {
     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);
     RtlAnsiStringToUnicodeString(&IoArcHalDeviceName, &ArcString, TRUE);
 
     /* Create the global system partition name */
     sprintf(Buffer, "\\ArcName\\%s", LoaderBlock->ArcBootDeviceName);
     RtlInitAnsiString(&ArcString, Buffer);
     RtlAnsiStringToUnicodeString(&IoArcBootDeviceName, &ArcString, TRUE);
 
     /* 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 succeed but we didn't find boot device, try to browse Cds */
     if (NT_SUCCESS(Status) && !FoundBoot)
     {
         Status = IopCreateArcNamesCd(LoaderBlock);
     }
 
     /* Return success */
     return Status;
 }

NTSTATUS IopCreateDeviceNode	(	IN PDEVICE_NODE	ParentNode,
		IN PDEVICE_OBJECT	PhysicalDeviceObject,
		IN PUNICODE_STRING	ServiceName,
		OUT PDEVICE_NODE *	DeviceNode
	)

Referenced by IopInitializeBootDrivers(), IopInitializeBuiltinDriver(), IopLoadUnloadDriver(), and IoReportDetectedDevice().

NTSTATUS NTAPI IopCreateDriver	(	IN PUNICODE_STRING DriverName	OPTIONAL,
		IN PDRIVER_INITIALIZE	InitializationFunction,
		IN PUNICODE_STRING RegistryPath	OPTIONAL,
		IN PCUNICODE_STRING	ServiceName,
		IN PLDR_DATA_TABLE_ENTRY ModuleObject	OPTIONAL,
		OUT PDRIVER_OBJECT *	pDriverObject
	)

Definition at line 1426 of file driver.c.

Referenced by IoCreateDriver(), and IopInitializeDriverModule().

 {
     WCHAR NameBuffer[100];
     USHORT NameLength;
     UNICODE_STRING LocalDriverName;
     NTSTATUS Status;
     OBJECT_ATTRIBUTES ObjectAttributes;
     ULONG ObjectSize;
     PDRIVER_OBJECT DriverObject;
     UNICODE_STRING ServiceKeyName;
     HANDLE hDriver;
     ULONG i, RetryCount = 0;
 
 try_again:
     /* First, create a unique name for the driver if we don't have one */
     if (!DriverName)
     {
         /* Create a random name and set up the string */
         NameLength = (USHORT)swprintf(NameBuffer,
                                       DRIVER_ROOT_NAME L"%08u",
                                       KeTickCount.LowPart);
         LocalDriverName.Length = NameLength * sizeof(WCHAR);
         LocalDriverName.MaximumLength = LocalDriverName.Length + sizeof(UNICODE_NULL);
         LocalDriverName.Buffer = NameBuffer;
     }
     else
     {
         /* So we can avoid another code path, use a local var */
         LocalDriverName = *DriverName;
     }
 
     /* Initialize the Attributes */
     ObjectSize = sizeof(DRIVER_OBJECT) + sizeof(EXTENDED_DRIVER_EXTENSION);
     InitializeObjectAttributes(&ObjectAttributes,
                                &LocalDriverName,
                                OBJ_PERMANENT | OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                NULL,
                                NULL);
 
     /* Create the Object */
     Status = ObCreateObject(KernelMode,
                             IoDriverObjectType,
                             &ObjectAttributes,
                             KernelMode,
                             NULL,
                             ObjectSize,
                             0,
                             0,
                             (PVOID*)&DriverObject);
     if (!NT_SUCCESS(Status)) return Status;
 
     DPRINT("IopCreateDriver(): created DO %p\n", DriverObject);
 
     /* Set up the Object */
     RtlZeroMemory(DriverObject, ObjectSize);
     DriverObject->Type = IO_TYPE_DRIVER;
     DriverObject->Size = sizeof(DRIVER_OBJECT);
 
     /*
      * Check whether RegistryPath and ModuleObject are both NULL because
      * IoCreateDriver() was called to initialize a built-in driver.
      */
     if ((RegistryPath != NULL) || (ModuleObject != NULL))
         DriverObject->Flags = DRVO_LEGACY_DRIVER;
     else
         DriverObject->Flags = DRVO_BUILTIN_DRIVER;
 
     DriverObject->DriverExtension = (PDRIVER_EXTENSION)(DriverObject + 1);
     DriverObject->DriverExtension->DriverObject = DriverObject;
     DriverObject->DriverInit = InitializationFunction;
     DriverObject->DriverSection = ModuleObject;
     /* Loop all Major Functions */
     for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
     {
         /* Invalidate each function */
         DriverObject->MajorFunction[i] = IopInvalidDeviceRequest;
     }
 
     /* Set up the service key name buffer */
     ServiceKeyName.MaximumLength = ServiceName->Length + sizeof(UNICODE_NULL);
     ServiceKeyName.Buffer = ExAllocatePoolWithTag(NonPagedPool,
                                                   ServiceKeyName.MaximumLength,
                                                   TAG_IO);
     if (!ServiceKeyName.Buffer)
     {
         /* Fail */
         ObMakeTemporaryObject(DriverObject);
         ObDereferenceObject(DriverObject);
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
     /* Copy the name and set it in the driver extension */
     RtlCopyUnicodeString(&ServiceKeyName,
                          ServiceName);
     DriverObject->DriverExtension->ServiceKeyName = ServiceKeyName;
 
     /* Make a copy of the driver name to store in the driver object */
     DriverObject->DriverName.MaximumLength = LocalDriverName.Length;
     DriverObject->DriverName.Buffer = ExAllocatePoolWithTag(PagedPool,
                                                             DriverObject->DriverName.MaximumLength,
                                                             TAG_IO);
     if (!DriverObject->DriverName.Buffer)
     {
         /* Fail */
         ObMakeTemporaryObject(DriverObject);
         ObDereferenceObject(DriverObject);
         return STATUS_INSUFFICIENT_RESOURCES;
     }
 
     RtlCopyUnicodeString(&DriverObject->DriverName,
                          &LocalDriverName);
 
     /* Add the Object and get its handle */
     Status = ObInsertObject(DriverObject,
                             NULL,
                             FILE_READ_DATA,
                             0,
                             NULL,
                             &hDriver);
 
     /* Eliminate small possibility when this function is called more than
        once in a row, and KeTickCount doesn't get enough time to change */
     if (!DriverName && (Status == STATUS_OBJECT_NAME_COLLISION) && (RetryCount < 100))
     {
         RetryCount++;
         goto try_again;
     }
 
     if (!NT_SUCCESS(Status)) return Status;
 
     /* Now reference it */
     Status = ObReferenceObjectByHandle(hDriver,
                                        0,
                                        IoDriverObjectType,
                                        KernelMode,
                                        (PVOID*)&DriverObject,
                                        NULL);
 
     /* Close the extra handle */
     ZwClose(hDriver);
 
     if (!NT_SUCCESS(Status))
     {
         /* Fail */
         ObMakeTemporaryObject(DriverObject);
         ObDereferenceObject(DriverObject);
         return Status;
     }
 
     DriverObject->HardwareDatabase = &IopHardwareDatabaseKey;
     DriverObject->DriverStart = ModuleObject ? ModuleObject->DllBase : 0;
     DriverObject->DriverSize = ModuleObject ? ModuleObject->SizeOfImage : 0;
 
     /* Finally, call its init function */
     DPRINT("RegistryKey: %wZ\n", RegistryPath);
     DPRINT("Calling driver entrypoint at %p\n", InitializationFunction);
     Status = (*InitializationFunction)(DriverObject, RegistryPath);
     if (!NT_SUCCESS(Status))
     {
         /* If it didn't work, then kill the object */
         DPRINT1("'%wZ' initialization failed, status (0x%08lx)\n", DriverName, Status);
         DriverObject->DriverSection = NULL;
         ObMakeTemporaryObject(DriverObject);
         ObDereferenceObject(DriverObject);
         return Status;
     }
     else
     {
         /* Returns to caller the object */
         *pDriverObject = DriverObject;
     }
 
     /* We're going to say if we don't have any DOs from DriverEntry, then we're not legacy.
      * Other parts of the I/O manager depend on this behavior */
     if (!DriverObject->DeviceObject) DriverObject->Flags &= ~DRVO_LEGACY_DRIVER;
 
     /* Loop all Major Functions */
     for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
     {
         /*
          * Make sure the driver didn't set any dispatch entry point to NULL!
          * Doing so is illegal; drivers shouldn't touch entry points they
          * do not implement.
          */
 
         /* Check if it did so anyway */
         if (!DriverObject->MajorFunction[i])
         {
             /* Print a warning in the debug log */
             DPRINT1("Driver <%wZ> set DriverObject->MajorFunction[%lu] to NULL!\n",
                     &DriverObject->DriverName, i);
 
             /* Fix it up */
             DriverObject->MajorFunction[i] = IopInvalidDeviceRequest;
         }
     }
 
     /* Return the Status */
     return Status;
 }

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(), IopStoreSystemPartitionInformation(), and IoSetSystemPartition().

NTSTATUS NTAPI IopCreateVpb ( IN PDEVICE_OBJECT DeviceObject )

Definition at line 155 of file volume.c.

Referenced by IoCreateDevice(), and IoVerifyVolume().

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

VOID NTAPI IopDeleteDevice ( IN PVOID ObjectBody )

Definition at line 50 of file device.c.

Referenced by IopCreateObjectTypes().

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

VOID NTAPI IopDeleteDriver ( IN PVOID ObjectBody )

Definition at line 58 of file driver.c.

Referenced by IopCreateObjectTypes().

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

VOID NTAPI IopDeleteFile ( IN PVOID ObjectBody )

Definition at line 1360 of file file.c.

Referenced by IopCreateObjectTypes(), and IopParseDevice().

 {
     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)
         {
            ExFreePoolWithTag(FileObject->FileName.Buffer, TAG_IO_NAME);
            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);
         }
     }
 }

VOID NTAPI IopDeleteIoCompletion ( PVOID ObjectBody )

Definition at line 100 of file iocomp.c.

Referenced by IopCreateObjectTypes().

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

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

Definition at line 460 of file device.c.

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

 {
     /* 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);
     }
 }

VOID NTAPI IopDereferenceVpbAndFree ( IN PVPB Vpb )

Definition at line 183 of file volume.c.

Referenced by IopParseDevice(), and IoVerifyVolume().

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

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

Definition at line 1200 of file pnpres.c.

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

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

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

Definition at line 170 of file file.c.

Referenced by IopCompleteRequest(), and IopParseDevice().

 {
     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 mem 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 reserved */
         if (DataBuffer->Reserved)
         {
             RtlMoveMemory((PWSTR)((ULONG_PTR)NewBuffer + Length),
                           (PWSTR)((ULONG_PTR)FileObject->FileName.Buffer + FileObject->FileName.Length - DataBuffer->Reserved),
                           DataBuffer->Reserved);
         }
 
         /* Then, 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)
             {
                 ExFreePoolWithTag(FileObject->FileName.Buffer, TAG_IO_NAME);
             }
 
             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);
 }

NTSTATUS IopEnumerateDevice ( IN PDEVICE_OBJECT DeviceObject )

Definition at line 2509 of file pnpmgr.c.

Referenced by IoInitSystem(), and IoSynchronousInvalidateDeviceRelations().

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

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Enumeration Type Documentation

Function Documentation