scratch.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	ScratchBuffer_BeginUse(context)   ScratchBuffer_BeginUseX((context), NULL, (ULONG)-1)

Functions
	_IRQL_requires_max_ (APC_LEVEL) VOID ScratchBuffer_Deallocate(_Inout_ PCDROM_DEVICE_EXTENSION DeviceExtension)
VOID	ScratchBuffer_ResetItems (_Inout_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ BOOLEAN ResetRequestHistory)
VOID	ScratchBuffer_SetupReadWriteSrb (_Inout_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST OriginalRequest, _In_ LARGE_INTEGER StartingOffset, _In_ ULONG RequiredLength, _Inout_updates_bytes_(RequiredLength) UCHAR *DataBuffer, _In_ BOOLEAN IsReadRequest, _In_ BOOLEAN UsePartialMdl)
NTSTATUS	ScratchBuffer_SendSrb (_Inout_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ BOOLEAN SynchronousSrb, _When_(SynchronousSrb, _Pre_null_) _When_(!SynchronousSrb, _In_opt_) PSRB_HISTORY_ITEM *SrbHistoryItem)
NTSTATUS	ScratchBuffer_PerformNextReadWrite (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ BOOLEAN FirstTry)
FORCEINLINE VOID	ScratchBuffer_BeginUseX (_Inout_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_opt_ LPCSTR File, ULONG Line)
FORCEINLINE VOID	ScratchBuffer_EndUse (_Inout_ PCDROM_DEVICE_EXTENSION DeviceExtension)
VOID	CompressSrbHistoryData (_Inout_ PSRB_HISTORY RequestHistory)
VOID	ValidateSrbHistoryDataPresumptions (_In_ SRB_HISTORY const *RequestHistory)

Variables
_In_opt_ WDFREQUEST	OriginalRequest
_In_opt_ WDFREQUEST _In_ ULONG	MaximumTransferLength
_In_opt_ WDFREQUEST _In_ ULONG _In_ BOOLEAN	GetDataFromDevice
_In_opt_ WDFREQUEST _In_ ULONG	TransferSize
_In_opt_ WDFREQUEST _In_ ULONG _In_ BOOLEAN _In_ PCDB	Cdb
_In_opt_ WDFREQUEST _In_ ULONG _In_ BOOLEAN _In_ PCDB _In_ UCHAR	OprationLength
_In_opt_ WDFREQUEST _In_ ULONG _In_ BOOLEAN _In_ PCDB _In_ UCHAR _In_ ULONG	TimeoutValue
KDEFERRED_ROUTINE	ScratchBuffer_ReadWriteTimerRoutine

Macro Definition Documentation

ScratchBuffer_BeginUse

#define ScratchBuffer_BeginUse

(

context

)

ScratchBuffer_BeginUseX((context), NULL, (ULONG)-1)

Definition at line 87 of file scratch.h.

Function Documentation

_IRQL_requires_max_()

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 37 of file cddata.c.

{
    THREAD_CONTEXT ThreadContext = {0};
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN Wait;
 
#ifdef CD_SANITY
    PVOID PreviousTopLevel;
#endif
 
    NTSTATUS Status;
 
#if DBG
 
    KIRQL SaveIrql = KeGetCurrentIrql();
 
#endif
 
    ASSERT_OPTIONAL_IRP( Irp );
 
    UNREFERENCED_PARAMETER( DeviceObject );
 
    FsRtlEnterFileSystem();
 
#ifdef CD_SANITY
    PreviousTopLevel = IoGetTopLevelIrp();
#endif
 
    //
    //  Loop until this request has been completed or posted.
    //
 
    do {
 
        //
        //  Use a try-except to handle the exception cases.
        //
 
        _SEH2_TRY {
 
            //
            //  If the IrpContext is NULL then this is the first pass through
            //  this loop.
            //
 
            if (IrpContext == NULL) {
 
                //
                //  Decide if this request is waitable an allocate the IrpContext.
                //  If the file object in the stack location is NULL then this
                //  is a mount which is always waitable.  Otherwise we look at
                //  the file object flags.
                //
 
                if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {
 
                    Wait = TRUE;
 
                } else {
 
                    Wait = CanFsdWait( Irp );
                }
 
                IrpContext = CdCreateIrpContext( Irp, Wait );
 
                //
                //  Update the thread context information.
                //
 
                CdSetThreadContext( IrpContext, &ThreadContext );
 
#ifdef CD_SANITY
                NT_ASSERT( !CdTestTopLevel ||
                        SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif
 
            //
            //  Otherwise cleanup the IrpContext for the retry.
            //
 
            } else {
 
                //
                //  Set the MORE_PROCESSING flag to make sure the IrpContext
                //  isn't inadvertently deleted here.  Then cleanup the
                //  IrpContext to perform the retry.
                //
 
                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
                CdCleanupIrpContext( IrpContext, FALSE );
            }
 
            //
            //  Case on the major irp code.
            //
 
            switch (IrpContext->MajorFunction) {
 
            case IRP_MJ_CREATE :
 
                Status = CdCommonCreate( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLOSE :
 
                Status = CdCommonClose( IrpContext, Irp );
                break;
 
            case IRP_MJ_READ :
 
                //
                //  If this is an Mdl complete request, don't go through
                //  common read.
                //
 
                if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {
 
                    Status = CdCompleteMdl( IrpContext, Irp );
 
                } else {
 
                    Status = CdCommonRead( IrpContext, Irp );
                }
 
                break;
 
            case IRP_MJ_WRITE :
 
                Status = CdCommonWrite( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_INFORMATION :
 
                Status = CdCommonQueryInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_SET_INFORMATION :
 
                Status = CdCommonSetInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_QUERY_VOLUME_INFORMATION :
 
                Status = CdCommonQueryVolInfo( IrpContext, Irp );
                break;
 
            case IRP_MJ_DIRECTORY_CONTROL :
 
                Status = CdCommonDirControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_FILE_SYSTEM_CONTROL :
 
                Status = CdCommonFsControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_DEVICE_CONTROL :
 
                Status = CdCommonDevControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_LOCK_CONTROL :
 
                Status = CdCommonLockControl( IrpContext, Irp );
                break;
 
            case IRP_MJ_CLEANUP :
 
                Status = CdCommonCleanup( IrpContext, Irp );
                break;
 
            case IRP_MJ_PNP :
 
                Status = CdCommonPnp( IrpContext, Irp );
                break;
 
            case IRP_MJ_SHUTDOWN :
 
                Status = CdCommonShutdown( IrpContext, Irp );
                break;
 
            default :
 
                Status = STATUS_INVALID_DEVICE_REQUEST;
                CdCompleteRequest( IrpContext, Irp, Status );
            }
 
        } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
 
            Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
        } _SEH2_END;
 
    } while (Status == STATUS_CANT_WAIT);
 
#ifdef CD_SANITY
    NT_ASSERT( !CdTestTopLevel ||
            (PreviousTopLevel == IoGetTopLevelIrp()) );
#endif
 
    FsRtlExitFileSystem();
 
    NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));
 
    return Status;
}

CompressSrbHistoryData()

VOID CompressSrbHistoryData

(

_Inout_ PSRB_HISTORY

RequestHistory

)

Definition at line 1033 of file scratch.c.

{
    ULONG i;
    NT_ASSERT( RequestHistory->UsedHistoryCount == RequestHistory->TotalHistoryCount );
    ValidateSrbHistoryDataPresumptions(RequestHistory);
 
    for (i=0; i < RequestHistory->UsedHistoryCount; i++)
    {
        // for each item...
        PSRB_HISTORY_ITEM toMatch = &( RequestHistory->History[i] );
        // hint: read const qualifiers backwards.  i.e. srbstatus is a const UCHAR
        // so, "UCHAR const * const x" is read "x is a const pointer to a const UCHAR"
        // unfortunately, "const UCHAR" is equivalent to "UCHAR const", which causes
        // people no end of confusion due to its widespread use.
        UCHAR const srbStatus = toMatch->SrbStatus;
        UCHAR const sense     = toMatch->NormalizedSenseData.SenseKey;
        UCHAR const asc       = toMatch->NormalizedSenseData.AdditionalSenseCode;
        UCHAR const ascq      = toMatch->NormalizedSenseData.AdditionalSenseCodeQualifier;
        ULONG j;
 
        // see if there are any at higher indices with identical Sense/ASC/ASCQ
        for (j = i+1; (toMatch->ClassDriverUse != 0xFF) && (j < RequestHistory->UsedHistoryCount); j++)
        {
            PSRB_HISTORY_ITEM found = &( RequestHistory->History[j] );
            // close enough match?
            if ((srbStatus == found->SrbStatus) &&
                (sense     == found->NormalizedSenseData.SenseKey) &&
                (asc       == found->NormalizedSenseData.AdditionalSenseCode) &&
                (ascq      == found->NormalizedSenseData.AdditionalSenseCodeQualifier)) {
 
                // add the fields to keep reasonable track of delay times.
                if (toMatch->MillisecondsDelayOnRetry + found->MillisecondsDelayOnRetry < toMatch->MillisecondsDelayOnRetry) {
                    toMatch->MillisecondsDelayOnRetry = MAXULONG;
                } else {
                    toMatch->MillisecondsDelayOnRetry += found->MillisecondsDelayOnRetry;
                }
 
                // this found item cannot contain any compressed entries because
                // the first entry with a given set of sense/asc/ascq will always
                // either be full (0xFF) or be the only partially-full entry with
                // that sense/asc/ascq.
                NT_ASSERT(found->ClassDriverUse == 0);
                // add the counts so we still know how many retries total
                toMatch->ClassDriverUse++;
 
 
                // if not the last entry, need to move later entries earlier in the array
                if (j != RequestHistory->UsedHistoryCount-1) {
                    // how many entries remain?
                    SIZE_T remainingBytes = RequestHistory->UsedHistoryCount - 1 - j;
                    remainingBytes *= sizeof(SRB_HISTORY_ITEM);
 
                    // note that MOVE is required due to overlapping entries
                    RtlMoveMemory(found, found+1, remainingBytes);
 
                    // Finally, decrement the number of used history count and
                    // decrement j to rescan the current location again
                    --RequestHistory->UsedHistoryCount;
                    --j;
                } // end moving of array elements around
            } // end of close enough match
        } // end j loop
    } // end i loop
 
    // unable to compress duplicate sense/asc/ascq, so just lose the most recent data
    if (RequestHistory->UsedHistoryCount == RequestHistory->TotalHistoryCount)
    {
        PSRB_HISTORY_ITEM item = &( RequestHistory->History[ RequestHistory->TotalHistoryCount-1 ] );
        RequestHistory->ClassDriverUse[0] += item->ClassDriverUse; // how many did we "lose"?
        RequestHistory->UsedHistoryCount--;
    }
 
    // finally, zero any that are no longer in use
    NT_ASSERT( RequestHistory->UsedHistoryCount != RequestHistory->TotalHistoryCount);
    {
        SIZE_T bytesToZero = RequestHistory->TotalHistoryCount - RequestHistory->UsedHistoryCount;
        bytesToZero *= sizeof(SRB_HISTORY_ITEM);
        RtlZeroMemory(&(RequestHistory->History[RequestHistory->UsedHistoryCount]), bytesToZero);
    }
 
    ValidateSrbHistoryDataPresumptions(RequestHistory);
    return;
}

Referenced by ScratchBuffer_SendSrb().

ScratchBuffer_BeginUseX()

FORCEINLINE VOID ScratchBuffer_BeginUseX	(	_Inout_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_opt_ LPCSTR	File,
		ULONG	Line
	)

Definition at line 90 of file scratch.h.

{
    // NOTE: these are not "real" locks.  They are simply to help
    //       avoid multiple uses of the scratch buffer. Thus, it
    //       is not critical to have atomic operations here.
    PVOID tmp = InterlockedCompareExchangePointer((PVOID)&(DeviceExtension->ScratchContext.ScratchInUse), (PVOID)-1, NULL);
    NT_ASSERT(tmp == NULL);
    UNREFERENCED_PARAMETER(tmp); //defensive coding, avoid PREFAST warning.
    DeviceExtension->ScratchContext.ScratchInUseFileName = File;
    DeviceExtension->ScratchContext.ScratchInUseLineNumber = Line;
    ScratchBuffer_ResetItems(DeviceExtension, TRUE);
    RequestClearSendTime(DeviceExtension->ScratchContext.ScratchRequest);
    return;
}

ScratchBuffer_EndUse()

FORCEINLINE VOID ScratchBuffer_EndUse

(

_Inout_ PCDROM_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 104 of file scratch.h.

{
    // NOTE: these are not "real" locks.  They are simply to help
    //       avoid multiple uses of the scratch buffer.  Thus, it
    //       is not critical to have atomic operations here.
 
    // On lock release, we erase ScratchInUseFileName and ScratchInUseLineNumber _before_ releasing ScratchInUse,
    // because otherwise we may erase these after the lock has been acquired again by another thread. We store the
    // old values of ScratchInUseFileName and ScratchInUseLineNumber in local variables to facilitate debugging,
    // if the ASSERT at the end of the function is hit.
    PCSTR  scratchInUseFileName;
    ULONG  scratchInUseLineNumber;
    PVOID  tmp;
 
    scratchInUseFileName = DeviceExtension->ScratchContext.ScratchInUseFileName;
    scratchInUseLineNumber = DeviceExtension->ScratchContext.ScratchInUseLineNumber;
    UNREFERENCED_PARAMETER(scratchInUseFileName);
    UNREFERENCED_PARAMETER(scratchInUseLineNumber);
    DeviceExtension->ScratchContext.ScratchInUseFileName = NULL;
    DeviceExtension->ScratchContext.ScratchInUseLineNumber = 0;
 
    //
    // If we have used the PartialMdl in the scratch context we should notify MM that we will be reusing it
    // otherwise it may leak System VA if some one below us has mapped the same.
    //
 
    if (DeviceExtension->ScratchContext.PartialMdlIsBuilt != FALSE)
    {
        MmPrepareMdlForReuse(DeviceExtension->ScratchContext.PartialMdl);
        DeviceExtension->ScratchContext.PartialMdlIsBuilt = FALSE;
    }
 
    tmp = InterlockedCompareExchangePointer((PVOID)&(DeviceExtension->ScratchContext.ScratchInUse), NULL, (PVOID)-1);
    NT_ASSERT(tmp == ((PVOID)-1));
    UNREFERENCED_PARAMETER(tmp); //defensive coding, avoid PREFAST warning.
    return;
}

Referenced by _IRQL_requires_max_(), DeviceScratchPreventMediaRemoval(), DeviceScratchSyncCache(), RequestIssueShutdownFlush(), ScratchBuffer_ReadWriteCompletionRoutine(), ScratchBuffer_ReadWriteEvtRequestCancel(), and ScratchBuffer_ReadWriteTimerRoutine().

ScratchBuffer_PerformNextReadWrite()

NTSTATUS ScratchBuffer_PerformNextReadWrite	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ BOOLEAN	FirstTry
	)

Definition at line 429 of file scratch.c.

{
    PCDROM_SCRATCH_READ_WRITE_CONTEXT   readWriteContext = &DeviceExtension->ScratchContext.ScratchReadWriteContext;
    PCDROM_REQUEST_CONTEXT              requestContext = RequestGetContext(DeviceExtension->ScratchContext.ScratchRequest);
    WDFREQUEST                          originalRequest = requestContext->OriginalRequest;
    NTSTATUS                            status = STATUS_SUCCESS;
 
    ULONG       transferSize;
    BOOLEAN     usePartialMdl;
 
    transferSize = min((readWriteContext->EntireXferLen - readWriteContext->TransferedBytes), readWriteContext->MaxLength);
 
    if (FirstTry)
    {
        DeviceExtension->ScratchContext.NumRetries = 0;
    }
 
    ScratchBuffer_ResetItems(DeviceExtension, FALSE);
 
    usePartialMdl = (readWriteContext->PacketsCount > 1 || readWriteContext->TransferedBytes > 0);
 
    ScratchBuffer_SetupReadWriteSrb(DeviceExtension,
                                    originalRequest,
                                    readWriteContext->StartingOffset,
                                    transferSize,
                                    readWriteContext->DataBuffer,
                                    readWriteContext->IsRead,
                                    usePartialMdl
                                    );
 
    WdfRequestSetCompletionRoutine(DeviceExtension->ScratchContext.ScratchRequest,
            ScratchBuffer_ReadWriteCompletionRoutine, DeviceExtension);
 
    status = ScratchBuffer_SendSrb(DeviceExtension, FALSE, (FirstTry ? &readWriteContext->SrbHistoryItem : NULL));
 
    return status;
}

Referenced by RequestHandleReadWrite(), ScratchBuffer_ReadWriteCompletionRoutine(), and ScratchBuffer_ReadWriteTimerRoutine().

ScratchBuffer_ResetItems()

VOID ScratchBuffer_ResetItems	(	_Inout_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ BOOLEAN	ResetRequestHistory
	)

Definition at line 343 of file scratch.c.

{
    NTSTATUS                 status = STATUS_SUCCESS;
    WDF_REQUEST_REUSE_PARAMS reuseParams;
    PIRP                     irp = NULL;
 
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchHistory    != NULL);
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchSense      != NULL);
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchSrb        != NULL);
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchRequest    != NULL);
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchBufferSize != 0);
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchBuffer     != NULL);
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchBufferMdl  != NULL);
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchInUse      != 0);
 
    irp = WdfRequestWdmGetIrp(DeviceExtension->ScratchContext.ScratchRequest);
 
    if (ResetRequestHistory)
    {
        PSRB_HISTORY history = DeviceExtension->ScratchContext.ScratchHistory;
        RtlZeroMemory(history->History, sizeof(SRB_HISTORY_ITEM) * history->TotalHistoryCount);
        history->ClassDriverUse[0] = 0;
        history->ClassDriverUse[1] = 0;
        history->ClassDriverUse[2] = 0;
        history->ClassDriverUse[3] = 0;
        history->UsedHistoryCount  = 0;
    }
 
    // re-use the KMDF request object
 
    // deassign the MdlAddress, this is the value we assign explicitly.
    // this is to prevent WdfRequestReuse to release the Mdl unexpectly.
    if (irp->MdlAddress)
    {
        irp->MdlAddress = NULL;
    }
 
    WDF_REQUEST_REUSE_PARAMS_INIT(&reuseParams, WDF_REQUEST_REUSE_NO_FLAGS, STATUS_NOT_SUPPORTED);
    status = WdfRequestReuse(DeviceExtension->ScratchContext.ScratchRequest, &reuseParams);
    // WDF request to format the request befor sending it
    if (NT_SUCCESS(status))
    {
        // clean up completion routine.
        WdfRequestSetCompletionRoutine(DeviceExtension->ScratchContext.ScratchRequest, NULL, NULL);
 
        status = WdfIoTargetFormatRequestForInternalIoctlOthers(DeviceExtension->IoTarget,
                                                                DeviceExtension->ScratchContext.ScratchRequest,
                                                                IOCTL_SCSI_EXECUTE_IN,
                                                                NULL, NULL,
                                                                NULL, NULL,
                                                                NULL, NULL);
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                       "ScratchBuffer_ResetItems: WdfIoTargetFormatRequestForInternalIoctlOthers failed, %!STATUS!\n",
                       status));
        }
    }
 
    RtlZeroMemory(DeviceExtension->ScratchContext.ScratchSense, sizeof(SENSE_DATA));
    RtlZeroMemory(DeviceExtension->ScratchContext.ScratchSrb, sizeof(SCSI_REQUEST_BLOCK));
 
    return;
}

Referenced by _IRQL_requires_max_(), ScratchBuffer_BeginUseX(), and ScratchBuffer_PerformNextReadWrite().

ScratchBuffer_SendSrb()

NTSTATUS ScratchBuffer_SendSrb	(	_Inout_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ BOOLEAN	SynchronousSrb,
		_When_(SynchronousSrb, _Pre_null_) _When_(!SynchronousSrb, _In_opt_) PSRB_HISTORY_ITEM *	SrbHistoryItem
	)

Definition at line 906 of file scratch.c.

{
    NTSTATUS                 status  = STATUS_SUCCESS;
    PSCSI_REQUEST_BLOCK      srb = DeviceExtension->ScratchContext.ScratchSrb;
    PSRB_HISTORY             history = DeviceExtension->ScratchContext.ScratchHistory;
    PSRB_HISTORY_ITEM        item = NULL;
    BOOLEAN                  requestCancelled = FALSE;
 
    srb->InternalStatus = 0;
    srb->SrbStatus = 0;
 
    // allocate/update history pre-command, if it is a synchronous request or we were supplied
    // with a storage for the history item
    if (SynchronousSrb || SrbHistoryItem != NULL)
    {
        // sending a packet implies a new history unit is to be used.
        NT_ASSERT( history->UsedHistoryCount <= history->TotalHistoryCount );
 
        // if already all used up, remove at least one history unit
        if (history->UsedHistoryCount == history->TotalHistoryCount )
        {
            CompressSrbHistoryData(history);
            NT_ASSERT( history->UsedHistoryCount < history->TotalHistoryCount );
        }
 
        // thus, since we are about to increment the count, it must now be less...
        NT_ASSERT( history->UsedHistoryCount < history->TotalHistoryCount );
 
        // increment the number of history units in use
        history->UsedHistoryCount++;
 
        // determine index to use
        item = &( history->History[ history->UsedHistoryCount-1 ] );
 
        if (SrbHistoryItem != NULL)
        {
            *SrbHistoryItem = item;
        }
 
        // zero out the history item
        RtlZeroMemory(item, sizeof(SRB_HISTORY_ITEM));
 
        // Query the tick count and store in the history
        KeQueryTickCount(&item->TickCountSent);
    }
 
    // get cancellation status;
    {
        PCDROM_REQUEST_CONTEXT  requestContext = RequestGetContext(DeviceExtension->ScratchContext.ScratchRequest);
 
        if (requestContext->OriginalRequest != NULL)
        {
            requestCancelled = WdfRequestIsCanceled(requestContext->OriginalRequest);
        }
    }
 
    if (!requestCancelled)
    {
        status = RequestSend(DeviceExtension,
                             DeviceExtension->ScratchContext.ScratchRequest,
                             DeviceExtension->IoTarget,
                             SynchronousSrb ? WDF_REQUEST_SEND_OPTION_SYNCHRONOUS : 0,
                             NULL);
 
        // If this is a synchronous request, update the history item immediately, including "normalized" sense data
        if (SynchronousSrb)
        {
            ULONG senseSize;
 
            // Query the tick count and store in the history
            KeQueryTickCount(&item->TickCountCompleted);
 
            // Copy the SRB Status
            item->SrbStatus = srb->SrbStatus;
 
            // Determine the amount of valid sense data
            if (srb->SenseInfoBufferLength >= RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseLength))
            {
                PSENSE_DATA sense = (PSENSE_DATA)srb->SenseInfoBuffer;
                senseSize = RTL_SIZEOF_THROUGH_FIELD(SENSE_DATA, AdditionalSenseLength) +
                            sense->AdditionalSenseLength;
                senseSize = min(senseSize, sizeof(SENSE_DATA));
            }
            else
            {
                senseSize = srb->SenseInfoBufferLength;
            }
 
            // Normalize the sense data copy in the history
            RtlZeroMemory(&(item->NormalizedSenseData), sizeof(SENSE_DATA));
            RtlCopyMemory(&(item->NormalizedSenseData), srb->SenseInfoBuffer, senseSize);
        }
    }
    else
    {
        DeviceExtension->ScratchContext.ScratchSrb->SrbStatus = SRB_STATUS_ABORTED;
        DeviceExtension->ScratchContext.ScratchSrb->InternalStatus = (ULONG)STATUS_CANCELLED;
        status = STATUS_CANCELLED;
    }
 
    return status;
}

Referenced by RequestIssueShutdownFlush(), and ScratchBuffer_PerformNextReadWrite().

ScratchBuffer_SetupReadWriteSrb()

VOID ScratchBuffer_SetupReadWriteSrb	(	_Inout_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	OriginalRequest,
		_In_ LARGE_INTEGER	StartingOffset,
		_In_ ULONG	RequiredLength,
		_Inout_updates_bytes_(RequiredLength) UCHAR *	DataBuffer,
		_In_ BOOLEAN	IsReadRequest,
		_In_ BOOLEAN	UsePartialMdl
	)

Definition at line 1212 of file scratch.c.

{
    //NOTE: R/W request not use the ScratchBuffer, instead, it uses the buffer associated with IRP.
 
    PSCSI_REQUEST_BLOCK srb = DeviceExtension->ScratchContext.ScratchSrb;
    PCDB                cdb = (PCDB)srb->Cdb;
    LARGE_INTEGER       logicalBlockAddr;
    ULONG               numTransferBlocks;
 
    PIRP                originalIrp = WdfRequestWdmGetIrp(OriginalRequest);
 
    PIRP                irp = WdfRequestWdmGetIrp(DeviceExtension->ScratchContext.ScratchRequest);
    PIO_STACK_LOCATION  irpStack = NULL;
 
    PCDROM_REQUEST_CONTEXT  requestContext = RequestGetContext(DeviceExtension->ScratchContext.ScratchRequest);
 
    requestContext->OriginalRequest = OriginalRequest;
 
 
    logicalBlockAddr.QuadPart = Int64ShrlMod32(StartingOffset.QuadPart, DeviceExtension->SectorShift);
    numTransferBlocks = RequiredLength >> DeviceExtension->SectorShift;
 
    // set to use the full scratch buffer via the scratch SRB
    irpStack = IoGetNextIrpStackLocation(irp);
    irpStack->MajorFunction = IRP_MJ_SCSI;
    if (IsReadRequest)
    {
        irpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_IN;
    }
    else
    {
        irpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_SCSI_EXECUTE_OUT;
    }
    irpStack->Parameters.Scsi.Srb = srb;
 
    // prepare the SRB with default values
    srb->Length = SCSI_REQUEST_BLOCK_SIZE;
    srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;
    srb->SrbStatus = 0;
    srb->ScsiStatus = 0;
    srb->NextSrb = NULL;
    srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;
    srb->SenseInfoBuffer = DeviceExtension->ScratchContext.ScratchSense;
 
    srb->DataBuffer = DataBuffer;
    srb->DataTransferLength = RequiredLength;
 
    srb->QueueSortKey = logicalBlockAddr.LowPart;
    if (logicalBlockAddr.QuadPart > 0xFFFFFFFF)
    {
        //
        // If the requested LBA is more than max ULONG set the
        // QueueSortKey to the maximum value, so that these
        // requests can be added towards the end of the queue.
        //
        srb->QueueSortKey = 0xFFFFFFFF;
    }
 
    srb->OriginalRequest = irp;
    srb->TimeOutValue = DeviceExtension->TimeOutValue;
 
    if (RequestIsRealtimeStreaming(OriginalRequest, IsReadRequest) &&
        !TEST_FLAG(DeviceExtension->PrivateFdoData->HackFlags, FDO_HACK_NO_STREAMING))
    {
        if (IsReadRequest)
        {
            RtlZeroMemory(&cdb->READ12, sizeof(cdb->READ12));
            REVERSE_BYTES(&cdb->READ12.LogicalBlock, &logicalBlockAddr.LowPart);
            REVERSE_BYTES(&cdb->READ12.TransferLength, &numTransferBlocks);
            cdb->READ12.Streaming = 1;
            cdb->READ12.OperationCode = SCSIOP_READ12;
            srb->CdbLength = sizeof(cdb->READ12);
        }
        else
        {
            RtlZeroMemory(&cdb->WRITE12, sizeof(cdb->WRITE12));
            REVERSE_BYTES(&cdb->WRITE12.LogicalBlock, &logicalBlockAddr.LowPart);
            REVERSE_BYTES(&cdb->WRITE12.TransferLength, &numTransferBlocks);
            cdb->WRITE12.Streaming = 1;
            cdb->WRITE12.OperationCode = SCSIOP_WRITE12;
            srb->CdbLength = sizeof(cdb->WRITE12);
        }
    }
    else
    {
        RtlZeroMemory(&cdb->CDB10, sizeof(cdb->CDB10));
        cdb->CDB10.LogicalBlockByte0 = ((PFOUR_BYTE)&logicalBlockAddr.LowPart)->Byte3;
        cdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)&logicalBlockAddr.LowPart)->Byte2;
        cdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)&logicalBlockAddr.LowPart)->Byte1;
        cdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)&logicalBlockAddr.LowPart)->Byte0;
        cdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)&numTransferBlocks)->Byte1;
        cdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)&numTransferBlocks)->Byte0;
        cdb->CDB10.OperationCode = (IsReadRequest) ? SCSIOP_READ : SCSIOP_WRITE;
        srb->CdbLength = sizeof(cdb->CDB10);
    }
 
    //  Set SRB and IRP flags
    srb->SrbFlags = DeviceExtension->SrbFlags;
    if (TEST_FLAG(originalIrp->Flags, IRP_PAGING_IO) ||
        TEST_FLAG(originalIrp->Flags, IRP_SYNCHRONOUS_PAGING_IO))
    {
        SET_FLAG(srb->SrbFlags, SRB_CLASS_FLAGS_PAGING);
    }
 
    SET_FLAG(srb->SrbFlags, (IsReadRequest) ? SRB_FLAGS_DATA_IN : SRB_FLAGS_DATA_OUT);
    SET_FLAG(srb->SrbFlags, SRB_FLAGS_ADAPTER_CACHE_ENABLE);
 
    //
    // If the request is not split, we can use the original IRP MDL.  If the
    // request needs to be split, we need to use a partial MDL.  The partial MDL
    // is needed because more than one driver might be mapping the same MDL
    // and this causes problems.
    //
    if (UsePartialMdl == FALSE)
    {
        irp->MdlAddress = originalIrp->MdlAddress;
    }
    else
    {
        if (DeviceExtension->ScratchContext.PartialMdlIsBuilt != FALSE)
        {
            MmPrepareMdlForReuse(DeviceExtension->ScratchContext.PartialMdl);
        }
 
        IoBuildPartialMdl(originalIrp->MdlAddress, DeviceExtension->ScratchContext.PartialMdl, srb->DataBuffer, srb->DataTransferLength);
        DeviceExtension->ScratchContext.PartialMdlIsBuilt = TRUE;
        irp->MdlAddress = DeviceExtension->ScratchContext.PartialMdl;
    }
 
    //DBGLOGSENDPACKET(Pkt);
    //HISTORYLOGSENDPACKET(Pkt);
 
    //
    // Set the original irp here for SFIO.
    //
    srb->SrbExtension = (PVOID)(originalIrp);
 
    return;
}

Referenced by ScratchBuffer_PerformNextReadWrite().

ValidateSrbHistoryDataPresumptions()

VOID ValidateSrbHistoryDataPresumptions

(

_In_ SRB_HISTORY const *

RequestHistory

)

Definition at line 1135 of file scratch.c.

{
#if DBG
    // validate that all fully-compressed items are before any non-fully-compressed items of any particular sense/asc/ascq
    // validate that there is at most one partially-compressed item of any particular sense/asc/ascq
    // validate that all items of any particular sense/asc/ascq that are uncompressed are at the end
    // THUS: A(255) A(255) A( 40) A(  0) A(  0) is legal for all types with A as sense/asc/ascq
    //       A(0)   B(255) A(  0) B( 17) B(  0) is also legal because A/B are different types of error
 
    ULONG i;
    for (i = 0; i < RequestHistory->UsedHistoryCount; i++)
    {
        SRB_HISTORY_ITEM const * toMatch = &( RequestHistory->History[i] );
        UCHAR const srbStatus = toMatch->SrbStatus;
        UCHAR const sense     = toMatch->NormalizedSenseData.SenseKey;
        UCHAR const asc       = toMatch->NormalizedSenseData.AdditionalSenseCode;
        UCHAR const ascq      = toMatch->NormalizedSenseData.AdditionalSenseCodeQualifier;
        ULONG j;
 
        BOOLEAN foundPartiallyCompressedItem =
            (toMatch->ClassDriverUse !=    0) &&
            (toMatch->ClassDriverUse != 0xFF) ;
        BOOLEAN foundUncompressedItem =
            (toMatch->ClassDriverUse ==    0) ;
 
        for (j = i+1; j < RequestHistory->UsedHistoryCount; j++)
        {
            SRB_HISTORY_ITEM const * found = &( RequestHistory->History[j] );
            if ((srbStatus == found->SrbStatus) &&
                (sense     == found->NormalizedSenseData.SenseKey) &&
                (asc       == found->NormalizedSenseData.AdditionalSenseCode) &&
                (ascq      == found->NormalizedSenseData.AdditionalSenseCodeQualifier)
                )
            {
                // found a matching type, so validate ordering rules
                if (foundUncompressedItem && (found->ClassDriverUse != 0))
                {
                    DbgPrintEx(DPFLTR_CDROM_ID, DPFLTR_ERROR_LEVEL,
                               "History data has compressed history following uncompressed history "
                               "for srbstatus/sense/asc/ascq of %02x/%02x/%02x/%02x at indices %d (%08x) and %d (%08x)\n",
                               srbStatus, sense, asc, ascq,
                               i,i, j,j
                               );
                    NT_ASSERT(FALSE);
                }
                else if (foundPartiallyCompressedItem && (found->ClassDriverUse == 0xFF))
                {
                    DbgPrintEx(DPFLTR_CDROM_ID, DPFLTR_ERROR_LEVEL,
                               "History data has fully compressed history following partially compressed history "
                               "for srbstatus/sense/asc/ascq of %02x/%02x/%02x/%02x at indices %d (%08x) and %d (%08x)\n",
                               srbStatus, sense, asc, ascq,
                               i,i, j,j
                               );
                    NT_ASSERT(FALSE);
                }
 
                // update if we have now found partially compressed and/or uncompressed items
                if (found->ClassDriverUse == 0)
                {
                    foundUncompressedItem = TRUE;
                }
                else if (found->ClassDriverUse != 0xFF)
                {
                    foundPartiallyCompressedItem = TRUE;
                }
            } // end match of (toMatch,found)
        } // end loop j
    } // end loop i
#else
    UNREFERENCED_PARAMETER(RequestHistory);
#endif
    return;
}

Referenced by CompressSrbHistoryData().

Variable Documentation

Cdb

_In_opt_ WDFREQUEST _In_ ULONG _In_ BOOLEAN _In_ PCDB Cdb

Definition at line 159 of file scratch.h.

Referenced by _Requires_lock_held_(), AhciATAPICommand(), AhciGetLba(), AtapiInterrupt__(), AtapiSendCommand(), ClasspIsOffloadDataTransferCommand(), ClasspIsReceiveTokenInformation(), ClasspIsTokenOperation(), ClasspTransferPacketGetNumberOfRetriesDone(), DeviceInquiryRequest(), DeviceReportLuns(), DeviceRequestCapacity(), DeviceRequestComplete(), DeviceRequestReadWrite(), DeviceRequestSense(), DiskIoctlVerifyThread(), DiskOpen(), DiskRead(), FdoSendInquiry(), GetSrbScsiData(), PortSendInquiry(), SpiScanAdapter(), SpiSendRequestSense(), SptiHandleScsiPassthru(), SptiInitializeSpt(), SptiTranslateSptToSrb(), SptiTranslateTaskFileToCdb(), SrbGetCdb(), SrbGetScsiData(), UDFCommonDeviceControl(), USBSTOR_FillInquiryData(), and USBSTOR_SendInternalCdb().

GetDataFromDevice

_In_opt_ WDFREQUEST _In_ ULONG _In_ BOOLEAN GetDataFromDevice

Definition at line 55 of file scratch.h.

MaximumTransferLength

_In_opt_ WDFREQUEST _In_ ULONG MaximumTransferLength

Definition at line 54 of file scratch.h.

Referenced by SptiHandleAtaPassthru(), SptiHandleScsiPassthru(), SptiInitializeApt(), and SptiInitializeSpt().

OprationLength

_In_opt_ WDFREQUEST _In_ ULONG _In_ BOOLEAN _In_ PCDB _In_ UCHAR OprationLength

Initial value:

{
    return ScratchBuffer_ExecuteCdbEx(DeviceExtension,
                                      OriginalRequest,
                                      TransferSize,
                                      GetDataFromDevice,
                                      Cdb,
                                      OprationLength,
                                      0)

Definition at line 160 of file scratch.h.

OriginalRequest

_In_opt_ WDFREQUEST OriginalRequest

Definition at line 53 of file scratch.h.

ScratchBuffer_ReadWriteTimerRoutine

KDEFERRED_ROUTINE ScratchBuffer_ReadWriteTimerRoutine

Definition at line 185 of file scratch.h.

Referenced by ScratchBuffer_ReadWriteCompletionRoutine().

TimeoutValue

_In_opt_ WDFREQUEST _In_ ULONG _In_ BOOLEAN _In_ PCDB _In_ UCHAR _In_ ULONG TimeoutValue

Definition at line 161 of file scratch.h.

TransferSize

_In_opt_ WDFREQUEST _In_ ULONG TransferSize

Definition at line 157 of file scratch.h.