cdrom.c File Reference

#include "ntddk.h"
#include "ntstrsafe.h"
#include "ntddstor.h"
#include "ntddtape.h"
#include "wdfcore.h"
#include "devpkey.h"
#include "cdrom.h"
#include "ioctl.h"
#include "mmc.h"
#include "scratch.h"

Include dependency graph for cdrom.c:

Go to the source code of this file.

Macros
#define	DEBUG_MAIN_SOURCE   1

Functions
BOOLEAN	BootEnvironmentIsWinPE (VOID)
NTSTATUS NTAPI	DriverEntry (_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath)
VOID NTAPI	DriverEvtCleanup (_In_ WDFOBJECT Driver)
NTSTATUS NTAPI	DriverEvtDeviceAdd (_In_ WDFDRIVER Driver, _Inout_ PWDFDEVICE_INIT DeviceInit)
VOID NTAPI	DeviceEvtCleanup (_In_ WDFOBJECT Device)
VOID NTAPI	DeviceEvtSelfManagedIoCleanup (_In_ WDFDEVICE Device)
NTSTATUS NTAPI	DeviceEvtD0Entry (_In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE PreviousState)
NTSTATUS NTAPI	DeviceEvtD0Exit (_In_ WDFDEVICE Device, _In_ WDF_POWER_DEVICE_STATE TargetState)
VOID NTAPI	DeviceEvtSurpriseRemoval (_In_ WDFDEVICE Device)
VOID NTAPI	CreateQueueEvtIoDefault (_In_ WDFQUEUE Queue, _In_ WDFREQUEST Request)
VOID NTAPI	DeviceEvtFileClose (_In_ WDFFILEOBJECT FileObject)
	_IRQL_requires_max_ (PASSIVE_LEVEL)
	_IRQL_requires_max_ (APC_LEVEL)
VOID	NormalizeIoctl (_Inout_ PWDF_REQUEST_PARAMETERS requestParameters)
VOID NTAPI	DeviceEvtIoInCallerContext (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)
BOOLEAN	RequestDispatchProcessDirectly (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
BOOLEAN	RequestDispatchToSequentialQueue (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
BOOLEAN	RequestDispatchSyncWithSequentialQueue (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
BOOLEAN	RequestDispatchSpecialIoctls (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
BOOLEAN	RequestDispatchUnknownRequests (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters)
VOID	RequestProcessInternalDeviceControl (_In_ WDFREQUEST Request, _In_ PCDROM_DEVICE_EXTENSION DeviceExtension)
VOID NTAPI	SequentialQueueEvtIoReadWrite (_In_ WDFQUEUE Queue, _In_ WDFREQUEST Request, _In_ size_t Length)
VOID NTAPI	ReadWriteWorkItemRoutine (_In_ WDFWORKITEM WorkItem)
VOID NTAPI	SequentialQueueEvtIoDeviceControl (_In_ WDFQUEUE Queue, _In_ WDFREQUEST Request, _In_ size_t OutputBufferLength, _In_ size_t InputBufferLength, _In_ ULONG IoControlCode)
VOID NTAPI	IoctlWorkItemRoutine (_In_ WDFWORKITEM WorkItem)
VOID NTAPI	SequentialQueueEvtCanceledOnQueue (_In_ WDFQUEUE Queue, _In_ WDFREQUEST Request)
NTSTATUS	RequestSynchronizeProcessWithSerialQueue (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)
NTSTATUS	RequestIsIoctlBlockedByExclusiveAccess (_In_ WDFREQUEST Request, _Out_ PBOOLEAN IsBlocked)
BOOLEAN	DeviceIsMmcUpdateRequired (_In_ WDFDEVICE Device)
VOID NTAPI	RequestEvtCleanup (_In_ WDFOBJECT Request)

Macro Definition Documentation

DEBUG_MAIN_SOURCE

#define DEBUG_MAIN_SOURCE   1

Definition at line 26 of file cdrom.c.

Function Documentation

_IRQL_requires_max_() [1/2]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 1473 of file cdrom.c.

{
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_INIT,
                "CleanupDisableMcn called for WDFDEVICE %p, WDFFILEOBJECT %p, locked %d times.\n",
                DeviceExtension->Device, FileObjectContext->FileObject, FileObjectContext->McnDisableCount));
 
    // For each secure lock on this handle decrement the secured lock count
    // for the FDO.  Keep track of the new value.
    while (FileObjectContext->McnDisableCount != 0)
    {
        DeviceEnableMediaChangeDetection(DeviceExtension, FileObjectContext, TRUE);
    }
 
    return STATUS_SUCCESS;
}

_IRQL_requires_max_() [2/2]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 1389 of file cdrom.c.

{
    NTSTATUS    status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "CleanupProtectedLocks called for WDFDEVICE %p, WDFFILEOBJECT %p, locked %d times.\n",
                DeviceExtension->Device, FileObjectContext->FileObject, FileObjectContext->LockCount));
 
    // Synchronize with ejection and ejection control requests.
    WdfWaitLockAcquire(DeviceExtension->EjectSynchronizationLock, NULL);
 
    // For each secure lock on this handle decrement the secured lock count
    // for the FDO.  Keep track of the new value.
    if (FileObjectContext->LockCount != 0)
    {
        DeviceExtension->ProtectedLockCount -= FileObjectContext->LockCount;
        FileObjectContext->LockCount = 0;
 
        // If the new lock count has been dropped to zero then issue a lock
        // command to the device.
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                    "FDO secured lock count = %d "
                    "lock count = %d\n",
                    DeviceExtension->ProtectedLockCount,
                    DeviceExtension->LockCount));
 
        if ((DeviceExtension->ProtectedLockCount == 0) && (DeviceExtension->LockCount == 0))
        {
            SCSI_REQUEST_BLOCK  srb = {0};
            PCDB                cdb = (PCDB) &(srb.Cdb);
 
            srb.CdbLength = 6;
 
            cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;
 
            // TRUE - prevent media removal.
            // FALSE - allow media removal.
            cdb->MEDIA_REMOVAL.Prevent = FALSE;
 
            // Set timeout value.
            srb.TimeOutValue = DeviceExtension->TimeOutValue;
            status = DeviceSendSrbSynchronously(DeviceExtension->Device,
                                                &srb,
                                                NULL,
                                                0,
                                                FALSE,
                                                NULL);
 
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "Allow media removal (unlock) request to drive returned %!STATUS!\n",
                        status));
        }
    }
 
    WdfWaitLockRelease(DeviceExtension->EjectSynchronizationLock);
 
    return status;
}

BootEnvironmentIsWinPE()

BOOLEAN BootEnvironmentIsWinPE

(

VOID

)

Definition at line 158 of file cdrom.c.

{
    NTSTATUS    status;
    WDFKEY      registryKey = NULL;
 
    DECLARE_CONST_UNICODE_STRING(registryKeyName, WINPE_REG_KEY_NAME);
 
    PAGED_CODE();
 
    status = WdfRegistryOpenKey(NULL,
                                &registryKeyName,
                                KEY_READ,
                                WDF_NO_OBJECT_ATTRIBUTES,
                                &registryKey);
 
    if (!NT_SUCCESS(status))
    {
        return FALSE;
    }
 
    WdfRegistryClose(registryKey);
    return TRUE;
} // end BootEnvironmentIsWinPE()

Referenced by DriverEntry().

CreateQueueEvtIoDefault()

VOID NTAPI CreateQueueEvtIoDefault	(	_In_ WDFQUEUE	Queue,
		_In_ WDFREQUEST	Request
	)

Definition at line 1266 of file cdrom.c.

{
    WDFFILEOBJECT           fileObject = WdfRequestGetFileObject(Request);
    WDFDEVICE               device = WdfIoQueueGetDevice(Queue);
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(device);
    PFILE_OBJECT_CONTEXT    fileObjectContext = NULL;
 
    PAGED_CODE();
 
    if (fileObject == NULL) {
 
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_QUEUE,
                    "Error: received a file create request with file object set to NULL\n"));
 
        RequestCompletion(deviceExtension, Request, STATUS_INTERNAL_ERROR, 0);
        return;
    }
 
    fileObjectContext = FileObjectGetContext(fileObject);
 
    // Initialize this WDFFILEOBJECT's context
    fileObjectContext->DeviceObject = device;
    fileObjectContext->FileObject = fileObject;
    fileObjectContext->LockCount = 0;
    fileObjectContext->McnDisableCount = 0;
    fileObjectContext->EnforceStreamingRead = FALSE;
    fileObjectContext->EnforceStreamingWrite = FALSE;
 
    // send down the create synchronously
    status = DeviceSendRequestSynchronously(device, Request, FALSE);
 
    // Need to complete the request in this routine.
    RequestCompletion(deviceExtension, Request, status, WdfRequestGetInformation(Request));
 
    return;
}

DeviceEvtCleanup()

VOID NTAPI DeviceEvtCleanup

(

_In_ WDFOBJECT

Device

)

Definition at line 856 of file cdrom.c.

{
    WDFDEVICE                device = (WDFDEVICE)Device;
    PCDROM_DEVICE_EXTENSION  deviceExtension = NULL;
 
    PAGED_CODE ();
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "WDFDEVICE %p cleanup: The device is about to be destroyed.\n",
                device));
 
    deviceExtension = DeviceGetExtension(device);
 
    FREE_POOL(deviceExtension->DeviceName.Buffer);
    RtlInitUnicodeString(&deviceExtension->DeviceName, NULL);
 
    if (deviceExtension->DeviceAdditionalData.WellKnownName.Buffer != NULL)
    {
        IoDeleteSymbolicLink(&deviceExtension->DeviceAdditionalData.WellKnownName);
    }
 
    FREE_POOL(deviceExtension->DeviceAdditionalData.WellKnownName.Buffer);
    RtlInitUnicodeString(&deviceExtension->DeviceAdditionalData.WellKnownName, NULL);
 
    return;
}

DeviceEvtD0Entry()

NTSTATUS NTAPI DeviceEvtD0Entry	(	_In_ WDFDEVICE	Device,
		_In_ WDF_POWER_DEVICE_STATE	PreviousState
	)

Definition at line 993 of file cdrom.c.

{
    PCDROM_DEVICE_EXTENSION     deviceExtension;
    NTSTATUS                    status = STATUS_SUCCESS;
    PZERO_POWER_ODD_INFO        zpoddInfo = NULL;
    STORAGE_IDLE_POWERUP_REASON powerupReason = {0};
 
    UNREFERENCED_PARAMETER(PreviousState);
    deviceExtension = DeviceGetExtension(Device);
 
    // Make certain not to do anything before properly initialized
    if (deviceExtension->IsInitialized)
    {
        zpoddInfo = deviceExtension->ZeroPowerODDInfo;
 
        if (zpoddInfo != NULL)
        {
            if (zpoddInfo->InZeroPowerState != FALSE)
            {
                // We just woke up from Zero Power state
                zpoddInfo->InZeroPowerState = FALSE;
                zpoddInfo->RetryFirstCommand = TRUE;
                zpoddInfo->BecomingReadyRetryCount = BECOMING_READY_RETRY_COUNT;
 
                status = DeviceZPODDGetPowerupReason(deviceExtension, &powerupReason);
 
                if (NT_SUCCESS(status) &&
                    (powerupReason.PowerupReason == StoragePowerupDeviceAttention))
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                                "DeviceEvtD0Entry: Device has left zero power state due to eject button pressed\n"
                                ));
 
                    // This wake-up is caused by user pressing the eject button.
                    // In case of drawer type, we need to soft eject the tray to emulate the effect.
                    // Note that the first command to the device after power resumed will
                    // be terminated with CHECK CONDITION status with sense code 6/29/00,
                    // but we already have a retry logic to handle this.
                    if ((zpoddInfo->LoadingMechanism == LOADING_MECHANISM_TRAY) && (zpoddInfo->Load == 0))    // Drawer
                    {
                        DeviceSendIoctlAsynchronously(deviceExtension, IOCTL_STORAGE_EJECT_MEDIA, deviceExtension->DeviceObject);
                    }
                }
                else
                {
                    // This wake-up is caused by non-cached CDB received or a 3rd-party driver
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                                "DeviceEvtD0Entry: Device has left zero power state due to IO received\n"
                                ));
 
                }
            }
        }
 
        DeviceEnableMainTimer(deviceExtension);
    }
 
    return STATUS_SUCCESS;
}

DeviceEvtD0Exit()

NTSTATUS NTAPI DeviceEvtD0Exit	(	_In_ WDFDEVICE	Device,
		_In_ WDF_POWER_DEVICE_STATE	TargetState
	)

Definition at line 1075 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION deviceExtension = NULL;
    PZERO_POWER_ODD_INFO    zpoddInfo = NULL;
 
    PAGED_CODE ();
 
    deviceExtension = DeviceGetExtension(Device);
    zpoddInfo = deviceExtension->ZeroPowerODDInfo;
 
    // we only process the situation that the device is going into D3.
    if ((TargetState != WdfPowerDeviceD3) &&
        (TargetState != WdfPowerDeviceD3Final))
    {
        return STATUS_SUCCESS;
    }
 
    // Stop the main timer
    DeviceDisableMainTimer(deviceExtension);
 
    // note: do not stop CreateQueue as the create request can be handled by port driver even the device is in D3 status.
 
    // If initialization was not finished or the device was removed, we cannot interact
    // with it device, so we have to exit
    if ((!deviceExtension->IsInitialized) || deviceExtension->SurpriseRemoved)
    {
        return STATUS_SUCCESS;
    }
 
 
#ifdef DBG
    #if (WINVER >= 0x0601)
    // this API is introduced in Windows7
    {
        ULONG   secondsRemaining = 0;
        BOOLEAN watchdogTimeSupported = FALSE;
 
        watchdogTimeSupported = PoQueryWatchdogTime(deviceExtension->LowerPdo, &secondsRemaining);
        UNREFERENCED_PARAMETER(watchdogTimeSupported);
    }
    #endif
#endif
 
    deviceExtension->PowerDownInProgress = TRUE;
 
    status = PowerContextBeginUse(deviceExtension);
 
    deviceExtension->PowerContext.Options.PowerDown = TRUE;
 
    // Step 1. LOCK QUEUE
    if (NT_SUCCESS(status) &&
        (TargetState != WdfPowerDeviceD3Final))
    {
        status = DeviceSendPowerDownProcessRequest(deviceExtension, NULL, NULL);
 
        if (NT_SUCCESS(status))
        {
            deviceExtension->PowerContext.Options.LockQueue = TRUE;
        }
 
        // Ignore failure.
        status = STATUS_SUCCESS;
    }
 
    deviceExtension->PowerContext.PowerChangeState.PowerDown++;
 
    // Step 2. QUIESCE QUEUE
    if (NT_SUCCESS(status) &&
        (TargetState != WdfPowerDeviceD3Final))
    {
        status = DeviceSendPowerDownProcessRequest(deviceExtension, NULL, NULL);
        UNREFERENCED_PARAMETER(status);
        // We don't care about the status.
        status = STATUS_SUCCESS;
    }
 
    deviceExtension->PowerContext.PowerChangeState.PowerDown++;
 
    // Step 3. SYNC CACHE command should be sent to drive if the media is currently writable.
    if (NT_SUCCESS(status) &&
        deviceExtension->DeviceAdditionalData.Mmc.WriteAllowed)
    {
        status = DeviceSendPowerDownProcessRequest(deviceExtension, NULL, NULL);
        UNREFERENCED_PARAMETER(status);
        status = STATUS_SUCCESS;
    }
 
    deviceExtension->PowerContext.PowerChangeState.PowerDown++;
 
    // Step 4. STOP UNIT
    if (NT_SUCCESS(status) &&
        !TEST_FLAG(deviceExtension->ScanForSpecialFlags, CDROM_SPECIAL_DISABLE_SPIN_DOWN))
    {
        status = DeviceSendPowerDownProcessRequest(deviceExtension, NULL, NULL);
        UNREFERENCED_PARAMETER(status);
        status = STATUS_SUCCESS;
    }
 
    if (TargetState == WdfPowerDeviceD3Final)
    {
        // We're done with the power context.
        PowerContextEndUse(deviceExtension);
    }
 
    // Bumping the media  change count  will force the file system to verify the volume when we resume
    SET_FLAG(deviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME);
    InterlockedIncrement((PLONG)&deviceExtension->MediaChangeCount);
 
    // If this power down is caused by Zero Power ODD, we should mark the device as in ZPODD mode.
    if (zpoddInfo != NULL)
    {
        zpoddInfo->InZeroPowerState = TRUE;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_POWER,
                    "Device has entered zero power state\n"
                    ));
    }
 
    deviceExtension->PowerDownInProgress = FALSE;
 
    return STATUS_SUCCESS;
}

DeviceEvtFileClose()

VOID NTAPI DeviceEvtFileClose

(

_In_ WDFFILEOBJECT

FileObject

)

Definition at line 1327 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
 
    PAGED_CODE();
 
    if (FileObject != NULL)
    {
        WDFDEVICE               device = WdfFileObjectGetDevice(FileObject);
        PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(device);
        PCDROM_DATA             cdData = &(deviceExtension->DeviceAdditionalData);
        PFILE_OBJECT_CONTEXT    fileObjectContext = FileObjectGetContext(FileObject);
 
        // cleanup locked media tray
        status = DeviceCleanupProtectedLocks(deviceExtension, fileObjectContext);
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "Failed to cleanup protected locks for WDFDEVICE %p, %!STATUS!\n", device, status));
        }
 
        // cleanup disabled MCN
        status = DeviceCleanupDisableMcn(deviceExtension, fileObjectContext);
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                        "Failed to disable MCN for WDFDEVICE %p, %!STATUS!\n", device, status));
        }
 
        // cleanup exclusive access
        if (EXCLUSIVE_MODE(cdData) && EXCLUSIVE_OWNER(cdData, FileObject))
        {
            status = DeviceUnlockExclusive(deviceExtension, FileObject, FALSE);
            if (!NT_SUCCESS(status))
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                            "Failed to release exclusive lock for WDFDEVICE %p, %!STATUS!\n", device, status));
            }
        }
    }
 
    return;
}

DeviceEvtIoInCallerContext()

VOID NTAPI DeviceEvtIoInCallerContext	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request
	)

Definition at line 1554 of file cdrom.c.

{
    NTSTATUS                status  = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    PCDROM_REQUEST_CONTEXT  requestContext = RequestGetContext(Request);
    WDF_REQUEST_PARAMETERS  requestParameters;
 
    requestContext->DeviceExtension = deviceExtension;
 
    // set the received time
    RequestSetReceivedTime(Request);
 
    // get the request parameters
    WDF_REQUEST_PARAMETERS_INIT(&requestParameters);
    WdfRequestGetParameters(Request, &requestParameters);
 
    if (requestParameters.Type == WdfRequestTypeDeviceControl)
    {
        BOOLEAN                         processed = FALSE;
        PCDROM_DATA                     cdData = &(deviceExtension->DeviceAdditionalData);
        PMEDIA_CHANGE_DETECTION_INFO    info = deviceExtension->MediaChangeDetectionInfo;
 
        if (requestParameters.Parameters.DeviceIoControl.IoControlCode != IOCTL_MCN_SYNC_FAKE_IOCTL)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                        "Receiving IOCTL: %lx\n",
                        requestParameters.Parameters.DeviceIoControl.IoControlCode));
        }
        else
        {
            TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL,
                        "Receiving IOCTL: %lx\n",
                        requestParameters.Parameters.DeviceIoControl.IoControlCode));
        }
 
        // If the device is in exclusive mode, check whether the request is from
        // the handle that locked the device.
        if (EXCLUSIVE_MODE(cdData) && !EXCLUSIVE_OWNER(cdData, WdfRequestGetFileObject(Request)))
        {
            BOOLEAN isBlocked = FALSE;
 
            status = RequestIsIoctlBlockedByExclusiveAccess(Request, &isBlocked);
            UNREFERENCED_PARAMETER(status); //defensive coding, avoid PREFAST warning.
 
            if (isBlocked)
            {
                if ((requestParameters.Parameters.DeviceIoControl.IoControlCode == IOCTL_STORAGE_EVENT_NOTIFICATION) &&
                    (info != NULL) && (info->AsynchronousNotificationSupported != FALSE))
                {
                    // If AN is supported and we receive a signal but we can't send down GESN
                    // due to exclusive lock, we should save it and fire a GESN when it's unlocked.
                    // We just need true/false here and don't need count because we will keep sending
                    // GESN until we deplete all events.
                    info->ANSignalPendingDueToExclusiveLock = TRUE;
                }
 
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                            "Access Denied! Device in exclusive mode.Failing Ioctl %lx\n",
                            requestParameters.Parameters.DeviceIoControl.IoControlCode));
                RequestCompletion(deviceExtension, Request, STATUS_ACCESS_DENIED, 0);
 
                return;
            }
        }
 
        NormalizeIoctl(&requestParameters);
 
        // 1. All requests that don't need to access device can be processed immediately
        if (!processed)
        {
            processed = RequestDispatchProcessDirectly(Device, Request, requestParameters);
        }
 
        // 2. Requests that should be put in sequential queue.
        if (!processed)
        {
            processed = RequestDispatchToSequentialQueue(Device, Request, requestParameters);
        }
 
        // 3. Requests that need to be processed sequentially and in caller's context.
        if (!processed)
        {
            processed = RequestDispatchSyncWithSequentialQueue(Device, Request, requestParameters);
        }
 
        // 4. Special requests that needs different process in different cases.
        if (!processed)
        {
            processed = RequestDispatchSpecialIoctls(Device, Request, requestParameters);
        }
 
        // 5. This is default behavior for unknown IOCTLs. To pass it to lower level.
        if (!processed)
        {
            processed = RequestDispatchUnknownRequests(Device, Request, requestParameters);
        }
 
        // All requests should be processed already.
        NT_ASSERT(processed);
        UNREFERENCED_PARAMETER(processed); //defensive coding, avoid PREFAST warning.
    }
    else if (requestParameters.Type == WdfRequestTypeDeviceControlInternal)
    {
        RequestProcessInternalDeviceControl(Request, deviceExtension);
    }
    else
    {
        // Requests other than IOCTLs will be forwarded to default queue.
        status = WdfDeviceEnqueueRequest(Device, Request);
        if (!NT_SUCCESS(status))
        {
            RequestCompletion(deviceExtension, Request, status, WdfRequestGetInformation(Request));
        }
    }
 
    return;
}

DeviceEvtSelfManagedIoCleanup()

VOID NTAPI DeviceEvtSelfManagedIoCleanup

(

_In_ WDFDEVICE

Device

)

Definition at line 902 of file cdrom.c.

{
    NTSTATUS                status;
    PCDROM_DEVICE_EXTENSION deviceExtension = NULL;
 
    PAGED_CODE ();
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_PNP,
                "DeviceEvtSelfManagedIoCleanup: WDFDEVICE %p is being stopped.\n",
                Device));
 
    // extract the device and driver extensions
    deviceExtension = DeviceGetExtension(Device);
 
    // Purge unprocessed requests, stop the IO queues.
    // Incoming request will be completed with STATUS_INVALID_DEVICE_STATE status.
    WdfIoQueuePurge(deviceExtension->SerialIOQueue, WDF_NO_EVENT_CALLBACK, WDF_NO_CONTEXT);
    WdfIoQueuePurge(deviceExtension->CreateQueue, WDF_NO_EVENT_CALLBACK, WDF_NO_CONTEXT);
 
    // Close the IoTarget so that we are sure there are no outstanding I/Os in the stack.
    if (deviceExtension->IoTarget)
    {
        WdfIoTargetClose(deviceExtension->IoTarget);
    }
 
    // Release the device
    if (!deviceExtension->SurpriseRemoved)
    {
        status = DeviceClaimRelease(deviceExtension, TRUE);  //status is mainly for debugging. we don't really care.
        UNREFERENCED_PARAMETER(status);             //defensive coding, avoid PREFAST warning.
    }
 
    // Be sure to flush the DPCs as the READ/WRITE timer routine may still be running
    // during device removal.  This call may take a while to complete.
    KeFlushQueuedDpcs();
 
    // Release all the memory that we have allocated.
 
    DeviceDeallocateMmcResources(Device);
    ScratchBuffer_Deallocate(deviceExtension);
    RtlZeroMemory(&(deviceExtension->DeviceAdditionalData.Mmc), sizeof(CDROM_MMC_EXTENSION));
 
    FREE_POOL(deviceExtension->DeviceDescriptor);
    FREE_POOL(deviceExtension->AdapterDescriptor);
    FREE_POOL(deviceExtension->PowerDescriptor);
    FREE_POOL(deviceExtension->SenseData);
 
    if (deviceExtension->DeviceAdditionalData.CachedInquiryData != NULL)
    {
        FREE_POOL(deviceExtension->DeviceAdditionalData.CachedInquiryData);
        deviceExtension->DeviceAdditionalData.CachedInquiryDataByteCount = 0;
    }
 
    FREE_POOL(deviceExtension->PrivateFdoData);
 
    DeviceReleaseMcnResources(deviceExtension);
 
    DeviceReleaseZPODDResources(deviceExtension);
 
    // Keep the system-wide CDROM count accurate, as programs use this info to
    // know when they have found all the cdroms in a system.
    IoGetConfigurationInformation()->CdRomCount--;
 
    deviceExtension->PartitionLength.QuadPart = 0;
 
    // All WDF objects related to Device will be automatically released
    // when the root object is deleted. No need to release them manually.
 
    return;
}

DeviceEvtSurpriseRemoval()

VOID NTAPI DeviceEvtSurpriseRemoval

(

_In_ WDFDEVICE

Device

)

Definition at line 1223 of file cdrom.c.

{
    PCDROM_DEVICE_EXTENSION deviceExtension = NULL;
 
    PAGED_CODE();
 
    deviceExtension = DeviceGetExtension(Device);
 
    deviceExtension->SurpriseRemoved = TRUE;
 
    // Stop the main timer
    DeviceDisableMainTimer(deviceExtension);
 
    // legacy behavior to set partition length to be 0.
    deviceExtension->PartitionLength.QuadPart = 0;
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "Surprisely remove a WDFDEVICE %p\n", Device));
 
    return;
}

DeviceIsMmcUpdateRequired()

BOOLEAN DeviceIsMmcUpdateRequired

(

_In_ WDFDEVICE

Device

)

Definition at line 4180 of file cdrom.c.

{
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    PCDROM_DATA             cdData = &(deviceExtension->DeviceAdditionalData);
 
    if ((cdData->Mmc.IsMmc) &&
        (cdData->Mmc.UpdateState == CdromMmcUpdateRequired))
    {
        return TRUE;
    }
    else
    {
        // no update required: just proceed
        return FALSE;
    }
}

Referenced by IoctlWorkItemRoutine(), ReadWriteWorkItemRoutine(), and SequentialQueueEvtIoReadWrite().

DriverEntry()

NTSTATUS NTAPI DriverEntry	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_ PUNICODE_STRING	RegistryPath
	)

Definition at line 75 of file cdrom.c.

{
    NTSTATUS                status;
    WDF_DRIVER_CONFIG       config;
    WDF_OBJECT_ATTRIBUTES   attributes;
    WDFDRIVER               driverObject = NULL;
 
    PAGED_CODE();
 
    // Initialize WPP Tracing
    WPP_INIT_TRACING(DriverObject, RegistryPath);
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "CDROM.SYS DriverObject %p loading\n",
                DriverObject));
 
    // Register DeviceAdd and DriverEvtCleanup callback.
    // WPP_CLEANUP will be called in DriverEvtCleanup
    WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, CDROM_DRIVER_EXTENSION);
    attributes.EvtCleanupCallback = DriverEvtCleanup;
 
    WDF_DRIVER_CONFIG_INIT(&config, DriverEvtDeviceAdd);
 
    status = WdfDriverCreate(DriverObject,
                             RegistryPath,
                             &attributes,
                             &config,
                             &driverObject);
 
    if (!NT_SUCCESS(status))
    {
        TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_INIT,
                    "WdfDriverCreate failed. %x\n",
                    status));
 
        // Cleanup tracing here because DriverUnload will not be called
        // as we have failed to create WDFDRIVER object itself.
        WPP_CLEANUP(DriverObject);
 
    }
    else
    {
        PCDROM_DRIVER_EXTENSION driverExtension = DriverGetExtension(driverObject);
 
        // Copy the registry path into the driver extension so we can use it later
        driverExtension->Version = 0x01;
        driverExtension->DriverObject = DriverObject;
 
        if (BootEnvironmentIsWinPE()) {
 
            SET_FLAG(driverExtension->Flags, CDROM_FLAG_WINPE_MODE);
        }
 
    }
 
    return status;
}

DriverEvtCleanup()

VOID NTAPI DriverEvtCleanup

(

_In_ WDFOBJECT

Driver

)

Definition at line 202 of file cdrom.c.

{
    WDFDRIVER driver = (WDFDRIVER)Driver;
 
    PAGED_CODE ();
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
                "CDROM.SYS DriverObject %p cleanup. Will be unloaded soon\n",
                driver));
 
    // Stop WPP Tracing
    WPP_CLEANUP( WdfDriverWdmGetDriverObject(driver) );
 
 
    return;
}

DriverEvtDeviceAdd()

NTSTATUS NTAPI DriverEvtDeviceAdd	(	_In_ WDFDRIVER	Driver,
		_Inout_ PWDFDEVICE_INIT	DeviceInit
	)

Definition at line 238 of file cdrom.c.

{
    NTSTATUS                        status = STATUS_SUCCESS;
    PCDROM_DRIVER_EXTENSION         driverExtension = NULL;
    WDFDEVICE                       device = NULL;
    PCDROM_DEVICE_EXTENSION         deviceExtension = NULL;
    BOOLEAN                         deviceClaimed = FALSE;
 
    WDF_OBJECT_ATTRIBUTES           attributes;
    WDF_FILEOBJECT_CONFIG           fileObjectConfig;
    WDF_IO_TARGET_OPEN_PARAMS       ioTargetOpenParams;
    WDF_IO_QUEUE_CONFIG             queueConfig;
    WDF_PNPPOWER_EVENT_CALLBACKS    pnpPowerCallbacks;
    WDF_REMOVE_LOCK_OPTIONS         removeLockOptions;
    PWCHAR                          wideDeviceName = NULL;
    UNICODE_STRING                  unicodeDeviceName;
    PDEVICE_OBJECT                  lowerPdo = NULL;
    ULONG                           deviceNumber = 0;
    ULONG                           devicePropertySessionId = INVALID_SESSION;
    ULONG                           devicePropertySize = 0;
    DEVPROPTYPE                     devicePropertyType = DEVPROP_TYPE_EMPTY;
 
    PAGED_CODE();
 
    driverExtension = DriverGetExtension(Driver);
 
    // 0. Initialize the objects that we're going to use
    RtlInitUnicodeString(&unicodeDeviceName, NULL);
 
    // 1. Register PnP&Power callbacks for any we are interested in.
    // If a callback isn't set, Framework will take the default action by itself.
    {
        // Zero out the PnpPowerCallbacks structure.
        WDF_PNPPOWER_EVENT_CALLBACKS_INIT(&pnpPowerCallbacks);
 
        // Use this callback to init resources that are used by the device and only needs to be called once.
        pnpPowerCallbacks.EvtDeviceSelfManagedIoInit = DeviceEvtSelfManagedIoInit;
 
        // Use this callback to prepare device for coming back from a lower power mode to D0.
        pnpPowerCallbacks.EvtDeviceD0Entry = DeviceEvtD0Entry;
 
        // Use this callback to prepare device for entering into a lower power mode.
        pnpPowerCallbacks.EvtDeviceD0Exit = DeviceEvtD0Exit;
 
        // Use this callback to free any resources used by device and will be called when the device is
        // powered down.
        pnpPowerCallbacks.EvtDeviceSelfManagedIoCleanup = DeviceEvtSelfManagedIoCleanup;
 
        pnpPowerCallbacks.EvtDeviceSurpriseRemoval = DeviceEvtSurpriseRemoval;
 
        // Register the PnP and power callbacks.
        WdfDeviceInitSetPnpPowerEventCallbacks(DeviceInit, &pnpPowerCallbacks);
    }
 
    // 2. Register the EvtIoInCallerContext to deal with IOCTLs that need to stay in original context.
    WdfDeviceInitSetIoInCallerContextCallback(DeviceInit,
                                              DeviceEvtIoInCallerContext);
 
    // 3. Register PreprocessCallback for IRP_MJ_POWER, IRP_MJ_FLUSH_BUFFERS and IRP_MJ_SHUTDOWN
    {
        UCHAR minorFunctions[1];
 
        minorFunctions[0] = IRP_MN_SET_POWER;
 
        status = WdfDeviceInitAssignWdmIrpPreprocessCallback(DeviceInit,
                                                             RequestProcessSetPower,
                                                             IRP_MJ_POWER,
                                                             minorFunctions,
                                                             RTL_NUMBER_OF(minorFunctions));
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                        "DriverEvtDeviceAdd: Assign IrpPreprocessCallback for IRP_MJ_POWER failed, "
                        "status: 0x%X\n", status));
 
            goto Exit;
        }
 
        status = WdfDeviceInitAssignWdmIrpPreprocessCallback(DeviceInit,
                                                             RequestProcessShutdownFlush,
                                                             IRP_MJ_FLUSH_BUFFERS,
                                                             NULL,
                                                             0);
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                        "DriverEvtDeviceAdd: Assign IrpPreprocessCallback for IRP_MJ_FLUSH_BUFFERS failed, "
                        "status: 0x%X\n", status));
 
            goto Exit;
        }
 
        status = WdfDeviceInitAssignWdmIrpPreprocessCallback(DeviceInit,
                                                             RequestProcessShutdownFlush,
                                                             IRP_MJ_SHUTDOWN,
                                                             NULL,
                                                             0);
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                        "DriverEvtDeviceAdd: Assign IrpPreprocessCallback for IRP_MJ_SHUTDOWN failed, "
                        "status: 0x%X\n", status));
 
            goto Exit;
        }
    }
 
    // 4. Set attributes to create Request Context area.
    {
        //Reuse this structure.
        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
                                                CDROM_REQUEST_CONTEXT);
        attributes.EvtCleanupCallback = RequestEvtCleanup;
 
        WdfDeviceInitSetRequestAttributes(DeviceInit,
                                          &attributes);
    }
 
    // 5. Register FileObject related callbacks
    {
        // Add FILE_OBJECT_EXTENSION as the context to the file object.
        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes, FILE_OBJECT_CONTEXT);
 
        // Set Entry points for Create and Close..
 
        // The framework doesn't sync the file create requests with pnp/power
        // state. Re-direct all the file create requests to a dedicated
        // queue, which will be purged manually during removal.
        WDF_FILEOBJECT_CONFIG_INIT(&fileObjectConfig,
                                   NULL, //CreateQueueEvtIoDefault,
                                   DeviceEvtFileClose,
                                   WDF_NO_EVENT_CALLBACK); // No callback for Cleanup
 
        fileObjectConfig.FileObjectClass = WdfFileObjectWdfCannotUseFsContexts;
 
        // Since we are registering file events and fowarding create request
        // ourself, we must also set AutoForwardCleanupClose so that cleanup
        // and close can also get forwarded.
        fileObjectConfig.AutoForwardCleanupClose = WdfTrue;
        attributes.SynchronizationScope = WdfSynchronizationScopeNone;
        attributes.ExecutionLevel = WdfExecutionLevelPassive;
 
        // Indicate that file object is optional.
        fileObjectConfig.FileObjectClass |= WdfFileObjectCanBeOptional;
 
        WdfDeviceInitSetFileObjectConfig(DeviceInit,
                                         &fileObjectConfig,
                                         &attributes);
    }
 
    // 6. Initialize device-wide attributes
    {
        // Declare ourselves as NOT owning power policy.
        // The power policy owner in storage stack is port driver.
        WdfDeviceInitSetPowerPolicyOwnership(DeviceInit, FALSE);
 
        // Set other DeviceInit attributes.
        WdfDeviceInitSetExclusive(DeviceInit, FALSE);
        WdfDeviceInitSetDeviceType(DeviceInit, FILE_DEVICE_CD_ROM);
        WdfDeviceInitSetCharacteristics(DeviceInit, FILE_REMOVABLE_MEDIA, FALSE);
        WdfDeviceInitSetIoType(DeviceInit, WdfDeviceIoDirect);
        WdfDeviceInitSetPowerPageable(DeviceInit);
 
        // We require the framework to acquire a remove lock before delivering all IRP types
        WDF_REMOVE_LOCK_OPTIONS_INIT(&removeLockOptions,
                                     WDF_REMOVE_LOCK_OPTION_ACQUIRE_FOR_IO);
 
        WdfDeviceInitSetRemoveLockOptions(DeviceInit, &removeLockOptions);
 
        // save the PDO for later reference
        lowerPdo = WdfFdoInitWdmGetPhysicalDevice(DeviceInit);
 
        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
                                                CDROM_DEVICE_EXTENSION);
 
        // We have a parallel queue, so WdfSynchronizationScopeNone is our only choice.
        attributes.SynchronizationScope = WdfSynchronizationScopeNone;
        attributes.ExecutionLevel = WdfExecutionLevelDispatch;
 
        // Provide a cleanup callback which will release memory allocated with ExAllocatePool*
        attributes.EvtCleanupCallback = DeviceEvtCleanup;
    }
 
    // 7. Now, the device can be created.
    {
        wideDeviceName = ExAllocatePoolWithTag(NonPagedPoolNx,
                                               64 * sizeof(WCHAR),
                                               CDROM_TAG_STRINGS);
 
        if (wideDeviceName == NULL)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto Exit;
        }
 
        // Find the lowest device number currently available.
        do {
            status = RtlStringCchPrintfW((NTSTRSAFE_PWSTR)wideDeviceName,
                                         64,
                                         L"\\Device\\CdRom%d",
                                         deviceNumber);
 
            if (!NT_SUCCESS(status)) {
                TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                            "DriverEvtDeviceAdd: Format device name failed with error: 0x%X\n", status));
 
                goto Exit;
            }
 
            RtlInitUnicodeString(&unicodeDeviceName, wideDeviceName);
 
            status = WdfDeviceInitAssignName(DeviceInit, &unicodeDeviceName);
            if (!NT_SUCCESS(status))
            {
                TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                            "DriverEvtDeviceAdd: WdfDeviceInitAssignName() failed with error: 0x%X\n", status));
 
                goto Exit;
            }
 
            status = WdfDeviceCreate(&DeviceInit, &attributes, &device);
 
            deviceNumber++;
 
        } while (status == STATUS_OBJECT_NAME_COLLISION);
 
        // When this loop exits the count is inflated by one - fix that.
        deviceNumber--;
 
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                        "DriverEvtDeviceAdd: Can not create a new device, status: 0x%X\n",
                        status));
 
            goto Exit;
        }
    }
 
    // 8. Fill up basic Device Extension settings and create a remote I/O target for the next-lower driver.
    //    The reason why we do not use the local I/O target is because we want to be able to close the
    //    I/O target on surprise removal.
    {
        deviceExtension = DeviceGetExtension(device);
 
        deviceExtension->Version = 0x01;
        deviceExtension->Size = sizeof(CDROM_DEVICE_EXTENSION);
 
        deviceExtension->DeviceObject = WdfDeviceWdmGetDeviceObject(device);
        deviceExtension->Device = device;
        deviceExtension->DriverExtension = driverExtension;
 
        deviceExtension->LowerPdo = lowerPdo;
 
        deviceExtension->DeviceType = FILE_DEVICE_CD_ROM;   //Always a FILE_DEVICE_CD_ROM for all device it manages.
        deviceExtension->DeviceName = unicodeDeviceName;
 
        deviceExtension->DeviceNumber = deviceNumber;
    }
    {
        WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
        attributes.ParentObject = deviceExtension->Device;
 
        status = WdfIoTargetCreate(deviceExtension->Device,
                                   &attributes,
                                   &deviceExtension->IoTarget);
 
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                        "DriverEvtDeviceAdd: Can not create a remote I/O target object, status: 0x%X\n",
                        status));
            goto Exit;
        }
 
        WDF_IO_TARGET_OPEN_PARAMS_INIT_EXISTING_DEVICE(&ioTargetOpenParams,
                                                       WdfDeviceWdmGetAttachedDevice(deviceExtension->Device));
 
        status = WdfIoTargetOpen(deviceExtension->IoTarget,
                                 &ioTargetOpenParams);
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                        "DriverEvtDeviceAdd: Can not open a remote I/O target for the next-lower device, status: 0x%X\n",
                        status));
 
            WdfObjectDelete(deviceExtension->IoTarget);
            deviceExtension->IoTarget = NULL;
 
            goto Exit;
        }
    }
 
    // 9. Claim the device, so that port driver will only accept the commands from CDROM.SYS for this device.
    // NOTE: The I/O should be issued after the device is started. But we would like to claim
    // the device as soon as possible, so this legacy behavior is kept.
    status = DeviceClaimRelease(deviceExtension, FALSE);
 
    if (!NT_SUCCESS(status))
    {
        // Someone already had this device - we're in trouble
        goto Exit;
    }
    else
    {
        deviceClaimed = TRUE;
    }
 
    //
    // CDROM Queueing Structure
    //
    // a. EvtIoInCallerContext (prior to queueing):
    //      This event will be used ONLY to forward down IOCTLs that come in at PASSIVE LEVEL
    //      and need to be forwarded down the stack in the original context.
    //
    // b. Main input queue: serial queue for main dispatching
    //      This queue will be used to do all dispatching of requests to serialize
    //      access to the device.  Any request that was previously completed in
    //      the Dispatch routines will be completed here.  Anything requiring device
    //      I/O will be sent through the serial I/O queue.
    //
    // 10. Set up IO queues after device being created.
    //
    {
        WDF_IO_QUEUE_CONFIG_INIT_DEFAULT_QUEUE(&queueConfig,
                                               WdfIoQueueDispatchSequential);
 
        queueConfig.PowerManaged                = WdfFalse;
 
#pragma prefast(push)
#pragma prefast(disable: 28155, "a joint handler for read/write cannot be EVT_WDF_IO_QUEUE_IO_READ and EVT_WDF_IO_QUEUE_IO_WRITE simultaneously")
#pragma prefast(disable: 28023, "a joint handler for read/write cannot be EVT_WDF_IO_QUEUE_IO_READ and EVT_WDF_IO_QUEUE_IO_WRITE simultaneously")
        queueConfig.EvtIoRead                   = SequentialQueueEvtIoReadWrite;
        queueConfig.EvtIoWrite                  = SequentialQueueEvtIoReadWrite;
#pragma prefast(pop)
 
        queueConfig.EvtIoDeviceControl          = SequentialQueueEvtIoDeviceControl;
        queueConfig.EvtIoCanceledOnQueue        = SequentialQueueEvtCanceledOnQueue;
 
        status = WdfIoQueueCreate(device,
                                  &queueConfig,
                                  WDF_NO_OBJECT_ATTRIBUTES,
                                  &(deviceExtension->SerialIOQueue));
        if (!NT_SUCCESS(status))
        {
            goto Exit;
        }
 
        // this queue is dedicated for file create requests.
        WDF_IO_QUEUE_CONFIG_INIT(&queueConfig, WdfIoQueueDispatchParallel);
 
        queueConfig.PowerManaged = WdfFalse;
        queueConfig.EvtIoDefault = CreateQueueEvtIoDefault;
 
        //Reuse this structure.
        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
                                                CDROM_REQUEST_CONTEXT);
 
        attributes.SynchronizationScope = WdfSynchronizationScopeNone;
        attributes.ExecutionLevel = WdfExecutionLevelPassive;
 
        status = WdfIoQueueCreate(device,
                                  &queueConfig,
                                  &attributes,
                                  &(deviceExtension->CreateQueue));
 
        if (!NT_SUCCESS(status))
        {
            goto Exit;
        }
 
        // Configure the device to use driver created queue for dispatching create.
        status = WdfDeviceConfigureRequestDispatching(device,
                                                      deviceExtension->CreateQueue,
                                                      WdfRequestTypeCreate);
 
        if (!NT_SUCCESS(status))
        {
            goto Exit;
        }
    }
 
    // 11. Set the alignment requirements for the device based on the host adapter requirements.
    //
    // NOTE: this should have been set when device is attached on device stack,
    // by keeping this legacy code, we could avoid issue that this value was not correctly set at that time.
    if (deviceExtension->LowerPdo->AlignmentRequirement > deviceExtension->DeviceObject->AlignmentRequirement)
    {
        WdfDeviceSetAlignmentRequirement(deviceExtension->Device,
                                         deviceExtension->LowerPdo->AlignmentRequirement);
    }
 
    // 12. Initialization of miscellaneous internal properties
 
    // CDROMs are not partitionable so starting offset is 0.
    deviceExtension->StartingOffset.LowPart = 0;
    deviceExtension->StartingOffset.HighPart = 0;
 
    // Set the default geometry for the cdrom to match what NT 4 used.
    // these values will be used to compute the cylinder count rather
    // than using it's NT 5.0 defaults.
    deviceExtension->DiskGeometry.MediaType = RemovableMedia;
    deviceExtension->DiskGeometry.TracksPerCylinder = 0x40;
    deviceExtension->DiskGeometry.SectorsPerTrack = 0x20;
 
    deviceExtension->DeviceAdditionalData.ReadWriteRetryDelay100nsUnits = WRITE_RETRY_DELAY_DVD_1x;
 
    // Clear the SrbFlags and disable synchronous transfers
    deviceExtension->SrbFlags = SRB_FLAGS_DISABLE_SYNCH_TRANSFER;
 
    // Set timeout value in seconds.
    deviceExtension->TimeOutValue = DeviceGetTimeOutValueFromRegistry();
    if ((deviceExtension->TimeOutValue > 30 * 60) || // longer than 30 minutes
        (deviceExtension->TimeOutValue == 0))
    {
        deviceExtension->TimeOutValue = SCSI_CDROM_TIMEOUT;
    }
 
    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_INIT,
               "DriverEvtDeviceAdd: device timeout is set to %x seconds",
               deviceExtension->TimeOutValue
               ));
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
    deviceExtension->IsVolumeOnlinePending = TRUE;
 
    WDF_IO_QUEUE_CONFIG_INIT(&queueConfig, WdfIoQueueDispatchManual);
 
    queueConfig.PowerManaged = WdfFalse;
 
    status = WdfIoQueueCreate(device,
                              &queueConfig,
                              WDF_NO_OBJECT_ATTRIBUTES,
                              &deviceExtension->ManualVolumeReadyQueue);
 
    if (!NT_SUCCESS(status))
    {
        goto Exit;
    }
#endif
 
    // 13. Initialize the stuff related to media locking
    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
    attributes.ParentObject = deviceExtension->Device;
    status = WdfWaitLockCreate(&attributes,
                               &deviceExtension->EjectSynchronizationLock);
 
    deviceExtension->LockCount = 0;
 
    // 14. Initialize context structures needed for asynchronous release queue and power requests
 
    if (NT_SUCCESS(status))
    {
        status = DeviceInitReleaseQueueContext(deviceExtension);
    }
 
    if (NT_SUCCESS(status))
    {
        status = DeviceInitPowerContext(deviceExtension);
    }
 
    // 15. Create external access points other than device name.
    if (NT_SUCCESS(status))
    {
        status = DeviceCreateWellKnownName(deviceExtension);
    }
 
    // 16. Query session id from the PDO.
    if (NT_SUCCESS(status))
    {
        status = IoGetDevicePropertyData(deviceExtension->LowerPdo,
                                         &DEVPKEY_Device_SessionId,
                                         0,
                                         0,
                                         sizeof(devicePropertySessionId),
                                         &devicePropertySessionId,
                                         &devicePropertySize,
                                         &devicePropertyType);
 
        if (!NT_SUCCESS(status))
        {
            // The device is global.
            devicePropertySessionId = INVALID_SESSION;
            status = STATUS_SUCCESS;
        }
    }
 
    // 17. Register interfaces for this device.
    if (NT_SUCCESS(status))
    {
        status = DeviceRegisterInterface(deviceExtension, CdRomDeviceInterface);
    }
 
    if (NT_SUCCESS(status))
    {
        // If this is a per-session DO, don't register for mount interface so that
        // mountmgr will not automatically assign a drive letter.
        if (devicePropertySessionId == INVALID_SESSION)
        {
            status = DeviceRegisterInterface(deviceExtension, MountedDeviceInterface);
        }
    }
 
    // 18. Initialize the shutdown/flush lock
    if (NT_SUCCESS(status))
    {
        WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
        attributes.ParentObject = deviceExtension->Device;
 
        status = WdfWaitLockCreate(&attributes, &deviceExtension->ShutdownFlushWaitLock);
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_PNP,
                        "DriverEvtDeviceAdd: Cannot create shutdown/flush waitlock, status: 0x%X\n",
                        status));
        }
    }
 
    // 19. Initialize the work item that is used to initiate asynchronous reads/writes
    if (NT_SUCCESS(status))
    {
        WDF_WORKITEM_CONFIG workItemConfig;
        WDF_OBJECT_ATTRIBUTES workItemAttributes;
 
        WDF_WORKITEM_CONFIG_INIT(&workItemConfig,
                                 ReadWriteWorkItemRoutine
                                 );
 
        WDF_OBJECT_ATTRIBUTES_INIT(&workItemAttributes);
        workItemAttributes.ParentObject = deviceExtension->Device;
 
        status = WdfWorkItemCreate(&workItemConfig,
                                   &workItemAttributes,
                                   &deviceExtension->ReadWriteWorkItem
                                   );
 
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_INIT,
                        "DriverEvtDeviceAdd: Cannot create read/write work item, status: 0x%X\n",
                        status));
        }
    }
 
    // 20. Initialize the work item that is used to process most IOCTLs at PASSIVE_LEVEL.
    if (NT_SUCCESS(status))
    {
        WDF_WORKITEM_CONFIG workItemConfig;
        WDF_OBJECT_ATTRIBUTES workItemAttributes;
 
        WDF_WORKITEM_CONFIG_INIT(&workItemConfig,
                                 IoctlWorkItemRoutine
                                 );
 
        WDF_OBJECT_ATTRIBUTES_INIT(&workItemAttributes);
        workItemAttributes.ParentObject = deviceExtension->Device;
 
        status = WdfWorkItemCreate(&workItemConfig,
                                   &workItemAttributes,
                                   &deviceExtension->IoctlWorkItem
                                   );
 
        if (!NT_SUCCESS(status))
        {
            TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_INIT,
                        "DriverEvtDeviceAdd: Cannot create ioctl work item, status: 0x%X\n",
                        status));
        }
    }
 
 
Exit:
 
    if (!NT_SUCCESS(status))
    {
        FREE_POOL(wideDeviceName);
 
        if (deviceExtension != NULL)
        {
            RtlInitUnicodeString(&deviceExtension->DeviceName, NULL);
        }
 
        // Release the device with the port driver, if it was claimed
        if ((deviceExtension != NULL) && deviceClaimed)
        {
            DeviceClaimRelease(deviceExtension, TRUE);
        }
        deviceClaimed = FALSE;
    }
 
    return status;
}

IoctlWorkItemRoutine()

VOID NTAPI IoctlWorkItemRoutine

(

_In_ WDFWORKITEM

WorkItem

)

Definition at line 3503 of file cdrom.c.

{
    PCDROM_DEVICE_EXTENSION             deviceExtension = NULL;
 
    PAGED_CODE ();
 
    deviceExtension = WdfObjectGetTypedContext(WdfWorkItemGetParentObject(WorkItem), CDROM_DEVICE_EXTENSION);
 
    if (DeviceIsMmcUpdateRequired(deviceExtension->Device))
    {
        // Issue command to update the drive capabilities.
        // The failure of MMC update is not considered critical,
        // so that we'll continue to process I/O even MMC update fails.
        DeviceUpdateMmcCapabilities(deviceExtension->Device);
    }
 
    RequestProcessSerializedIoctl(deviceExtension, deviceExtension->IoctlWorkItemContext.OriginalRequest);
}

NormalizeIoctl()

VOID NormalizeIoctl

(

_Inout_ PWDF_REQUEST_PARAMETERS

requestParameters

)

Definition at line 1514 of file cdrom.c.

{
    ULONG ioctlCode;
    ULONG baseCode;
    ULONG functionCode;
 
    // if this is a class driver ioctl then we need to change the base code
    // to IOCTL_STORAGE_BASE so that the switch statement can handle it.
    //
    // WARNING - currently the scsi class ioctl function codes are between
    // 0x200 & 0x300.  this routine depends on that fact
    ioctlCode = requestParameters->Parameters.DeviceIoControl.IoControlCode;
    baseCode = DEVICE_TYPE_FROM_CTL_CODE(ioctlCode);
    functionCode = (ioctlCode & (~0xffffc003)) >> 2;
 
    if ((baseCode == IOCTL_SCSI_BASE) ||
        (baseCode == IOCTL_DISK_BASE) ||
        (baseCode == IOCTL_TAPE_BASE) ||
        (baseCode == IOCTL_DVD_BASE) ||
        (baseCode == IOCTL_CDROM_BASE))
        //IOCTL_STORAGE_BASE does not need to be converted.
    {
        if((functionCode >= 0x200) && (functionCode <= 0x300))
        {
            ioctlCode = (ioctlCode & 0x0000ffff) | CTL_CODE(IOCTL_STORAGE_BASE, 0, 0, 0);
 
            TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_IOCTL,
                        "IOCTL code recalibrate, New ioctl code is %lx\n",
                        ioctlCode));
 
            // Set the code into request parameters, then "requestParameters" needs to be used for dispatch functions.
            requestParameters->Parameters.DeviceIoControl.IoControlCode = ioctlCode;
        }
    }
}

Referenced by DeviceEvtIoInCallerContext().

ReadWriteWorkItemRoutine()

VOID NTAPI ReadWriteWorkItemRoutine

(

_In_ WDFWORKITEM

WorkItem

)

Definition at line 3345 of file cdrom.c.

{
    PCDROM_DEVICE_EXTENSION             deviceExtension = NULL;
    WDFREQUEST                          readWriteRequest = NULL;
    WDF_REQUEST_PARAMETERS              readWriteRequestParameters;
    NTSTATUS                            status = STATUS_SUCCESS;
 
    PAGED_CODE ();
 
    deviceExtension = WdfObjectGetTypedContext(WdfWorkItemGetParentObject(WorkItem), CDROM_DEVICE_EXTENSION);
    readWriteRequest = deviceExtension->ReadWriteWorkItemContext.OriginalRequest;
    deviceExtension->ReadWriteWorkItemContext.OriginalRequest = NULL;
 
    WDF_REQUEST_PARAMETERS_INIT(&readWriteRequestParameters);
    WdfRequestGetParameters(readWriteRequest, &readWriteRequestParameters);
 
    if (DeviceIsMmcUpdateRequired(deviceExtension->Device))
    {
        // Issue command to update the drive capabilities.
        // The failure of MMC update is not considered critical, so we'll
        // continue to process the request even if MMC update fails.
        (VOID) DeviceUpdateMmcCapabilities(deviceExtension->Device);
    }
 
    // Now verify and process the request
    if (NT_SUCCESS(status))
    {
        status = RequestValidateReadWrite(deviceExtension, readWriteRequest, readWriteRequestParameters);
    }
    if (NT_SUCCESS(status))
    {
        status = RequestHandleReadWrite(deviceExtension, readWriteRequest, readWriteRequestParameters);
    }
 
    // Complete the request immediately on failure
    if (!NT_SUCCESS(status))
    {
        RequestCompletion(deviceExtension, readWriteRequest, status, 0);
    }
}

RequestDispatchProcessDirectly()

BOOLEAN RequestDispatchProcessDirectly	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 1694 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    BOOLEAN                 processed = FALSE;
    size_t                  dataLength = 0;
 
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    ULONG                   ioctlCode = RequestParameters.Parameters.DeviceIoControl.IoControlCode;
 
    switch (ioctlCode)
    {
 
    case IOCTL_CDROM_GET_INQUIRY_DATA:
    {
        status = RequestHandleGetInquiryData(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_GET_MEDIA_TYPES_EX:
    {
        status = RequestHandleGetMediaTypeEx(deviceExtension, Request, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_MOUNTDEV_QUERY_UNIQUE_ID:
    {
        status = RequestHandleMountQueryUniqueId(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_MOUNTDEV_QUERY_DEVICE_NAME:
    {
        status = RequestHandleMountQueryDeviceName(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_MOUNTDEV_QUERY_SUGGESTED_LINK_NAME:
    {
        status = RequestHandleMountQuerySuggestedLinkName(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_GET_DEVICE_NUMBER:
    {
        status = RequestHandleGetDeviceNumber(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_GET_HOTPLUG_INFO:
    {
        status = RequestHandleGetHotPlugInfo(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_SET_HOTPLUG_INFO:
    {
        status = RequestHandleSetHotPlugInfo(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_EVENT_NOTIFICATION:
    {
        status = RequestHandleEventNotification(deviceExtension, Request, &RequestParameters, &dataLength);
 
        processed = TRUE;
        break; // complete the irp
    }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
    case IOCTL_VOLUME_ONLINE:
    {
        //
        // Mount manager and volume manager will
        // follow this online with a post online
        // but other callers may not. In those
        // cases, we process this request right
        // away. We approximate that these other
        // callers are from user mode
        //
 
        if (WdfRequestGetRequestorMode(Request) == KernelMode)
        {
            processed = TRUE;
        }
        break;
    }
#endif
 
    default:
    {
        processed = FALSE;
        break;
    }
 
    } //end of switch (ioctlCode)
 
    if (processed)
    {
        UCHAR currentStackLocationFlags = 0;
        currentStackLocationFlags = RequestGetCurrentStackLocationFlags(Request);
 
        if ((status == STATUS_VERIFY_REQUIRED) &&
            (currentStackLocationFlags & SL_OVERRIDE_VERIFY_VOLUME))
        {
            // If the status is verified required and this request
            // should bypass verify required then retry the request.
            status = STATUS_IO_DEVICE_ERROR;
            UNREFERENCED_PARAMETER(status); // disables prefast warning; defensive coding...
 
            processed = RequestDispatchProcessDirectly(Device, Request, RequestParameters);
        }
        else
        {
            // Complete the request after processing it.
            RequestCompletion(deviceExtension, Request, status, dataLength);
        }
    }
 
    return processed;
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchProcessDirectly().

RequestDispatchSpecialIoctls()

BOOLEAN RequestDispatchSpecialIoctls	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 2849 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    BOOLEAN                 processed = FALSE;
    size_t                  dataLength = 0;
    BOOLEAN                 requestCompleted = FALSE;
 
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    PCDROM_DATA             cdData = &(deviceExtension->DeviceAdditionalData);
    ULONG                   ioctlCode = RequestParameters.Parameters.DeviceIoControl.IoControlCode;
 
    switch (ioctlCode)
    {
    case IOCTL_SCSI_PASS_THROUGH:
    case IOCTL_SCSI_PASS_THROUGH_DIRECT:
    case IOCTL_SCSI_PASS_THROUGH_EX:
    case IOCTL_SCSI_PASS_THROUGH_DIRECT_EX:
    {
        // SPTI is considered special case as we need to set the MinorFunction before pass to low level.
 
#if defined (_WIN64)
        if (WdfRequestIsFrom32BitProcess(Request))
        {
            if ((ioctlCode == IOCTL_SCSI_PASS_THROUGH) || (ioctlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT))
            {
                if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(SCSI_PASS_THROUGH32))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
            else
            {
                if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(SCSI_PASS_THROUGH32_EX))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
        }
        else
#endif
        {
            if ((ioctlCode == IOCTL_SCSI_PASS_THROUGH) || (ioctlCode == IOCTL_SCSI_PASS_THROUGH_DIRECT))
            {
                if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(SCSI_PASS_THROUGH))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
            else
            {
                if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(SCSI_PASS_THROUGH_EX))
                {
                    status = STATUS_INVALID_PARAMETER;
                }
            }
        }
 
        if (!NT_SUCCESS(status))
        {
            // validation failed.
            RequestCompletion(deviceExtension, Request, status, dataLength);
        }
        else
        {
            // keep the request in serialized manner and stay in user's context.
            status = RequestSetContextFields(Request, RequestHandleScsiPassThrough);
 
            if (NT_SUCCESS(status))
            {
                status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
            }
            else
            {
                RequestCompletion(deviceExtension, Request, status, 0);
            }
        }
 
        requestCompleted = TRUE;
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_QUERY_PROPERTY:
    {
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength < sizeof(STORAGE_PROPERTY_QUERY))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            PSTORAGE_PROPERTY_QUERY inputBuffer = NULL;
 
            status = WdfRequestRetrieveInputBuffer(Request,
                                                   RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                                   &inputBuffer,
                                                   NULL);
 
            if (NT_SUCCESS(status))
            {
                if (!EXCLUSIVE_MODE(cdData) ||                                     // not locked
                    EXCLUSIVE_OWNER(cdData, WdfRequestGetFileObject(Request)) ||   // request is from lock owner
                    (inputBuffer->QueryType == PropertyExistsQuery))               // request not access device
                {
                    if (inputBuffer->PropertyId == StorageDeviceUniqueIdProperty)
                    {
                        // previously handled in classpnp
                        // keep the request in serialized manner and stay in user's context.
                        status = RequestSetContextFields(Request, RequestHandleQueryPropertyDeviceUniqueId);
 
                        if (NT_SUCCESS(status))
                        {
                            status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
                            // remeber that the request has been completed.
                            requestCompleted = TRUE;
                        }
                    }
                    else if (inputBuffer->PropertyId == StorageDeviceWriteCacheProperty)
                    {
                        // previously handled in classpnp
                        // keep the request in serialized manner and stay in user's context.
                        status = RequestSetContextFields(Request, RequestHandleQueryPropertyWriteCache);
 
                        if (NT_SUCCESS(status))
                        {
                            status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
                            // remeber that the request has been completed.
                            requestCompleted = TRUE;
                        }
                    }
                    else
                    {
                        // Pass to port driver for handling
                        RequestDispatchUnknownRequests(Device, Request, RequestParameters);
 
                        // remeber that the request has been completed.
                        requestCompleted = TRUE;
                    }
                }
                else
                {
                    // If cached data exists, return cached data. Otherwise, fail the request.
                    if ((inputBuffer->QueryType == PropertyStandardQuery) &&
                        ((inputBuffer->PropertyId == StorageDeviceProperty) || (inputBuffer->PropertyId == StorageAdapterProperty)) )
                    {
                        status = RequestHandleQueryPropertyRetrieveCachedData(deviceExtension, Request, RequestParameters, &dataLength);
                    }
                    else
                    {
                        status = STATUS_ACCESS_DENIED;
                    }
                }
            }
        }
 
        processed = TRUE;
        break;
    }
 
    // this IOCTL is a fake one, used for MCN process sync-ed with serial queue.
    case IOCTL_MCN_SYNC_FAKE_IOCTL:
    {
        PIRP irp = WdfRequestWdmGetIrp(Request);
 
        if ((deviceExtension->MediaChangeDetectionInfo != NULL) &&
            (irp == deviceExtension->MediaChangeDetectionInfo->MediaChangeSyncIrp) &&
            (WdfRequestGetRequestorMode(Request) == KernelMode) &&
            (RequestParameters.Parameters.Others.Arg1 == RequestSetupMcnSyncIrp) &&
            (RequestParameters.Parameters.Others.Arg2 == RequestSetupMcnSyncIrp) &&
            (RequestParameters.Parameters.Others.Arg4 == RequestSetupMcnSyncIrp))
        {
            // This is the requset we use to sync Media Change Detection with sequential queue.
            status = WdfDeviceEnqueueRequest(Device, Request);
 
            if (!NT_SUCCESS(status))
            {
                RequestCompletion(deviceExtension, Request, status, dataLength);
            }
 
            requestCompleted = TRUE;
            processed = TRUE;
        }
        else
        {
            // process as an unknown request.
            processed = FALSE;
        }
        break;
    }
 
    default:
    {
        processed = FALSE;
        break;
    }
    } //end of switch (ioctlCode)
 
    if (processed && !requestCompleted)
    {
        UCHAR currentStackLocationFlags = 0;
        currentStackLocationFlags = RequestGetCurrentStackLocationFlags(Request);
 
        if ((status == STATUS_VERIFY_REQUIRED) &&
            (currentStackLocationFlags & SL_OVERRIDE_VERIFY_VOLUME))
        {
            // If the status is verified required and this request
            // should bypass verify required then retry the request.
            status = STATUS_IO_DEVICE_ERROR;
            UNREFERENCED_PARAMETER(status); // disables prefast warning; defensive coding...
 
            processed = RequestDispatchSpecialIoctls(Device, Request, RequestParameters);
        }
        else
        {
            RequestCompletion(deviceExtension, Request, status, dataLength);
        }
    }
 
    return processed;
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchSpecialIoctls().

RequestDispatchSyncWithSequentialQueue()

BOOLEAN RequestDispatchSyncWithSequentialQueue	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 2717 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    BOOLEAN                 processed = FALSE;
    size_t                  dataLength = 0;
 
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    ULONG                   ioctlCode = RequestParameters.Parameters.DeviceIoControl.IoControlCode;
 
    switch (ioctlCode)
    {
 
    case IOCTL_CDROM_EXCLUSIVE_ACCESS:
    {
        //1. Validate
        status =  RequestValidateExclusiveAccess(Request, RequestParameters, &dataLength);
 
        //2. keep the request in serialized manner and stay in user's context.
        if (NT_SUCCESS(status))
        {
            PCDROM_EXCLUSIVE_ACCESS exclusiveAccess = NULL;
 
            status = WdfRequestRetrieveInputBuffer(Request,
                                                   RequestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                                   &exclusiveAccess,
                                                   NULL);
 
            if (NT_SUCCESS(status))
            {
                // do not need to check "status" as it passed validation and cannot fail in WdfRequestRetrieveInputBuffer()
                switch (exclusiveAccess->RequestType)
                {
 
                    case ExclusiveAccessQueryState:
                    {
                        status = RequestSetContextFields(Request, RequestHandleExclusiveAccessQueryLockState);
                        break;
                    }
 
                    case ExclusiveAccessLockDevice:
                    {
                        status = RequestSetContextFields(Request, RequestHandleExclusiveAccessLockDevice);
                        break;
                    }
 
                    case ExclusiveAccessUnlockDevice:
                    {
                        status = RequestSetContextFields(Request, RequestHandleExclusiveAccessUnlockDevice);
                        break;
                    }
                    default:
                    {
                        // already valicated in RequestValidateExclusiveAccess()
                        NT_ASSERT(FALSE);
                        break;
                    }
                }
            }
 
            if (NT_SUCCESS(status))
            {
                // now, put the special synchronization information into the context
                status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
 
                // "status" is used for debugging in above statement, reset to success to avoid further work in this function.
                status = STATUS_SUCCESS;
            }
        }
 
        processed = TRUE;
        break; // complete the irp
    }
 
    default:
    {
        processed = FALSE;
        break;
    }
    } //end of switch (ioctlCode)
 
    // Following process is only valid if the request is not really processed. (failed in validation)
    if (processed && !NT_SUCCESS(status))
    {
        UCHAR currentStackLocationFlags = 0;
        currentStackLocationFlags = RequestGetCurrentStackLocationFlags(Request);
 
        if ((status == STATUS_VERIFY_REQUIRED) &&
            (currentStackLocationFlags & SL_OVERRIDE_VERIFY_VOLUME))
        {
            //
            // If the status is verified required and this request
            // should bypass verify required then retry the request.
            //
            status = STATUS_IO_DEVICE_ERROR;
            UNREFERENCED_PARAMETER(status); // disables prefast warning; defensive coding...
 
            processed = RequestDispatchSyncWithSequentialQueue(Device, Request, RequestParameters);
        }
        else
        {
            // Validation failed / forward failed, complete the request.
            RequestCompletion(deviceExtension, Request, status, dataLength);
        }
    }
 
    return processed;
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchSyncWithSequentialQueue().

RequestDispatchToSequentialQueue()

BOOLEAN RequestDispatchToSequentialQueue	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 1855 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    BOOLEAN                 processed = FALSE;
    size_t                  dataLength = 0;
    BOOLEAN                 inZeroPowerState = FALSE;
 
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    ULONG                   ioctlCode = RequestParameters.Parameters.DeviceIoControl.IoControlCode;
    PZERO_POWER_ODD_INFO    zpoddInfo = deviceExtension->ZeroPowerODDInfo;
 
    if ((zpoddInfo != NULL) &&
        (zpoddInfo->InZeroPowerState != FALSE))
    {
        inZeroPowerState = TRUE;
    }
 
    switch (ioctlCode)
    {
 
    case IOCTL_CDROM_RAW_READ:
    {
        status = RequestValidateRawRead(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_DRIVE_GEOMETRY_EX:
    case IOCTL_CDROM_GET_DRIVE_GEOMETRY_EX:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get drive geometryEx\n"));
        if ( RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
             (ULONG)FIELD_OFFSET(DISK_GEOMETRY_EX, Data))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = FIELD_OFFSET(DISK_GEOMETRY_EX, Data);
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_DRIVE_GEOMETRY:
    case IOCTL_CDROM_GET_DRIVE_GEOMETRY:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get drive geometry\n"));
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(DISK_GEOMETRY))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(DISK_GEOMETRY);
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_READ_TOC_EX:
    {
        status = RequestValidateReadTocEx(deviceExtension, Request, RequestParameters, &dataLength);
 
        if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_READ_TOC:
    {
        status = RequestValidateReadToc(deviceExtension, RequestParameters, &dataLength);
 
        if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_GET_LAST_SESSION:
    {
        status = RequestValidateGetLastSession(deviceExtension, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_PLAY_AUDIO_MSF:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Play audio MSF\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(CDROM_PLAY_AUDIO_MSF))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_SEEK_AUDIO_MSF:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Seek audio MSF\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(CDROM_SEEK_AUDIO_MSF))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_PAUSE_AUDIO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Pause audio\n"));
 
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_RESUME_AUDIO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Resume audio\n"));
 
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_READ_Q_CHANNEL:
    {
        status = RequestValidateReadQChannel(Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_GET_VOLUME:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get volume control\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(VOLUME_CONTROL))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(VOLUME_CONTROL);
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_SET_VOLUME:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Set volume control\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(VOLUME_CONTROL))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_STOP_AUDIO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Stop audio\n"));
 
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_CHECK_VERIFY:
    case IOCTL_STORAGE_CHECK_VERIFY2:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] Check Verify\n", Request));
 
        // Following check will let the condition "OutputBufferLength == 0" pass.
        // Since it's legacy behavior in classpnp, we need to keep it.
        if ((RequestParameters.Parameters.DeviceIoControl.OutputBufferLength > 0) &&
            (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG)))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(ULONG);
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_GET_REGION:
    {
        // validation will be done when process it.
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_READ_STRUCTURE:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_READ_STRUCTURE\n", Request));
 
        status = RequestValidateDvdReadStructure(deviceExtension, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_READ_KEY:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_READ_KEY\n", Request));
 
        status = RequestValidateDvdReadKey(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_START_SESSION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_START_SESSION\n", Request));
 
        status = RequestValidateDvdStartSession(deviceExtension, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_SEND_KEY:
    case IOCTL_DVD_SEND_KEY2:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_SEND_KEY\n", Request));
 
        status = RequestValidateDvdSendKey(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_SET_READ_AHEAD:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] SetReadAhead\n", Request));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(STORAGE_SET_READ_AHEAD))
        {
            status = STATUS_INVALID_PARAMETER;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_IS_WRITABLE:
    {
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_DRIVE_LAYOUT:
    {
        ULONG requiredSize = 0;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get drive layout\n"));
 
        requiredSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION, PartitionEntry[1]);
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            requiredSize)
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = requiredSize;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_DRIVE_LAYOUT_EX:
    {
        ULONG requiredSize = 0;
 
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get drive layoutEx\n"));
 
        requiredSize = FIELD_OFFSET(DRIVE_LAYOUT_INFORMATION_EX, PartitionEntry[1]);
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            requiredSize)
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = requiredSize;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_PARTITION_INFO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get Partition Info\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(PARTITION_INFORMATION))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(PARTITION_INFORMATION);
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_PARTITION_INFO_EX:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Get Partition InfoEx\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(PARTITION_INFORMATION_EX))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(PARTITION_INFORMATION_EX);
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_VERIFY:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: IOCTL_DISK_VERIFY to device %p through request %p\n",
                    Device,
                    Request));
 
        if (RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(VERIFY_INFORMATION))
        {
            status = STATUS_INVALID_PARAMETER;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DISK_GET_LENGTH_INFO:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: Disk Get Length InfoEx\n"));
 
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength <
            sizeof(GET_LENGTH_INFORMATION))
        {
            status = STATUS_BUFFER_TOO_SMALL;
            dataLength = sizeof(GET_LENGTH_INFORMATION);
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_GET_CONFIGURATION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_GET_CONFIGURATION\n", Request));
 
        status = RequestValidateGetConfiguration(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_SET_SPEED:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_SET_SPEED\n", Request));
 
        status = RequestValidateSetSpeed(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_DVD_END_SESSION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_DVD_END_SESSION\n", Request));
 
        status = RequestValidateDvdEndSession(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_END_SESSION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_AACS_END_SESSION\n", Request));
 
        status = RequestValidateAacsEndSession(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_MEDIA_KEY_BLOCK:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Querying full MKB with bufferSize of %x bytes\n",
                    (int)RequestParameters.Parameters.DeviceIoControl.OutputBufferLength
                    ));
 
        status = RequestValidateAacsReadMediaKeyBlock(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_START_SESSION:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Requesting AGID\n"
                    ));
 
        status = RequestValidateAacsStartSession(deviceExtension, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_SEND_CERTIFICATE:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Sending host certificate to drive\n"
                    ));
 
        status = RequestValidateAacsSendCertificate(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_GET_CERTIFICATE:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Querying drive certificate\n"
                    ));
 
        status = RequestValidateAacsGetCertificate(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_GET_CHALLENGE_KEY:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Querying drive challenge key\n"
                    ));
 
        status = RequestValidateAacsGetChallengeKey(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_SEND_CHALLENGE_KEY:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Sending drive challenge key\n"
                    ));
 
        status = RequestValidateAacsSendChallengeKey(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_VOLUME_ID:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Reading volume ID\n"
                    ));
 
        status = RequestValidateAacsReadVolumeId(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_SERIAL_NUMBER:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Reading Serial Number\n"
                    ));
 
        status = RequestValidateAacsReadSerialNumber(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_MEDIA_ID:
    {
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                    "AACS: Reading media ID\n"
                    ));
 
        status = RequestValidateAacsReadMediaId(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_AACS_READ_BINDING_NONCE:
    case IOCTL_AACS_GENERATE_BINDING_NONCE:
    {
        if (ioctlCode == IOCTL_AACS_GENERATE_BINDING_NONCE)
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "AACS: Generating new binding nonce\n"
                        ));
        }
        else
        {
            TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                        "AACS: Reading existing binding nonce\n"
                        ));
        }
 
        status = RequestValidateAacsBindingNonce(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_ENABLE_STREAMING:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_ENABLE_STREAMING\n", Request));
 
        status = RequestValidateEnableStreaming(Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_SEND_OPC_INFORMATION:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_SEND_OPC_INFORMATION\n", Request));
 
        status = RequestValidateSendOpcInformation(Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_CDROM_GET_PERFORMANCE:
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                    "RequestDispatchToSequentialQueue: [%p] IOCTL_CDROM_GET_PERFORMANCE\n", Request));
 
        status = RequestValidateGetPerformance(Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_MEDIA_REMOVAL:
    case IOCTL_STORAGE_EJECTION_CONTROL:
    {
        if(RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
           sizeof(PREVENT_MEDIA_REMOVAL))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_MCN_CONTROL:
    {
        if(RequestParameters.Parameters.DeviceIoControl.InputBufferLength <
            sizeof(PREVENT_MEDIA_REMOVAL))
        {
            status = STATUS_INFO_LENGTH_MISMATCH;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_RESERVE:
    case IOCTL_STORAGE_RELEASE:
    {
        // there is no validate check currently.
        status = STATUS_SUCCESS;
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_PERSISTENT_RESERVE_IN:
    case IOCTL_STORAGE_PERSISTENT_RESERVE_OUT:
    {
        status = RequestValidatePersistentReserve(deviceExtension, Request, RequestParameters, &dataLength);
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_STORAGE_EJECT_MEDIA:
    case IOCTL_STORAGE_LOAD_MEDIA:
    case IOCTL_STORAGE_LOAD_MEDIA2:
    {
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_FIND_NEW_DEVICES:
    {
        // process it.
        IoInvalidateDeviceRelations(deviceExtension->LowerPdo, BusRelations);
 
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_READ_CAPACITY:
    {
        if (RequestParameters.Parameters.DeviceIoControl.OutputBufferLength < sizeof(STORAGE_READ_CAPACITY))
        {
            dataLength = sizeof(STORAGE_READ_CAPACITY);
            status = STATUS_BUFFER_TOO_SMALL;
        }
        else if (inZeroPowerState != FALSE)
        {
            status = STATUS_NO_MEDIA_IN_DEVICE;
        }
        else
        {
            status = STATUS_SUCCESS;
        }
 
        processed = TRUE;
        break; // complete the irp
    }
 
    case IOCTL_STORAGE_CHECK_PRIORITY_HINT_SUPPORT:
    {
        // for disk.sys only in original classpnp
        status = STATUS_NOT_SUPPORTED;
 
        processed = TRUE;
        break; // complete the irp
    }
 
#if (NTDDI_VERSION >= NTDDI_WIN8)
    case IOCTL_DISK_ARE_VOLUMES_READY:
    {
        // this request doesn't access device at all, so seemingly it can be processed
        // directly; however, in case volume online is not received, we will need to
        // park these requests in a queue, and the only way a request can be queued is
        // if the request came out of another queue.
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break;
    }
 
    case IOCTL_VOLUME_ONLINE:
    case IOCTL_VOLUME_POST_ONLINE:
    {
        status = STATUS_SUCCESS;
 
        processed = TRUE;
        break;
    }
#endif
 
    default:
    {
        processed = FALSE;
        break;
    }
    } //end of switch (ioctlCode)
 
    if (processed)
    {
        UCHAR currentStackLocationFlags = 0;
        currentStackLocationFlags = RequestGetCurrentStackLocationFlags(Request);
 
        if ((status == STATUS_VERIFY_REQUIRED) &&
            (currentStackLocationFlags & SL_OVERRIDE_VERIFY_VOLUME))
        {
            // If the status is verified required and this request
            // should bypass verify required then retry the request.
            status = STATUS_IO_DEVICE_ERROR;
            UNREFERENCED_PARAMETER(status); // disables prefast warning; defensive coding...
 
            processed = RequestDispatchToSequentialQueue(Device, Request, RequestParameters);
        }
        else
        {
            if (NT_SUCCESS(status))
            {
                // Forward the request to serialized queue.
                status = WdfDeviceEnqueueRequest(Device, Request);
            }
 
            if (!NT_SUCCESS(status))
            {
                // Validation failed / forward failed, complete the request.
                RequestCompletion(deviceExtension, Request, status, dataLength);
            }
        }
    }
 
    return processed;
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchToSequentialQueue().

RequestDispatchUnknownRequests()

BOOLEAN RequestDispatchUnknownRequests	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request,
		_In_ WDF_REQUEST_PARAMETERS	RequestParameters
	)

Definition at line 3093 of file cdrom.c.

{
    NTSTATUS                status = STATUS_UNSUCCESSFUL;
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
 
    ULONG       baseCode = DEVICE_TYPE_FROM_CTL_CODE(RequestParameters.Parameters.DeviceIoControl.IoControlCode);
 
    if ((KeGetCurrentIrql() != PASSIVE_LEVEL) ||
        (baseCode == FILE_DEVICE_ACPI))
    {
        // 1. When IRQL is higher than PASSIVE_LEVEL,
        // 2. ataport sends IOCTL_ACPI_ASYNC_EVAL_METHOD before queue starts,
        // send request directly to lower driver.
        status = RequestHandleUnknownIoctl(Device, Request);
    }
    else
    {
        // keep the request in serialized manner and stay in user's context.
        status = RequestSetContextFields(Request, RequestHandleUnknownIoctl);
 
        if (NT_SUCCESS(status))
        {
            status = RequestSynchronizeProcessWithSerialQueue(Device, Request);
        }
        else
        {
            RequestCompletion(deviceExtension, Request, status, 0);
        }
    }
 
    UNREFERENCED_PARAMETER(status); //defensive coding, avoid PREFAST warning.
 
    // All unknown IOCTLs are processed in this function.
    return TRUE; //processed
}

Referenced by DeviceEvtIoInCallerContext(), and RequestDispatchSpecialIoctls().

RequestEvtCleanup()

VOID NTAPI RequestEvtCleanup

(

_In_ WDFOBJECT

Request

)

Definition at line 4215 of file cdrom.c.

{
    WDFREQUEST              request = (WDFREQUEST)Request;
    PCDROM_REQUEST_CONTEXT  requestContext = RequestGetContext(request);
 
    if (requestContext->SyncRequired)
    {
        // the event should have been signaled, just check that
        NT_ASSERT(KeReadStateEvent(requestContext->SyncEvent) != 0);
    }
}

RequestIsIoctlBlockedByExclusiveAccess()

NTSTATUS RequestIsIoctlBlockedByExclusiveAccess	(	_In_ WDFREQUEST	Request,
		_Out_ PBOOLEAN	IsBlocked
	)

Definition at line 4058 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    ULONG                   ioctlCode = 0;
    ULONG                   baseCode = 0;
    WDF_REQUEST_PARAMETERS  requestParameters;
 
    // Get the Request parameters
    WDF_REQUEST_PARAMETERS_INIT(&requestParameters);
    WdfRequestGetParameters(Request, &requestParameters);
 
    // check and initialize parameter
    if (IsBlocked == NULL)
    {
        //This is an internal function and this parameter must be supplied.
        NT_ASSERT(FALSE);
 
        return STATUS_INVALID_PARAMETER;
    }
    else
    {
        *IsBlocked = FALSE;
    }
 
    // check if this is an IOCTL
    if ((requestParameters.Type == WdfRequestTypeDeviceControl) ||
        (requestParameters.Type == WdfRequestTypeDeviceControlInternal))
    {
        //
        // Allow minimum set of commands that are required for the disk manager
        // to show the CD device, while in exclusive mode.
        // Note: These commands should not generate any requests to the device,
        //       and thus must be handled directly in StartIO during exclusive
        //       access (except for the exclusive owner, of course).
        //
        ioctlCode = requestParameters.Parameters.DeviceIoControl.IoControlCode;
        baseCode = DEVICE_TYPE_FROM_CTL_CODE(ioctlCode);
 
        if (ioctlCode == IOCTL_SCSI_GET_ADDRESS           ||
            ioctlCode == IOCTL_STORAGE_GET_HOTPLUG_INFO   ||
            ioctlCode == IOCTL_STORAGE_GET_DEVICE_NUMBER  ||
            ioctlCode == IOCTL_STORAGE_GET_MEDIA_TYPES_EX ||
            ioctlCode == IOCTL_CDROM_EXCLUSIVE_ACCESS     ||
            ioctlCode == IOCTL_CDROM_GET_INQUIRY_DATA
            )
        {
            *IsBlocked = FALSE;
        }
 
        //
        // Handle IOCTL_STORAGE_QUERY_PROPERTY special because:
        //  (1) PropertyExistsQuery should not generate device i/o
        //  (2) Queries for StorageDeviceProperty and StorageAdapterDescriptor
        //      will return cache'd data
    else if (ioctlCode == IOCTL_STORAGE_QUERY_PROPERTY)
        {
            PSTORAGE_PROPERTY_QUERY query = NULL;
            status = WdfRequestRetrieveInputBuffer(Request,
                                                   requestParameters.Parameters.DeviceIoControl.InputBufferLength,
                                                   (PVOID*)&query,
                                                   NULL);
 
            if (NT_SUCCESS(status))
            {
                if (query != NULL)
                {
                    if (query->QueryType == PropertyExistsQuery)
                    {
                        *IsBlocked = FALSE;
                    }
                    else if ((query->QueryType == PropertyStandardQuery) &&
                             ((query->PropertyId == StorageDeviceProperty) ||
                              (query->PropertyId == StorageAdapterProperty)))
                    {
                        *IsBlocked = FALSE;
                    }
                }
            }
        }
 
        // Return TRUE for unknown IOCTLs with STORAGE bases
    else if (baseCode == IOCTL_SCSI_BASE    ||
            baseCode == IOCTL_DISK_BASE    ||
            baseCode == IOCTL_CDROM_BASE   ||
            baseCode == IOCTL_STORAGE_BASE ||
            baseCode == IOCTL_DVD_BASE     )
        {
            *IsBlocked = TRUE;
        }
    }
    else
    {
        // this should only be called with an IOCTL
        NT_ASSERT(FALSE);
 
        status = STATUS_INVALID_PARAMETER;
    }
 
    return status;
}

Referenced by DeviceEvtIoInCallerContext(), RequestSynchronizeProcessWithSerialQueue(), and SequentialQueueEvtIoDeviceControl().

RequestProcessInternalDeviceControl()

VOID RequestProcessInternalDeviceControl	(	_In_ WDFREQUEST	Request,
		_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension
	)

Definition at line 3154 of file cdrom.c.

{
    NTSTATUS                 status = STATUS_SUCCESS;
    PIRP                     irp = NULL;
    PIO_STACK_LOCATION       irpStack = NULL;
    PIO_STACK_LOCATION       nextStack = NULL;
    BOOLEAN                  requestSent = FALSE;
 
    irp = WdfRequestWdmGetIrp(Request);
    irpStack = IoGetCurrentIrpStackLocation(irp);
    nextStack = IoGetNextIrpStackLocation(irp);
 
    // Set the parameters in the next stack location.
    nextStack->Parameters.Scsi.Srb = irpStack->Parameters.Scsi.Srb;
    nextStack->MajorFunction = IRP_MJ_SCSI;
    nextStack->MinorFunction = IRP_MN_SCSI_CLASS;
 
    WdfRequestSetCompletionRoutine(Request, RequestDummyCompletionRoutine, NULL);
 
    status = RequestSend(DeviceExtension,
                         Request,
                         DeviceExtension->IoTarget,
                         0,
                         &requestSent);
 
    // send the request straight down (asynchronously)
    if (!requestSent)
    {
        // fail the request
        RequestCompletion(DeviceExtension, Request, status, WdfRequestGetInformation(Request));
    }
 
    return;
}

Referenced by DeviceEvtIoInCallerContext().

RequestSynchronizeProcessWithSerialQueue()

NTSTATUS RequestSynchronizeProcessWithSerialQueue	(	_In_ WDFDEVICE	Device,
		_In_ WDFREQUEST	Request
	)

Definition at line 3893 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(Device);
    PCDROM_REQUEST_CONTEXT  requestContext = RequestGetContext(Request);
    PKEVENT                 bufferToFree = requestContext->SyncEvent;
 
    if (KeGetCurrentIrql() >= DISPATCH_LEVEL) {
        // cannot block at or above DISPATCH_LEVEL
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
            "RequestSynchronousProcessWithSerialQueue called at DISPATCH_LEVEL or above"));
        NT_ASSERT(FALSE);
        RequestCompletion(deviceExtension, Request, STATUS_INVALID_LEVEL, 0);
        return STATUS_INVALID_LEVEL;
    }
 
    // init the synchronization event
    KeInitializeEvent(requestContext->SyncEvent, NotificationEvent, FALSE);
 
    // do we still need to do something like this?
    // SET_FLAG(nextStack->Flags, SL_OVERRIDE_VERIFY_VOLUME);
 
    // NOTE: this mechanism relies on that KMDF will not complete request by itself.
    // Doing that will cause the syncEvent not fired thus this thread will stuck.
    // This should not really happen: our EvtCanceledOnQueue callbacks should be
    // called even if queues are purged for some reason. The only case when these
    // callbacks are not called is when a request is owned by the driver (i.e. has
    // already been passed to one of the registered handlers). In this case, it is
    // our responsibility to cancel such requests properly.
    status = WdfDeviceEnqueueRequest(Device, Request);
 
    if (!NT_SUCCESS(status))
    {
        // Failed to forward request! Pretend the sync event already occured, otherwise we'll hit
        // an assert in RequestEvtCleanup.
        KeSetEvent(requestContext->SyncEvent, IO_CD_ROM_INCREMENT, FALSE);
        RequestCompletion(deviceExtension, Request, status, WdfRequestGetInformation(Request));
    }
    else
    {
        NTSTATUS                waitStatus = STATUS_UNSUCCESSFUL;
        PCDROM_DATA             cdData = &(deviceExtension->DeviceAdditionalData);
        BOOLEAN                 fCallSyncCallback = FALSE;
        PIRP                    irp = WdfRequestWdmGetIrp(Request);
 
        // ok, now wait on the event
        while (waitStatus != STATUS_SUCCESS)
        {
            waitStatus = KeWaitForSingleObject(requestContext->SyncEvent, Executive, KernelMode, TRUE, NULL);
            if (waitStatus == STATUS_SUCCESS) // must check equality -- STATUS_ALERTED is success code
            {
                // do nothing
            }
            else if (waitStatus != STATUS_ALERTED)
            {
                // do nothing
                TracePrint((TRACE_LEVEL_FATAL, TRACE_FLAG_IOCTL,
                            "Request %p on device object %p had a non-alert, non-success result from wait (%!HRESULT!)\n",
                            Request, Device, waitStatus));
                NT_ASSERT(FALSE);
            }
            else if (PsIsThreadTerminating(PsGetCurrentThread()))
            {
                // the thread was alerted and is terminating, so cancel the irp
                // this will cause EvtIoCanceledOnQueue to be called, which will signal the event,
                // so we will get out of the while loop and eventually complete the request.
                if (IoCancelIrp(irp))
                {
                    // cancellation routine was called
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                                "Sychronize Ioctl: request %p cancelled from device %p\n",
                                Request, Device));
                }
                else
                {
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                                "Sychronize Ioctl: request %p could not be cancelled from device %p\n",
                                Request, Device));
                }
            }
            else
            {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_IOCTL,
                            "SPURIOUS ALERT waiting for Request %p on device %p (%!STATUS!)\n",
                            Request, Device, status));
            }
        } // end of wait loop on the event
 
        // because we've waited an unknown amount of time, should check
        // the cancelled flag to immediately fail the irp as appropriate
        if (WdfRequestIsCanceled(Request))
        {
            // the request was cancelled, thus we should always stop
            // processing here if possible.
            status = STATUS_CANCELLED;
            RequestCompletion(deviceExtension, Request, status, 0);
        }
        else if (EXCLUSIVE_MODE(cdData) && !EXCLUSIVE_OWNER(cdData, WdfRequestGetFileObject(Request)))
        {
            WDF_REQUEST_PARAMETERS  requestParameters;
            BOOLEAN                 isBlocked = FALSE;
 
            // get the request parameters
            WDF_REQUEST_PARAMETERS_INIT(&requestParameters);
            WdfRequestGetParameters(Request, &requestParameters);
 
            status = RequestIsIoctlBlockedByExclusiveAccess(Request, &isBlocked);
            if (isBlocked)
            {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                            "Access Denied! Device in exclusive mode.Failing Ioctl %lx\n",
                            requestParameters.Parameters.DeviceIoControl.IoControlCode));
                RequestCompletion(deviceExtension, Request, STATUS_ACCESS_DENIED, 0);
            }
            else
            {
                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_IOCTL,
                            "Ioctl %lx not blocked by cdrom being in exclusive mode\n",
                            requestParameters.Parameters.DeviceIoControl.IoControlCode));
                fCallSyncCallback = TRUE;
            }
        }
        else
        {
            fCallSyncCallback = TRUE;
        }
 
        if (fCallSyncCallback)
        {
            // Synchronization completed successfully.  Call the requested routine
            status = requestContext->SyncCallback(Device, Request);
        }
    }
 
    // The next SequentialQueue evt routine will not be triggered until the current request is completed.
 
    // clean up the request context setting.
    FREE_POOL(bufferToFree);
 
    return status;
}

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

SequentialQueueEvtCanceledOnQueue()

VOID NTAPI SequentialQueueEvtCanceledOnQueue	(	_In_ WDFQUEUE	Queue,
		_In_ WDFREQUEST	Request
	)

Definition at line 3848 of file cdrom.c.

{
    PCDROM_REQUEST_CONTEXT  requestContext = RequestGetContext(Request);
 
    if (requestContext->SyncRequired)
    {
        KeSetEvent(requestContext->SyncEvent, IO_CD_ROM_INCREMENT, FALSE);
    }
    else
    {
        PCDROM_DEVICE_EXTENSION deviceExtension = NULL;
        WDFDEVICE               device = WdfIoQueueGetDevice(Queue);
 
        deviceExtension = DeviceGetExtension(device);
 
        RequestCompletion(deviceExtension, Request, STATUS_CANCELLED, 0);
 
    }
 
    return;
}

SequentialQueueEvtIoDeviceControl()

VOID NTAPI SequentialQueueEvtIoDeviceControl	(	_In_ WDFQUEUE	Queue,
		_In_ WDFREQUEST	Request,
		_In_ size_t	OutputBufferLength,
		_In_ size_t	InputBufferLength,
		_In_ ULONG	IoControlCode
	)

Definition at line 3408 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    WDFDEVICE               device = WdfIoQueueGetDevice(Queue);
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(device);
    PCDROM_REQUEST_CONTEXT  requestContext = RequestGetContext(Request);
    PCDROM_DATA             cdData = &(deviceExtension->DeviceAdditionalData);
    WDF_REQUEST_PARAMETERS  requestParameters;
 
    UNREFERENCED_PARAMETER(OutputBufferLength);
    UNREFERENCED_PARAMETER(InputBufferLength);
    UNREFERENCED_PARAMETER(IoControlCode);
 
    // get the request parameters
    WDF_REQUEST_PARAMETERS_INIT(&requestParameters);
    WdfRequestGetParameters(Request, &requestParameters);
 
    // If the device is in exclusive mode, check whether the request is from
    // the handle that locked the device
    if (EXCLUSIVE_MODE(cdData) && !EXCLUSIVE_OWNER(cdData, WdfRequestGetFileObject(Request)))
    {
        BOOLEAN isBlocked = FALSE;
 
        status = RequestIsIoctlBlockedByExclusiveAccess(Request, &isBlocked);
        if (NT_SUCCESS(status) && isBlocked)
        {
            if (requestContext->SyncRequired)
            {
                // set the following event, so RequestSynchronizeProcessWithSerialQueue() can contintue run to process the real request.
                // this function will wait for the request process finishes.
                KeSetEvent(requestContext->SyncEvent, IO_CD_ROM_INCREMENT, FALSE);
            }
            else
            {
                TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_IOCTL,
                            "DeviceEvtIoInCallerContext: Access Denied! Device in exclusive mode.Failing Ioctl %lx\n",
                            requestParameters.Parameters.DeviceIoControl.IoControlCode));
                RequestCompletion(deviceExtension, Request, STATUS_ACCESS_DENIED, 0);
            }
 
            return;
        }
    }
 
    if (!cdData->Mmc.WriteAllowed &&
        ((requestParameters.Parameters.DeviceIoControl.IoControlCode == IOCTL_DISK_IS_WRITABLE) ||
         (requestParameters.Parameters.DeviceIoControl.IoControlCode == IOCTL_DISK_VERIFY)))
    {
        cdData->Mmc.UpdateState = CdromMmcUpdateRequired;
    }
 
    // check if this is a synchronized ioctl
    if (requestContext->SyncRequired)
    {
        // set the following event, so RequestSynchronizeProcessWithSerialQueue() can contintue run to process the real request.
        // this function will wait for the request process finishes.
        KeSetEvent(requestContext->SyncEvent, IO_CD_ROM_INCREMENT, FALSE);
    }
    else
    {
        deviceExtension->IoctlWorkItemContext.OriginalRequest = Request;
 
        // all other IOCTL processing is currently processed via a
        // work item running at PASSIVE_LEVEL.
        WdfWorkItemEnqueue(deviceExtension->IoctlWorkItem);
    }
 
    return;
}

SequentialQueueEvtIoReadWrite()

VOID NTAPI SequentialQueueEvtIoReadWrite	(	_In_ WDFQUEUE	Queue,
		_In_ WDFREQUEST	Request,
		_In_ size_t	Length
	)

Definition at line 3215 of file cdrom.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    WDFDEVICE               device = WdfIoQueueGetDevice(Queue);
    PCDROM_DEVICE_EXTENSION deviceExtension = DeviceGetExtension(device);
    WDF_REQUEST_PARAMETERS  requestParameters;
    PIRP                    wdmIrp = WdfRequestWdmGetIrp(Request);
    PIO_STACK_LOCATION      currentIrpStack = IoGetCurrentIrpStackLocation(wdmIrp);
    PCDROM_DATA             cdData = &(deviceExtension->DeviceAdditionalData);
 
    // Get the request parameters
    WDF_REQUEST_PARAMETERS_INIT(&requestParameters);
    WdfRequestGetParameters(Request, &requestParameters);
 
    if (requestParameters.Type ==  WdfRequestTypeRead)
    {
        TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL,
                    "Receiving READ, Length %Ix\n", (ULONG) Length));
    }
    else
    {
        TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL,
                    "Receiving WRITE, Length %Ix\n", (ULONG) Length));
    }
 
    // Check if a verify is required before a READ/WRITE
    if (TEST_FLAG(deviceExtension->DeviceObject->Flags, DO_VERIFY_VOLUME) &&
        (requestParameters.MinorFunction != CDROM_VOLUME_VERIFY_CHECKED) &&
        !TEST_FLAG(currentIrpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME))
    {
        //  DO_VERIFY_VOLUME is set for the device object,
        //  but this request is not itself a verify request.
        //  So fail this request.
        RequestCompletion(deviceExtension, Request, STATUS_VERIFY_REQUIRED, 0);
    }
    else
    {
        //  Since we've bypassed the verify-required tests we don't need to repeat
        //  them with this IRP - in particular we don't want to worry about
        //  hitting them at the partition 0 level if the request has come through
        //  a non-zero partition.
        currentIrpStack->MinorFunction = CDROM_VOLUME_VERIFY_CHECKED;
 
        // Fail READ/WRITE requests when music is playing
        if (deviceExtension->DeviceAdditionalData.PlayActive)
        {
            RequestCompletion(deviceExtension, Request, STATUS_DEVICE_BUSY, 0);
 
            return;
        }
 
        // Fail READ/WRITE requests from non-owners if the drive is locked
        if (EXCLUSIVE_MODE(cdData) && !EXCLUSIVE_OWNER(cdData, WdfRequestGetFileObject(Request)))
        {
            RequestCompletion(deviceExtension, Request, STATUS_ACCESS_DENIED, 0);
 
            return;
        }
 
        // Succeed READ/WRITE requests of length 0
        if (Length == 0)
        {
            //  Several parts of the code turn 0 into 0xffffffff,
            //  so don't process a zero-length request any further.
            RequestCompletion(deviceExtension, Request, STATUS_SUCCESS, Length);
 
            return;
        }
 
        // If there is an unexpected write request, we want to rediscover MMC capabilities
        if (!deviceExtension->DeviceAdditionalData.Mmc.WriteAllowed &&
            (requestParameters.Type == WdfRequestTypeWrite))
        {
            // Schedule MMC capabilities update now, but perform it later in a work item
            deviceExtension->DeviceAdditionalData.Mmc.UpdateState = CdromMmcUpdateRequired;
        }
 
        // If MMC capabilities update is required, we create a separate work item to avoid blocking
        // the current thread; otherwise, we initiate an async read/write in the current thread.
        if (DeviceIsMmcUpdateRequired(deviceExtension->Device))
        {
            deviceExtension->ReadWriteWorkItemContext.OriginalRequest = Request;
            WdfWorkItemEnqueue(deviceExtension->ReadWriteWorkItem);
 
            status = STATUS_SUCCESS;
        }
        else
        {
            status = RequestValidateReadWrite(deviceExtension, Request, requestParameters);
 
            if (NT_SUCCESS(status))
            {
                status = RequestHandleReadWrite(deviceExtension, Request, requestParameters);
            }
        }
 
        if (!NT_SUCCESS(status))
        {
            RequestCompletion(deviceExtension, Request, status, 0);
        }
    }
 
    return;
}

Referenced by DriverEvtDeviceAdd().