classp.h File Reference

#include <stddef.h>
#include <stdarg.h>
#include <stdlib.h>
#include <ntddk.h>
#include <scsi.h>
#include <wmidata.h>
#include <classpnp.h>
#include <storduid.h>
#include <mountdev.h>
#include <ioevent.h>
#include <ntstrsafe.h>
#include <ntintsafe.h>
#include <wdmguid.h>
#include <ntpoapi.h>
#include <srbhelper.h>
#include <storswtr.h>

Include dependency graph for classp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_MEDIA_CHANGE_DETECTION_INFO
struct	_FAILURE_PREDICTION_INFO
struct	_CLASS_RETRY_INFO
struct	_CSCAN_LIST
struct	_CLASS_ERROR_LOG_DATA
struct	_TRANSFER_PACKET
struct	_PNL_SLIST_HEADER
struct	_CLASS_PRIVATE_FDO_DATA
struct	_CLASS_PRIVATE_COMMON_DATA
struct	_IDLE_POWER_FDO_LIST_ENTRY
struct	_OFFLOAD_READ_CONTEXT
struct	_OFFLOAD_WRITE_CONTEXT
struct	_OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER
struct	_IO_RETRIED_LOG_MESSAGE_CONTEXT

Macros
#define	RTL_USE_AVL_TABLES   0
#define	DEBUG_COMP_ID   DPFLTR_CLASSPNP_ID
#define	WPP_GUID_CLASSPNP   (FA8DE7C4, ACDE, 4443, 9994, C4E2359A9EDB)
#define	WPP_CONTROL_GUIDS   WPP_CONTROL_GUIDS_NORMAL_FLAGS(WPP_GUID_CLASSPNP)
#define	PTRALIGN
#define	Add2Ptr(P, I)   ((PVOID)((PUCHAR)(P) + (I)))
#define	CLASSP_REG_SUBKEY_NAME   (L"Classpnp")
#define	CLASSP_REG_HACK_VALUE_NAME   (L"HackMask")
#define	CLASSP_REG_MMC_DETECTION_VALUE_NAME   (L"MMCDetectionState")
#define	CLASSP_REG_WRITE_CACHE_VALUE_NAME   (L"WriteCacheEnableOverride")
#define	CLASSP_REG_PERF_RESTORE_VALUE_NAME   (L"RestorePerfAtCount")
#define	CLASSP_REG_REMOVAL_POLICY_VALUE_NAME   (L"UserRemovalPolicy")
#define	CLASSP_REG_IDLE_INTERVAL_NAME   (L"IdleInterval")
#define	CLASSP_REG_IDLE_ACTIVE_MAX   (L"IdleOutstandingIoMax")
#define	CLASSP_REG_IDLE_PRIORITY_SUPPORTED   (L"IdlePrioritySupported")
#define	CLASSP_REG_ACCESS_ALIGNMENT_NOT_SUPPORTED   (L"AccessAlignmentQueryNotSupported")
#define	CLASSP_REG_DISBALE_IDLE_POWER_NAME   (L"DisableIdlePowerManagement")
#define	CLASSP_REG_IDLE_TIMEOUT_IN_SECONDS   (L"IdleTimeoutInSeconds")
#define	CLASSP_REG_DISABLE_D3COLD   (L"DisableD3Cold")
#define	CLASSP_REG_QERR_OVERRIDE_MODE   (L"QERROverrideMode")
#define	CLASSP_REG_LEGACY_ERROR_HANDLING   (L"LegacyErrorHandling")
#define	CLASSP_REG_COPY_OFFLOAD_MAX_TARGET_DURATION   (L"CopyOffloadMaxTargetDuration")
#define	CLASS_PERF_RESTORE_MINIMUM   (0x10)
#define	CLASS_ERROR_LEVEL_1   (0x4)
#define	CLASS_ERROR_LEVEL_2   (0x8)
#define	CLASS_MAX_INTERLEAVE_PER_CRITICAL_IO   (0x4)
#define	FDO_HACK_CANNOT_LOCK_MEDIA   (0x00000001)
#define	FDO_HACK_GESN_IS_BAD   (0x00000002)
#define	FDO_HACK_NO_SYNC_CACHE   (0x00000004)
#define	FDO_HACK_NO_RESERVE6   (0x00000008)
#define	FDO_HACK_GESN_IGNORE_OPCHANGE   (0x00000010)
#define	FDO_HACK_VALID_FLAGS   (0x0000001F)
#define	FDO_HACK_INVALID_FLAGS   (~FDO_HACK_VALID_FLAGS)
#define	NUM_LOCKMEDIAREMOVAL_RETRIES   1
#define	NUM_MODESENSE_RETRIES   1
#define	NUM_MODESELECT_RETRIES   1
#define	NUM_DRIVECAPACITY_RETRIES   1
#define	NUM_THIN_PROVISIONING_RETRIES   32
#define	NUM_IO_RETRIES   MAXIMUM_RETRIES
#define	LEGACY_NUM_IO_RETRIES   8
#define	CLASS_FILE_OBJECT_EXTENSION_KEY   'eteP'
#define	CLASSP_VOLUME_VERIFY_CHECKED   0x34
#define	CLASS_TAG_PRIVATE_DATA   'CPcS'
#define	CLASS_TAG_SENSE2   '2ScS'
#define	CLASS_TAG_WORKING_SET   'sWcS'
#define	CLASSPNP_POOL_TAG_GENERIC   'pCcS'
#define	CLASSPNP_POOL_TAG_TOKEN_OPERATION   'oTcS'
#define	CLASSPNP_POOL_TAG_SRB   'rScS'
#define	CLASSPNP_POOL_TAG_VPD   'pVcS'
#define	CLASSPNP_POOL_TAG_LOG_MESSAGE   'mlcS'
#define	CLASSPNP_POOL_TAG_ADDITIONAL_DATA   'DAcS'
#define	CLASSPNP_POOL_TAG_FIRMWARE   'wFcS'
#define	MAX_LIST_IDENTIFIER   MAXULONG
#define	NUM_POPULATE_TOKEN_RETRIES   1
#define	NUM_WRITE_USING_TOKEN_RETRIES   2
#define	NUM_RECEIVE_TOKEN_INFORMATION_RETRIES   2
#define	MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH   MAXUSHORT
#define	MAX_RECEIVE_TOKEN_INFORMATION_PARAMETER_DATA_LENGTH   MAXULONG
#define	MAX_TOKEN_TRANSFER_SIZE   MAXULONGLONG
#define	MAX_NUMBER_BLOCKS_PER_BLOCK_DEVICE_RANGE_DESCRIPTOR   MAXULONG
#define	DEFAULT_MAX_TARGET_DURATION   4
#define	DEFAULT_MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN   (64ULL * 1024 * 1024)
#define	MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN   (256ULL * 1024 * 1024)
#define	MIN_TOKEN_LIST_IDENTIFIERS   256
#define	MAX_TOKEN_LIST_IDENTIFIERS   MAXULONG
#define	MAX_NUMBER_BLOCK_DEVICE_DESCRIPTORS   64
#define	REG_DISK_CLASS_CONTROL   L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control\\DISK"
#define	REG_MAX_LIST_IDENTIFIER_VALUE   L"MaximumListIdentifier"
#define	VPD_PAGE_HEADER_SIZE   0x04
#define	GET_LBA_STATUS_RETRY_COUNT_MAX   (2)
#define	SHIFT10000   13
#define	CONST_MSECS_PER_SEC   1000
#define	Convert100nsToMilliseconds(LARGE_INTEGER)
#define	ConvertMillisecondsTo100ns(MILLISECONDS)
#define	NUM_ERROR_LOG_ENTRIES   16
#define	DBG_NUM_PACKET_LOG_ENTRIES   (64*2)
#define	MIN_INITIAL_TRANSFER_PACKETS   1
#define	MIN_WORKINGSET_TRANSFER_PACKETS_Client   16
#define	MAX_WORKINGSET_TRANSFER_PACKETS_Client   32
#define	MIN_WORKINGSET_TRANSFER_PACKETS_Server_UpperBound   256
#define	MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound   32
#define	MAX_WORKINGSET_TRANSFER_PACKETS_Server   1024
#define	MIN_WORKINGSET_TRANSFER_PACKETS_SPACES   512
#define	MAX_WORKINGSET_TRANSFER_PACKETS_SPACES   2048
#define	MAX_OUTSTANDING_IO_PER_LUN_DEFAULT   16
#define	MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE   8192
#define	QERR_SET_ZERO_ODX_OR_TP_ONLY   0
#define	QERR_SET_ZERO_ALWAYS   1
#define	QERR_SET_ZERO_NEVER   2
#define	MIN(a, b)   ((a) < (b) ? (a) : (b))
#define	MAX(a, b)   ((a) > (b) ? (a) : (b))
#define	NOT_READY_RETRY_INTERVAL   10
#define	MINIMUM_RETRY_UNITS   ((LONGLONG)32)
#define	MODE_PAGE_DATA_SIZE   192
#define	CLASS_IDLE_INTERVAL_MIN   12
#define	CLASS_IDLE_INTERVAL   12
#define	CLASS_STARVATION_INTERVAL   500
#define	FIFTY_MS_IN_100NS_UNITS   50 * 100
#define	HISTORYINITIALIZERETRYLOGS(_packet)
#define	HISTORYLOGSENDPACKET(_packet)
#define	HISTORYLOGRETURNEDPACKET(_packet)
#define	TRACKING_FORWARD_PROGRESS_PATH1   (0x00000001)
#define	TRACKING_FORWARD_PROGRESS_PATH2   (0x00000002)
#define	TRACKING_FORWARD_PROGRESS_PATH3   (0x00000004)

Typedefs
typedef struct _MEDIA_CHANGE_DETECTION_INFO	MEDIA_CHANGE_DETECTION_INFO
typedef struct _MEDIA_CHANGE_DETECTION_INFO *	PMEDIA_CHANGE_DETECTION_INFO
typedef enum MEDIA_LOCK_TYPE *	PMEDIA_LOCK_TYPE
typedef struct _FAILURE_PREDICTION_INFO	FAILURE_PREDICTION_INFO
typedef struct _FAILURE_PREDICTION_INFO *	PFAILURE_PREDICTION_INFO
typedef struct _CLASS_RETRY_INFO	CLASS_RETRY_INFO
typedef struct _CLASS_RETRY_INFO *	PCLASS_RETRY_INFO
typedef struct _CSCAN_LIST	CSCAN_LIST
typedef struct _CSCAN_LIST *	PCSCAN_LIST
typedef enum _CLASS_DETECTION_STATE	CLASS_DETECTION_STATE
typedef enum _CLASS_DETECTION_STATE *	PCLASS_DETECTION_STATE
typedef struct _CLASS_ERROR_LOG_DATA	CLASS_ERROR_LOG_DATA
typedef struct _CLASS_ERROR_LOG_DATA *	PCLASS_ERROR_LOG_DATA
typedef VOID(*	PCONTINUATION_ROUTINE) (_In_ PVOID Context)
typedef struct _TRANSFER_PACKET	TRANSFER_PACKET
typedef struct _TRANSFER_PACKET *	PTRANSFER_PACKET
typedef struct _PNL_SLIST_HEADER	PNL_SLIST_HEADER
typedef struct _PNL_SLIST_HEADER *	PPNL_SLIST_HEADER
typedef struct _IDLE_POWER_FDO_LIST_ENTRY	IDLE_POWER_FDO_LIST_ENTRY
typedef struct _IDLE_POWER_FDO_LIST_ENTRY *	PIDLE_POWER_FDO_LIST_ENTRY
typedef struct _OFFLOAD_READ_CONTEXT	OFFLOAD_READ_CONTEXT
typedef struct _OFFLOAD_READ_CONTEXT *	POFFLOAD_READ_CONTEXT
typedef struct _OFFLOAD_WRITE_CONTEXT	OFFLOAD_WRITE_CONTEXT
typedef struct _OFFLOAD_WRITE_CONTEXT *	POFFLOAD_WRITE_CONTEXT
typedef struct _OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER	OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER
typedef struct _OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER *	POPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER
typedef struct _IO_RETRIED_LOG_MESSAGE_CONTEXT	IO_RETRIED_LOG_MESSAGE_CONTEXT
typedef struct _IO_RETRIED_LOG_MESSAGE_CONTEXT *	PIO_RETRIED_LOG_MESSAGE_CONTEXT
typedef PVOID(*	PSRB_ALLOCATE_ROUTINE) (_In_ CLONG ByteSize)

Enumerations
enum	MEDIA_LOCK_TYPE {   SimpleMediaLock, SecureMediaLock, InternalMediaLock, SimpleMediaLock,   SecureMediaLock, InternalMediaLock }
enum	_CLASS_DETECTION_STATE { ClassDetectionUnknown = 0, ClassDetectionUnsupported = 1, ClassDetectionSupported = 2 }

Functions
	C_ASSERT ((sizeof(struct _CLASS_PRIVATE_COMMON_DATA) % sizeof(PVOID))==0)
FORCEINLINE VOID	SimpleInitSlistHdr (SINGLE_LIST_ENTRY *SListHdr)
FORCEINLINE VOID	SimplePushSlist (SINGLE_LIST_ENTRY *SListHdr, SINGLE_LIST_ENTRY *SListEntry)
FORCEINLINE SINGLE_LIST_ENTRY *	SimplePopSlist (SINGLE_LIST_ENTRY *SListHdr)
FORCEINLINE BOOLEAN	SimpleIsSlistEmpty (SINGLE_LIST_ENTRY *SListHdr)
FORCEINLINE BOOLEAN	ClasspIsIdleRequestSupported (PCLASS_PRIVATE_FDO_DATA FdoData, PIRP Irp)
FORCEINLINE VOID	ClasspMarkIrpAsIdle (PIRP Irp, BOOLEAN Idle)
FORCEINLINE BOOLEAN	ClasspIsIdleRequest (PIRP Irp)
FORCEINLINE LARGE_INTEGER	ClasspGetCurrentTime (VOID)
FORCEINLINE ULONGLONG	ClasspTimeDiffToMs (ULONGLONG TimeDiff)
FORCEINLINE BOOLEAN	ClasspSupportsUnmap (_In_ PCLASS_FUNCTION_SUPPORT_INFO SupportInfo)
FORCEINLINE BOOLEAN	ClasspIsThinProvisioned (_In_ PCLASS_FUNCTION_SUPPORT_INFO SupportInfo)
FORCEINLINE BOOLEAN	ClasspIsObsoletePortDriver (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
ULONG	ClasspCalculateLogicalSectorSize (_In_ PDEVICE_OBJECT Fdo, _In_ ULONG BytesPerBlockInBigEndian)
	_Dispatch_type_ (IRP_MJ_CREATE) _Dispatch_type_(IRP_MJ_CLOSE) DRIVER_DISPATCH ClassCreateClose
NTSTATUS	ClasspCreateClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID	ClasspCleanupProtectedLocks (IN PFILE_OBJECT_EXTENSION FsContext)
NTSTATUS	ClasspEjectionControl (IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN MEDIA_LOCK_TYPE LockType, IN BOOLEAN Lock)
	_Dispatch_type_ (IRP_MJ_READ) _Dispatch_type_(IRP_MJ_WRITE) DRIVER_DISPATCH ClassReadWrite
	_Dispatch_type_ (IRP_MJ_DEVICE_CONTROL) DRIVER_DISPATCH ClassDeviceControlDispatch
	_Dispatch_type_ (IRP_MJ_PNP) DRIVER_DISPATCH ClassDispatchPnp
NTSTATUS	ClassPnpStartDevice (IN PDEVICE_OBJECT DeviceObject)
	_Dispatch_type_ (IRP_MJ_SHUTDOWN) _Dispatch_type_(IRP_MJ_FLUSH_BUFFERS) DRIVER_DISPATCH ClassShutdownFlush
	_Dispatch_type_ (IRP_MJ_SYSTEM_CONTROL) DRIVER_DISPATCH ClassSystemControl
VOID	RetryRequest (PDEVICE_OBJECT DeviceObject, PIRP Irp, PSCSI_REQUEST_BLOCK Srb, BOOLEAN Associated, LONGLONG TimeDelta100ns)
NTSTATUS	ClassIoCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS	ClassPnpQueryFdoRelations (IN PDEVICE_OBJECT Fdo, IN PIRP Irp)
NTSTATUS	ClassRetrieveDeviceRelations (IN PDEVICE_OBJECT Fdo, IN DEVICE_RELATION_TYPE RelationType, OUT PDEVICE_RELATIONS *DeviceRelations)
NTSTATUS	ClassGetPdoId (IN PDEVICE_OBJECT Pdo, IN BUS_QUERY_ID_TYPE IdType, IN PUNICODE_STRING IdString)
NTSTATUS	ClassQueryPnpCapabilities (IN PDEVICE_OBJECT PhysicalDeviceObject, IN PDEVICE_CAPABILITIES Capabilities)
NTSTATUS	ClasspPagingNotificationCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_OBJECT RealDeviceObject)
NTSTATUS	ClasspMediaChangeCompletion (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
NTSTATUS	ClasspMcnControl (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PIRP Irp, IN PSCSI_REQUEST_BLOCK Srb)
VOID	ClasspRegisterMountedDeviceInterface (IN PDEVICE_OBJECT DeviceObject)
VOID	ClasspDisableTimer (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID	ClasspEnableTimer (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS	ClasspInitializeTimer (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID	ClasspDeleteTimer (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
BOOLEAN	ClasspUpdateTimerNoWakeTolerance (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS	ClasspDuidQueryProperty (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	ClassInitializeDispatchTables (PCLASS_DRIVER_EXTENSION DriverExtension)
NTSTATUS	ClasspPersistentReserve (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
VOID	InitializeDictionary (IN PDICTIONARY Dictionary)
BOOLEAN	TestDictionarySignature (IN PDICTIONARY Dictionary)
NTSTATUS	AllocateDictionaryEntry (IN PDICTIONARY Dictionary, IN ULONGLONG Key, IN ULONG Size, IN ULONG Tag, OUT PVOID *Entry)
PVOID	GetDictionaryEntry (IN PDICTIONARY Dictionary, IN ULONGLONG Key)
VOID	FreeDictionaryEntry (IN PDICTIONARY Dictionary, IN PVOID Entry)
NTSTATUS	ClasspAllocateReleaseRequest (IN PDEVICE_OBJECT Fdo)
VOID	ClasspFreeReleaseRequest (IN PDEVICE_OBJECT Fdo)
VOID	ClasspReleaseQueue (IN PDEVICE_OBJECT DeviceObject, IN PIRP ReleaseQueueIrp)
VOID	ClasspDisablePowerNotification (PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
	_Dispatch_type_ (IRP_MJ_POWER) DRIVER_DISPATCH ClassDispatchPower
NTSTATUS NTAPI	ClassMinimalPowerHandler (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
_IRQL_requires_same_ NTSTATUS	ClasspEnableIdlePower (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClassAddChild (_In_ PFUNCTIONAL_DEVICE_EXTENSION Parent, _In_ PPHYSICAL_DEVICE_EXTENSION Child, _In_ BOOLEAN AcquireLock)
PPHYSICAL_DEVICE_EXTENSION	ClassRemoveChild (IN PFUNCTIONAL_DEVICE_EXTENSION Parent, IN PPHYSICAL_DEVICE_EXTENSION Child, IN BOOLEAN AcquireLock)
VOID	ClasspRetryDpcTimer (IN PCLASS_PRIVATE_FDO_DATA FdoData)
VOID	ClassFreeOrReuseSrb (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN __drv_freesMem(mem) PSCSI_REQUEST_BLOCK Srb)
VOID	ClassRetryRequest (IN PDEVICE_OBJECT SelfDeviceObject, IN PIRP Irp, _In_ _In_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) IN LONGLONG TimeDelta100ns)
VOID	ClasspBuildRequestEx (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PIRP Irp, _In_ __drv_aliasesMem PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspAllocateReleaseQueueIrp (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS	ClasspAllocatePowerProcessIrp (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS	ClasspInitializeGesn (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PMEDIA_CHANGE_DETECTION_INFO Info)
VOID	ClassSendEjectionNotification (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID	ClasspScanForSpecialInRegistry (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID NTAPI	ClasspScanForClassHacks (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN ULONG_PTR Data)
NTSTATUS	ClasspInitializeHotplugInfo (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID	ClasspPerfIncrementErrorCount (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID	ClasspPerfIncrementSuccessfulIo (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
	__drv_allocatesMem (Mem) PTRANSFER_PACKET NewTransferPacket(PDEVICE_OBJECT Fdo)
VOID	DestroyTransferPacket (_In_ __drv_freesMem(mem) PTRANSFER_PACKET Pkt)
VOID	EnqueueFreeTransferPacket (PDEVICE_OBJECT Fdo, __drv_aliasesMem PTRANSFER_PACKET Pkt)
PTRANSFER_PACKET	DequeueFreeTransferPacket (PDEVICE_OBJECT Fdo, BOOLEAN AllocIfNeeded)
PTRANSFER_PACKET	DequeueFreeTransferPacketEx (_In_ PDEVICE_OBJECT Fdo, _In_ BOOLEAN AllocIfNeeded, _In_ ULONG Node)
VOID	SetupReadWriteTransferPacket (PTRANSFER_PACKET pkt, PVOID Buf, ULONG Len, LARGE_INTEGER DiskLocation, PIRP OriginalIrp)
NTSTATUS	SubmitTransferPacket (PTRANSFER_PACKET Pkt)
NTSTATUS	ServiceTransferRequest (PDEVICE_OBJECT Fdo, PIRP Irp, BOOLEAN PostToDpc)
VOID	TransferPacketQueueRetryDpc (PTRANSFER_PACKET Pkt)
BOOLEAN	InterpretTransferPacketError (PTRANSFER_PACKET Pkt)
BOOLEAN	RetryTransferPacket (PTRANSFER_PACKET Pkt)
VOID	EnqueueDeferredClientIrp (PDEVICE_OBJECT Fdo, PIRP Irp)
PIRP	DequeueDeferredClientIrp (PDEVICE_OBJECT Fdo)
VOID	InitLowMemRetry (PTRANSFER_PACKET Pkt, PVOID BufPtr, ULONG Len, LARGE_INTEGER TargetLocation)
BOOLEAN	StepLowMemRetry (PTRANSFER_PACKET Pkt)
VOID	SetupEjectionTransferPacket (TRANSFER_PACKET *Pkt, BOOLEAN PreventMediaRemoval, PKEVENT SyncEventPtr, PIRP OriginalIrp)
VOID	SetupModeSenseTransferPacket (TRANSFER_PACKET *Pkt, PKEVENT SyncEventPtr, PVOID ModeSenseBuffer, UCHAR ModeSenseBufferLen, UCHAR PageMode, UCHAR SubPage, PIRP OriginalIrp, UCHAR PageControl)
VOID	SetupModeSelectTransferPacket (TRANSFER_PACKET *Pkt, PKEVENT SyncEventPtr, PVOID ModeSelectBuffer, UCHAR ModeSelectBufferLen, BOOLEAN SavePages, PIRP OriginalIrp)
VOID	SetupDriveCapacityTransferPacket (TRANSFER_PACKET *Pkt, PVOID ReadCapacityBuffer, ULONG ReadCapacityBufferLen, PKEVENT SyncEventPtr, PIRP OriginalIrp, BOOLEAN Use16ByteCdb)
PMDL	BuildDeviceInputMdl (PVOID Buffer, ULONG BufferLen)
PMDL	ClasspBuildDeviceMdl (PVOID Buffer, ULONG BufferLen, BOOLEAN WriteToDevice)
VOID	FreeDeviceInputMdl (PMDL Mdl)
VOID	ClasspFreeDeviceMdl (PMDL Mdl)
NTSTATUS	InitializeTransferPackets (PDEVICE_OBJECT Fdo)
VOID	DestroyAllTransferPackets (PDEVICE_OBJECT Fdo)
VOID	InterpretCapacityData (PDEVICE_OBJECT Fdo, PREAD_CAPACITY_DATA_EX ReadCapacityData)
VOID	CleanupTransferPacketToWorkingSetSize (_In_ PDEVICE_OBJECT Fdo, _In_ BOOLEAN LimitNumPktToDelete, _In_ ULONG Node)
	_IRQL_requires_max_ (APC_LEVEL) _IRQL_requires_min_(PASSIVE_LEVEL) _IRQL_requires_same_ VOID ClasspSetupPopulateTokenTransferPacket(_In_ __drv_aliasesMem POFFLOAD_READ_CONTEXT OffloadReadContext
_In_ PTRANSFER_PACKET _In_ ULONG	_In_reads_bytes_ (Length) PUCHAR PopulateTokenBuffer
ULONG	ClasspModeSense (_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageMode, _In_ UCHAR PageControl)
NTSTATUS	ClasspModeSelect (_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSelectBuffer, _In_ ULONG Length, _In_ BOOLEAN SavePages)
NTSTATUS	ClasspWriteCacheProperty (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspAccessAlignmentProperty (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceSeekPenaltyProperty (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceGetLBProvisioningVPDPage (_In_ PDEVICE_OBJECT DeviceObject, _Inout_opt_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceGetBlockDeviceCharacteristicsVPDPage (_In_ PFUNCTIONAL_DEVICE_EXTENSION fdoExtension, _In_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceGetBlockLimitsVPDPage (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _Inout_bytecount_(SrbSize) PSCSI_REQUEST_BLOCK Srb, _In_ ULONG SrbSize, _Out_ PCLASS_VPD_B0_DATA BlockLimitsData)
NTSTATUS	ClasspDeviceTrimProperty (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceLBProvisioningProperty (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceTrimProcess (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PGUID ActivityId, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceGetLBAStatus (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceGetLBAStatusWorker (_In_ PDEVICE_OBJECT DeviceObject, _In_ PCLASS_VPD_B0_DATA BlockLimitsData, _In_ ULONGLONG StartingOffset, _In_ ULONGLONG LengthInBytes, _Out_ PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT DsmOutput, _Inout_ PULONG DsmOutputLength, _Inout_ PSCSI_REQUEST_BLOCK Srb, _In_ BOOLEAN ConsolidateableBlocksOnly, _In_ ULONG OutputVersion, _Out_ PBOOLEAN BlockLimitsDataMayHaveChanged)
VOID	ClassQueueThresholdEventWorker (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClassQueueResourceExhaustionEventWorker (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClassQueueCapacityChangedEventWorker (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClassQueueProvisioningTypeChangedEventWorker (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClasspQueueLogIOEventWithContextWorker (_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG SenseBufferSize, _In_ PVOID SenseData, _In_ UCHAR SrbStatus, _In_ UCHAR ScsiStatus, _In_ ULONG ErrorCode, _In_ ULONG CdbLength, _In_opt_ PCDB Cdb, _In_opt_ PTRANSFER_PACKET Pkt)
VOID	ClasspZeroQERR (_In_ PDEVICE_OBJECT DeviceObject)
	_IRQL_requires_max_ (PASSIVE_LEVEL) NTSTATUS ClasspGetMaximumTokenListIdentifier(_In_ PDEVICE_OBJECT DeviceObject
_IRQL_requires_same_ NTSTATUS	ClasspGetTokenOperationCommandBufferLength (_In_ PDEVICE_OBJECT Fdo, _In_ ULONG ServiceAction, _Inout_ PULONG CommandBufferLength, _Out_opt_ PULONG TokenOperationBufferLength, _Out_opt_ PULONG ReceiveTokenInformationBufferLength)
_IRQL_requires_same_ NTSTATUS	ClasspGetTokenOperationDescriptorLimits (_In_ PDEVICE_OBJECT Fdo, _In_ ULONG ServiceAction, _In_ ULONG MaxParameterBufferLength, _Out_ PULONG MaxBlockDescriptorsCount, _Out_ PULONGLONG MaxBlockDescriptorsLength)
NTSTATUS	ClasspDeviceMediaTypeProperty (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
_IRQL_requires_same_ PUCHAR	ClasspBinaryToAscii (_In_reads_(Length) PUCHAR HexBuffer, _In_ ULONG Length, _Inout_ PULONG UpdateLength)
FORCEINLINE BOOLEAN	ClasspIsTokenOperationComplete (_In_ ULONG CurrentStatus)
FORCEINLINE BOOLEAN	ClasspIsTokenOperation (_In_ PCDB Cdb)
FORCEINLINE BOOLEAN	ClasspIsReceiveTokenInformation (_In_ PCDB Cdb)
FORCEINLINE BOOLEAN	ClasspIsOffloadDataTransferCommand (_In_ PCDB Cdb)
VOID	ClasspInitializeIdleTimer (PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS	ClasspIsPortable (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _Out_ PBOOLEAN IsPortable)
VOID	ClasspGetInquiryVpdSupportInfo (_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS	ClasspGetLBProvisioningInfo (_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
	_IRQL_requires_ (PASSIVE_LEVEL) _IRQL_requires_same_ NTSTATUS ClassDetermineTokenOperationCommandSupport(_In_ PDEVICE_OBJECT DeviceObject)
_IRQL_requires_same_ NTSTATUS	ClasspGetBlockDeviceTokenLimitsInfo (_Inout_ PDEVICE_OBJECT DeviceObject)
_IRQL_requires_same_ VOID	ClasspReceivePopulateTokenInformation (_In_ POFFLOAD_READ_CONTEXT OffloadReadContext)
_IRQL_requires_same_ VOID	ClasspReceiveWriteUsingTokenInformation (_In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
VOID	ClasspCompleteOffloadRequest (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ NTSTATUS CompletionStatus)
VOID	ClasspCleanupOffloadReadContext (_In_ __drv_freesMem(mem) POFFLOAD_READ_CONTEXT OffloadReadContext)
VOID	ClasspCompleteOffloadRead (_In_ POFFLOAD_READ_CONTEXT OffloadReadContext, _In_ NTSTATUS CompletionStatus)
VOID	ClasspPopulateTokenTransferPacketDone (_In_ PVOID Context)
VOID	ClasspReceivePopulateTokenInformationTransferPacketDone (_In_ PVOID Context)
VOID	ClasspContinueOffloadWrite (_In_ __drv_aliasesMem POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
VOID	ClasspCleanupOffloadWriteContext (_In_ __drv_freesMem(mem) POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
VOID	ClasspCompleteOffloadWrite (_In_ __drv_freesMem(Mem) POFFLOAD_WRITE_CONTEXT OffloadWriteContext, _In_ NTSTATUS CompletionCausingStatus)
VOID	ClasspReceiveWriteUsingTokenInformationDone (_In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext, _In_ NTSTATUS CompletionCausingStatus)
VOID	ClasspWriteUsingTokenTransferPacketDone (_In_ PVOID Context)
VOID	ClasspReceiveWriteUsingTokenInformationTransferPacketDone (_In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
NTSTATUS	ClasspRefreshFunctionSupportInfo (_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ BOOLEAN ForceQuery)
NTSTATUS	ClasspBlockLimitsDataSnapshot (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ BOOLEAN ForceQuery, _Out_ PCLASS_VPD_B0_DATA BlockLimitsData, _Out_ PULONG GenerationCount)
NTSTATUS	InterpretReadCapacity16Data (_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PREAD_CAPACITY16_DATA ReadCapacity16Data)
NTSTATUS	ClassReadCapacity16 (_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClassDeviceGetLBProvisioningResources (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
_IRQL_requires_same_ NTSTATUS	ClasspStorageEventNotification (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
NTSTATUS	ClasspLogSystemEventWithDeviceNumber (_In_ PDEVICE_OBJECT DeviceObject, _In_ NTSTATUS IoErrorCode)
NTSTATUS	ClasspEnqueueIdleRequest (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	ClasspCompleteIdleRequest (PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS	ClasspPriorityHint (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	HistoryInitializeRetryLogs (_Out_ PSRB_HISTORY History, ULONG HistoryCount)
VOID	HistoryLogSendPacket (TRANSFER_PACKET *Pkt)
VOID	HistoryLogReturnedPacket (TRANSFER_PACKET *Pkt)
BOOLEAN	InterpretSenseInfoWithoutHistory (_In_ PDEVICE_OBJECT Fdo, _In_opt_ PIRP OriginalRequest, _In_ PSCSI_REQUEST_BLOCK Srb, UCHAR MajorFunctionCode, ULONG IoDeviceCode, ULONG PreviousRetryCount, _Out_ NTSTATUS *Status, _Out_opt_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *RetryIn100nsUnits)
BOOLEAN	ClasspMyStringMatches (_In_opt_z_ PCHAR StringToMatch, _In_z_ PCHAR TargetString)
VOID	ClasspInitializeRemoveTracking (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClasspUninitializeRemoveTracking (_In_ PDEVICE_OBJECT DeviceObject)
PVOID	DefaultStorageRequestBlockAllocateRoutine (_In_ CLONG ByteSize)
NTSTATUS	CreateStorageRequestBlock (_Inout_ PSTORAGE_REQUEST_BLOCK *Srb, _In_ USHORT AddressType, _In_opt_ PSRB_ALLOCATE_ROUTINE AllocateRoutine, _Inout_opt_ ULONG *ByteSize, _In_ ULONG NumSrbExData,...)
NTSTATUS	InitializeStorageRequestBlock (_Inout_bytecount_(ByteSize) PSTORAGE_REQUEST_BLOCK Srb, _In_ USHORT AddressType, _In_ ULONG ByteSize, _In_ ULONG NumSrbExData,...)
VOID	ClasspConvertToScsiRequestBlock (_Out_ PSCSI_REQUEST_BLOCK Srb, _In_ PSTORAGE_REQUEST_BLOCK SrbEx)
FORCEINLINE PCDB	ClasspTransferPacketGetCdb (_In_ PTRANSFER_PACKET Pkt)
FORCEINLINE BOOLEAN	ClasspTransferPacketGetNumberOfRetriesDone (_In_ PTRANSFER_PACKET Pkt, _In_ PCDB Cdb, _Out_ PULONG TimesAlreadyRetried)
FORCEINLINE PVOID	ClasspTransferPacketGetSenseInfoBuffer (_In_ PTRANSFER_PACKET Pkt)
FORCEINLINE UCHAR	ClasspTransferPacketGetSenseInfoBufferLength (_In_ PTRANSFER_PACKET Pkt)
FORCEINLINE VOID	ClasspSrbSetOriginalIrp (_In_ PSTORAGE_REQUEST_BLOCK_HEADER Srb, _In_ PIRP Irp)
FORCEINLINE BOOLEAN	PORT_ALLOCATED_SENSE_EX (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PSTORAGE_REQUEST_BLOCK_HEADER Srb)
FORCEINLINE VOID	FREE_PORT_ALLOCATED_SENSE_BUFFER_EX (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PSTORAGE_REQUEST_BLOCK_HEADER Srb)
BOOLEAN	ClasspFailurePredictionPeriodMissed (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
FORCEINLINE ULONG	ClasspGetMaxUsableBufferLengthFromOffset (_In_ PVOID BaseAddress, _In_ ULONG OffsetInBytes, _In_ ULONG BaseStructureSizeInBytes)
BOOLEAN	ClasspIsThinProvisioningError (_In_ PSCSI_REQUEST_BLOCK _Srb)
FORCEINLINE BOOLEAN	ClasspLowerLayerNotSupport (_In_ NTSTATUS Status)
NTSTATUS	ClassDeviceHwFirmwareGetInfoProcess (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
NTSTATUS	ClassDeviceHwFirmwareDownloadProcess (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClassDeviceHwFirmwareActivateProcess (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)

Variables
CLASSPNP_SCAN_FOR_SPECIAL_INFO	ClassBadItems []
GUID	ClassGuidQueryRegInfoEx
GUID	ClassGuidSenseInfo2
GUID	ClassGuidWorkingSet
GUID	ClassGuidSrbSupport
ULONG	ClassMaxInterleavePerCriticalIo
ULONG	MaxTokenOperationListIdentifier
volatile ULONG	TokenOperationListIdentifier
LIST_ENTRY	IdlePowerFDOList
PVOID	PowerSettingNotificationHandle
PVOID	ScreenStateNotificationHandle
BOOLEAN	ClasspScreenOff
KGUARDED_MUTEX	IdlePowerFDOListMutex
ULONG	DiskIdleTimeoutInMS
CONST LARGE_INTEGER	Magic10000
DRIVER_INITIALIZE	DriverEntry
DRIVER_UNLOAD	ClassUnload
DRIVER_ADD_DEVICE	ClassAddDevice
IO_COMPLETION_ROUTINE	ClasspSendSynchronousCompletion
DRIVER_STARTIO	ClasspStartIo
IO_COMPLETION_ROUTINE	ClassReleaseQueueCompletion
POWER_SETTING_CALLBACK	ClasspPowerSettingCallback
KDEFERRED_ROUTINE	ClasspRetryRequestDpc
IO_WORKITEM_ROUTINE	ClasspUpdateDiskProperties
IO_COMPLETION_ROUTINE	TransferPktComplete
KDEFERRED_ROUTINE	TransferPacketRetryTimerDpc
IO_WORKITEM_ROUTINE_EX	CleanupTransferPacketToWorkingSetSizeWorker
_In_ PTRANSFER_PACKET	Pkt
_In_ PTRANSFER_PACKET _In_ ULONG	Length
_In_ PTRANSFER_PACKET _In_ ULONG _In_ PIRP	OriginalIrp
_In_ PTRANSFER_PACKET _In_ ULONG _In_ PIRP _In_ ULONG	ListIdentifier
IO_WORKITEM_ROUTINE	ClasspLogIOEventWithContext
_In_z_ PWSTR	RegistryPath
_In_z_ PWSTR _Out_ PULONG	MaximumListIdentifier
_In_z_ PWSTR _Out_ PULONG	MaxDuration
_Inout_ PIRP	Irp
_Inout_ PIRP _Inout_ PSCSI_REQUEST_BLOCK	Srb
_In_ PVOID	BlockDescr
_In_ PVOID _Inout_ PULONG	CurrentBlockDescrIndex
_In_ PVOID _Inout_ PULONG _In_ ULONG	MaxBlockDescrCount
_In_ PVOID _Inout_ PULONG _In_ ULONG _Inout_ PULONG	CurrentLbaCount
_In_ PVOID _Inout_ PULONG _In_ ULONG _Inout_ PULONG _In_ ULONGLONG	MaxLbaCount
_In_ PVOID _Inout_ PULONG _In_ ULONG _Inout_ PULONG _In_ ULONGLONG _Inout_ PDEVICE_DATA_SET_RANGE	DataSetRange
_In_ PVOID _Inout_ PULONG _In_ ULONG _Inout_ PULONG _In_ ULONGLONG _Inout_ PDEVICE_DATA_SET_RANGE _Inout_ PULONGLONG	TotalSectorsProcessed
LIST_ENTRY	AllFdosList
IO_WORKITEM_ROUTINE	ClassLogThresholdEvent
IO_WORKITEM_ROUTINE	ClassLogResourceExhaustionEvent
RTL_GENERIC_COMPARE_ROUTINE	RemoveTrackingCompareRoutine
RTL_GENERIC_ALLOCATE_ROUTINE	RemoveTrackingAllocateRoutine
RTL_GENERIC_FREE_ROUTINE	RemoveTrackingFreeRoutine

Macro Definition Documentation

Add2Ptr

#define Add2Ptr	(		P,
			I
	)		((PVOID)((PUCHAR)(P) + (I)))

Definition at line 110 of file classp.h.

CLASS_ERROR_LEVEL_1

#define CLASS_ERROR_LEVEL_1   (0x4)

Definition at line 131 of file classp.h.

CLASS_ERROR_LEVEL_2

#define CLASS_ERROR_LEVEL_2   (0x8)

Definition at line 132 of file classp.h.

CLASS_FILE_OBJECT_EXTENSION_KEY

#define CLASS_FILE_OBJECT_EXTENSION_KEY   'eteP'

Definition at line 186 of file classp.h.

CLASS_IDLE_INTERVAL

#define CLASS_IDLE_INTERVAL   12

Definition at line 1199 of file classp.h.

CLASS_IDLE_INTERVAL_MIN

#define CLASS_IDLE_INTERVAL_MIN   12

Definition at line 1198 of file classp.h.

CLASS_MAX_INTERLEAVE_PER_CRITICAL_IO

#define CLASS_MAX_INTERLEAVE_PER_CRITICAL_IO   (0x4)

Definition at line 133 of file classp.h.

CLASS_PERF_RESTORE_MINIMUM

#define CLASS_PERF_RESTORE_MINIMUM   (0x10)

Definition at line 130 of file classp.h.

CLASS_STARVATION_INTERVAL

#define CLASS_STARVATION_INTERVAL   500

Definition at line 1200 of file classp.h.

CLASS_TAG_PRIVATE_DATA

#define CLASS_TAG_PRIVATE_DATA   'CPcS'

Definition at line 189 of file classp.h.

CLASS_TAG_SENSE2

#define CLASS_TAG_SENSE2   '2ScS'

Definition at line 190 of file classp.h.

CLASS_TAG_WORKING_SET

#define CLASS_TAG_WORKING_SET   'sWcS'

Definition at line 191 of file classp.h.

CLASSP_REG_ACCESS_ALIGNMENT_NOT_SUPPORTED

#define CLASSP_REG_ACCESS_ALIGNMENT_NOT_SUPPORTED   (L"AccessAlignmentQueryNotSupported")

Definition at line 122 of file classp.h.

CLASSP_REG_COPY_OFFLOAD_MAX_TARGET_DURATION

#define CLASSP_REG_COPY_OFFLOAD_MAX_TARGET_DURATION   (L"CopyOffloadMaxTargetDuration")

Definition at line 128 of file classp.h.

CLASSP_REG_DISABLE_D3COLD

#define CLASSP_REG_DISABLE_D3COLD   (L"DisableD3Cold")

Definition at line 125 of file classp.h.

CLASSP_REG_DISBALE_IDLE_POWER_NAME

#define CLASSP_REG_DISBALE_IDLE_POWER_NAME   (L"DisableIdlePowerManagement")

Definition at line 123 of file classp.h.

CLASSP_REG_HACK_VALUE_NAME

#define CLASSP_REG_HACK_VALUE_NAME   (L"HackMask")

Definition at line 114 of file classp.h.

CLASSP_REG_IDLE_ACTIVE_MAX

#define CLASSP_REG_IDLE_ACTIVE_MAX   (L"IdleOutstandingIoMax")

Definition at line 120 of file classp.h.

CLASSP_REG_IDLE_INTERVAL_NAME

#define CLASSP_REG_IDLE_INTERVAL_NAME   (L"IdleInterval")

Definition at line 119 of file classp.h.

CLASSP_REG_IDLE_PRIORITY_SUPPORTED

#define CLASSP_REG_IDLE_PRIORITY_SUPPORTED   (L"IdlePrioritySupported")

Definition at line 121 of file classp.h.

CLASSP_REG_IDLE_TIMEOUT_IN_SECONDS

#define CLASSP_REG_IDLE_TIMEOUT_IN_SECONDS   (L"IdleTimeoutInSeconds")

Definition at line 124 of file classp.h.

CLASSP_REG_LEGACY_ERROR_HANDLING

#define CLASSP_REG_LEGACY_ERROR_HANDLING   (L"LegacyErrorHandling")

Definition at line 127 of file classp.h.

CLASSP_REG_MMC_DETECTION_VALUE_NAME

#define CLASSP_REG_MMC_DETECTION_VALUE_NAME   (L"MMCDetectionState")

Definition at line 115 of file classp.h.

CLASSP_REG_PERF_RESTORE_VALUE_NAME

#define CLASSP_REG_PERF_RESTORE_VALUE_NAME   (L"RestorePerfAtCount")

Definition at line 117 of file classp.h.

CLASSP_REG_QERR_OVERRIDE_MODE

#define CLASSP_REG_QERR_OVERRIDE_MODE   (L"QERROverrideMode")

Definition at line 126 of file classp.h.

CLASSP_REG_REMOVAL_POLICY_VALUE_NAME

#define CLASSP_REG_REMOVAL_POLICY_VALUE_NAME   (L"UserRemovalPolicy")

Definition at line 118 of file classp.h.

CLASSP_REG_SUBKEY_NAME

#define CLASSP_REG_SUBKEY_NAME   (L"Classpnp")

Definition at line 112 of file classp.h.

CLASSP_REG_WRITE_CACHE_VALUE_NAME

#define CLASSP_REG_WRITE_CACHE_VALUE_NAME   (L"WriteCacheEnableOverride")

Definition at line 116 of file classp.h.

CLASSP_VOLUME_VERIFY_CHECKED

#define CLASSP_VOLUME_VERIFY_CHECKED   0x34

Definition at line 187 of file classp.h.

CLASSPNP_POOL_TAG_ADDITIONAL_DATA

#define CLASSPNP_POOL_TAG_ADDITIONAL_DATA   'DAcS'

Definition at line 197 of file classp.h.

CLASSPNP_POOL_TAG_FIRMWARE

#define CLASSPNP_POOL_TAG_FIRMWARE   'wFcS'

Definition at line 198 of file classp.h.

CLASSPNP_POOL_TAG_GENERIC

#define CLASSPNP_POOL_TAG_GENERIC   'pCcS'

Definition at line 192 of file classp.h.

CLASSPNP_POOL_TAG_LOG_MESSAGE

#define CLASSPNP_POOL_TAG_LOG_MESSAGE   'mlcS'

Definition at line 196 of file classp.h.

CLASSPNP_POOL_TAG_SRB

#define CLASSPNP_POOL_TAG_SRB   'rScS'

Definition at line 194 of file classp.h.

CLASSPNP_POOL_TAG_TOKEN_OPERATION

#define CLASSPNP_POOL_TAG_TOKEN_OPERATION   'oTcS'

Definition at line 193 of file classp.h.

CLASSPNP_POOL_TAG_VPD

#define CLASSPNP_POOL_TAG_VPD   'pVcS'

Definition at line 195 of file classp.h.

CONST_MSECS_PER_SEC

#define CONST_MSECS_PER_SEC   1000

Definition at line 251 of file classp.h.

Convert100nsToMilliseconds

#define Convert100nsToMilliseconds

(

LARGE_INTEGER

)

Value:

(                                                                   \
    RtlExtendedMagicDivide((LARGE_INTEGER), Magic10000, SHIFT10000)     \
    )

Definition at line 253 of file classp.h.

ConvertMillisecondsTo100ns

#define ConvertMillisecondsTo100ns

(

MILLISECONDS

)

Value:

(                      \
    RtlExtendedIntegerMultiply ((MILLISECONDS), 10000)                  \
    )

Definition at line 258 of file classp.h.

DBG_NUM_PACKET_LOG_ENTRIES

#define DBG_NUM_PACKET_LOG_ENTRIES   (64*2)

Definition at line 487 of file classp.h.

DEBUG_COMP_ID

#define DEBUG_COMP_ID   DPFLTR_CLASSPNP_ID

Definition at line 78 of file classp.h.

DEFAULT_MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN

#define DEFAULT_MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN   (64ULL * 1024 * 1024)

Definition at line 212 of file classp.h.

DEFAULT_MAX_TARGET_DURATION

#define DEFAULT_MAX_TARGET_DURATION   4

Definition at line 211 of file classp.h.

FDO_HACK_CANNOT_LOCK_MEDIA

#define FDO_HACK_CANNOT_LOCK_MEDIA   (0x00000001)

Definition at line 135 of file classp.h.

FDO_HACK_GESN_IGNORE_OPCHANGE

#define FDO_HACK_GESN_IGNORE_OPCHANGE   (0x00000010)

Definition at line 139 of file classp.h.

FDO_HACK_GESN_IS_BAD

#define FDO_HACK_GESN_IS_BAD   (0x00000002)

Definition at line 136 of file classp.h.

FDO_HACK_INVALID_FLAGS

#define FDO_HACK_INVALID_FLAGS   (~FDO_HACK_VALID_FLAGS)

Definition at line 142 of file classp.h.

FDO_HACK_NO_RESERVE6

#define FDO_HACK_NO_RESERVE6   (0x00000008)

Definition at line 138 of file classp.h.

FDO_HACK_NO_SYNC_CACHE

#define FDO_HACK_NO_SYNC_CACHE   (0x00000004)

Definition at line 137 of file classp.h.

FDO_HACK_VALID_FLAGS

#define FDO_HACK_VALID_FLAGS   (0x0000001F)

Definition at line 141 of file classp.h.

FIFTY_MS_IN_100NS_UNITS

#define FIFTY_MS_IN_100NS_UNITS   50 * 100

Definition at line 1205 of file classp.h.

GET_LBA_STATUS_RETRY_COUNT_MAX

#define GET_LBA_STATUS_RETRY_COUNT_MAX   (2)

Definition at line 229 of file classp.h.

HISTORYINITIALIZERETRYLOGS

#define HISTORYINITIALIZERETRYLOGS

(

_packet

)

Value:

{                                                     \
        if (_packet->RetryHistory != NULL)                \
        {                                                 \
            HistoryInitializeRetryLogs(                   \
                _packet->RetryHistory,                    \
                _packet->RetryHistory->TotalHistoryCount  \
                );                                        \
        }                                                 \
    }

Definition at line 2330 of file classp.h.

HISTORYLOGRETURNEDPACKET

#define HISTORYLOGRETURNEDPACKET

(

_packet

)

Value:

{                                          \
        if (_packet->RetryHistory != NULL) {   \
            HistoryLogReturnedPacket(_packet); \
        }                                      \
    }

Definition at line 2357 of file classp.h.

HISTORYLOGSENDPACKET

#define HISTORYLOGSENDPACKET

(

_packet

)

Value:

{                                        \
        if (_packet->RetryHistory != NULL) { \
            HistoryLogSendPacket(_packet);   \
        }                                    \
    }

Definition at line 2345 of file classp.h.

LEGACY_NUM_IO_RETRIES

#define LEGACY_NUM_IO_RETRIES   8

Definition at line 170 of file classp.h.

MAX

#define MAX	(		a,
			b
	)		((a) > (b) ? (a) : (b))

Definition at line 1191 of file classp.h.

MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE

#define MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE   8192

Definition at line 639 of file classp.h.

MAX_LIST_IDENTIFIER

#define MAX_LIST_IDENTIFIER   MAXULONG

Definition at line 203 of file classp.h.

MAX_NUMBER_BLOCK_DEVICE_DESCRIPTORS

#define MAX_NUMBER_BLOCK_DEVICE_DESCRIPTORS   64

Definition at line 216 of file classp.h.

MAX_NUMBER_BLOCKS_PER_BLOCK_DEVICE_RANGE_DESCRIPTOR

#define MAX_NUMBER_BLOCKS_PER_BLOCK_DEVICE_RANGE_DESCRIPTOR   MAXULONG

Definition at line 210 of file classp.h.

MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN

#define MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN   (256ULL * 1024 * 1024)

Definition at line 213 of file classp.h.

MAX_OUTSTANDING_IO_PER_LUN_DEFAULT

#define MAX_OUTSTANDING_IO_PER_LUN_DEFAULT   16

Definition at line 638 of file classp.h.

MAX_RECEIVE_TOKEN_INFORMATION_PARAMETER_DATA_LENGTH

#define MAX_RECEIVE_TOKEN_INFORMATION_PARAMETER_DATA_LENGTH   MAXULONG

Definition at line 208 of file classp.h.

MAX_TOKEN_LIST_IDENTIFIERS

#define MAX_TOKEN_LIST_IDENTIFIERS   MAXULONG

Definition at line 215 of file classp.h.

MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH

#define MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH   MAXUSHORT

Definition at line 207 of file classp.h.

MAX_TOKEN_TRANSFER_SIZE

#define MAX_TOKEN_TRANSFER_SIZE   MAXULONGLONG

Definition at line 209 of file classp.h.

MAX_WORKINGSET_TRANSFER_PACKETS_Client

#define MAX_WORKINGSET_TRANSFER_PACKETS_Client   32

Definition at line 632 of file classp.h.

MAX_WORKINGSET_TRANSFER_PACKETS_Server

#define MAX_WORKINGSET_TRANSFER_PACKETS_Server   1024

Definition at line 635 of file classp.h.

MAX_WORKINGSET_TRANSFER_PACKETS_SPACES

#define MAX_WORKINGSET_TRANSFER_PACKETS_SPACES   2048

Definition at line 637 of file classp.h.

MIN

#define MIN	(		a,
			b
	)		((a) < (b) ? (a) : (b))

Definition at line 1190 of file classp.h.

MIN_INITIAL_TRANSFER_PACKETS

#define MIN_INITIAL_TRANSFER_PACKETS   1

Definition at line 630 of file classp.h.

MIN_TOKEN_LIST_IDENTIFIERS

#define MIN_TOKEN_LIST_IDENTIFIERS   256

Definition at line 214 of file classp.h.

MIN_WORKINGSET_TRANSFER_PACKETS_Client

#define MIN_WORKINGSET_TRANSFER_PACKETS_Client   16

Definition at line 631 of file classp.h.

MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound

#define MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound   32

Definition at line 634 of file classp.h.

MIN_WORKINGSET_TRANSFER_PACKETS_Server_UpperBound

#define MIN_WORKINGSET_TRANSFER_PACKETS_Server_UpperBound   256

Definition at line 633 of file classp.h.

MIN_WORKINGSET_TRANSFER_PACKETS_SPACES

#define MIN_WORKINGSET_TRANSFER_PACKETS_SPACES   512

Definition at line 636 of file classp.h.

MINIMUM_RETRY_UNITS

#define MINIMUM_RETRY_UNITS   ((LONGLONG)32)

Definition at line 1195 of file classp.h.

MODE_PAGE_DATA_SIZE

#define MODE_PAGE_DATA_SIZE   192

Definition at line 1196 of file classp.h.

NOT_READY_RETRY_INTERVAL

#define NOT_READY_RETRY_INTERVAL   10

Definition at line 1194 of file classp.h.

NUM_DRIVECAPACITY_RETRIES

#define NUM_DRIVECAPACITY_RETRIES   1

Definition at line 161 of file classp.h.

NUM_ERROR_LOG_ENTRIES

#define NUM_ERROR_LOG_ENTRIES   16

Definition at line 486 of file classp.h.

NUM_IO_RETRIES

#define NUM_IO_RETRIES   MAXIMUM_RETRIES

Definition at line 169 of file classp.h.

NUM_LOCKMEDIAREMOVAL_RETRIES

#define NUM_LOCKMEDIAREMOVAL_RETRIES   1

Definition at line 158 of file classp.h.

NUM_MODESELECT_RETRIES

#define NUM_MODESELECT_RETRIES   1

Definition at line 160 of file classp.h.

NUM_MODESENSE_RETRIES

#define NUM_MODESENSE_RETRIES   1

Definition at line 159 of file classp.h.

NUM_POPULATE_TOKEN_RETRIES

#define NUM_POPULATE_TOKEN_RETRIES   1

Definition at line 204 of file classp.h.

NUM_RECEIVE_TOKEN_INFORMATION_RETRIES

#define NUM_RECEIVE_TOKEN_INFORMATION_RETRIES   2

Definition at line 206 of file classp.h.

NUM_THIN_PROVISIONING_RETRIES

#define NUM_THIN_PROVISIONING_RETRIES   32

Definition at line 162 of file classp.h.

NUM_WRITE_USING_TOKEN_RETRIES

#define NUM_WRITE_USING_TOKEN_RETRIES   2

Definition at line 205 of file classp.h.

PTRALIGN

#define PTRALIGN

Definition at line 96 of file classp.h.

QERR_SET_ZERO_ALWAYS

#define QERR_SET_ZERO_ALWAYS   1

Definition at line 1186 of file classp.h.

QERR_SET_ZERO_NEVER

#define QERR_SET_ZERO_NEVER   2

Definition at line 1187 of file classp.h.

QERR_SET_ZERO_ODX_OR_TP_ONLY

#define QERR_SET_ZERO_ODX_OR_TP_ONLY   0

Definition at line 1185 of file classp.h.

REG_DISK_CLASS_CONTROL

#define REG_DISK_CLASS_CONTROL   L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Control\\DISK"

Definition at line 218 of file classp.h.

REG_MAX_LIST_IDENTIFIER_VALUE

#define REG_MAX_LIST_IDENTIFIER_VALUE   L"MaximumListIdentifier"

Definition at line 219 of file classp.h.

RTL_USE_AVL_TABLES

#define RTL_USE_AVL_TABLES   0

Definition at line 28 of file classp.h.

SHIFT10000

#define SHIFT10000   13

Definition at line 246 of file classp.h.

TRACKING_FORWARD_PROGRESS_PATH1

#define TRACKING_FORWARD_PROGRESS_PATH1   (0x00000001)

Definition at line 2385 of file classp.h.

TRACKING_FORWARD_PROGRESS_PATH2

#define TRACKING_FORWARD_PROGRESS_PATH2   (0x00000002)

Definition at line 2386 of file classp.h.

TRACKING_FORWARD_PROGRESS_PATH3

#define TRACKING_FORWARD_PROGRESS_PATH3   (0x00000004)

Definition at line 2387 of file classp.h.

VPD_PAGE_HEADER_SIZE

#define VPD_PAGE_HEADER_SIZE   0x04

Definition at line 221 of file classp.h.

WPP_CONTROL_GUIDS

#define WPP_CONTROL_GUIDS   WPP_CONTROL_GUIDS_NORMAL_FLAGS(WPP_GUID_CLASSPNP)

Definition at line 87 of file classp.h.

WPP_GUID_CLASSPNP

#define WPP_GUID_CLASSPNP   (FA8DE7C4, ACDE, 4443, 9994, C4E2359A9EDB)

Definition at line 85 of file classp.h.

Typedef Documentation

CLASS_DETECTION_STATE

typedef enum _CLASS_DETECTION_STATE CLASS_DETECTION_STATE

CLASS_ERROR_LOG_DATA

typedef struct _CLASS_ERROR_LOG_DATA CLASS_ERROR_LOG_DATA

CLASS_RETRY_INFO

typedef struct _CLASS_RETRY_INFO CLASS_RETRY_INFO

CSCAN_LIST

typedef struct _CSCAN_LIST CSCAN_LIST

FAILURE_PREDICTION_INFO

typedef struct _FAILURE_PREDICTION_INFO FAILURE_PREDICTION_INFO

IDLE_POWER_FDO_LIST_ENTRY

typedef struct _IDLE_POWER_FDO_LIST_ENTRY IDLE_POWER_FDO_LIST_ENTRY

IO_RETRIED_LOG_MESSAGE_CONTEXT

typedef struct _IO_RETRIED_LOG_MESSAGE_CONTEXT IO_RETRIED_LOG_MESSAGE_CONTEXT

MEDIA_CHANGE_DETECTION_INFO

typedef struct _MEDIA_CHANGE_DETECTION_INFO MEDIA_CHANGE_DETECTION_INFO

OFFLOAD_READ_CONTEXT

typedef struct _OFFLOAD_READ_CONTEXT OFFLOAD_READ_CONTEXT

OFFLOAD_WRITE_CONTEXT

typedef struct _OFFLOAD_WRITE_CONTEXT OFFLOAD_WRITE_CONTEXT

OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER

typedef struct _OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER

PCLASS_DETECTION_STATE

typedef enum _CLASS_DETECTION_STATE * PCLASS_DETECTION_STATE

PCLASS_ERROR_LOG_DATA

typedef struct _CLASS_ERROR_LOG_DATA * PCLASS_ERROR_LOG_DATA

PCLASS_RETRY_INFO

typedef struct _CLASS_RETRY_INFO * PCLASS_RETRY_INFO

PCONTINUATION_ROUTINE

typedef VOID(* PCONTINUATION_ROUTINE) (_In_ PVOID Context)

Definition at line 492 of file classp.h.

PCSCAN_LIST

typedef struct _CSCAN_LIST * PCSCAN_LIST

PFAILURE_PREDICTION_INFO

typedef struct _FAILURE_PREDICTION_INFO * PFAILURE_PREDICTION_INFO

PIDLE_POWER_FDO_LIST_ENTRY

typedef struct _IDLE_POWER_FDO_LIST_ENTRY * PIDLE_POWER_FDO_LIST_ENTRY

PIO_RETRIED_LOG_MESSAGE_CONTEXT

typedef struct _IO_RETRIED_LOG_MESSAGE_CONTEXT * PIO_RETRIED_LOG_MESSAGE_CONTEXT

PMEDIA_CHANGE_DETECTION_INFO

typedef struct _MEDIA_CHANGE_DETECTION_INFO * PMEDIA_CHANGE_DETECTION_INFO

PMEDIA_LOCK_TYPE

typedef enum MEDIA_LOCK_TYPE * PMEDIA_LOCK_TYPE

PNL_SLIST_HEADER

typedef struct _PNL_SLIST_HEADER PNL_SLIST_HEADER

POFFLOAD_READ_CONTEXT

typedef struct _OFFLOAD_READ_CONTEXT * POFFLOAD_READ_CONTEXT

POFFLOAD_WRITE_CONTEXT

typedef struct _OFFLOAD_WRITE_CONTEXT * POFFLOAD_WRITE_CONTEXT

POPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER

typedef struct _OPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER * POPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER

PPNL_SLIST_HEADER

typedef struct _PNL_SLIST_HEADER * PPNL_SLIST_HEADER

PSRB_ALLOCATE_ROUTINE

typedef PVOID(* PSRB_ALLOCATE_ROUTINE) (_In_ CLONG ByteSize)

Definition at line 2409 of file classp.h.

PTRANSFER_PACKET

typedef struct _TRANSFER_PACKET * PTRANSFER_PACKET

TRANSFER_PACKET

typedef struct _TRANSFER_PACKET TRANSFER_PACKET

Enumeration Type Documentation

_CLASS_DETECTION_STATE

enum _CLASS_DETECTION_STATE

Enumerator
ClassDetectionUnknown
ClassDetectionUnsupported
ClassDetectionSupported

Definition at line 444 of file classp.h.

                                    {
    ClassDetectionUnknown = 0,
    ClassDetectionUnsupported = 1,
    ClassDetectionSupported = 2
} CLASS_DETECTION_STATE, *PCLASS_DETECTION_STATE;

MEDIA_LOCK_TYPE

enum MEDIA_LOCK_TYPE

Enumerator
SimpleMediaLock
SecureMediaLock
InternalMediaLock
SimpleMediaLock
SecureMediaLock
InternalMediaLock

Definition at line 378 of file classp.h.

             {
    SimpleMediaLock,
    SecureMediaLock,
    InternalMediaLock
} MEDIA_LOCK_TYPE, *PMEDIA_LOCK_TYPE;

Function Documentation

__drv_allocatesMem()

__drv_allocatesMem

(

Mem

)

Definition at line 1476 of file exfuncs.h.

{
  PVOID Entry;

  Lookaside->L.TotalAllocates++;
#ifdef NONAMELESSUNION
#if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
  Entry = ExInterlockedPopEntrySList(&Lookaside->L.u.ListHead,
                                     &Lookaside->Lock__ObsoleteButDoNotDelete);
#else
  Entry = InterlockedPopEntrySList(&Lookaside->L.u.ListHead);
#endif
  if (Entry == NULL) {
    Lookaside->L.u2.AllocateMisses++;
    Entry = (Lookaside->L.u4.Allocate)(Lookaside->L.Type,
                                       Lookaside->L.Size,
                                       Lookaside->L.Tag);
  }
#else /* NONAMELESSUNION */
#if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
  Entry = ExInterlockedPopEntrySList(&Lookaside->L.ListHead,
                                     &Lookaside->Lock__ObsoleteButDoNotDelete);
#else
  Entry = InterlockedPopEntrySList(&Lookaside->L.ListHead);
#endif
  if (Entry == NULL) {
    Lookaside->L.AllocateMisses++;
    Entry = (Lookaside->L.Allocate)(Lookaside->L.Type,
                                    Lookaside->L.Size,
                                    Lookaside->L.Tag);
  }
#endif /* NONAMELESSUNION */
  return Entry;
}

_Dispatch_type_() [1/7]

_Dispatch_type_

(

IRP_MJ_CREATE

)

Definition at line 984 of file isapnp.c.

{
    PAGED_CODE();

    Irp->IoStatus.Status = STATUS_SUCCESS;

    DPRINT("%s(%p, %p)\n", __FUNCTION__, DeviceObject, Irp);

    IoCompleteRequest(Irp, IO_NO_INCREMENT);

    return STATUS_SUCCESS;
}

_Dispatch_type_() [2/7]

_Dispatch_type_

(

IRP_MJ_READ

)

Definition at line 3505 of file read.c.

                                                                   {
    device_extension* Vcb = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PFILE_OBJECT FileObject = IrpSp->FileObject;
    ULONG bytes_read = 0;
    NTSTATUS Status;
    bool top_level;
    fcb* fcb;
    ccb* ccb;
    bool acquired_fcb_lock = false, wait;

    FsRtlEnterFileSystem();

    top_level = is_top_level(Irp);

    TRACE("read\n");

    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = vol_read(DeviceObject, Irp);
        goto exit2;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }

    Irp->IoStatus.Information = 0;

    if (IrpSp->MinorFunction & IRP_MN_COMPLETE) {
        CcMdlReadComplete(IrpSp->FileObject, Irp->MdlAddress);

        Irp->MdlAddress = NULL;
        Status = STATUS_SUCCESS;

        goto exit;
    }

    fcb = FileObject->FsContext;

    if (!fcb) {
        ERR("fcb was NULL\n");
        Status = STATUS_INVALID_PARAMETER;
        goto exit;
    }

    ccb = FileObject->FsContext2;

    if (!ccb) {
        ERR("ccb was NULL\n");
        Status = STATUS_INVALID_PARAMETER;
        goto exit;
    }

    if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_READ_DATA)) {
        WARN("insufficient privileges\n");
        Status = STATUS_ACCESS_DENIED;
        goto exit;
    }

    if (fcb == Vcb->volume_fcb) {
        TRACE("reading volume FCB\n");

        IoSkipCurrentIrpStackLocation(Irp);

        Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);

        goto exit2;
    }

    if (!(Irp->Flags & IRP_PAGING_IO))
        FsRtlCheckOplock(fcb_oplock(fcb), Irp, NULL, NULL, NULL);

    wait = IoIsOperationSynchronous(Irp);

    // Don't offload jobs when doing paging IO - otherwise this can lead to
    // deadlocks in CcCopyRead.
    if (Irp->Flags & IRP_PAGING_IO)
        wait = true;

    if (!(Irp->Flags & IRP_PAGING_IO) && FileObject->SectionObjectPointer && FileObject->SectionObjectPointer->DataSectionObject) {
        IO_STATUS_BLOCK iosb;

        CcFlushCache(FileObject->SectionObjectPointer, &IrpSp->Parameters.Read.ByteOffset, IrpSp->Parameters.Read.Length, &iosb);
        if (!NT_SUCCESS(iosb.Status)) {
            ERR("CcFlushCache returned %08lx\n", iosb.Status);
            return iosb.Status;
        }
    }

    if (!ExIsResourceAcquiredSharedLite(fcb->Header.Resource)) {
        if (!ExAcquireResourceSharedLite(fcb->Header.Resource, wait)) {
            Status = STATUS_PENDING;
            IoMarkIrpPending(Irp);
            goto exit;
        }

        acquired_fcb_lock = true;
    }

    Status = do_read(Irp, wait, &bytes_read);

    if (acquired_fcb_lock)
        ExReleaseResourceLite(fcb->Header.Resource);

exit:
    if (FileObject->Flags & FO_SYNCHRONOUS_IO && !(Irp->Flags & IRP_PAGING_IO))
        FileObject->CurrentByteOffset.QuadPart = IrpSp->Parameters.Read.ByteOffset.QuadPart + (NT_SUCCESS(Status) ? bytes_read : 0);

end:
    Irp->IoStatus.Status = Status;

    TRACE("Irp->IoStatus.Status = %08lx\n", Irp->IoStatus.Status);
    TRACE("Irp->IoStatus.Information = %Iu\n", Irp->IoStatus.Information);
    TRACE("returning %08lx\n", Status);

    if (Status != STATUS_PENDING)
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    else {
        if (!add_thread_job(Vcb, Irp))
            Status = do_read_job(Irp);
    }

exit2:
    if (top_level)
        IoSetTopLevelIrp(NULL);

    FsRtlExitFileSystem();

    return Status;
}

_Dispatch_type_() [3/7]

_Dispatch_type_

(

IRP_MJ_DEVICE_CONTROL

)

Definition at line 1007 of file isapnp.c.

{
    PISAPNP_COMMON_EXTENSION CommonExt = DeviceObject->DeviceExtension;

    PAGED_CODE();

    DPRINT("%s(%p, %p) Minor - %X\n", __FUNCTION__, DeviceObject, Irp,
           IoGetCurrentIrpStackLocation(Irp)->MinorFunction);

    if (CommonExt->Signature == IsaPnpBus)
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(((PISAPNP_FDO_EXTENSION)CommonExt)->Ldo, Irp);
    }
    else
    {
        NTSTATUS Status = Irp->IoStatus.Status;

        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
}

_Dispatch_type_() [4/7]

_Dispatch_type_

(

IRP_MJ_PNP

)

Definition at line 1581 of file isapnp.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;

    PAGED_CODE();

    if (DevExt->Signature == IsaPnpBus)
        return IsaFdoPnp((PISAPNP_FDO_EXTENSION)DevExt, Irp, IrpSp);
    else
        return IsaPdoPnp((PISAPNP_PDO_EXTENSION)DevExt, Irp, IrpSp);
}

_Dispatch_type_() [5/7]

_Dispatch_type_

(

IRP_MJ_SHUTDOWN

)

Definition at line 5510 of file btrfs.c.

                                                                                        {
    NTSTATUS Status;
    bool top_level;
    device_extension* Vcb = DeviceObject->DeviceExtension;

    FsRtlEnterFileSystem();

    TRACE("shutdown\n");

    top_level = is_top_level(Irp);

    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    }

    Status = STATUS_SUCCESS;

    do_shutdown(Irp);

end:
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;

    IoCompleteRequest( Irp, IO_NO_INCREMENT );

    if (top_level)
        IoSetTopLevelIrp(NULL);

    FsRtlExitFileSystem();

    return Status;
}

_Dispatch_type_() [6/7]

_Dispatch_type_

(

IRP_MJ_SYSTEM_CONTROL

)

Definition at line 5748 of file btrfs.c.

                                                                                              {
    NTSTATUS Status;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;

    FsRtlEnterFileSystem();

    top_level = is_top_level(Irp);

    Irp->IoStatus.Information = 0;

    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        volume_device_extension* vde = DeviceObject->DeviceExtension;

        IoSkipCurrentIrpStackLocation(Irp);

        Status = IoCallDriver(vde->attached_device, Irp);

        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_FS) {
        IoSkipCurrentIrpStackLocation(Irp);

        Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);

        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_BUS) {
        bus_device_extension* bde = DeviceObject->DeviceExtension;

        IoSkipCurrentIrpStackLocation(Irp);

        Status = IoCallDriver(bde->attached_device, Irp);

        goto exit;
    }

    Status = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);

exit:
    if (top_level)
        IoSetTopLevelIrp(NULL);

    FsRtlExitFileSystem();

    return Status;
}

_Dispatch_type_() [7/7]

_Dispatch_type_

(

IRP_MJ_POWER

)

Definition at line 1543 of file isapnp.c.

{
    PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;
    NTSTATUS Status;

    if (DevExt->Signature != IsaPnpBus)
    {
        switch (IoGetCurrentIrpStackLocation(Irp)->MinorFunction)
        {
            case IRP_MN_SET_POWER:
            case IRP_MN_QUERY_POWER:
                Status = STATUS_SUCCESS;
                Irp->IoStatus.Status = Status;
                break;

            default:
                Status = Irp->IoStatus.Status;
                break;
        }

        PoStartNextPowerIrp(Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }

    PoStartNextPowerIrp(Irp);
    IoSkipCurrentIrpStackLocation(Irp);
    return PoCallDriver(((PISAPNP_FDO_EXTENSION)DevExt)->Ldo, Irp);
}

_In_reads_bytes_()

_In_ PTRANSFER_PACKET _In_ ULONG _In_reads_bytes_

(

Length

)

_IRQL_requires_()

_IRQL_requires_

(

PASSIVE_LEVEL

)

Definition at line 13147 of file class.c.

{
    NTSTATUS status = STATUS_SUCCESS;

    PAGED_CODE();

    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClassDetermineTokenOperationCommandSupport (%p): Entering function.\n",
                DeviceObject));

    //
    // Send down Inquiry for VPD_THIRD_PARTY_COPY_PAGE and cache away the device parameters
    // from WINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR.
    //
    status = ClasspGetBlockDeviceTokenLimitsInfo(DeviceObject);

    if (NT_SUCCESS(status)) {

        ULONG maxListIdentifier = MaxTokenOperationListIdentifier;

        //
        // Query the maximum list identifier to use for TokenOperation commands.
        //
        if (NT_SUCCESS(ClasspGetMaximumTokenListIdentifier(DeviceObject, REG_DISK_CLASS_CONTROL, &maxListIdentifier))) {
            if (maxListIdentifier >= MIN_TOKEN_LIST_IDENTIFIERS) {

                NT_ASSERT(maxListIdentifier <= MAX_TOKEN_LIST_IDENTIFIERS);
                MaxTokenOperationListIdentifier = maxListIdentifier;
            }
        }

    }

    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClassDetermineTokenOperationCommandSupport (%p): Exiting function with status %x.\n",
                DeviceObject,
                status));

    return status;
}

_IRQL_requires_max_() [1/2]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 197 of file cddata.c.

{
    THREAD_CONTEXT ThreadContext = {0};
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN Wait;

#ifdef CD_SANITY
    PVOID PreviousTopLevel;
#endif

    NTSTATUS Status;

#if DBG

    KIRQL SaveIrql = KeGetCurrentIrql();

#endif

    ASSERT_OPTIONAL_IRP( Irp );

    UNREFERENCED_PARAMETER( DeviceObject );

    FsRtlEnterFileSystem();

#ifdef CD_SANITY
    PreviousTopLevel = IoGetTopLevelIrp();
#endif

    //
    //  Loop until this request has been completed or posted.
    //

    do {

        //
        //  Use a try-except to handle the exception cases.
        //

        _SEH2_TRY {

            //
            //  If the IrpContext is NULL then this is the first pass through
            //  this loop.
            //

            if (IrpContext == NULL) {

                //
                //  Decide if this request is waitable an allocate the IrpContext.
                //  If the file object in the stack location is NULL then this
                //  is a mount which is always waitable.  Otherwise we look at
                //  the file object flags.
                //

                if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {

                    Wait = TRUE;

                } else {

                    Wait = CanFsdWait( Irp );
                }

                IrpContext = CdCreateIrpContext( Irp, Wait );

                //
                //  Update the thread context information.
                //

                CdSetThreadContext( IrpContext, &ThreadContext );

#ifdef CD_SANITY
                NT_ASSERT( !CdTestTopLevel ||
                        SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif

            //
            //  Otherwise cleanup the IrpContext for the retry.
            //

            } else {

                //
                //  Set the MORE_PROCESSING flag to make sure the IrpContext
                //  isn't inadvertently deleted here.  Then cleanup the
                //  IrpContext to perform the retry.
                //

                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
                CdCleanupIrpContext( IrpContext, FALSE );
            }

            //
            //  Case on the major irp code.
            //

            switch (IrpContext->MajorFunction) {

            case IRP_MJ_CREATE :

                Status = CdCommonCreate( IrpContext, Irp );
                break;

            case IRP_MJ_CLOSE :

                Status = CdCommonClose( IrpContext, Irp );
                break;

            case IRP_MJ_READ :

                //
                //  If this is an Mdl complete request, don't go through
                //  common read.
                //

                if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {

                    Status = CdCompleteMdl( IrpContext, Irp );

                } else {

                    Status = CdCommonRead( IrpContext, Irp );
                }

                break;

            case IRP_MJ_WRITE :

                Status = CdCommonWrite( IrpContext, Irp );
                break;

            case IRP_MJ_QUERY_INFORMATION :

                Status = CdCommonQueryInfo( IrpContext, Irp );
                break;

            case IRP_MJ_SET_INFORMATION :

                Status = CdCommonSetInfo( IrpContext, Irp );
                break;

            case IRP_MJ_QUERY_VOLUME_INFORMATION :

                Status = CdCommonQueryVolInfo( IrpContext, Irp );
                break;

            case IRP_MJ_DIRECTORY_CONTROL :

                Status = CdCommonDirControl( IrpContext, Irp );
                break;

            case IRP_MJ_FILE_SYSTEM_CONTROL :

                Status = CdCommonFsControl( IrpContext, Irp );
                break;

            case IRP_MJ_DEVICE_CONTROL :

                Status = CdCommonDevControl( IrpContext, Irp );
                break;

            case IRP_MJ_LOCK_CONTROL :

                Status = CdCommonLockControl( IrpContext, Irp );
                break;

            case IRP_MJ_CLEANUP :

                Status = CdCommonCleanup( IrpContext, Irp );
                break;

            case IRP_MJ_PNP :

                Status = CdCommonPnp( IrpContext, Irp );
                break;

            case IRP_MJ_SHUTDOWN :

                Status = CdCommonShutdown( IrpContext, Irp );
                break;

            default :

                Status = STATUS_INVALID_DEVICE_REQUEST;
                CdCompleteRequest( IrpContext, Irp, Status );
            }

        } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {

            Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
        } _SEH2_END;

    } while (Status == STATUS_CANT_WAIT);

#ifdef CD_SANITY
    NT_ASSERT( !CdTestTopLevel ||
            (PreviousTopLevel == IoGetTopLevelIrp()) );
#endif

    FsRtlExitFileSystem();

    NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));

    return Status;
}

_IRQL_requires_max_() [2/2]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 64 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    NTSTATUS Status;

    /* The caller must allow at least one connection */
    if (MaxConnections == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }

    /* The request must be for a kernel handle */
    if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
    {
        return STATUS_INVALID_PARAMETER;
    }

    /*
     * Get rundown protection on the target to stop the owner
     * from unloading whilst this port object is open. It gets
     * removed in the FltpServerPortClose callback
     */
    Status = FltObjectReference(Filter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }

    /* Create the server port object for this filter */
    Status = ObCreateObject(KernelMode,
                            ServerPortObjectType,
                            ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_SERVER_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&PortObject);
    if (NT_SUCCESS(Status))
    {
        /* Zero out the struct */
        RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));

        /* Increment the ref count on the target filter */
        FltpObjectPointerReference((PFLT_OBJECT)Filter);

        /* Setup the filter port object */
        PortObject->Filter = Filter;
        PortObject->ConnectNotify = ConnectNotifyCallback;
        PortObject->DisconnectNotify = DisconnectNotifyCallback;
        PortObject->MessageNotify = MessageNotifyCallback;
        PortObject->Cookie = ServerPortCookie;
        PortObject->MaxConnections = MaxConnections;

        /* Insert the object */
        Status = ObInsertObject(PortObject,
                                NULL,
                                STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                0,
                                NULL,
                                (PHANDLE)ServerPort);
        if (NT_SUCCESS(Status))
        {
            /* Lock the connection list */
            ExAcquireFastMutex(&Filter->ConnectionList.mLock);

            /* Add the new port object to the connection list and increment the count */
            InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
            Filter->ConnectionList.mCount++;

            /* Unlock the connection list*/
            ExReleaseFastMutex(&Filter->ConnectionList.mLock);
        }
    }

    if (!NT_SUCCESS(Status))
    {
        /* Allow the filter to be cleaned up */
        FltObjectDereference(Filter);
    }

    return Status;
}

AllocateDictionaryEntry()

NTSTATUS AllocateDictionaryEntry	(	IN PDICTIONARY	Dictionary,
		IN ULONGLONG	Key,
		IN ULONG	Size,
		IN ULONG	Tag,
		OUT PVOID *	Entry
	)

Referenced by ClasspCreateClose().

BuildDeviceInputMdl()

PMDL BuildDeviceInputMdl	(	PVOID	Buffer,
		ULONG	BufferLen
	)

Definition at line 609 of file utils.c.

{
    return ClasspBuildDeviceMdl(Buffer, BufferLen, FALSE);
}

Referenced by ClasspModeSelect(), ClasspModeSense(), and ClassReadDriveCapacity().

C_ASSERT()

C_ASSERT

(

(sizeof(struct _CLASS_PRIVATE_COMMON_DATA) % sizeof(PVOID))

= =0

)

ClassAddChild()

VOID ClassAddChild	(	_In_ PFUNCTIONAL_DEVICE_EXTENSION	Parent,
		_In_ PPHYSICAL_DEVICE_EXTENSION	Child,
		_In_ BOOLEAN	AcquireLock
	)

Definition at line 12058 of file class.c.

{
    if(AcquireLock) {
        ClassAcquireChildLock(Parent);
    }

    #if DBG
        //
        // Make sure this child's not already in the list.
        //
        {
            PPHYSICAL_DEVICE_EXTENSION testChild;

            for (testChild = Parent->CommonExtension.ChildList;
                 testChild != NULL;
                 testChild = testChild->CommonExtension.ChildList) {

                NT_ASSERT(testChild != Child);
            }
        }
    #endif

    Child->CommonExtension.ChildList = Parent->CommonExtension.ChildList;
    Parent->CommonExtension.ChildList = Child;

    if(AcquireLock) {
        ClassReleaseChildLock(Parent);
    }
    return;
} // end ClassAddChild()

ClassDeviceGetLBProvisioningResources()

NTSTATUS ClassDeviceGetLBProvisioningResources	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp,
		_Inout_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 5087 of file utils.c.

{
    NTSTATUS status;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_LB_PROVISIONING_MAP_RESOURCES mapResources = (PSTORAGE_LB_PROVISIONING_MAP_RESOURCES)Irp->AssociatedIrp.SystemBuffer;

    status = ClassGetLBProvisioningResources(DeviceObject,
                                           Srb,
                                           irpStack->Parameters.DeviceIoControl.OutputBufferLength,
                                           mapResources);

    if (NT_SUCCESS(status)) {
        Irp->IoStatus.Information = mapResources->Size;
    } else {
        Irp->IoStatus.Information = 0;
    }

    Irp->IoStatus.Status = status;
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);

    return status;
}

Referenced by ClassDeviceControl().

ClassDeviceHwFirmwareActivateProcess()

NTSTATUS ClassDeviceHwFirmwareActivateProcess	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp,
		_Inout_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 8902 of file utils.c.

{
    NTSTATUS status = STATUS_SUCCESS;

#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)

    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_HW_FIRMWARE_ACTIVATE firmwareActivate = (PSTORAGE_HW_FIRMWARE_ACTIVATE)Irp->AssociatedIrp.SystemBuffer;
    BOOLEAN passDown = FALSE;
    PCDB cdb = NULL;
    ULONG   i;
    BOOLEAN lockHeld = FALSE;
    KLOCK_QUEUE_HANDLE lockHandle;


    //
    // Input buffer is not big enough to contain required input information.
    //
    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_HW_FIRMWARE_ACTIVATE)) {

        status = STATUS_INFO_LENGTH_MISMATCH;
        goto Exit_Firmware_Activate;
    }

    //
    // Input buffer basic validation.
    //
    if ((firmwareActivate->Version < sizeof(STORAGE_HW_FIRMWARE_ACTIVATE)) ||
        (firmwareActivate->Size > irpStack->Parameters.DeviceIoControl.InputBufferLength)) {

        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Activate;
    }

    //
    // Only process the request for a supported port driver.
    //
    if (!ClassDeviceHwFirmwareIsPortDriverSupported(DeviceObject)) {
        status = STATUS_NOT_IMPLEMENTED;
        goto Exit_Firmware_Activate;
    }

    //
    // Buffer "FunctionSupportInfo" is allocated during start device process. Following check defends against the situation
    // of receiving this IOCTL when the device is created but not started, or device start failed but did not get removed yet.
    //
    if (commonExtension->IsFdo && (fdoExtension->FunctionSupportInfo == NULL)) {

        status = STATUS_UNSUCCESSFUL;
        goto Exit_Firmware_Activate;
    }

    //
    // Process the situation that request should be forwarded to lower level.
    //
    if (!commonExtension->IsFdo) {
        passDown = TRUE;
    }

    if ((firmwareActivate->Flags & STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER) != 0) {
        passDown = TRUE;
    }

    if (passDown) {

        IoCopyCurrentIrpStackLocationToNext(Irp);

        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        FREE_POOL(Srb);
        return status;
    }

    //
    // If firmware information hasn't been cached in classpnp, retrieve it.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo == NULL) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
            status = STATUS_NOT_IMPLEMENTED;
            goto Exit_Firmware_Activate;
        } else {
            //
            // If this is the first time of retrieving firmware information,
            // send request to lower level to get it.
            //
            status = ClasspGetHwFirmwareInfo(DeviceObject);

            if (!NT_SUCCESS(status)) {
                goto Exit_Firmware_Activate;
            }
        }
    }

    //
    // Fail the request if the firmware information cannot be retrieved.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo == NULL) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
            status = STATUS_NOT_IMPLEMENTED;
        } else {
            status = STATUS_UNSUCCESSFUL;
        }

        goto Exit_Firmware_Activate;
    }

    //
    // Acquire the SyncLock to ensure the HwFirmwareInfo pointer doesn't change
    // while we're dereferencing it.
    //
    lockHeld = TRUE;
    KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);

    //
    // Validate the device support
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SupportUpgrade == FALSE) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit_Firmware_Activate;
    }

    //
    // Check if the slot number is valid.
    //
    for (i = 0; i < fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SlotCount; i++) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Slot[i].SlotNumber == firmwareActivate->Slot) {
            break;
        }
    }

    if (i >= fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SlotCount) {
        //
        // Either the slot number is out of scope or the slot is read-only.
        //
        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Activate;
    }

    //
    // We're done accessing HwFirmwareInfo at this point so we can release
    // the SyncLock.
    //
    NT_ASSERT(lockHeld);
    KeReleaseInStackQueuedSpinLock(&lockHandle);
    lockHeld = FALSE;

    //
    // Process the request by translating it into WRITE BUFFER command.
    //
    //
    // Setup the CDB. This should be an untagged request.
    //
    SrbSetCdbLength(Srb, CDB10GENERIC_LENGTH);
    cdb = SrbGetCdb(Srb);
    cdb->WRITE_BUFFER.OperationCode = SCSIOP_WRITE_DATA_BUFF;
    cdb->WRITE_BUFFER.Mode = SCSI_WRITE_BUFFER_MODE_ACTIVATE_DEFERRED_MICROCODE;
    cdb->WRITE_BUFFER.ModeSpecific = 0;                     //Reserved for Mode 0x0F
    cdb->WRITE_BUFFER.BufferID = firmwareActivate->Slot;    //NOTE: this field will be ignored by SCSI device.

    //
    // Set timeout value.
    //
    SrbSetTimeOutValue(Srb, FIRMWARE_ACTIVATE_TIMEOUT_VALUE);

    //
    // This routine uses a completion routine - ClassIoComplete() so we don't want to release
    // the remove lock until then.
    //
    status = ClassSendSrbAsynchronous(DeviceObject,
                                      Srb,
                                      Irp,
                                      NULL,
                                      0,
                                      FALSE);

    if (status != STATUS_PENDING) {
        //
        // If the irp cannot be sent down, the Srb has been freed. NULL it to prevent from freeing it again.
        //
        Srb = NULL;

        goto Exit_Firmware_Activate;
    }

    return status;

Exit_Firmware_Activate:

    //
    // Release the SyncLock if it's still held.
    // This should only happen in the failure path.
    //
    if (lockHeld) {
        KeReleaseInStackQueuedSpinLock(&lockHandle);
        lockHeld = FALSE;
    }

    //
    // Firmware Activate request will be failed.
    //
    NT_ASSERT(!NT_SUCCESS(status));

    Irp->IoStatus.Status = status;

#else
    status = STATUS_NOT_IMPLEMENTED;
    Irp->IoStatus.Status = status;
#endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)

    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);

    FREE_POOL(Srb);
    return status;
}

Referenced by ClassDeviceControl().

ClassDeviceHwFirmwareDownloadProcess()

NTSTATUS ClassDeviceHwFirmwareDownloadProcess	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp,
		_Inout_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 8541 of file utils.c.

{
    NTSTATUS status = STATUS_SUCCESS;

#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)

    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_HW_FIRMWARE_DOWNLOAD firmwareDownload = (PSTORAGE_HW_FIRMWARE_DOWNLOAD)Irp->AssociatedIrp.SystemBuffer;
    BOOLEAN passDown = FALSE;
    ULONG   i;
    ULONG   bufferSize = 0;
    PUCHAR  firmwareImageBuffer = NULL;
    PIRP irp2 = NULL;
    PIO_STACK_LOCATION newStack = NULL;
    PCDB cdb = NULL;
    BOOLEAN lockHeld = FALSE;
    KLOCK_QUEUE_HANDLE lockHandle;


    //
    // Input buffer is not big enough to contain required input information.
    //
    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_HW_FIRMWARE_DOWNLOAD)) {

        status = STATUS_INFO_LENGTH_MISMATCH;
        goto Exit_Firmware_Download;
    }

    //
    // Input buffer basic validation.
    //
    if ((firmwareDownload->Version < sizeof(STORAGE_HW_FIRMWARE_DOWNLOAD)) ||
        (firmwareDownload->Size > irpStack->Parameters.DeviceIoControl.InputBufferLength) ||
        ((firmwareDownload->BufferSize + FIELD_OFFSET(STORAGE_HW_FIRMWARE_DOWNLOAD, ImageBuffer)) > firmwareDownload->Size)) {

        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Download;
    }

    //
    // Only process the request for a supported port driver.
    //
    if (!ClassDeviceHwFirmwareIsPortDriverSupported(DeviceObject)) {
        status = STATUS_NOT_IMPLEMENTED;
        goto Exit_Firmware_Download;
    }

    //
    // Buffer "FunctionSupportInfo" is allocated during start device process. Following check defends against the situation
    // of receiving this IOCTL when the device is created but not started, or device start failed but did not get removed yet.
    //
    if (commonExtension->IsFdo && (fdoExtension->FunctionSupportInfo == NULL)) {

        status = STATUS_UNSUCCESSFUL;
        goto Exit_Firmware_Download;
    }

    //
    // Process the situation that request should be forwarded to lower level.
    //
    if (!commonExtension->IsFdo) {
        passDown = TRUE;
    }

    if ((firmwareDownload->Flags & STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER) != 0) {
        passDown = TRUE;
    }

    if (passDown) {

        IoCopyCurrentIrpStackLocationToNext(Irp);

        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        FREE_POOL(Srb);
        return status;
    }

    //
    // If firmware information hasn't been cached in classpnp, retrieve it.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo == NULL) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
            status = STATUS_NOT_IMPLEMENTED;
            goto Exit_Firmware_Download;
        } else {
            //
            // If this is the first time of retrieving firmware information,
            // send request to lower level to get it.
            //
            status = ClasspGetHwFirmwareInfo(DeviceObject);

            if (!NT_SUCCESS(status)) {
                goto Exit_Firmware_Download;
            }
        }
    }

    //
    // Fail the request if the firmware information cannot be retrieved.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo == NULL) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
            status = STATUS_NOT_IMPLEMENTED;
        } else {
            status = STATUS_UNSUCCESSFUL;
        }

        goto Exit_Firmware_Download;
    }

    //
    // Acquire the SyncLock to ensure the HwFirmwareInfo pointer doesn't change
    // while we're dereferencing it.
    //
    lockHeld = TRUE;
    KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);

    //
    // Validate the device support
    //
    if ((fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SupportUpgrade == FALSE) ||
        (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment == 0)) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit_Firmware_Download;
    }

    //
    // Check if the slot can be used to hold firmware image.
    //
    for (i = 0; i < fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SlotCount; i++) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Slot[i].SlotNumber == firmwareDownload->Slot) {
            break;
        }
    }

    if ((i >= fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SlotCount) ||
        (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Slot[i].ReadOnly == TRUE)) {
        //
        // Either the slot number is out of scope or the slot is read-only.
        //
        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Download;
    }

    //
    // Buffer size and alignment validation.
    // Max Offset and Buffer Size can be represented by SCSI command is max value for 3 bytes.
    //
    if ((firmwareDownload->BufferSize == 0) ||
        ((firmwareDownload->BufferSize % fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment) != 0) ||
        (firmwareDownload->BufferSize > fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadMaxSize) ||
        (firmwareDownload->BufferSize > fdoExtension->AdapterDescriptor->MaximumTransferLength) ||
        ((firmwareDownload->Offset % fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment) != 0) ||
        (firmwareDownload->Offset > 0xFFFFFF) ||
        (firmwareDownload->BufferSize > 0xFFFFFF)) {

        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Download;
    }


    //
    // Process the request by translating it into WRITE BUFFER command.
    //
    if (((ULONG_PTR)firmwareDownload->ImageBuffer % fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment) != 0) {
        //
        // Allocate buffer aligns to ImagePayloadAlignment to accommodate the alignment requirement.
        //
        bufferSize = ALIGN_UP_BY(firmwareDownload->BufferSize, fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment);

        //
        // We're done accessing HwFirmwareInfo at this point so we can release
        // the SyncLock.
        //
        NT_ASSERT(lockHeld);
        KeReleaseInStackQueuedSpinLock(&lockHandle);
        lockHeld = FALSE;

#ifdef _MSC_VER
#pragma prefast(suppress:6014, "The allocated memory that firmwareImageBuffer points to will be freed in ClassHwFirmwareDownloadComplete().")
#endif
        firmwareImageBuffer = ExAllocatePoolWithTag(NonPagedPoolNx, bufferSize, CLASSPNP_POOL_TAG_FIRMWARE);

        if (firmwareImageBuffer == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit_Firmware_Download;
        }

        RtlZeroMemory(firmwareImageBuffer, bufferSize);

        RtlCopyMemory(firmwareImageBuffer, firmwareDownload->ImageBuffer, (ULONG)firmwareDownload->BufferSize);

    } else {
        NT_ASSERT(lockHeld);
        KeReleaseInStackQueuedSpinLock(&lockHandle);
        lockHeld = FALSE;

        firmwareImageBuffer = firmwareDownload->ImageBuffer;
        bufferSize = (ULONG)firmwareDownload->BufferSize;
    }

    //
    // Allocate a new irp to send the WRITE BUFFER command down.
    // Similar process as IOCTL_STORAGE_CHECK_VERIFY.
    //
    irp2 = IoAllocateIrp((CCHAR)(DeviceObject->StackSize + 3), FALSE);

    if (irp2 == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;

        if (firmwareImageBuffer != firmwareDownload->ImageBuffer) {
            FREE_POOL(firmwareImageBuffer);
        }

        goto Exit_Firmware_Download;
    }

    //
    // Make sure to acquire the lock for the new irp.
    //
    ClassAcquireRemoveLock(DeviceObject, irp2);

    irp2->Tail.Overlay.Thread = Irp->Tail.Overlay.Thread;
    IoSetNextIrpStackLocation(irp2);

    //
    // Set the top stack location and shove the master Irp into the
    // top location
    //
    newStack = IoGetCurrentIrpStackLocation(irp2);
    newStack->Parameters.Others.Argument1 = Irp;
    newStack->DeviceObject = DeviceObject;

    //
    // Stick the firmware download completion routine onto the stack
    // and prepare the irp for the port driver
    //
    IoSetCompletionRoutine(irp2,
                           ClassHwFirmwareDownloadComplete,
                           (firmwareImageBuffer != firmwareDownload->ImageBuffer) ? firmwareImageBuffer : NULL,
                           TRUE,
                           TRUE,
                           TRUE);

    IoSetNextIrpStackLocation(irp2);
    newStack = IoGetCurrentIrpStackLocation(irp2);
    newStack->DeviceObject = DeviceObject;
    newStack->MajorFunction = irpStack->MajorFunction;
    newStack->MinorFunction = irpStack->MinorFunction;
    newStack->Flags = irpStack->Flags;


    //
    // Mark the master irp as pending - whether the lower level
    // driver completes it immediately or not this should allow it
    // to go all the way back up.
    //
    IoMarkIrpPending(Irp);

    //
    // Setup the CDB.
    //
    SrbSetCdbLength(Srb, CDB10GENERIC_LENGTH);
    cdb = SrbGetCdb(Srb);
    cdb->WRITE_BUFFER.OperationCode = SCSIOP_WRITE_DATA_BUFF;
    cdb->WRITE_BUFFER.Mode = SCSI_WRITE_BUFFER_MODE_DOWNLOAD_MICROCODE_WITH_OFFSETS_SAVE_DEFER_ACTIVATE;
    cdb->WRITE_BUFFER.ModeSpecific = 0;     //Reserved for Mode 0x0E
    cdb->WRITE_BUFFER.BufferID = firmwareDownload->Slot;

    cdb->WRITE_BUFFER.BufferOffset[0] = *((PCHAR)&firmwareDownload->Offset + 2);
    cdb->WRITE_BUFFER.BufferOffset[1] = *((PCHAR)&firmwareDownload->Offset + 1);
    cdb->WRITE_BUFFER.BufferOffset[2] = *((PCHAR)&firmwareDownload->Offset);

    cdb->WRITE_BUFFER.ParameterListLength[0] = *((PCHAR)&bufferSize + 2);
    cdb->WRITE_BUFFER.ParameterListLength[1] = *((PCHAR)&bufferSize + 1);
    cdb->WRITE_BUFFER.ParameterListLength[2] = *((PCHAR)&bufferSize);

    //
    // Send as a tagged command.
    //
    SrbSetRequestAttribute(Srb, SRB_HEAD_OF_QUEUE_TAG_REQUEST);
    SrbSetSrbFlags(Srb, SRB_FLAGS_NO_QUEUE_FREEZE | SRB_FLAGS_QUEUE_ACTION_ENABLE);

    //
    // Set timeout value.
    //
    SrbSetTimeOutValue(Srb, fdoExtension->TimeOutValue);

    //
    // This routine uses a completion routine so we don't want to release
    // the remove lock until then.
    //
    status = ClassSendSrbAsynchronous(DeviceObject,
                                      Srb,
                                      irp2,
                                      firmwareImageBuffer,
                                      bufferSize,
                                      TRUE);

    if (status != STATUS_PENDING) {
        //
        // If the new irp cannot be sent down, free allocated memory and bail out.
        //
        if (firmwareImageBuffer != firmwareDownload->ImageBuffer) {
            FREE_POOL(firmwareImageBuffer);
        }

        //
        // If the irp cannot be sent down, the Srb has been freed. NULL it to prevent from freeing it again.
        //
        Srb = NULL;

        ClassReleaseRemoveLock(DeviceObject, irp2);

        IoFreeIrp(irp2);

        goto Exit_Firmware_Download;
    }

    return status;

Exit_Firmware_Download:

    //
    // Release the SyncLock if it's still held.
    // This should only happen in the failure path.
    //
    if (lockHeld) {
        KeReleaseInStackQueuedSpinLock(&lockHandle);
        lockHeld = FALSE;
    }

    //
    // Firmware Download request will be failed.
    //
    NT_ASSERT(!NT_SUCCESS(status));

    Irp->IoStatus.Status = status;

#else
    status = STATUS_NOT_IMPLEMENTED;
    Irp->IoStatus.Status = status;
#endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)

    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);

    FREE_POOL(Srb);

    return status;
}

Referenced by ClassDeviceControl().

ClassDeviceHwFirmwareGetInfoProcess()

NTSTATUS ClassDeviceHwFirmwareGetInfoProcess	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 8366 of file utils.c.

{
    NTSTATUS status = STATUS_SUCCESS;

#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)

    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_HW_FIRMWARE_INFO_QUERY query = (PSTORAGE_HW_FIRMWARE_INFO_QUERY)Irp->AssociatedIrp.SystemBuffer;
    BOOLEAN passDown = FALSE;
    BOOLEAN copyData = FALSE;


    //
    // Input buffer is not big enough to contain required input information.
    //
    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_HW_FIRMWARE_INFO_QUERY)) {

        status = STATUS_INFO_LENGTH_MISMATCH;
        goto Exit_Firmware_Get_Info;
    }

    //
    // Output buffer is too small to contain return data.
    //
    if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_HW_FIRMWARE_INFO)) {

        status = STATUS_BUFFER_TOO_SMALL;
        goto Exit_Firmware_Get_Info;
    }

    //
    // Only process the request for a supported port driver.
    //
    if (!ClassDeviceHwFirmwareIsPortDriverSupported(DeviceObject)) {
        status = STATUS_NOT_IMPLEMENTED;
        goto Exit_Firmware_Get_Info;
    }

    //
    // Buffer "FunctionSupportInfo" is allocated during start device process. Following check defends against the situation
    // of receiving this IOCTL when the device is created but not started, or device start failed but did not get removed yet.
    //
    if (commonExtension->IsFdo && (fdoExtension->FunctionSupportInfo == NULL)) {

        status = STATUS_UNSUCCESSFUL;
        goto Exit_Firmware_Get_Info;
    }

    //
    // Process the situation that request should be forwarded to lower level.
    //
    if (!commonExtension->IsFdo) {
        passDown = TRUE;
    }

    if ((query->Flags & STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER) != 0) {
        passDown = TRUE;
    }

    if (passDown) {

        IoCopyCurrentIrpStackLocationToNext(Irp);

        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        return status;
    }

    //
    // The request is for a FDO. Process the request.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
        status = STATUS_NOT_IMPLEMENTED;
        goto Exit_Firmware_Get_Info;
    } else {
        //
        // Retrieve information from lower layer for the request. The cached information is not used
        // in case device firmware information changed.
        //
        status = ClasspGetHwFirmwareInfo(DeviceObject);
        copyData = NT_SUCCESS(status);
    }

Exit_Firmware_Get_Info:

    if (copyData) {
        //
        // Firmware information is already cached in classpnp. Return a copy.
        //
        KLOCK_QUEUE_HANDLE lockHandle;
        KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);

        ULONG dataLength = min(irpStack->Parameters.DeviceIoControl.OutputBufferLength, fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Size);

        memcpy(Irp->AssociatedIrp.SystemBuffer, fdoExtension->FunctionSupportInfo->HwFirmwareInfo, dataLength);

        KeReleaseInStackQueuedSpinLock(&lockHandle);

        Irp->IoStatus.Information = dataLength;
    }

    Irp->IoStatus.Status = status;

#else
    status = STATUS_NOT_IMPLEMENTED;
    Irp->IoStatus.Status = status;
#endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)

    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);

    return status;
}

Referenced by ClassDeviceControl().

ClassFreeOrReuseSrb()

VOID ClassFreeOrReuseSrb	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN __drv_freesMem(mem) PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 882 of file obsolete.c.

{
    PCOMMON_DEVICE_EXTENSION commonExt = &FdoExtension->CommonExtension;

    // This function is obsolete, but still called by DISK.SYS .
    // TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassFreeOrReuseSrb is OBSOLETE !"));

    //
    // safety net.  this should never occur.  if it does, it's a potential
    // memory leak.
    //
    NT_ASSERT(!TEST_FLAG(SrbGetSrbFlags(Srb), SRB_FLAGS_FREE_SENSE_BUFFER));

    if (commonExt->IsSrbLookasideListInitialized){
        /*
         *  Put the SRB back in our lookaside list.
         *
         *  Note:   Some class drivers use ClassIoComplete
         *            to complete SRBs that they themselves allocated.
         *            So we may be putting a "foreign" SRB
         *            (e.g. with a different pool tag) into our lookaside list.
         */
        ClasspFreeSrb(FdoExtension, Srb);
    }
    else {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,"ClassFreeOrReuseSrb: someone is trying to use an uninitialized SrbLookasideList !!!"));
        FREE_POOL(Srb);
    }
}

Referenced by _Success_(), ClassIoComplete(), ClassIoCompleteAssociated(), and ClasspEjectionControl().

ClassGetPdoId()

NTSTATUS ClassGetPdoId	(	IN PDEVICE_OBJECT	Pdo,
		IN BUS_QUERY_ID_TYPE	IdType,
		IN PUNICODE_STRING	IdString
	)

Definition at line 10151 of file class.c.

{
#ifdef _MSC_VER
#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
#endif
    PCLASS_DRIVER_EXTENSION driverExtension = IoGetDriverObjectExtension(Pdo->DriverObject, CLASS_DRIVER_EXTENSION_KEY);

    _Analysis_assume_(driverExtension != NULL);

    ASSERT_PDO(Pdo);
    NT_ASSERT(driverExtension->InitData.ClassQueryId);

    PAGED_CODE();

    return driverExtension->InitData.ClassQueryId( Pdo, IdType, IdString);
} // end ClassGetPdoId()

Referenced by ClassDispatchPnp().

ClassInitializeDispatchTables()

VOID ClassInitializeDispatchTables

(

PCLASS_DRIVER_EXTENSION

DriverExtension

)

Definition at line 38 of file dispatch.c.

{
    ULONG idx;

    PAGED_CODE();

    //
    // Initialize the standard device dispatch table
    //

    for (idx = 0; idx <= IRP_MJ_MAXIMUM_FUNCTION; idx++) {
        DriverExtension->DeviceMajorFunctionTable[idx] = ClassDispatchUnimplemented;
    }

    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_CREATE]         = ClassCreateClose;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_CLOSE]          = ClassCreateClose;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_READ]           = ClassReadWrite;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_WRITE]          = ClassReadWrite;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_DEVICE_CONTROL] = ClassDeviceControlDispatch;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_SCSI]           = ClassInternalIoControl;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_SHUTDOWN]       = ClassShutdownFlush;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_FLUSH_BUFFERS]  = ClassShutdownFlush;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_PNP]            = ClassDispatchPnp;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_POWER]          = ClassDispatchPower;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_SYSTEM_CONTROL] = ClassSystemControl;


    return;
}

Referenced by _IRQL_requires_max_().

ClassIoCompletion()

NTSTATUS ClassIoCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

ClassMinimalPowerHandler()

NTSTATUS NTAPI ClassMinimalPowerHandler	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 1890 of file power.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS status;

    ClassReleaseRemoveLock(DeviceObject, Irp);
    PoStartNextPowerIrp(Irp);

    switch (irpStack->MinorFunction)
    {
        case IRP_MN_SET_POWER:
        {
            switch (irpStack->Parameters.Power.ShutdownType)
            {
                case PowerActionNone:
                case PowerActionSleep:
                case PowerActionHibernate:
                {
                    if (TEST_FLAG(DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA))
                    {
                        if ((ClassGetVpb(DeviceObject) != NULL) && (ClassGetVpb(DeviceObject)->Flags & VPB_MOUNTED))
                        {
                            //
                            // This flag will cause the filesystem to verify the
                            // volume when coming out of hibernation or standby or runtime power
                            //
                            SET_FLAG(DeviceObject->Flags, DO_VERIFY_VOLUME);
                        }
                    }
                }
                break;
            }
        }

        //
        // Fall through
        //

        case IRP_MN_QUERY_POWER:
        {
            if (!commonExtension->IsFdo)
            {
                Irp->IoStatus.Status = STATUS_SUCCESS;
                Irp->IoStatus.Information = 0;
            }
        }
        break;
    }

    if (commonExtension->IsFdo)
    {
        IoCopyCurrentIrpStackLocationToNext(Irp);
        status = PoCallDriver(commonExtension->LowerDeviceObject, Irp);
    }
    else
    {
        status = Irp->IoStatus.Status;
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
    }

    return status;
} // end ClassMinimalPowerHandler()

Referenced by _IRQL_requires_max_().

ClasspAccessAlignmentProperty()

NTSTATUS ClasspAccessAlignmentProperty	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_Inout_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 1700 of file utils.c.

{
    NTSTATUS    status = STATUS_UNSUCCESSFUL;

    PCOMMON_DEVICE_EXTENSION     commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PSTORAGE_PROPERTY_QUERY      query = (PSTORAGE_PROPERTY_QUERY)Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION           irpStack = IoGetCurrentIrpStackLocation(Irp);
    ULONG                        length = 0;
    ULONG                        information = 0;

    PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR accessAlignment;

    //
    // check registry setting and fail the IOCTL if it's required.
    // this registry setting can be used to work around issues which upper layer doesn't support large physical sector size.
    //
    if (fdoExtension->FunctionSupportInfo->RegAccessAlignmentQueryNotSupported) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit;
    }

    if ( (DeviceObject->DeviceType != FILE_DEVICE_DISK) ||
         (TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE)) ||
         (fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty == Supported) ) {
        // if it's not disk, forward the request to lower layer,
        // if the IOCTL is supported by lower stack, forward it down.
        IoCopyCurrentIrpStackLocationToNext(Irp);

        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        return status;
    }

    //
    // Check proper query type.
    //

    if (query->QueryType == PropertyExistsQuery) {
        status = STATUS_SUCCESS;
        goto Exit;
    } else  if (query->QueryType != PropertyStandardQuery) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit;
    }

    //
    // Request validation.
    // Note that InputBufferLength and IsFdo have been validated before entering this routine.
    //

    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        status = STATUS_INVALID_LEVEL;
        goto Exit;
    }

    // do not touch this buffer because it can still be used as input buffer for lower layer in 'SupportUnknown' case.
    accessAlignment = (PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR)Irp->AssociatedIrp.SystemBuffer;

    length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;

    if (length < sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR)) {

        if (length >= sizeof(STORAGE_DESCRIPTOR_HEADER)) {

            information = sizeof(STORAGE_DESCRIPTOR_HEADER);
            accessAlignment->Version = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            accessAlignment->Size = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            status = STATUS_SUCCESS;
            goto Exit;
        }

        status = STATUS_BUFFER_TOO_SMALL;
        goto Exit;
    }

    // not support Cache Line,
    // 'BytesPerCacheLine' and 'BytesOffsetForCacheAlignment' fields are zero-ed.

    //
    // note that 'Supported' case has been handled at the beginning of this function.
    //
    switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty) {
    case SupportUnknown: {
        // send down request and wait for the request to complete.
        status = ClassForwardIrpSynchronous(commonExtension, Irp);

        if (ClasspLowerLayerNotSupport(status)) {
            // case 1: the request is not supported by lower layer, sends down command
            // some port drivers (or filter drivers) return STATUS_INVALID_DEVICE_REQUEST if a request is not supported.

            // ClassReadCapacity16() will either return status from cached data or send command to retrieve the information.
            if (ClasspIsObsoletePortDriver(fdoExtension) == FALSE) {
                status = ClassReadCapacity16(fdoExtension, Srb);
            } else {
                fdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus = status;
            }

            // data is ready in fdoExtension
            // set the support status after the SCSI command is executed to avoid racing condition between multiple same type of requests.
            fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty = NotSupported;

            if (NT_SUCCESS(status)) {
                // fill output buffer
                RtlZeroMemory(accessAlignment, length);
                accessAlignment->Version = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
                accessAlignment->Size = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
                accessAlignment->BytesPerLogicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector;
                accessAlignment->BytesPerPhysicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerPhysicalSector;
                accessAlignment->BytesOffsetForSectorAlignment = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesOffsetForSectorAlignment;

                // set returned data length
                information = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            } else {
                information = 0;
            }

        } else {
            // case 2: the request is supported and it completes successfully
            // case 3: the request is supported by lower stack but other failure status is returned.
            // from now on, the same request will be send down to lower stack directly.
            fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty = Supported;
            information = (ULONG)Irp->IoStatus.Information;


        }


        goto Exit;

        break;
    }

    case NotSupported: {

        // ClassReadCapacity16() will either return status from cached data or send command to retrieve the information.
        status = ClassReadCapacity16(fdoExtension, Srb);

        if (NT_SUCCESS(status)) {
            RtlZeroMemory(accessAlignment, length);
            accessAlignment->Version = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            accessAlignment->Size = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            accessAlignment->BytesPerLogicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector;
            accessAlignment->BytesPerPhysicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerPhysicalSector;
            accessAlignment->BytesOffsetForSectorAlignment = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesOffsetForSectorAlignment;

            information = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
        } else {
            information = 0;
        }
        goto Exit;

        break;
    }

    case Supported: {
        NT_ASSERT(FALSE); // this case is handled at the beginning of the function.
        status = STATUS_INTERNAL_ERROR;
        break;
    }

    }   // end of switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty)

Exit:

    //
    // Set the size and status in IRP
    //
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = status;

    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);

    return status;
}