cdrom.h File Reference

#include "wdf.h"
#include "ntddmmc.h"
#include "ntddcdvd.h"
#include "ntddcdrm.h"
#include "ntdddisk.h"
#include "ntddtape.h"
#include "ntddscsi.h"
#include "ntddvol.h"
#include "specstrings.h"
#include "cdromp.h"
#include <initguid.h>
#include <storswtr.h>

Include dependency graph for cdrom.h:

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

Go to the source code of this file.

Classes
struct	_ERROR_RECOVERY_DATA
struct	_CDROM_DRIVER_EXTENSION
struct	_CDROM_MMC_EXTENSION
struct	_CDROM_SCRATCH_READ_WRITE_CONTEXT
struct	_CDROM_SCRATCH_CONTEXT
struct	_CDROM_IOCTL_CONTEXT
struct	_CDROM_READ_WRITE_CONTEXT
struct	_CDROM_DATA
struct	_CDROM_POWER_OPTIONS
struct	_CDROM_POWER_CONTEXT
struct	_CDROM_DEVICE_EXTENSION
struct	_CDROM_REQUEST_CONTEXT
struct	_COMPLETION_CONTEXT

Macros
#define	DEBUG_COMP_ID   DPFLTR_CDROM_ID
#define	WPP_GUID_CDROM   (A4196372, C3C4, 42d5, 87BF, 7EDB2E9BCC27)
#define	WPP_CONTROL_GUIDS   WPP_CONTROL_GUIDS_NORMAL_FLAGS(WPP_GUID_CDROM)
#define	CDROM_HACK_DEC_RRD   (0x00000001)
#define	CDROM_HACK_FUJITSU_FMCD_10x   (0x00000002)
#define	CDROM_HACK_HITACHI_GD_2000   (0x00000008)
#define	CDROM_HACK_TOSHIBA_SD_W1101   (0x00000010)
#define	CDROM_HACK_BAD_GET_CONFIG_SUPPORT   (0x00000100)
#define	CDROM_HACK_BAD_TYPE_ONE_GET_CONFIG   (0x00000800)
#define	CDROM_HACK_BAD_VENDOR_PROFILES   (0x00001000)
#define	CDROM_HACK_MSFT_VIRTUAL_ODD   (0x00002000)
#define	CDROM_HACK_LOCKED_PAGES   (0x80000000)
#define	CDROM_HACK_VALID_FLAGS   (0x00003fff)
#define	CDROM_HACK_INVALID_FLAGS   (~CDROM_HACK_VALID_FLAGS)
#define	WRITE_RETRY_DELAY_CD_1x   ((LONGLONG)4266667)
#define	WRITE_RETRY_DELAY_CD_4x   ((LONGLONG)1066667)
#define	WRITE_RETRY_DELAY_CD_10x   ((LONGLONG) 426667)
#define	WRITE_RETRY_DELAY_DVD_1x   ((LONGLONG) 473373)
#define	WRITE_RETRY_DELAY_DVD_4x   ((LONGLONG) 118343)
#define	WRITE_RETRY_DELAY_DVD_16x   ((LONGLONG) 29586)
#define	WRITE_RETRY_DELAY_HDDVD_1x   ((LONGLONG) 143498)
#define	MAXIMUM_RETRIES   4
#define	CDROM_GET_CONFIGURATION_TIMEOUT   (0x4)
#define	CDROM_READ_DISC_INFORMATION_TIMEOUT   (0x4)
#define	CDROM_TEST_UNIT_READY_TIMEOUT   (0x14)
#define	CDROM_GET_PERFORMANCE_TIMEOUT   (0x14)
#define	CDROM_READ_CAPACITY_TIMEOUT   (0x14)
#define	START_UNIT_TIMEOUT   (60 * 4)
#define	MEDIA_CHANGE_TIMEOUT_TIME   300
#define	DEV_SAFE_START_UNIT   0x00000004
#define	DEV_POWER_PROTECTED   0x00000010
#define	CDROM_SPECIAL_DISABLE_SPIN_DOWN   0x00000001
#define	CDROM_SPECIAL_DISABLE_WRITE_CACHE   0x00000010
#define	SRB_CLASS_FLAGS_LOW_PRIORITY   0x10000000
#define	SRB_CLASS_FLAGS_PAGING   0x40000000
#define	CDROM_INTERPRET_SENSE_INFO2_MAXIMUM_HISTORY_COUNT   30000
#define	IOCTL_MCN_SYNC_FAKE_IOCTL   IOCTL_DISK_UPDATE_DRIVE_SIZE
#define	CDROM_FLAG_WINPE_MODE   0x00000001
#define	CdromMmcUpdateComplete   0
#define	CdromMmcUpdateRequired   1
#define	CdromMmcUpdateStarted   2
#define	SCSI_CDROM_TIMEOUT   10
#define	SCSI_CHANGER_BONUS_TIMEOUT   10
#define	SCSI_CDROM_OPC_TIMEOUT   260
#define	HITACHI_MODE_DATA_SIZE   12
#define	MODE_DATA_SIZE   64
#define	RAW_SECTOR_SIZE   2352
#define	COOKED_SECTOR_SIZE   2048
#define	CDROM_SRB_LIST_SIZE   4
#define	PLAY_ACTIVE(x)   (x->DeviceAdditionalData.PlayActive)
#define	MSF_TO_LBA(Minutes, Seconds, Frames)   (ULONG)((60 * 75 * (Minutes)) + (75 * (Seconds)) + ((Frames) - 150))
#define	ANY_SECTOR   0
#define	CD_DA_SECTOR   1
#define	YELLOW_MODE1_SECTOR   2
#define	YELLOW_MODE2_SECTOR   3
#define	FORM2_MODE1_SECTOR   4
#define	FORM2_MODE2_SECTOR   5
#define	MAX_COPY_PROTECT_AGID   4
#define	CDROM_TAG_AUTORUN_DISABLE   'ACcS'
#define	CDROM_TAG_MEDIA_CHANGE_DETECTION   'aCcS'
#define	CDROM_TAG_SCRATCH   'BCcS'
#define	CDROM_TAG_GET_CONFIG   'CCcS'
#define	CDROM_TAG_COMPLETION_CONTEXT   'cCcS'
#define	CDROM_TAG_DESCRIPTOR   'DCcS'
#define	CDROM_TAG_DISC_INFO   'dCcS'
#define	CDROM_TAG_SYNC_EVENT   'eCcS'
#define	CDROM_TAG_FEATURE   'FCcS'
#define	CDROM_TAG_GESN   'GCcS'
#define	CDROM_TAG_SENSE_INFO   'ICcS'
#define	CDROM_TAG_INQUIRY   'iCcS'
#define	CDROM_TAG_MODE_DATA   'MCcS'
#define	CDROM_TAG_STREAM   'OCCS'
#define	CDROM_TAG_NOTIFICATION   'oCcS'
#define	CDROM_TAG_PLAY_ACTIVE   'pCcS'
#define	CDROM_TAG_REGISTRY   'rCcS'
#define	CDROM_TAG_SRB   'SCcS'
#define	CDROM_TAG_STRINGS   'sCcS'
#define	CDROM_TAG_UPDATE_CAP   'UCcS'
#define	CDROM_TAG_ZERO_POWER_ODD   'ZCcS'
#define	DVD_TAG_READ_KEY   'uCcS'
#define	DVD_TAG_RPC2_CHECK   'VCcS'
#define	DVD_TAG_DVD_REGION   'vCcS'
#define	DVD_TAG_SECURITY   'XCcS'
#define	CDROM_SUBKEY_NAME   (L"CdRom")
#define	CDROM_READ_CD_NAME   (L"ReadCD")
#define	CDROM_NON_MMC_DRIVE_NAME   (L"NonMmc")
#define	CDROM_TYPE_ONE_GET_CONFIG_NAME   (L"NoTypeOneGetConfig")
#define	CDROM_NON_MMC_VENDOR_SPECIFIC_PROFILE   (L"NonMmcVendorSpecificProfile")
#define	DVD_DEFAULT_REGION   (L"DefaultDvdRegion")
#define	DVD_MAX_REGION   8
#define	AACS_MKB_PACK_SIZE   0x8000
#define	FREE_POOL(_PoolPtr)
#define	EXCLUSIVE_MODE(_CdData)   (_CdData->ExclusiveOwner != NULL)
#define	EXCLUSIVE_OWNER(_CdData, _FileObject)   (_CdData->ExclusiveOwner == _FileObject)
#define	IS_SCSIOP_READ(opCode)
#define	IS_SCSIOP_WRITE(opCode)
#define	IS_SCSIOP_READWRITE(opCode)   (IS_SCSIOP_READ(opCode) || IS_SCSIOP_WRITE(opCode))
#define	SET_FLAG(Flags, Bit)   ((Flags) |= (Bit))
#define	CLEAR_FLAG(Flags, Bit)   ((Flags) &= ~(Bit))
#define	TEST_FLAG(Flags, Bit)   (((Flags) & (Bit)) != 0)
#define	SIZEOF_ARRAY(ar)   (sizeof(ar)/sizeof((ar)[0]))
#define	UNIT_100NS_PER_SECOND   (10*1000*1000)
#define	SECONDS_TO_100NS_UNITS(x)   (((LONGLONG)x) * UNIT_100NS_PER_SECOND)
#define	SET_FLAG(Flags, Bit)   ((Flags) |= (Bit))
#define	CLEAR_FLAG(Flags, Bit)   ((Flags) &= ~(Bit))
#define	TEST_FLAG(Flags, Bit)   (((Flags) & (Bit)) != 0)

Typedefs
typedef struct _ERROR_RECOVERY_DATA	ERROR_RECOVERY_DATA
typedef struct _ERROR_RECOVERY_DATA *	PERROR_RECOVERY_DATA
typedef struct _CDROM_DEVICE_EXTENSION	CDROM_DEVICE_EXTENSION
typedef struct _CDROM_DEVICE_EXTENSION *	PCDROM_DEVICE_EXTENSION
typedef VOID(*	PCDROM_ERROR_HANDLER) (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _Inout_ PNTSTATUS Status, _Inout_ PBOOLEAN Retry)
typedef struct _CDROM_DRIVER_EXTENSION	CDROM_DRIVER_EXTENSION
typedef struct _CDROM_DRIVER_EXTENSION *	PCDROM_DRIVER_EXTENSION
typedef struct _CDROM_MMC_EXTENSION	CDROM_MMC_EXTENSION
typedef struct _CDROM_MMC_EXTENSION *	PCDROM_MMC_EXTENSION
typedef struct _CDROM_SCRATCH_READ_WRITE_CONTEXT	CDROM_SCRATCH_READ_WRITE_CONTEXT
typedef struct _CDROM_SCRATCH_READ_WRITE_CONTEXT *	PCDROM_SCRATCH_READ_WRITE_CONTEXT
typedef struct _CDROM_SCRATCH_CONTEXT	CDROM_SCRATCH_CONTEXT
typedef struct _CDROM_SCRATCH_CONTEXT *	PCDROM_SCRATCH_CONTEXT
typedef struct _CDROM_IOCTL_CONTEXT	CDROM_IOCTL_CONTEXT
typedef struct _CDROM_IOCTL_CONTEXT *	PCDROM_IOCTL_CONTEXT
typedef struct _CDROM_READ_WRITE_CONTEXT	CDROM_READ_WRITE_CONTEXT
typedef struct _CDROM_READ_WRITE_CONTEXT *	PCDROM_READ_WRITE_CONTEXT
typedef struct _CDROM_DATA	CDROM_DATA
typedef struct _CDROM_DATA *	PCDROM_DATA
typedef struct _CDROM_POWER_OPTIONS	CDROM_POWER_OPTIONS
typedef struct _CDROM_POWER_OPTIONS *	PCDROM_POWER_OPTIONS
typedef struct _CDROM_POWER_CONTEXT	CDROM_POWER_CONTEXT
typedef struct _CDROM_POWER_CONTEXT *	PCDROM_POWER_CONTEXT
typedef NTSTATUS	SYNC_HANDLER(_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)
typedef SYNC_HANDLER *	PSYNC_HANDLER
typedef struct _CDROM_REQUEST_CONTEXT	CDROM_REQUEST_CONTEXT
typedef struct _CDROM_REQUEST_CONTEXT *	PCDROM_REQUEST_CONTEXT
typedef struct _COMPLETION_CONTEXT	COMPLETION_CONTEXT
typedef struct _COMPLETION_CONTEXT *	PCOMPLETION_CONTEXT
typedef enum CDROM_DEVICE_INTERFACES *	PCDROM_DEVICE_INTERFACES
typedef VOID(*	PCDROM_SCAN_FOR_SPECIAL_HANDLER) (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ ULONG_PTR Data)

Enumerations
enum	CDROM_POWER_DOWN_STATE {   PowerDownDeviceInitial, PowerDownDeviceLocked, PowerDownDeviceQuiesced, PowerDownDeviceFlushed,   PowerDownDeviceStopped, PowerDownDeviceOff, PowerDownDeviceUnlocked }
enum	CDROM_POWER_UP_STATE {   PowerUpDeviceInitial, PowerUpDeviceLocked, PowerUpDeviceOn, PowerUpDeviceStarted,   PowerUpDeviceUnlocked }
enum	CDROM_DEVICE_INTERFACES { CdRomDeviceInterface = 0, MountedDeviceInterface }

Functions
	_IRQL_requires_max_ (DISPATCH_LEVEL) NTKERNELAPI BOOLEAN NTAPI PsIsThreadTerminating(_In_ PETHREAD Thread)
	C_ASSERT ((MAXULONG - sizeof(SRB_HISTORY))/30000 >=sizeof(SRB_HISTORY_ITEM))
FORCEINLINE BOOLEAN	ValidChar (UCHAR Ch)
FORCEINLINE BOOLEAN	PORT_ALLOCATED_SENSE (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb)
FORCEINLINE VOID	FREE_PORT_ALLOCATED_SENSE_BUFFER (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb)
VOID NTAPI	SequentialQueueEvtIoReadWrite (_In_ WDFQUEUE Queue, _In_ WDFREQUEST Request, _In_ size_t Length)
	_IRQL_requires_max_ (PASSIVE_LEVEL) NTSTATUS DeviceClaimRelease(_In_ PCDROM_DEVICE_EXTENSION DeviceExtension
	_IRQL_requires_max_ (APC_LEVEL) VOID DeviceReleaseMcnResources(_In_ PCDROM_DEVICE_EXTENSION DeviceExtension)
BOOLEAN	RequestSenseInfoInterpret (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ PSCSI_REQUEST_BLOCK Srb, _In_ ULONG RetriedCount, _Out_ NTSTATUS *Status, _Out_opt_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *RetryIntervalIn100ns)
VOID	RequestSetReceivedTime (_In_ WDFREQUEST Request)
VOID	RequestSetSentTime (_In_ WDFREQUEST Request)
VOID	RequestClearSendTime (_In_ WDFREQUEST Request)
BOOLEAN	RequestSenseInfoInterpretForScratchBuffer (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ ULONG RetriedCount, _Out_ NTSTATUS *Status, _Out_ _Deref_out_range_(0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG *RetryIntervalIn100ns)
VOID	DeviceSendNotification (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ const GUID *Guid, _In_ ULONG ExtraDataSize, _In_opt_ PVOID ExtraData)
VOID	DeviceSendStartUnit (_In_ WDFDEVICE Device)
VOID	DeviceReleaseQueue (_In_ WDFDEVICE Device)
VOID	DevicePerfIncrementErrorCount (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	DeviceErrorHandlerForMmc (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _Inout_ PNTSTATUS Status, _Inout_ PBOOLEAN Retry)
NTSTATUS	DeviceErrorHandlerForHitachiGD2000 (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _Inout_ PNTSTATUS Status, _Inout_ PBOOLEAN Retry)
VOID	DeviceSetMediaChangeStateEx (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ MEDIA_CHANGE_DETECTION_STATE NewState, _Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE OldState)
NTSTATUS	RequestSynchronizeProcessWithSerialQueue (_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)
NTSTATUS	RequestIsIoctlBlockedByExclusiveAccess (_In_ WDFREQUEST Request, _Out_ PBOOLEAN IsBlocked)
VOID	DeviceSendIoctlAsynchronously (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ ULONG IoControlCode, _In_ PDEVICE_OBJECT TargetDeviceObject)
BOOLEAN	DeviceIsMmcUpdateRequired (_In_ WDFDEVICE Device)
NTSTATUS	RequestSetContextFields (_In_ WDFREQUEST Request, _In_ PSYNC_HANDLER Handler)
NTSTATUS	RequestDuidGetDeviceIdProperty (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
NTSTATUS	RequestDuidGetDeviceProperty (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDF_REQUEST_PARAMETERS RequestParameters, _Out_ size_t *DataLength)
	_In_reads_bytes_ (Length) PCHAR ModeSenseBuffer
VOID	RequestSetupMcnSyncIrp (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension)
NTSTATUS	DeviceZPODDGetPowerupReason (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _Out_ PSTORAGE_IDLE_POWERUP_REASON PowerupReason)
FORCEINLINE ULONG	CountOfSetBitsUChar (UCHAR _X)
FORCEINLINE ULONG	CountOfSetBitsULong (ULONG _X)
FORCEINLINE ULONG	CountOfSetBitsULong32 (ULONG32 _X)
FORCEINLINE ULONG	CountOfSetBitsULong64 (ULONG64 _X)
FORCEINLINE ULONG	CountOfSetBitsUlongPtr (ULONG_PTR _X)
FORCEINLINE BOOLEAN	IsVolumeMounted (_In_ PDEVICE_OBJECT DeviceObject)
FORCEINLINE	_Ret_range_ (0, MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS) LONGLONG ConvertSectorsPerSecondTo100nsUnitsFor64kWrite(_In_range_(1
FORCEINLINE UCHAR	RequestGetCurrentStackLocationFlags (_In_ WDFREQUEST Request)
FORCEINLINE ULONG	TimeOutValueGetCapValue (_In_ ULONG TimeOutValue, _In_ ULONG Times)
VOID	RequestCompletion (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ NTSTATUS Status, _In_ ULONG_PTR Information)
NTSTATUS	RequestSend (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ WDFREQUEST Request, _In_ WDFIOTARGET IoTarget, _In_ ULONG Flags, _Out_opt_ PBOOLEAN RequestSent)
VOID	RequestProcessInternalDeviceControl (_In_ WDFREQUEST Request, _In_ PCDROM_DEVICE_EXTENSION DeviceExtension)

Variables
CDROM_SCAN_FOR_SPECIAL_INFO	CdromHackItems []
DRIVER_INITIALIZE	DriverEntry
EVT_WDF_DRIVER_DEVICE_ADD	DriverEvtDeviceAdd
EVT_WDF_OBJECT_CONTEXT_CLEANUP	DriverEvtCleanup
EVT_WDF_OBJECT_CONTEXT_CLEANUP	DeviceEvtCleanup
EVT_WDF_FILE_CLOSE	DeviceEvtFileClose
EVT_WDF_IO_IN_CALLER_CONTEXT	DeviceEvtIoInCallerContext
EVT_WDF_DEVICE_SELF_MANAGED_IO_INIT	DeviceEvtSelfManagedIoInit
EVT_WDF_DEVICE_SELF_MANAGED_IO_CLEANUP	DeviceEvtSelfManagedIoCleanup
EVT_WDF_DEVICE_D0_ENTRY	DeviceEvtD0Entry
EVT_WDF_DEVICE_D0_EXIT	DeviceEvtD0Exit
EVT_WDF_DEVICE_SURPRISE_REMOVAL	DeviceEvtSurpriseRemoval
EVT_WDF_IO_QUEUE_IO_DEFAULT	CreateQueueEvtIoDefault
EVT_WDF_IO_QUEUE_IO_DEVICE_CONTROL	SequentialQueueEvtIoDeviceControl
EVT_WDF_IO_QUEUE_IO_CANCELED_ON_QUEUE	SequentialQueueEvtCanceledOnQueue
EVT_WDF_OBJECT_CONTEXT_CLEANUP	RequestEvtCleanup
EVT_WDFDEVICE_WDM_IRP_PREPROCESS	RequestProcessShutdownFlush
EVT_WDFDEVICE_WDM_IRP_PREPROCESS	RequestProcessSetPower
_In_ BOOLEAN	Release
_In_ PSTORAGE_PROPERTY_ID	PropertyId
_In_ PSTORAGE_PROPERTY_ID _Outptr_ PSTORAGE_DESCRIPTOR_HEADER *	Descriptor
_In_ ULONG_PTR	Data
_In_z_ PCHAR	TargetString
_In_opt_ PWSTR	SubkeyName
_In_opt_ PWSTR _In_ PWSTR	ParameterName
_In_opt_ PWSTR _In_ PWSTR _Inout_ PULONG	ParameterValue
_In_ ULONG_PTR	HackFlags
_In_ PSCSI_REQUEST_BLOCK	Srb
_In_ PSCSI_REQUEST_BLOCK _In_opt_ PVOID	BufferAddress
_In_ PSCSI_REQUEST_BLOCK _In_opt_ PVOID _In_ ULONG	BufferLength
_In_ PSCSI_REQUEST_BLOCK _In_opt_ PVOID _In_ ULONG _In_ BOOLEAN	WriteToDevice
_In_ PSCSI_REQUEST_BLOCK _In_opt_ PVOID _In_ ULONG _In_ BOOLEAN _In_opt_ WDFREQUEST	OriginalRequest
EVT_WDF_REQUEST_COMPLETION_ROUTINE	DeviceAsynchronousCompletion
EVT_WDF_REQUEST_COMPLETION_ROUTINE	DeviceReleaseQueueCompletion
_In_ ULONG const	Length
_In_ ULONG const _In_ FEATURE_NUMBER const	Feature
_In_ ULONG const	Usable
_In_ PREAD_CAPACITY_DATA	ReadCapacityBuffer
_In_ CDROM_DEVICE_INTERFACES	InterfaceType
_In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE	CompletionRoutine
_In_opt_ PFN_WDF_REQUEST_COMPLETION_ROUTINE _In_opt_ WDFCONTEXT	Context
_In_ CDROM_SCAN_FOR_SPECIAL_INFO	DeviceList []
_In_ CDROM_SCAN_FOR_SPECIAL_INFO _In_ PCDROM_SCAN_FOR_SPECIAL_HANDLER	Function
EVT_WDF_WORKITEM	DeviceRestoreDefaultSpeed
_In_ PFILE_OBJECT_CONTEXT	FileObjectContext
_In_ WDFFILEOBJECT	FileObject
_In_ WDFFILEOBJECT _In_ BOOLEAN	IgnorePreviousMediaChanges
_In_ WDFREQUEST	Request
_In_ WDFREQUEST _In_ BOOLEAN	RequestFormated
IO_COMPLETION_ROUTINE	RequestAsynchronousIrpCompletion
_In_ ULONG _In_ UCHAR	PageCode
_In_ ULONG _In_ UCHAR _In_ UCHAR	PageControl
_In_ size_t _In_ UCHAR	PageMode
_In_ size_t _In_ UCHAR _In_ BOOLEAN	Use6Byte
_In_ WDFREQUEST _In_ MEDIA_LOCK_TYPE	LockType
_In_ WDFREQUEST _In_ MEDIA_LOCK_TYPE _In_ BOOLEAN	Lock
EVT_WDF_TIMER	DeviceMainTimerTickHandler
_In_ BOOLEAN	UseGesn
POWER_SETTING_CALLBACK	DevicePowerSettingCallback
_In_ BOOLEAN	IsActive
_In_ BOOLEAN _In_ BOOLEAN	SetIdleTimeout
_In_ ULONG	IoControlCode
_In_ ULONG _In_opt_ WDFREQUEST _In_opt_ PVOID	InputBuffer
_In_ ULONG _In_opt_ WDFREQUEST _In_opt_ PVOID _In_ size_t	InputBufferLength
_In_ ULONG _In_opt_ WDFREQUEST _In_opt_ PVOID _In_ size_t _In_ PVOID	OutputBuffer
_In_ ULONG _In_opt_ WDFREQUEST _In_opt_ PVOID _In_ size_t _In_ PVOID _In_ size_t	OutputBufferLength
_In_ ULONG _In_opt_ WDFREQUEST _In_opt_ PVOID _In_ size_t _In_ PVOID _In_ size_t _Out_ size_t *	DataLength
FORCEINLINE ULONG	SectorsPerSecond
EVT_WDF_REQUEST_COMPLETION_ROUTINE	RequestDummyCompletionRoutine
EVT_WDF_WORKITEM	IoctlWorkItemRoutine
EVT_WDF_WORKITEM	ReadWriteWorkItemRoutine

Macro Definition Documentation

AACS_MKB_PACK_SIZE

#define AACS_MKB_PACK_SIZE   0x8000

Definition at line 764 of file cdrom.h.

ANY_SECTOR

#define ANY_SECTOR   0

Definition at line 705 of file cdrom.h.

CD_DA_SECTOR

#define CD_DA_SECTOR   1

Definition at line 706 of file cdrom.h.

CDROM_FLAG_WINPE_MODE

#define CDROM_FLAG_WINPE_MODE   0x00000001

Definition at line 237 of file cdrom.h.

CDROM_GET_CONFIGURATION_TIMEOUT

#define CDROM_GET_CONFIGURATION_TIMEOUT   (0x4)

Definition at line 126 of file cdrom.h.

CDROM_GET_PERFORMANCE_TIMEOUT

#define CDROM_GET_PERFORMANCE_TIMEOUT   (0x14)

Definition at line 129 of file cdrom.h.

CDROM_HACK_BAD_GET_CONFIG_SUPPORT

#define CDROM_HACK_BAD_GET_CONFIG_SUPPORT   (0x00000100)

Definition at line 96 of file cdrom.h.

CDROM_HACK_BAD_TYPE_ONE_GET_CONFIG

#define CDROM_HACK_BAD_TYPE_ONE_GET_CONFIG   (0x00000800)

Definition at line 99 of file cdrom.h.

CDROM_HACK_BAD_VENDOR_PROFILES

#define CDROM_HACK_BAD_VENDOR_PROFILES   (0x00001000)

Definition at line 100 of file cdrom.h.

CDROM_HACK_DEC_RRD

#define CDROM_HACK_DEC_RRD   (0x00000001)

Definition at line 88 of file cdrom.h.

CDROM_HACK_FUJITSU_FMCD_10x

#define CDROM_HACK_FUJITSU_FMCD_10x   (0x00000002)

Definition at line 89 of file cdrom.h.

CDROM_HACK_HITACHI_GD_2000

#define CDROM_HACK_HITACHI_GD_2000   (0x00000008)

Definition at line 91 of file cdrom.h.

CDROM_HACK_INVALID_FLAGS

#define CDROM_HACK_INVALID_FLAGS   (~CDROM_HACK_VALID_FLAGS)

Definition at line 105 of file cdrom.h.

CDROM_HACK_LOCKED_PAGES

#define CDROM_HACK_LOCKED_PAGES   (0x80000000)

Definition at line 102 of file cdrom.h.

CDROM_HACK_MSFT_VIRTUAL_ODD

#define CDROM_HACK_MSFT_VIRTUAL_ODD   (0x00002000)

Definition at line 101 of file cdrom.h.

CDROM_HACK_TOSHIBA_SD_W1101

#define CDROM_HACK_TOSHIBA_SD_W1101   (0x00000010)

Definition at line 92 of file cdrom.h.

CDROM_HACK_VALID_FLAGS

#define CDROM_HACK_VALID_FLAGS   (0x00003fff)

Definition at line 104 of file cdrom.h.

CDROM_INTERPRET_SENSE_INFO2_MAXIMUM_HISTORY_COUNT

#define CDROM_INTERPRET_SENSE_INFO2_MAXIMUM_HISTORY_COUNT   30000

Definition at line 176 of file cdrom.h.

CDROM_NON_MMC_DRIVE_NAME

#define CDROM_NON_MMC_DRIVE_NAME   (L"NonMmc")

Definition at line 756 of file cdrom.h.

CDROM_NON_MMC_VENDOR_SPECIFIC_PROFILE

#define CDROM_NON_MMC_VENDOR_SPECIFIC_PROFILE   (L"NonMmcVendorSpecificProfile")

Definition at line 758 of file cdrom.h.

CDROM_READ_CAPACITY_TIMEOUT

#define CDROM_READ_CAPACITY_TIMEOUT   (0x14)

Definition at line 130 of file cdrom.h.

CDROM_READ_CD_NAME

#define CDROM_READ_CD_NAME   (L"ReadCD")

Definition at line 755 of file cdrom.h.

CDROM_READ_DISC_INFORMATION_TIMEOUT

#define CDROM_READ_DISC_INFORMATION_TIMEOUT   (0x4)

Definition at line 127 of file cdrom.h.

CDROM_SPECIAL_DISABLE_SPIN_DOWN

#define CDROM_SPECIAL_DISABLE_SPIN_DOWN   0x00000001

Definition at line 149 of file cdrom.h.

CDROM_SPECIAL_DISABLE_WRITE_CACHE

#define CDROM_SPECIAL_DISABLE_WRITE_CACHE   0x00000010

Definition at line 157 of file cdrom.h.

CDROM_SRB_LIST_SIZE

#define CDROM_SRB_LIST_SIZE   4

Definition at line 696 of file cdrom.h.

CDROM_SUBKEY_NAME

#define CDROM_SUBKEY_NAME   (L"CdRom")

Definition at line 754 of file cdrom.h.

CDROM_TAG_AUTORUN_DISABLE

#define CDROM_TAG_AUTORUN_DISABLE   'ACcS'

Definition at line 724 of file cdrom.h.

CDROM_TAG_COMPLETION_CONTEXT

#define CDROM_TAG_COMPLETION_CONTEXT   'cCcS'

Definition at line 729 of file cdrom.h.

CDROM_TAG_DESCRIPTOR

#define CDROM_TAG_DESCRIPTOR   'DCcS'

Definition at line 730 of file cdrom.h.

CDROM_TAG_DISC_INFO

#define CDROM_TAG_DISC_INFO   'dCcS'

Definition at line 731 of file cdrom.h.

CDROM_TAG_FEATURE

#define CDROM_TAG_FEATURE   'FCcS'

Definition at line 733 of file cdrom.h.

CDROM_TAG_GESN

#define CDROM_TAG_GESN   'GCcS'

Definition at line 734 of file cdrom.h.

CDROM_TAG_GET_CONFIG

#define CDROM_TAG_GET_CONFIG   'CCcS'

Definition at line 728 of file cdrom.h.

CDROM_TAG_INQUIRY

#define CDROM_TAG_INQUIRY   'iCcS'

Definition at line 736 of file cdrom.h.

CDROM_TAG_MEDIA_CHANGE_DETECTION

#define CDROM_TAG_MEDIA_CHANGE_DETECTION   'aCcS'

Definition at line 725 of file cdrom.h.

CDROM_TAG_MODE_DATA

#define CDROM_TAG_MODE_DATA   'MCcS'

Definition at line 737 of file cdrom.h.

CDROM_TAG_NOTIFICATION

#define CDROM_TAG_NOTIFICATION   'oCcS'

Definition at line 739 of file cdrom.h.

CDROM_TAG_PLAY_ACTIVE

#define CDROM_TAG_PLAY_ACTIVE   'pCcS'

Definition at line 740 of file cdrom.h.

CDROM_TAG_REGISTRY

#define CDROM_TAG_REGISTRY   'rCcS'

Definition at line 741 of file cdrom.h.

CDROM_TAG_SCRATCH

#define CDROM_TAG_SCRATCH   'BCcS'

Definition at line 727 of file cdrom.h.

CDROM_TAG_SENSE_INFO

#define CDROM_TAG_SENSE_INFO   'ICcS'

Definition at line 735 of file cdrom.h.

CDROM_TAG_SRB

#define CDROM_TAG_SRB   'SCcS'

Definition at line 742 of file cdrom.h.

CDROM_TAG_STREAM

#define CDROM_TAG_STREAM   'OCCS'

Definition at line 738 of file cdrom.h.

CDROM_TAG_STRINGS

#define CDROM_TAG_STRINGS   'sCcS'

Definition at line 743 of file cdrom.h.

CDROM_TAG_SYNC_EVENT

#define CDROM_TAG_SYNC_EVENT   'eCcS'

Definition at line 732 of file cdrom.h.

CDROM_TAG_UPDATE_CAP

#define CDROM_TAG_UPDATE_CAP   'UCcS'

Definition at line 744 of file cdrom.h.

CDROM_TAG_ZERO_POWER_ODD

#define CDROM_TAG_ZERO_POWER_ODD   'ZCcS'

Definition at line 745 of file cdrom.h.

CDROM_TEST_UNIT_READY_TIMEOUT

#define CDROM_TEST_UNIT_READY_TIMEOUT   (0x14)

Definition at line 128 of file cdrom.h.

CDROM_TYPE_ONE_GET_CONFIG_NAME

#define CDROM_TYPE_ONE_GET_CONFIG_NAME   (L"NoTypeOneGetConfig")

Definition at line 757 of file cdrom.h.

CdromMmcUpdateComplete

#define CdromMmcUpdateComplete   0

Definition at line 241 of file cdrom.h.

CdromMmcUpdateRequired

#define CdromMmcUpdateRequired   1

Definition at line 242 of file cdrom.h.

CdromMmcUpdateStarted

#define CdromMmcUpdateStarted   2

Definition at line 243 of file cdrom.h.

CLEAR_FLAG [1/2]

#define CLEAR_FLAG	(		Flags,
			Bit
	)		((Flags) &= ~(Bit))

Definition at line 1494 of file cdrom.h.

CLEAR_FLAG [2/2]

#define CLEAR_FLAG	(		Flags,
			Bit
	)		((Flags) &= ~(Bit))

Definition at line 1494 of file cdrom.h.

COOKED_SECTOR_SIZE

#define COOKED_SECTOR_SIZE   2048

Definition at line 694 of file cdrom.h.

DEBUG_COMP_ID

#define DEBUG_COMP_ID   DPFLTR_CDROM_ID

Definition at line 48 of file cdrom.h.

DEV_POWER_PROTECTED

#define DEV_POWER_PROTECTED   0x00000010

Definition at line 143 of file cdrom.h.

DEV_SAFE_START_UNIT

#define DEV_SAFE_START_UNIT   0x00000004

Definition at line 139 of file cdrom.h.

DVD_DEFAULT_REGION

#define DVD_DEFAULT_REGION   (L"DefaultDvdRegion")

Definition at line 760 of file cdrom.h.

DVD_MAX_REGION

#define DVD_MAX_REGION   8

Definition at line 761 of file cdrom.h.

DVD_TAG_DVD_REGION

#define DVD_TAG_DVD_REGION   'vCcS'

Definition at line 749 of file cdrom.h.

DVD_TAG_READ_KEY

#define DVD_TAG_READ_KEY   'uCcS'

Definition at line 747 of file cdrom.h.

DVD_TAG_RPC2_CHECK

#define DVD_TAG_RPC2_CHECK   'VCcS'

Definition at line 748 of file cdrom.h.

DVD_TAG_SECURITY

#define DVD_TAG_SECURITY   'XCcS'

Definition at line 750 of file cdrom.h.

EXCLUSIVE_MODE

#define EXCLUSIVE_MODE

(

_CdData

)

(_CdData->ExclusiveOwner != NULL)

Definition at line 788 of file cdrom.h.

EXCLUSIVE_OWNER

#define EXCLUSIVE_OWNER	(		_CdData,
			_FileObject
	)		(_CdData->ExclusiveOwner == _FileObject)

Definition at line 789 of file cdrom.h.

FORM2_MODE1_SECTOR

#define FORM2_MODE1_SECTOR   4

Definition at line 709 of file cdrom.h.

FORM2_MODE2_SECTOR

#define FORM2_MODE2_SECTOR   5

Definition at line 710 of file cdrom.h.

FREE_POOL

#define FREE_POOL

(

_PoolPtr

)

Value:

if (_PoolPtr != NULL) {     \
        ExFreePool(_PoolPtr);   \
        _PoolPtr = NULL;        \
    }

Definition at line 782 of file cdrom.h.

HITACHI_MODE_DATA_SIZE

#define HITACHI_MODE_DATA_SIZE   12

Definition at line 690 of file cdrom.h.

IOCTL_MCN_SYNC_FAKE_IOCTL

#define IOCTL_MCN_SYNC_FAKE_IOCTL   IOCTL_DISK_UPDATE_DRIVE_SIZE

Definition at line 181 of file cdrom.h.

IS_SCSIOP_READ

#define IS_SCSIOP_READ

(

opCode

)

Value:

((opCode == SCSIOP_READ6)   ||   \
       (opCode == SCSIOP_READ)    ||   \
       (opCode == SCSIOP_READ12)  ||   \
       (opCode == SCSIOP_READ16))

Definition at line 791 of file cdrom.h.

IS_SCSIOP_READWRITE

#define IS_SCSIOP_READWRITE

(

opCode

)

(IS_SCSIOP_READ(opCode) || IS_SCSIOP_WRITE(opCode))

Definition at line 803 of file cdrom.h.

IS_SCSIOP_WRITE

#define IS_SCSIOP_WRITE

(

opCode

)

Value:

((opCode == SCSIOP_WRITE6)   ||   \
       (opCode == SCSIOP_WRITE)    ||   \
       (opCode == SCSIOP_WRITE12)  ||   \
       (opCode == SCSIOP_WRITE16))

Definition at line 797 of file cdrom.h.

MAX_COPY_PROTECT_AGID

#define MAX_COPY_PROTECT_AGID   4

Definition at line 712 of file cdrom.h.

MAXIMUM_RETRIES

#define MAXIMUM_RETRIES   4

Definition at line 124 of file cdrom.h.

MEDIA_CHANGE_TIMEOUT_TIME

#define MEDIA_CHANGE_TIMEOUT_TIME   300

Definition at line 135 of file cdrom.h.

MODE_DATA_SIZE

#define MODE_DATA_SIZE   64

Definition at line 691 of file cdrom.h.

MSF_TO_LBA

#define MSF_TO_LBA	(		Minutes,
			Seconds,
			Frames
	)		(ULONG)((60 * 75 * (Minutes)) + (75 * (Seconds)) + ((Frames) - 150))

Definition at line 700 of file cdrom.h.

PLAY_ACTIVE

#define PLAY_ACTIVE

(

x

)

(x->DeviceAdditionalData.PlayActive)

Definition at line 698 of file cdrom.h.

RAW_SECTOR_SIZE

#define RAW_SECTOR_SIZE   2352

Definition at line 693 of file cdrom.h.

SCSI_CDROM_OPC_TIMEOUT

#define SCSI_CDROM_OPC_TIMEOUT   260

Definition at line 688 of file cdrom.h.

SCSI_CDROM_TIMEOUT

#define SCSI_CDROM_TIMEOUT   10

Definition at line 680 of file cdrom.h.

SCSI_CHANGER_BONUS_TIMEOUT

#define SCSI_CHANGER_BONUS_TIMEOUT   10

Definition at line 681 of file cdrom.h.

SECONDS_TO_100NS_UNITS

#define SECONDS_TO_100NS_UNITS

(

x

)

(((LONGLONG)x) * UNIT_100NS_PER_SECOND)

Definition at line 1488 of file cdrom.h.

SET_FLAG [1/2]

#define SET_FLAG	(		Flags,
			Bit
	)		((Flags) |= (Bit))

Definition at line 1493 of file cdrom.h.

SET_FLAG [2/2]

#define SET_FLAG	(		Flags,
			Bit
	)		((Flags) |= (Bit))

Definition at line 1493 of file cdrom.h.

SIZEOF_ARRAY

#define SIZEOF_ARRAY

(

ar

)

(sizeof(ar)/sizeof((ar)[0]))

Definition at line 1482 of file cdrom.h.

SRB_CLASS_FLAGS_LOW_PRIORITY

#define SRB_CLASS_FLAGS_LOW_PRIORITY   0x10000000

Definition at line 162 of file cdrom.h.

SRB_CLASS_FLAGS_PAGING

#define SRB_CLASS_FLAGS_PAGING   0x40000000

Definition at line 165 of file cdrom.h.

START_UNIT_TIMEOUT

#define START_UNIT_TIMEOUT   (60 * 4)

Definition at line 132 of file cdrom.h.

TEST_FLAG [1/2]

#define TEST_FLAG	(		Flags,
			Bit
	)		(((Flags) & (Bit)) != 0)

Definition at line 1495 of file cdrom.h.

TEST_FLAG [2/2]

#define TEST_FLAG	(		Flags,
			Bit
	)		(((Flags) & (Bit)) != 0)

Definition at line 1495 of file cdrom.h.

UNIT_100NS_PER_SECOND

#define UNIT_100NS_PER_SECOND   (10*1000*1000)

Definition at line 1487 of file cdrom.h.

WPP_CONTROL_GUIDS

#define WPP_CONTROL_GUIDS   WPP_CONTROL_GUIDS_NORMAL_FLAGS(WPP_GUID_CDROM)

Definition at line 58 of file cdrom.h.

WPP_GUID_CDROM

#define WPP_GUID_CDROM   (A4196372, C3C4, 42d5, 87BF, 7EDB2E9BCC27)

Definition at line 56 of file cdrom.h.

WRITE_RETRY_DELAY_CD_10x

#define WRITE_RETRY_DELAY_CD_10x   ((LONGLONG) 426667)

Definition at line 117 of file cdrom.h.

WRITE_RETRY_DELAY_CD_1x

#define WRITE_RETRY_DELAY_CD_1x   ((LONGLONG)4266667)

Definition at line 115 of file cdrom.h.

WRITE_RETRY_DELAY_CD_4x

#define WRITE_RETRY_DELAY_CD_4x   ((LONGLONG)1066667)

Definition at line 116 of file cdrom.h.

WRITE_RETRY_DELAY_DVD_16x

#define WRITE_RETRY_DELAY_DVD_16x   ((LONGLONG) 29586)

Definition at line 120 of file cdrom.h.

WRITE_RETRY_DELAY_DVD_1x

#define WRITE_RETRY_DELAY_DVD_1x   ((LONGLONG) 473373)

Definition at line 118 of file cdrom.h.

WRITE_RETRY_DELAY_DVD_4x

#define WRITE_RETRY_DELAY_DVD_4x   ((LONGLONG) 118343)

Definition at line 119 of file cdrom.h.

WRITE_RETRY_DELAY_HDDVD_1x

#define WRITE_RETRY_DELAY_HDDVD_1x   ((LONGLONG) 143498)

Definition at line 121 of file cdrom.h.

YELLOW_MODE1_SECTOR

#define YELLOW_MODE1_SECTOR   2

Definition at line 707 of file cdrom.h.

YELLOW_MODE2_SECTOR

#define YELLOW_MODE2_SECTOR   3

Definition at line 708 of file cdrom.h.

Typedef Documentation

CDROM_DATA

typedef struct _CDROM_DATA CDROM_DATA

CDROM_DEVICE_EXTENSION

typedef struct _CDROM_DEVICE_EXTENSION CDROM_DEVICE_EXTENSION

Definition at line 216 of file cdrom.h.

CDROM_DRIVER_EXTENSION

typedef struct _CDROM_DRIVER_EXTENSION CDROM_DRIVER_EXTENSION

CDROM_IOCTL_CONTEXT

typedef struct _CDROM_IOCTL_CONTEXT CDROM_IOCTL_CONTEXT

CDROM_MMC_EXTENSION

typedef struct _CDROM_MMC_EXTENSION CDROM_MMC_EXTENSION

CDROM_POWER_CONTEXT

typedef struct _CDROM_POWER_CONTEXT CDROM_POWER_CONTEXT

CDROM_POWER_OPTIONS

typedef struct _CDROM_POWER_OPTIONS CDROM_POWER_OPTIONS

CDROM_READ_WRITE_CONTEXT

typedef struct _CDROM_READ_WRITE_CONTEXT CDROM_READ_WRITE_CONTEXT

CDROM_REQUEST_CONTEXT

typedef struct _CDROM_REQUEST_CONTEXT CDROM_REQUEST_CONTEXT

CDROM_SCRATCH_CONTEXT

typedef struct _CDROM_SCRATCH_CONTEXT CDROM_SCRATCH_CONTEXT

CDROM_SCRATCH_READ_WRITE_CONTEXT

typedef struct _CDROM_SCRATCH_READ_WRITE_CONTEXT CDROM_SCRATCH_READ_WRITE_CONTEXT

COMPLETION_CONTEXT

typedef struct _COMPLETION_CONTEXT COMPLETION_CONTEXT

ERROR_RECOVERY_DATA

typedef struct _ERROR_RECOVERY_DATA ERROR_RECOVERY_DATA

PCDROM_DATA

typedef struct _CDROM_DATA * PCDROM_DATA

PCDROM_DEVICE_EXTENSION

typedef struct _CDROM_DEVICE_EXTENSION * PCDROM_DEVICE_EXTENSION

Definition at line 216 of file cdrom.h.

PCDROM_DEVICE_INTERFACES

typedef enum CDROM_DEVICE_INTERFACES * PCDROM_DEVICE_INTERFACES

PCDROM_DRIVER_EXTENSION

typedef struct _CDROM_DRIVER_EXTENSION * PCDROM_DRIVER_EXTENSION

PCDROM_ERROR_HANDLER

typedef VOID(* PCDROM_ERROR_HANDLER) (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ PSCSI_REQUEST_BLOCK Srb, _Inout_ PNTSTATUS Status, _Inout_ PBOOLEAN Retry)

Definition at line 222 of file cdrom.h.

PCDROM_IOCTL_CONTEXT

typedef struct _CDROM_IOCTL_CONTEXT * PCDROM_IOCTL_CONTEXT

PCDROM_MMC_EXTENSION

typedef struct _CDROM_MMC_EXTENSION * PCDROM_MMC_EXTENSION

PCDROM_POWER_CONTEXT

typedef struct _CDROM_POWER_CONTEXT * PCDROM_POWER_CONTEXT

PCDROM_POWER_OPTIONS

typedef struct _CDROM_POWER_OPTIONS * PCDROM_POWER_OPTIONS

PCDROM_READ_WRITE_CONTEXT

typedef struct _CDROM_READ_WRITE_CONTEXT * PCDROM_READ_WRITE_CONTEXT

PCDROM_REQUEST_CONTEXT

typedef struct _CDROM_REQUEST_CONTEXT * PCDROM_REQUEST_CONTEXT

PCDROM_SCAN_FOR_SPECIAL_HANDLER

typedef VOID(* PCDROM_SCAN_FOR_SPECIAL_HANDLER) (_In_ PCDROM_DEVICE_EXTENSION DeviceExtension, _In_ ULONG_PTR Data)

Definition at line 775 of file cdrom.h.

PCDROM_SCRATCH_CONTEXT

typedef struct _CDROM_SCRATCH_CONTEXT * PCDROM_SCRATCH_CONTEXT

PCDROM_SCRATCH_READ_WRITE_CONTEXT

typedef struct _CDROM_SCRATCH_READ_WRITE_CONTEXT * PCDROM_SCRATCH_READ_WRITE_CONTEXT

PCOMPLETION_CONTEXT

typedef struct _COMPLETION_CONTEXT * PCOMPLETION_CONTEXT

PERROR_RECOVERY_DATA

typedef struct _ERROR_RECOVERY_DATA * PERROR_RECOVERY_DATA

PSYNC_HANDLER

typedef SYNC_HANDLER* PSYNC_HANDLER

Definition at line 628 of file cdrom.h.

SYNC_HANDLER

typedef NTSTATUS SYNC_HANDLER(_In_ WDFDEVICE Device, _In_ WDFREQUEST Request)

Definition at line 623 of file cdrom.h.

Enumeration Type Documentation

CDROM_DEVICE_INTERFACES

enum CDROM_DEVICE_INTERFACES

Enumerator
CdRomDeviceInterface
MountedDeviceInterface

Definition at line 767 of file cdrom.h.

             {
    CdRomDeviceInterface = 0,     // CdRomClassGuid
    MountedDeviceInterface        // MOUNTDEV_MOUNTED_DEVICE_GUID
} CDROM_DEVICE_INTERFACES, *PCDROM_DEVICE_INTERFACES;

CDROM_POWER_DOWN_STATE

enum CDROM_POWER_DOWN_STATE

Enumerator
PowerDownDeviceInitial
PowerDownDeviceLocked
PowerDownDeviceQuiesced
PowerDownDeviceFlushed
PowerDownDeviceStopped
PowerDownDeviceOff
PowerDownDeviceUnlocked

Definition at line 407 of file cdrom.h.

             {
    PowerDownDeviceInitial,
    PowerDownDeviceLocked,
    PowerDownDeviceQuiesced,
    PowerDownDeviceFlushed,
    PowerDownDeviceStopped,
    PowerDownDeviceOff,
    PowerDownDeviceUnlocked
} CDROM_POWER_DOWN_STATE;

CDROM_POWER_UP_STATE

enum CDROM_POWER_UP_STATE

Enumerator
PowerUpDeviceInitial
PowerUpDeviceLocked
PowerUpDeviceOn
PowerUpDeviceStarted
PowerUpDeviceUnlocked

Definition at line 419 of file cdrom.h.

             {
    PowerUpDeviceInitial,
    PowerUpDeviceLocked,
    PowerUpDeviceOn,
    PowerUpDeviceStarted,
    PowerUpDeviceUnlocked
} CDROM_POWER_UP_STATE;

Function Documentation

_In_reads_bytes_()

_In_reads_bytes_

(

Length

)

_IRQL_requires_max_() [1/3]

_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Definition at line 1705 of file hardware.c.

{
    SendKey();
    Wake(LogicalDevice->CSN);
}

_IRQL_requires_max_() [2/3]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 64 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    NTSTATUS Status;

    /* The caller must allow at least one connection */
    if (MaxConnections == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }

    /* The request must be for a kernel handle */
    if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
    {
        return STATUS_INVALID_PARAMETER;
    }

    /*
     * Get rundown protection on the target to stop the owner
     * from unloading whilst this port object is open. It gets
     * removed in the FltpServerPortClose callback
     */
    Status = FltObjectReference(Filter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }

    /* Create the server port object for this filter */
    Status = ObCreateObject(KernelMode,
                            ServerPortObjectType,
                            ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_SERVER_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&PortObject);
    if (NT_SUCCESS(Status))
    {
        /* Zero out the struct */
        RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));

        /* Increment the ref count on the target filter */
        FltpObjectPointerReference((PFLT_OBJECT)Filter);

        /* Setup the filter port object */
        PortObject->Filter = Filter;
        PortObject->ConnectNotify = ConnectNotifyCallback;
        PortObject->DisconnectNotify = DisconnectNotifyCallback;
        PortObject->MessageNotify = MessageNotifyCallback;
        PortObject->Cookie = ServerPortCookie;
        PortObject->MaxConnections = MaxConnections;

        /* Insert the object */
        Status = ObInsertObject(PortObject,
                                NULL,
                                STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                0,
                                NULL,
                                (PHANDLE)ServerPort);
        if (NT_SUCCESS(Status))
        {
            /* Lock the connection list */
            ExAcquireFastMutex(&Filter->ConnectionList.mLock);

            /* Add the new port object to the connection list and increment the count */
            InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
            Filter->ConnectionList.mCount++;

            /* Unlock the connection list*/
            ExReleaseFastMutex(&Filter->ConnectionList.mLock);
        }
    }

    if (!NT_SUCCESS(Status))
    {
        /* Allow the filter to be cleaned up */
        FltObjectDereference(Filter);
    }

    return Status;
}

_IRQL_requires_max_() [3/3]

_IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 197 of file cddata.c.

{
    THREAD_CONTEXT ThreadContext = {0};
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN Wait;

#ifdef CD_SANITY
    PVOID PreviousTopLevel;
#endif

    NTSTATUS Status;

#if DBG

    KIRQL SaveIrql = KeGetCurrentIrql();

#endif

    ASSERT_OPTIONAL_IRP( Irp );

    UNREFERENCED_PARAMETER( DeviceObject );

    FsRtlEnterFileSystem();

#ifdef CD_SANITY
    PreviousTopLevel = IoGetTopLevelIrp();
#endif

    //
    //  Loop until this request has been completed or posted.
    //

    do {

        //
        //  Use a try-except to handle the exception cases.
        //

        _SEH2_TRY {

            //
            //  If the IrpContext is NULL then this is the first pass through
            //  this loop.
            //

            if (IrpContext == NULL) {

                //
                //  Decide if this request is waitable an allocate the IrpContext.
                //  If the file object in the stack location is NULL then this
                //  is a mount which is always waitable.  Otherwise we look at
                //  the file object flags.
                //

                if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {

                    Wait = TRUE;

                } else {

                    Wait = CanFsdWait( Irp );
                }

                IrpContext = CdCreateIrpContext( Irp, Wait );

                //
                //  Update the thread context information.
                //

                CdSetThreadContext( IrpContext, &ThreadContext );

#ifdef CD_SANITY
                NT_ASSERT( !CdTestTopLevel ||
                        SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif

            //
            //  Otherwise cleanup the IrpContext for the retry.
            //

            } else {

                //
                //  Set the MORE_PROCESSING flag to make sure the IrpContext
                //  isn't inadvertently deleted here.  Then cleanup the
                //  IrpContext to perform the retry.
                //

                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
                CdCleanupIrpContext( IrpContext, FALSE );
            }

            //
            //  Case on the major irp code.
            //

            switch (IrpContext->MajorFunction) {

            case IRP_MJ_CREATE :

                Status = CdCommonCreate( IrpContext, Irp );
                break;

            case IRP_MJ_CLOSE :

                Status = CdCommonClose( IrpContext, Irp );
                break;

            case IRP_MJ_READ :

                //
                //  If this is an Mdl complete request, don't go through
                //  common read.
                //

                if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {

                    Status = CdCompleteMdl( IrpContext, Irp );

                } else {

                    Status = CdCommonRead( IrpContext, Irp );
                }

                break;

            case IRP_MJ_WRITE :

                Status = CdCommonWrite( IrpContext, Irp );
                break;

            case IRP_MJ_QUERY_INFORMATION :

                Status = CdCommonQueryInfo( IrpContext, Irp );
                break;

            case IRP_MJ_SET_INFORMATION :

                Status = CdCommonSetInfo( IrpContext, Irp );
                break;

            case IRP_MJ_QUERY_VOLUME_INFORMATION :

                Status = CdCommonQueryVolInfo( IrpContext, Irp );
                break;

            case IRP_MJ_DIRECTORY_CONTROL :

                Status = CdCommonDirControl( IrpContext, Irp );
                break;

            case IRP_MJ_FILE_SYSTEM_CONTROL :

                Status = CdCommonFsControl( IrpContext, Irp );
                break;

            case IRP_MJ_DEVICE_CONTROL :

                Status = CdCommonDevControl( IrpContext, Irp );
                break;

            case IRP_MJ_LOCK_CONTROL :

                Status = CdCommonLockControl( IrpContext, Irp );
                break;

            case IRP_MJ_CLEANUP :

                Status = CdCommonCleanup( IrpContext, Irp );
                break;

            case IRP_MJ_PNP :

                Status = CdCommonPnp( IrpContext, Irp );
                break;

            case IRP_MJ_SHUTDOWN :

                Status = CdCommonShutdown( IrpContext, Irp );
                break;

            default :

                Status = STATUS_INVALID_DEVICE_REQUEST;
                CdCompleteRequest( IrpContext, Irp, Status );
            }

        } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {

            Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
        } _SEH2_END;

    } while (Status == STATUS_CANT_WAIT);

#ifdef CD_SANITY
    NT_ASSERT( !CdTestTopLevel ||
            (PreviousTopLevel == IoGetTopLevelIrp()) );
#endif

    FsRtlExitFileSystem();

    NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));

    return Status;
}

_Ret_range_()

FORCEINLINE _Ret_range_	(	0	,
		MAXIMUM_RETRY_FOR_SINGLE_IO_IN_100NS_UNITS
	)

C_ASSERT()

C_ASSERT

(

(MAXULONG - sizeof(SRB_HISTORY))/30000 >=sizeof(SRB_HISTORY_ITEM)

)

CountOfSetBitsUChar()

FORCEINLINE ULONG CountOfSetBitsUChar

(

UCHAR

_X

)

Definition at line 1500 of file cdrom.h.

                    { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }

Referenced by ClasspInitializeGesn(), and ClasspInterpretGesnData().

CountOfSetBitsULong()

FORCEINLINE ULONG CountOfSetBitsULong

(

ULONG

_X

)

Definition at line 1502 of file cdrom.h.

                    { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }

CountOfSetBitsULong32()

FORCEINLINE ULONG CountOfSetBitsULong32

(

ULONG32

_X

)

Definition at line 1504 of file cdrom.h.

                    { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }

CountOfSetBitsULong64()

FORCEINLINE ULONG CountOfSetBitsULong64

(

ULONG64

_X

)

Definition at line 1506 of file cdrom.h.

                    { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }

CountOfSetBitsUlongPtr()

FORCEINLINE ULONG CountOfSetBitsUlongPtr

(

ULONG_PTR

_X

)

Definition at line 1508 of file cdrom.h.

                    { ULONG i = 0; while (_X) { _X &= _X - 1; i++; } return i; }

DeviceErrorHandlerForHitachiGD2000()

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

Definition at line 361 of file sense.c.

{
    PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;

    if (!TEST_FLAG(Srb->SrbStatus, SRB_STATUS_AUTOSENSE_VALID))
    {
        return STATUS_SUCCESS; //nobody cares about this return value yet.
    }

    if (((senseBuffer->SenseKey & 0xf) == SCSI_SENSE_HARDWARE_ERROR) &&
        (senseBuffer->AdditionalSenseCode == 0x44))
    {
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                    "DeviceErrorHandlerForHitachiGD2000 (%p) => Internal Target "
                    "Failure Detected -- spinning up drive\n", DeviceExtension->Device));

        // the request should be retried because the device isn't ready
        *Retry = TRUE;
        *Status = STATUS_DEVICE_NOT_READY;

        // send a START_STOP unit to spin up the drive
        // NOTE: this temporarily violates the StartIo serialization
        //       mechanism, but the completion routine on this will NOT
        //       call StartNextPacket(), so it's a temporary disruption
        //       of the serialization only.
        DeviceSendStartUnit(DeviceExtension->Device);
    }

    return STATUS_SUCCESS;
}

DeviceErrorHandlerForMmc()

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

Definition at line 87 of file sense.c.

{
    BOOLEAN mediaChange = FALSE;
    PCDB    cdb = (PCDB)Srb->Cdb;

    if (TEST_FLAG(Srb->SrbStatus, SRB_STATUS_AUTOSENSE_VALID))
    {
        PSENSE_DATA senseBuffer = Srb->SenseInfoBuffer;

        // the following sense keys could indicate a change in capabilities.

        // we used to expect this to be serialized, and only hit from our
        // own routine. we now allow some requests to continue during our
        // processing of the capabilities update in order to allow
        // IoReadPartitionTable() to succeed.
        switch (senseBuffer->SenseKey & 0xf)
        {

        case SCSI_SENSE_NOT_READY:
        {
            if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_NO_MEDIA_IN_DEVICE)
            {
                if (DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed)
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: media removed, writes will be "
                               "failed until new media detected\n"));
                }

                // NOTE - REF #0002
                DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
            }
            else if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_LUN_NOT_READY)
            {
                if (senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_BECOMING_READY)
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: media becoming ready, "
                               "SHOULD notify shell of change time by sending "
                               "GESN request immediately!\n"));
                }
                else if (((senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_OPERATION_IN_PROGRESS) ||
                            (senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_LONG_WRITE_IN_PROGRESS)
                            ) &&
                           ((Srb->Cdb[0] == SCSIOP_READ) ||
                            (Srb->Cdb[0] == SCSIOP_READ6) ||
                            (Srb->Cdb[0] == SCSIOP_READ_CAPACITY) ||
                            (Srb->Cdb[0] == SCSIOP_READ_CD) ||
                            (Srb->Cdb[0] == SCSIOP_READ_CD_MSF) ||
                            (Srb->Cdb[0] == SCSIOP_READ_TOC) ||
                            (Srb->Cdb[0] == SCSIOP_WRITE) ||
                            (Srb->Cdb[0] == SCSIOP_WRITE6) ||
                            (Srb->Cdb[0] == SCSIOP_READ_TRACK_INFORMATION) ||
                            (Srb->Cdb[0] == SCSIOP_READ_DISK_INFORMATION)
                            )
                           )
                {
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: LONG_WRITE or "
                               "OP_IN_PROGRESS for limited subset of cmds -- "
                               "setting retry to TRUE\n"));
                    *Retry = TRUE;
                    *Status = STATUS_DEVICE_BUSY;
                }
            }
            break;
        } // end SCSI_SENSE_NOT_READY

        case SCSI_SENSE_UNIT_ATTENTION:
        {
            switch (senseBuffer->AdditionalSenseCode)
            {
            case SCSI_ADSENSE_MEDIUM_CHANGED:
            {
                // always update if the medium may have changed

                // NOTE - REF #0002
                DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
                DeviceExtension->DeviceAdditionalData.Mmc.UpdateState = CdromMmcUpdateRequired;

                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                           "DeviceErrorHandlerForMmc: media change detected, need to "
                           "update drive capabilities\n"));
                mediaChange = TRUE;
                break;

            } // end SCSI_ADSENSE_MEDIUM_CHANGED

            case SCSI_ADSENSE_BUS_RESET:
            {
                // NOTE - REF #0002
                DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
                DeviceExtension->DeviceAdditionalData.Mmc.UpdateState = CdromMmcUpdateRequired;

                TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                           "DeviceErrorHandlerForMmc: bus reset detected, need to "
                           "update drive capabilities\n"));
                break;

            } // end SCSI_ADSENSE_BUS_RESET

            case SCSI_ADSENSE_OPERATOR_REQUEST:
            {

                BOOLEAN b = FALSE;

                switch (senseBuffer->AdditionalSenseCodeQualifier)
                {
                case SCSI_SENSEQ_MEDIUM_REMOVAL:
                {
                    // eject notification currently handled by classpnp
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: Eject requested by user\n"));
                    *Retry = TRUE;
                    *Status = STATUS_DEVICE_BUSY;
                    break;
                }

                case SCSI_SENSEQ_WRITE_PROTECT_DISABLE:
                    b = TRUE;
                case SCSI_SENSEQ_WRITE_PROTECT_ENABLE:
                {
                    TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: Write protect %s requested "
                               "by user\n",
                               (b ? "disable" : "enable")));
                    *Retry = TRUE;
                    *Status = STATUS_DEVICE_BUSY;
                    // NOTE - REF #0002
                    DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
                    DeviceExtension->DeviceAdditionalData.Mmc.UpdateState = CdromMmcUpdateRequired;

                    break;
                }

                } // end of AdditionalSenseCodeQualifier switch


                break;

            } // end SCSI_ADSENSE_OPERATOR_REQUEST

            default:
            {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                           "DeviceErrorHandlerForMmc: Unit attention %02x/%02x\n",
                           senseBuffer->AdditionalSenseCode,
                           senseBuffer->AdditionalSenseCodeQualifier));
                break;
            }

            } // end of AdditionSenseCode switch
            break;

        } // end SCSI_SENSE_UNIT_ATTENTION

        case SCSI_SENSE_ILLEGAL_REQUEST:
        {
            if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_WRITE_PROTECT)
            {
                if (DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed)
                {
                    TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                               "DeviceErrorHandlerForMmc: media was writable, but "
                               "failed request with WRITE_PROTECT error...\n"));
                }
                // NOTE - REF #0002
                // do not update all the capabilities just because
                // we can't write to the disc.
                DeviceExtension->DeviceAdditionalData.Mmc.WriteAllowed = FALSE;
            }
            break;
        } // end SCSI_SENSE_ILLEGAL_REQUEST

        } // end of SenseKey switch

        // Check if we failed to set the DVD region key and send appropriate error
        if (cdb->CDB16.OperationCode == SCSIOP_SEND_KEY)
        {
            if (cdb->SEND_KEY.KeyFormat == DvdSetRpcKey)
            {
                if (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_NO_MEDIA_IN_DEVICE)
                {
                    // media of appropriate region required
                    *Status = STATUS_NO_MEDIA_IN_DEVICE;
                    *Retry = FALSE;
                }
                else if ((senseBuffer->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST) &&
                           (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_COPY_PROTECTION_FAILURE) &&
                           (senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_MEDIA_CODE_MISMATCHED_TO_LOGICAL_UNIT))
                {
                    // media of appropriate region required
                    *Status = STATUS_CSS_REGION_MISMATCH;
                    *Retry = FALSE;
                }
                else if ((senseBuffer->SenseKey == SCSI_SENSE_ILLEGAL_REQUEST) &&
                           (senseBuffer->AdditionalSenseCode == SCSI_ADSENSE_INVALID_MEDIA) &&
                           (senseBuffer->AdditionalSenseCodeQualifier == SCSI_SENSEQ_INCOMPATIBLE_FORMAT))
                {
                    // media of appropriate region required
                    *Status = STATUS_CSS_REGION_MISMATCH;
                    *Retry = FALSE;
                }
            }
        }
    } // end of SRB_STATUS_AUTOSENSE_VALID

    // On media change, if device speed should be reset to default then
    // queue a workitem to send the commands to the device. Do this on
    // media arrival as some device will fail this command if no media
    // is present. Ignore the fake media change from classpnp driver.
    if ((mediaChange == TRUE) && (*Status != STATUS_MEDIA_CHANGED))
    {
        if (DeviceExtension->DeviceAdditionalData.RestoreDefaults == TRUE)
        {
            NTSTATUS                status = STATUS_SUCCESS;
            WDF_OBJECT_ATTRIBUTES   attributes;
            WDF_WORKITEM_CONFIG     workitemConfig;
            WDFWORKITEM             workItem;

            WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
            attributes.ParentObject = DeviceExtension->Device;

            WDF_WORKITEM_CONFIG_INIT(&workitemConfig,
                                     DeviceRestoreDefaultSpeed);

            status = WdfWorkItemCreate(&workitemConfig,
                                       &attributes,
                                       &workItem);
            if (!NT_SUCCESS(status))
            {
                return STATUS_SUCCESS;
            }

            WdfWorkItemEnqueue(workItem);

            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                        "DeviceErrorHandlerForMmc: Restore device default speed for %p\n",
                        DeviceExtension->DeviceObject));
        }
    }
    return STATUS_SUCCESS;
}

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().

DevicePerfIncrementErrorCount()

VOID DevicePerfIncrementErrorCount

(

_In_ PCDROM_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 1378 of file common.c.

{
    PCDROM_PRIVATE_FDO_DATA fdoData = DeviceExtension->PrivateFdoData;
    KIRQL                   oldIrql;
    ULONG                   errors;

    KeAcquireSpinLock(&fdoData->SpinLock, &oldIrql);

    fdoData->Perf.SuccessfulIO = 0; // implicit interlock
    errors = InterlockedIncrement((PLONG)&DeviceExtension->ErrorCount);

    if (errors >= CLASS_ERROR_LEVEL_1)
    {
        // If the error count has exceeded the error limit, then disable
        // any tagged queuing, multiple requests per lu queueing
        // and sychronous data transfers.
        //
        // Clearing the no queue freeze flag prevents the port driver
        // from sending multiple requests per logical unit.
        CLEAR_FLAG(DeviceExtension->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE);
        CLEAR_FLAG(DeviceExtension->SrbFlags, SRB_FLAGS_QUEUE_ACTION_ENABLE);

        SET_FLAG(DeviceExtension->SrbFlags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);

        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                   "PerfIncrementErrorCount: Too many errors; disabling tagged queuing and "
                   "synchronous data tranfers.\n"));
    }

    if (errors >= CLASS_ERROR_LEVEL_2)
    {
        // If a second threshold is reached, disable disconnects.
        SET_FLAG(DeviceExtension->SrbFlags, SRB_FLAGS_DISABLE_DISCONNECT);
        TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                   "PerfIncrementErrorCount: Too many errors; disabling disconnects.\n"));
    }

    KeReleaseSpinLock(&fdoData->SpinLock, oldIrql);
    return;
}

Referenced by SenseInfoInterpretBySrbStatus().

DeviceReleaseQueue()

VOID DeviceReleaseQueue

(

_In_ WDFDEVICE

Device

)

Definition at line 1179 of file common.c.

{
    PCDROM_DEVICE_EXTENSION     deviceExtension = DeviceGetExtension(Device);
    PSCSI_REQUEST_BLOCK         srb = NULL;
    KIRQL                       currentIrql;

    // we raise irql seperately so we're not swapped out or suspended
    // while holding the release queue irp in this routine.  this lets
    // us release the spin lock before lowering irql.
    KeRaiseIrql(DISPATCH_LEVEL, &currentIrql);

    WdfSpinLockAcquire(deviceExtension->ReleaseQueueSpinLock);

    if (deviceExtension->ReleaseQueueInProgress)
    {
        // Someone is already doing this work - just set the flag to indicate that
        // we need to release the queue again.
        deviceExtension->ReleaseQueueNeeded = TRUE;
        WdfSpinLockRelease(deviceExtension->ReleaseQueueSpinLock);
        KeLowerIrql(currentIrql);

        return;
    }

    // Mark that there is a release queue in progress and drop the spinlock.
    deviceExtension->ReleaseQueueInProgress = TRUE;

    WdfSpinLockRelease(deviceExtension->ReleaseQueueSpinLock);

    srb = &(deviceExtension->ReleaseQueueSrb);

    // Optical media are removable, so we just flush the queue.  This will also release it.
    srb->Function = SRB_FUNCTION_FLUSH_QUEUE;

    srb->OriginalRequest = WdfRequestWdmGetIrp(deviceExtension->ReleaseQueueRequest);

    // Set a CompletionRoutine callback function.
    WdfRequestSetCompletionRoutine(deviceExtension->ReleaseQueueRequest,
                                   DeviceReleaseQueueCompletion,
                                   Device);
    // Send the request. If an error occurs, complete the request.
    RequestSend(deviceExtension,
                deviceExtension->ReleaseQueueRequest,
                deviceExtension->IoTarget,
                WDF_REQUEST_SEND_OPTION_IGNORE_TARGET_STATE,
                NULL);

    KeLowerIrql(currentIrql);

    return;

} // end DeviceReleaseQueue()

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

DeviceSendIoctlAsynchronously()

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

Definition at line 1030 of file common.c.

{
    PIRP                irp = NULL;
    PIO_STACK_LOCATION  nextIrpStack = NULL;

    irp = IoAllocateIrp(DeviceExtension->DeviceObject->StackSize, FALSE);

    if (irp != NULL)
    {
        nextIrpStack = IoGetNextIrpStackLocation(irp);

        nextIrpStack->MajorFunction = IRP_MJ_DEVICE_CONTROL;

        nextIrpStack->Parameters.DeviceIoControl.OutputBufferLength = 0;
        nextIrpStack->Parameters.DeviceIoControl.InputBufferLength = 0;
        nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IoControlCode;
        nextIrpStack->Parameters.DeviceIoControl.Type3InputBuffer = NULL;

        IoSetCompletionRoutine(irp,
                               RequestAsynchronousIrpCompletion,
                               DeviceExtension,
                               TRUE,
                               TRUE,
                               TRUE);

        (VOID) IoCallDriver(TargetDeviceObject, irp);
    }
}

Referenced by DeviceEvtD0Entry().

DeviceSendNotification()

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

Definition at line 799 of file common.c.

{
    PTARGET_DEVICE_CUSTOM_NOTIFICATION  notification;
    ULONG                               requiredSize;
    NTSTATUS                            status;

    status = RtlULongAdd((sizeof(TARGET_DEVICE_CUSTOM_NOTIFICATION) - sizeof(UCHAR)),
                         ExtraDataSize,
                         &requiredSize);

    if (!(NT_SUCCESS(status)) || (requiredSize > 0x0000ffff))
    {
        // MAX_USHORT, max total size for these events!
        TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_MCN,
                   "Error sending event: size too large! (%x)\n",
                   requiredSize));
        return;
    }

    notification = ExAllocatePoolWithTag(NonPagedPoolNx,
                                         requiredSize,
                                         CDROM_TAG_NOTIFICATION);

    // if none allocated, exit
    if (notification == NULL)
    {
        return;
    }

    // Prepare and send the request!
    RtlZeroMemory(notification, requiredSize);
    notification->Version = 1;
    notification->Size = (USHORT)(requiredSize);
    notification->FileObject = NULL;
    notification->NameBufferOffset = -1;
    notification->Event = *Guid;

    if (ExtraData != NULL)
    {
        RtlCopyMemory(notification->CustomDataBuffer, ExtraData, ExtraDataSize);
    }

    IoReportTargetDeviceChangeAsynchronous(DeviceExtension->LowerPdo,
                                           notification,
                                           NULL,
                                           NULL);

    FREE_POOL(notification);

    return;
}

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

DeviceSendStartUnit()

VOID DeviceSendStartUnit

(

_In_ WDFDEVICE

Device

)

Definition at line 877 of file common.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_DEVICE_EXTENSION deviceExtension = NULL;
    WDF_OBJECT_ATTRIBUTES   attributes;
    WDFREQUEST              startUnitRequest = NULL;
    WDFMEMORY               inputMemory = NULL;

    PCOMPLETION_CONTEXT     context = NULL;
    PSCSI_REQUEST_BLOCK     srb = NULL;
    PCDB                    cdb = NULL;

    deviceExtension = DeviceGetExtension(Device);

    if (NT_SUCCESS(status))
    {
        // Allocate Srb from nonpaged pool.
        context = ExAllocatePoolWithTag(NonPagedPoolNx,
                                        sizeof(COMPLETION_CONTEXT),
                                        CDROM_TAG_COMPLETION_CONTEXT);

        if (context == NULL)
        {
            TracePrint((TRACE_LEVEL_ERROR, TRACE_FLAG_GENERAL,
                       "DeviceSendStartUnit: Failed to allocate completion context\n"));

            status = STATUS_INTERNAL_ERROR;
        }
    }

    if (NT_SUCCESS(status))
    {
        // Save the device object in the context for use by the completion
        // routine.
        context->Device = Device;
        srb = &context->Srb;

        // Zero out srb.
        RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));

        // setup SRB structure.
        srb->Length = sizeof(SCSI_REQUEST_BLOCK);
        srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
        srb->TimeOutValue = START_UNIT_TIMEOUT;

        srb->SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
                        SRB_FLAGS_DISABLE_SYNCH_TRANSFER;

        // setup CDB
        srb->CdbLength = 6;
        cdb = (PCDB)srb->Cdb;

        cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
        cdb->START_STOP.Start = 1;
        cdb->START_STOP.Immediate = 0;
        cdb->START_STOP.LogicalUnitNumber = srb->Lun;

        //Create Request for sending down to port driver
        WDF_OBJECT_ATTRIBUTES_INIT_CONTEXT_TYPE(&attributes,
                                                CDROM_REQUEST_CONTEXT);
        attributes.ParentObject = deviceExtension->IoTarget;

        status = WdfRequestCreate(&attributes,
                                  deviceExtension->IoTarget,
                                  &startUnitRequest);
    }

    if (NT_SUCCESS(status))
    {
        srb->OriginalRequest = WdfRequestWdmGetIrp(startUnitRequest);
        NT_ASSERT(srb->OriginalRequest != NULL);

        //Prepare the request
        WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
        attributes.ParentObject = startUnitRequest;

        status = WdfMemoryCreatePreallocated(&attributes,
                                             (PVOID)srb,
                                             sizeof(SCSI_REQUEST_BLOCK),
                                             &inputMemory);
    }

    if (NT_SUCCESS(status))
    {
        status = WdfIoTargetFormatRequestForInternalIoctlOthers(deviceExtension->IoTarget,
                                                                startUnitRequest,
                                                                IOCTL_SCSI_EXECUTE_NONE,
                                                                inputMemory,
                                                                NULL,
                                                                NULL,
                                                                NULL,
                                                                NULL,
                                                                NULL);
    }

    if (NT_SUCCESS(status))
    {
        // Set a CompletionRoutine callback function.
        WdfRequestSetCompletionRoutine(startUnitRequest,
                                       DeviceAsynchronousCompletion,
                                       context);

        status = RequestSend(deviceExtension,
                             startUnitRequest,
                             deviceExtension->IoTarget,
                             0,
                             NULL);
    }

    // release resources when failed.
    if (!NT_SUCCESS(status))
    {
        FREE_POOL(context);
        if (startUnitRequest != NULL)
        {
            WdfObjectDelete(startUnitRequest);
        }
    }

    return;
} // end StartUnit()

Referenced by DeviceErrorHandlerForHitachiGD2000(), and SenseInfoInterpretByAdditionalSenseCode().

DeviceSetMediaChangeStateEx()

VOID DeviceSetMediaChangeStateEx	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ MEDIA_CHANGE_DETECTION_STATE	NewState,
		_Inout_opt_ PMEDIA_CHANGE_DETECTION_STATE	OldState
	)

Definition at line 751 of file autorun.c.

{
    PMEDIA_CHANGE_DETECTION_INFO info = DeviceExtension->MediaChangeDetectionInfo;
    LARGE_INTEGER                zero;
    NTSTATUS                     status;

    // timeout value must be 0, as this function can be called at DISPATCH_LEVEL.
    zero.QuadPart = 0;

    if (info == NULL)
    {
        return;
    }

    status = KeWaitForMutexObject(&info->MediaChangeMutex,
                                Executive,
                                KernelMode,
                                FALSE,
                                &zero);

    if (status == STATUS_TIMEOUT)
    {
        // Someone else is in the process of setting the media state.
        return;
    }

    // Change the media present state and signal an event, if applicable
    DeviceInternalSetMediaChangeState(DeviceExtension, NewState, OldState);

    KeReleaseMutex(&info->MediaChangeMutex, FALSE);

    return;
} // end DeviceSetMediaChangeStateEx()

Referenced by DeviceEvtSelfManagedIoInit(), and SenseInfoInterpretByAdditionalSenseCode().

DeviceZPODDGetPowerupReason()

NTSTATUS DeviceZPODDGetPowerupReason	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_Out_ PSTORAGE_IDLE_POWERUP_REASON	PowerupReason
	)

Definition at line 608 of file zpodd.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PIRP                    irp = NULL;
    IO_STATUS_BLOCK         ioStatus = {0};
    KEVENT                  event;

    RtlZeroMemory(PowerupReason, sizeof (STORAGE_IDLE_POWERUP_REASON));

    PowerupReason->Size = sizeof (STORAGE_IDLE_POWERUP_REASON);
    PowerupReason->Version = STORAGE_IDLE_POWERUP_REASON_VERSION_V1;

    //
    // Setup a synchronous irp.
    //

    KeInitializeEvent(&event, NotificationEvent, FALSE);

    irp = IoBuildDeviceIoControlRequest(IOCTL_STORAGE_GET_IDLE_POWERUP_REASON,
                                        DeviceExtension->LowerPdo,
                                        PowerupReason,
                                        sizeof (STORAGE_IDLE_POWERUP_REASON),
                                        PowerupReason,
                                        sizeof (STORAGE_IDLE_POWERUP_REASON),
                                        FALSE,
                                        &event,
                                        &ioStatus);

    if (irp == NULL)
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else
    {
        //
        // Send the synchronous request to port driver.
        //

        status = IoCallDriver(DeviceExtension->LowerPdo, irp);

        if (status == STATUS_PENDING)
        {
            KeWaitForSingleObject(&event, Executive, KernelMode, FALSE, NULL);

            status = ioStatus.Status;
        }
    }

    return status;
}

Referenced by DeviceEvtD0Entry().

FREE_PORT_ALLOCATED_SENSE_BUFFER()

FORCEINLINE VOID FREE_PORT_ALLOCATED_SENSE_BUFFER	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 839 of file cdrom.h.

{
#ifndef DEBUG
    UNREFERENCED_PARAMETER(DeviceExtension);
#endif
    NT_ASSERT(TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_PORT_DRIVER_ALLOCSENSE));
    NT_ASSERT(TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
    NT_ASSERT(Srb->SenseInfoBuffer != DeviceExtension->SenseData);

    ExFreePool(Srb->SenseInfoBuffer);
    Srb->SenseInfoBuffer = NULL;
    Srb->SenseInfoBufferLength = 0;
    CLEAR_FLAG(Srb->SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER);
    return;
}

Referenced by ClassAsynchronousCompletion(), ClassIoComplete(), ClassIoCompleteAssociated(), and DeviceAsynchronousCompletion().

IsVolumeMounted()

FORCEINLINE BOOLEAN IsVolumeMounted

(

_In_ PDEVICE_OBJECT

DeviceObject

)

Definition at line 1514 of file cdrom.h.

{
#pragma prefast(push)
#pragma prefast(disable: 28175, "there is no other way to check if there is volume mounted")
    return (DeviceObject->Vpb != NULL) &&
           ((DeviceObject->Vpb->Flags & VPB_MOUNTED) != 0);
#pragma prefast(pop)
}

Referenced by SenseInfoInterpretByAdditionalSenseCode(), and SenseInfoInterpretBySenseKey().

PORT_ALLOCATED_SENSE()

FORCEINLINE BOOLEAN PORT_ALLOCATED_SENSE	(	_In_ PCDROM_DEVICE_EXTENSION	DeviceExtension,
		_In_ PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 826 of file cdrom.h.

{
    UNREFERENCED_PARAMETER(DeviceExtension);
    return (BOOLEAN)((TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_PORT_DRIVER_ALLOCSENSE) &&
             TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER))
            );
}

Referenced by ClassAsynchronousCompletion(), ClassIoComplete(), ClassIoCompleteAssociated(), and DeviceAsynchronousCompletion().

RequestClearSendTime()

VOID RequestClearSendTime

(

_In_ WDFREQUEST

Request

)

Definition at line 111 of file common.c.

{
    PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);

    requestContext->TimeSentDownFirstTime.QuadPart = 0;
    requestContext->TimeSentDownLasttTime.QuadPart = 0;

    return;
}

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

RequestCompletion()

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

Definition at line 3439 of file common.c.

{
#ifdef DBG
    ULONG                   ioctlCode = 0;
    WDF_REQUEST_PARAMETERS  requestParameters;

    // Get the Request parameters
    WDF_REQUEST_PARAMETERS_INIT(&requestParameters);
    WdfRequestGetParameters(Request, &requestParameters);

    if (requestParameters.Type == WdfRequestTypeDeviceControl)
    {
        ioctlCode = requestParameters.Parameters.DeviceIoControl.IoControlCode;

        if (requestParameters.Parameters.DeviceIoControl.IoControlCode != IOCTL_MCN_SYNC_FAKE_IOCTL)
        {
            TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                       "Request complete - IOCTL - code: %X; Status: %X; Information: %X\n",
                       ioctlCode,
                       Status,
                       (ULONG)Information));
        }
        else
        {
            TracePrint((TRACE_LEVEL_VERBOSE, TRACE_FLAG_GENERAL,
                       "Request complete - IOCTL - code: %X; Status: %X; Information: %X\n",
                       ioctlCode,
                       Status,
                       (ULONG)Information));
        }
    }
    else if (requestParameters.Type == WdfRequestTypeRead)
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                   "Request complete - READ - Starting Offset: %X; Length: %X; Transferred Length: %X; Status: %X\n",
                   (ULONG)requestParameters.Parameters.Read.DeviceOffset,
                   (ULONG)requestParameters.Parameters.Read.Length,
                   (ULONG)Information,
                   Status));
    }
    else if (requestParameters.Type == WdfRequestTypeWrite)
    {
        TracePrint((TRACE_LEVEL_INFORMATION, TRACE_FLAG_GENERAL,
                   "Request complete - WRITE - Starting Offset: %X; Length: %X; Transferred Length: %X; Status: %X\n",
                   (ULONG)requestParameters.Parameters.Write.DeviceOffset,
                   (ULONG)requestParameters.Parameters.Write.Length,
                   (ULONG)Information,
                   Status));
    }
#endif

    if (IoIsErrorUserInduced(Status))
    {
        PIRP irp = WdfRequestWdmGetIrp(Request);
        if (irp->Tail.Overlay.Thread)
        {
            IoSetHardErrorOrVerifyDevice(irp, DeviceExtension->DeviceObject);
        }
    }

    if (!NT_SUCCESS(Status) && DeviceExtension->SurpriseRemoved == TRUE)
    {
        // IMAPI expects ERROR_DEV_NOT_EXISTS if recorder has been surprised removed,
        // or it will retry WRITE commands for up to 3 minutes
        // CDROM behavior should be consistent for all requests, including SCSI pass-through
        Status = STATUS_DEVICE_DOES_NOT_EXIST;
    }

    WdfRequestCompleteWithInformation(Request, Status, Information);

    return;
}

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

RequestDuidGetDeviceIdProperty()

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

Definition at line 2797 of file common.c.

{
    NTSTATUS                        status = STATUS_SUCCESS;
    PSTORAGE_DEVICE_ID_DESCRIPTOR   deviceIdDescriptor = NULL;
    PSTORAGE_DESCRIPTOR_HEADER      descHeader = NULL;
    STORAGE_PROPERTY_ID             propertyId = StorageDeviceIdProperty;

    *DataLength = 0;

    // Get the VPD page 83h data.
    status = DeviceRetrieveDescriptor(DeviceExtension->Device,
                                      &propertyId,
                                      (PSTORAGE_DESCRIPTOR_HEADER*)&deviceIdDescriptor);

    if (NT_SUCCESS(status) && (deviceIdDescriptor == NULL))
    {
        status = STATUS_NOT_FOUND;
    }

    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &descHeader,
                                                NULL);
    }

    if (NT_SUCCESS(status))
    {
        PSTORAGE_DEVICE_UNIQUE_IDENTIFIER   storageDuid = NULL;
        ULONG                               offset = descHeader->Size;
        PUCHAR                              dest = (PUCHAR)descHeader + offset;
        size_t                              outputBufferSize;

        outputBufferSize = RequestParameters.Parameters.DeviceIoControl.OutputBufferLength;

        // Adjust required size and potential destination location.
        status = RtlULongAdd(descHeader->Size, deviceIdDescriptor->Size, &descHeader->Size);

        if (NT_SUCCESS(status) &&
            (outputBufferSize < descHeader->Size))
        {
            // Output buffer is too small.  Return error and make sure
            // the caller gets info about required buffer size.
            *DataLength = descHeader->Size;
            status = STATUS_BUFFER_OVERFLOW;
        }

        if (NT_SUCCESS(status))
        {
            storageDuid = (PSTORAGE_DEVICE_UNIQUE_IDENTIFIER)descHeader;
            storageDuid->StorageDeviceIdOffset = offset;

            RtlCopyMemory(dest,
                          deviceIdDescriptor,
                          deviceIdDescriptor->Size);

            *DataLength = storageDuid->Size;
            status = STATUS_SUCCESS;
        }

        FREE_POOL(deviceIdDescriptor);
    }

    return status;
}

Referenced by RequestHandleQueryPropertyDeviceUniqueId().

RequestDuidGetDeviceProperty()

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

Definition at line 2888 of file common.c.

{
    NTSTATUS                          status = STATUS_SUCCESS;
    PSTORAGE_DEVICE_DESCRIPTOR        deviceDescriptor = DeviceExtension->DeviceDescriptor;
    PSTORAGE_DESCRIPTOR_HEADER        descHeader = NULL;
    PSTORAGE_DEVICE_UNIQUE_IDENTIFIER storageDuid;
    PUCHAR                            dest = NULL;

    if (deviceDescriptor == NULL)
    {
        status = STATUS_NOT_FOUND;
    }

    if (NT_SUCCESS(status))
    {
        status = WdfRequestRetrieveOutputBuffer(Request,
                                                RequestParameters.Parameters.DeviceIoControl.OutputBufferLength,
                                                &descHeader,
                                                NULL);
    }

    if (NT_SUCCESS(status) &&
        (deviceDescriptor->SerialNumberOffset == 0))
    {
        status = STATUS_NOT_FOUND;
    }

    // Use this info only if serial number is available.
    if (NT_SUCCESS(status))
    {
        ULONG offset = descHeader->Size;
        size_t outputBufferSize = RequestParameters.Parameters.DeviceIoControl.OutputBufferLength;

        // Adjust required size and potential destination location.
        dest = (PUCHAR)descHeader + offset;

        status = RtlULongAdd(descHeader->Size, deviceDescriptor->Size, &descHeader->Size);

        if (NT_SUCCESS(status) &&
            (outputBufferSize < descHeader->Size))
        {
            // Output buffer is too small.  Return error and make sure
            // the caller get info about required buffer size.
            *DataLength = descHeader->Size;
            status = STATUS_BUFFER_OVERFLOW;
        }

        if (NT_SUCCESS(status))
        {
            storageDuid = (PSTORAGE_DEVICE_UNIQUE_IDENTIFIER)descHeader;
            storageDuid->StorageDeviceOffset = offset;

            RtlCopyMemory(dest,
                          deviceDescriptor,
                          deviceDescriptor->Size);

            *DataLength = storageDuid->Size;
            status = STATUS_SUCCESS;
        }
    }

    return status;
}

Referenced by RequestHandleQueryPropertyDeviceUniqueId().

RequestGetCurrentStackLocationFlags()

FORCEINLINE UCHAR RequestGetCurrentStackLocationFlags

(

_In_ WDFREQUEST

Request

)

Definition at line 1554 of file cdrom.h.

{
    PIRP                irp = NULL;
    PIO_STACK_LOCATION  currentStack = NULL;

    irp = WdfRequestWdmGetIrp(Request);
    currentStack = IoGetCurrentIrpStackLocation(irp);

    return currentStack->Flags;
}

Referenced by RequestDispatchProcessDirectly(), RequestDispatchSpecialIoctls(), RequestDispatchSyncWithSequentialQueue(), RequestDispatchToSequentialQueue(), and RequestIsRealtimeStreaming().

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().

RequestSend()

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

Definition at line 3793 of file common.c.

{
    NTSTATUS                 status  = STATUS_SUCCESS;
    BOOLEAN                  requestSent = FALSE;
    WDF_REQUEST_SEND_OPTIONS options;

    UNREFERENCED_PARAMETER(DeviceExtension);

    if ((DeviceExtension->ZeroPowerODDInfo != NULL) &&
        (DeviceExtension->ZeroPowerODDInfo->InZeroPowerState != FALSE))
    {
    }

    // Now send down the request
    if (NT_SUCCESS(status))
    {
        WDF_REQUEST_SEND_OPTIONS_INIT(&options, Flags);

        RequestSetSentTime(Request);

        // send request and check status

        // Disable SDV warning about infinitely waiting in caller's context:
        //   1. Some requests (such as SCSI_PASS_THROUGH, contains buffer from user space) need to be sent down in caller’s context.
        //      Consequently, these requests wait in caller’s context until they are allowed to be sent down.
        //   2. Considering the situation that during sleep, a request can be hold by storage port driver. When system resumes, any time out value (if we set using KMDF time out value) might be expires.
        //      This will cause the waiting request being failed (behavior change). We’d rather not set time out value.

        _Analysis_assume_(options.Timeout != 0);
        requestSent = WdfRequestSend(Request, IoTarget, &options);
        _Analysis_assume_(options.Timeout == 0);

        // If WdfRequestSend fails, or if the WDF_REQUEST_SEND_OPTION_SYNCHRONOUS flag is set,
        // the driver can call WdfRequestGetStatus immediately after calling WdfRequestSend.
        if ((requestSent == FALSE) ||
            (Flags & WDF_REQUEST_SEND_OPTION_SYNCHRONOUS))
        {
            status = WdfRequestGetStatus(Request);

            if (requestSent == FALSE)
            {
                TracePrint((TRACE_LEVEL_WARNING, TRACE_FLAG_GENERAL,
                            "WdfRequestSend failed: %lx\n",
                            status
                            ));
            }
        }
        else
        {
            status = STATUS_SUCCESS;
        }

        if (RequestSent != NULL)
        {
            *RequestSent = requestSent;
        }
    }

    return status;
}

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

RequestSenseInfoInterpret()

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

Definition at line 2467 of file sense.c.

{
    BOOLEAN                 retry = FALSE;
    LONGLONG                retryIntervalIn100ns = 0;
    PZERO_POWER_ODD_INFO    zpoddInfo = DeviceExtension->ZeroPowerODDInfo;

    if (SRB_STATUS(Srb->SrbStatus) == SRB_STATUS_SUCCESS)
    {
        // request succeeded.
        if ((zpoddInfo != NULL) &&
            (zpoddInfo->BecomingReadyRetryCount > 0))
        {
            zpoddInfo->BecomingReadyRetryCount = 0;
        }

        *Status = STATUS_SUCCESS;
        retry = FALSE;
    }
    else
    {
        // request failed. We need to process the error.

        // 1. Release the queue if it is frozen.
        if (Srb->SrbStatus & SRB_STATUS_QUEUE_FROZEN)
        {
            DeviceReleaseQueue(DeviceExtension->Device);
        }

        if ((zpoddInfo != NULL) &&
            ((zpoddInfo->RetryFirstCommand != FALSE) || (zpoddInfo->BecomingReadyRetryCount > 0)))
        {
            retry = SenseInfoInterpretForZPODD(DeviceExtension,
                                               Srb,
                                               Status,
                                               &retryIntervalIn100ns);
        }

        if (retry == FALSE)
        {
            // 2. Error Processing
            if ((zpoddInfo != NULL) &&
                (zpoddInfo->BecomingReadyRetryCount > 0))
            {
                zpoddInfo->BecomingReadyRetryCount = 0;
            }

            retry = SenseInfoInterpret(DeviceExtension,
                                       Request,
                                       Srb,
                                       RetriedCount,
                                       Status,
                                       &retryIntervalIn100ns);
        }
    }

    if (RetryIntervalIn100ns != NULL)
    {
        *RetryIntervalIn100ns = retryIntervalIn100ns;
    }

    return retry;
}

Referenced by _IRQL_requires_max_(), and RequestSenseInfoInterpretForScratchBuffer().

RequestSenseInfoInterpretForScratchBuffer()

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

Definition at line 2564 of file sense.c.

{
    NT_ASSERT(DeviceExtension->ScratchContext.ScratchInUse != 0);

    return RequestSenseInfoInterpret(DeviceExtension,
                                     DeviceExtension->ScratchContext.ScratchRequest,
                                     DeviceExtension->ScratchContext.ScratchSrb,
                                     RetriedCount,
                                     Status,
                                     RetryIntervalIn100ns);
}

Referenced by RequestIssueShutdownFlush(), and ScratchBuffer_ReadWriteCompletionRoutine().

RequestSetContextFields()

NTSTATUS RequestSetContextFields	(	_In_ WDFREQUEST	Request,
		_In_ PSYNC_HANDLER	Handler
	)

Definition at line 2748 of file common.c.

{
    NTSTATUS                status = STATUS_SUCCESS;
    PCDROM_REQUEST_CONTEXT  requestContext = RequestGetContext(Request);
    PKEVENT                 syncEvent = NULL;

    syncEvent = ExAllocatePoolWithTag(NonPagedPoolNx,
                                      sizeof(KEVENT),
                                      CDROM_TAG_SYNC_EVENT);

    if (syncEvent == NULL)
    {
        // memory allocation failed.
        status = STATUS_INSUFFICIENT_RESOURCES;
    }
    else
    {
        // now, put the special synchronization information into the context
        requestContext->SyncRequired = TRUE;
        requestContext->SyncEvent = syncEvent;
        requestContext->SyncCallback = Handler;

        status = STATUS_SUCCESS;
    }

    return status;
}

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

RequestSetReceivedTime()

VOID RequestSetReceivedTime

(

_In_ WDFREQUEST

Request

)

Definition at line 64 of file common.c.

{
    PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);
    LARGE_INTEGER          temp;

    KeQueryTickCount(&temp);

    requestContext->TimeReceived = temp;

    return;
}

Referenced by DeviceEvtIoInCallerContext().

RequestSetSentTime()

VOID RequestSetSentTime

(

_In_ WDFREQUEST

Request

)

Definition at line 79 of file common.c.

{
    PCDROM_REQUEST_CONTEXT requestContext = RequestGetContext(Request);
    LARGE_INTEGER          temp;

    KeQueryTickCount(&temp);

    if (requestContext->TimeSentDownFirstTime.QuadPart == 0)
    {
        requestContext->TimeSentDownFirstTime = temp;
    }

    requestContext->TimeSentDownLasttTime = temp;

    if (requestContext->OriginalRequest != NULL)
    {
        PCDROM_REQUEST_CONTEXT originalRequestContext = RequestGetContext(requestContext->OriginalRequest);

        if (originalRequestContext->TimeSentDownFirstTime.QuadPart == 0)
        {
            originalRequestContext->TimeSentDownFirstTime = temp;
        }

        originalRequestContext->TimeSentDownLasttTime = temp;
    }

    return;
}

Referenced by RequestSend().

RequestSetupMcnSyncIrp()

VOID RequestSetupMcnSyncIrp

(

_In_ PCDROM_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 2749 of file autorun.c.

{
    PIRP                irp = NULL;
    PIO_STACK_LOCATION  irpStack = NULL;
    PIO_STACK_LOCATION  nextIrpStack = NULL;

    irp = DeviceExtension->MediaChangeDetectionInfo->MediaChangeSyncIrp;
    NT_ASSERT(irp != NULL);

    //
    //  For the driver that creates an IRP, there is no 'current' stack location.
    //  Step down one IRP stack location so that the extra top one
    //  becomes our 'current' one.
    //
    IoSetNextIrpStackLocation(irp);

    /*
     *  Cache our device object in the extra top IRP stack location
     *  so we have it in our completion routine.
     */
    irpStack = IoGetCurrentIrpStackLocation(irp);
    irpStack->DeviceObject = DeviceExtension->DeviceObject;

    //
    // If the irp is sent down when the volume needs to be
    // verified, CdRomUpdateGeometryCompletion won't complete
    // it since it's not associated with a thread.  Marking
    // it to override the verify causes it always be sent
    // to the port driver
    //
    nextIrpStack = IoGetNextIrpStackLocation(irp);

    SET_FLAG(nextIrpStack->Flags, SL_OVERRIDE_VERIFY_VOLUME);

    nextIrpStack->MajorFunction = IRP_MJ_DEVICE_CONTROL;
    // pick up this IOCTL code as it's not normaly seen for CD/DVD drive and does not require input.
    // set other fields to make this IOCTL recognizable by CDROM.SYS
    nextIrpStack->Parameters.Others.Argument1 = RequestSetupMcnSyncIrp;
    nextIrpStack->Parameters.Others.Argument2 = RequestSetupMcnSyncIrp;
    nextIrpStack->Parameters.DeviceIoControl.IoControlCode = IOCTL_MCN_SYNC_FAKE_IOCTL; //Argument3.
    nextIrpStack->Parameters.Others.Argument4 = RequestSetupMcnSyncIrp;

    IoSetCompletionRoutine(irp,
                           RequestMcnSyncIrpCompletion,
                           DeviceExtension,
                           TRUE,
                           TRUE,
                           TRUE);

    return;
}

Referenced by RequestDispatchSpecialIoctls(), and RequestSetupMcnSyncIrp().

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().

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().

TimeOutValueGetCapValue()

FORCEINLINE ULONG TimeOutValueGetCapValue	(	_In_ ULONG	TimeOutValue,
		_In_ ULONG	Times
	)

Definition at line 1569 of file cdrom.h.

{
    ULONG   value = 0;

    if (TimeOutValue > SCSI_CDROM_OPC_TIMEOUT)
    {
        // if time out value is specified by user in registry, and is
        // bigger than OPC time out, it should be big enough
        value = TimeOutValue;
    }
    else
    {
        // otherwise, OPC time out value should be the upper limit
        value = min(TimeOutValue * Times, SCSI_CDROM_OPC_TIMEOUT);
    }

    return value;
}