utils.c File Reference

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

Include dependency graph for utils.c:

Go to the source code of this file.

Macros
#define	FIRMWARE_ACTIVATE_TIMEOUT_VALUE   30

Functions
BOOLEAN	ClasspMyStringMatches (_In_opt_z_ PCHAR StringToMatch, _In_z_ PCHAR TargetString)
	_IRQL_requires_max_ (PASSIVE_LEVEL)
VOID	ClasspPerfIncrementErrorCount (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID	ClasspPerfIncrementSuccessfulIo (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
PMDL	ClasspBuildDeviceMdl (PVOID Buffer, ULONG BufferLen, BOOLEAN WriteToDevice)
PMDL	BuildDeviceInputMdl (PVOID Buffer, ULONG BufferLen)
VOID	ClasspFreeDeviceMdl (PMDL Mdl)
VOID	FreeDeviceInputMdl (PMDL Mdl)
NTSTATUS	ClasspDuidGetDeviceIdProperty (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS	ClasspDuidGetDeviceProperty (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	ClasspDuidGetDriveLayout (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	ClasspDuidQueryProperty (PDEVICE_OBJECT DeviceObject, PIRP Irp)
NTSTATUS	ClasspWriteCacheProperty (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
ULONG	ClasspCalculateLogicalSectorSize (_In_ PDEVICE_OBJECT Fdo, _In_ ULONG BytesPerBlockInBigEndian)
NTSTATUS	InterpretReadCapacity16Data (_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PREAD_CAPACITY16_DATA ReadCapacity16Data)
NTSTATUS	ClassReadCapacity16 (_Inout_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspAccessAlignmentProperty (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
static NTSTATUS	IncursSeekPenalty (_In_ USHORT MediumRotationRate, _In_ PBOOLEAN IncursSeekPenalty)
NTSTATUS	ClasspDeviceMediaTypeProperty (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceGetBlockDeviceCharacteristicsVPDPage (_In_ PFUNCTIONAL_DEVICE_EXTENSION fdoExtension, _In_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceSeekPenaltyProperty (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceGetLBProvisioningVPDPage (_In_ PDEVICE_OBJECT DeviceObject, _Inout_opt_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceGetBlockLimitsVPDPage (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _Inout_bytecount_(SrbSize) PSCSI_REQUEST_BLOCK Srb, _In_ ULONG SrbSize, _Out_ PCLASS_VPD_B0_DATA BlockLimitsData)
NTSTATUS	ClasspDeviceTrimProperty (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceLBProvisioningProperty (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
VOID	ConvertDataSetRangeToUnmapBlockDescr (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PUNMAP_BLOCK_DESCRIPTOR BlockDescr, _Inout_ PULONG CurrentBlockDescrIndex, _In_ ULONG MaxBlockDescrIndex, _Inout_ PULONGLONG CurrentLbaCount, _In_ ULONGLONG MaxLbaCount, _Inout_ PDEVICE_DATA_SET_RANGE DataSetRange)
NTSTATUS	DeviceProcessDsmTrimRequest (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PDEVICE_DATA_SET_RANGE DataSetRanges, _In_ ULONG DataSetRangesCount, _In_ ULONG UnmapGranularity, _In_ ULONG SrbFlags, _In_ PIRP Irp, _In_ PGUID ActivityId, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceTrimProcess (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_ PGUID ActivityId, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	GetLBAStatus (_In_ PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONGLONG StartingLBA, _Inout_ PLBA_STATUS_LIST_HEADER LBAStatusHeader, _In_ ULONG LBAStatusSize, _In_ BOOLEAN ConsolidateableBlocksOnly)
NTSTATUS	ClasspDeviceGetLBAStatus (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspDeviceGetLBAStatusWorker (_In_ PDEVICE_OBJECT DeviceObject, _In_ PCLASS_VPD_B0_DATA BlockLimitsData, _In_ ULONGLONG StartingOffset, _In_ ULONGLONG LengthInBytes, _Out_ PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT DsmOutput, _Inout_ PULONG DsmOutputLength, _Inout_ PSCSI_REQUEST_BLOCK Srb, _In_ BOOLEAN ConsolidateableBlocksOnly, _In_ ULONG OutputVersion, _Out_ PBOOLEAN BlockLimitsDataMayHaveChanged)
NTSTATUS	ClassGetLBProvisioningLogPage (_In_ PDEVICE_OBJECT DeviceObject, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONG LogPageSize, _Inout_ PLOG_PAGE_LOGICAL_BLOCK_PROVISIONING LogPage)
NTSTATUS	ClassInterpretLBProvisioningLogPage (_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG LogPageSize, _In_ PLOG_PAGE_LOGICAL_BLOCK_PROVISIONING LogPage, _In_ ULONG ResourcesSize, _Out_ PSTORAGE_LB_PROVISIONING_MAP_RESOURCES Resources)
NTSTATUS	ClassGetLBProvisioningResources (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONG ResourcesSize, _Inout_ PSTORAGE_LB_PROVISIONING_MAP_RESOURCES Resources)
NTSTATUS	ClassDeviceGetLBProvisioningResources (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
	_Function_class_ (IO_WORKITEM_ROUTINE)
NTSTATUS	ClasspLogSystemEventWithDeviceNumber (_In_ PDEVICE_OBJECT DeviceObject, _In_ NTSTATUS IoErrorCode)
VOID	ClassQueueThresholdEventWorker (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClassQueueResourceExhaustionEventWorker (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClassQueueCapacityChangedEventWorker (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClassQueueProvisioningTypeChangedEventWorker (_In_ PDEVICE_OBJECT DeviceObject)
VOID	ClasspQueueLogIOEventWithContextWorker (_In_ PDEVICE_OBJECT DeviceObject, _In_ ULONG SenseBufferSize, _In_ PVOID SenseData, _In_ UCHAR SrbStatus, _In_ UCHAR ScsiStatus, _In_ ULONG ErrorCode, _In_ ULONG CdbLength, _In_opt_ PCDB Cdb, _In_opt_ PTRANSFER_PACKET Pkt)
static BOOLEAN	ValidPersistentReserveScope (UCHAR Scope)
static BOOLEAN	ValidPersistentReserveType (UCHAR Type)
NTSTATUS	ClasspPersistentReserve (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClasspPriorityHint (PDEVICE_OBJECT DeviceObject, PIRP Irp)
VOID	ClasspConvertToScsiRequestBlock (_Out_ PSCSI_REQUEST_BLOCK Srb, _In_ PSTORAGE_REQUEST_BLOCK SrbEx)
	_IRQL_requires_max_ (APC_LEVEL)
_IRQL_requires_same_ NTSTATUS	ClasspGetTokenOperationCommandBufferLength (_In_ PDEVICE_OBJECT Fdo, _In_ ULONG ServiceAction, _Inout_ PULONG CommandBufferLength, _Out_opt_ PULONG TokenOperationBufferLength, _Out_opt_ PULONG ReceiveTokenInformationBufferLength)
_IRQL_requires_same_ NTSTATUS	ClasspGetTokenOperationDescriptorLimits (_In_ PDEVICE_OBJECT Fdo, _In_ ULONG ServiceAction, _In_ ULONG MaxParameterBufferLength, _Out_ PULONG MaxBlockDescriptorsCount, _Out_ PULONGLONG MaxBlockDescriptorsLength)
_IRQL_requires_same_ PUCHAR	ClasspBinaryToAscii (_In_reads_(Length) PUCHAR HexBuffer, _In_ ULONG Length, _Inout_ PULONG UpdateLength)
_IRQL_requires_same_ NTSTATUS	ClasspStorageEventNotification (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp)
VOID	ClasspZeroQERR (_In_ PDEVICE_OBJECT DeviceObject)
NTSTATUS	ClasspGetHwFirmwareInfo (_In_ PDEVICE_OBJECT DeviceObject)
__inline BOOLEAN	ClassDeviceHwFirmwareIsPortDriverSupported (_In_ PDEVICE_OBJECT DeviceObject)
NTSTATUS	ClassDeviceHwFirmwareGetInfoProcess (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp)
_IRQL_requires_same_	_IRQL_requires_max_ (DISPATCH_LEVEL)
NTSTATUS	ClassDeviceHwFirmwareDownloadProcess (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
NTSTATUS	ClassDeviceHwFirmwareActivateProcess (_In_ PDEVICE_OBJECT DeviceObject, _Inout_ PIRP Irp, _Inout_ PSCSI_REQUEST_BLOCK Srb)
BOOLEAN	ClasspIsThinProvisioningError (_In_ PSCSI_REQUEST_BLOCK Srb)

Macro Definition Documentation

FIRMWARE_ACTIVATE_TIMEOUT_VALUE

#define FIRMWARE_ACTIVATE_TIMEOUT_VALUE   30

Definition at line 37 of file utils.c.

Function Documentation

_Function_class_()

_Function_class_

(

IO_WORKITEM_ROUTINE

)

Definition at line 5136 of file utils.c.

{
    NTSTATUS status = STATUS_SUCCESS;
    PIO_WORKITEM workItem = (PIO_WORKITEM)Context;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PSCSI_REQUEST_BLOCK srb = NULL;
    STORAGE_LB_PROVISIONING_MAP_RESOURCES resources = {0};
    ULONG resourcesSize = sizeof(STORAGE_LB_PROVISIONING_MAP_RESOURCES);
    PIO_ERROR_LOG_PACKET errorLogEntry = NULL;
    ULONG logEntrySize = sizeof(IO_ERROR_LOG_PACKET);
    PWCHAR stringIndex = NULL;
    LONG stringSize = 0;
    ULONG srbSize;
 
    //
    // Allocate an SRB for getting the LBP log page.
    //
    if ((fdoExtension->AdapterDescriptor != NULL) &&
        (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK)) {
        srbSize = CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE;
    } else {
        srbSize = sizeof(SCSI_REQUEST_BLOCK);
    }
 
    srb = ExAllocatePoolWithTag(NonPagedPoolNx,
                                srbSize,
                                'ACcS');
    if (srb != NULL) {
 
        //
        // Try to get the LBP resources from the device so we can report them in
        // the system event log.
        //
        ClassGetLBProvisioningResources(DeviceObject,
                                        srb,
                                        resourcesSize,
                                        &resources);
 
        //
        // We need to allocate enough space for 3 insertion strings:
        // The first is a ULONG representing the disk number in decimal, which means
        // a max of 10 digits, plus one for the NULL character.
        // The second and third are ULONGLONGs representing the used and available
        // bytes, which means a max of 20 digits, plus one for the NULL character.
        // Make sure we do not exceed the max error log size or the max size of a
        // UCHAR since the size gets truncated to a UCHAR when we pass it to
        // IoAllocateErrorLogEntry().
        //
        logEntrySize = sizeof(IO_ERROR_LOG_PACKET) + (11 * sizeof(WCHAR)) + (2 * (21 * sizeof(WCHAR)));
        logEntrySize = min(logEntrySize, ERROR_LOG_MAXIMUM_SIZE);
        logEntrySize = min(logEntrySize, MAXUCHAR);
 
        errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(DeviceObject, (UCHAR)logEntrySize);
        if (errorLogEntry != NULL)
        {
            //
            // There are two event IDs we can use here.  Both use the disk number,
            // but one reports the available and used bytes while the other does not.
            // We fall back on the latter if we failed to obtain the available and
            // used byte counts from the LBP log page.
            //
            // The event insertion strings need to be in this order:
            // 1. The disk number. (Both event IDs use this.)
            // 2. Bytes used.
            // 3. Bytes available.
            //
 
            RtlZeroMemory(errorLogEntry, logEntrySize);
            errorLogEntry->StringOffset = sizeof(IO_ERROR_LOG_PACKET);
 
            stringIndex = (PWCHAR)((ULONG_PTR)errorLogEntry + sizeof(IO_ERROR_LOG_PACKET));
            stringSize = logEntrySize - sizeof(IO_ERROR_LOG_PACKET);
 
            //
            // Add the disk number to the insertion strings.
            //
            status = RtlStringCbPrintfW(stringIndex, stringSize, L"%d", fdoExtension->DeviceNumber);
 
            if (NT_SUCCESS(status) )
            {
                errorLogEntry->NumberOfStrings++;
 
                if (resources.UsedMappingResourcesValid &&
                    resources.AvailableMappingResourcesValid)
                {
                    //
                    // Add the used mapping resources to the insertion strings.
                    //
                    stringIndex += (wcslen(stringIndex) + 1);
                    stringSize -= (LONG)(wcslen(stringIndex) + 1) * sizeof(WCHAR);
 
                    status = RtlStringCbPrintfW(stringIndex, stringSize, L"%I64u", resources.UsedMappingResources);
 
                    if (NT_SUCCESS(status))
                    {
                        errorLogEntry->NumberOfStrings++;
 
                        //
                        // Add the available mapping resources to the insertion strings.
                        //
                        stringIndex += (wcslen(stringIndex) + 1);
                        stringSize -= (LONG)(wcslen(stringIndex) + 1) * sizeof(WCHAR);
 
                        status = RtlStringCbPrintfW(stringIndex, stringSize, L"%I64u", resources.AvailableMappingResources);
 
                        if (NT_SUCCESS(status))
                        {
                            errorLogEntry->NumberOfStrings++;
                        }
                    }
                }
                else
                {
                    TracePrint((TRACE_LEVEL_WARNING,
                                TRACE_FLAG_GENERAL,
                                "ClassLogThresholdEvent: DO (%p), Used and available mapping resources were unavailable.\n",
                                DeviceObject));
                }
            }
 
            //
            // If we were able to successfully assemble all 3 insertion strings,
            // then we can use one of the "extended" event IDs.  Otherwise, use the basic
            // event ID, which only requires the disk number.
            //
            if (errorLogEntry->NumberOfStrings == 3)
            {
                if (resources.UsedMappingResourcesScope == LOG_PAGE_LBP_RESOURCE_SCOPE_DEDICATED_TO_LUN &&
                    resources.AvailableMappingResourcesScope == LOG_PAGE_LBP_RESOURCE_SCOPE_DEDICATED_TO_LUN) {
 
                    errorLogEntry->ErrorCode = IO_WARNING_SOFT_THRESHOLD_REACHED_EX_LUN_LUN;
 
                } else if (resources.UsedMappingResourcesScope == LOG_PAGE_LBP_RESOURCE_SCOPE_DEDICATED_TO_LUN &&
                           resources.AvailableMappingResourcesScope == LOG_PAGE_LBP_RESOURCE_SCOPE_NOT_DEDICATED_TO_LUN) {
 
                    errorLogEntry->ErrorCode = IO_WARNING_SOFT_THRESHOLD_REACHED_EX_LUN_POOL;
 
                } else if (resources.UsedMappingResourcesScope == LOG_PAGE_LBP_RESOURCE_SCOPE_NOT_DEDICATED_TO_LUN &&
                           resources.AvailableMappingResourcesScope == LOG_PAGE_LBP_RESOURCE_SCOPE_DEDICATED_TO_LUN) {
 
                    errorLogEntry->ErrorCode = IO_WARNING_SOFT_THRESHOLD_REACHED_EX_POOL_LUN;
 
                } else if (resources.UsedMappingResourcesScope == LOG_PAGE_LBP_RESOURCE_SCOPE_NOT_DEDICATED_TO_LUN &&
                           resources.AvailableMappingResourcesScope == LOG_PAGE_LBP_RESOURCE_SCOPE_NOT_DEDICATED_TO_LUN) {
 
                    errorLogEntry->ErrorCode = IO_WARNING_SOFT_THRESHOLD_REACHED_EX_POOL_POOL;
 
                } else {
 
                    errorLogEntry->ErrorCode = IO_WARNING_SOFT_THRESHOLD_REACHED_EX;
                }
            }
            else
            {
                errorLogEntry->ErrorCode = IO_WARNING_SOFT_THRESHOLD_REACHED;
            }
 
            //
            // Write the error log packet to the system error logging thread.
            // It will be freed automatically.
            //
            IoWriteErrorLogEntry(errorLogEntry);
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_GENERAL,
                        "ClassLogThresholdEvent: DO (%p), Soft threshold notification logged.\n",
                        DeviceObject));
        }
        else
        {
            TracePrint((TRACE_LEVEL_ERROR,
                        TRACE_FLAG_GENERAL,
                        "ClassLogThresholdEvent: DO (%p), Failed to allocate memory for error log entry.\n",
                        DeviceObject));
        }
    } else {
        TracePrint((TRACE_LEVEL_ERROR,
                        TRACE_FLAG_GENERAL,
                        "ClassLogThresholdEvent: DO (%p), Failed to allocate memory for SRB.\n",
                        DeviceObject));
    }
 
 
    //
    // Clear the soft threshold event pending flag so that another can be queued.
    //
    InterlockedExchange((PLONG)&(fdoExtension->FunctionSupportInfo->LBProvisioningData.SoftThresholdEventPending), 0);
 
    ClassReleaseRemoveLock(DeviceObject, (PIRP)workItem);
 
    FREE_POOL(srb);
 
    if (workItem != NULL) {
        IoFreeWorkItem(workItem);
    }
}

_IRQL_requires_max_() [1/3]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 6894 of file utils.c.

{
    NTSTATUS status;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
    PSTORAGE_PROPERTY_QUERY query;
    PIO_STACK_LOCATION irpStack;
    ULONG length;
    ULONG information;
    PDEVICE_COPY_OFFLOAD_DESCRIPTOR copyOffloadDescr = (PDEVICE_COPY_OFFLOAD_DESCRIPTOR)Irp->AssociatedIrp.SystemBuffer;
 
    UNREFERENCED_PARAMETER(Srb);
 
    PAGED_CODE();
 
    fdoExtension = DeviceObject->DeviceExtension;
    query = (PSTORAGE_PROPERTY_QUERY)Irp->AssociatedIrp.SystemBuffer;
    irpStack = IoGetCurrentIrpStackLocation(Irp);
    length = 0;
    information = 0;
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspDeviceCopyOffloadProperty (%p): Entering function.\n",
                DeviceObject));
 
    //
    // Check proper query type.
    //
    if (query->QueryType == PropertyExistsQuery) {
 
        //
        // In order to maintain consistency with the how the rest of the properties
        // are handled, we shall always return success for PropertyExistsQuery.
        //
        status = STATUS_SUCCESS;
        goto __ClasspDeviceCopyOffloadProperty_Exit;
 
    } else if (query->QueryType != PropertyStandardQuery) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceCopyOffloadProperty (%p): Unsupported query type %x for Copy Offload property.\n",
                    DeviceObject,
                    query->QueryType));
 
        status = STATUS_NOT_SUPPORTED;
        goto __ClasspDeviceCopyOffloadProperty_Exit;
    }
 
    //
    // Request validation.
    // Note that InputBufferLength and IsFdo have been validated beforing entering this routine.
    //
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
 
        NT_ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceCopyOffloadProperty (%p): Query property for Copy Offload called at incorrect IRQL.\n",
                    DeviceObject));
 
        status = STATUS_INVALID_LEVEL;
        goto __ClasspDeviceCopyOffloadProperty_Exit;
    }
 
    length = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
 
    if (length < sizeof(DEVICE_COPY_OFFLOAD_DESCRIPTOR)) {
 
        if (length >= sizeof(STORAGE_DESCRIPTOR_HEADER)) {
 
            TracePrint((TRACE_LEVEL_WARNING,
                        TRACE_FLAG_IOCTL,
                        "ClasspDeviceCopyOffloadProperty (%p): Length %u specified for Copy Offload property enough only for header.\n",
                        DeviceObject,
                        length));
 
            information = sizeof(STORAGE_DESCRIPTOR_HEADER);
            copyOffloadDescr->Version = sizeof(DEVICE_COPY_OFFLOAD_DESCRIPTOR);
            copyOffloadDescr->Size = sizeof(DEVICE_COPY_OFFLOAD_DESCRIPTOR);
 
            status = STATUS_SUCCESS;
            goto __ClasspDeviceCopyOffloadProperty_Exit;
        }
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceCopyOffloadProperty (%p): Incorrect length %u specified for Copy Offload property.\n",
                    DeviceObject,
                    length));
 
        status = STATUS_BUFFER_TOO_SMALL;
        goto __ClasspDeviceCopyOffloadProperty_Exit;
    }
 
    if (!fdoExtension->FunctionSupportInfo->ValidInquiryPages.BlockDeviceRODLimits) {
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceCopyOffloadProperty (%p): Command not supported on this device.\n",
                    DeviceObject));
 
        status = STATUS_DEVICE_FEATURE_NOT_SUPPORTED;
        goto __ClasspDeviceCopyOffloadProperty_Exit;
    }
 
    if (!NT_SUCCESS(fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus)) {
 
        status = fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.CommandStatus;
 
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_IOCTL,
                    "ClasspDeviceCopyOffloadProperty (%p): VPD retrieval had failed with %x.\n",
                    DeviceObject,
                    status));
 
        goto __ClasspDeviceCopyOffloadProperty_Exit;
    }
 
    //
    // Fill in the output buffer.  All data is copied from the FDO extension where we
    // cached Block Limits and Block Device Token Limits info when the device was first initialized.
    //
    RtlZeroMemory(copyOffloadDescr, length);
    copyOffloadDescr->Version = 1;
    copyOffloadDescr->Size = sizeof(DEVICE_COPY_OFFLOAD_DESCRIPTOR);
    copyOffloadDescr->MaximumTokenLifetime = fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumInactivityTimer;
    copyOffloadDescr->DefaultTokenLifetime = fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.DefaultInactivityTimer;
    copyOffloadDescr->MaximumTransferSize = fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumTokenTransferSize;
    copyOffloadDescr->OptimalTransferCount = fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.OptimalTransferCount;
    copyOffloadDescr->MaximumDataDescriptors = fdoExtension->FunctionSupportInfo->BlockDeviceRODLimitsData.MaximumRangeDescriptors;
 
    if (NT_SUCCESS(fdoExtension->FunctionSupportInfo->BlockLimitsData.CommandStatus)) {
 
        copyOffloadDescr->MaximumTransferLengthPerDescriptor = fdoExtension->FunctionSupportInfo->BlockLimitsData.MaximumTransferLength;
        copyOffloadDescr->OptimalTransferLengthPerDescriptor = fdoExtension->FunctionSupportInfo->BlockLimitsData.OptimalTransferLength;
        copyOffloadDescr->OptimalTransferLengthGranularity = fdoExtension->FunctionSupportInfo->BlockLimitsData.OptimalTransferLengthGranularity;
    }
 
    information = sizeof(DEVICE_COPY_OFFLOAD_DESCRIPTOR);
    status = STATUS_SUCCESS;
 
__ClasspDeviceCopyOffloadProperty_Exit:
 
    //
    // Set the size and status in IRP
    //
    Irp->IoStatus.Information = information;
    Irp->IoStatus.Status = status;
 
    ClassReleaseRemoveLock(DeviceObject, Irp);
    ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
 
    TracePrint((TRACE_LEVEL_VERBOSE,
                TRACE_FLAG_IOCTL,
                "ClasspDeviceCopyOffloadProperty (%p): Exiting function with status %x.\n",
                DeviceObject,
                status));
 
    return status;
}

_IRQL_requires_max_() [2/3]

_IRQL_requires_same_ _IRQL_requires_max_

(

DISPATCH_LEVEL

)

Definition at line 8503 of file utils.c.

{
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
 
    PIRP originalIrp;
 
    //
    // Free the allocated buffer for firmware image.
    //
    if (Context != NULL) {
        FREE_POOL(Context);
    }
 
    originalIrp = irpStack->Parameters.Others.Argument1;
 
    NT_ASSERT(originalIrp != NULL);
 
    originalIrp->IoStatus.Status = Irp->IoStatus.Status;
    originalIrp->IoStatus.Information = Irp->IoStatus.Information;
 
    ClassReleaseRemoveLock(Fdo, originalIrp);
    ClassCompleteRequest(Fdo, originalIrp, IO_DISK_INCREMENT);
 
    IoFreeIrp(Irp);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
 
} // end ClassHwFirmwareDownloadComplete()

_IRQL_requires_max_() [3/3]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 71 of file utils.c.

{
    NTSTATUS                 status;
    RTL_QUERY_REGISTRY_TABLE queryTable[2] = {0};
    HANDLE                   deviceParameterHandle = NULL;
    HANDLE                   deviceSubkeyHandle = NULL;
    ULONG                    defaultParameterValue;
 
    PAGED_CODE();
 
    //
    // open the given parameter
    //
 
    status = IoOpenDeviceRegistryKey(FdoExtension->LowerPdo,
                                     PLUGPLAY_REGKEY_DEVICE,
                                     KEY_READ,
                                     &deviceParameterHandle);
 
    if (NT_SUCCESS(status) && (SubkeyName != NULL)) {
 
        UNICODE_STRING subkeyName;
        OBJECT_ATTRIBUTES objectAttributes = {0};
 
        RtlInitUnicodeString(&subkeyName, SubkeyName);
        InitializeObjectAttributes(&objectAttributes,
                                   &subkeyName,
                                   OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                   deviceParameterHandle,
                                   NULL);
 
        status = ZwOpenKey(&deviceSubkeyHandle,
                           KEY_READ,
                           &objectAttributes);
        if (!NT_SUCCESS(status)) {
            ZwClose(deviceParameterHandle);
        }
 
    }
 
    if (NT_SUCCESS(status)) {
 
        defaultParameterValue = *ParameterValue;
 
        queryTable->Flags         = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_TYPECHECK;
        queryTable->Name          = ParameterName;
        queryTable->EntryContext  = ParameterValue;
        queryTable->DefaultType   = (REG_DWORD << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_NONE;
        queryTable->DefaultData   = NULL;
        queryTable->DefaultLength = 0;
 
        status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
                                        (PWSTR)(SubkeyName ?
                                                deviceSubkeyHandle :
                                                deviceParameterHandle),
                                        queryTable,
                                        NULL,
                                        NULL);
        if (!NT_SUCCESS(status)) {
            *ParameterValue = defaultParameterValue; // use default value
        }
 
        //
        // close what we open
        //
 
        if (SubkeyName) {
            ZwClose(deviceSubkeyHandle);
        }
 
        ZwClose(deviceParameterHandle);
    }
 
    if (!NT_SUCCESS(status)) {
 
        //
        // Windows 2000 SP3 uses the driver-specific key, so look in there
        //
 
        status = IoOpenDeviceRegistryKey(FdoExtension->LowerPdo,
                                         PLUGPLAY_REGKEY_DRIVER,
                                         KEY_READ,
                                         &deviceParameterHandle);
 
        if (NT_SUCCESS(status) && (SubkeyName != NULL)) {
 
            UNICODE_STRING subkeyName;
            OBJECT_ATTRIBUTES objectAttributes = {0};
 
            RtlInitUnicodeString(&subkeyName, SubkeyName);
            InitializeObjectAttributes(&objectAttributes,
                                       &subkeyName,
                                       OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                                       deviceParameterHandle,
                                       NULL);
 
            status = ZwOpenKey(&deviceSubkeyHandle, KEY_READ, &objectAttributes);
 
            if (!NT_SUCCESS(status)) {
                ZwClose(deviceParameterHandle);
            }
        }
 
        if (NT_SUCCESS(status)) {
 
            defaultParameterValue = *ParameterValue;
 
            queryTable->Flags         = RTL_QUERY_REGISTRY_DIRECT | RTL_QUERY_REGISTRY_REQUIRED | RTL_QUERY_REGISTRY_TYPECHECK;
            queryTable->Name          = ParameterName;
            queryTable->EntryContext  = ParameterValue;
            queryTable->DefaultType   =  (REG_DWORD << RTL_QUERY_REGISTRY_TYPECHECK_SHIFT) | REG_NONE;
            queryTable->DefaultData   = NULL;
            queryTable->DefaultLength = 0;
 
            status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
                                            (PWSTR)(SubkeyName ?
                                                    deviceSubkeyHandle :
                                                    deviceParameterHandle),
                                            queryTable,
                                            NULL,
                                            NULL);
            if (NT_SUCCESS(status)) {
 
                //
                // Migrate the value over to the device-specific key
                //
 
                ClassSetDeviceParameter(FdoExtension, SubkeyName, ParameterName, *ParameterValue);
 
            } else {
 
                //
                // Use the default value
                //
 
                *ParameterValue = defaultParameterValue;
            }
 
            if (SubkeyName) {
                ZwClose(deviceSubkeyHandle);
            }
 
            ZwClose(deviceParameterHandle);
        }
    }
 
    return;
 
} // end ClassGetDeviceParameter()

BuildDeviceInputMdl()

PMDL BuildDeviceInputMdl	(	PVOID	Buffer,
		ULONG	BufferLen
	)

Definition at line 609 of file utils.c.

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

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

ClassDeviceGetLBProvisioningResources()

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

Definition at line 5087 of file utils.c.

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

Referenced by ClassDeviceControl().

ClassDeviceHwFirmwareActivateProcess()

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

Definition at line 8902 of file utils.c.

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

Referenced by ClassDeviceControl().

ClassDeviceHwFirmwareDownloadProcess()

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

Definition at line 8541 of file utils.c.

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

Referenced by ClassDeviceControl().

ClassDeviceHwFirmwareGetInfoProcess()

NTSTATUS ClassDeviceHwFirmwareGetInfoProcess	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PIRP	Irp
	)

Definition at line 8366 of file utils.c.

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

Referenced by ClassDeviceControl().

ClassDeviceHwFirmwareIsPortDriverSupported()

__inline BOOLEAN ClassDeviceHwFirmwareIsPortDriverSupported

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 8330 of file utils.c.

{
    //
    // If the request is for a FDO, process the request for Storport, SDstor and Spaceport only.
    // Don't process it if we don't have a miniport descriptor.
    //
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
 
    BOOLEAN isSupported = FALSE;
    if (commonExtension->IsFdo && (fdoExtension->MiniportDescriptor != NULL)) {
        isSupported = ((fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetStorport) ||
                       (fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetSpaceport) ||
                       (fdoExtension->MiniportDescriptor->Portdriver == StoragePortCodeSetSDport   ));
    }
 
    return isSupported;
}

Referenced by ClassDeviceHwFirmwareActivateProcess(), ClassDeviceHwFirmwareDownloadProcess(), and ClassDeviceHwFirmwareGetInfoProcess().

ClassGetLBProvisioningLogPage()

NTSTATUS ClassGetLBProvisioningLogPage	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ ULONG	LogPageSize,
		_Inout_ PLOG_PAGE_LOGICAL_BLOCK_PROVISIONING	LogPage
	)

Definition at line 4679 of file utils.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    NTSTATUS status = STATUS_SUCCESS;
    PCDB cdb = NULL;
 
    //
    // Make sure the caller passed in an adequate output buffer.  The Allocation
    // Length field in the Log Sense command is only 2 bytes so we need to also
    // make sure that the given log page size isn't larger than MAXUSHORT.
    //
    if (LogPage == NULL ||
        LogPageSize < sizeof(LOG_PAGE_LOGICAL_BLOCK_PROVISIONING) ||
        LogPageSize > MAXUSHORT)
    {
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_GENERAL,
                    "ClassGetLBProvisioningLogPage: DO (%p), Invalid parameter, LogPage = %p, LogPageSize = %u.\n",
                    DeviceObject,
                    LogPage,
                    LogPageSize));
 
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // Initialize the SRB.
    //
    if (fdoExtension->AdapterDescriptor->SrbType == SRB_TYPE_STORAGE_REQUEST_BLOCK) {
        status = InitializeStorageRequestBlock((PSTORAGE_REQUEST_BLOCK)Srb,
                                                STORAGE_ADDRESS_TYPE_BTL8,
                                                CLASS_SRBEX_SCSI_CDB16_BUFFER_SIZE,
                                                1,
                                                SrbExDataTypeScsiCdb16);
        if (NT_SUCCESS(status)) {
            ((PSTORAGE_REQUEST_BLOCK)Srb)->SrbFunction = SRB_FUNCTION_EXECUTE_SCSI;
        } else {
            //
            // Should not occur.
            //
            NT_ASSERT(FALSE);
        }
    } else {
        RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));
        Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
        Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    }
 
    //
    // Build and send down the Log Sense command.
    //
    SrbSetTimeOutValue(Srb, fdoExtension->TimeOutValue);
    SrbSetRequestTag(Srb, SP_UNTAGGED);
    SrbSetRequestAttribute(Srb, SRB_SIMPLE_TAG_REQUEST);
    SrbAssignSrbFlags(Srb, fdoExtension->SrbFlags);
    SrbSetCdbLength(Srb, sizeof(cdb->LOGSENSE));
 
    cdb = SrbGetCdb(Srb);
    cdb->LOGSENSE.OperationCode = SCSIOP_LOG_SENSE;
    cdb->LOGSENSE.PageCode = LOG_PAGE_CODE_LOGICAL_BLOCK_PROVISIONING;
    cdb->LOGSENSE.PCBit = 0;
    cdb->LOGSENSE.ParameterPointer[0] = 0;
    cdb->LOGSENSE.ParameterPointer[1] = 0;
    REVERSE_BYTES_SHORT(&(cdb->LOGSENSE.AllocationLength), &LogPageSize);
 
    status = ClassSendSrbSynchronous(fdoExtension->DeviceObject,
                                        Srb,
                                        LogPage,
                                        LogPageSize,
                                        FALSE);
 
    //
    // Handle the case where we get back STATUS_DATA_OVERRUN b/c the input
    // buffer was larger than necessary.
    //
    if (status == STATUS_DATA_OVERRUN &&
        SrbGetDataTransferLength(Srb) < LogPageSize)
    {
        status = STATUS_SUCCESS;
    }
 
    //
    // Log the command.
    //
    TracePrint((TRACE_LEVEL_INFORMATION,
                TRACE_FLAG_IOCTL,
                "ClassGetLBProvisioningLogPage: DO (%p), LogSense command issued for LBP log page. NT Status: %!STATUS!.\n",
                DeviceObject,
                status
                ));
 
    return status;
}

Referenced by ClassGetLBProvisioningResources().

ClassGetLBProvisioningResources()

NTSTATUS ClassGetLBProvisioningResources	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ ULONG	ResourcesSize,
		_Inout_ PSTORAGE_LB_PROVISIONING_MAP_RESOURCES	Resources
	)

Definition at line 4958 of file utils.c.

{
    NTSTATUS status;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    ULONG logPageSize;
    PLOG_PAGE_LOGICAL_BLOCK_PROVISIONING logPage = NULL;
 
    //
    // This functionality is only supported for devices that support logical
    // block provisioning.
    //
    if (fdoExtension->FunctionSupportInfo->ValidInquiryPages.LBProvisioning == FALSE)
    {
        TracePrint((TRACE_LEVEL_ERROR,
            TRACE_FLAG_GENERAL,
            "ClassGetLBProvisioningResources: DO (%p), Device does not support logical block provisioning.\n",
            DeviceObject));
 
        return STATUS_NOT_SUPPORTED;
    }
 
    //
    // Validate the output buffer.
    //
    if (Resources == NULL ||
        ResourcesSize < sizeof(STORAGE_LB_PROVISIONING_MAP_RESOURCES))
    {
        TracePrint((TRACE_LEVEL_ERROR,
            TRACE_FLAG_GENERAL,
            "ClassGetLBProvisioningResources: DO (%p), Invalid parameter, Resources = %p, ResourcesSize = %u.\n",
            DeviceObject,
            Resources,
            ResourcesSize));
 
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // Allocate a buffer for the log page.  Currently the log page contains:
    // 1. Log page header
    // 2. Log page parameter for used resources
    // 3. Log page parameter for available resources
    //
    logPageSize = sizeof(LOG_PAGE_LOGICAL_BLOCK_PROVISIONING) + (2 * sizeof(LOG_PARAMETER_THRESHOLD_RESOURCE_COUNT));
 
#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.
    //
    logPageSize = ALIGN_UP_BY(logPageSize, KeGetRecommendedSharedDataAlignment());
    logPage = (PLOG_PAGE_LOGICAL_BLOCK_PROVISIONING)ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, logPageSize,  CLASS_TAG_LB_PROVISIONING);
#else
    logPage = (PLOG_PAGE_LOGICAL_BLOCK_PROVISIONING)ExAllocatePoolWithTag(NonPagedPoolNx, logPageSize,  CLASS_TAG_LB_PROVISIONING);
#endif
    if (logPage != NULL)
    {
        //
        // Get the LBP log page from the device.
        //
        status = ClassGetLBProvisioningLogPage(DeviceObject,
                                               Srb,
                                               logPageSize,
                                               logPage);
 
        if (NT_SUCCESS(status))
        {
            //
            // Interpret the log page and fill in the output buffer.
            //
            status = ClassInterpretLBProvisioningLogPage(DeviceObject,
                                                         logPageSize,
                                                         logPage,
                                                         ResourcesSize,
                                                         Resources);
        }
 
        ExFreePool(logPage);
    }
    else
    {
        TracePrint((TRACE_LEVEL_ERROR,
                    TRACE_FLAG_GENERAL,
                    "ClassGetLBProvisioningResources: DO (%p), Failed to allocate memory for LBP log page.\n",
                    DeviceObject));
 
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    return status;
}

Referenced by ClassDeviceGetLBProvisioningResources().

ClassInterpretLBProvisioningLogPage()

NTSTATUS ClassInterpretLBProvisioningLogPage	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ ULONG	LogPageSize,
		_In_ PLOG_PAGE_LOGICAL_BLOCK_PROVISIONING	LogPage,
		_In_ ULONG	ResourcesSize,
		_Out_ PSTORAGE_LB_PROVISIONING_MAP_RESOURCES	Resources
	)

Definition at line 4800 of file utils.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    USHORT pageLength;
    PLOG_PARAMETER_HEADER parameter;
    PVOID endOfPage;
    USHORT parameterCode;
    ULONG resourceCount;
    UCHAR thresholdExponent = fdoExtension->FunctionSupportInfo->LBProvisioningData.ThresholdExponent;
    ULONGLONG thresholdSetSize;
 
    //
    // SBC-3 states that the threshold exponent (from the 0xB2 VPD page), must
    // be non-zero and less than or equal to 32.
    //
    if (thresholdExponent < 0 || thresholdExponent > 32)
    {
        TracePrint((TRACE_LEVEL_ERROR,
            TRACE_FLAG_GENERAL,
            "ClassInterpretLBProvisioningLogPage: DO (%p), Threshold Exponent (%u) is invalid.\n",
            DeviceObject,
            thresholdExponent));
 
        return STATUS_NOT_SUPPORTED;
    }
 
    if (Resources == NULL ||
        ResourcesSize < sizeof(STORAGE_LB_PROVISIONING_MAP_RESOURCES) ||
        LogPage == NULL ||
        LogPageSize < sizeof(LOG_PAGE_LOGICAL_BLOCK_PROVISIONING))
    {
        TracePrint((TRACE_LEVEL_ERROR,
            TRACE_FLAG_GENERAL,
            "ClassInterpretLBProvisioningLogPage: DO (%p), Invalid parameter, Resources = %p, ResourcesSize = %u, LogPage = %p, LogPageSize = %u.\n",
            DeviceObject,
            Resources,
            ResourcesSize,
            LogPage,
            LogPageSize));
 
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // Calculate the threshold set size (in LBAs).
    //
    thresholdSetSize = 1ULL << thresholdExponent;
 
    REVERSE_BYTES_SHORT(&pageLength, &(LogPage->PageLength));
 
    //
    // Initialize the output buffer.
    //
    RtlZeroMemory(Resources, sizeof(STORAGE_LB_PROVISIONING_MAP_RESOURCES));
    Resources->Size = sizeof(STORAGE_LB_PROVISIONING_MAP_RESOURCES);
    Resources->Version = sizeof(STORAGE_LB_PROVISIONING_MAP_RESOURCES);
 
    //
    // Make sure we don't walk off the end of the log page buffer
    // if pageLength is somehow longer than the buffer itself.
    //
    pageLength = (USHORT)min(pageLength, (LogPageSize - FIELD_OFFSET(LOG_PAGE_LOGICAL_BLOCK_PROVISIONING, Parameters)));
 
    parameter = (PLOG_PARAMETER_HEADER)((PUCHAR)LogPage + FIELD_OFFSET(LOG_PAGE_LOGICAL_BLOCK_PROVISIONING, Parameters));
    endOfPage = (PVOID)((PUCHAR)parameter + pageLength);
 
    //
    // Walk the parameters.
    //
    while ((PVOID)parameter < endOfPage)
    {
        if (parameter->ParameterLength > 0)
        {
            REVERSE_BYTES_SHORT(&parameterCode, &(parameter->ParameterCode));
            switch(parameterCode)
            {
                case LOG_PAGE_LBP_PARAMETER_CODE_AVAILABLE:
                {
                    REVERSE_BYTES(&resourceCount, &(((PLOG_PARAMETER_THRESHOLD_RESOURCE_COUNT)parameter)->ResourceCount));
                    Resources->AvailableMappingResources = (ULONGLONG)resourceCount * thresholdSetSize * (ULONGLONG)fdoExtension->DiskGeometry.BytesPerSector;
                    Resources->AvailableMappingResourcesValid = TRUE;
 
                    //
                    // Devices that implement SBC-3 revisions older than r27 will not specify
                    // an LBP log page parameter that has fields beyond ResourceCount.
                    //
                    if (parameter->ParameterLength > FIELD_OFFSET(LOG_PARAMETER_THRESHOLD_RESOURCE_COUNT, ResourceCount[3])) {
                        Resources->AvailableMappingResourcesScope = ((PLOG_PARAMETER_THRESHOLD_RESOURCE_COUNT)parameter)->Scope;
                    }
 
                    break;
                }
 
                case LOG_PAGE_LBP_PARAMETER_CODE_USED:
                {
                    REVERSE_BYTES(&resourceCount, &(((PLOG_PARAMETER_THRESHOLD_RESOURCE_COUNT)parameter)->ResourceCount));
                    Resources->UsedMappingResources = (ULONGLONG)resourceCount * thresholdSetSize * (ULONGLONG)fdoExtension->DiskGeometry.BytesPerSector;
                    Resources->UsedMappingResourcesValid = TRUE;
 
                    //
                    // Devices that implement SBC-3 revisions older than r27 will not specify
                    // an LBP log page parameter that has fields beyond ResourceCount.
                    //
                    if (parameter->ParameterLength > FIELD_OFFSET(LOG_PARAMETER_THRESHOLD_RESOURCE_COUNT, ResourceCount[3])) {
                        Resources->UsedMappingResourcesScope = ((PLOG_PARAMETER_THRESHOLD_RESOURCE_COUNT)parameter)->Scope;
                    }
 
                    break;
                }
            }
        }
 
        //
        // Move to the next parameter.
        //
        parameter = (PLOG_PARAMETER_HEADER)((PUCHAR)parameter + sizeof(LOG_PARAMETER_HEADER) + parameter->ParameterLength);
    }
 
    return STATUS_SUCCESS;
}

Referenced by ClassGetLBProvisioningResources().

ClasspAccessAlignmentProperty()

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

Definition at line 1700 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspBinaryToAscii()

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

Definition at line 7717 of file utils.c.

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

Referenced by ClasspContinueOffloadWrite(), and ClasspReceivePopulateTokenInformationTransferPacketDone().

ClasspBuildDeviceMdl()

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

Definition at line 582 of file utils.c.

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

Referenced by BuildDeviceInputMdl().

ClasspCalculateLogicalSectorSize()

ULONG ClasspCalculateLogicalSectorSize	(	_In_ PDEVICE_OBJECT	Fdo,
		_In_ ULONG	BytesPerBlockInBigEndian
	)

Definition at line 1483 of file utils.c.

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

Referenced by InterpretCapacityData(), and InterpretReadCapacity16Data().

ClasspConvertToScsiRequestBlock()

VOID ClasspConvertToScsiRequestBlock	(	_Out_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ PSTORAGE_REQUEST_BLOCK	SrbEx
	)

Definition at line 6559 of file utils.c.

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

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

ClasspDeviceGetBlockDeviceCharacteristicsVPDPage()

NTSTATUS ClasspDeviceGetBlockDeviceCharacteristicsVPDPage	(	_In_ PFUNCTIONAL_DEVICE_EXTENSION	fdoExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 2072 of file utils.c.

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

Referenced by ClasspDeviceMediaTypeProperty(), and ClasspDeviceSeekPenaltyProperty().

ClasspDeviceGetBlockLimitsVPDPage()

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

Definition at line 2521 of file utils.c.

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

Referenced by ClasspGetLBProvisioningInfo(), and ClasspRefreshFunctionSupportInfo().

ClasspDeviceGetLBAStatus()

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

Definition at line 3861 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspDeviceGetLBAStatusWorker()

NTSTATUS ClasspDeviceGetLBAStatusWorker	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PCLASS_VPD_B0_DATA	BlockLimitsData,
		_In_ ULONGLONG	StartingOffset,
		_In_ ULONGLONG	LengthInBytes,
		_Out_ PDEVICE_MANAGE_DATA_SET_ATTRIBUTES_OUTPUT	DsmOutput,
		_Inout_ PULONG	DsmOutputLength,
		_Inout_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ BOOLEAN	ConsolidateableBlocksOnly,
		_In_ ULONG	OutputVersion,
		_Out_ PBOOLEAN	BlockLimitsDataMayHaveChanged
	)

Definition at line 4079 of file utils.c.

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

Referenced by ClasspDeviceGetLBAStatus().

ClasspDeviceGetLBProvisioningVPDPage()

NTSTATUS ClasspDeviceGetLBProvisioningVPDPage	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_Inout_opt_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 2350 of file utils.c.

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

Referenced by ClasspGetLBProvisioningInfo().

ClasspDeviceLBProvisioningProperty()

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

Definition at line 2894 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspDeviceMediaTypeProperty()

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

Definition at line 1917 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspDeviceSeekPenaltyProperty()

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

Definition at line 2172 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspDeviceTrimProcess()

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

Definition at line 3476 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspDeviceTrimProperty()

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

Definition at line 2730 of file utils.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    PCOMMON_DEVICE_EXTENSION     commonExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = (PFUNCTIONAL_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
    PSTORAGE_PROPERTY_QUERY      query = (PSTORAGE_PROPERTY_QUERY)Irp->AssociatedIrp.SystemBuffer;
    PIO_STACK_LOCATION           irpStack = IoGetCurrentIrpStackLocation(Irp);
    ULONG                        length = 0;
    ULONG                        information = 0;
 
    PDEVICE_TRIM_DESCRIPTOR      trimDescr;
 
    UNREFERENCED_PARAMETER(Srb);
 
    if ( (DeviceObject->DeviceType != FILE_DEVICE_DISK) ||
         (TEST_FLAG(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE)) ||
         (fdoExtension->FunctionSupportInfo->LowerLayerSupport.TrimProperty == Supported) ) {
        // if it's not disk, forward the request to lower layer,
        // if the IOCTL is supported by lower stack, forward it down.
        IoCopyCurrentIrpStackLocationToNext(Irp);
 
        ClassReleaseRemoveLock(DeviceObject, Irp);
        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);
        return status;
    }
 
    //
    // Check proper query type.
    //
 
    if (query->QueryType == PropertyExistsQuery) {
        status = STATUS_SUCCESS;
        goto Exit;
    } else  if (query->QueryType != PropertyStandardQuery) {
        status = STATUS_NOT_SUPPORTED;
        goto Exit;
    }