class.c File Reference

#include "classp.h"
#include "debug.h"
#include <process.h>
#include <devpkey.h>
#include <ntiologc.h>

Include dependency graph for class.c:

Go to the source code of this file.

Macros
#define	CLASS_INIT_GUID   1
#define	DEBUG_MAIN_SOURCE   1
#define	FirstDriveLetter   'C'
#define	LastDriveLetter   'Z'

Functions
NTSTATUS	DllUnload (VOID)
NTSTATUS NTAPI	DriverEntry (IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)
	_IRQL_requires_max_ (PASSIVE_LEVEL)
VOID NTAPI	ClassUnload (IN PDRIVER_OBJECT DriverObject)
NTSTATUS NTAPI	ClassAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject)
NTSTATUS NTAPI	ClassDispatchPnp (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	ClassPnpStartDevice (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	ClassReadWrite (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID	InterpretCapacityData (PDEVICE_OBJECT Fdo, PREAD_CAPACITY_DATA_EX ReadCapacityData)
_Must_inspect_result_ NTSTATUS NTAPI	ClassReadDriveCapacity (_In_ PDEVICE_OBJECT Fdo)
VOID NTAPI	ClassSendStartUnit (_In_ PDEVICE_OBJECT Fdo)
NTSTATUS NTAPI	ClassAsynchronousCompletion (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
NTSTATUS	ServiceTransferRequest (PDEVICE_OBJECT Fdo, PIRP Irp, BOOLEAN PostToDpc)
NTSTATUS NTAPI	ClassIoComplete (IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	ClassSendSrbSynchronous (_In_ PDEVICE_OBJECT Fdo, _Inout_ PSCSI_REQUEST_BLOCK _Srb, _In_reads_bytes_opt_(BufferLength) PVOID BufferAddress, _In_ ULONG BufferLength, _In_ BOOLEAN WriteToDevice)
BOOLEAN NTAPI	ClassInterpretSenseInfo (_In_ PDEVICE_OBJECT Fdo, _In_ PSCSI_REQUEST_BLOCK _Srb, _In_ UCHAR MajorFunctionCode, _In_ ULONG IoDeviceCode, _In_ ULONG RetryCount, _Out_ NTSTATUS *Status, _Out_opt_ _Deref_out_range_(0, 100) ULONG *RetryInterval)
ULONG NTAPI	ClassModeSense (_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageMode)
ULONG NTAPI	ClassModeSenseEx (_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageMode, _In_ UCHAR PageControl)
ULONG	ClasspModeSense (_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageMode, _In_ UCHAR PageControl)
PVOID NTAPI	ClassFindModePage (_In_reads_bytes_(Length) PCHAR ModeSenseBuffer, _In_ ULONG Length, _In_ UCHAR PageMode, _In_ BOOLEAN Use6Byte)
NTSTATUS NTAPI	ClassModeSelect (_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSelectBuffer, _In_ ULONG Length, _In_ BOOLEAN SavePages)
NTSTATUS	ClasspModeSelect (_In_ PDEVICE_OBJECT Fdo, _In_reads_bytes_(Length) PCHAR ModeSelectBuffer, _In_ ULONG Length, _In_ BOOLEAN SavePages)
	_Success_ (return==STATUS_PENDING)
NTSTATUS NTAPI	ClassDeviceControlDispatch (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS NTAPI	ClassDeviceControl (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
NTSTATUS NTAPI	ClassShutdownFlush (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	ClasspIsPortable (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _Out_ PBOOLEAN IsPortable)
NTSTATUS NTAPI	ClassInternalIoControl (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	ClassCheckVerifyComplete (IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	ClassSignalCompletion (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 DeviceObject, IN PDEVICE_CAPABILITIES Capabilities)
__drv_aliasesMem	_IRQL_requires_max_ (DISPATCH_LEVEL)
VOID NTAPI	ClasspStartIo (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	ClasspSendSynchronousCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
VOID	ClasspRegisterMountedDeviceInterface (IN PDEVICE_OBJECT DeviceObject)
VOID NTAPI	ClassSendDeviceIoControlSynchronous (_In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT TargetDeviceObject, _Inout_updates_opt_(_Inexpressible_(max(InputBufferLength, OutputBufferLength))) PVOID Buffer, _In_ ULONG InputBufferLength, _In_ ULONG OutputBufferLength, _In_ BOOLEAN InternalDeviceIoControl, _Out_ PIO_STATUS_BLOCK IoStatus)
NTSTATUS NTAPI	ClassForwardIrpSynchronous (_In_ PCOMMON_DEVICE_EXTENSION CommonExtension, _In_ PIRP Irp)
NTSTATUS NTAPI	ClassSendIrpSynchronous (_In_ PDEVICE_OBJECT TargetDeviceObject, _In_ PIRP Irp)
PVPB NTAPI	ClassGetVpb (_In_ PDEVICE_OBJECT DeviceObject)
NTSTATUS	ClasspAllocateReleaseRequest (IN PDEVICE_OBJECT Fdo)
VOID	ClasspFreeReleaseRequest (IN PDEVICE_OBJECT Fdo)
VOID NTAPI	ClassReleaseQueue (_In_ PDEVICE_OBJECT Fdo)
NTSTATUS	ClasspAllocateReleaseQueueIrp (PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS	ClasspAllocatePowerProcessIrp (PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID	ClasspReleaseQueue (IN PDEVICE_OBJECT Fdo, IN PIRP ReleaseQueueIrp OPTIONAL)
NTSTATUS NTAPI	ClassReleaseQueueCompletion (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
VOID NTAPI	ClassReleaseChildLock (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
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 NTAPI	ClasspRetryRequestDpc (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID Arg1, IN PVOID Arg2)
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	ClasspRetryDpcTimer (IN PCLASS_PRIVATE_FDO_DATA FdoData)
NTSTATUS	ClasspInitializeHotplugInfo (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID NTAPI	ClasspScanForClassHacks (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN ULONG_PTR Data)
VOID	ClasspScanForSpecialInRegistry (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID NTAPI	ClasspUpdateDiskProperties (IN PDEVICE_OBJECT Fdo, IN PVOID Context)
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)
VOID	ClasspGetInquiryVpdSupportInfo (_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS	ClasspGetLBProvisioningInfo (_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
	_IRQL_requires_ (PASSIVE_LEVEL) ==NDIS_MEMORY_NONCACHED
_IRQL_requires_same_ NTSTATUS	ClasspGetBlockDeviceTokenLimitsInfo (_Inout_ PDEVICE_OBJECT DeviceObject)
	_IRQL_requires_max_ (APC_LEVEL)
VOID	ClasspCompleteOffloadRequest (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ NTSTATUS CompletionStatus)
VOID	ClasspPopulateTokenTransferPacketDone (_In_ PVOID Context)
VOID	ClasspCompleteOffloadRead (_In_ POFFLOAD_READ_CONTEXT OffloadReadContext, _In_ NTSTATUS CompletionStatus)
VOID	ClasspCleanupOffloadReadContext (_In_ __drv_freesMem(mem) POFFLOAD_READ_CONTEXT OffloadReadContext)
_IRQL_requires_same_ VOID	ClasspReceivePopulateTokenInformation (_In_ POFFLOAD_READ_CONTEXT OffloadReadContext)
VOID	ClasspReceivePopulateTokenInformationTransferPacketDone (_In_ PVOID Context)
VOID	ClasspContinueOffloadWrite (_In_ __drv_aliasesMem POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
VOID	ClasspAdvanceOffloadWritePosition (_In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext, _In_ ULONGLONG SectorsToAdvance)
VOID	ClasspWriteUsingTokenTransferPacketDone (_In_ PVOID Context)
VOID	ClasspReceiveWriteUsingTokenInformationDone (_In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext, _In_ NTSTATUS CompletionCausingStatus)
VOID	ClasspCompleteOffloadWrite (_In_ __drv_freesMem(Mem) POFFLOAD_WRITE_CONTEXT OffloadWriteContext, _In_ NTSTATUS CompletionCausingStatus)
VOID	ClasspCleanupOffloadWriteContext (_In_ __drv_freesMem(mem) POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
_IRQL_requires_same_ VOID	ClasspReceiveWriteUsingTokenInformation (_In_ POFFLOAD_WRITE_CONTEXT OffloadWriteContext)
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)

Variables
IO_COMPLETION_ROUTINE	ClassCheckVerifyComplete
ULONG	ClassPnpAllowUnload = TRUE
ULONG	ClassMaxInterleavePerCriticalIo = CLASS_MAX_INTERLEAVE_PER_CRITICAL_IO
CONST LARGE_INTEGER	Magic10000 = {{0xe219652c, 0xd1b71758}}
GUID	StoragePredictFailureDPSGuid = WDI_STORAGE_PREDICT_FAILURE_DPS_GUID
BOOLEAN	UseQPCTime = FALSE
BOOLEAN	InitSecurityCookie = FALSE
ULONG	MaxTokenOperationListIdentifier = MAX_TOKEN_LIST_IDENTIFIERS
volatile ULONG	TokenOperationListIdentifier = (ULONG)-1
LIST_ENTRY	IdlePowerFDOList = {0}
KGUARDED_MUTEX	IdlePowerFDOListMutex
PVOID	PowerSettingNotificationHandle
PVOID	ScreenStateNotificationHandle
ULONG	DiskIdleTimeoutInMS = 0xFFFFFFFF

Macro Definition Documentation

CLASS_INIT_GUID

#define CLASS_INIT_GUID   1

Definition at line 24 of file class.c.

DEBUG_MAIN_SOURCE

#define DEBUG_MAIN_SOURCE   1

Definition at line 25 of file class.c.

FirstDriveLetter

#define FirstDriveLetter   'C'

Definition at line 92 of file class.c.

LastDriveLetter

#define LastDriveLetter   'Z'

Definition at line 93 of file class.c.

Function Documentation

_IRQL_requires_()

_IRQL_requires_

(

PASSIVE_LEVEL

)

==NDIS_MEMORY_NONCACHED

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/3]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 13463 of file class.c.

{
    PIO_STACK_LOCATION irpStack;
    NTSTATUS status;
    PDEVICE_MANAGE_DATA_SET_ATTRIBUTES dsmAttributes;
    PDEVICE_DSM_OFFLOAD_READ_PARAMETERS offloadReadParameters;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
 
    UNREFERENCED_PARAMETER(Srb);
 
    //
    // This function must be called at less than dispatch level.
    // Fail if IRQL >= DISPATCH_LEVEL.
    //
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClassDeviceProcessOffloadRead (%p): Entering function. Irp %p\n",
                DeviceObject,
                Irp));
 
 
    irpStack = IoGetCurrentIrpStackLocation (Irp);
 
    //
    // Validations
    //
    status = ClasspValidateOffloadSupported(DeviceObject, Irp);
    if (!NT_SUCCESS(status)) {
        goto __ClassDeviceProcessOffloadRead_CompleteAndExit;
    }
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
 
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClassDeviceProcessOffloadRead (%p): Called at raised IRQL.\n",
                    DeviceObject));
 
        status = STATUS_INVALID_LEVEL;
        goto __ClassDeviceProcessOffloadRead_CompleteAndExit;
    }
 
    //
    // Ensure that this DSM IOCTL was generated in kernel
    //
    if (Irp->RequestorMode != KernelMode) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClassDeviceProcessOffloadRead (%p): Called from user mode.\n",
                    DeviceObject));
 
        status = STATUS_ACCESS_DENIED;
        goto __ClassDeviceProcessOffloadRead_CompleteAndExit;
    }
 
    status = ClasspValidateOffloadInputParameters(DeviceObject, Irp);
    if (!NT_SUCCESS(status)) {
        goto __ClassDeviceProcessOffloadRead_CompleteAndExit;
    }
 
    dsmAttributes = Irp->AssociatedIrp.SystemBuffer;
 
    //
    // Validate that we were passed in correct sized parameter block.
    //
    if (dsmAttributes->ParameterBlockLength < sizeof(DEVICE_DSM_OFFLOAD_READ_PARAMETERS)) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClassDeviceProcessOffloadRead (%p): Parameter block size (%u) too small. Required %u.\n",
                    DeviceObject,
                    dsmAttributes->ParameterBlockLength,
                    sizeof(DEVICE_DSM_OFFLOAD_READ_PARAMETERS)));
 
        status = STATUS_INVALID_PARAMETER;
        goto __ClassDeviceProcessOffloadRead_CompleteAndExit;
    }
 
    offloadReadParameters = Add2Ptr(dsmAttributes, dsmAttributes->ParameterBlockOffset);
 
    fdoExtension = DeviceObject->DeviceExtension;
 
    //
    // If the request TTL is greater than the max supported by this storage, the target will
    // end up failing this command, so might as well do the check up front.
    //
    if ((fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumInactivityTimer > 0) &&
        (offloadReadParameters->TimeToLive > fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumInactivityTimer)) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClassDeviceProcessOffloadRead (%p): Requested TTL (%u) greater than max supported (%u).\n",
                    DeviceObject,
                    offloadReadParameters->TimeToLive,
                    fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumInactivityTimer));
 
        status = STATUS_INVALID_PARAMETER;
        goto __ClassDeviceProcessOffloadRead_CompleteAndExit;
    }
 
    if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_OFFLOAD_READ_OUTPUT)) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClassDeviceProcessOffloadRead (%p): Output buffer size (%u) too small.\n",
                    DeviceObject,
                    irpStack->Parameters.DeviceIoControl.OutputBufferLength));
 
        status = STATUS_BUFFER_TOO_SMALL;
        goto __ClassDeviceProcessOffloadRead_CompleteAndExit;
    }
 
 
 
    status = ClasspServicePopulateTokenTransferRequest(DeviceObject, Irp);
 
    if (status == STATUS_PENDING) {
        goto __ClassDeviceProcessOffloadRead_Exit;
    }
 
__ClassDeviceProcessOffloadRead_CompleteAndExit:
    ClasspCompleteOffloadRequest(DeviceObject, Irp, status);
__ClassDeviceProcessOffloadRead_Exit:
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClassDeviceProcessOffloadRead (%p): Exiting function Irp %p with status %x.\n",
                DeviceObject,
                Irp,
                status));
 
    return status;
}

_IRQL_requires_max_() [2/3]

__drv_aliasesMem _IRQL_requires_max_

(

DISPATCH_LEVEL

)

Definition at line 10631 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
    return IoGetDriverObjectExtension(DriverObject, CLASS_DRIVER_EXTENSION_KEY);
} // end ClassGetDriverExtension()

_IRQL_requires_max_() [3/3]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 207 of file class.c.

{
    PDRIVER_OBJECT  DriverObject = Argument1;
    PUNICODE_STRING RegistryPath = Argument2;
 
    PCLASS_DRIVER_EXTENSION driverExtension;
 
    NTSTATUS        status;
 
 
 
    PAGED_CODE();
 
    //
    // Initialize the security cookie if needed.
    //
#ifndef __REACTOS__
    if (InitSecurityCookie == FALSE) {
        __security_init_cookie();
        InitSecurityCookie = TRUE;
    }
#endif
 
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT, "\n\nSCSI Class Driver\n"));
 
    ClasspInitializeDebugGlobals();
 
    //
    // Validate the length of this structure. This is effectively a
    // version check.
    //
 
    if (InitializationData->InitializationDataSize != sizeof(CLASS_INIT_DATA)) {
 
        //
        // This DebugPrint is to help third-party driver writers
        //
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT, "ClassInitialize: Class driver wrong version\n"));
        return (ULONG) STATUS_REVISION_MISMATCH;
    }
 
    //
    // Check that each required entry is not NULL. Note that Shutdown, Flush and Error
    // are not required entry points.
    //
 
    if ((!InitializationData->FdoData.ClassDeviceControl) ||
        (!((InitializationData->FdoData.ClassReadWriteVerification) ||
           (InitializationData->ClassStartIo))) ||
        (!InitializationData->ClassAddDevice) ||
        (!InitializationData->FdoData.ClassStartDevice)) {
 
        //
        // This DebugPrint is to help third-party driver writers
        //
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT,
            "ClassInitialize: Class device-specific driver missing required "
            "FDO entry\n"));
 
        return (ULONG) STATUS_REVISION_MISMATCH;
    }
 
    if ((InitializationData->ClassEnumerateDevice) &&
        ((!InitializationData->PdoData.ClassDeviceControl) ||
         (!InitializationData->PdoData.ClassStartDevice) ||
         (!((InitializationData->PdoData.ClassReadWriteVerification) ||
            (InitializationData->ClassStartIo))))) {
 
        //
        // This DebugPrint is to help third-party driver writers
        //
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT,  "ClassInitialize: Class device-specific missing "
                       "required PDO entry\n"));
 
        return (ULONG) STATUS_REVISION_MISMATCH;
    }
 
    if((InitializationData->FdoData.ClassStopDevice == NULL) ||
        ((InitializationData->ClassEnumerateDevice != NULL) &&
         (InitializationData->PdoData.ClassStopDevice == NULL))) {
 
        //
        // This DebugPrint is to help third-party driver writers
        //
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT,  "ClassInitialize: Class device-specific missing "
                       "required PDO entry\n"));
        NT_ASSERT(FALSE);
        return (ULONG) STATUS_REVISION_MISMATCH;
    }
 
    //
    // Setup the default power handlers if the class driver didn't provide
    // any.
    //
 
    if(InitializationData->FdoData.ClassPowerDevice == NULL) {
        InitializationData->FdoData.ClassPowerDevice = ClassMinimalPowerHandler;
    }
 
    if((InitializationData->ClassEnumerateDevice != NULL) &&
       (InitializationData->PdoData.ClassPowerDevice == NULL)) {
        InitializationData->PdoData.ClassPowerDevice = ClassMinimalPowerHandler;
    }
 
    //
    // warn that unload is not supported
    //
    // ISSUE-2000/02/03-peterwie
    // We should think about making this a fatal error.
    //
 
    if(InitializationData->ClassUnload == NULL) {
 
        //
        // This DebugPrint is to help third-party driver writers
        //
 
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT,  "ClassInitialize: driver does not support unload %wZ\n",
                    RegistryPath));
    }
 
    //
    // Create an extension for the driver object
    //
#ifdef _MSC_VER
#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
#endif
    status = IoAllocateDriverObjectExtension(DriverObject, CLASS_DRIVER_EXTENSION_KEY, sizeof(CLASS_DRIVER_EXTENSION), (PVOID *)&driverExtension);
 
    if(NT_SUCCESS(status)) {
 
        //
        // Copy the registry path into the driver extension so we can use it later
        //
 
        driverExtension->RegistryPath.Length = RegistryPath->Length;
        driverExtension->RegistryPath.MaximumLength = RegistryPath->MaximumLength;
 
        driverExtension->RegistryPath.Buffer =
            ExAllocatePoolWithTag(PagedPool,
                                  RegistryPath->MaximumLength,
                                  '1CcS');
 
        if(driverExtension->RegistryPath.Buffer == NULL) {
 
            status = STATUS_INSUFFICIENT_RESOURCES;
            return status;
        }
 
        RtlCopyUnicodeString(
            &(driverExtension->RegistryPath),
            RegistryPath);
 
        //
        // Copy the initialization data into the driver extension so we can reuse
        // it during our add device routine
        //
 
        RtlCopyMemory(
            &(driverExtension->InitData),
            InitializationData,
            sizeof(CLASS_INIT_DATA));
 
        driverExtension->DeviceCount = 0;
 
        ClassInitializeDispatchTables(driverExtension);
 
    } else if (status == STATUS_OBJECT_NAME_COLLISION) {
 
        //
        // The extension already exists - get a pointer to it
        //
#ifdef _MSC_VER
#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
#endif
        driverExtension = IoGetDriverObjectExtension(DriverObject, CLASS_DRIVER_EXTENSION_KEY);
 
        NT_ASSERT(driverExtension != NULL);
 
    } else {
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT,  "ClassInitialize: Class driver extension could not be "
                       "allocated %lx\n", status));
        return status;
    }
 
 
    //
    // Update driver object with entry points.
    //
 
#ifdef _MSC_VER
#pragma prefast(push)
#pragma prefast(disable:28175, "Accessing DRIVER_OBJECT fileds is OK here since this function " \
                               "is supposed to be invoked from DriverEntry only")
#endif
    DriverObject->MajorFunction[IRP_MJ_CREATE]          = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_CLOSE]           = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_READ]            = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_WRITE]           = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_SCSI]            = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]  = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_SHUTDOWN]        = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS]   = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_PNP]             = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_POWER]           = ClassGlobalDispatch;
    DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL]  = ClassGlobalDispatch;
 
    if (InitializationData->ClassStartIo) {
        DriverObject->DriverStartIo = ClasspStartIo;
    }
 
    if ((InitializationData->ClassUnload) && (ClassPnpAllowUnload == TRUE)) {
        DriverObject->DriverUnload = ClassUnload;
    } else {
        DriverObject->DriverUnload = NULL;
    }
 
    DriverObject->DriverExtension->AddDevice = ClassAddDevice;
#ifdef _MSC_VER
#pragma prefast(pop)
#endif
 
 
    //
    // Register for event tracing
    //
    if (driverExtension->EtwHandle == 0) {
        status = EtwRegister(&StoragePredictFailureDPSGuid,
                             NULL,
                             NULL,
                             &driverExtension->EtwHandle);
        if (!NT_SUCCESS(status)) {
            driverExtension->EtwHandle = 0;
        }
        WPP_INIT_TRACING(DriverObject, RegistryPath);
    }
 
 
    //
    // Ensure these are only initialized once.
    //
    if (IdlePowerFDOList.Flink == NULL) {
        InitializeListHead(&IdlePowerFDOList);
        KeInitializeGuardedMutex(&IdlePowerFDOListMutex);
    }
 
    status = STATUS_SUCCESS;
    return status;
} // end ClassInitialize()

_Success_()

_Success_

(

return

= = STATUS_PENDING

)

Definition at line 7019 of file class.c.

{
 
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PIO_STACK_LOCATION irpStack;
    PSTORAGE_REQUEST_BLOCK_HEADER Srb = (PSTORAGE_REQUEST_BLOCK_HEADER)_Srb;
 
    ULONG savedFlags;
 
    if (Srb->Function != SRB_FUNCTION_STORAGE_REQUEST_BLOCK) {
        //
        // Write length to SRB.
        //
 
        Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
 
        //
        // Set SCSI bus address.
        //
 
        Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    }
 
    //
    // This is a violation of the SCSI spec but it is required for
    // some targets.
    //
 
    // Srb->Cdb[1] |= deviceExtension->Lun << 5;
 
    //
    // Indicate auto request sense by specifying buffer and size.
    //
 
    SrbSetSenseInfoBuffer(Srb, fdoExtension->SenseData);
    SrbSetSenseInfoBufferLength(Srb, GET_FDO_EXTENSON_SENSE_DATA_LENGTH(fdoExtension));
 
    SrbSetDataBuffer(Srb, BufferAddress);
 
    //
    // Set the transfer length.
    //
    SrbSetDataTransferLength(Srb, BufferLength);
 
    //
    // Save the class driver specific flags away.
    //
 
    savedFlags = SrbGetSrbFlags(Srb) & SRB_FLAGS_CLASS_DRIVER_RESERVED;
 
    //
    // Allow the caller to specify that they do not wish
    // IoStartNextPacket() to be called in the completion routine.
    //
 
    SET_FLAG(savedFlags, (SrbGetSrbFlags(Srb) & SRB_FLAGS_DONT_START_NEXT_PACKET));
 
    //
    // If caller wants to this request to be tagged, save this fact.
    //
 
    if ( TEST_FLAG(SrbGetSrbFlags(Srb), SRB_FLAGS_QUEUE_ACTION_ENABLE) &&
         ( SRB_SIMPLE_TAG_REQUEST == SrbGetRequestAttribute(Srb) ||
           SRB_HEAD_OF_QUEUE_TAG_REQUEST == SrbGetRequestAttribute(Srb) ||
           SRB_ORDERED_QUEUE_TAG_REQUEST == SrbGetRequestAttribute(Srb) ) ) {
 
        SET_FLAG(savedFlags, SRB_FLAGS_QUEUE_ACTION_ENABLE);
        if (TEST_FLAG(SrbGetSrbFlags(Srb), SRB_FLAGS_NO_QUEUE_FREEZE)) {
            SET_FLAG(savedFlags, SRB_FLAGS_NO_QUEUE_FREEZE);
        }
    }
 
    if (BufferAddress != NULL) {
 
        //
        // Build Mdl if necessary.
        //
 
        if (Irp->MdlAddress == NULL) {
 
            PMDL mdl;
 
            mdl = IoAllocateMdl(BufferAddress,
                                BufferLength,
                                FALSE,
                                FALSE,
                                Irp);
 
            if ((mdl == NULL) || (Irp->MdlAddress == NULL)) {
 
                Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
 
                //
                // ClassIoComplete() would have free'd the srb
                //
 
                if (PORT_ALLOCATED_SENSE_EX(fdoExtension, Srb)) {
                    FREE_PORT_ALLOCATED_SENSE_BUFFER_EX(fdoExtension, Srb);
                }
                ClassFreeOrReuseSrb(fdoExtension, (PSCSI_REQUEST_BLOCK)Srb);
                ClassReleaseRemoveLock(Fdo, Irp);
                ClassCompleteRequest(Fdo, Irp, IO_NO_INCREMENT);
 
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            SET_FLAG(savedFlags, SRB_CLASS_FLAGS_FREE_MDL);
 
            MmBuildMdlForNonPagedPool(Irp->MdlAddress);
 
        } else {
 
            //
            // Make sure the buffer requested matches the MDL.
            //
 
            NT_ASSERT(BufferAddress == MmGetMdlVirtualAddress(Irp->MdlAddress));
        }
 
        //
        // Set read flag.
        //
 
        SrbAssignSrbFlags(Srb, WriteToDevice ? SRB_FLAGS_DATA_OUT : SRB_FLAGS_DATA_IN);
 
    } else {
 
        //
        // Clear flags.
        //
 
        SrbAssignSrbFlags(Srb, SRB_FLAGS_NO_DATA_TRANSFER);
    }
 
    //
    // Restore saved flags.
    //
 
    SrbSetSrbFlags(Srb, savedFlags);
 
    //
    // Disable synchronous transfer for these requests.
    //
 
    SrbSetSrbFlags(Srb, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
 
    //
    // Zero out status.
    //
 
    SrbSetScsiStatus(Srb, 0);
    Srb->SrbStatus = 0;
 
    SrbSetNextSrb(Srb, NULL);
 
    //
    // Save a few parameters in the current stack location.
    //
 
    irpStack = IoGetCurrentIrpStackLocation(Irp);
 
    //
    // Save retry count in current Irp stack.
    //
 
    irpStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;
 
    //
    // Set up IoCompletion routine address.
    //
 
    IoSetCompletionRoutine(Irp, ClassIoComplete, Srb, TRUE, TRUE, TRUE);
 
    //
    // Get next stack location and
    // set major function code.
    //
 
    irpStack = IoGetNextIrpStackLocation(Irp);
 
    irpStack->MajorFunction = IRP_MJ_SCSI;
 
    //
    // Save SRB address in next stack for port driver.
    //
 
    irpStack->Parameters.Scsi.Srb = (PSCSI_REQUEST_BLOCK)Srb;
 
    //
    // Set up Irp Address.
    //
 
    SrbSetOriginalRequest(Srb, Irp);
 
    //
    // Call the port driver to process the request.
    //
 
    IoMarkIrpPending(Irp);
 
    IoCallDriver(fdoExtension->CommonExtension.LowerDeviceObject, Irp);
 
    return STATUS_PENDING;
 
} // end ClassSendSrbAsynchronous()

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

ClassAddDevice()

NTSTATUS NTAPI ClassAddDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	PhysicalDeviceObject
	)

Definition at line 851 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(DriverObject, CLASS_DRIVER_EXTENSION_KEY);
 
    NTSTATUS status;
 
    PAGED_CODE();
 
 
    status = driverExtension->InitData.ClassAddDevice(DriverObject,
                                              PhysicalDeviceObject);
 
    return status;
} // end ClassAddDevice()

ClassAsynchronousCompletion()

NTSTATUS NTAPI ClassAsynchronousCompletion	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

Definition at line 3246 of file class.c.

{
    PCOMPLETION_CONTEXT context = Context;
    PSCSI_REQUEST_BLOCK srb;
    ULONG srbFunction;
    ULONG srbFlags;
 
    if (context == NULL) {
        return STATUS_INVALID_PARAMETER;
    }
 
    if (DeviceObject == NULL) {
 
        DeviceObject = context->DeviceObject;
    }
 
    srb = &context->Srb.Srb;
 
    if (srb->Function == SRB_FUNCTION_STORAGE_REQUEST_BLOCK) {
        srbFunction = ((PSTORAGE_REQUEST_BLOCK)srb)->SrbFunction;
        srbFlags = ((PSTORAGE_REQUEST_BLOCK)srb)->SrbFlags;
    } else {
        srbFunction = srb->Function;
        srbFlags = srb->SrbFlags;
    }
 
    //
    // If this is an execute srb, then check the return status and make sure.
    // the queue is not frozen.
    //
 
    if (srbFunction == SRB_FUNCTION_EXECUTE_SCSI) {
 
        //
        // Check for a frozen queue.
        //
 
        if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
 
            //
            // Unfreeze the queue getting the device object from the context.
            //
 
            ClassReleaseQueue(context->DeviceObject);
        }
    }
 
    { // free port-allocated sense buffer if we can detect
 
        if (((PCOMMON_DEVICE_EXTENSION)(DeviceObject->DeviceExtension))->IsFdo) {
 
            PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
            if (PORT_ALLOCATED_SENSE(fdoExtension, srb)) {
                FREE_PORT_ALLOCATED_SENSE_BUFFER(fdoExtension, srb);
            }
 
        } else {
 
            NT_ASSERT(!TEST_FLAG(srbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
 
        }
    }
 
 
    //
    // Free the context and the Irp.
    //
 
    if (Irp->MdlAddress != NULL) {
        MmUnlockPages(Irp->MdlAddress);
        IoFreeMdl(Irp->MdlAddress);
 
        Irp->MdlAddress = NULL;
    }
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
 
    FREE_POOL(context);
 
    IoFreeIrp(Irp);
 
    //
    // Indicate the I/O system should stop processing the Irp completion.
    //
 
    return STATUS_MORE_PROCESSING_REQUIRED;
 
} // end ClassAsynchronousCompletion()

Referenced by ClassSendStartUnit(), ResetBus(), and ScsiFlopProcessError().

ClassCheckVerifyComplete()

NTSTATUS NTAPI ClassCheckVerifyComplete	(	IN PDEVICE_OBJECT	Fdo,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 9578 of file class.c.

{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
 
    PIRP originalIrp;
 
    UNREFERENCED_PARAMETER(Context);
 
    ASSERT_FDO(Fdo);
 
    originalIrp = irpStack->Parameters.Others.Argument1;
 
    //
    // Copy the media change count and status
    //
 
    *((PULONG) (originalIrp->AssociatedIrp.SystemBuffer)) =
        fdoExtension->MediaChangeCount;
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "ClassCheckVerifyComplete - Media change count for"
                   "device %d is %lx - saved as %lx\n",
                fdoExtension->DeviceNumber,
                fdoExtension->MediaChangeCount,
                *((PULONG) originalIrp->AssociatedIrp.SystemBuffer)));
 
    originalIrp->IoStatus.Status = Irp->IoStatus.Status;
    originalIrp->IoStatus.Information = sizeof(ULONG);
 
    ClassReleaseRemoveLock(Fdo, originalIrp);
    ClassCompleteRequest(Fdo, originalIrp, IO_DISK_INCREMENT);
 
    IoFreeIrp(Irp);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
 
} // end ClassCheckVerifyComplete()

ClassDeviceControl()

NTSTATUS NTAPI ClassDeviceControl	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 7317 of file class.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
 
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PIO_STACK_LOCATION nextStack = NULL;
 
    ULONG controlCode = irpStack->Parameters.DeviceIoControl.IoControlCode;
 
    PSCSI_REQUEST_BLOCK srb = NULL;
    PCDB cdb = NULL;
 
    NTSTATUS status;
    ULONG modifiedIoControlCode = 0;
    GUID activityId = {0};
 
 
    //
    // If this is a pass through I/O control, set the minor function code
    // and device address and pass it to the port driver.
    //
 
    if ( (controlCode == IOCTL_SCSI_PASS_THROUGH) ||
         (controlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT) ||
         (controlCode == IOCTL_SCSI_PASS_THROUGH_EX) ||
         (controlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT_EX) ) {
 
 
 
        //
        // Validiate the user buffer for SCSI pass through.
        // For pass through EX: as the handler will validate the size anyway,
        //                      do not apply the similar check and leave the work to the handler.
        //
        if ( (controlCode == IOCTL_SCSI_PASS_THROUGH) ||
             (controlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT) ) {
 
        #if BUILD_WOW64_ENABLED && defined(_WIN64)
 
            if (IoIs32bitProcess(Irp)) {
 
                if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(SCSI_PASS_THROUGH32)){
 
                    Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
 
                    ClassReleaseRemoveLock(DeviceObject, Irp);
                    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
                    status = STATUS_INVALID_PARAMETER;
                    goto SetStatusAndReturn;
                }
            }
            else
 
        #endif
 
            {
                if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
                    sizeof(SCSI_PASS_THROUGH)) {
 
                    Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
 
                    ClassReleaseRemoveLock(DeviceObject, Irp);
                    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
                    status = STATUS_INVALID_PARAMETER;
                    goto SetStatusAndReturn;
                }
            }
        }
 
 
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        nextStack = IoGetNextIrpStackLocation(Irp);
        nextStack->MinorFunction = 1;
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
 
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        goto SetStatusAndReturn;
 
    }
 
    Irp->IoStatus.Information = 0;
 
 
    switch (controlCode) {
 
        case IOCTL_MOUNTDEV_QUERY_UNIQUE_ID: {
 
            PMOUNTDEV_UNIQUE_ID uniqueId;
 
            if (!commonExtension->MountedDeviceInterfaceName.Buffer) {
                status = STATUS_INVALID_PARAMETER;
                break;
            }
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(MOUNTDEV_UNIQUE_ID)) {
 
                status = STATUS_BUFFER_TOO_SMALL;
                Irp->IoStatus.Information = sizeof(MOUNTDEV_UNIQUE_ID);
                break;
            }
 
            uniqueId = Irp->AssociatedIrp.SystemBuffer;
            RtlZeroMemory(uniqueId, sizeof(MOUNTDEV_UNIQUE_ID));
            uniqueId->UniqueIdLength =
                    commonExtension->MountedDeviceInterfaceName.Length;
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(USHORT) + uniqueId->UniqueIdLength) {
 
                status = STATUS_BUFFER_OVERFLOW;
                Irp->IoStatus.Information = sizeof(MOUNTDEV_UNIQUE_ID);
                break;
            }
 
            RtlCopyMemory(uniqueId->UniqueId,
                          commonExtension->MountedDeviceInterfaceName.Buffer,
                          uniqueId->UniqueIdLength);
 
            status = STATUS_SUCCESS;
            Irp->IoStatus.Information = sizeof(USHORT) +
                                        uniqueId->UniqueIdLength;
            break;
        }
 
        case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME: {
 
            PMOUNTDEV_NAME name;
 
            NT_ASSERT(commonExtension->DeviceName.Buffer);
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(MOUNTDEV_NAME)) {
 
                status = STATUS_BUFFER_TOO_SMALL;
                Irp->IoStatus.Information = sizeof(MOUNTDEV_NAME);
                break;
            }
 
            name = Irp->AssociatedIrp.SystemBuffer;
            RtlZeroMemory(name, sizeof(MOUNTDEV_NAME));
            name->NameLength = commonExtension->DeviceName.Length;
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(USHORT) + name->NameLength) {
 
                status = STATUS_BUFFER_OVERFLOW;
                Irp->IoStatus.Information = sizeof(MOUNTDEV_NAME);
                break;
            }
 
            RtlCopyMemory(name->Name, commonExtension->DeviceName.Buffer,
                          name->NameLength);
 
            status = STATUS_SUCCESS;
            Irp->IoStatus.Information = sizeof(USHORT) + name->NameLength;
            break;
        }
 
        case IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME: {
 
            PMOUNTDEV_SUGGESTED_LINK_NAME suggestedName;
            WCHAR driveLetterNameBuffer[10] = {0};
            RTL_QUERY_REGISTRY_TABLE queryTable[2] = {0};
            PWSTR valueName;
            UNICODE_STRING driveLetterName;
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(MOUNTDEV_SUGGESTED_LINK_NAME)) {
 
                status = STATUS_BUFFER_TOO_SMALL;
                Irp->IoStatus.Information = sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
                break;
            }
 
            valueName = ExAllocatePoolWithTag(
                            PagedPool,
                            commonExtension->DeviceName.Length + sizeof(WCHAR),
                            '8CcS');
 
            if (!valueName) {
                status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }
 
            RtlCopyMemory(valueName, commonExtension->DeviceName.Buffer,
                          commonExtension->DeviceName.Length);
            valueName[commonExtension->DeviceName.Length/sizeof(WCHAR)] = 0;
 
            driveLetterName.Buffer = driveLetterNameBuffer;
            driveLetterName.MaximumLength = sizeof(driveLetterNameBuffer);
            driveLetterName.Length = 0;
 
            queryTable[0].Flags = RTL_QUERY_REGISTRY_REQUIRED |
                                  RTL_QUERY_REGISTRY_DIRECT |
                                  RTL_QUERY_REGISTRY_TYPECHECK;
            queryTable[0].Name = valueName;
            queryTable[0].EntryContext = &driveLetterName;
            queryTable->DefaultType = (REG_SZ << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_NONE;
 
            status = RtlQueryRegistryValues(RTL_REGISTRY_ABSOLUTE,
                                            L"\\Registry\\Machine\\System\\DISK",
                                            queryTable, NULL, NULL);
 
            if (!NT_SUCCESS(status)) {
                FREE_POOL(valueName);
                break;
            }
 
            if (driveLetterName.Length == 4 &&
                driveLetterName.Buffer[0] == '%' &&
                driveLetterName.Buffer[1] == ':') {
 
                driveLetterName.Buffer[0] = 0xFF;
 
            } else if (driveLetterName.Length != 4 ||
                driveLetterName.Buffer[0] < FirstDriveLetter ||
                driveLetterName.Buffer[0] > LastDriveLetter ||
                driveLetterName.Buffer[1] != ':') {
 
                status = STATUS_NOT_FOUND;
                FREE_POOL(valueName);
                break;
            }
 
            suggestedName = Irp->AssociatedIrp.SystemBuffer;
            RtlZeroMemory(suggestedName, sizeof(MOUNTDEV_SUGGESTED_LINK_NAME));
            suggestedName->UseOnlyIfThereAreNoOtherLinks = TRUE;
            suggestedName->NameLength = 28;
 
            Irp->IoStatus.Information =
                    FIELD_OFFSET(MOUNTDEV_SUGGESTED_LINK_NAME, Name) + 28;
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                Irp->IoStatus.Information) {
 
                Irp->IoStatus.Information =
                        sizeof(MOUNTDEV_SUGGESTED_LINK_NAME);
                status = STATUS_BUFFER_OVERFLOW;
                FREE_POOL(valueName);
                break;
            }
 
            RtlDeleteRegistryValue(RTL_REGISTRY_ABSOLUTE,
                                   L"\\Registry\\Machine\\System\\DISK",
                                   valueName);
 
            FREE_POOL(valueName);
 
            RtlCopyMemory(suggestedName->Name, L"\\DosDevices\\", 24);
            suggestedName->Name[12] = driveLetterName.Buffer[0];
            suggestedName->Name[13] = ':';
 
            //
            // NT_SUCCESS(status) based on RtlQueryRegistryValues
            //
            status = STATUS_SUCCESS;
 
            break;
        }
 
        default:
            status = STATUS_PENDING;
            break;
    }
 
    if (status != STATUS_PENDING) {
        ClassReleaseRemoveLock(DeviceObject, Irp);
        Irp->IoStatus.Status = status;
 
 
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
        return status;
    }
 
    if (commonExtension->IsFdo){
 
        PULONG_PTR function;
        PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)commonExtension;
        size_t sizeNeeded;
 
        //
        // Allocate a SCSI SRB for handling various IOCTLs.
        // NOTE - there is a case where an IOCTL is sent to classpnp before AdapterDescriptor
        // is initialized. In this case, default to legacy SRB.
        //
        if ((fdoExtension->AdapterDescriptor != NULL) &&
            (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK)) {
            sizeNeeded = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
        } else {
            sizeNeeded = sizeof(SCSI_REQUEST_BLOCK);
        }
 
        srb = ExAllocatePoolWithTag(NonPagedPoolNx,
                             sizeNeeded +
                             (sizeof(ULONG_PTR) * 2),
                             '9CcS');
 
        if (srb == NULL) {
 
            Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
            ClassReleaseRemoveLock(DeviceObject, Irp);
            ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto SetStatusAndReturn;
        }
 
        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;
                function = (PULONG_PTR)((PCHAR)srb + sizeNeeded);
            } else {
                //
                // Should not occur.
                //
                NT_ASSERT(FALSE);
                goto SetStatusAndReturn;
            }
        } else {
            RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
            srb->Length = sizeof(SCSI_REQUEST_BLOCK);
            srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
            function = (PULONG_PTR) ((PSCSI_REQUEST_BLOCK) (srb + 1));
        }
 
        //
        // Save the function code and the device object in the memory after
        // the SRB.
        //
 
        *function = (ULONG_PTR) DeviceObject;
        function++;
        *function = (ULONG_PTR) controlCode;
 
    } else {
        srb = NULL;
    }
 
    //
    // Change the device type to storage for the switch statement, but only
    // if from a legacy device type
    //
 
    if (((controlCode & 0xffff0000) == (IOCTL_DISK_BASE  << 16)) ||
        ((controlCode & 0xffff0000) == (IOCTL_TAPE_BASE  << 16)) ||
        ((controlCode & 0xffff0000) == (IOCTL_CDROM_BASE << 16))
        ) {
 
        modifiedIoControlCode = (controlCode & ~0xffff0000);
        modifiedIoControlCode |= (IOCTL_STORAGE_BASE << 16);
 
    } else {
 
        modifiedIoControlCode = controlCode;
 
    }
 
    TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL, "> ioctl %xh (%s)", modifiedIoControlCode, DBGGETIOCTLSTR(modifiedIoControlCode)));
 
 
    switch (modifiedIoControlCode) {
 
        case IOCTL_STORAGE_GET_HOTPLUG_INFO: {
 
            FREE_POOL(srb);
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(STORAGE_HOTPLUG_INFO)) {
 
                //
                // Indicate unsuccessful status and no data transferred.
                //
 
                Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
                Irp->IoStatus.Information = sizeof(STORAGE_HOTPLUG_INFO);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                status = STATUS_BUFFER_TOO_SMALL;
 
            } else if (!commonExtension->IsFdo) {
 
 
                //
                // Just forward this down and return
                //
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 
            } else {
 
                PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
                PSTORAGE_HOTPLUG_INFO info;
 
                fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)commonExtension;
                info = Irp->AssociatedIrp.SystemBuffer;
 
                *info = fdoExtension->PrivateFdoData->HotplugInfo;
                Irp->IoStatus.Status = STATUS_SUCCESS;
                Irp->IoStatus.Information = sizeof(STORAGE_HOTPLUG_INFO);
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                status = STATUS_SUCCESS;
            }
            break;
        }
 
        case IOCTL_STORAGE_SET_HOTPLUG_INFO: {
 
            FREE_POOL(srb);
 
            if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
                sizeof(STORAGE_HOTPLUG_INFO)) {
 
                //
                // Indicate unsuccessful status and no data transferred.
                //
 
                Irp->IoStatus.Status = STATUS_INFO_LENGTH_MISMATCH;
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                status = STATUS_INFO_LENGTH_MISMATCH;
                goto SetStatusAndReturn;
 
            }
 
            if (!commonExtension->IsFdo) {
 
 
                //
                // Just forward this down and return
                //
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 
            } else {
 
                PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)commonExtension;
                PSTORAGE_HOTPLUG_INFO info = Irp->AssociatedIrp.SystemBuffer;
 
                status = STATUS_SUCCESS;
 
                if (info->Size != fdoExtension->PrivateFdoData->HotplugInfo.Size)
                {
                    status = STATUS_INVALID_PARAMETER_1;
                }
 
                if (info->MediaRemovable != fdoExtension->PrivateFdoData->HotplugInfo.MediaRemovable)
                {
                    status = STATUS_INVALID_PARAMETER_2;
                }
 
                if (info->MediaHotplug != fdoExtension->PrivateFdoData->HotplugInfo.MediaHotplug)
                {
                    status = STATUS_INVALID_PARAMETER_3;
                }
 
                if (NT_SUCCESS(status))
                {
                    if (info->WriteCacheEnableOverride != fdoExtension->PrivateFdoData->HotplugInfo.WriteCacheEnableOverride)
                    {
                        fdoExtension->PrivateFdoData->HotplugInfo.WriteCacheEnableOverride = info->WriteCacheEnableOverride;
 
                        //
                        // Store the user-defined override in the registry
                        //
 
                        ClassSetDeviceParameter(fdoExtension,
                                                CLASSP_REG_SUBKEY_NAME,
                                                CLASSP_REG_WRITE_CACHE_VALUE_NAME,
                                                info->WriteCacheEnableOverride);
                    }
 
                    fdoExtension->PrivateFdoData->HotplugInfo.DeviceHotplug = info->DeviceHotplug;
 
                    //
                    // Store the user-defined override in the registry
                    //
 
                    ClassSetDeviceParameter(fdoExtension,
                                            CLASSP_REG_SUBKEY_NAME,
                                            CLASSP_REG_REMOVAL_POLICY_VALUE_NAME,
                                            (info->DeviceHotplug) ? RemovalPolicyExpectSurpriseRemoval : RemovalPolicyExpectOrderlyRemoval);
                }
 
                Irp->IoStatus.Status = status;
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
            }
 
            break;
        }
 
        case IOCTL_STORAGE_CHECK_VERIFY:
        case IOCTL_STORAGE_CHECK_VERIFY2: {
 
            PIRP irp2 = NULL;
            PIO_STACK_LOCATION newStack;
 
            PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = NULL;
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DeviceIoControl: Check verify\n"));
 
            //
            // If a buffer for a media change count was provided, make sure it's
            // big enough to hold the result
            //
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength) {
 
                //
                // If the buffer is too small to hold the media change count
                // then return an error to the caller
                //
 
                if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                    sizeof(ULONG)) {
 
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL, "DeviceIoControl: media count "
                                                                       "buffer too small\n"));
 
                    Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
                    Irp->IoStatus.Information = sizeof(ULONG);
 
                    FREE_POOL(srb);
 
                    ClassReleaseRemoveLock(DeviceObject, Irp);
                    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
                    status = STATUS_BUFFER_TOO_SMALL;
                    goto SetStatusAndReturn;
                }
            }
 
            if (!commonExtension->IsFdo) {
 
 
                //
                // If this is a PDO then we should just forward the request down
                //
                NT_ASSERT(!srb);
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
 
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 
                goto SetStatusAndReturn;
 
            } else {
 
                fdoExtension = DeviceObject->DeviceExtension;
 
            }
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength) {
 
                //
                // The caller has provided a valid buffer.  Allocate an additional
                // irp and stick the CheckVerify completion routine on it.  We will
                // then send this down to the port driver instead of the irp the
                // caller sent in
                //
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DeviceIoControl: Check verify wants "
                                                                       "media count\n"));
 
                //
                // Allocate a new irp to send the TestUnitReady to the port driver
                //
 
                irp2 = IoAllocateIrp((CCHAR) (DeviceObject->StackSize + 3), FALSE);
 
                if (irp2 == NULL) {
                    Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
                    Irp->IoStatus.Information = 0;
                    FREE_POOL(srb);
                    ClassReleaseRemoveLock(DeviceObject, Irp);
                    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                    status = STATUS_INSUFFICIENT_RESOURCES;
                    goto SetStatusAndReturn;
 
                    break;
                }
 
                //
                // 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 check verify completion routine onto the stack
                // and prepare the irp for the port driver
                //
 
                IoSetCompletionRoutine(irp2,
                                       ClassCheckVerifyComplete,
                                       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);
 
                Irp = irp2;
 
            }
 
            //
            // Test Unit Ready
            //
 
            SrbSetCdbLength(srb, 6);
            cdb = SrbGetCdb(srb);
            cdb->CDB6GENERIC.OperationCode = SCSIOP_TEST_UNIT_READY;
 
            //
            // Set timeout value.
            //
 
            SrbSetTimeOutValue(srb, fdoExtension->TimeOutValue);
 
            //
            // If this was a CV2 then mark the request as low-priority so we don't
            // spin up the drive just to satisfy it.
            //
 
            if (controlCode == IOCTL_STORAGE_CHECK_VERIFY2) {
                SrbSetSrbFlags(srb, SRB_CLASS_FLAGS_LOW_PRIORITY);
            }
 
            //
            // Since this routine will always hand the request to the
            // port driver if there isn't a data transfer to be done
            // we don't have to worry about completing the request here
            // on an error
            //
 
            //
            // This routine uses a completion routine so we don't want to release
            // the remove lock until then.
            //
 
            status = ClassSendSrbAsynchronous(DeviceObject,
                                              srb,
                                              Irp,
                                              NULL,
                                              0,
                                              FALSE);
 
            break;
        }
 
        case IOCTL_STORAGE_MEDIA_REMOVAL:
        case IOCTL_STORAGE_EJECTION_CONTROL: {
 
            PPREVENT_MEDIA_REMOVAL mediaRemoval = Irp->AssociatedIrp.SystemBuffer;
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,  "DiskIoControl: ejection control\n"));
 
            FREE_POOL(srb);
 
            if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
                sizeof(PREVENT_MEDIA_REMOVAL)) {
 
                //
                // Indicate unsuccessful status and no data transferred.
                //
 
                Irp->IoStatus.Status = STATUS_INFO_LENGTH_MISMATCH;
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                status = STATUS_INFO_LENGTH_MISMATCH;
                goto SetStatusAndReturn;
            }
 
            if (!commonExtension->IsFdo) {
 
 
                //
                // Just forward this down and return
                //
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
            }
            else {
 
                // i don't believe this assertion is valid.  this is a request
                // from user-mode, so they could request this for any device
                // they want?  also, we handle it properly.
                // NT_ASSERT(TEST_FLAG(DeviceObject->Characteristics, FILE_REMOVABLE_MEDIA));
                status = ClasspEjectionControl(
                            DeviceObject,
                            Irp,
                            ((modifiedIoControlCode ==
                            IOCTL_STORAGE_EJECTION_CONTROL) ? SecureMediaLock :
                                                              SimpleMediaLock),
                            mediaRemoval->PreventMediaRemoval);
 
                Irp->IoStatus.Status = status;
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
            }
 
            break;
        }
 
        case IOCTL_STORAGE_MCN_CONTROL: {
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,  "DiskIoControl: MCN control\n"));
 
            if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
                sizeof(PREVENT_MEDIA_REMOVAL)) {
 
                //
                // Indicate unsuccessful status and no data transferred.
                //
 
                Irp->IoStatus.Status = STATUS_INFO_LENGTH_MISMATCH;
                Irp->IoStatus.Information = 0;
 
                FREE_POOL(srb);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                status = STATUS_INFO_LENGTH_MISMATCH;
                goto SetStatusAndReturn;
            }
 
            if (!commonExtension->IsFdo) {
 
 
                //
                // Just forward this down and return
                //
 
                FREE_POOL(srb);
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 
            } else {
 
                //
                // Call to the FDO - handle the ejection control.
                //
 
                status = ClasspMcnControl(DeviceObject->DeviceExtension,
                                          Irp,
                                          srb);
            }
            goto SetStatusAndReturn;
        }
 
        case IOCTL_STORAGE_RESERVE:
        case IOCTL_STORAGE_RELEASE: {
 
            //
            // Reserve logical unit.
            //
 
            PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = NULL;
 
            if (!commonExtension->IsFdo) {
 
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                goto SetStatusAndReturn;
 
            } else {
                fdoExtension = DeviceObject->DeviceExtension;
            }
 
            if (TEST_FLAG(fdoExtension->PrivateFdoData->HackFlags, FDO_HACK_NO_RESERVE6))
            {
                SrbSetCdbLength(srb, 10);
                cdb = SrbGetCdb(srb);
                cdb->CDB10.OperationCode = (modifiedIoControlCode == IOCTL_STORAGE_RESERVE) ? SCSIOP_RESERVE_UNIT10 : SCSIOP_RELEASE_UNIT10;
            }
            else
            {
                SrbSetCdbLength(srb, 6);
                cdb = SrbGetCdb(srb);
                cdb->CDB6GENERIC.OperationCode = (modifiedIoControlCode == IOCTL_STORAGE_RESERVE) ? SCSIOP_RESERVE_UNIT : SCSIOP_RELEASE_UNIT;
            }
 
            //
            // Set timeout value.
            //
 
            SrbSetTimeOutValue(srb, fdoExtension->TimeOutValue);
 
            //
            // Send reserves as tagged requests.
            //
 
            if ( IOCTL_STORAGE_RESERVE == modifiedIoControlCode ) {
                SrbSetSrbFlags(srb, SRB_FLAGS_QUEUE_ACTION_ENABLE);
                SrbSetRequestAttribute(srb, SRB_SIMPLE_TAG_REQUEST);
            }
 
            status = ClassSendSrbAsynchronous(DeviceObject,
                                              srb,
                                              Irp,
                                              NULL,
                                              0,
                                              FALSE);
 
            break;
        }
 
        case IOCTL_STORAGE_PERSISTENT_RESERVE_IN:
        case IOCTL_STORAGE_PERSISTENT_RESERVE_OUT: {
 
            if (!commonExtension->IsFdo) {
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                goto SetStatusAndReturn;
            }
 
            //
            // Process Persistent Reserve
            //
 
            status = ClasspPersistentReserve(DeviceObject, Irp, srb);
 
            break;
 
        }
 
        case IOCTL_STORAGE_EJECT_MEDIA:
        case IOCTL_STORAGE_LOAD_MEDIA:
        case IOCTL_STORAGE_LOAD_MEDIA2:{
 
            //
            // Eject media.
            //
 
            PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = NULL;
 
            if (!commonExtension->IsFdo) {
 
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
 
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                goto SetStatusAndReturn;
            } else {
                fdoExtension = DeviceObject->DeviceExtension;
            }
 
            if (commonExtension->PagingPathCount != 0) {
 
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,  "ClassDeviceControl: call to eject paging device - "
                                                                    "failure\n"));
 
                status = STATUS_FILES_OPEN;
                Irp->IoStatus.Status = status;
 
                Irp->IoStatus.Information = 0;
 
                FREE_POOL(srb);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                goto SetStatusAndReturn;
            }
 
            //
            // Synchronize with ejection control and ejection cleanup code as
            // well as other eject/load requests.
            //
 
            KeEnterCriticalRegion();
            (VOID)KeWaitForSingleObject(&(fdoExtension->EjectSynchronizationEvent),
                                        UserRequest,
                                        KernelMode,
                                        FALSE,
                                        NULL);
 
            if (fdoExtension->ProtectedLockCount != 0) {
 
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,  "ClassDeviceControl: call to eject protected locked "
                                                                    "device - failure\n"));
 
                status = STATUS_DEVICE_BUSY;
                Irp->IoStatus.Status = status;
                Irp->IoStatus.Information = 0;
 
                FREE_POOL(srb);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
                KeSetEvent(&fdoExtension->EjectSynchronizationEvent,
                           IO_NO_INCREMENT,
                           FALSE);
                KeLeaveCriticalRegion();
 
                goto SetStatusAndReturn;
            }
 
            SrbSetCdbLength(srb, 6);
            cdb = SrbGetCdb(srb);
 
            cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
            cdb->START_STOP.LoadEject = 1;
 
            if (modifiedIoControlCode == IOCTL_STORAGE_EJECT_MEDIA) {
                cdb->START_STOP.Start = 0;
            } else {
                cdb->START_STOP.Start = 1;
            }
 
            //
            // Set timeout value.
            //
 
            SrbSetTimeOutValue(srb, fdoExtension->TimeOutValue);
            status = ClassSendSrbAsynchronous(DeviceObject,
                                                  srb,
                                                  Irp,
                                                  NULL,
                                                  0,
                                                  FALSE);
 
            KeSetEvent(&fdoExtension->EjectSynchronizationEvent, IO_NO_INCREMENT, FALSE);
            KeLeaveCriticalRegion();
 
            break;
        }
 
        case IOCTL_STORAGE_FIND_NEW_DEVICES: {
 
            FREE_POOL(srb);
 
            if (commonExtension->IsFdo) {
 
                IoInvalidateDeviceRelations(
                    ((PFUNCTIONAL_DEVICE_EXTENSION) commonExtension)->LowerPdo,
                    BusRelations);
 
                status = STATUS_SUCCESS;
                Irp->IoStatus.Status = status;
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
            }
            else {
 
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
            }
            break;
        }
 
        case IOCTL_STORAGE_GET_DEVICE_NUMBER: {
 
            FREE_POOL(srb);
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength >=
                sizeof(STORAGE_DEVICE_NUMBER)) {
 
                PSTORAGE_DEVICE_NUMBER deviceNumber =
                    Irp->AssociatedIrp.SystemBuffer;
                PFUNCTIONAL_DEVICE_EXTENSION fdoExtension =
                    commonExtension->PartitionZeroExtension;
 
                deviceNumber->DeviceType = fdoExtension->CommonExtension.DeviceObject->DeviceType;
                deviceNumber->DeviceNumber = fdoExtension->DeviceNumber;
                deviceNumber->PartitionNumber = commonExtension->PartitionNumber;
 
                status = STATUS_SUCCESS;
                Irp->IoStatus.Information = sizeof(STORAGE_DEVICE_NUMBER);
 
            } else {
                status = STATUS_BUFFER_TOO_SMALL;
                Irp->IoStatus.Information = sizeof(STORAGE_DEVICE_NUMBER);
            }
 
            Irp->IoStatus.Status = status;
            ClassReleaseRemoveLock(DeviceObject, Irp);
            ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
            break;
        }
 
 
        case IOCTL_STORAGE_READ_CAPACITY: {
 
            FREE_POOL(srb);
 
            if (irpStack->Parameters.DeviceIoControl.OutputBufferLength <
                sizeof(STORAGE_READ_CAPACITY)) {
 
                //
                // Indicate unsuccessful status and no data transferred.
                //
 
                Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
                Irp->IoStatus.Information = sizeof(STORAGE_READ_CAPACITY);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            if (!commonExtension->IsFdo) {
 
 
                //
                // Just forward this down and return
                //
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
            }
            else {
 
                PFUNCTIONAL_DEVICE_EXTENSION fdoExt = DeviceObject->DeviceExtension;
                PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
                PSTORAGE_READ_CAPACITY readCapacity = Irp->AssociatedIrp.SystemBuffer;
                LARGE_INTEGER diskLength;
 
                status = ClassReadDriveCapacity(DeviceObject);
                if (NT_SUCCESS(status) && fdoData->IsCachedDriveCapDataValid) {
 
                    readCapacity->Version = sizeof(STORAGE_READ_CAPACITY);
                    readCapacity->Size = sizeof(STORAGE_READ_CAPACITY);
 
                    REVERSE_BYTES(&readCapacity->BlockLength,
                                        &fdoData->LastKnownDriveCapacityData.BytesPerBlock);
                    REVERSE_BYTES_QUAD(&readCapacity->NumberOfBlocks,
                                       &fdoData->LastKnownDriveCapacityData.LogicalBlockAddress);
                    readCapacity->NumberOfBlocks.QuadPart++;
 
                    readCapacity->DiskLength = fdoExt->CommonExtension.PartitionLength;
 
                    //
                    // Make sure the lengths are equal.
                    // Remove this after testing.
                    //
                    diskLength.QuadPart = readCapacity->NumberOfBlocks.QuadPart *
                                            readCapacity->BlockLength;
 
                    Irp->IoStatus.Status = STATUS_SUCCESS;
                    Irp->IoStatus.Information = sizeof(STORAGE_READ_CAPACITY);
 
                } else {
                    //
                    // Read capacity request failed.
                    //
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,  "ClassDeviceControl: ClassReadDriveCapacity failed: 0x%X IsCachedDriveCapDataValid: %d\n",
                                   status, fdoData->IsCachedDriveCapDataValid));
                    Irp->IoStatus.Status = status;
                    Irp->IoStatus.Information = 0;
                }
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
            }
 
            break;
        }
 
        case IOCTL_STORAGE_QUERY_PROPERTY: {
 
            PSTORAGE_PROPERTY_QUERY query = Irp->AssociatedIrp.SystemBuffer;
 
            if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_PROPERTY_QUERY)) {
 
                status = STATUS_INFO_LENGTH_MISMATCH;
                Irp->IoStatus.Status = status;
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                FREE_POOL(srb);
                break;
            }
 
            if (!commonExtension->IsFdo) {
 
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                FREE_POOL(srb);
                break;
            }
 
            //
            // Determine PropertyId type and either call appropriate routine
            // or pass request to lower drivers.
            //
 
            switch ( query->PropertyId ) {
 
                case StorageDeviceUniqueIdProperty: {
 
                    status = ClasspDuidQueryProperty(DeviceObject, Irp);
                    break;
                }
 
                case StorageDeviceWriteCacheProperty: {
 
                    status = ClasspWriteCacheProperty(DeviceObject, Irp, srb);
                    break;
                }
 
                // these propertyId has been implemented in some port driver and filter drivers.
                // to keep the backwards compatibility, classpnp will send the request down if it's supported by lower layer.
                // otherwise, classpnp sends SCSI command and then interprets the result.
                case StorageAccessAlignmentProperty: {
 
                    status = ClasspAccessAlignmentProperty(DeviceObject, Irp, srb);
                    break;
                }
 
                case StorageDeviceSeekPenaltyProperty: {
 
                    status = ClasspDeviceSeekPenaltyProperty(DeviceObject, Irp, srb);
                    break;
                }
 
                case StorageDeviceTrimProperty: {
 
                    status = ClasspDeviceTrimProperty(DeviceObject, Irp, srb);
                    break;
                }
 
                case StorageDeviceLBProvisioningProperty: {
 
                    status = ClasspDeviceLBProvisioningProperty(DeviceObject, Irp, srb);
                    break;
                }
 
                case StorageDeviceCopyOffloadProperty: {
 
                    status = ClasspDeviceCopyOffloadProperty(DeviceObject, Irp, srb);
                    break;
                }
 
                case StorageDeviceMediumProductType: {
 
                    status = ClasspDeviceMediaTypeProperty(DeviceObject, Irp, srb);
                    break;
                }
 
                default: {
 
                    //
                    // Copy the Irp stack parameters to the next stack location.
                    //
 
                    IoCopyCurrentIrpStackLocationToNext(Irp);
 
                    ClassReleaseRemoveLock(DeviceObject, Irp);
                    status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                    break;
                }
            }   // end switch
 
            FREE_POOL(srb);
            break;
        }
 
        case IOCTL_STORAGE_CHECK_PRIORITY_HINT_SUPPORT: {
 
            FREE_POOL(srb);
 
            if (!commonExtension->IsFdo) {
 
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                break;
            }
 
            //
            // Process priority hit request
            //
 
            status = ClasspPriorityHint(DeviceObject, Irp);
            break;
        }
 
        case IOCTL_STORAGE_MANAGE_DATA_SET_ATTRIBUTES: {
 
            PDEVICE_MANAGE_DATA_SET_ATTRIBUTES dsmAttributes = Irp->AssociatedIrp.SystemBuffer;
 
            if (irpStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES)) {
 
                status = STATUS_INVALID_PARAMETER;
                Irp->IoStatus.Status = status;
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                FREE_POOL(srb);
                break;
            }
 
            if (irpStack->Parameters.DeviceIoControl.InputBufferLength <
                (sizeof(DEVICE_MANAGE_DATA_SET_ATTRIBUTES) + dsmAttributes->ParameterBlockLength + dsmAttributes->DataSetRangesLength)) {
 
                status = STATUS_INVALID_PARAMETER;
                Irp->IoStatus.Status = status;
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                FREE_POOL(srb);
                break;
            }
 
            if (!commonExtension->IsFdo) {
 
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                FREE_POOL(srb);
                break;
            }
 
            switch(dsmAttributes->Action) {
 
                // only process Trim action in class layer if possible.
                case DeviceDsmAction_Trim: {
                    status = ClasspDeviceTrimProcess(DeviceObject, Irp, &activityId, srb);
                    break;
                }
 
                case DeviceDsmAction_OffloadRead: {
                    status = ClassDeviceProcessOffloadRead(DeviceObject, Irp, srb);
                    break;
                }
 
                case DeviceDsmAction_OffloadWrite: {
                    status = ClassDeviceProcessOffloadWrite(DeviceObject, Irp, srb);
                    break;
                }
 
                case DeviceDsmAction_Allocation: {
                    status = ClasspDeviceGetLBAStatus(DeviceObject, Irp, srb);
                    break;
                }
 
 
                default: {
 
 
                    //
                    // Copy the Irp stack parameters to the next stack location.
                    //
 
                    IoCopyCurrentIrpStackLocationToNext(Irp);
 
                    ClassReleaseRemoveLock(DeviceObject, Irp);
                    status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                    break;
                }
            }   // end switch
 
            FREE_POOL(srb);
            break;
        }
 
        case IOCTL_STORAGE_GET_LB_PROVISIONING_MAP_RESOURCES: {
 
            if (commonExtension->IsFdo) {
 
                status = ClassDeviceGetLBProvisioningResources(DeviceObject, Irp, srb);
 
            } else {
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
            }
 
            FREE_POOL(srb);
 
            break;
        }
 
        case IOCTL_STORAGE_EVENT_NOTIFICATION: {
 
            FREE_POOL(srb);
 
            status = ClasspStorageEventNotification(DeviceObject, Irp);
            break;
        }
 
#if (NTDDI_VERSION >= NTDDI_WINTRHESHOLD)
        case IOCTL_STORAGE_FIRMWARE_GET_INFO: {
            FREE_POOL(srb);
 
            status = ClassDeviceHwFirmwareGetInfoProcess(DeviceObject, Irp);
            break;
        }
 
        case IOCTL_STORAGE_FIRMWARE_DOWNLOAD: {
            if (!commonExtension->IsFdo) {
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                goto SetStatusAndReturn;
            }
 
            status = ClassDeviceHwFirmwareDownloadProcess(DeviceObject, Irp, srb);
            break;
        }
 
        case IOCTL_STORAGE_FIRMWARE_ACTIVATE: {
            if (!commonExtension->IsFdo) {
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
 
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                goto SetStatusAndReturn;
            }
 
            status = ClassDeviceHwFirmwareActivateProcess(DeviceObject, Irp, srb);
            break;
        }
#endif
 
 
        default: {
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL, "IoDeviceControl: Unsupported device IOCTL %x for %p\n",
                        controlCode, DeviceObject));
 
 
            //
            // Pass the device control to the next driver.
            //
 
            FREE_POOL(srb);
 
            //
            // Copy the Irp stack parameters to the next stack location.
            //
 
            IoCopyCurrentIrpStackLocationToNext(Irp);
 
            ClassReleaseRemoveLock(DeviceObject, Irp);
            status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
            break;
        }
 
    } // end switch( ...
 
SetStatusAndReturn:
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "< ioctl %xh (%s): status %xh.", modifiedIoControlCode, DBGGETIOCTLSTR(modifiedIoControlCode), status));
 
    return status;
} // end ClassDeviceControl()

ClassDeviceControlDispatch()

NTSTATUS NTAPI ClassDeviceControlDispatch	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 7258 of file class.c.

{
 
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    ULONG isRemoved;
 
    isRemoved = ClassAcquireRemoveLock(DeviceObject, Irp);
    _Analysis_assume_(isRemoved);
    if(isRemoved) {
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
 
        Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
        return STATUS_DEVICE_DOES_NOT_EXIST;
    }
 
    //
    // Call the class specific driver DeviceControl routine.
    // If it doesn't handle it, it will call back into ClassDeviceControl.
    //
 
    NT_ASSERT(commonExtension->DevInfo->ClassDeviceControl);
 
    return commonExtension->DevInfo->ClassDeviceControl(DeviceObject,Irp);
} // end ClassDeviceControlDispatch()

Referenced by ClassInitializeDispatchTables().

ClassDispatchPnp()

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

Definition at line 894 of file class.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    BOOLEAN isFdo = commonExtension->IsFdo;
 
    PCLASS_DRIVER_EXTENSION driverExtension;
    PCLASS_INIT_DATA initData;
    PCLASS_DEV_INFO devInfo;
 
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
 
    NTSTATUS status = Irp->IoStatus.Status;
    BOOLEAN completeRequest = TRUE;
    BOOLEAN lockReleased = FALSE;
 
 
    PAGED_CODE();
 
    //
    // Extract all the useful information out of the driver object
    // extension
    //
 
#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);
 
    if (driverExtension){
 
        initData = &(driverExtension->InitData);
 
        if(isFdo) {
            devInfo = &(initData->FdoData);
        } else {
            devInfo = &(initData->PdoData);
        }
 
        ClassAcquireRemoveLock(DeviceObject, Irp);
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): minor code %#x for %s %p\n",
                       DeviceObject, Irp,
                       irpStack->MinorFunction,
                       isFdo ? "fdo" : "pdo",
                       DeviceObject));
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): previous %#x, current %#x\n",
                       DeviceObject, Irp,
                       commonExtension->PreviousState,
                       commonExtension->CurrentState));
 
 
        switch(irpStack->MinorFunction) {
 
            case IRP_MN_START_DEVICE: {
 
                //
                // if this is sent to the FDO we should forward it down the
                // attachment chain before we start the FDO.
                //
 
                if (isFdo) {
                    status = ClassForwardIrpSynchronous(commonExtension, Irp);
                }
                else {
                    status = STATUS_SUCCESS;
                }
 
                if (NT_SUCCESS(status)){
                    status = Irp->IoStatus.Status = ClassPnpStartDevice(DeviceObject);
                }
 
                break;
            }
 
 
            case IRP_MN_QUERY_DEVICE_RELATIONS: {
 
                DEVICE_RELATION_TYPE type =
                    irpStack->Parameters.QueryDeviceRelations.Type;
 
                PDEVICE_RELATIONS deviceRelations = NULL;
 
 
                if(!isFdo) {
 
                    if(type == TargetDeviceRelation) {
 
                        //
                        // Device relations has one entry built in to it's size.
                        //
 
                        status = STATUS_INSUFFICIENT_RESOURCES;
 
                        deviceRelations = ExAllocatePoolWithTag(PagedPool,
                                                         sizeof(DEVICE_RELATIONS),
                                                         '2CcS');
 
                        if(deviceRelations != NULL) {
 
                            RtlZeroMemory(deviceRelations,
                                          sizeof(DEVICE_RELATIONS));
 
                            Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;
 
                            deviceRelations->Count = 1;
                            deviceRelations->Objects[0] = DeviceObject;
                            ObReferenceObject(deviceRelations->Objects[0]);
 
                            status = STATUS_SUCCESS;
                        }
 
                    } else {
                        //
                        // PDO's just complete enumeration requests without altering
                        // the status.
                        //
 
                        status = Irp->IoStatus.Status;
                    }
 
                    break;
 
                } else if (type == BusRelations) {
 
                    NT_ASSERT(commonExtension->IsInitialized);
 
                    //
                    // Make sure we support enumeration
                    //
 
                    if(initData->ClassEnumerateDevice == NULL) {
 
                        //
                        // Just send the request down to the lower driver.  Perhaps
                        // It can enumerate children.
                        //
 
                    } else {
 
                        //
                        // Re-enumerate the device
                        //
 
                        status = ClassPnpQueryFdoRelations(DeviceObject, Irp);
 
                        if(!NT_SUCCESS(status)) {
                            completeRequest = TRUE;
                            break;
                        }
                    }
                }
 
 
                IoCopyCurrentIrpStackLocationToNext(Irp);
                ClassReleaseRemoveLock(DeviceObject, Irp);
                status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                completeRequest = FALSE;
 
                break;
            }
 
            case IRP_MN_QUERY_ID: {
 
                BUS_QUERY_ID_TYPE idType = irpStack->Parameters.QueryId.IdType;
                UNICODE_STRING unicodeString;
 
 
                if(isFdo) {
 
 
                    //
                    // FDO's should just forward the query down to the lower
                    // device objects
                    //
 
                    IoCopyCurrentIrpStackLocationToNext(Irp);
                    ClassReleaseRemoveLock(DeviceObject, Irp);
 
                    status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                    completeRequest = FALSE;
                    break;
                }
 
                //
                // PDO's need to give an answer - this is easy for now
                //
 
                RtlInitUnicodeString(&unicodeString, NULL);
 
                status = ClassGetPdoId(DeviceObject,
                                       idType,
                                       &unicodeString);
 
                if(status == STATUS_NOT_IMPLEMENTED) {
                    //
                    // The driver doesn't implement this ID (whatever it is).
                    // Use the status out of the IRP so that we don't mangle a
                    // response from someone else.
                    //
 
                    status = Irp->IoStatus.Status;
                } else if(NT_SUCCESS(status)) {
                    Irp->IoStatus.Information = (ULONG_PTR) unicodeString.Buffer;
                } else {
                    Irp->IoStatus.Information = (ULONG_PTR) NULL;
                }
 
                break;
            }
 
            case IRP_MN_QUERY_STOP_DEVICE:
            case IRP_MN_QUERY_REMOVE_DEVICE: {
 
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Processing QUERY_%s irp\n",
                            DeviceObject, Irp,
                            ((irpStack->MinorFunction == IRP_MN_QUERY_STOP_DEVICE) ?
                             "STOP" : "REMOVE")));
 
                //
                // If this device is in use for some reason (paging, etc...)
                // then we need to fail the request.
                //
 
                if(commonExtension->PagingPathCount != 0) {
 
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): device is in paging "
                                "path and cannot be removed\n",
                                DeviceObject, Irp));
                    status = STATUS_DEVICE_BUSY;
                    break;
                }
 
 
                //
                // Check with the class driver to see if the query operation
                // can succeed.
                //
 
                if(irpStack->MinorFunction == IRP_MN_QUERY_STOP_DEVICE) {
                    status = devInfo->ClassStopDevice(DeviceObject,
                                                      irpStack->MinorFunction);
                } else {
                    status = devInfo->ClassRemoveDevice(DeviceObject,
                                                        irpStack->MinorFunction);
                }
 
                if(NT_SUCCESS(status)) {
 
                    //
                    // ASSERT that we never get two queries in a row, as
                    // this will severly mess up the state machine
                    //
                    NT_ASSERT(commonExtension->CurrentState != irpStack->MinorFunction);
                    commonExtension->PreviousState = commonExtension->CurrentState;
                    commonExtension->CurrentState = irpStack->MinorFunction;
 
                    if(isFdo) {
                        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Forwarding QUERY_"
                                    "%s irp\n", DeviceObject, Irp,
                                    ((irpStack->MinorFunction == IRP_MN_QUERY_STOP_DEVICE) ?
                                     "STOP" : "REMOVE")));
                        status = ClassForwardIrpSynchronous(commonExtension, Irp);
                    }
                }
 
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Final status == %x\n",
                            DeviceObject, Irp, status));
 
                break;
            }
 
            case IRP_MN_CANCEL_STOP_DEVICE:
            case IRP_MN_CANCEL_REMOVE_DEVICE: {
 
 
                //
                // Check with the class driver to see if the query or cancel
                // operation can succeed.
                //
 
                if(irpStack->MinorFunction == IRP_MN_CANCEL_STOP_DEVICE) {
                    status = devInfo->ClassStopDevice(DeviceObject,
                                                      irpStack->MinorFunction);
                    NT_ASSERTMSG("ClassDispatchPnp !! CANCEL_STOP_DEVICE should never be failed\n", NT_SUCCESS(status));
                } else {
                    status = devInfo->ClassRemoveDevice(DeviceObject,
                                                        irpStack->MinorFunction);
                    NT_ASSERTMSG("ClassDispatchPnp !! CANCEL_REMOVE_DEVICE should never be failed\n", NT_SUCCESS(status));
                }
 
                Irp->IoStatus.Status = status;
 
                //
                // We got a CANCEL - roll back to the previous state only
                // if the current state is the respective QUERY state.
                //
 
                if(((irpStack->MinorFunction == IRP_MN_CANCEL_STOP_DEVICE) &&
                    (commonExtension->CurrentState == IRP_MN_QUERY_STOP_DEVICE)
                    ) ||
                   ((irpStack->MinorFunction == IRP_MN_CANCEL_REMOVE_DEVICE) &&
                    (commonExtension->CurrentState == IRP_MN_QUERY_REMOVE_DEVICE)
                    )
                   ) {
 
                    commonExtension->CurrentState =
                        commonExtension->PreviousState;
                    commonExtension->PreviousState = 0xff;
 
                }
 
 
                if(isFdo) {
 
 
                    IoCopyCurrentIrpStackLocationToNext(Irp);
                    ClassReleaseRemoveLock(DeviceObject, Irp);
                    status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                    completeRequest = FALSE;
                } else {
                    status = STATUS_SUCCESS;
                }
 
                break;
            }
 
            case IRP_MN_STOP_DEVICE: {
 
 
                //
                // These all mean nothing to the class driver currently.  The
                // port driver will handle all queueing when necessary.
                //
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): got stop request for %s\n",
                            DeviceObject, Irp,
                            (isFdo ? "fdo" : "pdo")
                            ));
 
                NT_ASSERT(commonExtension->PagingPathCount == 0);
 
                //
                // ISSUE-2000/02/03-peterwie
                // if we stop the timer here then it means no class driver can
                // do i/o in its ClassStopDevice routine.  This is because the
                // retry (among other things) is tied into the tick handler
                // and disabling retries could cause the class driver to deadlock.
                // Currently no class driver we're aware of issues i/o in its
                // Stop routine but this is a case we may want to defend ourself
                // against.
                //
 
                ClasspDisableTimer((PFUNCTIONAL_DEVICE_EXTENSION)commonExtension);
 
 
                status = devInfo->ClassStopDevice(DeviceObject, IRP_MN_STOP_DEVICE);
 
                NT_ASSERTMSG("ClassDispatchPnp !! STOP_DEVICE should never be failed\n", NT_SUCCESS(status));
 
                if(isFdo) {
                    status = ClassForwardIrpSynchronous(commonExtension, Irp);
                }
 
                if(NT_SUCCESS(status)) {
                    commonExtension->CurrentState = irpStack->MinorFunction;
                    commonExtension->PreviousState = 0xff;
                }
 
 
                break;
            }
 
            case IRP_MN_REMOVE_DEVICE:
            case IRP_MN_SURPRISE_REMOVAL: {
                UCHAR removeType = irpStack->MinorFunction;
 
                //
                // Log a sytem event when non-removable disks are surprise-removed.
                //
                if (isFdo &&
                    (removeType == IRP_MN_SURPRISE_REMOVAL)) {
 
                    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
                    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
                    BOOLEAN logSurpriseRemove = TRUE;
                    STORAGE_BUS_TYPE busType = fdoExtension->DeviceDescriptor->BusType;
 
                    //
                    // Don't log an event for VHDs
                    //
                    if (busType == BusTypeFileBackedVirtual) {
                        logSurpriseRemove = FALSE;
 
                    } else if (fdoData->HotplugInfo.MediaRemovable) {
                        logSurpriseRemove = FALSE;
 
                    } else if (fdoData->HotplugInfo.DeviceHotplug && ( busType == BusTypeUsb || busType == BusType1394)) {
 
                        /*
                        This device is reported as DeviceHotplug but since the busType is Usb or 1394, don't log an event
                        Note that some storage arrays may report DeviceHotplug and we would like to log an event in those cases
                        */
 
                        logSurpriseRemove = FALSE;
                    }
 
                    if (logSurpriseRemove) {
 
                        ClasspLogSystemEventWithDeviceNumber(DeviceObject, IO_WARNING_DISK_SURPRISE_REMOVED);
                    }
 
                }
 
                if (commonExtension->PagingPathCount != 0) {
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP, "ClassDispatchPnp (%p,%p): paging device is getting removed!", DeviceObject, Irp));
                }
 
                //
                // Release the lock for this IRP before calling in.
                //
                ClassReleaseRemoveLock(DeviceObject, Irp);
                lockReleased = TRUE;
 
                /*
                 *  Set IsRemoved before propagating the REMOVE down the stack.
                 *  This keeps class-initiated I/O (e.g. the MCN irp) from getting sent
                 *  after we propagate the remove.
                 */
                commonExtension->IsRemoved = REMOVE_PENDING;
 
                /*
                 *  If a timer was started on the device, stop it.
                 */
                 ClasspDisableTimer((PFUNCTIONAL_DEVICE_EXTENSION)commonExtension);
 
                /*
                 *  "Fire-and-forget" the remove irp to the lower stack.
                 *  Don't touch the irp (or the irp stack!) after this.
                 */
                if (isFdo) {
 
 
                    IoCopyCurrentIrpStackLocationToNext(Irp);
                    status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
                    NT_ASSERT(NT_SUCCESS(status));
                    completeRequest = FALSE;
                }
                else {
                    status = STATUS_SUCCESS;
                }
 
                /*
                 *  Do our own cleanup and call the class driver's remove
                 *  cleanup routine.
                 *  For IRP_MN_REMOVE_DEVICE, this also deletes our device object,
                 *  so don't touch the extension after this.
                 */
                commonExtension->PreviousState = commonExtension->CurrentState;
                commonExtension->CurrentState = removeType;
                ClassRemoveDevice(DeviceObject, removeType);
 
                break;
            }
 
            case IRP_MN_DEVICE_USAGE_NOTIFICATION: {
 
                DEVICE_USAGE_NOTIFICATION_TYPE type = irpStack->Parameters.UsageNotification.Type;
                BOOLEAN setPagable;
 
 
                switch(type) {
 
                    case DeviceUsageTypePaging: {
 
                        if ((irpStack->Parameters.UsageNotification.InPath) &&
                            (commonExtension->CurrentState != IRP_MN_START_DEVICE)) {
 
                            //
                            // Device isn't started.  Don't allow adding a
                            // paging file, but allow a removal of one.
                            //
 
                            status = STATUS_DEVICE_NOT_READY;
                            break;
                        }
 
                        NT_ASSERT(commonExtension->IsInitialized);
 
                        /*
                         *  Ensure that this user thread is not suspended while we are holding the PathCountEvent.
                         */
                        KeEnterCriticalRegion();
 
                        (VOID)KeWaitForSingleObject(&commonExtension->PathCountEvent,
                                                    Executive, KernelMode,
                                                    FALSE, NULL);
                        status = STATUS_SUCCESS;
 
                        //
                        // If the volume is removable we should try to lock it in
                        // place or unlock it once per paging path count
                        //
 
                        if (commonExtension->IsFdo){
                            status = ClasspEjectionControl(
                                            DeviceObject,
                                            Irp,
                                            InternalMediaLock,
                                            (BOOLEAN)irpStack->Parameters.UsageNotification.InPath);
                        }
 
                        if (!NT_SUCCESS(status)){
                            KeSetEvent(&commonExtension->PathCountEvent, IO_NO_INCREMENT, FALSE);
                            KeLeaveCriticalRegion();
                            break;
                        }
 
                        //
                        // if removing last paging device, need to set DO_POWER_PAGABLE
                        // bit here, and possible re-set it below on failure.
                        //
 
                        setPagable = FALSE;
 
                        if ((!irpStack->Parameters.UsageNotification.InPath) &&
                            (commonExtension->PagingPathCount == 1)) {
 
                            //
                            // removing last paging file
                            // must have DO_POWER_PAGABLE bits set, but only
                            // if none set the DO_POWER_INRUSH bit and no other special files
                            //
 
                            if (TEST_FLAG(DeviceObject->Flags, DO_POWER_INRUSH)) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Last "
                                            "paging file removed, but "
                                            "DO_POWER_INRUSH was set, so NOT "
                                            "setting DO_POWER_PAGABLE\n",
                                            DeviceObject, Irp));
                            } else if ((commonExtension->HibernationPathCount == 0) &&
                                       (commonExtension->DumpPathCount == 0)) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Last "
                                            "paging file removed, "
                                            "setting DO_POWER_PAGABLE\n",
                                            DeviceObject, Irp));
                                SET_FLAG(DeviceObject->Flags, DO_POWER_PAGABLE);
                                setPagable = TRUE;
                            }
 
                        }
 
                        //
                        // forward the irp before finishing handling the
                        // special cases
                        //
 
                        status = ClassForwardIrpSynchronous(commonExtension, Irp);
 
                        //
                        // now deal with the failure and success cases.
                        // note that we are not allowed to fail the irp
                        // once it is sent to the lower drivers.
                        //
 
                        if (NT_SUCCESS(status)) {
 
                            IoAdjustPagingPathCount(
                                (volatile LONG *)&commonExtension->PagingPathCount,
                                irpStack->Parameters.UsageNotification.InPath);
 
                            if (irpStack->Parameters.UsageNotification.InPath) {
                                if (commonExtension->PagingPathCount == 1) {
                                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): "
                                                "Clearing PAGABLE bit\n",
                                                DeviceObject, Irp));
                                    CLEAR_FLAG(DeviceObject->Flags, DO_POWER_PAGABLE);
 
 
                                }
 
                            }
 
                        } else {
 
                            //
                            // cleanup the changes done above
                            //
 
                            if (setPagable == TRUE) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Unsetting "
                                            "PAGABLE bit due to irp failure\n",
                                            DeviceObject, Irp));
                                CLEAR_FLAG(DeviceObject->Flags, DO_POWER_PAGABLE);
                                setPagable = FALSE;
                            }
 
                            //
                            // relock or unlock the media if needed.
                            //
 
                            if (commonExtension->IsFdo) {
 
                                ClasspEjectionControl(
                                        DeviceObject,
                                        Irp,
                                        InternalMediaLock,
                                        (BOOLEAN)!irpStack->Parameters.UsageNotification.InPath);
                            }
                        }
 
                        //
                        // set the event so the next one can occur.
                        //
 
                        KeSetEvent(&commonExtension->PathCountEvent,
                                   IO_NO_INCREMENT, FALSE);
                        KeLeaveCriticalRegion();
                        break;
                    }
 
                    case DeviceUsageTypeHibernation: {
 
                        //
                        // if removing last hiber device, need to set DO_POWER_PAGABLE
                        // bit here, and possible re-set it below on failure.
                        //
 
                        setPagable = FALSE;
 
                        if ((!irpStack->Parameters.UsageNotification.InPath) &&
                            (commonExtension->HibernationPathCount == 1)) {
 
                            //
                            // removing last hiber file
                            // must have DO_POWER_PAGABLE bits set, but only
                            // if none set the DO_POWER_INRUSH bit and no other special files
                            //
 
                            if (TEST_FLAG(DeviceObject->Flags, DO_POWER_INRUSH)) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Last "
                                            "hiber file removed, but "
                                            "DO_POWER_INRUSH was set, so NOT "
                                            "setting DO_POWER_PAGABLE\n",
                                            DeviceObject, Irp));
                            } else if ((commonExtension->PagingPathCount == 0) &&
                                       (commonExtension->DumpPathCount == 0)) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Last "
                                            "hiber file removed, "
                                            "setting DO_POWER_PAGABLE\n",
                                            DeviceObject, Irp));
                                SET_FLAG(DeviceObject->Flags, DO_POWER_PAGABLE);
                                setPagable = TRUE;
                            }
 
                        }
 
                        status = ClassForwardIrpSynchronous(commonExtension, Irp);
                        if (!NT_SUCCESS(status)) {
 
                            if (setPagable == TRUE) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Unsetting "
                                            "PAGABLE bit due to irp failure\n",
                                            DeviceObject, Irp));
                                CLEAR_FLAG(DeviceObject->Flags, DO_POWER_PAGABLE);
                                setPagable = FALSE;
                            }
 
                        } else {
 
                            IoAdjustPagingPathCount(
                                (volatile LONG *)&commonExtension->HibernationPathCount,
                                irpStack->Parameters.UsageNotification.InPath
                                );
 
                            if ((irpStack->Parameters.UsageNotification.InPath) &&
                                (commonExtension->HibernationPathCount == 1)) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): "
                                            "Clearing PAGABLE bit\n",
                                            DeviceObject, Irp));
                                CLEAR_FLAG(DeviceObject->Flags, DO_POWER_PAGABLE);
                            }
                        }
 
                        break;
                    }
 
                    case DeviceUsageTypeDumpFile: {
 
                        //
                        // if removing last dump device, need to set DO_POWER_PAGABLE
                        // bit here, and possible re-set it below on failure.
                        //
 
                        setPagable = FALSE;
 
                        if ((!irpStack->Parameters.UsageNotification.InPath) &&
                            (commonExtension->DumpPathCount == 1)) {
 
                            //
                            // removing last dump file
                            // must have DO_POWER_PAGABLE bits set, but only
                            // if none set the DO_POWER_INRUSH bit and no other special files
                            //
 
                            if (TEST_FLAG(DeviceObject->Flags, DO_POWER_INRUSH)) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Last "
                                            "dump file removed, but "
                                            "DO_POWER_INRUSH was set, so NOT "
                                            "setting DO_POWER_PAGABLE\n",
                                            DeviceObject, Irp));
                            } else if ((commonExtension->PagingPathCount == 0) &&
                                       (commonExtension->HibernationPathCount == 0)) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Last "
                                            "dump file removed, "
                                            "setting DO_POWER_PAGABLE\n",
                                            DeviceObject, Irp));
                                SET_FLAG(DeviceObject->Flags, DO_POWER_PAGABLE);
                                setPagable = TRUE;
                            }
 
                        }
 
                        status = ClassForwardIrpSynchronous(commonExtension, Irp);
                        if (!NT_SUCCESS(status)) {
 
                            if (setPagable == TRUE) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): Unsetting "
                                            "PAGABLE bit due to irp failure\n",
                                            DeviceObject, Irp));
                                CLEAR_FLAG(DeviceObject->Flags, DO_POWER_PAGABLE);
                                setPagable = FALSE;
                            }
 
                        } else {
 
                            IoAdjustPagingPathCount(
                                (volatile LONG *)&commonExtension->DumpPathCount,
                                irpStack->Parameters.UsageNotification.InPath
                                );
 
                            if ((irpStack->Parameters.UsageNotification.InPath) &&
                                (commonExtension->DumpPathCount == 1)) {
                                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): "
                                            "Clearing PAGABLE bit\n",
                                            DeviceObject, Irp));
                                CLEAR_FLAG(DeviceObject->Flags, DO_POWER_PAGABLE);
                            }
                        }
 
                        break;
                    }
 
                    case DeviceUsageTypeBoot: {
 
                        if (isFdo) {
                            PCLASS_PRIVATE_FDO_DATA fdoData;
 
                            fdoData = ((PFUNCTIONAL_DEVICE_EXTENSION)(DeviceObject->DeviceExtension))->PrivateFdoData;
 
 
                            //
                            // If boot disk has removal policy as RemovalPolicyExpectSurpriseRemoval (e.g. disk is hotplug-able),
                            // change the removal policy to RemovalPolicyExpectOrderlyRemoval.
                            // This will cause the write cache of disk to be enabled on subsequent start Fdo (next boot).
                            //
                            if ((fdoData != NULL) &&
                                fdoData->HotplugInfo.DeviceHotplug) {
 
                                fdoData->HotplugInfo.DeviceHotplug = FALSE;
                                fdoData->HotplugInfo.MediaRemovable = FALSE;
 
                                ClassSetDeviceParameter((PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension,
                                                        CLASSP_REG_SUBKEY_NAME,
                                                        CLASSP_REG_REMOVAL_POLICY_VALUE_NAME,
                                                        RemovalPolicyExpectOrderlyRemoval);
                            }
                        }
 
                        status = ClassForwardIrpSynchronous(commonExtension, Irp);
                        break;
                    }
 
                    default: {
                        status = STATUS_INVALID_PARAMETER;
                        break;
                    }
                }
                break;
            }
 
            case IRP_MN_QUERY_CAPABILITIES: {
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "ClassDispatchPnp (%p,%p): QueryCapabilities\n",
                            DeviceObject, Irp));
 
                if(!isFdo) {
 
                    status = ClassQueryPnpCapabilities(
                                DeviceObject,
                                irpStack->Parameters.DeviceCapabilities.Capabilities
                                );
 
                    break;
 
                } else {
 
                    PDEVICE_CAPABILITIES deviceCapabilities;
                    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
                    PCLASS_PRIVATE_FDO_DATA fdoData;
 
                    fdoExtension = DeviceObject->DeviceExtension;
                    fdoData = fdoExtension->PrivateFdoData;
                    deviceCapabilities =
                        irpStack->Parameters.DeviceCapabilities.Capabilities;
 
                    //
                    // forward the irp before handling the special cases
                    //
 
                    status = ClassForwardIrpSynchronous(commonExtension, Irp);
                    if (!NT_SUCCESS(status)) {
                        break;
                    }
 
                    //
                    // we generally want to remove the device from the hotplug
                    // applet, which requires the SR-OK bit to be set.
                    // only when the user specifies that they are capable of
                    // safely removing things do we want to clear this bit
                    // (saved in WriteCacheEnableOverride)
                    //
                    // setting of this bit is done either above, or by the
                    // lower driver.
                    //
                    // note: may not be started, so check we have FDO data first.
                    //
 
                    if (fdoData &&
                        fdoData->HotplugInfo.WriteCacheEnableOverride) {
                        if (deviceCapabilities->SurpriseRemovalOK) {
                            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,  "Classpnp: Clearing SR-OK bit in "
                                        "device capabilities due to hotplug "
                                        "device or media\n"));
                        }
                        deviceCapabilities->SurpriseRemovalOK = FALSE;
                    }
                    break;
 
                } // end QUERY_CAPABILITIES for FDOs
 
                break;
 
 
            } // end QUERY_CAPABILITIES
 
            default: {
 
                if (isFdo){
 
 
                    IoCopyCurrentIrpStackLocationToNext(Irp);
 
                    ClassReleaseRemoveLock(DeviceObject, Irp);
                    status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
 
                    completeRequest = FALSE;
                }
 
                break;
            }
        }
    }
    else {
        NT_ASSERT(driverExtension);
        status = STATUS_INTERNAL_ERROR;
    }
 
    if (completeRequest){
        Irp->IoStatus.Status = status;
 
        if (!lockReleased){
            ClassReleaseRemoveLock(DeviceObject, Irp);
        }
 
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP, "ClassDispatchPnp (%p,%p): leaving with previous %#x, current %#x.", DeviceObject, Irp, commonExtension->PreviousState, commonExtension->CurrentState));
    }
    else {
        /*
         *  The irp is already completed so don't touch it.
         *  This may be a remove so don't touch the device extension.
         */
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP, "ClassDispatchPnp (%p,%p): leaving.", DeviceObject, Irp));
    }
 
    return status;
} // end ClassDispatchPnp()

Referenced by ClassInitializeDispatchTables().

ClassFindModePage()

PVOID NTAPI ClassFindModePage	(	_In_reads_bytes_(Length) PCHAR	ModeSenseBuffer,
		_In_ ULONG	Length,
		_In_ UCHAR	PageMode,
		_In_ BOOLEAN	Use6Byte
	)

Definition at line 6798 of file class.c.

{
    PUCHAR limit;
    ULONG  parameterHeaderLength;
    PVOID result = NULL;
 
    limit = (PUCHAR)ModeSenseBuffer + Length;
    parameterHeaderLength = (Use6Byte) ? sizeof(MODE_PARAMETER_HEADER) : sizeof(MODE_PARAMETER_HEADER10);
 
    if (Length >= parameterHeaderLength) {
 
        PMODE_PARAMETER_HEADER10 modeParam10;
        ULONG blockDescriptorLength;
 
        /*
         *  Skip the mode select header and block descriptors.
         */
        if (Use6Byte){
            blockDescriptorLength = ((PMODE_PARAMETER_HEADER) ModeSenseBuffer)->BlockDescriptorLength;
        }
        else {
            modeParam10 = (PMODE_PARAMETER_HEADER10) ModeSenseBuffer;
            blockDescriptorLength = modeParam10->BlockDescriptorLength[1];
        }
 
        ModeSenseBuffer += parameterHeaderLength + blockDescriptorLength;
 
        //
        // ModeSenseBuffer now points at pages.  Walk the pages looking for the
        // requested page until the limit is reached.
        //
 
        while (ModeSenseBuffer +
               RTL_SIZEOF_THROUGH_FIELD(MODE_DISCONNECT_PAGE, PageLength) < (PCHAR)limit) {
 
            if (((PMODE_DISCONNECT_PAGE) ModeSenseBuffer)->PageCode == PageMode) {
 
                /*
                 * found the mode page.  make sure it's safe to touch it all
                 * before returning the pointer to caller
                 */
 
                if (ModeSenseBuffer + ((PMODE_DISCONNECT_PAGE)ModeSenseBuffer)->PageLength > (PCHAR)limit) {
                    /*
                     *  Return NULL since the page is not safe to access in full
                     */
                    result = NULL;
                }
                else {
                    result = ModeSenseBuffer;
                }
                break;
            }
 
            //
            // Advance to the next page which is 4-byte-aligned offset after this page.
            //
            ModeSenseBuffer +=
                ((PMODE_DISCONNECT_PAGE) ModeSenseBuffer)->PageLength +
                RTL_SIZEOF_THROUGH_FIELD(MODE_DISCONNECT_PAGE, PageLength);
 
        }
    }
 
    return result;
} // end ClassFindModePage()

Referenced by ClasspWriteCacheProperty(), ClasspZeroQERR(), DetermineDriveType(), DiskGetCacheInformation(), DiskGetInfoExceptionInformation(), DiskGetModePage(), DiskInfoExceptionComplete(), DiskSetCacheInformation(), and FormatMedia().

ClassForwardIrpSynchronous()

NTSTATUS NTAPI ClassForwardIrpSynchronous	(	_In_ PCOMMON_DEVICE_EXTENSION	CommonExtension,
		_In_ PIRP	Irp
	)

Definition at line 11343 of file class.c.

{
    IoCopyCurrentIrpStackLocationToNext(Irp);
    return ClassSendIrpSynchronous(CommonExtension->LowerDeviceObject, Irp);
} // end ClassForwardIrpSynchronous()

Referenced by ClassDispatchPnp(), ClasspAccessAlignmentProperty(), ClasspDeviceSeekPenaltyProperty(), ClasspDeviceTrimProcess(), ClasspDeviceTrimProperty(), and ClasspPriorityHint().

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

ClassGetVpb()

PVPB NTAPI ClassGetVpb

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 11473 of file class.c.

{
#ifdef _MSC_VER
#pragma prefast(suppress:28175)
#endif
    return DeviceObject->Vpb;
} // end ClassGetVpb()

Referenced by ClassInterpretSenseInfo(), ClassMinimalPowerHandler(), and ClasspInterpretGesnData().

ClassInternalIoControl()

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

Definition at line 9394 of file class.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
 
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PIO_STACK_LOCATION nextStack = IoGetNextIrpStackLocation(Irp);
 
    ULONG isRemoved;
 
    PSCSI_REQUEST_BLOCK srb;
 
    isRemoved = ClassAcquireRemoveLock(DeviceObject, Irp);
    _Analysis_assume_(isRemoved);
    if(isRemoved) {
 
        Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
 
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
        return STATUS_DEVICE_DOES_NOT_EXIST;
    }
 
    //
    // Get a pointer to the SRB.
    //
 
    srb = irpStack->Parameters.Scsi.Srb;
 
    //
    // Set the parameters in the next stack location.
    //
 
    if(commonExtension->IsFdo) {
        nextStack->Parameters.Scsi.Srb = srb;
        nextStack->MajorFunction = IRP_MJ_SCSI;
        nextStack->MinorFunction = IRP_MN_SCSI_CLASS;
 
    } else {
 
        IoCopyCurrentIrpStackLocationToNext(Irp);
    }
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
 
    return IoCallDriver(commonExtension->LowerDeviceObject, Irp);
} // end ClassInternalIoControl()

Referenced by ClassInitializeDispatchTables().

ClassInterpretSenseInfo()

BOOLEAN NTAPI ClassInterpretSenseInfo	(	_In_ PDEVICE_OBJECT	Fdo,
		_In_ PSCSI_REQUEST_BLOCK	_Srb,
		_In_ UCHAR	MajorFunctionCode,
		_In_ ULONG	IoDeviceCode,
		_In_ ULONG	RetryCount,
		_Out_ NTSTATUS *	Status,
		_Out_opt_ _Deref_out_range_(0, 100) ULONG *	RetryInterval
	)

Definition at line 4452 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    PSTORAGE_REQUEST_BLOCK_HEADER Srb = (PSTORAGE_REQUEST_BLOCK_HEADER)_Srb;
    PVOID senseBuffer = SrbGetSenseInfoBuffer(Srb);
    BOOLEAN retry = TRUE;
    BOOLEAN logError = FALSE;
    BOOLEAN unhandledError = FALSE;
    BOOLEAN incrementErrorCount = FALSE;
 
    //
    // NOTE: This flag must be used only for read/write requests that
    // fail with a unexpected retryable error.
    //
    BOOLEAN logRetryableError = TRUE;
 
    //
    // Indicates if we should log this error in our internal log.
    //
    BOOLEAN logErrorInternal = TRUE;
 
    ULONGLONG badSector = 0;
    ULONG uniqueId = 0;
 
    NTSTATUS logStatus;
 
    ULONGLONG readSector;
    ULONG index;
 
    ULONG retryInterval = 0;
    KIRQL oldIrql;
    PCDB cdb = SrbGetCdb(Srb);
    UCHAR cdbOpcode = 0;
    ULONG cdbLength = SrbGetCdbLength(Srb);
 
#if DBG
    BOOLEAN isReservationConflict = FALSE;
#endif
 
    if (cdb) {
        cdbOpcode = cdb->CDB6GENERIC.OperationCode;
    }
 
    *Status = STATUS_IO_DEVICE_ERROR;
    logStatus = -1;
 
    if (TEST_FLAG(SrbGetSrbFlags(Srb), SRB_CLASS_FLAGS_PAGING)) {
 
        //
        // Log anything remotely incorrect about paging i/o
        //
 
        logError = TRUE;
        uniqueId = 301;
        logStatus = IO_WARNING_PAGING_FAILURE;
    }
 
    //
    // Check that request sense buffer is valid.
    //
 
    NT_ASSERT(fdoExtension->CommonExtension.IsFdo);
 
 
    //
    // must handle the SRB_STATUS_INTERNAL_ERROR case first,
    // as it has  all the flags set.
    //
 
    if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_INTERNAL_ERROR) {
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                    "ClassInterpretSenseInfo: Internal Error code is %x\n",
                    SrbGetSystemStatus(Srb)));
 
        retry = FALSE;
        *Status = SrbGetSystemStatus(Srb);
 
    } else if (SrbGetScsiStatus(Srb) == SCSISTAT_RESERVATION_CONFLICT) {
 
        //
        // Need to reserve STATUS_DEVICE_BUSY to convey reservation conflict
        // for read/write requests as there are upper level components that
        // have built-in assumptions that STATUS_DEVICE_BUSY implies reservation
        // conflict.
        //
        *Status = STATUS_DEVICE_BUSY;
        retry = FALSE;
        logError = FALSE;
#if DBG
        isReservationConflict = TRUE;
#endif
 
    } else {
 
        BOOLEAN validSense = FALSE;
 
        if ((Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID) && senseBuffer)  {
 
            UCHAR errorCode = 0;
            UCHAR senseKey = 0;
            UCHAR addlSenseCode = 0;
            UCHAR addlSenseCodeQual = 0;
            BOOLEAN isIncorrectLengthValid = FALSE;
            BOOLEAN incorrectLength = FALSE;
            BOOLEAN isInformationValid = FALSE;
            ULONGLONG information = 0;
 
 
            validSense = ScsiGetSenseKeyAndCodes(senseBuffer,
                                                 SrbGetSenseInfoBufferLength(Srb),
                                                 SCSI_SENSE_OPTIONS_NONE,
                                                 &senseKey,
                                                 &addlSenseCode,
                                                 &addlSenseCodeQual);
 
            if (!validSense && !IsSenseDataFormatValueValid(senseBuffer)) {
 
                NT_ASSERT(FALSE);
 
                validSense = ScsiGetFixedSenseKeyAndCodes(senseBuffer,
                                                          SrbGetSenseInfoBufferLength(Srb),
                                                          &senseKey,
                                                          &addlSenseCode,
                                                          &addlSenseCodeQual);
            }
 
            if (!validSense) {
                goto __ClassInterpretSenseInfo_ProcessingInvalidSenseBuffer;
            }
 
            errorCode = ScsiGetSenseErrorCode(senseBuffer);
 
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: Error code is %x\n", errorCode));
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: Sense key is %x\n", senseKey));
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: Additional sense code is %x\n", addlSenseCode));
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: Additional sense code qualifier is %x\n", addlSenseCodeQual));
 
            if (IsDescriptorSenseDataFormat(senseBuffer)) {
 
                //
                // Sense data in Descriptor format
                //
 
                PVOID startBuffer = NULL;
                UCHAR startBufferLength = 0;
 
 
                if (ScsiGetSenseDescriptor(senseBuffer,
                                           SrbGetSenseInfoBufferLength(Srb),
                                           &startBuffer,
                                           &startBufferLength)) {
                    UCHAR outType;
                    PVOID outBuffer = NULL;
                    UCHAR outBufferLength = 0;
                    BOOLEAN foundBlockCommandType = FALSE;
                    BOOLEAN foundInformationType = FALSE;
                    UCHAR descriptorLength = 0;
 
                    UCHAR typeList[2] = {SCSI_SENSE_DESCRIPTOR_TYPE_INFORMATION,
                                         SCSI_SENSE_DESCRIPTOR_TYPE_BLOCK_COMMAND};
 
                    while ((!foundBlockCommandType || !foundInformationType) &&
                           ScsiGetNextSenseDescriptorByType(startBuffer,
                                                            startBufferLength,
                                                            typeList,
                                                            ARRAYSIZE(typeList),
                                                            &outType,
                                                            &outBuffer,
                                                            &outBufferLength)) {
 
                        descriptorLength = ScsiGetSenseDescriptorLength(outBuffer);
 
                        if (outBufferLength < descriptorLength) {
 
                            // Descriptor data is truncated.
                            // Complete searching descriptors. Exit the loop now.
                            break;
                        }
 
                        if (outType == SCSI_SENSE_DESCRIPTOR_TYPE_BLOCK_COMMAND) {
 
                            //
                            // Block Command type
                            //
 
                            if (!foundBlockCommandType) {
 
                                foundBlockCommandType = TRUE;
 
                                if (ScsiValidateBlockCommandSenseDescriptor(outBuffer, outBufferLength)) {
                                    incorrectLength = ((PSCSI_SENSE_DESCRIPTOR_BLOCK_COMMAND)outBuffer)->IncorrectLength;
                                    isIncorrectLengthValid = TRUE;
                                }
                            } else {
 
                                //
                                // A Block Command descriptor is already found earlier.
                                //
                                // T10 SPC specification only allows one descriptor for Block Command Descriptor type.
                                // Assert here to catch devices that violate this rule. Ignore this descriptor.
                                //
                                NT_ASSERT(FALSE);
                            }
 
                        } else if (outType == SCSI_SENSE_DESCRIPTOR_TYPE_INFORMATION) {
 
                            //
                            // Information type
                            //
 
                            if (!foundInformationType) {
 
                                foundInformationType = TRUE;
 
                                if (ScsiValidateInformationSenseDescriptor(outBuffer, outBufferLength)) {
                                    REVERSE_BYTES_QUAD(&information, &(((PSCSI_SENSE_DESCRIPTOR_INFORMATION)outBuffer)->Information));
                                    isInformationValid = TRUE;
                                }
                            } else {
 
                                //
                                // A Information descriptor is already found earlier.
                                //
                                // T10 SPC specification only allows one descriptor for Information Descriptor type.
                                // Assert here to catch devices that violate this rule. Ignore this descriptor.
                                //
                                NT_ASSERT(FALSE);
                            }
 
                        } else {
 
                            //
                            // ScsiGetNextDescriptorByType should only return a type that is specified by us.
                            //
                            NT_ASSERT(FALSE);
                            break;
                        }
 
                        //
                        // Advance to start address of next descriptor
                        //
                        startBuffer = (PUCHAR)outBuffer + descriptorLength;
                        startBufferLength = outBufferLength - descriptorLength;
                    }
                }
            } else {
 
                //
                // Sense data in Fixed format
                //
 
                incorrectLength = ((PFIXED_SENSE_DATA)(senseBuffer))->IncorrectLength;
                REVERSE_BYTES(&information, &(((PFIXED_SENSE_DATA)senseBuffer)->Information));
                isInformationValid = TRUE;
                isIncorrectLengthValid = TRUE;
            }
 
 
            switch (senseKey) {
 
                case SCSI_SENSE_NO_SENSE: {
 
                    //
                    // Check other indicators.
                    //
 
                    if (isIncorrectLengthValid && incorrectLength) {
 
                        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,  "ClassInterpretSenseInfo: "
                                    "Incorrect length detected.\n"));
                        *Status = STATUS_INVALID_BLOCK_LENGTH ;
                        retry   = FALSE;
 
                    } else {
 
                        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,  "ClassInterpretSenseInfo: "
                                    "No specific sense key\n"));
                        *Status = STATUS_IO_DEVICE_ERROR;
                        retry   = TRUE;
                    }
 
                    break;
                } // end SCSI_SENSE_NO_SENSE
 
                case SCSI_SENSE_RECOVERED_ERROR: {
 
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,  "ClassInterpretSenseInfo: "
                                "Recovered error\n"));
                    *Status = STATUS_SUCCESS;
                    retry = FALSE;
                    logError = TRUE;
                    uniqueId = 258;
 
                    switch(addlSenseCode) {
                        case SCSI_ADSENSE_TRACK_ERROR:
                        case SCSI_ADSENSE_SEEK_ERROR: {
                            logStatus = IO_ERR_SEEK_ERROR;
                            break;
                        }
 
                        case SCSI_ADSENSE_REC_DATA_NOECC:
                        case SCSI_ADSENSE_REC_DATA_ECC: {
                            logStatus = IO_RECOVERED_VIA_ECC;
                            break;
                        }
 
                        case SCSI_ADSENSE_FAILURE_PREDICTION_THRESHOLD_EXCEEDED: {
 
                            UCHAR wmiEventData[sizeof(ULONG)+sizeof(UCHAR)] = {0};
 
                            *((PULONG)wmiEventData) = sizeof(UCHAR);
                            wmiEventData[sizeof(ULONG)] = addlSenseCodeQual;
 
                            //
                            // Don't log another eventlog if we have already logged once
                            // NOTE: this should have been interlocked, but the structure
                            //       was publicly defined to use a BOOLEAN (char).  Since
                            //       media only reports these errors once per X minutes,
                            //       the potential race condition is nearly non-existant.
                            //       the worst case is duplicate log entries, so ignore.
                            //
 
                            logError = FALSE;
                            if (fdoExtension->FailurePredicted == 0) {
                                logError = TRUE;
                            }
                            fdoExtension->FailureReason = addlSenseCodeQual;
                            logStatus = IO_WRN_FAILURE_PREDICTED;
 
                            ClassNotifyFailurePredicted(fdoExtension,
                                                        (PUCHAR)wmiEventData,
                                                        sizeof(wmiEventData),
                                                        FALSE,   // do not log error
                                                        4,          // unique error value
                                                        SrbGetPathId(Srb),
                                                        SrbGetTargetId(Srb),
                                                        SrbGetLun(Srb));
 
                            fdoExtension->FailurePredicted = TRUE;
                            break;
                        }
 
                        default: {
                            logStatus = IO_ERR_CONTROLLER_ERROR;
                            break;
                        }
 
                    } // end switch(addlSenseCode)
 
                    if (isIncorrectLengthValid && incorrectLength) {
 
                        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,  "ClassInterpretSenseInfo: "
                                    "Incorrect length detected.\n"));
                        *Status = STATUS_INVALID_BLOCK_LENGTH ;
                    }
 
 
                    break;
                } // end SCSI_SENSE_RECOVERED_ERROR
 
                case SCSI_SENSE_NOT_READY: {
 
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                "Device not ready\n"));
                    *Status = STATUS_DEVICE_NOT_READY;
 
                    switch (addlSenseCode) {
 
                        case SCSI_ADSENSE_LUN_NOT_READY: {
 
                            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                        "Lun not ready\n"));
 
                            retryInterval = NOT_READY_RETRY_INTERVAL;
 
                            switch (addlSenseCodeQual) {
 
                                case SCSI_SENSEQ_BECOMING_READY: {
                                    DEVICE_EVENT_BECOMING_READY notReady = {0};
 
                                    logRetryableError = FALSE;
                                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                                "In process of becoming ready\n"));
 
                                    notReady.Version = 1;
                                    notReady.Reason = 1;
                                    notReady.Estimated100msToReady = retryInterval * 10;
                                    ClassSendNotification(fdoExtension,
                                                           &GUID_IO_DEVICE_BECOMING_READY,
                                                           sizeof(DEVICE_EVENT_BECOMING_READY),
                                                           &notReady);
                                    break;
                                }
 
                                case SCSI_SENSEQ_MANUAL_INTERVENTION_REQUIRED: {
                                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                                "Manual intervention required\n"));
                                    *Status = STATUS_NO_MEDIA_IN_DEVICE;
                                    retry = FALSE;
                                    break;
                                }
 
                                case SCSI_SENSEQ_FORMAT_IN_PROGRESS: {
                                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                                "Format in progress\n"));
                                    retry = FALSE;
                                    break;
                                }
 
                                case SCSI_SENSEQ_OPERATION_IN_PROGRESS: {
                                    DEVICE_EVENT_BECOMING_READY notReady = {0};
 
                                    logRetryableError = FALSE;
                                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                                "Operation In Progress\n"));
 
                                    notReady.Version = 1;
                                    notReady.Reason = 2;
                                    notReady.Estimated100msToReady = retryInterval * 10;
                                    ClassSendNotification(fdoExtension,
                                                           &GUID_IO_DEVICE_BECOMING_READY,
                                                           sizeof(DEVICE_EVENT_BECOMING_READY),
                                                           &notReady);
 
                                    break;
                                }
 
                                case SCSI_SENSEQ_LONG_WRITE_IN_PROGRESS: {
                                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                                "Long write in progress\n"));
                                    //
                                    // This has been seen as a transcient failure on some cdrom
                                    // drives. The cdrom class driver is going to override this
                                    // setting but has no way of dropping the retry interval
                                    //
                                    retry = FALSE;
                                    retryInterval = 1;
                                    break;
                                }
 
                                case SCSI_SENSEQ_SPACE_ALLOC_IN_PROGRESS: {
                                    logRetryableError = FALSE;
                                    TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                                "The device (%p) is busy allocating space.\n",
                                                Fdo));
 
                                    //
                                    // This indicates that a thinly-provisioned device has hit
                                    // a temporary resource exhaustion and is busy allocating
                                    // more space.  We need to retry the request as the device
                                    // will eventually be able to service it.
                                    //
                                    *Status = STATUS_RETRY;
                                    retry = TRUE;
 
                                    break;
                                }
 
                                case SCSI_SENSEQ_CAUSE_NOT_REPORTABLE: {
 
                                    if (!TEST_FLAG(fdoExtension->ScanForSpecialFlags,
                                                   CLASS_SPECIAL_CAUSE_NOT_REPORTABLE_HACK)) {
 
                                        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                                                    "ClassInterpretSenseInfo: "
                                                    "not ready, cause unknown\n"));
                                        /*
                                        Many non-WHQL certified drives (mostly CD-RW) return
                                        this when they have no media instead of the obvious
                                        choice of:
 
                                        SCSI_SENSE_NOT_READY/SCSI_ADSENSE_NO_MEDIA_IN_DEVICE
 
                                        These drives should not pass WHQL certification due
                                        to this discrepency.
 
                                        */
                                        retry = FALSE;
                                        break;
 
                                    } else {
 
                                        //
                                        // Treat this as init command required and fall through.
                                        //
                                    }
                                }
 
                                case SCSI_SENSEQ_INIT_COMMAND_REQUIRED:
                                default: {
                                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                                "Initializing command required\n"));
                                    retryInterval = 0; // go back to default
                                    logRetryableError = FALSE;
 
                                    //
                                    // This sense code/additional sense code
                                    // combination may indicate that the device
                                    // needs to be started.  Send an start unit if this
                                    // is a disk device.
                                    //
                                    if (TEST_FLAG(fdoExtension->DeviceFlags, DEV_SAFE_START_UNIT) &&
                                        !TEST_FLAG(SrbGetSrbFlags(Srb), SRB_CLASS_FLAGS_LOW_PRIORITY)){
 
                                        ClassSendStartUnit(Fdo);
                                    }
                                    break;
                                }
 
                            } // end switch (addlSenseCodeQual)
                            break;
                        }
 
                        case SCSI_ADSENSE_NO_MEDIA_IN_DEVICE: {
                            TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                        "No Media in device.\n"));
                            *Status = STATUS_NO_MEDIA_IN_DEVICE;
                            retry = FALSE;
 
                            //
                            // signal MCN that there isn't any media in the device
                            //
                            if (!TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)) {
                                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                            "No Media in a non-removable device %p\n",
                                            Fdo));
                            }
 
                            if (addlSenseCodeQual == 0xCC){
                                /*
                                 *  The IMAPI filter returns this ASCQ value when it is burning CD-R media.
                                 *  We want to indicate that the media is not present to most applications;
                                 *  but RSM has to know that the media is still in the drive (i.e. the drive is not free).
                                 */
                                ClassSetMediaChangeState(fdoExtension, MediaUnavailable, FALSE);
                            }
                            else {
                                ClassSetMediaChangeState(fdoExtension, MediaNotPresent, FALSE);
                            }
 
                            break;
                        }
                    } // end switch (addlSenseCode)
 
                    break;
                } // end SCSI_SENSE_NOT_READY
 
                case SCSI_SENSE_MEDIUM_ERROR: {
                    TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                "Medium Error (bad block)\n"));
                    *Status = STATUS_DEVICE_DATA_ERROR;
 
                    retry = FALSE;
                    logError = TRUE;
                    uniqueId = 256;
                    logStatus = IO_ERR_BAD_BLOCK;
 
                    //
                    // Check if this error is due to unknown format
                    //
                    if (addlSenseCode == SCSI_ADSENSE_INVALID_MEDIA) {
 
                        switch (addlSenseCodeQual) {
 
                            case SCSI_SENSEQ_UNKNOWN_FORMAT: {
 
                                *Status = STATUS_UNRECOGNIZED_MEDIA;
 
                                //
                                // Log error only if this is a paging request
                                //
                                if (!TEST_FLAG(SrbGetSrbFlags(Srb), SRB_CLASS_FLAGS_PAGING)) {
                                    logError = FALSE;
                                }
                                break;
                            }
 
                            case SCSI_SENSEQ_CLEANING_CARTRIDGE_INSTALLED: {
 
                                *Status = STATUS_CLEANER_CARTRIDGE_INSTALLED;
                                logError = FALSE;
                                break;
 
                            }
                            default: {
                                break;
                            }
                        } // end switch addlSenseCodeQual
 
                    } // end SCSI_ADSENSE_INVALID_MEDIA
 
                    break;
 
                } // end SCSI_SENSE_MEDIUM_ERROR
 
                case SCSI_SENSE_HARDWARE_ERROR: {
                    BOOLEAN logHardwareError = TRUE;
 
                    TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "ClassInterpretSenseInfo: "
                                "Hardware error\n"));
 
                    if (fdoData->LegacyErrorHandling == FALSE) {
                        //
                        // Hardware errors indicate something has seriously gone
                        // wrong with the device and retries are very unlikely to
                        // succeed so fail this request back immediately.
                        //
                        retry = FALSE;
                        *Status = STATUS_DEVICE_HARDWARE_ERROR;
                        logError = FALSE;
 
                    } else {
                        //
                        // Revert to legacy behavior.  That is, retry everything by default.
                        //
                        retry = TRUE;
                        *Status = STATUS_IO_DEVICE_ERROR;
                        logError = TRUE;
                        uniqueId = 257;
                        logStatus = IO_ERR_CONTROLLER_ERROR;
                        logHardwareError = FALSE;
 
                        //
                        // This indicates the possibility of a dropped FC packet.
                        //
                        if ((addlSenseCode == SCSI_ADSENSE_LOGICAL_UNIT_ERROR && addlSenseCodeQual == SCSI_SENSEQ_TIMEOUT_ON_LOGICAL_UNIT) ||
                            (addlSenseCode == SCSI_ADSENSE_DATA_TRANSFER_ERROR && addlSenseCodeQual == SCSI_SENSEQ_INITIATOR_RESPONSE_TIMEOUT)) {
                            //
                            // Fail requests that report this error back to the application.
                            //
                            retry = FALSE;
 
                            //
                            // Log a more descriptive error and avoid a second
                            // error message (IO_ERR_CONTROLLER_ERROR) being logged.
                            //
                            logHardwareError = TRUE;