mmc.c

Go to the documentation of this file.

/*--
 
Copyright (C) Microsoft Corporation. All rights reserved.
 
Module Name:
 
    mmc.c
 
Abstract:
 
    Include all funtions relate to MMC
 
Environment:
 
    kernel mode only
 
Notes:
 
 
Revision History:
 
--*/
 
#include "stddef.h"
#include "string.h"
 
#include "ntddk.h"
#include "ntddstor.h"
#include "cdrom.h"
#include "mmc.h"
#include "scratch.h"
 
#ifdef DEBUG_USE_WPP
#include "mmc.tmh"
#endif
 
#ifdef ALLOC_PRAGMA
 
#pragma alloc_text(PAGE, DeviceDeallocateMmcResources)
#pragma alloc_text(PAGE, DeviceAllocateMmcResources)
#pragma alloc_text(PAGE, DeviceUpdateMmcCapabilities)
#pragma alloc_text(PAGE, DeviceGetConfigurationWithAlloc)
#pragma alloc_text(PAGE, DeviceGetConfiguration)
#pragma alloc_text(PAGE, DeviceUpdateMmcWriteCapability)
#pragma alloc_text(PAGE, MmcDataFindFeaturePage)
#pragma alloc_text(PAGE, MmcDataFindProfileInProfiles)
#pragma alloc_text(PAGE, DeviceRetryTimeGuessBasedOnProfile)
#pragma alloc_text(PAGE, DeviceRetryTimeDetectionBasedOnModePage2A)
#pragma alloc_text(PAGE, DeviceRetryTimeDetectionBasedOnGetPerformance)
 
#endif
 
#pragma warning(push)
#pragma warning(disable:4214) // nonstandard extension used : bit field types other than int
 
_IRQL_requires_max_(APC_LEVEL)
VOID
DeviceDeallocateMmcResources(
    _In_ WDFDEVICE Device
    )
/*++
 
Routine Description:
 
   release MMC resources
 
Arguments:
 
    Device - device object
 
Return Value:
 
    none
 
--*/
{
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    PCDROM_DATA             cddata = &(deviceExtension->DeviceAdditionalData);
    PCDROM_MMC_EXTENSION    mmcData = &cddata->Mmc;
 
    PAGED_CODE();
 
    if (mmcData->CapabilitiesIrp)
    {
        IoFreeIrp(mmcData->CapabilitiesIrp);
        mmcData->CapabilitiesIrp = NULL;
    }
    if (mmcData->CapabilitiesMdl)
    {
        IoFreeMdl(mmcData->CapabilitiesMdl);
        mmcData->CapabilitiesMdl = NULL;
    }
    if (mmcData->CapabilitiesBuffer)
    {
        ExFreePool(mmcData->CapabilitiesBuffer);
        mmcData->CapabilitiesBuffer = NULL;
    }
    if (mmcData->CapabilitiesRequest)
    {
        WdfObjectDelete(mmcData->CapabilitiesRequest);
        mmcData->CapabilitiesRequest = NULL;
    }
    mmcData->CapabilitiesBufferSize = 0;
    mmcData->IsMmc = FALSE;
    mmcData->WriteAllowed = FALSE;
 
    return;
}
 
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceAllocateMmcResources(
    _In_ WDFDEVICE Device
    )
/*++
 
Routine Description:
 
   allocate all MMC resources needed
 
Arguments:
 
    Device - device object
 
Return Value:
 
    NTSTATUS
 
--*/
{
    NTSTATUS status                         = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    PCDROM_DATA cddata                      = &(deviceExtension->DeviceAdditionalData);
    PCDROM_MMC_EXTENSION mmcData            = &(cddata->Mmc);
    WDF_OBJECT_ATTRIBUTES attributes        = {0};
 
    PAGED_CODE();
 
    NT_ASSERT(mmcData->CapabilitiesBuffer == NULL);
    NT_ASSERT(mmcData->CapabilitiesBufferSize == 0);
 
    // allocate the buffer and set the buffer size.
    // retrieve drive configuration information.
    status = DeviceGetConfigurationWithAlloc(Device,
                                             &mmcData->CapabilitiesBuffer,
                                             &mmcData->CapabilitiesBufferSize,
                                             FeatureProfileList,
                                             SCSI_GET_CONFIGURATION_REQUEST_TYPE_ALL);
    if (!NT_SUCCESS(status))
    {
        NT_ASSERT(mmcData->CapabilitiesBuffer     == NULL);
        NT_ASSERT(mmcData->CapabilitiesBufferSize == 0);
        return status;
    }
 
    NT_ASSERT(mmcData->CapabilitiesBuffer     != NULL);
    NT_ASSERT(mmcData->CapabilitiesBufferSize != 0);
 
    // Create an MDL over the new Buffer (allocated by DeviceGetConfiguration)
    mmcData->CapabilitiesMdl = IoAllocateMdl(mmcData->CapabilitiesBuffer,
                                             mmcData->CapabilitiesBufferSize,
                                             FALSE, FALSE, NULL);
    if (mmcData->CapabilitiesMdl == NULL)
    {
        ExFreePool(mmcData->CapabilitiesBuffer);
        mmcData->CapabilitiesBuffer = NULL;
        mmcData->CapabilitiesBufferSize = 0;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // Create an IRP from which we will create a WDFREQUEST
    mmcData->CapabilitiesIrp = IoAllocateIrp(deviceExtension->DeviceObject->StackSize + 1, FALSE);
    if (mmcData->CapabilitiesIrp == NULL)
    {
        IoFreeMdl(mmcData->CapabilitiesMdl);
        mmcData->CapabilitiesMdl = NULL;
        ExFreePool(mmcData->CapabilitiesBuffer);
        mmcData->CapabilitiesBuffer = NULL;
        mmcData->CapabilitiesBufferSize = 0;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    // create WDF request object
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
                                            CDROM_REQUEST_CONTEXT);
    status = WdfRequestCreateFromIrp(&attributes,
                                     mmcData->CapabilitiesIrp,
                                     FALSE,
                                     &mmcData->CapabilitiesRequest);
    if (!NT_SUCCESS(status))
    {
        return status;
    }
 
    return STATUS_SUCCESS;
}
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceUpdateMmcCapabilities(
    _In_ WDFDEVICE Device
    )
/*++
 
Routine Description:
 
   issue get congiguration command ans save result in device extension
 
Arguments:
 
    Device - device object
 
Return Value:
 
    NTSTATUS
 
--*/
{
    NTSTATUS                 status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION  deviceExtension = DeviceGetExtension(Device);
    PCDROM_DATA              cdData = &(deviceExtension->DeviceAdditionalData);
    PCDROM_MMC_EXTENSION     mmcData = &(cdData->Mmc);
    ULONG                    returnedBytes = 0;
    LONG                     updateState;
 
    PAGED_CODE();
 
    // first of all, check if we're still in the CdromMmcUpdateRequired state
    // and, if yes, change it to CdromMmcUpdateStarted.
    updateState = InterlockedCompareExchange((PLONG)&(cdData->Mmc.UpdateState),
                                             CdromMmcUpdateStarted,
                                             CdromMmcUpdateRequired);
    if (updateState != CdromMmcUpdateRequired) {
        // Mmc capabilities have been already updated or are in the process of
        // being updated - just return STATUS_SUCCESS
        return STATUS_SUCCESS;
    }
 
    // default to read-only, no Streaming, non-blank
    mmcData->WriteAllowed = FALSE;
    mmcData->StreamingReadSupported = FALSE;
    mmcData->StreamingWriteSupported = FALSE;
 
    // Issue command to update the drive capabilities.
    // The failure of MMC update is not considered critical,
    // so that we'll continue to process I/O even MMC update fails.
    status = DeviceGetConfiguration(Device,
                                    mmcData->CapabilitiesBuffer,
                                    mmcData->CapabilitiesBufferSize,
                                    &returnedBytes,
                                    FeatureProfileList,
                                    SCSI_GET_CONFIGURATION_REQUEST_TYPE_CURRENT);
 
    if (NT_SUCCESS(status) &&                               // succeeded.
        (mmcData->CapabilitiesBufferSize >= returnedBytes)) // not overflow.
    {
        // update whether or not writes are allowed
        // this should be the *ONLY* place writes are set to allowed
        {
            BOOLEAN         writeAllowed = FALSE;
            FEATURE_NUMBER  validationSchema = 0;
            ULONG           blockingFactor = 1;
 
            DeviceUpdateMmcWriteCapability(mmcData->CapabilitiesBuffer,
                                           returnedBytes,
                                           TRUE,
                                           &writeAllowed,
                                           &validationSchema,
                                           &blockingFactor);
 
            mmcData->WriteAllowed = writeAllowed;
            mmcData->ValidationSchema = validationSchema;
            mmcData->Blocking = blockingFactor;
        }
 
        // Check if Streaming reads/writes are supported and cache
        // this information for later use.
        {
            PFEATURE_HEADER header;
            ULONG           minAdditionalLength;
 
            minAdditionalLength = FIELD_OFFSET(FEATURE_DATA_REAL_TIME_STREAMING, Reserved2) -
                                  sizeof(FEATURE_HEADER);
 
            header = MmcDataFindFeaturePage(mmcData->CapabilitiesBuffer,
                                            returnedBytes,
                                            FeatureRealTimeStreaming);
 
            if ((header != NULL) &&
                (header->Current) &&
                (header->AdditionalLength >= minAdditionalLength))
            {
                PFEATURE_DATA_REAL_TIME_STREAMING feature = (PFEATURE_DATA_REAL_TIME_STREAMING)header;
 
                // If Real-Time feature is current, then Streaming reads are supported for sure.
                mmcData->StreamingReadSupported = TRUE;
 
                // Streaming writes are supported if an appropriate bit is set in the feature page.
                mmcData->StreamingWriteSupported = (feature->StreamRecording == 1);
            }
        }
 
        // update the flag to reflect that if the media is CSS protected DVD or CPPM-protected DVDAudio
        {
            PFEATURE_HEADER header;
 
            header = DeviceFindFeaturePage(mmcData->CapabilitiesBuffer,
                                           returnedBytes,
                                           FeatureDvdCSS);
 
            mmcData->IsCssDvd = (header != NULL) && (header->Current);
        }
 
        // Update the guesstimate for the drive's write speed
        // Use the GetConfig profile first as a quick-guess based
        // on media "type", then continue with media-specific
        // queries for older media types, and use GET_PERFORMANCE
        // for all unknown/future media types.
        {
            // pseudo-code:
            // 1) Determine default based on profile (slowest for media)
            // 2) Determine default based on MODE PAGE 2Ah
            // 3) Determine default based on GET PERFORMANCE data
            // 4) Choose fastest reported speed (-1 == none reported)
            // 5) If all failed (returned -1), go with very safe (slow) default
            //
            // This ensures that the retries do not overload the drive's processor.
            // Sending at highest possible speed for the media is OK, because the
            // major downside is drive processor usage.  (bus usage too, but most
            // storage is becoming a point-to-point link.)
 
            FEATURE_PROFILE_TYPE const profile =
                                            mmcData->CapabilitiesBuffer->CurrentProfile[0] << (8*1) |
                                            mmcData->CapabilitiesBuffer->CurrentProfile[1] << (8*0) ;
            LONGLONG t1 = (LONGLONG)-1;
            LONGLONG t2 = (LONGLONG)-1;
            LONGLONG t3 = (LONGLONG)-1;
            LONGLONG t4 = (LONGLONG)-1;
            LONGLONG final;
 
            t1 = DeviceRetryTimeGuessBasedOnProfile(profile);
            t2 = DeviceRetryTimeDetectionBasedOnModePage2A(deviceExtension);
            t3 = DeviceRetryTimeDetectionBasedOnGetPerformance(deviceExtension, TRUE);
            t4 = DeviceRetryTimeDetectionBasedOnGetPerformance(deviceExtension, FALSE);
 
            // use the "fastest" value returned
            final = MAXLONGLONG;
            if (t4 != -1)
            {
                final = min(final, t4);
            }
            if (t3 != -1)
            {
                final = min(final, t3);
            }
            if (t2 != -1)
            {
                final = min(final, t2);
            }
            if (t1 != -1)
            {
                final = min(final, t1);
            }
            if (final == MAXLONGLONG)
            {
                // worst case -- use relatively slow default....
                final = WRITE_RETRY_DELAY_CD_4x;
            }
 
            cdData->ReadWriteRetryDelay100nsUnits = final;
        }
 
    }
    else
    {
        // Rediscovery of MMC capabilities has failed - we'll need to retry
        cdData->Mmc.UpdateState = CdromMmcUpdateRequired;
    }
 
    // Change the state to CdromMmcUpdateComplete if it is CdromMmcUpdateStarted.
    // If it is not, some error must have happened while this function was executed
    // and the state is CdromMmcUpdateRequired now. In that case, we want to perform
    // everything again, so we do not set CdromMmcUpdateComplete.
    InterlockedCompareExchange((PLONG)&(cdData->Mmc.UpdateState),
                               CdromMmcUpdateComplete,
                               CdromMmcUpdateStarted);
 
    return status;
}
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceGetConfigurationWithAlloc(
    _In_ WDFDEVICE               Device,
    _Outptr_result_bytebuffer_all_(*BytesReturned)
     PGET_CONFIGURATION_HEADER*  Buffer,  // this routine allocates this memory
    _Out_ PULONG                 BytesReturned,
    FEATURE_NUMBER const         StartingFeature,
    ULONG const                  RequestedType
    )
/*++
 
Routine Description:
 
    This function will allocates configuration buffer and set the size.
 
Arguments:
 
    Device - device object
    Buffer - to be allocated by this function
    BytesReturned - size of the buffer
    StartingFeature - the starting point of the feature list
    RequestedType -
 
Return Value:
 
    NTSTATUS
 
NOTE: does not handle case where more than 65000 bytes are returned,
      which requires multiple calls with different starting feature
      numbers.
 
--*/
{
    NTSTATUS                    status = STATUS_SUCCESS;
    GET_CONFIGURATION_HEADER    header = {0};  // eight bytes, not a lot
    PGET_CONFIGURATION_HEADER   buffer = NULL;
    ULONG                       returned = 0;
    ULONG                       size = 0;
    ULONG                       i = 0;
 
    PAGED_CODE();
 
    *Buffer = NULL;
    *BytesReturned = 0;
 
    // send the first request down to just get the header
    status = DeviceGetConfiguration(Device,
                                    &header,
                                    sizeof(header),
                                    &returned,
                                    StartingFeature,
                                    RequestedType);
 
    // now send command again, using information returned to allocate just enough memory
    if (NT_SUCCESS(status))
    {
        size = header.DataLength[0] << 24 |
               header.DataLength[1] << 16 |
               header.DataLength[2] <<  8 |
               header.DataLength[3] <<  0 ;
 
        // the loop is in case that the retrieved data length is bigger than last time reported.
        for (i = 0; (i < 4) && NT_SUCCESS(status); i++)
        {
            // the datalength field is the size *following* itself, so adjust accordingly
            size += 4*sizeof(UCHAR);
 
            // make sure the size is reasonable
            if (size <= sizeof(FEATURE_HEADER))
            {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                           "DeviceGetConfigurationWithAlloc: drive reports only %x bytes?\n",
                           size));
                status = STATUS_UNSUCCESSFUL;
            }
 
            if (NT_SUCCESS(status))
            {
                // allocate the memory
                buffer = (PGET_CONFIGURATION_HEADER)ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                                                          size,
                                                                          CDROM_TAG_FEATURE);
 
                if (buffer == NULL)
                {
                    status = STATUS_INSUFFICIENT_RESOURCES;
                }
            }
 
            if (NT_SUCCESS(status))
            {
                // send the first request down to just get the header
                status = DeviceGetConfiguration(Device,
                                                buffer,
                                                size,
                                                &returned,
                                                StartingFeature,
                                                RequestedType);
 
                if (!NT_SUCCESS(status))
                {
                    ExFreePool(buffer);
                }
                else if (returned > size)
                {
                    ExFreePool(buffer);
                    status = STATUS_INTERNAL_ERROR;
                }
            }
 
            // command succeeded.
            if (NT_SUCCESS(status))
            {
                returned = buffer->DataLength[0] << 24 |
                           buffer->DataLength[1] << 16 |
                           buffer->DataLength[2] <<  8 |
                           buffer->DataLength[3] <<  0 ;
                returned += 4*sizeof(UCHAR);
 
                if (returned <= size)
                {
                    *Buffer = buffer;
                    *BytesReturned = returned;  // amount of 'safe' memory
                    // succes, get out of loop.
                    status = STATUS_SUCCESS;
                    break;
                }
                else
                {
                    // the data size is bigger than the buffer size, retry using new size....
                    size = returned;
                    ExFreePool(buffer);
                    buffer = NULL;
                }
            }
        } // end of for() loop
    }
 
    if (!NT_SUCCESS(status))
    {
        // it failed after a number of attempts, so just fail.
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                   "DeviceGetConfigurationWithAlloc: Failed %d attempts to get all feature "
                   "information\n", i));
    }
 
    return status;
}
 
_IRQL_requires_max_(PASSIVE_LEVEL)
NTSTATUS
DeviceGetConfiguration(
    _In_  WDFDEVICE                 Device,
    _Out_writes_bytes_to_(BufferSize, *ValidBytes)
          PGET_CONFIGURATION_HEADER Buffer,
    _In_  ULONG const               BufferSize,
    _Out_ PULONG                    ValidBytes,
    _In_  FEATURE_NUMBER const      StartingFeature,
    _In_  ULONG const               RequestedType
    )
/*++
 
Routine Description:
 
    This function is used to get configuration data.
 
Arguments:
 
    Device - device object
    Buffer - buffer address to hold data.
    BufferSize - size of the buffer
    ValidBytes - valid data size in buffer
    StartingFeature - the starting point of the feature list
    RequestedType -
 
Return Value:
 
    NTSTATUS
 
NOTE: does not handle case where more than 64k bytes are returned,
      which requires multiple calls with different starting feature
      numbers.
 
--*/
{
    NTSTATUS                status;
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    SCSI_REQUEST_BLOCK      srb;
    PCDB                    cdb = (PCDB)srb.Cdb;
 
    PAGED_CODE();
 
    NT_ASSERT(ValidBytes);
 
    // when system is low resources we can receive empty buffer
    if (Buffer == NULL || BufferSize < sizeof(GET_CONFIGURATION_HEADER))
    {
        return STATUS_BUFFER_TOO_SMALL;
    }
 
    *ValidBytes = 0;
 
    RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));
    RtlZeroMemory(Buffer, BufferSize);
 
    if (TEST_FLAG(deviceExtension->DeviceAdditionalData.HackFlags, CDROM_HACK_BAD_GET_CONFIG_SUPPORT))
    {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
#pragma warning(push)
#pragma warning(disable: 6386) // OACR will complain buffer overrun: the writable size is 'BufferSize' bytes, but '65532'
                               // bytes might be written, which is impossible because BufferSize > 0xFFFC.
 
    if (BufferSize > 0xFFFC)
    {
        // cannot request more than 0xFFFC bytes in one request
        // Eventually will "stitch" together multiple requests if needed
        // Today, no drive has anywhere close to 4k.....
        return DeviceGetConfiguration(Device,
                                      Buffer,
                                      0xFFFC,
                                      ValidBytes,
                                      StartingFeature,
                                      RequestedType);
    }
#pragma warning(pop)
 
    //Start real work
    srb.TimeOutValue = CDROM_GET_CONFIGURATION_TIMEOUT;
    srb.CdbLength = 10;
 
    cdb->GET_CONFIGURATION.OperationCode = SCSIOP_GET_CONFIGURATION;
    cdb->GET_CONFIGURATION.RequestType = (UCHAR)RequestedType;
    cdb->GET_CONFIGURATION.StartingFeature[0] = (UCHAR)(StartingFeature >> 8);
    cdb->GET_CONFIGURATION.StartingFeature[1] = (UCHAR)(StartingFeature & 0xff);
    cdb->GET_CONFIGURATION.AllocationLength[0] = (UCHAR)(BufferSize >> 8);
    cdb->GET_CONFIGURATION.AllocationLength[1] = (UCHAR)(BufferSize & 0xff);
 
    status = DeviceSendSrbSynchronously(Device,
                                        &srb,
                                        Buffer,
                                        BufferSize,
                                        FALSE,
                                        NULL);
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
               "DeviceGetConfiguration: Status was %x\n", status));
 
    if (NT_SUCCESS(status) ||
        (status == STATUS_BUFFER_OVERFLOW) ||
        (status == STATUS_DATA_OVERRUN))
    {
        ULONG                       returned = srb.DataTransferLength;
        PGET_CONFIGURATION_HEADER   header = (PGET_CONFIGURATION_HEADER)Buffer;
        ULONG                       available = (header->DataLength[0] << (8*3)) |
                                                (header->DataLength[1] << (8*2)) |
                                                (header->DataLength[2] << (8*1)) |
                                                (header->DataLength[3] << (8*0)) ;
 
        available += RTL_SIZEOF_THROUGH_FIELD(GET_CONFIGURATION_HEADER, DataLength);
 
        _Analysis_assume_(srb.DataTransferLength <= BufferSize);
 
        // The true usable amount of data returned is the lesser of
        // * the returned data per the srb.DataTransferLength field
        // * the total size per the GET_CONFIGURATION_HEADER
        // This is because ATAPI can't tell how many bytes really
        // were transferred on success when using DMA.
        if (available < returned)
        {
            returned = available;
        }
 
        NT_ASSERT(returned <= BufferSize);
        *ValidBytes = (ULONG)returned;
 
        //This is succeed case
        status = STATUS_SUCCESS;
    }
    else
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                   "DeviceGetConfiguration: failed %x\n", status));
    }
 
    return status;
}
 
 
_IRQL_requires_max_(APC_LEVEL)
VOID
DeviceUpdateMmcWriteCapability(
    _In_reads_bytes_(BufferSize)
        PGET_CONFIGURATION_HEADER   Buffer,
    ULONG const                     BufferSize,
    BOOLEAN const                   CurrentOnly, // TRUE == can drive write now, FALSE == can drive ever write
    _Out_ PBOOLEAN                  Writable,
    _Out_ PFEATURE_NUMBER           ValidationSchema,
    _Out_ PULONG                    BlockingFactor
    )
/*++
 
Routine Description:
 
    This function will allocates configuration buffer and set the size.
 
Arguments:
 
    Buffer -
    BufferSize - size of the buffer
    CurrentOnly - valid data size in buffer
    Writable - the buffer is allocationed in non-paged pool.
    validationSchema - the starting point of the feature list
    BlockingFactor -
 
Return Value:
 
    NTSTATUS
 
NOTE: does not handle case where more than 64k bytes are returned,
      which requires multiple calls with different starting feature
      numbers.
 
--*/
{
    //
    // this routine is used to check if the drive can currently (current==TRUE)
    // or can ever (current==FALSE) write to media with the current CDROM.SYS
    // driver.  this check parses the GET_CONFIGURATION response data to search
    // for the appropriate features and/or if they are current.
    //
    // this function should not allocate any resources, and thus may safely
    // return from any point within the function.
    //
    PAGED_CODE();
 
    *Writable = FALSE;
    *ValidationSchema = 0;
    *BlockingFactor = 1;
 
    //
    // if the drive supports hardware defect management and random writes, that's
    // sufficient to allow writes.
    //
    {
        PFEATURE_HEADER defectHeader;
        PFEATURE_HEADER writableHeader;
 
        defectHeader   = MmcDataFindFeaturePage(Buffer,
                                                BufferSize,
                                                FeatureDefectManagement);
        writableHeader = MmcDataFindFeaturePage(Buffer,
                                                BufferSize,
                                                FeatureRandomWritable);
 
        if (defectHeader == NULL || writableHeader == NULL)
        {
            // cannot write this way
        }
        else if (!CurrentOnly)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "DeviceUpdateMmcWriteCapability => Writes supported (defect management)\n"));
            *Writable = TRUE;
            return;
        }
        else if (defectHeader->Current && writableHeader->Current)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "DeviceUpdateMmcWriteCapability => Writes *allowed* (defect management)\n"));
            *Writable = TRUE;
            *ValidationSchema = FeatureDefectManagement;
            return;
        }
    }
 
    // Certain validation schema require the blocking factor
    // This is a best-effort attempt to ensure that illegal
    // requests do not make it to drive
    {
        PFEATURE_HEADER header;
        ULONG           additionalLength;
 
        // Certain validation schema require the blocking factor
        // This is a best-effort attempt to ensure  that illegal
        // requests do not make it to drive
        additionalLength = RTL_SIZEOF_THROUGH_FIELD(FEATURE_DATA_RANDOM_READABLE, Blocking) - sizeof(FEATURE_HEADER);
 
        header = MmcDataFindFeaturePage(Buffer,
                                        BufferSize,
                                        FeatureRandomReadable);
 
        if ((header != NULL) &&
            (header->Current) &&
            (header->AdditionalLength >= additionalLength))
        {
            PFEATURE_DATA_RANDOM_READABLE feature = (PFEATURE_DATA_RANDOM_READABLE)header;
            *BlockingFactor = (feature->Blocking[0] << 8) | feature->Blocking[1];
        }
    }
 
    // the majority of features to indicate write capability
    // indicate this by a single feature existance/current bit.
    // thus, can use a table-based method for the majority
    // of the detection....
    {
        typedef struct {
            FEATURE_NUMBER  FeatureToFind;    // the ones allowed
            FEATURE_NUMBER  ValidationSchema; // and their related schema
        } FEATURE_TO_WRITE_SCHEMA_MAP;
 
        static FEATURE_TO_WRITE_SCHEMA_MAP const FeaturesToAllowWritesWith[] = {
            { FeatureRandomWritable,               FeatureRandomWritable               },
            { FeatureRigidRestrictedOverwrite,     FeatureRigidRestrictedOverwrite     },
            { FeatureRestrictedOverwrite,          FeatureRestrictedOverwrite          },
            { FeatureIncrementalStreamingWritable, FeatureIncrementalStreamingWritable },
        };
 
        ULONG count;
        for (count = 0; count < RTL_NUMBER_OF(FeaturesToAllowWritesWith); count++)
        {
            PFEATURE_HEADER header = MmcDataFindFeaturePage(Buffer,
                                                            BufferSize,
                                                            FeaturesToAllowWritesWith[count].FeatureToFind);
            if (header == NULL)
            {
                // cannot write using this method
            }
            else if (!CurrentOnly)
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                            "DeviceUpdateMmcWriteCapability => Writes supported (feature %04x)\n",
                            FeaturesToAllowWritesWith[count].FeatureToFind
                            ));
                *Writable = TRUE;
                return;
            }
            else if (header->Current)
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                            "DeviceUpdateMmcWriteCapability => Writes *allowed* (feature %04x)\n",
                            FeaturesToAllowWritesWith[count].FeatureToFind
                            ));
                *Writable = TRUE;
                *ValidationSchema = FeaturesToAllowWritesWith[count].ValidationSchema;
                return;
            }
        } // end count loop
    }
 
    // unfortunately, DVD+R media doesn't require IncrementalStreamingWritable feature
    // to be explicitly set AND it has a seperate bit in the feature to indicate
    // being able to write to this media type. Thus, use a special case of the above code.
    {
        PFEATURE_DATA_DVD_PLUS_R header;
        ULONG                    additionalLength = FIELD_OFFSET(FEATURE_DATA_DVD_PLUS_R, Reserved2[0]) - sizeof(FEATURE_HEADER);
        header = MmcDataFindFeaturePage(Buffer,
                                        BufferSize,
                                        FeatureDvdPlusR);
 
        if (header == NULL || (header->Header.AdditionalLength < additionalLength) || (!header->Write))
        {
            // cannot write this way
        }
        else if (!CurrentOnly)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "DeviceUpdateMmcWriteCapability => Writes supported (feature %04x)\n",
                        FeatureDvdPlusR
                        ));
            *Writable = TRUE;
            return;
        }
        else if (header->Header.Current)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "DeviceUpdateMmcWriteCapability => Writes *allowed* (feature %04x)\n",
                        FeatureDvdPlusR
                        ));
            *Writable = TRUE;
            *ValidationSchema = FeatureIncrementalStreamingWritable;
            return;
        }
    }
 
    // unfortunately, DVD+R DL media doesn't require IncrementalStreamingWritable feature
    // to be explicitly set AND it has a seperate bit in the feature to indicate
    // being able to write to this media type. Thus, use a special case of the above code.
    {
        PFEATURE_DATA_DVD_PLUS_R_DUAL_LAYER header;
        ULONG additionalLength = FIELD_OFFSET(FEATURE_DATA_DVD_PLUS_R_DUAL_LAYER, Reserved2[0]) - sizeof(FEATURE_HEADER);
        header = MmcDataFindFeaturePage(Buffer,
                                        BufferSize,
                                        FeatureDvdPlusRDualLayer);
 
        if (header == NULL || (header->Header.AdditionalLength < additionalLength) || (!header->Write))
        {
            // cannot write this way
        }
        else if (!CurrentOnly)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "DeviceUpdateMmcWriteCapability => Writes supported (feature %04x)\n",
                        FeatureDvdPlusRDualLayer
                        ));
            *Writable = TRUE;
            return;
        }
        else if (header->Header.Current)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "DeviceUpdateMmcWriteCapability => Writes *allowed* (feature %04x)\n",
                        FeatureDvdPlusRDualLayer
                        ));
            *Writable = TRUE;
            *ValidationSchema = FeatureIncrementalStreamingWritable;
            return;
        }
    }
 
    // There are currently a number of drives on the market
    // that fail to report:
    // (a) FeatureIncrementalStreamingWritable as current
    //     for CD-R / DVD-R profile.
    // (b) FeatureRestrictedOverwrite as current for CD-RW
    //     profile
    // (c) FeatureRigidRestrictedOverwrite as current for
    //     DVD-RW profile
    //
    // Thus, use the profiles also.
    {
        PFEATURE_HEADER header;
        header = MmcDataFindFeaturePage(Buffer,
                                        BufferSize,
                                        FeatureProfileList);
 
        if (header != NULL && header->Current)
        {
            // verify buffer bounds -- the below routine presumes full profile list provided
            PUCHAR bufferEnd = ((PUCHAR)Buffer) + BufferSize;
            PUCHAR headerEnd = ((PUCHAR)header) + header->AdditionalLength + RTL_SIZEOF_THROUGH_FIELD(FEATURE_HEADER, AdditionalLength);
            if (bufferEnd >= headerEnd) // this _should_ never occurr, but....
            {
                // Profiles don't contain any data other than current/not current.
                // thus, can generically loop through them to see if any of the
                // below (in order of preference) are current.
                typedef struct {
                    FEATURE_PROFILE_TYPE ProfileToFind;    // the ones allowed
                    FEATURE_NUMBER       ValidationSchema; // and their related schema
                } PROFILE_TO_WRITE_SCHEMA_MAP;
 
                static PROFILE_TO_WRITE_SCHEMA_MAP const ProfilesToAllowWritesWith[] = {
                    { ProfileDvdRewritable,  FeatureRigidRestrictedOverwrite     },
                    { ProfileCdRewritable,   FeatureRestrictedOverwrite },
                    { ProfileDvdRecordable,  FeatureIncrementalStreamingWritable },
                    { ProfileCdRecordable,   FeatureIncrementalStreamingWritable },
                };
 
                ULONG count;
                for (count = 0; count < RTL_NUMBER_OF(ProfilesToAllowWritesWith); count++)
                {
                    BOOLEAN exists = FALSE;
                    MmcDataFindProfileInProfiles((PFEATURE_DATA_PROFILE_LIST)header,
                                                 ProfilesToAllowWritesWith[count].ProfileToFind,
                                                 CurrentOnly,
                                                 &exists);
                    if (exists)
                    {
                        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                                    "DeviceUpdateMmcWriteCapability => Writes %s (profile %04x)\n",
                                    (CurrentOnly ? "*allowed*" : "supported"),
                                    FeatureDvdPlusR
                                    ));
 
                        *Writable = TRUE;
                        *ValidationSchema = ProfilesToAllowWritesWith[count].ValidationSchema;
                        return;
                    }
                } // end count loop
            } // end if (bufferEnd >= headerEnd)
 
        } // end if (header != NULL && header->Current)
    }
 
    // nothing matched to say it's writable.....
    return;
}
 
_IRQL_requires_max_(APC_LEVEL)
PVOID
MmcDataFindFeaturePage(
    _In_reads_bytes_(Length)
        PGET_CONFIGURATION_HEADER   FeatureBuffer,
    ULONG const                     Length,
    FEATURE_NUMBER const            Feature
    )
/*++
 
Routine Description:
 
    search the specific feature from feature list buffer
 
Arguments:
 
    FeatureBuffer - buffer of feature list
    Length - size of the buffer
    Feature - feature wanted to find
 
Return Value:
 
    PVOID - if found, pointer of starting address of the specific feature.
            otherwise, NULL.
 
--*/
{
    PUCHAR buffer;
    PUCHAR limit;
    ULONG  validLength;
 
    PAGED_CODE();
 
    if (Length < sizeof(GET_CONFIGURATION_HEADER) + sizeof(FEATURE_HEADER)) {
        return NULL;
    }
 
    // Calculate the length of valid data available in the
    // capabilities buffer from the DataLength field
    REVERSE_BYTES(&validLength, FeatureBuffer->DataLength);
    validLength += RTL_SIZEOF_THROUGH_FIELD(GET_CONFIGURATION_HEADER, DataLength);
 
    // set limit to point to first illegal address
    limit  = (PUCHAR)FeatureBuffer;
    limit += min(Length, validLength);
 
    // set buffer to point to first page
    buffer = FeatureBuffer->Data;
 
    // loop through each page until we find the requested one, or
    // until it's not safe to access the entire feature header
    // (if equal, have exactly enough for the feature header)
    while (buffer + sizeof(FEATURE_HEADER) <= limit)
    {
        PFEATURE_HEADER header = (PFEATURE_HEADER)buffer;
        FEATURE_NUMBER  thisFeature;
 
        thisFeature  = (header->FeatureCode[0] << 8) |
                       (header->FeatureCode[1]);
 
        if (thisFeature == Feature)
        {
            PUCHAR temp;
 
            // if don't have enough memory to safely access all the feature
            // information, return NULL
            temp = buffer;
            temp += sizeof(FEATURE_HEADER);
            temp += header->AdditionalLength;
 
            if (temp > limit)
            {
                // this means the transfer was cut-off, an insufficiently
                // small buffer was given, or other arbitrary error.  since
                // it's not safe to view the amount of data (even though
                // the header is safe) in this feature, pretend it wasn't
                // transferred at all...
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                           "Feature %x exists, but not safe to access all its "
                           "data.  returning NULL\n", Feature));
                return NULL;
            }
            else
            {
                return buffer;
            }
        }
 
        if ((header->AdditionalLength % 4) &&
            !(Feature >= 0xff00 && Feature <= 0xffff))
        {
            return NULL;
        }
 
        buffer += sizeof(FEATURE_HEADER);
        buffer += header->AdditionalLength;
 
    }
    return NULL;
}
 
_IRQL_requires_max_(APC_LEVEL)
VOID
MmcDataFindProfileInProfiles(
    _In_ FEATURE_DATA_PROFILE_LIST const* ProfileHeader,
    _In_ FEATURE_PROFILE_TYPE const       ProfileToFind,
    _In_ BOOLEAN const                    CurrentOnly,
    _Out_ PBOOLEAN                        Found
    )
/*++
 
Routine Description:
 
    search the specific feature from feature list buffer
 
Arguments:
 
    ProfileHeader - buffer of profile list
    ProfileToFind - profile to be found
    CurrentOnly -
 
Return Value:
 
    Found - found or not
 
--*/
{
    FEATURE_DATA_PROFILE_LIST_EX const * profile;
    ULONG numberOfProfiles;
    ULONG i;
 
    PAGED_CODE();
 
    // initialize output
    *Found = FALSE;
 
    // sanity check
    if (ProfileHeader->Header.AdditionalLength % 2 != 0)
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                   "Profile total length %x is not integral multiple of 4\n",
                   ProfileHeader->Header.AdditionalLength));
        NT_ASSERT(FALSE);
        return;
    }
 
    // calculate number of profiles
    numberOfProfiles = ProfileHeader->Header.AdditionalLength / 4;
    profile = ProfileHeader->Profiles; // zero-sized array
 
    // loop through profiles
    for (i = 0; i < numberOfProfiles; i++)
    {
        FEATURE_PROFILE_TYPE currentProfile;
 
        currentProfile = (profile->ProfileNumber[0] << 8) |
                         (profile->ProfileNumber[1] & 0xff);
 
        if (currentProfile == ProfileToFind)
        {
            if (profile->Current || (!CurrentOnly))
            {
                *Found = TRUE;
            }
        }
 
        profile++;
    }
 
    return;
}
 
_IRQL_requires_max_(APC_LEVEL)
_Ret_range_(-1,MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS)
LONGLONG
DeviceRetryTimeGuessBasedOnProfile(
    FEATURE_PROFILE_TYPE const Profile
    )
/*++
 
Routine Description:
 
    determine the retry time based on profile
 
Arguments:
 
    Profile -
 
Return Value:
 
    LONGLONG - retry time
 
--*/
{
    LONGLONG result = -1; // this means we have no idea
 
    PAGED_CODE();
 
    switch (Profile)
    {
    case ProfileInvalid:               // = 0x0000,
    case ProfileNonRemovableDisk:      // = 0x0001,
    case ProfileRemovableDisk:         // = 0x0002,
    case ProfileMOErasable:            // = 0x0003,
    case ProfileMOWriteOnce:           // = 0x0004,
    case ProfileAS_MO:                 // = 0x0005,
    // Reserved                             0x0006 - 0x0007,
    // Reserved                             0x000b - 0x000f,
    // Reserved                             0x0017 - 0x0019
    // Reserved                             0x001C - 001F
    // Reserved                             0x0023 - 0x0029
    // Reserved                             0x002C - 0x003F
    // Reserved                             0x0044 - 0x004F
    // Reserved                             0x0053 - 0xfffe
    case ProfileNonStandard:          //  = 0xffff
    default:
    {
        NOTHING; // no default
        break;
    }
 
    case ProfileCdrom:                 // = 0x0008,
    case ProfileCdRecordable:          // = 0x0009,
    case ProfileCdRewritable:          // = 0x000a,
    case ProfileDDCdrom:               // = 0x0020, // obsolete
    case ProfileDDCdRecordable:        // = 0x0021, // obsolete
    case ProfileDDCdRewritable:        // = 0x0022, // obsolete
    {
        // 4x is ok as all CD drives have
        // at least 64k*4 (256k) buffer
        // and this is just a first-pass
        // guess based only on profile
        result = WRITE_RETRY_DELAY_CD_4x;
        break;
    }
    case ProfileDvdRom:                // = 0x0010,
    case ProfileDvdRecordable:         // = 0x0011,
    case ProfileDvdRam:                // = 0x0012,
    case ProfileDvdRewritable:         // = 0x0013,  // restricted overwrite
    case ProfileDvdRWSequential:       // = 0x0014,
    case ProfileDvdDashRLayerJump:     // = 0x0016,
    case ProfileDvdPlusRW:             // = 0x001A,
    case ProfileDvdPlusR:              // = 0x001B,
    {
        result = WRITE_RETRY_DELAY_DVD_1x;
        break;
    }
    case ProfileDvdDashRDualLayer:     // = 0x0015,
    case ProfileDvdPlusRWDualLayer:    // = 0x002A,
    case ProfileDvdPlusRDualLayer:     // = 0x002B,
    {
        result = WRITE_RETRY_DELAY_DVD_1x;
        break;
    }
 
    case ProfileBDRom:                 // = 0x0040,
    case ProfileBDRSequentialWritable: // = 0x0041,  // BD-R 'SRM'
    case ProfileBDRRandomWritable:     // = 0x0042,  // BD-R 'RRM'
    case ProfileBDRewritable:          // = 0x0043,
    {
        // I could not find specifications for the
        // minimal 1x data rate for BD media.  Use
        // HDDVD values for now, since they are
        // likely to be similar.  Also, all media
        // except for CD, DVD, and AS-MO should
        // already fully support GET_CONFIG, so
        // this guess is only used if we fail to
        // get a performance descriptor....
        result = WRITE_RETRY_DELAY_HDDVD_1x;
        break;
    }
 
    case ProfileHDDVDRom:              // = 0x0050,
    case ProfileHDDVDRecordable:       // = 0x0051,
    case ProfileHDDVDRam:              // = 0x0052,
    {
        // All HDDVD drives support GET_PERFORMANCE
        // so this guess is fine at 1x....
        result = WRITE_RETRY_DELAY_HDDVD_1x;
        break;
    }
 
    // addition of any further profile types is not
    // technically required as GET PERFORMANCE
    // should succeed for all future drives.  However,
    // it is useful in case GET PERFORMANCE does
    // fail for other reasons (i.e. bus resets, etc)
 
    } // end switch(Profile)
 
    return result;
}
 
_IRQL_requires_max_(APC_LEVEL)
_Ret_range_(-1,MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS)
LONGLONG
DeviceRetryTimeDetectionBasedOnModePage2A(
    _In_ PCDROM_DEVICE_EXTENSION DeviceExtension
    )
/*++
 
Routine Description:
 
    determine the retry time based on mode sense data
 
Arguments:
 
    DeviceExtension - device context
 
Return Value:
 
    LONGLONG - retry time
 
--*/
{
    NTSTATUS    status;
    ULONG       transferSize = min(0xFFF0, DeviceExtension->ScratchContext.ScratchBufferSize);
    CDB         cdb;
    LONGLONG    result = -1;
 
    PAGED_CODE();
 
    ScratchBuffer_BeginUse(DeviceExtension);
 
    RtlZeroMemory(&cdb, sizeof(CDB));
    // Set up the CDB
    cdb.MODE_SENSE10.OperationCode = SCSIOP_MODE_SENSE10;
    cdb.MODE_SENSE10.Dbd           = 1;
    cdb.MODE_SENSE10.PageCode      = MODE_PAGE_CAPABILITIES;
    cdb.MODE_SENSE10.AllocationLength[0] = (UCHAR)(transferSize >> 8);
    cdb.MODE_SENSE10.AllocationLength[1] = (UCHAR)(transferSize & 0xFF);
 
    status = ScratchBuffer_ExecuteCdb(DeviceExtension, NULL, transferSize, TRUE, &cdb, 10);
 
    // analyze the data on success....
    if (NT_SUCCESS(status))
    {
        MODE_PARAMETER_HEADER10 const* header = DeviceExtension->ScratchContext.ScratchBuffer;
        CDVD_CAPABILITIES_PAGE const*  page = NULL;
        ULONG dataLength = (header->ModeDataLength[0] << (8*1)) |
                           (header->ModeDataLength[1] << (8*0)) ;
 
        // no possible overflow
        if (dataLength != 0)
        {
            dataLength += RTL_SIZEOF_THROUGH_FIELD(MODE_PARAMETER_HEADER10, ModeDataLength);
        }
 
        // If it's not abundantly clear, we really don't trust the drive
        // to be returning valid data.  Get the page pointer and usable
        // size of the page here...
        if (dataLength < sizeof(MODE_PARAMETER_HEADER10))
        {
            dataLength = 0;
        }
        else if (dataLength > DeviceExtension->ScratchContext.ScratchBufferSize)
        {
            dataLength = 0;
        }
        else if ((header->BlockDescriptorLength[1] == 0) &&
                 (header->BlockDescriptorLength[0] == 0))
        {
            dataLength -= sizeof(MODE_PARAMETER_HEADER10);
            page = (CDVD_CAPABILITIES_PAGE const *)(header + 1);
        }
        else if ((header->BlockDescriptorLength[1] == 0) &&
                 (header->BlockDescriptorLength[0] == sizeof(MODE_PARAMETER_BLOCK)))
        {
            dataLength -= sizeof(MODE_PARAMETER_HEADER10);
            dataLength -= min(dataLength, sizeof(MODE_PARAMETER_BLOCK));
            page = (CDVD_CAPABILITIES_PAGE const *)
                                            ( ((PUCHAR)header) +
                                              sizeof(MODE_PARAMETER_HEADER10) +
                                              sizeof(MODE_PARAMETER_BLOCK)
                                              );
        }
 
        // Change dataLength from the size available per the header to
        // the size available per the page itself.
        if ((page != NULL) &&
            (dataLength >= RTL_SIZEOF_THROUGH_FIELD(CDVD_CAPABILITIES_PAGE, PageLength))
            )
        {
            dataLength = min(dataLength, ((ULONG)(page->PageLength) + 2));
        }
 
        // Ignore the page if the fastest write speed field isn't available.
        if ((page != NULL) &&
            (dataLength < RTL_SIZEOF_THROUGH_FIELD(CDVD_CAPABILITIES_PAGE, WriteSpeedMaximum))
            )
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT,
                        "ModePage 2Ah was requested, but drive reported "
                        "only %x bytes (%x needed). Ignoring.\n",
                        dataLength,
                        RTL_SIZEOF_THROUGH_FIELD(CDVD_CAPABILITIES_PAGE, WriteSpeedMaximum)
                        ));
            page = NULL;
        }
 
        // Verify the page we requested is the one the drive actually provided
        if ((page != NULL) && (page->PageCode != MODE_PAGE_CAPABILITIES))
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_INIT,
                        "ModePage 2Ah was requested, but drive reported "
                        "page %x\n",
                        page->PageCode
                        ));
            page = NULL;
        }
 
        // If _everything_ succeeded, then use the speed value in the page!
        if (page != NULL)
        {
            ULONG temp =
                (page->WriteSpeedMaximum[0] << (8*1)) |
                (page->WriteSpeedMaximum[1] << (8*0)) ;
            // stored as 1,000 byte increments...
            temp *= 1000;
            // typically stored at 2448 bytes/sector due to CD media
            // error up to 20% high by presuming it returned 2048 data
            // and convert to sectors/second
            temp /= 2048;
            // currently: sectors/sec
            // ignore too-small or zero values
            if (temp != 0)
            {
                result = ConvertSectorsPerSecondTo100nsUnitsFor64kWrite(temp);
            }
        }
    }
 
    ScratchBuffer_EndUse(DeviceExtension);
 
    return result;
}
 
 
_IRQL_requires_max_(APC_LEVEL)
_Ret_range_(-1,MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS)
LONGLONG
DeviceRetryTimeDetectionBasedOnGetPerformance(
    _In_ PCDROM_DEVICE_EXTENSION DeviceExtension,
    _In_ BOOLEAN                 UseLegacyNominalPerformance
    )
/*++
 
Routine Description:
 
    determine the retry time based on get performance data
 
Arguments:
 
    DeviceExtension - device context
    UseLegacyNominalPerformance -
 
Return Value:
 
    LONGLONG - retry time
 
--*/
{
    typedef struct _GET_PERFORMANCE_HEADER {
        UCHAR TotalDataLength[4]; // not including this field
        UCHAR Except : 1;
        UCHAR Write  : 1;
        UCHAR Reserved0 : 6;
        UCHAR Reserved1[3];
    } GET_PERFORMANCE_HEADER, *PGET_PERFORMANCE_HEADER;
    C_ASSERT( sizeof(GET_PERFORMANCE_HEADER) == 8);
 
    typedef struct _GET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR {
        UCHAR StartLba[4];
        UCHAR StartPerformance[4];
        UCHAR EndLba[4];
        UCHAR EndPerformance[4];
    } GET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR, *PGET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR;
    C_ASSERT( sizeof(GET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR) == 16);
 
 
    typedef struct _GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR {
        UCHAR MixedReadWrite          : 1;
        UCHAR GuaranteedForWholeMedia : 1;
        UCHAR Reserved0_RDD           : 1;
        UCHAR WriteRotationControl    : 2;
        UCHAR Reserved1               : 3;
        UCHAR Reserved2[3];
 
        UCHAR MediaCapacity[4];
        UCHAR ReadSpeedKilobytesPerSecond[4];
        UCHAR WriteSpeedKilobytesPerSecond[4];
    } GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR, *PGET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR;
    C_ASSERT( sizeof(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR) == 16);
 
 
    NTSTATUS    status;
    LONGLONG    result = -1;
 
    // transfer size -- descriptors + 8 byte header
    // Note: this size is identical for both descriptor types
    C_ASSERT( sizeof(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR) == sizeof(GET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR));
 
    ULONG const maxDescriptors = min(200, (DeviceExtension->ScratchContext.ScratchBufferSize-sizeof(GET_PERFORMANCE_HEADER))/sizeof(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR));
    ULONG       validDescriptors = 0;
    ULONG       transferSize = sizeof(GET_PERFORMANCE_HEADER) + (maxDescriptors*sizeof(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR));
    CDB         cdb;
 
    PAGED_CODE();
 
    ScratchBuffer_BeginUse(DeviceExtension);
 
    RtlZeroMemory(&cdb, sizeof(CDB));
    // Set up the CDB
    if (UseLegacyNominalPerformance)
    {
        cdb.GET_PERFORMANCE.OperationCode = SCSIOP_GET_PERFORMANCE;
        cdb.GET_PERFORMANCE.Except = 0;
        cdb.GET_PERFORMANCE.Write = 1;
        cdb.GET_PERFORMANCE.Tolerance = 2; // only defined option
        cdb.GET_PERFORMANCE.MaximumNumberOfDescriptors[1] = (UCHAR)maxDescriptors;
        cdb.GET_PERFORMANCE.Type = 0; // legacy nominal descriptors
    }
    else
    {
        cdb.GET_PERFORMANCE.OperationCode = SCSIOP_GET_PERFORMANCE;
        cdb.GET_PERFORMANCE.MaximumNumberOfDescriptors[1] = (UCHAR)maxDescriptors;
        cdb.GET_PERFORMANCE.Type = 3; // write speed
    }
 
    status = ScratchBuffer_ExecuteCdbEx(DeviceExtension, NULL, transferSize, TRUE, &cdb, 12, CDROM_GET_PERFORMANCE_TIMEOUT);
 
    // determine how many valid descriptors there actually are
    if (NT_SUCCESS(status))
    {
        GET_PERFORMANCE_HEADER const* header = (GET_PERFORMANCE_HEADER const*)DeviceExtension->ScratchContext.ScratchBuffer;
        ULONG temp1 = (header->TotalDataLength[0] << (8*3)) |
                      (header->TotalDataLength[1] << (8*2)) |
                      (header->TotalDataLength[2] << (8*1)) |
                      (header->TotalDataLength[3] << (8*0)) ;
 
        // adjust data size for header
        if (temp1 + (ULONG)RTL_SIZEOF_THROUGH_FIELD(GET_PERFORMANCE_HEADER, TotalDataLength) < temp1)
        {
            temp1 = 0;
        }
        else if (temp1 != 0)
        {
            temp1 += RTL_SIZEOF_THROUGH_FIELD(GET_PERFORMANCE_HEADER, TotalDataLength);
        }
 
        if (temp1 == 0)
        {
            // no data returned
        }
        else if (temp1 <= sizeof(GET_PERFORMANCE_HEADER))
        {
            // only the header returned, no descriptors
        }
        else if (UseLegacyNominalPerformance &&
                 ((header->Except != 0) || (header->Write == 0))
                 )
        {
            // bad data being returned -- ignore it
        }
        else if (!UseLegacyNominalPerformance &&
                 ((header->Except != 0) || (header->Write != 0))
                 )
        {
            // returning Performance (Type 0) data, not requested Write Speed (Type 3) data
        }
        else if ( (temp1 - sizeof(GET_PERFORMANCE_HEADER)) % sizeof(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR) != 0)
        {
            // Note: this size is identical for both descriptor types
            C_ASSERT( sizeof(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR) == sizeof(GET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR));
 
            // not returning valid data....
        }
        else // save how many are usable
        {
            // Note: this size is identical for both descriptor types
            C_ASSERT( sizeof(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR) == sizeof(GET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR));
 
            // take the smaller usable value
            temp1 = min(temp1, DeviceExtension->ScratchContext.ScratchSrb->DataTransferLength);
            // then determine the usable descriptors
            validDescriptors = (temp1 - sizeof(GET_PERFORMANCE_HEADER)) / sizeof(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR);
        }
    }
 
    // The drive likely supports this command.
    // Verify the data makes sense.
    if (NT_SUCCESS(status))
    {
        ULONG       i;
        GET_PERFORMANCE_HEADER const*                 header = (GET_PERFORMANCE_HEADER const*)DeviceExtension->ScratchContext.ScratchBuffer;
        GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR const* descriptor = (GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR const*)(header+1); // pointer math
 
        // NOTE: We could write this loop twice, once for each write descriptor type
        //       However, the only fields of interest are the writeKBps field (Type 3) and
        //       the EndPerformance field (Type 0), which both exist in the same exact
        //       location and have essentially the same meaning.  So, just use the same
        //       loop/structure pointers for both of the to simplify the readability of
        //       this code.  The C_ASSERT()s here verify this at compile-time.
 
        C_ASSERT( sizeof(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR) == sizeof(GET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR));
        C_ASSERT( FIELD_OFFSET(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR, WriteSpeedKilobytesPerSecond) ==
                  FIELD_OFFSET(GET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR, EndPerformance)
                  );
        C_ASSERT( RTL_FIELD_SIZE(GET_PERFORMANCE_WRITE_SPEED_DESCRIPTOR, WriteSpeedKilobytesPerSecond) ==
                  RTL_FIELD_SIZE(GET_PERFORMANCE_NOMINAL_PERFORMANCE_DESCRIPTOR, EndPerformance)
                  );
 
        // loop through them all, and find the fastest listed write speed
        for (i = 0; NT_SUCCESS(status) && (i <validDescriptors); descriptor++, i++)
        {
            ULONG const writeKBps =
                (descriptor->WriteSpeedKilobytesPerSecond[0] << (8*3)) |
                (descriptor->WriteSpeedKilobytesPerSecond[1] << (8*2)) |
                (descriptor->WriteSpeedKilobytesPerSecond[2] << (8*1)) |
                (descriptor->WriteSpeedKilobytesPerSecond[3] << (8*0)) ;
 
            // Avoid overflow and still have good estimates
            // 0x1 0000 0000 / 1000  == 0x00418937 == maximum writeKBps to multiple first
            ULONG const sectorsPerSecond =
                (writeKBps > 0x00418937) ? // would overflow occur by multiplying by 1000?
                ((writeKBps / 2048) * 1000) : // must divide first, minimal loss of accuracy
                ((writeKBps * 1000) / 2048) ; // must multiply first, avoid loss of accuracy
 
            if (sectorsPerSecond <= 0)
            {
                break; // out of the loop -- no longer valid data (very defensive programming)
            }
 
            // we have at least one valid result, so prevent returning -1 as our result
            if (result == -1) { result = MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS; }
 
            // take the fastest speed (smallest wait time) we've found thus far
            result = min(result, ConvertSectorsPerSecondTo100nsUnitsFor64kWrite(sectorsPerSecond));
        }
    }
 
    ScratchBuffer_EndUse(DeviceExtension);
 
    return result;
}
 
#pragma warning(pop) // un-sets any local warning changes