#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)
	Sends a synchronous IOCTL to the specified device object.

_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 491 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 2408 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 55 of file gui.c.

{
    return NULL;
}

◆ _Dispatch_type_() [1/7]

_Dispatch_type_ ( IRP_MJ_CREATE )

Definition at line 1353 of file isapnp.c.

{
    PAGED_CODE();
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
 
    DPRINT("%s(%p, %p)\n", __FUNCTION__, DeviceObject, Irp);
 
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
    return STATUS_SUCCESS;
}

◆ _Dispatch_type_() [2/7]

_Dispatch_type_ ( IRP_MJ_DEVICE_CONTROL )

Definition at line 1376 of file isapnp.c.

{
    PISAPNP_COMMON_EXTENSION CommonExt = DeviceObject->DeviceExtension;
 
    PAGED_CODE();
 
    DPRINT("%s(%p, %p) Minor - %X\n", __FUNCTION__, DeviceObject, Irp,
           IoGetCurrentIrpStackLocation(Irp)->MinorFunction);
 
    if (CommonExt->Signature == IsaPnpBus)
    {
        IoSkipCurrentIrpStackLocation(Irp);
        return IoCallDriver(((PISAPNP_FDO_EXTENSION)CommonExt)->Ldo, Irp);
    }
    else
    {
        NTSTATUS Status = Irp->IoStatus.Status;
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
}

◆ _Dispatch_type_() [3/7]

_Dispatch_type_ ( IRP_MJ_PNP )

Definition at line 1331 of file isapnp.c.

{
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;
 
    PAGED_CODE();
 
    if (DevExt->Signature == IsaPnpBus)
        return IsaFdoPnp((PISAPNP_FDO_EXTENSION)DevExt, Irp, IrpSp);
    else
        return IsaPdoPnp((PISAPNP_PDO_EXTENSION)DevExt, Irp, IrpSp);
}

◆ _Dispatch_type_() [4/7]

_Dispatch_type_ ( IRP_MJ_POWER )

Definition at line 1293 of file isapnp.c.

{
    PISAPNP_COMMON_EXTENSION DevExt = DeviceObject->DeviceExtension;
    NTSTATUS Status;
 
    if (DevExt->Signature != IsaPnpBus)
    {
        switch (IoGetCurrentIrpStackLocation(Irp)->MinorFunction)
        {
            case IRP_MN_SET_POWER:
            case IRP_MN_QUERY_POWER:
                Status = STATUS_SUCCESS;
                Irp->IoStatus.Status = Status;
                break;
 
            default:
                Status = Irp->IoStatus.Status;
                break;
        }
 
        PoStartNextPowerIrp(Irp);
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return Status;
    }
 
    PoStartNextPowerIrp(Irp);
    IoSkipCurrentIrpStackLocation(Irp);
    return PoCallDriver(((PISAPNP_FDO_EXTENSION)DevExt)->Ldo, Irp);
}

◆ _Dispatch_type_() [5/7]

_Dispatch_type_ ( IRP_MJ_READ )

Definition at line 3505 of file read.c.

                                                                   {
    device_extension* Vcb = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
    PFILE_OBJECT FileObject = IrpSp->FileObject;
    ULONG bytes_read = 0;
    NTSTATUS Status;
    bool top_level;
    fcb* fcb;
    ccb* ccb;
    bool acquired_fcb_lock = false, wait;
 
    FsRtlEnterFileSystem();
 
    top_level = is_top_level(Irp);
 
    TRACE("read\n");
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = vol_read(DeviceObject, Irp);
        goto exit2;
    } else if (!Vcb || Vcb->type != VCB_TYPE_FS) {
        Status = STATUS_INVALID_PARAMETER;
        goto end;
    }
 
    Irp->IoStatus.Information = 0;
 
    if (IrpSp->MinorFunction & IRP_MN_COMPLETE) {
        CcMdlReadComplete(IrpSp->FileObject, Irp->MdlAddress);
 
        Irp->MdlAddress = NULL;
        Status = STATUS_SUCCESS;
 
        goto exit;
    }
 
    fcb = FileObject->FsContext;
 
    if (!fcb) {
        ERR("fcb was NULL\n");
        Status = STATUS_INVALID_PARAMETER;
        goto exit;
    }
 
    ccb = FileObject->FsContext2;
 
    if (!ccb) {
        ERR("ccb was NULL\n");
        Status = STATUS_INVALID_PARAMETER;
        goto exit;
    }
 
    if (Irp->RequestorMode == UserMode && !(ccb->access & FILE_READ_DATA)) {
        WARN("insufficient privileges\n");
        Status = STATUS_ACCESS_DENIED;
        goto exit;
    }
 
    if (fcb == Vcb->volume_fcb) {
        TRACE("reading volume FCB\n");
 
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
 
        goto exit2;
    }
 
    if (!(Irp->Flags & IRP_PAGING_IO))
        FsRtlCheckOplock(fcb_oplock(fcb), Irp, NULL, NULL, NULL);
 
    wait = IoIsOperationSynchronous(Irp);
 
    // Don't offload jobs when doing paging IO - otherwise this can lead to
    // deadlocks in CcCopyRead.
    if (Irp->Flags & IRP_PAGING_IO)
        wait = true;
 
    if (!(Irp->Flags & IRP_PAGING_IO) && FileObject->SectionObjectPointer && FileObject->SectionObjectPointer->DataSectionObject) {
        IO_STATUS_BLOCK iosb;
 
        CcFlushCache(FileObject->SectionObjectPointer, &IrpSp->Parameters.Read.ByteOffset, IrpSp->Parameters.Read.Length, &iosb);
        if (!NT_SUCCESS(iosb.Status)) {
            ERR("CcFlushCache returned %08lx\n", iosb.Status);
            return iosb.Status;
        }
    }
 
    if (!ExIsResourceAcquiredSharedLite(fcb->Header.Resource)) {
        if (!ExAcquireResourceSharedLite(fcb->Header.Resource, wait)) {
            Status = STATUS_PENDING;
            IoMarkIrpPending(Irp);
            goto exit;
        }
 
        acquired_fcb_lock = true;
    }
 
    Status = do_read(Irp, wait, &bytes_read);
 
    if (acquired_fcb_lock)
        ExReleaseResourceLite(fcb->Header.Resource);
 
exit:
    if (FileObject->Flags & FO_SYNCHRONOUS_IO && !(Irp->Flags & IRP_PAGING_IO))
        FileObject->CurrentByteOffset.QuadPart = IrpSp->Parameters.Read.ByteOffset.QuadPart + (NT_SUCCESS(Status) ? bytes_read : 0);
 
end:
    Irp->IoStatus.Status = Status;
 
    TRACE("Irp->IoStatus.Status = %08lx\n", Irp->IoStatus.Status);
    TRACE("Irp->IoStatus.Information = %Iu\n", Irp->IoStatus.Information);
    TRACE("returning %08lx\n", Status);
 
    if (Status != STATUS_PENDING)
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    else {
        if (!add_thread_job(Vcb, Irp))
            Status = do_read_job(Irp);
    }
 
exit2:
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

◆ _Dispatch_type_() [6/7]

_Dispatch_type_ ( IRP_MJ_SHUTDOWN )

Definition at line 5510 of file btrfs.c.

                                                                                        {
    NTSTATUS Status;
    bool top_level;
    device_extension* Vcb = DeviceObject->DeviceExtension;
 
    FsRtlEnterFileSystem();
 
    TRACE("shutdown\n");
 
    top_level = is_top_level(Irp);
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        Status = STATUS_INVALID_DEVICE_REQUEST;
        goto end;
    }
 
    Status = STATUS_SUCCESS;
 
    do_shutdown(Irp);
 
end:
    Irp->IoStatus.Status = Status;
    Irp->IoStatus.Information = 0;
 
    IoCompleteRequest( Irp, IO_NO_INCREMENT );
 
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

◆ _Dispatch_type_() [7/7]

_Dispatch_type_ ( IRP_MJ_SYSTEM_CONTROL )

Definition at line 5748 of file btrfs.c.

                                                                                              {
    NTSTATUS Status;
    device_extension* Vcb = DeviceObject->DeviceExtension;
    bool top_level;
 
    FsRtlEnterFileSystem();
 
    top_level = is_top_level(Irp);
 
    Irp->IoStatus.Information = 0;
 
    if (Vcb && Vcb->type == VCB_TYPE_VOLUME) {
        volume_device_extension* vde = DeviceObject->DeviceExtension;
 
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(vde->attached_device, Irp);
 
        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_FS) {
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(Vcb->Vpb->RealDevice, Irp);
 
        goto exit;
    } else if (Vcb && Vcb->type == VCB_TYPE_BUS) {
        bus_device_extension* bde = DeviceObject->DeviceExtension;
 
        IoSkipCurrentIrpStackLocation(Irp);
 
        Status = IoCallDriver(bde->attached_device, Irp);
 
        goto exit;
    }
 
    Status = Irp->IoStatus.Status;
    IoCompleteRequest(Irp, IO_NO_INCREMENT);
 
exit:
    if (top_level)
        IoSetTopLevelIrp(NULL);
 
    FsRtlExitFileSystem();
 
    return Status;
}

◆ _In_reads_bytes_()

_In_ PTRANSFER_PACKET _In_ ULONG _In_reads_bytes_ ( Length )

◆ _IRQL_requires_()

_IRQL_requires_ ( PASSIVE_LEVEL )

Sends a synchronous IOCTL to the specified device object.

Parameters

[in]	IoControlCode	The IOCTL to send to the device.
[in]	DeviceObject	Pointer to the device object that will handle the IOCTL.
[in]	InputBuffer	Optional pointer to a buffer containing input data for the IOCTL. When specified, the buffer should be at least of InputBufferLength size.
[in]	InputBufferLength	Size in bytes, of the buffer pointed by InputBuffer.
[out]	OutputBuffer	Optional pointer to a buffer that will receive output data from the IOCTL. When specified, the buffer should be at least of OutputBufferLength size.
[in]	OutputBufferLength	Size in bytes, of the buffer pointed by OutputBuffer.
[in]	FileObject	Optional pointer to a file object that may be necessary for the IOCTL.

Returns: An NTSTATUS code indicating success or failure of this function.

Note: Must be called at PASSIVE_LEVEL with all APCs enabled.

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 37 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 923 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    NTSTATUS Status;
 
    /* The caller must allow at least one connection */
    if (MaxConnections == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* The request must be for a kernel handle */
    if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /*
     * Get rundown protection on the target to stop the owner
     * from unloading whilst this port object is open. It gets
     * removed in the FltpServerPortClose callback
     */
    Status = FltObjectReference(Filter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* Create the server port object for this filter */
    Status = ObCreateObject(KernelMode,
                            ServerPortObjectType,
                            ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_SERVER_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&PortObject);
    if (NT_SUCCESS(Status))
    {
        /* Zero out the struct */
        RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));
 
        /* Increment the ref count on the target filter */
        FltpObjectPointerReference((PFLT_OBJECT)Filter);
 
        /* Setup the filter port object */
        PortObject->Filter = Filter;
        PortObject->ConnectNotify = ConnectNotifyCallback;
        PortObject->DisconnectNotify = DisconnectNotifyCallback;
        PortObject->MessageNotify = MessageNotifyCallback;
        PortObject->Cookie = ServerPortCookie;
        PortObject->MaxConnections = MaxConnections;
 
        /* Insert the object */
        Status = ObInsertObject(PortObject,
                                NULL,
                                STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                0,
                                NULL,
                                (PHANDLE)ServerPort);
        if (NT_SUCCESS(Status))
        {
            /* Lock the connection list */
            ExAcquireFastMutex(&Filter->ConnectionList.mLock);
 
            /* Add the new port object to the connection list and increment the count */
            InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
            Filter->ConnectionList.mCount++;
 
            /* Unlock the connection list*/
            ExReleaseFastMutex(&Filter->ConnectionList.mLock);
        }
    }
 
    if (!NT_SUCCESS(Status))
    {
        /* Allow the filter to be cleaned up */
        FltObjectDereference(Filter);
    }
 
    return Status;
}

◆ AllocateDictionaryEntry()

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

Referenced by ClasspCreateClose().

◆ BuildDeviceInputMdl()

PMDL BuildDeviceInputMdl	(	PVOID	Buffer,
		ULONG	BufferLen
	)

Definition at line 609 of file utils.c.

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

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

◆ C_ASSERT()

C_ASSERT ( (sizeof(struct _CLASS_PRIVATE_COMMON_DATA) % sizeof(PVOID)) = =0 )

◆ ClassAddChild()

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

Definition at line 12058 of file class.c.

{
    if(AcquireLock) {
        ClassAcquireChildLock(Parent);
    }
 
    #if DBG
        //
        // Make sure this child's not already in the list.
        //
        {
            PPHYSICAL_DEVICE_EXTENSION testChild;
 
            for (testChild = Parent->CommonExtension.ChildList;
                 testChild != NULL;
                 testChild = testChild->CommonExtension.ChildList) {
 
                NT_ASSERT(testChild != Child);
            }
        }
    #endif
 
    Child->CommonExtension.ChildList = Parent->CommonExtension.ChildList;
    Parent->CommonExtension.ChildList = Child;
 
    if(AcquireLock) {
        ClassReleaseChildLock(Parent);
    }
    return;
} // end ClassAddChild()

◆ ClassDeviceGetLBProvisioningResources()

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

Definition at line 5087 of file utils.c.

{
    NTSTATUS status;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_LB_PROVISIONING_MAP_RESOURCES mapResources = (PSTORAGE_LB_PROVISIONING_MAP_RESOURCES)Irp->AssociatedIrp.SystemBuffer;
 
    status = ClassGetLBProvisioningResources(DeviceObject,
                                           Srb,
                                           irpStack->Parameters.DeviceIoControl.OutputBufferLength,
                                           mapResources);
 
    if (NT_SUCCESS(status)) {
        Irp->IoStatus.Information = mapResources->Size;
    } else {
        Irp->IoStatus.Information = 0;
    }
 
    Irp->IoStatus.Status = status;
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClassDeviceHwFirmwareActivateProcess()

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

Definition at line 8902 of file utils.c.

{
    NTSTATUS status = STATUS_SUCCESS;
 
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
 
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
 
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_HW_FIRMWARE_ACTIVATE firmwareActivate = (PSTORAGE_HW_FIRMWARE_ACTIVATE)Irp->AssociatedIrp.SystemBuffer;
    BOOLEAN passDown = FALSE;
    PCDB cdb = NULL;
    ULONG   i;
    BOOLEAN lockHeld = FALSE;
    KLOCK_QUEUE_HANDLE lockHandle;
 
 
    //
    // Input buffer is not big enough to contain required input information.
    //
    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_HW_FIRMWARE_ACTIVATE)) {
 
        status = STATUS_INFO_LENGTH_MISMATCH;
        goto Exit_Firmware_Activate;
    }
 
    //
    // Input buffer basic validation.
    //
    if ((firmwareActivate->Version < sizeof(STORAGE_HW_FIRMWARE_ACTIVATE)) ||
        (firmwareActivate->Size > irpStack->Parameters.DeviceIoControl.InputBufferLength)) {
 
        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Activate;
    }
 
    //
    // Only process the request for a supported port driver.
    //
    if (!ClassDeviceHwFirmwareIsPortDriverSupported(DeviceObject)) {
        status = STATUS_NOT_IMPLEMENTED;
        goto Exit_Firmware_Activate;
    }
 
    //
    // Buffer "FunctionSupportInfo" is allocated during start device process. Following check defends against the situation
    // of receiving this IOCTL when the device is created but not started, or device start failed but did not get removed yet.
    //
    if (commonExtension->IsFdo && (fdoExtension->FunctionSupportInfo == NULL)) {
 
        status = STATUS_UNSUCCESSFUL;
        goto Exit_Firmware_Activate;
    }
 
    //
    // Process the situation that request should be forwarded to lower level.
    //
    if (!commonExtension->IsFdo) {
        passDown = TRUE;
    }
 
    if ((firmwareActivate->Flags & STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER) != 0) {
        passDown = TRUE;
    }
 
    if (passDown) {
 
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        FREE_POOL(Srb);
        return status;
    }
 
    //
    // If firmware information hasn't been cached in classpnp, retrieve it.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo == NULL) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
            status = STATUS_NOT_IMPLEMENTED;
            goto Exit_Firmware_Activate;
        } else {
            //
            // If this is the first time of retrieving firmware information,
            // send request to lower level to get it.
            //
            status = ClasspGetHwFirmwareInfo(DeviceObject);
 
            if (!NT_SUCCESS(status)) {
                goto Exit_Firmware_Activate;
            }
        }
    }
 
    //
    // Fail the request if the firmware information cannot be retrieved.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo == NULL) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
            status = STATUS_NOT_IMPLEMENTED;
        } else {
            status = STATUS_UNSUCCESSFUL;
        }
 
        goto Exit_Firmware_Activate;
    }
 
    //
    // Acquire the SyncLock to ensure the HwFirmwareInfo pointer doesn't change
    // while we're dereferencing it.
    //
    lockHeld = TRUE;
    KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);
 
    //
    // Validate the device support
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SupportUpgrade == FALSE) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit_Firmware_Activate;
    }
 
    //
    // Check if the slot number is valid.
    //
    for (i = 0; i < fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SlotCount; i++) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Slot[i].SlotNumber == firmwareActivate->Slot) {
            break;
        }
    }
 
    if (i >= fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SlotCount) {
        //
        // Either the slot number is out of scope or the slot is read-only.
        //
        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Activate;
    }
 
    //
    // We're done accessing HwFirmwareInfo at this point so we can release
    // the SyncLock.
    //
    NT_ASSERT(lockHeld);
    KeReleaseInStackQueuedSpinLock(&lockHandle);
    lockHeld = FALSE;
 
    //
    // Process the request by translating it into WRITE BUFFER command.
    //
    //
    // Setup the CDB. This should be an untagged request.
    //
    SrbSetCdbLength(Srb, CDB10GENERIC_LENGTH);
    cdb = SrbGetCdb(Srb);
    cdb->WRITE_BUFFER.OperationCode = SCSIOP_WRITE_DATA_BUFF;
    cdb->WRITE_BUFFER.Mode = SCSI_WRITE_BUFFER_MODE_ACTIVATE_DEFERRED_MICROCODE;
    cdb->WRITE_BUFFER.ModeSpecific = 0;                     //Reserved for Mode 0x0F
    cdb->WRITE_BUFFER.BufferID = firmwareActivate->Slot;    //NOTE: this field will be ignored by SCSI device.
 
    //
    // Set timeout value.
    //
    SrbSetTimeOutValue(Srb, FIRMWARE_ACTIVATE_TIMEOUT_VALUE);
 
    //
    // This routine uses a completion routine - ClassIoComplete() so we don't want to release
    // the remove lock until then.
    //
    status = ClassSendSrbAsynchronous(DeviceObject,
                                      Srb,
                                      Irp,
                                      NULL,
                                      0,
                                      FALSE);
 
    if (status != STATUS_PENDING) {
        //
        // If the irp cannot be sent down, the Srb has been freed. NULL it to prevent from freeing it again.
        //
        Srb = NULL;
 
        goto Exit_Firmware_Activate;
    }
 
    return status;
 
Exit_Firmware_Activate:
 
    //
    // Release the SyncLock if it's still held.
    // This should only happen in the failure path.
    //
    if (lockHeld) {
        KeReleaseInStackQueuedSpinLock(&lockHandle);
        lockHeld = FALSE;
    }
 
    //
    // Firmware Activate request will be failed.
    //
    NT_ASSERT(!NT_SUCCESS(status));
 
    Irp->IoStatus.Status = status;
 
#else
    status = STATUS_NOT_IMPLEMENTED;
    Irp->IoStatus.Status = status;
#endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    FREE_POOL(Srb);
    return status;
}

Referenced by ClassDeviceControl().

◆ ClassDeviceHwFirmwareDownloadProcess()

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

Definition at line 8541 of file utils.c.

{
    NTSTATUS status = STATUS_SUCCESS;
 
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
 
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
 
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_HW_FIRMWARE_DOWNLOAD firmwareDownload = (PSTORAGE_HW_FIRMWARE_DOWNLOAD)Irp->AssociatedIrp.SystemBuffer;
    BOOLEAN passDown = FALSE;
    ULONG   i;
    ULONG   bufferSize = 0;
    PUCHAR  firmwareImageBuffer = NULL;
    PIRP irp2 = NULL;
    PIO_STACK_LOCATION newStack = NULL;
    PCDB cdb = NULL;
    BOOLEAN lockHeld = FALSE;
    KLOCK_QUEUE_HANDLE lockHandle;
 
 
    //
    // Input buffer is not big enough to contain required input information.
    //
    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_HW_FIRMWARE_DOWNLOAD)) {
 
        status = STATUS_INFO_LENGTH_MISMATCH;
        goto Exit_Firmware_Download;
    }
 
    //
    // Input buffer basic validation.
    //
    if ((firmwareDownload->Version < sizeof(STORAGE_HW_FIRMWARE_DOWNLOAD)) ||
        (firmwareDownload->Size > irpStack->Parameters.DeviceIoControl.InputBufferLength) ||
        ((firmwareDownload->BufferSize + FIELD_OFFSET(STORAGE_HW_FIRMWARE_DOWNLOAD, ImageBuffer)) > firmwareDownload->Size)) {
 
        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Download;
    }
 
    //
    // Only process the request for a supported port driver.
    //
    if (!ClassDeviceHwFirmwareIsPortDriverSupported(DeviceObject)) {
        status = STATUS_NOT_IMPLEMENTED;
        goto Exit_Firmware_Download;
    }
 
    //
    // Buffer "FunctionSupportInfo" is allocated during start device process. Following check defends against the situation
    // of receiving this IOCTL when the device is created but not started, or device start failed but did not get removed yet.
    //
    if (commonExtension->IsFdo && (fdoExtension->FunctionSupportInfo == NULL)) {
 
        status = STATUS_UNSUCCESSFUL;
        goto Exit_Firmware_Download;
    }
 
    //
    // Process the situation that request should be forwarded to lower level.
    //
    if (!commonExtension->IsFdo) {
        passDown = TRUE;
    }
 
    if ((firmwareDownload->Flags & STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER) != 0) {
        passDown = TRUE;
    }
 
    if (passDown) {
 
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        FREE_POOL(Srb);
        return status;
    }
 
    //
    // If firmware information hasn't been cached in classpnp, retrieve it.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo == NULL) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
            status = STATUS_NOT_IMPLEMENTED;
            goto Exit_Firmware_Download;
        } else {
            //
            // If this is the first time of retrieving firmware information,
            // send request to lower level to get it.
            //
            status = ClasspGetHwFirmwareInfo(DeviceObject);
 
            if (!NT_SUCCESS(status)) {
                goto Exit_Firmware_Download;
            }
        }
    }
 
    //
    // Fail the request if the firmware information cannot be retrieved.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo == NULL) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
            status = STATUS_NOT_IMPLEMENTED;
        } else {
            status = STATUS_UNSUCCESSFUL;
        }
 
        goto Exit_Firmware_Download;
    }
 
    //
    // Acquire the SyncLock to ensure the HwFirmwareInfo pointer doesn't change
    // while we're dereferencing it.
    //
    lockHeld = TRUE;
    KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);
 
    //
    // Validate the device support
    //
    if ((fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SupportUpgrade == FALSE) ||
        (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment == 0)) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit_Firmware_Download;
    }
 
    //
    // Check if the slot can be used to hold firmware image.
    //
    for (i = 0; i < fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SlotCount; i++) {
        if (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Slot[i].SlotNumber == firmwareDownload->Slot) {
            break;
        }
    }
 
    if ((i >= fdoExtension->FunctionSupportInfo->HwFirmwareInfo->SlotCount) ||
        (fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Slot[i].ReadOnly == TRUE)) {
        //
        // Either the slot number is out of scope or the slot is read-only.
        //
        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Download;
    }
 
    //
    // Buffer size and alignment validation.
    // Max Offset and Buffer Size can be represented by SCSI command is max value for 3 bytes.
    //
    if ((firmwareDownload->BufferSize == 0) ||
        ((firmwareDownload->BufferSize % fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment) != 0) ||
        (firmwareDownload->BufferSize > fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadMaxSize) ||
        (firmwareDownload->BufferSize > fdoExtension->AdapterDescriptor->MaximumTransferLength) ||
        ((firmwareDownload->Offset % fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment) != 0) ||
        (firmwareDownload->Offset > 0xFFFFFF) ||
        (firmwareDownload->BufferSize > 0xFFFFFF)) {
 
        status = STATUS_INVALID_PARAMETER;
        goto Exit_Firmware_Download;
    }
 
 
    //
    // Process the request by translating it into WRITE BUFFER command.
    //
    if (((ULONG_PTR)firmwareDownload->ImageBuffer % fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment) != 0) {
        //
        // Allocate buffer aligns to ImagePayloadAlignment to accommodate the alignment requirement.
        //
        bufferSize = ALIGN_UP_BY(firmwareDownload->BufferSize, fdoExtension->FunctionSupportInfo->HwFirmwareInfo->ImagePayloadAlignment);
 
        //
        // We're done accessing HwFirmwareInfo at this point so we can release
        // the SyncLock.
        //
        NT_ASSERT(lockHeld);
        KeReleaseInStackQueuedSpinLock(&lockHandle);
        lockHeld = FALSE;
 
#ifdef _MSC_VER
#pragma prefast(suppress:6014, "The allocated memory that firmwareImageBuffer points to will be freed in ClassHwFirmwareDownloadComplete().")
#endif
        firmwareImageBuffer = ExAllocatePoolWithTag(NonPagedPoolNx, bufferSize, CLASSPNP_POOL_TAG_FIRMWARE);
 
        if (firmwareImageBuffer == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit_Firmware_Download;
        }
 
        RtlZeroMemory(firmwareImageBuffer, bufferSize);
 
        RtlCopyMemory(firmwareImageBuffer, firmwareDownload->ImageBuffer, (ULONG)firmwareDownload->BufferSize);
 
    } else {
        NT_ASSERT(lockHeld);
        KeReleaseInStackQueuedSpinLock(&lockHandle);
        lockHeld = FALSE;
 
        firmwareImageBuffer = firmwareDownload->ImageBuffer;
        bufferSize = (ULONG)firmwareDownload->BufferSize;
    }
 
    //
    // Allocate a new irp to send the WRITE BUFFER command down.
    // Similar process as IOCTL_STORAGE_CHECK_VERIFY.
    //
    irp2 = IoAllocateIrp((CCHAR)(DeviceObject->StackSize + 3), FALSE);
 
    if (irp2 == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        if (firmwareImageBuffer != firmwareDownload->ImageBuffer) {
            FREE_POOL(firmwareImageBuffer);
        }
 
        goto Exit_Firmware_Download;
    }
 
    //
    // Make sure to acquire the lock for the new irp.
    //
    ClassAcquireRemoveLock(DeviceObject, irp2);
 
    irp2->Tail.Overlay.Thread = Irp->Tail.Overlay.Thread;
    IoSetNextIrpStackLocation(irp2);
 
    //
    // Set the top stack location and shove the master Irp into the
    // top location
    //
    newStack = IoGetCurrentIrpStackLocation(irp2);
    newStack->Parameters.Others.Argument1 = Irp;
    newStack->DeviceObject = DeviceObject;
 
    //
    // Stick the firmware download completion routine onto the stack
    // and prepare the irp for the port driver
    //
    IoSetCompletionRoutine(irp2,
                           ClassHwFirmwareDownloadComplete,
                           (firmwareImageBuffer != firmwareDownload->ImageBuffer) ? firmwareImageBuffer : NULL,
                           TRUE,
                           TRUE,
                           TRUE);
 
    IoSetNextIrpStackLocation(irp2);
    newStack = IoGetCurrentIrpStackLocation(irp2);
    newStack->DeviceObject = DeviceObject;
    newStack->MajorFunction = irpStack->MajorFunction;
    newStack->MinorFunction = irpStack->MinorFunction;
    newStack->Flags = irpStack->Flags;
 
 
    //
    // Mark the master irp as pending - whether the lower level
    // driver completes it immediately or not this should allow it
    // to go all the way back up.
    //
    IoMarkIrpPending(Irp);
 
    //
    // Setup the CDB.
    //
    SrbSetCdbLength(Srb, CDB10GENERIC_LENGTH);
    cdb = SrbGetCdb(Srb);
    cdb->WRITE_BUFFER.OperationCode = SCSIOP_WRITE_DATA_BUFF;
    cdb->WRITE_BUFFER.Mode = SCSI_WRITE_BUFFER_MODE_DOWNLOAD_MICROCODE_WITH_OFFSETS_SAVE_DEFER_ACTIVATE;
    cdb->WRITE_BUFFER.ModeSpecific = 0;     //Reserved for Mode 0x0E
    cdb->WRITE_BUFFER.BufferID = firmwareDownload->Slot;
 
    cdb->WRITE_BUFFER.BufferOffset[0] = *((PCHAR)&firmwareDownload->Offset + 2);
    cdb->WRITE_BUFFER.BufferOffset[1] = *((PCHAR)&firmwareDownload->Offset + 1);
    cdb->WRITE_BUFFER.BufferOffset[2] = *((PCHAR)&firmwareDownload->Offset);
 
    cdb->WRITE_BUFFER.ParameterListLength[0] = *((PCHAR)&bufferSize + 2);
    cdb->WRITE_BUFFER.ParameterListLength[1] = *((PCHAR)&bufferSize + 1);
    cdb->WRITE_BUFFER.ParameterListLength[2] = *((PCHAR)&bufferSize);
 
    //
    // Send as a tagged command.
    //
    SrbSetRequestAttribute(Srb, SRB_HEAD_OF_QUEUE_TAG_REQUEST);
    SrbSetSrbFlags(Srb, SRB_FLAGS_NO_QUEUE_FREEZE | SRB_FLAGS_QUEUE_ACTION_ENABLE);
 
    //
    // Set timeout value.
    //
    SrbSetTimeOutValue(Srb, fdoExtension->TimeOutValue);
 
    //
    // This routine uses a completion routine so we don't want to release
    // the remove lock until then.
    //
    status = ClassSendSrbAsynchronous(DeviceObject,
                                      Srb,
                                      irp2,
                                      firmwareImageBuffer,
                                      bufferSize,
                                      TRUE);
 
    if (status != STATUS_PENDING) {
        //
        // If the new irp cannot be sent down, free allocated memory and bail out.
        //
        if (firmwareImageBuffer != firmwareDownload->ImageBuffer) {
            FREE_POOL(firmwareImageBuffer);
        }
 
        //
        // If the irp cannot be sent down, the Srb has been freed. NULL it to prevent from freeing it again.
        //
        Srb = NULL;
 
        ClassReleaseRemoveLock(DeviceObject, irp2);
 
        IoFreeIrp(irp2);
 
        goto Exit_Firmware_Download;
    }
 
    return status;
 
Exit_Firmware_Download:
 
    //
    // Release the SyncLock if it's still held.
    // This should only happen in the failure path.
    //
    if (lockHeld) {
        KeReleaseInStackQueuedSpinLock(&lockHandle);
        lockHeld = FALSE;
    }
 
    //
    // Firmware Download request will be failed.
    //
    NT_ASSERT(!NT_SUCCESS(status));
 
    Irp->IoStatus.Status = status;
 
#else
    status = STATUS_NOT_IMPLEMENTED;
    Irp->IoStatus.Status = status;
#endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    FREE_POOL(Srb);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClassDeviceHwFirmwareGetInfoProcess()

NTSTATUS ClassDeviceHwFirmwareGetInfoProcess	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 8366 of file utils.c.

{
    NTSTATUS status = STATUS_SUCCESS;
 
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
 
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_HW_FIRMWARE_INFO_QUERY query = (PSTORAGE_HW_FIRMWARE_INFO_QUERY)Irp->AssociatedIrp.SystemBuffer;
    BOOLEAN passDown = FALSE;
    BOOLEAN copyData = FALSE;
 
 
    //
    // Input buffer is not big enough to contain required input information.
    //
    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_HW_FIRMWARE_INFO_QUERY)) {
 
        status = STATUS_INFO_LENGTH_MISMATCH;
        goto Exit_Firmware_Get_Info;
    }
 
    //
    // Output buffer is too small to contain return data.
    //
    if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_HW_FIRMWARE_INFO)) {
 
        status = STATUS_BUFFER_TOO_SMALL;
        goto Exit_Firmware_Get_Info;
    }
 
    //
    // Only process the request for a supported port driver.
    //
    if (!ClassDeviceHwFirmwareIsPortDriverSupported(DeviceObject)) {
        status = STATUS_NOT_IMPLEMENTED;
        goto Exit_Firmware_Get_Info;
    }
 
    //
    // Buffer "FunctionSupportInfo" is allocated during start device process. Following check defends against the situation
    // of receiving this IOCTL when the device is created but not started, or device start failed but did not get removed yet.
    //
    if (commonExtension->IsFdo && (fdoExtension->FunctionSupportInfo == NULL)) {
 
        status = STATUS_UNSUCCESSFUL;
        goto Exit_Firmware_Get_Info;
    }
 
    //
    // Process the situation that request should be forwarded to lower level.
    //
    if (!commonExtension->IsFdo) {
        passDown = TRUE;
    }
 
    if ((query->Flags & STORAGE_HW_FIRMWARE_REQUEST_FLAG_CONTROLLER) != 0) {
        passDown = TRUE;
    }
 
    if (passDown) {
 
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        return status;
    }
 
    //
    // The request is for a FDO. Process the request.
    //
    if (fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport == NotSupported) {
        status = STATUS_NOT_IMPLEMENTED;
        goto Exit_Firmware_Get_Info;
    } else {
        //
        // Retrieve information from lower layer for the request. The cached information is not used
        // in case device firmware information changed.
        //
        status = ClasspGetHwFirmwareInfo(DeviceObject);
        copyData = NT_SUCCESS(status);
    }
 
Exit_Firmware_Get_Info:
 
    if (copyData) {
        //
        // Firmware information is already cached in classpnp. Return a copy.
        //
        KLOCK_QUEUE_HANDLE lockHandle;
        KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);
 
        ULONG dataLength = min(irpStack->Parameters.DeviceIoControl.OutputBufferLength, fdoExtension->FunctionSupportInfo->HwFirmwareInfo->Size);
 
        memcpy(Irp->AssociatedIrp.SystemBuffer, fdoExtension->FunctionSupportInfo->HwFirmwareInfo, dataLength);
 
        KeReleaseInStackQueuedSpinLock(&lockHandle);
 
        Irp->IoStatus.Information = dataLength;
    }
 
    Irp->IoStatus.Status = status;
 
#else
    status = STATUS_NOT_IMPLEMENTED;
    Irp->IoStatus.Status = status;
#endif // #if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClassFreeOrReuseSrb()

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

Definition at line 882 of file obsolete.c.

{
    PCOMMON_DEVICE_EXTENSION commonExt = &FdoExtension->CommonExtension;
 
    // This function is obsolete, but still called by DISK.SYS .
    // TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassFreeOrReuseSrb is OBSOLETE !"));
 
    //
    // safety net.  this should never occur.  if it does, it's a potential
    // memory leak.
    //
    NT_ASSERT(!TEST_FLAG(SrbGetSrbFlags(Srb), SRB_FLAGS_FREE_SENSE_BUFFER));
 
    if (commonExt->IsSrbLookasideListInitialized){
        /*
         *  Put the SRB back in our lookaside list.
         *
         *  Note:   Some class drivers use ClassIoComplete
         *            to complete SRBs that they themselves allocated.
         *            So we may be putting a "foreign" SRB
         *            (e.g. with a different pool tag) into our lookaside list.
         */
        ClasspFreeSrb(FdoExtension, Srb);
    }
    else {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,"ClassFreeOrReuseSrb: someone is trying to use an uninitialized SrbLookasideList !!!"));
        FREE_POOL(Srb);
    }
}

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

◆ ClassGetPdoId()

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

Definition at line 10151 of file class.c.

{
#ifdef _MSC_VER
#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
#endif
    PCLASS_DRIVER_EXTENSION driverExtension = IoGetDriverObjectExtension(Pdo->DriverObject, CLASS_DRIVER_EXTENSION_KEY);
 
    _Analysis_assume_(driverExtension != NULL);
 
    ASSERT_PDO(Pdo);
    NT_ASSERT(driverExtension->InitData.ClassQueryId);
 
    PAGED_CODE();
 
    return driverExtension->InitData.ClassQueryId( Pdo, IdType, IdString);
} // end ClassGetPdoId()

Referenced by ClassDispatchPnp().

◆ ClassInitializeDispatchTables()

VOID ClassInitializeDispatchTables ( PCLASS_DRIVER_EXTENSION DriverExtension )

Definition at line 38 of file dispatch.c.

{
    ULONG idx;
 
    PAGED_CODE();
 
    //
    // Initialize the standard device dispatch table
    //
 
    for (idx = 0; idx <= IRP_MJ_MAXIMUM_FUNCTION; idx++) {
        DriverExtension->DeviceMajorFunctionTable[idx] = ClassDispatchUnimplemented;
    }
 
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_CREATE]         = ClassCreateClose;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_CLOSE]          = ClassCreateClose;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_READ]           = ClassReadWrite;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_WRITE]          = ClassReadWrite;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_DEVICE_CONTROL] = ClassDeviceControlDispatch;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_SCSI]           = ClassInternalIoControl;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_SHUTDOWN]       = ClassShutdownFlush;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_FLUSH_BUFFERS]  = ClassShutdownFlush;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_PNP]            = ClassDispatchPnp;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_POWER]          = ClassDispatchPower;
    DriverExtension->DeviceMajorFunctionTable[IRP_MJ_SYSTEM_CONTROL] = ClassSystemControl;
 
 
    return;
}

Referenced by _IRQL_requires_max_().

◆ ClassIoCompletion()

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

◆ ClassMinimalPowerHandler()

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

Definition at line 1890 of file power.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    PoStartNextPowerIrp(Irp);
 
    switch (irpStack->MinorFunction)
    {
        case IRP_MN_SET_POWER:
        {
            switch (irpStack->Parameters.Power.ShutdownType)
            {
                case PowerActionNone:
                case PowerActionSleep:
                case PowerActionHibernate:
                {
                    if (TEST_FLAG(DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA))
                    {
                        if ((ClassGetVpb(DeviceObject) != NULL) && (ClassGetVpb(DeviceObject)->Flags & VPB_MOUNTED))
                        {
                            //
                            // This flag will cause the filesystem to verify the
                            // volume when coming out of hibernation or standby or runtime power
                            //
                            SET_FLAG(DeviceObject->Flags, DO_VERIFY_VOLUME);
                        }
                    }
                }
                break;
            }
        }
 
        //
        // Fall through
        //
 
        case IRP_MN_QUERY_POWER:
        {
            if (!commonExtension->IsFdo)
            {
                Irp->IoStatus.Status = STATUS_SUCCESS;
                Irp->IoStatus.Information = 0;
            }
        }
        break;
    }
 
    if (commonExtension->IsFdo)
    {
        IoCopyCurrentIrpStackLocationToNext(Irp);
        status = PoCallDriver(commonExtension->LowerDeviceObject, Irp);
    }
    else
    {
        status = Irp->IoStatus.Status;
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
    }
 
    return status;
} // end ClassMinimalPowerHandler()

Referenced by _IRQL_requires_max_().

◆ ClasspAccessAlignmentProperty()

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

Definition at line 1700 of file utils.c.

{
    NTSTATUS    status = STATUS_UNSUCCESSFUL;
 
    PCOMMON_DEVICE_EXTENSION     commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PSTORAGE_PROPERTY_QUERY      query = (PSTORAGE_PROPERTY_QUERY)Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION           irpStack = IoGetCurrentIrpStackLocation(Irp);
    ULONG                        length = 0;
    ULONG                        information = 0;
 
    PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR accessAlignment;
 
    //
    // check registry setting and fail the IOCTL if it's required.
    // this registry setting can be used to work around issues which upper layer doesn't support large physical sector size.
    //
    if (fdoExtension->FunctionSupportInfo->RegAccessAlignmentQueryNotSupported) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit;
    }
 
    if ( (DeviceObject->DeviceType != FILE_DEVICE_DISK) ||
         (TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE)) ||
         (fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty == Supported) ) {
        // if it's not disk, forward the request to lower layer,
        // if the IOCTL is supported by lower stack, forward it down.
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        return status;
    }
 
    //
    // Check proper query type.
    //
 
    if (query->QueryType == PropertyExistsQuery) {
        status = STATUS_SUCCESS;
        goto Exit;
    } else  if (query->QueryType != PropertyStandardQuery) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit;
    }
 
    //
    // Request validation.
    // Note that InputBufferLength and IsFdo have been validated before entering this routine.
    //
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        status = STATUS_INVALID_LEVEL;
        goto Exit;
    }
 
    // do not touch this buffer because it can still be used as input buffer for lower layer in 'SupportUnknown' case.
    accessAlignment = (PSTORAGE_ACCESS_ALIGNMENT_DESCRIPTOR)Irp->AssociatedIrp.SystemBuffer;
 
    length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    if (length < sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR)) {
 
        if (length >= sizeof(STORAGE_DESCRIPTOR_HEADER)) {
 
            information = sizeof(STORAGE_DESCRIPTOR_HEADER);
            accessAlignment->Version = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            accessAlignment->Size = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            status = STATUS_SUCCESS;
            goto Exit;
        }
 
        status = STATUS_BUFFER_TOO_SMALL;
        goto Exit;
    }
 
    // not support Cache Line,
    // 'BytesPerCacheLine' and 'BytesOffsetForCacheAlignment' fields are zero-ed.
 
    //
    // note that 'Supported' case has been handled at the beginning of this function.
    //
    switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty) {
    case SupportUnknown: {
        // send down request and wait for the request to complete.
        status = ClassForwardIrpSynchronous(commonExtension, Irp);
 
        if (ClasspLowerLayerNotSupport(status)) {
            // case 1: the request is not supported by lower layer, sends down command
            // some port drivers (or filter drivers) return STATUS_INVALID_DEVICE_REQUEST if a request is not supported.
 
            // ClassReadCapacity16() will either return status from cached data or send command to retrieve the information.
            if (ClasspIsObsoletePortDriver(fdoExtension) == FALSE) {
                status = ClassReadCapacity16(fdoExtension, Srb);
            } else {
                fdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus = status;
            }
 
            // data is ready in fdoExtension
            // set the support status after the SCSI command is executed to avoid racing condition between multiple same type of requests.
            fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty = NotSupported;
 
            if (NT_SUCCESS(status)) {
                // fill output buffer
                RtlZeroMemory(accessAlignment, length);
                accessAlignment->Version = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
                accessAlignment->Size = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
                accessAlignment->BytesPerLogicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector;
                accessAlignment->BytesPerPhysicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerPhysicalSector;
                accessAlignment->BytesOffsetForSectorAlignment = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesOffsetForSectorAlignment;
 
                // set returned data length
                information = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            } else {
                information = 0;
            }
 
        } else {
            // case 2: the request is supported and it completes successfully
            // case 3: the request is supported by lower stack but other failure status is returned.
            // from now on, the same request will be send down to lower stack directly.
            fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty = Supported;
            information = (ULONG)Irp->IoStatus.Information;
 
 
        }
 
 
        goto Exit;
 
        break;
    }
 
    case NotSupported: {
 
        // ClassReadCapacity16() will either return status from cached data or send command to retrieve the information.
        status = ClassReadCapacity16(fdoExtension, Srb);
 
        if (NT_SUCCESS(status)) {
            RtlZeroMemory(accessAlignment, length);
            accessAlignment->Version = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            accessAlignment->Size = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
            accessAlignment->BytesPerLogicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector;
            accessAlignment->BytesPerPhysicalSector = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerPhysicalSector;
            accessAlignment->BytesOffsetForSectorAlignment = fdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesOffsetForSectorAlignment;
 
            information = sizeof(STORAGE_ACCESS_ALIGNMENT_DESCRIPTOR);
        } else {
            information = 0;
        }
        goto Exit;
 
        break;
    }
 
    case Supported: {
        NT_ASSERT(FALSE); // this case is handled at the beginning of the function.
        status = STATUS_INTERNAL_ERROR;
        break;
    }
 
    }   // end of switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.AccessAlignmentProperty)
 
Exit:
 
    //
    // Set the size and status in IRP
    //
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspAllocatePowerProcessIrp()

NTSTATUS ClasspAllocatePowerProcessIrp ( IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

◆ ClasspAllocateReleaseQueueIrp()

NTSTATUS ClasspAllocateReleaseQueueIrp ( IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

◆ ClasspAllocateReleaseRequest()

NTSTATUS ClasspAllocateReleaseRequest ( IN PDEVICE_OBJECT Fdo )

Definition at line 11489 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
 
    PAGED_CODE();
 
    KeInitializeSpinLock(&(fdoExtension->ReleaseQueueSpinLock));
 
    fdoExtension->ReleaseQueueNeeded = FALSE;
    fdoExtension->ReleaseQueueInProgress = FALSE;
    fdoExtension->ReleaseQueueIrpFromPool = FALSE;
 
    //
    // The class driver is responsible for allocating a properly sized irp,
    // or ClassReleaseQueue will attempt to do it on the first error.
    //
 
    fdoExtension->ReleaseQueueIrp = NULL;
 
    //
    // Write length to SRB.
    //
 
    fdoExtension->ReleaseQueueSrb.Length = sizeof(SCSI_REQUEST_BLOCK);
 
    return STATUS_SUCCESS;
} // end ClasspAllocateReleaseRequest()

◆ ClasspBinaryToAscii()

_IRQL_requires_same_ PUCHAR ClasspBinaryToAscii	(	_In_reads_(Length) PUCHAR	HexBuffer,
		_In_ ULONG	Length,
		_Inout_ PULONG	UpdateLength
	)

Definition at line 7717 of file utils.c.

{
    static const UCHAR integerTable[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    ULONG i;
    ULONG j;
    ULONG actualLength;
    PUCHAR buffer = NULL;
    UCHAR highWord;
    UCHAR lowWord;
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspBinaryToAscii (HexBuff %p): Entering function.\n",
                HexBuffer));
 
    if (!HexBuffer || Length == 0) {
        *UpdateLength = 0;
        goto __ClasspBinaryToAscii_Exit;
    }
 
    //
    // Each byte converts into 2 chars:
    // e.g. 0x05 => '0' '5'
    //      0x0C => '0' 'C'
    //      0x12 => '1' '2'
    // And we need a terminating NULL for the string.
    //
    actualLength = (Length * 2) + 1;
 
    //
    // Allocate the buffer.
    //
    buffer = ExAllocatePoolWithTag(NonPagedPoolNx, actualLength, CLASSPNP_POOL_TAG_TOKEN_OPERATION);
    if (!buffer) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspBinaryToAscii (HexBuff %p): Failed to allocate buffer for ASCII equivalent.\n",
                    HexBuffer));
 
        *UpdateLength = 0;
        goto __ClasspBinaryToAscii_Exit;
    }
 
    RtlZeroMemory(buffer, actualLength);
 
    for (i = 0, j = 0; i < Length; i++) {
 
        //
        // Split out each nibble from the binary byte.
        //
        highWord = HexBuffer[i] >> 4;
        lowWord = HexBuffer[i] & 0x0F;
 
        //
        // Using the lookup table, convert and stuff into
        // the ascii buffer.
        //
        buffer[j++] = integerTable[highWord];
#ifdef _MSC_VER
#pragma warning(suppress: 6386) // PREFast bug means it doesn't see that Length < actualLength
#endif
        buffer[j++] = integerTable[lowWord];
    }
 
    //
    // Update the caller's length field.
    //
    *UpdateLength = actualLength;
 
__ClasspBinaryToAscii_Exit:
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspBinaryToAscii (HexBuff %p): Exiting function with buffer %s.\n",
                HexBuffer,
                (buffer == NULL) ? "" : (const char*)buffer));
 
    return buffer;
}

Referenced by ClasspContinueOffloadWrite(), and ClasspReceivePopulateTokenInformationTransferPacketDone().

◆ ClasspBlockLimitsDataSnapshot()

NTSTATUS ClasspBlockLimitsDataSnapshot	(	_In_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_In_ BOOLEAN	ForceQuery,
		_Out_ PCLASS_VPD_B0_DATA	BlockLimitsData,
		_Out_ PULONG	GenerationCount
	)

Definition at line 16504 of file class.c.

{
    NTSTATUS            status;
    KLOCK_QUEUE_HANDLE  lockHandle;
 
    status = ClasspRefreshFunctionSupportInfo(FdoExtension, ForceQuery);
 
    KeAcquireInStackQueuedSpinLock(&FdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);
    *BlockLimitsData = FdoExtension->FunctionSupportInfo->BlockLimitsData;
    *GenerationCount = FdoExtension->FunctionSupportInfo->GenerationCount;
    KeReleaseInStackQueuedSpinLock(&lockHandle);
 
    return status;
}

Referenced by ClasspDeviceGetLBAStatus(), ClasspDeviceLBProvisioningProperty(), and ClasspDeviceTrimProcess().

◆ ClasspBuildDeviceMdl()

PMDL ClasspBuildDeviceMdl	(	PVOID	Buffer,
		ULONG	BufferLen,
		BOOLEAN	WriteToDevice
	)

Definition at line 582 of file utils.c.

{
    PMDL mdl;
 
    mdl = IoAllocateMdl(Buffer, BufferLen, FALSE, FALSE, NULL);
    if (mdl){
        _SEH2_TRY {
            MmProbeAndLockPages(mdl, KernelMode, WriteToDevice ? IoReadAccess : IoWriteAccess);
#ifdef _MSC_VER
        #pragma warning(suppress: 6320) // We want to handle any exception that MmProbeAndLockPages might throw
#endif
        } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
            NTSTATUS status = _SEH2_GetExceptionCode();
 
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT, "ClasspBuildDeviceMdl: MmProbeAndLockPages failed with %xh.", status));
            IoFreeMdl(mdl);
            mdl = NULL;
        } _SEH2_END;
    }
    else {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT, "ClasspBuildDeviceMdl: IoAllocateMdl failed"));
    }
 
    return mdl;
}

Referenced by BuildDeviceInputMdl().

◆ ClasspBuildRequestEx()

VOID ClasspBuildRequestEx	(	_In_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_In_ PIRP	Irp,
		_In_ __drv_aliasesMem PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 537 of file obsolete.c.

{
    PIO_STACK_LOCATION  currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
    PIO_STACK_LOCATION  nextIrpStack = IoGetNextIrpStackLocation(Irp);
 
    LARGE_INTEGER       startingOffset = currentIrpStack->Parameters.Read.ByteOffset;
 
    PCDB                cdb;
    ULONG               logicalBlockAddress;
    USHORT              transferBlocks;
    NTSTATUS            status;
    PSTORAGE_REQUEST_BLOCK_HEADER srbHeader = (PSTORAGE_REQUEST_BLOCK_HEADER)Srb;
 
    // This function is obsolete, but still called by CDROM.SYS .
    // TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClasspBuildRequestEx is OBSOLETE !"));
 
    if (Srb == NULL) {
        NT_ASSERT(FALSE);
        return;
    }
 
    //
    // Calculate relative sector address.
    //
 
    logicalBlockAddress =
        (ULONG)(Int64ShrlMod32(startingOffset.QuadPart,
                               FdoExtension->SectorShift));
 
    //
    // Prepare the SRB.
    // NOTE - for extended SRB, size used is based on allocation in ClasspAllocateSrb.
    //
 
    if (FdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        status = InitializeStorageRequestBlock((PSTORAGE_REQUEST_BLOCK)Srb,
                                               STORAGE_ADDRESS_TYPE_BTL8,
                                               CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE,
                                               1,
                                               SrbExDataTypeScsiCdb16);
        if (!NT_SUCCESS(status)) {
            NT_ASSERT(FALSE);
            return;
        }
 
        ((PSTORAGE_REQUEST_BLOCK)Srb)->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
    } else {
        RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));
 
        //
        // Write length to SRB.
        //
 
        Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
 
        Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    }
 
 
    //
    // Set up IRP Address.
    //
 
    SrbSetOriginalRequest(srbHeader, Irp);
 
    //
    // Set up data buffer
    //
 
    SrbSetDataBuffer(srbHeader,
                           MmGetMdlVirtualAddress(Irp->MdlAddress));
 
    //
    // Save byte count of transfer in SRB Extension.
    //
 
    SrbSetDataTransferLength(srbHeader,
                                   currentIrpStack->Parameters.Read.Length);
 
    //
    // Initialize the queue actions field.
    //
 
    SrbSetRequestAttribute(srbHeader, SRB_SIMPLE_TAG_REQUEST);
 
    //
    // Queue sort key is Relative Block Address.
    //
 
    SrbSetQueueSortKey(srbHeader, logicalBlockAddress);
 
    //
    // Indicate auto request sense by specifying buffer and size.
    //
 
    SrbSetSenseInfoBuffer(srbHeader, FdoExtension->SenseData);
    SrbSetSenseInfoBufferLength(srbHeader, GET_FDO_EXTENSON_SENSE_DATA_LENGTH(FdoExtension));
 
    //
    // Set timeout value of one unit per 64k bytes of data.
    //
 
    SrbSetTimeOutValue(srbHeader,
                             ((SrbGetDataTransferLength(srbHeader) + 0xFFFF) >> 16) *
                              FdoExtension->TimeOutValue);
 
    //
    // Indicate that 10-byte CDB's will be used.
    //
 
    SrbSetCdbLength(srbHeader, 10);
 
    //
    // Fill in CDB fields.
    //
 
    cdb = SrbGetCdb(srbHeader);
    NT_ASSERT(cdb != NULL);
 
    transferBlocks = (USHORT)(currentIrpStack->Parameters.Read.Length >>
                              FdoExtension->SectorShift);
 
    //
    // Move little endian values into CDB in big endian format.
    //
 
    cdb->CDB10.LogicalBlockByte0 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte3;
    cdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte2;
    cdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte1;
    cdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte0;
 
    cdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)&transferBlocks)->Byte1;
    cdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)&transferBlocks)->Byte0;
 
    //
    // Set transfer direction flag and Cdb command.
    //
 
    if (currentIrpStack->MajorFunction == IRP_MJ_READ) {
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW,  "ClassBuildRequest: Read Command\n"));
 
        SrbSetSrbFlags(srbHeader, SRB_FLAGS_DATA_IN);
        cdb->CDB10.OperationCode = SCSIOP_READ;
 
    } else {
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW,  "ClassBuildRequest: Write Command\n"));
 
        SrbSetSrbFlags(srbHeader, SRB_FLAGS_DATA_OUT);
        cdb->CDB10.OperationCode = SCSIOP_WRITE;
 
    }
 
    //
    // If this is not a write-through request, then allow caching.
    //
 
    if (!(currentIrpStack->Flags & SL_WRITE_THROUGH)) {
 
        SrbSetSrbFlags(srbHeader, SRB_FLAGS_ADAPTER_CACHE_ENABLE);
 
    } else {
 
        //
        // If write caching is enable then force media access in the
        // cdb.
        //
 
        cdb->CDB10.ForceUnitAccess = FdoExtension->CdbForceUnitAccess;
    }
 
    if (TEST_FLAG(Irp->Flags, (IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO))) {
        SrbSetSrbFlags(srbHeader, SRB_CLASS_FLAGS_PAGING);
    }
 
    //
    // OR in the default flags from the device object.
    //
 
    SrbSetSrbFlags(srbHeader, FdoExtension->SrbFlags);
 
    //
    // Set up major SCSI function.
    //
 
    nextIrpStack->MajorFunction = IRP_MJ_SCSI;
 
    //
    // Save SRB address in next stack for port driver.
    //
 
    nextIrpStack->Parameters.Scsi.Srb = Srb;
 
    //
    // Save retry count in current IRP stack.
    //
 
    currentIrpStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;
 
    //
    // Set up IoCompletion routine address.
    //
 
    IoSetCompletionRoutine(Irp, ClassIoComplete, Srb, TRUE, TRUE, TRUE);
 
}

Referenced by ClassBuildRequest().

◆ ClasspCalculateLogicalSectorSize()

ULONG ClasspCalculateLogicalSectorSize	(	_In_ PDEVICE_OBJECT	Fdo,
		_In_ ULONG	BytesPerBlockInBigEndian
	)

Definition at line 1483 of file utils.c.

{
    ULONG logicalSectorSize;
 
    REVERSE_BYTES(&logicalSectorSize, &BytesPerBlockInBigEndian);
 
    if (logicalSectorSize == 0) {
        logicalSectorSize = 512;
    } else {
        //
        //  Clear all but the highest set bit.
        //  That will give us a bytesPerSector value that is a power of 2.
        //
        if (logicalSectorSize & (logicalSectorSize-1)) {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT, "FDO %ph has non-standard sector size 0x%x.", Fdo, logicalSectorSize));
            do {
                logicalSectorSize &= logicalSectorSize-1;
            }
            while (logicalSectorSize & (logicalSectorSize-1));
        }
    }
 
    return logicalSectorSize;
}

Referenced by InterpretCapacityData(), and InterpretReadCapacity16Data().

◆ ClasspCleanupOffloadReadContext()

VOID ClasspCleanupOffloadReadContext ( _In_ __drv_freesMem(mem) POFFLOAD_READ_CONTEXT OffloadReadContext )

Definition at line 14335 of file class.c.

{
    PMDL populateTokenMdl;
 
    populateTokenMdl = OffloadReadContext->PopulateTokenMdl;
 
    NT_ASSERT(OffloadReadContext != NULL);
 
    if (populateTokenMdl) {
        ClasspFreeDeviceMdl(populateTokenMdl);
    }
    FREE_POOL(OffloadReadContext);
 
    return;
}

Referenced by ClasspCompleteOffloadRead().

◆ ClasspCleanupOffloadWriteContext()

VOID ClasspCleanupOffloadWriteContext ( _In_ __drv_freesMem(mem) POFFLOAD_WRITE_CONTEXT OffloadWriteContext )

Definition at line 15902 of file class.c.

{
    PMDL writeUsingTokenMdl = OffloadWriteContext->WriteUsingTokenMdl;
 
    if (writeUsingTokenMdl) {
        ClasspFreeDeviceMdl(writeUsingTokenMdl);
    }
    FREE_POOL(OffloadWriteContext);
 
    return;
}

Referenced by ClasspCompleteOffloadWrite().

◆ ClasspCleanupProtectedLocks()

VOID ClasspCleanupProtectedLocks ( IN PFILE_OBJECT_EXTENSION FsContext )

Definition at line 296 of file create.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension =
        FsContext->DeviceObject->DeviceExtension;
 
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension =
        commonExtension->PartitionZeroExtension;
 
    ULONG newDeviceLockCount = 1;
 
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "ClasspCleanupProtectedLocks called for %p\n",
                FsContext->DeviceObject));
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "ClasspCleanupProtectedLocks - FsContext %p is locked "
                "%d times\n", FsContext, FsContext->LockCount));
 
    NT_ASSERT(BreakOnClose == FALSE);
 
    //
    // Synchronize with ejection and ejection control requests.
    //
 
    KeEnterCriticalRegion();
    (VOID)KeWaitForSingleObject(&(fdoExtension->EjectSynchronizationEvent),
                                UserRequest,
                                KernelMode,
                                FALSE,
                          NULL);
 
    //
    // For each secure lock on this handle decrement the secured lock count
    // for the FDO.  Keep track of the new value.
    //
 
    if (FsContext->LockCount != 0) {
 
        do {
 
            InterlockedDecrement((volatile LONG *)&FsContext->LockCount);
 
            newDeviceLockCount =
                InterlockedDecrement(&fdoExtension->ProtectedLockCount);
 
        } while (FsContext->LockCount > 0);
 
        //
        // If the new lock count has been dropped to zero then issue a lock
        // command to the device.
        //
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCleanupProtectedLocks: FDO secured lock count = %d "
                    "lock count = %d\n",
                    fdoExtension->ProtectedLockCount,
                    fdoExtension->LockCount));
 
        if ((newDeviceLockCount == 0) && (fdoExtension->LockCount == 0)) {
 
            SCSI_REQUEST_BLOCK srb = {0};
            UCHAR srbExBuffer[CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE] = {0};
            PSTORAGE_REQUEST_BLOCK srbEx = (PSTORAGE_REQUEST_BLOCK)srbExBuffer;
            PCDB cdb = NULL;
            NTSTATUS status;
            PSCSI_REQUEST_BLOCK srbPtr;
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "ClasspCleanupProtectedLocks: FDO lock count dropped "
                        "to zero\n"));
 
            if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
#ifdef _MSC_VER
                #pragma prefast(suppress:26015, "InitializeStorageRequestBlock ensures buffer access is bounded")
#endif
                status = InitializeStorageRequestBlock(srbEx,
                                                       STORAGE_ADDRESS_TYPE_BTL8,
                                                       sizeof(srbExBuffer),
                                                       1,
                                                       SrbExDataTypeScsiCdb16);
                if (NT_SUCCESS(status)) {
                    srbEx->TimeOutValue = fdoExtension->TimeOutValue;
                    SrbSetCdbLength(srbEx, 6);
                    cdb = SrbGetCdb(srbEx);
                    srbPtr = (PSCSI_REQUEST_BLOCK)srbEx;
                } else {
                    //
                    // Should not happen. Revert to legacy SRB.
                    //
                    NT_ASSERT(FALSE);
                    srb.TimeOutValue = fdoExtension->TimeOutValue;
                    srb.CdbLength = 6;
                    cdb = (PCDB) &(srb.Cdb);
                    srbPtr = &srb;
                }
 
            } else {
 
                srb.TimeOutValue = fdoExtension->TimeOutValue;
                srb.CdbLength = 6;
                cdb = (PCDB) &(srb.Cdb);
                srbPtr = &srb;
 
            }
 
            cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;
 
            //
            // TRUE - prevent media removal.
            // FALSE - allow media removal.
            //
 
            cdb->MEDIA_REMOVAL.Prevent = FALSE;
 
            status = ClassSendSrbSynchronous(fdoExtension->DeviceObject,
                                             srbPtr,
                                             NULL,
                                             0,
                                             FALSE);
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "ClasspCleanupProtectedLocks: unlock request to drive "
                        "returned status %lx\n", status));
        }
    }
 
    KeSetEvent(&fdoExtension->EjectSynchronizationEvent,
               IO_NO_INCREMENT,
               FALSE);
    KeLeaveCriticalRegion();
    return;
}

Referenced by ClasspCreateClose().

◆ ClasspCompleteIdleRequest()

VOID ClasspCompleteIdleRequest ( PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 713 of file clntirp.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = FdoExtension->PrivateFdoData;
 
    //
    // Issue the next idle request if there are any left in the queue, there are
    // no non-idle requests outstanding, there are less than max idle requests
    // outstanding, and it has been long enough since the completion of the last
    // non-idle request.
    //
    if ((fdoData->IdleIoCount > 0) &&
        (fdoData->ActiveIdleIoCount < fdoData->IdleActiveIoMax) &&
        (fdoData->ActiveIoCount <= 0) &&
        (ClasspIdleDurationSufficient(fdoData, NULL))) {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_TIMER, "ClasspCompleteIdleRequest: Service next idle reqeusts\n"));
        ClasspServiceIdleRequest(FdoExtension, TRUE);
    }
 
    return;
}

Referenced by TransferPktComplete().

◆ ClasspCompleteOffloadRead()

VOID ClasspCompleteOffloadRead	(	_In_ POFFLOAD_READ_CONTEXT	OffloadReadContext,
		_In_ NTSTATUS	CompletionStatus
	)

Definition at line 14255 of file class.c.

{
    PDEVICE_MANAGE_DATA_SET_ATTRIBUTES dsmAttributes;
    ULONGLONG entireXferLen;
    PDEVICE_OBJECT fdo;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
    PIRP irp;
    NTSTATUS status;
    PUCHAR token;
    ULONGLONG totalSectorsProcessed;
 
    status = CompletionStatus;
    dsmAttributes = OffloadReadContext->OffloadReadDsmIrp->AssociatedIrp.SystemBuffer;
    totalSectorsProcessed = OffloadReadContext->TotalSectorsProcessed;
    fdoExt = OffloadReadContext->Fdo->DeviceExtension;
    entireXferLen = OffloadReadContext->EntireXferLen;
    token = OffloadReadContext->Token;
    irp = OffloadReadContext->OffloadReadDsmIrp;
    fdo = OffloadReadContext->Fdo;
 
    ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->OffloadReadFlags = 0;
    ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->Reserved = 0;
 
    if (NT_SUCCESS(status)) {
        ULONGLONG totalBytesProcessed = totalSectorsProcessed * fdoExt->DiskGeometry.BytesPerSector;
 
        TracePrint((totalBytesProcessed == entireXferLen ? TRACE_LEVEL_INFORMATION : TRACE_LEVEL_WARNING,
                    TRACE_FLAG_IOCTL,
                    "ClasspCompleteOffloadRead (%p): Successfully populated token with %I64u (out of %I64u) bytes (list Id %x).\n",
                    fdo,
                    totalBytesProcessed,
                    entireXferLen,
                    OffloadReadContext->ListIdentifier));
 
        if (totalBytesProcessed < entireXferLen) {
            SET_FLAG(((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->OffloadReadFlags, STORAGE_OFFLOAD_READ_RANGE_TRUNCATED);
        }
        ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->LengthProtected = totalBytesProcessed;
        ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->TokenLength = STORAGE_OFFLOAD_MAX_TOKEN_LENGTH;
        RtlCopyMemory(&((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->Token, token, STORAGE_OFFLOAD_MAX_TOKEN_LENGTH);
    } else {
        ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->LengthProtected = 0;
        ((PSTORAGE_OFFLOAD_READ_OUTPUT)dsmAttributes)->TokenLength = 0;
    }
 
    irp->IoStatus.Information = sizeof(STORAGE_OFFLOAD_READ_OUTPUT);
 
    ClasspCompleteOffloadRequest(fdo, irp, status);
    ClasspCleanupOffloadReadContext(OffloadReadContext);
    OffloadReadContext = NULL;
 
    return;
}

Referenced by ClasspPopulateTokenTransferPacketDone(), ClasspReceivePopulateTokenInformation(), and ClasspReceivePopulateTokenInformationTransferPacketDone().

◆ ClasspCompleteOffloadRequest()

VOID ClasspCompleteOffloadRequest	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_ NTSTATUS	CompletionStatus
	)

Definition at line 13632 of file class.c.

{
    NTSTATUS status = CompletionStatus;
 
 
    Irp->IoStatus.Status = status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return;
}

Referenced by _IRQL_requires_max_(), ClasspCompleteOffloadRead(), and ClasspCompleteOffloadWrite().

◆ ClasspCompleteOffloadWrite()

VOID ClasspCompleteOffloadWrite	(	_In_ __drv_freesMem(Mem) POFFLOAD_WRITE_CONTEXT	OffloadWriteContext,
		_In_ NTSTATUS	CompletionCausingStatus
	)

Definition at line 15788 of file class.c.

{
    PDEVICE_OBJECT fdo;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
    PDEVICE_MANAGE_DATA_SET_ATTRIBUTES dsmAttributes;
    PULONGLONG totalSectorsProcessedSuccessfully;
    ULONGLONG entireXferLen;
    PIRP irp;
    PBOOLEAN tokenInvalidated;
    ULONG listIdentifier;
    ULONGLONG totalSectorsProcessed;
    NTSTATUS status;
    ULONGLONG totalBytesProcessed;
 
    fdo = OffloadWriteContext->Fdo;
    fdoExt = fdo->DeviceExtension;
    dsmAttributes = OffloadWriteContext->DsmAttributes;
    totalSectorsProcessedSuccessfully = &OffloadWriteContext->TotalSectorsProcessedSuccessfully;
    entireXferLen = OffloadWriteContext->EntireXferLen;
    irp = OffloadWriteContext->OffloadWriteDsmIrp;
    tokenInvalidated = &OffloadWriteContext->TokenInvalidated;
    listIdentifier = OffloadWriteContext->ListIdentifier;
    totalSectorsProcessed = OffloadWriteContext->TotalSectorsProcessed;
    status = CompletionCausingStatus;
 
    ((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->OffloadWriteFlags = 0;
    ((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->Reserved = 0;
 
    totalBytesProcessed = (*totalSectorsProcessedSuccessfully) * fdoExt->DiskGeometry.BytesPerSector;
 
    TracePrint((totalBytesProcessed == entireXferLen ? TRACE_LEVEL_INFORMATION : TRACE_LEVEL_WARNING,
                TRACE_FLAG_IOCTL,
                "ClasspCompleteOffloadWrite (%p): %ws wrote using token %I64u (out of %I64u) bytes (Irp %p).\n",
                fdo,
                NT_SUCCESS(status) ? L"Successful" : L"Failed",
                totalBytesProcessed,
                entireXferLen,
                irp));
 
    if (totalBytesProcessed > 0 && totalBytesProcessed < entireXferLen) {
        SET_FLAG(((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->OffloadWriteFlags, STORAGE_OFFLOAD_WRITE_RANGE_TRUNCATED);
    }
    if (*tokenInvalidated) {
        SET_FLAG(((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->OffloadWriteFlags, STORAGE_OFFLOAD_TOKEN_INVALID);
    }
    ((PSTORAGE_OFFLOAD_WRITE_OUTPUT)dsmAttributes)->LengthCopied = totalBytesProcessed;
 
 
    if (!NT_SUCCESS(status)) {
 
        TracePrint((TRACE_LEVEL_WARNING,
                    TRACE_FLAG_IOCTL,
                    "ClasspCompleteOffloadWrite (%p): TokenOperation for WriteUsingToken (list Id %u) completed with %x writing %I64u blocks (currentTotal %I64u blocks).\n",
                    fdo,
                    listIdentifier,
                    status,
                    totalSectorsProcessed,
                    *totalSectorsProcessedSuccessfully));
 
        //
        // Even if target returned an error, from the OS upper layers' perspective,
        // it is a success (with truncation) if any data at all was written.
        //
        if (*totalSectorsProcessedSuccessfully) {
            status = STATUS_SUCCESS;
        }
    }
 
    irp->IoStatus.Information = sizeof(STORAGE_OFFLOAD_WRITE_OUTPUT);
 
    ClasspCompleteOffloadRequest(fdo, irp, status);
    ClasspCleanupOffloadWriteContext(OffloadWriteContext);
    OffloadWriteContext = NULL;
 
    return;
}

Referenced by ClasspContinueOffloadWrite(), ClasspReceiveWriteUsingTokenInformation(), ClasspReceiveWriteUsingTokenInformationDone(), ClasspReceiveWriteUsingTokenInformationTransferPacketDone(), and ClasspWriteUsingTokenTransferPacketDone().

◆ ClasspContinueOffloadWrite()

VOID ClasspContinueOffloadWrite ( _In_ __drv_aliasesMem POFFLOAD_WRITE_CONTEXT OffloadWriteContext )

Definition at line 15187 of file class.c.

{
    BOOLEAN allDataSetRangeFullyConverted;
    ULONG blockDescrIndex;
    PBLOCK_DEVICE_RANGE_DESCRIPTOR blockDescrPointer;
    PVOID buffer;
    ULONG bufferLength;
    ULONGLONG dataSetRangeByteOffset;
    ULONG dataSetRangeIndex;
    PDEVICE_DATA_SET_RANGE dataSetRanges;
    ULONG dataSetRangesCount;
    ULONGLONG entireXferLen;
    PDEVICE_OBJECT fdo;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
    PIRP irp;
    ULONG lbaCount;
    ULONG listIdentifier;
    ULONGLONG logicalBlockOffset;
    ULONG maxBlockDescrCount;
    ULONGLONG maxLbaCount;
    PDEVICE_DSM_OFFLOAD_WRITE_PARAMETERS offloadWriteParameters;
    PTRANSFER_PACKET pkt;
    PIRP pseudoIrp;
    NTSTATUS status;
    DEVICE_DATA_SET_RANGE tempDataSetRange;
    BOOLEAN tempDataSetRangeFullyConverted;
    PVOID tokenAscii;
    ULONG tokenSize;
    ULONGLONG totalSectorCount;
    ULONGLONG totalSectorsProcessedSuccessfully;
    ULONGLONG totalSectorsToProcess;
    ULONG transferSize;
    USHORT writeUsingTokenDataLength;
    USHORT writeUsingTokenDescriptorsLength;
    PMDL writeUsingTokenMdl;
 
    tokenAscii = NULL;
    tokenSize = BLOCK_DEVICE_TOKEN_SIZE;
    tempDataSetRangeFullyConverted = FALSE;
    allDataSetRangeFullyConverted = FALSE;
    fdo = OffloadWriteContext->Fdo;
    fdoExt = fdo->DeviceExtension;
    irp = OffloadWriteContext->OffloadWriteDsmIrp;
    buffer = OffloadWriteContext + 1;
    bufferLength = OffloadWriteContext->BufferLength;
    dataSetRanges = OffloadWriteContext->DataSetRanges;
    offloadWriteParameters = OffloadWriteContext->OffloadWriteParameters;
    pseudoIrp = &OffloadWriteContext->PseudoIrp;
    writeUsingTokenMdl = OffloadWriteContext->WriteUsingTokenMdl;
    entireXferLen = OffloadWriteContext->EntireXferLen;
 
    RtlZeroMemory(buffer, bufferLength);
 
    pkt = DequeueFreeTransferPacket(fdo, TRUE);
    if (!pkt){
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspContinueOffloadWrite (%p): Failed to retrieve transfer packet for TokenOperation (WriteUsingToken) operation.\n",
                    fdo));
 
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto __ClasspContinueOffloadWrite_ErrorExit;
    }
 
    OffloadWriteContext->Pkt = pkt;
 
    blockDescrPointer = (PBLOCK_DEVICE_RANGE_DESCRIPTOR)
        &((PWRITE_USING_TOKEN_HEADER)buffer)->BlockDeviceRangeDescriptor[0];
 
    blockDescrIndex = 0;
    lbaCount = 0;
 
    totalSectorsToProcess = 0;
 
    maxBlockDescrCount = OffloadWriteContext->MaxBlockDescrCount;
    maxLbaCount = OffloadWriteContext->MaxLbaCount;
 
    //
    // The OffloadWriteContext->DataSetRangeIndex, DataSetRangeByteOffset, and
    // TotalSectorsProcessedSuccessfully don't move forward until RRTI has
    // reported the actual amount written.
    //
    // For that reason, this function only updates
    // OffloadWriteContext->TotalSectorsProcessed, which tracks the number of
    // sectors requested to be written by the current WRITE USING TOKEN command
    // (not all will necessarily be written).
    //
 
    dataSetRangeIndex = OffloadWriteContext->DataSetRangeIndex;
    dataSetRangesCount = OffloadWriteContext->DataSetRangesCount;
    dataSetRangeByteOffset = OffloadWriteContext->DataSetRangeByteOffset;
    totalSectorsProcessedSuccessfully = OffloadWriteContext->TotalSectorsProcessedSuccessfully;
 
    //
    // Send WriteUsingToken commands when the buffer is full or all input entries are converted.
    //
    while (!((blockDescrIndex == maxBlockDescrCount) ||        // buffer full or block descriptor count reached
             (lbaCount == maxLbaCount) ||                      // block LBA count reached
             (allDataSetRangeFullyConverted))) {               // all DataSetRanges have been converted
 
        NT_ASSERT(dataSetRangeIndex < dataSetRangesCount);
        NT_ASSERT(dataSetRangeByteOffset < dataSetRanges[dataSetRangeIndex].LengthInBytes);
 
        tempDataSetRange.StartingOffset = dataSetRanges[dataSetRangeIndex].StartingOffset + dataSetRangeByteOffset;
        tempDataSetRange.LengthInBytes = dataSetRanges[dataSetRangeIndex].LengthInBytes - dataSetRangeByteOffset;
 
        totalSectorCount = 0;
 
        ClasspConvertDataSetRangeToBlockDescr(fdo,
                                              blockDescrPointer,
                                              &blockDescrIndex,
                                              maxBlockDescrCount,
                                              &lbaCount,
                                              maxLbaCount,
                                              &tempDataSetRange,
                                              &totalSectorCount);
 
        tempDataSetRangeFullyConverted = (tempDataSetRange.LengthInBytes == 0) ? TRUE : FALSE;
 
        allDataSetRangeFullyConverted = tempDataSetRangeFullyConverted && ((dataSetRangeIndex + 1) == dataSetRangesCount);
 
        if (tempDataSetRangeFullyConverted) {
            dataSetRangeIndex += 1;
            dataSetRangeByteOffset = 0;
            NT_ASSERT(dataSetRangeIndex <= dataSetRangesCount);
        } else {
            dataSetRangeByteOffset += totalSectorCount * fdoExt->DiskGeometry.BytesPerSector;
            NT_ASSERT(dataSetRangeByteOffset < dataSetRanges[dataSetRangeIndex].LengthInBytes);
        }
 
        totalSectorsToProcess += totalSectorCount;
    }
 
    //
    // Save the number of sectors being attempted in this WRITE USING TOKEN
    // command, so that a success return from the command will know how much
    // was written, without needing to issue a RECEIVE ROD TOKEN INFORMATION
    // command.
    //
    OffloadWriteContext->TotalSectorsToProcess = totalSectorsToProcess;
    OffloadWriteContext->TotalSectorsProcessed = 0;
 
    //
    // Calculate transfer size, including the header
    //
    transferSize = (blockDescrIndex * sizeof(BLOCK_DEVICE_RANGE_DESCRIPTOR)) + FIELD_OFFSET(WRITE_USING_TOKEN_HEADER, BlockDeviceRangeDescriptor);
 
    NT_ASSERT(transferSize <= MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH);
 
    writeUsingTokenDataLength = (USHORT)transferSize - RTL_SIZEOF_THROUGH_FIELD(WRITE_USING_TOKEN_HEADER, WriteUsingTokenDataLength);
    REVERSE_BYTES_SHORT(((PWRITE_USING_TOKEN_HEADER)buffer)->WriteUsingTokenDataLength, &writeUsingTokenDataLength);
 
    ((PWRITE_USING_TOKEN_HEADER)buffer)->Immediate = 0;
 
    logicalBlockOffset = OffloadWriteContext->LogicalBlockOffset + totalSectorsProcessedSuccessfully;
    REVERSE_BYTES_QUAD(((PWRITE_USING_TOKEN_HEADER)buffer)->BlockOffsetIntoToken, &logicalBlockOffset);
 
    RtlCopyMemory(((PWRITE_USING_TOKEN_HEADER)buffer)->Token,
                  &offloadWriteParameters->Token,
                  BLOCK_DEVICE_TOKEN_SIZE);
 
    writeUsingTokenDescriptorsLength = (USHORT)transferSize - FIELD_OFFSET(WRITE_USING_TOKEN_HEADER, BlockDeviceRangeDescriptor);
    REVERSE_BYTES_SHORT(((PWRITE_USING_TOKEN_HEADER)buffer)->BlockDeviceRangeDescriptorListLength, &writeUsingTokenDescriptorsLength);
 
    RtlZeroMemory(pseudoIrp, sizeof(IRP));
 
    pseudoIrp->IoStatus.Status = STATUS_SUCCESS;
    pseudoIrp->IoStatus.Information = 0;
    pseudoIrp->Tail.Overlay.DriverContext[0] = LongToPtr(1);
    pseudoIrp->MdlAddress = writeUsingTokenMdl;
 
    InterlockedCompareExchange((volatile LONG *)&TokenOperationListIdentifier, -1, MaxTokenOperationListIdentifier);
    listIdentifier = InterlockedIncrement((volatile LONG *)&TokenOperationListIdentifier);
 
    ClasspSetupWriteUsingTokenTransferPacket(
        OffloadWriteContext,
        pkt,
        transferSize,
        (PUCHAR)buffer,
        pseudoIrp,
        listIdentifier);
 
    tokenAscii = ClasspBinaryToAscii((PUCHAR)(((PWRITE_USING_TOKEN_HEADER)buffer)->Token),
                                     tokenSize,
                                     &tokenSize);
 
    TracePrint((TRACE_LEVEL_INFORMATION,
                TRACE_FLAG_IOCTL,
                "ClasspContinueOffloadWrite (%p): Offloading write for %I64u bytes (versus %I64u) [via %u descriptors]. \
                \n\t\t\tDataLength: %u, DescriptorsLength: %u. Pkt %p (list id %x) [Token: %s]\n",
                fdo,
                totalSectorsToProcess * fdoExt->DiskGeometry.BytesPerSector,
                entireXferLen,
                blockDescrIndex,
                writeUsingTokenDataLength,
                writeUsingTokenDescriptorsLength,
                pkt,
                listIdentifier,
                (tokenAscii == NULL) ? "" : tokenAscii));
 
    FREE_POOL(tokenAscii);
 
    OffloadWriteContext->ListIdentifier = listIdentifier;
 
    SubmitTransferPacket(pkt);
 
    //
    // ClasspWriteUsingTokenTransferPacketDone() takes care of completing the
    // IRP, so this function is done.
    //
 
    return;
 
    //
    // Error cleaup label only - not used in success case:
    //
 
__ClasspContinueOffloadWrite_ErrorExit:
 
    NT_ASSERT(!NT_SUCCESS(status));
 
    //
    // ClasspCompleteOffloadWrite also cleans up offloadWriteContext.
    //
 
    ClasspCompleteOffloadWrite(OffloadWriteContext, status);
 
    return;
}

Referenced by ClasspReceiveWriteUsingTokenInformationDone().

◆ ClasspConvertToScsiRequestBlock()

VOID ClasspConvertToScsiRequestBlock	(	_Out_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ PSTORAGE_REQUEST_BLOCK	SrbEx
	)

Definition at line 6559 of file utils.c.

{
    PSTOR_ADDR_BTL8 storAddrBtl8;
    ULONG i;
    BOOLEAN foundEntry = FALSE;
    PSRBEX_DATA srbExData;
 
    if ((Srb == NULL) || (SrbEx == NULL)) {
        return;
    }
 
    RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));
 
    Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
    Srb->Function = (UCHAR)SrbEx->SrbFunction;
    Srb->SrbStatus = SrbEx->SrbStatus;
    Srb->QueueTag = (UCHAR)SrbEx->RequestTag;
    Srb->QueueAction = (UCHAR)SrbEx->RequestAttribute;
    Srb->SrbFlags = SrbEx->SrbFlags;
    Srb->DataTransferLength = SrbEx->DataTransferLength;
    Srb->TimeOutValue = SrbEx->TimeOutValue;
    Srb->DataBuffer = SrbEx->DataBuffer;
    Srb->OriginalRequest = SrbEx->OriginalRequest;
    Srb->SrbExtension = SrbEx->MiniportContext;
    Srb->InternalStatus = SrbEx->SystemStatus;
 
    //
    // Handle address fields
    //
    if (SrbEx->AddressOffset >= sizeof(STORAGE_REQUEST_BLOCK)) {
        storAddrBtl8 = (PSTOR_ADDR_BTL8)((PCHAR)SrbEx + SrbEx->AddressOffset);
 
        if (storAddrBtl8->Type == STOR_ADDRESS_TYPE_BTL8) {
            Srb->PathId = storAddrBtl8->Path;
            Srb->TargetId = storAddrBtl8->Target;
            Srb->Lun = storAddrBtl8->Lun;
        } else {
            // Catch unsupported address types
            NT_ASSERT(FALSE);
        }
    }
 
    //
    // Handle SRB function specific fields
    //
    if (SrbEx->NumSrbExData > 0) {
 
        for (i = 0; i < SrbEx->NumSrbExData; i++) {
 
            if ((SrbEx->SrbExDataOffset[i] == 0) ||
                (SrbEx->SrbExDataOffset[i] < sizeof(STORAGE_REQUEST_BLOCK))) {
                // Catch invalid offsets
                NT_ASSERT(FALSE);
                continue;
            }
 
            srbExData = (PSRBEX_DATA)((PCHAR)SrbEx + SrbEx->SrbExDataOffset[i]);
 
            switch (SrbEx->SrbFunction) {
 
                case SRB_FUNCTION_EXECUTE_SCSI:
 
                    switch (srbExData->Type) {
 
                        case SrbExDataTypeScsiCdb16:
                            Srb->ScsiStatus = ((PSRBEX_DATA_SCSI_CDB16)srbExData)->ScsiStatus;
                            Srb->CdbLength = ((PSRBEX_DATA_SCSI_CDB16)srbExData)->CdbLength;
                            Srb->SenseInfoBufferLength = ((PSRBEX_DATA_SCSI_CDB16)srbExData)->SenseInfoBufferLength;
                            Srb->SenseInfoBuffer = ((PSRBEX_DATA_SCSI_CDB16)srbExData)->SenseInfoBuffer;
                            RtlCopyMemory(Srb->Cdb, ((PSRBEX_DATA_SCSI_CDB16)srbExData)->Cdb, sizeof(Srb->Cdb));
                            foundEntry = TRUE;
                            break;
 
                        case SrbExDataTypeScsiCdb32:
                            Srb->ScsiStatus = ((PSRBEX_DATA_SCSI_CDB32)srbExData)->ScsiStatus;
                            Srb->CdbLength = ((PSRBEX_DATA_SCSI_CDB32)srbExData)->CdbLength;
                            Srb->SenseInfoBufferLength = ((PSRBEX_DATA_SCSI_CDB32)srbExData)->SenseInfoBufferLength;
                            Srb->SenseInfoBuffer = ((PSRBEX_DATA_SCSI_CDB32)srbExData)->SenseInfoBuffer;
 
                            // Copy only the first 16 bytes
                            RtlCopyMemory(Srb->Cdb, ((PSRBEX_DATA_SCSI_CDB32)srbExData)->Cdb, sizeof(Srb->Cdb));
                            foundEntry = TRUE;
                            break;
 
                        case SrbExDataTypeScsiCdbVar:
                            Srb->ScsiStatus = ((PSRBEX_DATA_SCSI_CDB_VAR)srbExData)->ScsiStatus;
                            Srb->CdbLength = (UCHAR)((PSRBEX_DATA_SCSI_CDB_VAR)srbExData)->CdbLength;
                            Srb->SenseInfoBufferLength = ((PSRBEX_DATA_SCSI_CDB_VAR)srbExData)->SenseInfoBufferLength;
                            Srb->SenseInfoBuffer = ((PSRBEX_DATA_SCSI_CDB_VAR)srbExData)->SenseInfoBuffer;
 
                            // Copy only the first 16 bytes
                            RtlCopyMemory(Srb->Cdb, ((PSRBEX_DATA_SCSI_CDB_VAR)srbExData)->Cdb, sizeof(Srb->Cdb));
                            foundEntry = TRUE;
                            break;
 
                        default:
                            break;
 
                    }
                    break;
 
                case SRB_FUNCTION_WMI:
 
                    if (srbExData->Type == SrbExDataTypeWmi) {
                        ((PSCSI_WMI_REQUEST_BLOCK)Srb)->WMISubFunction = ((PSRBEX_DATA_WMI)srbExData)->WMISubFunction;
                        ((PSCSI_WMI_REQUEST_BLOCK)Srb)->WMIFlags = ((PSRBEX_DATA_WMI)srbExData)->WMIFlags;
                        ((PSCSI_WMI_REQUEST_BLOCK)Srb)->DataPath = ((PSRBEX_DATA_WMI)srbExData)->DataPath;
                        foundEntry = TRUE;
                    }
                    break;
 
                case SRB_FUNCTION_PNP:
 
                    if (srbExData->Type == SrbExDataTypePnP) {
                        ((PSCSI_PNP_REQUEST_BLOCK)Srb)->PnPAction = ((PSRBEX_DATA_PNP)srbExData)->PnPAction;
                        ((PSCSI_PNP_REQUEST_BLOCK)Srb)->PnPSubFunction = ((PSRBEX_DATA_PNP)srbExData)->PnPSubFunction;
                        ((PSCSI_PNP_REQUEST_BLOCK)Srb)->SrbPnPFlags = ((PSRBEX_DATA_PNP)srbExData)->SrbPnPFlags;
                        foundEntry = TRUE;
                    }
                    break;
 
                case SRB_FUNCTION_POWER:
 
                    if (srbExData->Type == SrbExDataTypePower) {
                        ((PSCSI_POWER_REQUEST_BLOCK)Srb)->DevicePowerState = ((PSRBEX_DATA_POWER)srbExData)->DevicePowerState;
                        ((PSCSI_POWER_REQUEST_BLOCK)Srb)->PowerAction = ((PSRBEX_DATA_POWER)srbExData)->PowerAction;
                        ((PSCSI_POWER_REQUEST_BLOCK)Srb)->SrbPowerFlags = ((PSRBEX_DATA_POWER)srbExData)->SrbPowerFlags;
                        foundEntry = TRUE;
                    }
                    break;
 
                default:
                    break;
 
            }
 
            //
            // Quit on first match
            //
            if (foundEntry) {
                break;
            }
        }
    }
 
    return;
}

Referenced by ClassInterpretSenseInfo(), InterpretSenseInfoWithoutHistory(), and InterpretTransferPacketError().

◆ ClasspCreateClose()

NTSTATUS ClasspCreateClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 123 of file create.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
 
    PFILE_OBJECT fileObject = irpStack->FileObject;
 
    NTSTATUS status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
 
    //
    // ISSUE-2000/3/28-henrygab - if lower stack fails create/close, we end up
    // in an inconsistent state.  re-write to verify all args and allocate all
    // required resources, then pass the irp down, then complete the
    // transaction.  this is because we also cannot forward the irp, then fail
    // it after it has succeeded a lower-level driver.
    //
 
    if(irpStack->MajorFunction == IRP_MJ_CREATE) {
 
        PIO_SECURITY_CONTEXT securityContext =
            irpStack->Parameters.Create.SecurityContext;
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCREATEClose: create received for device %p\n",
                    DeviceObject));
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCREATEClose: desired access %lx\n",
                    securityContext->DesiredAccess));
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCREATEClose: file object %p\n",
                    irpStack->FileObject));
 
        NT_ASSERT(BreakOnClose == FALSE);
 
        if(irpStack->FileObject != NULL) {
 
            PFILE_OBJECT_EXTENSION fsContext;
 
            //
            // Allocate our own file object extension for this device object.
            //
 
            status = AllocateDictionaryEntry(
                        &commonExtension->FileObjectDictionary,
                        (ULONGLONG) irpStack->FileObject,
                        sizeof(FILE_OBJECT_EXTENSION),
                        CLASS_TAG_FILE_OBJECT_EXTENSION,
                        (PVOID *)&fsContext);
 
            if(NT_SUCCESS(status)) {
 
                RtlZeroMemory(fsContext,
                              sizeof(FILE_OBJECT_EXTENSION));
 
                fsContext->FileObject = irpStack->FileObject;
                fsContext->DeviceObject = DeviceObject;
            } else if (status == STATUS_OBJECT_NAME_COLLISION) {
                status = STATUS_SUCCESS;
            }
        }
 
    } else {
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCreateCLOSE: close received for device %p\n",
                    DeviceObject));
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "ClasspCreateCLOSE: file object %p\n",
                    fileObject));
 
        if(irpStack->FileObject != NULL) {
 
            PFILE_OBJECT_EXTENSION fsContext =
                ClassGetFsContext(commonExtension, irpStack->FileObject);
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "ClasspCreateCLOSE: file extension %p\n",
                        fsContext));
 
            if(fsContext != NULL) {
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                            "ClasspCreateCLOSE: extension is ours - "
                            "freeing\n"));
                NT_ASSERT(BreakOnClose == FALSE);
 
                ClasspCleanupProtectedLocks(fsContext);
 
                ClasspCleanupDisableMcn(fsContext);
 
                FreeDictionaryEntry(&(commonExtension->FileObjectDictionary),
                                    fsContext);
            }
        }
    }
 
    //
    // Notify the lower levels about the create or close operation - give them
    // a chance to cleanup too.
    //
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "ClasspCreateClose: %s for devobj %p\n",
                (NT_SUCCESS(status) ? "Success" : "FAILED"),
                DeviceObject));
 
 
    if(NT_SUCCESS(status)) {
 
        KEVENT event;
 
        //
        // Set up the event to wait on
        //
 
        KeInitializeEvent(&event, SynchronizationEvent, FALSE);
 
        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine( Irp, ClassSignalCompletion, &event,
                                TRUE, TRUE, TRUE);
 
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 
        if(status == STATUS_PENDING) {
            (VOID)KeWaitForSingleObject(&event,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        NULL);
            status = Irp->IoStatus.Status;
        }
 
        if (!NT_SUCCESS(status)) {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT,
                        "ClasspCreateClose: Lower driver failed, but we "
                        "succeeded.  This is a problem, lock counts will be "
                        "out of sync between levels.\n"));
        }
 
    }
 
 
    return status;
}

Referenced by ClassCreateClose().

◆ ClasspDeleteTimer()

VOID ClasspDeleteTimer ( _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 3798 of file autorun.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = NULL;
 
    if (FdoExtension->CommonExtension.IsFdo) {
        fdoData = FdoExtension->PrivateFdoData;
        if (fdoData != NULL) {
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
            if (fdoData->TickTimer != NULL) {
                EXT_DELETE_PARAMETERS parameters;
                ExInitializeDeleteTimerParameters(&parameters);
                ExDeleteTimer(fdoData->TickTimer, TRUE, FALSE, &parameters);
                fdoData->TickTimer = NULL;
            }
#endif
            fdoData->TimerInitialized = FALSE;
            fdoData->TickTimerEnabled = FALSE;
        }
    }
}

Referenced by ClassPnpStartDevice().

◆ ClasspDeviceGetBlockDeviceCharacteristicsVPDPage()

NTSTATUS ClasspDeviceGetBlockDeviceCharacteristicsVPDPage	(	_In_ PFUNCTIONAL_DEVICE_EXTENSION	fdoExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 2072 of file utils.c.

{
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    PCDB cdb;
    UCHAR bufferLength = sizeof(VPD_BLOCK_DEVICE_CHARACTERISTICS_PAGE);  // data is 64 bytes
    ULONG allocationBufferLength = bufferLength;
    PVPD_BLOCK_DEVICE_CHARACTERISTICS_PAGE dataBuffer = NULL;
 
 
#if defined(_ARM_) || defined(_ARM64_)
    //
    // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
    // based platforms. We are taking the conservative approach here.
    //
    allocationBufferLength = ALIGN_UP_BY(allocationBufferLength,KeGetRecommendedSharedDataAlignment());
    dataBuffer = (PVPD_BLOCK_DEVICE_CHARACTERISTICS_PAGE)ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                                                                allocationBufferLength,
                                                                                '5CcS'
                                                                                );
#else
 
    dataBuffer = (PVPD_BLOCK_DEVICE_CHARACTERISTICS_PAGE)ExAllocatePoolWithTag(NonPagedPoolNx,
                                                                                bufferLength,
                                                                                '5CcS'
                                                                                );
#endif
    if (dataBuffer == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit;
    }
 
    RtlZeroMemory(dataBuffer, allocationBufferLength);
 
    // prepare the Srb
    SrbSetTimeOutValue(Srb, fdoExtension->TimeOutValue);
    SrbSetRequestTag(Srb, SP_UNTAGGED);
    SrbSetRequestAttribute(Srb, SRB_SIMPLE_TAG_REQUEST);
    SrbAssignSrbFlags(Srb, fdoExtension->SrbFlags);
 
    SrbSetCdbLength(Srb, 6);
 
    cdb = SrbGetCdb(Srb);
    cdb->CDB6INQUIRY3.OperationCode = SCSIOP_INQUIRY;
    cdb->CDB6INQUIRY3.EnableVitalProductData = 1;       //EVPD bit
    cdb->CDB6INQUIRY3.PageCode = VPD_BLOCK_DEVICE_CHARACTERISTICS;
    cdb->CDB6INQUIRY3.AllocationLength = bufferLength;  //AllocationLength field in CDB6INQUIRY3 is only one byte.
 
    status = ClassSendSrbSynchronous(fdoExtension->CommonExtension.DeviceObject,
                                        Srb,
                                        dataBuffer,
                                        allocationBufferLength,
                                        FALSE);
    if (NT_SUCCESS(status)) {
        if (SrbGetDataTransferLength(Srb) < 0x8) {
            // the device should return at least 8 bytes of data for use.
            status = STATUS_UNSUCCESSFUL;
        } else if ( (dataBuffer->PageLength != 0x3C) || (dataBuffer->PageCode != VPD_BLOCK_DEVICE_CHARACTERISTICS) ) {
            // 'PageLength' shall be 0x3C; and 'PageCode' shall match.
            status = STATUS_UNSUCCESSFUL;
        } else {
            // cache data into fdoExtension
            fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumRotationRate = (dataBuffer->MediumRotationRateMsb << 8) |
                                                                                                dataBuffer->MediumRotationRateLsb;
            fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumProductType = dataBuffer->MediumProductType;
            fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.NominalFormFactor = dataBuffer->NominalFormFactor;
        }
    } else {
        // the command failed, surface up the command error from 'status' variable. Nothing to do here.
    }
 
Exit:
    if (dataBuffer != NULL) {
        ExFreePool(dataBuffer);
    }
 
    return status;
}

Referenced by ClasspDeviceMediaTypeProperty(), and ClasspDeviceSeekPenaltyProperty().

◆ ClasspDeviceGetBlockLimitsVPDPage()

NTSTATUS ClasspDeviceGetBlockLimitsVPDPage	(	_In_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_Inout_bytecount_(SrbSize) PSCSI_REQUEST_BLOCK	Srb,
		_In_ ULONG	SrbSize,
		_Out_ PCLASS_VPD_B0_DATA	BlockLimitsData
	)

Definition at line 2521 of file utils.c.

{
    NTSTATUS                     status = STATUS_UNSUCCESSFUL;
    PVOID                        dataBuffer = NULL;
    UCHAR                        bufferLength = VPD_MAX_BUFFER_SIZE;  // use biggest buffer possible
    ULONG                        allocationBufferLength = bufferLength;
    PCDB                         cdb;
    PVPD_BLOCK_LIMITS_PAGE       blockLimits = NULL;
    ULONG                        dataTransferLength = 0;
 
    //
    // Set default values for UNMAP parameters based upon UNMAP support or lack
    // thereof.
    //
    if (FdoExtension->FunctionSupportInfo->LBProvisioningData.LBPU) {
        //
        // If UNMAP is supported, we default to the maximum LBA count and
        // block descriptor count.  We also default the UNMAP granularity to
        // a single block and specify no granularity alignment.
        //
        BlockLimitsData->MaxUnmapLbaCount = (ULONG)-1;
        BlockLimitsData->MaxUnmapBlockDescrCount = (ULONG)-1;
        BlockLimitsData->OptimalUnmapGranularity = 1;
        BlockLimitsData->UnmapGranularityAlignment = 0;
        BlockLimitsData->UGAVALID = FALSE;
    } else {
        BlockLimitsData->MaxUnmapLbaCount = 0;
        BlockLimitsData->MaxUnmapBlockDescrCount = 0;
        BlockLimitsData->OptimalUnmapGranularity = 0;
        BlockLimitsData->UnmapGranularityAlignment = 0;
        BlockLimitsData->UGAVALID = FALSE;
    }
 
    //
    // Try to get the Block Limits VPD page (0xB0), if it is supported.
    //
    if (FdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockLimits == TRUE)
    {
#if defined(_ARM_) || defined(_ARM64_)
        //
        // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
        // based platforms. We are taking the conservative approach here.
        //
        allocationBufferLength = ALIGN_UP_BY(allocationBufferLength, KeGetRecommendedSharedDataAlignment());
        dataBuffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, allocationBufferLength, '0CcS');
#else
        dataBuffer = ExAllocatePoolWithTag(NonPagedPoolNx, bufferLength, '0CcS');
#endif
        if (dataBuffer == NULL)
        {
            // return without updating FdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus
            // the field will remain value as "-1", so that the command will be attempted next time this function is called.
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        blockLimits = (PVPD_BLOCK_LIMITS_PAGE)dataBuffer;
 
        RtlZeroMemory(dataBuffer, allocationBufferLength);
 
        if (FdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
 
#ifdef _MSC_VER
            #pragma prefast(suppress:26015, "InitializeStorageRequestBlock ensures buffer access is bounded")
#endif
            status = InitializeStorageRequestBlock((PSTORAGE_REQUEST_BLOCK)Srb,
                                                   STORAGE_ADDRESS_TYPE_BTL8,
                                                   SrbSize,
                                                   1,
                                                   SrbExDataTypeScsiCdb16);
 
            if (NT_SUCCESS(status)) {
                ((PSTORAGE_REQUEST_BLOCK)Srb)->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
            } else {
                //
                // Should not occur.
                //
                NT_ASSERT(FALSE);
            }
        } else {
            RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));
            Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
            Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
            status = STATUS_SUCCESS;
        }
 
        if (NT_SUCCESS(status)) {
            // prepare the Srb
            SrbSetTimeOutValue(Srb, FdoExtension->TimeOutValue);
            SrbSetRequestTag(Srb, SP_UNTAGGED);
            SrbSetRequestAttribute(Srb, SRB_SIMPLE_TAG_REQUEST);
            SrbAssignSrbFlags(Srb, FdoExtension->SrbFlags);
 
            SrbSetCdbLength(Srb, 6);
 
            cdb = SrbGetCdb(Srb);
            cdb->CDB6INQUIRY3.OperationCode = SCSIOP_INQUIRY;
            cdb->CDB6INQUIRY3.EnableVitalProductData = 1;       //EVPD bit
            cdb->CDB6INQUIRY3.PageCode = VPD_BLOCK_LIMITS;
            cdb->CDB6INQUIRY3.AllocationLength = bufferLength;  //AllocationLength field in CDB6INQUIRY3 is only one byte.
 
            status = ClassSendSrbSynchronous(FdoExtension->DeviceObject,
                                             Srb,
                                             dataBuffer,
                                             allocationBufferLength,
                                             FALSE);
            dataTransferLength = SrbGetDataTransferLength(Srb);
        }
 
        //
        // Handle the case where we get back STATUS_DATA_OVERRUN b/c the input
        // buffer was larger than necessary.
        //
 
        if (status == STATUS_DATA_OVERRUN && dataTransferLength < bufferLength)
        {
            status = STATUS_SUCCESS;
        }
 
        if (NT_SUCCESS(status))
        {
            USHORT pageLength;
            REVERSE_BYTES_SHORT(&pageLength, &(blockLimits->PageLength));
 
            //
            // Regardless of the device's support for unmap, cache away at least the basic block limits information
            //
            if (dataTransferLength >= 0x10 && blockLimits->PageCode == VPD_BLOCK_LIMITS) {
 
                // (6:7) OPTIMAL TRANSFER LENGTH GRANULARITY
                REVERSE_BYTES_SHORT(&BlockLimitsData->OptimalTransferLengthGranularity, &blockLimits->OptimalTransferLengthGranularity);
                // (8:11) MAXIMUM TRANSFER LENGTH
                REVERSE_BYTES(&BlockLimitsData->MaximumTransferLength, &blockLimits->MaximumTransferLength);
                // (12:15) OPTIMAL TRANSFER LENGTH
                REVERSE_BYTES(&BlockLimitsData->OptimalTransferLength, &blockLimits->OptimalTransferLength);
            }
 
            if ((dataTransferLength < 0x24) ||
                (pageLength < (FIELD_OFFSET(VPD_BLOCK_LIMITS_PAGE,Reserved1) - FIELD_OFFSET(VPD_BLOCK_LIMITS_PAGE,Reserved0))) ||
                (blockLimits->PageCode != VPD_BLOCK_LIMITS))
            {
                // the device should return at least 36 bytes of data for use.
                // 'PageCode' shall match and we need all the relevant data after the header.
                status = STATUS_INFO_LENGTH_MISMATCH;
            }
        }
 
        if (NT_SUCCESS(status))
        {
            // cache data into FdoExtension
            // (20:23) MAXIMUM UNMAP LBA COUNT
            REVERSE_BYTES(&BlockLimitsData->MaxUnmapLbaCount, &blockLimits->MaximumUnmapLBACount);
            // (24:27) MAXIMUM UNMAP BLOCK DESCRIPTOR COUNT
            REVERSE_BYTES(&BlockLimitsData->MaxUnmapBlockDescrCount, &blockLimits->MaximumUnmapBlockDescriptorCount);
            // (28:31) OPTIMAL UNMAP GRANULARITY
            REVERSE_BYTES(&BlockLimitsData->OptimalUnmapGranularity, &blockLimits->OptimalUnmapGranularity);
 
            // (32:35) UNMAP GRANULARITY ALIGNMENT; (32) bit7: UGAVALID
            BlockLimitsData->UGAVALID = blockLimits->UGAValid;
            if (BlockLimitsData->UGAVALID == TRUE) {
                REVERSE_BYTES(&BlockLimitsData->UnmapGranularityAlignment, &blockLimits->UnmapGranularityAlignment);
                BlockLimitsData->UnmapGranularityAlignment &= 0x7FFFFFFF; // remove value of UGAVALID bit.
            } else {
                BlockLimitsData->UnmapGranularityAlignment = 0;
            }
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_PNP,
                        "ClasspDeviceGetBlockLimitsVPDPage (%p): %s %s (rev %s) reported following parameters: \
                        \n\t\t\tOptimalTransferLengthGranularity: %u \
                        \n\t\t\tMaximumTransferLength: %u \
                        \n\t\t\tOptimalTransferLength: %u \
                        \n\t\t\tMaximumUnmapLBACount: %u \
                        \n\t\t\tMaximumUnmapBlockDescriptorCount: %u \
                        \n\t\t\tOptimalUnmapGranularity: %u \
                        \n\t\t\tUGAValid: %u \
                        \n\t\t\tUnmapGranularityAlignment: %u\n",
                        FdoExtension->DeviceObject,
                        (PCSZ)(((PUCHAR)FdoExtension->DeviceDescriptor) + FdoExtension->DeviceDescriptor->VendorIdOffset),
                        (PCSZ)(((PUCHAR)FdoExtension->DeviceDescriptor) + FdoExtension->DeviceDescriptor->ProductIdOffset),
                        (PCSZ)(((PUCHAR)FdoExtension->DeviceDescriptor) + FdoExtension->DeviceDescriptor->ProductRevisionOffset),
                        BlockLimitsData->OptimalTransferLengthGranularity,
                        BlockLimitsData->MaximumTransferLength,
                        BlockLimitsData->OptimalTransferLength,
                        BlockLimitsData->MaxUnmapLbaCount,
                        BlockLimitsData->MaxUnmapBlockDescrCount,
                        BlockLimitsData->OptimalUnmapGranularity,
                        BlockLimitsData->UGAVALID,
                        BlockLimitsData->UnmapGranularityAlignment));
 
        }
    } else {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
 
    BlockLimitsData->CommandStatus = status;
 
Exit:
    FREE_POOL(dataBuffer);
 
    return status;
}

Referenced by ClasspGetLBProvisioningInfo(), and ClasspRefreshFunctionSupportInfo().

◆ ClasspDeviceGetLBAStatus()

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

Definition at line 3861 of file utils.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION               fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION                         irpStack = IoGetCurrentIrpStackLocation(Irp);
    PDEVICE_MANAGE_DATA_SET_ATTRIBUTES         dsmAttributes = (PDEVICE_MANAGE_DATA_SET_ATTRIBUTES)Irp->AssociatedIrp.SystemBuffer;
    PDEVICE_DATA_SET_RANGE                     dataSetRanges = NULL;
    PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT  dsmOutput = (PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT)Irp->AssociatedIrp.SystemBuffer;
    ULONG                                      dsmOutputLength;
    NTSTATUS                                   finalStatus;
    NTSTATUS                                   getLBAWorkerStatus;
    ULONG                                      retryCount;
    ULONG                                      retryCountMax;
    CLASS_VPD_B0_DATA                          blockLimitsData;
    ULONG                                      generationCount1;
    ULONG                                      generationCount2;
    BOOLEAN                                    blockLimitsDataMayHaveChanged;
    ULONG_PTR                                  information = 0;
    LONGLONG                                   startingOffset;
    ULONGLONG                                  lengthInBytes;
    BOOLEAN                                    consolidateableBlocksOnly = FALSE;
    ULONG                                      outputVersion;
 
    //
    // Basic parameter validation.
    // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
    //
    if (dsmOutput == NULL ||
        dsmAttributes == NULL)
    {
        finalStatus = STATUS_INVALID_PARAMETER;
        goto Exit;
    }
 
    if (TEST_FLAG(dsmAttributes->Flags, DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE)) {
        //
        // The caller wants the mapping status of the entire disk.
        //
        ULONG unmapGranularityAlignment = 0;
        if (fdoExtension->FunctionSupportInfo->BlockLimitsData.UGAVALID) {
            unmapGranularityAlignment = fdoExtension->FunctionSupportInfo->BlockLimitsData.UnmapGranularityAlignment;
        }
        startingOffset = unmapGranularityAlignment;
        lengthInBytes = (ULONGLONG)fdoExtension->CommonExtension.PartitionLength.QuadPart - (ULONGLONG)startingOffset;
    } else {
        if (dsmAttributes->DataSetRangesOffset == 0 ||
            dsmAttributes->DataSetRangesLength == 0) {
            finalStatus = STATUS_INVALID_PARAMETER;
            goto Exit;
        }
 
        //
        // We only service the first dataset range specified.
        //
        dataSetRanges = (PDEVICE_DATA_SET_RANGE)((PUCHAR)dsmAttributes + dsmAttributes->DataSetRangesOffset);
        startingOffset = dataSetRanges[0].StartingOffset;
        lengthInBytes = dataSetRanges[0].LengthInBytes;
    }
 
 
    //
    // See if the sender is requesting a specific version of the output data
    // structure.  Othwerwise, default to V1.
    //
    outputVersion = DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V1;
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
    if ((dsmAttributes->ParameterBlockOffset >= sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES)) &&
        (dsmAttributes->ParameterBlockLength >= sizeof(DEVICE_DATA_SET_LBP_STATE_PARAMETERS))) {
        PDEVICE_DATA_SET_LBP_STATE_PARAMETERS parameters = Add2Ptr(dsmAttributes, dsmAttributes->ParameterBlockOffset);
        if ((parameters->Version == DEVICE_DATA_SET_LBP_STATE_PARAMETERS_VERSION_V1) &&
            (parameters->Size >= sizeof(DEVICE_DATA_SET_LBP_STATE_PARAMETERS))) {
 
            outputVersion = parameters->OutputVersion;
 
            if ((outputVersion != DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V1) &&
                (outputVersion != DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V2)) {
                finalStatus = STATUS_INVALID_PARAMETER;
                goto Exit;
            }
        }
    }
#endif
 
    //
    // Take a snapshot of the block limits data for the worker function to use.
    // We need to fail the request if we fail to get updated block limits data
    // since we need an accurate Optimal Unmap Granularity value to properly
    // convert the returned mapping descriptors into a bitmap.
    //
    finalStatus = ClasspBlockLimitsDataSnapshot(fdoExtension,
                                                TRUE,
                                                &blockLimitsData,
                                                &generationCount1);
 
    if (!NT_SUCCESS(finalStatus)) {
        information = 0;
        goto Exit;
    }
 
    if (dsmAttributes->Flags & DEVICE_DSM_FLAG_ALLOCATION_CONSOLIDATEABLE_ONLY) {
        consolidateableBlocksOnly = TRUE;
    }
 
    //
    // The retry logic is to handle the case when block limits data changes during rare occasions
    // (e.g. diff-VHD fork or merge).
    //
    retryCountMax = GET_LBA_STATUS_RETRY_COUNT_MAX;
    for (retryCount = 0; retryCount < retryCountMax; retryCount++) {
 
        dsmOutputLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
        getLBAWorkerStatus = ClasspDeviceGetLBAStatusWorker(DeviceObject,
                                                            &blockLimitsData,
                                                            startingOffset,
                                                            lengthInBytes,
                                                            dsmOutput,
                                                            &dsmOutputLength,
                                                            Srb,
                                                            consolidateableBlocksOnly,
                                                            outputVersion,
                                                            &blockLimitsDataMayHaveChanged);
 
        if (!NT_SUCCESS(getLBAWorkerStatus) && !blockLimitsDataMayHaveChanged) {
            information = 0;
            finalStatus = getLBAWorkerStatus;
            break;
        }
 
        //
        // Again, we need to fail the request if we fail to get updated block
        // limits data since we need an accurate Optimal Unmap Granularity value.
        //
        finalStatus = ClasspBlockLimitsDataSnapshot(fdoExtension,
                                                    TRUE,
                                                    &blockLimitsData,
                                                    &generationCount2);
        if (!NT_SUCCESS(finalStatus)) {
            information = 0;
            goto Exit;
        }
 
        if (generationCount1 == generationCount2) {
            //
            // Block limits data stays the same during the call to ClasspDeviceGetLBAStatusWorker()
            // The result from ClasspDeviceGetLBAStatusWorker() is valid.
            //
            finalStatus = getLBAWorkerStatus;
            if (NT_SUCCESS(finalStatus)) {
                information = dsmOutputLength;
            }
            break;
        }
 
        //
        // Try again with the latest block limits data
        //
        generationCount1 = generationCount2;
        information = 0;
        finalStatus = STATUS_DEVICE_DATA_ERROR;
    }
 
Exit:
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = finalStatus;
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
    return finalStatus;
}

Referenced by ClassDeviceControl().

◆ ClasspDeviceGetLBAStatusWorker()

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
	)

Definition at line 4079 of file utils.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    PFUNCTIONAL_DEVICE_EXTENSION               fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    PDEVICE_DATA_SET_LB_PROVISIONING_STATE     lbpState;
    ULONG                                      bitMapGranularityInBits = FIELD_SIZE(DEVICE_DATA_SET_LB_PROVISIONING_STATE,SlabAllocationBitMap[0]) * 8;
    ULONG                                      requiredOutputLength;
    ULONG                                      outputLength = *DsmOutputLength;
 
    ULONG                                      blocksPerSlab;
    ULONGLONG                                  bytesPerSlab;
    ULONGLONG                                  alignmentInBytes = 0;
    ULONG                                      alignmentInBlocks = 0;
    ULONG                                      maxBufferSize;
    ULONG                                      maxSlabs;
    ULONGLONG                                  requestedSlabs; // Total number of slabs requested by the caller.
    ULONGLONG                                  startingLBA;
    ULONGLONG                                  startingOffsetDelta;
    ULONG                                      totalProcessedSlabs = 0; // Total number of slabs we processed.
    ULONGLONG                                  slabsPerCommand; // Number of slabs we can ask for in one Get LBA Status command.
    BOOLEAN                                    doneProcessing = FALSE; // Indicates we should break out of the Get LBA Status loop.
 
    ULONG                                      lbaStatusSize;
    PLBA_STATUS_LIST_HEADER                    lbaStatusListHeader = NULL;
 
    //
    // This function can fail if the block limits data on the device changes.
    // This flag tells the caller if it should retry with a newer block limits data
    //
    *BlockLimitsDataMayHaveChanged = FALSE;
 
    //
    // Make sure we're running at PASSIVE_LEVEL
    //
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL)
    {
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        status = STATUS_INVALID_LEVEL;
        goto Exit;
    }
 
    //
    // Don't send down a Get LBA Status command if UNMAP isn't supported.
    //
    if (!fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPU)
    {
        return STATUS_NOT_SUPPORTED;
        goto Exit;
    }
 
    //
    // Make sure we have a non-zero value for the number of bytes per block.
    // Otherwise we will end up dividing by zero later on.
    //
    if (fdoExtension->DiskGeometry.BytesPerSector == 0)
    {
        status = ClassReadDriveCapacity(fdoExtension->DeviceObject);
        if(!NT_SUCCESS(status) || fdoExtension->DiskGeometry.BytesPerSector == 0)
        {
            status = STATUS_INVALID_DEVICE_REQUEST;
            goto Exit;
        }
    }
 
    //
    // We only service the first dataset range specified.
    //
    if (BlockLimitsData->UGAVALID == TRUE) {
        alignmentInBlocks = BlockLimitsData->UnmapGranularityAlignment;
        alignmentInBytes = (ULONGLONG)alignmentInBlocks * (ULONGLONG)fdoExtension->DiskGeometry.BytesPerSector;
    }
 
    //
    // Make sure the specified range is valid.  The Unmap Granularity Alignment
    // defines a region at the beginning of the disk that cannot be
    // mapped/unmapped so the specified range should not include any part of that
    // region.
    //
    if (LengthInBytes == 0 ||
        StartingOffset < alignmentInBytes ||
        StartingOffset + LengthInBytes > (ULONGLONG)fdoExtension->CommonExtension.PartitionLength.QuadPart)
    {
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceGetLBAStatusWorker (%p): Invalid range, length is %I64u bytes, starting offset is %I64u bytes, Unmap alignment is %I64u bytes, and disk size is %I64u bytes\n",
                    DeviceObject,
                    LengthInBytes,
                    StartingOffset,
                    alignmentInBytes,
                    (ULONGLONG)fdoExtension->CommonExtension.PartitionLength.QuadPart));
 
        status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }
 
    //
    // Calculate the number of bytes per slab so that we can convert (and
    // possibly align) the given offset (given in bytes) to slabs.
    //
    blocksPerSlab = BlockLimitsData->OptimalUnmapGranularity;
    bytesPerSlab = (ULONGLONG)blocksPerSlab * (ULONGLONG)fdoExtension->DiskGeometry.BytesPerSector;
 
    //
    // If the starting offset is not slab-aligned, we need to adjust it to
    // be aligned with the next highest slab.  We also need to save the delta
    // to return to the user later.
    //
    if (((StartingOffset - alignmentInBytes) % bytesPerSlab) != 0)
    {
        startingLBA = (((StartingOffset - alignmentInBytes) / bytesPerSlab) + 1) * (ULONGLONG)blocksPerSlab + alignmentInBlocks;
        startingOffsetDelta = (startingLBA * fdoExtension->DiskGeometry.BytesPerSector) - StartingOffset;
    }
    else
    {
        startingLBA = ((StartingOffset - alignmentInBytes) / bytesPerSlab) * (ULONGLONG)blocksPerSlab + alignmentInBlocks;
        startingOffsetDelta = 0;
    }
 
    //
    // Caclulate the number of slabs the caller requested.
    //
    if ((LengthInBytes % bytesPerSlab) == 0) {
        requestedSlabs = (LengthInBytes / bytesPerSlab);
    } else {
        //
        // Round up the number of requested slabs if the length indicates a
        // partial slab.  This should cover the case where the user specifies
        // a dataset range for the whole disk, but the size of the disk is not
        // a slab-multiple.  Rounding up allows us to return the status of the
        // partial slab
        //
        requestedSlabs = (LengthInBytes / bytesPerSlab) + 1;
    }
 
    //
    // If the caller asked for no slabs then return STATUS_INVALID_PARAMETER.
    //
    if (requestedSlabs == 0)
    {
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceGetLBAStatusWorker (%p): Invalid number (%I64u) of slabs requested\n",
                    DeviceObject,
                    requestedSlabs));
 
        status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }
 
    //
    // Cap requested slabs at MAXULONG since SlabAllocationBitMapBitCount
    // is a 4-byte field.  We may return less data than requested, but the
    // caller can simply re-query for the omitted portion(s).
    //
    requestedSlabs = min(requestedSlabs, MAXULONG);
 
    //
    // Calculate the required size of the output buffer based upon the desired
    // version of the output structure.
    // In the worst case, Get LBA Status returns a descriptor for each slab
    // requested, thus the required output buffer length is equal to:
    //  1. The size of DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT; plus
    //  2. The size of DEVICE_DATA_SET_LB_PROVISIONING_STATE(_V2); plus
    //  3. The size of a ULONG array large enough to hold a bit for each slab requested.
    //     (The first element is already allocated in DEVICE_DATA_SET_LB_PROVISIONING_STATE(_V2).)
    //
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
    if (OutputVersion == DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V2) {
 
        requiredOutputLength = (ULONG)(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT)
                                        + sizeof(DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2)
                                        + (((requestedSlabs - 1) / bitMapGranularityInBits))
                                           * FIELD_SIZE(DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2, SlabAllocationBitMap[0]));
 
    } else
#else
    UNREFERENCED_PARAMETER(OutputVersion);
#endif
    {
 
        requiredOutputLength = (ULONG)(sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT)
                                        + sizeof(DEVICE_DATA_SET_LB_PROVISIONING_STATE)
                                        + (((requestedSlabs - 1) / bitMapGranularityInBits))
                                           * FIELD_SIZE(DEVICE_DATA_SET_LB_PROVISIONING_STATE, SlabAllocationBitMap[0]));
    }
 
    //
    // The output buffer is not big enough to hold the requested data.
    // Inform the caller of the correct buffer size.
    //
    if (outputLength < requiredOutputLength)
    {
        status = STATUS_BUFFER_TOO_SMALL;
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceGetLBAStatusWorker (%p): Given output buffer is %u bytes, needs to be %u bytes\n",
                    DeviceObject,
                    outputLength,
                    requiredOutputLength));
 
        //
        // If the output buffer is big enough, write the required buffer
        // length to the first ULONG bytes of the output buffer.
        //
        if (outputLength >= sizeof(ULONG))
        {
            *((PULONG)DsmOutput) = requiredOutputLength;
        }
 
        goto Exit;
    }
 
    //
    // Calculate the maximum number of slabs that could be returned by a single
    // Get LBA Status command.  The max buffer size could either be capped by
    // the Parameter Data Length field or the Max Transfer Length of the
    // adapter.
    // The number of slabs we actually ask for in a single command is the
    // smaller of the number of slabs requested by the user or the max number
    // of slabs we can theoretically ask for in a single command.
    //
    maxBufferSize = MIN(MAXULONG, fdoExtension->PrivateFdoData->HwMaxXferLen);
    maxSlabs = (maxBufferSize - sizeof(LBA_STATUS_LIST_HEADER)) / sizeof(LBA_STATUS_DESCRIPTOR);
    slabsPerCommand = min(requestedSlabs, maxSlabs);
 
    //
    // Allocate the buffer that will contain the returned LBA Status Descriptors.
    // Assume that in the worst case every other slab has a different mapping
    // status.  That means that there may be a descriptor for every slab requested.
    //
    lbaStatusSize = (ULONG)(sizeof(LBA_STATUS_LIST_HEADER) + (slabsPerCommand * sizeof(LBA_STATUS_DESCRIPTOR)));
#if defined(_ARM_) || defined(_ARM64_)
    //
    // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
    // based platforms. We are taking the conservative approach here.
    //
    lbaStatusSize = ALIGN_UP_BY(lbaStatusSize,KeGetRecommendedSharedDataAlignment());
    lbaStatusListHeader = (PLBA_STATUS_LIST_HEADER)ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, lbaStatusSize, CLASS_TAG_LB_PROVISIONING);
#else
    lbaStatusListHeader = (PLBA_STATUS_LIST_HEADER)ExAllocatePoolWithTag(NonPagedPoolNx, lbaStatusSize, CLASS_TAG_LB_PROVISIONING);
#endif
 
    if (lbaStatusListHeader == NULL)
    {
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceGetLBAStatusWorker (%p): Failed to allocate %u bytes for descriptors\n",
                    DeviceObject,
                    lbaStatusSize));
 
        NT_ASSERT(lbaStatusListHeader != NULL);
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit;
    }
 
    //
    // Set default values for the output buffer.
    // If we process at least one slab from the device we will update the
    // offset and lengths accordingly.
    //
    DsmOutput->Action = DeviceDsmAction_Allocation;
    DsmOutput->Size = sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT);
    DsmOutput->OutputBlockOffset = 0;
    DsmOutput->OutputBlockLength = 0;
    *DsmOutputLength = DsmOutput->Size;
 
    //
    // The returned DEVICE_DATA_SET_LB_PROVISIONING_STATE is at the end of the
    // DSM output structure.  Zero it out before we start to fill it in.
    //
    lbpState = Add2Ptr(DsmOutput, sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT));
    RtlZeroMemory(lbpState, requiredOutputLength - sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT));
 
    do {
        //
        // Send down GetLBAStatus for the current range.
        //
        status = GetLBAStatus(fdoExtension,
                              Srb,
                              startingLBA,
                              lbaStatusListHeader,
                              lbaStatusSize,
                              ConsolidateableBlocksOnly);
 
        if (NT_SUCCESS(status))
        {
            ULONG descrIndex = 0;
            ULONG descrSize = 0;
            ULONG descrSizeOverhead;
            ULONG descrCount = 0;
            ULONGLONG expectedStartingLBA;
            BOOLEAN processCurrentDescriptor = TRUE;
            ULONG commandProcessedSlabs = 0; // Number of slabs processed for this command.
 
            descrSizeOverhead = FIELD_OFFSET(LBA_STATUS_LIST_HEADER, Descriptors[0]) -
                                RTL_SIZEOF_THROUGH_FIELD(LBA_STATUS_LIST_HEADER, ParameterLength);
            REVERSE_BYTES(&descrSize, &(lbaStatusListHeader->ParameterLength));
 
            //
            // If the returned Parameter Data Length field describes more
            // descriptors than we allocated space for then make sure we don't
            // try to process more descriptors than are actually present.
            //
            if (descrSize > (lbaStatusSize - RTL_SIZEOF_THROUGH_FIELD(LBA_STATUS_LIST_HEADER, ParameterLength))) {
                descrSize = (lbaStatusSize - RTL_SIZEOF_THROUGH_FIELD(LBA_STATUS_LIST_HEADER, ParameterLength));
            }
 
            if (descrSize >= descrSizeOverhead) {
                descrSize -= descrSizeOverhead;
                descrCount = descrSize / sizeof(LBA_STATUS_DESCRIPTOR);
 
                //
                // Make sure at least one descriptor was returned.
                //
                if (descrCount > 0) {
                    //
                    // We expect the first starting LBA returned by the device to be the
                    // same starting LBA we specified in the command.
                    //
                    expectedStartingLBA = startingLBA;
 
                    //
                    // Translate the returned LBA status descriptors into a bitmap where each bit represents
                    // a slab.  The slab size is represented by the Optimal Unmap Granularity.
                    // 1 = The slab is mapped.
                    // 0 = The slab is unmapped (deallocated or anchored).
                    //
                    for (descrIndex = 0; descrIndex < descrCount && totalProcessedSlabs < requestedSlabs && !doneProcessing; descrIndex++)
                    {
                        PLBA_STATUS_DESCRIPTOR lbaStatusDescr = &(lbaStatusListHeader->Descriptors[descrIndex]);
                        ULONGLONG returnedStartingLBA;
                        ULONG mapped = (lbaStatusDescr->ProvisioningStatus != LBA_STATUS_MAPPED) ? 0x0 : 0x1;
                        ULONG lbaCount = 0;
 
                        REVERSE_BYTES_QUAD(&returnedStartingLBA, &(lbaStatusDescr->StartingLBA));
                        REVERSE_BYTES(&lbaCount, &(lbaStatusDescr->LogicalBlockCount));
 
                        if (returnedStartingLBA != expectedStartingLBA)
                        {
                            //
                            // We expect the descriptors will express a contiguous range of LBAs.
                            // If the starting LBA is not contiguous with the LBA range from the
                            // previous descriptor then we should not process any more descriptors,
                            // including the current one.
                            //
                            TracePrint((TRACE_LEVEL_ERROR,
                                        TRACE_FLAG_IOCTL,
                                        "ClasspDeviceGetLBAStatusWorker (%p): Device returned starting LBA = %I64x when %I64x was expected.\n",
                                        DeviceObject,
                                        returnedStartingLBA,
                                        startingLBA));
 
                            doneProcessing = TRUE;
                            processCurrentDescriptor = FALSE;
                            *BlockLimitsDataMayHaveChanged = TRUE;
                        }
                        else if (lbaCount > 0 && lbaCount % blocksPerSlab != 0)
                        {
                            //
                            // If the device returned an LBA count with a partial slab, round
                            // the LBA count up to the nearest slab and set a flag to stop
                            // processing further descriptors.  This is mainly to handle the
                            // case where disk size may not be slab-aligned and thus the last
                            // "slab" is actually a partial slab.
                            //
                            TracePrint((TRACE_LEVEL_WARNING,
                                    TRACE_FLAG_IOCTL,
                                    "ClasspDeviceGetLBAStatusWorker (%p): Device returned an LBA count (%u) that is not a multiple of the slab size (%u)\n",
                                    DeviceObject,
                                    lbaCount,
                                    blocksPerSlab));
 
                            lbaCount = ((lbaCount / blocksPerSlab) + 1) * blocksPerSlab;
 
                            doneProcessing = TRUE;
                            processCurrentDescriptor = TRUE;
                        }
                        else if (lbaCount == 0)
                        {
                            //
                            // If the LBA count is 0, just skip this descriptor.
                            //
                            TracePrint((TRACE_LEVEL_WARNING,
                                    TRACE_FLAG_IOCTL,
                                    "ClasspDeviceGetLBAStatusWorker (%p): Device returned a zero LBA count\n",
                                    DeviceObject));
 
                            processCurrentDescriptor = FALSE;
                        }
 
                        //
                        // Generate bits for the slabs described in the current descriptor.
                        // It's possible the device may have returned more slabs than requested
                        // so we make sure to stop once we've processed all we need.
                        //
                        if (processCurrentDescriptor)
                        {
                            ULONG descrSlabs = lbaCount / blocksPerSlab; // Number of slabs in this descriptor.
 
                            for(; 0 < descrSlabs && totalProcessedSlabs < requestedSlabs; descrSlabs--, commandProcessedSlabs++, totalProcessedSlabs++)
                            {
                                ULONG bitMapIndex = totalProcessedSlabs / bitMapGranularityInBits;
                                ULONG bitPos = totalProcessedSlabs % bitMapGranularityInBits;
 
                                #if (NTDDI_VERSION >= NTDDI_WINBLUE)
                                if (OutputVersion == DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V2) {
                                    ((PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2)lbpState)->SlabAllocationBitMap[bitMapIndex] |= (mapped << bitPos);
                                } else
                                #endif
                                {
                                    lbpState->SlabAllocationBitMap[bitMapIndex] |= (mapped << bitPos);
                                }
                            }
                        }
 
                        //
                        // Calculate the next expected starting LBA.
                        //
                        expectedStartingLBA = returnedStartingLBA + lbaCount;
                    }
 
                    if (commandProcessedSlabs > 0) {
 
                        //
                        // Calculate the starting LBA we'll use for the next command.
                        //
                        startingLBA += ((ULONGLONG)commandProcessedSlabs * (ULONGLONG)blocksPerSlab);
 
                    } else {
                        //
                        // This should never happen, but we should handle it gracefully anyway.
                        //
                        TracePrint((TRACE_LEVEL_ERROR,
                                    TRACE_FLAG_IOCTL,
                                    "ClasspDeviceGetLBAStatusWorker (%p): The slab allocation bitmap has zero length.\n",
                                    DeviceObject));
 
                        NT_ASSERT(commandProcessedSlabs != 0);
                        doneProcessing = TRUE;
                        status = STATUS_UNSUCCESSFUL;
                    }
                } else {
                    TracePrint((TRACE_LEVEL_ERROR,
                                TRACE_FLAG_IOCTL,
                                "ClasspDeviceGetLBAStatusWorker (%p): Device returned no LBA Status Descriptors.\n",
                                DeviceObject));
 
                    doneProcessing = TRUE;
                    status = STATUS_UNSUCCESSFUL;
                }
            } else {
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_IOCTL,
                            "ClasspDeviceGetLBAStatusWorker (%p): not enough bytes returned\n",
                            DeviceObject));
 
                doneProcessing = TRUE;
                status = STATUS_DEVICE_DATA_ERROR;
            }
        }
 
    //
    // Loop until we encounter some error or we've processed all the requested slabs.
    //
    } while (NT_SUCCESS(status) &&
             !doneProcessing &&
             (totalProcessedSlabs < requestedSlabs));
 
    //
    // At least one slab was returned by the device and processed, which we
    // consider success.  It's up to the caller to detect truncation.
    // Update the output buffer sizes, offsets, etc. accordingly.
    //
    if (totalProcessedSlabs > 0) {
 
        #if (NTDDI_VERSION >= NTDDI_WINBLUE)
        if (OutputVersion == DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V2) {
            PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 lbpStateV2 = (PDEVICE_DATA_SET_LB_PROVISIONING_STATE_V2)lbpState;
 
            lbpStateV2->SlabSizeInBytes = bytesPerSlab;
            lbpStateV2->SlabOffsetDeltaInBytes = startingOffsetDelta;
            lbpStateV2->SlabAllocationBitMapBitCount = totalProcessedSlabs;
            lbpStateV2->SlabAllocationBitMapLength = ((totalProcessedSlabs - 1) / (ULONGLONG)bitMapGranularityInBits) + 1;
            lbpStateV2->Version = DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V2;
 
            //
            // Note that there is already one element of the bitmap array allocated
            // in the DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2 structure itself, which
            // is why we subtract 1 from SlabAllocationBitMapLength.
            //
            lbpStateV2->Size = sizeof(DEVICE_DATA_SET_LB_PROVISIONING_STATE_V2)
                               + ((lbpStateV2->SlabAllocationBitMapLength - 1) * sizeof(lbpStateV2->SlabAllocationBitMap[0]));
 
        } else
        #endif
        {
 
            lbpState->SlabSizeInBytes = bytesPerSlab;
            lbpState->SlabOffsetDeltaInBytes = (ULONG)startingOffsetDelta;
            lbpState->SlabAllocationBitMapBitCount = totalProcessedSlabs;
            lbpState->SlabAllocationBitMapLength = ((totalProcessedSlabs - 1) / bitMapGranularityInBits) + 1;
            lbpState->Version = DEVICE_DATA_SET_LB_PROVISIONING_STATE_VERSION_V1;
 
            //
            // Note that there is already one element of the bitmap array allocated
            // in the DEVICE_DATA_SET_LB_PROVISIONING_STATE structure itself, which
            // is why we subtract 1 from SlabAllocationBitMapLength.
            //
            lbpState->Size = sizeof(DEVICE_DATA_SET_LB_PROVISIONING_STATE)
                             + ((lbpState->SlabAllocationBitMapLength - 1) * sizeof(lbpState->SlabAllocationBitMap[0]));
        }
 
        DsmOutput->OutputBlockLength = lbpState->Size; // Size is at the same offset in all versions of the structure.
        DsmOutput->OutputBlockOffset = sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT);
        *DsmOutputLength = DsmOutput->Size + DsmOutput->OutputBlockLength;
 
        status = STATUS_SUCCESS;
    }
 
    TracePrint((TRACE_LEVEL_INFORMATION,
            TRACE_FLAG_IOCTL,
            "ClasspDeviceGetLBAStatusWorker (%p): Processed a total of %u slabs\n",
            DeviceObject,
            totalProcessedSlabs));
Exit:
 
    FREE_POOL(lbaStatusListHeader);
    return status;
}

Referenced by ClasspDeviceGetLBAStatus().

◆ ClasspDeviceGetLBProvisioningVPDPage()

NTSTATUS ClasspDeviceGetLBProvisioningVPDPage	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_opt_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 2350 of file utils.c.

{
    NTSTATUS                     status = STATUS_UNSUCCESSFUL;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    USHORT                       pageLength = 0;
 
    PVOID                        dataBuffer = NULL;
    UCHAR                        bufferLength = VPD_MAX_BUFFER_SIZE;  // use biggest buffer possible
    ULONG                        allocationBufferLength = bufferLength; // Since the CDB size may differ from the actual buffer allocation
    PCDB                         cdb;
    ULONG                        dataTransferLength = 0;
    PVPD_LOGICAL_BLOCK_PROVISIONING_PAGE  lbProvisioning = NULL;
 
    //
    // if the informaiton has been attempted to retrieve, return the cached status.
    //
    if (fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus != -1) {
        // get cached NTSTATUS from previous call.
        return fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus;
    }
 
    //
    // Initialize LBProvisioningData fields to 'unsupported' defaults.
    //
    fdoExtension->FunctionSupportInfo->LBProvisioningData.ProvisioningType = PROVISIONING_TYPE_UNKNOWN;
    fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPRZ = FALSE;
    fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPU = FALSE;
    fdoExtension->FunctionSupportInfo->LBProvisioningData.ANC_SUP = FALSE;
    fdoExtension->FunctionSupportInfo->LBProvisioningData.ThresholdExponent = 0;
 
    //
    // Try to get the Thin Provisioning VPD page (0xB2), if it is supported.
    //
    if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.LBProvisioning == TRUE &&
        Srb != NULL)
    {
#if defined(_ARM_) || defined(_ARM64_)
        //
        // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
        // based platforms. We are taking the conservative approach here.
        //
        //
        allocationBufferLength = ALIGN_UP_BY(allocationBufferLength,KeGetRecommendedSharedDataAlignment());
        dataBuffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, allocationBufferLength,'0CcS');
#else
        dataBuffer = ExAllocatePoolWithTag(NonPagedPoolNx, bufferLength,'0CcS');
#endif
        if (dataBuffer == NULL) {
            // return without updating FdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus
            // the field will remain value as "-1", so that the command will be attempted next time this function is called.
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        lbProvisioning = (PVPD_LOGICAL_BLOCK_PROVISIONING_PAGE)dataBuffer;
 
        RtlZeroMemory(dataBuffer, allocationBufferLength);
 
        if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
            status = InitializeStorageRequestBlock((PSTORAGE_REQUEST_BLOCK)Srb,
                                                   STORAGE_ADDRESS_TYPE_BTL8,
                                                   CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE,
                                                   1,
                                                   SrbExDataTypeScsiCdb16);
            if (NT_SUCCESS(status)) {
                ((PSTORAGE_REQUEST_BLOCK)Srb)->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
            } else {
                //
                // Should not occur.
                //
                NT_ASSERT(FALSE);
            }
        } else {
            RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));
            Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
            Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
            status = STATUS_SUCCESS;
        }
 
        if (NT_SUCCESS(status)) {
            // prepare the Srb
            SrbSetTimeOutValue(Srb, fdoExtension->TimeOutValue);
            SrbSetRequestTag(Srb, SP_UNTAGGED);
            SrbSetRequestAttribute(Srb, SRB_SIMPLE_TAG_REQUEST);
            SrbAssignSrbFlags(Srb, fdoExtension->SrbFlags);
 
            SrbSetCdbLength(Srb, 6);
 
            cdb = SrbGetCdb(Srb);
            cdb->CDB6INQUIRY3.OperationCode = SCSIOP_INQUIRY;
            cdb->CDB6INQUIRY3.EnableVitalProductData = 1;       //EVPD bit
            cdb->CDB6INQUIRY3.PageCode = VPD_LOGICAL_BLOCK_PROVISIONING;
            cdb->CDB6INQUIRY3.AllocationLength = bufferLength;  //AllocationLength field in CDB6INQUIRY3 is only one byte.
 
            status = ClassSendSrbSynchronous(fdoExtension->DeviceObject,
                                             Srb,
                                             dataBuffer,
                                             allocationBufferLength,
                                             FALSE);
 
            dataTransferLength = SrbGetDataTransferLength(Srb);
        }
 
        //
        // Handle the case where we get back STATUS_DATA_OVERRUN b/c the input
        // buffer was larger than necessary.
        //
        if (status == STATUS_DATA_OVERRUN && dataTransferLength < bufferLength)
        {
            status = STATUS_SUCCESS;
        }
 
        if (NT_SUCCESS(status)) {
            REVERSE_BYTES_SHORT(&pageLength, &(lbProvisioning->PageLength));
        }
 
        if ( NT_SUCCESS(status) &&
                ((dataTransferLength < 0x08) ||
                (pageLength < (FIELD_OFFSET(VPD_LOGICAL_BLOCK_PROVISIONING_PAGE, Reserved2) - FIELD_OFFSET(VPD_LOGICAL_BLOCK_PROVISIONING_PAGE,ThresholdExponent))) ||
                (lbProvisioning->PageCode != VPD_LOGICAL_BLOCK_PROVISIONING)) ) {
            // the device should return at least 8 bytes of data for use.
            // 'PageCode' shall match and we need all the relevant data after the header.
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
 
        //
        // Fill in the FDO extension with either the data from the VPD page, or
        // use defaults if there was an error.
        //
        if (NT_SUCCESS(status))
        {
            fdoExtension->FunctionSupportInfo->LBProvisioningData.ProvisioningType = lbProvisioning->ProvisioningType;
            fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPRZ = lbProvisioning->LBPRZ;
            fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPU = lbProvisioning->LBPU;
            fdoExtension->FunctionSupportInfo->LBProvisioningData.ANC_SUP = lbProvisioning->ANC_SUP;
            fdoExtension->FunctionSupportInfo->LBProvisioningData.ThresholdExponent = lbProvisioning->ThresholdExponent;
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_PNP,
                        "ClasspDeviceGetLBProvisioningVPDPage (%p): %s %s (rev %s) reported following parameters: \
                        \n\t\t\tProvisioningType: %u \
                        \n\t\t\tLBPRZ: %u \
                        \n\t\t\tLBPU: %u \
                        \n\t\t\tANC_SUP: %I64u \
                        \n\t\t\tThresholdExponent: %u\n",
                        DeviceObject,
                        (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->VendorIdOffset),
                        (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->ProductIdOffset),
                        (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->ProductRevisionOffset),
                        lbProvisioning->ProvisioningType,
                        lbProvisioning->LBPRZ,
                        lbProvisioning->LBPU,
                        lbProvisioning->ANC_SUP,
                        lbProvisioning->ThresholdExponent));
        }
    } else {
        status = STATUS_INVALID_DEVICE_REQUEST;
    }
 
    fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus = status;
 
Exit:
    FREE_POOL(dataBuffer);
 
    return status;
}

Referenced by ClasspGetLBProvisioningInfo().

◆ ClasspDeviceLBProvisioningProperty()

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

Definition at line 2894 of file utils.c.

{
    NTSTATUS                     status = STATUS_SUCCESS;
    NTSTATUS                     blockLimitsStatus;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PSTORAGE_PROPERTY_QUERY      query = (PSTORAGE_PROPERTY_QUERY)Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION           irpStack = IoGetCurrentIrpStackLocation(Irp);
    ULONG                        length = 0;
    ULONG                        information = 0;
    CLASS_VPD_B0_DATA            blockLimitsData;
    ULONG                        generationCount;
 
    PDEVICE_LB_PROVISIONING_DESCRIPTOR  lbpDescr;
 
    UNREFERENCED_PARAMETER(Srb);
 
    //
    // Check proper query type.
    //
    if (query->QueryType == PropertyExistsQuery) {
        status = STATUS_SUCCESS;
        goto Exit;
    } else  if (query->QueryType != PropertyStandardQuery) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit;
    }
 
    //
    // Request validation.
    // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
    //
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        status = STATUS_INVALID_LEVEL;
        goto Exit;
    }
 
    lbpDescr = (PDEVICE_LB_PROVISIONING_DESCRIPTOR)Irp->AssociatedIrp.SystemBuffer;
 
    length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    RtlZeroMemory(lbpDescr, length);
 
    if (length < DEVICE_LB_PROVISIONING_DESCRIPTOR_V1_SIZE) {
 
        if (length >= sizeof(STORAGE_DESCRIPTOR_HEADER)) {
 
            information = sizeof(STORAGE_DESCRIPTOR_HEADER);
            lbpDescr->Version = sizeof(DEVICE_LB_PROVISIONING_DESCRIPTOR);
            lbpDescr->Size = sizeof(DEVICE_LB_PROVISIONING_DESCRIPTOR);
            status = STATUS_SUCCESS;
            goto Exit;
        }
 
        status = STATUS_BUFFER_TOO_SMALL;
        goto Exit;
    }
 
    //
    // Set the structure version/size based upon the size of the given output
    // buffer.  We may be working with an older component that was built with
    // the V1 structure definition.
    //
    if (length < sizeof(DEVICE_LB_PROVISIONING_DESCRIPTOR)) {
        lbpDescr->Version = DEVICE_LB_PROVISIONING_DESCRIPTOR_V1_SIZE;
        lbpDescr->Size = DEVICE_LB_PROVISIONING_DESCRIPTOR_V1_SIZE;
        information = DEVICE_LB_PROVISIONING_DESCRIPTOR_V1_SIZE;
    } else {
        lbpDescr->Version = sizeof(DEVICE_LB_PROVISIONING_DESCRIPTOR);
        lbpDescr->Size = sizeof(DEVICE_LB_PROVISIONING_DESCRIPTOR);
        information = sizeof(DEVICE_LB_PROVISIONING_DESCRIPTOR);
    }
 
    //
    // Take a snapshot of the block limits data since it can change.
    // If we failed to get the block limits data, we'll just set the Optimal
    // Unmap Granularity (and alignment) will default to 0.  We don't want to
    // fail the request outright since there is some non-block limits data that
    // we can return.
    //
    blockLimitsStatus = ClasspBlockLimitsDataSnapshot(fdoExtension,
                                                      TRUE,
                                                      &blockLimitsData,
                                                      &generationCount);
 
    //
    // Fill in the output buffer.  All data is copied from the FDO extension where we
    // cached Logical Block Provisioning info when the device was first initialized.
    //
 
    lbpDescr->ThinProvisioningEnabled = ClasspIsThinProvisioned(fdoExtension->FunctionSupportInfo);
 
    //
    // Make sure we have a non-zero value for the number of bytes per block.
    //
    if (fdoExtension->DiskGeometry.BytesPerSector == 0)
    {
        status = ClassReadDriveCapacity(fdoExtension->DeviceObject);
        if(!NT_SUCCESS(status) || fdoExtension->DiskGeometry.BytesPerSector == 0)
        {
            status = STATUS_INVALID_DEVICE_REQUEST;
            information = 0;
            goto Exit;
        }
    }
 
    lbpDescr->ThinProvisioningReadZeros = fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPRZ;
    lbpDescr->AnchorSupported = fdoExtension->FunctionSupportInfo->LBProvisioningData.ANC_SUP;
 
    if (NT_SUCCESS(blockLimitsStatus)) {
        lbpDescr->UnmapGranularityAlignmentValid = blockLimitsData.UGAVALID;
 
        //
        // Granularity and Alignment are given to us in units of blocks,
        // but we convert and return them in bytes as it is more convenient
        // to the caller.
        //
        lbpDescr->OptimalUnmapGranularity = (ULONGLONG)blockLimitsData.OptimalUnmapGranularity * fdoExtension->DiskGeometry.BytesPerSector;
        lbpDescr->UnmapGranularityAlignment = (ULONGLONG)blockLimitsData.UnmapGranularityAlignment * fdoExtension->DiskGeometry.BytesPerSector;
 
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
        //
        // If the output buffer is large enough (i.e. not a V1 structure) copy
        // over the max UNMAP LBA count and max UNMAP block descriptor count.
        //
        if (length >= sizeof(DEVICE_LB_PROVISIONING_DESCRIPTOR)) {
            lbpDescr->MaxUnmapLbaCount = blockLimitsData.MaxUnmapLbaCount;
            lbpDescr->MaxUnmapBlockDescriptorCount = blockLimitsData.MaxUnmapBlockDescrCount;
        }
#endif
    }
 
Exit:
 
    //
    // Set the size and status in IRP
    //
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspDeviceMediaTypeProperty()

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

Definition at line 1917 of file utils.c.

{
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PSTORAGE_PROPERTY_QUERY query = (PSTORAGE_PROPERTY_QUERY)Irp->AssociatedIrp.SystemBuffer;
    PSTORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR pDesc = (PSTORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR)Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION irpStack;
    ULONG length = 0;
    ULONG information = 0;
 
    irpStack = IoGetCurrentIrpStackLocation(Irp);
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspDeviceMediaTypeProperty (%p): Entering function.\n",
                DeviceObject));
 
    //
    // Check proper query type.
    //
    if (query->QueryType == PropertyExistsQuery) {
 
        //
        // In order to maintain consistency with the how the rest of the properties
        // are handled, always return success for PropertyExistsQuery.
        //
        status = STATUS_SUCCESS;
        goto __ClasspDeviceMediaTypeProperty_Exit;
 
    } else if (query->QueryType != PropertyStandardQuery) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceMediaTypeProperty (%p): Unsupported query type %x for media type property.\n",
                    DeviceObject,
                    query->QueryType));
 
        status = STATUS_NOT_SUPPORTED;
        goto __ClasspDeviceMediaTypeProperty_Exit;
    }
 
    //
    // Validate the request.
    // InputBufferLength and IsFdo have already been validated.
    //
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
 
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceMediaTypeProperty (%p): Query property for media type at incorrect IRQL.\n",
                    DeviceObject));
 
        status = STATUS_INVALID_LEVEL;
        goto __ClasspDeviceMediaTypeProperty_Exit;
    }
 
    length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    if (length >= sizeof(STORAGE_DESCRIPTOR_HEADER)) {
 
        information = sizeof(STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR);
        pDesc->Version = sizeof(STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR);
        pDesc->Size = sizeof(STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR);
    } else {
 
        status = STATUS_BUFFER_TOO_SMALL;
        goto __ClasspDeviceMediaTypeProperty_Exit;
    }
 
    if (length < sizeof(STORAGE_MEDIUM_PRODUCT_TYPE_DESCRIPTOR)) {
 
        status = STATUS_SUCCESS;
        goto __ClasspDeviceMediaTypeProperty_Exit;
    }
 
    //
    // Only query BlockDeviceCharacteristics VPD page if device support has been confirmed.
    //
    if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceCharacteristics == TRUE) {
        status = ClasspDeviceGetBlockDeviceCharacteristicsVPDPage(fdoExtension, Srb);
    } else {
        //
        // Otherwise device was previously found lacking support for this VPD page. Fail the request.
        //
        status = STATUS_INVALID_DEVICE_REQUEST;
        goto __ClasspDeviceMediaTypeProperty_Exit;
    }
 
    if (!NT_SUCCESS(status)) {
 
        status = fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.CommandStatus;
        information = 0;
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceGetBlockDeviceCharacteristicsVPDPage (%p): VPD retrieval fails with %x.\n",
                    DeviceObject,
                    status));
 
        goto __ClasspDeviceMediaTypeProperty_Exit;
    }
 
    //
    // Fill in the output buffer.  All data is copied from the FDO extension, cached
    //  from device response to earlier VPD_BLOCK_DEVICE_CHARACTERISTICS query.
    //
    pDesc->MediumProductType = fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumProductType;
    status = STATUS_SUCCESS;
 
__ClasspDeviceMediaTypeProperty_Exit:
 
    //
    // Set the size and status in IRP
    //
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspDeviceMediaTypeProperty (%p): Exiting function with status %x.\n",
                DeviceObject,
                status));
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspDeviceSeekPenaltyProperty()

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

Definition at line 2172 of file utils.c.

{
    NTSTATUS    status = STATUS_UNSUCCESSFUL;
 
    PCOMMON_DEVICE_EXTENSION     commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PSTORAGE_PROPERTY_QUERY      query = (PSTORAGE_PROPERTY_QUERY)Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION           irpStack = IoGetCurrentIrpStackLocation(Irp);
    ULONG                        length = 0;
    ULONG                        information = 0;
    BOOLEAN                      incursSeekPenalty = TRUE;
    PDEVICE_SEEK_PENALTY_DESCRIPTOR seekPenalty;
 
    if ( (DeviceObject->DeviceType != FILE_DEVICE_DISK) ||
         (TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE)) ||
         (fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty == Supported) ) {
        // if it's not disk, forward the request to lower layer,
        // if the IOCTL is supported by lower stack, forward it down.
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        return status;
    }
 
    //
    // Check proper query type.
    //
 
    if (query->QueryType == PropertyExistsQuery) {
        status = STATUS_SUCCESS;
        goto Exit;
    } else  if (query->QueryType != PropertyStandardQuery) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit;
    }
 
    //
    // Request validation.
    // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
    //
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        status = STATUS_INVALID_LEVEL;
        goto Exit;
    }
 
    // do not touch this buffer because it can still be used as input buffer for lower layer in 'SupportUnknown' case.
    seekPenalty = (PDEVICE_SEEK_PENALTY_DESCRIPTOR)Irp->AssociatedIrp.SystemBuffer;
 
    length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    if (length < sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR)) {
 
        if (length >= sizeof(STORAGE_DESCRIPTOR_HEADER)) {
 
            information = sizeof(STORAGE_DESCRIPTOR_HEADER);
            seekPenalty->Version = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR);
            seekPenalty->Size = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR);
            status = STATUS_SUCCESS;
            goto Exit;
        }
 
        status = STATUS_BUFFER_TOO_SMALL;
        goto Exit;
    }
 
    //
    // note that 'Supported' case has been handled at the beginning of this function.
    //
    switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty) {
    case SupportUnknown: {
        // send down request and wait for the request to complete.
        status = ClassForwardIrpSynchronous(commonExtension, Irp);
 
        if (ClasspLowerLayerNotSupport(status)) {
            // case 1: the request is not supported by lower layer, sends down command
            // some port drivers (or filter drivers) return STATUS_INVALID_DEVICE_REQUEST if a request is not supported.
 
            // send INQUIRY command if the VPD page is supported.
            if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceCharacteristics == TRUE) {
                status = ClasspDeviceGetBlockDeviceCharacteristicsVPDPage(fdoExtension, Srb);
            } else {
                // the INQUIRY - VPD page command to discover the info is not supported, fail the request.
                status = STATUS_INVALID_DEVICE_REQUEST;
            }
 
            if (NT_SUCCESS(status)) {
                status = IncursSeekPenalty(fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumRotationRate, &incursSeekPenalty);
            }
 
            fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.CommandStatus = status;
 
            // data is ready in fdoExtension
            // set the support status after the SCSI command is executed to avoid racing condition between multiple same type of requests.
            fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty = NotSupported;
 
            // fill output buffer
            if (NT_SUCCESS(status)) {
                RtlZeroMemory(seekPenalty, length);
                seekPenalty->Version = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR);
                seekPenalty->Size = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR);
                seekPenalty->IncursSeekPenalty = incursSeekPenalty;
                information = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR);
 
 
            } else {
                information = 0;
            }
 
        } else {
            // case 2: the request is supported and it completes successfully
            // case 3: the request is supported by lower stack but other failure status is returned.
            // from now on, the same request will be send down to lower stack directly.
            fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty = Supported;
            information = (ULONG)Irp->IoStatus.Information;
 
        }
 
 
        goto Exit;
 
        break;
    }
 
    case NotSupported: {
        status = fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.CommandStatus;
 
        if (NT_SUCCESS(status)) {
            status = IncursSeekPenalty(fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.MediumRotationRate, &incursSeekPenalty);
        }
 
        if (NT_SUCCESS(status)) {
            RtlZeroMemory(seekPenalty, length);
            seekPenalty->Version = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR);
            seekPenalty->Size = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR);
            seekPenalty->IncursSeekPenalty = incursSeekPenalty;
            information = sizeof(DEVICE_SEEK_PENALTY_DESCRIPTOR);
 
        } else {
            information = 0;
        }
 
        goto Exit;
 
        break;
    }
 
    case Supported: {
        NT_ASSERT(FALSE); // this case is handled at the begining of the function.
        break;
    }
 
    }   // end of switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.SeekPenaltyProperty)
 
Exit:
 
    //
    // Set the size and status in IRP
    //
    Irp->IoStatus.Information = information;;
    Irp->IoStatus.Status = status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspDeviceTrimProcess()

NTSTATUS ClasspDeviceTrimProcess	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_ PGUID	ActivityId,
		_Inout_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 3476 of file utils.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    PCOMMON_DEVICE_EXTENSION     commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 
    PDEVICE_MANAGE_DATA_SET_ATTRIBUTES dsmAttributes = Irp->AssociatedIrp.SystemBuffer;
 
    PDEVICE_DATA_SET_RANGE      dataSetRanges;
    ULONG                       dataSetRangesCount;
    DEVICE_DATA_SET_RANGE       entireDataSetRange = {0};
    ULONG                       i;
    ULONGLONG                   granularityAlignmentInBytes;
    ULONG                       granularityInBlocks;
    ULONG                       srbFlags = 0;
 
    CLASS_VPD_B0_DATA           blockLimitsData;
    ULONG                       generationCount;
 
 
    if ( (DeviceObject->DeviceType != FILE_DEVICE_DISK) ||
         (TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE)) ||
         (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess == Supported) ) {
        // if it's not disk, forward the request to lower layer,
        // if the IOCTL is supported by lower stack, forward it down.
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        TracePrint((TRACE_LEVEL_INFORMATION,
                    TRACE_FLAG_GENERAL,
                    "ClasspDeviceTrimProcess (%p): Lower layer supports Trim DSM IOCTL, forwarding IOCTL.\n",
                    DeviceObject));
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        return status;
    }
 
    //
    // Request validation.
    // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
    //
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        status = STATUS_INVALID_LEVEL;
        goto Exit;
    }
 
 
    //
    // If the caller has not set the "entire dataset range" flag then at least
    // one dataset range should be specified.  However, if the caller *has* set
    // the flag, then there should not be any dataset ranges specified.
    //
    if ((!TEST_FLAG(dsmAttributes->Flags, DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE) &&
         (dsmAttributes->DataSetRangesOffset == 0 ||
          dsmAttributes->DataSetRangesLength == 0)) ||
        (TEST_FLAG(dsmAttributes->Flags, DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE) &&
         (dsmAttributes->DataSetRangesOffset != 0 ||
          dsmAttributes->DataSetRangesLength != 0))) {
 
        status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }
 
    //
    // note that 'Supported' case has been handled at the beginning of this function.
    //
    switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess) {
        case SupportUnknown: {
            // send down request and wait for the request to complete.
            status = ClassForwardIrpSynchronous(commonExtension, Irp);
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                    TRACE_FLAG_GENERAL,
                    "ClasspDeviceTrimProcess (%p): Trim DSM IOCTL support unknown.  Forwarded IOCTL and received NTSTATUS %!STATUS!.\n",
                    DeviceObject,
                    status));
 
            if (ClasspLowerLayerNotSupport(status)) {
                // case 1: the request is not supported by lower layer, sends down command
                // some port drivers (or filter drivers) return STATUS_INVALID_DEVICE_REQUEST if a request is not supported.
                // In this case we'll just fall through to the NotSupported case so that we can handle it ourselves.
 
                //
                // VPD pages 0xB2 and 0xB0 should have been cached in Start Device phase - ClassPnpStartDevice.
                // 0xB2 page: fdoExtension->FunctionSupportInfo->LBProvisioningData;
                // 0xB0 page: fdoExtension->FunctionSupportInfo->BlockLimitsData
                //
                if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.LBProvisioning == TRUE) {
                    NT_ASSERT(fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus != -1);
                }
 
                if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockLimits == TRUE) {
                    NT_ASSERT(fdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus != -1);
                }
 
            } else {
 
                // case 2: the request is supported and it completes successfully
                // case 3: the request is supported by lower stack but other failure status is returned.
                // from now on, the same request will be send down to lower stack directly.
                fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess = Supported;
                goto Exit;
            }
        }
 
        case NotSupported: {
 
            // send UNMAP command if it is supported. don't need to check 'status' value.
            if (ClasspSupportsUnmap(fdoExtension->FunctionSupportInfo))
            {
                //
                // Make sure that we know the bytes per sector (logical block) as it's
                // necessary for calculations involving granularity and alignment.
                //
                if (fdoExtension->DiskGeometry.BytesPerSector == 0) {
                    status = ClassReadDriveCapacity(fdoExtension->DeviceObject);
                    if(!NT_SUCCESS(status) || fdoExtension->DiskGeometry.BytesPerSector == 0) {
                        status = STATUS_INVALID_DEVICE_REQUEST;
                        goto Exit;
                    }
                }
 
                //
                // Take a snapshot of the block limits data since it can change.
                // It's acceptable if the block limits data is outdated since
                // there isn't a hard requirement on the unmap granularity.
                //
                ClasspBlockLimitsDataSnapshot(fdoExtension,
                                              FALSE,
                                              &blockLimitsData,
                                              &generationCount);
 
                //
                // Check to see if the Optimal Unmap Granularity and Unmap Granularity
                // Alignment have been specified.  If not, default the granularity to
                // one block and the alignment to zero.
                //
                if (blockLimitsData.OptimalUnmapGranularity != 0)
                {
                    granularityInBlocks = blockLimitsData.OptimalUnmapGranularity;
                }
                else
                {
                    granularityInBlocks = 1;
 
                    TracePrint((TRACE_LEVEL_INFORMATION,
                                TRACE_FLAG_GENERAL,
                                "ClasspDeviceTrimProcess (%p): Optimal Unmap Granularity not provided, defaulted to 1.\n",
                                DeviceObject));
                }
 
                if (blockLimitsData.UGAVALID == TRUE)
                {
                    granularityAlignmentInBytes = (ULONGLONG)blockLimitsData.UnmapGranularityAlignment * fdoExtension->DiskGeometry.BytesPerSector;
                }
                else
                {
                    granularityAlignmentInBytes = 0;
 
                    TracePrint((TRACE_LEVEL_INFORMATION,
                                TRACE_FLAG_GENERAL,
                                "ClasspDeviceTrimProcess (%p): Unmap Granularity Alignment not provided, defaulted to 0.\n",
                                DeviceObject));
                }
 
                if (TEST_FLAG(dsmAttributes->Flags, DEVICE_DSM_FLAG_ENTIRE_DATA_SET_RANGE))
                {
                    //
                    // The caller wants to UNMAP the entire disk so we need to build a single
                    // dataset range that represents the entire disk.
                    //
                    entireDataSetRange.StartingOffset = granularityAlignmentInBytes;
                    entireDataSetRange.LengthInBytes = (ULONGLONG)fdoExtension->CommonExtension.PartitionLength.QuadPart - (ULONGLONG)entireDataSetRange.StartingOffset;
 
                    dataSetRanges = &entireDataSetRange;
                    dataSetRangesCount = 1;
                }
                else
                {
 
                    dataSetRanges = (PDEVICE_DATA_SET_RANGE)((PUCHAR)dsmAttributes + dsmAttributes->DataSetRangesOffset);
                    dataSetRangesCount = dsmAttributes->DataSetRangesLength / sizeof(DEVICE_DATA_SET_RANGE);
 
                    //
                    // Validate the data ranges.  Make sure the range is block-aligned,
                    // falls in a valid portion of the disk, and is non-zero.
                    //
                    for (i = 0; i < dataSetRangesCount; i++)
                    {
                        if ((dataSetRanges[i].StartingOffset % fdoExtension->DiskGeometry.BytesPerSector != 0) ||
                            (dataSetRanges[i].LengthInBytes % fdoExtension->DiskGeometry.BytesPerSector != 0) ||
                            (dataSetRanges[i].StartingOffset < (LONGLONG)granularityAlignmentInBytes) ||
                            (dataSetRanges[i].LengthInBytes == 0) ||
                            ((ULONGLONG)dataSetRanges[i].StartingOffset + dataSetRanges[i].LengthInBytes > (ULONGLONG)fdoExtension->CommonExtension.PartitionLength.QuadPart))
                        {
                            TracePrint((TRACE_LEVEL_ERROR,
                                        TRACE_FLAG_IOCTL,
                                        "ClasspDeviceTrimProcess (%p): Invalid dataset range.  StartingOffset = %I64x, LengthInBytes = %I64x\n",
                                        DeviceObject,
                                        dataSetRanges[i].StartingOffset,
                                        dataSetRanges[i].LengthInBytes));
 
                            status = STATUS_INVALID_PARAMETER;
                            goto Exit;
                        }
                    }
                }
 
 
                if (!TEST_FLAG(dsmAttributes->Flags, DEVICE_DSM_FLAG_TRIM_NOT_FS_ALLOCATED))
                {
                    {
                        //
                        // For security reasons, file-level TRIM must be forwarded on only
                        // if reading the unmapped blocks' contents will return back zeros.
                        // This is because if LBPRZ bit is not set, it indicates that a read
                        // of unmapped blocks may return "any" data thus potentially leaking
                        // in data (into the read buffer) from other blocks.
                        //
                        if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.LBProvisioning &&
                            !fdoExtension->FunctionSupportInfo->LBProvisioningData.LBPRZ) {
 
                            TracePrint((TRACE_LEVEL_ERROR,
                                        TRACE_FLAG_IOCTL,
                                        "ClasspDeviceTrimProcess (%p): Device does not support file level TRIM.\n",
                                        DeviceObject));
 
                            status = STATUS_TRIM_READ_ZERO_NOT_SUPPORTED;
                            goto Exit;
                        }
                    }
                }
 
                // process DSM IOCTL
                status = DeviceProcessDsmTrimRequest(fdoExtension,
                                                     dataSetRanges,
                                                     dataSetRangesCount,
                                                     granularityInBlocks,
                                                     srbFlags,
                                                     Irp,
                                                     ActivityId,
                                                     Srb);
            } else {
                // DSM IOCTL should be completed as not supported
 
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_IOCTL,
                            "ClasspDeviceTrimProcess (%p): Device does not support UNMAP.\n",
                            DeviceObject));
 
                status = STATUS_NOT_SUPPORTED;
            }
 
            // set the support status after the SCSI command is executed to avoid racing condition between multiple same type of requests.
            fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess = NotSupported;
 
            break;
        }
 
        case Supported: {
            NT_ASSERT(FALSE); // this case is handled at the begining of the function.
            break;
        }
 
    }   // end of switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProcess)
 
Exit:
 
    //
    // Set the size and status in IRP
    //
    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = status;
 
 
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspDeviceTrimProperty()

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

Definition at line 2730 of file utils.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    PCOMMON_DEVICE_EXTENSION     commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PSTORAGE_PROPERTY_QUERY      query = (PSTORAGE_PROPERTY_QUERY)Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION           irpStack = IoGetCurrentIrpStackLocation(Irp);
    ULONG                        length = 0;
    ULONG                        information = 0;
 
    PDEVICE_TRIM_DESCRIPTOR      trimDescr;
 
    UNREFERENCED_PARAMETER(Srb);
 
    if ( (DeviceObject->DeviceType != FILE_DEVICE_DISK) ||
         (TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE)) ||
         (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty == Supported) ) {
        // if it's not disk, forward the request to lower layer,
        // if the IOCTL is supported by lower stack, forward it down.
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        return status;
    }
 
    //
    // Check proper query type.
    //
 
    if (query->QueryType == PropertyExistsQuery) {
        status = STATUS_SUCCESS;
        goto Exit;
    } else  if (query->QueryType != PropertyStandardQuery) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit;
    }
 
    //
    // Request validation.
    // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
    //
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        status = STATUS_INVALID_LEVEL;
        goto Exit;
    }
 
    // do not touch this buffer because it can still be used as input buffer for lower layer in 'SupportUnknown' case.
    trimDescr = (PDEVICE_TRIM_DESCRIPTOR)Irp->AssociatedIrp.SystemBuffer;
 
    length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    if (length < sizeof(DEVICE_TRIM_DESCRIPTOR)) {
 
        if (length >= sizeof(STORAGE_DESCRIPTOR_HEADER)) {
 
            information = sizeof(STORAGE_DESCRIPTOR_HEADER);
            trimDescr->Version = sizeof(DEVICE_TRIM_DESCRIPTOR);
            trimDescr->Size = sizeof(DEVICE_TRIM_DESCRIPTOR);
            status = STATUS_SUCCESS;
            goto Exit;
        }
 
        status = STATUS_BUFFER_TOO_SMALL;
        goto Exit;
    }
 
    //
    // note that 'Supported' case has been handled at the beginning of this function.
    //
    switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty) {
    case SupportUnknown: {
        // send down request and wait for the request to complete.
        status = ClassForwardIrpSynchronous(commonExtension, Irp);
 
        if ( (status == STATUS_NOT_SUPPORTED) ||
             (status == STATUS_NOT_IMPLEMENTED) ||
             (status == STATUS_INVALID_DEVICE_REQUEST) ||
             (status == STATUS_INVALID_PARAMETER_1) ) {
            // case 1: the request is not supported by lower layer, sends down command
            // some port drivers (or filter drivers) return STATUS_INVALID_DEVICE_REQUEST if a request is not supported.
            status = fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus;
            NT_ASSERT(status != -1);
 
            // data is ready in fdoExtension
            // set the support status after the SCSI command is executed to avoid racing condition between multiple same type of requests.
            fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty = NotSupported;
 
            if (NT_SUCCESS(status)) {
                // fill output buffer
                RtlZeroMemory(trimDescr, length);
                trimDescr->Version = sizeof(DEVICE_TRIM_DESCRIPTOR);
                trimDescr->Size = sizeof(DEVICE_TRIM_DESCRIPTOR);
                trimDescr->TrimEnabled = ClasspSupportsUnmap(fdoExtension->FunctionSupportInfo);
 
                // set returned data length
                information = sizeof(DEVICE_TRIM_DESCRIPTOR);
            } else {
                // there was error retrieving TrimProperty. Surface the error up from 'status' variable.
                information = 0;
            }
            goto Exit;
        } else {
            // case 2: the request is supported and it completes successfully
            // case 3: the request is supported by lower stack but other failure status is returned.
            // from now on, the same request will be send down to lower stack directly.
            fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty = Supported;
            information = (ULONG)Irp->IoStatus.Information;
            goto Exit;
        }
        break;
    }
 
    case NotSupported: {
        status = fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus;
        NT_ASSERT(status != -1);
 
        if (NT_SUCCESS(status)) {
            RtlZeroMemory(trimDescr, length);
            trimDescr->Version = sizeof(DEVICE_TRIM_DESCRIPTOR);
            trimDescr->Size = sizeof(DEVICE_TRIM_DESCRIPTOR);
            trimDescr->TrimEnabled = ClasspSupportsUnmap(fdoExtension->FunctionSupportInfo);
 
            information = sizeof(DEVICE_TRIM_DESCRIPTOR);
        } else {
            information = 0;
        }
        goto Exit;
 
        break;
    }
 
    case Supported: {
        NT_ASSERT(FALSE); // this case is handled at the begining of the function.
        break;
    }
 
    }   // end of switch (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty)
 
Exit:
 
    //
    // Set the size and status in IRP
    //
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspDisablePowerNotification()

VOID ClasspDisablePowerNotification ( PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

◆ ClasspDisableTimer()

VOID ClasspDisableTimer ( _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 3956 of file autorun.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = NULL;
 
    if (FdoExtension->CommonExtension.IsFdo) {
        fdoData = FdoExtension->PrivateFdoData;
    }
 
    if (fdoData && fdoData->TimerInitialized == TRUE) {
 
        //
        // we are only going to stop the actual timer in remove device routine
        // or when done transitioning to D3 (timer will be started again when
        // done transitioning to D0).
        //
        // it is the responsibility of the code within the timer routine to
        // check if the device is removed and not processing io for the final
        // call.
        // this keeps the code clean and prevents lots of bugs.
        //
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
        NT_ASSERT(fdoData->TickTimer != NULL);
        ExCancelTimer(fdoData->TickTimer, NULL);
#else
        KeCancelTimer(&fdoData->TickTimer);
#endif
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,  "ClasspDisableTimer: Periodic tick timer disabled "
                    "for device %p\n", FdoExtension->DeviceObject));
        fdoData->TickTimerEnabled = FALSE;
 
    } else {
 
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,  "ClasspDisableTimer: Timer never initialized\n"));
 
    }
 
    return;
} // end ClasspDisableTimer()

Referenced by ClassDispatchPnp(), and ClasspPowerHandler().

◆ ClasspDuidQueryProperty()

NTSTATUS ClasspDuidQueryProperty	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 997 of file utils.c.

{
    PSTORAGE_PROPERTY_QUERY query =  Irp->AssociatedIrp.SystemBuffer;
    PSTORAGE_DESCRIPTOR_HEADER descHeader;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
 
    NTSTATUS status;
 
    ULONG outLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    BOOLEAN includeOptionalIds;
    BOOLEAN overflow = FALSE;
    BOOLEAN infoFound = FALSE;
    BOOLEAN useStatus = TRUE;   // Use the status directly instead of relying on overflow and infoFound flags.
 
    //
    // Must run at less then dispatch.
    //
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
 
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        status = STATUS_INVALID_LEVEL;
        goto FnExit;
    }
 
    //
    // Check proper query type.
    //
 
    if (query->QueryType == PropertyExistsQuery) {
        Irp->IoStatus.Information = 0;
        status = STATUS_SUCCESS;
        goto FnExit;
    }
 
    if (query->QueryType != PropertyStandardQuery) {
        status = STATUS_NOT_SUPPORTED;
        goto FnExit;
    }
 
    //
    // Check AdditionalParameters validity.
    //
 
    if (query->AdditionalParameters[0] == DUID_INCLUDE_SOFTWARE_IDS) {
        includeOptionalIds = TRUE;
    } else if (query->AdditionalParameters[0] == DUID_HARDWARE_IDS_ONLY) {
        includeOptionalIds = FALSE;
    } else {
        status = STATUS_INVALID_PARAMETER;
        goto FnExit;
    }
 
    //
    // Verify output parameters.
    //
 
    if (outLength < sizeof(STORAGE_DESCRIPTOR_HEADER)) {
 
        status = STATUS_INFO_LENGTH_MISMATCH;
        goto FnExit;
    }
 
    //
    // From this point forward the status depends on the overflow
    // and infoFound flags.
    //
 
    useStatus = FALSE;
 
    descHeader = Irp->AssociatedIrp.SystemBuffer;
    RtlZeroMemory(descHeader, outLength);
 
    descHeader->Version = DUID_VERSION_1;
    descHeader->Size = sizeof(STORAGE_DEVICE_UNIQUE_IDENTIFIER);
 
    //
    // Try to build device unique id from StorageDeviceIdProperty.
    //
 
    status = ClasspDuidGetDeviceIdProperty(DeviceObject,
                                           Irp);
 
    if (status == STATUS_BUFFER_OVERFLOW) {
        overflow = TRUE;
    }
 
    if (NT_SUCCESS(status)) {
        infoFound = TRUE;
    }
 
    //
    // Try to build device unique id from StorageDeviceProperty.
    //
 
    status = ClasspDuidGetDeviceProperty(DeviceObject,
                                         Irp);
 
    if (status == STATUS_BUFFER_OVERFLOW) {
        overflow = TRUE;
    }
 
    if (NT_SUCCESS(status)) {
        infoFound = TRUE;
    }
 
    //
    // The following portion is optional and only included if the
    // caller requested software IDs.
    //
 
    if (!includeOptionalIds) {
        goto FnExit;
    }
 
    //
    // Try to build device unique id from drive layout signature (disk
    // devices only).
    //
 
    status = ClasspDuidGetDriveLayout(DeviceObject,
                                      Irp);
 
    if (status == STATUS_BUFFER_OVERFLOW) {
        overflow = TRUE;
    }
 
    if (NT_SUCCESS(status)) {
        infoFound = TRUE;
    }
 
FnExit:
 
    if (!useStatus) {
 
        //
        // Return overflow, success, or a generic error.
        //
 
        if (overflow) {
 
            //
            // If output buffer is STORAGE_DESCRIPTOR_HEADER, then return
            // success to the user.  Otherwise, send an error so the user
            // knows a larger buffer is required.
            //
 
            if (outLength == sizeof(STORAGE_DESCRIPTOR_HEADER)) {
                status = STATUS_SUCCESS;
                Irp->IoStatus.Information = sizeof(STORAGE_DESCRIPTOR_HEADER);
            } else {
                status = STATUS_BUFFER_OVERFLOW;
            }
 
        } else if (infoFound) {
            status = STATUS_SUCCESS;
 
            //
            // Exercise the compare routine.  This should always succeed.
            //
 
            NT_ASSERT(DuidExactMatch == CompareStorageDuids(Irp->AssociatedIrp.SystemBuffer,
                                                         Irp->AssociatedIrp.SystemBuffer));
 
        } else {
            status = STATUS_NOT_FOUND;
        }
    }
 
    Irp->IoStatus.Status = status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspEjectionControl()

NTSTATUS ClasspEjectionControl	(	IN PDEVICE_OBJECT	Fdo,
		IN PIRP	Irp,
		IN MEDIA_LOCK_TYPE	LockType,
		IN BOOLEAN	Lock
	)

Definition at line 474 of file create.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION FdoExtension = Fdo->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension =
        (PCOMMON_DEVICE_EXTENSION) FdoExtension;
 
    PFILE_OBJECT_EXTENSION fsContext = NULL;
    NTSTATUS status;
    PSCSI_REQUEST_BLOCK srb = NULL;
    BOOLEAN countChanged = FALSE;
 
    PAGED_CODE();
 
    /*
     *  Ensure that the user thread is not suspended while we are holding EjectSynchronizationEvent.
     */
    KeEnterCriticalRegion();
 
    status = KeWaitForSingleObject(
                &(FdoExtension->EjectSynchronizationEvent),
                UserRequest,
                KernelMode,
                FALSE,
                NULL);
 
    NT_ASSERT(status == STATUS_SUCCESS);
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                "ClasspEjectionControl: "
                "Received request for %s lock type\n",
                LockTypeStrings[LockType]
                ));
 
    _SEH2_TRY {
        PCDB cdb = NULL;
 
        //
        // Determine if this is a "secured" request.
        //
 
        if (LockType == SecureMediaLock) {
 
            PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
            PFILE_OBJECT fileObject = irpStack->FileObject;
 
            //
            // Make sure that the file object we are supplied has a
            // proper FsContext before we try doing a secured lock.
            //
 
            if (fileObject != NULL) {
                fsContext = ClassGetFsContext(commonExtension, fileObject);
            }
 
            if (fsContext == NULL) {
 
                //
                // This handle isn't setup correctly.  We can't let the
                // operation go.
                //
 
                status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
        }
 
        if (Lock) {
 
            //
            // This is a lock command.  Reissue the command in case bus or
            // device was reset and the lock was cleared.
            // note: may need to decrement count if actual lock operation
            //       failed....
            //
 
            switch (LockType) {
 
                case SimpleMediaLock: {
                    FdoExtension->LockCount++;
                    countChanged = TRUE;
                    break;
                }
 
                case SecureMediaLock: {
                    fsContext->LockCount++;
                    FdoExtension->ProtectedLockCount++;
                    countChanged = TRUE;
                    break;
                }
 
                case InternalMediaLock: {
                    FdoExtension->InternalLockCount++;
                    countChanged = TRUE;
                    break;
                }
            }
 
        } else {
 
            //
            // This is an unlock command.  If it's a secured one then make sure
            // the caller has a lock outstanding or return an error.
            // note: may need to re-increment the count if actual unlock
            //       operation fails....
            //
 
            switch (LockType) {
 
                case SimpleMediaLock: {
                    if(FdoExtension->LockCount != 0) {
                        FdoExtension->LockCount--;
                        countChanged = TRUE;
                    }
                    break;
                }
 
                case SecureMediaLock: {
                    if(fsContext->LockCount == 0) {
                        status = STATUS_INVALID_DEVICE_STATE;
                        _SEH2_LEAVE;
                    }
                    fsContext->LockCount--;
                    FdoExtension->ProtectedLockCount--;
                    countChanged = TRUE;
                    break;
                }
 
                case InternalMediaLock: {
                    NT_ASSERT(FdoExtension->InternalLockCount != 0);
                    FdoExtension->InternalLockCount--;
                    countChanged = TRUE;
                    break;
                }
            }
 
            //
            // We only send an unlock command to the drive if both the
            // secured and unsecured lock counts have dropped to zero.
            //
 
            if ((FdoExtension->ProtectedLockCount != 0) ||
                (FdoExtension->InternalLockCount != 0) ||
                (FdoExtension->LockCount != 0)) {
 
                status = STATUS_SUCCESS;
                _SEH2_LEAVE;
            }
        }
 
        status = STATUS_SUCCESS;
        if (TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)) {
 
            srb = (PSCSI_REQUEST_BLOCK)ClasspAllocateSrb(FdoExtension);
 
            if (srb == NULL) {
                status = STATUS_INSUFFICIENT_RESOURCES;
                _SEH2_LEAVE;
            }
 
            if (FdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
 
                //
                // NOTE - this is based on size used in ClasspAllocateSrb
                //
 
                status = InitializeStorageRequestBlock((PSTORAGE_REQUEST_BLOCK)srb,
                                                       STORAGE_ADDRESS_TYPE_BTL8,
                                                       CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE,
                                                       1,
                                                       SrbExDataTypeScsiCdb16);
                if (!NT_SUCCESS(status)) {
                    NT_ASSERT(FALSE);
                    _SEH2_LEAVE;
                }
 
            } else {
                RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
            }
 
            SrbSetCdbLength(srb, 6);
            cdb = SrbGetCdb(srb);
            NT_ASSERT(cdb != NULL);
 
            cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;
 
            //
            // TRUE - prevent media removal.
            // FALSE - allow media removal.
            //
 
            cdb->MEDIA_REMOVAL.Prevent = Lock;
 
            //
            // Set timeout value.
            //
 
            SrbSetTimeOutValue(srb, FdoExtension->TimeOutValue);
 
            //
            // The actual lock operation on the device isn't so important
            // as the internal lock counts.  Ignore failures.
            //
 
            status = ClassSendSrbSynchronous(FdoExtension->DeviceObject,
                                             srb,
                                             NULL,
                                             0,
                                             FALSE);
        }
 
    } _SEH2_FINALLY {
 
        if (!NT_SUCCESS(status)) {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                        "ClasspEjectionControl: FAILED status %x -- "
                        "reverting lock counts\n", status));
 
            if (countChanged) {
 
                //
                // have to revert to previous counts if the
                // lock/unlock operation actually failed.
                //
 
                if (Lock) {
 
                    switch (LockType) {
 
                        case SimpleMediaLock: {
                            FdoExtension->LockCount--;
                            break;
                        }
 
                        case SecureMediaLock: {
                            fsContext->LockCount--;
                            FdoExtension->ProtectedLockCount--;
                            break;
                        }
 
                        case InternalMediaLock: {
                            FdoExtension->InternalLockCount--;
                            break;
                        }
                    }
 
                } else {
 
                    switch (LockType) {
 
                        case SimpleMediaLock: {
                            FdoExtension->LockCount++;
                            break;
                        }
 
                        case SecureMediaLock: {
                            fsContext->LockCount++;
                            FdoExtension->ProtectedLockCount++;
                            break;
                        }
 
                        case InternalMediaLock: {
                            FdoExtension->InternalLockCount++;
                            break;
                        }
                    }
                }
 
            }
 
        } else {
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                        "ClasspEjectionControl: Succeeded\n"));
 
        }
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "ClasspEjectionControl: "
                    "Current Counts: Internal: %x  Secure: %x  Simple: %x\n",
                    FdoExtension->InternalLockCount,
                    FdoExtension->ProtectedLockCount,
                    FdoExtension->LockCount
                    ));
 
        KeSetEvent(&(FdoExtension->EjectSynchronizationEvent),
                   IO_NO_INCREMENT,
                   FALSE);
        KeLeaveCriticalRegion();
 
        if (srb) {
            ClassFreeOrReuseSrb(FdoExtension, srb);
        }
 
    } _SEH2_END;
    return status;
}

Referenced by ClassDeviceControl(), and ClassDispatchPnp().

◆ ClasspEnableIdlePower()

_IRQL_requires_same_ NTSTATUS ClasspEnableIdlePower ( _In_ PDEVICE_OBJECT DeviceObject )

Definition at line 2550 of file power.c.

{
    NTSTATUS status = STATUS_SUCCESS;
    ULONG d3ColdDisabledByUser = FALSE;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ULONG idleTimeoutOverrideInSeconds = 0;
 
    //
    // This function should only be called once.
    //
    NT_ASSERT(fdoExtension->FunctionSupportInfo->IdlePower.IdlePowerEnabled == FALSE);
 
    ClassGetDeviceParameter(fdoExtension,
                        CLASSP_REG_SUBKEY_NAME,
                        CLASSP_REG_DISABLE_D3COLD,
                        &d3ColdDisabledByUser);
 
    //
    // If the device is hot-pluggable or the user has explicitly
    // disabled D3Cold, do not enable D3Cold for this device.
    //
    if (d3ColdDisabledByUser || fdoExtension->PrivateFdoData->HotplugInfo.DeviceHotplug) {
        fdoExtension->FunctionSupportInfo->IdlePower.D3ColdSupported = 0;
    }
 
    ClassGetDeviceParameter(fdoExtension,
                            CLASSP_REG_SUBKEY_NAME,
                            CLASSP_REG_IDLE_TIMEOUT_IN_SECONDS,
                            &idleTimeoutOverrideInSeconds);
 
    //
    // Set the idle timeout.  If the user has not specified an override value,
    // this will either be a default value or will have been updated by the
    // power setting notification callback.
    //
    if (idleTimeoutOverrideInSeconds != 0) {
        fdoExtension->FunctionSupportInfo->IdlePower.D3IdleTimeout = (idleTimeoutOverrideInSeconds * 1000);
        fdoExtension->FunctionSupportInfo->IdlePower.D3IdleTimeoutOverridden = TRUE;
    } else {
        fdoExtension->FunctionSupportInfo->IdlePower.D3IdleTimeout = DiskIdleTimeoutInMS;
    }
 
    //
    // We don't allow disks to be wakeable.
    //
    fdoExtension->FunctionSupportInfo->IdlePower.DeviceWakeable = FALSE;
 
    //
    // Send IOCTL_STORAGE_ENABLE_IDLE_POWER to the port driver to enable idle
    // power management by the port driver.
    //
    status = ClasspSendEnableIdlePowerIoctl(DeviceObject);
 
    if (NT_SUCCESS(status)) {
        PIDLE_POWER_FDO_LIST_ENTRY fdoEntry = NULL;
 
        //
        // Put this FDO on the list of devices that are idle power managed.
        //
        fdoEntry = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(IDLE_POWER_FDO_LIST_ENTRY), CLASS_TAG_POWER);
        if (fdoEntry) {
 
            fdoExtension->FunctionSupportInfo->IdlePower.IdlePowerEnabled = TRUE;
 
            fdoEntry->Fdo = DeviceObject;
 
            KeAcquireGuardedMutex(&IdlePowerFDOListMutex);
            InsertHeadList(&IdlePowerFDOList, &(fdoEntry->ListEntry));
            KeReleaseGuardedMutex(&IdlePowerFDOListMutex);
 
            //
            // If not registered already, register for disk idle timeout power
            // setting notifications.  The power manager will call our power
            // setting callback very soon to set the idle timeout to the actual
            // value.
            //
            if (PowerSettingNotificationHandle == NULL) {
                PoRegisterPowerSettingCallback(DeviceObject,
                                                &GUID_DISK_IDLE_TIMEOUT,
                                                &ClasspPowerSettingCallback,
                                                NULL,
                                                &(PowerSettingNotificationHandle));
            }
        } else {
            fdoExtension->FunctionSupportInfo->IdlePower.IdlePowerEnabled = FALSE;
            status = STATUS_UNSUCCESSFUL;
        }
    }
 
    return status;
}

◆ ClasspEnableTimer()

VOID ClasspEnableTimer ( _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 3857 of file autorun.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = NULL;
 
    if (FdoExtension->CommonExtension.IsFdo) {
        fdoData = FdoExtension->PrivateFdoData;
    }
 
    if (fdoData != NULL) {
        //
        // The timer should have already been initialized, but if that's not
        // the case it's not the end of the world.  We can attempt to
        // initialize it now.
        //
        NT_ASSERT(fdoData->TimerInitialized);
        if (fdoData->TimerInitialized == FALSE) {
            NTSTATUS status;
            status = ClasspInitializeTimer(FdoExtension);
            if (NT_SUCCESS(status) == FALSE) {
                return;
            }
        }
 
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
        if (fdoData->TickTimer != NULL) {
            EXT_SET_PARAMETERS parameters;
            LONGLONG period = TICK_TIMER_PERIOD_IN_MSEC * (10 * 1000); // Convert to units of 100ns.
            LONGLONG dueTime = period * (-1); // Negative sign indicates dueTime is relative.
 
            ExInitializeSetTimerParameters(&parameters);
 
            //
            // Set the no-wake tolerance to "unlimited" if the conditions below
            // are met.  An "unlimited" no-wake tolerance means that the timer
            // will *never* wake the processor if the processor is in a
            // low-power state.
            //  1. The screen is off.
            //  2. The class driver is *not* a consumer of the tick timer (ClassTick is NULL).
            //  3. This is a disk device.
            // Otherwise the tolerance is set to the normal tolerable delay.
            //
            if (ClasspScreenOff &&
                FdoExtension->CommonExtension.DriverExtension->InitData.ClassTick == NULL &&
                FdoExtension->DeviceObject->DeviceType == FILE_DEVICE_DISK) {
                parameters.NoWakeTolerance = EX_TIMER_UNLIMITED_TOLERANCE;
            } else {
                parameters.NoWakeTolerance = TICK_TIMER_DELAY_IN_MSEC * (10 * 1000);
            }
 
            fdoData->CurrentNoWakeTolerance = parameters.NoWakeTolerance;
 
            ExSetTimer(fdoData->TickTimer,
                       dueTime,
                       period,
                       &parameters);
 
            fdoData->TickTimerEnabled = TRUE;
        } else {
            NT_ASSERT(fdoData->TickTimer != NULL);
        }
#else
        //
        // Start the periodic tick timer using a coalescable timer with some delay
        //
        {
            LARGE_INTEGER timeout;
            timeout.QuadPart = TICK_TIMER_PERIOD_IN_MSEC * (10 * 1000) * (-1);
            KeSetCoalescableTimer(&fdoData->TickTimer,
                                  timeout, TICK_TIMER_PERIOD_IN_MSEC, TICK_TIMER_DELAY_IN_MSEC,
                                  &fdoData->TickTimerDpc);
            fdoData->TickTimerEnabled = TRUE;
        }
#endif
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,  "ClasspEnableTimer: Periodic tick timer enabled "
                    "for device %p\n", FdoExtension->DeviceObject));
 
    }
 
} // end ClasspEnableTimer()

Referenced by ClasspDeviceLockFailurePowerIrpCompletion(), and ClasspPowerUpCompletion().

◆ ClasspEnqueueIdleRequest()

NTSTATUS ClasspEnqueueIdleRequest	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 576 of file clntirp.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    KIRQL oldIrql;
    BOOLEAN issueRequest = TRUE;
    LARGE_INTEGER currentTime;
    LARGE_INTEGER* pCurrentTime;
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_TIMER, "ClasspEnqueueIdleRequest: Queue idle request %p\n", Irp));
 
    IoMarkIrpPending(Irp);
 
    //
    // Reset issueRequest if the idle duration is not sufficient.
    //
    pCurrentTime = &currentTime;
    if (ClasspIdleDurationSufficient(fdoData, &pCurrentTime) == FALSE) {
        issueRequest = FALSE;
    }
 
    //
    // If there are already max active idle requests in the port driver, then
    // queue this idle request.
    //
    if (fdoData->ActiveIdleIoCount >= fdoData->IdleActiveIoMax) {
        issueRequest = FALSE;
    }
 
 
    KeAcquireSpinLock(&fdoData->IdleListLock, &oldIrql);
    if (IsListEmpty(&fdoData->IdleIrpList)) {
        NT_ASSERT(fdoData->IdleIoCount == 0);
    }
    InsertTailList(&fdoData->IdleIrpList, &Irp->Tail.Overlay.ListEntry);
 
 
    fdoData->IdleIoCount++;
    if (!fdoData->IdleTimerStarted) {
        ClasspStartIdleTimer(fdoData);
    }
 
    if (fdoData->IdleIoCount != 1) {
        issueRequest = FALSE;
    }
 
 
    KeReleaseSpinLock(&fdoData->IdleListLock, oldIrql);
 
    if (issueRequest) {
        ClasspServiceIdleRequest(fdoExtension, FALSE);
    }
 
    return STATUS_PENDING;
}

Referenced by ClassReadWrite().

◆ ClasspFailurePredictionPeriodMissed()

BOOLEAN ClasspFailurePredictionPeriodMissed ( _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 4391 of file autorun.c.

{
    LARGE_INTEGER currentTime;
    LARGE_INTEGER timeDifference;
    BOOLEAN missedPeriod = FALSE;
 
    NT_ASSERT(FdoExtension);
    NT_ASSERT(FdoExtension->FailurePredictionInfo);
    NT_ASSERT(FdoExtension->FailurePredictionInfo->Method != FailurePredictionNone);
 
    //
    // Find the difference between the last failure prediction
    // query and the current time and convert it to seconds.
    //
    KeQuerySystemTime(&currentTime);
    timeDifference.QuadPart = currentTime.QuadPart - FdoExtension->FailurePredictionInfo->LastFailurePredictionQueryTime.QuadPart;
    timeDifference.QuadPart /= (10LL * 1000LL * 1000LL);
 
    if (timeDifference.QuadPart >= FdoExtension->FailurePredictionInfo->Period) {
        missedPeriod = TRUE;
    }
 
    return missedPeriod;
}

Referenced by _Function_class_(), ClasspDeviceLockFailurePowerIrpCompletion(), and ClasspPowerUpCompletion().

◆ ClasspFreeDeviceMdl()

VOID ClasspFreeDeviceMdl ( PMDL Mdl )

Definition at line 615 of file utils.c.

{
    MmUnlockPages(Mdl);
    IoFreeMdl(Mdl);
}

Referenced by ClasspCleanupOffloadReadContext(), ClasspCleanupOffloadWriteContext(), and FreeDeviceInputMdl().

◆ ClasspFreeReleaseRequest()

VOID ClasspFreeReleaseRequest ( IN PDEVICE_OBJECT Fdo )

Definition at line 11525 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
 
    PAGED_CODE();
 
    //KIRQL oldIrql;
 
    NT_ASSERT(fdoExtension->CommonExtension.IsRemoved != NO_REMOVE);
 
    //
    // free anything the driver allocated
    //
 
    if (fdoExtension->ReleaseQueueIrp) {
        if (fdoExtension->ReleaseQueueIrpFromPool) {
            FREE_POOL(fdoExtension->ReleaseQueueIrp);
        } else {
            IoFreeIrp(fdoExtension->ReleaseQueueIrp);
        }
        fdoExtension->ReleaseQueueIrp = NULL;
    }
 
    //
    // free anything that we allocated
    //
 
    if ((fdoExtension->PrivateFdoData) &&
        (fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated)) {
 
        FREE_POOL(fdoExtension->PrivateFdoData->ReleaseQueueIrp);
        fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated = FALSE;
    }
 
    return;
} // end ClasspFreeReleaseRequest()

◆ ClasspGetBlockDeviceTokenLimitsInfo()

_IRQL_requires_same_ NTSTATUS ClasspGetBlockDeviceTokenLimitsInfo ( _Inout_ PDEVICE_OBJECT DeviceObject )

Definition at line 13220 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    NTSTATUS status;
    PSCSI_REQUEST_BLOCK srb = NULL;
    ULONG srbSize = 0;
    USHORT pageLength = 0;
    USHORT descriptorLength = 0;
    PVOID dataBuffer = NULL;
    UCHAR bufferLength = VPD_MAX_BUFFER_SIZE;
    ULONG allocationBufferLength = bufferLength;
    PCDB cdb;
    ULONG dataTransferLength = 0;
    PVPD_THIRD_PARTY_COPY_PAGE operatingParameters = NULL;
    PWINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR blockDeviceTokenLimits = NULL;
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClasspGetBlockDeviceTokenLimitsInfo (%p): Entering function.\n",
                DeviceObject));
 
    //
    // Allocate an SRB for querying the device for LBP-related info.
    //
    if ((fdoExtension->AdapterDescriptor != NULL) &&
        (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK)) {
        srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
    } else {
        srbSize = sizeof(SCSI_REQUEST_BLOCK);
    }
 
    srb = ExAllocatePoolWithTag(NonPagedPoolNx, srbSize, CLASSPNP_POOL_TAG_SRB);
 
    if (!srb) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_PNP,
                    "ClasspGetBlockDeviceTokenLimitsInfo (%p): Couldn't allocate SRB.\n",
                    DeviceObject));
 
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto __ClasspGetBlockDeviceTokenLimitsInfo_Exit;
    }
 
#if defined(_ARM_) || defined(_ARM64_)
    //
    // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
    // based platforms. We are taking the conservative approach here.
    //
    allocationBufferLength = ALIGN_UP_BY(allocationBufferLength, KeGetRecommendedSharedDataAlignment());
    dataBuffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, allocationBufferLength, CLASSPNP_POOL_TAG_VPD);
#else
    dataBuffer = ExAllocatePoolWithTag(NonPagedPoolNx, bufferLength, CLASSPNP_POOL_TAG_VPD);
#endif
 
    if (!dataBuffer) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_PNP,
                    "ClasspGetBlockDeviceTokenLimitsInfo (%p): Couldn't allocate dataBuffer.\n",
                    DeviceObject));
 
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto __ClasspGetBlockDeviceTokenLimitsInfo_Exit;
    }
 
    operatingParameters = (PVPD_THIRD_PARTY_COPY_PAGE)dataBuffer;
 
    RtlZeroMemory(dataBuffer, allocationBufferLength);
 
    if ((fdoExtension->AdapterDescriptor != NULL) &&
        (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK)) {
        status = InitializeStorageRequestBlock((PSTORAGE_REQUEST_BLOCK)srb,
                                               STORAGE_ADDRESS_TYPE_BTL8,
                                               CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE,
                                               1,
                                               SrbExDataTypeScsiCdb16);
        if (NT_SUCCESS(status)) {
 
            ((PSTORAGE_REQUEST_BLOCK)srb)->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
 
        } else {
 
            //
            // Should not occur. Revert to legacy SRB.
            //
            NT_ASSERT(FALSE);
 
            TracePrint((TRACE_LEVEL_WARNING,
                        TRACE_FLAG_PNP,
                        "ClasspGetBlockDeviceTokenLimitsInfo (%p): Falling back to using SRB (instead of SRB_EX).\n",
                        DeviceObject));
 
            RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
            srb->Length = sizeof(SCSI_REQUEST_BLOCK);
            srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
        }
    } else {
 
        RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
        srb->Length = sizeof(SCSI_REQUEST_BLOCK);
        srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    }
 
    SrbSetTimeOutValue(srb, fdoExtension->TimeOutValue);
    SrbSetRequestTag(srb, SP_UNTAGGED);
    SrbSetRequestAttribute(srb, SRB_SIMPLE_TAG_REQUEST);
    SrbAssignSrbFlags(srb, fdoExtension->SrbFlags);
 
    SrbSetCdbLength(srb, 6);
 
    cdb = SrbGetCdb(srb);
    cdb->CDB6INQUIRY3.OperationCode = SCSIOP_INQUIRY;
    cdb->CDB6INQUIRY3.EnableVitalProductData = 1;
    cdb->CDB6INQUIRY3.PageCode = VPD_THIRD_PARTY_COPY;
    cdb->CDB6INQUIRY3.AllocationLength = bufferLength;
 
    status = ClassSendSrbSynchronous(fdoExtension->DeviceObject,
                                     srb,
                                     dataBuffer,
                                     allocationBufferLength,
                                     FALSE);
 
    //
    // Handle the case where we get back STATUS_DATA_OVERRUN because the input
    // buffer was larger than necessary.
    //
    dataTransferLength = SrbGetDataTransferLength(srb);
 
    if (status == STATUS_DATA_OVERRUN && dataTransferLength < bufferLength) {
 
        status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(status)) {
 
        REVERSE_BYTES_SHORT(&pageLength, &operatingParameters->PageLength);
 
    } else {
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_PNP,
                    "ClasspGetBlockDeviceTokenLimitsInfo (%p): Inquiry for TPC VPD failed with %x.\n",
                    DeviceObject,
                    status));
    }
 
    if ((NT_SUCCESS(status)) &&
        (pageLength >= sizeof(WINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR))) {
 
        USHORT descriptorType;
 
        blockDeviceTokenLimits = (PWINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR)operatingParameters->ThirdPartyCopyDescriptors;
        REVERSE_BYTES_SHORT(&descriptorType, &blockDeviceTokenLimits->DescriptorType);
        REVERSE_BYTES_SHORT(&descriptorLength, &blockDeviceTokenLimits->DescriptorLength);
 
        if ((descriptorType == BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR_TYPE_WINDOWS) &&
            (VPD_PAGE_HEADER_SIZE + descriptorLength == sizeof(WINDOWS_BLOCK_DEVICE_TOKEN_LIMITS_DESCRIPTOR))) {
 
            fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits = TRUE;
 
            REVERSE_BYTES_SHORT(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumRangeDescriptors, &blockDeviceTokenLimits->MaximumRangeDescriptors);
            REVERSE_BYTES(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumInactivityTimer, &blockDeviceTokenLimits->MaximumInactivityTimer);
            REVERSE_BYTES(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.DefaultInactivityTimer, &blockDeviceTokenLimits->DefaultInactivityTimer);
            REVERSE_BYTES_QUAD(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumTokenTransferSize, &blockDeviceTokenLimits->MaximumTokenTransferSize);
            REVERSE_BYTES_QUAD(&fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.OptimalTransferCount, &blockDeviceTokenLimits->OptimalTransferCount);
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_PNP,
                        "ClasspGetBlockDeviceTokenLimitsInfo (%p): %s %s (rev %s) reported following parameters: \
                        \n\t\t\tMaxRangeDescriptors: %u\n\t\t\tMaxIAT: %u\n\t\t\tDefaultIAT: %u \
                        \n\t\t\tMaxTokenTransferSize: %I64u\n\t\t\tOptimalTransferCount: %I64u\n\t\t\tOptimalTransferLengthGranularity: %u \
                        \n\t\t\tOptimalTransferLength: %u\n\t\t\tMaxTransferLength: %u\n",
                        DeviceObject,
                        (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->VendorIdOffset),
                        (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->ProductIdOffset),
                        (PCSZ)(((PUCHAR)fdoExtension->DeviceDescriptor) + fdoExtension->DeviceDescriptor->ProductRevisionOffset),
                        fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumRangeDescriptors,
                        fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumInactivityTimer,
                        fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.DefaultInactivityTimer,
                        fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumTokenTransferSize,
                        fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.OptimalTransferCount,
                        fdoExtension->FunctionSupportInfo->BlockLimitsData.OptimalTransferLengthGranularity,
                        fdoExtension->FunctionSupportInfo->BlockLimitsData.OptimalTransferLength,
                        fdoExtension->FunctionSupportInfo->BlockLimitsData.MaximumTransferLength));
        } else {
 
            TracePrint((TRACE_LEVEL_WARNING,
                        TRACE_FLAG_PNP,
                        "ClasspGetBlockDeviceTokenLimitsInfo (%p): ThirdPartyCopy VPD data doesn't have Windows OffloadDataTransfer descriptor.\n",
                        DeviceObject));
 
            fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits = FALSE;
            status = STATUS_DEVICE_FEATURE_NOT_SUPPORTED;
        }
    } else {
 
        TracePrint((TRACE_LEVEL_WARNING,
                    TRACE_FLAG_PNP,
                    "ClasspGetBlockDeviceTokenLimitsInfo (%p): TPC VPD data didn't return TPC descriptors of interest.\n",
                    DeviceObject));
 
        fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits = FALSE;
        status = STATUS_DEVICE_FEATURE_NOT_SUPPORTED;
    }
 
__ClasspGetBlockDeviceTokenLimitsInfo_Exit:
 
    FREE_POOL(dataBuffer);
    FREE_POOL(srb);
    fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus = status;
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_PNP,
                "ClasspGetBlockDeviceTokenLimitsInfo (%p): Exiting function with status %x.\n",
                DeviceObject,
                status));
 
    return status;
}

Referenced by _IRQL_requires_().

◆ ClasspGetCurrentTime()

FORCEINLINE LARGE_INTEGER ClasspGetCurrentTime ( VOID )

Definition at line 1280 of file classp.h.

{
    LARGE_INTEGER currentTime;
 
#ifndef __REACTOS__
    currentTime.QuadPart = KeQueryUnbiasedInterruptTimePrecise((ULONG64*)&currentTime.QuadPart);
#else
    currentTime = KeQueryPerformanceCounter(NULL);
#endif
 
    return currentTime;
}

Referenced by ClasspIdleDurationSufficient(), ClasspIdleTimerDpc(), ClasspStartIdleTimer(), ClassReadWrite(), and TransferPktComplete().

◆ ClasspGetInquiryVpdSupportInfo()

VOID ClasspGetInquiryVpdSupportInfo ( _Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 12914 of file class.c.

{
    NTSTATUS                  status;
    PCOMMON_DEVICE_EXTENSION  commonExtension = (PCOMMON_DEVICE_EXTENSION)FdoExtension;
    SCSI_REQUEST_BLOCK        srb = {0};
    PCDB                      cdb;
    PVPD_SUPPORTED_PAGES_PAGE supportedPages = NULL;
    UCHAR                     bufferLength = VPD_MAX_BUFFER_SIZE;
    ULONG                     allocationBufferLength = bufferLength;
    UCHAR srbExBuffer[CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE] = {0};
    PSTORAGE_REQUEST_BLOCK_HEADER srbHeader;
 
#if defined(_ARM_) || defined(_ARM64_)
    //
    // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
    // based platforms. We are taking the conservative approach here.
    //
    allocationBufferLength = ALIGN_UP_BY(allocationBufferLength,KeGetRecommendedSharedDataAlignment());
    supportedPages = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                           allocationBufferLength,
                                           '3CcS'
                                           );
 
#else
    supportedPages = ExAllocatePoolWithTag(NonPagedPoolNx,
                                           bufferLength,
                                           '3CcS'
                                           );
#endif
 
    if (supportedPages == NULL) {
        // memory allocation failure.
        return;
    }
 
    RtlZeroMemory(supportedPages, allocationBufferLength);
 
    // prepare the Srb
    if (FdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
 
#ifdef _MSC_VER
        #pragma prefast(suppress:26015, "InitializeStorageRequestBlock ensures buffer access is bounded")
#endif
        status = InitializeStorageRequestBlock((PSTORAGE_REQUEST_BLOCK)srbExBuffer,
                                               STORAGE_ADDRESS_TYPE_BTL8,
                                               sizeof(srbExBuffer),
                                               1,
                                               SrbExDataTypeScsiCdb16);
 
        if (!NT_SUCCESS(status)) {
            //
            // Should not happen. Revert to legacy SRB.
            NT_ASSERT(FALSE);
            srb.Length = SCSI_REQUEST_BLOCK_SIZE;
            srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
            srbHeader = (PSTORAGE_REQUEST_BLOCK_HEADER)&srb;
        } else {
            ((PSTORAGE_REQUEST_BLOCK)srbExBuffer)->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
            srbHeader = (PSTORAGE_REQUEST_BLOCK_HEADER)srbExBuffer;
        }
 
    } else {
        srb.Length = SCSI_REQUEST_BLOCK_SIZE;
        srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
        srbHeader = (PSTORAGE_REQUEST_BLOCK_HEADER)&srb;
    }
 
    SrbSetTimeOutValue(srbHeader, FdoExtension->TimeOutValue);
    SrbSetRequestTag(srbHeader, SP_UNTAGGED);
    SrbSetRequestAttribute(srbHeader, SRB_SIMPLE_TAG_REQUEST);
    SrbAssignSrbFlags(srbHeader, FdoExtension->SrbFlags);
    SrbSetCdbLength(srbHeader, 6);
 
    cdb = SrbGetCdb(srbHeader);
    cdb->CDB6INQUIRY3.OperationCode = SCSIOP_INQUIRY;
    cdb->CDB6INQUIRY3.EnableVitalProductData = 1;       //EVPD bit
    cdb->CDB6INQUIRY3.PageCode = VPD_SUPPORTED_PAGES;
    cdb->CDB6INQUIRY3.AllocationLength = bufferLength;  //AllocationLength field in CDB6INQUIRY3 is only one byte.
 
    status = ClassSendSrbSynchronous(commonExtension->DeviceObject,
                                     (PSCSI_REQUEST_BLOCK)srbHeader,
                                     supportedPages,
                                     allocationBufferLength,
                                     FALSE);
 
    //
    // Handle the case where we get back STATUS_DATA_OVERRUN b/c the input
    // buffer was larger than necessary.
    //
    if (status == STATUS_DATA_OVERRUN && SrbGetDataTransferLength(srbHeader) < bufferLength)
    {
        status = STATUS_SUCCESS;
    }
 
    if ( NT_SUCCESS(status) &&
         (supportedPages->PageLength > 0) &&
         (supportedPages->SupportedPageList[0] > 0) ) {
        // ataport treats all INQUIRY command as standard INQUIRY command, thus fills invalid info
        // If VPD INQUIRY is supported, the first page reported (additional length field for standard INQUIRY data) should be '00'
        status = STATUS_NOT_SUPPORTED;
    }
 
    if (NT_SUCCESS(status)) {
        int i;
 
        for (i = 0; i < supportedPages->PageLength; i++) {
            if ( (i > 0) && (supportedPages->SupportedPageList[i] <= supportedPages->SupportedPageList[i - 1]) ) {
                // shall be in ascending order beginning with page code 00h.
                FdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits = FALSE;
                FdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockLimits = FALSE;
                FdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceCharacteristics = FALSE;
                FdoExtension->FunctionSupportInfo->ValidInquiryPages.LBProvisioning = FALSE;
 
 
                break;
            }
            switch (supportedPages->SupportedPageList[i]) {
                case VPD_THIRD_PARTY_COPY:
                    FdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits = TRUE;
                    break;
 
                case VPD_BLOCK_LIMITS:
                    FdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockLimits = TRUE;
                    break;
 
                case VPD_BLOCK_DEVICE_CHARACTERISTICS:
                    FdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceCharacteristics = TRUE;
                    break;
 
                case VPD_LOGICAL_BLOCK_PROVISIONING:
                    FdoExtension->FunctionSupportInfo->ValidInquiryPages.LBProvisioning = TRUE;
                    break;
 
            }
        }
    }
 
    ExFreePool(supportedPages);
 
    return;
}

◆ ClasspGetLBProvisioningInfo()

NTSTATUS ClasspGetLBProvisioningInfo ( _Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 13087 of file class.c.

{
    PSCSI_REQUEST_BLOCK srb = NULL;
    ULONG               srbSize = 0;
 
    //
    // Make sure we actually have data structures to work with.
    //
    if (FdoExtension == NULL ||
        FdoExtension->FunctionSupportInfo == NULL) {
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // Allocate an SRB for querying the device for LBP-related info if either
    // the Logical Block Provisioning (0xB2) or Block Limits (0xB0) VPD page
    // exists.
    //
    if ((FdoExtension->FunctionSupportInfo->ValidInquiryPages.LBProvisioning == TRUE) ||
        (FdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockLimits == TRUE)) {
 
        if ((FdoExtension->AdapterDescriptor != NULL) &&
            (FdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK)) {
            srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
        } else {
            srbSize = sizeof(SCSI_REQUEST_BLOCK);
        }
 
        srb = ExAllocatePoolWithTag(NonPagedPoolNx, srbSize, '0DcS');
 
        if (srb == NULL) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    //
    // Get the Logical Block Provisioning VPD page (0xB2).  This function will
    // set some default values if the LBP VPD page is not supported.
    //
    ClasspDeviceGetLBProvisioningVPDPage(FdoExtension->DeviceObject, srb);
 
 
    //
    // Get the Block Limits VPD page (0xB0), which may override the default
    // UNMAP parameter values set above.
    //
    ClasspDeviceGetBlockLimitsVPDPage(FdoExtension,
                                      srb,
                                      srbSize,
                                      &FdoExtension->FunctionSupportInfo->BlockLimitsData);
 
    FREE_POOL(srb);
 
    return STATUS_SUCCESS;
}

◆ ClasspGetMaxUsableBufferLengthFromOffset()

FORCEINLINE ULONG ClasspGetMaxUsableBufferLengthFromOffset	(	_In_ PVOID	BaseAddress,
		_In_ ULONG	OffsetInBytes,
		_In_ ULONG	BaseStructureSizeInBytes
	)

Definition at line 2585 of file classp.h.

{
 
    ULONG_PTR offsetAddress = ((ULONG_PTR)BaseAddress + OffsetInBytes);
 
    if (offsetAddress < (ULONG_PTR)BaseAddress) {
        //
        // This means BaseAddress + OffsetInBytes > ULONG_PTR_MAX.
        //
        return 0;
    }
 
    if (OffsetInBytes > BaseStructureSizeInBytes) {
        return 0;
    }
 
    return BaseStructureSizeInBytes - OffsetInBytes;
}

◆ ClasspGetTokenOperationCommandBufferLength()

_IRQL_requires_same_ NTSTATUS ClasspGetTokenOperationCommandBufferLength	(	_In_ PDEVICE_OBJECT	Fdo,
		_In_ ULONG	ServiceAction,
		_Inout_ PULONG	CommandBufferLength,
		_Out_opt_ PULONG	TokenOperationBufferLength,
		_Out_opt_ PULONG	ReceiveTokenInformationBufferLength
	)

Definition at line 7356 of file utils.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    ULONG tokenOperationBufferLength;
    ULONG receiveTokenInformationBufferLength;
    PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
    PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExtension->PartitionZeroExtension->AdapterDescriptor;
    ULONG hwMaxXferLen;
    ULONG bufferLength = 0;
    ULONG tokenOperationHeaderSize;
    ULONG responseSize;
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspGetTokenOperationCommandBufferLengths (%p): Entering function.\n",
                Fdo));
 
    NT_ASSERT(fdoExt->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits &&
              NT_SUCCESS(fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus));
 
    if (ServiceAction == SERVICE_ACTION_POPULATE_TOKEN) {
        tokenOperationHeaderSize = FIELD_OFFSET(POPULATE_TOKEN_HEADER, BlockDeviceRangeDescriptor);
        responseSize = FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER, TokenDescriptor) + sizeof(BLOCK_DEVICE_TOKEN_DESCRIPTOR);
    } else {
        tokenOperationHeaderSize = FIELD_OFFSET(WRITE_USING_TOKEN_HEADER, BlockDeviceRangeDescriptor);
        responseSize = 0;
    }
 
    //
    // The TokenOperation command can specify a parameter length of max 2^16.
    // If the device has a max limit on the number of range descriptors that can be specified in
    // the TokenOperation command, we are limited to the lesser of these two values.
    //
    if (fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumRangeDescriptors == 0) {
 
        tokenOperationBufferLength = MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH;
 
    } else {
 
        tokenOperationBufferLength = MIN(tokenOperationHeaderSize + fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumRangeDescriptors * sizeof(BLOCK_DEVICE_RANGE_DESCRIPTOR),
                                         MAX_TOKEN_OPERATION_PARAMETER_DATA_LENGTH);
    }
 
 
    //
    // The ReceiveTokenInformation command can specify a parameter length of max 2 ^ 32
    // Also, since the sense data can be of variable size, we'll use MAX_SENSE_BUFFER_SIZE.
    //
    receiveTokenInformationBufferLength = MIN(FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData) + MAX_SENSE_BUFFER_SIZE + responseSize,
                                              MAX_RECEIVE_TOKEN_INFORMATION_PARAMETER_DATA_LENGTH);
 
    //
    // Since we're going to reuse the buffer for both the TokenOperation and the ReceiveTokenInformation
    // commands, the buffer length needs to handle both operations.
    //
    bufferLength = MAX(tokenOperationBufferLength, receiveTokenInformationBufferLength);
 
    //
    // The buffer length needs to be further limited to the adapter's capability though.
    //
    hwMaxXferLen = MIN(fdoData->HwMaxXferLen, adapterDesc->MaximumTransferLength);
    bufferLength = MIN(bufferLength, hwMaxXferLen);
 
    *CommandBufferLength = bufferLength;
 
    if (TokenOperationBufferLength) {
        *TokenOperationBufferLength = tokenOperationBufferLength;
    }
 
    if (ReceiveTokenInformationBufferLength) {
        *ReceiveTokenInformationBufferLength = receiveTokenInformationBufferLength;
    }
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspGetTokenOperationCommandBufferLengths (%p): Exiting function with bufferLength %u (tokenOpBufLen %u, recTokenInfoBufLen %u).\n",
                Fdo,
                bufferLength,
                tokenOperationBufferLength,
                receiveTokenInformationBufferLength));
 
    return STATUS_SUCCESS;
}

◆ ClasspGetTokenOperationDescriptorLimits()

_IRQL_requires_same_ NTSTATUS ClasspGetTokenOperationDescriptorLimits	(	_In_ PDEVICE_OBJECT	Fdo,
		_In_ ULONG	ServiceAction,
		_In_ ULONG	MaxParameterBufferLength,
		_Out_ PULONG	MaxBlockDescriptorsCount,
		_Out_ PULONGLONG	MaxBlockDescriptorsLength
	)

Definition at line 7472 of file utils.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    ULONG tokenOperationHeaderSize = (ServiceAction == SERVICE_ACTION_POPULATE_TOKEN) ?
                                     FIELD_OFFSET(POPULATE_TOKEN_HEADER, BlockDeviceRangeDescriptor) :
                                     FIELD_OFFSET(WRITE_USING_TOKEN_HEADER, BlockDeviceRangeDescriptor);
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspGetTokenOperationDescriptorLimits (%p): Entering function.\n",
                Fdo));
 
    NT_ASSERT(fdoExt->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits &&
              NT_SUCCESS(fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus));
 
    *MaxBlockDescriptorsCount = (MaxParameterBufferLength - tokenOperationHeaderSize) / sizeof(BLOCK_DEVICE_RANGE_DESCRIPTOR);
    *MaxBlockDescriptorsLength = (fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumTokenTransferSize == 0) ?
                                  MAX_TOKEN_TRANSFER_SIZE : fdoExt->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumTokenTransferSize;
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspGetTokenOperationDescriptorLimits (%p): Exiting function with MaxDescr %u, MaxXferBlocks %I64u.\n",
                Fdo,
                *MaxBlockDescriptorsCount,
                *MaxBlockDescriptorsLength));
 
    return STATUS_SUCCESS;
}

◆ ClasspInitializeGesn()

NTSTATUS ClasspInitializeGesn	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN PMEDIA_CHANGE_DETECTION_INFO	Info
	)

Definition at line 1990 of file autorun.c.

{
    PNOTIFICATION_EVENT_STATUS_HEADER header;
    CLASS_DETECTION_STATE detectionState = ClassDetectionUnknown;
    PSTORAGE_DEVICE_DESCRIPTOR deviceDescriptor;
    NTSTATUS status = STATUS_NOT_SUPPORTED;
    PIRP irp;
    KEVENT event;
    BOOLEAN retryImmediately;
    ULONG i;
    ULONG atapiResets;
    ULONG srbFlags;
 
    PAGED_CODE();
    NT_ASSERT(Info == FdoExtension->MediaChangeDetectionInfo);
 
    //
    // read if we already know the abilities of the device
    //
 
    ClassGetDeviceParameter(FdoExtension,
                            CLASSP_REG_SUBKEY_NAME,
                            CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                            (PULONG)&detectionState);
 
    if (detectionState == ClassDetectionUnsupported) {
        goto ExitWithError;
    }
 
    //
    // check if the device has a hack flag saying never to try this.
    //
 
    if (TEST_FLAG(FdoExtension->PrivateFdoData->HackFlags,
                  FDO_HACK_GESN_IS_BAD)) {
 
        ClassSetDeviceParameter(FdoExtension,
                                CLASSP_REG_SUBKEY_NAME,
                                CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                                ClassDetectionUnsupported);
        goto ExitWithError;
 
    }
 
 
    //
    // else go through the process since we allocate buffers and
    // get all sorts of device settings.
    //
 
    if (Info->Gesn.Buffer == NULL) {
        Info->Gesn.Buffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                                  GESN_BUFFER_SIZE,
                                                  '??cS');
    }
    if (Info->Gesn.Buffer == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto ExitWithError;
    }
    if (Info->Gesn.Mdl != NULL) {
        IoFreeMdl(Info->Gesn.Mdl);
    }
    Info->Gesn.Mdl = IoAllocateMdl(Info->Gesn.Buffer,
                                   GESN_BUFFER_SIZE,
                                   FALSE, FALSE, NULL);
    if (Info->Gesn.Mdl == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto ExitWithError;
    }
 
    MmBuildMdlForNonPagedPool(Info->Gesn.Mdl);
    Info->Gesn.BufferSize = GESN_BUFFER_SIZE;
    Info->Gesn.EventMask = 0;
 
    //
    // all items are prepared to use GESN (except the event mask, so don't
    // optimize this part out!).
    //
    // now see if it really works. we have to loop through this because
    // many SAMSUNG (and one COMPAQ) drives timeout when requesting
    // NOT_READY events, even when the IMMEDIATE bit is set. :(
    //
    // using a drive list is cumbersome, so this might fix the problem.
    //
 
    deviceDescriptor = FdoExtension->DeviceDescriptor;
    atapiResets = 0;
    retryImmediately = TRUE;
    for (i = 0; i < 16 && retryImmediately == TRUE; i++) {
 
        irp = ClasspPrepareMcnIrp(FdoExtension, Info, TRUE);
        if (irp == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto ExitWithError;
        }
 
        if (Info->MediaChangeSrb.Srb.Function == SRB_FUNCTION_STORAGE_REQUEST_BLOCK) {
            srbFlags = Info->MediaChangeSrb.SrbEx.SrbFlags;
        } else {
            srbFlags = Info->MediaChangeSrb.Srb.SrbFlags;
        }
        NT_ASSERT(TEST_FLAG(srbFlags, SRB_FLAGS_NO_QUEUE_FREEZE));
 
        //
        // replace the completion routine with a different one this time...
        //
 
        KeInitializeEvent(&event, SynchronizationEvent, FALSE);
        IoSetCompletionRoutine(irp,
                               ClassSignalCompletion,
                               &event,
                               TRUE, TRUE, TRUE);
 
        status = IoCallDriver(FdoExtension->CommonExtension.LowerDeviceObject, irp);
 
        if (status == STATUS_PENDING) {
            status = KeWaitForSingleObject(&event,
                                           Executive,
                                           KernelMode,
                                           FALSE,
                                           NULL);
            NT_ASSERT(NT_SUCCESS(status));
        }
        ClassReleaseRemoveLock(FdoExtension->DeviceObject, irp);
 
        if (SRB_STATUS(Info->MediaChangeSrb.Srb.SrbStatus) != SRB_STATUS_SUCCESS) {
 
            InterpretSenseInfoWithoutHistory(FdoExtension->DeviceObject,
                                             irp,
                                             &(Info->MediaChangeSrb.Srb),
                                             IRP_MJ_SCSI,
                                             0,
                                             0,
                                             &status,
                                             NULL);
        }
 
        if ((deviceDescriptor->BusType == BusTypeAtapi) &&
            (Info->MediaChangeSrb.Srb.SrbStatus == SRB_STATUS_BUS_RESET)
            ) {
 
            //
            // ATAPI unfortunately returns SRB_STATUS_BUS_RESET instead
            // of SRB_STATUS_TIMEOUT, so we cannot differentiate between
            // the two.  if we get this status four time consecutively,
            // stop trying this command.  it is too late to change ATAPI
            // at this point, so special-case this here. (07/10/2001)
            // NOTE: any value more than 4 may cause the device to be
            //       marked missing.
            //
 
            atapiResets++;
            if (atapiResets >= 4) {
                status = STATUS_IO_DEVICE_ERROR;
                goto ExitWithError;
            }
        }
 
        if (status == STATUS_DATA_OVERRUN) {
            status = STATUS_SUCCESS;
        }
 
        if ((status == STATUS_INVALID_DEVICE_REQUEST) ||
            (status == STATUS_TIMEOUT) ||
            (status == STATUS_IO_DEVICE_ERROR) ||
            (status == STATUS_IO_TIMEOUT)
            ) {
 
            //
            // with these error codes, we don't ever want to try this command
            // again on this device, since it reacts poorly.
            //
 
            ClassSetDeviceParameter(FdoExtension,
                                    CLASSP_REG_SUBKEY_NAME,
                                    CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                                    ClassDetectionUnsupported);
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
                       "Classpnp => GESN test failed %x for fdo %p\n",
                       status, FdoExtension->DeviceObject));
            goto ExitWithError;
 
 
        }
 
        if (!NT_SUCCESS(status)) {
 
            //
            // this may be other errors that should not disable GESN
            // for all future start_device calls.
            //
 
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
                       "Classpnp => GESN test failed %x for fdo %p\n",
                       status, FdoExtension->DeviceObject));
            goto ExitWithError;
        }
 
        if (i == 0) {
 
            //
            // the first time, the request was just retrieving a mask of
            // available bits.  use this to mask future requests.
            //
 
            header = (PNOTIFICATION_EVENT_STATUS_HEADER)(Info->Gesn.Buffer);
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                       "Classpnp => Fdo %p supports event mask %x\n",
                       FdoExtension->DeviceObject, header->SupportedEventClasses));
 
 
            if (TEST_FLAG(header->SupportedEventClasses,
                          NOTIFICATION_MEDIA_STATUS_CLASS_MASK)) {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                           "Classpnp => GESN supports MCN\n"));
            }
            if (TEST_FLAG(header->SupportedEventClasses,
                          NOTIFICATION_DEVICE_BUSY_CLASS_MASK)) {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                           "Classpnp => GESN supports DeviceBusy\n"));
            }
            if (TEST_FLAG(header->SupportedEventClasses,
                          NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK)) {
 
                if (TEST_FLAG(FdoExtension->PrivateFdoData->HackFlags,
                              FDO_HACK_GESN_IGNORE_OPCHANGE)) {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                                "Classpnp => GESN supports OpChange, but "
                                "must ignore these events for compatibility\n"));
                    CLEAR_FLAG(header->SupportedEventClasses,
                               NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK);
                } else {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                                "Classpnp => GESN supports OpChange\n"));
                }
            }
            Info->Gesn.EventMask = header->SupportedEventClasses;
 
            //
            // realistically, we are only considering the following events:
            //    EXTERNAL REQUEST - this is being tested for play/stop/etc.
            //    MEDIA STATUS - autorun and ejection requests.
            //    DEVICE BUSY - to allow us to predict when media will be ready.
            // therefore, we should not bother querying for the other,
            // unknown events. clear all but the above flags.
            //
 
            Info->Gesn.EventMask &=
                NOTIFICATION_OPERATIONAL_CHANGE_CLASS_MASK |
                NOTIFICATION_EXTERNAL_REQUEST_CLASS_MASK   |
                NOTIFICATION_MEDIA_STATUS_CLASS_MASK       |
                NOTIFICATION_DEVICE_BUSY_CLASS_MASK        ;
 
 
            //
            // HACKHACK - REF #0001
            // Some devices will *never* report an event if we've also requested
            // that it report lower-priority events.  this is due to a
            // misunderstanding in the specification wherein a "No Change" is
            // interpreted to be a real event.  what should occur is that the
            // device should ignore "No Change" events when multiple event types
            // are requested unless there are no other events waiting.  this
            // greatly reduces the number of requests that the host must send
            // to determine if an event has occurred. Since we must work on all
            // drives, default to enabling the hack until we find evidence of
            // proper firmware.
            //
            if (Info->Gesn.EventMask == 0) {
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                           "Classpnp => GESN supported, but not mask we care "
                           "about (%x) for FDO %p\n",
                           header->SupportedEventClasses,
                           FdoExtension->DeviceObject));
                goto ExitWithError;
 
            } else if (CountOfSetBitsUChar(Info->Gesn.EventMask) == 1) {
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                           "Classpnp => GESN hack not required for FDO %p\n",
                           FdoExtension->DeviceObject));
 
            } else {
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                           "Classpnp => GESN hack enabled for FDO %p\n",
                           FdoExtension->DeviceObject));
                Info->Gesn.HackEventMask = 1;
 
            }
 
        } else {
 
            //
            // not the first time looping through, so interpret the results.
            //
 
            status = ClasspInterpretGesnData(FdoExtension,
                                             (PVOID)Info->Gesn.Buffer,
                                             &retryImmediately);
 
            if (!NT_SUCCESS(status)) {
 
                //
                // This drive does not support GESN correctly
                //
 
                ClassSetDeviceParameter(FdoExtension,
                                        CLASSP_REG_SUBKEY_NAME,
                                        CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                                        ClassDetectionUnsupported);
                goto ExitWithError;
            }
        }
 
    } // end loop of GESN requests....
 
    //
    // we can only use this if it can be relied upon for media changes,
    // since we are (by definition) no longer going to be polling via
    // a TEST_UNIT_READY irp, and drives will not report UNIT ATTENTION
    // for this command (although a filter driver, such as one for burning
    // cd's, might still fake those errors).
    //
    // since we also rely upon NOT_READY events to change the cursor
    // into a "wait" cursor; GESN is still more reliable than other
    // methods, and includes eject button requests, so we'll use it
    // without DEVICE_BUSY in Windows Vista.
    //
 
    if (TEST_FLAG(Info->Gesn.EventMask, NOTIFICATION_MEDIA_STATUS_CLASS_MASK)) {
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                   "Classpnp => Enabling GESN support for fdo %p\n",
                   FdoExtension->DeviceObject));
        Info->Gesn.Supported = TRUE;
 
        ClassSetDeviceParameter(FdoExtension,
                                CLASSP_REG_SUBKEY_NAME,
                                CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                                ClassDetectionSupported);
 
        return STATUS_SUCCESS;
 
    }
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
               "Classpnp => GESN available but not enabled for fdo %p\n",
               FdoExtension->DeviceObject));
    goto ExitWithError;
 
    // fall through...
 
ExitWithError:
    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
               "Classpnp => GESN support detection failed  for fdo %p with status %08x\n",
               FdoExtension->DeviceObject, status));
 
 
    if (Info->Gesn.Mdl) {
        IoFreeMdl(Info->Gesn.Mdl);
        Info->Gesn.Mdl = NULL;
    }
    FREE_POOL(Info->Gesn.Buffer);
    Info->Gesn.Supported  = 0;
    Info->Gesn.EventMask  = 0;
    Info->Gesn.BufferSize = 0;
    return STATUS_NOT_SUPPORTED;
 
}

Referenced by ClasspInitializePolling().

◆ ClasspInitializeHotplugInfo()

NTSTATUS ClasspInitializeHotplugInfo ( IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 12507 of file class.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = FdoExtension->PrivateFdoData;
    DEVICE_REMOVAL_POLICY deviceRemovalPolicy = 0;
    NTSTATUS status;
    ULONG resultLength = 0;
    ULONG writeCacheOverride;
 
    PAGED_CODE();
 
    //
    // start with some default settings
    //
    RtlZeroMemory(&(fdoData->HotplugInfo), sizeof(STORAGE_HOTPLUG_INFO));
 
    //
    // set the size (aka version)
    //
 
    fdoData->HotplugInfo.Size = sizeof(STORAGE_HOTPLUG_INFO);
 
    //
    // set if the device has removable media
    //
 
    if (FdoExtension->DeviceDescriptor->RemovableMedia) {
        fdoData->HotplugInfo.MediaRemovable = TRUE;
    } else {
        fdoData->HotplugInfo.MediaRemovable = FALSE;
    }
 
    //
    // this refers to devices which, for reasons not yet understood,
    // do not fail PREVENT_MEDIA_REMOVAL requests even though they
    // have no way to lock the media into the drive.  this allows
    // the filesystems to turn off delayed-write caching for these
    // devices as well.
    //
 
    if (TEST_FLAG(FdoExtension->PrivateFdoData->HackFlags,
                  FDO_HACK_CANNOT_LOCK_MEDIA)) {
        fdoData->HotplugInfo.MediaHotplug = TRUE;
    } else {
        fdoData->HotplugInfo.MediaHotplug = FALSE;
    }
 
    //
    // Query the default removal policy from the kernel
    //
 
    status = IoGetDeviceProperty(FdoExtension->LowerPdo,
                                 DevicePropertyRemovalPolicy,
                                 sizeof(DEVICE_REMOVAL_POLICY),
                                 (PVOID)&deviceRemovalPolicy,
                                 &resultLength);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    if (resultLength != sizeof(DEVICE_REMOVAL_POLICY)) {
        return STATUS_UNSUCCESSFUL;
    }
 
    //
    // Look into the registry to see if the user has chosen
    // to override the default setting for the removal policy.
    // User can override only if the default removal policy is
    // orderly or suprise removal.
 
    if ((deviceRemovalPolicy == RemovalPolicyExpectOrderlyRemoval) ||
        (deviceRemovalPolicy == RemovalPolicyExpectSurpriseRemoval)) {
 
        DEVICE_REMOVAL_POLICY userRemovalPolicy = 0;
 
        ClassGetDeviceParameter(FdoExtension,
                                CLASSP_REG_SUBKEY_NAME,
                                CLASSP_REG_REMOVAL_POLICY_VALUE_NAME,
                                (PULONG)&userRemovalPolicy);
 
        //
        // Validate the override value and use it only if it is an
        // allowed value.
        //
        if ((userRemovalPolicy == RemovalPolicyExpectOrderlyRemoval) ||
            (userRemovalPolicy == RemovalPolicyExpectSurpriseRemoval)) {
            deviceRemovalPolicy = userRemovalPolicy;
        }
    }
 
    //
    // use this info to set the DeviceHotplug setting
    // don't rely on DeviceCapabilities, since it can't properly
    // determine device relations, etc.  let the kernel figure this
    // stuff out instead.
    //
 
    if (deviceRemovalPolicy == RemovalPolicyExpectSurpriseRemoval) {
        fdoData->HotplugInfo.DeviceHotplug = TRUE;
    } else {
        fdoData->HotplugInfo.DeviceHotplug = FALSE;
    }
 
    //
    // this refers to the *filesystem* caching, but has to be included
    // here since it's a per-device setting.  this may change to be
    // stored by the system in the future.
    //
 
    writeCacheOverride = FALSE;
    ClassGetDeviceParameter(FdoExtension,
                            CLASSP_REG_SUBKEY_NAME,
                            CLASSP_REG_WRITE_CACHE_VALUE_NAME,
                            &writeCacheOverride);
 
    if (writeCacheOverride) {
        fdoData->HotplugInfo.WriteCacheEnableOverride = TRUE;
    } else {
        fdoData->HotplugInfo.WriteCacheEnableOverride = FALSE;
    }
 
    return STATUS_SUCCESS;
}

Referenced by ClassPnpStartDevice().

◆ ClasspInitializeIdleTimer()

VOID ClasspInitializeIdleTimer ( PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 175 of file clntirp.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = FdoExtension->PrivateFdoData;
    ULONG idleInterval = CLASS_IDLE_INTERVAL;
    ULONG idlePrioritySupported = TRUE;
    ULONG activeIdleIoMax = 1;
 
    ClassGetDeviceParameter(FdoExtension,
                            CLASSP_REG_SUBKEY_NAME,
                            CLASSP_REG_IDLE_PRIORITY_SUPPORTED,
                            &idlePrioritySupported);
 
 
    if (idlePrioritySupported == FALSE) {
        //
        // User has set the registry to disable idle priority for this disk.
        // No need to initialize any further.
        // Always ensure that none of the other fields used for idle priority
        // io are ever used without checking if it is supported.
        //
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_TIMER, "ClasspInitializeIdleTimer: Idle priority not supported for disk %p\n", FdoExtension));
        fdoData->IdlePrioritySupported = FALSE;
        fdoData->IdleIoCount = 0;
        fdoData->ActiveIoCount = 0;
        return;
    }
 
    ClassGetDeviceParameter(FdoExtension,
                            CLASSP_REG_SUBKEY_NAME,
                            CLASSP_REG_IDLE_INTERVAL_NAME,
                            &idleInterval);
 
    if ((idleInterval < CLASS_IDLE_INTERVAL_MIN) || (idleInterval > USHORT_MAX)) {
        //
        // If the interval is too low or too high, reset it to the default value.
        //
        idleInterval = CLASS_IDLE_INTERVAL;
    }
 
    fdoData->IdlePrioritySupported = TRUE;
    KeInitializeSpinLock(&fdoData->IdleListLock);
    KeInitializeTimer(&fdoData->IdleTimer);
    KeInitializeDpc(&fdoData->IdleDpc, ClasspIdleTimerDpc, FdoExtension);
    InitializeListHead(&fdoData->IdleIrpList);
    fdoData->IdleTimerStarted = FALSE;
    fdoData->StarvationDuration = CLASS_STARVATION_INTERVAL;
    fdoData->IdleInterval = (USHORT)(idleInterval);
    fdoData->IdleIoCount = 0;
    fdoData->ActiveIoCount = 0;
    fdoData->ActiveIdleIoCount = 0;
 
    ClassGetDeviceParameter(FdoExtension,
                            CLASSP_REG_SUBKEY_NAME,
                            CLASSP_REG_IDLE_ACTIVE_MAX,
                            &activeIdleIoMax);
 
    activeIdleIoMax = max(activeIdleIoMax, 1);
    activeIdleIoMax = min(activeIdleIoMax, USHORT_MAX);
 
    fdoData->IdleActiveIoMax = (USHORT)activeIdleIoMax;
 
    return;
}

◆ ClasspInitializeRemoveTracking()

VOID ClasspInitializeRemoveTracking ( _In_ PDEVICE_OBJECT DeviceObject )

Definition at line 500 of file lock.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
 
    #if DBG
        KeInitializeSpinLock(&commonExtension->RemoveTrackingSpinlock);
 
        commonExtension->RemoveTrackingList = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(RTL_GENERIC_TABLE), CLASS_TAG_LOCK_TRACKING);
 
        if (commonExtension->RemoveTrackingList != NULL)
        {
            RtlInitializeGenericTable(commonExtension->RemoveTrackingList,
                                      RemoveTrackingCompareRoutine,
                                      RemoveTrackingAllocateRoutine,
                                      RemoveTrackingFreeRoutine,
                                      NULL);
        }
    #else
 
        UNREFERENCED_PARAMETER(DeviceObject);
 
        commonExtension->RemoveTrackingSpinlock = (ULONG_PTR) -1;
        commonExtension->RemoveTrackingList = NULL;
    #endif
}

◆ ClasspInitializeTimer()

NTSTATUS ClasspInitializeTimer ( _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 3737 of file autorun.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = NULL;
 
    if (FdoExtension->CommonExtension.IsFdo) {
        fdoData = FdoExtension->PrivateFdoData;
    }
 
    if (fdoData == NULL) {
        return STATUS_UNSUCCESSFUL;
    }
 
    if (fdoData->TimerInitialized == FALSE) {
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
        NT_ASSERT(fdoData->TickTimer == NULL);
        //
        // The tick timer is a no-wake timer, which means it will not wake
        // the processor while the processor is in a low power state until
        // the timer's no-wake tolerance is reached.
        //
        fdoData->TickTimer = ExAllocateTimer(ClasspTimerTickEx, FdoExtension, EX_TIMER_NO_WAKE);
        if (fdoData->TickTimer == NULL) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
#else
        KeInitializeDpc(&fdoData->TickTimerDpc, ClasspTimerTick, FdoExtension);
        KeInitializeTimer(&fdoData->TickTimer);
#endif
        fdoData->TimerInitialized = TRUE;
    }
 
    return STATUS_SUCCESS;
}

Referenced by ClasspEnableTimer(), and ClassPnpStartDevice().

◆ ClasspIsIdleRequest()

FORCEINLINE BOOLEAN ClasspIsIdleRequest ( PIRP Irp )

Definition at line 1268 of file classp.h.

{
#ifdef _MSC_VER
#pragma warning(suppress:4305) // truncation is not an issue for this use case
#endif
    return ((BOOLEAN)Irp->Tail.Overlay.DriverContext[1]);
}

Referenced by SubmitTransferPacket(), and TransferPktComplete().

◆ ClasspIsIdleRequestSupported()

FORCEINLINE BOOLEAN ClasspIsIdleRequestSupported	(	PCLASS_PRIVATE_FDO_DATA	FdoData,
		PIRP	Irp
	)

Definition at line 1236 of file classp.h.

{
#ifndef __REACTOS__
    IO_PRIORITY_HINT ioPriority = IoGetIoPriorityHint(Irp);
    return ((ioPriority <= IoPriorityLow) && (FdoData->IdlePrioritySupported == TRUE));
#else
    return (FdoData->IdlePrioritySupported == TRUE);
#endif
}

Referenced by ClassReadWrite().

◆ ClasspIsObsoletePortDriver()

FORCEINLINE BOOLEAN ClasspIsObsoletePortDriver ( _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 1335 of file classp.h.

{
    if ( (FdoExtension->MiniportDescriptor != NULL) &&
         (FdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetSCSIport) ) {
        return TRUE;
    }
 
    return FALSE;
}

Referenced by ClasspAccessAlignmentProperty(), and ClassReadCapacity16().

◆ ClasspIsOffloadDataTransferCommand()

FORCEINLINE BOOLEAN ClasspIsOffloadDataTransferCommand ( _In_ PCDB Cdb )

Definition at line 2087 of file classp.h.

{
    BOOLEAN offloadCommand = (ClasspIsTokenOperation(Cdb) || ClasspIsReceiveTokenInformation(Cdb)) ? TRUE : FALSE;
 
    return offloadCommand;
}

Referenced by ClassInterpretSenseInfo(), and InterpretTransferPacketError().

◆ ClasspIsPortable()

NTSTATUS ClasspIsPortable	(	_In_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_Out_ PBOOLEAN	IsPortable
	)

Definition at line 8837 of file class.c.

{
    DEVPROP_BOOLEAN            isInternal = DEVPROP_FALSE;
    BOOLEAN                    isPortable = FALSE;
    ULONG                      size       = 0;
    NTSTATUS                   status     = STATUS_SUCCESS;
    DEVPROPTYPE                type       = DEVPROP_TYPE_EMPTY;
 
    PAGED_CODE();
 
    *IsPortable = FALSE;
 
    //
    // Check to see if the underlying device
    // object is in local machine container
    //
 
    status = IoGetDevicePropertyData(FdoExtension->LowerPdo,
                                     &DEVPKEY_Device_InLocalMachineContainer,
                                     0,
                                     0,
                                     sizeof(isInternal),
                                     &isInternal,
                                     &size,
                                     &type);
 
    if (!NT_SUCCESS(status)) {
        goto cleanup;
    }
 
    NT_ASSERT(size == sizeof(isInternal));
    NT_ASSERT(type == DEVPROP_TYPE_BOOLEAN);
 
    //
    // Volume is hot-pluggable if the disk pdo
    // container id differs from that of root device
    //
 
    if (isInternal == DEVPROP_TRUE) {
        goto cleanup;
    }
 
    isPortable = TRUE;
 
    //
    // Examine the  bus type to  ensure
    // that this really is a fixed disk
    //
 
    if (FdoExtension->DeviceDescriptor->BusType == BusTypeFibre ||
        FdoExtension->DeviceDescriptor->BusType == BusTypeiScsi ||
        FdoExtension->DeviceDescriptor->BusType == BusTypeRAID) {
 
        isPortable = FALSE;
    }
 
    *IsPortable = isPortable;
 
cleanup:
 
    return status;
}

Referenced by ClassPnpStartDevice().

◆ ClasspIsReceiveTokenInformation()

FORCEINLINE BOOLEAN ClasspIsReceiveTokenInformation ( _In_ PCDB Cdb )

Definition at line 2066 of file classp.h.

{
    BOOLEAN receiveTokenInformation = FALSE;
 
    if (Cdb) {
        ULONG opCode = Cdb->AsByte[0];
        ULONG serviceAction = Cdb->AsByte[1];
 
        if (opCode == SCSIOP_RECEIVE_ROD_TOKEN_INFORMATION && serviceAction == SERVICE_ACTION_RECEIVE_TOKEN_INFORMATION) {
 
            receiveTokenInformation = TRUE;
        }
    }
 
    return receiveTokenInformation;
}

Referenced by ClassInterpretSenseInfo(), ClasspIsOffloadDataTransferCommand(), and ClasspTransferPacketGetNumberOfRetriesDone().

◆ ClasspIsThinProvisioned()

FORCEINLINE BOOLEAN ClasspIsThinProvisioned ( _In_ PCLASS_FUNCTION_SUPPORT_INFO SupportInfo )

Definition at line 1317 of file classp.h.

{
    //
    // We only support thinly provisioned devices that also support UNMAP.
    //
    if (SupportInfo->LBProvisioningData.ProvisioningType == PROVISIONING_TYPE_THIN &&
        SupportInfo->LBProvisioningData.LBPU == TRUE)
    {
        return TRUE;
    }
 
    return FALSE;
}

Referenced by ClasspDeviceLBProvisioningProperty().

◆ ClasspIsThinProvisioningError()

BOOLEAN ClasspIsThinProvisioningError ( _In_ PSCSI_REQUEST_BLOCK _Srb )

Definition at line 9127 of file utils.c.

{
    if (TEST_FLAG(Srb->SrbStatus, SRB_STATUS_AUTOSENSE_VALID)) {
        PVOID senseBuffer = SrbGetSenseInfoBuffer(Srb);
        if (senseBuffer) {
            UCHAR senseKey = 0;
            UCHAR addlSenseCode = 0;
            UCHAR addlSenseCodeQual = 0;
            BOOLEAN validSense = ScsiGetSenseKeyAndCodes(senseBuffer,
                                                         SrbGetSenseInfoBufferLength(Srb),
                                                         SCSI_SENSE_OPTIONS_NONE,
                                                         &senseKey,
                                                         &addlSenseCode,
                                                         &addlSenseCodeQual);
 
            return (validSense
                    && (senseKey == SCSI_SENSE_UNIT_ATTENTION)
                    && (addlSenseCode == SCSI_ADSENSE_LB_PROVISIONING)
                    && (addlSenseCodeQual == SCSI_SENSEQ_SOFT_THRESHOLD_REACHED));
        }
    }
    return FALSE;
}

Referenced by RetryTransferPacket().

◆ ClasspIsTokenOperation()

FORCEINLINE BOOLEAN ClasspIsTokenOperation ( _In_ PCDB Cdb )

Definition at line 2044 of file classp.h.

{
    BOOLEAN tokenOperation = FALSE;
 
    if (Cdb) {
        ULONG opCode = Cdb->AsByte[0];
        ULONG serviceAction = Cdb->AsByte[1];
 
        if ((opCode == SCSIOP_POPULATE_TOKEN && serviceAction == SERVICE_ACTION_POPULATE_TOKEN) ||
            (opCode == SCSIOP_WRITE_USING_TOKEN && serviceAction == SERVICE_ACTION_WRITE_USING_TOKEN)) {
 
            tokenOperation = TRUE;
        }
    }
 
    return tokenOperation;
}

Referenced by ClasspIsOffloadDataTransferCommand(), and InterpretTransferPacketError().

◆ ClasspIsTokenOperationComplete()

FORCEINLINE BOOLEAN ClasspIsTokenOperationComplete ( _In_ ULONG CurrentStatus )

Definition at line 2023 of file classp.h.

{
    BOOLEAN operationCompleted = FALSE;
 
    switch (CurrentStatus) {
        case OPERATION_COMPLETED_WITH_SUCCESS:
        case OPERATION_COMPLETED_WITH_ERROR:
        case OPERATION_COMPLETED_WITH_RESIDUAL_DATA:
        case OPERATION_TERMINATED: {
 
            operationCompleted = TRUE;
        }
    }
 
    return operationCompleted;
}

Referenced by ClasspReceivePopulateTokenInformationTransferPacketDone(), and ClasspReceiveWriteUsingTokenInformationTransferPacketDone().

◆ ClasspLogSystemEventWithDeviceNumber()

NTSTATUS ClasspLogSystemEventWithDeviceNumber	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ NTSTATUS	IoErrorCode
	)

Definition at line 5354 of file utils.c.

{
    NTSTATUS status = STATUS_INSUFFICIENT_RESOURCES;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PIO_ERROR_LOG_PACKET errorLogEntry = NULL;
    ULONG logEntrySize = sizeof(IO_ERROR_LOG_PACKET);
    PWCHAR stringIndex = NULL;
    LONG stringSize = 0;
 
    //
    // We need to allocate enough space for one insertion string: a ULONG
    // representing the disk number in decimal, which means a max of 10 digits,
    // plus one for the NULL character.
    // Make sure we do not exceed the max error log size or the max size of a
    // UCHAR since the size gets truncated to a UCHAR when we pass it to
    // IoAllocateErrorLogEntry().
    //
    logEntrySize = sizeof(IO_ERROR_LOG_PACKET) + (11 * sizeof(WCHAR));
    logEntrySize = min(logEntrySize, ERROR_LOG_MAXIMUM_SIZE);
    logEntrySize = min(logEntrySize, MAXUCHAR);
 
    errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(DeviceObject, (UCHAR)logEntrySize);
    if (errorLogEntry) {
 
        RtlZeroMemory(errorLogEntry, logEntrySize);
        errorLogEntry->StringOffset = sizeof(IO_ERROR_LOG_PACKET);
        errorLogEntry->ErrorCode = IoErrorCode;
 
        stringIndex = (PWCHAR)((ULONG_PTR)errorLogEntry + sizeof(IO_ERROR_LOG_PACKET));
        stringSize = logEntrySize - sizeof(IO_ERROR_LOG_PACKET);
 
        //
        // Add the disk number to the insertion strings.
        //
        status = RtlStringCbPrintfW(stringIndex, stringSize, L"%d", fdoExtension->DeviceNumber);
 
        if (NT_SUCCESS(status)) {
            errorLogEntry->NumberOfStrings++;
        }
 
        //
        // Write the error log packet to the system error logging thread.
        // It will be freed automatically.
        //
        IoWriteErrorLogEntry(errorLogEntry);
 
        status = STATUS_SUCCESS;
    }
 
    return status;
}

Referenced by ClassDispatchPnp(), and ClassIoComplete().

◆ ClasspLowerLayerNotSupport()

FORCEINLINE BOOLEAN ClasspLowerLayerNotSupport ( _In_ NTSTATUS Status )

Definition at line 2638 of file classp.h.

{
    return ((Status == STATUS_NOT_SUPPORTED) ||
            (Status == STATUS_NOT_IMPLEMENTED) ||
            (Status == STATUS_INVALID_DEVICE_REQUEST) ||
            (Status == STATUS_INVALID_PARAMETER_1));
}

Referenced by ClasspAccessAlignmentProperty(), ClasspDeviceSeekPenaltyProperty(), ClasspDeviceTrimProcess(), and ClasspGetHwFirmwareInfo().

◆ ClasspMarkIrpAsIdle()

FORCEINLINE VOID ClasspMarkIrpAsIdle	(	PIRP	Irp,
		BOOLEAN	Idle
	)

Definition at line 1251 of file classp.h.

{
#ifndef __REACTOS__
// truncation is not an issue for this use case
// nonstandard extension used is not an issue for this use case
#pragma warning(suppress:4305; suppress:4213)
    ((BOOLEAN)Irp->Tail.Overlay.DriverContext[1]) = Idle;
#else
    ((PULONG_PTR)Irp->Tail.Overlay.DriverContext)[1] = Idle;
#endif
}

Referenced by ClassReadWrite().

◆ ClasspMcnControl()

NTSTATUS ClasspMcnControl	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN PIRP	Irp,
		IN PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 3276 of file autorun.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension =
        (PCOMMON_DEVICE_EXTENSION) FdoExtension;
 
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PPREVENT_MEDIA_REMOVAL request = Irp->AssociatedIrp.SystemBuffer;
 
    PFILE_OBJECT fileObject = irpStack->FileObject;
    PFILE_OBJECT_EXTENSION fsContext = NULL;
 
    NTSTATUS status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    //
    // Check to make sure we have a file object extension to keep track of this
    // request.  If not we'll fail it before synchronizing.
    //
 
    TRY {
 
        if(fileObject != NULL) {
            fsContext = ClassGetFsContext(commonExtension, fileObject);
        }else if(Irp->RequestorMode == KernelMode) { // && fileObject == NULL
            fsContext = &FdoExtension->KernelModeMcnContext;
        }
 
        if (fsContext == NULL) {
 
            //
            // This handle isn't setup correctly.  We can't let the
            // operation go.
            //
 
            status = STATUS_INVALID_PARAMETER;
            LEAVE;
        }
 
        if(request->PreventMediaRemoval) {
 
            //
            // This is a lock command.  Reissue the command in case bus or
            // device was reset and the lock was cleared.
            //
 
            ClassDisableMediaChangeDetection(FdoExtension);
            InterlockedIncrement((volatile LONG *)&(fsContext->McnDisableCount));
 
        } else {
 
            if(fsContext->McnDisableCount == 0) {
                status = STATUS_INVALID_DEVICE_STATE;
                LEAVE;
            }
 
            InterlockedDecrement((volatile LONG *)&(fsContext->McnDisableCount));
            ClassEnableMediaChangeDetection(FdoExtension);
        }
 
    } FINALLY {
 
        Irp->IoStatus.Status = status;
 
        FREE_POOL(Srb);
 
        ClassReleaseRemoveLock(FdoExtension->DeviceObject, Irp);
        ClassCompleteRequest(FdoExtension->DeviceObject,
                             Irp,
                             IO_NO_INCREMENT);
    }
    return status;
} // end ClasspMcnControl(

Referenced by ClassDeviceControl().

◆ ClasspMediaChangeCompletion()

NTSTATUS ClasspMediaChangeCompletion	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

◆ ClasspModeSelect()

NTSTATUS ClasspModeSelect	(	_In_ PDEVICE_OBJECT	Fdo,
		_In_reads_bytes_(Length) PCHAR	ModeSelectBuffer,
		_In_ ULONG	Length,
		_In_ BOOLEAN	SavePages
	)

Definition at line 6919 of file class.c.

{
 
    PMDL senseBufferMdl;
    NTSTATUS status = STATUS_UNSUCCESSFUL;
 
    senseBufferMdl = BuildDeviceInputMdl(ModeSelectBuffer, Length);
    if (senseBufferMdl) {
 
        TRANSFER_PACKET *pkt = DequeueFreeTransferPacket(Fdo, TRUE);
        if (pkt){
            KEVENT event;
            IRP pseudoIrp = {0};
 
            /*
             *  Store the number of packets servicing the irp (one)
             *  inside the original IRP.  It will be used to counted down
             *  to zero when the packet completes.
             *  Initialize the original IRP's status to success.
             *  If the packet fails, we will set it to the error status.
             */
            pseudoIrp.Tail.Overlay.DriverContext[0] = LongToPtr(1);
            pseudoIrp.IoStatus.Status = STATUS_SUCCESS;
            pseudoIrp.IoStatus.Information = 0;
            pseudoIrp.MdlAddress = senseBufferMdl;
 
            /*
             *  Set this up as a SYNCHRONOUS transfer, submit it,
             *  and wait for the packet to complete.  The result
             *  status will be written to the original irp.
             */
            NT_ASSERT(Length <= 0x0ff);
            KeInitializeEvent(&event, SynchronizationEvent, FALSE);
            SetupModeSelectTransferPacket(pkt, &event, ModeSelectBuffer, (UCHAR)Length, SavePages, &pseudoIrp);
            SubmitTransferPacket(pkt);
            (VOID)KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
 
            if (!NT_SUCCESS(pseudoIrp.IoStatus.Status)){
                /*
                 *  This request can sometimes fail legitimately
                 *  (e.g. when a SCSI device is attached but turned off)
                 *  so this is not necessarily a device/driver bug.
                 */
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassModeSelect on Fdo %ph failed with status %xh.", Fdo, pseudoIrp.IoStatus.Status));
            }
 
            status = pseudoIrp.IoStatus.Status;
        }
 
        FreeDeviceInputMdl(senseBufferMdl);
    } else {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    return status;
}

Referenced by ClassModeSelect(), and ClasspZeroQERR().

◆ ClasspModeSense()

ULONG ClasspModeSense	(	_In_ PDEVICE_OBJECT	Fdo,
		_In_reads_bytes_(Length) PCHAR	ModeSenseBuffer,
		_In_ ULONG	Length,
		_In_ UCHAR	PageMode,
		_In_ UCHAR	PageControl
	)

Definition at line 6681 of file class.c.

{
    ULONG lengthTransferred = 0;
    PMDL senseBufferMdl;
 
    PAGED_CODE();
 
    senseBufferMdl = BuildDeviceInputMdl(ModeSenseBuffer, Length);
    if (senseBufferMdl){
 
        TRANSFER_PACKET *pkt = DequeueFreeTransferPacket(Fdo, TRUE);
        if (pkt){
            KEVENT event;
            IRP pseudoIrp = {0};
 
            /*
             *  Store the number of packets servicing the irp (one)
             *  inside the original IRP.  It will be used to counted down
             *  to zero when the packet completes.
             *  Initialize the original IRP's status to success.
             *  If the packet fails, we will set it to the error status.
             */
            pseudoIrp.Tail.Overlay.DriverContext[0] = LongToPtr(1);
            pseudoIrp.IoStatus.Status = STATUS_SUCCESS;
            pseudoIrp.IoStatus.Information = 0;
            pseudoIrp.MdlAddress = senseBufferMdl;
 
            /*
             *  Set this up as a SYNCHRONOUS transfer, submit it,
             *  and wait for the packet to complete.  The result
             *  status will be written to the original irp.
             */
            NT_ASSERT(Length <= 0x0ff);
            KeInitializeEvent(&event, SynchronizationEvent, FALSE);
            SetupModeSenseTransferPacket(pkt, &event, ModeSenseBuffer, (UCHAR)Length, PageMode, 0, &pseudoIrp, PageControl);
            SubmitTransferPacket(pkt);
            (VOID)KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
 
            if (NT_SUCCESS(pseudoIrp.IoStatus.Status)){
                lengthTransferred = (ULONG)pseudoIrp.IoStatus.Information;
            }
            else {
                /*
                 *  This request can sometimes fail legitimately
                 *  (e.g. when a SCSI device is attached but turned off)
                 *  so this is not necessarily a device/driver bug.
                 */
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClasspModeSense on Fdo %ph failed with status %xh.", Fdo, pseudoIrp.IoStatus.Status));
            }
        }
 
        FreeDeviceInputMdl(senseBufferMdl);
    }
 
    return lengthTransferred;
}

Referenced by ClassModeSense(), ClassModeSenseEx(), and ClasspWriteCacheProperty().

◆ ClasspMyStringMatches()

BOOLEAN ClasspMyStringMatches	(	_In_opt_z_ PCHAR	StringToMatch,
		_In_z_ PCHAR	TargetString
	)

Definition at line 51 of file utils.c.

{
    ULONG length;  // strlen returns an int, not size_t (!)
    PAGED_CODE();
    NT_ASSERT(TargetString);
    // if no match requested, return TRUE
    if (StringToMatch == NULL) {
        return TRUE;
    }
    // cache the string length for efficiency
    length = (ULONG)strlen(StringToMatch);
    // ZERO-length strings may only match zero-length strings
    if (length == 0) {
        return (strlen(TargetString) == 0);
    }
    // strncmp returns zero if the strings match
    return (strncmp(StringToMatch, TargetString, length) == 0);
}

◆ ClassPnpQueryFdoRelations()

NTSTATUS ClassPnpQueryFdoRelations	(	IN PDEVICE_OBJECT	Fdo,
		IN PIRP	Irp
	)

Definition at line 9843 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
#ifdef _MSC_VER
#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
#endif
    PCLASS_DRIVER_EXTENSION driverExtension = IoGetDriverObjectExtension(Fdo->DriverObject, CLASS_DRIVER_EXTENSION_KEY);
 
    PAGED_CODE();
 
    _Analysis_assume_(driverExtension != NULL);
 
    //
    // If there's already an enumeration in progress then don't start another
    // one.
    //
 
    if(InterlockedIncrement((volatile LONG *)&(fdoExtension->EnumerationInterlock)) == 1) {
        driverExtension->InitData.ClassEnumerateDevice(Fdo);
    }
 
    Irp->IoStatus.Status = ClassRetrieveDeviceRelations(
                                Fdo,
                                BusRelations,
                                (PDEVICE_RELATIONS *) &Irp->IoStatus.Information);
    InterlockedDecrement((volatile LONG *)&(fdoExtension->EnumerationInterlock));
 
    return Irp->IoStatus.Status;
} // end ClassPnpQueryFdoRelations()

Referenced by ClassDispatchPnp().

◆ ClassPnpStartDevice()

NTSTATUS ClassPnpStartDevice ( IN PDEVICE_OBJECT DeviceObject )

Definition at line 1819 of file class.c.

{
    PCLASS_DRIVER_EXTENSION driverExtension;
    PCLASS_INIT_DATA initData;
 
    PCLASS_DEV_INFO devInfo;
 
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    BOOLEAN isFdo = commonExtension->IsFdo;
 
    BOOLEAN isMountedDevice = TRUE;
    BOOLEAN isPortable = FALSE;
 
    NTSTATUS status = STATUS_SUCCESS;
    PDEVICE_POWER_DESCRIPTOR powerDescriptor = NULL;
 
 
    PAGED_CODE();
 
#ifdef _MSC_VER
#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
#endif
    driverExtension = IoGetDriverObjectExtension(DeviceObject->DriverObject, CLASS_DRIVER_EXTENSION_KEY);
 
    initData = &(driverExtension->InitData);
    if(isFdo) {
        devInfo = &(initData->FdoData);
    } else {
        devInfo = &(initData->PdoData);
    }
 
    NT_ASSERT(devInfo->ClassInitDevice != NULL);
    NT_ASSERT(devInfo->ClassStartDevice != NULL);
 
    if (!commonExtension->IsInitialized){
 
        //
        // perform FDO/PDO specific initialization
        //
 
        if (isFdo){
            STORAGE_PROPERTY_ID propertyId;
 
            //
            // allocate a private extension for class data
            //
 
            if (fdoExtension->PrivateFdoData == NULL) {
                fdoExtension->PrivateFdoData = ExAllocatePoolWithTag(NonPagedPoolNx,
                                                                     sizeof(CLASS_PRIVATE_FDO_DATA),
                                                                     CLASS_TAG_PRIVATE_DATA
                                                                     );
            }
 
            if (fdoExtension->PrivateFdoData == NULL) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Cannot allocate for private fdo data\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            RtlZeroMemory(fdoExtension->PrivateFdoData, sizeof(CLASS_PRIVATE_FDO_DATA));
 
 
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
            //
            // Allocate a structure to hold more data than what we can put in FUNCTIONAL_DEVICE_EXTENSION.
            // This structure's memory is managed by classpnp, so it is more extensible.
            //
            if (fdoExtension->AdditionalFdoData == NULL) {
                fdoExtension->AdditionalFdoData = ExAllocatePoolWithTag(NonPagedPoolNx,
                                                                        sizeof(ADDITIONAL_FDO_DATA),
                                                                        CLASSPNP_POOL_TAG_ADDITIONAL_DATA
                                                                        );
            }
 
            if (fdoExtension->AdditionalFdoData == NULL) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Cannot allocate memory for the additional data structure.\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            RtlZeroMemory(fdoExtension->AdditionalFdoData, sizeof(ADDITIONAL_FDO_DATA));
#endif
 
            status = ClasspInitializeTimer(fdoExtension);
            if (NT_SUCCESS(status) == FALSE) {
                FREE_POOL(fdoExtension->PrivateFdoData);
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
                FREE_POOL(fdoExtension->AdditionalFdoData);
#endif
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Failed to initialize tick timer\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            //
            // allocate LowerLayerSupport for class data
            //
 
            if (fdoExtension->FunctionSupportInfo == NULL) {
                fdoExtension->FunctionSupportInfo = (PCLASS_FUNCTION_SUPPORT_INFO)ExAllocatePoolWithTag(NonPagedPoolNx,
                                                                                                        sizeof(CLASS_FUNCTION_SUPPORT_INFO),
                                                                                                        '3BcS'
                                                                                                        );
            }
 
            if (fdoExtension->FunctionSupportInfo == NULL) {
                ClasspDeleteTimer(fdoExtension);
                FREE_POOL(fdoExtension->PrivateFdoData);
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
                FREE_POOL(fdoExtension->AdditionalFdoData);
#endif
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Cannot allocate for FunctionSupportInfo\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            //
            // initialize the struct's various fields.
            //
            RtlZeroMemory(fdoExtension->FunctionSupportInfo, sizeof(CLASS_FUNCTION_SUPPORT_INFO));
            KeInitializeSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock);
 
            //
            // intialize the CommandStatus to -1 indicates that no effort made yet to retrieve the info.
            // Possible values of CommandStatus (data type: NTSTATUS):
            //     -1:             It's not attempted yet to retrieve the information.
            //     success:        Command sent and succeeded, information cached in FdoExtension.
            //     failed/warning: Command is either not supported or failed by device or lower level driver.
            //                     The command should not be attempted again.
            //
            fdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus = -1;
            fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.CommandStatus = -1;
            fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus = -1;
            fdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus = -1;
            fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus = -1;
 
 
            KeInitializeTimer(&fdoExtension->PrivateFdoData->Retry.Timer);
            KeInitializeDpc(&fdoExtension->PrivateFdoData->Retry.Dpc,
                            ClasspRetryRequestDpc,
                            DeviceObject);
            KeInitializeSpinLock(&fdoExtension->PrivateFdoData->Retry.Lock);
            fdoExtension->PrivateFdoData->Retry.Granularity = KeQueryTimeIncrement();
            commonExtension->Reserved4 = (ULONG_PTR)(' GPH'); // debug aid
            InitializeListHead(&fdoExtension->PrivateFdoData->DeferredClientIrpList);
 
            KeInitializeSpinLock(&fdoExtension->PrivateFdoData->SpinLock);
 
            //
            // keep a pointer to the senseinfo2 stuff locally also (used in every read/write).
            //
            fdoExtension->PrivateFdoData->InterpretSenseInfo = driverExtension->InterpretSenseInfo;
 
            fdoExtension->PrivateFdoData->MaxNumberOfIoRetries = NUM_IO_RETRIES;
 
            //
            // Initialize release queue extended SRB
            //
            status = InitializeStorageRequestBlock(&(fdoExtension->PrivateFdoData->ReleaseQueueSrb.SrbEx),
                                                   STORAGE_ADDRESS_TYPE_BTL8,
                                                   sizeof(fdoExtension->PrivateFdoData->ReleaseQueueSrb.ReleaseQueueSrbBuffer),
                                                   0);
            if (!NT_SUCCESS(status)) {
                NT_ASSERT(FALSE);
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,
                            "ClassPnpStartDevice: fail to initialize release queue extended SRB 0x%x\n", status));
                return status;
            }
 
 
            /*
             *  Anchor the FDO in our static list.
             *  Pnp is synchronized, so we shouldn't need any synchronization here.
             */
            InsertTailList(&AllFdosList, &fdoExtension->PrivateFdoData->AllFdosListEntry);
 
            //
            // NOTE: the old interface allowed the class driver to allocate
            // this.  this was unsafe for low-memory conditions. allocate one
            // unconditionally now, and modify our internal functions to use
            // our own exclusively as it is the only safe way to do this.
            //
 
            status = ClasspAllocateReleaseQueueIrp(fdoExtension);
            if (!NT_SUCCESS(status)) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Cannot allocate the private release queue irp\n"));
                return status;
            }
 
            status = ClasspAllocatePowerProcessIrp(fdoExtension);
            if (!NT_SUCCESS(status)) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Cannot allocate the power process irp\n"));
                return status;
            }
 
            //
            // Call port driver to get miniport properties for disk devices
            // It's ok for this call to fail
            //
 
            if ((DeviceObject->DeviceType == FILE_DEVICE_DISK) &&
                (!TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE))) {
 
                propertyId = StorageMiniportProperty;
 
                status = ClassGetDescriptor(fdoExtension->CommonExtension.LowerDeviceObject,
                                            &propertyId,
                                            (PVOID *)&fdoExtension->MiniportDescriptor);
 
                //
                // function ClassGetDescriptor returns succeed with buffer "fdoExtension->MiniportDescriptor" allocated.
                //
                if ( NT_SUCCESS(status) &&
                     (fdoExtension->MiniportDescriptor->Portdriver != StoragePortCodeSetStorport &&
                      fdoExtension->MiniportDescriptor->Portdriver != StoragePortCodeSetUSBport) ) {
                    //
                    // field "IoTimeoutValue" supported for either Storport or USBStor
                    //
                    fdoExtension->MiniportDescriptor->IoTimeoutValue = 0;
                }
 
 
 
            }
 
            //
            // Call port driver to get adapter capabilities.
            //
 
            propertyId = StorageAdapterProperty;
 
            status = ClassGetDescriptor(
                        commonExtension->LowerDeviceObject,
                        &propertyId,
                        (PVOID *)&fdoExtension->AdapterDescriptor);
            if (!NT_SUCCESS(status)) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: ClassGetDescriptor [ADAPTER] failed %lx\n", status));
                return status;
            }
 
            //
            // Call port driver to get device descriptor.
            //
 
            propertyId = StorageDeviceProperty;
 
            status = ClassGetDescriptor(
                        commonExtension->LowerDeviceObject,
                        &propertyId,
                        (PVOID *)&fdoExtension->DeviceDescriptor);
            if (NT_SUCCESS(status)){
 
                ClasspScanForSpecialInRegistry(fdoExtension);
                ClassScanForSpecial(fdoExtension, ClassBadItems, ClasspScanForClassHacks);
 
                //
                // allow perf to be re-enabled after a given number of failed IOs
                // require this number to be at least CLASS_PERF_RESTORE_MINIMUM
                //
 
                {
                    ULONG t = CLASS_PERF_RESTORE_MINIMUM;
 
                    ClassGetDeviceParameter(fdoExtension,
                                            CLASSP_REG_SUBKEY_NAME,
                                            CLASSP_REG_PERF_RESTORE_VALUE_NAME,
                                            &t);
                    if (t >= CLASS_PERF_RESTORE_MINIMUM) {
                        fdoExtension->PrivateFdoData->Perf.ReEnableThreshhold = t;
                    }
                }
 
                //
                // compatibility comes first.  writable cd media will not
                // get a SYNCH_CACHE on power down.
                //
                if (fdoExtension->DeviceObject->DeviceType != FILE_DEVICE_DISK) {
                    SET_FLAG(fdoExtension->PrivateFdoData->HackFlags, FDO_HACK_NO_SYNC_CACHE);
                }
 
 
                //
                // Test if the device is portable and updated the characteristics if so
                //
                status = ClasspIsPortable(fdoExtension,
                                          &isPortable);
 
                if (NT_SUCCESS(status) && (isPortable == TRUE)) {
                    DeviceObject->Characteristics |= FILE_PORTABLE_DEVICE;
                }
 
                //
                // initialize the hotplug information only after the ScanForSpecial
                // routines, as it relies upon the hack flags.
                //
                status = ClasspInitializeHotplugInfo(fdoExtension);
                if (NT_SUCCESS(status)){
                    /*
                     *  Allocate/initialize TRANSFER_PACKETs and related resources.
                     */
                    status = InitializeTransferPackets(DeviceObject);
                }
                else {
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Could not initialize hotplug information %lx\n", status));
                }
            }
            else {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: ClassGetDescriptor [DEVICE] failed %lx\n", status));
                return status;
            }
 
 
            if (NT_SUCCESS(status)) {
 
                //
                // Retrieve info on whether async notification is supported by port drivers
                //
                propertyId = StorageDevicePowerProperty;
 
                status = ClassGetDescriptor(fdoExtension->CommonExtension.LowerDeviceObject,
                                            &propertyId,
                                            (PVOID *)&powerDescriptor);
                if (NT_SUCCESS(status) && (powerDescriptor != NULL)) {
                    fdoExtension->FunctionSupportInfo->AsynchronousNotificationSupported = powerDescriptor->AsynchronousNotificationSupported;
                    fdoExtension->FunctionSupportInfo->IdlePower.D3ColdSupported = powerDescriptor->D3ColdSupported;
                    fdoExtension->FunctionSupportInfo->IdlePower.NoVerifyDuringIdlePower = powerDescriptor->NoVerifyDuringIdlePower;
                    FREE_POOL(powerDescriptor);
                } else {
                    TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: ClassGetDescriptor [DevicePower] failed %lx\n", status));
 
                    //
                    // Ignore error as device power property is optional
                    //
                    status = STATUS_SUCCESS;
                }
            }
        }
 
        //
        // ISSUE - drivers need to disable write caching on the media
        //         if hotplug and !useroverride.  perhaps we should
        //         allow registration of a callback to enable/disable
        //         write cache instead.
        //
 
        if (NT_SUCCESS(status)){
            status = devInfo->ClassInitDevice(DeviceObject);
        }
 
        if (commonExtension->IsFdo) {
            fdoExtension->PrivateFdoData->Perf.OriginalSrbFlags = fdoExtension->SrbFlags;
 
            //
            // initialization for disk device
            //
            if ((DeviceObject->DeviceType == FILE_DEVICE_DISK) &&
                (!TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE))) {
 
                ULONG accessAlignmentNotSupported = 0;
                ULONG qerrOverrideMode = QERR_SET_ZERO_ODX_OR_TP_ONLY;
                ULONG legacyErrorHandling = FALSE;
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,
                           "ClassPnpStartDevice: Enabling idle timer for %p\n", DeviceObject));
                // Initialize idle timer for disk devices
                ClasspInitializeIdleTimer(fdoExtension);
 
                if (ClasspIsObsoletePortDriver(fdoExtension) == FALSE) {
                    // get INQUIRY VPD support information. It's safe to send command as everything is ready in ClassInitDevice().
                    ClasspGetInquiryVpdSupportInfo(fdoExtension);
 
                    // Query and cache away Logical Block Provisioning info in the FDO extension.
                    // The cached information will be used in responding to some IOCTLs
                    ClasspGetLBProvisioningInfo(fdoExtension);
 
                    //
                    // Query and cache away Block Device ROD Limits info in the FDO extension.
                    //
                    if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits) {
                        ClassDetermineTokenOperationCommandSupport(DeviceObject);
                    }
 
                    //
                    // See if the user has specified a particular QERR override
                    // mode. "Override" meaning setting QERR = 0 via Mode Select.
                    //  0 = Only when ODX or Thin Provisioning are supported (default)
                    //  1 = Always
                    //  2 = Never (or any value >= 2)
                    //
                    ClassGetDeviceParameter(fdoExtension,
                                            CLASSP_REG_SUBKEY_NAME,
                                            CLASSP_REG_QERR_OVERRIDE_MODE,
                                            &qerrOverrideMode);
 
                    //
                    // If this device is thinly provisioned or supports ODX, we
                    // may need to force QERR to zero.  The user may have also
                    // specified that we should always or never do this.
                    //
                    if (qerrOverrideMode == QERR_SET_ZERO_ALWAYS ||
                        (qerrOverrideMode == QERR_SET_ZERO_ODX_OR_TP_ONLY &&
                         (ClasspIsThinProvisioned(fdoExtension->FunctionSupportInfo) ||
                          NT_SUCCESS(ClasspValidateOffloadSupported(DeviceObject, NULL))))) {
 
                        ClasspZeroQERR(DeviceObject);
                    }
 
                } else {
 
                    //
                    // Since this device has been exposed by a legacy miniport (e.g. SCSIPort miniport)
                    // set its LB Provisioning command status to an error status that will be surfaced
                    // up to the caller of a TRIM/Unmap command.
                    //
                    fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus = STATUS_UNSUCCESSFUL;
                    fdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus = STATUS_UNSUCCESSFUL;
                    fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus = STATUS_UNSUCCESSFUL;
                }
 
                // Get registry setting of failing the IOCTL for AccessAlignment Property.
                ClassGetDeviceParameter(fdoExtension,
                                        CLASSP_REG_SUBKEY_NAME,
                                        CLASSP_REG_ACCESS_ALIGNMENT_NOT_SUPPORTED,
                                        &accessAlignmentNotSupported);
 
                if (accessAlignmentNotSupported > 0) {
                    fdoExtension->FunctionSupportInfo->RegAccessAlignmentQueryNotSupported = TRUE;
                }
 
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
 
 
                //
                // See if the user has specified legacy error handling.
                //
                ClassGetDeviceParameter(fdoExtension,
                                        CLASSP_REG_SUBKEY_NAME,
                                        CLASSP_REG_LEGACY_ERROR_HANDLING,
                                        &legacyErrorHandling);
 
                if (legacyErrorHandling) {
                    //
                    // Legacy error handling means that the maximum number of
                    // retries allowd for an IO request is 8 instead of 4.
                    //
                    fdoExtension->PrivateFdoData->MaxNumberOfIoRetries = LEGACY_NUM_IO_RETRIES;
                    fdoExtension->PrivateFdoData->LegacyErrorHandling = TRUE;
                }
#else
                UNREFERENCED_PARAMETER(legacyErrorHandling);
#endif
 
 
                //
                // Get the copy offload max target duration value.
                // This function will set the default value if one hasn't been
                // specified in the registry.
                //
                ClasspGetCopyOffloadMaxDuration(DeviceObject,
                                                REG_DISK_CLASS_CONTROL,
                                                &(fdoExtension->PrivateFdoData->CopyOffloadMaxTargetDuration));
 
            }
 
        }
    }
 
    if (!NT_SUCCESS(status)){
 
        //
        // Just bail out - the remove that comes down will clean up the
        // initialized scraps.
        //
 
        return status;
    } else {
        commonExtension->IsInitialized = TRUE;
    }
 
    //
    // If device requests autorun functionality or a once a second callback
    // then enable the once per second timer. Exception is if media change
    // detection is desired but device supports async notification.
    //
    // NOTE: This assumes that ClassInitializeMediaChangeDetection is always
    //       called in the context of the ClassInitDevice callback. If called
    //       after then this check will have already been made and the
    //       once a second timer will not have been enabled.
    //
    if ((isFdo) &&
        ((initData->ClassTick != NULL) ||
         ((fdoExtension->MediaChangeDetectionInfo != NULL) &&
          (fdoExtension->FunctionSupportInfo != NULL) &&
          (fdoExtension->FunctionSupportInfo->AsynchronousNotificationSupported == FALSE)) ||
         ((fdoExtension->FailurePredictionInfo != NULL) &&
          (fdoExtension->FailurePredictionInfo->Method != FailurePredictionNone))))
    {
        ClasspEnableTimer(fdoExtension);
 
        //
        // In addition, we may change our polling behavior when the screen is
        // off so register for screen state notification if we haven't already
        // done so.
        //
        if (ScreenStateNotificationHandle == NULL) {
            PoRegisterPowerSettingCallback(DeviceObject,
                                            &GUID_CONSOLE_DISPLAY_STATE,
                                            &ClasspPowerSettingCallback,
                                            NULL,
                                            &ScreenStateNotificationHandle);
        }
    }
 
    //
    // NOTE: the timer looks at commonExtension->CurrentState now
    //       to prevent Media Change Notification code from running
    //       until the device is started, but allows the device
    //       specific tick handler to run.  therefore it is imperative
    //       that commonExtension->CurrentState not be updated until
    //       the device specific startdevice handler has finished.
    //
 
    status = devInfo->ClassStartDevice(DeviceObject);
 
    if (NT_SUCCESS(status)){
        commonExtension->CurrentState = IRP_MN_START_DEVICE;
 
        if((isFdo) && (initData->ClassEnumerateDevice != NULL)) {
            isMountedDevice = FALSE;
        }
 
        if (DeviceObject->DeviceType != FILE_DEVICE_CD_ROM) {
 
            isMountedDevice = FALSE;
        }
 
        //
        // Register for mounted device interface if this is a
        // sfloppy device.
        //
        if ((DeviceObject->DeviceType == FILE_DEVICE_DISK) &&
            (TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE))) {
 
            isMountedDevice = TRUE;
        }
 
        if(isMountedDevice) {
            ClasspRegisterMountedDeviceInterface(DeviceObject);
        }
 
        if(commonExtension->IsFdo) {
            IoWMIRegistrationControl(DeviceObject, WMIREG_ACTION_REGISTER);
 
            //
            // Tell Storport (Usbstor or SD) to enable idle power management for this
            // device, assuming the user hasn't turned it off in the registry.
            //
            if (fdoExtension->FunctionSupportInfo != NULL &&
                fdoExtension->FunctionSupportInfo->IdlePower.IdlePowerEnabled == FALSE &&
                fdoExtension->MiniportDescriptor != NULL &&
                (fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetStorport ||
                 fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetSDport ||
                 fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetUSBport)) {
                ULONG disableIdlePower= 0;
                ClassGetDeviceParameter(fdoExtension,
                                        CLASSP_REG_SUBKEY_NAME,
                                        CLASSP_REG_DISBALE_IDLE_POWER_NAME,
                                        &disableIdlePower);
 
                if (!disableIdlePower) {
                    ClasspEnableIdlePower(DeviceObject);
                }
            }
        }
    }
    else {
        ClasspDisableTimer(fdoExtension);
    }
 
 
    return status;
}

Referenced by ClassDispatchPnp().

◆ ClasspPagingNotificationCompletion()

NTSTATUS ClasspPagingNotificationCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PDEVICE_OBJECT	RealDeviceObject
	)

◆ ClasspPerfIncrementErrorCount()

VOID ClasspPerfIncrementErrorCount ( IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 432 of file utils.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = FdoExtension->PrivateFdoData;
    KIRQL oldIrql;
    ULONG errors;
 
    KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
 
    fdoData->Perf.SuccessfulIO = 0; // implicit interlock
    errors = InterlockedIncrement((volatile LONG *)&FdoExtension->ErrorCount);
 
    if (!fdoData->DisableThrottling) {
 
        if (errors >= CLASS_ERROR_LEVEL_1) {
 
            //
            // If the error count has exceeded the error limit, then disable
            // any tagged queuing, multiple requests per lu queueing
            // and sychronous data transfers.
            //
            // Clearing the no queue freeze flag prevents the port driver
            // from sending multiple requests per logical unit.
            //
 
            CLEAR_FLAG(FdoExtension->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE);
            CLEAR_FLAG(FdoExtension->SrbFlags, SRB_FLAGS_QUEUE_ACTION_ENABLE);
 
            SET_FLAG(FdoExtension->SrbFlags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "ClasspPerfIncrementErrorCount: "
                        "Too many errors; disabling tagged queuing and "
                        "synchronous data tranfers.\n"));
 
        }
 
        if (errors >= CLASS_ERROR_LEVEL_2) {
 
            //
            // If a second threshold is reached, disable disconnects.
            //
 
            SET_FLAG(FdoExtension->SrbFlags, SRB_FLAGS_DISABLE_DISCONNECT);
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "ClasspPerfIncrementErrorCount: "
                        "Too many errors; disabling disconnects.\n"));
        }
    }
 
    KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
    return;
}

Referenced by ClassInterpretSenseInfo().

◆ ClasspPerfIncrementSuccessfulIo()

VOID ClasspPerfIncrementSuccessfulIo ( IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 486 of file utils.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = FdoExtension->PrivateFdoData;
    KIRQL oldIrql;
    ULONG errors;
    ULONG succeeded = 0;
 
    //
    // don't take a hit from the interlocked op unless we're in
    // a degraded state and we've got a threshold to hit.
    //
 
    if (FdoExtension->ErrorCount == 0) {
        return;
    }
 
    if (fdoData->Perf.ReEnableThreshhold == 0) {
        return;
    }
 
    succeeded = InterlockedIncrement((volatile LONG *)&fdoData->Perf.SuccessfulIO);
    if (succeeded < fdoData->Perf.ReEnableThreshhold) {
        return;
    }
 
    //
    // if we hit the threshold, grab the spinlock and verify we've
    // actually done so.  this allows us to ignore the spinlock 99%
    // of the time.
    //
 
    KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
 
    //
    // re-read the value, so we don't run this multiple times
    // for a single threshhold being hit.  this keeps errorcount
    // somewhat useful.
    //
 
    succeeded = fdoData->Perf.SuccessfulIO;
 
    if ((FdoExtension->ErrorCount != 0) &&
        (fdoData->Perf.ReEnableThreshhold <= succeeded)
        ) {
 
        fdoData->Perf.SuccessfulIO = 0; // implicit interlock
 
        NT_ASSERT(FdoExtension->ErrorCount > 0);
        errors = InterlockedDecrement((volatile LONG *)&FdoExtension->ErrorCount);
 
        //
        // note: do in reverse order of the sets "just in case"
        //
 
        if (errors < CLASS_ERROR_LEVEL_2) {
            if (errors == CLASS_ERROR_LEVEL_2 - 1) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "ClasspPerfIncrementSuccessfulIo: "
                            "Error level 2 no longer required.\n"));
            }
            if (!TEST_FLAG(fdoData->Perf.OriginalSrbFlags,
                           SRB_FLAGS_DISABLE_DISCONNECT)) {
                CLEAR_FLAG(FdoExtension->SrbFlags,
                           SRB_FLAGS_DISABLE_DISCONNECT);
            }
        }
 
        if (errors < CLASS_ERROR_LEVEL_1) {
            if (errors == CLASS_ERROR_LEVEL_1 - 1) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "ClasspPerfIncrementSuccessfulIo: "
                            "Error level 1 no longer required.\n"));
            }
            if (!TEST_FLAG(fdoData->Perf.OriginalSrbFlags,
                           SRB_FLAGS_DISABLE_SYNCH_TRANSFER)) {
                CLEAR_FLAG(FdoExtension->SrbFlags,
                           SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
            }
            if (TEST_FLAG(fdoData->Perf.OriginalSrbFlags,
                          SRB_FLAGS_QUEUE_ACTION_ENABLE)) {
                SET_FLAG(FdoExtension->SrbFlags,
                         SRB_FLAGS_QUEUE_ACTION_ENABLE);
            }
            if (TEST_FLAG(fdoData->Perf.OriginalSrbFlags,
                          SRB_FLAGS_NO_QUEUE_FREEZE)) {
                SET_FLAG(FdoExtension->SrbFlags,
                         SRB_FLAGS_NO_QUEUE_FREEZE);
            }
        }
    } // end of threshhold definitely being hit for first time
 
    KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
    return;
}

Referenced by ClassIoComplete(), and TransferPktComplete().

◆ ClasspPersistentReserve()

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

Definition at line 6211 of file utils.c.

{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PCDB cdb = NULL;
    PPERSISTENT_RESERVE_COMMAND prCommand = Irp->AssociatedIrp.SystemBuffer;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
 
    NTSTATUS status;
 
    ULONG dataBufLen;
    ULONG controlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
 
    BOOLEAN writeToDevice;
 
    //
    // Check common input buffer parameters.
    //
 
    if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
            sizeof(PERSISTENT_RESERVE_COMMAND) ||
        prCommand->Size < sizeof(PERSISTENT_RESERVE_COMMAND)) {
 
        status = STATUS_INFO_LENGTH_MISMATCH;
        Irp->IoStatus.Status = status;
        Irp->IoStatus.Information = 0;
 
        FREE_POOL(Srb);
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
        goto ClasspPersistentReserve_Exit;
    }
 
    //
    // Check buffer alignment. Only an issue if another kernel mode component
    // (not the I/O manager) allocates the buffer.
    //
 
    if ((ULONG_PTR)prCommand & fdoExtension->AdapterDescriptor->AlignmentMask) {
 
        status = STATUS_INVALID_USER_BUFFER;
        Irp->IoStatus.Status = status;
        Irp->IoStatus.Information = 0;
 
        FREE_POOL(Srb);
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
        goto ClasspPersistentReserve_Exit;
    }
 
    //
    // Check additional parameters.
    //
 
    status = STATUS_SUCCESS;
 
    SrbSetCdbLength(Srb, 10);
    cdb = SrbGetCdb(Srb);
 
    if (controlCode == IOCTL_STORAGE_PERSISTENT_RESERVE_IN) {
 
        //
        // Check output buffer for PR In.
        //
 
        if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
            prCommand->PR_IN.AllocationLength) {
 
            status = STATUS_INVALID_PARAMETER;
        }
 
        switch (prCommand->PR_IN.ServiceAction) {
 
        case RESERVATION_ACTION_READ_KEYS:
 
            if (prCommand->PR_IN.AllocationLength < sizeof(PRI_REGISTRATION_LIST)) {
 
                status = STATUS_INVALID_PARAMETER;
            }
 
            break;
 
        case RESERVATION_ACTION_READ_RESERVATIONS:
 
            if (prCommand->PR_IN.AllocationLength < sizeof(PRI_RESERVATION_LIST)) {
 
                status = STATUS_INVALID_PARAMETER;
            }
 
            break;
 
        default:
 
            status = STATUS_INVALID_PARAMETER;
            break;
        }
 
        if (!NT_SUCCESS(status)) {
 
            Irp->IoStatus.Status = status;
            Irp->IoStatus.Information = 0;
 
            FREE_POOL(Srb);
 
            ClassReleaseRemoveLock(DeviceObject, Irp);
            ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
            goto ClasspPersistentReserve_Exit;
        }
 
        //
        // Fill in the CDB.
        //
 
        cdb->PERSISTENT_RESERVE_IN.OperationCode    = SCSIOP_PERSISTENT_RESERVE_IN;
        cdb->PERSISTENT_RESERVE_IN.ServiceAction    = prCommand->PR_IN.ServiceAction;
 
        REVERSE_BYTES_SHORT(&(cdb->PERSISTENT_RESERVE_IN.AllocationLength),
                            &(prCommand->PR_IN.AllocationLength));
 
        dataBufLen = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
        writeToDevice = FALSE;
 
 
    } else {
 
        //
        // Verify ServiceAction, Scope, and Type
        //
 
        switch (prCommand->PR_OUT.ServiceAction) {
 
        case RESERVATION_ACTION_REGISTER:
        case RESERVATION_ACTION_REGISTER_IGNORE_EXISTING:
        case RESERVATION_ACTION_CLEAR:
 
            // Scope and type ignored.
 
            break;
 
        case RESERVATION_ACTION_RESERVE:
        case RESERVATION_ACTION_RELEASE:
        case RESERVATION_ACTION_PREEMPT:
        case RESERVATION_ACTION_PREEMPT_ABORT:
 
            if (!ValidPersistentReserveScope(prCommand->PR_OUT.Scope) ||
                !ValidPersistentReserveType(prCommand->PR_OUT.Type)) {
 
                status = STATUS_INVALID_PARAMETER;
 
            }
 
            break;
 
        default:
 
            status = STATUS_INVALID_PARAMETER;
 
            break;
        }
 
        //
        // Check input buffer for PR Out.
        // Caller must include the PR parameter list.
        //
 
        if (NT_SUCCESS(status)) {
 
            if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
                    (sizeof(PERSISTENT_RESERVE_COMMAND) +
                     sizeof(PRO_PARAMETER_LIST)) ||
                prCommand->Size <
                    irpStack->Parameters.DeviceIoControl.InputBufferLength) {
 
            status = STATUS_INVALID_PARAMETER;
 
            }
        }
 
 
        if (!NT_SUCCESS(status)) {
 
            Irp->IoStatus.Status = status;
            Irp->IoStatus.Information = 0;
 
            FREE_POOL(Srb);
 
            ClassReleaseRemoveLock(DeviceObject, Irp);
            ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
            goto ClasspPersistentReserve_Exit;
        }
 
        //
        // Fill in the CDB.
        //
 
        cdb->PERSISTENT_RESERVE_OUT.OperationCode   = SCSIOP_PERSISTENT_RESERVE_OUT;
        cdb->PERSISTENT_RESERVE_OUT.ServiceAction   = prCommand->PR_OUT.ServiceAction;
        cdb->PERSISTENT_RESERVE_OUT.Scope           = prCommand->PR_OUT.Scope;
        cdb->PERSISTENT_RESERVE_OUT.Type            = prCommand->PR_OUT.Type;
 
        cdb->PERSISTENT_RESERVE_OUT.ParameterListLength[1] = (UCHAR)sizeof(PRO_PARAMETER_LIST);
 
        //
        // Move the parameter list to the beginning of the data buffer (so it is aligned
        // correctly and that the MDL describes it correctly).
        //
 
        RtlMoveMemory(prCommand,
                      prCommand->PR_OUT.ParameterList,
                      sizeof(PRO_PARAMETER_LIST));
 
        dataBufLen = sizeof(PRO_PARAMETER_LIST);
        writeToDevice = TRUE;
    }
 
    //
    // Fill in the SRB
    //
 
    //
    // Set timeout value.
    //
 
    SrbSetTimeOutValue(Srb, fdoExtension->TimeOutValue);
 
    //
    // Send as a tagged request.
    //
 
    SrbSetRequestAttribute(Srb, SRB_HEAD_OF_QUEUE_TAG_REQUEST);
    SrbSetSrbFlags(Srb, SRB_FLAGS_NO_QUEUE_FREEZE | SRB_FLAGS_QUEUE_ACTION_ENABLE);
 
    status = ClassSendSrbAsynchronous(DeviceObject,
                                      Srb,
                                      Irp,
                                      prCommand,
                                      dataBufLen,
                                      writeToDevice);
 
ClasspPersistentReserve_Exit:
 
    return status;
 
}

Referenced by ClassDeviceControl().

◆ ClasspPopulateTokenTransferPacketDone()

VOID ClasspPopulateTokenTransferPacketDone ( _In_ PVOID Context )

Definition at line 14166 of file class.c.

{
    PDEVICE_OBJECT fdo;
    ULONG listIdentifier;
    POFFLOAD_READ_CONTEXT offloadReadContext;
    PTRANSFER_PACKET pkt;
    PIRP pseudoIrp;
    NTSTATUS status;
 
    offloadReadContext = Context;
    pseudoIrp = &offloadReadContext->PseudoIrp;
    pkt = offloadReadContext->Pkt;
    fdo = offloadReadContext->Fdo;
    listIdentifier = offloadReadContext->ListIdentifier;
 
    offloadReadContext->Pkt = NULL;
 
 
    status = pseudoIrp->IoStatus.Status;
    NT_ASSERT(status != STATUS_PENDING);
 
    if (!NT_SUCCESS(status)) {
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspPopulateTokenTransferPacketDone (%p): Generate token for list Id %x failed with %x (Pkt %p).\n",
                    fdo,
                    listIdentifier,
                    status,
                    pkt));
        goto __ClasspPopulateTokenTransferPacketDone_ErrorExit;
    }
 
    //
    // If a token was successfully generated, it is now time to retrieve the token.
    // The called function is responsible for completing the offload read DSM IRP.
    //
    ClasspReceivePopulateTokenInformation(offloadReadContext);
 
    //
    // ClasspReceivePopulateTokenInformation() takes care of completing the IRP,
    // so this function is done regardless of success or failure in
    // ClasspReceivePopulateTokenInformation().
    //
 
    return;
 
    //
    // Error cleanup label only - not used in success case:
    //
 
__ClasspPopulateTokenTransferPacketDone_ErrorExit:
 
    NT_ASSERT(!NT_SUCCESS(status));
 
    //
    // ClasspCompleteOffloadRead also cleans up offloadReadContext.
    //
 
    ClasspCompleteOffloadRead(offloadReadContext, status);
 
    return;
}

Referenced by _IRQL_requires_max_().

◆ ClasspPriorityHint()

NTSTATUS ClasspPriorityHint	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 6480 of file utils.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    PSTORAGE_PRIORITY_HINT_SUPPORT priSupport = Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS status = STATUS_SUCCESS;
 
    Irp->IoStatus.Information = 0;
 
    //
    // Check whether this device supports idle priority.
    //
    if (!fdoData->IdlePrioritySupported) {
        status = STATUS_NOT_SUPPORTED;
        goto PriorityHintExit;
    }
 
    if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
        sizeof(STORAGE_PRIORITY_HINT_SUPPORT)) {
 
        status = STATUS_BUFFER_TOO_SMALL;
        goto PriorityHintExit;
    }
 
    RtlZeroMemory(priSupport, sizeof(STORAGE_PRIORITY_HINT_SUPPORT));
 
    status = ClassForwardIrpSynchronous(commonExtension, Irp);
    if (!NT_SUCCESS(status)) {
        //
        // If I/O priority is not supported by lower drivers, just set the
        // priorities supported by class driver.
        //
        TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_IOCTL, "ClasspPriorityHint: I/O priority not supported by port driver.\n"));
        priSupport->SupportFlags = 0;
        status = STATUS_SUCCESS;
    }
 
    TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_IOCTL, "ClasspPriorityHint: I/O priorities supported by port driver: %X\n", priSupport->SupportFlags));
 
    priSupport->SupportFlags |= (1 << IoPriorityVeryLow) |
                                (1 << IoPriorityLow) |
                                (1 << IoPriorityNormal) ;
 
    TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_IOCTL, "ClasspPriorityHint: I/O priorities supported: %X\n", priSupport->SupportFlags));
    Irp->IoStatus.Information = sizeof(STORAGE_PRIORITY_HINT_SUPPORT);
 
PriorityHintExit:
 
    Irp->IoStatus.Status = status;
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspQueueLogIOEventWithContextWorker()

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
	)

Definition at line 6010 of file utils.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    POPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER ioLogMessageContextHeader = NULL;
    PVOID senseData = NULL;
    PIO_WORKITEM workItem = NULL;
    ULONG senseBufferSize = 0;
    LARGE_INTEGER lba = {0};
 
    if (!commonExtension->IsFdo) {
        return;
    }
 
    if (!Cdb) {
        return;
    }
 
    workItem = IoAllocateWorkItem(DeviceObject);
    if (!workItem) {
        goto __ClasspQueueLogIOEventWithContextWorker_ExitWithMessage;
    }
 
    if (SenseBufferSize) {
        senseData = ExAllocatePoolWithTag(NonPagedPoolNx, SenseBufferSize, CLASSPNP_POOL_TAG_LOG_MESSAGE);
        if (senseData) {
            senseBufferSize = SenseBufferSize;
        }
    }
 
    if (CdbLength == 16) {
        REVERSE_BYTES_QUAD(&lba, Cdb->CDB16.LogicalBlock);
    } else {
        ((PFOUR_BYTE)&lba.LowPart)->Byte3 = Cdb->CDB10.LogicalBlockByte0;
        ((PFOUR_BYTE)&lba.LowPart)->Byte2 = Cdb->CDB10.LogicalBlockByte1;
        ((PFOUR_BYTE)&lba.LowPart)->Byte1 = Cdb->CDB10.LogicalBlockByte2;
        ((PFOUR_BYTE)&lba.LowPart)->Byte0 = Cdb->CDB10.LogicalBlockByte3;
    }
 
    //
    // Calculate the amount of buffer required for the insertion strings.
    //
    switch (ErrorCode) {
        case IO_ERROR_IO_HARDWARE_ERROR:
        case IO_WARNING_IO_OPERATION_RETRIED: {
 
            PIO_RETRIED_LOG_MESSAGE_CONTEXT ioLogMessageContext = NULL;
 
            ioLogMessageContext = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(IO_RETRIED_LOG_MESSAGE_CONTEXT), CLASSPNP_POOL_TAG_LOG_MESSAGE);
            if (!ioLogMessageContext) {
                goto __ClasspQueueLogIOEventWithContextWorker_ExitWithMessage;
            }
 
            ioLogMessageContext->Lba.QuadPart = lba.QuadPart;
            ioLogMessageContext->DeviceNumber = fdoExtension->DeviceNumber;
 
            ioLogMessageContextHeader = (POPCODE_SENSE_DATA_IO_LOG_MESSAGE_CONTEXT_HEADER)ioLogMessageContext;
 
            break;
        }
 
        default: goto __ClasspQueueLogIOEventWithContextWorker_Exit;
    }
 
    TracePrint((TRACE_LEVEL_INFORMATION,
                TRACE_FLAG_GENERAL,
                "ClasspQueueLogIOEventWithContextWorker: DO (%p), Pkt (%p), Queueing IO retried event log message work item.\n",
                DeviceObject,
                Pkt));
 
    ioLogMessageContextHeader->WorkItem = workItem;
    if (senseData) {
        RtlCopyMemory(senseData, SenseData, SenseBufferSize);
    }
    ioLogMessageContextHeader->SenseData = senseData;
    ioLogMessageContextHeader->SenseDataSize = senseBufferSize;
    ioLogMessageContextHeader->SrbStatus = SrbStatus;
    ioLogMessageContextHeader->ScsiStatus = ScsiStatus;
    ioLogMessageContextHeader->OpCode = Cdb->CDB6GENERIC.OperationCode;
    ioLogMessageContextHeader->Reserved = 0;
    ioLogMessageContextHeader->ErrorCode = ErrorCode;
 
    ClassAcquireRemoveLock(DeviceObject, (PIRP)(workItem));
 
    //
    // Queue a work item to write the system event log.
    //
    IoQueueWorkItem(workItem, ClasspLogIOEventWithContext, DelayedWorkQueue, ioLogMessageContextHeader);
 
    return;
 
__ClasspQueueLogIOEventWithContextWorker_ExitWithMessage:
 
    TracePrint((TRACE_LEVEL_ERROR,
                TRACE_FLAG_GENERAL,
                "ClasspQueueLogIOEventWithContextWorker: DO (%p), Failed to allocate memory for the log message.\n",
                DeviceObject));
 
__ClasspQueueLogIOEventWithContextWorker_Exit:
    if (senseData) {
        ExFreePool(senseData);
    }
    if (workItem) {
        IoFreeWorkItem(workItem);
    }
    if (ioLogMessageContextHeader) {
        ExFreePool(ioLogMessageContextHeader);
    }
}

Referenced by ClassInterpretSenseInfo().

◆ ClasspReceivePopulateTokenInformation()

_IRQL_requires_same_ VOID ClasspReceivePopulateTokenInformation ( _In_ POFFLOAD_READ_CONTEXT OffloadReadContext )

Definition at line 14374 of file class.c.

{
    PVOID buffer;
    ULONG bufferLength;
    ULONG cdbLength;
    PDEVICE_OBJECT fdo;
    PIRP irp;
    ULONG listIdentifier;
    PTRANSFER_PACKET pkt;
    PIRP pseudoIrp;
    ULONG receiveTokenInformationBufferLength;
    PSCSI_REQUEST_BLOCK srb;
    NTSTATUS status;
    ULONG tempSizeUlong;
    PULONGLONG totalSectorsProcessed;
 
    totalSectorsProcessed = &OffloadReadContext->TotalSectorsProcessed;
    buffer = OffloadReadContext + 1;
    bufferLength = OffloadReadContext->BufferLength;
    fdo = OffloadReadContext->Fdo;
    irp = OffloadReadContext->OffloadReadDsmIrp;
    receiveTokenInformationBufferLength = OffloadReadContext->ReceiveTokenInformationBufferLength;
    listIdentifier = OffloadReadContext->ListIdentifier;
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspReceivePopulateTokenInformation (%p): Entering function. Irp %p\n",
                fdo,
                irp));
 
    srb = &OffloadReadContext->Srb;
    *totalSectorsProcessed = 0;
 
    pkt = DequeueFreeTransferPacket(fdo, TRUE);
    if (!pkt){
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspReceivePopulateTokenInformation (%p): Failed to retrieve transfer packet for ReceiveTokenInformation (PopulateToken) operation.\n",
                    fdo));
 
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto __ClasspReceivePopulateTokenInformation_ErrorExit;
    }
 
    OffloadReadContext->Pkt = pkt;
 
    RtlZeroMemory(buffer, bufferLength);
 
    tempSizeUlong = receiveTokenInformationBufferLength - 4;
    REVERSE_BYTES(((PRECEIVE_TOKEN_INFORMATION_HEADER)buffer)->AvailableData, &tempSizeUlong);
 
    pseudoIrp = &OffloadReadContext->PseudoIrp;
    RtlZeroMemory(pseudoIrp, sizeof(IRP));
 
 
    pseudoIrp->IoStatus.Status = STATUS_SUCCESS;
    pseudoIrp->IoStatus.Information = 0;
    pseudoIrp->Tail.Overlay.DriverContext[0] = LongToPtr(1);
    pseudoIrp->MdlAddress = OffloadReadContext->PopulateTokenMdl;
 
    ClasspSetupReceivePopulateTokenInformationTransferPacket(
        OffloadReadContext,
        pkt,
        receiveTokenInformationBufferLength,
        (PUCHAR)buffer,
        pseudoIrp,
        listIdentifier);
 
    //
    // Cache away the CDB as it may be required for forwarded sense data
    // after this command completes.
    //
    RtlZeroMemory(srb, sizeof(*srb));
    cdbLength = SrbGetCdbLength(pkt->Srb);
    if (cdbLength <= 16) {
        RtlCopyMemory(&srb->Cdb, SrbGetCdb(pkt->Srb), cdbLength);
    }
 
    SubmitTransferPacket(pkt);
 
    return;
 
    //
    // Error cleanup label only - not used in success case:
    //
 
__ClasspReceivePopulateTokenInformation_ErrorExit:
 
    NT_ASSERT(!NT_SUCCESS(status));
 
    //
    // ClasspCompleteOffloadRead also cleans up offloadReadContext.
    //
 
    ClasspCompleteOffloadRead(OffloadReadContext, status);
 
    return;
}

Referenced by ClasspPopulateTokenTransferPacketDone().

◆ ClasspReceivePopulateTokenInformationTransferPacketDone()

VOID ClasspReceivePopulateTokenInformationTransferPacketDone ( _In_ PVOID Context )

Definition at line 14504 of file class.c.

{
    ULONG availableData;
    PVOID buffer;
    UCHAR completionStatus;
    ULONG estimatedRetryInterval;
    PDEVICE_OBJECT fdo;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
    PIRP irp;
    ULONG listIdentifier;
    POFFLOAD_READ_CONTEXT offloadReadContext;
    BOOLEAN operationCompleted;
    UCHAR operationStatus;
    PIRP pseudoIrp;
    USHORT segmentsProcessed;
    PSENSE_DATA senseData;
    ULONG senseDataFieldLength;
    UCHAR senseDataLength;
    PSCSI_REQUEST_BLOCK srb;
    NTSTATUS status;
    PUCHAR token;
    PVOID tokenAscii;
    PBLOCK_DEVICE_TOKEN_DESCRIPTOR tokenDescriptor;
    ULONG tokenDescriptorLength;
    PRECEIVE_TOKEN_INFORMATION_HEADER tokenInformationResults;
    PRECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER tokenInformationResultsResponse;
    ULONG tokenLength;
    ULONG tokenSize;
    PULONGLONG totalSectorsProcessed;
    ULONGLONG totalSectorsToProcess;
    ULONGLONG transferBlockCount;
 
    offloadReadContext = Context;
    fdo = offloadReadContext->Fdo;
    fdoExt = fdo->DeviceExtension;
    buffer = offloadReadContext + 1;
    listIdentifier = offloadReadContext->ListIdentifier;
    irp = offloadReadContext->OffloadReadDsmIrp;
    totalSectorsToProcess = offloadReadContext->TotalSectorsToProcess;
    totalSectorsProcessed = &offloadReadContext->TotalSectorsProcessed;
    srb = &offloadReadContext->Srb;
    tokenAscii = NULL;
    tokenSize = BLOCK_DEVICE_TOKEN_SIZE;
    tokenInformationResults = (PRECEIVE_TOKEN_INFORMATION_HEADER)buffer;
    senseData = (PSENSE_DATA)((PUCHAR)tokenInformationResults + FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData));
    transferBlockCount = 0;
    tokenInformationResultsResponse = NULL;
    tokenDescriptor = NULL;
    operationCompleted = FALSE;
    tokenDescriptorLength = 0;
    tokenLength = 0;
    token = NULL;
    pseudoIrp = &offloadReadContext->PseudoIrp;
 
    status = pseudoIrp->IoStatus.Status;
    NT_ASSERT(status != STATUS_PENDING);
 
    //
    // The buffer we hand allows for the max sizes for all the fields whereas the returned
    // data may be lesser (e.g. sense data info will almost never be MAX_SENSE_BUFFER_SIZE, etc.
    // so handle underrun "error"
    //
    if (status == STATUS_DATA_OVERRUN) {
 
        status = STATUS_SUCCESS;
    }
 
    if (!NT_SUCCESS(status)) {
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Token retrieval failed for list Id %x with %x.\n",
                    fdo,
                    listIdentifier,
                    status));
        goto __ClasspReceivePopulateTokenInformationTransferPacketDone_Exit;
    }
 
    REVERSE_BYTES(&availableData, &tokenInformationResults->AvailableData);
 
    NT_ASSERT(availableData <= FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData) + MAX_SENSE_BUFFER_SIZE +
                               FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER, TokenDescriptor) + BLOCK_DEVICE_TOKEN_SIZE);
 
    NT_ASSERT(tokenInformationResults->ResponseToServiceAction == SERVICE_ACTION_POPULATE_TOKEN);
 
    operationStatus = tokenInformationResults->OperationStatus;
    operationCompleted = ClasspIsTokenOperationComplete(operationStatus);
    NT_ASSERT(operationCompleted);
 
    REVERSE_BYTES(&estimatedRetryInterval, &tokenInformationResults->EstimatedStatusUpdateDelay);
 
    completionStatus = tokenInformationResults->CompletionStatus;
 
    NT_ASSERT(tokenInformationResults->TransferCountUnits == TRANSFER_COUNT_UNITS_NUMBER_BLOCKS);
    REVERSE_BYTES_QUAD(&transferBlockCount, &tokenInformationResults->TransferCount);
 
    REVERSE_BYTES_SHORT(&segmentsProcessed, &tokenInformationResults->SegmentsProcessed);
    NT_ASSERT(segmentsProcessed == 0);
 
    if (operationCompleted) {
 
        if (transferBlockCount > totalSectorsToProcess) {
 
            //
            // Buggy or hostile target.  Don't let it claim more was procesed
            // than was requested.  Since this is likely a bug and it's unknown
            // how much was actually transferred, assume no data was
            // transferred.
            //
 
            NT_ASSERT(transferBlockCount <= totalSectorsToProcess);
            transferBlockCount = 0;
        }
 
        if (operationStatus != OPERATION_COMPLETED_WITH_SUCCESS &&
            operationStatus != OPERATION_COMPLETED_WITH_RESIDUAL_DATA) {
 
            //
            // Assert on buggy response from target, but in any case, make sure not
            // to claim that any data was written.
            //
 
            NT_ASSERT(transferBlockCount == 0);
            transferBlockCount = 0;
        }
 
        //
        // Since the TokenOperation was sent down synchronously, the operation is complete as soon as the command returns.
        //
 
        senseDataFieldLength = tokenInformationResults->SenseDataFieldLength;
        senseDataLength = tokenInformationResults->SenseDataLength;
        NT_ASSERT(senseDataFieldLength >= senseDataLength);
 
        tokenInformationResultsResponse = (PRECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER)((PUCHAR)tokenInformationResults +
                                                                                               FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData) +
                                                                                               tokenInformationResults->SenseDataFieldLength);
 
        REVERSE_BYTES(&tokenDescriptorLength, &tokenInformationResultsResponse->TokenDescriptorsLength);
 
        if (tokenDescriptorLength > 0) {
 
            NT_ASSERT(tokenDescriptorLength == sizeof(BLOCK_DEVICE_TOKEN_DESCRIPTOR));
 
            if (tokenDescriptorLength != sizeof(BLOCK_DEVICE_TOKEN_DESCRIPTOR)) {
 
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_IOCTL,
                            "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Bad firmware, token descriptor length %u.\n",
                            fdo,
                            tokenDescriptorLength));
 
                NT_ASSERT((*totalSectorsProcessed) == 0);
                NT_ASSERT(tokenLength == 0);
 
            } else {
 
                USHORT restrictedId;
 
                tokenDescriptor = (PBLOCK_DEVICE_TOKEN_DESCRIPTOR)tokenInformationResultsResponse->TokenDescriptor;
 
                REVERSE_BYTES_SHORT(&restrictedId, &tokenDescriptor->TokenIdentifier);
                NT_ASSERT(restrictedId == 0);
 
                tokenLength = BLOCK_DEVICE_TOKEN_SIZE;
                token = tokenDescriptor->Token;
 
                *totalSectorsProcessed = transferBlockCount;
 
                if (transferBlockCount < totalSectorsToProcess) {
 
                    NT_ASSERT(operationStatus == OPERATION_COMPLETED_WITH_RESIDUAL_DATA ||
                              operationStatus == OPERATION_COMPLETED_WITH_ERROR ||
                              operationStatus == OPERATION_TERMINATED);
 
                    if (transferBlockCount == 0) {
                        //
                        // Treat the same as not getting a token.
                        //
 
                        tokenLength = 0;
                    }
 
                } else {
 
                    NT_ASSERT(operationStatus == OPERATION_COMPLETED_WITH_SUCCESS);
                    NT_ASSERT(transferBlockCount == totalSectorsToProcess);
                }
 
                    //
                    // Need to convert to ascii.
                    //
                    tokenAscii = ClasspBinaryToAscii((PUCHAR)token,
                                                     tokenSize,
                                                     &tokenSize);
 
                    TracePrint((transferBlockCount == totalSectorsToProcess ? TRACE_LEVEL_INFORMATION : TRACE_LEVEL_WARNING,
                                TRACE_FLAG_IOCTL,
                                "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): %wsToken %s generated successfully for list Id %x for data size %I64u bytes.\n",
                                fdo,
                                transferBlockCount == totalSectorsToProcess ? L"" : L"Target truncated read. ",
                                (tokenAscii == NULL) ? "" : tokenAscii,
                                listIdentifier,
                                (*totalSectorsProcessed) * fdoExt->DiskGeometry.BytesPerSector));
 
                    FREE_POOL(tokenAscii);
            }
        } else {
 
            TracePrint((TRACE_LEVEL_ERROR,
                        TRACE_FLAG_IOCTL,
                        "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Target failed to generate a token for list Id %x for data size %I64u bytes (requested %I64u bytes).\n",
                        fdo,
                        listIdentifier,
                        transferBlockCount * fdoExt->DiskGeometry.BytesPerSector,
                        totalSectorsToProcess * fdoExt->DiskGeometry.BytesPerSector));
 
            *totalSectorsProcessed = 0;
 
            NT_ASSERT(operationStatus == OPERATION_COMPLETED_WITH_ERROR);
        }
 
        //
        // Operation that completes with success can have sense data (for target to pass on some extra info)
        // but we don't care about such sense info.
        // Operation that complete but not with success, may not have sense data associated, but may
        // have valid CompletionStatus.
        //
        // The "status" may be overriden by ClassInterpretSenseInfo().  Final
        // status is determined a bit later - this is just the default status
        // when ClassInterpretSenseInfo() doesn't get to run here.
        //
        status = STATUS_SUCCESS;
        if (operationStatus == OPERATION_COMPLETED_WITH_ERROR ||
            operationStatus == OPERATION_COMPLETED_WITH_RESIDUAL_DATA ||
            operationStatus == OPERATION_TERMINATED) {
 
            SrbSetScsiStatus((PSTORAGE_REQUEST_BLOCK_HEADER)srb, completionStatus);
 
            if (senseDataLength) {
 
                ULONG retryInterval;
 
                NT_ASSERT(senseDataLength <= sizeof(SENSE_DATA));
 
                srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
 
                srb->SrbStatus = SRB_STATUS_AUTOSENSE_VALID | SRB_STATUS_ERROR;
                SrbSetSenseInfoBuffer((PSTORAGE_REQUEST_BLOCK_HEADER)srb, senseData);
                SrbSetSenseInfoBufferLength((PSTORAGE_REQUEST_BLOCK_HEADER)srb, senseDataLength);
 
                ClassInterpretSenseInfo(fdo,
                                        srb,
                                        IRP_MJ_SCSI,
                                        0,
                                        0,
                                        &status,
                                        &retryInterval);
 
                TracePrint((TRACE_LEVEL_WARNING,
                            TRACE_FLAG_IOCTL,
                            "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Reason for truncation/failure: %x - for list Id %x for data size %I64u bytes.\n",
                            fdo,
                            status,
                            listIdentifier,
                            transferBlockCount * fdoExt->DiskGeometry.BytesPerSector));
            } else {
 
                TracePrint((TRACE_LEVEL_WARNING,
                            TRACE_FLAG_IOCTL,
                            "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): No sense data available but reason for truncation/failure, possibly: %x - for list Id %x for data size %I64u bytes.\n",
                            fdo,
                            completionStatus,
                            listIdentifier,
                            transferBlockCount * fdoExt->DiskGeometry.BytesPerSector));
            }
        }
 
        if (tokenLength > 0) {
 
            offloadReadContext->Token = token;
 
            //
            // Even if target returned an error, from the OS upper layers' perspective,
            // it is a success (with truncation) if any data at all was read.
            //
            status = STATUS_SUCCESS;
 
        } else {
 
            if (NT_SUCCESS(status)) {
                //
                // Make sure status is a failing status, without throwing away an
                // already-failing status obtained from sense data.
                //
                status = STATUS_UNSUCCESSFUL;
            }
        }
 
        //
        // Done with the operation.
        //
 
        NT_ASSERT(status != STATUS_PENDING);
        goto __ClasspReceivePopulateTokenInformationTransferPacketDone_Exit;
 
    } else {
 
        status = STATUS_UNSUCCESSFUL;
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Token retrieval failed for list Id %x with %x.\n",
                    fdo,
                    listIdentifier,
                    status));
 
        NT_ASSERT(*totalSectorsProcessed == 0);
        goto __ClasspReceivePopulateTokenInformationTransferPacketDone_Exit;
    }
 
__ClasspReceivePopulateTokenInformationTransferPacketDone_Exit:
 
    if (status != STATUS_PENDING) {
 
        //
        // The "status" value can be success or failure at this point, as
        // appropriate.
        //
 
        ClasspCompleteOffloadRead(offloadReadContext, status);
    }
 
    //
    // Due to tracing a potentially freed pointer value "Irp", this trace could
    // be delayed beyond another offload op picking up the same pointer value
    // for its Irp.  This function exits after the operation is complete when
    // status != STATUS_PENDING.
    //
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspReceivePopulateTokenInformationTransferPacketDone (%p): Exiting function (Irp %p) with internal status %x.\n",
                fdo,
                irp,
                status));
 
    return;
}

◆ ClasspReceiveWriteUsingTokenInformation()

_IRQL_requires_same_ VOID ClasspReceiveWriteUsingTokenInformation ( _In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext )

Definition at line 15937 of file class.c.

{
    PVOID buffer;
    ULONG bufferLength;
    ULONG cdbLength;
    PDEVICE_OBJECT fdo;
    PIRP irp;
    ULONG listIdentifier;
    PTRANSFER_PACKET pkt;
    PIRP pseudoIrp;
    ULONG receiveTokenInformationBufferLength;
    PSCSI_REQUEST_BLOCK srb;
    NTSTATUS status;
    ULONG tempSizeUlong;
    PMDL writeUsingTokenMdl;
 
    fdo = OffloadWriteContext->Fdo;
    irp = OffloadWriteContext->OffloadWriteDsmIrp;
    pseudoIrp = &OffloadWriteContext->PseudoIrp;
    buffer = OffloadWriteContext + 1;
    bufferLength = OffloadWriteContext->BufferLength;
    receiveTokenInformationBufferLength = OffloadWriteContext->ReceiveTokenInformationBufferLength;
    writeUsingTokenMdl = OffloadWriteContext->WriteUsingTokenMdl;
    listIdentifier = OffloadWriteContext->ListIdentifier;
    srb = &OffloadWriteContext->Srb;
    status = STATUS_SUCCESS;
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspReceiveWriteUsingTokenInformation (%p): Entering function. Irp %p\n",
                fdo,
                irp));
 
    //
    // The WRITE USING TOKEN wasn't immediately fully successful, so that means
    // the only way to find out how many sectors were processed by the WRITE
    // USING TOKEN is to get a successful RECEIVE ROD TOKEN INFORMATION that
    // indicates the operation is complete.
    //
 
    NT_ASSERT(OffloadWriteContext->TotalSectorsProcessed == 0);
 
    pkt = DequeueFreeTransferPacket(fdo, TRUE);
 
    if (!pkt) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspReceiveWriteUsingTokenInformation (%p): Failed to retrieve transfer packet for ReceiveTokenInformation (WriteUsingToken) operation.\n",
                    fdo));
 
        status = STATUS_INSUFFICIENT_RESOURCES;
 
        goto __ClasspReceiveWriteUsingTokenInformation_ErrorExit;
    }
 
    RtlZeroMemory(buffer, bufferLength);
 
    tempSizeUlong = receiveTokenInformationBufferLength - 4;
    REVERSE_BYTES(((PRECEIVE_TOKEN_INFORMATION_HEADER)buffer)->AvailableData, &tempSizeUlong);
 
    RtlZeroMemory(pseudoIrp, sizeof(IRP));
 
    pseudoIrp->IoStatus.Status = STATUS_SUCCESS;
    pseudoIrp->IoStatus.Information = 0;
    pseudoIrp->Tail.Overlay.DriverContext[0] = LongToPtr(1);
    pseudoIrp->MdlAddress = writeUsingTokenMdl;
 
    ClasspSetupReceiveWriteUsingTokenInformationTransferPacket(
        OffloadWriteContext,
        pkt,
        bufferLength,
        (PUCHAR)buffer,
        pseudoIrp,
        listIdentifier);
 
    //
    // Cache away the CDB as it may be required for forwarded sense data
    // after this command completes.
    //
    RtlZeroMemory(srb, sizeof(*srb));
    cdbLength = SrbGetCdbLength(pkt->Srb);
    if (cdbLength <= 16) {
        RtlCopyMemory(&srb->Cdb, SrbGetCdb(pkt->Srb), cdbLength);
    }
 
    SubmitTransferPacket(pkt);
 
    return;
 
    //
    // Error label only - not used by success cases:
    //
 
__ClasspReceiveWriteUsingTokenInformation_ErrorExit:
 
    NT_ASSERT(!NT_SUCCESS(status));
 
    //
    // ClasspCompleteOffloadWrite also cleans up OffloadWriteContext.
    //
 
    ClasspCompleteOffloadWrite(OffloadWriteContext, status);
 
    return;
}

Referenced by ClasspWriteUsingTokenTransferPacketDone().

◆ ClasspReceiveWriteUsingTokenInformationDone()

VOID ClasspReceiveWriteUsingTokenInformationDone	(	_In_ POFFLOAD_WRITE_CONTEXT	OffloadWriteContext,
		_In_ NTSTATUS	CompletionCausingStatus
	)

Definition at line 15695 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = OffloadWriteContext->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
 
    //
    // Time taken in 100ns units.
    //
    ULONGLONG durationIn100ns = (KeQueryInterruptTime() - OffloadWriteContext->OperationStartTime);
    ULONGLONG maxTargetDuration = fdoData->CopyOffloadMaxTargetDuration * 10ULL * 1000 * 1000;
 
    NT_ASSERT(
        OffloadWriteContext->TotalSectorsProcessedSuccessfully <=
        OffloadWriteContext->TotalRequestSizeSectors);
 
 
    if (OffloadWriteContext->TotalSectorsProcessedSuccessfully == OffloadWriteContext->TotalRequestSizeSectors) {
 
        ClasspCompleteOffloadWrite(OffloadWriteContext, CompletionCausingStatus);
 
        goto __ClasspReceiveWriteUsingTokenInformationDone_Exit;
    }
 
    //
    // Since we don't want a layered timeout mechanism (e.g. guest and parent OS in Hyper-V scenarios)
    // to cause a SCSI timeout for the higher layer token operations.
    //
    if (maxTargetDuration <= durationIn100ns) {
 
        TracePrint((TRACE_LEVEL_WARNING,
                    TRACE_FLAG_IOCTL,
                    "ClasspReceiveWriteUsingTokenInformationDone (%p): Truncating write (list id %x) because of max-duration-rule.\n",
                    OffloadWriteContext->Fdo,
                    OffloadWriteContext->ListIdentifier));
 
        //
        // We could technically pass in STATUS_IO_OPERATION_TIMEOUT, but ClasspCompleteOffloadWrite
        // won't end up doing anything (useful) with this status, since some bytes would already
        // have been transferred.
        //
        ClasspCompleteOffloadWrite(OffloadWriteContext, STATUS_UNSUCCESSFUL);
 
        goto __ClasspReceiveWriteUsingTokenInformationDone_Exit;
    }
 
    NT_ASSERT(
        OffloadWriteContext->TotalSectorsProcessedSuccessfully <
        OffloadWriteContext->TotalRequestSizeSectors);
 
    //
    // Keep going with the next sub-request.
    //
 
    ClasspContinueOffloadWrite(OffloadWriteContext);
 
__ClasspReceiveWriteUsingTokenInformationDone_Exit:
 
    return;
}

Referenced by ClasspReceiveWriteUsingTokenInformationTransferPacketDone(), and ClasspWriteUsingTokenTransferPacketDone().

◆ ClasspReceiveWriteUsingTokenInformationTransferPacketDone()

VOID ClasspReceiveWriteUsingTokenInformationTransferPacketDone ( _In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext )

Definition at line 16071 of file class.c.

{
    ULONG availableData;
    PVOID buffer;
    UCHAR completionStatus;
    ULONG estimatedRetryInterval;
    PDEVICE_OBJECT fdo;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
    PIRP irp;
    ULONG listIdentifier;
    BOOLEAN operationCompleted;
    UCHAR operationStatus;
    PIRP pseudoIrp;
    USHORT segmentsProcessed;
    PSENSE_DATA senseData;
    ULONG senseDataFieldLength;
    UCHAR senseDataLength;
    PSCSI_REQUEST_BLOCK srb;
    NTSTATUS status;
    ULONG tokenDescriptorLength;
    PRECEIVE_TOKEN_INFORMATION_HEADER tokenInformationResults;
    PRECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER tokenInformationResponsePadding;
    PBOOLEAN tokenInvalidated;
    PULONGLONG totalSectorsProcessed;
    ULONGLONG totalSectorsToProcess;
    ULONGLONG transferBlockCount;
 
    fdo = OffloadWriteContext->Fdo;
    fdoExt = fdo->DeviceExtension;
    listIdentifier = OffloadWriteContext->ListIdentifier;
    totalSectorsProcessed = &OffloadWriteContext->TotalSectorsProcessed;
    totalSectorsToProcess = OffloadWriteContext->TotalSectorsToProcess;
    irp = OffloadWriteContext->OffloadWriteDsmIrp;
    pseudoIrp = &OffloadWriteContext->PseudoIrp;
    tokenInvalidated = &OffloadWriteContext->TokenInvalidated;
    srb = &OffloadWriteContext->Srb;
    operationCompleted = FALSE;
    buffer = OffloadWriteContext + 1;
    tokenInformationResults = (PRECEIVE_TOKEN_INFORMATION_HEADER)buffer;
    senseData = (PSENSE_DATA)((PUCHAR)tokenInformationResults + FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData));
    transferBlockCount = 0;
    tokenInformationResponsePadding = NULL;
    tokenDescriptorLength = 0;
 
    NT_ASSERT((*totalSectorsProcessed) == 0);
 
    OffloadWriteContext->Pkt = NULL;
 
 
    status = pseudoIrp->IoStatus.Status;
    NT_ASSERT(status != STATUS_PENDING);
 
    //
    // The buffer we hand allows for the max sizes for all the fields whereas the returned
    // data may be lesser (e.g. sense data info will almost never be MAX_SENSE_BUFFER_SIZE, etc.
    // so handle underrun "error"
    //
    if (status == STATUS_DATA_OVERRUN) {
 
        status = STATUS_SUCCESS;
    }
 
    if (!NT_SUCCESS(status)) {
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): Failed with %x to retrieve write results for list Id %x for data size %I64u bytes.\n",
                    fdo,
                    status,
                    listIdentifier,
                    totalSectorsToProcess * fdoExt->DiskGeometry.BytesPerSector));
 
        NT_ASSERT((*totalSectorsProcessed) == 0);
 
        goto __ClasspReceiveWriteUsingTokenInformationTransferPacketDone_ErrorExit;
    }
 
    REVERSE_BYTES(&availableData, &tokenInformationResults->AvailableData);
 
    NT_ASSERT(availableData <= FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData) + MAX_SENSE_BUFFER_SIZE);
 
    NT_ASSERT(tokenInformationResults->ResponseToServiceAction == SERVICE_ACTION_WRITE_USING_TOKEN);
 
    operationStatus = tokenInformationResults->OperationStatus;
    operationCompleted = ClasspIsTokenOperationComplete(operationStatus);
    NT_ASSERT(operationCompleted);
 
    REVERSE_BYTES(&estimatedRetryInterval, &tokenInformationResults->EstimatedStatusUpdateDelay);
 
    completionStatus = tokenInformationResults->CompletionStatus;
 
    senseDataFieldLength = tokenInformationResults->SenseDataFieldLength;
    senseDataLength = tokenInformationResults->SenseDataLength;
    NT_ASSERT(senseDataFieldLength >= senseDataLength);
 
    tokenInformationResponsePadding = (PRECEIVE_TOKEN_INFORMATION_RESPONSE_HEADER)((PUCHAR)tokenInformationResults +
                                                                                           FIELD_OFFSET(RECEIVE_TOKEN_INFORMATION_HEADER, SenseData) +
                                                                                           tokenInformationResults->SenseDataFieldLength);
 
    REVERSE_BYTES(&tokenDescriptorLength, &tokenInformationResponsePadding->TokenDescriptorsLength);
    NT_ASSERT(tokenDescriptorLength == 0);
 
    NT_ASSERT(tokenInformationResults->TransferCountUnits == TRANSFER_COUNT_UNITS_NUMBER_BLOCKS);
    REVERSE_BYTES_QUAD(&transferBlockCount, &tokenInformationResults->TransferCount);
 
    REVERSE_BYTES_SHORT(&segmentsProcessed, &tokenInformationResults->SegmentsProcessed);
    NT_ASSERT(segmentsProcessed == 0);
 
    if (operationCompleted) {
 
        if (transferBlockCount > totalSectorsToProcess) {
 
            //
            // Buggy or hostile target.  Don't let it claim more was procesed
            // than was requested.  Since this is likely a bug and it's unknown
            // how much was actually transferred, assume no data was
            // transferred.
            //
 
            NT_ASSERT(transferBlockCount <= totalSectorsToProcess);
            transferBlockCount = 0;
        }
 
        if (operationStatus != OPERATION_COMPLETED_WITH_SUCCESS &&
            operationStatus != OPERATION_COMPLETED_WITH_RESIDUAL_DATA) {
 
            //
            // Assert on buggy response from target, but in any case, make sure not
            // to claim that any data was written.
            //
 
            NT_ASSERT(transferBlockCount == 0);
            transferBlockCount = 0;
        }
 
        //
        // Since the TokenOperation was sent down synchronously but failed, the operation is complete as soon as the
        // ReceiveTokenInformation command returns.
        //
 
        NT_ASSERT((*totalSectorsProcessed) == 0);
        *totalSectorsProcessed = transferBlockCount;
        ClasspAdvanceOffloadWritePosition(OffloadWriteContext, transferBlockCount);
 
        if (transferBlockCount < totalSectorsToProcess) {
 
            NT_ASSERT(operationStatus == OPERATION_COMPLETED_WITH_RESIDUAL_DATA ||
                      operationStatus == OPERATION_COMPLETED_WITH_ERROR ||
                      operationStatus == OPERATION_TERMINATED);
 
        } else {
 
            NT_ASSERT(operationStatus == OPERATION_COMPLETED_WITH_SUCCESS);
        }
 
        TracePrint((transferBlockCount == totalSectorsToProcess ? TRACE_LEVEL_INFORMATION : TRACE_LEVEL_WARNING,
                    TRACE_FLAG_IOCTL,
                    "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): %wsSuccessfully wrote (for list Id %x) for data size %I64u bytes\n",
                    fdo,
                    transferBlockCount == totalSectorsToProcess ? L"" : L"Target truncated write. ",
                    listIdentifier,
                    (*totalSectorsProcessed) * fdoExt->DiskGeometry.BytesPerSector));
 
        //
        // Operation that completes with success can have sense data (for target to pass on some extra info)
        // but we don't care about such sense info.
        // Operation that complete but not with success, may not have sense data associated, but may
        // have valid CompletionStatus.
        //
        // The "status" may be overriden by ClassInterpretSenseInfo().  Final
        // status is determined a bit later - this is just the default status
        // when ClassInterpretSenseInfo() doesn't get to run here.
        //
        status = STATUS_SUCCESS;
        if (operationStatus == OPERATION_COMPLETED_WITH_ERROR ||
            operationStatus == OPERATION_COMPLETED_WITH_RESIDUAL_DATA ||
            operationStatus == OPERATION_TERMINATED) {
 
            SrbSetScsiStatus((PSTORAGE_REQUEST_BLOCK_HEADER)srb, completionStatus);
 
            if (senseDataLength) {
 
                ULONG retryInterval;
 
                NT_ASSERT(senseDataLength <= sizeof(SENSE_DATA));
 
                srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
 
                srb->SrbStatus = SRB_STATUS_AUTOSENSE_VALID | SRB_STATUS_ERROR;
                SrbSetSenseInfoBuffer((PSTORAGE_REQUEST_BLOCK_HEADER)srb, senseData);
                SrbSetSenseInfoBufferLength((PSTORAGE_REQUEST_BLOCK_HEADER)srb, senseDataLength);
 
                ClassInterpretSenseInfo(fdo,
                                        srb,
                                        IRP_MJ_SCSI,
                                        0,
                                        0,
                                        &status,
                                        &retryInterval);
 
                TracePrint((TRACE_LEVEL_WARNING,
                            TRACE_FLAG_IOCTL,
                            "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): Reason for truncation/failure: %x - for list Id %x for data size %I64u bytes.\n",
                            fdo,
                            status,
                            listIdentifier,
                            transferBlockCount * fdoExt->DiskGeometry.BytesPerSector));
 
                //
                // If the token isn't valid any longer, we should let the upper layers know so that
                // they don't waste time retrying the write with the same token.
                //
                if (status == STATUS_INVALID_TOKEN) {
 
                    *tokenInvalidated = TRUE;
                }
            } else {
 
                TracePrint((TRACE_LEVEL_WARNING,
                            TRACE_FLAG_IOCTL,
                            "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): No sense data available but reason for truncation/failure, possibly: %x - for list Id %x for data size %I64u bytes.\n",
                            fdo,
                            completionStatus,
                            listIdentifier,
                            transferBlockCount * fdoExt->DiskGeometry.BytesPerSector));
            }
        }
 
        //
        // Initialize status. Upper layer needs to know if command failed because it
        // timed out without doing any writing.  ClasspCompleteOffloadWrite() will
        // force status to success if any data was written, so it's this function's
        // job to set the status appropriately based on the outcome of this
        // WRITE USING TOKEN command, and then ClasspCompleteOffloadWrite()
        // can override with success if previos WRITE USING TOKEN commands
        // issued for the same upper request were able to write some data.
        //
        if (transferBlockCount != 0) {
            status = STATUS_SUCCESS;
        } else {
 
            if (NT_SUCCESS(status)) {
                //
                // Make sure status is a failing status, without throwing away an
                // already-failing status obtained from sense data.
                //
                status = STATUS_UNSUCCESSFUL;
            }
        }
 
        NT_ASSERT(status != STATUS_PENDING);
 
        if (!NT_SUCCESS(status)) {
            goto __ClasspReceiveWriteUsingTokenInformationTransferPacketDone_ErrorExit;
        }
 
        ClasspReceiveWriteUsingTokenInformationDone(OffloadWriteContext, status);
        status = STATUS_PENDING;
        goto __ClasspReceiveWriteUsingTokenInformationTransferPacketDone_Exit;
 
    } else {
 
        status = STATUS_UNSUCCESSFUL;
 
        goto __ClasspReceiveWriteUsingTokenInformationTransferPacketDone_ErrorExit;
    }
 
    //
    // Error label only - not used in success case:
    //
 
__ClasspReceiveWriteUsingTokenInformationTransferPacketDone_ErrorExit:
 
    NT_ASSERT(!NT_SUCCESS(status));
 
    ClasspCompleteOffloadWrite(OffloadWriteContext, status);
 
__ClasspReceiveWriteUsingTokenInformationTransferPacketDone_Exit:
 
    //
    // Due to tracing a potentially freed pointer value "Irp", this trace could
    // be delayed beyond another offload op picking up the same pointer value
    // for its Irp.
    //
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspReceiveWriteUsingTokenInformationTransferPacketDone (%p): Exiting function (Irp %p) with status %x.\n",
                fdo,
                irp,
                status));
 
    return;
}

◆ ClasspRefreshFunctionSupportInfo()

NTSTATUS ClasspRefreshFunctionSupportInfo	(	_Inout_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_In_ BOOLEAN	ForceQuery
	)

Definition at line 16395 of file class.c.

{
    NTSTATUS            status;
    PSCSI_REQUEST_BLOCK srb = NULL;
    ULONG               srbSize;
    CLASS_VPD_B0_DATA   blockLimitsDataNew;
    PCLASS_VPD_B0_DATA  blockLimitsDataOriginal;
    KLOCK_QUEUE_HANDLE  lockHandle;
    ULONG               generationCount;
    ULONG               changeRequestCount;
 
    //
    // ChangeRequestCount is incremented every time we get an unit attention with
    // SCSI_ADSENSE_OPERATING_CONDITIONS_CHANGED.  GenerationCount will be set to
    // ChangeRequestCount after CLASS_FUNCTION_SUPPORT_INFO is refreshed with the latest
    // VPD data.  i.e.  if both values are the same, data in
    // CLASS_FUNCTION_SUPPORT_INFO is current
    //
 
    generationCount = FdoExtension->FunctionSupportInfo->GenerationCount;
    changeRequestCount = FdoExtension->FunctionSupportInfo->ChangeRequestCount;
    if (!ForceQuery && generationCount == changeRequestCount) {
        return STATUS_SUCCESS;
    }
 
    //
    // Allocate an SRB for querying the device for LBP-related info if either
    // the Logical Block Provisioning (0xB2) or Block Limits (0xB0) VPD page
    // exists.
    //
    if ((FdoExtension->AdapterDescriptor != NULL) &&
        (FdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK)) {
        srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
    } else {
        srbSize = sizeof(SCSI_REQUEST_BLOCK);
    }
 
    srb = ExAllocatePoolWithTag(NonPagedPoolNx, srbSize, '1DcS');
    if (srb == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    status = ClasspDeviceGetBlockLimitsVPDPage(FdoExtension,
                                               srb,
                                               srbSize,
                                               &blockLimitsDataNew);
 
    if (NT_SUCCESS(status)) {
 
        KeAcquireInStackQueuedSpinLock(&FdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);
 
        //
        // If the generationCount didn't change since we looked at it last time, it means
        // no one has tried to update the CLASS_FUNCTION_SUPPORT_INFO data; otherwise, someone
        // else has beat us to it.
        //
        if (generationCount == FdoExtension->FunctionSupportInfo->GenerationCount) {
 
            blockLimitsDataOriginal = &FdoExtension->FunctionSupportInfo->BlockLimitsData;
            if (blockLimitsDataOriginal->CommandStatus == -1) {
                //
                // CommandStatus == -1 means this is the first time we have
                // gotten the block limits data.
                //
                *blockLimitsDataOriginal = blockLimitsDataNew;
            } else {
                //
                // We only expect the Optimal Unmap Granularity (and alignment)
                // to change, so those are the only parameters we update.
                //
                blockLimitsDataOriginal->UGAVALID = blockLimitsDataNew.UGAVALID;
                blockLimitsDataOriginal->UnmapGranularityAlignment = blockLimitsDataNew.UnmapGranularityAlignment;
                blockLimitsDataOriginal->OptimalUnmapGranularity = blockLimitsDataNew.OptimalUnmapGranularity;
            }
            FdoExtension->FunctionSupportInfo->GenerationCount = changeRequestCount;
        }
 
        KeReleaseInStackQueuedSpinLock(&lockHandle);
    }
 
    FREE_POOL(srb);
    return status;
}

Referenced by ClasspBlockLimitsDataSnapshot().

◆ ClasspRegisterMountedDeviceInterface()

VOID ClasspRegisterMountedDeviceInterface ( IN PDEVICE_OBJECT DeviceObject )

Definition at line 10970 of file class.c.

{
 
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    BOOLEAN isFdo = commonExtension->IsFdo;
    PDEVICE_OBJECT pdo;
    UNICODE_STRING interfaceName;
 
    NTSTATUS status;
 
    PAGED_CODE();
 
    if(isFdo) {
 
        PFUNCTIONAL_DEVICE_EXTENSION functionalExtension;
 
        functionalExtension =
            (PFUNCTIONAL_DEVICE_EXTENSION) commonExtension;
        pdo = functionalExtension->LowerPdo;
    } else {
        pdo = DeviceObject;
    }
 
#ifdef _MSC_VER
#pragma prefast(suppress:6014, "The allocated memory that interfaceName points to will be freed in ClassRemoveDevice().")
#endif
    status = IoRegisterDeviceInterface(
                pdo,
                &MOUNTDEV_MOUNTED_DEVICE_GUID,
                NULL,
                &interfaceName
                );
 
    if(NT_SUCCESS(status)) {
 
        //
        // Copy the interface name before setting the interface state - the
        // name is needed by the components we notify.
        //
 
        commonExtension->MountedDeviceInterfaceName = interfaceName;
        status = IoSetDeviceInterfaceState(&interfaceName, TRUE);
 
        if(!NT_SUCCESS(status)) {
            RtlFreeUnicodeString(&interfaceName);
        }
    }
 
    if(!NT_SUCCESS(status)) {
        RtlInitUnicodeString(&(commonExtension->MountedDeviceInterfaceName),
                             NULL);
    }
    return;
} // end ClasspRegisterMountedDeviceInterface()

◆ ClasspReleaseQueue()

VOID ClasspReleaseQueue	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	ReleaseQueueIrp
	)

Definition at line 11743 of file class.c.

{
    PIO_STACK_LOCATION irpStack;
    PIRP irp;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PDEVICE_OBJECT lowerDevice;
    PSTORAGE_REQUEST_BLOCK_HEADER srb;
    KIRQL currentIrql;
    ULONG function;
 
    lowerDevice = fdoExtension->CommonExtension.LowerDeviceObject;
 
    //
    // we raise irql seperately so we're not swapped out or suspended
    // while holding the release queue irp in this routine.  this lets
    // us release the spin lock before lowering irql.
    //
 
    KeRaiseIrql(DISPATCH_LEVEL, &currentIrql);
 
    KeAcquireSpinLockAtDpcLevel(&(fdoExtension->ReleaseQueueSpinLock));
 
    //
    // make sure that if they passed us an irp, it matches our allocated irp.
    //
 
    NT_ASSERT((ReleaseQueueIrp == NULL) ||
           (ReleaseQueueIrp == fdoExtension->PrivateFdoData->ReleaseQueueIrp));
 
    //
    // ASSERT that we've already allocated this. (should not occur)
    // try to allocate it anyways, then finally bugcheck if
    // there's still no memory...
    //
 
    NT_ASSERT(fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated);
    if (!fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated) {
        ClasspAllocateReleaseQueueIrp(fdoExtension);
    }
    if (!fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated) {
        KeBugCheckEx(SCSI_DISK_DRIVER_INTERNAL, 0x12, (ULONG_PTR)Fdo, 0x0, 0x0);
    }
 
    if ((fdoExtension->ReleaseQueueInProgress) && (ReleaseQueueIrp == NULL)) {
 
        //
        // Someone is already using the irp - just set the flag to indicate that
        // we need to release the queue again.
        //
 
        fdoExtension->ReleaseQueueNeeded = TRUE;
        KeReleaseSpinLockFromDpcLevel(&(fdoExtension->ReleaseQueueSpinLock));
        KeLowerIrql(currentIrql);
        return;
 
    }
 
    //
    // Mark that there is a release queue in progress and drop the spinlock.
    //
 
    fdoExtension->ReleaseQueueInProgress = TRUE;
    if (ReleaseQueueIrp) {
        irp = ReleaseQueueIrp;
    } else {
        irp = fdoExtension->PrivateFdoData->ReleaseQueueIrp;
    }
 
    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srb = (PSTORAGE_REQUEST_BLOCK_HEADER)&(fdoExtension->PrivateFdoData->ReleaseQueueSrb.SrbEx);
    } else {
        srb = (PSTORAGE_REQUEST_BLOCK_HEADER)&(fdoExtension->ReleaseQueueSrb);
    }
 
    KeReleaseSpinLockFromDpcLevel(&(fdoExtension->ReleaseQueueSpinLock));
 
    NT_ASSERT(irp != NULL);
 
    irpStack = IoGetNextIrpStackLocation(irp);
 
    irpStack->MajorFunction = IRP_MJ_SCSI;
 
    SrbSetOriginalRequest(srb, irp);
 
    //
    // Store the SRB address in next stack for port driver.
    //
 
    irpStack->Parameters.Scsi.Srb = (PSCSI_REQUEST_BLOCK)srb;
 
    //
    // If this device is removable then flush the queue.  This will also
    // release it.
    //
 
    if (TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)){
       function = SRB_FUNCTION_FLUSH_QUEUE;
    }
    else {
       function = SRB_FUNCTION_RELEASE_QUEUE;
    }
 
    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        ((PSTORAGE_REQUEST_BLOCK)srb)->SrbFunction = function;
    } else {
        srb->Function = (UCHAR)function;
    }
 
    ClassAcquireRemoveLock(Fdo, irp);
 
    IoSetCompletionRoutine(irp,
                           ClassReleaseQueueCompletion,
                           Fdo,
                           TRUE,
                           TRUE,
                           TRUE);
 
    IoCallDriver(lowerDevice, irp);
 
    KeLowerIrql(currentIrql);
 
    return;
 
} // end ClassReleaseQueue()

Referenced by ClassReleaseQueue(), and ClassReleaseQueueCompletion().

◆ ClasspRetryDpcTimer()

VOID ClasspRetryDpcTimer ( IN PCLASS_PRIVATE_FDO_DATA FdoData )

Definition at line 12457 of file class.c.

{
    LARGE_INTEGER fire;
 
    NT_ASSERT(FdoData->Retry.Tick.QuadPart != (LONGLONG)0);
    NT_ASSERT(FdoData->Retry.ListHead      != NULL);  // never fire an empty list
 
    //
    // fire == (CurrentTick - now) * (100ns per tick)
    //
    // NOTE: Overflow is nearly impossible and is ignored here
    //
 
    KeQueryTickCount(&fire);
    fire.QuadPart =  FdoData->Retry.Tick.QuadPart - fire.QuadPart;
    fire.QuadPart *= FdoData->Retry.Granularity;
 
    //
    // fire is now multiples of 100ns until should fire the timer.
    // if timer should already have expired, or would fire too quickly,
    // fire it in some arbitrary number of ticks to prevent infinitely
    // recursing.
    //
 
    if (fire.QuadPart < MINIMUM_RETRY_UNITS) {
        fire.QuadPart = MINIMUM_RETRY_UNITS;
    }
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                "ClassRetry: ======= %I64x ticks\n",
                fire.QuadPart));
 
    //
    // must use negative to specify relative time to fire
    //
 
    fire.QuadPart = fire.QuadPart * ((LONGLONG)-1);
 
    //
    // set the timer, since this is the first addition
    //
 
    KeSetTimerEx(&FdoData->Retry.Timer, fire, 0, &FdoData->Retry.Dpc);
 
    return;
} // end ClasspRetryDpcTimer()

Referenced by ClasspRetryRequestDpc(), and ClassRetryRequest().

◆ ClasspScanForClassHacks()

VOID NTAPI ClasspScanForClassHacks	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN ULONG_PTR	Data
	)

Definition at line 12634 of file class.c.

{
    PAGED_CODE();
 
    //
    // remove invalid flags and save
    //
 
    CLEAR_FLAG(Data, FDO_HACK_INVALID_FLAGS);
    SET_FLAG(FdoExtension->PrivateFdoData->HackFlags, Data);
    return;
}

Referenced by ClassPnpStartDevice().

◆ ClasspScanForSpecialInRegistry()

VOID ClasspScanForSpecialInRegistry ( IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 12651 of file class.c.

{
    HANDLE             deviceParameterHandle; // device instance key
    HANDLE             classParameterHandle; // classpnp subkey
    OBJECT_ATTRIBUTES  objectAttributes = {0};
    UNICODE_STRING     subkeyName;
    NTSTATUS           status;
 
    //
    // seeded in the ENUM tree by ClassInstaller
    //
    ULONG deviceHacks;
    RTL_QUERY_REGISTRY_TABLE queryTable[2] = {0}; // null terminated array
 
    PAGED_CODE();
 
    deviceParameterHandle = NULL;
    classParameterHandle = NULL;
    deviceHacks = 0;
 
    status = IoOpenDeviceRegistryKey(FdoExtension->LowerPdo,
                                     PLUGPLAY_REGKEY_DEVICE,
                                     KEY_WRITE,
                                     &deviceParameterHandle
                                     );
 
    if (!NT_SUCCESS(status)) {
        goto cleanupScanForSpecial;
    }
 
    RtlInitUnicodeString(&subkeyName, CLASSP_REG_SUBKEY_NAME);
    InitializeObjectAttributes(&objectAttributes,
                               &subkeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               deviceParameterHandle,
                               NULL
                               );
 
    status = ZwOpenKey( &classParameterHandle,
                        KEY_READ,
                        &objectAttributes
                        );
 
    if (!NT_SUCCESS(status)) {
        goto cleanupScanForSpecial;
    }
 
    //
    // Setup the structure to read
    //
 
    queryTable[0].Flags         = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_TYPECHECK;
    queryTable[0].Name          = CLASSP_REG_HACK_VALUE_NAME;
    queryTable[0].EntryContext  = &deviceHacks;
    queryTable[0].DefaultType   = (REG_DWORD << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_DWORD;
    queryTable[0].DefaultData   = &deviceHacks;
    queryTable[0].DefaultLength = 0;
 
    //
    // read values
    //
 
    status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
                                    (PWSTR)classParameterHandle,
                                    &queryTable[0],
                                    NULL,
                                    NULL
                                    );
    if (!NT_SUCCESS(status)) {
        goto cleanupScanForSpecial;
    }
 
    //
    // remove unknown values and save...
    //
 
    CLEAR_FLAG(deviceHacks, FDO_HACK_INVALID_FLAGS);
    SET_FLAG(FdoExtension->PrivateFdoData->HackFlags, deviceHacks);
 
 
cleanupScanForSpecial:
 
    if (deviceParameterHandle) {
        ZwClose(deviceParameterHandle);
    }
 
    if (classParameterHandle) {
        ZwClose(classParameterHandle);
    }
 
    //
    // we should modify the system hive to include another key for us to grab
    // settings from.  in this case:  Classpnp\HackFlags
    //
    // the use of a DWORD value for the HackFlags allows 32 hacks w/o
    // significant use of the registry, and also reduces OEM exposure.
    //
    // definition of bit flags:
    //   0x00000001 -- Device succeeds PREVENT_MEDIUM_REMOVAL, but
    //                 cannot actually prevent removal.
    //   0x00000002 -- Device hard-hangs or times out for GESN requests.
    //   0xfffffffc -- Currently reserved, may be used later.
    //
 
    return;
}

Referenced by ClassPnpStartDevice().

◆ ClasspSrbSetOriginalIrp()

FORCEINLINE VOID ClasspSrbSetOriginalIrp	(	_In_ PSTORAGE_REQUEST_BLOCK_HEADER	Srb,
		_In_ PIRP	Irp
	)

Definition at line 2530 of file classp.h.

{
    if (Srb->Function == SRB_FUNCTION_STORAGE_REQUEST_BLOCK)
    {
        ((PSTORAGE_REQUEST_BLOCK)Srb)->MiniportContext = (PVOID)Irp;
    }
    else
    {
        ((PSCSI_REQUEST_BLOCK)Srb)->SrbExtension = (PVOID)Irp;
    }
}

Referenced by SubmitTransferPacket().

◆ ClasspStorageEventNotification()

_IRQL_requires_same_ NTSTATUS ClasspStorageEventNotification	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp
	)

Definition at line 7826 of file utils.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
    PIO_STACK_LOCATION irpStack;
    PSTORAGE_EVENT_NOTIFICATION storageEvents;
    NTSTATUS status;
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspStorageEventNotification (%p): Entering function Irp %p.\n",
                DeviceObject,
                Irp));
 
    fdoExtension = DeviceObject->DeviceExtension;
    irpStack = IoGetCurrentIrpStackLocation (Irp);
    storageEvents = Irp->AssociatedIrp.SystemBuffer;
    status = STATUS_SUCCESS;
 
    if (!storageEvents) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspStorageEventNotification (%p): NULL storage events passed in.\n",
                    DeviceObject));
 
        status = STATUS_INVALID_PARAMETER;
        goto __ClasspStorageEventNotification_Exit;
    }
 
    if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_EVENT_NOTIFICATION)) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspStorageEventNotification (%p): Input buffer size (%u) too small.\n",
                    DeviceObject,
                    irpStack->Parameters.DeviceIoControl.InputBufferLength));
 
        status = STATUS_INFO_LENGTH_MISMATCH;
        goto __ClasspStorageEventNotification_Exit;
    }
 
    if ((storageEvents->Version != STORAGE_EVENT_NOTIFICATION_VERSION_V1) ||
        (storageEvents->Size != sizeof(STORAGE_EVENT_NOTIFICATION))) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspStorageEventNotification (%p): Invalid version/size [version %u, size %u].\n",
                    DeviceObject,
                    storageEvents->Version,
                    storageEvents->Size));
 
        status = STATUS_INVALID_PARAMETER;
        goto __ClasspStorageEventNotification_Exit;
    }
 
    //
    // Handle a media status event.
    //
    if (storageEvents->Events & STORAGE_EVENT_MEDIA_STATUS) {
 
        //
        // Only initiate operation if underlying port driver supports asynchronous notification
        // and this is the FDO.
        //
        if ((fdoExtension->CommonExtension.IsFdo == TRUE) &&
            (fdoExtension->FunctionSupportInfo->AsynchronousNotificationSupported)) {
            ClassCheckMediaState(fdoExtension);
        } else {
            status = STATUS_NOT_SUPPORTED;
        }
 
    }
 
__ClasspStorageEventNotification_Exit:
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspStorageEventNotification (%p): Exiting function Irp %p with status %x.\n",
                DeviceObject,
                Irp,
                status));
 
    Irp->IoStatus.Information = 0;
    Irp->IoStatus.Status = status;
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspSupportsUnmap()

FORCEINLINE BOOLEAN ClasspSupportsUnmap ( _In_ PCLASS_FUNCTION_SUPPORT_INFO SupportInfo )

Definition at line 1308 of file classp.h.

{
    return SupportInfo->LBProvisioningData.LBPU;
}

Referenced by ClasspDeviceTrimProcess(), and ClasspDeviceTrimProperty().

◆ ClasspTimeDiffToMs()

FORCEINLINE ULONGLONG ClasspTimeDiffToMs ( ULONGLONG TimeDiff )

Definition at line 1297 of file classp.h.

{
    TimeDiff /= (10 * 1000);
 
    return TimeDiff;
}

Referenced by ClasspGetIdleTime(), and ClasspIdleTimerDpc().

◆ ClasspTransferPacketGetCdb()

FORCEINLINE PCDB ClasspTransferPacketGetCdb ( _In_ PTRANSFER_PACKET Pkt )

Definition at line 2445 of file classp.h.

{
    return SrbGetCdb(Pkt->Srb);
}

Referenced by InterpretTransferPacketError().

◆ ClasspTransferPacketGetNumberOfRetriesDone()

FORCEINLINE BOOLEAN ClasspTransferPacketGetNumberOfRetriesDone	(	_In_ PTRANSFER_PACKET	Pkt,
		_In_ PCDB	Cdb,
		_Out_ PULONG	TimesAlreadyRetried
	)

Definition at line 2459 of file classp.h.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
 
    if (Cdb->MEDIA_REMOVAL.OperationCode == SCSIOP_MEDIUM_REMOVAL)
    {
        *TimesAlreadyRetried = NUM_LOCKMEDIAREMOVAL_RETRIES - Pkt->NumRetries;
    }
    else if ((Cdb->MODE_SENSE.OperationCode == SCSIOP_MODE_SENSE) ||
               (Cdb->MODE_SENSE.OperationCode == SCSIOP_MODE_SENSE10))
    {
        *TimesAlreadyRetried = NUM_MODESENSE_RETRIES - Pkt->NumRetries;
    }
    else if ((Cdb->CDB10.OperationCode == SCSIOP_READ_CAPACITY) ||
               (Cdb->CDB16.OperationCode == SCSIOP_READ_CAPACITY16))
    {
        *TimesAlreadyRetried = NUM_DRIVECAPACITY_RETRIES - Pkt->NumRetries;
    }
    else if (IS_SCSIOP_READWRITE(Cdb->CDB10.OperationCode))
    {
        *TimesAlreadyRetried = fdoData->MaxNumberOfIoRetries - Pkt->NumRetries;
    }
    else if (Cdb->TOKEN_OPERATION.OperationCode == SCSIOP_POPULATE_TOKEN &&
               Cdb->TOKEN_OPERATION.ServiceAction == SERVICE_ACTION_POPULATE_TOKEN)
    {
        *TimesAlreadyRetried = NUM_POPULATE_TOKEN_RETRIES - Pkt->NumRetries;
    }
    else if (Cdb->TOKEN_OPERATION.OperationCode == SCSIOP_WRITE_USING_TOKEN &&
               Cdb->TOKEN_OPERATION.ServiceAction == SERVICE_ACTION_WRITE_USING_TOKEN)
    {
        *TimesAlreadyRetried = NUM_WRITE_USING_TOKEN_RETRIES - Pkt->NumRetries;
    }
    else if (ClasspIsReceiveTokenInformation(Cdb))
    {
        *TimesAlreadyRetried = NUM_RECEIVE_TOKEN_INFORMATION_RETRIES - Pkt->NumRetries;
    }
 
    else
    {
        *TimesAlreadyRetried = 0;
        return FALSE;
    }
 
 
    return TRUE;
}

Referenced by InterpretTransferPacketError().

◆ ClasspTransferPacketGetSenseInfoBuffer()

FORCEINLINE PVOID ClasspTransferPacketGetSenseInfoBuffer ( _In_ PTRANSFER_PACKET Pkt )

Definition at line 2513 of file classp.h.

{
    return SrbGetSenseInfoBuffer(Pkt->Srb);
}

Referenced by HistoryLogReturnedPacket(), and InterpretTransferPacketError().

◆ ClasspTransferPacketGetSenseInfoBufferLength()

FORCEINLINE UCHAR ClasspTransferPacketGetSenseInfoBufferLength ( _In_ PTRANSFER_PACKET Pkt )

Definition at line 2521 of file classp.h.

{
    return SrbGetSenseInfoBufferLength(Pkt->Srb);
}

Referenced by HistoryLogReturnedPacket(), and InterpretTransferPacketError().

◆ ClasspUninitializeRemoveTracking()

VOID ClasspUninitializeRemoveTracking ( _In_ PDEVICE_OBJECT DeviceObject )

Definition at line 529 of file lock.c.

{
    #if DBG
        PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
        PRTL_GENERIC_TABLE removeTrackingList = commonExtension->RemoveTrackingList;
 
        ASSERTMSG("Removing the device while still holding remove locks",
                   commonExtension->RemoveTrackingUntrackedCount == 0 &&
                   removeTrackingList != NULL ? RtlNumberGenericTableElements(removeTrackingList) == 0 : TRUE);
 
        if (removeTrackingList != NULL)
        {
            KIRQL oldIrql;
            KeAcquireSpinLock(&commonExtension->RemoveTrackingSpinlock, &oldIrql);
 
            FREE_POOL(removeTrackingList);
            commonExtension->RemoveTrackingList = NULL;
 
            KeReleaseSpinLock(&commonExtension->RemoveTrackingSpinlock, oldIrql);
        }
 
    #else
 
        UNREFERENCED_PARAMETER(DeviceObject);
    #endif
}

◆ ClasspUpdateTimerNoWakeTolerance()

BOOLEAN ClasspUpdateTimerNoWakeTolerance ( _In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 3653 of file autorun.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = NULL;
 
    if (FdoExtension->CommonExtension.IsFdo) {
        fdoData = FdoExtension->PrivateFdoData;
    }
 
    if (fdoData != NULL &&
        fdoData->TickTimer != NULL &&
        fdoData->TimerInitialized &&
        fdoData->TickTimerEnabled) {
 
        LONGLONG noWakeTolerance = TICK_TIMER_DELAY_IN_MSEC * (10 * 1000);
 
        //
        // Set the no-wake tolerance to "unlimited" if the conditions below
        // are met.  An "unlimited" no-wake tolerance means that the timer
        // will *never* wake the processor if the processor is in a
        // low-power state.
        //  1. The screen is off.
        //  2. The class driver is *not* a consumer of the tick timer (ClassTick is NULL).
        //  3. This is a disk device.
        // Otherwise the tolerance is set to the normal, default tolerable delay.
        //
        if (ClasspScreenOff &&
            FdoExtension->CommonExtension.DriverExtension->InitData.ClassTick == NULL &&
            FdoExtension->DeviceObject->DeviceType == FILE_DEVICE_DISK) {
            noWakeTolerance = EX_TIMER_UNLIMITED_TOLERANCE;
        }
 
        //
        // The new tolerance is different from the current tolerance so we need
        // to set/reset the timer with the new tolerance value.
        //
        if (fdoData->CurrentNoWakeTolerance != noWakeTolerance) {
            EXT_SET_PARAMETERS parameters;
            LONGLONG period = TICK_TIMER_PERIOD_IN_MSEC * (10 * 1000); // Convert to units of 100ns.
            LONGLONG dueTime = period * (-1); // Negative sign indicates dueTime is relative.
 
            ExInitializeSetTimerParameters(&parameters);
            parameters.NoWakeTolerance = noWakeTolerance;
            fdoData->CurrentNoWakeTolerance = noWakeTolerance;
 
            ExSetTimer(fdoData->TickTimer,
                       dueTime,
                       period,
                       &parameters);
 
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by _Function_class_().

◆ ClasspWriteCacheProperty()

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

Definition at line 1199 of file utils.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PSTORAGE_WRITE_CACHE_PROPERTY writeCache;
    PSTORAGE_PROPERTY_QUERY query =  Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PMODE_PARAMETER_HEADER modeData = NULL;
    PMODE_CACHING_PAGE pageData = NULL;
    ULONG length, information = 0;
    NTSTATUS status;
    PCDB cdb;
 
    //
    // Must run at less then dispatch.
    //
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
 
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        status = STATUS_INVALID_LEVEL;
        goto WriteCacheExit;
    }
 
    //
    // Check proper query type.
    //
 
    if (query->QueryType == PropertyExistsQuery) {
        status = STATUS_SUCCESS;
        goto WriteCacheExit;
    }
 
    if (query->QueryType != PropertyStandardQuery) {
        status = STATUS_NOT_SUPPORTED;
        goto WriteCacheExit;
    }
 
    length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    if (length < sizeof(STORAGE_DESCRIPTOR_HEADER)) {
        status = STATUS_INFO_LENGTH_MISMATCH;
        goto WriteCacheExit;
    }
 
    writeCache = (PSTORAGE_WRITE_CACHE_PROPERTY) Irp->AssociatedIrp.SystemBuffer;
    RtlZeroMemory(writeCache, length);
 
    //
    // Set version and required size.
    //
 
    writeCache->Version = sizeof(STORAGE_WRITE_CACHE_PROPERTY);
    writeCache->Size = sizeof(STORAGE_WRITE_CACHE_PROPERTY);
 
    if (length < sizeof(STORAGE_WRITE_CACHE_PROPERTY)) {
        information = sizeof(STORAGE_DESCRIPTOR_HEADER);
        status = STATUS_SUCCESS;
        goto WriteCacheExit;
    }
 
    //
    // Set known values
    //
 
    writeCache->NVCacheEnabled = FALSE;
    writeCache->UserDefinedPowerProtection = TEST_FLAG(fdoExtension->DeviceFlags, DEV_POWER_PROTECTED);
 
    //
    // Check for flush cache support by sending a sync cache command
    // to the device.
    //
 
    //
    // Set timeout value and mark the request as not being a tagged request.
    //
    SrbSetTimeOutValue(Srb, fdoExtension->TimeOutValue * 4);
    SrbSetRequestTag(Srb, SP_UNTAGGED);
    SrbSetRequestAttribute(Srb, SRB_SIMPLE_TAG_REQUEST);
    SrbAssignSrbFlags(Srb, fdoExtension->SrbFlags);
 
    SrbSetCdbLength(Srb, 10);
    cdb = SrbGetCdb(Srb);
    cdb->CDB10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE;
 
    status = ClassSendSrbSynchronous(DeviceObject,
                                     Srb,
                                     NULL,
                                     0,
                                     TRUE);
    if (NT_SUCCESS(status)) {
        writeCache->FlushCacheSupported = TRUE;
    } else {
        //
        // Device does not support sync cache
        //
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Synchronize cache failed with status 0x%X\n", status));
        writeCache->FlushCacheSupported = FALSE;
        //
        // Reset the status if there was any failure
        //
        status = STATUS_SUCCESS;
    }
 
    modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                     MODE_PAGE_DATA_SIZE,
                                     CLASS_TAG_MODE_DATA);
 
    if (modeData == NULL) {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Unable to allocate mode data buffer\n"));
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto WriteCacheExit;
    }
 
    RtlZeroMemory(modeData, MODE_PAGE_DATA_SIZE);
 
    length = ClassModeSense(DeviceObject,
                            (PCHAR) modeData,
                            MODE_PAGE_DATA_SIZE,
                            MODE_PAGE_CACHING);
 
    if (length < sizeof(MODE_PARAMETER_HEADER)) {
 
        //
        // Retry the request in case of a check condition.
        //
 
        length = ClassModeSense(DeviceObject,
                                (PCHAR) modeData,
                                MODE_PAGE_DATA_SIZE,
                                MODE_PAGE_CACHING);
 
        if (length < sizeof(MODE_PARAMETER_HEADER)) {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Mode Sense failed\n"));
            status = STATUS_IO_DEVICE_ERROR;
            goto WriteCacheExit;
        }
    }
 
    //
    // If the length is greater than length indicated by the mode data reset
    // the data to the mode data.
    //
 
    if (length > (ULONG) (modeData->ModeDataLength + 1)) {
        length = modeData->ModeDataLength + 1;
    }
 
    //
    // Look for caching page in the returned mode page data.
    //
 
    pageData = ClassFindModePage((PCHAR) modeData,
                                 length,
                                 MODE_PAGE_CACHING,
                                 TRUE);
 
    //
    // Check if valid caching page exists.
    //
 
    if (pageData == NULL) {
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Unable to find caching mode page.\n"));
        //
        // Set write cache value as unknown.
        //
        writeCache->WriteCacheEnabled = WriteCacheEnableUnknown;
        writeCache->WriteCacheType = WriteCacheTypeUnknown;
    } else {
        writeCache->WriteCacheEnabled = pageData->WriteCacheEnable ?
                                            WriteCacheEnabled : WriteCacheDisabled;
 
        writeCache->WriteCacheType = pageData->WriteCacheEnable ?
                                            WriteCacheTypeWriteBack : WriteCacheTypeUnknown;
    }
 
    //
    // Check write through support. If the device previously failed a write request
    // with FUA bit is set, then CLASS_SPECIAL_FUA_NOT_SUPPORTED will be set,
    // which means write through is not support by the device.
    //
 
    if ((modeData->DeviceSpecificParameter & MODE_DSP_FUA_SUPPORTED) &&
        (!TEST_FLAG(fdoExtension->ScanForSpecialFlags, CLASS_SPECIAL_FUA_NOT_SUPPORTED))) {
        writeCache->WriteThroughSupported = WriteThroughSupported;
    } else {
        writeCache->WriteThroughSupported = WriteThroughNotSupported;
    }
 
    //
    // Get the changeable caching mode page and check write cache is changeable.
    //
 
    RtlZeroMemory(modeData, MODE_PAGE_DATA_SIZE);
 
    length = ClasspModeSense(DeviceObject,
                            (PCHAR) modeData,
                            MODE_PAGE_DATA_SIZE,
                            MODE_PAGE_CACHING,
                            MODE_SENSE_CHANGEABLE_VALUES);
 
    if (length < sizeof(MODE_PARAMETER_HEADER)) {
 
        //
        // Retry the request in case of a check condition.
        //
 
        length = ClasspModeSense(DeviceObject,
                                (PCHAR) modeData,
                                MODE_PAGE_DATA_SIZE,
                                MODE_PAGE_CACHING,
                                MODE_SENSE_CHANGEABLE_VALUES);
 
        if (length < sizeof(MODE_PARAMETER_HEADER)) {
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Mode Sense failed\n"));
 
            //
            // If the device fails to return changeable pages, then
            // set the write cache changeable value to unknown.
            //
 
            writeCache->WriteCacheChangeable = WriteCacheChangeUnknown;
            information = sizeof(STORAGE_WRITE_CACHE_PROPERTY);
            goto WriteCacheExit;
        }
    }
 
    //
    // If the length is greater than length indicated by the mode data reset
    // the data to the mode data.
    //
 
    if (length > (ULONG) (modeData->ModeDataLength + 1)) {
        length = modeData->ModeDataLength + 1;
    }
 
    //
    // Look for caching page in the returned mode page data.
    //
 
    pageData = ClassFindModePage((PCHAR) modeData,
                                 length,
                                 MODE_PAGE_CACHING,
                                 TRUE);
    //
    // Check if valid caching page exists.
    //
 
    if (pageData == NULL) {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "ClasspWriteCacheProperty: Unable to find caching mode page.\n"));
        //
        // Set write cache changeable value to unknown.
        //
        writeCache->WriteCacheChangeable = WriteCacheChangeUnknown;
    } else {
        writeCache->WriteCacheChangeable = pageData->WriteCacheEnable ?
                                            WriteCacheChangeable : WriteCacheNotChangeable;
    }
 
    information = sizeof(STORAGE_WRITE_CACHE_PROPERTY);
 
WriteCacheExit:
 
    FREE_POOL(modeData);
 
    //
    // Set the size and status in IRP
    //
    Irp->IoStatus.Information = information;;
    Irp->IoStatus.Status = status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    return status;
}

Referenced by ClassDeviceControl().

◆ ClasspWriteUsingTokenTransferPacketDone()

VOID ClasspWriteUsingTokenTransferPacketDone ( _In_ PVOID Context )

Definition at line 15519 of file class.c.

{
    ULONGLONG entireXferLen;
    PDEVICE_OBJECT fdo;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt;
    ULONG listIdentifier;
    POFFLOAD_WRITE_CONTEXT offloadWriteContext;
    PTRANSFER_PACKET pkt;
    PIRP pseudoIrp;
    NTSTATUS status;
    PBOOLEAN tokenInvalidated;
    ULONGLONG totalSectorsToProcess;
 
    offloadWriteContext = Context;
    pseudoIrp = &offloadWriteContext->PseudoIrp;
    fdo = offloadWriteContext->Fdo;
    fdoExt = fdo->DeviceExtension;
    listIdentifier = offloadWriteContext->ListIdentifier;
    totalSectorsToProcess = offloadWriteContext->TotalSectorsToProcess;
    entireXferLen = offloadWriteContext->EntireXferLen;
    tokenInvalidated = &offloadWriteContext->TokenInvalidated;
    pkt = offloadWriteContext->Pkt;
 
    offloadWriteContext->Pkt = NULL;
 
 
    status = pseudoIrp->IoStatus.Status;
    NT_ASSERT(status != STATUS_PENDING);
 
    //
    // If the request failed with any of the following errors, then it is meaningless to send
    // down a ReceiveTokenInformation (regardless of whether the transfer was requested as sync
    // or async), since the target has no saved information about the command:
    // - STATUS_INVALID_TOKEN
    // - STATUS_INVALID_PARAMETER
    //
    if (status == STATUS_INVALID_PARAMETER ||
        status == STATUS_INVALID_TOKEN) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspWriteUsingTokenTransferPacketDone (%p): Write failed with %x (list id %x).\n",
                    fdo,
                    status,
                    listIdentifier));
 
        //
        // If the token isn't valid any longer, we should let the upper layers know so that
        // they don't waste time retrying the write with the same token.
        //
        if (status == STATUS_INVALID_TOKEN) {
 
            *tokenInvalidated = TRUE;
        }
 
        NT_ASSERT(status != STATUS_PENDING && !NT_SUCCESS(status));
        goto __ClasspWriteUsingTokenTransferPacketDone_Exit;
 
    } else if ((NT_SUCCESS(status)) &&
               (pkt->Srb->SrbStatus == SRB_STATUS_SUCCESS || pkt->TransferCount != 0)) {
 
        //
        // If the TokenOperation command was sent to the target requesting synchronous data
        // transfer, a success indicates that the command is complete.
        // This could either be because of a successful completion of the entire transfer
        // or because of a partial transfer due to target truncation. If it is the latter,
        // and the information field of the sense data has returned the TransferCount, we
        // can avoid sending down an RRTI.
        //
        if (pkt->Srb->SrbStatus == SRB_STATUS_SUCCESS) {
 
            //
            // The entire transfer has completed successfully.
            //
            offloadWriteContext->TotalSectorsProcessed = totalSectorsToProcess;
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_IOCTL,
                        "ClasspWriteUsingTokenTransferPacketDone (%p): Successfully wrote using token %I64u (out of %I64u) bytes (list Id %x).\n",
                        fdo,
                        totalSectorsToProcess * fdoExt->DiskGeometry.BytesPerSector,
                        entireXferLen,
                        listIdentifier));
        } else {
 
            //
            // The target has returned how much data it transferred in the response to the
            // WUT command itself, allowing us to optimize by removing the necessaity for
            // sending down an RRTI to query the TransferCount.
            //
            NT_ASSERT(pkt->TransferCount);
 
            offloadWriteContext->TotalSectorsProcessed = totalSectorsToProcess = pkt->TransferCount;
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_IOCTL,
                        "ClasspWriteUsingTokenTransferPacketDone (%p): Target truncated write using token %I64u (out of %I64u) bytes (list Id %x).\n",
                        fdo,
                        totalSectorsToProcess * fdoExt->DiskGeometry.BytesPerSector,
                        entireXferLen,
                        listIdentifier));
        }
 
        ClasspAdvanceOffloadWritePosition(offloadWriteContext, totalSectorsToProcess);
 
        NT_ASSERT(status != STATUS_PENDING);
 
        //
        // ClasspReceiveWriteUsingTokenInformationDone() takes care of
        // completing the operation (eventually), so pending from point of view
        // of this function.
        //
 
        ClasspReceiveWriteUsingTokenInformationDone(offloadWriteContext, status);
        status = STATUS_PENDING;
 
        goto __ClasspWriteUsingTokenTransferPacketDone_Exit;
 
    } else {
 
        //
        // Since the TokenOperation was failed (or the target truncated the transfer but
        // didn't indicate the amount), we need to send down ReceiveTokenInformation.
        //
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspWriteUsingTokenTransferPacketDone (%p): Write failed with status %x, %x (list id %x).\n",
                    fdo,
                    status,
                    pkt->Srb->SrbStatus,
                    listIdentifier));
 
        ClasspReceiveWriteUsingTokenInformation(offloadWriteContext);
 
        status = STATUS_PENDING;
        goto __ClasspWriteUsingTokenTransferPacketDone_Exit;
    }
 
__ClasspWriteUsingTokenTransferPacketDone_Exit:
 
    if (status != STATUS_PENDING) {
        ClasspCompleteOffloadWrite(offloadWriteContext, status);
    }
 
    return;
}

◆ ClasspZeroQERR()

VOID ClasspZeroQERR ( _In_ PDEVICE_OBJECT DeviceObject )

Definition at line 7938 of file utils.c.

{
    PMODE_PARAMETER_HEADER modeData = NULL;
    PMODE_CONTROL_PAGE pageData = NULL;
    ULONG size = 0;
 
    modeData = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                    MODE_PAGE_DATA_SIZE,
                                    CLASS_TAG_MODE_DATA);
 
    if (modeData == NULL) {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_SCSI, "ClasspZeroQERR: Unable to allocate mode data buffer\n"));
        goto ClasspZeroQERR_Exit;
    }
 
    RtlZeroMemory(modeData, MODE_PAGE_DATA_SIZE);
 
    size = ClassModeSense(DeviceObject,
                            (PCHAR) modeData,
                            MODE_PAGE_DATA_SIZE,
                            MODE_PAGE_CONTROL);
 
    if (size < sizeof(MODE_PARAMETER_HEADER)) {
 
        //
        // Retry the request in case of a check condition.
        //
 
        size = ClassModeSense(DeviceObject,
                                (PCHAR) modeData,
                                MODE_PAGE_DATA_SIZE,
                                MODE_PAGE_CONTROL);
 
        if (size < sizeof(MODE_PARAMETER_HEADER)) {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_SCSI, "ClasspZeroQERR: Mode Sense failed\n"));
            goto ClasspZeroQERR_Exit;
        }
    }
 
    //
    // If the size is greater than size indicated by the mode data reset
    // the data to the mode data.
    //
 
    if (size > (ULONG) (modeData->ModeDataLength + 1)) {
        size = modeData->ModeDataLength + 1;
    }
 
    //
    // Look for control page in the returned mode page data.
    //
 
    pageData = ClassFindModePage((PCHAR) modeData,
                                    size,
                                    MODE_PAGE_CONTROL,
                                    TRUE);
 
    if (pageData) {
        TracePrint((TRACE_LEVEL_VERBOSE,
                    TRACE_FLAG_SCSI,
                    "ClasspZeroQERR (%p): Current settings: QERR = %u, TST = %u, TAS = %u.\n",
                    DeviceObject,
                    pageData->QERR,
                    pageData->TST,
                    pageData->TAS));
 
        if (pageData->QERR != 0) {
            NTSTATUS status;
            UCHAR pageSavable = 0;
 
            //
            // Set QERR to 0 with a Mode Select command.  Re-use the modeData
            // and pageData structures.
            //
            pageData->QERR = 0;
 
            //
            // We use the original Page Savable (PS) value for the Save Pages
            // (SP) bit due to behavior described under the MODE SELECT(6)
            // section of SPC-4.
            //
            pageSavable = pageData->PageSavable;
 
            status = ClasspModeSelect(DeviceObject,
                                     (PCHAR)modeData,
                                     size,
                                     pageSavable);
 
            if (!NT_SUCCESS(status)) {
                TracePrint((TRACE_LEVEL_WARNING,
                    TRACE_FLAG_SCSI,
                    "ClasspZeroQERR (%p): Failed to set QERR = 0 with status %x\n",
                    DeviceObject,
                    status));
            }
        }
    }
 
ClasspZeroQERR_Exit:
 
    if (modeData != NULL) {
        ExFreePool(modeData);
    }
}

◆ ClassQueryPnpCapabilities()

NTSTATUS ClassQueryPnpCapabilities	(	IN PDEVICE_OBJECT	PhysicalDeviceObject,
		IN PDEVICE_CAPABILITIES	Capabilities
	)

Definition at line 10192 of file class.c.

{
    PCLASS_DRIVER_EXTENSION driverExtension =
        ClassGetDriverExtension(DeviceObject->DriverObject);
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
 
    PCLASS_QUERY_PNP_CAPABILITIES queryRoutine = NULL;
 
    PAGED_CODE();
 
    NT_ASSERT(DeviceObject);
    NT_ASSERT(Capabilities);
 
    if(commonExtension->IsFdo) {
        queryRoutine = driverExtension->InitData.FdoData.ClassQueryPnpCapabilities;
    } else {
        queryRoutine = driverExtension->InitData.PdoData.ClassQueryPnpCapabilities;
    }
 
    if(queryRoutine) {
        return queryRoutine(DeviceObject,
                            Capabilities);
    } else {
        return STATUS_NOT_IMPLEMENTED;
    }
} // end ClassQueryPnpCapabilities()

Referenced by ClassDispatchPnp().

◆ ClassQueueCapacityChangedEventWorker()

VOID ClassQueueCapacityChangedEventWorker ( _In_ PDEVICE_OBJECT DeviceObject )

Definition at line 5637 of file utils.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
    PIO_WORKITEM workItem = NULL;
 
    if (commonExtension->IsFdo)
    {
        workItem = IoAllocateWorkItem(DeviceObject);
 
        if (workItem)
        {
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_GENERAL,
                        "ClassQueueCapacityChangedEventWorker: DO (%p), Queueing capacity changed event work item.\n",
                        DeviceObject));
 
            ClassAcquireRemoveLock(DeviceObject, (PIRP)(workItem));
 
            //
            // Queue a work item to write the threshold notification to the
            // system event log.
            //
            IoQueueWorkItem(workItem, ClassLogCapacityChangedProcess, DelayedWorkQueue, workItem);
        }
        else
        {
            TracePrint((TRACE_LEVEL_ERROR,
                        TRACE_FLAG_GENERAL,
                        "ClassQueueCapacityChangedEventWorker: DO (%p), Failed to allocate memory for the work item.\n",
                        DeviceObject));
        }
    }
}

Referenced by ClassInterpretSenseInfo().

◆ ClassQueueProvisioningTypeChangedEventWorker()

VOID ClassQueueProvisioningTypeChangedEventWorker ( _In_ PDEVICE_OBJECT DeviceObject )

Definition at line 5726 of file utils.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
    PIO_WORKITEM workItem = NULL;
 
    if (commonExtension->IsFdo)
    {
        workItem = IoAllocateWorkItem(DeviceObject);
 
        if (workItem)
        {
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_GENERAL,
                        "ClassQueueProvisioningTypeChangedEventWorker: DO (%p), Queueing LB provisioning type changed event work item.\n",
                        DeviceObject));
 
            ClassAcquireRemoveLock(DeviceObject, (PIRP)(workItem));
 
            //
            // Queue a work item to write the threshold notification to the
            // system event log.
            //
            IoQueueWorkItem(workItem, ClassLogProvisioningTypeChangedEvent, DelayedWorkQueue, workItem);
        }
        else
        {
            TracePrint((TRACE_LEVEL_ERROR,
                        TRACE_FLAG_GENERAL,
                        "ClassQueueProvisioningTypeChangedEventWorker: DO (%p), Failed to allocate memory for the work item.\n",
                        DeviceObject));
        }
    }
}

Referenced by ClassInterpretSenseInfo().

◆ ClassQueueResourceExhaustionEventWorker()

VOID ClassQueueResourceExhaustionEventWorker ( _In_ PDEVICE_OBJECT DeviceObject )

Definition at line 5528 of file utils.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
    PIO_WORKITEM workItem = NULL;
 
    if (commonExtension->IsFdo)
    {
        workItem = IoAllocateWorkItem(DeviceObject);
 
        if (workItem)
        {
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_GENERAL,
                        "ClassQueueResourceExhaustionEventWorker: DO (%p), Queueing permanent resource exhaustion event work item.\n",
                        DeviceObject));
 
            ClassAcquireRemoveLock(DeviceObject, (PIRP)(workItem));
 
            //
            // Queue a work item to write the threshold notification to the
            // system event log.
            //
            IoQueueWorkItem(workItem, ClassLogResourceExhaustionEvent, DelayedWorkQueue, workItem);
        }
        else
        {
            TracePrint((TRACE_LEVEL_ERROR,
                        TRACE_FLAG_GENERAL,
                        "ClassQueueResourceExhaustionEventWorker: DO (%p), Failed to allocate memory for the work item.\n",
                        DeviceObject));
        }
    }
}

Referenced by ClassInterpretSenseInfo().

◆ ClassQueueThresholdEventWorker()

VOID ClassQueueThresholdEventWorker ( _In_ PDEVICE_OBJECT DeviceObject )

Definition at line 5471 of file utils.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = (PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)(DeviceObject->DeviceExtension);
    PIO_WORKITEM workItem = NULL;
 
    if (commonExtension->IsFdo &&
        InterlockedCompareExchange((PLONG)&(fdoExtension->FunctionSupportInfo->LBProvisioningData.SoftThresholdEventPending), 1, 0) == 0)
    {
        workItem = IoAllocateWorkItem(DeviceObject);
 
        if (workItem)
        {
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_GENERAL,
                        "ClassQueueThresholdEventWorker: DO (%p), Queueing soft threshold notification work item.\n",
                        DeviceObject));
 
 
            ClassAcquireRemoveLock(DeviceObject, (PIRP)(workItem));
 
            //
            // Queue a work item to write the threshold notification to the
            // system event log.
            //
            IoQueueWorkItem(workItem, ClassLogThresholdEvent, DelayedWorkQueue, workItem);
        }
        else
        {
            //
            // Clear the soft threshold event pending flag since this is normally
            // done when the work item completes.
            //
            InterlockedExchange((PLONG)&(fdoExtension->FunctionSupportInfo->LBProvisioningData.SoftThresholdEventPending), 0);
 
            TracePrint((TRACE_LEVEL_ERROR,
                        TRACE_FLAG_GENERAL,
                        "ClassQueueThresholdEventWorker: DO (%p), Failed to allocate memory for the work item.\n",
                        DeviceObject));
        }
    }
}

Referenced by ClassInterpretSenseInfo().

◆ ClassReadCapacity16()

NTSTATUS ClassReadCapacity16	(	_Inout_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_Inout_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 1568 of file utils.c.

{
    NTSTATUS              status = STATUS_SUCCESS;
    PREAD_CAPACITY16_DATA dataBuffer = NULL;
    UCHAR                 bufferLength = sizeof(READ_CAPACITY16_DATA);
    ULONG                 allocationBufferLength = bufferLength; //DMA buffer size for alignment
    PCDB                  cdb;
    ULONG                 dataTransferLength = 0;
 
    //
    // If the information retrieval has already been attempted, return the cached status.
    //
    if (FdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus != -1) {
        // get cached NTSTATUS from previous call.
        return FdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus;
    }
 
    if (ClasspIsObsoletePortDriver(FdoExtension)) {
        FdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus = STATUS_NOT_IMPLEMENTED;
        return STATUS_NOT_IMPLEMENTED;
    }
 
#if defined(_ARM_) || defined(_ARM64_)
    //
    // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
    // based platforms. We are taking the conservative approach here.
    //
    allocationBufferLength = ALIGN_UP_BY(allocationBufferLength,KeGetRecommendedSharedDataAlignment());
    dataBuffer = (PREAD_CAPACITY16_DATA)ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, allocationBufferLength, '4CcS');
#else
    dataBuffer = (PREAD_CAPACITY16_DATA)ExAllocatePoolWithTag(NonPagedPoolNx, bufferLength, '4CcS');
#endif
 
    if (dataBuffer == NULL) {
        // return without updating FdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus
        // the field will remain value as "-1", so that the command will be attempted next time this function is called.
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(dataBuffer, allocationBufferLength);
 
    //
    // Initialize the SRB.
    //
    if (FdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        status = InitializeStorageRequestBlock((PSTORAGE_REQUEST_BLOCK)Srb,
                                                STORAGE_ADDRESS_TYPE_BTL8,
                                                CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE,
                                                1,
                                                SrbExDataTypeScsiCdb16);
        if (NT_SUCCESS(status)) {
            ((PSTORAGE_REQUEST_BLOCK)Srb)->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
        } else {
            //
            // Should not occur.
            //
            NT_ASSERT(FALSE);
        }
    } else {
        RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));
        Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
        Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    }
 
    //prepare the Srb
    if (NT_SUCCESS(status))
    {
 
        SrbSetTimeOutValue(Srb, FdoExtension->TimeOutValue);
        SrbSetRequestTag(Srb, SP_UNTAGGED);
        SrbSetRequestAttribute(Srb, SRB_SIMPLE_TAG_REQUEST);
        SrbAssignSrbFlags(Srb, FdoExtension->SrbFlags);
 
        SrbSetCdbLength(Srb, 16);
 
        cdb = SrbGetCdb(Srb);
        cdb->READ_CAPACITY16.OperationCode = SCSIOP_READ_CAPACITY16;
        cdb->READ_CAPACITY16.ServiceAction = SERVICE_ACTION_READ_CAPACITY16;
        cdb->READ_CAPACITY16.AllocationLength[3] = bufferLength;
 
        status = ClassSendSrbSynchronous(FdoExtension->DeviceObject,
                                         Srb,
                                         dataBuffer,
                                         allocationBufferLength,
                                         FALSE);
 
        dataTransferLength = SrbGetDataTransferLength(Srb);
    }
 
    if (NT_SUCCESS(status) && (dataTransferLength < 16))
    {
        // the device should return at least 16 bytes of data for this command.
        status = STATUS_INFO_LENGTH_MISMATCH;
    }
 
    //
    // Handle the case where we get back STATUS_DATA_OVERRUN b/c the input
    // buffer was larger than necessary.
    //
    if (status == STATUS_DATA_OVERRUN && dataTransferLength < bufferLength)
    {
        status = STATUS_SUCCESS;
    }
 
    if (NT_SUCCESS(status))
    {
        // cache data into FdoExtension
        status = InterpretReadCapacity16Data(FdoExtension, dataBuffer);
    }
 
    // cache the status indicates that this funciton has been called.
    FdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus = status;
 
    ExFreePool(dataBuffer);
 
    return status;
}

Referenced by ClasspAccessAlignmentProperty().

◆ ClassRemoveChild()

PPHYSICAL_DEVICE_EXTENSION ClassRemoveChild	(	IN PFUNCTIONAL_DEVICE_EXTENSION	Parent,
		IN PPHYSICAL_DEVICE_EXTENSION	Child,
		IN BOOLEAN	AcquireLock
	)

Definition at line 12119 of file class.c.

{
    if(AcquireLock) {
        ClassAcquireChildLock(Parent);
    }
 
    TRY {
        PCOMMON_DEVICE_EXTENSION previousChild = &Parent->CommonExtension;
 
        //
        // If the list is empty then bail out now.
        //
 
        if(Parent->CommonExtension.ChildList == NULL) {
            Child = NULL;
            LEAVE;
        }
 
        //
        // If the caller specified a child then find the child object before
        // it.  If none was specified then the FDO is the child object before
        // the one we want to remove.
        //
 
        if(Child != NULL) {
 
            //
            // Scan through the child list to find the entry which points to
            // this one.
            //
 
            do {
                NT_ASSERT(previousChild != &Child->CommonExtension);
 
                if(previousChild->ChildList == Child) {
                    break;
                }
 
                previousChild = &previousChild->ChildList->CommonExtension;
            } while(previousChild != NULL);
 
            if(previousChild == NULL) {
                Child = NULL;
                LEAVE;
            }
        }
 
        //
        // Save the next child away then unlink it from the list.
        //
 
        Child = previousChild->ChildList;
        previousChild->ChildList = Child->CommonExtension.ChildList;
        Child->CommonExtension.ChildList = NULL;
 
    } FINALLY {
        if(AcquireLock) {
            ClassReleaseChildLock(Parent);
        }
    }
    return Child;
} // end ClassRemoveChild()

◆ ClassRetrieveDeviceRelations()

NTSTATUS ClassRetrieveDeviceRelations	(	IN PDEVICE_OBJECT	Fdo,
		IN DEVICE_RELATION_TYPE	RelationType,
		OUT PDEVICE_RELATIONS *	DeviceRelations
	)

Definition at line 10005 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
 
    ULONG count = 0;
    ULONG i;
 
    PPHYSICAL_DEVICE_EXTENSION nextChild;
 
    ULONG relationsSize;
    PDEVICE_RELATIONS deviceRelations = NULL;
    PDEVICE_RELATIONS oldRelations = *DeviceRelations;
 
    NTSTATUS status;
 
    UNREFERENCED_PARAMETER(RelationType);
 
    PAGED_CODE();
 
    ClassAcquireChildLock(fdoExtension);
 
    nextChild = fdoExtension->CommonExtension.ChildList;
 
    //
    // Count the number of PDO's attached to this disk
    //
 
    while (nextChild != NULL) {
        PCOMMON_DEVICE_EXTENSION commonExtension;
 
        commonExtension = &(nextChild->CommonExtension);
 
        NT_ASSERTMSG("ClassPnp internal error: missing child on active list\n",
                  (nextChild->IsMissing == FALSE));
 
        nextChild = commonExtension->ChildList;
 
        count++;
    };
 
    //
    // If relations already exist in the QDR, adjust the current count
    // to include the previous list.
    //
 
    if (oldRelations) {
        count += oldRelations->Count;
    }
 
    relationsSize = (sizeof(DEVICE_RELATIONS) +
                     (count * sizeof(PDEVICE_OBJECT)));
 
    deviceRelations = ExAllocatePoolWithTag(PagedPool, relationsSize, '5BcS');
 
    if (deviceRelations == NULL) {
 
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_ENUM,  "ClassRetrieveDeviceRelations: unable to allocate "
                       "%d bytes for device relations\n", relationsSize));
 
        ClassReleaseChildLock(fdoExtension);
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(deviceRelations, relationsSize);
 
    if (oldRelations) {
 
        //
        // Copy the old relations to the new list and free the old list.
        //
 
        for (i = 0; i < oldRelations->Count; i++) {
            deviceRelations->Objects[i] = oldRelations->Objects[i];
        }
 
        FREE_POOL(oldRelations);
    }
 
    nextChild = fdoExtension->CommonExtension.ChildList;
    i = count;
 
    while (nextChild != NULL) {
        PCOMMON_DEVICE_EXTENSION commonExtension;
 
        commonExtension = &(nextChild->CommonExtension);
 
        NT_ASSERTMSG("ClassPnp internal error: missing child on active list\n",
                  (nextChild->IsMissing == FALSE));
 
    _Analysis_assume_(i >= 1);
    deviceRelations->Objects[--i] = nextChild->DeviceObject;
 
        status = ObReferenceObjectByPointer(
                    nextChild->DeviceObject,
                    0,
                    NULL,
                    KernelMode);
        if (!NT_SUCCESS(status)) {
            NT_ASSERT(!"Error referencing child device by pointer");
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_ENUM,
                        "ClassRetrieveDeviceRelations: Error referencing child "
                        "device %p by pointer\n", nextChild->DeviceObject));
 
        }
        nextChild->IsEnumerated = TRUE;
        nextChild = commonExtension->ChildList;
    }
 
    NT_ASSERTMSG("Child list has changed: ", i == 0);
 
    deviceRelations->Count = count;
    *DeviceRelations = deviceRelations;
 
    ClassReleaseChildLock(fdoExtension);
    return STATUS_SUCCESS;
} // end ClassRetrieveDeviceRelations()

Referenced by ClassPnpQueryFdoRelations().

◆ ClassRetryRequest()

VOID ClassRetryRequest	(	IN PDEVICE_OBJECT	SelfDeviceObject,
		IN PIRP	Irp,
		_In_ _In_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) IN LONGLONG	TimeDelta100ns
	)

Definition at line 12317 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData;
    PCLASS_RETRY_INFO  retryInfo;
    LARGE_INTEGER      delta;
    KIRQL irql;
 
    //
    // this checks we aren't destroying irps
    //
    NT_ASSERT(sizeof(CLASS_RETRY_INFO) <= (4*sizeof(PVOID)));
 
    fdoExtension = SelfDeviceObject->DeviceExtension;
 
    if (!fdoExtension->CommonExtension.IsFdo) {
 
        //
        // this debug print/assertion should ALWAYS be investigated.
        // ClassRetryRequest can currently only be used by FDO's
        //
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "ClassRetryRequestEx: LOST IRP %p\n", Irp));
        NT_ASSERT(!"ClassRetryRequestEx Called From PDO? LOST IRP");
        return;
 
    }
 
    fdoData = fdoExtension->PrivateFdoData;
 
    if (TimeDelta100ns < 0) {
        NT_ASSERT(!"ClassRetryRequest - must use positive delay");
        TimeDelta100ns *= -1;
    }
 
    /*
     *  We are going to queue the irp and send it down in a timer DPC.
     *  This means that we may be causing the irp to complete on a different thread than the issuing thread.
     *  So mark the irp pending.
     */
    IoMarkIrpPending(Irp);
 
    //
    // prepare what we can out of the loop
    //
 
    retryInfo = (PCLASS_RETRY_INFO)(&Irp->Tail.Overlay.DriverContext[0]);
    RtlZeroMemory(retryInfo, sizeof(CLASS_RETRY_INFO));
 
    delta.QuadPart = (TimeDelta100ns / fdoData->Retry.Granularity);
    if (TimeDelta100ns % fdoData->Retry.Granularity) {
        delta.QuadPart ++; // round up to next tick
    }
    if (delta.QuadPart == (LONGLONG)0) {
        delta.QuadPart = MINIMUM_RETRY_UNITS;
    }
 
    //
    // now determine if we should fire another DPC or not
    //
 
    KeAcquireSpinLock(&fdoData->Retry.Lock, &irql);
 
    //
    // always add request to the list
    //
 
    retryInfo->Next = fdoData->Retry.ListHead;
    fdoData->Retry.ListHead = retryInfo;
 
    if (fdoData->Retry.Delta.QuadPart == (LONGLONG)0) {
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassRetry: +++ %p\n", Irp));
 
        //
        // must be exactly one item on list
        //
 
        NT_ASSERT(fdoData->Retry.ListHead       != NULL);
        NT_ASSERT(fdoData->Retry.ListHead->Next == NULL);
 
        //
        // if currentDelta is zero, always fire a DPC
        //
 
        KeQueryTickCount(&fdoData->Retry.Tick);
        fdoData->Retry.Tick.QuadPart  += delta.QuadPart;
        fdoData->Retry.Delta.QuadPart  = delta.QuadPart;
        ClasspRetryDpcTimer(fdoData);
 
    } else if (delta.QuadPart > fdoData->Retry.Delta.QuadPart) {
 
        //
        // if delta is greater than the list's current delta,
        // increase the DPC handling time by difference
        // and update the delta to new larger value
        // allow the DPC to re-fire itself if needed
        //
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassRetry:  ++ %p\n", Irp));
 
        //
        // must be at least two items on list
        //
 
        NT_ASSERT(fdoData->Retry.ListHead       != NULL);
        NT_ASSERT(fdoData->Retry.ListHead->Next != NULL);
 
        fdoData->Retry.Tick.QuadPart  -= fdoData->Retry.Delta.QuadPart;
        fdoData->Retry.Tick.QuadPart  += delta.QuadPart;
 
        fdoData->Retry.Delta.QuadPart  = delta.QuadPart;
 
    } else {
 
        //
        // just inserting it on the list was enough
        //
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassRetry:  ++ %p\n", Irp));
 
    }
 
 
    KeReleaseSpinLock(&fdoData->Retry.Lock, irql);
 
 
} // end ClassRetryRequest()

Referenced by RetryPowerRequest(), and RetryRequest().

◆ ClassSendEjectionNotification()

VOID ClassSendEjectionNotification ( IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension )

Definition at line 155 of file autorun.c.

{
    //
    // For post-NT5.1 work, need to move EjectSynchronizationEvent
    // to be a MUTEX so we can attempt to grab it here and benefit
    // from deadlock detection.  This will allow checking if the media
    // has been locked by programs before broadcasting these events.
    // (what's the point of broadcasting if the media is not locked?)
    //
    // This would currently only be a slight optimization.  For post-NT5.1,
    // it would allow us to send a single PERSISTENT_PREVENT to MMC devices,
    // thereby cleaning up a lot of the ejection code.  Then, when the
    // ejection request occured, we could see if any locks for the media
    // existed.  if locked, broadcast.  if not, we send the eject irp.
    //
 
    //
    // for now, just always broadcast.  make this a public routine,
    // so class drivers can add special hacks to broadcast this for their
    // non-MMC-compliant devices also from sense codes.
    //
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN, "ClassSendEjectionNotification: media EJECT_REQUEST"));
    ClassSendNotification(FdoExtension,
                           &GUID_IO_MEDIA_EJECT_REQUEST,
                           0,
                           NULL);
    return;
}

Referenced by ClassInterpretSenseInfo(), and ClasspInterpretGesnData().

◆ CleanupTransferPacketToWorkingSetSize()

VOID CleanupTransferPacketToWorkingSetSize	(	_In_ PDEVICE_OBJECT	Fdo,
		_In_ BOOLEAN	LimitNumPktToDelete,
		_In_ ULONG	Node
	)

Definition at line 1615 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    KIRQL oldIrql;
    SINGLE_LIST_ENTRY pktList;
    PSINGLE_LIST_ENTRY slistEntry;
    PTRANSFER_PACKET pktToDelete;
    ULONG requiredNumPktToDelete = fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets -
                                   fdoData->LocalMaxWorkingSetTransferPackets;
 
    if (LimitNumPktToDelete) {
        requiredNumPktToDelete = MIN(requiredNumPktToDelete, MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE);
    }
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW, "CleanupTransferPacketToWorkingSetSize (%p): Exiting stress, block freeing %d packets.", Fdo, requiredNumPktToDelete));
 
    /*
     *  Check the counter again with lock held.  This eliminates a race condition
     *  while still allowing us to not grab the spinlock in the common codepath.
     *
     *  Note that the spinlock does not synchronize with threads dequeuing free
     *  packets to send (DequeueFreeTransferPacket does that with a lightweight
     *  interlocked exchange); the spinlock prevents multiple threads in this function
     *  from deciding to free too many extra packets at once.
     */
    SimpleInitSlistHdr(&pktList);
    KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
    while ((fdoData->FreeTransferPacketsLists[Node].NumFreeTransferPackets >= fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets) &&
           (fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets > fdoData->LocalMaxWorkingSetTransferPackets) &&
           (requiredNumPktToDelete--)){
 
        pktToDelete = DequeueFreeTransferPacketEx(Fdo, FALSE, Node);
        if (pktToDelete){
            SimplePushSlist(&pktList,
                            (PSINGLE_LIST_ENTRY)&pktToDelete->SlistEntry);
            InterlockedDecrement((volatile LONG *)&fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets);
        } else {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW,
                "Extremely unlikely condition (non-fatal): %d packets dequeued at once for Fdo %p. NumTotalTransferPackets=%d (1). Node=%d",
                fdoData->LocalMaxWorkingSetTransferPackets,
                Fdo,
                fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets,
                Node));
            break;
        }
    }
    KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
 
    slistEntry = SimplePopSlist(&pktList);
    while (slistEntry) {
        pktToDelete = CONTAINING_RECORD(slistEntry, TRANSFER_PACKET, SlistEntry);
        DestroyTransferPacket(pktToDelete);
        slistEntry = SimplePopSlist(&pktList);
    }
 
    return;
}

Referenced by CleanupTransferPacketToWorkingSetSizeWorker(), and EnqueueFreeTransferPacket().

◆ CreateStorageRequestBlock()

NTSTATUS CreateStorageRequestBlock	(	_Inout_ PSTORAGE_REQUEST_BLOCK *	Srb,
		_In_ USHORT	AddressType,
		_In_opt_ PSRB_ALLOCATE_ROUTINE	AllocateRoutine,
		_Inout_opt_ ULONG *	ByteSize,
		_In_ ULONG	NumSrbExData,
			...
	)

Definition at line 249 of file srblib.c.

{
    ULONG sizeNeeded = 0;
    va_list ap;
    ULONG i;
    NTSTATUS status = STATUS_SUCCESS;
 
    // Ensure SrbExData offsets are pointer type aligned
    sizeNeeded = sizeof(STORAGE_REQUEST_BLOCK);
    if (NumSrbExData > 0) {
        sizeNeeded += ((NumSrbExData - 1) * sizeof(ULONG));
        if (sizeNeeded % sizeof(PVOID)) {
            sizeNeeded += (sizeof(PVOID) - (sizeNeeded % sizeof(PVOID)));
        }
    }
 
    if (AddressType == STORAGE_ADDRESS_TYPE_BTL8)
    {
        sizeNeeded += sizeof(STOR_ADDR_BTL8);
    } else
    {
        status = STATUS_INVALID_PARAMETER;
    }
 
    va_start(ap, NumSrbExData);
 
    for (i = 0; i < NumSrbExData && status == STATUS_SUCCESS; i++)
    {
        switch (va_arg(ap, SRBEXDATATYPE))
        {
            case SrbExDataTypeBidirectional:
                sizeNeeded += sizeof(SRBEX_DATA_BIDIRECTIONAL);
                break;
            case SrbExDataTypeScsiCdb16:
                sizeNeeded += sizeof(SRBEX_DATA_SCSI_CDB16);
                break;
            case SrbExDataTypeScsiCdb32:
                sizeNeeded += sizeof(SRBEX_DATA_SCSI_CDB32);
                break;
            case SrbExDataTypeScsiCdbVar:
                sizeNeeded += sizeof(SRBEX_DATA_SCSI_CDB_VAR) + va_arg(ap, ULONG);
                break;
            case SrbExDataTypeWmi:
                sizeNeeded += sizeof(SRBEX_DATA_WMI);
                break;
            case SrbExDataTypePower:
                sizeNeeded += sizeof(SRBEX_DATA_POWER);
                break;
            case SrbExDataTypePnP:
                sizeNeeded += sizeof(SRBEX_DATA_PNP);
                break;
            case SrbExDataTypeIoInfo:
                sizeNeeded += sizeof(SRBEX_DATA_IO_INFO);
                break;
            default:
                status = STATUS_INVALID_PARAMETER;
                break;
        }
    }
    va_end(ap);
 
    if (status == STATUS_SUCCESS)
    {
        if (AllocateRoutine)
        {
            *Srb = AllocateRoutine(sizeNeeded);
            if (*Srb == NULL)
            {
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
        }
 
        if (ByteSize != NULL)
        {
            *ByteSize = sizeNeeded;
        }
 
        if (*Srb)
        {
            va_start(ap, NumSrbExData);
#ifdef _MSC_VER
            #pragma prefast(suppress:26015, "pInitializeStorageRequestBlock will set the SrbLength field")
#endif
            status = pInitializeStorageRequestBlock(*Srb, AddressType, sizeNeeded, NumSrbExData, ap);
            va_end(ap);
        }
 
    }
 
    return status;
}

Referenced by __drv_allocatesMem(), and InitializeTransferPackets().

◆ DefaultStorageRequestBlockAllocateRoutine()

PVOID DefaultStorageRequestBlockAllocateRoutine ( _In_ CLONG ByteSize )

Definition at line 28 of file srblib.c.

{
    return ExAllocatePoolWithTag(NonPagedPoolNx, ByteSize, '+brs');
}

Referenced by __drv_allocatesMem(), and InitializeTransferPackets().

◆ DequeueDeferredClientIrp()

PIRP DequeueDeferredClientIrp ( PDEVICE_OBJECT Fdo )

Definition at line 113 of file clntirp.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    PIRP irp;
 
    //
    // The DeferredClientIrpList is almost always empty.
    // We don't want to grab the spinlock every time we check it (which is on every xfer completion)
    // so check once first before we grab the spinlock.
    //
    if (IsListEmpty(&fdoData->DeferredClientIrpList)){
        irp = NULL;
    }
    else {
        PLIST_ENTRY listEntry;
        KIRQL oldIrql;
 
        KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
        if (IsListEmpty(&fdoData->DeferredClientIrpList)){
            listEntry = NULL;
        }
        else {
            listEntry = RemoveHeadList(&fdoData->DeferredClientIrpList);
        }
        KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
 
        if (listEntry == NULL) {
            irp = NULL;
        }
        else {
            irp = CONTAINING_RECORD(listEntry, IRP, Tail.Overlay.ListEntry);
            NT_ASSERT(irp->Type == IO_TYPE_IRP);
 
 
            InitializeListHead(&irp->Tail.Overlay.ListEntry);
        }
    }
 
    return irp;
}

Referenced by TransferPktComplete().

◆ DequeueFreeTransferPacket()

PTRANSFER_PACKET DequeueFreeTransferPacket	(	PDEVICE_OBJECT	Fdo,
		BOOLEAN	AllocIfNeeded
	)

Definition at line 656 of file xferpkt.c.

{
    return DequeueFreeTransferPacketEx(Fdo, AllocIfNeeded, KeGetCurrentNodeNumber());
}

Referenced by ClasspContinueOffloadWrite(), ClasspModeSelect(), ClasspModeSense(), ClasspReceivePopulateTokenInformation(), ClasspReceiveWriteUsingTokenInformation(), ClassReadDriveCapacity(), and ServiceTransferRequest().

◆ DequeueFreeTransferPacketEx()

PTRANSFER_PACKET DequeueFreeTransferPacketEx	(	_In_ PDEVICE_OBJECT	Fdo,
		_In_ BOOLEAN	AllocIfNeeded,
		_In_ ULONG	Node
	)

Definition at line 661 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    PTRANSFER_PACKET pkt;
    PSLIST_ENTRY slistEntry;
 
    slistEntry = InterlockedPopEntrySList(&(fdoData->FreeTransferPacketsLists[Node].SListHeader));
 
    if (slistEntry) {
        slistEntry->Next = NULL;
        pkt = CONTAINING_RECORD(slistEntry, TRANSFER_PACKET, SlistEntry);
        InterlockedDecrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[Node].NumFreeTransferPackets));
 
        // when dequeuing the packet, also reset the history data
        HISTORYINITIALIZERETRYLOGS(pkt);
 
    } else {
        if (AllocIfNeeded) {
            /*
             *  We are in stress and have run out of lookaside packets.
             *  In order to service the current transfer,
             *  allocate an extra packet.
             *  We will free it lazily when we are out of stress.
             */
            pkt = NewTransferPacket(Fdo);
            if (pkt) {
                InterlockedIncrement((volatile LONG *)&fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets);
                fdoData->FreeTransferPacketsLists[Node].DbgPeakNumTransferPackets =
                    max(fdoData->FreeTransferPacketsLists[Node].DbgPeakNumTransferPackets,
                        fdoData->FreeTransferPacketsLists[Node].NumTotalTransferPackets);
            } else {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_RW, "DequeueFreeTransferPacket: packet allocation failed"));
            }
        } else {
            pkt = NULL;
        }
    }
 
    return pkt;
}

Referenced by CleanupTransferPacketToWorkingSetSize(), DequeueFreeTransferPacket(), DestroyAllTransferPackets(), and EnqueueFreeTransferPacket().

◆ DestroyAllTransferPackets()

VOID DestroyAllTransferPackets ( PDEVICE_OBJECT Fdo )

Definition at line 288 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    TRANSFER_PACKET *pkt;
    ULONG index;
    ULONG arraySize;
 
    PAGED_CODE();
 
    //
    // fdoData->FreeTransferPacketsLists could be NULL if
    // there was an error during start device.
    //
    if (fdoData->FreeTransferPacketsLists != NULL) {
 
        NT_ASSERT(IsListEmpty(&fdoData->DeferredClientIrpList));
 
        arraySize = KeQueryHighestNodeNumber() + 1;
        for (index = 0; index < arraySize; index++) {
            pkt = DequeueFreeTransferPacketEx(Fdo, FALSE, index);
            while (pkt) {
                DestroyTransferPacket(pkt);
                InterlockedDecrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[index].NumTotalTransferPackets));
                pkt = DequeueFreeTransferPacketEx(Fdo, FALSE, index);
            }
 
            NT_ASSERT(fdoData->FreeTransferPacketsLists[index].NumTotalTransferPackets == 0);
        }
    }
 
    FREE_POOL(fdoData->SrbTemplate);
}

◆ DestroyTransferPacket()

VOID DestroyTransferPacket ( _In_ __drv_freesMem(mem) PTRANSFER_PACKET Pkt )

Definition at line 500 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    KIRQL oldIrql;
 
    NT_ASSERT(!Pkt->SlistEntry.Next);
//    NT_ASSERT(!Pkt->OriginalIrp);
 
    KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
 
    /*
     *  Delete the packet from our all-packets queue.
     */
    NT_ASSERT(!IsListEmpty(&Pkt->AllPktsListEntry));
    NT_ASSERT(!IsListEmpty(&fdoData->AllTransferPacketsList));
    RemoveEntryList(&Pkt->AllPktsListEntry);
    InitializeListHead(&Pkt->AllPktsListEntry);
 
    KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
 
    IoFreeMdl(Pkt->PartialMdl);
    IoFreeIrp(Pkt->Irp);
    FREE_POOL(Pkt->RetryHistory);
    FREE_POOL(Pkt->Srb);
    FREE_POOL(Pkt);
}

Referenced by CleanupTransferPacketToWorkingSetSize(), DestroyAllTransferPackets(), and EnqueueFreeTransferPacket().

◆ EnqueueDeferredClientIrp()

VOID EnqueueDeferredClientIrp	(	PDEVICE_OBJECT	Fdo,
		PIRP	Irp
	)

Definition at line 78 of file clntirp.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    KIRQL oldIrql;
 
 
    KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
    InsertTailList(&fdoData->DeferredClientIrpList, &Irp->Tail.Overlay.ListEntry);
 
 
    KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
}

Referenced by ServiceTransferRequest().

◆ EnqueueFreeTransferPacket()

VOID EnqueueFreeTransferPacket	(	PDEVICE_OBJECT	Fdo,
		__drv_aliasesMem PTRANSFER_PACKET	Pkt
	)

Definition at line 529 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    ULONG allocateNode;
    KIRQL oldIrql;
 
    NT_ASSERT(!Pkt->SlistEntry.Next);
 
    allocateNode = Pkt->AllocateNode;
    InterlockedPushEntrySList(&(fdoData->FreeTransferPacketsLists[allocateNode].SListHeader), &Pkt->SlistEntry);
    InterlockedIncrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[allocateNode].NumFreeTransferPackets));
 
    /*
     *  If the total number of packets is larger than LocalMinWorkingSetTransferPackets,
     *  that means that we've been in stress.  If all those packets are now
     *  free, then we are now out of stress and can free the extra packets.
     *  Attempt to free down to LocalMaxWorkingSetTransferPackets immediately, and
     *  down to LocalMinWorkingSetTransferPackets lazily (one at a time).
     *  However, since we're at DPC, do this is a work item. If the device is removed
     *  or we are unable to allocate the work item, do NOT free more than
     *  MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE. Subsequent IO completions will end up freeing
     *  up the rest, even if it is MAX_CLEANUP_TRANSFER_PACKETS_AT_ONCE at a time.
     */
    if (fdoData->FreeTransferPacketsLists[allocateNode].NumFreeTransferPackets >=
        fdoData->FreeTransferPacketsLists[allocateNode].NumTotalTransferPackets) {
 
        /*
         *  1.  Immediately snap down to our UPPER threshold.
         */
        if (fdoData->FreeTransferPacketsLists[allocateNode].NumTotalTransferPackets >
            fdoData->LocalMaxWorkingSetTransferPackets) {
 
            ULONG isRemoved;
            PIO_WORKITEM workItem = NULL;
 
            workItem = IoAllocateWorkItem(Fdo);
 
            //
            // Acquire a remove lock in order to make sure the device object and its
            // private data structures will exist when the workitem fires.
            // The remove lock will be released by the workitem (CleanupTransferPacketToWorkingSetSize).
            //
            isRemoved = ClassAcquireRemoveLock(Fdo, (PIRP)workItem);
 
            if (workItem && !isRemoved) {
 
                TracePrint((TRACE_LEVEL_INFORMATION,
                            TRACE_FLAG_GENERAL,
                            "EnqueueFreeTransferPacket: Device (%p), queuing work item to clean up free transfer packets.\n",
                            Fdo));
 
                //
                // Queue a work item to trim down the total number of transfer packets to with the
                // working size.
                //
                IoQueueWorkItemEx(workItem, CleanupTransferPacketToWorkingSetSizeWorker, DelayedWorkQueue, (PVOID)(ULONG_PTR)allocateNode);
 
            } else {
 
                if (workItem) {
                    IoFreeWorkItem(workItem);
                }
 
                if (isRemoved != REMOVE_COMPLETE) {
                    ClassReleaseRemoveLock(Fdo, (PIRP)workItem);
                }
 
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_GENERAL,
                            "EnqueueFreeTransferPacket: Device (%p), Failed to allocate memory for the work item.\n",
                            Fdo));
 
                CleanupTransferPacketToWorkingSetSize(Fdo, TRUE, allocateNode);
            }
        }
 
        /*
         *  2.  Lazily work down to our LOWER threshold (by only freeing one packet at a time).
         */
        if (fdoData->FreeTransferPacketsLists[allocateNode].NumTotalTransferPackets >
            fdoData->LocalMinWorkingSetTransferPackets){
            /*
             *  Check the counter again with lock held.  This eliminates a race condition
             *  while still allowing us to not grab the spinlock in the common codepath.
             *
             *  Note that the spinlock does not synchronize with threads dequeuing free
             *  packets to send (DequeueFreeTransferPacket does that with a lightweight
             *  interlocked exchange); the spinlock prevents multiple threads in this function
             *  from deciding to free too many extra packets at once.
             */
            PTRANSFER_PACKET pktToDelete = NULL;
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW, "Exiting stress, lazily freeing one of %d/%d packets from node %d.",
                fdoData->FreeTransferPacketsLists[allocateNode].NumTotalTransferPackets,
                fdoData->LocalMinWorkingSetTransferPackets,
                allocateNode));
 
            KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
            if ((fdoData->FreeTransferPacketsLists[allocateNode].NumFreeTransferPackets >=
                fdoData->FreeTransferPacketsLists[allocateNode].NumTotalTransferPackets) &&
                (fdoData->FreeTransferPacketsLists[allocateNode].NumTotalTransferPackets >
                fdoData->LocalMinWorkingSetTransferPackets)){
 
                pktToDelete = DequeueFreeTransferPacketEx(Fdo, FALSE, allocateNode);
                if (pktToDelete) {
                    InterlockedDecrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[allocateNode].NumTotalTransferPackets));
                } else {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_RW,
                        "Extremely unlikely condition (non-fatal): %d packets dequeued at once for Fdo %p. NumTotalTransferPackets=%d (2). Node=%d",
                        fdoData->LocalMinWorkingSetTransferPackets,
                        Fdo,
                        fdoData->FreeTransferPacketsLists[allocateNode].NumTotalTransferPackets,
                        allocateNode));
                }
            }
            KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
 
            if (pktToDelete) {
                DestroyTransferPacket(pktToDelete);
            }
        }
 
    }
 
}

Referenced by InitializeTransferPackets(), ServiceTransferRequest(), and TransferPktComplete().

◆ FREE_PORT_ALLOCATED_SENSE_BUFFER_EX()

FORCEINLINE VOID FREE_PORT_ALLOCATED_SENSE_BUFFER_EX	(	_In_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_In_ PSTORAGE_REQUEST_BLOCK_HEADER	Srb
	)

Definition at line 2560 of file classp.h.

{
    NT_ASSERT(TEST_FLAG(SrbGetSrbFlags(Srb), SRB_FLAGS_PORT_DRIVER_ALLOCSENSE));
    NT_ASSERT(TEST_FLAG(SrbGetSrbFlags(Srb), SRB_FLAGS_FREE_SENSE_BUFFER));
    NT_ASSERT(SrbGetSenseInfoBuffer(Srb) != FdoExtension->SenseData);
 
    ExFreePool(SrbGetSenseInfoBuffer(Srb));
    SrbSetSenseInfoBuffer(Srb, FdoExtension->SenseData);
    SrbSetSenseInfoBufferLength(Srb, GET_FDO_EXTENSON_SENSE_DATA_LENGTH(FdoExtension));
    SrbClearSrbFlags(Srb, SRB_FLAGS_FREE_SENSE_BUFFER);
    return;
}

Referenced by _Success_(), ClasspMediaChangeDetectionCompletion(), ClassSendSrbSynchronous(), TransferPacketRetryTimerDpc(), and TransferPktComplete().

◆ FreeDeviceInputMdl()

VOID FreeDeviceInputMdl ( PMDL Mdl )

Definition at line 622 of file utils.c.

{
    ClasspFreeDeviceMdl(Mdl);
    return;
}

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

◆ FreeDictionaryEntry()

VOID FreeDictionaryEntry	(	IN PDICTIONARY	Dictionary,
		IN PVOID	Entry
	)

Definition at line 189 of file dictlib.c.

{
    PDICTIONARY_HEADER header;
    PDICTIONARY_HEADER *entry;
    KIRQL oldIrql;
    BOOLEAN found;
 
    found = FALSE;
    header = CONTAINING_RECORD(Entry, DICTIONARY_HEADER, Data);
 
    KeAcquireSpinLock(&(Dictionary->SpinLock), &oldIrql);
 
    entry = &(Dictionary->List);
    while(*entry != NULL) {
 
        if(*entry == header) {
            *entry = header->Next;
            found = TRUE;
            break;
        } else {
            entry = &(*entry)->Next;
        }
    }
 
    KeReleaseSpinLock(&(Dictionary->SpinLock), oldIrql);
 
    //
    // calling this w/an invalid pointer invalidates the dictionary system,
    // so NT_ASSERT() that we never try to Free something not in the list
    //
 
    NT_ASSERT(found);
    if (found) {
        FREE_POOL(header);
    }
 
    return;
 
}

Referenced by ClasspCreateClose().

◆ GetDictionaryEntry()

PVOID GetDictionaryEntry	(	IN PDICTIONARY	Dictionary,
		IN ULONGLONG	Key
	)

Definition at line 157 of file dictlib.c.

{
    PDICTIONARY_HEADER entry;
    PVOID data;
    KIRQL oldIrql;
 
 
    data = NULL;
 
    KeAcquireSpinLock(&(Dictionary->SpinLock), &oldIrql);
 
    entry = Dictionary->List;
    while (entry != NULL) {
 
        if (entry->Key == Key) {
            data = entry->Data;
            break;
        } else {
            entry = entry->Next;
        }
    }
 
    KeReleaseSpinLock(&(Dictionary->SpinLock), oldIrql);
 
    return data;
}

Referenced by _IRQL_requires_max_().

◆ HistoryInitializeRetryLogs()

VOID HistoryInitializeRetryLogs	(	_Out_ PSRB_HISTORY	History,
		ULONG	HistoryCount
	)

Definition at line 36 of file history.c.

                                                                                {
    ULONG tmpSize = HistoryCount * sizeof(SRB_HISTORY_ITEM);
    tmpSize += sizeof(SRB_HISTORY) - sizeof(SRB_HISTORY_ITEM);
    RtlZeroMemory(History, tmpSize);
    History->TotalHistoryCount = HistoryCount;
    return;
}

Referenced by __drv_allocatesMem().

◆ HistoryLogReturnedPacket()

VOID HistoryLogReturnedPacket ( TRANSFER_PACKET * Pkt )

Definition at line 83 of file history.c.

                                                    {
 
    PSRB_HISTORY history;
    PSRB_HISTORY_ITEM item;
    UCHAR senseSize;
    PVOID senseInfoBuffer;
    UCHAR senseInfoBufferLength;
    SENSE_DATA convertedSenseBuffer = {0};
    BOOLEAN validSense = TRUE;
 
    NT_ASSERT( Pkt->RetryHistory != NULL );
    history = Pkt->RetryHistory;
    NT_ASSERT( history->UsedHistoryCount <= history->TotalHistoryCount );
    item = &( history->History[ history->UsedHistoryCount-1 ] );
 
    // Query the tick count and store in the history
    KeQueryTickCount(&item->TickCountCompleted);
 
    // Copy the SRB Status...
    item->SrbStatus = Pkt->Srb->SrbStatus;
 
    //
    // Process sense data
    //
 
    senseInfoBuffer = ClasspTransferPacketGetSenseInfoBuffer(Pkt);
    senseInfoBufferLength = ClasspTransferPacketGetSenseInfoBufferLength(Pkt);
 
    if (IsDescriptorSenseDataFormat(senseInfoBuffer)) {
 
        validSense = ScsiConvertToFixedSenseFormat(senseInfoBuffer,
                                                   senseInfoBufferLength,
                                                   (PVOID)&convertedSenseBuffer,
                                                   sizeof(convertedSenseBuffer));
 
        if (validSense) {
            senseInfoBuffer = (PVOID)&convertedSenseBuffer;
            senseInfoBufferLength = sizeof(convertedSenseBuffer);
        }
    }
 
    RtlZeroMemory(&(item->NormalizedSenseData), sizeof(item->NormalizedSenseData));
 
    if (validSense) {
 
        // Determine the amount of valid sense data
 
        if (!ScsiGetTotalSenseByteCountIndicated(senseInfoBuffer,
                                                 senseInfoBufferLength,
                                                 &senseSize)) {
            senseSize = senseInfoBufferLength;
        }
 
        // Normalize the sense data copy in the history
        senseSize = min(senseSize, sizeof(item->NormalizedSenseData));
        RtlCopyMemory(&(item->NormalizedSenseData),
                      senseInfoBuffer,
                      senseSize
                      );
    }
 
    return;
}

◆ HistoryLogSendPacket()

VOID HistoryLogSendPacket ( TRANSFER_PACKET * Pkt )

Definition at line 45 of file history.c.

                                                 {
 
    PSRB_HISTORY history;
    PSRB_HISTORY_ITEM item;
 
    NT_ASSERT( Pkt->RetryHistory != NULL );
    history = Pkt->RetryHistory;
    // sending a packet implies a new history unit is to be used.
    NT_ASSERT( history->UsedHistoryCount <= history->TotalHistoryCount );
 
    // if already all used up, request class driver to remove at least one history unit
    if (history->UsedHistoryCount == history->TotalHistoryCount )
    {
        PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Pkt->Fdo->DeviceExtension;
        PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
        NT_ASSERT( fdoData->InterpretSenseInfo != NULL );
        NT_ASSERT( fdoData->InterpretSenseInfo->Compress != NULL );
        fdoData->InterpretSenseInfo->Compress( fdoExtension->DeviceObject, history );
        NT_ASSERT( history->UsedHistoryCount < history->TotalHistoryCount );
    }
 
    // thus, since we are about to increment the count, it must now be less...
    NT_ASSERT( history->UsedHistoryCount < history->TotalHistoryCount );
 
    // increment the number of history units in use
    history->UsedHistoryCount++;
 
    // determine index to use
    item = &( history->History[ history->UsedHistoryCount-1 ] );
 
    // zero out the history item
    RtlZeroMemory(item, sizeof(SRB_HISTORY_ITEM));
 
    // Query the tick count and store in the history
    KeQueryTickCount(&item->TickCountSent);
    return;
}

◆ InitializeDictionary()

VOID InitializeDictionary ( IN PDICTIONARY Dictionary )

Definition at line 58 of file dictlib.c.

{
    RtlZeroMemory(Dictionary, sizeof(DICTIONARY));
    Dictionary->Signature = DICTIONARY_SIGNATURE;
    KeInitializeSpinLock(&Dictionary->SpinLock);
    return;
}

◆ InitializeStorageRequestBlock()

NTSTATUS InitializeStorageRequestBlock	(	_Inout_bytecount_(ByteSize) PSTORAGE_REQUEST_BLOCK	Srb,
		_In_ USHORT	AddressType,
		_In_ ULONG	ByteSize,
		_In_ ULONG	NumSrbExData,
			...
	)

Definition at line 206 of file srblib.c.

{
    NTSTATUS status;
    va_list ap;
    va_start(ap, NumSrbExData);
    status = pInitializeStorageRequestBlock(Srb, AddressType, ByteSize, NumSrbExData, ap);
    va_end(ap);
    return status;
}

Referenced by ClassDeviceControl(), ClassGetLBProvisioningLogPage(), ClasspBuildRequestEx(), ClasspCleanupProtectedLocks(), ClasspDeviceGetBlockLimitsVPDPage(), ClasspDeviceGetLBProvisioningVPDPage(), ClasspEjectionControl(), ClasspGetBlockDeviceTokenLimitsInfo(), ClasspGetInquiryVpdSupportInfo(), ClasspInterpretGesnData(), ClassPnpStartDevice(), ClasspPowerDownCompletion(), ClasspPowerHandler(), ClasspPowerUpCompletion(), ClasspPrepareMcnIrp(), ClassReadCapacity16(), ClassSendStartUnit(), and DeviceProcessDsmTrimRequest().

◆ InitializeTransferPackets()

NTSTATUS InitializeTransferPackets ( PDEVICE_OBJECT Fdo )

Definition at line 45 of file xferpkt.c.

{
    PCOMMON_DEVICE_EXTENSION commonExt = Fdo->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExt->PartitionZeroExtension->AdapterDescriptor;
    PSTORAGE_DEVICE_IO_CAPABILITY_DESCRIPTOR devIoCapabilityDesc = NULL;
    STORAGE_PROPERTY_ID propertyId;
    OSVERSIONINFOEXW osVersionInfo;
    ULONG hwMaxPages;
    ULONG arraySize;
    ULONG index;
    ULONG maxOutstandingIOPerLUN;
    ULONG minWorkingSetTransferPackets;
    ULONG maxWorkingSetTransferPackets;
 
    NTSTATUS status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    //
    //  Precompute the maximum transfer length
    //
    NT_ASSERT(adapterDesc->MaximumTransferLength);
 
    hwMaxPages = adapterDesc->MaximumPhysicalPages ? adapterDesc->MaximumPhysicalPages-1 : 0;
 
    fdoData->HwMaxXferLen = MIN(adapterDesc->MaximumTransferLength, hwMaxPages << PAGE_SHIFT);
    fdoData->HwMaxXferLen = MAX(fdoData->HwMaxXferLen, PAGE_SIZE);
 
    //
    // Allocate per-node free packet lists
    //
    arraySize = KeQueryHighestNodeNumber() + 1;
    fdoData->FreeTransferPacketsLists =
        ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                              sizeof(PNL_SLIST_HEADER) * arraySize,
                              CLASS_TAG_PRIVATE_DATA);
 
    if (fdoData->FreeTransferPacketsLists == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        return status;
    }
 
    for (index = 0; index < arraySize; index++) {
        InitializeSListHead(&(fdoData->FreeTransferPacketsLists[index].SListHeader));
        fdoData->FreeTransferPacketsLists[index].NumTotalTransferPackets = 0;
        fdoData->FreeTransferPacketsLists[index].NumFreeTransferPackets = 0;
    }
 
    InitializeListHead(&fdoData->AllTransferPacketsList);
 
    //
    // Set the packet threshold numbers based on the Windows Client or Server SKU.
    //
 
    osVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
    status = RtlGetVersion((POSVERSIONINFOW) &osVersionInfo);
 
    NT_ASSERT( NT_SUCCESS(status));
 
    //
    // Retrieve info on IO capability supported by port drivers
    //
 
    propertyId = StorageDeviceIoCapabilityProperty;
    status = ClassGetDescriptor(fdoExt->CommonExtension.LowerDeviceObject,
                                &propertyId,
                                (PVOID *)&devIoCapabilityDesc);
 
    if (NT_SUCCESS(status) && (devIoCapabilityDesc != NULL)) {
        maxOutstandingIOPerLUN = devIoCapabilityDesc->LunMaxIoCount;
        FREE_POOL(devIoCapabilityDesc);
 
#if DBG
        fdoData->MaxOutstandingIOPerLUN = maxOutstandingIOPerLUN;
#endif
 
    } else {
        maxOutstandingIOPerLUN = MAX_OUTSTANDING_IO_PER_LUN_DEFAULT;
 
#if DBG
        fdoData->MaxOutstandingIOPerLUN = 0;
#endif
 
    }
 
    //
    // StorageDeviceIoCapabilityProperty support is optional so
    // ignore any failures.
    //
 
    status = STATUS_SUCCESS;
 
 
    if ((osVersionInfo.wProductType != VER_NT_DOMAIN_CONTROLLER) &&
        (osVersionInfo.wProductType != VER_NT_SERVER)) {
 
        // this is Client SKU
 
            minWorkingSetTransferPackets = MIN_WORKINGSET_TRANSFER_PACKETS_Client;
 
        // Note: the reason we use max here is to guarantee a reasonable large max number
        // in the case where the port driver may return a very small supported outstanding
        // IOs. For example, even EMMC drive only reports 1 outstanding IO supported, we
        // may still want to set this value to be at least
        // MAX_WORKINGSET_TRANSFER_PACKETS_Client.
        maxWorkingSetTransferPackets = max(MAX_WORKINGSET_TRANSFER_PACKETS_Client,
                                           2 * maxOutstandingIOPerLUN);
 
    } else {
 
        // this is Server SKU
        // Note: the addition max here to make sure we set the min to be at least
        // MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound no matter what maxOutstandingIOPerLUN
        // reported. We shouldn't set this value to be smaller than client system.
        // In other words, the minWorkingSetTransferPackets for server will always between
        // MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound and MIN_WORKINGSET_TRANSFER_PACKETS_Server_UpperBound
 
        minWorkingSetTransferPackets =
            max(MIN_WORKINGSET_TRANSFER_PACKETS_Server_LowerBound,
                min(MIN_WORKINGSET_TRANSFER_PACKETS_Server_UpperBound,
                    maxOutstandingIOPerLUN));
 
        maxWorkingSetTransferPackets = max(MAX_WORKINGSET_TRANSFER_PACKETS_Server,
                                           2 * maxOutstandingIOPerLUN);
    }
 
 
    fdoData->LocalMinWorkingSetTransferPackets = minWorkingSetTransferPackets;
    fdoData->LocalMaxWorkingSetTransferPackets = maxWorkingSetTransferPackets;
 
    //
    //  Allow class driver to override the settings
    //
    if (commonExt->DriverExtension->WorkingSet != NULL) {
        PCLASS_WORKING_SET workingSet = commonExt->DriverExtension->WorkingSet;
 
        // override only if non-zero
        if (workingSet->XferPacketsWorkingSetMinimum != 0)
        {
            fdoData->LocalMinWorkingSetTransferPackets = workingSet->XferPacketsWorkingSetMinimum;
            // adjust maximum upwards if needed
            if (fdoData->LocalMaxWorkingSetTransferPackets < fdoData->LocalMinWorkingSetTransferPackets)
            {
                fdoData->LocalMaxWorkingSetTransferPackets = fdoData->LocalMinWorkingSetTransferPackets;
            }
        }
        // override only if non-zero
        if (workingSet->XferPacketsWorkingSetMaximum != 0)
        {
            fdoData->LocalMaxWorkingSetTransferPackets = workingSet->XferPacketsWorkingSetMaximum;
            // adjust minimum downwards if needed
            if (fdoData->LocalMinWorkingSetTransferPackets > fdoData->LocalMaxWorkingSetTransferPackets)
            {
                fdoData->LocalMinWorkingSetTransferPackets = fdoData->LocalMaxWorkingSetTransferPackets;
            }
        }
        // that's all the adjustments required/allowed
    } // end working set size special code
 
    for (index = 0; index < arraySize; index++) {
        while (fdoData->FreeTransferPacketsLists[index].NumFreeTransferPackets < MIN_INITIAL_TRANSFER_PACKETS){
            PTRANSFER_PACKET pkt = NewTransferPacket(Fdo);
            if (pkt) {
                InterlockedIncrement((volatile LONG *)&(fdoData->FreeTransferPacketsLists[index].NumTotalTransferPackets));
                pkt->AllocateNode = index;
                EnqueueFreeTransferPacket(Fdo, pkt);
            } else {
                status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }
        }
        fdoData->FreeTransferPacketsLists[index].DbgPeakNumTransferPackets = fdoData->FreeTransferPacketsLists[index].NumTotalTransferPackets;
    }
 
    //
    //  Pre-initialize our SCSI_REQUEST_BLOCK template with all
    //  the constant fields.  This will save a little time for each xfer.
    //  NOTE: a CdbLength field of 10 may not always be appropriate
    //
 
    if (NT_SUCCESS(status))  {
        if (fdoExt->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
            ULONG ByteSize = 0;
 
    #if (NTDDI_VERSION >= NTDDI_WINBLUE)
            if ((fdoExt->MiniportDescriptor != NULL) &&
                (fdoExt->MiniportDescriptor->Size >= RTL_SIZEOF_THROUGH_FIELD(STORAGE_MINIPORT_DESCRIPTOR, ExtraIoInfoSupported)) &&
                (fdoExt->MiniportDescriptor->ExtraIoInfoSupported == TRUE)) {
                status = CreateStorageRequestBlock((PSTORAGE_REQUEST_BLOCK *)&fdoData->SrbTemplate,
                                                    fdoExt->AdapterDescriptor->AddressType,
                                                    DefaultStorageRequestBlockAllocateRoutine,
                                                    &ByteSize,
                                                    2,
                                                    SrbExDataTypeScsiCdb16,
                                                    SrbExDataTypeIoInfo
                                                  );
            } else {
                status = CreateStorageRequestBlock((PSTORAGE_REQUEST_BLOCK *)&fdoData->SrbTemplate,
                                                    fdoExt->AdapterDescriptor->AddressType,
                                                    DefaultStorageRequestBlockAllocateRoutine,
                                                    &ByteSize,
                                                    1,
                                                    SrbExDataTypeScsiCdb16
                                                  );
            }
    #else
            status = CreateStorageRequestBlock((PSTORAGE_REQUEST_BLOCK *)&fdoData->SrbTemplate,
                                                fdoExt->AdapterDescriptor->AddressType,
                                                DefaultStorageRequestBlockAllocateRoutine,
                                                &ByteSize,
                                                1,
                                                SrbExDataTypeScsiCdb16
                                                );
    #endif
            if (NT_SUCCESS(status)) {
                ((PSTORAGE_REQUEST_BLOCK) fdoData->SrbTemplate)->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
            } else {
                NT_ASSERT(FALSE);
            }
        } else {
            fdoData->SrbTemplate = ExAllocatePoolWithTag(NonPagedPoolNx, sizeof(SCSI_REQUEST_BLOCK), '-brs');
            if (fdoData->SrbTemplate == NULL) {
                status = STATUS_INSUFFICIENT_RESOURCES;
            } else {
                RtlZeroMemory(fdoData->SrbTemplate, sizeof(SCSI_REQUEST_BLOCK));
                fdoData->SrbTemplate->Length = sizeof(SCSI_REQUEST_BLOCK);
                fdoData->SrbTemplate->Function = SRB_FUNCTION_EXECUTE_SCSI;
            }
        }
    }
 
    if (status == STATUS_SUCCESS) {
        SrbSetRequestAttribute(fdoData->SrbTemplate, SRB_SIMPLE_TAG_REQUEST);
        SrbSetSenseInfoBufferLength(fdoData->SrbTemplate, SENSE_BUFFER_SIZE_EX);
        SrbSetCdbLength(fdoData->SrbTemplate, 10);
    }
 
    return status;
}

Referenced by ClassPnpStartDevice().

◆ InitLowMemRetry()

VOID InitLowMemRetry	(	PTRANSFER_PACKET	Pkt,
		PVOID	BufPtr,
		ULONG	Len,
		LARGE_INTEGER	TargetLocation
	)

Definition at line 670 of file retry.c.

{
    NT_ASSERT(Len > 0);
    NT_ASSERT(!Pkt->InLowMemRetry);
 
    if (Pkt->DriverUsesStartIO)
    {
        /*
         * special case: StartIO-based writing must stay serialized for performance
         * and proper operations (i.e. sequential writing mode).  If need more than
         * one transfer to perform this operation, and it's a StartIO-based driver
         * (such as CDROM), then just use a single packet and use the retry logic
         * that's already built-in to the packet engine.  Note that low-mem retry
         * cannot be used directly because some write methods do not work if the
         * writes are only PAGE_SIZE (i.e. packet writing may corrupt data).
         */
        Pkt->InLowMemRetry = FALSE;
    }
    else
    {
        Pkt->InLowMemRetry = TRUE;
    }
    Pkt->LowMemRetry_remainingBufPtr = BufPtr;
    Pkt->LowMemRetry_remainingBufLen = Len;
    Pkt->LowMemRetry_nextChunkTargetLocation = TargetLocation;
}

Referenced by RetryTransferPacket(), and ServiceTransferRequest().

◆ InterpretCapacityData()

VOID InterpretCapacityData	(	PDEVICE_OBJECT	Fdo,
		PREAD_CAPACITY_DATA_EX	ReadCapacityData
	)

Definition at line 2640 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    ULONG cylinderSize;
    ULONG bytesPerSector;
    LARGE_INTEGER lastSector;
    LARGE_INTEGER largeInt;
 
    bytesPerSector = ClasspCalculateLogicalSectorSize(Fdo, ReadCapacityData->BytesPerBlock);
 
    fdoExt->DiskGeometry.BytesPerSector = bytesPerSector;
    WHICH_BIT(fdoExt->DiskGeometry.BytesPerSector, fdoExt->SectorShift);
 
    /*
     *  LogicalBlockAddress is the last sector of the logical drive, in big-endian.
     *  It tells us the size of the drive (#sectors is lastSector+1).
     */
 
    largeInt = ReadCapacityData->LogicalBlockAddress;
    REVERSE_BYTES_QUAD(&lastSector, &largeInt);
 
    if (fdoExt->DMActive){
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT,  "ClassReadDriveCapacity: reducing number of sectors by %d\n", fdoExt->DMSkew));
        lastSector.QuadPart -= fdoExt->DMSkew;
    }
 
    /*
     *  Check to see if we have a geometry we should be using already.
     *  If not, we set part of the disk geometry to garbage values that will be filled in by the caller (e.g. disk.sys).
     *
     *  So the first call to ClassReadDriveCapacity always sets a meaningless geometry.
     *  TracksPerCylinder and SectorsPerTrack are kind of meaningless anyway wrt I/O,
     *  because I/O is always targeted to a logical sector number.
     *  All that really matters is BytesPerSector and the number of sectors.
     */
    cylinderSize = fdoExt->DiskGeometry.TracksPerCylinder * fdoExt->DiskGeometry.SectorsPerTrack;
    if (cylinderSize == 0){
        fdoExt->DiskGeometry.TracksPerCylinder = 0xff;
        fdoExt->DiskGeometry.SectorsPerTrack = 0x3f;
        cylinderSize = fdoExt->DiskGeometry.TracksPerCylinder * fdoExt->DiskGeometry.SectorsPerTrack;
    }
 
    /*
     *  Calculate number of cylinders.
     *  If there are zero cylinders, then the device lied AND it's
     *  smaller than 0xff*0x3f (about 16k sectors, usually 8 meg)
     *  this can fit into a single LONGLONG, so create another usable
     *  geometry, even if it's unusual looking.
     *  This allows small, non-standard devices, such as Sony's Memory Stick, to show up as having a partition.
     */
    fdoExt->DiskGeometry.Cylinders.QuadPart = (LONGLONG)((lastSector.QuadPart + 1)/cylinderSize);
    if (fdoExt->DiskGeometry.Cylinders.QuadPart == (LONGLONG)0) {
        fdoExt->DiskGeometry.SectorsPerTrack    = 1;
        fdoExt->DiskGeometry.TracksPerCylinder  = 1;
        fdoExt->DiskGeometry.Cylinders.QuadPart = lastSector.QuadPart + 1;
    }
 
    /*
     *  Calculate media capacity in bytes.
     *  For this purpose we treat the entire LUN as is if it is one partition.  Disk will deal with actual partitioning.
     */
    fdoExt->CommonExtension.PartitionLength.QuadPart =
        ((LONGLONG)(lastSector.QuadPart + 1)) << fdoExt->SectorShift;
 
    /*
     *  Is this removable or fixed media
     */
    if (TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)){
        fdoExt->DiskGeometry.MediaType = RemovableMedia;
    }
    else {
        fdoExt->DiskGeometry.MediaType = FixedMedia;
    }
 
}

Referenced by ClassReadDriveCapacity().

◆ InterpretReadCapacity16Data()

NTSTATUS InterpretReadCapacity16Data	(	_Inout_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_In_ PREAD_CAPACITY16_DATA	ReadCapacity16Data
	)

Definition at line 1517 of file utils.c.

{
    NTSTATUS status = STATUS_SUCCESS;
    USHORT   lowestAlignedBlock;
    USHORT   logicalBlocksPerPhysicalBlock;
    PCLASS_READ_CAPACITY16_DATA cachedData = &(FdoExtension->FunctionSupportInfo->ReadCapacity16Data);
 
    // use Logical Sector Size from DiskGeometry to avoid duplicated calculation.
    FdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector = ClasspCalculateLogicalSectorSize(FdoExtension->DeviceObject, ReadCapacity16Data->BytesPerBlock);
 
    // FdoExtension->DiskGeometry.BytesPerSector might be 0 for class drivers that don't get READ CAPACITY info yet.
    NT_ASSERT( (FdoExtension->DiskGeometry.BytesPerSector == 0) ||
               (FdoExtension->DiskGeometry.BytesPerSector == FdoExtension->FunctionSupportInfo->ReadCapacity16Data.BytesPerLogicalSector) );
 
    logicalBlocksPerPhysicalBlock = 1 << ReadCapacity16Data->LogicalPerPhysicalExponent;
    lowestAlignedBlock = (ReadCapacity16Data->LowestAlignedBlock_MSB << 8) | ReadCapacity16Data->LowestAlignedBlock_LSB;
 
    if (lowestAlignedBlock > logicalBlocksPerPhysicalBlock) {
        // we get garbage data
        status = STATUS_UNSUCCESSFUL;
    } else {
        // value of lowestAlignedBlock (from T10 spec) needs to be converted.
        lowestAlignedBlock = (logicalBlocksPerPhysicalBlock - lowestAlignedBlock) % logicalBlocksPerPhysicalBlock;
    }
 
    if (NT_SUCCESS(status)) {
        // fill output buffer
        cachedData->BytesPerPhysicalSector = cachedData->BytesPerLogicalSector * logicalBlocksPerPhysicalBlock;
        cachedData->BytesOffsetForSectorAlignment = cachedData->BytesPerLogicalSector * lowestAlignedBlock;
 
        //
        // Fill in the Logical Block Provisioning info.  Note that we do not
        // use these fields; we use the Provisioning Type and LBPRZ fields from
        // the Logical Block Provisioning VPD page (0xB2).
        //
        cachedData->LBProvisioningEnabled = ReadCapacity16Data->LBPME;
        cachedData->LBProvisioningReadZeros = ReadCapacity16Data->LBPRZ;
 
        TracePrint((TRACE_LEVEL_INFORMATION,
                    TRACE_FLAG_INIT,
                    "InterpretReadCapacity16Data: Device\'s LBP enabled = %d\n",
                    cachedData->LBProvisioningEnabled));
    }
 
    return status;
}

Referenced by ClassReadCapacity16().

◆ InterpretSenseInfoWithoutHistory()

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
	)

Definition at line 12844 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    LONGLONG tmpRetry = 0;
    BOOLEAN retry = FALSE;
 
    if (fdoData->InterpretSenseInfo != NULL)
    {
        SCSI_REQUEST_BLOCK tempSrb = {0};
        PSCSI_REQUEST_BLOCK srbPtr = Srb;
 
        // SAL annotations and ClassInitializeEx() both validate this
        NT_ASSERT(fdoData->InterpretSenseInfo->Interpret != NULL);
 
        //
        // If class driver does not support extended SRB and this is
        // an extended SRB, convert to legacy SRB and pass to class
        // driver.
        //
        if ((Srb->Function == SRB_FUNCTION_STORAGE_REQUEST_BLOCK) &&
            ((fdoExtension->CommonExtension.DriverExtension->SrbSupport &
              CLASS_SRB_STORAGE_REQUEST_BLOCK) == 0)) {
            ClasspConvertToScsiRequestBlock(&tempSrb, (PSTORAGE_REQUEST_BLOCK)Srb);
            srbPtr = &tempSrb;
        }
 
        retry = fdoData->InterpretSenseInfo->Interpret(Fdo,
                                                       OriginalRequest,
                                                       srbPtr,
                                                       MajorFunctionCode,
                                                       IoDeviceCode,
                                                       PreviousRetryCount,
                                                       NULL,
                                                       Status,
                                                       &tmpRetry);
    }
    else
    {
        ULONG seconds = 0;
 
        retry = ClassInterpretSenseInfo(Fdo,
                                        Srb,
                                        MajorFunctionCode,
                                        IoDeviceCode,
                                        PreviousRetryCount,
                                        Status,
                                        &seconds);
        tmpRetry = ((LONGLONG)seconds) * 1000 * 1000 * 10;
    }
 
 
    if (RetryIn100nsUnits != NULL)
    {
        *RetryIn100nsUnits = tmpRetry;
    }
    return retry;
}

Referenced by ClassIoComplete(), ClassIoCompleteAssociated(), ClasspInitializeGesn(), ClasspMediaChangeDetectionCompletion(), ClasspPowerDownCompletion(), ClasspPowerUpCompletion(), and ClassSendSrbSynchronous().

◆ InterpretTransferPacketError()

BOOLEAN InterpretTransferPacketError ( PTRANSFER_PACKET Pkt )

Definition at line 40 of file retry.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    ULONG timesAlreadyRetried;
    BOOLEAN shouldRetry = FALSE;
    PCDB pCdb = ClasspTransferPacketGetCdb(Pkt);
 
    /*
     *  Interpret the error using the returned sense info first.
     */
    Pkt->RetryIn100nsUnits = 0;
 
 
    /*
     *  Pre-calculate the number of times the IO has already been
     *  retried, so that all InterpretSenseInfo routines get the right value.
     */
    if (ClasspTransferPacketGetNumberOfRetriesDone(Pkt, pCdb, &timesAlreadyRetried) == FALSE)
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "Unhandled SRB Function %xh in error path for packet %p (did miniport change Srb.Cdb.OperationCode ?)", (ULONG)pCdb->CDB10.OperationCode, Pkt));
    }
 
    if (fdoData->InterpretSenseInfo != NULL) {
 
        SCSI_REQUEST_BLOCK tempSrb = { 0 };
        PSCSI_REQUEST_BLOCK srbPtr = (PSCSI_REQUEST_BLOCK)Pkt->Srb;
 
        // SAL annotation and ClassInitializeEx() both validate this
        NT_ASSERT(fdoData->InterpretSenseInfo->Interpret != NULL);
 
        //
        // If class driver does not support extended SRB and this is
        // an extended SRB, convert to legacy SRB and pass to class
        // driver.
        //
        if ((Pkt->Srb->Function == SRB_FUNCTION_STORAGE_REQUEST_BLOCK) &&
            ((fdoExtension->CommonExtension.DriverExtension->SrbSupport &
            CLASS_SRB_STORAGE_REQUEST_BLOCK) == 0)) {
            ClasspConvertToScsiRequestBlock(&tempSrb, (PSTORAGE_REQUEST_BLOCK)Pkt->Srb);
            srbPtr = &tempSrb;
        }
 
        shouldRetry = fdoData->InterpretSenseInfo->Interpret(Pkt->Fdo,
                                                             Pkt->OriginalIrp,
                                                             srbPtr,
                                                             IRP_MJ_SCSI,
                                                             0,
                                                             timesAlreadyRetried,
                                                             Pkt->RetryHistory,
                                                             &Pkt->Irp->IoStatus.Status,
                                                             &Pkt->RetryIn100nsUnits);
 
 
    } else {
 
        //
        // In this case, fdoData->InterpretSenseInfo == NULL so we must do our
        // own error code and sense info processing.
        //
 
        PVOID senseInfoBuffer = ClasspTransferPacketGetSenseInfoBuffer(Pkt);
        UCHAR senseInfoBufferLength = ClasspTransferPacketGetSenseInfoBufferLength(Pkt);
        BOOLEAN validSense = FALSE;
        UCHAR senseKey = 0;
        UCHAR additionalSenseCode = 0;
        UCHAR additionalSenseQual = 0;
 
        NT_ASSERT(senseInfoBuffer);
 
        validSense = ScsiGetSenseKeyAndCodes(senseInfoBuffer,
                                             senseInfoBufferLength,
                                             SCSI_SENSE_OPTIONS_FIXED_FORMAT_IF_UNKNOWN_FORMAT_INDICATED,
                                             &senseKey,
                                             &additionalSenseCode,
                                             &additionalSenseQual);
 
        if (pCdb->MEDIA_REMOVAL.OperationCode == SCSIOP_MEDIUM_REMOVAL) {
 
            ULONG retryIntervalSeconds = 0;
            /*
             *  This is an Ejection Control SRB.  Interpret its sense info specially.
             */
            shouldRetry = ClassInterpretSenseInfo(
                Pkt->Fdo,
                (PSCSI_REQUEST_BLOCK)Pkt->Srb,
                IRP_MJ_SCSI,
                0,
                timesAlreadyRetried,
                &Pkt->Irp->IoStatus.Status,
                &retryIntervalSeconds);
 
            if (shouldRetry) {
                /*
                 *  If the device is not ready, wait at least 2 seconds before retrying.
                 */
                BOOLEAN setRetryIntervalSeconds = FALSE;
 
                if (validSense) {
 
                    if ((Pkt->Irp->IoStatus.Status == STATUS_DEVICE_NOT_READY) &&
                        (additionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY)) {
                        setRetryIntervalSeconds = TRUE;
                    }
                }
 
                if (!setRetryIntervalSeconds && (SRB_STATUS(Pkt->Srb->SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT)) {
                    setRetryIntervalSeconds = TRUE;
                }
 
                if (setRetryIntervalSeconds) {
                    retryIntervalSeconds = MAX(retryIntervalSeconds, 2);
                }
            }
 
            if (shouldRetry)
            {
                Pkt->RetryIn100nsUnits = retryIntervalSeconds;
                Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
            }
 
        }
        else if ((pCdb->MODE_SENSE.OperationCode == SCSIOP_MODE_SENSE) ||
                 (pCdb->MODE_SENSE.OperationCode == SCSIOP_MODE_SENSE10)) {
 
            ULONG retryIntervalSeconds = 0;
            /*
             *  This is an Mode Sense SRB.  Interpret its sense info specially.
             */
            shouldRetry = ClassInterpretSenseInfo(
                Pkt->Fdo,
                (PSCSI_REQUEST_BLOCK)Pkt->Srb,
                IRP_MJ_SCSI,
                0,
                timesAlreadyRetried,
                &Pkt->Irp->IoStatus.Status,
                &retryIntervalSeconds);
            if (shouldRetry) {
                /*
                 *  If the device is not ready, wait at least 2 seconds before retrying.
                 */
                BOOLEAN setRetryIntervalSeconds = FALSE;
 
                if (validSense) {
                    if ((Pkt->Irp->IoStatus.Status == STATUS_DEVICE_NOT_READY) &&
                        (additionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY)) {
                        setRetryIntervalSeconds = TRUE;
                    }
                }
 
                if (!setRetryIntervalSeconds && (SRB_STATUS(Pkt->Srb->SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT)) {
                    setRetryIntervalSeconds = TRUE;
                }
 
                if (setRetryIntervalSeconds) {
                    retryIntervalSeconds = MAX(retryIntervalSeconds, 2);
                }
            }
 
            /*
             *  Some special cases for mode sense.
             */
            if (Pkt->Irp->IoStatus.Status == STATUS_VERIFY_REQUIRED) {
                shouldRetry = TRUE;
            }
            else if (SRB_STATUS(Pkt->Srb->SrbStatus) == SRB_STATUS_DATA_OVERRUN) {
                /*
                 *  This is a HACK.
                 *  Atapi returns SRB_STATUS_DATA_OVERRUN when it really means
                 *  underrun (i.e. success, and the buffer is longer than needed).
                 *  So treat this as a success.
                 *  When the caller of this function sees that the status was changed to success,
                 *  it will add the transferred length to the original irp.
                 */
                Pkt->Irp->IoStatus.Status = STATUS_SUCCESS;
                shouldRetry = FALSE;
            }
 
            if (shouldRetry)
            {
                Pkt->RetryIn100nsUnits = retryIntervalSeconds;
                Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
            }
 
        }
        else if ((pCdb->CDB10.OperationCode == SCSIOP_READ_CAPACITY) ||
                 (pCdb->CDB16.OperationCode == SCSIOP_READ_CAPACITY16)) {
 
            ULONG retryIntervalSeconds = 0;
 
            /*
             *  This is a Drive Capacity SRB.  Interpret its sense info specially.
             */
            shouldRetry = ClassInterpretSenseInfo(
                Pkt->Fdo,
                (PSCSI_REQUEST_BLOCK)Pkt->Srb,
                IRP_MJ_SCSI,
                0,
                timesAlreadyRetried,
                &Pkt->Irp->IoStatus.Status,
                &retryIntervalSeconds);
            if (Pkt->Irp->IoStatus.Status == STATUS_VERIFY_REQUIRED) {
                shouldRetry = TRUE;
            }
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
            else if (ClasspSrbTimeOutStatus(Pkt->Srb)) {
 
                Pkt->TimedOut = TRUE;
 
                if (shouldRetry) {
                    //
                    // For requests that have timed-out we may only perform a limited
                    // number of retries.  This is typically less than the general
                    // number of retries allowed.
                    //
                    if (Pkt->NumIoTimeoutRetries == 0) {
                        shouldRetry = FALSE;
                    } else {
                        Pkt->NumIoTimeoutRetries--;
                        //
                        // We expect to be able to retry if there are some general retries remaining.
                        //
                    }
                }
            }
#endif
 
            if (shouldRetry)
            {
                Pkt->RetryIn100nsUnits = retryIntervalSeconds;
                Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
            }
 
        }
        else if (IS_SCSIOP_READWRITE(pCdb->CDB10.OperationCode)) {
 
            ULONG retryIntervalSeconds = 0;
            /*
             *  This is a Read/Write Data packet.
             */
            PIO_STACK_LOCATION origCurrentSp = IoGetCurrentIrpStackLocation(Pkt->OriginalIrp);
 
            shouldRetry = ClassInterpretSenseInfo(Pkt->Fdo,
                                                  (PSCSI_REQUEST_BLOCK)Pkt->Srb,
                                                  origCurrentSp->MajorFunction,
                                                  0,
                                                  timesAlreadyRetried,
                                                  &Pkt->Irp->IoStatus.Status,
                                                  &retryIntervalSeconds);
 
            /*
             *  Deal with some special cases.
             */
            if (Pkt->Irp->IoStatus.Status == STATUS_INSUFFICIENT_RESOURCES) {
                /*
                 *  We are in extreme low-memory stress.
                 *  We will retry in smaller chunks.
                 */
                shouldRetry = TRUE;
            }
            else if (TEST_FLAG(origCurrentSp->Flags, SL_OVERRIDE_VERIFY_VOLUME) &&
                     (Pkt->Irp->IoStatus.Status == STATUS_VERIFY_REQUIRED)) {
                /*
                 *  We are still verifying a (possibly) reloaded disk/cdrom.
                 *  So retry the request.
                 */
                Pkt->Irp->IoStatus.Status = STATUS_IO_DEVICE_ERROR;
                shouldRetry = TRUE;
 
            }
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
            else if (ClasspSrbTimeOutStatus(Pkt->Srb)) {
 
                Pkt->TimedOut = TRUE;
 
                if (shouldRetry) {
                    //
                    // For requests that have timed-out we may only perform a limited
                    // number of retries.  This is typically less than the general
                    // number of retries allowed.
                    //
                    if (Pkt->NumIoTimeoutRetries == 0) {
                        shouldRetry = FALSE;
                    } else {
                        Pkt->NumIoTimeoutRetries--;
                        //
                        // We expect to be able to retry if there are some general retries remaining.
                        //
                    }
                }
            }
#endif
 
            if (shouldRetry)
            {
                Pkt->RetryIn100nsUnits = retryIntervalSeconds;
                Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
            }
 
        } else if (ClasspIsOffloadDataTransferCommand(pCdb)) {
 
            ULONG retryIntervalSeconds = 0;
 
            Pkt->TransferCount = 0;
 
            shouldRetry = ClassInterpretSenseInfo(
                Pkt->Fdo,
                (PSCSI_REQUEST_BLOCK)Pkt->Srb,
                IRP_MJ_SCSI,
                0,
                timesAlreadyRetried,
                &Pkt->Irp->IoStatus.Status,
                &retryIntervalSeconds);
 
            if (shouldRetry) {
 
                Pkt->RetryIn100nsUnits = retryIntervalSeconds;
                Pkt->RetryIn100nsUnits *= 1000 * 1000 * 10;
 
            } else {
 
                if (ClasspIsTokenOperation(pCdb)) {
 
                    BOOLEAN isInformationValid = FALSE;
                    ULONGLONG information = 0;
 
                    if (validSense) {
 
                        //
                        // If this is a data underrun condition (i.e. target truncated the offload data transfer),
                        // the SenseData's Information field may have the TransferCount.
                        //
                        if ((senseKey == SCSI_SENSE_COPY_ABORTED || senseKey == SCSI_SENSE_ABORTED_COMMAND) &&
                            (additionalSenseCode == SCSI_ADSENSE_COPY_TARGET_DEVICE_ERROR && additionalSenseQual == SCSI_SENSEQ_DATA_UNDERRUN)) {
 
                            //
                            // Sense data in Descriptor format
                            //
                            if (IsDescriptorSenseDataFormat(senseInfoBuffer)) {
 
                                PVOID startBuffer = NULL;
                                UCHAR startBufferLength = 0;
 
 
                                if (ScsiGetSenseDescriptor(senseInfoBuffer,
                                                            SrbGetSenseInfoBufferLength(Pkt->Srb),
                                                            &startBuffer,
                                                            &startBufferLength)) {
                                    UCHAR outType;
                                    PVOID outBuffer = NULL;
                                    UCHAR outBufferLength = 0;
 
                                    UCHAR typeList[1] = { SCSI_SENSE_DESCRIPTOR_TYPE_INFORMATION };
 
                                    if (ScsiGetNextSenseDescriptorByType(startBuffer,
                                        startBufferLength,
                                        typeList,
                                        ARRAYSIZE(typeList),
                                        &outType,
                                        &outBuffer,
                                        &outBufferLength)) {
 
                                        if (outType == SCSI_SENSE_DESCRIPTOR_TYPE_INFORMATION) {
 
                                            if (ScsiValidateInformationSenseDescriptor(outBuffer, outBufferLength)) {
                                                REVERSE_BYTES_QUAD(&information, &(((PSCSI_SENSE_DESCRIPTOR_INFORMATION)outBuffer)->Information));
                                                isInformationValid = TRUE;
                                            }
 
                                        } else {
 
                                            //
                                            // ScsiGetNextDescriptorByType should only return a type that is specified by us.
                                            //
                                            NT_ASSERT(FALSE);
                                        }
                                    }
                                }
                            } else {
 
                                //
                                // Sense data in Fixed format
                                //
                                REVERSE_BYTES(&information, &(((PFIXED_SENSE_DATA)senseInfoBuffer)->Information));
                                isInformationValid = TRUE;
                            }
 
                            if (isInformationValid) {
                                Pkt->TransferCount = information;
                            }
                        }
                    }
                }
            }
 
        }
        else {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "Unhandled SRB Function %xh in error path for packet %p (did miniport change Srb.Cdb.OperationCode ?)", (ULONG)pCdb->CDB10.OperationCode, Pkt));
        }
    }
 
    return shouldRetry;
}

Referenced by TransferPktComplete().

◆ PORT_ALLOCATED_SENSE_EX()

FORCEINLINE BOOLEAN PORT_ALLOCATED_SENSE_EX	(	_In_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_In_ PSTORAGE_REQUEST_BLOCK_HEADER	Srb
	)

Definition at line 2547 of file classp.h.

{
    return ((BOOLEAN)((TEST_FLAG(SrbGetSrbFlags(Srb), SRB_FLAGS_PORT_DRIVER_ALLOCSENSE) &&
             TEST_FLAG(SrbGetSrbFlags(Srb), SRB_FLAGS_FREE_SENSE_BUFFER)) &&
            (SrbGetSenseInfoBuffer(Srb) != FdoExtension->SenseData))
            );
}

Referenced by _Success_(), ClasspMediaChangeDetectionCompletion(), ClassSendSrbSynchronous(), TransferPacketRetryTimerDpc(), and TransferPktComplete().

◆ RetryRequest()

VOID RetryRequest	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PSCSI_REQUEST_BLOCK	Srb,
		BOOLEAN	Associated,
		LONGLONG	TimeDelta100ns
	)

Definition at line 359 of file obsolete.c.

{
    PIO_STACK_LOCATION currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
    PIO_STACK_LOCATION nextIrpStack = IoGetNextIrpStackLocation(Irp);
    ULONG transferByteCount;
    ULONG dataTransferLength;
    PSTORAGE_REQUEST_BLOCK_HEADER srbHeader = (PSTORAGE_REQUEST_BLOCK_HEADER)Srb;
 
    // This function is obsolete but is still used by some of our class drivers.
    // TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "RetryRequest is OBSOLETE !"));
 
    //
    // Determine the transfer count of the request.  If this is a read or a
    // write then the transfer count is in the Irp stack.  Otherwise assume
    // the MDL contains the correct length.  If there is no MDL then the
    // transfer length must be zero.
    //
 
    dataTransferLength = SrbGetDataTransferLength(srbHeader);
    if (currentIrpStack->MajorFunction == IRP_MJ_READ ||
        currentIrpStack->MajorFunction == IRP_MJ_WRITE) {
 
        _Analysis_assume_(currentIrpStack->Parameters.Read.Length <= dataTransferLength);
        transferByteCount = currentIrpStack->Parameters.Read.Length;
 
    } else if (Irp->MdlAddress != NULL) {
 
        //
        // Note this assumes that only read and write requests are spilt and
        // other request do not need to be.  If the data buffer address in
        // the MDL and the SRB don't match then transfer length is most
        // likely incorrect.
        //
 
        NT_ASSERT(SrbGetDataBuffer(srbHeader) == MmGetMdlVirtualAddress(Irp->MdlAddress));
    _Analysis_assume_(Irp->MdlAddress->ByteCount <= dataTransferLength);
        transferByteCount = Irp->MdlAddress->ByteCount;
 
    } else {
 
        transferByteCount = 0;
    }
 
    //
    // this is a safety net.  this should not normally be hit, since we are
    // not guaranteed to be an fdoExtension
    //
 
    NT_ASSERT(!TEST_FLAG(SrbGetSrbFlags(srbHeader), SRB_FLAGS_FREE_SENSE_BUFFER));
 
    //
    // Reset byte count of transfer in SRB Extension.
    //
 
    SrbSetDataTransferLength(srbHeader, transferByteCount);
 
    //
    // Zero SRB statuses.
    //
 
    srbHeader->SrbStatus = 0;
    SrbSetScsiStatus(srbHeader, 0);
 
    //
    // If this is the last retry, then disable all the special flags.
    //
 
    if ( 0 == (ULONG)(ULONG_PTR)currentIrpStack->Parameters.Others.Argument4 ) {
        //
        // Set the no disconnect flag, disable synchronous data transfers and
        // disable tagged queuing. This fixes some errors.
        // NOTE: Cannot clear these flags, just add to them
        //
 
        SrbSetSrbFlags(srbHeader,
                          SRB_FLAGS_DISABLE_DISCONNECT | SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
        SrbClearSrbFlags(srbHeader, SRB_FLAGS_QUEUE_ACTION_ENABLE);
 
        SrbSetQueueTag(srbHeader, SP_UNTAGGED);
    }
 
 
    //
    // Set up major SCSI function.
    //
 
    nextIrpStack->MajorFunction = IRP_MJ_SCSI;
 
    //
    // Save SRB address in next stack for port driver.
    //
 
    nextIrpStack->Parameters.Scsi.Srb = Srb;
 
    if (Associated){
        IoSetCompletionRoutine(Irp, ClassIoCompleteAssociated, Srb, TRUE, TRUE, TRUE);
    }
    else {
        IoSetCompletionRoutine(Irp, ClassIoComplete, Srb, TRUE, TRUE, TRUE);
    }
 
    ClassRetryRequest(DeviceObject, Irp, TimeDelta100ns);
    return;
} // end RetryRequest()

Referenced by ClassIoComplete(), ClassIoCompleteAssociated(), and ClassReadDriveCapacity().

◆ RetryTransferPacket()

BOOLEAN RetryTransferPacket ( PTRANSFER_PACKET Pkt )

Definition at line 453 of file retry.c.

{
    BOOLEAN packetDone;
    BOOLEAN scaleDown = FALSE;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    PCDB pCdb = SrbGetCdb(Pkt->Srb);
 
#if !defined(__REACTOS__) && NTDDI_VERSION >= NTDDI_WINBLUE
    if(ClasspIsThinProvisioningError((PSCSI_REQUEST_BLOCK)Pkt->Srb) &&
        (pCdb != NULL) && IS_SCSIOP_READWRITE(pCdb->CDB10.OperationCode)) {
 
        if(Pkt->NumThinProvisioningRetries >= NUM_THIN_PROVISIONING_RETRIES) {
            //We've already retried this the maximum times.  Bail out.
            return TRUE;
        }
        Pkt->NumThinProvisioningRetries++;
    }
    else {
        NT_ASSERT(Pkt->NumRetries > 0 || Pkt->RetryHistory);
        Pkt->NumRetries--;
    }
#else
    NT_ASSERT(Pkt->NumRetries > 0 || Pkt->RetryHistory);
    Pkt->NumRetries--;
#endif
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "retrying failed transfer (pkt=%ph, op=%s)", Pkt, DBGGETSCSIOPSTR(Pkt->Srb)));
 
    if (!fdoData->DisableThrottling) {
 
        //
        // If this is the last retry, then turn off disconnect, sync transfer,
        // and tagged queuing.  On all other retries, leave the original settings.
        // Do not apply this for thin provisioning soft threshold errors, since
        // they should succeed as soon as they're retried on the right IT nexus.
        //
        if ((Pkt->NumRetries == 0) && !ClasspIsThinProvisioningError((PSCSI_REQUEST_BLOCK)Pkt->Srb)) {
            scaleDown = TRUE;
        }
 
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
        //
        // If this request previously timed-out and there are no more retries left
        // for timed-out requests, then we should also apply the scale down.
        //
        if (Pkt->TimedOut && Pkt->NumIoTimeoutRetries == 0) {
            scaleDown = TRUE;
        }
#endif
    }
 
 
    if (scaleDown) {
        /*
         *  Tone down performance on the retry.
         *  This increases the chance for success on the retry.
         *  We've seen instances of drives that fail consistently but then start working
         *  once this scale-down is applied.
         */
        SrbSetSrbFlags(Pkt->Srb, SRB_FLAGS_DISABLE_DISCONNECT);
        SrbSetSrbFlags(Pkt->Srb, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
        SrbClearSrbFlags(Pkt->Srb, SRB_FLAGS_QUEUE_ACTION_ENABLE);
        SrbSetRequestTag(Pkt->Srb, SP_UNTAGGED);
    }
 
    if (Pkt->Irp->IoStatus.Status == STATUS_INSUFFICIENT_RESOURCES) {
 
        UCHAR cdbOpcode = 0;
        BOOLEAN isReadWrite = FALSE;
 
        if (pCdb) {
            cdbOpcode = pCdb->CDB10.OperationCode;
            isReadWrite = IS_SCSIOP_READWRITE(cdbOpcode);
        }
 
        if ((Pkt->DriverUsesStartIO) &&
            ( (cdbOpcode == SCSIOP_WRITE6 ) ||
              (cdbOpcode == SCSIOP_WRITE  ) ||
              (cdbOpcode == SCSIOP_WRITE12) ||
              (cdbOpcode == SCSIOP_WRITE16) )) {
 
            /* don't retry writes in super-low-memory conditions if the
             * driver must serialize against StartIO.  This is because
             * some write methods used in such drivers cannot accept
             * random-sized writes. (i.e CD-RW in packet writing mode)
             * Reads, however, are always safe to split up.
             */
            SET_FLAG(fdoData->TrackingFlags, TRACKING_FORWARD_PROGRESS_PATH1);
            packetDone = TRUE;
        }
        else if (Pkt->InLowMemRetry || !isReadWrite){
            /*
             *  This should never happen under normal circumstances.
             *  The memory manager guarantees that at least four pages will
             *  be available to allow forward progress in the port driver.
             *  So a one-page transfer should never fail with insufficient resources.
             *
             *  However, it is possible to get in here with virtual storage
             *  or thin provisioned storage for example.
             *  A single sector write can trigger an allocation request and
             *  presently a forward progress guarantee is not provided.
             *  VHD also may have some limitations in forward progress guarantee.
             *  And USB too might also fall into this category.
             */
            SET_FLAG(fdoData->TrackingFlags, TRACKING_FORWARD_PROGRESS_PATH2);
            packetDone = TRUE;
        }
        else {
            /*
             *  We are in low-memory stress.
             *  Start the low-memory retry state machine, which tries to
             *  resend the packet in little one-page chunks.
             */
            SET_FLAG(fdoData->TrackingFlags, TRACKING_FORWARD_PROGRESS_PATH3);
            InitLowMemRetry(Pkt,
                            Pkt->BufPtrCopy,
                            Pkt->BufLenCopy,
                            Pkt->TargetLocationCopy);
            StepLowMemRetry(Pkt);
            packetDone = FALSE;
        }
    }
    else {
        /*
         *  Retry the packet by simply resending it after a delay.
         *  Put the packet back in the pending queue and
         *  schedule a timer to retry the transfer.
         *
         *  Do not call SetupReadWriteTransferPacket again because:
         *  (1)  The minidriver may have set some bits
         *       in the SRB that it needs again and
         *  (2)  doing so would reset numRetries.
         *
         *  BECAUSE we do not call SetupReadWriteTransferPacket again,
         *  we have to reset a couple fields in the SRB that
         *  some miniports overwrite when they fail an SRB.
         */
 
        SrbSetDataBuffer(Pkt->Srb, Pkt->BufPtrCopy);
        SrbSetDataTransferLength(Pkt->Srb, Pkt->BufLenCopy);
 
        TransferPacketQueueRetryDpc(Pkt);
 
        packetDone = FALSE;
    }
 
    return packetDone;
}

Referenced by TransferPktComplete().

◆ ServiceTransferRequest()

NTSTATUS ServiceTransferRequest	(	PDEVICE_OBJECT	Fdo,
		PIRP	Irp,
		BOOLEAN	PostToDpc
	)

Definition at line 3341 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
    PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExtension->PartitionZeroExtension->AdapterDescriptor;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    IO_PAGING_PRIORITY priority = (TEST_FLAG(Irp->Flags, IRP_PAGING_IO)) ? IoGetPagingIoPriority(Irp) : IoPagingPriorityInvalid;
    BOOLEAN deferClientIrp = FALSE;
    BOOLEAN driverUsesStartIO = (commonExtension->DriverExtension->InitData.ClassStartIo != NULL);
    KIRQL oldIrql;
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    PIO_STACK_LOCATION  currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
 
    /*
     * Initialize IRP status for the master IRP to
     * - STATUS_FT_READ_FROM_COPY if it's a copy-specific read
     * - STATUS_SUCCESS otherwise.
     *
     * This is required. When Classpnp determines the status for the master IRP
     * when completing child IRPs, the call to IoSetMasterIrpStatus
     * will be functioning properly (See TransferPktComplete function)
     *
     * Note:
     * If the IRP is a copy-specific read, File System already initialized the IRP status
     * to be STATUS_FT_READ_FROM_COPY. However, this can be changed when the IRP arrives
     * at Classpnp. It's possible that other drivers in the stack may initialize the
     * IRP status field to other values before forwarding the IRP down the stack.
     * To be defensive, we initialize the IRP status to either STATUS_FT_READ_FROM_COPY
     * if it's a copy-specific read, or STATUS_SUCCESS otherwise.
     */
    if (currentIrpStack->MajorFunction == IRP_MJ_READ &&
        TEST_FLAG(currentIrpStack->Flags, SL_KEY_SPECIFIED) &&
        IsKeyReadCopyNumber(currentIrpStack->Parameters.Read.Key)) {
        Irp->IoStatus.Status = STATUS_FT_READ_FROM_COPY;
    } else {
        Irp->IoStatus.Status = STATUS_SUCCESS;
    }
 
    //
    // If this is a high priority request, hold off all other Io requests
    //
 
    if (priority == IoPagingPriorityHigh)
    {
        KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
 
        if (fdoData->NumHighPriorityPagingIo == 0)
        {
            //
            // Entering throttle mode
            //
 
            KeQuerySystemTime(&fdoData->ThrottleStartTime);
        }
 
        fdoData->NumHighPriorityPagingIo++;
        fdoData->MaxInterleavedNormalIo += ClassMaxInterleavePerCriticalIo;
 
        KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
    }
    else
    {
        if (fdoData->NumHighPriorityPagingIo != 0)
        {
            //
            // This request wasn't flagged as critical and atleast one critical request
            // is currently outstanding. Queue this request until all of those are done
            // but only if the interleave threshold has been reached
            //
 
            KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
 
            if (fdoData->NumHighPriorityPagingIo != 0)
            {
                if (fdoData->MaxInterleavedNormalIo == 0)
                {
                    deferClientIrp = TRUE;
                }
                else
                {
                    fdoData->MaxInterleavedNormalIo--;
                }
            }
 
            KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
        }
    }
 
    if (!deferClientIrp)
    {
        PIO_STACK_LOCATION currentSp = IoGetCurrentIrpStackLocation(Irp);
        ULONG entireXferLen = currentSp->Parameters.Read.Length;
        PUCHAR bufPtr = MmGetMdlVirtualAddress(Irp->MdlAddress);
        LARGE_INTEGER targetLocation = currentSp->Parameters.Read.ByteOffset;
        PTRANSFER_PACKET pkt;
        SINGLE_LIST_ENTRY pktList;
        PSINGLE_LIST_ENTRY slistEntry;
        ULONG hwMaxXferLen;
        ULONG numPackets;
        ULONG i;
 
 
        /*
         *  We precomputed fdoData->HwMaxXferLen using (MaximumPhysicalPages-1).
         *  If the buffer is page-aligned, that's one less page crossing so we can add the page back in.
         *  Note: adapters that return MaximumPhysicalPages=0x10 depend on this to
         *           transfer aligned 64K requests in one piece.
         *  Also note:  make sure adding PAGE_SIZE back in doesn't wrap to zero.
         */
        if (((ULONG_PTR)bufPtr & (PAGE_SIZE-1)) || (fdoData->HwMaxXferLen > 0xffffffff-PAGE_SIZE)){
            hwMaxXferLen = fdoData->HwMaxXferLen;
        }
        else {
            NT_ASSERT((PAGE_SIZE%fdoExt->DiskGeometry.BytesPerSector) == 0);
            hwMaxXferLen = min(fdoData->HwMaxXferLen+PAGE_SIZE, adapterDesc->MaximumTransferLength);
        }
 
        /*
         *  Compute the number of hw xfers we'll have to do.
         *  Calculate this without allowing for an overflow condition.
         */
        NT_ASSERT(hwMaxXferLen >= PAGE_SIZE);
        numPackets = entireXferLen/hwMaxXferLen;
        if (entireXferLen % hwMaxXferLen){
            numPackets++;
        }
 
        /*
         *  Use our 'simple' slist functions since we don't need interlocked.
         */
        SimpleInitSlistHdr(&pktList);
 
        if (driverUsesStartIO) {
            /*
             * special case: StartIO-based writing must stay serialized, so just
             * re-use one packet.
             */
            pkt = DequeueFreeTransferPacket(Fdo, TRUE);
            if (pkt) {
                SimplePushSlist(&pktList, (PSINGLE_LIST_ENTRY)&pkt->SlistEntry);
                i = 1;
            } else {
                i = 0;
            }
        } else {
            /*
             *  First get all the TRANSFER_PACKETs that we'll need at once.
             */
            for (i = 0; i < numPackets; i++){
                pkt = DequeueFreeTransferPacket(Fdo, TRUE);
                if (pkt){
                    SimplePushSlist(&pktList, (PSINGLE_LIST_ENTRY)&pkt->SlistEntry);
                }
                else {
                    break;
                }
            }
        }
 
 
        if ((i == numPackets) &&
            (!driverUsesStartIO)) {
            NTSTATUS pktStat;
 
            /*
             *  The IoStatus.Information field will be incremented to the
             *  transfer length as the pieces complete.
             */
            Irp->IoStatus.Information = 0;
 
            /*
             *  Store the number of transfer pieces inside the original IRP.
             *  It will be used to count down the pieces as they complete.
             */
            Irp->Tail.Overlay.DriverContext[0] = LongToPtr(numPackets);
 
            /*
             *  For the common 1-packet case, we want to allow for an optimization by BlkCache
             *  (and also potentially synchronous storage drivers) which may complete the
             *  downward request synchronously.
             *  In that synchronous completion case, we want to _not_ mark the original irp pending
             *  and thereby save on the top-level APC.
             *  It's critical to coordinate this with the completion routine so that we mark the original irp
             *  pending if-and-only-if we return STATUS_PENDING for it.
             */
            if (numPackets > 1){
                IoMarkIrpPending(Irp);
                status = STATUS_PENDING;
            }
            else {
                status = STATUS_SUCCESS;
            }
 
            /*
             *  Transmit the pieces of the transfer.
             */
            while (entireXferLen > 0){
                ULONG thisPieceLen = MIN(hwMaxXferLen, entireXferLen);
 
                /*
                 *  Set up a TRANSFER_PACKET for this piece and send it.
                 */
                slistEntry = SimplePopSlist(&pktList);
                NT_ASSERT(slistEntry);
                pkt = CONTAINING_RECORD(slistEntry, TRANSFER_PACKET, SlistEntry);
                SetupReadWriteTransferPacket(   pkt,
                                            bufPtr,
                                            thisPieceLen,
                                            targetLocation,
                                            Irp);
 
                //
                // If the IRP needs to be split, then we need to use a partial MDL.
                // This prevents problems if the same MDL is mapped multiple times.
                //
                if (numPackets > 1) {
                    pkt->UsePartialMdl = TRUE;
                }
 
                /*
                 *  When an IRP is completed, the completion routine checks to see if there
                 *  is a deferred IRP ready to sent down (assuming that there are no non-idle
                 *  requests waiting to be serviced). If such a deferred IRP is available, it
                 *  is sent down using this routine. However, if the lower driver completes
                 *  the request inline, there is a potential for multiple deferred IRPs being
                 *  sent down in the context of the same completion thread, thus exhausting
                 *  the call stack.
                 *  In order to prevent this from happening, we need to ensure that deferred
                 *  IRPs that are dequeued in the context of a request's completion routine
                 *  get posted to a DPC.
                 */
                if (PostToDpc) {
 
                    pkt->RetryIn100nsUnits = 0;
                    TransferPacketQueueRetryDpc(pkt);
                    status = STATUS_PENDING;
 
                } else {
 
                    pktStat = SubmitTransferPacket(pkt);
 
                    /*
                     *  If any of the packets completes with pending, we MUST return pending.
                     *  Also, if a packet completes with an error, return pending; this is because
                     *  in the completion routine we mark the original irp pending if the packet failed
                     *  (since we may retry, thereby switching threads).
                     */
                    if (pktStat != STATUS_SUCCESS){
                        status = STATUS_PENDING;
                    }
                }
 
                entireXferLen -= thisPieceLen;
                bufPtr += thisPieceLen;
                targetLocation.QuadPart += thisPieceLen;
            }
            NT_ASSERT(SimpleIsSlistEmpty(&pktList));
        }
        else if (i >= 1){
            /*
             *  We were unable to get all the TRANSFER_PACKETs we need,
             *  but we did get at least one.
             *  That means that we are in extreme low-memory stress.
             *  We'll try doing this transfer using a single packet.
             *  The port driver is certainly also in stress, so use one-page
             *  transfers.
             */
 
            /*
             *  Free all but one of the TRANSFER_PACKETs.
             */
            while (i-- > 1){
                slistEntry = SimplePopSlist(&pktList);
                NT_ASSERT(slistEntry);
                pkt = CONTAINING_RECORD(slistEntry, TRANSFER_PACKET, SlistEntry);
                EnqueueFreeTransferPacket(Fdo, pkt);
            }
 
            /*
             *  Get the single TRANSFER_PACKET that we'll be using.
             */
            slistEntry = SimplePopSlist(&pktList);
            NT_ASSERT(slistEntry);
            NT_ASSERT(SimpleIsSlistEmpty(&pktList));
            pkt = CONTAINING_RECORD(slistEntry, TRANSFER_PACKET, SlistEntry);
 
            if (!driverUsesStartIO) {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_RW, "Insufficient packets available in ServiceTransferRequest - entering lowMemRetry with pkt=%p.", pkt));
            }
 
            /*
             *  Set the number of transfer packets (one)
             *  inside the original irp.
             */
            Irp->IoStatus.Information = 0;
            Irp->Tail.Overlay.DriverContext[0] = LongToPtr(1);
            IoMarkIrpPending(Irp);
 
            /*
             *  Set up the TRANSFER_PACKET for a lowMem transfer and launch.
             */
            SetupReadWriteTransferPacket(  pkt,
                                        bufPtr,
                                        entireXferLen,
                                        targetLocation,
                                        Irp);
 
            InitLowMemRetry(pkt, bufPtr, entireXferLen, targetLocation);
            StepLowMemRetry(pkt);
            status = STATUS_PENDING;
        }
        else {
            /*
             *  We were unable to get ANY TRANSFER_PACKETs.
             *  Defer this client irp until some TRANSFER_PACKETs free up.
             */
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_RW, "No packets available in ServiceTransferRequest - deferring transfer (Irp=%p)...", Irp));
 
            if (priority == IoPagingPriorityHigh)
            {
                KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
 
                if (fdoData->MaxInterleavedNormalIo < ClassMaxInterleavePerCriticalIo)
                {
                    fdoData->MaxInterleavedNormalIo = 0;
                }
                else
                {
                    fdoData->MaxInterleavedNormalIo -= ClassMaxInterleavePerCriticalIo;
                }
 
                fdoData->NumHighPriorityPagingIo--;
 
                if (fdoData->NumHighPriorityPagingIo == 0)
                {
                    LARGE_INTEGER period;
 
                    //
                    // Exiting throttle mode
                    //
 
                    KeQuerySystemTime(&fdoData->ThrottleStopTime);
 
                    period.QuadPart = fdoData->ThrottleStopTime.QuadPart - fdoData->ThrottleStartTime.QuadPart;
                    fdoData->LongestThrottlePeriod.QuadPart = max(fdoData->LongestThrottlePeriod.QuadPart, period.QuadPart);
                }
 
                KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
            }
 
            deferClientIrp = TRUE;
        }
    }
    _Analysis_assume_(deferClientIrp);
    if (deferClientIrp)
    {
        IoMarkIrpPending(Irp);
        EnqueueDeferredClientIrp(Fdo, Irp);
        status = STATUS_PENDING;
    }
 
    NT_ASSERT(status != STATUS_UNSUCCESSFUL);
 
    return status;
}

Referenced by ClasspServiceIdleRequest(), ClassReadWrite(), ClassSplitRequest(), and TransferPktComplete().

◆ SetupDriveCapacityTransferPacket()

VOID SetupDriveCapacityTransferPacket	(	TRANSFER_PACKET *	Pkt,
		PVOID	ReadCapacityBuffer,
		ULONG	ReadCapacityBufferLen,
		PKEVENT	SyncEventPtr,
		PIRP	OriginalIrp,
		BOOLEAN	Use16ByteCdb
	)

Definition at line 1480 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    PCDB pCdb;
    ULONG srbLength;
    ULONG timeoutValue = fdoExt->TimeOutValue;
 
    if (fdoExt->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbLength = ((PSTORAGE_REQUEST_BLOCK) fdoData->SrbTemplate)->SrbLength;
        NT_ASSERT(((PSTORAGE_REQUEST_BLOCK) Pkt->Srb)->SrbLength >= srbLength);
    } else {
        srbLength = fdoData->SrbTemplate->Length;
    }
    RtlCopyMemory(Pkt->Srb, fdoData->SrbTemplate, srbLength); // copies _contents_ of SRB blocks
 
    SrbSetRequestAttribute(Pkt->Srb, SRB_SIMPLE_TAG_REQUEST);
    SrbSetOriginalRequest(Pkt->Srb, Pkt->Irp);
    SrbSetSenseInfoBuffer(Pkt->Srb, &Pkt->SrbErrorSenseData);
    SrbSetSenseInfoBufferLength(Pkt->Srb, sizeof(Pkt->SrbErrorSenseData));
 
 
    SrbSetTimeOutValue(Pkt->Srb, timeoutValue);
    SrbSetDataBuffer(Pkt->Srb, ReadCapacityBuffer);
    SrbSetDataTransferLength(Pkt->Srb, ReadCapacityBufferLen);
 
    SrbAssignSrbFlags(Pkt->Srb, fdoExt->SrbFlags | SRB_FLAGS_DATA_IN | SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE);
 
    pCdb = SrbGetCdb(Pkt->Srb);
    if (pCdb) {
        if (Use16ByteCdb == TRUE) {
            NT_ASSERT(ReadCapacityBufferLen >= sizeof(READ_CAPACITY_DATA_EX));
            SrbSetCdbLength(Pkt->Srb, 16);
            pCdb->CDB16.OperationCode = SCSIOP_READ_CAPACITY16;
            REVERSE_BYTES(&pCdb->CDB16.TransferLength, &ReadCapacityBufferLen);
            pCdb->AsByte[1] = 0x10; // Service Action
        } else {
            SrbSetCdbLength(Pkt->Srb, 10);
            pCdb->CDB10.OperationCode = SCSIOP_READ_CAPACITY;
        }
    }
 
    Pkt->BufPtrCopy = ReadCapacityBuffer;
    Pkt->BufLenCopy = ReadCapacityBufferLen;
 
    Pkt->OriginalIrp = OriginalIrp;
    Pkt->NumRetries = NUM_DRIVECAPACITY_RETRIES;
#if !defined(__REACTOS__) && NTDDI_VERSION >= NTDDI_WINBLUE
    Pkt->NumIoTimeoutRetries = NUM_DRIVECAPACITY_RETRIES;
#endif
 
    Pkt->SyncEventPtr = SyncEventPtr;
    Pkt->CompleteOriginalIrpWhenLastPacketCompletes = FALSE;
}

Referenced by ClassReadDriveCapacity().

◆ SetupEjectionTransferPacket()

VOID SetupEjectionTransferPacket	(	TRANSFER_PACKET *	Pkt,
		BOOLEAN	PreventMediaRemoval,
		PKEVENT	SyncEventPtr,
		PIRP	OriginalIrp
	)

Definition at line 1315 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    PCDB pCdb;
    ULONG srbLength;
 
    PAGED_CODE();
 
    if (fdoExt->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbLength = ((PSTORAGE_REQUEST_BLOCK) fdoData->SrbTemplate)->SrbLength;
        NT_ASSERT(((PSTORAGE_REQUEST_BLOCK) Pkt->Srb)->SrbLength >= srbLength);
    } else {
        srbLength = fdoData->SrbTemplate->Length;
    }
    RtlCopyMemory(Pkt->Srb, fdoData->SrbTemplate, srbLength); // copies _contents_ of SRB blocks
 
    SrbSetRequestAttribute(Pkt->Srb, SRB_SIMPLE_TAG_REQUEST);
    SrbSetCdbLength(Pkt->Srb, 6);
    SrbSetOriginalRequest(Pkt->Srb, Pkt->Irp);
    SrbSetSenseInfoBuffer(Pkt->Srb, &Pkt->SrbErrorSenseData);
    SrbSetSenseInfoBufferLength(Pkt->Srb, sizeof(Pkt->SrbErrorSenseData));
    SrbSetTimeOutValue(Pkt->Srb, fdoExt->TimeOutValue);
 
    SrbAssignSrbFlags(Pkt->Srb, fdoExt->SrbFlags | SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE);
 
    pCdb = SrbGetCdb(Pkt->Srb);
    if (pCdb) {
        pCdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;
        pCdb->MEDIA_REMOVAL.Prevent = PreventMediaRemoval;
    }
 
    Pkt->BufPtrCopy = NULL;
    Pkt->BufLenCopy = 0;
 
    Pkt->OriginalIrp = OriginalIrp;
    Pkt->NumRetries = NUM_LOCKMEDIAREMOVAL_RETRIES;
    Pkt->SyncEventPtr = SyncEventPtr;
    Pkt->CompleteOriginalIrpWhenLastPacketCompletes = FALSE;
}

◆ SetupModeSelectTransferPacket()

VOID SetupModeSelectTransferPacket	(	TRANSFER_PACKET *	Pkt,
		PKEVENT	SyncEventPtr,
		PVOID	ModeSelectBuffer,
		UCHAR	ModeSelectBufferLen,
		BOOLEAN	SavePages,
		PIRP	OriginalIrp
	)

Definition at line 1425 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    PCDB pCdb;
    ULONG srbLength;
 
    if (fdoExt->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbLength = ((PSTORAGE_REQUEST_BLOCK) fdoData->SrbTemplate)->SrbLength;
        NT_ASSERT(((PSTORAGE_REQUEST_BLOCK) Pkt->Srb)->SrbLength >= srbLength);
    } else {
        srbLength = fdoData->SrbTemplate->Length;
    }
    RtlCopyMemory(Pkt->Srb, fdoData->SrbTemplate, srbLength); // copies _contents_ of SRB blocks
 
    SrbSetRequestAttribute(Pkt->Srb, SRB_SIMPLE_TAG_REQUEST);
    SrbSetCdbLength(Pkt->Srb, 6);
    SrbSetOriginalRequest(Pkt->Srb, Pkt->Irp);
    SrbSetSenseInfoBuffer(Pkt->Srb, &Pkt->SrbErrorSenseData);
    SrbSetSenseInfoBufferLength(Pkt->Srb, sizeof(Pkt->SrbErrorSenseData));
    SrbSetTimeOutValue(Pkt->Srb, fdoExt->TimeOutValue);
    SrbSetDataBuffer(Pkt->Srb, ModeSelectBuffer);
    SrbSetDataTransferLength(Pkt->Srb, ModeSelectBufferLen);
 
    SrbAssignSrbFlags(Pkt->Srb, fdoExt->SrbFlags | SRB_FLAGS_DATA_OUT | SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE);
 
    pCdb = SrbGetCdb(Pkt->Srb);
    if (pCdb) {
        pCdb->MODE_SELECT.OperationCode = SCSIOP_MODE_SELECT;
        pCdb->MODE_SELECT.SPBit = SavePages;
        pCdb->MODE_SELECT.PFBit = 1;
        pCdb->MODE_SELECT.ParameterListLength = (UCHAR)ModeSelectBufferLen;
    }
 
    Pkt->BufPtrCopy = ModeSelectBuffer;
    Pkt->BufLenCopy = ModeSelectBufferLen;
 
    Pkt->OriginalIrp = OriginalIrp;
    Pkt->NumRetries = NUM_MODESELECT_RETRIES;
    Pkt->SyncEventPtr = SyncEventPtr;
    Pkt->CompleteOriginalIrpWhenLastPacketCompletes = FALSE;
}

Referenced by ClasspModeSelect().

◆ SetupModeSenseTransferPacket()

VOID SetupModeSenseTransferPacket	(	TRANSFER_PACKET *	Pkt,
		PKEVENT	SyncEventPtr,
		PVOID	ModeSenseBuffer,
		UCHAR	ModeSenseBufferLen,
		UCHAR	PageMode,
		UCHAR	SubPage,
		PIRP	OriginalIrp,
		UCHAR	PageControl
	)

Definition at line 1365 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    PCDB pCdb;
    ULONG srbLength;
 
    PAGED_CODE();
 
    if (fdoExt->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbLength = ((PSTORAGE_REQUEST_BLOCK) fdoData->SrbTemplate)->SrbLength;
        NT_ASSERT(((PSTORAGE_REQUEST_BLOCK) Pkt->Srb)->SrbLength >= srbLength);
    } else {
        srbLength = fdoData->SrbTemplate->Length;
    }
    RtlCopyMemory(Pkt->Srb, fdoData->SrbTemplate, srbLength); // copies _contents_ of SRB blocks
 
    SrbSetRequestAttribute(Pkt->Srb, SRB_SIMPLE_TAG_REQUEST);
    SrbSetCdbLength(Pkt->Srb, 6);
    SrbSetOriginalRequest(Pkt->Srb, Pkt->Irp);
    SrbSetSenseInfoBuffer(Pkt->Srb, &Pkt->SrbErrorSenseData);
    SrbSetSenseInfoBufferLength(Pkt->Srb, sizeof(Pkt->SrbErrorSenseData));
    SrbSetTimeOutValue(Pkt->Srb, fdoExt->TimeOutValue);
    SrbSetDataBuffer(Pkt->Srb, ModeSenseBuffer);
    SrbSetDataTransferLength(Pkt->Srb, ModeSenseBufferLen);
 
 
    SrbAssignSrbFlags(Pkt->Srb, fdoExt->SrbFlags | SRB_FLAGS_DATA_IN | SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE);
 
    pCdb = SrbGetCdb(Pkt->Srb);
    if (pCdb) {
        pCdb->MODE_SENSE.OperationCode = SCSIOP_MODE_SENSE;
        pCdb->MODE_SENSE.PageCode = PageMode;
        pCdb->MODE_SENSE.SubPageCode = SubPage;
        pCdb->MODE_SENSE.Pc = PageControl;
        pCdb->MODE_SENSE.AllocationLength = (UCHAR)ModeSenseBufferLen;
    }
 
    Pkt->BufPtrCopy = ModeSenseBuffer;
    Pkt->BufLenCopy = ModeSenseBufferLen;
 
    Pkt->OriginalIrp = OriginalIrp;
    Pkt->NumRetries = NUM_MODESENSE_RETRIES;
    Pkt->SyncEventPtr = SyncEventPtr;
    Pkt->CompleteOriginalIrpWhenLastPacketCompletes = FALSE;
}

Referenced by ClasspModeSense().

◆ SetupReadWriteTransferPacket()

VOID SetupReadWriteTransferPacket	(	PTRANSFER_PACKET	pkt,
		PVOID	Buf,
		ULONG	Len,
		LARGE_INTEGER	DiskLocation,
		PIRP	OriginalIrp
	)

Definition at line 718 of file xferpkt.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Pkt->Fdo->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension = Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    PIO_STACK_LOCATION origCurSp = IoGetCurrentIrpStackLocation(OriginalIrp);
    UCHAR majorFunc = origCurSp->MajorFunction;
    LARGE_INTEGER logicalBlockAddr;
    ULONG numTransferBlocks;
    PCDB pCdb;
    ULONG srbLength;
    ULONG timeoutValue = fdoExt->TimeOutValue;
 
    logicalBlockAddr.QuadPart = Int64ShrlMod32(DiskLocation.QuadPart, fdoExt->SectorShift);
    numTransferBlocks = Len >> fdoExt->SectorShift;
 
    /*
     * This field is useful when debugging, since low-memory conditions are
     * handled differently for CDROM (which is the only driver using StartIO)
     */
    Pkt->DriverUsesStartIO = (commonExtension->DriverExtension->InitData.ClassStartIo != NULL);
 
    /*
     *  Slap the constant SRB fields in from our pre-initialized template.
     *  We'll then only have to fill in the unique fields for this transfer.
     *  Tell lower drivers to sort the SRBs by the logical block address
     *  so that disk seeks are minimized.
     */
    if (fdoExt->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbLength = ((PSTORAGE_REQUEST_BLOCK) fdoData->SrbTemplate)->SrbLength;
        NT_ASSERT(((PSTORAGE_REQUEST_BLOCK) Pkt->Srb)->SrbLength >= srbLength);
    } else {
        srbLength = fdoData->SrbTemplate->Length;
    }
    RtlCopyMemory(Pkt->Srb, fdoData->SrbTemplate, srbLength); // copies _contents_ of SRB blocks
    SrbSetDataBuffer(Pkt->Srb, Buf);
    SrbSetDataTransferLength(Pkt->Srb, Len);
    SrbSetQueueSortKey(Pkt->Srb, logicalBlockAddr.LowPart);
    if (logicalBlockAddr.QuadPart > 0xFFFFFFFF) {
        //
        // If the requested LBA is more than max ULONG set the
        // QueueSortKey to the maximum value, so that these
        // requests can be added towards the end of the queue.
        //
 
        SrbSetQueueSortKey(Pkt->Srb, 0xFFFFFFFF);
    }
    SrbSetOriginalRequest(Pkt->Srb, Pkt->Irp);
    SrbSetSenseInfoBuffer(Pkt->Srb, &Pkt->SrbErrorSenseData);
 
 
    SrbSetTimeOutValue(Pkt->Srb, timeoutValue);
 
    /*
     *  Arrange values in CDB in big-endian format.
     */
    pCdb = SrbGetCdb(Pkt->Srb);
    if (pCdb) {
        if (TEST_FLAG(fdoExt->DeviceFlags, DEV_USE_16BYTE_CDB)) {
            REVERSE_BYTES_QUAD(&pCdb->CDB16.LogicalBlock, &logicalBlockAddr);
            REVERSE_BYTES(&pCdb->CDB16.TransferLength, &numTransferBlocks);
            pCdb->CDB16.OperationCode = (majorFunc==IRP_MJ_READ) ? SCSIOP_READ16 : SCSIOP_WRITE16;
            SrbSetCdbLength(Pkt->Srb, 16);
        } else {
            pCdb->CDB10.LogicalBlockByte0 = ((PFOUR_BYTE)&logicalBlockAddr.LowPart)->Byte3;
            pCdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)&logicalBlockAddr.LowPart)->Byte2;
            pCdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)&logicalBlockAddr.LowPart)->Byte1;
            pCdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)&logicalBlockAddr.LowPart)->Byte0;
            pCdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)&numTransferBlocks)->Byte1;
            pCdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)&numTransferBlocks)->Byte0;
            pCdb->CDB10.OperationCode = (majorFunc==IRP_MJ_READ) ? SCSIOP_READ : SCSIOP_WRITE;
        }
    }
 
    /*
     *  Set SRB and IRP flags
     */
    SrbAssignSrbFlags(Pkt->Srb, fdoExt->SrbFlags);
    if (TEST_FLAG(OriginalIrp->Flags, IRP_PAGING_IO) ||
        TEST_FLAG(OriginalIrp->Flags, IRP_SYNCHRONOUS_PAGING_IO)){
        SrbSetSrbFlags(Pkt->Srb, SRB_CLASS_FLAGS_PAGING);
    }
    SrbSetSrbFlags(Pkt->Srb, (majorFunc==IRP_MJ_READ) ? SRB_FLAGS_DATA_IN : SRB_FLAGS_DATA_OUT);
 
    /*
     *  Allow caching only if this is not a write-through request.
     *  If write-through and caching is enabled on the device, force
     *  media access.
     *  Ignore SL_WRITE_THROUGH for reads; it's only set because the file handle was opened with WRITE_THROUGH.
     */
    if ((majorFunc == IRP_MJ_WRITE) && TEST_FLAG(origCurSp->Flags, SL_WRITE_THROUGH) && pCdb) {
        pCdb->CDB10.ForceUnitAccess = fdoExt->CdbForceUnitAccess;
    } else {
        SrbSetSrbFlags(Pkt->Srb, SRB_FLAGS_ADAPTER_CACHE_ENABLE);
    }
 
    /*
     *  Remember the buf and len in the SRB because miniports
     *  can overwrite SRB.DataTransferLength and we may need it again
     *  for the retry.
     */
    Pkt->BufPtrCopy = Buf;
    Pkt->BufLenCopy = Len;
    Pkt->TargetLocationCopy = DiskLocation;
 
    Pkt->OriginalIrp = OriginalIrp;
    Pkt->NumRetries = fdoData->MaxNumberOfIoRetries;
    Pkt->SyncEventPtr = NULL;
    Pkt->CompleteOriginalIrpWhenLastPacketCompletes = TRUE;
#if !defined(__REACTOS__) && NTDDI_VERSION >= NTDDI_WINBLUE
    Pkt->NumIoTimeoutRetries = fdoData->MaxNumberOfIoRetries;
    Pkt->NumThinProvisioningRetries = 0;
#endif
 
 
    if (pCdb) {
        DBGLOGFLUSHINFO(fdoData, TRUE, (BOOLEAN)(pCdb->CDB10.ForceUnitAccess), FALSE);
    } else {
        DBGLOGFLUSHINFO(fdoData, TRUE, FALSE, FALSE);
    }
}

Referenced by ServiceTransferRequest(), and StepLowMemRetry().

◆ SimpleInitSlistHdr()

FORCEINLINE VOID SimpleInitSlistHdr ( SINGLE_LIST_ENTRY * SListHdr )

Definition at line 1211 of file classp.h.

{
    SListHdr->Next = NULL;
}

Referenced by CleanupTransferPacketToWorkingSetSize(), and ServiceTransferRequest().

◆ SimpleIsSlistEmpty()

FORCEINLINE BOOLEAN SimpleIsSlistEmpty ( SINGLE_LIST_ENTRY * SListHdr )

Definition at line 1229 of file classp.h.

{
    return (SListHdr->Next == NULL);
}

Referenced by ServiceTransferRequest().

◆ SimplePopSlist()

FORCEINLINE SINGLE_LIST_ENTRY * SimplePopSlist ( SINGLE_LIST_ENTRY * SListHdr )

Definition at line 1220 of file classp.h.

{
    SINGLE_LIST_ENTRY *sListEntry = SListHdr->Next;
    if (sListEntry){
        SListHdr->Next = sListEntry->Next;
        sListEntry->Next = NULL;
    }
    return sListEntry;
}

Referenced by CleanupTransferPacketToWorkingSetSize(), and ServiceTransferRequest().

◆ SimplePushSlist()

FORCEINLINE VOID SimplePushSlist	(	SINGLE_LIST_ENTRY *	SListHdr,
		SINGLE_LIST_ENTRY *	SListEntry
	)

Definition at line 1215 of file classp.h.

{
    SListEntry->Next = SListHdr->Next;
    SListHdr->Next = SListEntry;
}

Referenced by CleanupTransferPacketToWorkingSetSize(), and ServiceTransferRequest().

◆ StepLowMemRetry()

BOOLEAN StepLowMemRetry ( PTRANSFER_PACKET Pkt )

Definition at line 706 of file retry.c.

{
    BOOLEAN packetDone;
 
    if (Pkt->LowMemRetry_remainingBufLen == 0){
        packetDone = TRUE;
    }
    else {
        ULONG thisChunkLen;
        if (Pkt->DriverUsesStartIO)
        {
            /*
             * Need the fdoData for the HwMaxXferLen
             */
            PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Pkt->Fdo->DeviceExtension;
            PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
 
            /*
             * Need the adapterDesc to limit transfers based on byte count
             */
            PCOMMON_DEVICE_EXTENSION commonExtension = Pkt->Fdo->DeviceExtension;
            PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExtension->PartitionZeroExtension->AdapterDescriptor;
 
            ULONG hwMaxXferLen;
 
            /*
             * special case: StartIO-based writing must stay serialized for performance
             * and proper operations (i.e. sequential writing mode).  If need more than
             * one transfer to perform this operation, and it's a StartIO-based driver
             * (such as CDROM), then just use a single packet and use the retry logic
             * that's already built-in to the packet engine.  Note that low-mem retry
             * cannot be used directly because some write methods do not work if the
             * writes are only PAGE_SIZE (i.e. packet writing may corrupt data).
             */
            NT_ASSERT(!Pkt->InLowMemRetry);
 
            /*
             *  We precomputed fdoData->HwMaxXferLen using (MaximumPhysicalPages-1).
             *  If the buffer is page-aligned, that's one less page crossing so we can add the page back in.
             *  Note: adapters that return MaximumPhysicalPages=0x10 depend on this to
             *           transfer aligned 64K requests in one piece.
             *  Also note:  make sure adding PAGE_SIZE back in doesn't wrap to zero.
             */
 
            if (((ULONG_PTR)(Pkt->LowMemRetry_remainingBufPtr) & (PAGE_SIZE-1)) || (fdoData->HwMaxXferLen > 0xffffffff-PAGE_SIZE)){
                hwMaxXferLen = fdoData->HwMaxXferLen;
            }
            else {
                NT_ASSERT((PAGE_SIZE%fdoExt->DiskGeometry.BytesPerSector) == 0);
                hwMaxXferLen = min(fdoData->HwMaxXferLen+PAGE_SIZE, adapterDesc->MaximumTransferLength);
            }
            thisChunkLen = MIN(Pkt->LowMemRetry_remainingBufLen, hwMaxXferLen);
        }
        else {
            /*
             *  Make sure the little chunk we send is <= a page length
             *  AND that it does not cross any page boundaries.
             */
            ULONG bytesToNextPageBoundary;
            bytesToNextPageBoundary = PAGE_SIZE-(ULONG)((ULONG_PTR)Pkt->LowMemRetry_remainingBufPtr%PAGE_SIZE);
            thisChunkLen = MIN(Pkt->LowMemRetry_remainingBufLen, bytesToNextPageBoundary);
            NT_ASSERT(Pkt->InLowMemRetry);
        }
 
 
        /*
         *  Set up the transfer packet for the new little chunk.
         *  This will reset numRetries so that we retry each chunk as required.
         */
        SetupReadWriteTransferPacket(Pkt,
                                     Pkt->LowMemRetry_remainingBufPtr,
                                     thisChunkLen,
                                     Pkt->LowMemRetry_nextChunkTargetLocation,
                                     Pkt->OriginalIrp);
 
        Pkt->LowMemRetry_remainingBufPtr += thisChunkLen;
        Pkt->LowMemRetry_remainingBufLen -= thisChunkLen;
        Pkt->LowMemRetry_nextChunkTargetLocation.QuadPart += thisChunkLen;
 
        //
        // When running in low-memory stress, always use a partial MDL.
        // This allows lower drivers to potentially map a smaller buffer.
        //
        Pkt->UsePartialMdl = TRUE;
 
        TransferPacketQueueRetryDpc(Pkt);
 
        packetDone = FALSE;
    }
 
    return packetDone;
}

Referenced by RetryTransferPacket(), ServiceTransferRequest(), and TransferPktComplete().

◆ SubmitTransferPacket()

NTSTATUS SubmitTransferPacket ( PTRANSFER_PACKET Pkt )

Definition at line 850 of file xferpkt.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = Pkt->Fdo->DeviceExtension;
    PDEVICE_OBJECT nextDevObj = commonExtension->LowerDeviceObject;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Pkt->Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    BOOLEAN idleRequest = FALSE;
    PIO_STACK_LOCATION nextSp;
 
    NT_ASSERT(Pkt->Irp->CurrentLocation == Pkt->Irp->StackCount+1);
 
    /*
     *  Attach the SRB to the IRP.
     *  The reused IRP's stack location has to be rewritten for each retry
     *  call because IoCompleteRequest clears the stack locations.
     */
    IoReuseIrp(Pkt->Irp, STATUS_NOT_SUPPORTED);
 
 
    nextSp = IoGetNextIrpStackLocation(Pkt->Irp);
    nextSp->MajorFunction = IRP_MJ_SCSI;
    nextSp->Parameters.Scsi.Srb = (PSCSI_REQUEST_BLOCK)Pkt->Srb;
 
    SrbSetScsiStatus(Pkt->Srb, 0);
    Pkt->Srb->SrbStatus = 0;
    SrbSetSenseInfoBufferLength(Pkt->Srb, SENSE_BUFFER_SIZE_EX);
 
    if (Pkt->CompleteOriginalIrpWhenLastPacketCompletes) {
        /*
         *  Only dereference the "original IRP"'s stack location
         *  if its a real client irp (as opposed to a static irp
         *  we're using just for result status for one of the non-IO scsi commands).
         *
         *  For read/write, propagate the storage-specific IRP stack location flags
         *  (e.g. SL_OVERRIDE_VERIFY_VOLUME, SL_WRITE_THROUGH).
         */
        PIO_STACK_LOCATION origCurSp = IoGetCurrentIrpStackLocation(Pkt->OriginalIrp);
        nextSp->Flags = origCurSp->Flags;
    }
 
    //
    // If the request is not split, we can use the original IRP MDL.  If the
    // request needs to be split, we need to use a partial MDL.  The partial MDL
    // is needed because more than one driver might be mapping the same MDL
    // and this causes problems.
    //
    if (Pkt->UsePartialMdl == FALSE) {
        Pkt->Irp->MdlAddress = Pkt->OriginalIrp->MdlAddress;
    } else {
        IoBuildPartialMdl(Pkt->OriginalIrp->MdlAddress, Pkt->PartialMdl, SrbGetDataBuffer(Pkt->Srb), SrbGetDataTransferLength(Pkt->Srb));
        Pkt->Irp->MdlAddress = Pkt->PartialMdl;
    }
 
 
    DBGLOGSENDPACKET(Pkt);
    HISTORYLOGSENDPACKET(Pkt);
 
    //
    // Set the original irp here for SFIO.
    //
    ClasspSrbSetOriginalIrp(Pkt->Srb, (PVOID) (Pkt->OriginalIrp));
 
    //
    // No need to lock for IdlePrioritySupported, since it will
    // be modified only at initialization time.
    //
    if (fdoData->IdlePrioritySupported == TRUE) {
        idleRequest = ClasspIsIdleRequest(Pkt->OriginalIrp);
        if (idleRequest) {
            InterlockedIncrement(&fdoData->ActiveIdleIoCount);
        } else {
            InterlockedIncrement(&fdoData->ActiveIoCount);
        }
    }
 
    IoSetCompletionRoutine(Pkt->Irp, TransferPktComplete, Pkt, TRUE, TRUE, TRUE);
    return IoCallDriver(nextDevObj, Pkt->Irp);
}

Referenced by ClasspContinueOffloadWrite(), ClasspModeSelect(), ClasspModeSense(), ClasspReceivePopulateTokenInformation(), ClasspReceiveWriteUsingTokenInformation(), ClassReadDriveCapacity(), ServiceTransferRequest(), and TransferPacketRetryTimerDpc().

◆ TestDictionarySignature()

BOOLEAN TestDictionarySignature ( IN PDICTIONARY Dictionary )

Definition at line 70 of file dictlib.c.

{
    return Dictionary->Signature == DICTIONARY_SIGNATURE;
}

◆ TransferPacketQueueRetryDpc()

VOID TransferPacketQueueRetryDpc ( PTRANSFER_PACKET Pkt )

Definition at line 604 of file retry.c.

{
    KeInitializeDpc(&Pkt->RetryTimerDPC, TransferPacketRetryTimerDpc, Pkt);
 
    if (Pkt->RetryIn100nsUnits == 0){
        KeInsertQueueDpc(&Pkt->RetryTimerDPC, NULL, NULL);
    }
    else {
        LARGE_INTEGER timerPeriod;
 
        NT_ASSERT(Pkt->RetryIn100nsUnits < 100 * 1000 * 1000 * 10); // sanity check -- 100 seconds is normally too long
        timerPeriod.QuadPart = -(Pkt->RetryIn100nsUnits);
        KeInitializeTimer(&Pkt->RetryTimer);
        KeSetTimer(&Pkt->RetryTimer, timerPeriod, &Pkt->RetryTimerDPC);
    }
}