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

Referenced by ClassDeviceControl().

ClasspDuidGetDeviceIdProperty()

NTSTATUS ClasspDuidGetDeviceIdProperty	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 689 of file utils.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PSTORAGE_DEVICE_ID_DESCRIPTOR deviceIdDescriptor = NULL;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_DESCRIPTOR_HEADER descHeader;
    PSTORAGE_DEVICE_UNIQUE_IDENTIFIER storageDuid;
    PUCHAR dest;
 
    STORAGE_PROPERTY_ID propertyId = StorageDeviceIdProperty;
 
    NTSTATUS status;
 
    ULONG queryLength;
    ULONG offset;
 
    //
    // Get the VPD page 83h data.
    //
 
    status = ClassGetDescriptor(commonExtension->LowerDeviceObject,
                                &propertyId,
                                (PVOID *)&deviceIdDescriptor);
 
    if (!NT_SUCCESS(status) || !deviceIdDescriptor) {
        goto FnExit;
    }
 
    queryLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
    descHeader = Irp->AssociatedIrp.SystemBuffer;
 
    //
    // Adjust required size and potential destination location.
    //
 
    offset = descHeader->Size;
    dest = (PUCHAR)descHeader + offset;
 
    descHeader->Size += deviceIdDescriptor->Size;
 
    if (queryLength < descHeader->Size) {
 
        //
        // Output buffer is too small.  Return error and make sure
        // the caller gets info about required buffer size.
        //
 
        Irp->IoStatus.Information = sizeof(STORAGE_DESCRIPTOR_HEADER);
        status = STATUS_BUFFER_OVERFLOW;
        goto FnExit;
    }
 
    storageDuid = Irp->AssociatedIrp.SystemBuffer;
    storageDuid->StorageDeviceIdOffset = offset;
 
    RtlCopyMemory(dest,
                  deviceIdDescriptor,
                  deviceIdDescriptor->Size);
 
    Irp->IoStatus.Information = storageDuid->Size;
    status = STATUS_SUCCESS;
 
FnExit:
 
    FREE_POOL(deviceIdDescriptor);
 
    return status;
}

Referenced by ClasspDuidQueryProperty().

ClasspDuidGetDeviceProperty()

NTSTATUS ClasspDuidGetDeviceProperty	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 782 of file utils.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    PSTORAGE_DEVICE_DESCRIPTOR deviceDescriptor = fdoExtension->DeviceDescriptor;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_DESCRIPTOR_HEADER descHeader;
    PSTORAGE_DEVICE_UNIQUE_IDENTIFIER storageDuid;
    PUCHAR dest;
 
    NTSTATUS status = STATUS_NOT_FOUND;
 
    ULONG queryLength;
    ULONG offset;
 
    //
    // Use the StorageDeviceProperty already cached in the device extension.
    //
 
    if (!deviceDescriptor) {
        goto FnExit;
    }
 
    queryLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
    descHeader = Irp->AssociatedIrp.SystemBuffer;
 
    //
    // Use this info only if serial number is available.
    //
 
    if (deviceDescriptor->SerialNumberOffset == 0) {
        goto FnExit;
    }
 
    //
    // Adjust required size and potential destination location.
    //
 
    offset = descHeader->Size;
    dest = (PUCHAR)descHeader + offset;
 
    descHeader->Size += deviceDescriptor->Size;
 
    if (queryLength < descHeader->Size) {
 
        //
        // Output buffer is too small.  Return error and make sure
        // the caller get info about required buffer size.
        //
 
        Irp->IoStatus.Information = sizeof(STORAGE_DESCRIPTOR_HEADER);
        status = STATUS_BUFFER_OVERFLOW;
        goto FnExit;
    }
 
    storageDuid = Irp->AssociatedIrp.SystemBuffer;
    storageDuid->StorageDeviceOffset = offset;
 
    RtlCopyMemory(dest,
                  deviceDescriptor,
                  deviceDescriptor->Size);
 
    Irp->IoStatus.Information = storageDuid->Size;
    status = STATUS_SUCCESS;
 
FnExit:
 
    return status;
}

Referenced by ClasspDuidQueryProperty().

ClasspDuidGetDriveLayout()

NTSTATUS ClasspDuidGetDriveLayout	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 875 of file utils.c.

{
    PDRIVE_LAYOUT_INFORMATION_EX layoutEx = NULL;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PSTORAGE_DESCRIPTOR_HEADER descHeader;
    PSTORAGE_DEVICE_UNIQUE_IDENTIFIER storageDuid;
    PSTORAGE_DEVICE_LAYOUT_SIGNATURE driveLayoutSignature;
 
    NTSTATUS status = STATUS_NOT_FOUND;
 
    ULONG queryLength;
    ULONG offset;
 
    //
    // Only process disk-type devices.
    //
 
    if (DeviceObject->DeviceType != FILE_DEVICE_DISK) {
        goto FnExit;
    }
 
    //
    // Get current partition table and process only if GPT
    // or MBR layout.
    //
 
    status = IoReadPartitionTableEx(DeviceObject, &layoutEx);
 
    if (!NT_SUCCESS(status)) {
        status = STATUS_NOT_FOUND;
        goto FnExit;
    }
 
    if (layoutEx->PartitionStyle != PARTITION_STYLE_GPT &&
        layoutEx->PartitionStyle != PARTITION_STYLE_MBR) {
        status = STATUS_NOT_FOUND;
        goto FnExit;
    }
 
    queryLength = irpStack->Parameters.DeviceIoControl.OutputBufferLength;
    descHeader = Irp->AssociatedIrp.SystemBuffer;
 
    //
    // Adjust required size and potential destination location.
    //
 
    offset = descHeader->Size;
    driveLayoutSignature = (PSTORAGE_DEVICE_LAYOUT_SIGNATURE)((PUCHAR)descHeader + offset);
 
    descHeader->Size += sizeof(STORAGE_DEVICE_LAYOUT_SIGNATURE);
 
    if (queryLength < descHeader->Size) {
 
        //
        // Output buffer is too small.  Return error and make sure
        // the caller get info about required buffer size.
        //
 
        Irp->IoStatus.Information = sizeof(STORAGE_DESCRIPTOR_HEADER);
        status = STATUS_BUFFER_OVERFLOW;
        goto FnExit;
    }
 
    storageDuid = Irp->AssociatedIrp.SystemBuffer;
 
    driveLayoutSignature->Size = sizeof(STORAGE_DEVICE_LAYOUT_SIGNATURE);
    driveLayoutSignature->Version = DUID_VERSION_1;
 
    if (layoutEx->PartitionStyle == PARTITION_STYLE_MBR) {
 
        driveLayoutSignature->Mbr = TRUE;
 
        RtlCopyMemory(&driveLayoutSignature->DeviceSpecific.MbrSignature,
                      &layoutEx->Mbr.Signature,
                      sizeof(layoutEx->Mbr.Signature));
 
    } else {
 
        driveLayoutSignature->Mbr = FALSE;
 
        RtlCopyMemory(&driveLayoutSignature->DeviceSpecific.GptDiskId,
                      &layoutEx->Gpt.DiskId,
                      sizeof(layoutEx->Gpt.DiskId));
    }
 
    storageDuid->DriveLayoutSignatureOffset = offset;
 
    Irp->IoStatus.Information = storageDuid->Size;
    status = STATUS_SUCCESS;
 
 
FnExit:
 
    FREE_POOL(layoutEx);
 
    return status;
}

Referenced by ClasspDuidQueryProperty().

ClasspDuidQueryProperty()

NTSTATUS ClasspDuidQueryProperty	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 997 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspFreeDeviceMdl()

VOID ClasspFreeDeviceMdl

(

PMDL

Mdl

)

Definition at line 615 of file utils.c.

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

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

ClasspGetHwFirmwareInfo()

NTSTATUS ClasspGetHwFirmwareInfo

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 8190 of file utils.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
 
    PSTORAGE_HW_FIRMWARE_INFO firmwareInfo = NULL;
    PSTORAGE_HW_FIRMWARE_INFO_QUERY query = NULL;
 
    IO_STATUS_BLOCK ioStatus = {0};
    ULONG dataLength = sizeof(STORAGE_HW_FIRMWARE_INFO);
    ULONG iteration = 1;
 
    CLASS_FUNCTION_SUPPORT oldState;
    KLOCK_QUEUE_HANDLE  lockHandle;
 
    //
    // Try to get firmware information that contains only one slot.
    // We will retry the query if the required buffer size is bigger than that.
    //
retry:
 
    firmwareInfo = ExAllocatePoolWithTag(NonPagedPoolNx, dataLength, CLASSPNP_POOL_TAG_FIRMWARE);
 
    if (firmwareInfo == NULL) {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT, "ClasspGetHwFirmwareInfo: cannot allocate memory to hold data. \n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    RtlZeroMemory(firmwareInfo, dataLength);
 
    //
    // Set up query data, making sure the "Flags" field indicating the request is for device itself.
    //
    query = (PSTORAGE_HW_FIRMWARE_INFO_QUERY)firmwareInfo;
 
    query->Version = sizeof(STORAGE_HW_FIRMWARE_INFO_QUERY);
    query->Size = sizeof(STORAGE_HW_FIRMWARE_INFO_QUERY);
    query->Flags = 0;
 
    //
    // On the first pass we just want to get the first few
    // bytes of the descriptor so we can read it's size
    //
    ClassSendDeviceIoControlSynchronous(IOCTL_STORAGE_FIRMWARE_GET_INFO,
                                        commonExtension->LowerDeviceObject,
                                        query,
                                        sizeof(STORAGE_HW_FIRMWARE_INFO_QUERY),
                                        dataLength,
                                        FALSE,
                                        &ioStatus
                                        );
 
    if (!NT_SUCCESS(ioStatus.Status) &&
        (ioStatus.Status != STATUS_BUFFER_OVERFLOW)) {
        if (ClasspLowerLayerNotSupport(ioStatus.Status)) {
            oldState = InterlockedCompareExchange((PLONG)(&fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport), (LONG)NotSupported, (ULONG)SupportUnknown);
        }
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT, "ClasspGetHwFirmwareInfo: error %lx trying to "
                                                        "query hardware firmware information #%d \n", ioStatus.Status, iteration));
        FREE_POOL(firmwareInfo);
        return ioStatus.Status;
    }
 
    //
    // Catch implementation issues from lower level driver.
    //
    if ((firmwareInfo->Version < sizeof(STORAGE_HW_FIRMWARE_INFO)) ||
        (firmwareInfo->Size < sizeof(STORAGE_HW_FIRMWARE_INFO)) ||
        (firmwareInfo->SlotCount == 0) ||
        (firmwareInfo->ImagePayloadMaxSize > fdoExtension->AdapterDescriptor->MaximumTransferLength)) {
 
        oldState = InterlockedCompareExchange((PLONG)(&fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport), (LONG)NotSupported, (ULONG)SupportUnknown);
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_INIT, "ClasspGetHwFirmwareInfo: error in returned data! "
                                                        "Version: 0x%X, Size: 0x%X, SlotCount: 0x%X, ActiveSlot: 0x%X, PendingActiveSlot: 0x%X, ImagePayloadMaxSize: 0x%X \n",
                                                        firmwareInfo->Version,
                                                        firmwareInfo->Size,
                                                        firmwareInfo->SlotCount,
                                                        firmwareInfo->ActiveSlot,
                                                        firmwareInfo->PendingActivateSlot,
                                                        firmwareInfo->ImagePayloadMaxSize));
 
        FREE_POOL(firmwareInfo);
        return STATUS_UNSUCCESSFUL;
    }
 
    //
    // If the data size is bigger than sizeof(STORAGE_HW_FIRMWARE_INFO), e.g. device has more than one firmware slot,
    // allocate a buffer to get all the data.
    //
    if ((firmwareInfo->Size > sizeof(STORAGE_HW_FIRMWARE_INFO)) &&
        (iteration < 2)) {
 
        dataLength = max(firmwareInfo->Size, sizeof(STORAGE_HW_FIRMWARE_INFO) + sizeof(STORAGE_HW_FIRMWARE_SLOT_INFO) * (firmwareInfo->SlotCount - 1));
 
        //
        // Retry the query with required buffer length.
        //
        FREE_POOL(firmwareInfo);
        iteration++;
        goto retry;
    }
 
 
    //
    // Set the support status and use the memory we've allocated as caching buffer.
    // In case of a competing thread already set the state, it will assign the caching buffer so release the current allocated one.
    //
    KeAcquireInStackQueuedSpinLock(&fdoExtension->FunctionSupportInfo->SyncLock, &lockHandle);
 
    oldState = InterlockedCompareExchange((PLONG)(&fdoExtension->FunctionSupportInfo->HwFirmwareGetInfoSupport), (LONG)Supported, (ULONG)SupportUnknown);
 
    if (oldState == SupportUnknown) {
        fdoExtension->FunctionSupportInfo->HwFirmwareInfo = firmwareInfo;
    } else if (oldState == Supported) {
        //
        // swap the buffers to keep the latest version.
        //
        PSTORAGE_HW_FIRMWARE_INFO cachedInfo = fdoExtension->FunctionSupportInfo->HwFirmwareInfo;
 
        fdoExtension->FunctionSupportInfo->HwFirmwareInfo = firmwareInfo;
 
        FREE_POOL(cachedInfo);
    } else {
        FREE_POOL(firmwareInfo);
    }
 
    KeReleaseInStackQueuedSpinLock(&lockHandle);
 
    return ioStatus.Status;
} // end ClasspGetHwFirmwareInfo()

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

ClasspGetTokenOperationCommandBufferLength()

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

Definition at line 7356 of file utils.c.

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

ClasspGetTokenOperationDescriptorLimits()

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

Definition at line 7472 of file utils.c.

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

ClasspIsThinProvisioningError()

BOOLEAN ClasspIsThinProvisioningError

(

_In_ PSCSI_REQUEST_BLOCK

Srb

)

Definition at line 9127 of file utils.c.

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

Referenced by RetryTransferPacket().

ClasspLogSystemEventWithDeviceNumber()

NTSTATUS ClasspLogSystemEventWithDeviceNumber	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ NTSTATUS	IoErrorCode
	)

Definition at line 5354 of file utils.c.

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

Referenced by ClassDispatchPnp(), and ClassIoComplete().

ClasspMyStringMatches()

BOOLEAN ClasspMyStringMatches	(	_In_opt_z_ PCHAR	StringToMatch,
		_In_z_ PCHAR	TargetString
	)

Definition at line 51 of file utils.c.

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

ClasspPerfIncrementErrorCount()

VOID ClasspPerfIncrementErrorCount

(

IN PFUNCTIONAL_DEVICE_EXTENSION

FdoExtension

)

Definition at line 432 of file utils.c.

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

Referenced by ClassInterpretSenseInfo().

ClasspPerfIncrementSuccessfulIo()

VOID ClasspPerfIncrementSuccessfulIo

(

IN PFUNCTIONAL_DEVICE_EXTENSION

FdoExtension

)

Definition at line 486 of file utils.c.

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

Referenced by ClassIoComplete(), and TransferPktComplete().

ClasspPersistentReserve()

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

Definition at line 6211 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspPriorityHint()

NTSTATUS ClasspPriorityHint	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 6480 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspQueueLogIOEventWithContextWorker()

VOID ClasspQueueLogIOEventWithContextWorker	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ ULONG	SenseBufferSize,
		_In_ PVOID	SenseData,
		_In_ UCHAR	SrbStatus,
		_In_ UCHAR	ScsiStatus,
		_In_ ULONG	ErrorCode,
		_In_ ULONG	CdbLength,
		_In_opt_ PCDB	Cdb,
		_In_opt_ PTRANSFER_PACKET	Pkt
	)

Definition at line 6010 of file utils.c.

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

Referenced by ClassInterpretSenseInfo().

ClasspStorageEventNotification()

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

Definition at line 7826 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspWriteCacheProperty()

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

Definition at line 1199 of file utils.c.

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

Referenced by ClassDeviceControl().

ClasspZeroQERR()

VOID ClasspZeroQERR

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 7938 of file utils.c.

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

ClassQueueCapacityChangedEventWorker()

VOID ClassQueueCapacityChangedEventWorker

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 5637 of file utils.c.

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

Referenced by ClassInterpretSenseInfo().

ClassQueueProvisioningTypeChangedEventWorker()

VOID ClassQueueProvisioningTypeChangedEventWorker

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 5726 of file utils.c.

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

Referenced by ClassInterpretSenseInfo().

ClassQueueResourceExhaustionEventWorker()

VOID ClassQueueResourceExhaustionEventWorker

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 5528 of file utils.c.

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

Referenced by ClassInterpretSenseInfo().

ClassQueueThresholdEventWorker()

VOID ClassQueueThresholdEventWorker

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 5471 of file utils.c.

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

Referenced by ClassInterpretSenseInfo().

ClassReadCapacity16()

NTSTATUS ClassReadCapacity16	(	_Inout_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_Inout_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 1568 of file utils.c.

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

Referenced by ClasspAccessAlignmentProperty().

ConvertDataSetRangeToUnmapBlockDescr()

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
	)

Definition at line 3047 of file utils.c.

{
 
    ULONGLONG startingSector;
    ULONGLONG sectorCount;
 
    TracePrint((TRACE_LEVEL_INFORMATION,
                    TRACE_FLAG_IOCTL,
                    "ConvertDataSetRangeToUnmapBlockDescr (%p): Generating UNMAP Block Descriptors from DataSetRange: \
                     \n\t\tStartingOffset = %I64u bytes \
                     \n\t\tLength = %I64u bytes\n",
                    FdoExtension->DeviceObject,
                    DataSetRange->StartingOffset,
                    DataSetRange->LengthInBytes));
 
    while ( (DataSetRange->LengthInBytes > 0) &&
            (*CurrentBlockDescrIndex < MaxBlockDescrIndex) &&
            (*CurrentLbaCount < MaxLbaCount) ) {
 
        //
        // Convert the starting offset and length from bytes to blocks.
        //
        startingSector = (ULONGLONG)(DataSetRange->StartingOffset / FdoExtension->DiskGeometry.BytesPerSector);
        sectorCount = (DataSetRange->LengthInBytes / FdoExtension->DiskGeometry.BytesPerSector);
 
        //
        // Make sure the sector count isn't more than can be specified with a
        // single descriptor.
        //
        if (sectorCount > MAXULONG) {
            sectorCount = MAXULONG;
        }
 
        //
        // The max LBA count is the max number of LBAs that can be unmapped with
        // a single UNMAP command.  Make sure we don't exceed this value.
        //
        if ((*CurrentLbaCount + sectorCount) > MaxLbaCount) {
            sectorCount = MaxLbaCount - *CurrentLbaCount;
        }
 
        REVERSE_BYTES_QUAD(BlockDescr[*CurrentBlockDescrIndex].StartingLba, &startingSector);
        REVERSE_BYTES(BlockDescr[*CurrentBlockDescrIndex].LbaCount, (PULONG)&sectorCount);
 
        DataSetRange->StartingOffset += sectorCount * FdoExtension->DiskGeometry.BytesPerSector;
        DataSetRange->LengthInBytes -= sectorCount * FdoExtension->DiskGeometry.BytesPerSector;
 
        *CurrentBlockDescrIndex += 1;
        *CurrentLbaCount += (ULONG)sectorCount;
 
        TracePrint((TRACE_LEVEL_INFORMATION,
                    TRACE_FLAG_IOCTL,
                    "ConvertDataSetRangeToUnmapBlockDescr (%p): Generated UNMAP Block Descriptor: \
                     \n\t\t\tStartingLBA = %I64u \
                     \n\t\t\tLBACount = %I64u\n",
                    FdoExtension->DeviceObject,
                    startingSector,
                    sectorCount));
    }
 
    return;
}

Referenced by DeviceProcessDsmTrimRequest().

DeviceProcessDsmTrimRequest()

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
	)

Definition at line 3164 of file utils.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
 
    PUNMAP_LIST_HEADER      buffer = NULL;
    PUNMAP_BLOCK_DESCRIPTOR blockDescrPointer;
    ULONG                   bufferLength;
    ULONG                   maxBlockDescrCount;
    ULONG                   neededBlockDescrCount;
    ULONG                   i;
 
    BOOLEAN                 allDataSetRangeFullyConverted;
    BOOLEAN                 needToSendCommand;
    BOOLEAN                 tempDataSetRangeFullyConverted;
 
    ULONG                   dataSetRangeIndex;
    DEVICE_DATA_SET_RANGE   tempDataSetRange;
 
    ULONG                   blockDescrIndex;
    ULONGLONG               lbaCount;
    ULONGLONG               maxLbaCount;
    ULONGLONG               maxParameterListLength;
 
 
    UNREFERENCED_PARAMETER(UnmapGranularity);
    UNREFERENCED_PARAMETER(ActivityId);
    UNREFERENCED_PARAMETER(Irp);
 
    //
    // The given LBA ranges are in DEVICE_DATA_SET_RANGE format and need to be converted into UNMAP Block Descriptors.
    // The UNMAP command is able to carry 0xFFFF bytes (0xFFF8 in reality as there are 8 bytes of header plus n*16 bytes of Block Descriptors) of data.
    // The actual size will also be constrained by the Maximum LBA Count and Maximum Transfer Length.
    //
 
    //
    // 1.1 Calculate how many Block Descriptors are needed to complete this request.
    //
    neededBlockDescrCount = 0;
    for (i = 0; i < DataSetRangesCount; i++) {
        lbaCount = DataSetRanges[i].LengthInBytes / FdoExtension->DiskGeometry.BytesPerSector;
 
        //
        // 1.1.1 the UNMAP_BLOCK_DESCRIPTOR LbaCount is 32 bits, the max value is 0xFFFFFFFF
        //
        if (lbaCount > 0) {
            neededBlockDescrCount += (ULONG)((lbaCount - 1) / MAXULONG + 1);
        }
    }
 
    //
    // Honor Max Unmap Block Descriptor Count if it has been specified.  Otherwise,
    // use the maximum value that the Parameter List Length field will allow (0xFFFF).
    // If the count is 0xFFFFFFFF, then no maximum is specified.
    //
    if (FdoExtension->FunctionSupportInfo->BlockLimitsData.MaxUnmapBlockDescrCount != 0 &&
        FdoExtension->FunctionSupportInfo->BlockLimitsData.MaxUnmapBlockDescrCount != MAXULONG)
    {
        maxParameterListLength = (ULONGLONG)(FdoExtension->FunctionSupportInfo->BlockLimitsData.MaxUnmapBlockDescrCount * sizeof(UNMAP_BLOCK_DESCRIPTOR))
                                 + sizeof(UNMAP_LIST_HEADER);
 
        //
        // In the SBC-3, the Max Unmap Block Descriptor Count field in the 0xB0
        // page is 4 bytes and the Parameter List Length in the UNMAP command is
        // 2 bytes, therefore it is possible that the Max Unmap Block Descriptor
        // Count could imply more bytes than can be specified in the Parameter
        // List Length field.  Adjust for that here.
        //
        maxParameterListLength = min(maxParameterListLength, MAXUSHORT);
    }
    else
    {
        maxParameterListLength = MAXUSHORT;
    }
 
    //
    // 1.2 Calculate the buffer size needed, capped by the device's limitations.
    //
    bufferLength = min(FdoExtension->PrivateFdoData->HwMaxXferLen, (ULONG)maxParameterListLength);
    bufferLength = min(bufferLength, (neededBlockDescrCount * sizeof(UNMAP_BLOCK_DESCRIPTOR) + sizeof(UNMAP_LIST_HEADER)));
 
    maxBlockDescrCount = (bufferLength - sizeof(UNMAP_LIST_HEADER)) / sizeof(UNMAP_BLOCK_DESCRIPTOR);
 
    if (maxBlockDescrCount == 0) {
        //
        // This shouldn't happen since we've already done validation.
        //
        TracePrint((TRACE_LEVEL_INFORMATION,
                                TRACE_FLAG_IOCTL,
                                "DeviceProcessDsmTrimRequest (%p): Max Block Descriptor count is Zero\n",
                                FdoExtension->DeviceObject));
 
        NT_ASSERT(maxBlockDescrCount != 0);
        status = STATUS_DATA_ERROR;
        goto Exit;
    }
 
    //
    // The Maximum LBA Count is set during device initialization.
    //
    maxLbaCount = (ULONGLONG)FdoExtension->FunctionSupportInfo->BlockLimitsData.MaxUnmapLbaCount;
    if (maxLbaCount == 0) {
        //
        // This shouldn't happen since we've already done validation.
        //
        TracePrint((TRACE_LEVEL_INFORMATION,
                                TRACE_FLAG_IOCTL,
                                "DeviceProcessDsmTrimRequest (%p): Max LBA count is Zero\n",
                                FdoExtension->DeviceObject));
 
        NT_ASSERT(maxLbaCount != 0);
        status = STATUS_DATA_ERROR;
        goto Exit;
    }
 
    //
    // Finally, allocate the buffer we'll use to send the UNMAP command.
    //
 
#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.
    //
    bufferLength = ALIGN_UP_BY(bufferLength,KeGetRecommendedSharedDataAlignment());
    buffer = (PUNMAP_LIST_HEADER)ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned, bufferLength, CLASS_TAG_LB_PROVISIONING);
#else
    buffer = (PUNMAP_LIST_HEADER)ExAllocatePoolWithTag(NonPagedPoolNx, bufferLength, CLASS_TAG_LB_PROVISIONING);
#endif
 
    if (buffer == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto Exit;
    }
 
    RtlZeroMemory(buffer, bufferLength);
 
    blockDescrPointer = &buffer->Descriptors[0];
 
    allDataSetRangeFullyConverted = FALSE;
    needToSendCommand = FALSE;
    tempDataSetRangeFullyConverted = TRUE;
    dataSetRangeIndex = 0;
    RtlZeroMemory(&tempDataSetRange, sizeof(tempDataSetRange));
 
    blockDescrIndex = 0;
    lbaCount = 0;
 
 
    while (!allDataSetRangeFullyConverted) {
 
        //
        // If the previous entry conversion completed, go on to the next one;
        // otherwise, continue processing the current entry.
        //
        if (tempDataSetRangeFullyConverted) {
            tempDataSetRange.StartingOffset = DataSetRanges[dataSetRangeIndex].StartingOffset;
            tempDataSetRange.LengthInBytes = DataSetRanges[dataSetRangeIndex].LengthInBytes;
            dataSetRangeIndex++;
        }
 
        ConvertDataSetRangeToUnmapBlockDescr(FdoExtension,
                                                blockDescrPointer,
                                                &blockDescrIndex,
                                                maxBlockDescrCount,
                                                &lbaCount,
                                                maxLbaCount,
                                                &tempDataSetRange
                                                );
 
        tempDataSetRangeFullyConverted = (tempDataSetRange.LengthInBytes == 0) ? TRUE : FALSE;
 
        allDataSetRangeFullyConverted = tempDataSetRangeFullyConverted && (dataSetRangeIndex == DataSetRangesCount);
 
        //
        // Send the UNMAP command when the buffer is full or when all input entries are converted.
        //
        if ((blockDescrIndex == maxBlockDescrCount) ||         // Buffer full or block descriptor count reached
            (lbaCount == maxLbaCount) ||                       // Block LBA count reached
             allDataSetRangeFullyConverted) {                   // All DataSetRanges have been converted
 
            USHORT transferSize;
            USHORT tempSize;
            PCDB   cdb;
 
            //
            // Get the transfer size, including the header.
            //
            transferSize = (USHORT)(blockDescrIndex * sizeof(UNMAP_BLOCK_DESCRIPTOR) + sizeof(UNMAP_LIST_HEADER));
            if (transferSize > bufferLength)
            {
                //
                // This should never happen.
                //
                NT_ASSERT(transferSize <= bufferLength);
                status = STATUS_BUFFER_TOO_SMALL;
                break;
            }
 
            tempSize = transferSize - (USHORT)FIELD_OFFSET(UNMAP_LIST_HEADER, BlockDescrDataLength);
            REVERSE_BYTES_SHORT(buffer->DataLength, &tempSize);
            tempSize = transferSize - (USHORT)FIELD_OFFSET(UNMAP_LIST_HEADER, Descriptors[0]);
            REVERSE_BYTES_SHORT(buffer->BlockDescrDataLength, &tempSize);
 
            //
            // 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);
                    break;
                }
 
            } else {
                RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));
                Srb->Length = sizeof(SCSI_REQUEST_BLOCK);
                Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
            }
 
            //
            // Prepare the Srb
            //
            SrbSetTimeOutValue(Srb, FdoExtension->TimeOutValue);
            SrbSetRequestTag(Srb, SP_UNTAGGED);
            SrbSetRequestAttribute(Srb, SRB_SIMPLE_TAG_REQUEST);
 
            //
            // Set the SrbFlags to indicate that it's a data-out operation.
            // Also set any passed-in SrbFlags.
            //
            SrbAssignSrbFlags(Srb, FdoExtension->SrbFlags);
            SrbClearSrbFlags(Srb, SRB_FLAGS_DATA_IN);
            SrbSetSrbFlags(Srb, SRB_FLAGS_DATA_OUT);
            SrbSetSrbFlags(Srb, SrbFlags);
 
            SrbSetCdbLength(Srb, 10);
 
            cdb = SrbGetCdb(Srb);
            cdb->UNMAP.OperationCode = SCSIOP_UNMAP;
            cdb->UNMAP.Anchor = 0;
            cdb->UNMAP.GroupNumber = 0;
            cdb->UNMAP.AllocationLength[0] = (UCHAR)(transferSize >> 8);
            cdb->UNMAP.AllocationLength[1] = (UCHAR)transferSize;
 
            status = ClassSendSrbSynchronous(FdoExtension->DeviceObject,
                                             Srb,
                                             buffer,
                                             transferSize,
                                             TRUE);
 
            TracePrint((TRACE_LEVEL_INFORMATION,
                        TRACE_FLAG_IOCTL,
                        "DeviceProcessDsmTrimRequest (%p): UNMAP command issued. Returned NTSTATUS: %!STATUS!.\n",
                        FdoExtension->DeviceObject,
                        status
                        ));
 
            //
            // Clear the buffer so we can re-use it.
            //
            blockDescrIndex = 0;
            lbaCount = 0;
            RtlZeroMemory(buffer, bufferLength);
        }
    }
 
Exit:
 
    FREE_POOL(buffer);
 
    return status;
}

Referenced by ClasspDeviceTrimProcess().

FreeDeviceInputMdl()

VOID FreeDeviceInputMdl

(

PMDL

Mdl

)

Definition at line 622 of file utils.c.

{
    ClasspFreeDeviceMdl(Mdl);
    return;
}

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

GetLBAStatus()

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
	)

Definition at line 3772 of file utils.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDB                    cdb;
 
    if (LBAStatusHeader == NULL || LBAStatusSize == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // Build and send down the Get LBA Status command.
    //
    SrbSetTimeOutValue(Srb, FdoExtension->TimeOutValue);
    SrbSetRequestTag(Srb, SP_UNTAGGED);
    SrbSetRequestAttribute(Srb, SRB_SIMPLE_TAG_REQUEST);
    SrbAssignSrbFlags(Srb, FdoExtension->SrbFlags);
    SrbSetCdbLength(Srb, sizeof(cdb->GET_LBA_STATUS));
 
 
    cdb = SrbGetCdb(Srb);
    cdb->GET_LBA_STATUS.OperationCode = SCSIOP_GET_LBA_STATUS;
    cdb->GET_LBA_STATUS.ServiceAction = SERVICE_ACTION_GET_LBA_STATUS;
    REVERSE_BYTES_QUAD(&(cdb->GET_LBA_STATUS.StartingLBA), &StartingLBA);
    REVERSE_BYTES(&(cdb->GET_LBA_STATUS.AllocationLength), &LBAStatusSize);
 
    TracePrint((TRACE_LEVEL_INFORMATION,
                TRACE_FLAG_IOCTL,
                "GetLBAStatus (%p): sending command with StartingLBA = 0x%I64x, AllocationLength = 0x%I64x, ConsolidateableBlocksOnly = %u\n",
                FdoExtension->DeviceObject,
                StartingLBA,
                LBAStatusSize,
                ConsolidateableBlocksOnly));
 
    status = ClassSendSrbSynchronous(FdoExtension->DeviceObject,
                                        Srb,
                                        LBAStatusHeader,
                                        LBAStatusSize,
                                        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) < LBAStatusSize)
    {
        status = STATUS_SUCCESS;
    }
 
    // log command.
    TracePrint((TRACE_LEVEL_INFORMATION,
                TRACE_FLAG_IOCTL,
                "GetLBAStatus (%p): command returned NT Status: %!STATUS!\n",
                FdoExtension->DeviceObject,
                status
                ));
 
    return status;
}

Referenced by ClasspDeviceGetLBAStatusWorker().

IncursSeekPenalty()

static NTSTATUS IncursSeekPenalty ( _In_ USHORT  MediumRotationRate, _In_ PBOOLEAN  IncursSeekPenalty  )

static

Definition at line 1888 of file utils.c.

{
    NTSTATUS status;
 
    if (MediumRotationRate == 0x0001) {
        // Non-rotating media (e.g., solid state device)
        *IncursSeekPenalty = FALSE;
        status = STATUS_SUCCESS;
    } else if ( (MediumRotationRate >= 0x401) &&
                (MediumRotationRate <= 0xFFFE) ) {
        // Nominal media rotation rate in rotations per minute (rpm)
        *IncursSeekPenalty = TRUE;
        status = STATUS_SUCCESS;
    } else {
        // Unknown cases:
        //    0 - Rate not reported
        //    0002h-0400h - Reserved
        //    FFFFh - Reserved
        status = STATUS_UNSUCCESSFUL;
    }
 
    return status;
}

Referenced by ClasspDeviceSeekPenaltyProperty(), and IncursSeekPenalty().

InterpretReadCapacity16Data()

NTSTATUS InterpretReadCapacity16Data	(	_Inout_ PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		_In_ PREAD_CAPACITY16_DATA	ReadCapacity16Data
	)

Definition at line 1517 of file utils.c.

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

Referenced by ClassReadCapacity16().

ValidPersistentReserveScope()

static BOOLEAN ValidPersistentReserveScope ( UCHAR  Scope )

static

Definition at line 6152 of file utils.c.

{
    switch (Scope) {
    case RESERVATION_SCOPE_LU:
    case RESERVATION_SCOPE_ELEMENT:
 
        return TRUE;
 
    default:
 
        break;
    }
 
    return FALSE;
}

Referenced by ClasspPersistentReserve().

ValidPersistentReserveType()

static BOOLEAN ValidPersistentReserveType ( UCHAR  Type )

static

Definition at line 6171 of file utils.c.

{
    switch (Type) {
    case RESERVATION_TYPE_WRITE_EXCLUSIVE:
    case RESERVATION_TYPE_EXCLUSIVE:
    case RESERVATION_TYPE_WRITE_EXCLUSIVE_REGISTRANTS:
    case RESERVATION_TYPE_EXCLUSIVE_REGISTRANTS:
 
        return TRUE;
 
    default:
 
        break;
    }
 
    return FALSE;
}

Referenced by ClasspPersistentReserve().