common.c File Reference

#include "ntddk.h"
#include "ntddstor.h"
#include "ntstrsafe.h"
#include "cdrom.h"
#include "scratch.h"

Include dependency graph for common.c:

Go to the source code of this file.

Functions
VOID	RequestSetReceivedTime (_In_ WDFREQUEST Request)
VOID	RequestSetSentTime (_In_ WDFREQUEST Request)
VOID	RequestClearSendTime (_In_ WDFREQUEST Request)
	_IRQL_requires_max_ (PASSIVE_LEVEL)
	_IRQL_requires_max_ (APC_LEVEL)
VOID	DeviceSendNotification (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ const GUID *Guid, _In_ ULONG ExtraDataSize, _In_opt_ PVOID ExtraData)
VOID	DeviceSendStartUnit (_In_ WDFDEVICE Device)
VOID	DeviceSendIoctlAsynchronously (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT TargetDeviceObject)
NTSTATUS NTAPI	RequestAsynchronousIrpCompletion (_In_ PDEVICE_OBJECT DeviceObject, _In_ PIRP Irp, _In_reads_opt_(_Inexpressible_("varies")) PVOID Context)
VOID NTAPI	DeviceAsynchronousCompletion (_In_ WDFREQUEST Request, _In_ WDFIOTARGET Target, _In_ PWDF_REQUEST_COMPLETION_PARAMS Params, _In_ WDFCONTEXT Context)
VOID	DeviceReleaseQueue (_In_ WDFDEVICE Device)
VOID NTAPI	DeviceReleaseQueueCompletion (_In_ WDFREQUEST Request, _In_ WDFIOTARGET Target, _In_ PWDF_REQUEST_COMPLETION_PARAMS Params, _In_ WDFCONTEXT Context)
VOID	DevicePerfIncrementErrorCount (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension)
VOID NTAPI	DeviceRestoreDefaultSpeed (_In_ WDFWORKITEM WorkItem)
NTSTATUS	RequestSetContextFields (_In_ WDFREQUEST Request, _In_ PSYNC_HANDLER Handler)
NTSTATUS	RequestDuidGetDeviceIdProperty (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestDuidGetDeviceProperty (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
VOID	RequestCompletion (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ NTSTATUS Status, _In_ ULONG_PTR Information)
VOID NTAPI	RequestDummyCompletionRoutine (_In_ WDFREQUEST Request, _In_ WDFIOTARGET Target, _In_ PWDF_REQUEST_COMPLETION_PARAMS Params, _In_ WDFCONTEXT Context)
	_IRQL_requires_max_ (DISPATCH_LEVEL)
NTSTATUS	RequestSend (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDFIOTARGET IoTarget, _In_ ULONG Flags, _Out_opt_ PBOOLEAN RequestSent)

Variables
LPCSTR	LockTypeStrings []

Function Documentation

_IRQL_requires_max_() [1/3]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 383 of file common.c.

{
    NTSTATUS                    status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION     deviceExtension = DeviceGetExtension(Device);
    BOOLEAN                     requestCancelled = FALSE;
    PCDROM_REQUEST_CONTEXT      requestContext = RequestGetContext(Request);
 
    PAGED_CODE();
 
    if (!RequestFormated)
    {
        // set request up for sending down
        WdfRequestFormatRequestUsingCurrentType(Request);
    }
 
    // get cancellation status for the original request
    if (requestContext->OriginalRequest != NULL)
    {
        requestCancelled = WdfRequestIsCanceled(requestContext->OriginalRequest);
    }
 
    if (!requestCancelled)
    {
        status = RequestSend(deviceExtension,
                             Request,
                             deviceExtension->IoTarget,
                             WDF_REQUEST_SEND_OPTION_SYNCHRONOUS,
                             NULL);
    }
    else
    {
        status = STATUS_CANCELLED;
    }
 
    return status;
}

_IRQL_requires_max_() [2/3]

_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Definition at line 3557 of file common.c.

{
    NTSTATUS                    status;
    BOOLEAN                     requestSent = FALSE;
 
    BOOLEAN                     shouldRetry = TRUE;
    PCDB                        cdb = (PCDB)DeviceExtension->PowerContext.Srb.Cdb;
    ULONG                       timeoutValue = DeviceExtension->TimeOutValue;
    ULONG                       retryCount = 1;
 
    // reset some fields.
    DeviceExtension->PowerContext.RetryIntervalIn100ns = 0;
    status = PowerContextReuseRequest(DeviceExtension);
    RequestClearSendTime(DeviceExtension->PowerContext.PowerRequest);
 
    if (!NT_SUCCESS(status))
    {
        return status;
    }
 
    // set proper timeout value and max retry count.
    switch(DeviceExtension->PowerContext.PowerChangeState.PowerDown)
    {
    case PowerDownDeviceInitial:
    case PowerDownDeviceQuiesced:
    case PowerDownDeviceStopped:
        break;
 
    case PowerDownDeviceLocked:
        // Case of issuing SYNC CACHE command. Do not use power irp timeout remaining time in this case
        // as we want to give best try on SYNC CACHE command.
        retryCount = MAXIMUM_RETRIES;
        timeoutValue = DeviceExtension->TimeOutValue;
        break;
 
    case PowerDownDeviceFlushed:
    {
        // Case of issuing STOP UNIT command
        // As "Imme" bit is set to '1', this command should be completed in short time.
        // This command is at low importance, failure of this command has very small impact.
        ULONG secondsRemaining = 0;
 
#if (WINVER >= 0x0601)
        // this API is introduced in Windows7
        PoQueryWatchdogTime(DeviceExtension->LowerPdo, &secondsRemaining);
#endif
 
        if (secondsRemaining == 0)
        {
            // not able to retrieve remaining time from PoQueryWatchdogTime API, use default values.
            retryCount = MAXIMUM_RETRIES;
            timeoutValue = SCSI_CDROM_TIMEOUT;
        }
        else
        {
            // plan to leave about 30 seconds to lower level drivers if possible.
            if (secondsRemaining >= 32)
            {
                retryCount = (secondsRemaining - 30)/SCSI_CDROM_TIMEOUT + 1;
                timeoutValue = SCSI_CDROM_TIMEOUT;
 
                if (retryCount > MAXIMUM_RETRIES)
                {
                    retryCount = MAXIMUM_RETRIES;
                }
 
                if (retryCount == 1)
                {
                    timeoutValue = secondsRemaining - 30;
                }
            }
            else
            {
                // issue the command with minimal timeout value and do not retry on it.
                retryCount = 1;
                timeoutValue = 2;
            }
        }
    }
        break;
    default:
        NT_ASSERT( FALSE );
        status = STATUS_NOT_IMPLEMENTED;
        return status;
    }
 
    DeviceExtension->PowerContext.RetryCount = retryCount;
 
    // issue command.
    while (shouldRetry)
    {
 
        // set SRB fields.
        DeviceExtension->PowerContext.Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
                                                     SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
                                                     SRB_FLAGS_NO_QUEUE_FREEZE |
                                                     SRB_FLAGS_BYPASS_LOCKED_QUEUE |
                                                     SRB_FLAGS_D3_PROCESSING;
 
        DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
        DeviceExtension->PowerContext.Srb.TimeOutValue = timeoutValue;
 
        if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceInitial)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_LOCK_QUEUE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceLocked)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_QUIESCE_DEVICE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
        {
            // Case of issuing SYNC CACHE command.
            DeviceExtension->PowerContext.Srb.CdbLength = 10;
            cdb->SYNCHRONIZE_CACHE10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceFlushed)
        {
            // Case of issuing STOP UNIT command.
            DeviceExtension->PowerContext.Srb.CdbLength = 6;
            cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
            cdb->START_STOP.Start = 0;
            cdb->START_STOP.Immediate = 1;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceStopped)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_UNLOCK_QUEUE;
        }
 
        // Set up completion routine and context if requested
        if (CompletionRoutine)
        {
            WdfRequestSetCompletionRoutine(DeviceExtension->PowerContext.PowerRequest,
                                           CompletionRoutine,
                                           Context);
        }
 
        status = RequestSend(DeviceExtension,
                             DeviceExtension->PowerContext.PowerRequest,
                             DeviceExtension->IoTarget,
                             CompletionRoutine ? 0 : WDF_REQUEST_SEND_OPTION_SYNCHRONOUS,
                             &requestSent);
 
        if (requestSent)
        {
            if ((CompletionRoutine == NULL) &&
                (SRB_STATUS(DeviceExtension->PowerContext.Srb.SrbStatus) != SRB_STATUS_SUCCESS))
            {
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_POWER,
                            "%p\tError occured when issuing %s command to device. Srb %p, Status %x\n",
                            DeviceExtension->PowerContext.PowerRequest,
                            (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced) ? "SYNC CACHE" : "STOP UNIT",
                            &DeviceExtension->PowerContext.Srb,
                            DeviceExtension->PowerContext.Srb.SrbStatus));
 
                NT_ASSERT(!(TEST_FLAG(DeviceExtension->PowerContext.Srb.SrbStatus, SRB_STATUS_QUEUE_FROZEN)));
 
                shouldRetry = RequestSenseInfoInterpret(DeviceExtension,
                                                        DeviceExtension->PowerContext.PowerRequest,
                                                        &(DeviceExtension->PowerContext.Srb),
                                                        retryCount - DeviceExtension->PowerContext.RetryCount,
                                                        &status,
                                                        &(DeviceExtension->PowerContext.RetryIntervalIn100ns));
 
                if (shouldRetry && (DeviceExtension->PowerContext.RetryCount-- == 0))
                {
                    shouldRetry = FALSE;
                }
            }
            else
            {
                // succeeded, do not need to retry.
                shouldRetry = FALSE;
            }
 
        }
        else
        {
            // request failed to be sent
            shouldRetry = FALSE;
        }
 
        if (shouldRetry)
        {
            LARGE_INTEGER t;
            t.QuadPart = -DeviceExtension->PowerContext.RetryIntervalIn100ns;
            KeDelayExecutionThread(KernelMode, FALSE, &t);
 
            status = PowerContextReuseRequest(DeviceExtension);
            if (!NT_SUCCESS(status))
            {
                shouldRetry = FALSE;
            }
        }
    }
 
    if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
    {
        // record SYNC CACHE command completion time stamp.
        KeQueryTickCount(&DeviceExtension->PowerContext.Step1CompleteTime);
    }
 
    return status;
}

_IRQL_requires_max_() [3/3]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 135 of file common.c.

{
    NTSTATUS        status;
    WDFKEY          rootKey = NULL;
    WDFKEY          subKey = NULL;
    UNICODE_STRING  registrySubKeyName;
    UNICODE_STRING  registryValueName;
    ULONG           defaultParameterValue;
 
    PAGED_CODE();
 
    RtlInitUnicodeString(&registryValueName, ParameterName);
 
    if (SubkeyName != NULL)
    {
        RtlInitUnicodeString(&registrySubKeyName, SubkeyName);
    }
 
    // open the hardware key
    status = WdfDeviceOpenRegistryKey(DeviceExtension->Device,
                                      PLUGPLAY_REGKEY_DEVICE,
                                      KEY_READ,
                                      WDF_NO_OBJECT_ATTRIBUTES,
                                      &rootKey);
 
    // open the sub key
    if (NT_SUCCESS(status) && (SubkeyName != NULL))
    {
        status = WdfRegistryOpenKey(rootKey,
                                    &registrySubKeyName,
                                    KEY_READ,
                                    WDF_NO_OBJECT_ATTRIBUTES,
                                    &subKey);
 
        if (!NT_SUCCESS(status))
        {
            WdfRegistryClose(rootKey);
            rootKey = NULL;
        }
    }
 
    if (NT_SUCCESS(status) && (rootKey != NULL))
    {
        defaultParameterValue = *ParameterValue;
 
        status = WdfRegistryQueryULong((subKey != NULL) ? subKey : rootKey,
                                       &registryValueName,
                                       ParameterValue);
 
        if (!NT_SUCCESS(status))
        {
            *ParameterValue = defaultParameterValue; // use default value
        }
    }
 
    // close what we open
    if (subKey != NULL)
    {
        WdfRegistryClose(subKey);
        subKey = NULL;
    }
 
    if (rootKey != NULL)
    {
        WdfRegistryClose(rootKey);
        rootKey = NULL;
    }
 
    // Windows 2000 SP3 uses the driver-specific key, so look in there
    if (!NT_SUCCESS(status))
    {
        // open the software key
        status = WdfDeviceOpenRegistryKey(DeviceExtension->Device,
                                          PLUGPLAY_REGKEY_DRIVER,
                                          KEY_READ,
                                          WDF_NO_OBJECT_ATTRIBUTES,
                                          &rootKey);
 
        // open the sub key
        if (NT_SUCCESS(status) && (SubkeyName != NULL))
        {
            status = WdfRegistryOpenKey(rootKey,
                                        &registrySubKeyName,
                                        KEY_READ,
                                        WDF_NO_OBJECT_ATTRIBUTES,
                                        &subKey);
 
            if (!NT_SUCCESS(status))
            {
                WdfRegistryClose(rootKey);
                rootKey = NULL;
            }
        }
 
        if (NT_SUCCESS(status) && (rootKey != NULL))
        {
            defaultParameterValue = *ParameterValue;
 
            status = WdfRegistryQueryULong((subKey != NULL) ? subKey : rootKey,
                                           &registryValueName,
                                           ParameterValue);
 
            if (!NT_SUCCESS(status))
            {
                *ParameterValue = defaultParameterValue; // use default value
            }
            else
            {
                // Migrate the value over to the device-specific key
                DeviceSetParameter(DeviceExtension, SubkeyName, ParameterName, *ParameterValue);
            }
        }
 
        // close what we open
        if (subKey != NULL)
        {
            WdfRegistryClose(subKey);
            subKey = NULL;
        }
 
        if (rootKey != NULL)
        {
            WdfRegistryClose(rootKey);
            rootKey = NULL;
        }
    }
 
    return;
 
} // end DeviceetParameter()

DeviceAsynchronousCompletion()

VOID NTAPI DeviceAsynchronousCompletion	(	_In_ WDFREQUEST	Request,
		_In_ WDFIOTARGET	Target,
		_In_ PWDF_REQUEST_COMPLETION_PARAMS	Params,
		_In_ WDFCONTEXT	Context
	)

Definition at line 1116 of file common.c.

{
    PCOMPLETION_CONTEXT     context = (PCOMPLETION_CONTEXT)Context;
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(context->Device);
 
    UNREFERENCED_PARAMETER(Target);
    UNREFERENCED_PARAMETER(Params);
 
    // If this is an execute srb, then check the return status and make sure.
    // the queue is not frozen.
    if (context->Srb.Function == SRB_FUNCTION_EXECUTE_SCSI)
    {
        // Check for a frozen queue.
        if (context->Srb.SrbStatus & SRB_STATUS_QUEUE_FROZEN)
        {
            // Unfreeze the queue getting the device object from the context.
            DeviceReleaseQueue(context->Device);
        }
    }
 
    // free port-allocated sense buffer if we can detect
    //
    if (PORT_ALLOCATED_SENSE(deviceExtension, &context->Srb))
    {
        FREE_PORT_ALLOCATED_SENSE_BUFFER(deviceExtension, &context->Srb);
    }
 
    FREE_POOL(context);
 
    WdfObjectDelete(Request);
 
} // end DeviceAsynchronousCompletion()

DevicePerfIncrementErrorCount()

VOID DevicePerfIncrementErrorCount

(

_In_ PCDROM_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 1378 of file common.c.

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

Referenced by SenseInfoInterpretBySrbStatus().

DeviceReleaseQueue()

VOID DeviceReleaseQueue

(

_In_ WDFDEVICE

Device

)

Definition at line 1179 of file common.c.

{
    PCDROM_DEVICE_EXTENSION     deviceExtension = DeviceGetExtension(Device);
    PSCSI_REQUEST_BLOCK         srb = NULL;
    KIRQL                       currentIrql;
 
    // we raise irql seperately so we're not swapped out or suspended
    // while holding the release queue irp in this routine.  this lets
    // us release the spin lock before lowering irql.
    KeRaiseIrql(DISPATCH_LEVEL, &currentIrql);
 
    WdfSpinLockAcquire(deviceExtension->ReleaseQueueSpinLock);
 
    if (deviceExtension->ReleaseQueueInProgress)
    {
        // Someone is already doing this work - just set the flag to indicate that
        // we need to release the queue again.
        deviceExtension->ReleaseQueueNeeded = TRUE;
        WdfSpinLockRelease(deviceExtension->ReleaseQueueSpinLock);
        KeLowerIrql(currentIrql);
 
        return;
    }
 
    // Mark that there is a release queue in progress and drop the spinlock.
    deviceExtension->ReleaseQueueInProgress = TRUE;
 
    WdfSpinLockRelease(deviceExtension->ReleaseQueueSpinLock);
 
    srb = &(deviceExtension->ReleaseQueueSrb);
 
    // Optical media are removable, so we just flush the queue.  This will also release it.
    srb->Function = SRB_FUNCTION_FLUSH_QUEUE;
 
    srb->OriginalRequest = WdfRequestWdmGetIrp(deviceExtension->ReleaseQueueRequest);
 
    // Set a CompletionRoutine callback function.
    WdfRequestSetCompletionRoutine(deviceExtension->ReleaseQueueRequest,
                                   DeviceReleaseQueueCompletion,
                                   Device);
    // Send the request. If an error occurs, complete the request.
    RequestSend(deviceExtension,
                deviceExtension->ReleaseQueueRequest,
                deviceExtension->IoTarget,
                WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE,
                NULL);
 
    KeLowerIrql(currentIrql);
 
    return;
 
} // end DeviceReleaseQueue()

Referenced by DeviceAsynchronousCompletion(), DeviceReleaseQueueCompletion(), and RequestSenseInfoInterpret().

DeviceReleaseQueueCompletion()

VOID NTAPI DeviceReleaseQueueCompletion	(	_In_ WDFREQUEST	Request,
		_In_ WDFIOTARGET	Target,
		_In_ PWDF_REQUEST_COMPLETION_PARAMS	Params,
		_In_ WDFCONTEXT	Context
	)

Definition at line 1257 of file common.c.

{
    NTSTATUS                    status;
    WDFDEVICE                   device = Context;
    PCDROM_DEVICE_EXTENSION     deviceExtension = DeviceGetExtension(device);
 
    BOOLEAN                     releaseQueueNeeded = FALSE;
    WDF_REQUEST_REUSE_PARAMS    params = {0};
 
    UNREFERENCED_PARAMETER(Target);
    UNREFERENCED_PARAMETER(Params);
 
    WDF_REQUEST_REUSE_PARAMS_INIT(&params,
                                  WDF_REQUEST_REUSE_NO_FLAGS,
                                  STATUS_SUCCESS);
 
    // Grab the spinlock and clear the release queue in progress flag so others
    // can run. Save (and clear) the state of the release queue needed flag
    // so that we can issue a new release queue outside the spinlock.
    WdfSpinLockAcquire(deviceExtension->ReleaseQueueSpinLock);
 
    releaseQueueNeeded = deviceExtension->ReleaseQueueNeeded;
 
    deviceExtension->ReleaseQueueNeeded = FALSE;
    deviceExtension->ReleaseQueueInProgress = FALSE;
 
    // Reuse the ReleaseQueueRequest for the next time.
    status = WdfRequestReuse(Request,&params);
 
    if (NT_SUCCESS(status))
    {
        // Preformat the ReleaseQueueRequest for the next time.
        // This should always succeed because it was already preformatted once during device initialization
        status = WdfIoTargetFormatRequestForInternalIoctlOthers(deviceExtension->IoTarget,
                                                                Request,
                                                                IOCTL_SCSI_EXECUTE_NONE,
                                                                deviceExtension->ReleaseQueueInputMemory,
                                                                NULL,
                                                                NULL,
                                                                NULL,
                                                                NULL,
                                                                NULL);
    }
 
    if (!NT_SUCCESS(status))
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                   "DeviceReleaseQueueCompletion: WdfIoTargetFormatRequestForInternalIoctlOthers failed, %!STATUS!\n",
                   status));
    }
 
    RequestClearSendTime(Request);
 
    WdfSpinLockRelease(deviceExtension->ReleaseQueueSpinLock);
 
    // If we need a release queue then issue one now.  Another processor may
    // have already started one in which case we'll try to issue this one after
    // it is done - but we should never recurse more than one deep.
    if (releaseQueueNeeded)
    {
        DeviceReleaseQueue(device);
    }
 
    return;
 
} // DeviceReleaseQueueCompletion()

DeviceRestoreDefaultSpeed()

VOID NTAPI DeviceRestoreDefaultSpeed

(

_In_ WDFWORKITEM

WorkItem

)

Definition at line 2631 of file common.c.

{
    NTSTATUS                status;
    WDFDEVICE               device = WdfWorkItemGetParentObject(WorkItem);
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(device);
    PPERFORMANCE_DESCRIPTOR perfDescriptor;
    ULONG                   transferLength = sizeof(PERFORMANCE_DESCRIPTOR);
    SCSI_REQUEST_BLOCK      srb = {0};
    PCDB                    cdb = (PCDB)srb.Cdb;
 
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL, "DeviceRestoreDefaultSpeed: Restore device speed for %p\n", device));
 
    perfDescriptor = ExAllocatePoolWithTag(NonPagedPoolNxCacheAligned,
                                           transferLength,
                                           CDROM_TAG_STREAM);
    if (perfDescriptor == NULL)
    {
        return;
    }
 
    RtlZeroMemory(perfDescriptor, transferLength);
 
    perfDescriptor->RestoreDefaults = TRUE;
 
    srb.TimeOutValue = deviceExtension->TimeOutValue;
 
    srb.CdbLength = 12;
    cdb->SET_STREAMING.OperationCode = SCSIOP_SET_STREAMING;
    REVERSE_BYTES_SHORT(&cdb->SET_STREAMING.ParameterListLength, &transferLength);
 
    status = DeviceSendSrbSynchronously(device,
                                        &srb,
                                        perfDescriptor,
                                        transferLength,
                                        TRUE,
                                        NULL);
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
               "DeviceRestoreDefaultSpeed: Set Streaming command completed with status: 0x%X\n", status));
 
    FREE_POOL(perfDescriptor);
    WdfObjectDelete(WorkItem);
 
    return;
}

DeviceSendIoctlAsynchronously()

VOID DeviceSendIoctlAsynchronously	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ ULONG	IoControlCode,
		_In_ PDEVICE_OBJECT	TargetDeviceObject
	)

Definition at line 1030 of file common.c.

{
    PIRP                irp = NULL;
    PIO_STACK_LOCATION  nextIrpStack = NULL;
 
    irp = IoAllocateIrp(DeviceExtension->DeviceObject->StackSize, FALSE);
 
    if (irp != NULL)
    {
        nextIrpStack = IoGetNextIrpStackLocation(irp);
 
        nextIrpStack->MajorFunction = IRP_MJ_DEVICE_CONTROL;
 
        nextIrpStack->Parameters.DeviceIoControl.OutputBufferLength = 0;
        nextIrpStack->Parameters.DeviceIoControl.InputBufferLength = 0;
        nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IoControlCode;
        nextIrpStack->Parameters.DeviceIoControl.Type3InputBuffer = NULL;
 
        IoSetCompletionRoutine(irp,
                               RequestAsynchronousIrpCompletion,
                               DeviceExtension,
                               TRUE,
                               TRUE,
                               TRUE);
 
        (VOID) IoCallDriver(TargetDeviceObject, irp);
    }
}

Referenced by DeviceEvtD0Entry().

DeviceSendNotification()

VOID DeviceSendNotification	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ const GUID *	Guid,
		_In_ ULONG	ExtraDataSize,
		_In_opt_ PVOID	ExtraData
	)

Definition at line 799 of file common.c.

{
    PTARGET_DEVICE_CUSTOM_NOTIFICATION  notification;
    ULONG                               requiredSize;
    NTSTATUS                            status;
 
    status = RtlULongAdd((sizeof(TARGET_DEVICE_CUSTOM_NOTIFICATION) - sizeof(UCHAR)),
                         ExtraDataSize,
                         &requiredSize);
 
    if (!(NT_SUCCESS(status)) || (requiredSize > 0x0000ffff))
    {
        // MAX_USHORT, max total size for these events!
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
                   "Error sending event: size too large! (%x)\n",
                   requiredSize));
        return;
    }
 
    notification = ExAllocatePoolWithTag(NonPagedPoolNx,
                                         requiredSize,
                                         CDROM_TAG_NOTIFICATION);
 
    // if none allocated, exit
    if (notification == NULL)
    {
        return;
    }
 
    // Prepare and send the request!
    RtlZeroMemory(notification, requiredSize);
    notification->Version = 1;
    notification->Size = (USHORT)(requiredSize);
    notification->FileObject = NULL;
    notification->NameBufferOffset = -1;
    notification->Event = *Guid;
 
    if (ExtraData != NULL)
    {
        RtlCopyMemory(notification->CustomDataBuffer, ExtraData, ExtraDataSize);
    }
 
    IoReportTargetDeviceChangeAsynchronous(DeviceExtension->LowerPdo,
                                           notification,
                                           NULL,
                                           NULL);
 
    FREE_POOL(notification);
 
    return;
}

Referenced by DeviceInternalSetMediaChangeState(), SenseInfoInterpretByAdditionalSenseCode(), and SenseInfoInterpretForZPODD().

DeviceSendStartUnit()

VOID DeviceSendStartUnit

(

_In_ WDFDEVICE

Device

)

Definition at line 877 of file common.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION deviceExtension = NULL;
    WDF_OBJECT_ATTRIBUTES   attributes;
    WDFREQUEST              startUnitRequest = NULL;
    WDFMEMORY               inputMemory = NULL;
 
    PCOMPLETION_CONTEXT     context = NULL;
    PSCSI_REQUEST_BLOCK     srb = NULL;
    PCDB                    cdb = NULL;
 
    deviceExtension = DeviceGetExtension(Device);
 
    if (NT_SUCCESS(status))
    {
        // Allocate Srb from nonpaged pool.
        context = ExAllocatePoolWithTag(NonPagedPoolNx,
                                        sizeof(COMPLETION_CONTEXT),
                                        CDROM_TAG_COMPLETION_CONTEXT);
 
        if (context == NULL)
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                       "DeviceSendStartUnit: Failed to allocate completion context\n"));
 
            status = STATUS_INTERNAL_ERROR;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        // Save the device object in the context for use by the completion
        // routine.
        context->Device = Device;
        srb = &context->Srb;
 
        // Zero out srb.
        RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));
 
        // setup SRB structure.
        srb->Length = sizeof(SCSI_REQUEST_BLOCK);
        srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
        srb->TimeOutValue = START_UNIT_TIMEOUT;
 
        srb->SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
                        SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
 
        // setup CDB
        srb->CdbLength = 6;
        cdb = (PCDB)srb->Cdb;
 
        cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
        cdb->START_STOP.Start = 1;
        cdb->START_STOP.Immediate = 0;
        cdb->START_STOP.LogicalUnitNumber = srb->Lun;
 
        //Create Request for sending down to port driver
        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
                                                CDROM_REQUEST_CONTEXT);
        attributes.ParentObject = deviceExtension->IoTarget;
 
        status = WdfRequestCreate(&attributes,
                                  deviceExtension->IoTarget,
                                  &startUnitRequest);
    }
 
    if (NT_SUCCESS(status))
    {
        srb->OriginalRequest = WdfRequestWdmGetIrp(startUnitRequest);
        NT_ASSERT(srb->OriginalRequest != NULL);
 
        //Prepare the request
        WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
        attributes.ParentObject = startUnitRequest;
 
        status = WdfMemoryCreatePreallocated(&attributes,
                                             (PVOID)srb,
                                             sizeof(SCSI_REQUEST_BLOCK),
                                             &inputMemory);
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfIoTargetFormatRequestForInternalIoctlOthers(deviceExtension->IoTarget,
                                                                startUnitRequest,
                                                                IOCTL_SCSI_EXECUTE_NONE,
                                                                inputMemory,
                                                                NULL,
                                                                NULL,
                                                                NULL,
                                                                NULL,
                                                                NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        // Set a CompletionRoutine callback function.
        WdfRequestSetCompletionRoutine(startUnitRequest,
                                       DeviceAsynchronousCompletion,
                                       context);
 
        status = RequestSend(deviceExtension,
                             startUnitRequest,
                             deviceExtension->IoTarget,
                             0,
                             NULL);
    }
 
    // release resources when failed.
    if (!NT_SUCCESS(status))
    {
        FREE_POOL(context);
        if (startUnitRequest != NULL)
        {
            WdfObjectDelete(startUnitRequest);
        }
    }
 
    return;
} // end StartUnit()

Referenced by DeviceErrorHandlerForHitachiGD2000(), and SenseInfoInterpretByAdditionalSenseCode().

RequestAsynchronousIrpCompletion()

NTSTATUS NTAPI RequestAsynchronousIrpCompletion	(	_In_ PDEVICE_OBJECT	DeviceObject,
		_In_ PIRP	Irp,
		_In_reads_opt_(_Inexpressible_("varies")) PVOID	Context
	)

Definition at line 1082 of file common.c.

{
    UNREFERENCED_PARAMETER(DeviceObject);
    UNREFERENCED_PARAMETER(Context);
 
    IoFreeIrp(Irp);
 
    return STATUS_MORE_PROCESSING_REQUIRED;
}

RequestClearSendTime()

VOID RequestClearSendTime

(

_In_ WDFREQUEST

Request

)

Definition at line 111 of file common.c.

{
    PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);
 
    requestContext->TimeSentDownFirstTime.QuadPart = 0;
    requestContext->TimeSentDownLasttTime.QuadPart = 0;
 
    return;
}

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

RequestCompletion()

VOID RequestCompletion	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ NTSTATUS	Status,
		_In_ ULONG_PTR	Information
	)

Definition at line 3439 of file common.c.

{
#ifdef DBG
    ULONG                   ioctlCode = 0;
    WDF_REQUEST_PARAMETERS  requestParameters;
 
    // Get the Request parameters
    WDF_REQUEST_PARAMETERS_INIT(&requestParameters);
    WdfRequestGetParameters(Request, &requestParameters);
 
    if (requestParameters.Type == WdfRequestTypeDeviceControl)
    {
        ioctlCode = requestParameters.Parameters.DeviceIoControl.IoControlCode;
 
        if (requestParameters.Parameters.DeviceIoControl.IoControlCode != IOCTL_MCN_SYNC_FAKE_IOCTL)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                       "Request complete - IOCTL - code: %X; Status: %X; Information: %X\n",
                       ioctlCode,
                       Status,
                       (ULONG)Information));
        }
        else
        {
            TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL,
                       "Request complete - IOCTL - code: %X; Status: %X; Information: %X\n",
                       ioctlCode,
                       Status,
                       (ULONG)Information));
        }
    }
    else if (requestParameters.Type == WdfRequestTypeRead)
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                   "Request complete - READ - Starting Offset: %X; Length: %X; Transferred Length: %X; Status: %X\n",
                   (ULONG)requestParameters.Parameters.Read.DeviceOffset,
                   (ULONG)requestParameters.Parameters.Read.Length,
                   (ULONG)Information,
                   Status));
    }
    else if (requestParameters.Type == WdfRequestTypeWrite)
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                   "Request complete - WRITE - Starting Offset: %X; Length: %X; Transferred Length: %X; Status: %X\n",
                   (ULONG)requestParameters.Parameters.Write.DeviceOffset,
                   (ULONG)requestParameters.Parameters.Write.Length,
                   (ULONG)Information,
                   Status));
    }
#endif
 
    if (IoIsErrorUserInduced(Status))
    {
        PIRP irp = WdfRequestWdmGetIrp(Request);
        if (irp->Tail.Overlay.Thread)
        {
            IoSetHardErrorOrVerifyDevice(irp, DeviceExtension->DeviceObject);
        }
    }
 
    if (!NT_SUCCESS(Status) && DeviceExtension->SurpriseRemoved == TRUE)
    {
        // IMAPI expects ERROR_DEV_NOT_EXISTS if recorder has been surprised removed,
        // or it will retry WRITE commands for up to 3 minutes
        // CDROM behavior should be consistent for all requests, including SCSI pass-through
        Status = STATUS_DEVICE_DOES_NOT_EXIST;
    }
 
    WdfRequestCompleteWithInformation(Request, Status, Information);
 
    return;
}

Referenced by CreateQueueEvtIoDefault(), DeviceEvtIoInCallerContext(), ReadWriteWorkItemRoutine(), RequestDispatchProcessDirectly(), RequestDispatchSpecialIoctls(), RequestDispatchSyncWithSequentialQueue(), RequestDispatchToSequentialQueue(), RequestDispatchUnknownRequests(), RequestHandleQueryPropertyDeviceUniqueId(), RequestHandleQueryPropertyWriteCache(), RequestHandleReadWrite(), RequestProcessInternalDeviceControl(), RequestSynchronizeProcessWithSerialQueue(), ScratchBuffer_ReadWriteCompletionRoutine(), ScratchBuffer_ReadWriteEvtRequestCancel(), ScratchBuffer_ReadWriteTimerRoutine(), SequentialQueueEvtCanceledOnQueue(), SequentialQueueEvtIoDeviceControl(), and SequentialQueueEvtIoReadWrite().

RequestDuidGetDeviceIdProperty()

NTSTATUS RequestDuidGetDeviceIdProperty	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 2797 of file common.c.

{
    NTSTATUS                        status = STATUS_SUCCESS;
    PSTORAGE_DEVICE_ID_DESCRIPTOR   deviceIdDescriptor = NULL;
    PSTORAGE_DESCRIPTOR_HEADER      descHeader = NULL;
    STORAGE_PROPERTY_ID             propertyId = StorageDeviceIdProperty;
 
    *DataLength = 0;
 
    // Get the VPD page 83h data.
    status = DeviceRetrieveDescriptor(DeviceExtension->Device,
                                      &propertyId,
                                      (PSTORAGE_DESCRIPTOR_HEADER*)&deviceIdDescriptor);
 
    if (NT_SUCCESS(status) && (deviceIdDescriptor == NULL))
    {
        status = STATUS_NOT_FOUND;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &descHeader,
                                                NULL);
    }
 
    if (NT_SUCCESS(status))
    {
        PSTORAGE_DEVICE_UNIQUE_IDENTIFIER   storageDuid = NULL;
        ULONG                               offset = descHeader->Size;
        PUCHAR                              dest = (PUCHAR)descHeader + offset;
        size_t                              outputBufferSize;
 
        outputBufferSize = RequestParameters.Parameters.DeviceIoControl.OutputBufferLength;
 
        // Adjust required size and potential destination location.
        status = RtlULongAdd(descHeader->Size, deviceIdDescriptor->Size, &descHeader->Size);
 
        if (NT_SUCCESS(status) &&
            (outputBufferSize < descHeader->Size))
        {
            // Output buffer is too small.  Return error and make sure
            // the caller gets info about required buffer size.
            *DataLength = descHeader->Size;
            status = STATUS_BUFFER_OVERFLOW;
        }
 
        if (NT_SUCCESS(status))
        {
            storageDuid = (PSTORAGE_DEVICE_UNIQUE_IDENTIFIER)descHeader;
            storageDuid->StorageDeviceIdOffset = offset;
 
            RtlCopyMemory(dest,
                          deviceIdDescriptor,
                          deviceIdDescriptor->Size);
 
            *DataLength = storageDuid->Size;
            status = STATUS_SUCCESS;
        }
 
        FREE_POOL(deviceIdDescriptor);
    }
 
    return status;
}

Referenced by RequestHandleQueryPropertyDeviceUniqueId().

RequestDuidGetDeviceProperty()

NTSTATUS RequestDuidGetDeviceProperty	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters,
		_Out_ size_t *	DataLength
	)

Definition at line 2888 of file common.c.

{
    NTSTATUS                          status = STATUS_SUCCESS;
    PSTORAGE_DEVICE_DESCRIPTOR        deviceDescriptor = DeviceExtension->DeviceDescriptor;
    PSTORAGE_DESCRIPTOR_HEADER        descHeader = NULL;
    PSTORAGE_DEVICE_UNIQUE_IDENTIFIER storageDuid;
    PUCHAR                            dest = NULL;
 
    if (deviceDescriptor == NULL)
    {
        status = STATUS_NOT_FOUND;
    }
 
    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &descHeader,
                                                NULL);
    }
 
    if (NT_SUCCESS(status) &&
        (deviceDescriptor->SerialNumberOffset == 0))
    {
        status = STATUS_NOT_FOUND;
    }
 
    // Use this info only if serial number is available.
    if (NT_SUCCESS(status))
    {
        ULONG offset = descHeader->Size;
        size_t outputBufferSize = RequestParameters.Parameters.DeviceIoControl.OutputBufferLength;
 
        // Adjust required size and potential destination location.
        dest = (PUCHAR)descHeader + offset;
 
        status = RtlULongAdd(descHeader->Size, deviceDescriptor->Size, &descHeader->Size);
 
        if (NT_SUCCESS(status) &&
            (outputBufferSize < descHeader->Size))
        {
            // Output buffer is too small.  Return error and make sure
            // the caller get info about required buffer size.
            *DataLength = descHeader->Size;
            status = STATUS_BUFFER_OVERFLOW;
        }
 
        if (NT_SUCCESS(status))
        {
            storageDuid = (PSTORAGE_DEVICE_UNIQUE_IDENTIFIER)descHeader;
            storageDuid->StorageDeviceOffset = offset;
 
            RtlCopyMemory(dest,
                          deviceDescriptor,
                          deviceDescriptor->Size);
 
            *DataLength = storageDuid->Size;
            status = STATUS_SUCCESS;
        }
    }
 
    return status;
}

Referenced by RequestHandleQueryPropertyDeviceUniqueId().

RequestDummyCompletionRoutine()

VOID NTAPI RequestDummyCompletionRoutine	(	_In_ WDFREQUEST	Request,
		_In_ WDFIOTARGET	Target,
		_In_ PWDF_REQUEST_COMPLETION_PARAMS	Params,
		_In_ WDFCONTEXT	Context
	)

Definition at line 3520 of file common.c.

{
    UNREFERENCED_PARAMETER(Target);
    UNREFERENCED_PARAMETER(Params);
    UNREFERENCED_PARAMETER(Context);
 
    WdfRequestCompleteWithInformation(Request,
                                      WdfRequestGetStatus(Request),
                                      WdfRequestGetInformation(Request));
}

RequestSend()

NTSTATUS RequestSend	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ WDFREQUEST	Request,
		_In_ WDFIOTARGET	IoTarget,
		_In_ ULONG	Flags,
		_Out_opt_ PBOOLEAN	RequestSent
	)

Definition at line 3793 of file common.c.

{
    NTSTATUS                 status  = STATUS_SUCCESS;
    BOOLEAN                  requestSent = FALSE;
    WDF_REQUEST_SEND_OPTIONS options;
 
    UNREFERENCED_PARAMETER(DeviceExtension);
 
    if ((DeviceExtension->ZeroPowerODDInfo != NULL) &&
        (DeviceExtension->ZeroPowerODDInfo->InZeroPowerState != FALSE))
    {
    }
 
    // Now send down the request
    if (NT_SUCCESS(status))
    {
        WDF_REQUEST_SEND_OPTIONS_INIT(&options, Flags);
 
        RequestSetSentTime(Request);
 
        // send request and check status
 
        // Disable SDV warning about infinitely waiting in caller's context:
        //   1. Some requests (such as SCSI_PASS_THROUGH, contains buffer from user space) need to be sent down in caller’s context.
        //      Consequently, these requests wait in caller’s context until they are allowed to be sent down.
        //   2. Considering the situation that during sleep, a request can be hold by storage port driver. When system resumes, any time out value (if we set using KMDF time out value) might be expires.
        //      This will cause the waiting request being failed (behavior change). We’d rather not set time out value.
 
        _Analysis_assume_(options.Timeout != 0);
        requestSent = WdfRequestSend(Request, IoTarget, &options);
        _Analysis_assume_(options.Timeout == 0);
 
        // If WdfRequestSend fails, or if the WDF_REQUEST_SEND_OPTION_SYNCHRONOUS flag is set,
        // the driver can call WdfRequestGetStatus immediately after calling WdfRequestSend.
        if ((requestSent == FALSE) ||
            (Flags & WDF_REQUEST_SEND_OPTION_SYNCHRONOUS))
        {
            status = WdfRequestGetStatus(Request);
 
            if (requestSent == FALSE)
            {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                            "WdfRequestSend failed: %lx\n",
                            status
                            ));
            }
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        if (RequestSent != NULL)
        {
            *RequestSent = requestSent;
        }
    }
 
    return status;
}

Referenced by _IRQL_requires_max_(), DeviceReleaseQueue(), DeviceSendStartUnit(), RequestProcessInternalDeviceControl(), and ScratchBuffer_SendSrb().

RequestSetContextFields()

NTSTATUS RequestSetContextFields	(	_In_ WDFREQUEST	Request,
		_In_ PSYNC_HANDLER	Handler
	)

Definition at line 2748 of file common.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_REQUEST_CONTEXT  requestContext = RequestGetContext(Request);
    PKEVENT                 syncEvent = NULL;
 
    syncEvent = ExAllocatePoolWithTag(NonPagedPoolNx,
                                      sizeof(KEVENT),
                                      CDROM_TAG_SYNC_EVENT);
 
    if (syncEvent == NULL)
    {
        // memory allocation failed.
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else
    {
        // now, put the special synchronization information into the context
        requestContext->SyncRequired = TRUE;
        requestContext->SyncEvent = syncEvent;
        requestContext->SyncCallback = Handler;
 
        status = STATUS_SUCCESS;
    }
 
    return status;
}

Referenced by RequestDispatchSpecialIoctls(), RequestDispatchSyncWithSequentialQueue(), and RequestDispatchUnknownRequests().

RequestSetReceivedTime()

VOID RequestSetReceivedTime

(

_In_ WDFREQUEST

Request

)

Definition at line 64 of file common.c.

{
    PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);
    LARGE_INTEGER          temp;
 
    KeQueryTickCount(&temp);
 
    requestContext->TimeReceived = temp;
 
    return;
}

Referenced by DeviceEvtIoInCallerContext().

RequestSetSentTime()

VOID RequestSetSentTime

(

_In_ WDFREQUEST

Request

)

Definition at line 79 of file common.c.

{
    PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);
    LARGE_INTEGER          temp;
 
    KeQueryTickCount(&temp);
 
    if (requestContext->TimeSentDownFirstTime.QuadPart == 0)
    {
        requestContext->TimeSentDownFirstTime = temp;
    }
 
    requestContext->TimeSentDownLasttTime = temp;
 
    if (requestContext->OriginalRequest != NULL)
    {
        PCDROM_REQUEST_CONTEXT originalRequestContext = RequestGetContext(requestContext->OriginalRequest);
 
        if (originalRequestContext->TimeSentDownFirstTime.QuadPart == 0)
        {
            originalRequestContext->TimeSentDownFirstTime = temp;
        }
 
        originalRequestContext->TimeSentDownLasttTime = temp;
    }
 
    return;
}

Referenced by RequestSend().

Variable Documentation

LockTypeStrings

LPCSTR LockTypeStrings[]

Initial value:

= {"Simple",
                            "Secure",
                            "Internal"
                            }

Definition at line 58 of file common.c.