sense.c File Reference

#include "stddef.h"
#include "string.h"
#include "ntddk.h"
#include "ntddstor.h"
#include "cdrom.h"
#include "ntstrsafe.h"

Include dependency graph for sense.c:

Go to the source code of this file.

Classes
struct	_ERROR_LOG_CONTEXT

Macros
#define	TOTAL_COUNT_RETRY_DEFAULT   4
#define	TOTAL_COUNT_RETRY_LOCK_MEDIA   1
#define	TOTAL_COUNT_RETRY_MODESENSE   1
#define	TOTAL_COUNT_RETRY_READ_CAPACITY   1
#define	TOTAL_SECONDS_RETRY_TIME_WRITE   160
#define	TOTAL_SECONDS_RETRY_TIME_MEDIUM_REMOVAL   120

Typedefs
typedef struct _ERROR_LOG_CONTEXT	ERROR_LOG_CONTEXT
typedef struct _ERROR_LOG_CONTEXT *	PERROR_LOG_CONTEXT

Functions
VOID	SenseInfoInterpretRefineByIoControl (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ ULONG IoControlCode, _In_ BOOLEAN OverrideVerifyVolume, _Inout_ BOOLEAN *Retry, _Inout_ NTSTATUS *Status)
NTSTATUS	DeviceErrorHandlerForMmc (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _Inout_ PNTSTATUS Status, _Inout_ PBOOLEAN Retry)
NTSTATUS	DeviceErrorHandlerForHitachiGD2000 (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _Inout_ PNTSTATUS Status, _Inout_ PBOOLEAN Retry)
VOID	SenseInfoRequestGetInformation (_In_ WDFREQUEST Request, _Out_ UCHAR *MajorFunctionCode, _Out_ ULONG *IoControlCode, _Out_ BOOLEAN *OverrideVerifyVolume, _Out_ ULONGLONG *Total100nsSinceFirstSend)
BOOLEAN	SenseInfoInterpretByAdditionalSenseCode (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ UCHAR AdditionalSenseCode, _In_ UCHAR AdditionalSenseCodeQual, _Inout_ NTSTATUS *Status, _Inout_ BOOLEAN *Retry, _Out_ _Deref_out_range_(0, 100) ULONG *RetryIntervalInSeconds, _Inout_ PERROR_LOG_CONTEXT LogContext)
VOID	SenseInfoInterpretBySenseKey (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSENSE_DATA SenseData, _In_ UCHAR SenseKey, _Inout_ NTSTATUS *Status, _Inout_ BOOLEAN *Retry, _Out_ _Deref_out_range_(0, 100) ULONG *RetryIntervalInSeconds, _Inout_ PERROR_LOG_CONTEXT LogContext)
VOID	SenseInfoInterpretBySrbStatus (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONG RetriedCount, _Inout_ NTSTATUS *Status, _Inout_ BOOLEAN *Retry, _Out_ _Deref_out_range_(0, 100) ULONG *RetryIntervalInSeconds, _Inout_ PERROR_LOG_CONTEXT LogContext)
VOID	SenseInfoLogError (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ UCHAR MajorFunctionCode, _In_ ULONG IoControlCode, _In_ ULONG RetriedCount, _In_ NTSTATUS *Status, _In_ BOOLEAN *Retry, _Inout_ PERROR_LOG_CONTEXT LogContext)
VOID	SenseInfoInterpretRefineByScsiCommand (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONG RetriedCount, _In_ LONGLONG Total100nsSinceFirstSend, _In_ BOOLEAN OverrideVerifyVolume, _Inout_ BOOLEAN *Retry, _Inout_ NTSTATUS *Status, _Inout_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *RetryIntervalIn100ns)
BOOLEAN	SenseInfoInterpret (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONG RetriedCount, _Out_ NTSTATUS *Status, _Out_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *RetryIntervalIn100ns)
BOOLEAN	SenseInfoInterpretForZPODD (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _Out_ NTSTATUS *Status, _Out_ _Out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *RetryIntervalIn100ns)
BOOLEAN	RequestSenseInfoInterpret (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONG RetriedCount, _Out_ NTSTATUS *Status, _Out_opt_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *RetryIntervalIn100ns)
BOOLEAN	RequestSenseInfoInterpretForScratchBuffer (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ ULONG RetriedCount, _Out_ NTSTATUS *Status, _Out_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *RetryIntervalIn100ns)

Macro Definition Documentation

TOTAL_COUNT_RETRY_DEFAULT

#define TOTAL_COUNT_RETRY_DEFAULT   4

Definition at line 69 of file sense.c.

TOTAL_COUNT_RETRY_LOCK_MEDIA

#define TOTAL_COUNT_RETRY_LOCK_MEDIA   1

Definition at line 70 of file sense.c.

TOTAL_COUNT_RETRY_MODESENSE

#define TOTAL_COUNT_RETRY_MODESENSE   1

Definition at line 71 of file sense.c.

TOTAL_COUNT_RETRY_READ_CAPACITY

#define TOTAL_COUNT_RETRY_READ_CAPACITY   1

Definition at line 72 of file sense.c.

TOTAL_SECONDS_RETRY_TIME_MEDIUM_REMOVAL

#define TOTAL_SECONDS_RETRY_TIME_MEDIUM_REMOVAL   120

Definition at line 76 of file sense.c.

TOTAL_SECONDS_RETRY_TIME_WRITE

#define TOTAL_SECONDS_RETRY_TIME_WRITE   160

Definition at line 75 of file sense.c.

Typedef Documentation

ERROR_LOG_CONTEXT

typedef struct _ERROR_LOG_CONTEXT ERROR_LOG_CONTEXT

PERROR_LOG_CONTEXT

typedef struct _ERROR_LOG_CONTEXT * PERROR_LOG_CONTEXT

Function Documentation

DeviceErrorHandlerForHitachiGD2000()

NTSTATUS DeviceErrorHandlerForHitachiGD2000	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_Inout_ PNTSTATUS	Status,
		_Inout_ PBOOLEAN	Retry
	)

Definition at line 361 of file sense.c.

{
    PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
 
    if (!TEST_FLAG(Srb->SrbStatus, SRB_STATUS_AUTOSENSE_VALID))
    {
        return STATUS_SUCCESS; //nobody cares about this return value yet.
    }
 
    if (((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_HARDWARE_ERROR) &&
        (senseBuffer->AdditionalSenseCode == 0x44))
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                    "DeviceErrorHandlerForHitachiGD2000 (%p) => Internal Target "
                    "Failure Detected -- spinning up drive\n", DeviceExtension->Device));
 
        // the request should be retried because the device isn't ready
        *Retry = TRUE;
        *Status = STATUS_DEVICE_NOT_READY;
 
        // send a START_STOP unit to spin up the drive
        // NOTE: this temporarily violates the StartIo serialization
        //       mechanism, but the completion routine on this will NOT
        //       call StartNextPacket(), so it's a temporary disruption
        //       of the serialization only.
        DeviceSendStartUnit(DeviceExtension->Device);
    }
 
    return STATUS_SUCCESS;
}

DeviceErrorHandlerForMmc()

NTSTATUS DeviceErrorHandlerForMmc	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_Inout_ PNTSTATUS	Status,
		_Inout_ PBOOLEAN	Retry
	)

Definition at line 87 of file sense.c.

{
    BOOLEAN mediaChange = FALSE;
    PCDB    cdb = (PCDB)Srb->Cdb;
 
    if (TEST_FLAG(Srb->SrbStatus, SRB_STATUS_AUTOSENSE_VALID))
    {
        PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;
 
        // the following sense keys could indicate a change in capabilities.
 
        // we used to expect this to be serialized, and only hit from our
        // own routine. we now allow some requests to continue during our
        // processing of the capabilities update in order to allow
        // IoReadPartitionTable() to succeed.
        switch (senseBuffer->SenseKey & 0xf)
        {
 
        case SCSI_SENSE_NOT_READY:
        {
            if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_NO_MEDIA_IN_DEVICE)
            {
                if (DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed)
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: media removed, writes will be "
                               "failed until new media detected\n"));
                }
 
                // NOTE - REF #0002
                DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
            }
            else if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY)
            {
                if (senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_BECOMING_READY)
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: media becoming ready, "
                               "SHOULD notify shell of change time by sending "
                               "GESN request immediately!\n"));
                }
                else if (((senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_OPERATION_IN_PROGRESS) ||
                            (senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_LONG_WRITE_IN_PROGRESS)
                            ) &&
                           ((Srb->Cdb[0] == SCSIOP_READ) ||
                            (Srb->Cdb[0] == SCSIOP_READ6) ||
                            (Srb->Cdb[0] == SCSIOP_READ_CAPACITY) ||
                            (Srb->Cdb[0] == SCSIOP_READ_CD) ||
                            (Srb->Cdb[0] == SCSIOP_READ_CD_MSF) ||
                            (Srb->Cdb[0] == SCSIOP_READ_TOC) ||
                            (Srb->Cdb[0] == SCSIOP_WRITE) ||
                            (Srb->Cdb[0] == SCSIOP_WRITE6) ||
                            (Srb->Cdb[0] == SCSIOP_READ_TRACK_INFORMATION) ||
                            (Srb->Cdb[0] == SCSIOP_READ_DISK_INFORMATION)
                            )
                           )
                {
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: LONG_WRITE or "
                               "OP_IN_PROGRESS for limited subset of cmds -- "
                               "setting retry to TRUE\n"));
                    *Retry = TRUE;
                    *Status = STATUS_DEVICE_BUSY;
                }
            }
            break;
        } // end SCSI_SENSE_NOT_READY
 
        case SCSI_SENSE_UNIT_ATTENTION:
        {
            switch (senseBuffer->AdditionalSenseCode)
            {
            case SCSI_ADSENSE_MEDIUM_CHANGED:
            {
                // always update if the medium may have changed
 
                // NOTE - REF #0002
                DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
                DeviceExtension->DeviceAdditionalData.Mmc.UpdateState = CdromMmcUpdateRequired;
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                           "DeviceErrorHandlerForMmc: media change detected, need to "
                           "update drive capabilities\n"));
                mediaChange = TRUE;
                break;
 
            } // end SCSI_ADSENSE_MEDIUM_CHANGED
 
            case SCSI_ADSENSE_BUS_RESET:
            {
                // NOTE - REF #0002
                DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
                DeviceExtension->DeviceAdditionalData.Mmc.UpdateState = CdromMmcUpdateRequired;
 
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                           "DeviceErrorHandlerForMmc: bus reset detected, need to "
                           "update drive capabilities\n"));
                break;
 
            } // end SCSI_ADSENSE_BUS_RESET
 
            case SCSI_ADSENSE_OPERATOR_REQUEST:
            {
 
                BOOLEAN b = FALSE;
 
                switch (senseBuffer->AdditionalSenseCodeQualifier)
                {
                case SCSI_SENSEQ_MEDIUM_REMOVAL:
                {
                    // eject notification currently handled by classpnp
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: Eject requested by user\n"));
                    *Retry = TRUE;
                    *Status = STATUS_DEVICE_BUSY;
                    break;
                }
 
                case SCSI_SENSEQ_WRITE_PROTECT_DISABLE:
                    b = TRUE;
                case SCSI_SENSEQ_WRITE_PROTECT_ENABLE:
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: Write protect %s requested "
                               "by user\n",
                               (b ? "disable" : "enable")));
                    *Retry = TRUE;
                    *Status = STATUS_DEVICE_BUSY;
                    // NOTE - REF #0002
                    DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
                    DeviceExtension->DeviceAdditionalData.Mmc.UpdateState = CdromMmcUpdateRequired;
 
                    break;
                }
 
                } // end of AdditionalSenseCodeQualifier switch
 
 
                break;
 
            } // end SCSI_ADSENSE_OPERATOR_REQUEST
 
            default:
            {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                           "DeviceErrorHandlerForMmc: Unit attention %02x/%02x\n",
                           senseBuffer->AdditionalSenseCode,
                           senseBuffer->AdditionalSenseCodeQualifier));
                break;
            }
 
            } // end of AdditionSenseCode switch
            break;
 
        } // end SCSI_SENSE_UNIT_ATTENTION
 
        case SCSI_SENSE_ILLEGAL_REQUEST:
        {
            if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_WRITE_PROTECT)
            {
                if (DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed)
                {
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: media was writable, but "
                               "failed request with WRITE_PROTECT error...\n"));
                }
                // NOTE - REF #0002
                // do not update all the capabilities just because
                // we can't write to the disc.
                DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
            }
            break;
        } // end SCSI_SENSE_ILLEGAL_REQUEST
 
        } // end of SenseKey switch
 
        // Check if we failed to set the DVD region key and send appropriate error
        if (cdb->CDB16.OperationCode == SCSIOP_SEND_KEY)
        {
            if (cdb->SEND_KEY.KeyFormat == DvdSetRpcKey)
            {
                if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_NO_MEDIA_IN_DEVICE)
                {
                    // media of appropriate region required
                    *Status = STATUS_NO_MEDIA_IN_DEVICE;
                    *Retry = FALSE;
                }
                else if ((senseBuffer->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST) &&
                           (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_COPY_PROTECTION_FAILURE) &&
                           (senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_MEDIA_CODE_MISMATCHED_TO_LOGICAL_UNIT))
                {
                    // media of appropriate region required
                    *Status = STATUS_CSS_REGION_MISMATCH;
                    *Retry = FALSE;
                }
                else if ((senseBuffer->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST) &&
                           (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_INVALID_MEDIA) &&
                           (senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_INCOMPATIBLE_FORMAT))
                {
                    // media of appropriate region required
                    *Status = STATUS_CSS_REGION_MISMATCH;
                    *Retry = FALSE;
                }
            }
        }
    } // end of SRB_STATUS_AUTOSENSE_VALID
 
    // On media change, if device speed should be reset to default then
    // queue a workitem to send the commands to the device. Do this on
    // media arrival as some device will fail this command if no media
    // is present. Ignore the fake media change from classpnp driver.
    if ((mediaChange == TRUE) && (*Status != STATUS_MEDIA_CHANGED))
    {
        if (DeviceExtension->DeviceAdditionalData.RestoreDefaults == TRUE)
        {
            NTSTATUS                status = STATUS_SUCCESS;
            WDF_OBJECT_ATTRIBUTES   attributes;
            WDF_WORKITEM_CONFIG     workitemConfig;
            WDFWORKITEM             workItem;
 
            WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
            attributes.ParentObject = DeviceExtension->Device;
 
            WDF_WORKITEM_CONFIG_INIT(&workitemConfig,
                                     DeviceRestoreDefaultSpeed);
 
            status = WdfWorkItemCreate(&workitemConfig,
                                       &attributes,
                                       &workItem);
            if (!NT_SUCCESS(status))
            {
                return STATUS_SUCCESS;
            }
 
            WdfWorkItemEnqueue(workItem);
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                        "DeviceErrorHandlerForMmc: Restore device default speed for %p\n",
                        DeviceExtension->DeviceObject));
        }
    }
    return STATUS_SUCCESS;
}

RequestSenseInfoInterpret()

BOOLEAN RequestSenseInfoInterpret	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ ULONG	RetriedCount,
		_Out_ NTSTATUS *	Status,
		_Out_opt_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *	RetryIntervalIn100ns
	)

Definition at line 2467 of file sense.c.

{
    BOOLEAN                 retry = FALSE;
    LONGLONG                retryIntervalIn100ns = 0;
    PZERO_POWER_ODD_INFO    zpoddInfo = DeviceExtension->ZeroPowerODDInfo;
 
    if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SUCCESS)
    {
        // request succeeded.
        if ((zpoddInfo != NULL) &&
            (zpoddInfo->BecomingReadyRetryCount > 0))
        {
            zpoddInfo->BecomingReadyRetryCount = 0;
        }
 
        *Status = STATUS_SUCCESS;
        retry = FALSE;
    }
    else
    {
        // request failed. We need to process the error.
 
        // 1. Release the queue if it is frozen.
        if (Srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN)
        {
            DeviceReleaseQueue(DeviceExtension->Device);
        }
 
        if ((zpoddInfo != NULL) &&
            ((zpoddInfo->RetryFirstCommand != FALSE) || (zpoddInfo->BecomingReadyRetryCount > 0)))
        {
            retry = SenseInfoInterpretForZPODD(DeviceExtension,
                                               Srb,
                                               Status,
                                               &retryIntervalIn100ns);
        }
 
        if (retry == FALSE)
        {
            // 2. Error Processing
            if ((zpoddInfo != NULL) &&
                (zpoddInfo->BecomingReadyRetryCount > 0))
            {
                zpoddInfo->BecomingReadyRetryCount = 0;
            }
 
            retry = SenseInfoInterpret(DeviceExtension,
                                       Request,
                                       Srb,
                                       RetriedCount,
                                       Status,
                                       &retryIntervalIn100ns);
        }
    }
 
    if (RetryIntervalIn100ns != NULL)
    {
        *RetryIntervalIn100ns = retryIntervalIn100ns;
    }
 
    return retry;
}

Referenced by _IRQL_requires_max_(), and RequestSenseInfoInterpretForScratchBuffer().

RequestSenseInfoInterpretForScratchBuffer()

BOOLEAN RequestSenseInfoInterpretForScratchBuffer	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ ULONG	RetriedCount,
		_Out_ NTSTATUS *	Status,
		_Out_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *	RetryIntervalIn100ns
	)

Definition at line 2564 of file sense.c.

{
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchInUse != 0);
 
    return RequestSenseInfoInterpret(DeviceExtension,
                                     DeviceExtension->ScratchContext.ScratchRequest,
                                     DeviceExtension->ScratchContext.ScratchSrb,
                                     RetriedCount,
                                     Status,
                                     RetryIntervalIn100ns);
}

Referenced by RequestIssueShutdownFlush(), and ScratchBuffer_ReadWriteCompletionRoutine().

SenseInfoInterpret()

BOOLEAN SenseInfoInterpret	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ ULONG	RetriedCount,
		_Out_ NTSTATUS *	Status,
		_Out_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *	RetryIntervalIn100ns
	)

Definition at line 2038 of file sense.c.

{
    ULONG               retryIntervalInSeconds = 0;
    BOOLEAN             retry = TRUE;
    PSENSE_DATA         senseBuffer = Srb->SenseInfoBuffer;
    ULONG               readSector = 0;
    ERROR_LOG_CONTEXT   logContext;
 
    UCHAR                   majorFunctionCode = 0;
    ULONG                   ioControlCode = 0;
    BOOLEAN                 overrideVerifyVolume = FALSE;
    ULONGLONG               total100nsSinceFirstSend = 0;
    PZERO_POWER_ODD_INFO    zpoddInfo = DeviceExtension->ZeroPowerODDInfo;
 
    //
    *Status = STATUS_IO_DEVICE_ERROR;
 
    RtlZeroMemory(&logContext, sizeof(ERROR_LOG_CONTEXT));
    logContext.ErrorCode = -1;
 
    // Get Original Request related information
    SenseInfoRequestGetInformation(Request,
                                   &majorFunctionCode,
                                   &ioControlCode,
                                   &overrideVerifyVolume,
                                   &total100nsSinceFirstSend);
 
    if(TEST_FLAG(Srb->SrbFlags, SRB_CLASS_FLAGS_PAGING))
    {
        // Log anything remotely incorrect about paging i/o
        logContext.LogError = TRUE;
        logContext.UniqueErrorValue = 301;
        logContext.ErrorCode = IO_WARNING_PAGING_FAILURE;
    }
 
    // must handle the SRB_STATUS_INTERNAL_ERROR case first,
    // as it has all the flags set.
    if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_INTERNAL_ERROR)
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                    "SenseInfoInterpret: Internal Error code is %x\n",
                    Srb->InternalStatus));
 
        retry = FALSE;
        *Status = Srb->InternalStatus;
    }
    else if (Srb->ScsiStatus == SCSISTAT_RESERVATION_CONFLICT)
    {
        retry = FALSE;
        *Status = STATUS_DEVICE_BUSY;
        logContext.LogError = FALSE;
    }
    else if ((Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID) &&
             (Srb->SenseInfoBufferLength >= RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseLength)))
    {
        UCHAR   senseKey = (UCHAR)(senseBuffer->SenseKey & 0x0f);
        UCHAR   additionalSenseCode = 0;
        UCHAR   additionalSenseCodeQual = 0;
 
        // Zero the additional sense code and additional sense code qualifier
        // if they were not returned by the device.
        readSector = senseBuffer->AdditionalSenseLength + offsetof(SENSE_DATA, AdditionalSenseLength);
        if (readSector > Srb->SenseInfoBufferLength)
        {
            readSector = Srb->SenseInfoBufferLength;
        }
 
        additionalSenseCode = (readSector >= RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseCode)) ?
                               senseBuffer->AdditionalSenseCode : 0;
        additionalSenseCodeQual = (readSector >= RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseCodeQualifier)) ?
                                   senseBuffer->AdditionalSenseCodeQualifier : 0;
 
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                    "SCSI Error - \n"
                    "\tcdb: %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n"
                    "\tsrb status: %X; sense: %02X/%02X/%02X; Retried count: %d\n\n",
                    Srb->Cdb[0], Srb->Cdb[1], Srb->Cdb[2], Srb->Cdb[3], Srb->Cdb[4], Srb->Cdb[5],
                    Srb->Cdb[6], Srb->Cdb[7], Srb->Cdb[8], Srb->Cdb[9], Srb->Cdb[10], Srb->Cdb[11],
                    Srb->Cdb[12], Srb->Cdb[13], Srb->Cdb[14], Srb->Cdb[15],
                    SRB_STATUS(Srb->SrbStatus),
                    senseKey,
                    additionalSenseCode,
                    additionalSenseCodeQual,
                    RetriedCount));
 
        if (senseKey == SCSI_SENSE_UNIT_ATTENTION)
        {
            ULONG   mediaChangeCount;
 
            // A media change may have occured so increment the change count for the physical device
            mediaChangeCount = InterlockedIncrement((PLONG)&DeviceExtension->MediaChangeCount);
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                       "SenseInfoInterpret: Media change count for device %d incremented to %#lx\n",
                       DeviceExtension->DeviceNumber, mediaChangeCount));
        }
 
        if ((zpoddInfo != NULL) &&
            (((PCDB)Srb->Cdb)->CDB6GENERIC.OperationCode == SCSIOP_TEST_UNIT_READY))
        {
            // This sense code is in response to the Test Unit Ready sent during delayed power down
            // request. Copy the sense data into the zpoddInfo structure for later processing.
            zpoddInfo->SenseKey = senseKey;
            zpoddInfo->AdditionalSenseCode = additionalSenseCode;
            zpoddInfo->AdditionalSenseCodeQualifier = additionalSenseCodeQual;
        }
 
        // Interpret error by specific ASC & ASCQ first,
        // If the error is not handled, interpret using f
        {
            BOOLEAN notHandled = FALSE;
            notHandled = SenseInfoInterpretByAdditionalSenseCode(DeviceExtension,
                                                                 Srb,
                                                                 additionalSenseCode,
                                                                 additionalSenseCodeQual,
                                                                 Status,
                                                                 &retry,
                                                                 &retryIntervalInSeconds,
                                                                 &logContext);
 
            if (notHandled)
            {
                SenseInfoInterpretBySenseKey(DeviceExtension,
                                             senseBuffer,
                                             senseKey,
                                             Status,
                                             &retry,
                                             &retryIntervalInSeconds,
                                             &logContext);
            }
        }
 
        // Try to determine the bad sector from the inquiry data.
        if ((IS_SCSIOP_READWRITE(((PCDB)Srb->Cdb)->CDB10.OperationCode)) ||
            (((PCDB)Srb->Cdb)->CDB10.OperationCode == SCSIOP_VERIFY)     ||
            (((PCDB)Srb->Cdb)->CDB10.OperationCode == SCSIOP_VERIFY16))
        {
            ULONG index;
            readSector = 0;
 
            for (index = 0; index < 4; index++)
            {
                logContext.BadSector = (logContext.BadSector << 8) | senseBuffer->Information[index];
            }
 
            for (index = 0; index < 4; index++)
            {
                readSector = (readSector << 8) | Srb->Cdb[index+2];
            }
 
            index = (((PCDB)Srb->Cdb)->CDB10.TransferBlocksMsb << 8) |
                    ((PCDB)Srb->Cdb)->CDB10.TransferBlocksLsb;
 
            // Make sure the bad sector is within the read sectors.
            if (!(logContext.BadSector >= readSector && logContext.BadSector < (readSector + index)))
            {
                logContext.BadSector = readSector;
            }
        }
    }
    else
    {
        // Request sense buffer not valid. No sense information
        // to pinpoint the error. Return general request fail.
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                    "SCSI Error - \n"
                    "\tcdb: %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n"
                    "\tsrb status: %X; sense info not valid; Retried count: %d\n\n",
                    Srb->Cdb[0], Srb->Cdb[1], Srb->Cdb[2], Srb->Cdb[3], Srb->Cdb[4], Srb->Cdb[5],
                    Srb->Cdb[6], Srb->Cdb[7], Srb->Cdb[8], Srb->Cdb[9], Srb->Cdb[10], Srb->Cdb[11],
                    Srb->Cdb[12], Srb->Cdb[13], Srb->Cdb[14], Srb->Cdb[15],
                    SRB_STATUS(Srb->SrbStatus),
                    RetriedCount));
 
        SenseInfoInterpretBySrbStatus(DeviceExtension,
                                      Srb,
                                      RetriedCount,
                                      Status,
                                      &retry,
                                      &retryIntervalInSeconds,
                                      &logContext);
    }
 
    // all functions using unit - seconds for retry Interval already be called.
    *RetryIntervalIn100ns = SECONDS_TO_100NS_UNITS(retryIntervalInSeconds);
 
    // call the device specific error handler if it has one.
    // DeviceErrorHandlerForMmmc() for all MMC devices
    // or DeviceErrorHandlerForHitachiGD2000() for HITACHI GD-2000, HITACHI DVD-ROM GD-2000
    if (DeviceExtension->DeviceAdditionalData.ErrorHandler)
    {
        DeviceExtension->DeviceAdditionalData.ErrorHandler(DeviceExtension, Srb, Status, &retry);
    }
 
    // Refine retry based on SCSI command
    SenseInfoInterpretRefineByScsiCommand(DeviceExtension,
                                          Srb,
                                          RetriedCount,
                                          total100nsSinceFirstSend,
                                          overrideVerifyVolume,
                                          &retry,
                                          Status,
                                          RetryIntervalIn100ns);
 
    // Refine retry based on IOCTL code.
    if (majorFunctionCode == IRP_MJ_DEVICE_CONTROL)
    {
        SenseInfoInterpretRefineByIoControl(DeviceExtension,
                                            ioControlCode,
                                            overrideVerifyVolume,
                                            &retry,
                                            Status);
    }
 
    // LOG the error:
    //  Always log the error in our internal log.
    //  If logError is set, also log the error in the system log.
    SenseInfoLogError(DeviceExtension,
                      Srb,
                      majorFunctionCode,
                      ioControlCode,
                      RetriedCount,
                      Status,
                      &retry,
                      &logContext);
 
    // all process about the error done. check if the irp was cancelled.
    if ((!NT_SUCCESS(*Status)) && retry)
    {
        PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);
 
        if ((requestContext->OriginalRequest != NULL) &&
            WdfRequestIsCanceled(requestContext->OriginalRequest)
            )
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                       "Request %p was cancelled when it would have been retried\n",
                       requestContext->OriginalRequest));
 
            *Status = STATUS_CANCELLED;
            retry = FALSE;
            *RetryIntervalIn100ns = 0;
        }
    }
 
    // now, all decisions are made. display trace information.
    if (retry)
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                   "Command shall be retried in %2I64d.%03I64d seconds\n",
                   (*RetryIntervalIn100ns / UNIT_100NS_PER_SECOND),
                   (*RetryIntervalIn100ns / 10000) % 1000
                   ));
    }
    else
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                   "Will not retry; Sense/ASC/ASCQ of %02x/%02x/%02x\n",
                   senseBuffer->SenseKey,
                   senseBuffer->AdditionalSenseCode,
                   senseBuffer->AdditionalSenseCodeQualifier
                   ));
    }
 
    return retry;
 
} // end SenseInfoInterpret()

Referenced by RequestSenseInfoInterpret().

SenseInfoInterpretByAdditionalSenseCode()

BOOLEAN SenseInfoInterpretByAdditionalSenseCode	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ UCHAR	AdditionalSenseCode,
		_In_ UCHAR	AdditionalSenseCodeQual,
		_Inout_ NTSTATUS *	Status,
		_Inout_ BOOLEAN *	Retry,
		_Out_ _Deref_out_range_(0, 100) ULONG *	RetryIntervalInSeconds,
		_Inout_ PERROR_LOG_CONTEXT	LogContext
	)

Definition at line 484 of file sense.c.

{
    BOOLEAN     needFurtherInterpret = TRUE;
    PSENSE_DATA senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
    // set default values for retry fields.
    *Status = STATUS_IO_DEVICE_ERROR;
    *Retry = TRUE;
    *RetryIntervalInSeconds = 0;
 
    switch (AdditionalSenseCode)
    {
    case SCSI_ADSENSE_LUN_NOT_READY:
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretByAdditionalSenseCode: Lun not ready\n"));
 
            //
            //  Many non-WHQL certified drives (mostly CD-RW) return
            //  2/4/0 when they have no media instead of the obvious choice of:
            //
            //      SCSI_SENSE_NOT_READY/SCSI_ADSENSE_NO_MEDIA_IN_DEVICE
            //
            //  These drives should not pass WHQL certification due to this discrepency.
            //
            //  However, we have to retry on 2/4/0 (Not ready, LUN not ready, no info)
            //  and also 3/2/0 (no seek complete).
            //
            //  These conditions occur when the shell tries to examine an
            //  injected CD (e.g. for autoplay) before the CD is spun up.
            //
            //  The drive should be returning an ASCQ of SCSI_SENSEQ_BECOMING_READY
            //  (0x01) in order to comply with WHQL standards.
            //
            //  The default retry timeout of one second is acceptable to balance
            //  these discrepencies.  don't modify the status, though....
            //
 
            switch (AdditionalSenseCodeQual)
            {
            case SCSI_SENSEQ_OPERATION_IN_PROGRESS:
                {
                    DEVICE_EVENT_BECOMING_READY notReady = {0};
 
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                                "SenseInfoInterpretByAdditionalSenseCode: Operation In Progress\n"));
 
                    needFurtherInterpret = FALSE;
 
                    *Retry = TRUE;
                    *RetryIntervalInSeconds = NOT_READY_RETRY_INTERVAL;
                    *Status = STATUS_DEVICE_NOT_READY;
 
                    notReady.Version = 1;
                    notReady.Reason = 2;
                    notReady.Estimated100msToReady = *RetryIntervalInSeconds * 10;
                    DeviceSendNotification(DeviceExtension,
                                           &GUID_IO_DEVICE_BECOMING_READY,
                                           sizeof(DEVICE_EVENT_BECOMING_READY),
                                           &notReady);
 
                    break;
                }
 
            case SCSI_SENSEQ_BECOMING_READY:
                {
                    DEVICE_EVENT_BECOMING_READY notReady = {0};
 
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                                "SenseInfoInterpretByAdditionalSenseCode: In process of becoming ready\n"));
 
                    needFurtherInterpret = FALSE;
 
                    *Retry = TRUE;
                    *RetryIntervalInSeconds = NOT_READY_RETRY_INTERVAL;
                    *Status = STATUS_DEVICE_NOT_READY;
 
                    notReady.Version = 1;
                    notReady.Reason = 1;
                    notReady.Estimated100msToReady = *RetryIntervalInSeconds * 10;
                    DeviceSendNotification(DeviceExtension,
                                           &GUID_IO_DEVICE_BECOMING_READY,
                                           sizeof(DEVICE_EVENT_BECOMING_READY),
                                           &notReady);
 
                    break;
                }
 
            case SCSI_SENSEQ_LONG_WRITE_IN_PROGRESS:
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                                "SenseInfoInterpretByAdditionalSenseCode: Long write in progress\n"));
 
                    needFurtherInterpret = FALSE;
 
                    // This has been seen as a transcient failure on some drives
                    *Status = STATUS_DEVICE_NOT_READY;
                    *Retry = TRUE;
                    // Set retry interval to be 0 as the drive can be ready at anytime.
                    *RetryIntervalInSeconds = 0;
 
                    break;
                }
 
            case SCSI_SENSEQ_MANUAL_INTERVENTION_REQUIRED:
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                                "SenseInfoInterpretByAdditionalSenseCode: Manual intervention required\n"));
 
                    needFurtherInterpret = FALSE;
 
                    *Status = STATUS_NO_MEDIA_IN_DEVICE;
                    *Retry = FALSE;
                    *RetryIntervalInSeconds = NOT_READY_RETRY_INTERVAL;
 
                    break;
                }
 
            case SCSI_SENSEQ_FORMAT_IN_PROGRESS:
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                                "SenseInfoInterpretByAdditionalSenseCode: Format in progress\n"));
 
                    needFurtherInterpret = FALSE;
 
                    *Status = STATUS_DEVICE_NOT_READY;
                    *Retry = FALSE;
                    *RetryIntervalInSeconds = NOT_READY_RETRY_INTERVAL;
 
                    break;
                }
 
            case SCSI_SENSEQ_CAUSE_NOT_REPORTABLE:
            case SCSI_SENSEQ_INIT_COMMAND_REQUIRED:
            default:
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                                "SenseInfoInterpretByAdditionalSenseCode: Initializing command required\n"));
 
                    needFurtherInterpret = FALSE;
 
                    *Status = STATUS_DEVICE_NOT_READY;
                    *Retry = TRUE;
                    *RetryIntervalInSeconds = 0;
 
                    // This sense code/additional sense code combination may indicate
                    // that the device needs to be started.
                    if (TEST_FLAG(DeviceExtension->DeviceFlags, DEV_SAFE_START_UNIT) &&
                        !TEST_FLAG(Srb->SrbFlags, SRB_CLASS_FLAGS_LOW_PRIORITY))
                    {
                        DeviceSendStartUnit(DeviceExtension->Device);
                    }
 
                    break;
                }
            } // end switch (AdditionalSenseCodeQual)
            break;
 
        } // end case (SCSI_ADSENSE_LUN_NOT_READY)
 
    case SCSI_ADSENSE_NO_MEDIA_IN_DEVICE:
        {
            TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretByAdditionalSenseCode: No Media in device.\n"));
 
            needFurtherInterpret = FALSE;
 
            *Status = STATUS_NO_MEDIA_IN_DEVICE;
            *Retry = FALSE;
 
            if (AdditionalSenseCodeQual == 0xCC)
            {
                //  The IMAPIv1 filter returns this ASCQ value while it is burning CD media, and we want
                //  to preserve this functionality for compatibility reasons.
                //  We want to indicate that the media is not present to most applications;
                //  but RSM has to know that the media is still in the drive (i.e. the drive is not free).
                DeviceSetMediaChangeStateEx(DeviceExtension, MediaUnavailable, NULL);
            }
            else
            {
                DeviceSetMediaChangeStateEx(DeviceExtension, MediaNotPresent, NULL);
            }
 
            break;
        } // end case SCSI_ADSENSE_NO_MEDIA_IN_DEVICE
 
    case SCSI_ADSENSE_INVALID_MEDIA:
        {
        switch (AdditionalSenseCodeQual)
        {
 
        case SCSI_SENSEQ_UNKNOWN_FORMAT:
            {
                needFurtherInterpret = FALSE;
 
                // Log error only if this is a paging request
                *Status = STATUS_UNRECOGNIZED_MEDIA;
                *Retry = FALSE;
 
                LogContext->LogError = TEST_FLAG(Srb->SrbFlags, SRB_CLASS_FLAGS_PAGING);
                LogContext->UniqueErrorValue = 256;
                LogContext->ErrorCode = IO_ERR_BAD_BLOCK;
 
                break;
            }
 
        case SCSI_SENSEQ_INCOMPATIBLE_FORMAT:
            {
                needFurtherInterpret = FALSE;
 
                *Status = STATUS_UNRECOGNIZED_MEDIA;
                *Retry = FALSE;
 
                LogContext->LogError = FALSE;
 
                break;
            }
 
        case SCSI_SENSEQ_CLEANING_CARTRIDGE_INSTALLED:
            {
                needFurtherInterpret = FALSE;
 
                *Status = STATUS_CLEANER_CARTRIDGE_INSTALLED;
                *Retry = FALSE;
 
                LogContext->LogError = FALSE;
                LogContext->UniqueErrorValue = 256;
                LogContext->ErrorCode = IO_ERR_BAD_BLOCK;
                break;
            }
 
        default:
            {
                needFurtherInterpret = TRUE;
                break;
            }
        } // end case AdditionalSenseCodeQual
 
        break;
        } // end case SCSI_ADSENSE_NO_MEDIA_IN_DEVICE
 
    case SCSI_ADSENSE_NO_SEEK_COMPLETE:
        {
        switch (AdditionalSenseCodeQual)
        {
 
        case 0x00:
            {
                needFurtherInterpret = FALSE;
 
                *Status = STATUS_DEVICE_DATA_ERROR;
                *Retry = TRUE;
                *RetryIntervalInSeconds = 0;
                LogContext->LogError = TRUE;
                LogContext->UniqueErrorValue = 256;
                LogContext->ErrorCode = IO_ERR_BAD_BLOCK;
                break;
            }
 
        default:
            {
                needFurtherInterpret = TRUE;
                break;
            }
        }
 
        break;
        } // end case SCSI_ADSENSE_NO_SEEK_COMPLETE
 
    case SCSI_ADSENSE_LUN_COMMUNICATION:
        {
        switch (AdditionalSenseCodeQual)
        {
 
        case SCSI_SESNEQ_COMM_CRC_ERROR:
            {
                needFurtherInterpret = FALSE;
 
                *Status = STATUS_IO_DEVICE_ERROR;
                *Retry = TRUE;
                *RetryIntervalInSeconds = 1;
                LogContext->LogError = TRUE;
                LogContext->UniqueErrorValue = 257;
                LogContext->ErrorCode = IO_ERR_CONTROLLER_ERROR;
                break;
            }
 
        default:
            {
                needFurtherInterpret = TRUE;
                break;
            }
        }
 
        break;
        } // end case SCSI_ADSENSE_LUN_COMMUNICATION
 
    case SCSI_ADSENSE_ILLEGAL_BLOCK:
        {
            needFurtherInterpret = FALSE;
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretByAdditionalSenseCode: Illegal block address\n"));
            *Status = STATUS_NONEXISTENT_SECTOR;
            *Retry = FALSE;
            break;
        }
 
    case SCSI_ADSENSE_INVALID_LUN:
        {
            needFurtherInterpret = FALSE;
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretByAdditionalSenseCode: Invalid LUN\n"));
            *Status = STATUS_NO_SUCH_DEVICE;
            *Retry = FALSE;
            break;
        }
 
    case SCSI_ADSENSE_COPY_PROTECTION_FAILURE:
        {
            needFurtherInterpret = FALSE;
 
            *Retry = FALSE;
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretByAdditionalSenseCode: Key - Copy protection failure\n"));
 
            switch (AdditionalSenseCodeQual)
            {
            case SCSI_SENSEQ_AUTHENTICATION_FAILURE:
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretByAdditionalSenseCode: Authentication failure\n"));
                *Status = STATUS_CSS_AUTHENTICATION_FAILURE;
                break;
            case SCSI_SENSEQ_KEY_NOT_PRESENT:
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretByAdditionalSenseCode: Key not present\n"));
                *Status = STATUS_CSS_KEY_NOT_PRESENT;
                break;
            case SCSI_SENSEQ_KEY_NOT_ESTABLISHED:
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretByAdditionalSenseCode: Key not established\n"));
                *Status = STATUS_CSS_KEY_NOT_ESTABLISHED;
                break;
            case SCSI_SENSEQ_READ_OF_SCRAMBLED_SECTOR_WITHOUT_AUTHENTICATION:
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretByAdditionalSenseCode: Read of scrambled sector w/o authentication\n"));
                *Status = STATUS_CSS_SCRAMBLED_SECTOR;
                break;
            case SCSI_SENSEQ_MEDIA_CODE_MISMATCHED_TO_LOGICAL_UNIT:
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretByAdditionalSenseCode: Media region does not logical unit region\n"));
                *Status = STATUS_CSS_REGION_MISMATCH;
                break;
            case SCSI_SENSEQ_LOGICAL_UNIT_RESET_COUNT_ERROR:
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretByAdditionalSenseCode: Region set error -- region may be permanent\n"));
                *Status = STATUS_CSS_RESETS_EXHAUSTED;
                break;
 
            default:
                *Status = STATUS_COPY_PROTECTION_FAILURE;
                break;
            } // end switch of ASCQ for COPY_PROTECTION_FAILURE
 
            break;
        }
 
    case SCSI_ADSENSE_INVALID_CDB:
        {
            needFurtherInterpret = FALSE;
 
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretByAdditionalSenseCode: Key - Invalid CDB\n"));
 
            *Status = STATUS_INVALID_DEVICE_REQUEST;
            *Retry = FALSE;
 
            // Note: the retry interval is not typically used.
            // it is set here only because a ClassErrorHandler
            // cannot set the RetryIntervalInSeconds, and the error may
            // require a few commands to be sent to clear whatever
            // caused this condition (i.e. disk clears the write
            // cache, requiring at least two commands)
            //
            // hopefully, this shortcoming can be changed for blackcomb.
            *RetryIntervalInSeconds = 3;
 
            break;
        }
 
    case SCSI_ADSENSE_MEDIUM_CHANGED:
        {
            needFurtherInterpret = FALSE;
            *RetryIntervalInSeconds = 0;
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_MCN,
                        "SenseInfoInterpretByAdditionalSenseCode: Media changed\n"));
 
            DeviceSetMediaChangeStateEx(DeviceExtension, MediaPresent, NULL);
 
            // special process for Media Change
            if (IsVolumeMounted(DeviceExtension->DeviceObject))
            {
                // Set bit to indicate that media may have changed and volume needs verification.
                SET_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME);
 
                *Status = STATUS_VERIFY_REQUIRED;
                *Retry = FALSE;
            }
            else
            {
                *Status = STATUS_IO_DEVICE_ERROR;
                *Retry = TRUE;
            }
            break;
        }
 
    case SCSI_ADSENSE_OPERATOR_REQUEST:
        {
            switch (AdditionalSenseCodeQual)
            {
            case SCSI_SENSEQ_MEDIUM_REMOVAL:
                {
                    needFurtherInterpret = FALSE;
                    *RetryIntervalInSeconds = 0;
 
                    InterlockedIncrement((PLONG)&DeviceExtension->MediaChangeCount);
 
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretByAdditionalSenseCode: Ejection request received!\n"));
                    //Send eject notification.
                    DeviceSendNotification(DeviceExtension,
                                           &GUID_IO_MEDIA_EJECT_REQUEST,
                                           0,
                                           NULL);
                    // special process for Media Change
                    if (IsVolumeMounted(DeviceExtension->DeviceObject))
                    {
                        // Set bit to indicate that media may have changed and volume needs verification.
                        SET_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME);
 
                        *Status = STATUS_VERIFY_REQUIRED;
                        *Retry = FALSE;
                    }
                    else
                    {
                        *Status = STATUS_IO_DEVICE_ERROR;
                        *Retry = TRUE;
                    }
                    break;
                }
            default:
                {
                    needFurtherInterpret = TRUE;
                    break;
                }
            }
            break;
        }
 
    case SCSI_ADSENSE_OPERATING_CONDITIONS_CHANGED:
        {
            needFurtherInterpret = FALSE;
            *RetryIntervalInSeconds = 5;
 
            InterlockedIncrement((PLONG)&DeviceExtension->MediaChangeCount);
 
            // Device information has changed, we need to rescan the
            // bus for changed information such as the capacity.
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretByAdditionalSenseCode: Device information changed. Invalidate the bus\n"));
 
            IoInvalidateDeviceRelations(DeviceExtension->LowerPdo, BusRelations);
 
            // special process for Media Change
            if (IsVolumeMounted(DeviceExtension->DeviceObject))
            {
                // Set bit to indicate that media may have changed and volume needs verification.
                SET_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME);
 
                *Status = STATUS_VERIFY_REQUIRED;
                *Retry = FALSE;
            }
            else
            {
                *Status = STATUS_IO_DEVICE_ERROR;
                *Retry = TRUE;
            }
            break;
        } //end Case SCSI_ADSENSE_OPERATING_CONDITIONS_CHANGED
 
 
    case SCSI_ADSENSE_REC_DATA_NOECC:
    case SCSI_ADSENSE_REC_DATA_ECC:
        {
            needFurtherInterpret = FALSE;
 
            *Status = STATUS_SUCCESS;
            *Retry = FALSE;
            LogContext->LogError = TRUE;
            LogContext->UniqueErrorValue = 258;
            LogContext->ErrorCode = IO_RECOVERED_VIA_ECC;
 
            if (senseBuffer->IncorrectLength)
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretByAdditionalSenseCode: Incorrect length detected.\n"));
                *Status = STATUS_INVALID_BLOCK_LENGTH ;
            }
            break;
        }
 
    case SCSI_ADSENSE_FAILURE_PREDICTION_THRESHOLD_EXCEEDED:
        {
            UCHAR wmiEventData[sizeof(ULONG)+sizeof(UCHAR)] = {0};
 
            *((PULONG)wmiEventData) = sizeof(UCHAR);
            wmiEventData[sizeof(ULONG)] = AdditionalSenseCodeQual;
 
            needFurtherInterpret = FALSE;
 
            // Don't log another eventlog if we have already logged once
            // NOTE: this should have been interlocked, but the structure
            //       was publicly defined to use a BOOLEAN (char).  Since
            //       media only reports these errors once per X minutes,
            //       the potential race condition is nearly non-existant.
            //       the worst case is duplicate log entries, so ignore.
 
            *Status = STATUS_SUCCESS;
            *Retry = FALSE;
            LogContext->UniqueErrorValue = 258;
            LogContext->LogError = TRUE;
            LogContext->ErrorCode = IO_WRN_FAILURE_PREDICTED;
 
            if (senseBuffer->IncorrectLength)
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretByAdditionalSenseCode: Incorrect length detected.\n"));
                *Status = STATUS_INVALID_BLOCK_LENGTH ;
            }
            break;
        }
 
    case 0x57:
        {
            // UNABLE_TO_RECOVER_TABLE_OF_CONTENTS
            // the Matshita CR-585 returns this for all read commands
            // on blank CD-R and CD-RW media, and we need to handle
            // this for READ_CD detection ability.
            switch (AdditionalSenseCodeQual)
            {
            case 0x00:
                {
                    needFurtherInterpret = FALSE;
 
                    *Status = STATUS_UNRECOGNIZED_MEDIA;
                    *Retry = FALSE;
                    break;
                }
            default:
                {
                    needFurtherInterpret = TRUE;
                    break;
                }
            }
            break;
        }   //end case Matshita specific error 0x57
 
    default:
        {
            needFurtherInterpret = TRUE;
            break;
        }
    }
 
    return needFurtherInterpret;
}

Referenced by SenseInfoInterpret().

SenseInfoInterpretBySenseKey()

VOID SenseInfoInterpretBySenseKey	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSENSE_DATA	SenseData,
		_In_ UCHAR	SenseKey,
		_Inout_ NTSTATUS *	Status,
		_Inout_ BOOLEAN *	Retry,
		_Out_ _Deref_out_range_(0, 100) ULONG *	RetryIntervalInSeconds,
		_Inout_ PERROR_LOG_CONTEXT	LogContext
	)

Definition at line 1080 of file sense.c.

{
    // set default values for retry fields.
    *Status = STATUS_IO_DEVICE_ERROR;
    *Retry = TRUE;
    *RetryIntervalInSeconds = 0;
 
    switch (SenseKey)
    {
    case SCSI_SENSE_NOT_READY:
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Key - Not Ready (bad block)\n"));
 
            *Status = STATUS_DEVICE_NOT_READY;
            *Retry = TRUE;
 
            // for unprocessed "not ready" codes, retry the command immediately.
            *RetryIntervalInSeconds = 0;
            break;
        }
 
    case SCSI_SENSE_DATA_PROTECT:
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Key - Media write protected\n"));
            *Status = STATUS_MEDIA_WRITE_PROTECTED;
            *Retry = FALSE;
            break;
        }
 
    case SCSI_SENSE_MEDIUM_ERROR:
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Key - Medium Error (bad block)\n"));
 
            *Status = STATUS_DEVICE_DATA_ERROR;
            *Retry = FALSE;
            LogContext->LogError = TRUE;
            LogContext->UniqueErrorValue = 256;
            LogContext->ErrorCode = IO_ERR_BAD_BLOCK;
 
            break;
        } // end SCSI_SENSE_MEDIUM_ERROR
 
    case SCSI_SENSE_HARDWARE_ERROR:
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Key - Hardware error\n"));
 
            *Status = STATUS_IO_DEVICE_ERROR;
            *Retry = TRUE;
            LogContext->LogError = TRUE;
            LogContext->UniqueErrorValue = 257;
            LogContext->ErrorCode = IO_ERR_CONTROLLER_ERROR;
 
            break;
        } // end SCSI_SENSE_HARDWARE_ERROR
 
    case SCSI_SENSE_ILLEGAL_REQUEST:
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Key - Illegal SCSI request\n"));
            *Status = STATUS_INVALID_DEVICE_REQUEST;
            *Retry = FALSE;
 
            break;
        } // end SCSI_SENSE_ILLEGAL_REQUEST
 
    case SCSI_SENSE_UNIT_ATTENTION:
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Key - Unit Attention\n"));
 
            // A media change may have occured so increment the change
            // count for the physical device
            InterlockedIncrement((PLONG)&DeviceExtension->MediaChangeCount);
 
            if (IsVolumeMounted(DeviceExtension->DeviceObject))
            {
                // Set bit to indicate that media may have changed
                // and volume needs verification.
                SET_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME);
 
                *Status = STATUS_VERIFY_REQUIRED;
                *Retry = FALSE;
            }
            else
            {
                *Status = STATUS_IO_DEVICE_ERROR;
                *Retry = TRUE;
            }
 
            break;
 
        } // end SCSI_SENSE_UNIT_ATTENTION
 
    case SCSI_SENSE_ABORTED_COMMAND:
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Command aborted\n"));
            *Status = STATUS_IO_DEVICE_ERROR;
            *Retry = TRUE;
            *RetryIntervalInSeconds = 1;
            break;
        } // end SCSI_SENSE_ABORTED_COMMAND
 
    case SCSI_SENSE_BLANK_CHECK:
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Media blank check\n"));
            *Retry = FALSE;
            *Status = STATUS_NO_DATA_DETECTED;
            break;
        } // end SCSI_SENSE_BLANK_CHECK
 
    case SCSI_SENSE_RECOVERED_ERROR:
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Recovered error\n"));
            *Status = STATUS_SUCCESS;
            *Retry = FALSE;
            LogContext->LogError = TRUE;
            LogContext->UniqueErrorValue = 258;
            LogContext->ErrorCode = IO_ERR_CONTROLLER_ERROR;
 
            if (SenseData->IncorrectLength)
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretBySenseKey: Incorrect length detected.\n"));
                *Status = STATUS_INVALID_BLOCK_LENGTH ;
            }
 
            break;
        } // end SCSI_SENSE_RECOVERED_ERROR
 
    case SCSI_SENSE_NO_SENSE:
        {
            // Check other indicators.
            if (SenseData->IncorrectLength)
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretBySenseKey: Incorrect length detected.\n"));
                *Status = STATUS_INVALID_BLOCK_LENGTH ;
                *Retry   = FALSE;
            }
            else
            {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                            "SenseInfoInterpretBySenseKey: No specific sense key\n"));
                *Status = STATUS_IO_DEVICE_ERROR;
                *Retry = TRUE;
            }
 
            break;
        } // end SCSI_SENSE_NO_SENSE
 
    default:
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretBySenseKey: Unrecognized sense code\n"));
            *Status = STATUS_IO_DEVICE_ERROR;
            *Retry = TRUE;
            *RetryIntervalInSeconds = 0;
 
            break;
        }
 
    } // end switch (SenseKey)
 
    return;
}

Referenced by SenseInfoInterpret().

SenseInfoInterpretBySrbStatus()

VOID SenseInfoInterpretBySrbStatus	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ ULONG	RetriedCount,
		_Inout_ NTSTATUS *	Status,
		_Inout_ BOOLEAN *	Retry,
		_Out_ _Deref_out_range_(0, 100) ULONG *	RetryIntervalInSeconds,
		_Inout_ PERROR_LOG_CONTEXT	LogContext
	)

Definition at line 1262 of file sense.c.

{
    BOOLEAN incrementErrorCount = FALSE;
 
    // set default values for retry fields.
    *Status = STATUS_IO_DEVICE_ERROR;
    *Retry = TRUE;
    *RetryIntervalInSeconds = 0;
 
    switch (SRB_STATUS(Srb->SrbStatus))
    {
    case SRB_STATUS_INVALID_LUN:
    case SRB_STATUS_INVALID_TARGET_ID:
    case SRB_STATUS_NO_DEVICE:
    case SRB_STATUS_NO_HBA:
    case SRB_STATUS_INVALID_PATH_ID:
    {
        *Status = STATUS_NO_SUCH_DEVICE;
        *Retry = FALSE;
        break;
    }
 
    case SRB_STATUS_COMMAND_TIMEOUT:
    case SRB_STATUS_TIMEOUT:
    {
        // Update the error count for the device.
        *Status = STATUS_IO_TIMEOUT;
        *Retry = TRUE;
        *RetryIntervalInSeconds = 0;
        incrementErrorCount = TRUE;
        break;
    }
 
    case SRB_STATUS_ABORTED:
    {
        // Update the error count for the device.
        *Status = STATUS_IO_TIMEOUT;
        *Retry = TRUE;
        *RetryIntervalInSeconds = 1;
        incrementErrorCount = TRUE;
        break;
    }
 
    case SRB_STATUS_SELECTION_TIMEOUT:
    {
        *Status = STATUS_DEVICE_NOT_CONNECTED;
        *Retry = FALSE;
        *RetryIntervalInSeconds = 2;
        LogContext->LogError = TRUE;
        LogContext->ErrorCode = IO_ERR_NOT_READY;
        LogContext->UniqueErrorValue = 260;
        break;
    }
 
    case SRB_STATUS_DATA_OVERRUN:
    {
        *Status = STATUS_DATA_OVERRUN;
        *Retry = FALSE;
        break;
    }
 
    case SRB_STATUS_PHASE_SEQUENCE_FAILURE:
    {
        // Update the error count for the device.
        incrementErrorCount = TRUE;
        *Status = STATUS_IO_DEVICE_ERROR;
 
        // If there was phase sequence error then limit the number of retries.
        *Retry = (RetriedCount <= 1);
 
        break;
    }
 
    case SRB_STATUS_REQUEST_FLUSHED:
    {
        // If the status needs verification bit is set.  Then set
        // the status to need verification and no retry; otherwise,
        // just retry the request.
        if (TEST_FLAG(DeviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME))
        {
            *Status = STATUS_VERIFY_REQUIRED;
            *Retry = FALSE;
        }
        else
        {
            *Status = STATUS_IO_DEVICE_ERROR;
            *Retry = TRUE;
        }
 
        break;
    }
 
    case SRB_STATUS_INVALID_REQUEST:
    {
        *Status = STATUS_INVALID_DEVICE_REQUEST;
        *Retry = FALSE;
        break;
    }
 
    case SRB_STATUS_UNEXPECTED_BUS_FREE:
    case SRB_STATUS_PARITY_ERROR:
        // Update the error count for the device and fall through to below
        incrementErrorCount = TRUE;
 
    case SRB_STATUS_BUS_RESET:
    {
        *Status = STATUS_IO_DEVICE_ERROR;
        *Retry = TRUE;
        break;
    }
 
    case SRB_STATUS_ERROR:
    {
        *Status = STATUS_IO_DEVICE_ERROR;
        *Retry = TRUE;
 
        if (Srb->ScsiStatus == 0)
        {
            // This is some strange return code.  Update the error
            // count for the device.
            incrementErrorCount = TRUE;
        }
 
        if (Srb->ScsiStatus == SCSISTAT_BUSY)
        {
            *Status = STATUS_DEVICE_NOT_READY;
        }
 
        break;
    }
 
    default:
    {
        *Status = STATUS_IO_DEVICE_ERROR;
        *Retry = TRUE;
        LogContext->LogError = TRUE;
        LogContext->ErrorCode = IO_ERR_CONTROLLER_ERROR;
        LogContext->UniqueErrorValue = 259;
        LogContext->ErrorUnhandled = TRUE;
        break;
    }
 
    } //end of (SRB_STATUS(Srb->SrbStatus))
 
    if (incrementErrorCount)
    {
        // if any error count occurred, delay the retry of this io by
        // at least one second, if caller supports it.
        if (*RetryIntervalInSeconds == 0)
        {
            *RetryIntervalInSeconds = 1;
        }
 
        DevicePerfIncrementErrorCount(DeviceExtension);
    }
 
    return;
}

Referenced by SenseInfoInterpret().

SenseInfoInterpretForZPODD()

BOOLEAN SenseInfoInterpretForZPODD	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_Out_ NTSTATUS *	Status,
		_Out_ _Out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *	RetryIntervalIn100ns
	)

Definition at line 2341 of file sense.c.

{
    BOOLEAN                 retry = FALSE;
    PSENSE_DATA             senseBuffer = Srb->SenseInfoBuffer;
    ULONG                   readSector = 0;
    PZERO_POWER_ODD_INFO    zpoddInfo = DeviceExtension->ZeroPowerODDInfo;
 
    *Status = STATUS_IO_DEVICE_ERROR;
    *RetryIntervalIn100ns = 0;
 
    if (zpoddInfo->RetryFirstCommand != FALSE)
    {
        // The first command to the logical unit after power resumed will be terminated
        // with CHECK CONDITION Status, 6/29/00 POWER ON, RESET, OR BUS DEVICE RESET OCCURRED
 
        // We have observed some devices return a different sense code, and thus as long as
        // the first command after power resume fails, we just retry one more time.
        zpoddInfo->RetryFirstCommand = FALSE;
 
        retry = TRUE;
    }
    else if ((Srb->SrbStatus & SRB_STATUS_AUTOSENSE_VALID) &&
             (Srb->SenseInfoBufferLength >= RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseLength)))
    {
        UCHAR   senseKey = (UCHAR)(senseBuffer->SenseKey & 0x0f);
        UCHAR   additionalSenseCode = 0;
        UCHAR   additionalSenseCodeQual = 0;
 
        // Zero the additional sense code and additional sense code qualifier
        // if they were not returned by the device.
        readSector = senseBuffer->AdditionalSenseLength + offsetof(SENSE_DATA, AdditionalSenseLength);
        if (readSector > Srb->SenseInfoBufferLength)
        {
            readSector = Srb->SenseInfoBufferLength;
        }
 
        additionalSenseCode = (readSector >= RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseCode)) ?
                               senseBuffer->AdditionalSenseCode : 0;
        additionalSenseCodeQual = (readSector >= RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseCodeQualifier)) ?
                                   senseBuffer->AdditionalSenseCodeQualifier : 0;
 
        // If sense code is 2/4/1, device is becoming ready from ZPODD mode. According to Mt Fuji, device
        // could take up to 800msec to be fully operational.
        if ((senseKey == SCSI_SENSE_NOT_READY) &&
            (additionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY) &&
            (additionalSenseCodeQual == SCSI_SENSEQ_BECOMING_READY))
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                        "SenseInfoInterpretForZPODD: In process of becoming ready\n"));
 
            zpoddInfo->BecomingReadyRetryCount--;
 
            if (zpoddInfo->BecomingReadyRetryCount > 0)
            {
                DEVICE_EVENT_BECOMING_READY notReady = {0};
 
                retry = TRUE;
                *Status = STATUS_DEVICE_NOT_READY;
                *RetryIntervalIn100ns = BECOMING_READY_RETRY_INTERNVAL_IN_100NS;
 
                notReady.Version = 1;
                notReady.Reason = 1;
                notReady.Estimated100msToReady = (ULONG) *RetryIntervalIn100ns / (1000 * 1000);
                DeviceSendNotification(DeviceExtension,
                                       &GUID_IO_DEVICE_BECOMING_READY,
                                       sizeof(DEVICE_EVENT_BECOMING_READY),
                                       &notReady);
            }
        }
    }
 
    // now, all decisions are made. display trace information.
    if (retry)
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                   "Command shall be retried in %2I64d.%03I64d seconds\n",
                   (*RetryIntervalIn100ns / UNIT_100NS_PER_SECOND),
                   (*RetryIntervalIn100ns / 10000) % 1000
                   ));
    }
    else
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                   "Will not retry; Sense/ASC/ASCQ of %02x/%02x/%02x\n",
                   senseBuffer->SenseKey,
                   senseBuffer->AdditionalSenseCode,
                   senseBuffer->AdditionalSenseCodeQualifier
                   ));
    }
 
    return retry;
 
} // end SenseInfoInterpret()

Referenced by RequestSenseInfoInterpret().

SenseInfoInterpretRefineByIoControl()

VOID SenseInfoInterpretRefineByIoControl	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ ULONG	IoControlCode,
		_In_ BOOLEAN	OverrideVerifyVolume,
		_Inout_ BOOLEAN *	Retry,
		_Inout_ NTSTATUS *	Status
	)

Definition at line 1953 of file sense.c.

{
    PAGED_CODE();
 
    if ((IoControlCode == IOCTL_CDROM_GET_LAST_SESSION) ||
        (IoControlCode == IOCTL_CDROM_READ_TOC)         ||
        (IoControlCode == IOCTL_CDROM_READ_TOC_EX)      ||
        (IoControlCode == IOCTL_CDROM_GET_CONFIGURATION)||
        (IoControlCode == IOCTL_CDROM_GET_VOLUME))
    {
        if (*Status == STATUS_DATA_OVERRUN)
        {
            *Status = STATUS_SUCCESS;
            *Retry = FALSE;
        }
    }
 
    if (IoControlCode == IOCTL_CDROM_READ_Q_CHANNEL)
    {
        PLAY_ACTIVE(DeviceExtension) = FALSE;
    }
 
    // If the status is verified required and the this request
    // should bypass verify required then retry the request.
    if (OverrideVerifyVolume && (*Status == STATUS_VERIFY_REQUIRED))
    {
        // note: status gets overwritten here
        *Status = STATUS_IO_DEVICE_ERROR;
        *Retry = TRUE;
 
        if ((IoControlCode == IOCTL_CDROM_CHECK_VERIFY) ||
            (IoControlCode == IOCTL_STORAGE_CHECK_VERIFY) ||
            (IoControlCode == IOCTL_STORAGE_CHECK_VERIFY2) ||
            (IoControlCode == IOCTL_DISK_CHECK_VERIFY)
           )
        {
            // Update the geometry information, as the media could have changed.
            (VOID) MediaReadCapacity(DeviceExtension->Device);
        } // end of ioctls to update capacity
    }
 
    if (!NT_SUCCESS(*Status) && (IoControlCode == IOCTL_CDROM_SET_SPEED))
    {
        // If set speed request fails then we should disable the restore speed option.
        // Otherwise we will try to restore to default speed on next media change,
        // if requested by the caller.
        DeviceExtension->DeviceAdditionalData.RestoreDefaults = FALSE;
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "Disable restore default\n"));
    }
 
    return;
}

Referenced by SenseInfoInterpret().

SenseInfoInterpretRefineByScsiCommand()

VOID SenseInfoInterpretRefineByScsiCommand	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ ULONG	RetriedCount,
		_In_ LONGLONG	Total100nsSinceFirstSend,
		_In_ BOOLEAN	OverrideVerifyVolume,
		_Inout_ BOOLEAN *	Retry,
		_Inout_ NTSTATUS *	Status,
		_Inout_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *	RetryIntervalIn100ns
	)

Definition at line 1663 of file sense.c.

{
    UCHAR const opCode = Srb->Cdb[0];
    CDB const*  cdb = (CDB const*)(Srb->Cdb);
    PSENSE_DATA senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
 
    if (opCode == SCSIOP_MEDIUM_REMOVAL)
    {
        if (( cdb->AsByte[1]         == 0) &&
            ( cdb->AsByte[2]         == 0) &&
            ( cdb->AsByte[3]         == 0) &&
            ((cdb->AsByte[4] & 0xFC) == 0)
            )
        {
            // byte[4] == 0x3 or byte[4] == 0x1  ==  UNLOCK OF MEDIA
            if ((cdb->AsByte[4] & 0x01) == 0)
            {
                if (RetriedCount < TOTAL_COUNT_RETRY_DEFAULT)
                {
                    // keep retrying unlock operation for several times
                    *Retry = TRUE;
                }
            }
            else // LOCK REQUEST
            {
                // do not retry LOCK requests more than once (per CLASSPNP code)
                if (RetriedCount > TOTAL_COUNT_RETRY_LOCK_MEDIA)
                {
                    *Retry = FALSE;
                }
            }
        }
 
        // want a minimum time to retry of 2 seconds
        if ((*Status == STATUS_DEVICE_NOT_READY) &&
            (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY))
        {
            *RetryIntervalIn100ns = max(*RetryIntervalIn100ns, SECONDS_TO_100NS_UNITS(2));
        }
        else if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT)
        {
            *RetryIntervalIn100ns = max(*RetryIntervalIn100ns, SECONDS_TO_100NS_UNITS(2));
        }
    }
    else if ((opCode == SCSIOP_MODE_SENSE) || (opCode == SCSIOP_MODE_SENSE10))
    {
        // want a minimum time to retry of 2 seconds
        if ((*Status == STATUS_DEVICE_NOT_READY) &&
            (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY))
        {
            *RetryIntervalIn100ns = max(*RetryIntervalIn100ns, SECONDS_TO_100NS_UNITS(2));
        }
        else if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT)
        {
            *RetryIntervalIn100ns = max(*RetryIntervalIn100ns, SECONDS_TO_100NS_UNITS(2));
        }
 
        // Want to ignore a STATUS_VERIFY_REQUIRED error because it either
        // doesn't make sense or is required to satisfy the VERIFY.
        if (*Status == STATUS_VERIFY_REQUIRED)
        {
            *Retry = TRUE;
        }
        else if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_DATA_OVERRUN)
        {
            /*
             *  This is a HACK.
             *  Atapi returns SRB_STATUS_DATA_OVERRUN when it really means
             *  underrun (i.e. success, and the buffer is longer than needed).
             *  So treat this as a success.
             *  When the caller of this function sees that the status was changed to success,
             *  it will add the transferred length to the original irp.
             */
            *Status = STATUS_SUCCESS;
            *Retry = FALSE;
        }
 
        // limit the count of retries
        if (RetriedCount > TOTAL_COUNT_RETRY_MODESENSE)
        {
            *Retry = FALSE;
        }
    }
    else if ((opCode == SCSIOP_READ_CAPACITY) || (opCode == SCSIOP_READ_CAPACITY16))
    {
        // Want to ignore a STATUS_VERIFY_REQUIRED error because it either
        // doesn't make sense or is required to satisfy the VERIFY.
        if (*Status == STATUS_VERIFY_REQUIRED)
        {
            *Retry = TRUE;
        }
 
        if (RetriedCount > TOTAL_COUNT_RETRY_READ_CAPACITY)
        {
            *Retry = FALSE;
        }
    }
    else if ((opCode == SCSIOP_RESERVE_UNIT) || (opCode == SCSIOP_RELEASE_UNIT))
    {
        // The RESERVE(6) / RELEASE(6) commands are optional.
        // So if they aren't supported, try the 10-byte equivalents
        if (*Status == STATUS_INVALID_DEVICE_REQUEST)
        {
            PCDB tempCdb = (PCDB)Srb->Cdb;
 
            Srb->CdbLength = 10;
            tempCdb->CDB10.OperationCode = (tempCdb->CDB6GENERIC.OperationCode == SCSIOP_RESERVE_UNIT)
                                            ? SCSIOP_RESERVE_UNIT10
                                            : SCSIOP_RELEASE_UNIT10;
 
            SET_FLAG(DeviceExtension->PrivateFdoData->HackFlags, FDO_HACK_NO_RESERVE6);
            *Retry = TRUE;
        }
    }
    else if (IS_SCSIOP_READWRITE(opCode))
    {
        // Retry if still verifying a (possibly) reloaded disk/cdrom.
        if (OverrideVerifyVolume && (*Status == STATUS_VERIFY_REQUIRED))
        {
            *Status = STATUS_IO_DEVICE_ERROR;
            *Retry = TRUE;
        }
 
        // Special case for streaming READ/WRITE commands
        if (((opCode == SCSIOP_READ12) && (cdb->READ12.Streaming == 1)) ||
            ((opCode == SCSIOP_WRITE12) && (cdb->WRITE12.Streaming == 1)))
        {
            // We've got a failure while performing a streaming operation and now need to guess if
            // it's likely to be a permanent error because the drive does not support streaming at all
            // (in which case we're going to fall back to normal reads/writes), or a transient error
            // (in which case we quickly fail the request but contrinue to use streaming).
            //
            // We analyze the sense information to make that decision. Bus resets and device timeouts
            // are treated as permanent errors, because some non-compliant devices may even hang when
            // they get a command that they do not expect.
 
            BOOLEAN     disableStreaming = FALSE;
 
            if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_TIMEOUT ||
                SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_COMMAND_TIMEOUT ||
                SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SELECTION_TIMEOUT ||
                SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_BUS_RESET)
            {
                disableStreaming = TRUE;
            }
            else if ((senseBuffer->SenseKey &0xf) == SCSI_SENSE_UNIT_ATTENTION)
            {
                if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_BUS_RESET ||
                    senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_INSUFFICIENT_TIME_FOR_OPERATION)
                {
                    disableStreaming = TRUE;
                }
            }
            else if ((senseBuffer->SenseKey &0xf) == SCSI_SENSE_ILLEGAL_REQUEST)
            {
                // LBA Out of Range is an exception, as it's more likely to be caused by
                // upper layers attempting to read/write a wrong LBA.
                if (senseBuffer->AdditionalSenseCode != SCSI_ADSENSE_ILLEGAL_BLOCK)
                {
                    disableStreaming = TRUE;
                }
            }
 
            if (disableStreaming)
            {
                // if the failure looks permanent, we disable streaming for all future reads/writes
                // and retry the command immediately
                SET_FLAG(DeviceExtension->PrivateFdoData->HackFlags, FDO_HACK_NO_STREAMING);
                *Retry = TRUE;
                *RetryIntervalIn100ns = 0;
            }
            else
            {
                // if the failure looks transient, we simply fail the current request without retries
                // to minimize the time of processing
                *Retry = FALSE;
            }
        }
 
        // Special-case handling of READ/WRITE commands.  These commands now have a 120 second timeout,
        // but the preferred behavior (and that taken by many drives) is to immediately report 2/4/x
        // on OPC and similar commands.  Thus, retries must occur for at least 160 seconds
        // (120 seconds + four 10 second retries) as a conservative guess.
        // Note: 160s retry time is also a result of discussion with OEMs for case of 2/4/7 and 2/4/8.
        if (*Retry)
        {
            if ((Total100nsSinceFirstSend < 0) ||
                (((senseBuffer->SenseKey &0xf) == SCSI_SENSE_HARDWARE_ERROR) && (senseBuffer->AdditionalSenseCode == 0x09)))
            {
                // time information is not valid. use default retry count.
                // or if it's SERVO FAILURE, use retry count instead of 160s retry.
                *Retry = (RetriedCount <= TOTAL_COUNT_RETRY_DEFAULT);
            }
            else if (Total100nsSinceFirstSend > SECONDS_TO_100NS_UNITS(TOTAL_SECONDS_RETRY_TIME_WRITE))
            {
                *Retry = FALSE;
            }
 
            // How long should we request a delay for during writing?  This depends entirely on
            // the current write speed of the drive.  If we request retries too quickly,
            // we can overload the processor on the drive (resulting in garbage being written),
            // but too slowly results in lesser performance.
            //
            *RetryIntervalIn100ns = DeviceExtension->DeviceAdditionalData.ReadWriteRetryDelay100nsUnits;
 
        } // end retry for 160 seconds modification
    }
    else if (opCode == SCSIOP_GET_PERFORMANCE)
    {
        if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_DATA_OVERRUN)
        {
            //  This is a HACK.
            //  Atapi returns SRB_STATUS_DATA_OVERRUN when it really means
            //  underrun (i.e. success, and the buffer is longer than needed).
            //  So treat this as a success.
            //  When the caller of this function sees that the status was changed to success,
            //  it will add the transferred length to the original irp.
            *Status = STATUS_SUCCESS;
            *Retry = FALSE;
        }
 
        if ((Srb->SenseInfoBufferLength < RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA,AdditionalSenseCodeQualifier)) ||
            !TEST_FLAG(Srb->SrbStatus, SRB_STATUS_AUTOSENSE_VALID))
        {
            // If get configuration command is failing and if the request type is TYPE ONE
            // then most likely the device does not support this request type. Set the
            // flag so that the TYPE ONE requests will be tried as TYPE ALL requets.
            if ((SRB_STATUS(Srb->SrbStatus) != SRB_STATUS_SUCCESS) &&
                (SRB_STATUS(Srb->SrbStatus) != SRB_STATUS_DATA_OVERRUN) &&
                (((PCDB)Srb->Cdb)->GET_CONFIGURATION.RequestType == SCSI_GET_CONFIGURATION_REQUEST_TYPE_ONE))
            {
 
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                           "TYPE ONE GetConfiguration failed. Set hack flag and retry.\n"));
                SET_FLAG(DeviceExtension->DeviceAdditionalData.HackFlags, CDROM_HACK_BAD_TYPE_ONE_GET_CONFIG);
                *Retry = TRUE;
            }
        }
 
        // limit retries to GET_PERFORMANCE commands to default retry count
        if (RetriedCount > TOTAL_COUNT_RETRY_DEFAULT)
        {
            *Retry = FALSE;
        }
    }
    else // default handler -- checks for retry count only.
    {
        if (RetriedCount > TOTAL_COUNT_RETRY_DEFAULT)
        {
            *Retry = FALSE;
        }
    }
 
    return;
}

Referenced by SenseInfoInterpret().

SenseInfoLogError()

VOID SenseInfoLogError	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb,
		_In_ UCHAR	MajorFunctionCode,
		_In_ ULONG	IoControlCode,
		_In_ ULONG	RetriedCount,
		_In_ NTSTATUS *	Status,
		_In_ BOOLEAN *	Retry,
		_Inout_ PERROR_LOG_CONTEXT	LogContext
	)

Definition at line 1430 of file sense.c.

{
    //      Always log the error in our internal log.
    //      If logError is set, also log the error in the system log.
    PSENSE_DATA          senseBuffer = (PSENSE_DATA)Srb->SenseInfoBuffer;
    ULONG                totalSize = 0;
    ULONG                senseBufferSize = 0;
    IO_ERROR_LOG_PACKET  staticErrLogEntry = {0};
    CDROM_ERROR_LOG_DATA staticErrLogData = {0};
 
    // Calculate the total size of the error log entry.
    // add to totalSize in the order that they are used.
    // the advantage to calculating all the sizes here is
    // that we don't have to do a bunch of extraneous checks
    // later on in this code path.
    totalSize = sizeof(IO_ERROR_LOG_PACKET)     // required
              + sizeof(CDROM_ERROR_LOG_DATA);   // struct for ease
 
    // also save any available extra sense data, up to the maximum errlog
    // packet size .  WMI should be used for real-time analysis.
    // the event log should only be used for post-mortem debugging.
    if (TEST_FLAG(Srb->SrbStatus, SRB_STATUS_AUTOSENSE_VALID))
    {
        ULONG       validSenseBytes;
        BOOLEAN     validSense;
 
        // make sure we can at least access the AdditionalSenseLength field
        validSense = RTL_CONTAINS_FIELD(senseBuffer,
                                        Srb->SenseInfoBufferLength,
                                        AdditionalSenseLength);
        if (validSense)
        {
            // if extra info exists, copy the maximum amount of available
            // sense data that is safe into the the errlog.
            validSenseBytes = senseBuffer->AdditionalSenseLength
                                + offsetof(SENSE_DATA, AdditionalSenseLength);
 
            // this is invalid because it causes overflow!
            // whoever sent this type of request would cause
            // a system crash.
            NT_ASSERT(validSenseBytes < MAX_ADDITIONAL_SENSE_BYTES);
 
            // set to save the most sense buffer possible
            senseBufferSize = max(validSenseBytes, sizeof(SENSE_DATA));
            senseBufferSize = min(senseBufferSize, Srb->SenseInfoBufferLength);
        }
        else
        {
            // it's smaller than required to read the total number of
            // valid bytes, so just use the SenseInfoBufferLength field.
            senseBufferSize = Srb->SenseInfoBufferLength;
        }
 
        //  Bump totalSize by the number of extra senseBuffer bytes
        //  (beyond the default sense buffer within CDROM_ERROR_LOG_DATA).
        //  Make sure to never allocate more than ERROR_LOG_MAXIMUM_SIZE.
        if (senseBufferSize > sizeof(SENSE_DATA))
        {
            totalSize += senseBufferSize-sizeof(SENSE_DATA);
            if (totalSize > ERROR_LOG_MAXIMUM_SIZE)
            {
                senseBufferSize -= totalSize-ERROR_LOG_MAXIMUM_SIZE;
                totalSize = ERROR_LOG_MAXIMUM_SIZE;
            }
        }
    }
 
    // If we've used up all of our retry attempts, set the final status to
    // reflect the appropriate result.
    //
    // ISSUE: the test below should also check RetriedCount to determine if we will actually retry,
    //            but there is no easy test because we'd have to consider the original retry count
    //            for the op; besides, InterpretTransferPacketError sometimes ignores the retry
    //            decision returned by this function.  So just ErrorRetried to be true in the majority case.
    //
    if (*Retry)
    {
        staticErrLogEntry.FinalStatus = STATUS_SUCCESS;
        staticErrLogData.ErrorRetried = TRUE;
    }
    else
    {
        staticErrLogEntry.FinalStatus = *Status;
    }
 
    // Don't log generic IO_WARNING_PAGING_FAILURE message if either the
    // I/O is retried, or it completed successfully.
    if ((LogContext->ErrorCode == IO_WARNING_PAGING_FAILURE) &&
        (*Retry || NT_SUCCESS(*Status)) )
    {
        LogContext->LogError = FALSE;
    }
 
    if (TEST_FLAG(Srb->SrbFlags, SRB_CLASS_FLAGS_PAGING))
    {
        staticErrLogData.ErrorPaging = TRUE;
    }
 
    staticErrLogData.ErrorUnhandled = LogContext->ErrorUnhandled;
 
    // Calculate the device offset if there is a geometry.
    staticErrLogEntry.DeviceOffset.QuadPart = (LONGLONG)LogContext->BadSector;
    staticErrLogEntry.DeviceOffset.QuadPart *= (LONGLONG)DeviceExtension->DiskGeometry.BytesPerSector;
 
    if (LogContext->ErrorCode == -1)
    {
        staticErrLogEntry.ErrorCode = STATUS_IO_DEVICE_ERROR;
    }
    else
    {
        staticErrLogEntry.ErrorCode = LogContext->ErrorCode;
    }
 
    //  The dump data follows the IO_ERROR_LOG_PACKET
    staticErrLogEntry.DumpDataSize = (USHORT)totalSize - sizeof(IO_ERROR_LOG_PACKET);
 
    staticErrLogEntry.SequenceNumber = 0;
    staticErrLogEntry.MajorFunctionCode = MajorFunctionCode;
    staticErrLogEntry.IoControlCode = IoControlCode;
    staticErrLogEntry.RetryCount = (UCHAR)RetriedCount;
    staticErrLogEntry.UniqueErrorValue = LogContext->UniqueErrorValue;
 
    KeQueryTickCount(&staticErrLogData.TickCount);
    staticErrLogData.PortNumber = (ULONG)-1;
 
    //  Save the entire contents of the SRB.
    staticErrLogData.Srb = *Srb;
 
    //  For our private log, save just the default length of the SENSE_DATA.
    if (senseBufferSize != 0)
    {
        RtlCopyMemory(&staticErrLogData.SenseData, senseBuffer, min(senseBufferSize, sizeof(SENSE_DATA)));
    }
 
    // Save the error log in our context.
    // We only save the default sense buffer length.
    {
        KIRQL                oldIrql;
        KeAcquireSpinLock(&DeviceExtension->PrivateFdoData->SpinLock, &oldIrql);
        DeviceExtension->PrivateFdoData->ErrorLogs[DeviceExtension->PrivateFdoData->ErrorLogNextIndex] = staticErrLogData;
        DeviceExtension->PrivateFdoData->ErrorLogNextIndex++;
        DeviceExtension->PrivateFdoData->ErrorLogNextIndex %= NUM_ERROR_LOG_ENTRIES;
        KeReleaseSpinLock(&DeviceExtension->PrivateFdoData->SpinLock, oldIrql);
    }
 
    //  If logError is set, also save this log in the system's error log.
    //  But make sure we don't log TUR failures over and over
    //  (e.g. if an external drive was switched off and we're still sending TUR's to it every second).
    if (LogContext->LogError)
    {
        // We do not want to log certain system events repetitively
        switch (((PCDB)Srb->Cdb)->CDB10.OperationCode)
        {
            case SCSIOP_TEST_UNIT_READY:
            {
                if (DeviceExtension->PrivateFdoData->LoggedTURFailureSinceLastIO)
                {
                    LogContext->LogError = FALSE;
                }
                else
                {
                    DeviceExtension->PrivateFdoData->LoggedTURFailureSinceLastIO = TRUE;
                }
 
                break;
            }
 
            case SCSIOP_SYNCHRONIZE_CACHE:
            {
                if (DeviceExtension->PrivateFdoData->LoggedSYNCFailure)
                {
                    LogContext->LogError = FALSE;
                }
                else
                {
                    DeviceExtension->PrivateFdoData->LoggedSYNCFailure = TRUE;
                }
 
                break;
            }
        }
 
        // Do not log 5/21/00 LOGICAL BLOCK ADDRESS OUT OF RANGE if the disc is blank,
        // it is known to litter the Event Log with repetitive errors
        // Do not log this error for READ, as it's known that File System mount process reads different sectors from media.
        if (senseBufferSize > RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseCodeQualifier) &&
            senseBuffer->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST &&
            senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_ILLEGAL_BLOCK &&
            senseBuffer->AdditionalSenseCodeQualifier == 0 &&
            IS_SCSIOP_READ(((PCDB)Srb->Cdb)->CDB10.OperationCode))
        {
            LogContext->LogError = FALSE;
        }
    }
 
    //  Write the error log packet to the system error logging thread.
    if (LogContext->LogError)
    {
        PIO_ERROR_LOG_PACKET    errorLogEntry;
        PCDROM_ERROR_LOG_DATA   errlogData;
 
        errorLogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(DeviceExtension->DeviceObject, (UCHAR)totalSize);
        if (errorLogEntry)
        {
            errlogData = (PCDROM_ERROR_LOG_DATA)errorLogEntry->DumpData;
 
            *errorLogEntry = staticErrLogEntry;
            *errlogData = staticErrLogData;
 
            //  For the system log, copy as much of the sense buffer as possible.
            if (senseBufferSize != 0)
            {
                RtlCopyMemory(&errlogData->SenseData, senseBuffer, senseBufferSize);
            }
 
            //  errorLogEntry - It will be freed by the kernel.
            IoWriteErrorLogEntry(errorLogEntry);
        }
    }
 
    return;
}

Referenced by SenseInfoInterpret().

SenseInfoRequestGetInformation()

VOID SenseInfoRequestGetInformation	(	_In_ WDFREQUEST	Request,
		_Out_ UCHAR *	MajorFunctionCode,
		_Out_ ULONG *	IoControlCode,
		_Out_ BOOLEAN *	OverrideVerifyVolume,
		_Out_ ULONGLONG *	Total100nsSinceFirstSend
	)

Definition at line 426 of file sense.c.

{
    PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);
 
    *MajorFunctionCode = 0;
    *IoControlCode = 0;
    *OverrideVerifyVolume = FALSE;
    *Total100nsSinceFirstSend = 0;
 
    if (requestContext->OriginalRequest != NULL)
    {
        PIO_STACK_LOCATION originalIrpStack = NULL;
 
        PIRP originalIrp = WdfRequestWdmGetIrp(requestContext->OriginalRequest);
 
        if (originalIrp != NULL)
        {
            originalIrpStack = IoGetCurrentIrpStackLocation(originalIrp);
        }
 
        if (originalIrpStack != NULL)
        {
            *MajorFunctionCode = originalIrpStack->MajorFunction;
 
            if (*MajorFunctionCode == IRP_MJ_DEVICE_CONTROL)
            {
                *IoControlCode = originalIrpStack->Parameters.DeviceIoControl.IoControlCode;
            }
 
            *OverrideVerifyVolume = TEST_FLAG(originalIrpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME);
        }
    }
 
    // Calculate time past since the request was first time sent.
    if (requestContext->TimeSentDownFirstTime.QuadPart > 0)
    {
        LARGE_INTEGER tmp;
        KeQueryTickCount(&tmp);
        tmp.QuadPart -= requestContext->TimeSentDownFirstTime.QuadPart;
        tmp.QuadPart *= KeQueryTimeIncrement();
        *Total100nsSinceFirstSend = tmp.QuadPart;
    }
    else
    {
        // set to -1 if field TimeSentDownFirstTime not set.
        *Total100nsSinceFirstSend = (ULONGLONG) -1;
    }
 
    return;
}

Referenced by SenseInfoInterpret().