class.c

Go to the documentation of this file.

/*++
 
Copyright (C) Microsoft Corporation, 1991 - 2010
 
Module Name:
 
    class.c
 
Abstract:
 
    SCSI class driver routines
 
Environment:
 
    kernel mode only
 
Notes:
 
 
Revision History:
 
--*/
 
#define CLASS_INIT_GUID 1
#define DEBUG_MAIN_SOURCE 1
 
#include "classp.h"
#include "debug.h"
#include <process.h>
#include <devpkey.h>
#include <ntiologc.h>
 
 
#ifdef DEBUG_USE_WPP
#include "class.tmh"
#endif
 
#ifdef ALLOC_PRAGMA
    #pragma alloc_text(INIT, DriverEntry)
    #pragma alloc_text(PAGE, ClassAddDevice)
    #pragma alloc_text(PAGE, ClassClaimDevice)
    #pragma alloc_text(PAGE, ClassCreateDeviceObject)
    #pragma alloc_text(PAGE, ClassDispatchPnp)
    #pragma alloc_text(PAGE, ClassGetDescriptor)
    #pragma alloc_text(PAGE, ClassGetPdoId)
    #pragma alloc_text(PAGE, ClassInitialize)
    #pragma alloc_text(PAGE, ClassInitializeEx)
    #pragma alloc_text(PAGE, ClassInvalidateBusRelations)
    #pragma alloc_text(PAGE, ClassMarkChildMissing)
    #pragma alloc_text(PAGE, ClassMarkChildrenMissing)
    #pragma alloc_text(PAGE, ClassModeSense)
    #pragma alloc_text(PAGE, ClassPnpQueryFdoRelations)
    #pragma alloc_text(PAGE, ClassPnpStartDevice)
    #pragma alloc_text(PAGE, ClassQueryPnpCapabilities)
    #pragma alloc_text(PAGE, ClassQueryTimeOutRegistryValue)
    #pragma alloc_text(PAGE, ClassRemoveDevice)
    #pragma alloc_text(PAGE, ClassRetrieveDeviceRelations)
    #pragma alloc_text(PAGE, ClassUpdateInformationInRegistry)
    #pragma alloc_text(PAGE, ClassSendDeviceIoControlSynchronous)
    #pragma alloc_text(PAGE, ClassUnload)
    #pragma alloc_text(PAGE, ClasspAllocateReleaseRequest)
    #pragma alloc_text(PAGE, ClasspFreeReleaseRequest)
    #pragma alloc_text(PAGE, ClasspInitializeHotplugInfo)
    #pragma alloc_text(PAGE, ClasspRegisterMountedDeviceInterface)
    #pragma alloc_text(PAGE, ClasspScanForClassHacks)
    #pragma alloc_text(PAGE, ClasspScanForSpecialInRegistry)
    #pragma alloc_text(PAGE, ClasspModeSense)
    #pragma alloc_text(PAGE, ClasspIsPortable)
    #pragma alloc_text(PAGE, ClassAcquireChildLock)
    #pragma alloc_text(PAGE, ClassDetermineTokenOperationCommandSupport)
    #pragma alloc_text(PAGE, ClassDeviceProcessOffloadRead)
    #pragma alloc_text(PAGE, ClassDeviceProcessOffloadWrite)
    #pragma alloc_text(PAGE, ClasspServicePopulateTokenTransferRequest)
    #pragma alloc_text(PAGE, ClasspServiceWriteUsingTokenTransferRequest)
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
    #pragma alloc_text(PAGE, ClassModeSenseEx)
#endif
#endif
 
#ifdef _MSC_VER
#pragma prefast(disable:28159, "There are certain cases when we have to bugcheck...")
#endif
 
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;
 
#define FirstDriveLetter 'C'
#define LastDriveLetter  'Z'
 
BOOLEAN UseQPCTime = FALSE;
 
//
// Keep track of whether security cookie is initialized or not. This is
// required by SDL.
//
 
BOOLEAN InitSecurityCookie = FALSE;
 
//
// List Identifier for offload data transfer operations
//
ULONG MaxTokenOperationListIdentifier = MAX_TOKEN_LIST_IDENTIFIERS;
volatile ULONG TokenOperationListIdentifier = (ULONG)-1;
 
//
// List of FDOs that have enabled idle power management.
//
LIST_ENTRY IdlePowerFDOList = {0};
KGUARDED_MUTEX IdlePowerFDOListMutex;
 
//
// Handle used to register for power setting notifications.
//
PVOID PowerSettingNotificationHandle;
 
//
// Handle used to register for screen state setting notifications.
//
PVOID ScreenStateNotificationHandle;
 
//
// Disk idle timeout in milliseconds.
// We default this to 0xFFFFFFFF as this is what the power manager considers
// "never" and ensures we do not set a disk idle timeout until the power
// manager calls us back with a different value.
//
ULONG DiskIdleTimeoutInMS = 0xFFFFFFFF;
 
 
NTSTATUS DllUnload(VOID)
{
    DbgPrintEx(DPFLTR_CLASSPNP_ID, DPFLTR_INFO_LEVEL, "classpnp.sys is now unloading\n");
 
    if (PowerSettingNotificationHandle) {
        PoUnregisterPowerSettingCallback(PowerSettingNotificationHandle);
        PowerSettingNotificationHandle = NULL;
    }
 
    if (ScreenStateNotificationHandle) {
        PoUnregisterPowerSettingCallback(ScreenStateNotificationHandle);
        ScreenStateNotificationHandle = NULL;
    }
 
 
    return STATUS_SUCCESS;
}
 
 
/*++////////////////////////////////////////////////////////////////////////////
 
DriverEntry()
 
Routine Description:
 
    Temporary entry point needed to initialize the class system dll.
    It doesn't do anything.
 
Arguments:
 
    DriverObject - Pointer to the driver object created by the system.
 
Return Value:
 
   STATUS_SUCCESS
 
--*/
NTSTATUS
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
DriverEntry(
    IN PDRIVER_OBJECT DriverObject,
    IN PUNICODE_STRING RegistryPath
    )
{
    UNREFERENCED_PARAMETER(DriverObject);
    UNREFERENCED_PARAMETER(RegistryPath);
 
    return STATUS_SUCCESS;
}
 
 
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassInitialize()
 
Routine Description:
 
    This routine is called by a class driver during its
    DriverEntry routine to initialize the driver.
 
Arguments:
 
    Argument1          - Driver Object.
    Argument2          - Registry Path.
    InitializationData - Device-specific driver's initialization data.
 
Return Value:
 
    A valid return code for a DriverEntry routine.
 
--*/
_IRQL_requires_max_(PASSIVE_LEVEL)
_Must_inspect_result_
ULONG
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassInitialize(
    _In_  PVOID            Argument1,
    _In_  PVOID            Argument2,
    _In_  PCLASS_INIT_DATA InitializationData
    )
{
    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()
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassInitializeEx()
 
Routine Description:
 
    This routine is allows the caller to do any extra initialization or
    setup that is not done in ClassInitialize. The operation is
    controlled by the GUID that is passed and the contents of the Data
    parameter is dependent upon the GUID.
 
    This is the list of supported operations:
 
    GUID_CLASSPNP_QUERY_REGINFOEX == CLASS_QUERY_WMI_REGINFO_EX_LIST
 
        Initialized classpnp to callback a PCLASS_QUERY_WMI_REGINFO_EX
        callback instead of a PCLASS_QUERY_WMI_REGINFO callback. The
        former callback allows the driver to specify the name of the
        mof resource.
 
    GUID_CLASSPNP_SENSEINFO2      == CLASS_INTERPRET_SENSE_INFO2
 
        Initialize classpnp to callback into class drive for interpretation
        of all sense info, and to indicate the count of "history" to keep
        for each packet.
 
    GUID_CLASSPNP_WORKING_SET     == CLASS_WORKING_SET
 
        Allow class driver to override the min and max working set transfer
        packet value used in classpnp.
 
    GUID_CLASSPNP_SRB_SUPPORT     == ULONG
 
        Allow class driver to provide supported SRB types.
 
Arguments:
 
    DriverObject
    Guid
    Data
 
Return Value:
 
    Status Code
 
--*/
_IRQL_requires_max_(PASSIVE_LEVEL)
_Must_inspect_result_
ULONG
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassInitializeEx(
    _In_  PDRIVER_OBJECT   DriverObject,
    _In_  LPGUID           Guid,
    _In_  PVOID            Data
    )
{
    PCLASS_DRIVER_EXTENSION driverExtension;
 
    NTSTATUS        status;
 
    PAGED_CODE();
 
#ifdef _MSC_VER
#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
#endif
    driverExtension = IoGetDriverObjectExtension( DriverObject, CLASS_DRIVER_EXTENSION_KEY );
 
    if (driverExtension == NULL)
    {
        NT_ASSERT(FALSE);
        return (ULONG)STATUS_UNSUCCESSFUL;
    }
 
    if (IsEqualGUID(Guid, &ClassGuidQueryRegInfoEx))
    {
        PCLASS_QUERY_WMI_REGINFO_EX_LIST List;
 
        //
        // Indicate the device supports PCLASS_QUERY_REGINFO_EX
        // callback instead of PCLASS_QUERY_REGINFO callback.
        //
        List = (PCLASS_QUERY_WMI_REGINFO_EX_LIST)Data;
 
        if (List->Size == sizeof(CLASS_QUERY_WMI_REGINFO_EX_LIST))
        {
            driverExtension->ClassFdoQueryWmiRegInfoEx = List->ClassFdoQueryWmiRegInfoEx;
            driverExtension->ClassPdoQueryWmiRegInfoEx = List->ClassPdoQueryWmiRegInfoEx;
            status = STATUS_SUCCESS;
        } else {
            status = STATUS_INVALID_PARAMETER;
        }
    }
    else if (IsEqualGUID(Guid, &ClassGuidWorkingSet))
    {
        PCLASS_WORKING_SET infoOriginal = (PCLASS_WORKING_SET)Data;
        PCLASS_WORKING_SET info = NULL;
 
        // only try to allocate memory for cached copy if size is correct
        if (infoOriginal->Size != sizeof(CLASS_WORKING_SET))
        {
            // incorrect size -- client programming error
            status = STATUS_INVALID_PARAMETER;
        }
        else
        {
            info = ExAllocatePoolWithTag(NonPagedPoolNx,
                                         sizeof(CLASS_WORKING_SET),
                                         CLASS_TAG_WORKING_SET
                                         );
            if (info == NULL)
            {
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
            else
            {
                // cache the structure internally
                RtlCopyMemory(info, infoOriginal, sizeof(CLASS_WORKING_SET));
                status = STATUS_SUCCESS;
            }
        }
        // if we successfully cached a copy, validate all the data within
        if (NT_SUCCESS(status))
        {
            if (info->Size != sizeof(CLASS_WORKING_SET))
            {
                // incorrect size -- client programming error
                status = STATUS_INVALID_PARAMETER;
            }
            else if (info->XferPacketsWorkingSetMaximum > CLASS_WORKING_SET_MAXIMUM)
            {
                // too many requested in the working set
                status = STATUS_INVALID_PARAMETER;
            }
            else if (info->XferPacketsWorkingSetMinimum > CLASS_WORKING_SET_MAXIMUM)
            {
                // too many requested in the working set
                status = STATUS_INVALID_PARAMETER;
            }
            else if (driverExtension->InitData.FdoData.DeviceType != FILE_DEVICE_CD_ROM)
            {
                // classpnp developer wants to restrict this code path
                // for now to CDROM devices only.
                status = STATUS_INVALID_DEVICE_REQUEST;
            }
            else if (driverExtension->WorkingSet != NULL)
            {
                // not allowed to change it once it is set for a driver
                status = STATUS_INVALID_PARAMETER;
                NT_ASSERT(FALSE);
            }
        }
        // save results or cleanup
        if (NT_SUCCESS(status))
        {
            driverExtension->WorkingSet = info; info = NULL;
        }
        else
        {
            FREE_POOL( info );
        }
    }
    else if (IsEqualGUID(Guid, &ClassGuidSenseInfo2))
    {
        PCLASS_INTERPRET_SENSE_INFO2 infoOriginal = (PCLASS_INTERPRET_SENSE_INFO2)Data;
        PCLASS_INTERPRET_SENSE_INFO2 info = NULL;
 
        // only try to allocate memory for cached copy if size is correct
        if (infoOriginal->Size != sizeof(CLASS_INTERPRET_SENSE_INFO2))
        {
            // incorrect size -- client programming error
            status = STATUS_INVALID_PARAMETER;
        }
        else
        {
            info = ExAllocatePoolWithTag(NonPagedPoolNx,
                                         sizeof(CLASS_INTERPRET_SENSE_INFO2),
                                         CLASS_TAG_SENSE2
                                         );
            if (info == NULL)
            {
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
            else
            {
                // cache the structure internally
                RtlCopyMemory(info, infoOriginal, sizeof(CLASS_INTERPRET_SENSE_INFO2));
                status = STATUS_SUCCESS;
            }
        }
 
        // if we successfully cached a copy, validate all the data within
        if (NT_SUCCESS(status))
        {
            if (info->Size != sizeof(CLASS_INTERPRET_SENSE_INFO2))
            {
                // incorrect size -- client programming error
                status = STATUS_INVALID_PARAMETER;
            }
            else if (info->HistoryCount > CLASS_INTERPRET_SENSE_INFO2_MAXIMUM_HISTORY_COUNT)
            {
                // incorrect count -- client programming error
                status = STATUS_INVALID_PARAMETER;
            }
            else if (info->Compress == NULL)
            {
                // Compression of the history is required to be supported
                status = STATUS_INVALID_PARAMETER;
            }
            else if (info->HistoryCount == 0)
            {
                // History count cannot be zero
                status = STATUS_INVALID_PARAMETER;
            }
            else if (info->Interpret == NULL)
            {
                // Updated interpret sense info function is required
                status = STATUS_INVALID_PARAMETER;
            }
            else if (driverExtension->InitData.FdoData.DeviceType != FILE_DEVICE_CD_ROM)
            {
                // classpnp developer wants to restrict this code path
                // for now to CDROM devices only.
                status = STATUS_INVALID_DEVICE_REQUEST;
            }
            else if (driverExtension->InterpretSenseInfo != NULL)
            {
                // not allowed to change it once it is set for a driver
                status = STATUS_INVALID_PARAMETER;
                NT_ASSERT(FALSE);
            }
        }
 
        // save results or cleanup
        if (NT_SUCCESS(status))
        {
            driverExtension->InterpretSenseInfo = info; info = NULL;
        }
        else
        {
            FREE_POOL( info );
        }
    }
    else if (IsEqualGUID(Guid, &ClassGuidSrbSupport))
    {
        ULONG srbSupport = *((PULONG)Data);
 
        //
        // Validate that at least one of the supported bit flags is set. Assume
        // all class drivers support SCSI_REQUEST_BLOCK as a class driver that
        // supports only extended SRB is not feasible.
        //
        if ((srbSupport &
             (CLASS_SRB_SCSI_REQUEST_BLOCK | CLASS_SRB_STORAGE_REQUEST_BLOCK)) != 0) {
            driverExtension->SrbSupport = srbSupport;
            status = STATUS_SUCCESS;
 
            //
            // Catch cases of a class driver reporting only extended SRB support
            //
            if ((driverExtension->SrbSupport & CLASS_SRB_SCSI_REQUEST_BLOCK) == 0) {
                NT_ASSERT(FALSE);
            }
        } else {
            status = STATUS_INVALID_PARAMETER;
        }
    }
    else
    {
        status = STATUS_NOT_SUPPORTED;
    }
 
    return status;
 
} // end ClassInitializeEx()
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassUnload()
 
Routine Description:
 
    called when there are no more references to the driver.  this allows
    drivers to be updated without rebooting.
 
Arguments:
 
    DriverObject - a pointer to the driver object that is being unloaded
 
Status:
 
--*/
VOID
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassUnload(
    IN PDRIVER_OBJECT DriverObject
    )
{
    PCLASS_DRIVER_EXTENSION driverExtension;
 
    PAGED_CODE();
 
    NT_ASSERT( DriverObject->DeviceObject == NULL );
 
#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 );
 
 
    if (driverExtension == NULL)
    {
        NT_ASSERT(FALSE);
        return;
    }
 
    NT_ASSERT(driverExtension->RegistryPath.Buffer != NULL);
    NT_ASSERT(driverExtension->InitData.ClassUnload != NULL);
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,  "ClassUnload: driver unloading %wZ\n",
                &driverExtension->RegistryPath));
 
    //
    // attempt to process the driver's unload routine first.
    //
 
    driverExtension->InitData.ClassUnload(DriverObject);
 
    //
    // free own allocated resources and return
    //
 
    FREE_POOL( driverExtension->WorkingSet          );
    FREE_POOL( driverExtension->InterpretSenseInfo  );
    FREE_POOL( driverExtension->RegistryPath.Buffer );
    driverExtension->RegistryPath.Length = 0;
    driverExtension->RegistryPath.MaximumLength = 0;
 
 
    //
    // Unregister ETW
    //
    if (driverExtension->EtwHandle != 0) {
        EtwUnregister(driverExtension->EtwHandle);
        driverExtension->EtwHandle = 0;
 
        WPP_CLEANUP(DriverObject);
    }
 
 
    return;
} // end ClassUnload()
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassAddDevice()
 
Routine Description:
 
    SCSI class driver add device routine.  This is called by pnp when a new
    physical device come into being.
 
    This routine will call out to the class driver to verify that it should
    own this device then will create and attach a device object and then hand
    it to the driver to initialize and create symbolic links
 
Arguments:
 
    DriverObject - a pointer to the driver object that this is being created for
    PhysicalDeviceObject - a pointer to the physical device object
 
Status: STATUS_NO_SUCH_DEVICE if the class driver did not want this device
    STATUS_SUCCESS if the creation and attachment was successful
    status of device creation and initialization
 
--*/
NTSTATUS
#ifdef _MSC_VER
#pragma prefast(suppress:28152, "We expect the class driver to clear the DO_DEVICE_INITIALIZING flag in its AddDevice routine.")
#endif
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassAddDevice(
    IN PDRIVER_OBJECT DriverObject,
    IN PDEVICE_OBJECT PhysicalDeviceObject
    )
{
#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()
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassDispatchPnp()
 
Routine Description:
 
    Storage class driver pnp routine.  This is called by the io system when
    a PNP request is sent to the device.
 
Arguments:
 
    DeviceObject - pointer to the device object
 
    Irp - pointer to the io request packet
 
Return Value:
 
    status
 
--*/
NTSTATUS
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassDispatchPnp(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )
{
    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()
 
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassPnpStartDevice()
 
Routine Description:
 
    Storage class driver routine for IRP_MN_START_DEVICE requests.
    This routine kicks off any device specific initialization
 
Arguments:
 
    DeviceObject - a pointer to the device object
 
    Irp - a pointer to the io request packet
 
Return Value:
 
    none
 
--*/
NTSTATUS ClassPnpStartDevice(IN PDEVICE_OBJECT DeviceObject)
{
    PCLASS_DRIVER_EXTENSION driverExtension;
    PCLASS_INIT_DATA initData;
 
    PCLASS_DEV_INFO devInfo;
 
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    BOOLEAN isFdo = commonExtension->IsFdo;
 
    BOOLEAN isMountedDevice = TRUE;
    BOOLEAN isPortable = FALSE;
 
    NTSTATUS status = STATUS_SUCCESS;
    PDEVICE_POWER_DESCRIPTOR powerDescriptor = NULL;
 
 
    PAGED_CODE();
 
#ifdef _MSC_VER
#pragma warning(suppress:4054) // okay to type cast function pointer as data pointer for this use case
#endif
    driverExtension = IoGetDriverObjectExtension(DeviceObject->DriverObject, CLASS_DRIVER_EXTENSION_KEY);
 
    initData = &(driverExtension->InitData);
    if(isFdo) {
        devInfo = &(initData->FdoData);
    } else {
        devInfo = &(initData->PdoData);
    }
 
    NT_ASSERT(devInfo->ClassInitDevice != NULL);
    NT_ASSERT(devInfo->ClassStartDevice != NULL);
 
    if (!commonExtension->IsInitialized){
 
        //
        // perform FDO/PDO specific initialization
        //
 
        if (isFdo){
            STORAGE_PROPERTY_ID propertyId;
 
            //
            // allocate a private extension for class data
            //
 
            if (fdoExtension->PrivateFdoData == NULL) {
                fdoExtension->PrivateFdoData = ExAllocatePoolWithTag(NonPagedPoolNx,
                                                                     sizeof(CLASS_PRIVATE_FDO_DATA),
                                                                     CLASS_TAG_PRIVATE_DATA
                                                                     );
            }
 
            if (fdoExtension->PrivateFdoData == NULL) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Cannot allocate for private fdo data\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            RtlZeroMemory(fdoExtension->PrivateFdoData, sizeof(CLASS_PRIVATE_FDO_DATA));
 
 
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
            //
            // Allocate a structure to hold more data than what we can put in FUNCTIONAL_DEVICE_EXTENSION.
            // This structure's memory is managed by classpnp, so it is more extensible.
            //
            if (fdoExtension->AdditionalFdoData == NULL) {
                fdoExtension->AdditionalFdoData = ExAllocatePoolWithTag(NonPagedPoolNx,
                                                                        sizeof(ADDITIONAL_FDO_DATA),
                                                                        CLASSPNP_POOL_TAG_ADDITIONAL_DATA
                                                                        );
            }
 
            if (fdoExtension->AdditionalFdoData == NULL) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Cannot allocate memory for the additional data structure.\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            RtlZeroMemory(fdoExtension->AdditionalFdoData, sizeof(ADDITIONAL_FDO_DATA));
#endif
 
            status = ClasspInitializeTimer(fdoExtension);
            if (NT_SUCCESS(status) == FALSE) {
                FREE_POOL(fdoExtension->PrivateFdoData);
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
                FREE_POOL(fdoExtension->AdditionalFdoData);
#endif
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP, "ClassPnpStartDevice: Failed to initialize tick timer\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            //
            // allocate LowerLayerSupport for class data
            //
 
            if (fdoExtension->FunctionSupportInfo == NULL) {
                fdoExtension->FunctionSupportInfo = (PCLASS_FUNCTION_SUPPORT_INFO)ExAllocatePoolWithTag(NonPagedPoolNx,
                                                                                                        sizeof(CLASS_FUNCTION_SUPPORT_INFO),
                                                                                                        '3BcS'
                                                                                                        );
            }
 
            if (fdoExtension->FunctionSupportInfo == NULL) {
                ClasspDeleteTimer(fdoExtension);
                FREE_POOL(fdoExtension->PrivateFdoData);
#if (NTDDI_VERSION >= NTDDI_WINTHRESHOLD)
                FREE_POOL(fdoExtension->AdditionalFdoData);
#endif
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Cannot allocate for FunctionSupportInfo\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            //
            // initialize the struct's various fields.
            //
            RtlZeroMemory(fdoExtension->FunctionSupportInfo, sizeof(CLASS_FUNCTION_SUPPORT_INFO));
            KeInitializeSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock);
 
            //
            // intialize the CommandStatus to -1 indicates that no effort made yet to retrieve the info.
            // Possible values of CommandStatus (data type: NTSTATUS):
            //     -1:             It's not attempted yet to retrieve the information.
            //     success:        Command sent and succeeded, information cached in FdoExtension.
            //     failed/warning: Command is either not supported or failed by device or lower level driver.
            //                     The command should not be attempted again.
            //
            fdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus = -1;
            fdoExtension->FunctionSupportInfo->DeviceCharacteristicsData.CommandStatus = -1;
            fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus = -1;
            fdoExtension->FunctionSupportInfo->ReadCapacity16Data.CommandStatus = -1;
            fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus = -1;
 
 
            KeInitializeTimer(&fdoExtension->PrivateFdoData->Retry.Timer);
            KeInitializeDpc(&fdoExtension->PrivateFdoData->Retry.Dpc,
                            ClasspRetryRequestDpc,
                            DeviceObject);
            KeInitializeSpinLock(&fdoExtension->PrivateFdoData->Retry.Lock);
            fdoExtension->PrivateFdoData->Retry.Granularity = KeQueryTimeIncrement();
            commonExtension->Reserved4 = (ULONG_PTR)(' GPH'); // debug aid
            InitializeListHead(&fdoExtension->PrivateFdoData->DeferredClientIrpList);
 
            KeInitializeSpinLock(&fdoExtension->PrivateFdoData->SpinLock);
 
            //
            // keep a pointer to the senseinfo2 stuff locally also (used in every read/write).
            //
            fdoExtension->PrivateFdoData->InterpretSenseInfo = driverExtension->InterpretSenseInfo;
 
            fdoExtension->PrivateFdoData->MaxNumberOfIoRetries = NUM_IO_RETRIES;
 
            //
            // Initialize release queue extended SRB
            //
            status = InitializeStorageRequestBlock(&(fdoExtension->PrivateFdoData->ReleaseQueueSrb.SrbEx),
                                                   STORAGE_ADDRESS_TYPE_BTL8,
                                                   sizeof(fdoExtension->PrivateFdoData->ReleaseQueueSrb.ReleaseQueueSrbBuffer),
                                                   0);
            if (!NT_SUCCESS(status)) {
                NT_ASSERT(FALSE);
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,
                            "ClassPnpStartDevice: fail to initialize release queue extended SRB 0x%x\n", status));
                return status;
            }
 
 
            /*
             *  Anchor the FDO in our static list.
             *  Pnp is synchronized, so we shouldn't need any synchronization here.
             */
            InsertTailList(&AllFdosList, &fdoExtension->PrivateFdoData->AllFdosListEntry);
 
            //
            // NOTE: the old interface allowed the class driver to allocate
            // this.  this was unsafe for low-memory conditions. allocate one
            // unconditionally now, and modify our internal functions to use
            // our own exclusively as it is the only safe way to do this.
            //
 
            status = ClasspAllocateReleaseQueueIrp(fdoExtension);
            if (!NT_SUCCESS(status)) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Cannot allocate the private release queue irp\n"));
                return status;
            }
 
            status = ClasspAllocatePowerProcessIrp(fdoExtension);
            if (!NT_SUCCESS(status)) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Cannot allocate the power process irp\n"));
                return status;
            }
 
            //
            // Call port driver to get miniport properties for disk devices
            // It's ok for this call to fail
            //
 
            if ((DeviceObject->DeviceType == FILE_DEVICE_DISK) &&
                (!TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE))) {
 
                propertyId = StorageMiniportProperty;
 
                status = ClassGetDescriptor(fdoExtension->CommonExtension.LowerDeviceObject,
                                            &propertyId,
                                            (PVOID *)&fdoExtension->MiniportDescriptor);
 
                //
                // function ClassGetDescriptor returns succeed with buffer "fdoExtension->MiniportDescriptor" allocated.
                //
                if ( NT_SUCCESS(status) &&
                     (fdoExtension->MiniportDescriptor->Portdriver != StoragePortCodeSetStorport &&
                      fdoExtension->MiniportDescriptor->Portdriver != StoragePortCodeSetUSBport) ) {
                    //
                    // field "IoTimeoutValue" supported for either Storport or USBStor
                    //
                    fdoExtension->MiniportDescriptor->IoTimeoutValue = 0;
                }
 
 
 
            }
 
            //
            // Call port driver to get adapter capabilities.
            //
 
            propertyId = StorageAdapterProperty;
 
            status = ClassGetDescriptor(
                        commonExtension->LowerDeviceObject,
                        &propertyId,
                        (PVOID *)&fdoExtension->AdapterDescriptor);
            if (!NT_SUCCESS(status)) {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: ClassGetDescriptor [ADAPTER] failed %lx\n", status));
                return status;
            }
 
            //
            // Call port driver to get device descriptor.
            //
 
            propertyId = StorageDeviceProperty;
 
            status = ClassGetDescriptor(
                        commonExtension->LowerDeviceObject,
                        &propertyId,
                        (PVOID *)&fdoExtension->DeviceDescriptor);
            if (NT_SUCCESS(status)){
 
                ClasspScanForSpecialInRegistry(fdoExtension);
                ClassScanForSpecial(fdoExtension, ClassBadItems, ClasspScanForClassHacks);
 
                //
                // allow perf to be re-enabled after a given number of failed IOs
                // require this number to be at least CLASS_PERF_RESTORE_MINIMUM
                //
 
                {
                    ULONG t = CLASS_PERF_RESTORE_MINIMUM;
 
                    ClassGetDeviceParameter(fdoExtension,
                                            CLASSP_REG_SUBKEY_NAME,
                                            CLASSP_REG_PERF_RESTORE_VALUE_NAME,
                                            &t);
                    if (t >= CLASS_PERF_RESTORE_MINIMUM) {
                        fdoExtension->PrivateFdoData->Perf.ReEnableThreshhold = t;
                    }
                }
 
                //
                // compatibility comes first.  writable cd media will not
                // get a SYNCH_CACHE on power down.
                //
                if (fdoExtension->DeviceObject->DeviceType != FILE_DEVICE_DISK) {
                    SET_FLAG(fdoExtension->PrivateFdoData->HackFlags, FDO_HACK_NO_SYNC_CACHE);
                }
 
 
                //
                // Test if the device is portable and updated the characteristics if so
                //
                status = ClasspIsPortable(fdoExtension,
                                          &isPortable);
 
                if (NT_SUCCESS(status) && (isPortable == TRUE)) {
                    DeviceObject->Characteristics |= FILE_PORTABLE_DEVICE;
                }
 
                //
                // initialize the hotplug information only after the ScanForSpecial
                // routines, as it relies upon the hack flags.
                //
                status = ClasspInitializeHotplugInfo(fdoExtension);
                if (NT_SUCCESS(status)){
                    /*
                     *  Allocate/initialize TRANSFER_PACKETs and related resources.
                     */
                    status = InitializeTransferPackets(DeviceObject);
                }
                else {
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_PNP,  "ClassPnpStartDevice: Could not initialize hotplug information %lx\n", status));
                }
            }
            else {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: ClassGetDescriptor [DEVICE] failed %lx\n", status));
                return status;
            }
 
 
            if (NT_SUCCESS(status)) {
 
                //
                // Retrieve info on whether async notification is supported by port drivers
                //
                propertyId = StorageDevicePowerProperty;
 
                status = ClassGetDescriptor(fdoExtension->CommonExtension.LowerDeviceObject,
                                            &propertyId,
                                            (PVOID *)&powerDescriptor);
                if (NT_SUCCESS(status) && (powerDescriptor != NULL)) {
                    fdoExtension->FunctionSupportInfo->AsynchronousNotificationSupported = powerDescriptor->AsynchronousNotificationSupported;
                    fdoExtension->FunctionSupportInfo->IdlePower.D3ColdSupported = powerDescriptor->D3ColdSupported;
                    fdoExtension->FunctionSupportInfo->IdlePower.NoVerifyDuringIdlePower = powerDescriptor->NoVerifyDuringIdlePower;
                    FREE_POOL(powerDescriptor);
                } else {
                    TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_PNP,  "ClassPnpStartDevice: ClassGetDescriptor [DevicePower] failed %lx\n", status));
 
                    //
                    // Ignore error as device power property is optional
                    //
                    status = STATUS_SUCCESS;
                }
            }
        }
 
        //
        // ISSUE - drivers need to disable write caching on the media
        //         if hotplug and !useroverride.  perhaps we should
        //         allow registration of a callback to enable/disable
        //         write cache instead.
        //
 
        if (NT_SUCCESS(status)){
            status = devInfo->ClassInitDevice(DeviceObject);
        }
 
        if (commonExtension->IsFdo) {
            fdoExtension->PrivateFdoData->Perf.OriginalSrbFlags = fdoExtension->SrbFlags;
 
            //
            // initialization for disk device
            //
            if ((DeviceObject->DeviceType == FILE_DEVICE_DISK) &&
                (!TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE))) {
 
                ULONG accessAlignmentNotSupported = 0;
                ULONG qerrOverrideMode = QERR_SET_ZERO_ODX_OR_TP_ONLY;
                ULONG legacyErrorHandling = FALSE;
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,
                           "ClassPnpStartDevice: Enabling idle timer for %p\n", DeviceObject));
                // Initialize idle timer for disk devices
                ClasspInitializeIdleTimer(fdoExtension);
 
                if (ClasspIsObsoletePortDriver(fdoExtension) == FALSE) {
                    // get INQUIRY VPD support information. It's safe to send command as everything is ready in ClassInitDevice().
                    ClasspGetInquiryVpdSupportInfo(fdoExtension);
 
                    // Query and cache away Logical Block Provisioning info in the FDO extension.
                    // The cached information will be used in responding to some IOCTLs
                    ClasspGetLBProvisioningInfo(fdoExtension);
 
                    //
                    // Query and cache away Block Device ROD Limits info in the FDO extension.
                    //
                    if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits) {
                        ClassDetermineTokenOperationCommandSupport(DeviceObject);
                    }
 
                    //
                    // See if the user has specified a particular QERR override
                    // mode. "Override" meaning setting QERR = 0 via Mode Select.
                    //  0 = Only when ODX or Thin Provisioning are supported (default)
                    //  1 = Always
                    //  2 = Never (or any value >= 2)
                    //
                    ClassGetDeviceParameter(fdoExtension,
                                            CLASSP_REG_SUBKEY_NAME,
                                            CLASSP_REG_QERR_OVERRIDE_MODE,
                                            &qerrOverrideMode);
 
                    //
                    // If this device is thinly provisioned or supports ODX, we
                    // may need to force QERR to zero.  The user may have also
                    // specified that we should always or never do this.
                    //
                    if (qerrOverrideMode == QERR_SET_ZERO_ALWAYS ||
                        (qerrOverrideMode == QERR_SET_ZERO_ODX_OR_TP_ONLY &&
                         (ClasspIsThinProvisioned(fdoExtension->FunctionSupportInfo) ||
                          NT_SUCCESS(ClasspValidateOffloadSupported(DeviceObject, NULL))))) {
 
                        ClasspZeroQERR(DeviceObject);
                    }
 
                } else {
 
                    //
                    // Since this device has been exposed by a legacy miniport (e.g. SCSIPort miniport)
                    // set its LB Provisioning command status to an error status that will be surfaced
                    // up to the caller of a TRIM/Unmap command.
                    //
                    fdoExtension->FunctionSupportInfo->LBProvisioningData.CommandStatus = STATUS_UNSUCCESSFUL;
                    fdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus = STATUS_UNSUCCESSFUL;
                    fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus = STATUS_UNSUCCESSFUL;
                }
 
                // Get registry setting of failing the IOCTL for AccessAlignment Property.
                ClassGetDeviceParameter(fdoExtension,
                                        CLASSP_REG_SUBKEY_NAME,
                                        CLASSP_REG_ACCESS_ALIGNMENT_NOT_SUPPORTED,
                                        &accessAlignmentNotSupported);
 
                if (accessAlignmentNotSupported > 0) {
                    fdoExtension->FunctionSupportInfo->RegAccessAlignmentQueryNotSupported = TRUE;
                }
 
#if (NTDDI_VERSION >= NTDDI_WINBLUE)
 
 
                //
                // See if the user has specified legacy error handling.
                //
                ClassGetDeviceParameter(fdoExtension,
                                        CLASSP_REG_SUBKEY_NAME,
                                        CLASSP_REG_LEGACY_ERROR_HANDLING,
                                        &legacyErrorHandling);
 
                if (legacyErrorHandling) {
                    //
                    // Legacy error handling means that the maximum number of
                    // retries allowd for an IO request is 8 instead of 4.
                    //
                    fdoExtension->PrivateFdoData->MaxNumberOfIoRetries = LEGACY_NUM_IO_RETRIES;
                    fdoExtension->PrivateFdoData->LegacyErrorHandling = TRUE;
                }
#else
                UNREFERENCED_PARAMETER(legacyErrorHandling);
#endif
 
 
                //
                // Get the copy offload max target duration value.
                // This function will set the default value if one hasn't been
                // specified in the registry.
                //
                ClasspGetCopyOffloadMaxDuration(DeviceObject,
                                                REG_DISK_CLASS_CONTROL,
                                                &(fdoExtension->PrivateFdoData->CopyOffloadMaxTargetDuration));
 
            }
 
        }
    }
 
    if (!NT_SUCCESS(status)){
 
        //
        // Just bail out - the remove that comes down will clean up the
        // initialized scraps.
        //
 
        return status;
    } else {
        commonExtension->IsInitialized = TRUE;
    }
 
    //
    // If device requests autorun functionality or a once a second callback
    // then enable the once per second timer. Exception is if media change
    // detection is desired but device supports async notification.
    //
    // NOTE: This assumes that ClassInitializeMediaChangeDetection is always
    //       called in the context of the ClassInitDevice callback. If called
    //       after then this check will have already been made and the
    //       once a second timer will not have been enabled.
    //
    if ((isFdo) &&
        ((initData->ClassTick != NULL) ||
         ((fdoExtension->MediaChangeDetectionInfo != NULL) &&
          (fdoExtension->FunctionSupportInfo != NULL) &&
          (fdoExtension->FunctionSupportInfo->AsynchronousNotificationSupported == FALSE)) ||
         ((fdoExtension->FailurePredictionInfo != NULL) &&
          (fdoExtension->FailurePredictionInfo->Method != FailurePredictionNone))))
    {
        ClasspEnableTimer(fdoExtension);
 
        //
        // In addition, we may change our polling behavior when the screen is
        // off so register for screen state notification if we haven't already
        // done so.
        //
        if (ScreenStateNotificationHandle == NULL) {
            PoRegisterPowerSettingCallback(DeviceObject,
                                            &GUID_CONSOLE_DISPLAY_STATE,
                                            &ClasspPowerSettingCallback,
                                            NULL,
                                            &ScreenStateNotificationHandle);
        }
    }
 
    //
    // NOTE: the timer looks at commonExtension->CurrentState now
    //       to prevent Media Change Notification code from running
    //       until the device is started, but allows the device
    //       specific tick handler to run.  therefore it is imperative
    //       that commonExtension->CurrentState not be updated until
    //       the device specific startdevice handler has finished.
    //
 
    status = devInfo->ClassStartDevice(DeviceObject);
 
    if (NT_SUCCESS(status)){
        commonExtension->CurrentState = IRP_MN_START_DEVICE;
 
        if((isFdo) && (initData->ClassEnumerateDevice != NULL)) {
            isMountedDevice = FALSE;
        }
 
        if (DeviceObject->DeviceType != FILE_DEVICE_CD_ROM) {
 
            isMountedDevice = FALSE;
        }
 
        //
        // Register for mounted device interface if this is a
        // sfloppy device.
        //
        if ((DeviceObject->DeviceType == FILE_DEVICE_DISK) &&
            (TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE))) {
 
            isMountedDevice = TRUE;
        }
 
        if(isMountedDevice) {
            ClasspRegisterMountedDeviceInterface(DeviceObject);
        }
 
        if(commonExtension->IsFdo) {
            IoWMIRegistrationControl(DeviceObject, WMIREG_ACTION_REGISTER);
 
            //
            // Tell Storport (Usbstor or SD) to enable idle power management for this
            // device, assuming the user hasn't turned it off in the registry.
            //
            if (fdoExtension->FunctionSupportInfo != NULL &&
                fdoExtension->FunctionSupportInfo->IdlePower.IdlePowerEnabled == FALSE &&
                fdoExtension->MiniportDescriptor != NULL &&
                (fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetStorport ||
                 fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetSDport ||
                 fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetUSBport)) {
                ULONG disableIdlePower= 0;
                ClassGetDeviceParameter(fdoExtension,
                                        CLASSP_REG_SUBKEY_NAME,
                                        CLASSP_REG_DISBALE_IDLE_POWER_NAME,
                                        &disableIdlePower);
 
                if (!disableIdlePower) {
                    ClasspEnableIdlePower(DeviceObject);
                }
            }
        }
    }
    else {
        ClasspDisableTimer(fdoExtension);
    }
 
 
    return status;
}
 
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassReadWrite()
 
Routine Description:
 
    This is the system entry point for read and write requests. The
    device-specific handler is invoked to perform any validation necessary.
 
    If the device object is a PDO (partition object) then the request will
    simply be adjusted for Partition0 and issued to the lower device driver.
 
    IF the device object is an FDO (paritition 0 object), the number of bytes
    in the request are checked against the maximum byte counts that the adapter
    supports and requests are broken up into
    smaller sizes if necessary.
 
Arguments:
 
    DeviceObject - a pointer to the device object for this request
 
    Irp - IO request
 
Return Value:
 
    NT Status
 
--*/
NTSTATUS
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassReadWrite(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PDEVICE_OBJECT      lowerDeviceObject = commonExtension->LowerDeviceObject;
    PIO_STACK_LOCATION  currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
    ULONG               transferByteCount = currentIrpStack->Parameters.Read.Length;
    ULONG               isRemoved;
    NTSTATUS            status;
 
    /*
     *  Grab the remove lock.  If we can't acquire it, bail out.
     */
    isRemoved = ClassAcquireRemoveLock(DeviceObject, Irp);
    if (isRemoved) {
        Irp->IoStatus.Status = STATUS_DEVICE_DOES_NOT_EXIST;
        Irp->IoStatus.Information = 0;
        ClassReleaseRemoveLock(DeviceObject, Irp);
        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
        status = STATUS_DEVICE_DOES_NOT_EXIST;
    }
    else if (TEST_FLAG(DeviceObject->Flags, DO_VERIFY_VOLUME) &&
             (currentIrpStack->MinorFunction != CLASSP_VOLUME_VERIFY_CHECKED) &&
             !TEST_FLAG(currentIrpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME)){
 
        /*
         *  DO_VERIFY_VOLUME is set for the device object,
         *  but this request is not itself a verify request.
         *  So fail this request.
         */
        if (Irp->Tail.Overlay.Thread != NULL) {
            IoSetHardErrorOrVerifyDevice(Irp, DeviceObject);
        }
        Irp->IoStatus.Status = STATUS_VERIFY_REQUIRED;
        Irp->IoStatus.Information = 0;
        ClassReleaseRemoveLock(DeviceObject, Irp);
        ClassCompleteRequest(DeviceObject, Irp, 0);
        status = STATUS_VERIFY_REQUIRED;
    }
    else {
 
        /*
         *  Since we've bypassed the verify-required tests we don't need to repeat
         *  them with this IRP - in particular we don't want to worry about
         *  hitting them at the partition 0 level if the request has come through
         *  a non-zero partition.
         */
        currentIrpStack->MinorFunction = CLASSP_VOLUME_VERIFY_CHECKED;
 
        /*
         *  Call the miniport driver's pre-pass filter to check if we
         *  should continue with this transfer.
         */
        NT_ASSERT(commonExtension->DevInfo->ClassReadWriteVerification);
        status = commonExtension->DevInfo->ClassReadWriteVerification(DeviceObject, Irp);
        // Code Analysis cannot analyze the code paths specific to clients.
        _Analysis_assume_(status != STATUS_PENDING);
        if (!NT_SUCCESS(status)){
            NT_ASSERT(Irp->IoStatus.Status == status);
            Irp->IoStatus.Information = 0;
            ClassReleaseRemoveLock(DeviceObject, Irp);
            ClassCompleteRequest (DeviceObject, Irp, IO_NO_INCREMENT);
        }
        else if (status == STATUS_PENDING){
            /*
             *  ClassReadWriteVerification queued this request.
             *  So don't touch the irp anymore.
             */
        }
        else {
 
            if (transferByteCount == 0) {
                /*
                 *  Several parts of the code turn 0 into 0xffffffff,
                 *  so don't process a zero-length request any further.
                 */
                Irp->IoStatus.Status = STATUS_SUCCESS;
                Irp->IoStatus.Information = 0;
                ClassReleaseRemoveLock(DeviceObject, Irp);
                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                status = STATUS_SUCCESS;
            }
            else {
                /*
                 *  If the driver has its own StartIo routine, call it.
                 */
                if (commonExtension->DriverExtension->InitData.ClassStartIo) {
                    IoMarkIrpPending(Irp);
                    IoStartPacket(DeviceObject, Irp, NULL, NULL);
                    status = STATUS_PENDING;
                }
                else {
                    /*
                     *  The driver does not have its own StartIo routine.
                     *  So process this request ourselves.
                     */
 
                    /*
                     *  Add partition byte offset to make starting byte relative to
                     *  beginning of disk.
                     */
                    currentIrpStack->Parameters.Read.ByteOffset.QuadPart +=
                        commonExtension->StartingOffset.QuadPart;
 
                    if (commonExtension->IsFdo){
 
                        PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
                        PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
 
                        /*
                         *  Add in any skew for the disk manager software.
                         */
                        currentIrpStack->Parameters.Read.ByteOffset.QuadPart +=
                             commonExtension->PartitionZeroExtension->DMByteSkew;
 
                        //
                        // In case DEV_USE_16BYTE_CDB flag is not set, R/W request will be translated into READ/WRITE 10 SCSI command.
                        // These SCSI commands have 4 bytes in "Starting LBA" field.
                        // Requests cannot be represented in these SCSI commands should be failed.
                        //
                        if (!TEST_FLAG(fdoExtension->DeviceFlags, DEV_USE_16BYTE_CDB)) {
                            LARGE_INTEGER startingLba;
 
                            startingLba.QuadPart = currentIrpStack->Parameters.Read.ByteOffset.QuadPart >> fdoExtension->SectorShift;
 
                            if (startingLba.QuadPart > MAXULONG) {
                                Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
                                Irp->IoStatus.Information = 0;
                                ClassReleaseRemoveLock(DeviceObject, Irp);
                                ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
                                status = STATUS_INVALID_PARAMETER;
                                goto Exit;
                            }
                        }
 
#if DBG
                        //
                        // Record the caller if:
                        // 1. the disk is currently off
                        // 2. the operation is a read, (likely resulting in disk spinnage)
                        // 3. the operation is marked WT (likely resulting in disk spinnage)
                        //
                        if((fdoExtension->DevicePowerState == PowerDeviceD3) && // disk is off
                            ((currentIrpStack->MajorFunction == IRP_MJ_READ) ||                       // It's a read.
                             (TEST_FLAG(currentIrpStack->Flags, SL_WRITE_THROUGH))) ) {               // they *really* want it to go to disk.
 
                            SnapDiskStartup();
                        }
#endif
 
                        /*
                         *  Perform the actual transfer(s) on the hardware
                         *  to service this request.
                         */
                        if (ClasspIsIdleRequestSupported(fdoData, Irp)) {
                            ClasspMarkIrpAsIdle(Irp, TRUE);
                            status = ClasspEnqueueIdleRequest(DeviceObject, Irp);
                        } else {
                            UCHAR uniqueAddr = 0;
 
                            //
                            // Since we're touching fdoData after servicing the transfer packet, this opens us up to
                            // a potential window, where the device may be removed between the time that
                            // ServiceTransferPacket completes and we've had a chance to access fdoData. In order
                            // to guard against this, we acquire the removelock an additional time here. This
                            // acquire is guaranteed to succeed otherwise we wouldn't be here (because of the
                            // outer acquire).
                            // The sequence of events we're guarding against with this remLock acquire is:
                            // 1. This UL IRP acquired the lock.
                            // 2. Device gets surprised removed, then gets IRP_MN_REMOVE_DEVICE; ClassRemoveDevice
                            //    waits for the above RemoveLock.
                            // 3. ServiceTransferRequest breaks the UL IRP into DL IRPs.
                            // 4. DL IRPs complete with STATUS_NO_SUCH_DEVICE and TransferPktComplete completes the UL
                            //    IRP with STATUS_NO_SUCH_DEVICE; releases the RemoveLock.
                            // 5. ClassRemoveDevice is now unblocked, continues running and frees resources (including
                            //    fdoData).
                            // 6. Finally ClassReadWrite gets to run again and accesses a freed fdoData when trying to
                            //    check/update idle-related fields.
                            //
                            ClassAcquireRemoveLock(DeviceObject, (PVOID)&uniqueAddr);
 
                            ClasspMarkIrpAsIdle(Irp, FALSE);
                            status = ServiceTransferRequest(DeviceObject, Irp, FALSE);
                            if (fdoData->IdlePrioritySupported == TRUE) {
                                fdoData->LastNonIdleIoTime = ClasspGetCurrentTime();
                            }
 
                            ClassReleaseRemoveLock(DeviceObject, (PVOID)&uniqueAddr);
                        }
                    }
                    else {
                        /*
                         *  This is a child PDO enumerated for our FDO by e.g. disk.sys
                         *  and owned by e.g. partmgr.  Send it down to the next device
                         *  and the same irp will come back to us for the FDO.
                         */
                        IoCopyCurrentIrpStackLocationToNext(Irp);
                        ClassReleaseRemoveLock(DeviceObject, Irp);
                        status = IoCallDriver(lowerDeviceObject, Irp);
                    }
                }
            }
        }
    }
 
Exit:
    return status;
}
 
 
VOID InterpretCapacityData(PDEVICE_OBJECT Fdo, PREAD_CAPACITY_DATA_EX ReadCapacityData)
{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    ULONG cylinderSize;
    ULONG bytesPerSector;
    LARGE_INTEGER lastSector;
    LARGE_INTEGER largeInt;
 
    bytesPerSector = ClasspCalculateLogicalSectorSize(Fdo, ReadCapacityData->BytesPerBlock);
 
    fdoExt->DiskGeometry.BytesPerSector = bytesPerSector;
    WHICH_BIT(fdoExt->DiskGeometry.BytesPerSector, fdoExt->SectorShift);
 
    /*
     *  LogicalBlockAddress is the last sector of the logical drive, in big-endian.
     *  It tells us the size of the drive (#sectors is lastSector+1).
     */
 
    largeInt = ReadCapacityData->LogicalBlockAddress;
    REVERSE_BYTES_QUAD(&lastSector, &largeInt);
 
    if (fdoExt->DMActive){
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT,  "ClassReadDriveCapacity: reducing number of sectors by %d\n", fdoExt->DMSkew));
        lastSector.QuadPart -= fdoExt->DMSkew;
    }
 
    /*
     *  Check to see if we have a geometry we should be using already.
     *  If not, we set part of the disk geometry to garbage values that will be filled in by the caller (e.g. disk.sys).
     *
     *  So the first call to ClassReadDriveCapacity always sets a meaningless geometry.
     *  TracksPerCylinder and SectorsPerTrack are kind of meaningless anyway wrt I/O,
     *  because I/O is always targeted to a logical sector number.
     *  All that really matters is BytesPerSector and the number of sectors.
     */
    cylinderSize = fdoExt->DiskGeometry.TracksPerCylinder * fdoExt->DiskGeometry.SectorsPerTrack;
    if (cylinderSize == 0){
        fdoExt->DiskGeometry.TracksPerCylinder = 0xff;
        fdoExt->DiskGeometry.SectorsPerTrack = 0x3f;
        cylinderSize = fdoExt->DiskGeometry.TracksPerCylinder * fdoExt->DiskGeometry.SectorsPerTrack;
    }
 
    /*
     *  Calculate number of cylinders.
     *  If there are zero cylinders, then the device lied AND it's
     *  smaller than 0xff*0x3f (about 16k sectors, usually 8 meg)
     *  this can fit into a single LONGLONG, so create another usable
     *  geometry, even if it's unusual looking.
     *  This allows small, non-standard devices, such as Sony's Memory Stick, to show up as having a partition.
     */
    fdoExt->DiskGeometry.Cylinders.QuadPart = (LONGLONG)((lastSector.QuadPart + 1)/cylinderSize);
    if (fdoExt->DiskGeometry.Cylinders.QuadPart == (LONGLONG)0) {
        fdoExt->DiskGeometry.SectorsPerTrack    = 1;
        fdoExt->DiskGeometry.TracksPerCylinder  = 1;
        fdoExt->DiskGeometry.Cylinders.QuadPart = lastSector.QuadPart + 1;
    }
 
    /*
     *  Calculate media capacity in bytes.
     *  For this purpose we treat the entire LUN as is if it is one partition.  Disk will deal with actual partitioning.
     */
    fdoExt->CommonExtension.PartitionLength.QuadPart =
        ((LONGLONG)(lastSector.QuadPart + 1)) << fdoExt->SectorShift;
 
    /*
     *  Is this removable or fixed media
     */
    if (TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)){
        fdoExt->DiskGeometry.MediaType = RemovableMedia;
    }
    else {
        fdoExt->DiskGeometry.MediaType = FixedMedia;
    }
 
}
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassReadDriveCapacity()
 
Routine Description:
 
    This routine sends a READ CAPACITY to the requested device, updates
    the geometry information in the device object and returns
    when it is complete.  This routine is synchronous.
 
    This routine must be called with the remove lock held or some other
    assurance that the Fdo will not be removed while processing.
 
Arguments:
 
    DeviceObject - Supplies a pointer to the device object that represents
        the device whose capacity is to be read.
 
Return Value:
 
    Status is returned.
 
--*/
_Must_inspect_result_
NTSTATUS
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassReadDriveCapacity(_In_ PDEVICE_OBJECT Fdo)
{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    READ_CAPACITY_DATA_EX PTRALIGN readCapacityData = {0};
    PTRANSFER_PACKET pkt;
    NTSTATUS status;
    PMDL driveCapMdl = NULL;
    KEVENT event;
    IRP pseudoIrp = {0};
    ULONG readCapacityDataSize;
    BOOLEAN use16ByteCdb;
    BOOLEAN match = TRUE;
 
    use16ByteCdb = TEST_FLAG(fdoExt->DeviceFlags, DEV_USE_16BYTE_CDB);
 
RetryRequest:
 
    if (use16ByteCdb) {
        readCapacityDataSize = sizeof(READ_CAPACITY_DATA_EX);
    } else {
        readCapacityDataSize = sizeof(READ_CAPACITY_DATA);
    }
 
    if (driveCapMdl != NULL) {
        FreeDeviceInputMdl(driveCapMdl);
        driveCapMdl = NULL;
    }
 
    //
    // Allocate the MDL based on the Read Capacity command.
    //
    driveCapMdl = BuildDeviceInputMdl(&readCapacityData, readCapacityDataSize);
    if (driveCapMdl == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto SafeExit;
    }
 
    pkt = DequeueFreeTransferPacket(Fdo, TRUE);
    if (pkt == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto SafeExit;
    }
 
    //
    //  Our engine needs an "original irp" to write the status back to
    //  and to count down packets (one in this case).
    //  Just use a pretend irp for this.
    //
 
    pseudoIrp.Tail.Overlay.DriverContext[0] = LongToPtr(1);
    pseudoIrp.IoStatus.Status = STATUS_SUCCESS;
    pseudoIrp.IoStatus.Information = 0;
    pseudoIrp.MdlAddress = driveCapMdl;
 
    //
    //  Set this up as a SYNCHRONOUS transfer, submit it,
    //  and wait for the packet to complete.  The result
    //  status will be written to the original irp.
    //
 
    KeInitializeEvent(&event, SynchronizationEvent, FALSE);
    SetupDriveCapacityTransferPacket(pkt,
                                     &readCapacityData,
                                     readCapacityDataSize,
                                     &event,
                                     &pseudoIrp,
                                     use16ByteCdb);
    SubmitTransferPacket(pkt);
    (VOID)KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
 
    status = pseudoIrp.IoStatus.Status;
 
    //
    //  If we got an UNDERRUN, retry exactly once.
    //  (The transfer_packet engine didn't retry because the result
    //   status was success).
    //
 
    if (NT_SUCCESS(status) &&
       (pseudoIrp.IoStatus.Information < readCapacityDataSize)) {
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT, "ClassReadDriveCapacity: read len (%xh) < %xh, retrying ...",
                (ULONG)pseudoIrp.IoStatus.Information, readCapacityDataSize));
 
        pkt = DequeueFreeTransferPacket(Fdo, TRUE);
        if (pkt) {
            pseudoIrp.Tail.Overlay.DriverContext[0] = LongToPtr(1);
            pseudoIrp.IoStatus.Status = STATUS_SUCCESS;
            pseudoIrp.IoStatus.Information = 0;
            KeInitializeEvent(&event, SynchronizationEvent, FALSE);
            SetupDriveCapacityTransferPacket(pkt,
                                             &readCapacityData,
                                             readCapacityDataSize,
                                             &event,
                                             &pseudoIrp,
                                             use16ByteCdb);
            SubmitTransferPacket(pkt);
            (VOID)KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
            status = pseudoIrp.IoStatus.Status;
            if (pseudoIrp.IoStatus.Information < readCapacityDataSize){
                status = STATUS_DEVICE_BUSY;
            }
        } else {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    if (NT_SUCCESS(status)) {
        //
        //  The request succeeded. Check for 8 byte LBA support.
        //
 
        if (use16ByteCdb == FALSE) {
 
            PREAD_CAPACITY_DATA readCapacity;
 
            //
            // Check whether the device supports 8 byte LBA. If the device supports
            // it then retry the request using 16 byte CDB.
            //
 
            readCapacity = (PREAD_CAPACITY_DATA) &readCapacityData;
 
            if (readCapacity->LogicalBlockAddress == 0xFFFFFFFF) {
                //
                // Device returned max size for last LBA. Need to send
                // 16 byte request to get the size.
                //
                use16ByteCdb = TRUE;
                goto RetryRequest;
 
            } else {
                //
                // Convert the 4 byte LBA (READ_CAPACITY_DATA) to 8 byte LBA (READ_CAPACITY_DATA_EX)
                // format for ease of use. This is the only format stored in the device extension.
                //
 
                RtlMoveMemory((PUCHAR)(&readCapacityData) + sizeof(ULONG), readCapacity, sizeof(READ_CAPACITY_DATA));
                RtlZeroMemory((PUCHAR)(&readCapacityData), sizeof(ULONG));
 
            }
        } else {
            //
            // Device completed 16 byte command successfully, it supports 8-byte LBA.
            //
 
            SET_FLAG(fdoExt->DeviceFlags, DEV_USE_16BYTE_CDB);
        }
 
        //
        // Read out and store the drive information.
        //
 
        InterpretCapacityData(Fdo, &readCapacityData);
 
        //
        // Before caching the new drive capacity, compare it with the
        // cached capacity for any change.
        //
 
        if (fdoData->IsCachedDriveCapDataValid == TRUE) {
 
            match = (BOOLEAN) RtlEqualMemory(&fdoData->LastKnownDriveCapacityData,
                                    &readCapacityData, sizeof(READ_CAPACITY_DATA_EX));
        }
 
        //
        // Store the readCapacityData in private FDO data.
        // This is so that runtime memory failures don't cause disk.sys to put
        // the paging disk in an error state. Also this is used in
        // IOCTL_STORAGE_READ_CAPACITY.
        //
        fdoData->LastKnownDriveCapacityData = readCapacityData;
        fdoData->IsCachedDriveCapDataValid = TRUE;
 
        if (match == FALSE) {
            if (commonExtension->CurrentState != IRP_MN_START_DEVICE)
            {
                //
                // This can happen if a disk reports Parameters Changed / Capacity Data Changed sense data.
                // NT_ASSERT(!"Drive capacity has changed while the device wasn't started!");
                //
            } else {
                //
                // state of (commonExtension->CurrentState == IRP_MN_START_DEVICE) indicates that the device has been started.
                // UpdateDiskPropertiesWorkItemActive is used as a flag to ensure we only have one work item updating the disk
                // properties at a time.
                //
                if (InterlockedCompareExchange((volatile LONG *)&fdoData->UpdateDiskPropertiesWorkItemActive, 1, 0) == 0)
                {
                    PIO_WORKITEM workItem;
 
                    workItem = IoAllocateWorkItem(Fdo);
 
                    if (workItem) {
                        //
                        // The disk capacity has changed, send notification to the disk driver.
                        // Start a work item to notify the disk class driver asynchronously.
                        //
                        IoQueueWorkItem(workItem, ClasspUpdateDiskProperties, DelayedWorkQueue, workItem);
                    } else {
                        InterlockedExchange((volatile LONG *)&fdoData->UpdateDiskPropertiesWorkItemActive, 0);
                    }
                }
            }
        }
 
    } else {
        //
        //  The request failed.
        //
 
        //
        // ISSUE - 2000/02/04 - henrygab - non-512-byte sector sizes and failed geometry update
        //    what happens when the disk's sector size is bigger than
        //    512 bytes and we hit this code path?  this is untested.
        //
        // If the read capacity fails, set the geometry to reasonable parameter
        // so things don't fail at unexpected places.  Zero the geometry
        // except for the bytes per sector and sector shift.
        //
 
        //
        //  This request can sometimes fail legitimately
        //  (e.g. when a SCSI device is attached but turned off)
        //  so this is not necessarily a device/driver bug.
        //
 
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT, "ClassReadDriveCapacity on Fdo %p failed with status %ul.", Fdo, status));
 
        //
        //  Write in a default disk geometry which we HOPE is right (??).
        //
 
        RtlZeroMemory(&fdoExt->DiskGeometry, sizeof(DISK_GEOMETRY));
        fdoExt->DiskGeometry.BytesPerSector = 512;
        fdoExt->SectorShift = 9;
        fdoExt->CommonExtension.PartitionLength.QuadPart = (LONGLONG) 0;
 
        //
        //  Is this removable or fixed media
        //
 
        if (TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)){
            fdoExt->DiskGeometry.MediaType = RemovableMedia;
        } else {
            fdoExt->DiskGeometry.MediaType = FixedMedia;
        }
    }
 
SafeExit:
 
 
    //
    // In case DEV_USE_16BYTE_CDB flag is not set, classpnp translates R/W request into READ/WRITE 10 SCSI command.
    // These SCSI commands have 2 bytes in "Transfer Blocks" field.
    // Make sure this max length (0xFFFF * sector size) is respected during request split.
    //
    if (!TEST_FLAG(fdoExt->DeviceFlags, DEV_USE_16BYTE_CDB)) {
        ULONG cdb10MaxBlocks = ((ULONG)USHORT_MAX) << fdoExt->SectorShift;
 
        fdoData->HwMaxXferLen = min(cdb10MaxBlocks, fdoData->HwMaxXferLen);
    }
 
    if (driveCapMdl != NULL) {
        FreeDeviceInputMdl(driveCapMdl);
    }
 
    //
    // If the request failed for some reason then invalidate the cached
    // capacity data for removable devices. So that we won't return
    // wrong capacity in IOCTL_STORAGE_READ_CAPACITY
    //
 
    if (!NT_SUCCESS(status) && (fdoExt->DiskGeometry.MediaType == RemovableMedia)) {
        fdoData->IsCachedDriveCapDataValid = FALSE;
    }
 
    //
    //  Don't let memory failures (either here or in the port driver) in the ReadDriveCapacity call
    //  put the paging disk in an error state such that paging fails.
    //  Return the last known drive capacity (which may possibly be slightly out of date, even on
    //  fixed media, e.g. for storage cabinets that can grow a logical disk).
    //
    if ((status == STATUS_INSUFFICIENT_RESOURCES) &&
        (fdoData->IsCachedDriveCapDataValid) &&
        (fdoExt->DiskGeometry.MediaType == FixedMedia)) {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT, "ClassReadDriveCapacity: defaulting to cached DriveCapacity data"));
        InterpretCapacityData(Fdo, &fdoData->LastKnownDriveCapacityData);
        status = STATUS_SUCCESS;
    }
 
    return status;
}
 
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassSendStartUnit()
 
Routine Description:
 
    Send command to SCSI unit to start or power up.
    Because this command is issued asynchronounsly, that is, without
    waiting on it to complete, the IMMEDIATE flag is not set. This
    means that the CDB will not return until the drive has powered up.
    This should keep subsequent requests from being submitted to the
    device before it has completely spun up.
 
    This routine is called from the InterpretSense routine, when a
    request sense returns data indicating that a drive must be
    powered up.
 
    This routine may also be called from a class driver's error handler,
    or anytime a non-critical start device should be sent to the device.
 
Arguments:
 
    Fdo - The functional device object for the stopped device.
 
Return Value:
 
    None.
 
--*/
VOID
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassSendStartUnit(
    _In_ PDEVICE_OBJECT Fdo
    )
{
    PIO_STACK_LOCATION irpStack;
    PIRP irp;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PSCSI_REQUEST_BLOCK srb;
    PCOMPLETION_CONTEXT context;
    PCDB cdb;
    NTSTATUS status;
    PSTORAGE_REQUEST_BLOCK srbEx;
 
    //
    // Allocate Srb from nonpaged pool.
    //
 
    context = ExAllocatePoolWithTag(NonPagedPoolNx,
                             sizeof(COMPLETION_CONTEXT),
                             '6CcS');
 
    if (context == NULL) {
 
        //
        // ISSUE-2000/02/03-peterwie
        // This code path was inheritted from the NT 4.0 class2.sys driver.
        // It needs to be changed to survive low-memory conditions.
        //
 
        KeBugCheck(SCSI_DISK_DRIVER_INTERNAL);
    }
 
    //
    // Save the device object in the context for use by the completion
    // routine.
    //
 
    context->DeviceObject = Fdo;
 
    srb = &context->Srb.Srb;
    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        srbEx = &context->Srb.SrbEx;
        status = InitializeStorageRequestBlock(srbEx,
                                               STORAGE_ADDRESS_TYPE_BTL8,
                                               sizeof(context->Srb.SrbExBuffer),
                                               1,
                                               SrbExDataTypeScsiCdb16);
        if (!NT_SUCCESS(status)) {
            FREE_POOL(context);
            NT_ASSERT(FALSE);
            return;
        }
 
        srbEx->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
 
    } else {
 
        //
        // Zero out srb.
        //
 
        RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
 
        //
        // Write length to SRB.
        //
 
        srb->Length = sizeof(SCSI_REQUEST_BLOCK);
 
        srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    }
 
    //
    // Set timeout value large enough for drive to spin up.
    //
 
    SrbSetTimeOutValue(srb, START_UNIT_TIMEOUT);
 
    //
    // Set the transfer length.
    //
 
    SrbAssignSrbFlags(srb,
                      (SRB_FLAGS_NO_DATA_TRANSFER  |
                       SRB_FLAGS_DISABLE_AUTOSENSE |
                       SRB_FLAGS_DISABLE_SYNCH_TRANSFER));
 
    //
    // Build the start unit CDB.
    //
 
    SrbSetCdbLength(srb, 6);
    cdb = SrbGetCdb(srb);
 
    cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
    cdb->START_STOP.Start = 1;
    cdb->START_STOP.Immediate = 0;
    cdb->START_STOP.LogicalUnitNumber = srb->Lun;
 
    //
    // Build the asynchronous request to be sent to the port driver.
    // Since this routine is called from a DPC the IRP should always be
    // available.
    //
 
    irp = IoAllocateIrp(Fdo->StackSize, FALSE);
 
    if (irp == NULL) {
 
        //
        // ISSUE-2000/02/03-peterwie
        // This code path was inheritted from the NT 4.0 class2.sys driver.
        // It needs to be changed to survive low-memory conditions.
        //
 
        KeBugCheck(SCSI_DISK_DRIVER_INTERNAL);
 
    }
 
    ClassAcquireRemoveLock(Fdo, irp);
 
    IoSetCompletionRoutine(irp,
                           (PIO_COMPLETION_ROUTINE)ClassAsynchronousCompletion,
                           context,
                           TRUE,
                           TRUE,
                           TRUE);
 
    irpStack = IoGetNextIrpStackLocation(irp);
    irpStack->MajorFunction = IRP_MJ_SCSI;
    SrbSetOriginalRequest(srb, irp);
 
    //
    // Store the SRB address in next stack for port driver.
    //
 
    irpStack->Parameters.Scsi.Srb = srb;
 
    //
    // Call the port driver with the IRP.
    //
 
    IoCallDriver(fdoExtension->CommonExtension.LowerDeviceObject, irp);
 
    return;
 
} // end StartUnit()
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassAsynchronousCompletion() ISSUE-2000/02/18-henrygab - why public?!
 
Routine Description:
 
    This routine is called when an asynchronous I/O request
    which was issused by the class driver completes.  Examples of such requests
    are release queue or START UNIT. This routine releases the queue if
    necessary.  It then frees the context and the IRP.
 
Arguments:
 
    DeviceObject - The device object for the logical unit; however since this
        is the top stack location the value is NULL.
 
    Irp - Supplies a pointer to the Irp to be processed.
 
    Context - Supplies the context to be used to process this request.
 
Return Value:
 
    None.
 
--*/
NTSTATUS
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassAsynchronousCompletion(
    PDEVICE_OBJECT DeviceObject,
    PIRP Irp,
    PVOID Context
    )
{
    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()
 
 
NTSTATUS
ServiceTransferRequest(
    PDEVICE_OBJECT Fdo,
    PIRP Irp,
    BOOLEAN PostToDpc
    )
 
/*++
 
Routine description:
 
    This routine processes Io requests, splitting them if they
    are larger than what the hardware can handle at a time. If
    there isn't enough memory available, the request is placed
    in a queue, to be processed at a later time
 
    If this is a high priority  paging request, all regular Io
    are throttled to provide Mm with better thoroughput
 
Arguments:
 
    Fdo - The functional device object processing the request
    Irp - The Io request to be processed
    PostToDpc - Flag that indicates that this IRP must be posted to a DPC
 
Return Value:
 
    STATUS_SUCCESS if successful, an error code otherwise
 
--*/
 
{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExt = Fdo->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension = Fdo->DeviceExtension;
    PSTORAGE_ADAPTER_DESCRIPTOR adapterDesc = commonExtension->PartitionZeroExtension->AdapterDescriptor;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExt->PrivateFdoData;
    IO_PAGING_PRIORITY priority = (TEST_FLAG(Irp->Flags, IRP_PAGING_IO)) ? IoGetPagingIoPriority(Irp) : IoPagingPriorityInvalid;
    BOOLEAN deferClientIrp = FALSE;
    BOOLEAN driverUsesStartIO = (commonExtension->DriverExtension->InitData.ClassStartIo != NULL);
    KIRQL oldIrql;
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    PIO_STACK_LOCATION  currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
 
    /*
     * Initialize IRP status for the master IRP to
     * - STATUS_FT_READ_FROM_COPY if it's a copy-specific read
     * - STATUS_SUCCESS otherwise.
     *
     * This is required. When Classpnp determines the status for the master IRP
     * when completing child IRPs, the call to IoSetMasterIrpStatus
     * will be functioning properly (See TransferPktComplete function)
     *
     * Note:
     * If the IRP is a copy-specific read, File System already initialized the IRP status
     * to be STATUS_FT_READ_FROM_COPY. However, this can be changed when the IRP arrives
     * at Classpnp. It's possible that other drivers in the stack may initialize the
     * IRP status field to other values before forwarding the IRP down the stack.
     * To be defensive, we initialize the IRP status to either STATUS_FT_READ_FROM_COPY
     * if it's a copy-specific read, or STATUS_SUCCESS otherwise.
     */
    if (currentIrpStack->MajorFunction == IRP_MJ_READ &&
        TEST_FLAG(currentIrpStack->Flags, SL_KEY_SPECIFIED) &&
        IsKeyReadCopyNumber(currentIrpStack->Parameters.Read.Key)) {
        Irp->IoStatus.Status = STATUS_FT_READ_FROM_COPY;
    } else {
        Irp->IoStatus.Status = STATUS_SUCCESS;
    }
 
    //
    // If this is a high priority request, hold off all other Io requests
    //
 
    if (priority == IoPagingPriorityHigh)
    {
        KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
 
        if (fdoData->NumHighPriorityPagingIo == 0)
        {
            //
            // Entering throttle mode
            //
 
            KeQuerySystemTime(&fdoData->ThrottleStartTime);
        }
 
        fdoData->NumHighPriorityPagingIo++;
        fdoData->MaxInterleavedNormalIo += ClassMaxInterleavePerCriticalIo;
 
        KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
    }
    else
    {
        if (fdoData->NumHighPriorityPagingIo != 0)
        {
            //
            // This request wasn't flagged as critical and atleast one critical request
            // is currently outstanding. Queue this request until all of those are done
            // but only if the interleave threshold has been reached
            //
 
            KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
 
            if (fdoData->NumHighPriorityPagingIo != 0)
            {
                if (fdoData->MaxInterleavedNormalIo == 0)
                {
                    deferClientIrp = TRUE;
                }
                else
                {
                    fdoData->MaxInterleavedNormalIo--;
                }
            }
 
            KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
        }
    }
 
    if (!deferClientIrp)
    {
        PIO_STACK_LOCATION currentSp = IoGetCurrentIrpStackLocation(Irp);
        ULONG entireXferLen = currentSp->Parameters.Read.Length;
        PUCHAR bufPtr = MmGetMdlVirtualAddress(Irp->MdlAddress);
        LARGE_INTEGER targetLocation = currentSp->Parameters.Read.ByteOffset;
        PTRANSFER_PACKET pkt;
        SINGLE_LIST_ENTRY pktList;
        PSINGLE_LIST_ENTRY slistEntry;
        ULONG hwMaxXferLen;
        ULONG numPackets;
        ULONG i;
 
 
        /*
         *  We precomputed fdoData->HwMaxXferLen using (MaximumPhysicalPages-1).
         *  If the buffer is page-aligned, that's one less page crossing so we can add the page back in.
         *  Note: adapters that return MaximumPhysicalPages=0x10 depend on this to
         *           transfer aligned 64K requests in one piece.
         *  Also note:  make sure adding PAGE_SIZE back in doesn't wrap to zero.
         */
        if (((ULONG_PTR)bufPtr & (PAGE_SIZE-1)) || (fdoData->HwMaxXferLen > 0xffffffff-PAGE_SIZE)){
            hwMaxXferLen = fdoData->HwMaxXferLen;
        }
        else {
            NT_ASSERT((PAGE_SIZE%fdoExt->DiskGeometry.BytesPerSector) == 0);
            hwMaxXferLen = min(fdoData->HwMaxXferLen+PAGE_SIZE, adapterDesc->MaximumTransferLength);
        }
 
        /*
         *  Compute the number of hw xfers we'll have to do.
         *  Calculate this without allowing for an overflow condition.
         */
        NT_ASSERT(hwMaxXferLen >= PAGE_SIZE);
        numPackets = entireXferLen/hwMaxXferLen;
        if (entireXferLen % hwMaxXferLen){
            numPackets++;
        }
 
        /*
         *  Use our 'simple' slist functions since we don't need interlocked.
         */
        SimpleInitSlistHdr(&pktList);
 
        if (driverUsesStartIO) {
            /*
             * special case: StartIO-based writing must stay serialized, so just
             * re-use one packet.
             */
            pkt = DequeueFreeTransferPacket(Fdo, TRUE);
            if (pkt) {
                SimplePushSlist(&pktList, (PSINGLE_LIST_ENTRY)&pkt->SlistEntry);
                i = 1;
            } else {
                i = 0;
            }
        } else {
            /*
             *  First get all the TRANSFER_PACKETs that we'll need at once.
             */
            for (i = 0; i < numPackets; i++){
                pkt = DequeueFreeTransferPacket(Fdo, TRUE);
                if (pkt){
                    SimplePushSlist(&pktList, (PSINGLE_LIST_ENTRY)&pkt->SlistEntry);
                }
                else {
                    break;
                }
            }
        }
 
 
        if ((i == numPackets) &&
            (!driverUsesStartIO)) {
            NTSTATUS pktStat;
 
            /*
             *  The IoStatus.Information field will be incremented to the
             *  transfer length as the pieces complete.
             */
            Irp->IoStatus.Information = 0;
 
            /*
             *  Store the number of transfer pieces inside the original IRP.
             *  It will be used to count down the pieces as they complete.
             */
            Irp->Tail.Overlay.DriverContext[0] = LongToPtr(numPackets);
 
            /*
             *  For the common 1-packet case, we want to allow for an optimization by BlkCache
             *  (and also potentially synchronous storage drivers) which may complete the
             *  downward request synchronously.
             *  In that synchronous completion case, we want to _not_ mark the original irp pending
             *  and thereby save on the top-level APC.
             *  It's critical to coordinate this with the completion routine so that we mark the original irp
             *  pending if-and-only-if we return STATUS_PENDING for it.
             */
            if (numPackets > 1){
                IoMarkIrpPending(Irp);
                status = STATUS_PENDING;
            }
            else {
                status = STATUS_SUCCESS;
            }
 
            /*
             *  Transmit the pieces of the transfer.
             */
            while (entireXferLen > 0){
                ULONG thisPieceLen = MIN(hwMaxXferLen, entireXferLen);
 
                /*
                 *  Set up a TRANSFER_PACKET for this piece and send it.
                 */
                slistEntry = SimplePopSlist(&pktList);
                NT_ASSERT(slistEntry);
                pkt = CONTAINING_RECORD(slistEntry, TRANSFER_PACKET, SlistEntry);
                SetupReadWriteTransferPacket(   pkt,
                                            bufPtr,
                                            thisPieceLen,
                                            targetLocation,
                                            Irp);
 
                //
                // If the IRP needs to be split, then we need to use a partial MDL.
                // This prevents problems if the same MDL is mapped multiple times.
                //
                if (numPackets > 1) {
                    pkt->UsePartialMdl = TRUE;
                }
 
                /*
                 *  When an IRP is completed, the completion routine checks to see if there
                 *  is a deferred IRP ready to sent down (assuming that there are no non-idle
                 *  requests waiting to be serviced). If such a deferred IRP is available, it
                 *  is sent down using this routine. However, if the lower driver completes
                 *  the request inline, there is a potential for multiple deferred IRPs being
                 *  sent down in the context of the same completion thread, thus exhausting
                 *  the call stack.
                 *  In order to prevent this from happening, we need to ensure that deferred
                 *  IRPs that are dequeued in the context of a request's completion routine
                 *  get posted to a DPC.
                 */
                if (PostToDpc) {
 
                    pkt->RetryIn100nsUnits = 0;
                    TransferPacketQueueRetryDpc(pkt);
                    status = STATUS_PENDING;
 
                } else {
 
                    pktStat = SubmitTransferPacket(pkt);
 
                    /*
                     *  If any of the packets completes with pending, we MUST return pending.
                     *  Also, if a packet completes with an error, return pending; this is because
                     *  in the completion routine we mark the original irp pending if the packet failed
                     *  (since we may retry, thereby switching threads).
                     */
                    if (pktStat != STATUS_SUCCESS){
                        status = STATUS_PENDING;
                    }
                }
 
                entireXferLen -= thisPieceLen;
                bufPtr += thisPieceLen;
                targetLocation.QuadPart += thisPieceLen;
            }
            NT_ASSERT(SimpleIsSlistEmpty(&pktList));
        }
        else if (i >= 1){
            /*
             *  We were unable to get all the TRANSFER_PACKETs we need,
             *  but we did get at least one.
             *  That means that we are in extreme low-memory stress.
             *  We'll try doing this transfer using a single packet.
             *  The port driver is certainly also in stress, so use one-page
             *  transfers.
             */
 
            /*
             *  Free all but one of the TRANSFER_PACKETs.
             */
            while (i-- > 1){
                slistEntry = SimplePopSlist(&pktList);
                NT_ASSERT(slistEntry);
                pkt = CONTAINING_RECORD(slistEntry, TRANSFER_PACKET, SlistEntry);
                EnqueueFreeTransferPacket(Fdo, pkt);
            }
 
            /*
             *  Get the single TRANSFER_PACKET that we'll be using.
             */
            slistEntry = SimplePopSlist(&pktList);
            NT_ASSERT(slistEntry);
            NT_ASSERT(SimpleIsSlistEmpty(&pktList));
            pkt = CONTAINING_RECORD(slistEntry, TRANSFER_PACKET, SlistEntry);
 
            if (!driverUsesStartIO) {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_RW, "Insufficient packets available in ServiceTransferRequest - entering lowMemRetry with pkt=%p.", pkt));
            }
 
            /*
             *  Set the number of transfer packets (one)
             *  inside the original irp.
             */
            Irp->IoStatus.Information = 0;
            Irp->Tail.Overlay.DriverContext[0] = LongToPtr(1);
            IoMarkIrpPending(Irp);
 
            /*
             *  Set up the TRANSFER_PACKET for a lowMem transfer and launch.
             */
            SetupReadWriteTransferPacket(  pkt,
                                        bufPtr,
                                        entireXferLen,
                                        targetLocation,
                                        Irp);
 
            InitLowMemRetry(pkt, bufPtr, entireXferLen, targetLocation);
            StepLowMemRetry(pkt);
            status = STATUS_PENDING;
        }
        else {
            /*
             *  We were unable to get ANY TRANSFER_PACKETs.
             *  Defer this client irp until some TRANSFER_PACKETs free up.
             */
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_RW, "No packets available in ServiceTransferRequest - deferring transfer (Irp=%p)...", Irp));
 
            if (priority == IoPagingPriorityHigh)
            {
                KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);
 
                if (fdoData->MaxInterleavedNormalIo < ClassMaxInterleavePerCriticalIo)
                {
                    fdoData->MaxInterleavedNormalIo = 0;
                }
                else
                {
                    fdoData->MaxInterleavedNormalIo -= ClassMaxInterleavePerCriticalIo;
                }
 
                fdoData->NumHighPriorityPagingIo--;
 
                if (fdoData->NumHighPriorityPagingIo == 0)
                {
                    LARGE_INTEGER period;
 
                    //
                    // Exiting throttle mode
                    //
 
                    KeQuerySystemTime(&fdoData->ThrottleStopTime);
 
                    period.QuadPart = fdoData->ThrottleStopTime.QuadPart - fdoData->ThrottleStartTime.QuadPart;
                    fdoData->LongestThrottlePeriod.QuadPart = max(fdoData->LongestThrottlePeriod.QuadPart, period.QuadPart);
                }
 
                KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
            }
 
            deferClientIrp = TRUE;
        }
    }
    _Analysis_assume_(deferClientIrp);
    if (deferClientIrp)
    {
        IoMarkIrpPending(Irp);
        EnqueueDeferredClientIrp(Fdo, Irp);
        status = STATUS_PENDING;
    }
 
    NT_ASSERT(status != STATUS_UNSUCCESSFUL);
 
    return status;
}
 
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassIoComplete()
 
Routine Description:
 
    This routine executes when the port driver has completed a request.
    It looks at the SRB status in the completing SRB and if not success
    it checks for valid request sense buffer information. If valid, the
    info is used to update status with more precise message of type of
    error. This routine deallocates the SRB.
 
    This routine should only be placed on the stack location for a class
    driver FDO.
 
Arguments:
 
    Fdo - Supplies the device object which represents the logical
        unit.
 
    Irp - Supplies the Irp which has completed.
 
    Context - Supplies a pointer to the SRB.
 
Return Value:
 
    NT status
 
--*/
NTSTATUS
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassIoComplete(
    IN PDEVICE_OBJECT Fdo,
    IN PIRP Irp,
    IN PVOID Context
    )
{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSCSI_REQUEST_BLOCK srb = Context;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    NTSTATUS status;
    BOOLEAN retry;
    BOOLEAN callStartNextPacket;
    ULONG srbFlags;
    ULONG srbFunction;
 
    NT_ASSERT(fdoExtension->CommonExtension.IsFdo);
 
    if (srb->Function == SRB_FUNCTION_STORAGE_REQUEST_BLOCK) {
        srbFlags = ((PSTORAGE_REQUEST_BLOCK)srb)->SrbFlags;
        srbFunction = ((PSTORAGE_REQUEST_BLOCK)srb)->SrbFunction;
    } else {
        srbFlags = srb->SrbFlags;
        srbFunction = srb->Function;
    }
 
    #if DBG
        if (srbFunction == SRB_FUNCTION_FLUSH) {
            DBGLOGFLUSHINFO(fdoData, FALSE, FALSE, TRUE);
        }
    #endif
 
    //
    // Check SRB status for success of completing request.
    //
 
    if (SRB_STATUS(srb->SrbStatus) != SRB_STATUS_SUCCESS) {
        LONGLONG retryInterval;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,  "ClassIoComplete: IRP %p, SRB %p\n", Irp, srb));
 
        //
        // Release the queue if it is frozen.
        //
 
        if (srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN) {
            ClassReleaseQueue(Fdo);
        }
        retry = InterpretSenseInfoWithoutHistory(
            Fdo,
            Irp,
            srb,
            irpStack->MajorFunction,
            ((irpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL) ?
             irpStack->Parameters.DeviceIoControl.IoControlCode :
             0),
            MAXIMUM_RETRIES -
                ((ULONG)(ULONG_PTR)irpStack->Parameters.Others.Argument4),
            &status,
            &retryInterval);
 
        //
        // For Persistent Reserve requests, make sure user gets back partial data.
        //
 
        if (irpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL &&
            (irpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_STORAGE_PERSISTENT_RESERVE_IN ||
             irpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_STORAGE_PERSISTENT_RESERVE_OUT) &&
            status == STATUS_DATA_OVERRUN) {
 
            status = STATUS_SUCCESS;
            retry = FALSE;
        }
 
        //
        // If the status is verified required and the this request
        // should bypass verify required then retry the request.
        //
 
        if (TEST_FLAG(irpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME) &&
            status == STATUS_VERIFY_REQUIRED) {
 
            status = STATUS_IO_DEVICE_ERROR;
            retry = TRUE;
        }
 
#ifndef __REACTOS__
#pragma warning(suppress:4213) // okay to cast Arg4 as a ulong for this use case
        if (retry && ((ULONG)(ULONG_PTR)irpStack->Parameters.Others.Argument4)--) {
#else
        if (retry && (*(ULONG *)&irpStack->Parameters.Others.Argument4)--) {
#endif
 
 
            //
            // Retry request.
            //
 
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,  "Retry request %p\n", Irp));
 
            if (PORT_ALLOCATED_SENSE(fdoExtension, srb)) {
                FREE_PORT_ALLOCATED_SENSE_BUFFER(fdoExtension, srb);
            }
 
            RetryRequest(Fdo, Irp, srb, FALSE, retryInterval);
            return STATUS_MORE_PROCESSING_REQUIRED;
        }
 
    } else {
 
        //
        // Set status for successful request
        //
        fdoData->LoggedTURFailureSinceLastIO = FALSE;
        ClasspPerfIncrementSuccessfulIo(fdoExtension);
        status = STATUS_SUCCESS;
    } // end if (SRB_STATUS(srb->SrbStatus) == SRB_STATUS_SUCCESS)
 
 
    //
    // ensure we have returned some info, and it matches what the
    // original request wanted for PAGING operations only
    //
 
    if ((NT_SUCCESS(status)) && TEST_FLAG(Irp->Flags, IRP_PAGING_IO)) {
        NT_ASSERT(Irp->IoStatus.Information != 0);
        NT_ASSERT(irpStack->Parameters.Read.Length == Irp->IoStatus.Information);
    }
 
    //
    // remember if the caller wanted to skip calling IoStartNextPacket.
    // for legacy reasons, we cannot call IoStartNextPacket for IoDeviceControl
    // calls.  this setting only affects device objects with StartIo routines.
    //
 
    callStartNextPacket = !TEST_FLAG(srbFlags, SRB_FLAGS_DONT_START_NEXT_PACKET);
    if (irpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL) {
        callStartNextPacket = FALSE;
    }
 
    //
    // Free MDL if allocated.
    //
 
    if (TEST_FLAG(srbFlags, SRB_CLASS_FLAGS_FREE_MDL)) {
        SrbClearSrbFlags(srb, SRB_CLASS_FLAGS_FREE_MDL);
        IoFreeMdl(Irp->MdlAddress);
        Irp->MdlAddress = NULL;
    }
 
 
    //
    // Free the srb
    //
 
    if (!TEST_FLAG(srbFlags, SRB_CLASS_FLAGS_PERSISTANT)) {
 
        if (PORT_ALLOCATED_SENSE(fdoExtension, srb)) {
            FREE_PORT_ALLOCATED_SENSE_BUFFER(fdoExtension, srb);
        }
 
        if (fdoExtension->CommonExtension.IsSrbLookasideListInitialized){
            ClassFreeOrReuseSrb(fdoExtension, srb);
        }
        else {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL, "ClassIoComplete is freeing an SRB (possibly) on behalf of another driver."));
            FREE_POOL(srb);
        }
 
    } else {
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,  "ClassIoComplete: Not Freeing srb @ %p because "
                    "SRB_CLASS_FLAGS_PERSISTANT set\n", srb));
        if (PORT_ALLOCATED_SENSE(fdoExtension, srb)) {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,  "ClassIoComplete: Not Freeing sensebuffer @ %p "
                        " because SRB_CLASS_FLAGS_PERSISTANT set\n",
                        srb->SenseInfoBuffer));
        }
 
    }
 
    //
    // Set status in completing IRP.
    //
 
    Irp->IoStatus.Status = status;
 
    //
    // Set the hard error if necessary.
    //
 
    if (!NT_SUCCESS(status) &&
        IoIsErrorUserInduced(status) &&
        (Irp->Tail.Overlay.Thread != NULL)
        ) {
 
        //
        // Store DeviceObject for filesystem, and clear
        // in IoStatus.Information field.
        //
 
        IoSetHardErrorOrVerifyDevice(Irp, Fdo);
        Irp->IoStatus.Information = 0;
    }
 
    //
    // If disk firmware update succeeded, log a system event.
    //
 
    if (NT_SUCCESS(status) &&
        (irpStack->MajorFunction == IRP_MJ_DEVICE_CONTROL) &&
        (irpStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_STORAGE_FIRMWARE_ACTIVATE)) {
 
        ClasspLogSystemEventWithDeviceNumber(Fdo, IO_WARNING_DISK_FIRMWARE_UPDATED);
    }
 
    //
    // If pending has be returned for this irp then mark the current stack as
    // pending.
    //
 
    if (Irp->PendingReturned) {
        IoMarkIrpPending(Irp);
    }
 
    if (fdoExtension->CommonExtension.DriverExtension->InitData.ClassStartIo) {
        if (callStartNextPacket) {
            KIRQL oldIrql;
            KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
            IoStartNextPacket(Fdo, TRUE); // Yes, some IO must now be cancellable.
            KeLowerIrql(oldIrql);
        }
    }
 
    ClassReleaseRemoveLock(Fdo, Irp);
 
    return status;
 
} // end ClassIoComplete()
 
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassSendSrbSynchronous()
 
Routine Description:
 
    This routine is called by SCSI device controls to complete an
    SRB and send it to the port driver synchronously (ie wait for
    completion). The CDB is already completed along with the SRB CDB
    size and request timeout value.
 
Arguments:
 
    Fdo - Supplies the functional device object which represents the target.
 
    Srb - Supplies a partially initialized SRB. The SRB cannot come from zone.
 
    BufferAddress - Supplies the address of the buffer.
 
    BufferLength - Supplies the length in bytes of the buffer.
 
    WriteToDevice - Indicates the data should be transfer to the device.
 
Return Value:
 
    NTSTATUS indicating the final results of the operation.
 
    If NT_SUCCESS(), then the amount of usable data is contained in the field
       Srb->DataTransferLength
 
--*/
NTSTATUS
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
ClassSendSrbSynchronous(
    _In_ PDEVICE_OBJECT Fdo,
    _Inout_ PSCSI_REQUEST_BLOCK _Srb,
    _In_reads_bytes_opt_(BufferLength) PVOID BufferAddress,
    _In_ ULONG BufferLength,
    _In_ BOOLEAN WriteToDevice
    )
{
 
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData = fdoExtension->PrivateFdoData;
    IO_STATUS_BLOCK ioStatus = {0};
    PIRP irp;
    PIO_STACK_LOCATION irpStack;
    KEVENT event;
    PVOID senseInfoBuffer = NULL;
    ULONG senseInfoBufferLength = SENSE_BUFFER_SIZE_EX;
    ULONG retryCount = MAXIMUM_RETRIES;
    NTSTATUS status;
    BOOLEAN retry;
    PSTORAGE_REQUEST_BLOCK_HEADER Srb = (PSTORAGE_REQUEST_BLOCK_HEADER)_Srb;
 
    //
    // NOTE: This code is only pagable because we are not freezing
    //       the queue.  Allowing the queue to be frozen from a pagable
    //       routine could leave the queue frozen as we try to page in
    //       the code to unfreeze the queue.  The result would be a nice
    //       case of deadlock.  Therefore, since we are unfreezing the
    //       queue regardless of the result, just set the NO_FREEZE_QUEUE
    //       flag in the SRB.
    //
 
    NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
    NT_ASSERT(fdoExtension->CommonExtension.IsFdo);
 
    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;
    }
 
    //
    // The Srb->Function should have been set corresponding to SrbType.
    //
 
    NT_ASSERT( ((fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_SCSI_REQUEST_BLOCK) && (Srb->Function == SRB_FUNCTION_EXECUTE_SCSI)) ||
               ((fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) && (Srb->Function == SRB_FUNCTION_STORAGE_REQUEST_BLOCK)) );
 
 
    //
    // Sense buffer is in aligned nonpaged pool.
    //
 
#if defined(_ARM_) || defined(_ARM64_)
 
    //
    // ARM has specific alignment requirements, although this will not have a functional impact on x86 or amd64
    // based platforms. We are taking the conservative approach here.
    //
    senseInfoBufferLength = ALIGN_UP_BY(senseInfoBufferLength,KeGetRecommendedSharedDataAlignment());
 
#endif
 
    senseInfoBuffer = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                            senseInfoBufferLength,
                                            '7CcS');
 
    if (senseInfoBuffer == NULL) {
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,  "ClassSendSrbSynchronous: Can't allocate request sense "
                       "buffer\n"));
        return(STATUS_INSUFFICIENT_RESOURCES);
    }
 
 
    //
    // Enable auto request sense.
    //
    SrbSetSenseInfoBufferLength(Srb, SENSE_BUFFER_SIZE_EX);
    SrbSetSenseInfoBuffer(Srb, senseInfoBuffer);
 
    SrbSetDataBuffer(Srb, BufferAddress);
 
 
    //
    // Start retries here.
    //
 
retry:
 
    //
    // use fdoextension's flags by default.
    // do not move out of loop, as the flag may change due to errors
    // sending this command.
    //
 
    SrbAssignSrbFlags(Srb, fdoExtension->SrbFlags);
 
    if (BufferAddress != NULL) {
        if (WriteToDevice) {
            SrbSetSrbFlags(Srb, SRB_FLAGS_DATA_OUT);
        } else {
            SrbSetSrbFlags(Srb, SRB_FLAGS_DATA_IN);
        }
    }
 
 
    //
    // Initialize the QueueAction field.
    //
 
    SrbSetRequestAttribute(Srb, SRB_SIMPLE_TAG_REQUEST);
 
    //
    // Disable synchronous transfer for these requests.
    //
    SrbSetSrbFlags(Srb, SRB_FLAGS_DISABLE_SYNCH_TRANSFER | SRB_FLAGS_NO_QUEUE_FREEZE);
 
    //
    // Set the event object to the unsignaled state.
    // It will be used to signal request completion.
    //
 
    KeInitializeEvent(&event, NotificationEvent, FALSE);
 
    //
    // Build device I/O control request with METHOD_NEITHER data transfer.
    // We'll queue a completion routine to cleanup the MDL's and such ourself.
    //
 
    irp = IoAllocateIrp(
            (CCHAR) (fdoExtension->CommonExtension.LowerDeviceObject->StackSize + 1),
            FALSE);
 
    if (irp == NULL) {
        FREE_POOL(senseInfoBuffer);
        SrbSetSenseInfoBuffer(Srb, NULL);
        SrbSetSenseInfoBufferLength(Srb, 0);
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,  "ClassSendSrbSynchronous: Can't allocate Irp\n"));
        return(STATUS_INSUFFICIENT_RESOURCES);
    }
 
    //
    // Get next stack location.
    //
 
    irpStack = IoGetNextIrpStackLocation(irp);
 
    //
    // Set up SRB for execute scsi request. Save SRB address in next stack
    // for the port driver.
    //
 
    irpStack->MajorFunction = IRP_MJ_SCSI;
    irpStack->Parameters.Scsi.Srb = (PSCSI_REQUEST_BLOCK)Srb;
 
    IoSetCompletionRoutine(irp,
                           ClasspSendSynchronousCompletion,
                           Srb,
                           TRUE,
                           TRUE,
                           TRUE);
 
    irp->UserIosb = &ioStatus;
    irp->UserEvent = &event;
 
    if (BufferAddress) {
        //
        // Build an MDL for the data buffer and stick it into the irp.  The
        // completion routine will unlock the pages and free the MDL.
        //
 
        irp->MdlAddress = IoAllocateMdl( BufferAddress,
                                         BufferLength,
                                         FALSE,
                                         FALSE,
                                         irp );
        if (irp->MdlAddress == NULL) {
            FREE_POOL(senseInfoBuffer);
            SrbSetSenseInfoBuffer(Srb, NULL);
            SrbSetSenseInfoBufferLength(Srb, 0);
            IoFreeIrp( irp );
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,  "ClassSendSrbSynchronous: Can't allocate MDL\n"));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        _SEH2_TRY {
 
            //
            // the io manager unlocks these pages upon completion
            //
 
            MmProbeAndLockPages( irp->MdlAddress,
                                 KernelMode,
                                 (WriteToDevice ? IoReadAccess :
                                                  IoWriteAccess));
 
#ifdef _MSC_VER
        #pragma warning(suppress: 6320) // We want to handle any exception that MmProbeAndLockPages might throw
#endif
        } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
            status = _SEH2_GetExceptionCode();
 
            FREE_POOL(senseInfoBuffer);
            SrbSetSenseInfoBuffer(Srb, NULL);
            SrbSetSenseInfoBufferLength(Srb, 0);
            IoFreeMdl(irp->MdlAddress);
            IoFreeIrp(irp);
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,  "ClassSendSrbSynchronous: Exception %lx "
                           "locking buffer\n", status));
            _SEH2_YIELD(return status);
        } _SEH2_END;
    }
 
    //
    // Set the transfer length.
    //
 
    SrbSetDataTransferLength(Srb, BufferLength);
 
    //
    // Zero out status.
    //
 
    SrbSetScsiStatus(Srb, 0);
    Srb->SrbStatus = 0;
    SrbSetNextSrb(Srb, NULL);
 
    //
    // Set up IRP Address.
    //
 
    SrbSetOriginalRequest(Srb, irp);
 
    //
    // Call the port driver with the request and wait for it to complete.
    //
 
    status = IoCallDriver(fdoExtension->CommonExtension.LowerDeviceObject, irp);
 
    if (status == STATUS_PENDING) {
        (VOID)KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);
        status = ioStatus.Status;
    }
 
//    NT_ASSERT(SRB_STATUS(Srb->SrbStatus) != SRB_STATUS_PENDING);
    NT_ASSERT(status != STATUS_PENDING);
    NT_ASSERT(!(Srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN));
 
    //
    // Clear the IRP address in SRB as IRP has been freed at this time
    // and don't want to leave any references that may be accessed.
    //
 
    SrbSetOriginalRequest(Srb, NULL);
 
    //
    // Check that request completed without error.
    //
 
    if (SRB_STATUS(Srb->SrbStatus) != SRB_STATUS_SUCCESS) {
 
        LONGLONG retryInterval;
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL, "ClassSendSrbSynchronous - srb %ph failed (op=%s srbstat=%s(%xh), irpstat=%xh, sense=%s/%s/%s)", Srb,
                    DBGGETSCSIOPSTR(Srb),
                    DBGGETSRBSTATUSSTR(Srb), (ULONG)Srb->SrbStatus, status,
                    DBGGETSENSECODESTR(Srb),
                    DBGGETADSENSECODESTR(Srb),
                    DBGGETADSENSEQUALIFIERSTR(Srb)));
 
        //
        // assert that the queue is not frozen
        //
 
        NT_ASSERT(!TEST_FLAG(Srb->SrbStatus, SRB_STATUS_QUEUE_FROZEN));
 
        //
        // Update status and determine if request should be retried.
        //
 
        retry = InterpretSenseInfoWithoutHistory(Fdo,
                                                 NULL, // no valid irp exists
                                                 (PSCSI_REQUEST_BLOCK)Srb,
                                                 IRP_MJ_SCSI,
                                                 0,
                                                 MAXIMUM_RETRIES  - retryCount,
                                                 &status,
                                                 &retryInterval);
 
        if (retry) {
 
            BOOLEAN validSense = FALSE;
            UCHAR additionalSenseCode = 0;
 
            if (status == STATUS_DEVICE_NOT_READY) {
 
                validSense = ScsiGetSenseKeyAndCodes(senseInfoBuffer,
                                                     SrbGetSenseInfoBufferLength(Srb),
                                                     SCSI_SENSE_OPTIONS_FIXED_FORMAT_IF_UNKNOWN_FORMAT_INDICATED,
                                                     NULL,
                                                     &additionalSenseCode,
                                                     NULL);
            }
 
            if ((validSense && additionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY) ||
                (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT)) {
 
                LARGE_INTEGER delay;
 
                //
                // Delay for at least 2 seconds.
                //
 
                if (retryInterval < 2*1000*1000*10) {
                    retryInterval = 2*1000*1000*10;
                }
 
                delay.QuadPart = -retryInterval;
 
                //
                // Stall for a while to let the device become ready
                //
 
                KeDelayExecutionThread(KernelMode, FALSE, &delay);
 
            }
 
 
            //
            // If retries are not exhausted then retry this operation.
            //
 
            if (retryCount--) {
 
                if (PORT_ALLOCATED_SENSE_EX(fdoExtension, Srb)) {
                    FREE_PORT_ALLOCATED_SENSE_BUFFER_EX(fdoExtension, Srb);
                }
 
                goto retry;
            }
        }
 
 
    } else {
        fdoData->LoggedTURFailureSinceLastIO = FALSE;
        status = STATUS_SUCCESS;
    }
 
    //
    // required even though we allocated our own, since the port driver may
    // have allocated one also
    //
 
    if (PORT_ALLOCATED_SENSE_EX(fdoExtension, Srb)) {
        FREE_PORT_ALLOCATED_SENSE_BUFFER_EX(fdoExtension, Srb);
    }
 
    FREE_POOL(senseInfoBuffer);
    SrbSetSenseInfoBuffer(Srb, NULL);
    SrbSetSenseInfoBufferLength(Srb, 0);
 
    return status;
}
 
 
/*++////////////////////////////////////////////////////////////////////////////
 
ClassInterpretSenseInfo()
 
Routine Description:
 
    This routine interprets the data returned from the SCSI
    request sense. It determines the status to return in the
    IRP and whether this request can be retried.
 
Arguments:
 
    Fdo - Supplies the device object associated with this request.
 
    Srb - Supplies the scsi request block which failed.
 
    MajorFunctionCode - Supplies the function code to be used for logging.
 
    IoDeviceCode - Supplies the device code to be used for logging.
 
    RetryCount - Number of times that the request has been retried.
 
    Status - Returns the status for the request.
 
    RetryInterval - Number of seconds before the request should be retried.
                    Zero indicates the request should be immediately retried.
 
Return Value:
 
    BOOLEAN TRUE: Drivers should retry this request.
            FALSE: Drivers should not retry this request.
 
--*/
BOOLEAN
NTAPI /* ReactOS Change: GCC Does not support STDCALL by default */
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
    )
{
    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