/****************************************************************************** * I/O Manager Functions * ******************************************************************************/ $if (_WDMDDK_) /* * NTSTATUS * IoAcquireRemoveLock( * IN PIO_REMOVE_LOCK RemoveLock, * IN OPTIONAL PVOID Tag) */ #if DBG #define IoAcquireRemoveLock(RemoveLock, Tag) \ IoAcquireRemoveLockEx(RemoveLock, Tag, __FILE__, __LINE__, sizeof (IO_REMOVE_LOCK)) #else #define IoAcquireRemoveLock(RemoveLock, Tag) \ IoAcquireRemoveLockEx(RemoveLock, Tag, "", 1, sizeof (IO_REMOVE_LOCK)) #endif /* * VOID * IoAdjustPagingPathCount( * IN PLONG Count, * IN BOOLEAN Increment) */ #define IoAdjustPagingPathCount(_Count, \ _Increment) \ { \ if (_Increment) \ { \ InterlockedIncrement(_Count); \ } \ else \ { \ InterlockedDecrement(_Count); \ } \ } #if !defined(_M_AMD64) NTHALAPI VOID NTAPI READ_PORT_BUFFER_UCHAR( IN PUCHAR Port, IN PUCHAR Buffer, IN ULONG Count); NTHALAPI VOID NTAPI READ_PORT_BUFFER_ULONG( IN PULONG Port, IN PULONG Buffer, IN ULONG Count); NTHALAPI VOID NTAPI READ_PORT_BUFFER_USHORT( IN PUSHORT Port, IN PUSHORT Buffer, IN ULONG Count); NTHALAPI UCHAR NTAPI READ_PORT_UCHAR( IN PUCHAR Port); NTHALAPI ULONG NTAPI READ_PORT_ULONG( IN PULONG Port); NTHALAPI USHORT NTAPI READ_PORT_USHORT( IN PUSHORT Port); NTKERNELAPI VOID NTAPI READ_REGISTER_BUFFER_UCHAR( IN PUCHAR Register, IN PUCHAR Buffer, IN ULONG Count); NTKERNELAPI VOID NTAPI READ_REGISTER_BUFFER_ULONG( IN PULONG Register, IN PULONG Buffer, IN ULONG Count); NTKERNELAPI VOID NTAPI READ_REGISTER_BUFFER_USHORT( IN PUSHORT Register, IN PUSHORT Buffer, IN ULONG Count); NTKERNELAPI UCHAR NTAPI READ_REGISTER_UCHAR( IN PUCHAR Register); NTKERNELAPI ULONG NTAPI READ_REGISTER_ULONG( IN PULONG Register); NTKERNELAPI USHORT NTAPI READ_REGISTER_USHORT( IN PUSHORT Register); NTHALAPI VOID NTAPI WRITE_PORT_BUFFER_UCHAR( IN PUCHAR Port, IN PUCHAR Buffer, IN ULONG Count); NTHALAPI VOID NTAPI WRITE_PORT_BUFFER_ULONG( IN PULONG Port, IN PULONG Buffer, IN ULONG Count); NTHALAPI VOID NTAPI WRITE_PORT_BUFFER_USHORT( IN PUSHORT Port, IN PUSHORT Buffer, IN ULONG Count); NTHALAPI VOID NTAPI WRITE_PORT_UCHAR( IN PUCHAR Port, IN UCHAR Value); NTHALAPI VOID NTAPI WRITE_PORT_ULONG( IN PULONG Port, IN ULONG Value); NTHALAPI VOID NTAPI WRITE_PORT_USHORT( IN PUSHORT Port, IN USHORT Value); NTKERNELAPI VOID NTAPI WRITE_REGISTER_BUFFER_UCHAR( IN PUCHAR Register, IN PUCHAR Buffer, IN ULONG Count); NTKERNELAPI VOID NTAPI WRITE_REGISTER_BUFFER_ULONG( IN PULONG Register, IN PULONG Buffer, IN ULONG Count); NTKERNELAPI VOID NTAPI WRITE_REGISTER_BUFFER_USHORT( IN PUSHORT Register, IN PUSHORT Buffer, IN ULONG Count); NTKERNELAPI VOID NTAPI WRITE_REGISTER_UCHAR( IN PUCHAR Register, IN UCHAR Value); NTKERNELAPI VOID NTAPI WRITE_REGISTER_ULONG( IN PULONG Register, IN ULONG Value); NTKERNELAPI VOID NTAPI WRITE_REGISTER_USHORT( IN PUSHORT Register, IN USHORT Value); #else FORCEINLINE VOID READ_PORT_BUFFER_UCHAR( IN PUCHAR Port, IN PUCHAR Buffer, IN ULONG Count) { __inbytestring((USHORT)(ULONG_PTR)Port, Buffer, Count); } FORCEINLINE VOID READ_PORT_BUFFER_ULONG( IN PULONG Port, IN PULONG Buffer, IN ULONG Count) { __indwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count); } FORCEINLINE VOID READ_PORT_BUFFER_USHORT( IN PUSHORT Port, IN PUSHORT Buffer, IN ULONG Count) { __inwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count); } FORCEINLINE UCHAR READ_PORT_UCHAR( IN PUCHAR Port) { return __inbyte((USHORT)(ULONG_PTR)Port); } FORCEINLINE ULONG READ_PORT_ULONG( IN PULONG Port) { return __indword((USHORT)(ULONG_PTR)Port); } FORCEINLINE USHORT READ_PORT_USHORT( IN PUSHORT Port) { return __inword((USHORT)(ULONG_PTR)Port); } FORCEINLINE VOID READ_REGISTER_BUFFER_UCHAR( IN PUCHAR Register, IN PUCHAR Buffer, IN ULONG Count) { __movsb(Register, Buffer, Count); } FORCEINLINE VOID READ_REGISTER_BUFFER_ULONG( IN PULONG Register, IN PULONG Buffer, IN ULONG Count) { __movsd(Register, Buffer, Count); } FORCEINLINE VOID READ_REGISTER_BUFFER_USHORT( IN PUSHORT Register, IN PUSHORT Buffer, IN ULONG Count) { __movsw(Register, Buffer, Count); } FORCEINLINE UCHAR READ_REGISTER_UCHAR( IN volatile UCHAR *Register) { return *Register; } FORCEINLINE ULONG READ_REGISTER_ULONG( IN volatile ULONG *Register) { return *Register; } FORCEINLINE USHORT READ_REGISTER_USHORT( IN volatile USHORT *Register) { return *Register; } FORCEINLINE VOID WRITE_PORT_BUFFER_UCHAR( IN PUCHAR Port, IN PUCHAR Buffer, IN ULONG Count) { __outbytestring((USHORT)(ULONG_PTR)Port, Buffer, Count); } FORCEINLINE VOID WRITE_PORT_BUFFER_ULONG( IN PULONG Port, IN PULONG Buffer, IN ULONG Count) { __outdwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count); } FORCEINLINE VOID WRITE_PORT_BUFFER_USHORT( IN PUSHORT Port, IN PUSHORT Buffer, IN ULONG Count) { __outwordstring((USHORT)(ULONG_PTR)Port, Buffer, Count); } FORCEINLINE VOID WRITE_PORT_UCHAR( IN PUCHAR Port, IN UCHAR Value) { __outbyte((USHORT)(ULONG_PTR)Port, Value); } FORCEINLINE VOID WRITE_PORT_ULONG( IN PULONG Port, IN ULONG Value) { __outdword((USHORT)(ULONG_PTR)Port, Value); } FORCEINLINE VOID WRITE_PORT_USHORT( IN PUSHORT Port, IN USHORT Value) { __outword((USHORT)(ULONG_PTR)Port, Value); } FORCEINLINE VOID WRITE_REGISTER_BUFFER_UCHAR( IN PUCHAR Register, IN PUCHAR Buffer, IN ULONG Count) { LONG Synch; __movsb(Register, Buffer, Count); InterlockedOr(&Synch, 1); } FORCEINLINE VOID WRITE_REGISTER_BUFFER_ULONG( IN PULONG Register, IN PULONG Buffer, IN ULONG Count) { LONG Synch; __movsd(Register, Buffer, Count); InterlockedOr(&Synch, 1); } FORCEINLINE VOID WRITE_REGISTER_BUFFER_USHORT( IN PUSHORT Register, IN PUSHORT Buffer, IN ULONG Count) { LONG Synch; __movsw(Register, Buffer, Count); InterlockedOr(&Synch, 1); } FORCEINLINE VOID WRITE_REGISTER_UCHAR( IN volatile UCHAR *Register, IN UCHAR Value) { LONG Synch; *Register = Value; InterlockedOr(&Synch, 1); } FORCEINLINE VOID WRITE_REGISTER_ULONG( IN volatile ULONG *Register, IN ULONG Value) { LONG Synch; *Register = Value; InterlockedOr(&Synch, 1); } FORCEINLINE VOID WRITE_REGISTER_USHORT( IN volatile USHORT *Register, IN USHORT Value) { LONG Sync; *Register = Value; InterlockedOr(&Sync, 1); } #endif #if defined(USE_DMA_MACROS) && !defined(_NTHAL_) && \ (defined(_NTDDK_) || defined(_NTDRIVER_)) || defined(_WDM_INCLUDED_) #define DMA_MACROS_DEFINED _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) FORCEINLINE NTSTATUS IoAllocateAdapterChannel( _In_ PDMA_ADAPTER DmaAdapter, _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG NumberOfMapRegisters, _In_ PDRIVER_CONTROL ExecutionRoutine, _In_ PVOID Context) { PALLOCATE_ADAPTER_CHANNEL AllocateAdapterChannel; AllocateAdapterChannel = *(DmaAdapter)->DmaOperations->AllocateAdapterChannel; ASSERT(AllocateAdapterChannel); return AllocateAdapterChannel(DmaAdapter, DeviceObject, NumberOfMapRegisters, ExecutionRoutine, Context); } FORCEINLINE BOOLEAN NTAPI IoFlushAdapterBuffers( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ PVOID MapRegisterBase, _In_ PVOID CurrentVa, _In_ ULONG Length, _In_ BOOLEAN WriteToDevice) { PFLUSH_ADAPTER_BUFFERS FlushAdapterBuffers; FlushAdapterBuffers = *(DmaAdapter)->DmaOperations->FlushAdapterBuffers; ASSERT(FlushAdapterBuffers); return FlushAdapterBuffers(DmaAdapter, Mdl, MapRegisterBase, CurrentVa, Length, WriteToDevice); } FORCEINLINE VOID NTAPI IoFreeAdapterChannel( _In_ PDMA_ADAPTER DmaAdapter) { PFREE_ADAPTER_CHANNEL FreeAdapterChannel; FreeAdapterChannel = *(DmaAdapter)->DmaOperations->FreeAdapterChannel; ASSERT(FreeAdapterChannel); FreeAdapterChannel(DmaAdapter); } FORCEINLINE VOID NTAPI IoFreeMapRegisters( _In_ PDMA_ADAPTER DmaAdapter, _In_ PVOID MapRegisterBase, _In_ ULONG NumberOfMapRegisters) { PFREE_MAP_REGISTERS FreeMapRegisters; FreeMapRegisters = *(DmaAdapter)->DmaOperations->FreeMapRegisters; ASSERT(FreeMapRegisters); FreeMapRegisters(DmaAdapter, MapRegisterBase, NumberOfMapRegisters); } FORCEINLINE PHYSICAL_ADDRESS NTAPI IoMapTransfer( _In_ PDMA_ADAPTER DmaAdapter, _In_ PMDL Mdl, _In_ PVOID MapRegisterBase, _In_ PVOID CurrentVa, _Inout_ PULONG Length, _In_ BOOLEAN WriteToDevice) { PMAP_TRANSFER MapTransfer; MapTransfer = *(DmaAdapter)->DmaOperations->MapTransfer; ASSERT(MapTransfer); return MapTransfer(DmaAdapter, Mdl, MapRegisterBase, CurrentVa, Length, WriteToDevice); } #endif $endif (_WDMDDK_) $if (_NTDDK_) /* * VOID IoAssignArcName( * IN PUNICODE_STRING ArcName, * IN PUNICODE_STRING DeviceName); */ #define IoAssignArcName(_ArcName, _DeviceName) ( \ IoCreateSymbolicLink((_ArcName), (_DeviceName))) /* * VOID * IoDeassignArcName( * IN PUNICODE_STRING ArcName) */ #define IoDeassignArcName IoDeleteSymbolicLink FORCEINLINE VOID NTAPI IoInitializeDriverCreateContext( PIO_DRIVER_CREATE_CONTEXT DriverContext) { RtlZeroMemory(DriverContext, sizeof(IO_DRIVER_CREATE_CONTEXT)); DriverContext->Size = sizeof(IO_DRIVER_CREATE_CONTEXT); } $endif (_NTDDK_) $if (_NTIFS_) #define IoIsFileOpenedExclusively(FileObject) ( \ (BOOLEAN) !( \ (FileObject)->SharedRead || \ (FileObject)->SharedWrite || \ (FileObject)->SharedDelete \ ) \ ) #if (NTDDI_VERSION == NTDDI_WIN2K) NTKERNELAPI NTSTATUS NTAPI IoRegisterFsRegistrationChangeEx( _In_ PDRIVER_OBJECT DriverObject, _In_ PDRIVER_FS_NOTIFICATION DriverNotificationRoutine); #endif $endif (_NTIFS_) #if (NTDDI_VERSION >= NTDDI_WIN2K) $if (_WDMDDK_) _Acquires_lock_(_Global_cancel_spin_lock_) _Requires_lock_not_held_(_Global_cancel_spin_lock_) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_raises_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoAcquireCancelSpinLock( _Out_ _At_(*Irql, _IRQL_saves_) PKIRQL Irql); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoAcquireRemoveLockEx( _Inout_ PIO_REMOVE_LOCK RemoveLock, _In_opt_ PVOID Tag, _In_ PCSTR File, _In_ ULONG Line, _In_ ULONG RemlockSize); _IRQL_requires_max_(DISPATCH_LEVEL) _Ret_range_(<=, 0) NTKERNELAPI NTSTATUS NTAPI IoAllocateDriverObjectExtension( _In_ PDRIVER_OBJECT DriverObject, _In_ PVOID ClientIdentificationAddress, _In_ ULONG DriverObjectExtensionSize, _Post_ _At_(*DriverObjectExtension, _When_(return==0, __drv_aliasesMem __drv_allocatesMem(Mem) _Post_notnull_)) _When_(return == 0, _Outptr_result_bytebuffer_(DriverObjectExtensionSize)) PVOID *DriverObjectExtension); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PVOID NTAPI IoAllocateErrorLogEntry( _In_ PVOID IoObject, _In_ UCHAR EntrySize); _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PIRP NTAPI IoAllocateIrp( _In_ CCHAR StackSize, _In_ BOOLEAN ChargeQuota); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PMDL NTAPI IoAllocateMdl( _In_opt_ __drv_aliasesMem PVOID VirtualAddress, _In_ ULONG Length, _In_ BOOLEAN SecondaryBuffer, _In_ BOOLEAN ChargeQuota, _Inout_opt_ PIRP Irp); __drv_allocatesMem(Mem) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PIO_WORKITEM NTAPI IoAllocateWorkItem( _In_ PDEVICE_OBJECT DeviceObject); _IRQL_requires_max_(APC_LEVEL) _Ret_range_(<=, 0) NTKERNELAPI NTSTATUS NTAPI IoAttachDevice( _In_ _Kernel_requires_resource_held_(Memory) _When_(return==0, __drv_aliasesMem) PDEVICE_OBJECT SourceDevice, _In_ PUNICODE_STRING TargetDevice, _Out_ PDEVICE_OBJECT *AttachedDevice); _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PDEVICE_OBJECT NTAPI IoAttachDeviceToDeviceStack( _In_ _Kernel_requires_resource_held_(Memory) _When_(return!=0, __drv_aliasesMem) PDEVICE_OBJECT SourceDevice, _In_ PDEVICE_OBJECT TargetDevice); _Must_inspect_result_ __drv_aliasesMem _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PIRP NTAPI IoBuildAsynchronousFsdRequest( _In_ ULONG MajorFunction, _In_ PDEVICE_OBJECT DeviceObject, _Inout_opt_ PVOID Buffer, _In_opt_ ULONG Length, _In_opt_ PLARGE_INTEGER StartingOffset, _In_opt_ PIO_STATUS_BLOCK IoStatusBlock); _Must_inspect_result_ __drv_aliasesMem _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PIRP NTAPI IoBuildDeviceIoControlRequest( _In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT DeviceObject, _In_opt_ PVOID InputBuffer, _In_ ULONG InputBufferLength, _Out_opt_ PVOID OutputBuffer, _In_ ULONG OutputBufferLength, _In_ BOOLEAN InternalDeviceIoControl, _In_opt_ PKEVENT Event, _Out_ PIO_STATUS_BLOCK IoStatusBlock); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoBuildPartialMdl( _In_ PMDL SourceMdl, _Inout_ PMDL TargetMdl, _In_ PVOID VirtualAddress, _In_ ULONG Length); _Must_inspect_result_ __drv_aliasesMem _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PIRP NTAPI IoBuildSynchronousFsdRequest( _In_ ULONG MajorFunction, _In_ PDEVICE_OBJECT DeviceObject, _Inout_opt_ PVOID Buffer, _In_opt_ ULONG Length, _In_opt_ PLARGE_INTEGER StartingOffset, _In_ PKEVENT Event, _Out_ PIO_STATUS_BLOCK IoStatusBlock); _IRQL_requires_max_(DISPATCH_LEVEL) _Success_(TRUE) NTKERNELAPI NTSTATUS FASTCALL IofCallDriver( _In_ PDEVICE_OBJECT DeviceObject, _Inout_ __drv_aliasesMem PIRP Irp); #define IoCallDriver IofCallDriver _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL IofCompleteRequest( _In_ PIRP Irp, _In_ CCHAR PriorityBoost); #define IoCompleteRequest IofCompleteRequest _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN NTAPI IoCancelIrp( _In_ PIRP Irp); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoCheckShareAccess( _In_ ACCESS_MASK DesiredAccess, _In_ ULONG DesiredShareAccess, _Inout_ PFILE_OBJECT FileObject, _Inout_ PSHARE_ACCESS ShareAccess, _In_ BOOLEAN Update); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL IofCompleteRequest( _In_ PIRP Irp, _In_ CCHAR PriorityBoost); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoConnectInterrupt( _Out_ PKINTERRUPT *InterruptObject, _In_ PKSERVICE_ROUTINE ServiceRoutine, _In_opt_ PVOID ServiceContext, _In_opt_ PKSPIN_LOCK SpinLock, _In_ ULONG Vector, _In_ KIRQL Irql, _In_ KIRQL SynchronizeIrql, _In_ KINTERRUPT_MODE InterruptMode, _In_ BOOLEAN ShareVector, _In_ KAFFINITY ProcessorEnableMask, _In_ BOOLEAN FloatingSave); _IRQL_requires_max_(APC_LEVEL) _Ret_range_(<=, 0) NTKERNELAPI NTSTATUS NTAPI IoCreateDevice( _In_ PDRIVER_OBJECT DriverObject, _In_ ULONG DeviceExtensionSize, _In_opt_ PUNICODE_STRING DeviceName, _In_ DEVICE_TYPE DeviceType, _In_ ULONG DeviceCharacteristics, _In_ BOOLEAN Exclusive, _Outptr_result_nullonfailure_ _At_(*DeviceObject, __drv_allocatesMem(Mem) _When_(((_In_function_class_(DRIVER_INITIALIZE)) ||(_In_function_class_(DRIVER_DISPATCH))), __drv_aliasesMem)) PDEVICE_OBJECT *DeviceObject); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoCreateFile( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_opt_ PLARGE_INTEGER AllocationSize, _In_ ULONG FileAttributes, _In_ ULONG ShareAccess, _In_ ULONG Disposition, _In_ ULONG CreateOptions, _In_opt_ PVOID EaBuffer, _In_ ULONG EaLength, _In_ CREATE_FILE_TYPE CreateFileType, _In_opt_ PVOID InternalParameters, _In_ ULONG Options); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PKEVENT NTAPI IoCreateNotificationEvent( _In_ PUNICODE_STRING EventName, _Out_ PHANDLE EventHandle); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoCreateSymbolicLink( _In_ PUNICODE_STRING SymbolicLinkName, _In_ PUNICODE_STRING DeviceName); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PKEVENT NTAPI IoCreateSynchronizationEvent( _In_ PUNICODE_STRING EventName, _Out_ PHANDLE EventHandle); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoCreateUnprotectedSymbolicLink( _In_ PUNICODE_STRING SymbolicLinkName, _In_ PUNICODE_STRING DeviceName); _IRQL_requires_max_(APC_LEVEL) _Kernel_clear_do_init_(__yes) NTKERNELAPI VOID NTAPI IoDeleteDevice( _In_ _Kernel_requires_resource_held_(Memory) __drv_freesMem(Mem) PDEVICE_OBJECT DeviceObject); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoDeleteSymbolicLink( _In_ PUNICODE_STRING SymbolicLinkName); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoDetachDevice( _Inout_ PDEVICE_OBJECT TargetDevice); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoDisconnectInterrupt( _In_ PKINTERRUPT InterruptObject); __drv_freesMem(Mem) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoFreeIrp( _In_ PIRP Irp); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoFreeMdl( PMDL Mdl); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoFreeWorkItem( _In_ __drv_freesMem(Mem) PIO_WORKITEM IoWorkItem); NTKERNELAPI PDEVICE_OBJECT NTAPI IoGetAttachedDevice( IN PDEVICE_OBJECT DeviceObject); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference( _In_ PDEVICE_OBJECT DeviceObject); NTKERNELAPI NTSTATUS NTAPI IoGetBootDiskInformation( _Inout_ PBOOTDISK_INFORMATION BootDiskInformation, _In_ ULONG Size); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoGetDeviceInterfaceAlias( _In_ PUNICODE_STRING SymbolicLinkName, _In_ CONST GUID *AliasInterfaceClassGuid, _Out_ _When_(return==0, _At_(AliasSymbolicLinkName->Buffer, __drv_allocatesMem(Mem))) PUNICODE_STRING AliasSymbolicLinkName); NTKERNELAPI PEPROCESS NTAPI IoGetCurrentProcess(VOID); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoGetDeviceInterfaces( _In_ CONST GUID *InterfaceClassGuid, _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ ULONG Flags, _Outptr_result_nullonfailure_ _At_(*SymbolicLinkList, _When_(return==0, __drv_allocatesMem(Mem))) PZZWSTR *SymbolicLinkList); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoGetDeviceObjectPointer( _In_ PUNICODE_STRING ObjectName, _In_ ACCESS_MASK DesiredAccess, _Out_ PFILE_OBJECT *FileObject, _Out_ PDEVICE_OBJECT *DeviceObject); _IRQL_requires_max_(PASSIVE_LEVEL) _When_((DeviceProperty & __string_type), _At_(PropertyBuffer, _Post_z_)) _When_((DeviceProperty & __multiString_type), _At_(PropertyBuffer, _Post_ _NullNull_terminated_)) NTKERNELAPI NTSTATUS NTAPI IoGetDeviceProperty( _In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _In_ ULONG BufferLength, _Out_writes_bytes_opt_(BufferLength) PVOID PropertyBuffer, _Deref_out_range_(<=, BufferLength) PULONG ResultLength); _Must_inspect_result_ _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PDMA_ADAPTER NTAPI IoGetDmaAdapter( _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ PDEVICE_DESCRIPTION DeviceDescription, _Out_ _When_(return!=0, _Kernel_IoGetDmaAdapter_ _At_(*NumberOfMapRegisters, _Must_inspect_result_)) PULONG NumberOfMapRegisters); __drv_aliasesMem _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PVOID NTAPI IoGetDriverObjectExtension( _In_ PDRIVER_OBJECT DriverObject, _In_ PVOID ClientIdentificationAddress); _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI PVOID NTAPI IoGetInitialStack(VOID); NTKERNELAPI PDEVICE_OBJECT NTAPI IoGetRelatedDeviceObject( _In_ PFILE_OBJECT FileObject); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoQueueWorkItem( _Inout_ PIO_WORKITEM IoWorkItem, _In_ PIO_WORKITEM_ROUTINE WorkerRoutine, _In_ WORK_QUEUE_TYPE QueueType, _In_opt_ __drv_aliasesMem PVOID Context); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoInitializeIrp( _Inout_ PIRP Irp, _In_ USHORT PacketSize, _In_ CCHAR StackSize); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoInitializeRemoveLockEx( _Out_ PIO_REMOVE_LOCK Lock, _In_ ULONG AllocateTag, _In_ ULONG MaxLockedMinutes, _In_ ULONG HighWatermark, _In_ ULONG RemlockSize); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoInitializeTimer( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIO_TIMER_ROUTINE TimerRoutine, _In_opt_ __drv_aliasesMem PVOID Context); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoInvalidateDeviceRelations( _In_ PDEVICE_OBJECT DeviceObject, _In_ DEVICE_RELATION_TYPE Type); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoInvalidateDeviceState( _In_ PDEVICE_OBJECT PhysicalDeviceObject); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI BOOLEAN NTAPI IoIsWdmVersionAvailable( _When_(MajorVersion!=1&&MajorVersion!=6, _In_ __drv_reportError("MajorVersion must be 1 or 6")) UCHAR MajorVersion, _In_ _When_(MinorVersion!=0 && MinorVersion!=5 && MinorVersion!=16 && MinorVersion!=32 && MinorVersion!=48, __drv_reportError("MinorVersion must be 0, 0x5, 0x10, 0x20, or 0x30")) UCHAR MinorVersion); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoOpenDeviceInterfaceRegistryKey( _In_ PUNICODE_STRING SymbolicLinkName, _In_ ACCESS_MASK DesiredAccess, _Out_ PHANDLE DeviceInterfaceKey); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoOpenDeviceRegistryKey( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG DevInstKeyType, _In_ ACCESS_MASK DesiredAccess, _Out_ PHANDLE DevInstRegKey); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoRegisterDeviceInterface( _In_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ CONST GUID *InterfaceClassGuid, _In_opt_ PUNICODE_STRING ReferenceString, _Out_ _When_(return==0, _At_(SymbolicLinkName->Buffer, __drv_allocatesMem(Mem))) PUNICODE_STRING SymbolicLinkName); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoRegisterPlugPlayNotification( _In_ IO_NOTIFICATION_EVENT_CATEGORY EventCategory, _In_ ULONG EventCategoryFlags, _In_opt_ PVOID EventCategoryData, _In_ PDRIVER_OBJECT DriverObject, _In_ PDRIVER_NOTIFICATION_CALLBACK_ROUTINE CallbackRoutine, _Inout_opt_ __drv_aliasesMem PVOID Context, _Outptr_result_nullonfailure_ _At_(*NotificationEntry, _When_(return==0, __drv_allocatesMem(Mem))) PVOID *NotificationEntry); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoRegisterShutdownNotification( _In_ PDEVICE_OBJECT DeviceObject); _Requires_lock_held_(_Global_cancel_spin_lock_) _Releases_lock_(_Global_cancel_spin_lock_) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoReleaseCancelSpinLock( _In_ _IRQL_restores_ _IRQL_uses_cancel_ KIRQL Irql); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoReleaseRemoveLockAndWaitEx( _Inout_ PIO_REMOVE_LOCK RemoveLock, _In_opt_ PVOID Tag, _In_ ULONG RemlockSize); NTKERNELAPI VOID NTAPI IoReleaseRemoveLockEx( _Inout_ PIO_REMOVE_LOCK RemoveLock, _In_opt_ PVOID Tag, _In_ ULONG RemlockSize); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoRemoveShareAccess( _In_ PFILE_OBJECT FileObject, _Inout_ PSHARE_ACCESS ShareAccess); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoReportTargetDeviceChange( _In_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ PVOID NotificationStructure); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoReportTargetDeviceChangeAsynchronous( _In_ PDEVICE_OBJECT PhysicalDeviceObject, _In_ PVOID NotificationStructure, _In_opt_ PDEVICE_CHANGE_COMPLETE_CALLBACK Callback, _In_opt_ PVOID Context); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoRequestDeviceEject( _In_ PDEVICE_OBJECT PhysicalDeviceObject); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoReuseIrp( _Inout_ PIRP Irp, _In_ NTSTATUS Status); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoSetDeviceInterfaceState( _In_ PUNICODE_STRING SymbolicLinkName, _In_ BOOLEAN Enable); NTKERNELAPI VOID NTAPI IoSetShareAccess( _In_ ACCESS_MASK DesiredAccess, _In_ ULONG DesiredShareAccess, _Inout_ PFILE_OBJECT FileObject, _Out_ PSHARE_ACCESS ShareAccess); _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoStartNextPacket( _In_ PDEVICE_OBJECT DeviceObject, _In_ BOOLEAN Cancelable); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoStartNextPacketByKey( _In_ PDEVICE_OBJECT DeviceObject, _In_ BOOLEAN Cancelable, _In_ ULONG Key); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoStartPacket( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_opt_ PULONG Key, _In_opt_ PDRIVER_CANCEL CancelFunction); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoStartTimer( _In_ PDEVICE_OBJECT DeviceObject); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoStopTimer( _In_ PDEVICE_OBJECT DeviceObject); _IRQL_requires_max_(PASSIVE_LEVEL) __drv_freesMem(Pool) NTKERNELAPI NTSTATUS NTAPI IoUnregisterPlugPlayNotification( _In_ PVOID NotificationEntry); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoUnregisterShutdownNotification( _In_ PDEVICE_OBJECT DeviceObject); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoUpdateShareAccess( _In_ PFILE_OBJECT FileObject, _Inout_ PSHARE_ACCESS ShareAccess); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoWMIAllocateInstanceIds( _In_ GUID *Guid, _In_ ULONG InstanceCount, _Out_ ULONG *FirstInstanceId); NTKERNELAPI NTSTATUS NTAPI IoWMIQuerySingleInstanceMultiple( _In_reads_(ObjectCount) PVOID *DataBlockObjectList, _In_reads_(ObjectCount) PUNICODE_STRING InstanceNames, _In_ ULONG ObjectCount, _Inout_ ULONG *InOutBufferSize, _Out_writes_bytes_opt_(*InOutBufferSize) PVOID OutBuffer); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoWMIRegistrationControl( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG Action); NTKERNELAPI NTSTATUS NTAPI IoWMISuggestInstanceName( _In_opt_ PDEVICE_OBJECT PhysicalDeviceObject, _In_opt_ PUNICODE_STRING SymbolicLinkName, _In_ BOOLEAN CombineNames, _Out_ PUNICODE_STRING SuggestedInstanceName); _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _Ret_range_(<=, 0) NTKERNELAPI NTSTATUS NTAPI IoWMIWriteEvent( _Inout_ _When_(return==0, __drv_aliasesMem) PVOID WnodeEventItem); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoWriteErrorLogEntry( _In_ PVOID ElEntry); NTKERNELAPI PIRP NTAPI IoGetTopLevelIrp(VOID); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoRegisterLastChanceShutdownNotification( _In_ PDEVICE_OBJECT DeviceObject); NTKERNELAPI VOID NTAPI IoSetTopLevelIrp( _In_opt_ PIRP Irp); $endif (_WDMDDK_) $if (_NTDDK_) #if !(defined(USE_DMA_MACROS) && (defined(_NTDDK_) || defined(_NTDRIVER_)) || defined(_WDM_INCLUDED_)) _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoAllocateAdapterChannel( _In_ PADAPTER_OBJECT AdapterObject, _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG NumberOfMapRegisters, _In_ PDRIVER_CONTROL ExecutionRoutine, _In_ PVOID Context); #endif #if !defined(DMA_MACROS_DEFINED) //DECLSPEC_DEPRECATED_DDK NTHALAPI PHYSICAL_ADDRESS NTAPI IoMapTransfer( _In_ PADAPTER_OBJECT AdapterObject, _In_ PMDL Mdl, _In_ PVOID MapRegisterBase, _In_ PVOID CurrentVa, _Inout_ PULONG Length, _In_ BOOLEAN WriteToDevice); #endif _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoAllocateController( _In_ PCONTROLLER_OBJECT ControllerObject, _In_ PDEVICE_OBJECT DeviceObject, _In_ PDRIVER_CONTROL ExecutionRoutine, _In_opt_ PVOID Context); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PCONTROLLER_OBJECT NTAPI IoCreateController( _In_ ULONG Size); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoDeleteController( _In_ PCONTROLLER_OBJECT ControllerObject); _IRQL_requires_max_(DISPATCH_LEVEL) _IRQL_requires_min_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoFreeController( _In_ PCONTROLLER_OBJECT ControllerObject); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PCONFIGURATION_INFORMATION NTAPI IoGetConfigurationInformation(VOID); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PDEVICE_OBJECT NTAPI IoGetDeviceToVerify( _In_ PETHREAD Thread); NTKERNELAPI VOID NTAPI IoCancelFileOpen( _In_ PDEVICE_OBJECT DeviceObject, _In_ PFILE_OBJECT FileObject); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PGENERIC_MAPPING NTAPI IoGetFileObjectGenericMapping(VOID); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI PIRP NTAPI IoMakeAssociatedIrp( _In_ PIRP Irp, _In_ CCHAR StackSize); NTKERNELAPI NTSTATUS NTAPI IoQueryDeviceDescription( _In_opt_ PINTERFACE_TYPE BusType, _In_opt_ PULONG BusNumber, _In_opt_ PCONFIGURATION_TYPE ControllerType, _In_opt_ PULONG ControllerNumber, _In_opt_ PCONFIGURATION_TYPE PeripheralType, _In_opt_ PULONG PeripheralNumber, _In_ PIO_QUERY_DEVICE_ROUTINE CalloutRoutine, _Inout_opt_ PVOID Context); _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID NTAPI IoRaiseHardError( _In_ PIRP Irp, _In_opt_ PVPB Vpb, _In_ PDEVICE_OBJECT RealDeviceObject); _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI BOOLEAN NTAPI IoRaiseInformationalHardError( _In_ NTSTATUS ErrorStatus, _In_opt_ PUNICODE_STRING String, _In_opt_ PKTHREAD Thread); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoRegisterBootDriverReinitialization( _In_ PDRIVER_OBJECT DriverObject, _In_ PDRIVER_REINITIALIZE DriverReinitializationRoutine, _In_opt_ PVOID Context); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI VOID NTAPI IoRegisterDriverReinitialization( _In_ PDRIVER_OBJECT DriverObject, _In_ PDRIVER_REINITIALIZE DriverReinitializationRoutine, _In_opt_ PVOID Context); NTKERNELAPI NTSTATUS NTAPI IoAttachDeviceByPointer( _In_ PDEVICE_OBJECT SourceDevice, _In_ PDEVICE_OBJECT TargetDevice); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoReportDetectedDevice( _In_ PDRIVER_OBJECT DriverObject, _In_ INTERFACE_TYPE LegacyBusType, _In_ ULONG BusNumber, _In_ ULONG SlotNumber, _In_opt_ PCM_RESOURCE_LIST ResourceList, _In_opt_ PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirements, _In_ BOOLEAN ResourceAssigned, _Inout_ PDEVICE_OBJECT *DeviceObject); NTKERNELAPI NTSTATUS NTAPI IoReportResourceForDetection( _In_ PDRIVER_OBJECT DriverObject, _In_reads_bytes_opt_(DriverListSize) PCM_RESOURCE_LIST DriverList, _In_opt_ ULONG DriverListSize, _In_opt_ PDEVICE_OBJECT DeviceObject, _In_reads_bytes_opt_(DeviceListSize) PCM_RESOURCE_LIST DeviceList, _In_opt_ ULONG DeviceListSize, _Out_ PBOOLEAN ConflictDetected); NTKERNELAPI NTSTATUS NTAPI IoReportResourceUsage( _In_opt_ PUNICODE_STRING DriverClassName, _In_ PDRIVER_OBJECT DriverObject, _In_reads_bytes_opt_(DriverListSize) PCM_RESOURCE_LIST DriverList, _In_opt_ ULONG DriverListSize, _In_opt_ PDEVICE_OBJECT DeviceObject, _In_reads_bytes_opt_(DeviceListSize) PCM_RESOURCE_LIST DeviceList, _In_opt_ ULONG DeviceListSize, _In_ BOOLEAN OverrideConflict, _Out_ PBOOLEAN ConflictDetected); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI VOID NTAPI IoSetHardErrorOrVerifyDevice( _In_ PIRP Irp, _In_ PDEVICE_OBJECT DeviceObject); NTKERNELAPI NTSTATUS NTAPI IoAssignResources( _In_ PUNICODE_STRING RegistryPath, _In_opt_ PUNICODE_STRING DriverClassName, _In_ PDRIVER_OBJECT DriverObject, _In_opt_ PDEVICE_OBJECT DeviceObject, _In_opt_ PIO_RESOURCE_REQUIREMENTS_LIST RequestedResources, _Inout_ PCM_RESOURCE_LIST *AllocatedResources); _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN NTAPI IoSetThreadHardErrorMode( _In_ BOOLEAN EnableHardErrors); $endif (_NTDDK_) $if (_NTIFS_) NTKERNELAPI VOID NTAPI IoAcquireVpbSpinLock( _Out_ PKIRQL Irql); NTKERNELAPI NTSTATUS NTAPI IoCheckDesiredAccess( _Inout_ PACCESS_MASK DesiredAccess, _In_ ACCESS_MASK GrantedAccess); NTKERNELAPI NTSTATUS NTAPI IoCheckEaBufferValidity( _In_ PFILE_FULL_EA_INFORMATION EaBuffer, _In_ ULONG EaLength, _Out_ PULONG ErrorOffset); NTKERNELAPI NTSTATUS NTAPI IoCheckFunctionAccess( _In_ ACCESS_MASK GrantedAccess, _In_ UCHAR MajorFunction, _In_ UCHAR MinorFunction, _In_ ULONG IoControlCode, _In_opt_ PVOID Argument1, _In_opt_ PVOID Argument2); NTKERNELAPI NTSTATUS NTAPI IoCheckQuerySetFileInformation( _In_ FILE_INFORMATION_CLASS FileInformationClass, _In_ ULONG Length, _In_ BOOLEAN SetOperation); NTKERNELAPI NTSTATUS NTAPI IoCheckQuerySetVolumeInformation( _In_ FS_INFORMATION_CLASS FsInformationClass, _In_ ULONG Length, _In_ BOOLEAN SetOperation); NTKERNELAPI NTSTATUS NTAPI IoCheckQuotaBufferValidity( _In_ PFILE_QUOTA_INFORMATION QuotaBuffer, _In_ ULONG QuotaLength, _Out_ PULONG ErrorOffset); NTKERNELAPI PFILE_OBJECT NTAPI IoCreateStreamFileObject( _In_opt_ PFILE_OBJECT FileObject, _In_opt_ PDEVICE_OBJECT DeviceObject); NTKERNELAPI PFILE_OBJECT NTAPI IoCreateStreamFileObjectLite( _In_opt_ PFILE_OBJECT FileObject, _In_opt_ PDEVICE_OBJECT DeviceObject); NTKERNELAPI BOOLEAN NTAPI IoFastQueryNetworkAttributes( _In_ POBJECT_ATTRIBUTES ObjectAttributes, _In_ ACCESS_MASK DesiredAccess, _In_ ULONG OpenOptions, _Out_ PIO_STATUS_BLOCK IoStatus, _Out_ PFILE_NETWORK_OPEN_INFORMATION Buffer); NTKERNELAPI NTSTATUS NTAPI IoPageRead( _In_ PFILE_OBJECT FileObject, _In_ PMDL Mdl, _In_ PLARGE_INTEGER Offset, _In_ PKEVENT Event, _Out_ PIO_STATUS_BLOCK IoStatusBlock); NTKERNELAPI PDEVICE_OBJECT NTAPI IoGetBaseFileSystemDeviceObject( _In_ PFILE_OBJECT FileObject); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PCONFIGURATION_INFORMATION NTAPI IoGetConfigurationInformation(VOID); NTKERNELAPI ULONG NTAPI IoGetRequestorProcessId( _In_ PIRP Irp); NTKERNELAPI PEPROCESS NTAPI IoGetRequestorProcess( _In_ PIRP Irp); NTKERNELAPI PIRP NTAPI IoGetTopLevelIrp(VOID); NTKERNELAPI BOOLEAN NTAPI IoIsOperationSynchronous( _In_ PIRP Irp); NTKERNELAPI BOOLEAN NTAPI IoIsSystemThread( _In_ PETHREAD Thread); NTKERNELAPI BOOLEAN NTAPI IoIsValidNameGraftingBuffer( _In_ PIRP Irp, _In_ PREPARSE_DATA_BUFFER ReparseBuffer); NTKERNELAPI NTSTATUS NTAPI IoQueryFileInformation( _In_ PFILE_OBJECT FileObject, _In_ FILE_INFORMATION_CLASS FileInformationClass, _In_ ULONG Length, _Out_ PVOID FileInformation, _Out_ PULONG ReturnedLength); NTKERNELAPI NTSTATUS NTAPI IoQueryVolumeInformation( _In_ PFILE_OBJECT FileObject, _In_ FS_INFORMATION_CLASS FsInformationClass, _In_ ULONG Length, _Out_ PVOID FsInformation, _Out_ PULONG ReturnedLength); NTKERNELAPI VOID NTAPI IoQueueThreadIrp( _In_ PIRP Irp); NTKERNELAPI VOID NTAPI IoRegisterFileSystem( _In_ __drv_aliasesMem PDEVICE_OBJECT DeviceObject); NTKERNELAPI NTSTATUS NTAPI IoRegisterFsRegistrationChange( _In_ PDRIVER_OBJECT DriverObject, _In_ PDRIVER_FS_NOTIFICATION DriverNotificationRoutine); NTKERNELAPI VOID NTAPI IoReleaseVpbSpinLock( _In_ KIRQL Irql); NTKERNELAPI VOID NTAPI IoSetDeviceToVerify( _In_ PETHREAD Thread, _In_opt_ PDEVICE_OBJECT DeviceObject); NTKERNELAPI NTSTATUS NTAPI IoSetInformation( _In_ PFILE_OBJECT FileObject, _In_ FILE_INFORMATION_CLASS FileInformationClass, _In_ ULONG Length, _In_ PVOID FileInformation); NTKERNELAPI VOID NTAPI IoSetTopLevelIrp( _In_opt_ PIRP Irp); NTKERNELAPI NTSTATUS NTAPI IoSynchronousPageWrite( _In_ PFILE_OBJECT FileObject, _In_ PMDL Mdl, _In_ PLARGE_INTEGER FileOffset, _In_ PKEVENT Event, _Out_ PIO_STATUS_BLOCK IoStatusBlock); NTKERNELAPI PEPROCESS NTAPI IoThreadToProcess( _In_ PETHREAD Thread); NTKERNELAPI VOID NTAPI IoUnregisterFileSystem( _In_ PDEVICE_OBJECT DeviceObject); NTKERNELAPI VOID NTAPI IoUnregisterFsRegistrationChange( _In_ PDRIVER_OBJECT DriverObject, _In_ PDRIVER_FS_NOTIFICATION DriverNotificationRoutine); NTKERNELAPI NTSTATUS NTAPI IoVerifyVolume( _In_ PDEVICE_OBJECT DeviceObject, _In_ BOOLEAN AllowRawMount); NTKERNELAPI NTSTATUS NTAPI IoGetRequestorSessionId( _In_ PIRP Irp, _Out_ PULONG pSessionId); $endif (_NTIFS_) #endif /* (NTDDI_VERSION >= NTDDI_WIN2K) */ $if (_NTDDK_) #if (NTDDI_VERSION >= NTDDI_WIN2KSP3) NTKERNELAPI BOOLEAN NTAPI IoIsFileOriginRemote( _In_ PFILE_OBJECT FileObject); NTKERNELAPI NTSTATUS NTAPI IoSetFileOrigin( _In_ PFILE_OBJECT FileObject, _In_ BOOLEAN Remote); #endif /* (NTDDI_VERSION >= NTDDI_WIN2KSP3) */ $endif (_NTDDK_) #if (NTDDI_VERSION >= NTDDI_WINXP) $if (_WDMDDK_) NTKERNELAPI NTSTATUS NTAPI IoCsqInitialize( _Out_ PIO_CSQ Csq, _In_ PIO_CSQ_INSERT_IRP CsqInsertIrp, _In_ PIO_CSQ_REMOVE_IRP CsqRemoveIrp, _In_ PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp, _In_ PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock, _In_ PIO_CSQ_RELEASE_LOCK CsqReleaseLock, _In_ PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp); NTKERNELAPI VOID NTAPI IoCsqInsertIrp( _Inout_ PIO_CSQ Csq, _Inout_ PIRP Irp, _Out_opt_ PIO_CSQ_IRP_CONTEXT Context); NTKERNELAPI PIRP NTAPI IoCsqRemoveIrp( _Inout_ PIO_CSQ Csq, _Inout_ PIO_CSQ_IRP_CONTEXT Context); NTKERNELAPI PIRP NTAPI IoCsqRemoveNextIrp( _Inout_ PIO_CSQ Csq, _In_opt_ PVOID PeekContext); NTKERNELAPI BOOLEAN NTAPI IoForwardIrpSynchronously( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp); #define IoForwardAndCatchIrp IoForwardIrpSynchronously NTKERNELAPI VOID NTAPI IoFreeErrorLogEntry( _In_ PVOID ElEntry); _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoSetCompletionRoutineEx( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PIO_COMPLETION_ROUTINE CompletionRoutine, _In_opt_ PVOID Context, _In_ BOOLEAN InvokeOnSuccess, _In_ BOOLEAN InvokeOnError, _In_ BOOLEAN InvokeOnCancel); VOID NTAPI IoSetStartIoAttributes( _In_ PDEVICE_OBJECT DeviceObject, _In_ BOOLEAN DeferredStartIo, _In_ BOOLEAN NonCancelable); NTKERNELAPI NTSTATUS NTAPI IoWMIDeviceObjectToInstanceName( _In_ PVOID DataBlockObject, _In_ PDEVICE_OBJECT DeviceObject, _Out_ PUNICODE_STRING InstanceName); NTKERNELAPI NTSTATUS NTAPI IoWMIExecuteMethod( _In_ PVOID DataBlockObject, _In_ PUNICODE_STRING InstanceName, _In_ ULONG MethodId, _In_ ULONG InBufferSize, _Inout_ PULONG OutBufferSize, _Inout_updates_bytes_to_opt_(*OutBufferSize, InBufferSize) PUCHAR InOutBuffer); NTKERNELAPI NTSTATUS NTAPI IoWMIHandleToInstanceName( _In_ PVOID DataBlockObject, _In_ HANDLE FileHandle, _Out_ PUNICODE_STRING InstanceName); NTKERNELAPI NTSTATUS NTAPI IoWMIOpenBlock( _In_ LPCGUID DataBlockGuid, _In_ ULONG DesiredAccess, _Out_ PVOID *DataBlockObject); NTKERNELAPI NTSTATUS NTAPI IoWMIQueryAllData( _In_ PVOID DataBlockObject, _Inout_ ULONG *InOutBufferSize, _Out_writes_bytes_opt_(*InOutBufferSize) PVOID OutBuffer); NTKERNELAPI NTSTATUS NTAPI IoWMIQueryAllDataMultiple( _In_reads_(ObjectCount) PVOID *DataBlockObjectList, _In_ ULONG ObjectCount, _Inout_ ULONG *InOutBufferSize, _Out_writes_bytes_opt_(*InOutBufferSize) PVOID OutBuffer); NTKERNELAPI NTSTATUS NTAPI IoWMIQuerySingleInstance( _In_ PVOID DataBlockObject, _In_ PUNICODE_STRING InstanceName, _Inout_ ULONG *InOutBufferSize, _Out_writes_bytes_opt_(*InOutBufferSize) PVOID OutBuffer); NTKERNELAPI NTSTATUS NTAPI IoWMISetNotificationCallback( _Inout_ PVOID Object, _In_ WMI_NOTIFICATION_CALLBACK Callback, _In_opt_ PVOID Context); NTKERNELAPI NTSTATUS NTAPI IoWMISetSingleInstance( _In_ PVOID DataBlockObject, _In_ PUNICODE_STRING InstanceName, _In_ ULONG Version, _In_ ULONG ValueBufferSize, _In_reads_bytes_(ValueBufferSize) PVOID ValueBuffer); NTKERNELAPI NTSTATUS NTAPI IoWMISetSingleItem( _In_ PVOID DataBlockObject, _In_ PUNICODE_STRING InstanceName, _In_ ULONG DataItemId, _In_ ULONG Version, _In_ ULONG ValueBufferSize, _In_reads_bytes_(ValueBufferSize) PVOID ValueBuffer); $endif (_WDMDDK_) $if (_NTDDK_) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS FASTCALL IoReadPartitionTable( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG SectorSize, _In_ BOOLEAN ReturnRecognizedPartitions, _Out_ struct _DRIVE_LAYOUT_INFORMATION **PartitionBuffer); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS FASTCALL IoSetPartitionInformation( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG SectorSize, _In_ ULONG PartitionNumber, _In_ ULONG PartitionType); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS FASTCALL IoWritePartitionTable( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG SectorSize, _In_ ULONG SectorsPerTrack, _In_ ULONG NumberOfHeads, _In_ struct _DRIVE_LAYOUT_INFORMATION *PartitionBuffer); NTKERNELAPI NTSTATUS NTAPI IoCreateDisk( _In_ PDEVICE_OBJECT DeviceObject, _In_opt_ struct _CREATE_DISK* Disk); NTKERNELAPI NTSTATUS NTAPI IoReadDiskSignature( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG BytesPerSector, _Out_ PDISK_SIGNATURE Signature); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoReadPartitionTableEx( _In_ PDEVICE_OBJECT DeviceObject, _Out_ struct _DRIVE_LAYOUT_INFORMATION_EX **PartitionBuffer); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoSetPartitionInformationEx( _In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG PartitionNumber, _In_ struct _SET_PARTITION_INFORMATION_EX *PartitionInfo); NTKERNELAPI NTSTATUS NTAPI IoSetSystemPartition( _In_ PUNICODE_STRING VolumeNameString); NTKERNELAPI NTSTATUS NTAPI IoVerifyPartitionTable( _In_ PDEVICE_OBJECT DeviceObject, _In_ BOOLEAN FixErrors); NTKERNELAPI NTSTATUS NTAPI IoVolumeDeviceToDosName( _In_ PVOID VolumeDeviceObject, _Out_ _When_(return==0, _At_(DosName->Buffer, __drv_allocatesMem(Mem))) PUNICODE_STRING DosName); _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI NTSTATUS NTAPI IoWritePartitionTableEx( _In_ PDEVICE_OBJECT DeviceObject, _In_reads_(_Inexpressible_(FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[0]))) struct _DRIVE_LAYOUT_INFORMATION_EX *DriveLayout); NTKERNELAPI NTSTATUS NTAPI IoCreateFileSpecifyDeviceObjectHint( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_opt_ PLARGE_INTEGER AllocationSize, _In_ ULONG FileAttributes, _In_ ULONG ShareAccess, _In_ ULONG Disposition, _In_ ULONG CreateOptions, _In_opt_ PVOID EaBuffer, _In_ ULONG EaLength, _In_ CREATE_FILE_TYPE CreateFileType, _In_opt_ PVOID InternalParameters, _In_ ULONG Options, _In_opt_ PVOID DeviceObject); NTKERNELAPI NTSTATUS NTAPI IoAttachDeviceToDeviceStackSafe( _In_ PDEVICE_OBJECT SourceDevice, _In_ PDEVICE_OBJECT TargetDevice, _Outptr_ PDEVICE_OBJECT *AttachedToDeviceObject); $endif (_NTDDK_) $if (_NTIFS_) NTKERNELAPI PFILE_OBJECT NTAPI IoCreateStreamFileObjectEx( _In_opt_ PFILE_OBJECT FileObject, _In_opt_ PDEVICE_OBJECT DeviceObject, _Out_opt_ PHANDLE FileObjectHandle); NTKERNELAPI NTSTATUS NTAPI IoQueryFileDosDeviceName( _In_ PFILE_OBJECT FileObject, _Out_ POBJECT_NAME_INFORMATION *ObjectNameInformation); NTKERNELAPI NTSTATUS NTAPI IoEnumerateDeviceObjectList( _In_ PDRIVER_OBJECT DriverObject, _Out_writes_bytes_to_opt_(DeviceObjectListSize,(*ActualNumberDeviceObjects)*sizeof(PDEVICE_OBJECT)) PDEVICE_OBJECT *DeviceObjectList, _In_ ULONG DeviceObjectListSize, _Out_ PULONG ActualNumberDeviceObjects); NTKERNELAPI PDEVICE_OBJECT NTAPI IoGetLowerDeviceObject( _In_ PDEVICE_OBJECT DeviceObject); NTKERNELAPI PDEVICE_OBJECT NTAPI IoGetDeviceAttachmentBaseRef( _In_ PDEVICE_OBJECT DeviceObject); NTKERNELAPI NTSTATUS NTAPI IoGetDiskDeviceObject( _In_ PDEVICE_OBJECT FileSystemDeviceObject, _Out_ PDEVICE_OBJECT *DiskDeviceObject); $endif (_NTIFS_) #endif /* (NTDDI_VERSION >= NTDDI_WINXP) */ $if (_WDMDDK_) #if (NTDDI_VERSION >= NTDDI_WINXPSP1) NTKERNELAPI NTSTATUS NTAPI IoValidateDeviceIoControlAccess( _In_ PIRP Irp, _In_ ULONG RequiredAccess); #endif $endif (_WDMDDK_) $if (_WDMDDK_ || _NTDDK_) #if (NTDDI_VERSION >= NTDDI_WS03) $endif (_WDMDDK_ || _NTDDK_) $if (_NTDDK_) NTKERNELAPI IO_PAGING_PRIORITY FASTCALL IoGetPagingIoPriority( _In_ PIRP Irp); $endif (_NTDDK_) $if (_WDMDDK_) NTKERNELAPI NTSTATUS NTAPI IoCsqInitializeEx( _Out_ PIO_CSQ Csq, _In_ PIO_CSQ_INSERT_IRP_EX CsqInsertIrp, _In_ PIO_CSQ_REMOVE_IRP CsqRemoveIrp, _In_ PIO_CSQ_PEEK_NEXT_IRP CsqPeekNextIrp, _In_ PIO_CSQ_ACQUIRE_LOCK CsqAcquireLock, _In_ PIO_CSQ_RELEASE_LOCK CsqReleaseLock, _In_ PIO_CSQ_COMPLETE_CANCELED_IRP CsqCompleteCanceledIrp); NTKERNELAPI NTSTATUS NTAPI IoCsqInsertIrpEx( _Inout_ PIO_CSQ Csq, _Inout_ PIRP Irp, _Out_opt_ PIO_CSQ_IRP_CONTEXT Context, _In_opt_ PVOID InsertContext); $endif (_WDMDDK_) $if (_WDMDDK_ || _NTDDK_) #endif /* (NTDDI_VERSION >= NTDDI_WS03) */ $endif (_WDMDDK_ || _NTDDK_) $if (_NTDDK_ || _NTIFS_) #if (NTDDI_VERSION >= NTDDI_WS03SP1) $endif (_NTDDK_ || _NTIFS_) $if (_NTDDK_) BOOLEAN NTAPI IoTranslateBusAddress( _In_ INTERFACE_TYPE InterfaceType, _In_ ULONG BusNumber, _In_ PHYSICAL_ADDRESS BusAddress, _Inout_ PULONG AddressSpace, _Out_ PPHYSICAL_ADDRESS TranslatedAddress); $endif (_NTDDK_) $if (_NTIFS_) NTKERNELAPI NTSTATUS NTAPI IoEnumerateRegisteredFiltersList( _Out_writes_bytes_to_opt_(DriverObjectListSize,(*ActualNumberDriverObjects)*sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList, _In_ ULONG DriverObjectListSize, _Out_ PULONG ActualNumberDriverObjects); $endif (_NTIFS_) $if (_NTDDK_ || _NTIFS_) #endif /* (NTDDI_VERSION >= NTDDI_WS03SP1) */ $endif (_NTDDK_ || _NTIFS_) #if (NTDDI_VERSION >= NTDDI_VISTA) $if (_WDMDDK_) NTKERNELAPI NTSTATUS NTAPI IoGetBootDiskInformationLite( _Outptr_ PBOOTDISK_INFORMATION_LITE *BootDiskInformation); NTKERNELAPI NTSTATUS NTAPI IoCheckShareAccessEx( _In_ ACCESS_MASK DesiredAccess, _In_ ULONG DesiredShareAccess, _Inout_ PFILE_OBJECT FileObject, _Inout_ PSHARE_ACCESS ShareAccess, _In_ BOOLEAN Update, _In_ PBOOLEAN WritePermission); NTKERNELAPI NTSTATUS NTAPI IoConnectInterruptEx( _Inout_ PIO_CONNECT_INTERRUPT_PARAMETERS Parameters); NTKERNELAPI VOID NTAPI IoDisconnectInterruptEx( _In_ PIO_DISCONNECT_INTERRUPT_PARAMETERS Parameters); LOGICAL NTAPI IoWithinStackLimits( _In_ ULONG_PTR RegionStart, _In_ SIZE_T RegionSize); NTKERNELAPI VOID NTAPI IoSetShareAccessEx( _In_ ACCESS_MASK DesiredAccess, _In_ ULONG DesiredShareAccess, _Inout_ PFILE_OBJECT FileObject, _Out_ PSHARE_ACCESS ShareAccess, _In_ PBOOLEAN WritePermission); ULONG NTAPI IoSizeofWorkItem(VOID); VOID NTAPI IoInitializeWorkItem( _In_ PVOID IoObject, _Out_ PIO_WORKITEM IoWorkItem); VOID NTAPI IoUninitializeWorkItem( _Inout_ PIO_WORKITEM IoWorkItem); _IRQL_requires_max_(DISPATCH_LEVEL) VOID NTAPI IoQueueWorkItemEx( _Inout_ PIO_WORKITEM IoWorkItem, _In_ PIO_WORKITEM_ROUTINE_EX WorkerRoutine, _In_ WORK_QUEUE_TYPE QueueType, _In_opt_ __drv_aliasesMem PVOID Context); IO_PRIORITY_HINT NTAPI IoGetIoPriorityHint( _In_ PIRP Irp); NTSTATUS NTAPI IoSetIoPriorityHint( _In_ PIRP Irp, _In_ IO_PRIORITY_HINT PriorityHint); NTSTATUS NTAPI IoAllocateSfioStreamIdentifier( _In_ PFILE_OBJECT FileObject, _In_ ULONG Length, _In_ PVOID Signature, _Out_ PVOID *StreamIdentifier); PVOID NTAPI IoGetSfioStreamIdentifier( _In_ PFILE_OBJECT FileObject, _In_ PVOID Signature); NTSTATUS NTAPI IoFreeSfioStreamIdentifier( _In_ PFILE_OBJECT FileObject, _In_ PVOID Signature); _IRQL_requires_max_(DISPATCH_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoRequestDeviceEjectEx( _In_ PDEVICE_OBJECT PhysicalDeviceObject, _In_opt_ PIO_DEVICE_EJECT_CALLBACK Callback, _In_opt_ PVOID Context, _In_opt_ PDRIVER_OBJECT DriverObject); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoSetDevicePropertyData( _In_ PDEVICE_OBJECT Pdo, _In_ CONST DEVPROPKEY *PropertyKey, _In_ LCID Lcid, _In_ ULONG Flags, _In_ DEVPROPTYPE Type, _In_ ULONG Size, _In_opt_ PVOID Data); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoGetDevicePropertyData( _In_ PDEVICE_OBJECT Pdo, _In_ CONST DEVPROPKEY *PropertyKey, _In_ LCID Lcid, _Reserved_ ULONG Flags, _In_ ULONG Size, _Out_ PVOID Data, _Out_ PULONG RequiredSize, _Out_ PDEVPROPTYPE Type); $endif (_WDMDDK_) $if (_NTDDK_) NTKERNELAPI NTSTATUS NTAPI IoUpdateDiskGeometry( _In_ PDEVICE_OBJECT DeviceObject, _In_ struct _DISK_GEOMETRY_EX* OldDiskGeometry, _In_ struct _DISK_GEOMETRY_EX* NewDiskGeometry); PTXN_PARAMETER_BLOCK NTAPI IoGetTransactionParameterBlock( _In_ PFILE_OBJECT FileObject); NTKERNELAPI NTSTATUS NTAPI IoCreateFileEx( _Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_opt_ PLARGE_INTEGER AllocationSize, _In_ ULONG FileAttributes, _In_ ULONG ShareAccess, _In_ ULONG Disposition, _In_ ULONG CreateOptions, _In_opt_ PVOID EaBuffer, _In_ ULONG EaLength, _In_ CREATE_FILE_TYPE CreateFileType, _In_opt_ PVOID InternalParameters, _In_ ULONG Options, _In_opt_ PIO_DRIVER_CREATE_CONTEXT DriverContext); NTSTATUS NTAPI IoSetIrpExtraCreateParameter( _Inout_ PIRP Irp, _In_ struct _ECP_LIST *ExtraCreateParameter); VOID NTAPI IoClearIrpExtraCreateParameter( _Inout_ PIRP Irp); NTSTATUS NTAPI IoGetIrpExtraCreateParameter( _In_ PIRP Irp, _Outptr_result_maybenull_ struct _ECP_LIST **ExtraCreateParameter); BOOLEAN NTAPI IoIsFileObjectIgnoringSharing( _In_ PFILE_OBJECT FileObject); $endif (_NTDDK_) $if (_NTIFS_) FORCEINLINE VOID NTAPI IoInitializePriorityInfo( _In_ PIO_PRIORITY_INFO PriorityInfo) { PriorityInfo->Size = sizeof(IO_PRIORITY_INFO); PriorityInfo->ThreadPriority = 0xffff; PriorityInfo->IoPriority = IoPriorityNormal; PriorityInfo->PagePriority = 0; } $endif (_NTIFS_) #endif /* (NTDDI_VERSION >= NTDDI_VISTA) */ $if (_WDMDDK_) #define IoCallDriverStackSafeDefault(a, b) IoCallDriver(a, b) #if (NTDDI_VERSION >= NTDDI_WS08) _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoReplacePartitionUnit( _In_ PDEVICE_OBJECT TargetPdo, _In_ PDEVICE_OBJECT SparePdo, _In_ ULONG Flags); #endif $endif (_WDMDDK_) #if (NTDDI_VERSION >= NTDDI_WIN7) $if (_WDMDDK_) NTKERNELAPI NTSTATUS NTAPI IoGetAffinityInterrupt( _In_ PKINTERRUPT InterruptObject, _Out_ PGROUP_AFFINITY GroupAffinity); NTSTATUS NTAPI IoGetContainerInformation( _In_ IO_CONTAINER_INFORMATION_CLASS InformationClass, _In_opt_ PVOID ContainerObject, _Inout_updates_bytes_opt_(BufferLength) PVOID Buffer, _In_ ULONG BufferLength); NTSTATUS NTAPI IoRegisterContainerNotification( _In_ IO_CONTAINER_NOTIFICATION_CLASS NotificationClass, _In_ PIO_CONTAINER_NOTIFICATION_FUNCTION CallbackFunction, _In_reads_bytes_opt_(NotificationInformationLength) PVOID NotificationInformation, _In_ ULONG NotificationInformationLength, _Out_ PVOID CallbackRegistration); VOID NTAPI IoUnregisterContainerNotification( _In_ PVOID CallbackRegistration); _IRQL_requires_max_(PASSIVE_LEVEL) __drv_freesMem(Pool) NTKERNELAPI NTSTATUS NTAPI IoUnregisterPlugPlayNotificationEx( _In_ PVOID NotificationEntry); _IRQL_requires_max_(PASSIVE_LEVEL) _Must_inspect_result_ NTKERNELAPI NTSTATUS NTAPI IoGetDeviceNumaNode( _In_ PDEVICE_OBJECT Pdo, _Out_ PUSHORT NodeNumber); $endif (_WDMDDK_) $if (_NTDDK_) NTSTATUS NTAPI IoSetFileObjectIgnoreSharing( _In_ PFILE_OBJECT FileObject); $endif (_NTDDK_) $if (_NTIFS_) NTKERNELAPI NTSTATUS NTAPI IoRegisterFsRegistrationChangeMountAware( _In_ PDRIVER_OBJECT DriverObject, _In_ PDRIVER_FS_NOTIFICATION DriverNotificationRoutine, _In_ BOOLEAN SynchronizeWithMounts); NTKERNELAPI NTSTATUS NTAPI IoReplaceFileObjectName( _In_ PFILE_OBJECT FileObject, _In_reads_bytes_(FileNameLength) PWSTR NewFileName, _In_ USHORT FileNameLength); $endif (_NTIFS_) #endif /* (NTDDI_VERSION >= NTDDI_WIN7) */ $if (_WDMDDK_) #if defined(_WIN64) NTKERNELAPI ULONG NTAPI IoWMIDeviceObjectToProviderId( _In_ PDEVICE_OBJECT DeviceObject); #else #define IoWMIDeviceObjectToProviderId(DeviceObject) ((ULONG)(DeviceObject)) #endif /* * USHORT * IoSizeOfIrp( * IN CCHAR StackSize) */ #define IoSizeOfIrp(_StackSize) \ ((USHORT) (sizeof(IRP) + ((_StackSize) * (sizeof(IO_STACK_LOCATION))))) FORCEINLINE VOID IoSkipCurrentIrpStackLocation( _Inout_ PIRP Irp) { ASSERT(Irp->CurrentLocation <= Irp->StackCount); Irp->CurrentLocation++; #ifdef NONAMELESSUNION Irp->Tail.Overlay.s.u.CurrentStackLocation++; #else Irp->Tail.Overlay.CurrentStackLocation++; #endif } FORCEINLINE VOID IoSetNextIrpStackLocation( _Inout_ PIRP Irp) { ASSERT(Irp->CurrentLocation > 0); Irp->CurrentLocation--; #ifdef NONAMELESSUNION Irp->Tail.Overlay.s.u.CurrentStackLocation--; #else Irp->Tail.Overlay.CurrentStackLocation--; #endif } __drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation( _In_ PIRP Irp) { ASSERT(Irp->CurrentLocation > 0); #ifdef NONAMELESSUNION return ((Irp)->Tail.Overlay.s.u.CurrentStackLocation - 1 ); #else return ((Irp)->Tail.Overlay.CurrentStackLocation - 1 ); #endif } _IRQL_requires_max_(DISPATCH_LEVEL) FORCEINLINE VOID IoSetCompletionRoutine( _In_ PIRP Irp, _In_opt_ PIO_COMPLETION_ROUTINE CompletionRoutine, _In_opt_ __drv_aliasesMem PVOID Context, _In_ BOOLEAN InvokeOnSuccess, _In_ BOOLEAN InvokeOnError, _In_ BOOLEAN InvokeOnCancel) { PIO_STACK_LOCATION irpSp; ASSERT( (InvokeOnSuccess || InvokeOnError || InvokeOnCancel) ? (CompletionRoutine != NULL) : TRUE ); irpSp = IoGetNextIrpStackLocation(Irp); irpSp->CompletionRoutine = CompletionRoutine; irpSp->Context = Context; irpSp->Control = 0; if (InvokeOnSuccess) { irpSp->Control = SL_INVOKE_ON_SUCCESS; } if (InvokeOnError) { irpSp->Control |= SL_INVOKE_ON_ERROR; } if (InvokeOnCancel) { irpSp->Control |= SL_INVOKE_ON_CANCEL; } } _IRQL_requires_max_(DISPATCH_LEVEL) _Ret_maybenull_ FORCEINLINE PDRIVER_CANCEL IoSetCancelRoutine( _Inout_ PIRP Irp, _In_opt_ PDRIVER_CANCEL CancelRoutine) { return (PDRIVER_CANCEL)(ULONG_PTR) InterlockedExchangePointer((PVOID *)&(Irp)->CancelRoutine, (PVOID)(ULONG_PTR)(CancelRoutine)); } FORCEINLINE VOID IoRequestDpc( _Inout_ PDEVICE_OBJECT DeviceObject, _In_opt_ PIRP Irp, _In_opt_ __drv_aliasesMem PVOID Context) { KeInsertQueueDpc(&DeviceObject->Dpc, Irp, Context); } /* * VOID * IoReleaseRemoveLock( * IN PIO_REMOVE_LOCK RemoveLock, * IN PVOID Tag) */ #define IoReleaseRemoveLock(_RemoveLock, \ _Tag) \ IoReleaseRemoveLockEx(_RemoveLock, _Tag, sizeof(IO_REMOVE_LOCK)) /* * VOID * IoReleaseRemoveLockAndWait( * IN PIO_REMOVE_LOCK RemoveLock, * IN PVOID Tag) */ #define IoReleaseRemoveLockAndWait(_RemoveLock, \ _Tag) \ IoReleaseRemoveLockAndWaitEx(_RemoveLock, _Tag, sizeof(IO_REMOVE_LOCK)) #if defined(_WIN64) _IRQL_requires_max_(DISPATCH_LEVEL) NTKERNELAPI BOOLEAN IoIs32bitProcess( _In_opt_ PIRP Irp); #endif #define PLUGPLAY_REGKEY_DEVICE 1 #define PLUGPLAY_REGKEY_DRIVER 2 #define PLUGPLAY_REGKEY_CURRENT_HWPROFILE 4 __drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation( _In_ PIRP Irp) { ASSERT(Irp->CurrentLocation <= Irp->StackCount + 1); #ifdef NONAMELESSUNION return Irp->Tail.Overlay.s.u.CurrentStackLocation; #else return Irp->Tail.Overlay.CurrentStackLocation; #endif } FORCEINLINE VOID IoMarkIrpPending( _Inout_ PIRP Irp) { IoGetCurrentIrpStackLocation((Irp))->Control |= SL_PENDING_RETURNED; } /* * BOOLEAN * IoIsErrorUserInduced( * IN NTSTATUS Status); */ #define IoIsErrorUserInduced(Status) \ ((BOOLEAN)(((Status) == STATUS_DEVICE_NOT_READY) || \ ((Status) == STATUS_IO_TIMEOUT) || \ ((Status) == STATUS_MEDIA_WRITE_PROTECTED) || \ ((Status) == STATUS_NO_MEDIA_IN_DEVICE) || \ ((Status) == STATUS_VERIFY_REQUIRED) || \ ((Status) == STATUS_UNRECOGNIZED_MEDIA) || \ ((Status) == STATUS_WRONG_VOLUME))) /* VOID * IoInitializeRemoveLock( * IN PIO_REMOVE_LOCK Lock, * IN ULONG AllocateTag, * IN ULONG MaxLockedMinutes, * IN ULONG HighWatermark) */ #define IoInitializeRemoveLock( \ Lock, AllocateTag, MaxLockedMinutes, HighWatermark) \ IoInitializeRemoveLockEx(Lock, AllocateTag, MaxLockedMinutes, \ HighWatermark, sizeof(IO_REMOVE_LOCK)) FORCEINLINE VOID IoInitializeDpcRequest( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIO_DPC_ROUTINE DpcRoutine) { #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable:28024) #endif KeInitializeDpc(&DeviceObject->Dpc, (PKDEFERRED_ROUTINE) DpcRoutine, DeviceObject); #ifdef _MSC_VER #pragma warning(pop) #endif } #define DEVICE_INTERFACE_INCLUDE_NONACTIVE 0x00000001 /* * ULONG * IoGetFunctionCodeFromCtlCode( * IN ULONG ControlCode) */ #define IoGetFunctionCodeFromCtlCode(_ControlCode) \ (((_ControlCode) >> 2) & 0x00000FFF) FORCEINLINE VOID IoCopyCurrentIrpStackLocationToNext( _Inout_ PIRP Irp) { PIO_STACK_LOCATION irpSp; PIO_STACK_LOCATION nextIrpSp; irpSp = IoGetCurrentIrpStackLocation(Irp); nextIrpSp = IoGetNextIrpStackLocation(Irp); RtlCopyMemory(nextIrpSp, irpSp, FIELD_OFFSET(IO_STACK_LOCATION, CompletionRoutine)); nextIrpSp->Control = 0; } _IRQL_requires_max_(APC_LEVEL) NTKERNELAPI VOID NTAPI IoGetStackLimits( _Out_ PULONG_PTR LowLimit, _Out_ PULONG_PTR HighLimit); _IRQL_requires_max_(APC_LEVEL) FORCEINLINE ULONG_PTR IoGetRemainingStackSize(VOID) { ULONG_PTR End, Begin; ULONG_PTR Result; IoGetStackLimits(&Begin, &End); Result = (ULONG_PTR)(&End) - Begin; return Result; } #if (NTDDI_VERSION >= NTDDI_WS03) FORCEINLINE VOID IoInitializeThreadedDpcRequest( _In_ PDEVICE_OBJECT DeviceObject, _In_ PIO_DPC_ROUTINE DpcRoutine) { #ifdef _MSC_VER #pragma warning(push) #pragma warning(disable:28024) #pragma warning(disable:28128) #endif KeInitializeThreadedDpc(&DeviceObject->Dpc, (PKDEFERRED_ROUTINE) DpcRoutine, DeviceObject ); #ifdef _MSC_VER #pragma warning(pop) #endif } #endif $endif (_WDMDDK_)