#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 4769 of file create.c.

                                                                            {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp;
     device_extension* Vcb = DeviceObject->DeviceExtension;
     bool top_level, locked = false;
 
     FsRtlEnterFileSystem();
 
     TRACE("create (flags = %lx)\n", Irp->Flags);
 
     top_level = is_top_level(Irp);
 
     /* return success if just called for FS device object */
     if (DeviceObject == master_devobj)  {
         TRACE("create called for FS device object\n");
 
         Irp->IoStatus.Information = FILE_OPENED;
         Status = STATUS_SUCCESS;
 
         goto exit;
     } else if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
         Status = vol_create(DeviceObject, Irp);
         goto exit;
     } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
         Status = STATUS_INVALID_PARAMETER;
         goto exit;
     }
 
     if (!(Vcb->Vpb->Flags & VPB_MOUNTED)) {
         Status = STATUS_DEVICE_NOT_READY;
         goto exit;
     }
 
     if (Vcb->removing) {
         Status = STATUS_ACCESS_DENIED;
         goto exit;
     }
 
     Status = verify_vcb(Vcb, Irp);
     if (!NT_SUCCESS(Status)) {
         ERR("verify_vcb returned %08lx\n", Status);
         goto exit;
     }
 
     ExAcquireResourceSharedLite(&Vcb->load_lock, true);
     locked = true;
 
     IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
     if (IrpSp->Flags != 0) {
         uint32_t flags = IrpSp->Flags;
 
         TRACE("flags:\n");
 
         if (flags & SL_CASE_SENSITIVE) {
             TRACE("SL_CASE_SENSITIVE\n");
             flags &= ~SL_CASE_SENSITIVE;
         }
 
         if (flags & SL_FORCE_ACCESS_CHECK) {
             TRACE("SL_FORCE_ACCESS_CHECK\n");
             flags &= ~SL_FORCE_ACCESS_CHECK;
         }
 
         if (flags & SL_OPEN_PAGING_FILE) {
             TRACE("SL_OPEN_PAGING_FILE\n");
             flags &= ~SL_OPEN_PAGING_FILE;
         }
 
         if (flags & SL_OPEN_TARGET_DIRECTORY) {
             TRACE("SL_OPEN_TARGET_DIRECTORY\n");
             flags &= ~SL_OPEN_TARGET_DIRECTORY;
         }
 
         if (flags & SL_STOP_ON_SYMLINK) {
             TRACE("SL_STOP_ON_SYMLINK\n");
             flags &= ~SL_STOP_ON_SYMLINK;
         }
 
         if (flags)
             WARN("unknown flags: %x\n", flags);
     } else {
         TRACE("flags: (none)\n");
     }
 
     if (!IrpSp->FileObject) {
         ERR("FileObject was NULL\n");
         Status = STATUS_INVALID_PARAMETER;
         goto exit;
     }
 
     if (IrpSp->FileObject->RelatedFileObject) {
         fcb* relatedfcb = IrpSp->FileObject->RelatedFileObject->FsContext;
 
         if (relatedfcb && relatedfcb->Vcb != Vcb) {
             WARN("RelatedFileObject was for different device\n");
             Status = STATUS_INVALID_PARAMETER;
             goto exit;
         }
     }
 
     // opening volume
     if (IrpSp->FileObject->FileName.Length == 0 && !IrpSp->FileObject->RelatedFileObject) {
         ULONG RequestedDisposition = ((IrpSp->Parameters.Create.Options >> 24) & 0xff);
         ULONG RequestedOptions = IrpSp->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
 #ifdef DEBUG_FCB_REFCOUNTS
         LONG rc;
 #endif
         ccb* ccb;
 
         TRACE("open operation for volume\n");
 
         if (RequestedDisposition != FILE_OPEN && RequestedDisposition != FILE_OPEN_IF) {
             Status = STATUS_ACCESS_DENIED;
             goto exit;
         }
 
         if (RequestedOptions & FILE_DIRECTORY_FILE) {
             Status = STATUS_NOT_A_DIRECTORY;
             goto exit;
         }
 
         ccb = ExAllocatePoolWithTag(NonPagedPool, sizeof(*ccb), ALLOC_TAG);
         if (!ccb) {
             ERR("out of memory\n");
             Status = STATUS_INSUFFICIENT_RESOURCES;
             goto exit;
         }
 
         RtlZeroMemory(ccb, sizeof(*ccb));
 
         ccb->NodeType = BTRFS_NODE_TYPE_CCB;
         ccb->NodeSize = sizeof(*ccb);
         ccb->disposition = RequestedDisposition;
         ccb->options = RequestedOptions;
         ccb->access = IrpSp->Parameters.Create.SecurityContext->AccessState->PreviouslyGrantedAccess;
         ccb->manage_volume_privilege = has_manage_volume_privilege(IrpSp->Parameters.Create.SecurityContext->AccessState,
                                                                    IrpSp->Flags & SL_FORCE_ACCESS_CHECK ? UserMode : Irp->RequestorMode);
         ccb->reserving = false;
         ccb->lxss = called_from_lxss();
 
 #ifdef DEBUG_FCB_REFCOUNTS
         rc = InterlockedIncrement(&Vcb->volume_fcb->refcount);
         WARN("fcb %p: refcount now %i (volume)\n", Vcb->volume_fcb, rc);
 #else
         InterlockedIncrement(&Vcb->volume_fcb->refcount);
 #endif
         IrpSp->FileObject->FsContext = Vcb->volume_fcb;
         IrpSp->FileObject->FsContext2 = ccb;
 
         IrpSp->FileObject->SectionObjectPointer = &Vcb->volume_fcb->nonpaged->segment_object;
 
         if (!IrpSp->FileObject->Vpb)
             IrpSp->FileObject->Vpb = DeviceObject->Vpb;
 
         InterlockedIncrement(&Vcb->open_files);
 
         Irp->IoStatus.Information = FILE_OPENED;
         Status = STATUS_SUCCESS;
     } else {
         LIST_ENTRY rollback;
         bool skip_lock;
 
         InitializeListHead(&rollback);
 
         TRACE("file name: %.*S\n", (int)(IrpSp->FileObject->FileName.Length / sizeof(WCHAR)), IrpSp->FileObject->FileName.Buffer);
 
         if (IrpSp->FileObject->RelatedFileObject)
             TRACE("related file = %p\n", IrpSp->FileObject->RelatedFileObject);
 
         // Don't lock again if we're being called from within CcCopyRead etc.
         skip_lock = ExIsResourceAcquiredExclusiveLite(&Vcb->tree_lock);
 
         if (!skip_lock)
             ExAcquireResourceSharedLite(&Vcb->tree_lock, true);
 
         ExAcquireResourceSharedLite(&Vcb->fileref_lock, true);
 
         Status = open_file(DeviceObject, Vcb, Irp, &rollback);
 
         if (!NT_SUCCESS(Status))
             do_rollback(Vcb, &rollback);
         else
             clear_rollback(&rollback);
 
         ExReleaseResourceLite(&Vcb->fileref_lock);
 
         if (!skip_lock)
             ExReleaseResourceLite(&Vcb->tree_lock);
     }
 
 exit:
     Irp->IoStatus.Status = Status;
     IoCompleteRequest( Irp, NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT );
 
     TRACE("create returning %08lx\n", Status);
 
     if (locked)
         ExReleaseResourceLite(&Vcb->load_lock);
 
     if (top_level)
         IoSetTopLevelIrp(NULL);
 
     FsRtlExitFileSystem();
 
     return Status;
 }

◆ _Dispatch_type_() [2/7]

_Dispatch_type_ ( IRP_MJ_READ )

Definition at line 3515 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 252 of file devctrl.c.

                                                                                    {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
     bool top_level;
 
     FsRtlEnterFileSystem();
 
     top_level = is_top_level(Irp);
 
     Irp->IoStatus.Information = 0;
 
     if (Vcb) {
         if (Vcb->type == VCB_TYPE_CONTROL) {
             Status = control_ioctl(Irp);
             goto end;
         } else if (Vcb->type == VCB_TYPE_VOLUME) {
             Status = vol_device_control(DeviceObject, Irp);
             goto end;
         } else if (Vcb->type != VCB_TYPE_FS) {
             Status = STATUS_INVALID_PARAMETER;
             goto end;
         }
     } else {
         Status = STATUS_INVALID_PARAMETER;
         goto end;
     }
 
     switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
         case IOCTL_MOUNTDEV_QUERY_STABLE_GUID:
             Status = mountdev_query_stable_guid(Vcb, Irp);
             goto end;
 
         case IOCTL_DISK_IS_WRITABLE:
             Status = is_writable(Vcb);
             goto end;
 
         default:
             TRACE("unhandled control code %lx\n", IrpSp->Parameters.DeviceIoControl.IoControlCode);
             break;
     }
 
     IoSkipCurrentIrpStackLocation(Irp);
 
     Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
 
     goto end2;
 
 end:
     Irp->IoStatus.Status = Status;
 
     if (Status != STATUS_PENDING)
         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
 end2:
     TRACE("returning %08lx\n", Status);
 
     if (top_level)
         IoSetTopLevelIrp(NULL);
 
     FsRtlExitFileSystem();
 
     return Status;
 }

◆ _Dispatch_type_() [4/7]

_Dispatch_type_ ( IRP_MJ_PNP )

Definition at line 620 of file pnp.c.

                                                                   {
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
     NTSTATUS Status;
     bool top_level;
 
     FsRtlEnterFileSystem();
 
     top_level = is_top_level(Irp);
 
     if (Vcb && Vcb->type == VCB_TYPE_BUS) {
         Status = bus_pnp(DeviceObject->DeviceExtension, Irp);
         goto exit;
     } else 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_PDO) {
         Status = pdo_pnp(DeviceObject, Irp);
         goto end;
     } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
         Status = STATUS_INVALID_PARAMETER;
         goto end;
     }
 
     Status = STATUS_NOT_IMPLEMENTED;
 
     switch (IrpSp->MinorFunction) {
         case IRP_MN_CANCEL_REMOVE_DEVICE:
             Status = pnp_cancel_remove_device(DeviceObject);
             break;
 
         case IRP_MN_QUERY_REMOVE_DEVICE:
             Status = pnp_query_remove_device(DeviceObject, Irp);
             break;
 
         case IRP_MN_REMOVE_DEVICE:
             Status = pnp_remove_device(DeviceObject);
             break;
 
         case IRP_MN_SURPRISE_REMOVAL:
             Status = pnp_surprise_removal(DeviceObject, Irp);
             break;
 
         case IRP_MN_DEVICE_USAGE_NOTIFICATION:
             Status = pnp_device_usage_notification(DeviceObject, Irp);
             goto exit;
 
         default:
             TRACE("passing minor function 0x%x on\n", IrpSp->MinorFunction);
 
             IoSkipCurrentIrpStackLocation(Irp);
             Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
             goto exit;
     }
 
 end:
     Irp->IoStatus.Status = Status;
 
     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
 exit:
     TRACE("returning %08lx\n", Status);
 
     if (top_level)
         IoSetTopLevelIrp(NULL);
 
     FsRtlExitFileSystem();
 
     return Status;
 }

◆ _Dispatch_type_() [5/7]

_Dispatch_type_ ( IRP_MJ_SHUTDOWN )

Definition at line 5437 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 = vol_shutdown(DeviceObject, Irp);
         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 5675 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 5581 of file btrfs.c.

                                                                                      {
     NTSTATUS Status;
     PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
     device_extension* Vcb = DeviceObject->DeviceExtension;
     bool top_level;
 
     // no need for FsRtlEnterFileSystem, as this only ever gets called in a system thread
 
     top_level = is_top_level(Irp);
 
     Irp->IoStatus.Information = 0;
 
     if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
         volume_device_extension* vde = DeviceObject->DeviceExtension;
 
         if (IrpSp->MinorFunction == IRP_MN_QUERY_POWER && IrpSp->Parameters.Power.Type == SystemPowerState &&
             IrpSp->Parameters.Power.State.SystemState != PowerSystemWorking && vde->mounted_device) {
             device_extension* Vcb2 = vde->mounted_device->DeviceExtension;
 
             /* If power state is about to go to sleep or hibernate, do a flush. We do this on IRP_MJ_QUERY_POWER
             * rather than IRP_MJ_SET_POWER because we know that the hard disks are still awake. */
 
             if (Vcb2) {
                 ExAcquireResourceExclusiveLite(&Vcb2->tree_lock, true);
 
                 if (Vcb2->need_write && !Vcb2->readonly) {
                     TRACE("doing protective flush on power state change\n");
                     Status = do_write(Vcb2, NULL);
                 } else
                     Status = STATUS_SUCCESS;
 
                 free_trees(Vcb2);
 
                 if (!NT_SUCCESS(Status))
                     ERR("do_write returned %08lx\n", Status);
 
                 ExReleaseResourceLite(&Vcb2->tree_lock);
             }
         } else if (IrpSp->MinorFunction == IRP_MN_SET_POWER && IrpSp->Parameters.Power.Type == SystemPowerState &&
             IrpSp->Parameters.Power.State.SystemState == PowerSystemWorking && vde->mounted_device) {
             device_extension* Vcb2 = vde->mounted_device->DeviceExtension;
 
             /* If waking up, make sure that the FS hasn't been changed while we've been out (e.g., by dual-boot Linux) */
 
             if (Vcb2) {
                 PIO_WORKITEM work_item;
 
                 work_item = IoAllocateWorkItem(DeviceObject);
                 if (!work_item) {
                     ERR("out of memory\n");
                 } else
                     IoQueueWorkItem(work_item, check_after_wakeup, DelayedWorkQueue, Vcb2);
             }
         }
 
         PoStartNextPowerIrp(Irp);
         IoSkipCurrentIrpStackLocation(Irp);
         Status = PoCallDriver(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;
 
         PoStartNextPowerIrp(Irp);
         IoSkipCurrentIrpStackLocation(Irp);
         Status = PoCallDriver(bde->attached_device, Irp);
 
         goto exit;
     }
 
     if (IrpSp->MinorFunction == IRP_MN_SET_POWER || IrpSp->MinorFunction == IRP_MN_QUERY_POWER)
         Irp->IoStatus.Status = STATUS_SUCCESS;
 
     Status = Irp->IoStatus.Status;
 
     PoStartNextPowerIrp(Irp);
 
     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
 exit:
     if (top_level)
         IoSetTopLevelIrp(NULL);
 
     return Status;
 }

◆ _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 = 

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ Add2Ptr

◆ CLASS_ERROR_LEVEL_1

◆ CLASS_ERROR_LEVEL_2

◆ CLASS_FILE_OBJECT_EXTENSION_KEY

◆ CLASS_IDLE_INTERVAL

◆ CLASS_IDLE_INTERVAL_MIN

◆ CLASS_MAX_INTERLEAVE_PER_CRITICAL_IO

◆ CLASS_PERF_RESTORE_MINIMUM

◆ CLASS_STARVATION_INTERVAL

◆ CLASS_TAG_PRIVATE_DATA

◆ CLASS_TAG_SENSE2

◆ CLASS_TAG_WORKING_SET

◆ CLASSP_REG_ACCESS_ALIGNMENT_NOT_SUPPORTED

◆ CLASSP_REG_COPY_OFFLOAD_MAX_TARGET_DURATION

◆ CLASSP_REG_DISABLE_D3COLD

◆ CLASSP_REG_DISBALE_IDLE_POWER_NAME

◆ CLASSP_REG_HACK_VALUE_NAME

◆ CLASSP_REG_IDLE_ACTIVE_MAX

◆ CLASSP_REG_IDLE_INTERVAL_NAME

◆ CLASSP_REG_IDLE_PRIORITY_SUPPORTED

◆ CLASSP_REG_IDLE_TIMEOUT_IN_SECONDS

◆ CLASSP_REG_LEGACY_ERROR_HANDLING

◆ CLASSP_REG_MMC_DETECTION_VALUE_NAME

◆ CLASSP_REG_PERF_RESTORE_VALUE_NAME

◆ CLASSP_REG_QERR_OVERRIDE_MODE

◆ CLASSP_REG_REMOVAL_POLICY_VALUE_NAME

◆ CLASSP_REG_SUBKEY_NAME

◆ CLASSP_REG_WRITE_CACHE_VALUE_NAME

◆ CLASSP_VOLUME_VERIFY_CHECKED

◆ CLASSPNP_POOL_TAG_ADDITIONAL_DATA

◆ CLASSPNP_POOL_TAG_FIRMWARE

◆ CLASSPNP_POOL_TAG_GENERIC

◆ CLASSPNP_POOL_TAG_LOG_MESSAGE

◆ CLASSPNP_POOL_TAG_SRB

◆ CLASSPNP_POOL_TAG_TOKEN_OPERATION

◆ CLASSPNP_POOL_TAG_VPD

◆ CONST_MSECS_PER_SEC

◆ Convert100nsToMilliseconds

◆ ConvertMillisecondsTo100ns

◆ DBG_NUM_PACKET_LOG_ENTRIES

◆ DEBUG_COMP_ID

◆ DEFAULT_MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN

◆ DEFAULT_MAX_TARGET_DURATION

◆ FDO_HACK_CANNOT_LOCK_MEDIA

◆ FDO_HACK_GESN_IGNORE_OPCHANGE

◆ FDO_HACK_GESN_IS_BAD

◆ FDO_HACK_INVALID_FLAGS

◆ FDO_HACK_NO_RESERVE6

◆ FDO_HACK_NO_SYNC_CACHE

◆ FDO_HACK_VALID_FLAGS

◆ FIFTY_MS_IN_100NS_UNITS

◆ GET_LBA_STATUS_RETRY_COUNT_MAX

◆ HISTORYINITIALIZERETRYLOGS

◆ HISTORYLOGRETURNEDPACKET

◆ HISTORYLOGSENDPACKET

◆ LEGACY_NUM_IO_RETRIES

◆ MAX

◆ MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE

◆ MAX_LIST_IDENTIFIER

◆ MAX_NUMBER_BLOCK_DEVICE_DESCRIPTORS

◆ MAX_NUMBER_BLOCKS_PER_BLOCK_DEVICE_RANGE_DESCRIPTOR

◆ MAX_NUMBER_BYTES_PER_SYNC_WRITE_USING_TOKEN

◆ MAX_OUTSTANDING_IO_PER_LUN_DEFAULT

◆ MAX_RECEIVE_TOKEN_INFORMATION_PARAMETER_DATA_LENGTH

◆ MAX_TOKEN_LIST_IDENTIFIERS

◆ MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH

◆ MAX_TOKEN_TRANSFER_SIZE

◆ MAX_WORKINGSET_TRANSFER_PACKETS_Client

◆ MAX_WORKINGSET_TRANSFER_PACKETS_Server

◆ MAX_WORKINGSET_TRANSFER_PACKETS_SPACES

◆ MIN

◆ MIN_INITIAL_TRANSFER_PACKETS

◆ MIN_TOKEN_LIST_IDENTIFIERS