classp.h File Reference

#include <ntddk.h>
#include <classpnp.h>
#include <ioevent.h>
#include <pseh/pseh2.h>
#include "debug.h"

Include dependency graph for classp.h:

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

Go to the source code of this file.

Classes
struct	_MEDIA_CHANGE_DETECTION_INFO
struct	_FAILURE_PREDICTION_INFO
struct	_CLASS_RETRY_INFO
struct	_CSCAN_LIST
struct	_CLASS_ERROR_LOG_DATA
struct	_TRANSFER_PACKET
struct	_CLASS_PRIVATE_FDO_DATA

Macros
#define	CLASSP_REG_SUBKEY_NAME   (L"Classpnp")
#define	CLASSP_REG_HACK_VALUE_NAME   (L"HackMask")
#define	CLASSP_REG_MMC_DETECTION_VALUE_NAME   (L"MMCDetectionState")
#define	CLASSP_REG_WRITE_CACHE_VALUE_NAME   (L"WriteCacheEnableOverride")
#define	CLASSP_REG_PERF_RESTORE_VALUE_NAME   (L"RestorePerfAtCount")
#define	CLASSP_REG_REMOVAL_POLICY_VALUE_NAME   (L"UserRemovalPolicy")
#define	CLASS_PERF_RESTORE_MINIMUM   (0x10)
#define	CLASS_ERROR_LEVEL_1   (0x4)
#define	CLASS_ERROR_LEVEL_2   (0x8)
#define	FDO_HACK_CANNOT_LOCK_MEDIA   (0x00000001)
#define	FDO_HACK_GESN_IS_BAD   (0x00000002)
#define	FDO_HACK_NO_SYNC_CACHE   (0x00000004)
#define	FDO_HACK_VALID_FLAGS   (0x00000007)
#define	FDO_HACK_INVALID_FLAGS   (~FDO_HACK_VALID_FLAGS)
#define	NUM_LOCKMEDIAREMOVAL_RETRIES   1
#define	NUM_MODESENSE_RETRIES   1
#define	NUM_DRIVECAPACITY_RETRIES   1
#define	CLASS_FILE_OBJECT_EXTENSION_KEY   'eteP'
#define	CLASSP_VOLUME_VERIFY_CHECKED   0x34
#define	CLASS_TAG_PRIVATE_DATA   'CPcS'
#define	CLASS_TAG_PRIVATE_DATA_FDO   'FPcS'
#define	CLASS_TAG_PRIVATE_DATA_PDO   'PPcS'
#define	NUM_ERROR_LOG_ENTRIES   16
#define	MIN_INITIAL_TRANSFER_PACKETS   1
#define	MIN_WORKINGSET_TRANSFER_PACKETS_Consumer   4
#define	MAX_WORKINGSET_TRANSFER_PACKETS_Consumer   64
#define	MIN_WORKINGSET_TRANSFER_PACKETS_Server   64
#define	MAX_WORKINGSET_TRANSFER_PACKETS_Server   1024
#define	MIN_WORKINGSET_TRANSFER_PACKETS_Enterprise   256
#define	MAX_WORKINGSET_TRANSFER_PACKETS_Enterprise   2048
#define	MIN(a, b)   ((a) < (b) ? (a) : (b))
#define	MAX(a, b)   ((a) > (b) ? (a) : (b))
#define	NOT_READY_RETRY_INTERVAL   10
#define	MINIMUM_RETRY_UNITS   ((LONGLONG)32)

Typedefs
typedef enum MEDIA_LOCK_TYPE *	PMEDIA_LOCK_TYPE
typedef struct _FAILURE_PREDICTION_INFO	FAILURE_PREDICTION_INFO
typedef struct _FAILURE_PREDICTION_INFO *	PFAILURE_PREDICTION_INFO
typedef struct _CLASS_RETRY_INFO	CLASS_RETRY_INFO
typedef struct _CLASS_RETRY_INFO *	PCLASS_RETRY_INFO
typedef struct _CSCAN_LIST	CSCAN_LIST
typedef struct _CSCAN_LIST *	PCSCAN_LIST
typedef enum _CLASS_DETECTION_STATE	CLASS_DETECTION_STATE
typedef enum _CLASS_DETECTION_STATE *	PCLASS_DETECTION_STATE
typedef struct _CLASS_ERROR_LOG_DATA	CLASS_ERROR_LOG_DATA
typedef struct _CLASS_ERROR_LOG_DATA *	PCLASS_ERROR_LOG_DATA
typedef struct _TRANSFER_PACKET	TRANSFER_PACKET
typedef struct _TRANSFER_PACKET *	PTRANSFER_PACKET

Enumerations
enum	MEDIA_LOCK_TYPE { SimpleMediaLock, SecureMediaLock, InternalMediaLock }
enum	_CLASS_DETECTION_STATE { ClassDetectionUnknown = 0, ClassDetectionUnsupported = 1, ClassDetectionSupported = 2 }

Functions
static VOID	SimpleInitSlistHdr (SLIST_ENTRY *SListHdr)
static VOID	SimplePushSlist (SLIST_ENTRY *SListHdr, SLIST_ENTRY *SListEntry)
static SLIST_ENTRY *	SimplePopSlist (SLIST_ENTRY *SListHdr)
static BOOLEAN	SimpleIsSlistEmpty (SLIST_ENTRY *SListHdr)
NTSTATUS NTAPI	ClasspCreateClose (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	ClasspCleanupProtectedLocks (IN PFILE_OBJECT_EXTENSION FsContext)
NTSTATUS NTAPI	ClasspEjectionControl (IN PDEVICE_OBJECT Fdo, IN PIRP Irp, IN MEDIA_LOCK_TYPE LockType, IN BOOLEAN Lock)
NTSTATUS NTAPI	ClassPnpStartDevice (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	ClassShutdownFlush (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	RetryRequest (PDEVICE_OBJECT DeviceObject, PIRP Irp, PSCSI_REQUEST_BLOCK Srb, BOOLEAN Associated, ULONG RetryInterval)
NTSTATUS NTAPI	ClassIoCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context)
NTSTATUS NTAPI	ClassPnpQueryFdoRelations (IN PDEVICE_OBJECT Fdo, IN PIRP Irp)
NTSTATUS NTAPI	ClassRetrieveDeviceRelations (IN PDEVICE_OBJECT Fdo, IN DEVICE_RELATION_TYPE RelationType, OUT PDEVICE_RELATIONS *DeviceRelations)
NTSTATUS NTAPI	ClassGetPdoId (IN PDEVICE_OBJECT Pdo, IN BUS_QUERY_ID_TYPE IdType, IN PUNICODE_STRING IdString)
NTSTATUS NTAPI	ClassQueryPnpCapabilities (IN PDEVICE_OBJECT PhysicalDeviceObject, IN PDEVICE_CAPABILITIES Capabilities)
NTSTATUS NTAPI	ClasspPagingNotificationCompletion (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PDEVICE_OBJECT RealDeviceObject)
NTSTATUS NTAPI	ClasspMediaChangeCompletion (PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
PFILE_OBJECT_EXTENSION NTAPI	ClasspGetFsContext (IN PCOMMON_DEVICE_EXTENSION CommonExtension, IN PFILE_OBJECT FileObject)
NTSTATUS NTAPI	ClasspMcnControl (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PIRP Irp, IN PSCSI_REQUEST_BLOCK Srb)
VOID NTAPI	ClasspRegisterMountedDeviceInterface (IN PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	ClasspDisableTimer (PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI	ClasspEnableTimer (PDEVICE_OBJECT DeviceObject)
VOID NTAPI	InitializeDictionary (IN PDICTIONARY Dictionary)
BOOLEAN NTAPI	TestDictionarySignature (IN PDICTIONARY Dictionary)
NTSTATUS NTAPI	AllocateDictionaryEntry (IN PDICTIONARY Dictionary, IN ULONGLONG Key, IN ULONG Size, IN ULONG Tag, OUT PVOID *Entry)
PVOID NTAPI	GetDictionaryEntry (IN PDICTIONARY Dictionary, IN ULONGLONG Key)
VOID NTAPI	FreeDictionaryEntry (IN PDICTIONARY Dictionary, IN PVOID Entry)
NTSTATUS NTAPI	ClasspAllocateReleaseRequest (IN PDEVICE_OBJECT Fdo)
VOID NTAPI	ClasspFreeReleaseRequest (IN PDEVICE_OBJECT Fdo)
VOID NTAPI	ClasspReleaseQueue (IN PDEVICE_OBJECT DeviceObject, IN PIRP ReleaseQueueIrp)
VOID NTAPI	ClasspDisablePowerNotification (PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS NTAPI	ClassMinimalPowerHandler (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
VOID NTAPI	ClassAddChild (IN PFUNCTIONAL_DEVICE_EXTENSION Parent, IN PPHYSICAL_DEVICE_EXTENSION Child, IN BOOLEAN AcquireLock)
PPHYSICAL_DEVICE_EXTENSION NTAPI	ClassRemoveChild (IN PFUNCTIONAL_DEVICE_EXTENSION Parent, IN PPHYSICAL_DEVICE_EXTENSION Child, IN BOOLEAN AcquireLock)
VOID NTAPI	ClasspRetryDpcTimer (IN PCLASS_PRIVATE_FDO_DATA FdoData)
VOID NTAPI	ClassFreeOrReuseSrb (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PSCSI_REQUEST_BLOCK Srb)
VOID NTAPI	ClassRetryRequest (IN PDEVICE_OBJECT SelfDeviceObject, IN PIRP Irp, IN LARGE_INTEGER TimeDelta100ns)
VOID NTAPI	ClasspBuildRequestEx (IN PFUNCTIONAL_DEVICE_EXTENSION Fdo, IN PIRP Irp, IN PSCSI_REQUEST_BLOCK Srb)
NTSTATUS NTAPI	ClasspAllocateReleaseQueueIrp (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
NTSTATUS NTAPI	ClasspInitializeGesn (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN PMEDIA_CHANGE_DETECTION_INFO Info)
VOID NTAPI	ClasspSendNotification (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN const GUID *Guid, IN ULONG ExtraDataSize, IN PVOID ExtraData)
VOID NTAPI	ClassSendEjectionNotification (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID NTAPI	ClasspScanForSpecialInRegistry (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID NTAPI	ClasspScanForClassHacks (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension, IN ULONG_PTR Data)
NTSTATUS NTAPI	ClasspInitializeHotplugInfo (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID NTAPI	ClasspPerfIncrementErrorCount (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
VOID NTAPI	ClasspPerfIncrementSuccessfulIo (IN PFUNCTIONAL_DEVICE_EXTENSION FdoExtension)
PTRANSFER_PACKET NTAPI	NewTransferPacket (PDEVICE_OBJECT Fdo)
VOID NTAPI	DestroyTransferPacket (PTRANSFER_PACKET Pkt)
VOID NTAPI	EnqueueFreeTransferPacket (PDEVICE_OBJECT Fdo, PTRANSFER_PACKET Pkt)
PTRANSFER_PACKET NTAPI	DequeueFreeTransferPacket (PDEVICE_OBJECT Fdo, BOOLEAN AllocIfNeeded)
VOID NTAPI	SetupReadWriteTransferPacket (PTRANSFER_PACKET pkt, PVOID Buf, ULONG Len, LARGE_INTEGER DiskLocation, PIRP OriginalIrp)
VOID NTAPI	SubmitTransferPacket (PTRANSFER_PACKET Pkt)
NTSTATUS NTAPI	TransferPktComplete (IN PDEVICE_OBJECT NullFdo, IN PIRP Irp, IN PVOID Context)
VOID NTAPI	ServiceTransferRequest (PDEVICE_OBJECT Fdo, PIRP Irp)
VOID NTAPI	TransferPacketRetryTimerDpc (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
BOOLEAN NTAPI	InterpretTransferPacketError (PTRANSFER_PACKET Pkt)
BOOLEAN NTAPI	RetryTransferPacket (PTRANSFER_PACKET Pkt)
VOID NTAPI	EnqueueDeferredClientIrp (PCLASS_PRIVATE_FDO_DATA FdoData, PIRP Irp)
PIRP NTAPI	DequeueDeferredClientIrp (PCLASS_PRIVATE_FDO_DATA FdoData)
VOID NTAPI	InitLowMemRetry (PTRANSFER_PACKET Pkt, PVOID BufPtr, ULONG Len, LARGE_INTEGER TargetLocation)
BOOLEAN NTAPI	StepLowMemRetry (PTRANSFER_PACKET Pkt)
VOID NTAPI	SetupEjectionTransferPacket (TRANSFER_PACKET *Pkt, BOOLEAN PreventMediaRemoval, PKEVENT SyncEventPtr, PIRP OriginalIrp)
VOID NTAPI	SetupModeSenseTransferPacket (TRANSFER_PACKET *Pkt, PKEVENT SyncEventPtr, PVOID ModeSenseBuffer, UCHAR ModeSenseBufferLen, UCHAR PageMode, PIRP OriginalIrp)
VOID NTAPI	SetupDriveCapacityTransferPacket (TRANSFER_PACKET *Pkt, PVOID ReadCapacityBuffer, ULONG ReadCapacityBufferLen, PKEVENT SyncEventPtr, PIRP OriginalIrp)
PMDL NTAPI	BuildDeviceInputMdl (PVOID Buffer, ULONG BufferLen)
VOID NTAPI	FreeDeviceInputMdl (PMDL Mdl)
NTSTATUS NTAPI	InitializeTransferPackets (PDEVICE_OBJECT Fdo)
VOID NTAPI	DestroyAllTransferPackets (PDEVICE_OBJECT Fdo)

Variables
CLASSPNP_SCAN_FOR_SPECIAL_INFO	ClassBadItems []
GUID	ClassGuidQueryRegInfoEx
DRIVER_INITIALIZE	DriverEntry
DRIVER_UNLOAD	ClassUnload
DRIVER_DISPATCH	ClassCreateClose
DRIVER_DISPATCH	ClassReadWrite
DRIVER_DISPATCH	ClassDeviceControlDispatch
DRIVER_DISPATCH	ClassDispatchPnp
DRIVER_DISPATCH	ClassSystemControl
DRIVER_ADD_DEVICE	ClassAddDevice
IO_COMPLETION_ROUTINE	ClasspSendSynchronousCompletion
DRIVER_STARTIO	ClasspStartIo
IO_COMPLETION_ROUTINE	ClassReleaseQueueCompletion
DRIVER_DISPATCH	ClassDispatchPower
KDEFERRED_ROUTINE	ClasspRetryRequestDpc

Macro Definition Documentation

CLASS_ERROR_LEVEL_1

#define CLASS_ERROR_LEVEL_1   (0x4)

Definition at line 50 of file classp.h.

CLASS_ERROR_LEVEL_2

#define CLASS_ERROR_LEVEL_2   (0x8)

Definition at line 51 of file classp.h.

CLASS_FILE_OBJECT_EXTENSION_KEY

#define CLASS_FILE_OBJECT_EXTENSION_KEY   'eteP'

Definition at line 79 of file classp.h.

CLASS_PERF_RESTORE_MINIMUM

#define CLASS_PERF_RESTORE_MINIMUM   (0x10)

Definition at line 49 of file classp.h.

CLASS_TAG_PRIVATE_DATA

#define CLASS_TAG_PRIVATE_DATA   'CPcS'

Definition at line 82 of file classp.h.

CLASS_TAG_PRIVATE_DATA_FDO

#define CLASS_TAG_PRIVATE_DATA_FDO   'FPcS'

Definition at line 83 of file classp.h.

CLASS_TAG_PRIVATE_DATA_PDO

#define CLASS_TAG_PRIVATE_DATA_PDO   'PPcS'

Definition at line 84 of file classp.h.

CLASSP_REG_HACK_VALUE_NAME

#define CLASSP_REG_HACK_VALUE_NAME   (L"HackMask")

Definition at line 43 of file classp.h.

CLASSP_REG_MMC_DETECTION_VALUE_NAME

#define CLASSP_REG_MMC_DETECTION_VALUE_NAME   (L"MMCDetectionState")

Definition at line 44 of file classp.h.

CLASSP_REG_PERF_RESTORE_VALUE_NAME

#define CLASSP_REG_PERF_RESTORE_VALUE_NAME   (L"RestorePerfAtCount")

Definition at line 46 of file classp.h.

CLASSP_REG_REMOVAL_POLICY_VALUE_NAME

#define CLASSP_REG_REMOVAL_POLICY_VALUE_NAME   (L"UserRemovalPolicy")

Definition at line 47 of file classp.h.

CLASSP_REG_SUBKEY_NAME

#define CLASSP_REG_SUBKEY_NAME   (L"Classpnp")

Definition at line 41 of file classp.h.

CLASSP_REG_WRITE_CACHE_VALUE_NAME

#define CLASSP_REG_WRITE_CACHE_VALUE_NAME   (L"WriteCacheEnableOverride")

Definition at line 45 of file classp.h.

CLASSP_VOLUME_VERIFY_CHECKED

#define CLASSP_VOLUME_VERIFY_CHECKED   0x34

Definition at line 80 of file classp.h.

FDO_HACK_CANNOT_LOCK_MEDIA

#define FDO_HACK_CANNOT_LOCK_MEDIA   (0x00000001)

Definition at line 53 of file classp.h.

FDO_HACK_GESN_IS_BAD

#define FDO_HACK_GESN_IS_BAD   (0x00000002)

Definition at line 54 of file classp.h.

FDO_HACK_INVALID_FLAGS

#define FDO_HACK_INVALID_FLAGS   (~FDO_HACK_VALID_FLAGS)

Definition at line 58 of file classp.h.

FDO_HACK_NO_SYNC_CACHE

#define FDO_HACK_NO_SYNC_CACHE   (0x00000004)

Definition at line 55 of file classp.h.

FDO_HACK_VALID_FLAGS

#define FDO_HACK_VALID_FLAGS   (0x00000007)

Definition at line 57 of file classp.h.

MAX

#define MAX	(		a,
			b
	)		((a) > (b) ? (a) : (b))

Definition at line 468 of file classp.h.

MAX_WORKINGSET_TRANSFER_PACKETS_Consumer

#define MAX_WORKINGSET_TRANSFER_PACKETS_Consumer   64

Definition at line 376 of file classp.h.

MAX_WORKINGSET_TRANSFER_PACKETS_Enterprise

#define MAX_WORKINGSET_TRANSFER_PACKETS_Enterprise   2048

Definition at line 380 of file classp.h.

MAX_WORKINGSET_TRANSFER_PACKETS_Server

#define MAX_WORKINGSET_TRANSFER_PACKETS_Server   1024

Definition at line 378 of file classp.h.

MIN

#define MIN	(		a,
			b
	)		((a) < (b) ? (a) : (b))

Definition at line 467 of file classp.h.

MIN_INITIAL_TRANSFER_PACKETS

#define MIN_INITIAL_TRANSFER_PACKETS   1

Definition at line 374 of file classp.h.

MIN_WORKINGSET_TRANSFER_PACKETS_Consumer

#define MIN_WORKINGSET_TRANSFER_PACKETS_Consumer   4

Definition at line 375 of file classp.h.

MIN_WORKINGSET_TRANSFER_PACKETS_Enterprise

#define MIN_WORKINGSET_TRANSFER_PACKETS_Enterprise   256

Definition at line 379 of file classp.h.

MIN_WORKINGSET_TRANSFER_PACKETS_Server

#define MIN_WORKINGSET_TRANSFER_PACKETS_Server   64

Definition at line 377 of file classp.h.

MINIMUM_RETRY_UNITS

#define MINIMUM_RETRY_UNITS   ((LONGLONG)32)

Definition at line 472 of file classp.h.

NOT_READY_RETRY_INTERVAL

#define NOT_READY_RETRY_INTERVAL   10

Definition at line 471 of file classp.h.

NUM_DRIVECAPACITY_RETRIES

#define NUM_DRIVECAPACITY_RETRIES   1

Definition at line 76 of file classp.h.

NUM_ERROR_LOG_ENTRIES

#define NUM_ERROR_LOG_ENTRIES   16

Definition at line 280 of file classp.h.

NUM_LOCKMEDIAREMOVAL_RETRIES

#define NUM_LOCKMEDIAREMOVAL_RETRIES   1

Definition at line 74 of file classp.h.

NUM_MODESENSE_RETRIES

#define NUM_MODESENSE_RETRIES   1

Definition at line 75 of file classp.h.

Typedef Documentation

CLASS_DETECTION_STATE

typedef enum _CLASS_DETECTION_STATE CLASS_DETECTION_STATE

CLASS_ERROR_LOG_DATA

typedef struct _CLASS_ERROR_LOG_DATA CLASS_ERROR_LOG_DATA

CLASS_RETRY_INFO

typedef struct _CLASS_RETRY_INFO CLASS_RETRY_INFO

CSCAN_LIST

typedef struct _CSCAN_LIST CSCAN_LIST

FAILURE_PREDICTION_INFO

typedef struct _FAILURE_PREDICTION_INFO FAILURE_PREDICTION_INFO

PCLASS_DETECTION_STATE

typedef enum _CLASS_DETECTION_STATE * PCLASS_DETECTION_STATE

PCLASS_ERROR_LOG_DATA

typedef struct _CLASS_ERROR_LOG_DATA * PCLASS_ERROR_LOG_DATA

PCLASS_RETRY_INFO

typedef struct _CLASS_RETRY_INFO * PCLASS_RETRY_INFO

PCSCAN_LIST

typedef struct _CSCAN_LIST * PCSCAN_LIST

PFAILURE_PREDICTION_INFO

typedef struct _FAILURE_PREDICTION_INFO * PFAILURE_PREDICTION_INFO

PMEDIA_LOCK_TYPE

typedef enum MEDIA_LOCK_TYPE * PMEDIA_LOCK_TYPE

PTRANSFER_PACKET

typedef struct _TRANSFER_PACKET * PTRANSFER_PACKET

TRANSFER_PACKET

typedef struct _TRANSFER_PACKET TRANSFER_PACKET

Enumeration Type Documentation

_CLASS_DETECTION_STATE

enum _CLASS_DETECTION_STATE

Enumerator
ClassDetectionUnknown
ClassDetectionUnsupported
ClassDetectionSupported

Definition at line 251 of file classp.h.

                                    {
    ClassDetectionUnknown = 0,
    ClassDetectionUnsupported = 1,
    ClassDetectionSupported = 2
} CLASS_DETECTION_STATE, *PCLASS_DETECTION_STATE;

MEDIA_LOCK_TYPE

enum MEDIA_LOCK_TYPE

Enumerator
SimpleMediaLock
SecureMediaLock
InternalMediaLock

Definition at line 189 of file classp.h.

             {
    SimpleMediaLock,
    SecureMediaLock,
    InternalMediaLock
} MEDIA_LOCK_TYPE, *PMEDIA_LOCK_TYPE;

Function Documentation

AllocateDictionaryEntry()

NTSTATUS NTAPI AllocateDictionaryEntry	(	IN PDICTIONARY	Dictionary,
		IN ULONGLONG	Key,
		IN ULONG	Size,
		IN ULONG	Tag,
		OUT PVOID *	Entry
	)

Definition at line 60 of file dictlib.c.

{
    PDICTIONARY_HEADER header;
    KIRQL oldIrql;
    PDICTIONARY_HEADER *entry;

    NTSTATUS status = STATUS_SUCCESS;

    *Entry = NULL;

    header = ExAllocatePoolWithTag(NonPagedPool,
                                   Size + sizeof(DICTIONARY_HEADER),
                                   Tag);

    if(header == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(header, sizeof(DICTIONARY_HEADER) + Size);
    header->Key = Key;

    //
    // Find the correct location for this entry in the dictionary.
    //

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

    TRY {

        entry = &(Dictionary->List);

        while(*entry != NULL) {
            if((*entry)->Key == Key) {

                //
                // Dictionary must have unique keys.
                //

                status = STATUS_OBJECT_NAME_COLLISION;
                LEAVE;

            } else if ((*entry)->Key < Key) {

                //
                // We will go ahead and insert the key in here.
                //
                break;
            } else {
                entry = &((*entry)->Next);
            }
        }

        //
        // If we make it here then we will go ahead and do the insertion.
        //

        header->Next = *entry;
        *entry = header;

    } FINALLY {
        KeReleaseSpinLock(&(Dictionary->SpinLock), oldIrql);

        if(!NT_SUCCESS(status)) {
            ExFreePool(header);
        } else {
            *Entry = (PVOID) header->Data;
        }
    }
    return status;
}

Referenced by ClasspCreateClose().

BuildDeviceInputMdl()

PMDL NTAPI BuildDeviceInputMdl	(	PVOID	Buffer,
		ULONG	BufferLen
	)

Definition at line 480 of file utils.c.

{
    PMDL mdl;

    mdl = IoAllocateMdl(Buffer, BufferLen, FALSE, FALSE, NULL);
    if (mdl){
        _SEH2_TRY {
            /*
             *  We are reading from the device.
             *  Therefore, the device is WRITING to the locked memory.
             *  So we request IoWriteAccess.
             */
            MmProbeAndLockPages(mdl, KernelMode, IoWriteAccess);

        } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
            NTSTATUS status = _SEH2_GetExceptionCode();

            DBGWARN(("BuildReadMdl: MmProbeAndLockPages failed with %xh.", status));
            IoFreeMdl(mdl);
            mdl = NULL;
        } _SEH2_END;
    }
    else {
        DBGWARN(("BuildReadMdl: IoAllocateMdl failed"));
    }

    return mdl;
}

Referenced by ClassModeSense(), and ClassReadDriveCapacity().

ClassAddChild()

VOID NTAPI ClassAddChild	(	IN PFUNCTIONAL_DEVICE_EXTENSION	Parent,
		IN PPHYSICAL_DEVICE_EXTENSION	Child,
		IN BOOLEAN	AcquireLock
	)

Definition at line 8566 of file class.c.

{
    if(AcquireLock) {
        ClassAcquireChildLock(Parent);
    }

    #if DBG
        //
        // Make sure this child's not already in the list.
        //
        {
            PPHYSICAL_DEVICE_EXTENSION testChild;

            for (testChild = Parent->CommonExtension.ChildList;
                 testChild != NULL;
                 testChild = testChild->CommonExtension.ChildList) {

                ASSERT(testChild != Child);
            }
        }
    #endif

    Child->CommonExtension.ChildList = Parent->CommonExtension.ChildList;
    Parent->CommonExtension.ChildList = Child;

    if(AcquireLock) {
        ClassReleaseChildLock(Parent);
    }
    return;
} // end ClassAddChild()

Referenced by ClassCreateDeviceObject().

ClassFreeOrReuseSrb()

VOID NTAPI ClassFreeOrReuseSrb	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 824 of file obsolete.c.

{
    PCOMMON_DEVICE_EXTENSION commonExt = &FdoExtension->CommonExtension;
    //KIRQL oldIrql;
    //PIRP blockedIrp;

    // This function is obsolete, but still called by DISK.SYS .
    // DBGWARN(("ClassFreeOrReuseSrb is OBSOLETE !"));

    //
    // safety net.  this should never occur.  if it does, it's a potential
    // memory leak.
    //
    ASSERT(!TEST_FLAG(Srb->SrbFlags, SRB_FLAGS_FREE_SENSE_BUFFER));
   
    if (commonExt->IsSrbLookasideListInitialized){
        /*
         *  Put the SRB back in our lookaside list.
         *
         *  BUGBUG - Some class drivers use ClassIoComplete
         *            to complete SRBs that they themselves allocated.
         *            So we may be putting a "foreign" SRB
         *            (e.g. with a different pool tag) into our lookaside list.
         */
        ClasspFreeSrb(FdoExtension, Srb);
    }
    else {
        DBGERR(("ClassFreeOrReuseSrb: someone is trying to use an uninitialized SrbLookasideList !!!"));
        ExFreePool(Srb);
    }
}

Referenced by ClassIoComplete(), ClassIoCompleteAssociated(), ClasspEjectionControl(), and ClassSendSrbAsynchronous().

ClassGetPdoId()

NTSTATUS NTAPI ClassGetPdoId	(	IN PDEVICE_OBJECT	Pdo,
		IN BUS_QUERY_ID_TYPE	IdType,
		IN PUNICODE_STRING	IdString
	)

Definition at line 6824 of file class.c.

{
    PCLASS_DRIVER_EXTENSION
        driverExtension = IoGetDriverObjectExtension(Pdo->DriverObject,
                                                     CLASS_DRIVER_EXTENSION_KEY);

    ASSERT_PDO(Pdo);
    ASSERT(driverExtension->InitData.ClassQueryId);

    PAGED_CODE();

    return driverExtension->InitData.ClassQueryId( Pdo, IdType, IdString);
} // end ClassGetPdoId()

Referenced by ClassDispatchPnp().

ClassIoCompletion()

NTSTATUS NTAPI ClassIoCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PVOID	Context
	)

Definition at line 4730 of file class2.c.

{
    UNREFERENCED_PARAMETER(Context);
    UNREFERENCED_PARAMETER(DeviceObject);

    //
    // If pending is returned for this Irp then mark current stack
    // as pending
    //

    if (Irp->PendingReturned) {

        IoMarkIrpPending( Irp );
    }

    return Irp->IoStatus.Status;
}

Referenced by ScsiClassInternalIoControl().

ClassMinimalPowerHandler()

NTSTATUS NTAPI ClassMinimalPowerHandler	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 1302 of file power.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS status;

    ClassReleaseRemoveLock(DeviceObject, Irp);
    PoStartNextPowerIrp(Irp);

    if(commonExtension->IsFdo) {

        if (DeviceObject->Characteristics & FILE_REMOVABLE_MEDIA) {

            PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = 
                DeviceObject->DeviceExtension;

            //
            // Check if the system is going to hibernate or standby.
            //
            if (irpStack->MinorFunction == IRP_MN_SET_POWER){
                PVPB vpb;
                
                switch (irpStack->Parameters.Power.ShutdownType){
                    
                    case PowerActionSleep:
                    case PowerActionHibernate:
                        //
                        // If the volume is mounted, set the verify bit so that
                        // the filesystem will be forced re-read the media
                        // after coming out of hibernation or standby.
                        //
                        vpb = ClassGetVpb(fdoExtension->DeviceObject);
                        if (vpb && (vpb->Flags & VPB_MOUNTED)){
                            SET_FLAG(fdoExtension->DeviceObject->Flags, DO_VERIFY_VOLUME);  
                        } 
                        break;
                    default:
                        break;
                }
            } 
        }

        IoCopyCurrentIrpStackLocationToNext(Irp);
        return PoCallDriver(commonExtension->LowerDeviceObject, Irp);

    } else {

        if (irpStack->MinorFunction != IRP_MN_SET_POWER &&
            irpStack->MinorFunction != IRP_MN_QUERY_POWER) {
           
            NOTHING;

        } else {

            Irp->IoStatus.Status = STATUS_SUCCESS;
            Irp->IoStatus.Information = 0;

        }
        status = Irp->IoStatus.Status;

        ClassCompleteRequest(DeviceObject, Irp, IO_NO_INCREMENT);
        return status;
    }
} // end ClassMinimalPowerHandler()

Referenced by ClassInitialize().

ClasspAllocateReleaseQueueIrp()

NTSTATUS NTAPI ClasspAllocateReleaseQueueIrp

(

IN PFUNCTIONAL_DEVICE_EXTENSION

FdoExtension

)

ClasspAllocateReleaseRequest()

NTSTATUS NTAPI ClasspAllocateReleaseRequest

(

IN PDEVICE_OBJECT

Fdo

)

Definition at line 8062 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    //PIO_STACK_LOCATION irpStack;

    KeInitializeSpinLock(&(fdoExtension->ReleaseQueueSpinLock));

    fdoExtension->ReleaseQueueNeeded = FALSE;
    fdoExtension->ReleaseQueueInProgress = FALSE;
    fdoExtension->ReleaseQueueIrpFromPool = FALSE;

    //
    // The class driver is responsible for allocating a properly sized irp,
    // or ClassReleaseQueue will attempt to do it on the first error.
    //

    fdoExtension->ReleaseQueueIrp = NULL;

    //
    // Write length to SRB.
    //

    fdoExtension->ReleaseQueueSrb.Length = sizeof(SCSI_REQUEST_BLOCK);

    return STATUS_SUCCESS;
} // end ClasspAllocateReleaseRequest()

Referenced by ClassCreateDeviceObject().

ClasspBuildRequestEx()

VOID NTAPI ClasspBuildRequestEx	(	IN PFUNCTIONAL_DEVICE_EXTENSION	Fdo,
		IN PIRP	Irp,
		IN PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 503 of file obsolete.c.

{
    PIO_STACK_LOCATION  currentIrpStack = IoGetCurrentIrpStackLocation(Irp);
    PIO_STACK_LOCATION  nextIrpStack = IoGetNextIrpStackLocation(Irp);

    LARGE_INTEGER       startingOffset = currentIrpStack->Parameters.Read.ByteOffset;

    PCDB                cdb;
    ULONG               logicalBlockAddress;
    USHORT              transferBlocks;

    // This function is obsolete, but still called by CDROM.SYS .
    // DBGWARN(("ClasspBuildRequestEx is OBSOLETE !"));

    //
    // Prepare the SRB.
    //

    RtlZeroMemory(Srb, sizeof(SCSI_REQUEST_BLOCK));

    //
    // Calculate relative sector address.
    //

    logicalBlockAddress =
        (ULONG)(Int64ShrlMod32(startingOffset.QuadPart,
                               FdoExtension->SectorShift));

    //
    // Write length to SRB.
    //

    Srb->Length = sizeof(SCSI_REQUEST_BLOCK);

    //
    // Set up IRP Address.
    //

    Srb->OriginalRequest = Irp;

    //
    // Set up target ID and logical unit number.
    //

    Srb->Function = SRB_FUNCTION_EXECUTE_SCSI;
    Srb->DataBuffer = MmGetMdlVirtualAddress(Irp->MdlAddress);

    //
    // Save byte count of transfer in SRB Extension.
    //

    Srb->DataTransferLength = currentIrpStack->Parameters.Read.Length;

    //
    // Initialize the queue actions field.
    //

    Srb->QueueAction = SRB_SIMPLE_TAG_REQUEST;

    //
    // Queue sort key is Relative Block Address.
    //

    Srb->QueueSortKey = logicalBlockAddress;

    //
    // Indicate auto request sense by specifying buffer and size.
    //

    Srb->SenseInfoBuffer = FdoExtension->SenseData;
    Srb->SenseInfoBufferLength = SENSE_BUFFER_SIZE;

    //
    // Set timeout value of one unit per 64k bytes of data.
    //

    Srb->TimeOutValue = ((Srb->DataTransferLength + 0xFFFF) >> 16) *
                        FdoExtension->TimeOutValue;

    //
    // Zero statuses.
    //

    Srb->SrbStatus = Srb->ScsiStatus = 0;
    Srb->NextSrb = 0;

    //
    // Indicate that 10-byte CDB's will be used.
    //

    Srb->CdbLength = 10;

    //
    // Fill in CDB fields.
    //

    cdb = (PCDB)Srb->Cdb;

    transferBlocks = (USHORT)(currentIrpStack->Parameters.Read.Length >>
                              FdoExtension->SectorShift);

    //
    // Move little endian values into CDB in big endian format.
    //

    cdb->CDB10.LogicalBlockByte0 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte3;
    cdb->CDB10.LogicalBlockByte1 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte2;
    cdb->CDB10.LogicalBlockByte2 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte1;
    cdb->CDB10.LogicalBlockByte3 = ((PFOUR_BYTE)&logicalBlockAddress)->Byte0;

    cdb->CDB10.TransferBlocksMsb = ((PFOUR_BYTE)&transferBlocks)->Byte1;
    cdb->CDB10.TransferBlocksLsb = ((PFOUR_BYTE)&transferBlocks)->Byte0;

    //
    // Set transfer direction flag and Cdb command.
    //

    if (currentIrpStack->MajorFunction == IRP_MJ_READ) {

        DebugPrint((3, "ClassBuildRequest: Read Command\n"));

        SET_FLAG(Srb->SrbFlags, SRB_FLAGS_DATA_IN);
        cdb->CDB10.OperationCode = SCSIOP_READ;

    } else {

        DebugPrint((3, "ClassBuildRequest: Write Command\n"));

        SET_FLAG(Srb->SrbFlags, SRB_FLAGS_DATA_OUT);
        cdb->CDB10.OperationCode = SCSIOP_WRITE;
    }

    //
    // If this is not a write-through request, then allow caching.
    //

    if (!(currentIrpStack->Flags & SL_WRITE_THROUGH)) {

        SET_FLAG(Srb->SrbFlags, SRB_FLAGS_ADAPTER_CACHE_ENABLE);

    } else {

        //
        // If write caching is enable then force media access in the
        // cdb.
        //

        if (FdoExtension->DeviceFlags & DEV_WRITE_CACHE) {
            cdb->CDB10.ForceUnitAccess = TRUE;
        }
    }

    if(TEST_FLAG(Irp->Flags, (IRP_PAGING_IO | IRP_SYNCHRONOUS_PAGING_IO))) {
        SET_FLAG(Srb->SrbFlags, SRB_CLASS_FLAGS_PAGING);
    }

    //
    // OR in the default flags from the device object.
    //

    SET_FLAG(Srb->SrbFlags, FdoExtension->SrbFlags);

    //
    // Set up major SCSI function.
    //

    nextIrpStack->MajorFunction = IRP_MJ_SCSI;

    //
    // Save SRB address in next stack for port driver.
    //

    nextIrpStack->Parameters.Scsi.Srb = Srb;

    //
    // Save retry count in current IRP stack.
    //

    currentIrpStack->Parameters.Others.Argument4 = (PVOID)MAXIMUM_RETRIES;

    //
    // Set up IoCompletion routine address.
    //

    IoSetCompletionRoutine(Irp, ClassIoComplete, Srb, TRUE, TRUE, TRUE);

}

Referenced by ClassBuildRequest().

ClasspCleanupProtectedLocks()

VOID NTAPI ClasspCleanupProtectedLocks

(

IN PFILE_OBJECT_EXTENSION

FsContext

)

Definition at line 298 of file create.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension =
        FsContext->DeviceObject->DeviceExtension;

    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension =
        commonExtension->PartitionZeroExtension;

    ULONG newDeviceLockCount = 1;

    PAGED_CODE();

    DebugPrint((2,
                "ClasspCleanupProtectedLocks called for %p\n",
                FsContext->DeviceObject));
    DebugPrint((2,
                "ClasspCleanupProtectedLocks - FsContext %p is locked "
                "%d times\n", FsContext, FsContext->LockCount));

    ASSERT(BreakOnClose == FALSE);

    //
    // Synchronize with ejection and ejection control requests.
    //

    KeEnterCriticalRegion();
    KeWaitForSingleObject(&(fdoExtension->EjectSynchronizationEvent),
                          UserRequest,
                          UserMode,
                          FALSE,
                          NULL);

    //
    // For each secure lock on this handle decrement the secured lock count
    // for the FDO.  Keep track of the new value.
    //

    if(FsContext->LockCount != 0) {

        do {

            InterlockedDecrement((PLONG)&FsContext->LockCount);

            newDeviceLockCount =
                InterlockedDecrement(&fdoExtension->ProtectedLockCount);

        } while(FsContext->LockCount != 0);

        //
        // If the new lock count has been dropped to zero then issue a lock
        // command to the device.
        //

        DebugPrint((2,
                    "ClasspCleanupProtectedLocks: FDO secured lock count = %d "
                    "lock count = %d\n",
                    fdoExtension->ProtectedLockCount,
                    fdoExtension->LockCount));

        if((newDeviceLockCount == 0) && (fdoExtension->LockCount == 0)) {

            SCSI_REQUEST_BLOCK srb;
            PCDB cdb;
            NTSTATUS status;

            DebugPrint((2,
                        "ClasspCleanupProtectedLocks: FDO lock count dropped "
                        "to zero\n"));

            RtlZeroMemory(&srb, sizeof(SCSI_REQUEST_BLOCK));
            cdb = (PCDB) &(srb.Cdb);

            srb.CdbLength = 6;

            cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;

            //
            // TRUE - prevent media removal.
            // FALSE - allow media removal.
            //

            cdb->MEDIA_REMOVAL.Prevent = FALSE;

            //
            // Set timeout value.
            //

            srb.TimeOutValue = fdoExtension->TimeOutValue;
            status = ClassSendSrbSynchronous(fdoExtension->DeviceObject,
                                             &srb,
                                             NULL,
                                             0,
                                             FALSE);

            DebugPrint((2,
                        "ClasspCleanupProtectedLocks: unlock request to drive "
                        "returned status %lx\n", status));
        }
    }

    KeSetEvent(&fdoExtension->EjectSynchronizationEvent,
               IO_NO_INCREMENT,
               FALSE);
    KeLeaveCriticalRegion();
    return;
}

Referenced by ClasspCreateClose().

ClasspCreateClose()

NTSTATUS NTAPI ClasspCreateClose	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 125 of file create.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);

    PFILE_OBJECT fileObject = irpStack->FileObject;

    NTSTATUS status = STATUS_SUCCESS;

    PAGED_CODE();


    //
    // ISSUE-2000/3/28-henrygab - if lower stack fails create/close, we end up
    // in an inconsistent state.  re-write to verify all args and allocate all
    // required resources, then pass the irp down, then complete the
    // transaction.  this is because we also cannot forward the irp, then fail
    // it after it has succeeded a lower-level driver.
    //

    if(irpStack->MajorFunction == IRP_MJ_CREATE) {

        PIO_SECURITY_CONTEXT securityContext =
            irpStack->Parameters.Create.SecurityContext;
        DebugPrint((2,
                    "ClasspCREATEClose: create received for device %p\n",
                    DeviceObject));
        DebugPrint((2,
                    "ClasspCREATEClose: desired access %lx\n",
                    securityContext->DesiredAccess));
        DebugPrint((2,
                    "ClasspCREATEClose: file object %lx\n",
                    irpStack->FileObject));

        ASSERT(BreakOnClose == FALSE);

        if(irpStack->FileObject != NULL) {

            PFILE_OBJECT_EXTENSION fsContext;

            //
            // Allocate our own file object extension for this device object.
            //

            status = AllocateDictionaryEntry(
                        &commonExtension->FileObjectDictionary,
                        (ULONG_PTR)irpStack->FileObject,
                        sizeof(FILE_OBJECT_EXTENSION),
                        CLASS_TAG_FILE_OBJECT_EXTENSION,
                        (PVOID *)&fsContext);

            if(NT_SUCCESS(status)) {

                RtlZeroMemory(fsContext,
                              sizeof(FILE_OBJECT_EXTENSION));

                fsContext->FileObject = irpStack->FileObject;
                fsContext->DeviceObject = DeviceObject;
            } else if (status == STATUS_OBJECT_NAME_COLLISION) {
                status = STATUS_SUCCESS;
            }
        }

    } else {

        DebugPrint((2,
                    "ClasspCreateCLOSE: close received for device %p\n",
                    DeviceObject));
        DebugPrint((2,
                    "ClasspCreateCLOSE: file object %p\n",
                    fileObject));

        if(irpStack->FileObject != NULL) {

            PFILE_OBJECT_EXTENSION fsContext =
                ClasspGetFsContext(commonExtension, irpStack->FileObject);

            DebugPrint((2,
                        "ClasspCreateCLOSE: file extension %p\n",
                        fsContext));

            if(fsContext != NULL) {

                DebugPrint((2,
                            "ClasspCreateCLOSE: extension is ours - "
                            "freeing\n"));
                ASSERT(BreakOnClose == FALSE);

                ClasspCleanupProtectedLocks(fsContext);

                ClasspCleanupDisableMcn(fsContext);

                FreeDictionaryEntry(&(commonExtension->FileObjectDictionary),
                                    fsContext);
            }
        }
    }

    //
    // Notify the lower levels about the create or close operation - give them
    // a chance to cleanup too.
    //

    DebugPrint((2,
                "ClasspCreateClose: %s for devobj %p\n",
                (NT_SUCCESS(status) ? "Success" : "FAILED"),
                DeviceObject));


    if(NT_SUCCESS(status)) {

        KEVENT event;

        //
        // Set up the event to wait on
        //

        KeInitializeEvent(&event, SynchronizationEvent, FALSE);

        IoCopyCurrentIrpStackLocationToNext(Irp);
        IoSetCompletionRoutine( Irp, ClassSignalCompletion, &event,
                                TRUE, TRUE, TRUE);

        status = IoCallDriver(commonExtension->LowerDeviceObject, Irp);

        if(status == STATUS_PENDING) {
            KeWaitForSingleObject(&event,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
            status = Irp->IoStatus.Status;
        }

        if (!NT_SUCCESS(status)) {
            DebugPrint((ClassDebugError,
                        "ClasspCreateClose: Lower driver failed, but we "
                        "succeeded.  This is a problem, lock counts will be "
                        "out of sync between levels.\n"));
        }

    }


    return status;
}

Referenced by ClassCreateClose().

ClasspDisablePowerNotification()

VOID NTAPI ClasspDisablePowerNotification

(

PFUNCTIONAL_DEVICE_EXTENSION

FdoExtension

)

ClasspDisableTimer()

NTSTATUS NTAPI ClasspDisableTimer

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 3285 of file autorun.c.

{
    //PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    //PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    //PMEDIA_CHANGE_DETECTION_INFO mCDInfo = fdoExtension->MediaChangeDetectionInfo;
    //PFAILURE_PREDICTION_INFO fPInfo = fdoExtension->FailurePredictionInfo;
    //NTSTATUS status;

    PAGED_CODE();

    if (DeviceObject->Timer != NULL) {

        //
        // we are only going to stop the actual timer in remove device routine.
        // it is the responsibility of the code within the timer routine to
        // check if the device is removed and not processing io for the final
        // call.
        // this keeps the code clean and prevents lots of bugs.
        //


        IoStopTimer(DeviceObject);
        DebugPrint((3, "ClasspDisableTimer: Once a second timer disabled "
                    "for device %p\n", DeviceObject));

    } else {

        DebugPrint((1, "ClasspDisableTimer: Timer never enabled\n"));

    }

    return STATUS_SUCCESS;
} // end ClasspDisableTimer()

Referenced by ClassPnpStartDevice(), ClassRemoveDevice(), and ClassSetFailurePredictionPoll().

ClasspEjectionControl()

NTSTATUS NTAPI ClasspEjectionControl	(	IN PDEVICE_OBJECT	Fdo,
		IN PIRP	Irp,
		IN MEDIA_LOCK_TYPE	LockType,
		IN BOOLEAN	Lock
	)

Definition at line 449 of file create.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION FdoExtension = Fdo->DeviceExtension;
    PCOMMON_DEVICE_EXTENSION commonExtension =
        (PCOMMON_DEVICE_EXTENSION) FdoExtension;

    PFILE_OBJECT_EXTENSION fsContext = NULL;
    NTSTATUS status;
    volatile PSCSI_REQUEST_BLOCK srb = NULL;
    BOOLEAN countChanged = FALSE;

    PAGED_CODE();

    //
    // Interlock with ejection and secure lock cleanup code.  This is a
    // user request so we can allow the stack to get swapped out while we
    // wait for synchronization.
    //

    status = KeWaitForSingleObject(
                &(FdoExtension->EjectSynchronizationEvent),
                UserRequest,
                UserMode,
                FALSE,
                NULL);

    ASSERT(status == STATUS_SUCCESS);

    DebugPrint((2,
                "ClasspEjectionControl: "
                "Received request for %s lock type\n",
                LockTypeStrings[LockType]
                ));

    _SEH2_TRY {
        PCDB cdb;

        srb = ClasspAllocateSrb(FdoExtension);

        if(srb == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }

        RtlZeroMemory(srb, sizeof(SCSI_REQUEST_BLOCK));

        cdb = (PCDB) srb->Cdb;

        //
        // Determine if this is a "secured" request.
        //

        if(LockType == SecureMediaLock) {

            PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
            PFILE_OBJECT fileObject = irpStack->FileObject;

            //
            // Make sure that the file object we are supplied has a
            // proper FsContext before we try doing a secured lock.
            //

            if(fileObject != NULL) {
                fsContext = ClasspGetFsContext(commonExtension, fileObject);
            }

            if (fsContext == NULL) {

                //
                // This handle isn't setup correctly.  We can't let the
                // operation go.
                //

                status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
        }

        if(Lock) {

            //
            // This is a lock command.  Reissue the command in case bus or
            // device was reset and the lock was cleared.
            // note: may need to decrement count if actual lock operation
            //       failed....
            //

            switch(LockType) {

                case SimpleMediaLock: {
                    FdoExtension->LockCount++;
                    countChanged = TRUE;
                    break;
                }

                case SecureMediaLock: {
                    fsContext->LockCount++;
                    FdoExtension->ProtectedLockCount++;
                    countChanged = TRUE;
                    break;
                }

                case InternalMediaLock: {
                    FdoExtension->InternalLockCount++;
                    countChanged = TRUE;
                    break;
                }
            }

        } else {

            //
            // This is an unlock command.  If it's a secured one then make sure
            // the caller has a lock outstanding or return an error.
            // note: may need to re-increment the count if actual unlock
            //       operation fails....
            //

            switch(LockType) {

                case SimpleMediaLock: {
                    if(FdoExtension->LockCount != 0) {
                        FdoExtension->LockCount--;
                        countChanged = TRUE;
                    }
                    break;
                }

                case SecureMediaLock: {
                    if(fsContext->LockCount == 0) {
                        status = STATUS_INVALID_DEVICE_STATE;
                        _SEH2_LEAVE;
                    }
                    fsContext->LockCount--;
                    FdoExtension->ProtectedLockCount--;
                    countChanged = TRUE;
                    break;
                }

                case InternalMediaLock: {
                    ASSERT(FdoExtension->InternalLockCount != 0);
                    FdoExtension->InternalLockCount--;
                    countChanged = TRUE;
                    break;
                }
            }

            //
            // We only send an unlock command to the drive if both the
            // secured and unsecured lock counts have dropped to zero.
            //

            if((FdoExtension->ProtectedLockCount != 0) ||
               (FdoExtension->InternalLockCount != 0) ||
               (FdoExtension->LockCount != 0)) {

                status = STATUS_SUCCESS;
                _SEH2_LEAVE;
            }
        }

        status = STATUS_SUCCESS;
        if (TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)) {

            srb->CdbLength = 6;
            cdb->MEDIA_REMOVAL.OperationCode = SCSIOP_MEDIUM_REMOVAL;

            //
            // TRUE - prevent media removal.
            // FALSE - allow media removal.
            //

            cdb->MEDIA_REMOVAL.Prevent = Lock;

            //
            // Set timeout value.
            //

            srb->TimeOutValue = FdoExtension->TimeOutValue;

            //
            // The actual lock operation on the device isn't so important
            // as the internal lock counts.  Ignore failures.
            //

            status = ClassSendSrbSynchronous(FdoExtension->DeviceObject,
                                             srb,
                                             NULL,
                                             0,
                                             FALSE);
        }

    } _SEH2_FINALLY {

        if (!NT_SUCCESS(status)) {
            DebugPrint((2,
                        "ClasspEjectionControl: FAILED status %x -- "
                        "reverting lock counts\n", status));

            if (countChanged) {

                //
                // have to revert to previous counts if the
                // lock/unlock operation actually failed.
                //

                if(Lock) {

                    switch(LockType) {

                        case SimpleMediaLock: {
                            FdoExtension->LockCount--;
                            break;
                        }

                        case SecureMediaLock: {
                            fsContext->LockCount--;
                            FdoExtension->ProtectedLockCount--;
                            break;
                        }

                        case InternalMediaLock: {
                            FdoExtension->InternalLockCount--;
                            break;
                        }
                    }

                } else {

                    switch(LockType) {

                        case SimpleMediaLock: {
                            FdoExtension->LockCount++;
                            break;
                        }

                        case SecureMediaLock: {
                            fsContext->LockCount++;
                            FdoExtension->ProtectedLockCount++;
                            break;
                        }

                        case InternalMediaLock: {
                            FdoExtension->InternalLockCount++;
                            break;
                        }
                    }
                }

            }

        } else {

            DebugPrint((2,
                        "ClasspEjectionControl: Succeeded\n"));

        }

        DebugPrint((2,
                    "ClasspEjectionControl: "
                    "Current Counts: Internal: %x  Secure: %x  Simple: %x\n",
                    FdoExtension->InternalLockCount,
                    FdoExtension->ProtectedLockCount,
                    FdoExtension->LockCount
                    ));

        KeSetEvent(&(FdoExtension->EjectSynchronizationEvent),
                   IO_NO_INCREMENT,
                   FALSE);
        if (srb) {
            ClassFreeOrReuseSrb(FdoExtension, srb);
        }

    } _SEH2_END;
    return status;
}

Referenced by ClassDeviceControl(), and ClassDispatchPnp().

ClasspEnableTimer()

NTSTATUS NTAPI ClasspEnableTimer

(

PDEVICE_OBJECT

DeviceObject

)

Definition at line 3234 of file autorun.c.

{
    NTSTATUS status;

    PAGED_CODE();

    if (DeviceObject->Timer == NULL) {

        status = IoInitializeTimer(DeviceObject, ClasspTimerTick, NULL);

    } else {

        status = STATUS_SUCCESS;

    }

    if (NT_SUCCESS(status)) {

        IoStartTimer(DeviceObject);
        DebugPrint((1, "ClasspEnableTimer: Once a second timer enabled "
                    "for device %p\n", DeviceObject));

    }

    DebugPrint((1, "ClasspEnableTimer: Device %p, Status %lx "
                "initializing timer\n", DeviceObject, status));

    return status;

} // end ClasspEnableTimer()

Referenced by ClassPnpStartDevice(), and ClassSetFailurePredictionPoll().

ClasspFreeReleaseRequest()

VOID NTAPI ClasspFreeReleaseRequest

(

IN PDEVICE_OBJECT

Fdo

)

Definition at line 8098 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    //KIRQL oldIrql;

    ASSERT(fdoExtension->CommonExtension.IsRemoved != NO_REMOVE);

    //
    // free anything the driver allocated
    //

    if (fdoExtension->ReleaseQueueIrp) {
        if (fdoExtension->ReleaseQueueIrpFromPool) {
            ExFreePool(fdoExtension->ReleaseQueueIrp);
        } else {
            IoFreeIrp(fdoExtension->ReleaseQueueIrp);
        }
        fdoExtension->ReleaseQueueIrp = NULL;
    }

    //
    // free anything that we allocated
    //

    if ((fdoExtension->PrivateFdoData) &&
        (fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated)) {

        ExFreePool(fdoExtension->PrivateFdoData->ReleaseQueueIrp);
        fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated = FALSE;
        fdoExtension->PrivateFdoData->ReleaseQueueIrp = NULL;
    }

    return;
} // end ClasspFreeReleaseRequest()

Referenced by ClassRemoveDevice().

ClasspGetFsContext()

PFILE_OBJECT_EXTENSION NTAPI ClasspGetFsContext	(	IN PCOMMON_DEVICE_EXTENSION	CommonExtension,
		IN PFILE_OBJECT	FileObject
	)

Definition at line 969 of file create.c.

{
    PAGED_CODE();
    return GetDictionaryEntry(&(CommonExtension->FileObjectDictionary),
                              (ULONG_PTR)FileObject);
}

Referenced by ClasspCreateClose(), ClasspEjectionControl(), and ClasspMcnControl().

ClasspInitializeGesn()

NTSTATUS NTAPI ClasspInitializeGesn	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN PMEDIA_CHANGE_DETECTION_INFO	Info
	)

Definition at line 1668 of file autorun.c.

{    
    PNOTIFICATION_EVENT_STATUS_HEADER header;
    CLASS_DETECTION_STATE detectionState = ClassDetectionUnknown;
    PSTORAGE_ADAPTER_DESCRIPTOR adapterDescriptor;
    NTSTATUS status = STATUS_NOT_SUPPORTED;
    PIRP irp;
    KEVENT event;
    BOOLEAN retryImmediately;
    ULONG i;
    ULONG atapiResets;

    
    PAGED_CODE();
    ASSERT(Info == FdoExtension->MediaChangeDetectionInfo);

    //
    // read if we already know the abilities of the device
    //

    ClassGetDeviceParameter(FdoExtension,
                            CLASSP_REG_SUBKEY_NAME,
                            CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                            (PULONG)&detectionState);
    
    if (detectionState == ClassDetectionUnsupported) {
        goto ExitWithError;
    }

    //
    // check if the device has a hack flag saying never to try this.
    //

    if (TEST_FLAG(FdoExtension->PrivateFdoData->HackFlags,
                  FDO_HACK_GESN_IS_BAD)) {
        
        detectionState = ClassDetectionUnsupported;
        ClassSetDeviceParameter(FdoExtension,
                                CLASSP_REG_SUBKEY_NAME,
                                CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                                ClassDetectionSupported);
        goto ExitWithError;

    }


    //
    // else go through the process since we allocate buffers and 
    // get all sorts of device settings.
    //

    if (Info->Gesn.Buffer == NULL) {
        Info->Gesn.Buffer = ExAllocatePoolWithTag(NonPagedPoolCacheAligned,
                                                  GESN_BUFFER_SIZE,
                                                  '??cS');
    }
    if (Info->Gesn.Buffer == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto ExitWithError;
    }
    if (Info->Gesn.Mdl != NULL) {
        IoFreeMdl(Info->Gesn.Mdl);
    }
    Info->Gesn.Mdl = IoAllocateMdl(Info->Gesn.Buffer,
                                   GESN_BUFFER_SIZE,
                                   FALSE, FALSE, NULL);
    if (Info->Gesn.Mdl == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto ExitWithError;
    }

    MmBuildMdlForNonPagedPool(Info->Gesn.Mdl);
    Info->Gesn.BufferSize = GESN_BUFFER_SIZE;
    Info->Gesn.EventMask = 0;

    //
    // all items are prepared to use GESN (except the event mask, so don't
    // optimize this part out!).
    //
    // now see if it really works. we have to loop through this because
    // many SAMSUNG (and one COMPAQ) drives timeout when requesting
    // NOT_READY events, even when the IMMEDIATE bit is set. :(
    //
    // using a drive list is cumbersome, so this might fix the problem.
    //

    adapterDescriptor = FdoExtension->AdapterDescriptor;
    atapiResets = 0;
    retryImmediately = TRUE;
    for (i = 0; (i < 16) && (retryImmediately != FALSE); i++) {
    
        irp = ClasspPrepareMcnIrp(FdoExtension, Info, TRUE);
        if (irp == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto ExitWithError;
        }

        ASSERT(TEST_FLAG(Info->MediaChangeSrb.SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE));
    
        //
        // replace the completion routine with a different one this time...
        //
    
        IoSetCompletionRoutine(irp,
                               ClassSignalCompletion,
                               &event,
                               TRUE, TRUE, TRUE);
        KeInitializeEvent(&event, SynchronizationEvent, FALSE);
    
        status = IoCallDriver(FdoExtension->CommonExtension.LowerDeviceObject, irp);
    
        if (status == STATUS_PENDING) {
            status = KeWaitForSingleObject(&event,
                                           Executive,
                                           KernelMode,
                                           FALSE,
                                           NULL);
            ASSERT(NT_SUCCESS(status));
        }
        ClassReleaseRemoveLock(FdoExtension->DeviceObject, irp);
    
        if (SRB_STATUS(Info->MediaChangeSrb.SrbStatus) != SRB_STATUS_SUCCESS) {
            ClassInterpretSenseInfo(FdoExtension->DeviceObject,
                                    &(Info->MediaChangeSrb),
                                    IRP_MJ_SCSI,
                                    0,
                                    0,
                                    &status,
                                    NULL);
        }

        if ((adapterDescriptor->BusType == BusTypeAtapi) &&
            (Info->MediaChangeSrb.SrbStatus == SRB_STATUS_BUS_RESET)
            ) {

            //
            // ATAPI unfortunately returns SRB_STATUS_BUS_RESET instead
            // of SRB_STATUS_TIMEOUT, so we cannot differentiate between
            // the two.  if we get this status four time consecutively,
            // stop trying this command.  it is too late to change ATAPI
            // at this point, so special-case this here. (07/10/2001)
            // NOTE: any value more than 4 may cause the device to be
            //       marked missing.
            //

            atapiResets++;
            if (atapiResets >= 4) {
                status = STATUS_IO_DEVICE_ERROR;
                goto ExitWithError;
            }
        }

        if (status == STATUS_DATA_OVERRUN) {
            status = STATUS_SUCCESS;
        }
    
        if ((status == STATUS_INVALID_DEVICE_REQUEST) ||
            (status == STATUS_TIMEOUT) ||
            (status == STATUS_IO_DEVICE_ERROR) ||
            (status == STATUS_IO_TIMEOUT)
            ) {
    
            //
            // with these error codes, we don't ever want to try this command
            // again on this device, since it reacts poorly.
            //
    
            ClassSetDeviceParameter(FdoExtension,
                                    CLASSP_REG_SUBKEY_NAME,
                                    CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                                    ClassDetectionUnsupported);
            KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugWarning,
                       "Classpnp => GESN test failed %x for fdo %p\n",
                       status, FdoExtension->DeviceObject));
            goto ExitWithError;

    
        }
    
        if (!NT_SUCCESS(status)) {

            //
            // this may be other errors that should not disable GESN
            // for all future start_device calls.
            //

            KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugWarning,
                       "Classpnp => GESN test failed %x for fdo %p\n",
                       status, FdoExtension->DeviceObject));
            goto ExitWithError;
        }
    
        if (i == 0) {

            //
            // the first time, the request was just retrieving a mask of
            // available bits.  use this to mask future requests.
            //
        
            header = (PNOTIFICATION_EVENT_STATUS_HEADER)(Info->Gesn.Buffer);
            
            KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugMCN,
                       "Classpnp => Fdo %p supports event mask %x\n",
                       FdoExtension->DeviceObject, header->SupportedEventClasses));
            
        
            if (TEST_FLAG(header->SupportedEventClasses,
                          NOTIFICATION_MEDIA_STATUS_CLASS_MASK)) {
                KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugMCN,
                           "Classpnp => GESN supports MCN\n"));
            }
            if (TEST_FLAG(header->SupportedEventClasses,
                          NOTIFICATION_DEVICE_BUSY_CLASS_MASK)) {
                KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugMCN,
                           "Classpnp => GESN supports DeviceBusy\n"));
            }
            Info->Gesn.EventMask = header->SupportedEventClasses;

            //
            // realistically, we are only considering the following events:
            //    EXTERNAL REQUEST - this is being tested for play/stop/etc.
            //    MEDIA STATUS - autorun and ejection requests.
            //    DEVICE BUSY - to allow us to predict when media will be ready.
            // therefore, we should not bother querying for the other,
            // unknown events. clear all but the above flags.
            //
        
            Info->Gesn.EventMask &=
                NOTIFICATION_EXTERNAL_REQUEST_CLASS_MASK |
                NOTIFICATION_MEDIA_STATUS_CLASS_MASK     |
                NOTIFICATION_DEVICE_BUSY_CLASS_MASK      ;
        
        
            //
            // HACKHACK - REF #0001
            // Some devices will *never* report an event if we've also requested
            // that it report lower-priority events.  this is due to a
            // misunderstanding in the specification wherein a "No Change" is
            // interpreted to be a real event.  what should occur is that the
            // device should ignore "No Change" events when multiple event types
            // are requested unless there are no other events waiting.  this
            // greatly reduces the number of requests that the host must send
            // to determine if an event has occurred. Since we must work on all
            // drives, default to enabling the hack until we find evidence of
            // proper firmware.
            //
        
            if (CountOfSetBitsUChar(Info->Gesn.EventMask) == 1) {
                KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugMCN,
                           "Classpnp => GESN hack %s for FDO %p\n",
                           "not required", FdoExtension->DeviceObject));
            } else {
                KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugMCN,
                           "Classpnp => GESN hack %s for FDO %p\n",
                           "enabled", FdoExtension->DeviceObject));
                Info->Gesn.HackEventMask = 1;
            }

        } else {
            
            //
            // not the first time looping through, so interpret the results.
            //

            ClasspInterpretGesnData(FdoExtension,
                                    (PVOID)Info->Gesn.Buffer,
                                    &retryImmediately);

        }

    } // end loop of GESN requests....

    //
    // we can only use this if it can be relied upon for media changes,
    // since we are (by definition) no longer going to be polling via
    // a TEST_UNIT_READY irp, and drives will not report UNIT ATTENTION
    // for this command (although a filter driver, such as one for burning
    // cd's, might still fake those errors).
    //
    // since we also rely upon NOT_READY events to change the cursor
    // into a "wait" cursor, we can't use GESN without NOT_READY support.
    //
    
    if (TEST_FLAG(Info->Gesn.EventMask,
                  NOTIFICATION_MEDIA_STATUS_CLASS_MASK) &&
        TEST_FLAG(Info->Gesn.EventMask,
                  NOTIFICATION_DEVICE_BUSY_CLASS_MASK)
        ) {
        
        KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugMCN,
                   "Classpnp => Enabling GESN support for fdo %p\n",
                   FdoExtension->DeviceObject));
        Info->Gesn.Supported = TRUE;

        ClassSetDeviceParameter(FdoExtension,
                                CLASSP_REG_SUBKEY_NAME,
                                CLASSP_REG_MMC_DETECTION_VALUE_NAME,
                                ClassDetectionSupported);

        return STATUS_SUCCESS;

    }
    
    KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugMCN,
               "Classpnp => GESN available but not enabled for fdo %p\n",
               FdoExtension->DeviceObject));
    goto ExitWithError;

    // fall through...

ExitWithError:
    if (Info->Gesn.Mdl) {
        IoFreeMdl(Info->Gesn.Mdl);
        Info->Gesn.Mdl = NULL;
    }
    if (Info->Gesn.Buffer) {
        ExFreePool(Info->Gesn.Buffer);
        Info->Gesn.Buffer = NULL;
    }
    Info->Gesn.Supported  = 0;
    Info->Gesn.EventMask  = 0;
    Info->Gesn.BufferSize = 0;
    return STATUS_NOT_SUPPORTED;

}

Referenced by ClasspInitializePolling().

ClasspInitializeHotplugInfo()

NTSTATUS NTAPI ClasspInitializeHotplugInfo

(

IN PFUNCTIONAL_DEVICE_EXTENSION

FdoExtension

)

Definition at line 8964 of file class.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = FdoExtension->PrivateFdoData;
    DEVICE_REMOVAL_POLICY deviceRemovalPolicy;
    NTSTATUS status;
    ULONG resultLength = 0;
    ULONG writeCacheOverride;

    PAGED_CODE();

    //
    // start with some default settings
    //
    RtlZeroMemory(&(fdoData->HotplugInfo), sizeof(STORAGE_HOTPLUG_INFO));

    //
    // set the size (aka version)
    //

    fdoData->HotplugInfo.Size = sizeof(STORAGE_HOTPLUG_INFO);

    //
    // set if the device has removable media
    //

    if (FdoExtension->DeviceDescriptor->RemovableMedia) {
        fdoData->HotplugInfo.MediaRemovable = TRUE;
    } else {
        fdoData->HotplugInfo.MediaRemovable = FALSE;
    }

    //
    // this refers to devices which, for reasons not yet understood,
    // do not fail PREVENT_MEDIA_REMOVAL requests even though they
    // have no way to lock the media into the drive.  this allows
    // the filesystems to turn off delayed-write caching for these
    // devices as well.
    //

    if (TEST_FLAG(FdoExtension->PrivateFdoData->HackFlags,
                  FDO_HACK_CANNOT_LOCK_MEDIA)) {
        fdoData->HotplugInfo.MediaHotplug = TRUE;
    } else {
        fdoData->HotplugInfo.MediaHotplug = FALSE;
    }


    //
    // Look into the registry to  see if the user has  chosen
    // to override the default setting for the removal policy
    //

    RtlZeroMemory(&deviceRemovalPolicy, sizeof(DEVICE_REMOVAL_POLICY));

    ClassGetDeviceParameter(FdoExtension,
                            CLASSP_REG_SUBKEY_NAME,
                            CLASSP_REG_REMOVAL_POLICY_VALUE_NAME,
                            (PULONG)&deviceRemovalPolicy);

    if (deviceRemovalPolicy == 0)
    {
        //
        // Query the default removal policy from the kernel
        //

        status = IoGetDeviceProperty(FdoExtension->LowerPdo,
                                     DevicePropertyRemovalPolicy,
                                     sizeof(DEVICE_REMOVAL_POLICY),
                                     (PVOID)&deviceRemovalPolicy,
                                     &resultLength);
        if (!NT_SUCCESS(status))
        {
            return status;
        }

        if (resultLength != sizeof(DEVICE_REMOVAL_POLICY))
        {
            return STATUS_UNSUCCESSFUL;
        }
    }

    //
    // use this info to set the DeviceHotplug setting
    // don't rely on DeviceCapabilities, since it can't properly
    // determine device relations, etc.  let the kernel figure this
    // stuff out instead.
    //

    if (deviceRemovalPolicy == RemovalPolicyExpectSurpriseRemoval) {
        fdoData->HotplugInfo.DeviceHotplug = TRUE;
    } else {
        fdoData->HotplugInfo.DeviceHotplug = FALSE;
    }

    //
    // this refers to the *filesystem* caching, but has to be included
    // here since it's a per-device setting.  this may change to be
    // stored by the system in the future.
    //

    writeCacheOverride = FALSE;
    ClassGetDeviceParameter(FdoExtension,
                            CLASSP_REG_SUBKEY_NAME,
                            CLASSP_REG_WRITE_CACHE_VALUE_NAME,
                            &writeCacheOverride);

    if (writeCacheOverride) {
        fdoData->HotplugInfo.WriteCacheEnableOverride = TRUE;
    } else {
        fdoData->HotplugInfo.WriteCacheEnableOverride = FALSE;
    }

    return STATUS_SUCCESS;
}

Referenced by ClassPnpStartDevice().

ClasspMcnControl()

NTSTATUS NTAPI ClasspMcnControl	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN PIRP	Irp,
		IN PSCSI_REQUEST_BLOCK	Srb
	)

Definition at line 2890 of file autorun.c.

{
    PCOMMON_DEVICE_EXTENSION commonExtension =
        (PCOMMON_DEVICE_EXTENSION) FdoExtension;

    PIO_STACK_LOCATION irpStack = IoGetCurrentIrpStackLocation(Irp);
    PPREVENT_MEDIA_REMOVAL request = Irp->AssociatedIrp.SystemBuffer;

    PFILE_OBJECT fileObject = irpStack->FileObject;
    PFILE_OBJECT_EXTENSION fsContext = NULL;

    NTSTATUS status = STATUS_SUCCESS;

    PAGED_CODE();

    //
    // Check to make sure we have a file object extension to keep track of this
    // request.  If not we'll fail it before synchronizing.
    //

    TRY {

        if(fileObject != NULL) {
            fsContext = ClasspGetFsContext(commonExtension, fileObject);
        }else if(Irp->RequestorMode == KernelMode) { // && fileObject == NULL
            fsContext = &FdoExtension->KernelModeMcnContext;
        }

        if (fsContext == NULL) {

            //
            // This handle isn't setup correctly.  We can't let the
            // operation go.
            //

            status = STATUS_INVALID_PARAMETER;
            LEAVE;
        }

        if(request->PreventMediaRemoval) {

            //
            // This is a lock command.  Reissue the command in case bus or
            // device was reset and the lock was cleared.
            //

            ClassDisableMediaChangeDetection(FdoExtension);
            InterlockedIncrement((PLONG)&fsContext->McnDisableCount);

        } else {

            if(fsContext->McnDisableCount == 0) {
                status = STATUS_INVALID_DEVICE_STATE;
                LEAVE;
            }

            InterlockedDecrement((PLONG)&fsContext->McnDisableCount);
            ClassEnableMediaChangeDetection(FdoExtension);
        }

    } FINALLY {

        Irp->IoStatus.Status = status;

        if(Srb) {
            ExFreePool(Srb);
        }

        ClassReleaseRemoveLock(FdoExtension->DeviceObject, Irp);
        ClassCompleteRequest(FdoExtension->DeviceObject,
                             Irp,
                             IO_NO_INCREMENT);
    }
    return status;
} // end ClasspMcnControl(

Referenced by ClassDeviceControl().

ClasspMediaChangeCompletion()

NTSTATUS NTAPI ClasspMediaChangeCompletion	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp,
		PVOID	Context
	)

ClassPnpQueryFdoRelations()

NTSTATUS NTAPI ClassPnpQueryFdoRelations	(	IN PDEVICE_OBJECT	Fdo,
		IN PIRP	Irp
	)

Definition at line 6551 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PCLASS_DRIVER_EXTENSION
        driverExtension = IoGetDriverObjectExtension(Fdo->DriverObject,
                                                     CLASS_DRIVER_EXTENSION_KEY);

    PAGED_CODE();

    //
    // If there's already an enumeration in progress then don't start another
    // one.
    //

    if(InterlockedIncrement((PLONG)&fdoExtension->EnumerationInterlock) == 1) {
        driverExtension->InitData.ClassEnumerateDevice(Fdo);
    }

    Irp->IoStatus.Information = (ULONG_PTR) NULL;

    Irp->IoStatus.Status = ClassRetrieveDeviceRelations(
                                Fdo,
                                BusRelations,
                                (PDEVICE_RELATIONS*)&Irp->IoStatus.Information);
    InterlockedDecrement((PLONG)&fdoExtension->EnumerationInterlock);

    return Irp->IoStatus.Status;
} // end ClassPnpQueryFdoRelations()

Referenced by ClassDispatchPnp().

ClassPnpStartDevice()

NTSTATUS NTAPI ClassPnpStartDevice

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 1265 of file class.c.

{
    PCLASS_DRIVER_EXTENSION driverExtension;
    PCLASS_INIT_DATA initData;

    PCLASS_DEV_INFO devInfo;

    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = DeviceObject->DeviceExtension;
    BOOLEAN isFdo = commonExtension->IsFdo;

    BOOLEAN isMountedDevice = TRUE;
    //UNICODE_STRING  interfaceName;

    BOOLEAN timerStarted;

    NTSTATUS status = STATUS_SUCCESS;

    PAGED_CODE();

    driverExtension = IoGetDriverObjectExtension(DeviceObject->DriverObject,
                                                 CLASS_DRIVER_EXTENSION_KEY);

    initData = &(driverExtension->InitData);
    if(isFdo) {
        devInfo = &(initData->FdoData);
    } else {
        devInfo = &(initData->PdoData);
    }

    ASSERT(devInfo->ClassInitDevice != NULL);
    ASSERT(devInfo->ClassStartDevice != NULL);

    if (!commonExtension->IsInitialized){

        //
        // perform FDO/PDO specific initialization
        //

        if (isFdo){
            STORAGE_PROPERTY_ID propertyId;

            //
            // allocate a private extension for class data
            //

            if (fdoExtension->PrivateFdoData == NULL) {
                fdoExtension->PrivateFdoData =
                    ExAllocatePoolWithTag(NonPagedPool,
                                          sizeof(CLASS_PRIVATE_FDO_DATA),
                                          CLASS_TAG_PRIVATE_DATA
                                          );
            }

            if (fdoExtension->PrivateFdoData == NULL) {
                DebugPrint((0, "ClassPnpStartDevice: Cannot allocate for "
                            "private fdo data\n"));
                return STATUS_INSUFFICIENT_RESOURCES;
            }

            //
            // initialize the struct's various fields.
            //

            RtlZeroMemory(fdoExtension->PrivateFdoData,
                          sizeof(CLASS_PRIVATE_FDO_DATA)
                          );
            KeInitializeTimer(&fdoExtension->PrivateFdoData->Retry.Timer);
            KeInitializeDpc(&fdoExtension->PrivateFdoData->Retry.Dpc,
                            ClasspRetryRequestDpc,
                            DeviceObject);
            KeInitializeSpinLock(&fdoExtension->PrivateFdoData->Retry.Lock);
            fdoExtension->PrivateFdoData->Retry.Granularity =
                KeQueryTimeIncrement();
            commonExtension->Reserved4 = (ULONG_PTR)(' GPH'); // debug aid

            //
            // NOTE: the old interface allowed the class driver to allocate
            // this.  this was unsafe for low-memory conditions. allocate one
            // unconditionally now, and modify our internal functions to use
            // our own exclusively as it is the only safe way to do this.
            //

            status = ClasspAllocateReleaseQueueIrp(fdoExtension);
            if (!NT_SUCCESS(status)) {
                DebugPrint((0, "ClassPnpStartDevice: Cannot allocate the "
                            "private release queue irp\n"));
                return status;
            }

            //
            // Call port driver to get adapter capabilities.
            //

            propertyId = StorageAdapterProperty;

            status = ClassGetDescriptor(
                        commonExtension->LowerDeviceObject,
                        &propertyId,
                        (PSTORAGE_DESCRIPTOR_HEADER *)&fdoExtension->AdapterDescriptor);

            if(!NT_SUCCESS(status)) {

                //
                // This DebugPrint is to help third-party driver writers
                //

                DebugPrint((0, "ClassPnpStartDevice: ClassGetDescriptor "
                               "[ADAPTER] failed %lx\n", status));
                return status;
            }

            //
            // Call port driver to get device descriptor.
            //

            propertyId = StorageDeviceProperty;

            status = ClassGetDescriptor(
                        commonExtension->LowerDeviceObject,
                        &propertyId,
                        (PSTORAGE_DESCRIPTOR_HEADER *)&fdoExtension->DeviceDescriptor);

            if(!NT_SUCCESS(status)) {

                //
                // This DebugPrint is to help third-party driver writers
                //

                DebugPrint((0, "ClassPnpStartDevice: ClassGetDescriptor "
                               "[DEVICE] failed %lx\n", status));
                return status;
            }

            ClasspScanForSpecialInRegistry(fdoExtension);
            ClassScanForSpecial(fdoExtension,
                                ClassBadItems,
                                ClasspScanForClassHacks);

            //
            // allow perf to be re-enabled after a given number of failed IOs
            // require this number to be at least CLASS_PERF_RESTORE_MINIMUM
            //

            {
                ULONG t = 0;
                ClassGetDeviceParameter(fdoExtension,
                                        CLASSP_REG_SUBKEY_NAME,
                                        CLASSP_REG_PERF_RESTORE_VALUE_NAME,
                                        &t);
                if (t >= CLASS_PERF_RESTORE_MINIMUM) {
                    fdoExtension->PrivateFdoData->Perf.ReEnableThreshold = t;
                }
            }


            //
            // compatibility comes first.  writable cd media will not
            // get a SYNCH_CACHE on power down.
            //

            if (fdoExtension->DeviceObject->DeviceType != FILE_DEVICE_DISK) {
                SET_FLAG(fdoExtension->PrivateFdoData->HackFlags,
                         FDO_HACK_NO_SYNC_CACHE);
            }

            //
            // initialize the hotplug information only after the ScanForSpecial
            // routines, as it relies upon the hack flags.
            //

            status = ClasspInitializeHotplugInfo(fdoExtension);

            if (!NT_SUCCESS(status)) {
                DebugPrint((1, "ClassPnpStartDevice: Could not initialize "
                            "hotplug information %lx\n", status));
                return status;
            }

            /*
             *  Allocate/initialize TRANSFER_PACKETs and related resources.
             */
            status = InitializeTransferPackets(DeviceObject);
        }

        //
        // ISSUE - drivers need to disable write caching on the media
        //         if hotplug and !useroverride.  perhaps we should
        //         allow registration of a callback to enable/disable
        //         write cache instead.
        //

        if (NT_SUCCESS(status)){
            status = devInfo->ClassInitDevice(DeviceObject);
        }

    }

    if (!NT_SUCCESS(status)){

        //
        // Just bail out - the remove that comes down will clean up the
        // initialized scraps.
        //

        return status;
    } else {
        commonExtension->IsInitialized = TRUE;

        if (commonExtension->IsFdo) {
            fdoExtension->PrivateFdoData->Perf.OriginalSrbFlags = fdoExtension->SrbFlags;
        }

    }

    //
    // If device requests autorun functionality or a once a second callback
    // then enable the once per second timer.
    //
    // NOTE: This assumes that ClassInitializeMediaChangeDetection is always
    //       called in the context of the ClassInitDevice callback. If called
    //       after then this check will have already been made and the
    //       once a second timer will not have been enabled.
    //
    if ((isFdo) &&
        ((initData->ClassTick != NULL) ||
         (fdoExtension->MediaChangeDetectionInfo != NULL) ||
         ((fdoExtension->FailurePredictionInfo != NULL) &&
          (fdoExtension->FailurePredictionInfo->Method != FailurePredictionNone))))
    {
        ClasspEnableTimer(DeviceObject);
        timerStarted = TRUE;
    } else {
        timerStarted = FALSE;
    }

    //
    // NOTE: the timer looks at commonExtension->CurrentState now
    //       to prevent Media Change Notification code from running
    //       until the device is started, but allows the device
    //       specific tick handler to run.  therefore it is imperative
    //       that commonExtension->CurrentState not be updated until
    //       the device specific startdevice handler has finished.
    //

    status = devInfo->ClassStartDevice(DeviceObject);

    if(NT_SUCCESS(status)) {
        commonExtension->CurrentState = IRP_MN_START_DEVICE;

        if((isFdo) && (initData->ClassEnumerateDevice != NULL)) {
            isMountedDevice = FALSE;
        }

        if((DeviceObject->DeviceType != FILE_DEVICE_DISK) &&
           (DeviceObject->DeviceType != FILE_DEVICE_CD_ROM)) {

            isMountedDevice = FALSE;
        }


        if(isMountedDevice) {
            ClasspRegisterMountedDeviceInterface(DeviceObject);
        }

        if((commonExtension->IsFdo) &&
           (devInfo->ClassWmiInfo.GuidRegInfo != NULL)) {

            IoWMIRegistrationControl(DeviceObject, WMIREG_ACTION_REGISTER);
        }
    } else {

        if (timerStarted) {
            ClasspDisableTimer(DeviceObject);
        }
    }

    return status;
}

Referenced by ClassDispatchPnp().

ClasspPagingNotificationCompletion()

NTSTATUS NTAPI ClasspPagingNotificationCompletion	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PDEVICE_OBJECT	RealDeviceObject
	)

ClasspPerfIncrementErrorCount()

VOID NTAPI ClasspPerfIncrementErrorCount

(

IN PFUNCTIONAL_DEVICE_EXTENSION

FdoExtension

)

Definition at line 333 of file utils.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = FdoExtension->PrivateFdoData;
    KIRQL oldIrql;
    ULONG errors;

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

    fdoData->Perf.SuccessfulIO = 0; // implicit interlock
    errors = InterlockedIncrement((PLONG)&FdoExtension->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 synchronous data transfers.
        //
        // Clearing the no queue freeze flag prevents the port driver
        // from sending multiple requests per logical unit.
        //

        CLEAR_FLAG(FdoExtension->SrbFlags, SRB_FLAGS_NO_QUEUE_FREEZE);
        CLEAR_FLAG(FdoExtension->SrbFlags, SRB_FLAGS_QUEUE_ACTION_ENABLE);

        SET_FLAG(FdoExtension->SrbFlags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);

        DebugPrint((ClassDebugError, "ClasspPerfIncrementErrorCount: "
                    "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(FdoExtension->SrbFlags, SRB_FLAGS_DISABLE_DISCONNECT);
        DebugPrint((ClassDebugError, "ClasspPerfIncrementErrorCount: "
                    "Too many errors; disabling disconnects.\n"));
    }

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

Referenced by ClassInterpretSenseInfo().

ClasspPerfIncrementSuccessfulIo()

VOID NTAPI ClasspPerfIncrementSuccessfulIo

(

IN PFUNCTIONAL_DEVICE_EXTENSION

FdoExtension

)

Definition at line 385 of file utils.c.

{
    PCLASS_PRIVATE_FDO_DATA fdoData = FdoExtension->PrivateFdoData;
    KIRQL oldIrql;
    ULONG errors;
    ULONG succeeded = 0;

    //
    // don't take a hit from the interlocked op unless we're in
    // a degraded state and we've got a threshold to hit.
    //

    if (FdoExtension->ErrorCount == 0) {
        return;
    }

    if (fdoData->Perf.ReEnableThreshold == 0) {
        return;
    }

    succeeded = InterlockedIncrement((PLONG)&fdoData->Perf.SuccessfulIO);
    if (succeeded < fdoData->Perf.ReEnableThreshold) {
        return;
    }

    //
    // if we hit the threshold, grab the spinlock and verify we've
    // actually done so.  this allows us to ignore the spinlock 99%
    // of the time.
    //

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

    //
    // re-read the value, so we don't run this multiple times
    // for a single threshold being hit.  this keeps errorcount
    // somewhat useful.
    //

    succeeded = fdoData->Perf.SuccessfulIO;

    if ((FdoExtension->ErrorCount != 0) &&
        (fdoData->Perf.ReEnableThreshold <= succeeded)
        ) {

        fdoData->Perf.SuccessfulIO = 0; // implicit interlock

        ASSERT(FdoExtension->ErrorCount > 0);
        errors = InterlockedDecrement((PLONG)&FdoExtension->ErrorCount);

        //
        // note: do in reverse order of the sets "just in case"
        //

        if (errors < CLASS_ERROR_LEVEL_2) {
            if (errors == CLASS_ERROR_LEVEL_2 - 1) {
                DebugPrint((ClassDebugError, "ClasspPerfIncrementSuccessfulIo: "
                            "Error level 2 no longer required.\n"));
            }
            if (!TEST_FLAG(fdoData->Perf.OriginalSrbFlags,
                           SRB_FLAGS_DISABLE_DISCONNECT)) {
                CLEAR_FLAG(FdoExtension->SrbFlags,
                           SRB_FLAGS_DISABLE_DISCONNECT);
            }
        }

        if (errors < CLASS_ERROR_LEVEL_1) {
            if (errors == CLASS_ERROR_LEVEL_1 - 1) {
                DebugPrint((ClassDebugError, "ClasspPerfIncrementSuccessfulIo: "
                            "Error level 1 no longer required.\n"));
            }
            if (!TEST_FLAG(fdoData->Perf.OriginalSrbFlags,
                           SRB_FLAGS_DISABLE_SYNCH_TRANSFER)) {
                CLEAR_FLAG(FdoExtension->SrbFlags,
                           SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
            }
            if (TEST_FLAG(fdoData->Perf.OriginalSrbFlags,
                          SRB_FLAGS_QUEUE_ACTION_ENABLE)) {
                SET_FLAG(FdoExtension->SrbFlags,
                         SRB_FLAGS_QUEUE_ACTION_ENABLE);
            }
            if (TEST_FLAG(fdoData->Perf.OriginalSrbFlags,
                          SRB_FLAGS_NO_QUEUE_FREEZE)) {
                SET_FLAG(FdoExtension->SrbFlags,
                         SRB_FLAGS_NO_QUEUE_FREEZE);
            }
        }
    } // end of threshold definitely being hit for first time

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

Referenced by ClassIoComplete(), and TransferPktComplete().

ClasspRegisterMountedDeviceInterface()

VOID NTAPI ClasspRegisterMountedDeviceInterface

(

IN PDEVICE_OBJECT

DeviceObject

)

Definition at line 7569 of file class.c.

{

    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;
    BOOLEAN isFdo = commonExtension->IsFdo;

    PDEVICE_OBJECT pdo;
    UNICODE_STRING interfaceName;

    NTSTATUS status;

    if(isFdo) {

        PFUNCTIONAL_DEVICE_EXTENSION functionalExtension;

        functionalExtension =
            (PFUNCTIONAL_DEVICE_EXTENSION) commonExtension;
        pdo = functionalExtension->LowerPdo;
    } else {
        pdo = DeviceObject;
    }

    status = IoRegisterDeviceInterface(
                pdo,
                &MOUNTDEV_MOUNTED_DEVICE_GUID,
                NULL,
                &interfaceName
                );

    if(NT_SUCCESS(status)) {

        //
        // Copy the interface name before setting the interface state - the
        // name is needed by the components we notify.
        //

        commonExtension->MountedDeviceInterfaceName = interfaceName;
        status = IoSetDeviceInterfaceState(&interfaceName, TRUE);

        if(!NT_SUCCESS(status)) {
            RtlFreeUnicodeString(&interfaceName);
        }
    }

    if(!NT_SUCCESS(status)) {
        RtlInitUnicodeString(&(commonExtension->MountedDeviceInterfaceName),
                             NULL);
    }
    return;
} // end ClasspRegisterMountedDeviceInterface()

Referenced by ClassPnpStartDevice().

ClasspReleaseQueue()

VOID NTAPI ClasspReleaseQueue	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	ReleaseQueueIrp
	)

Definition at line 8269 of file class.c.

{
    PIO_STACK_LOCATION irpStack;
    PIRP irp;
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;
    PDEVICE_OBJECT lowerDevice;
    PSCSI_REQUEST_BLOCK srb;
    KIRQL currentIrql;

    lowerDevice = fdoExtension->CommonExtension.LowerDeviceObject;

    //
    // we raise irql separately 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);

    KeAcquireSpinLockAtDpcLevel(&(fdoExtension->ReleaseQueueSpinLock));

    //
    // make sure that if they passed us an irp, it matches our allocated irp.
    //

    ASSERT((ReleaseQueueIrp == NULL) ||
           (ReleaseQueueIrp == fdoExtension->PrivateFdoData->ReleaseQueueIrp));

    //
    // ASSERT that we've already allocated this. (should not occur)
    // try to allocate it anyways, then finally bugcheck if
    // there's still no memory...
    //

    ASSERT(fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated);
    if (!fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated) {
        ClasspAllocateReleaseQueueIrp(fdoExtension);
    }
    if (!fdoExtension->PrivateFdoData->ReleaseQueueIrpAllocated) {
        KeBugCheckEx(SCSI_DISK_DRIVER_INTERNAL, 0x12, (ULONG_PTR)Fdo, 0x0, 0x0);
    }

    if ((fdoExtension->ReleaseQueueInProgress) && (ReleaseQueueIrp == NULL)) {

        //
        // Someone is already using the irp - just set the flag to indicate that
        // we need to release the queue again.
        //

        fdoExtension->ReleaseQueueNeeded = TRUE;
        KeReleaseSpinLockFromDpcLevel(&(fdoExtension->ReleaseQueueSpinLock));
        KeLowerIrql(currentIrql);
        return;

    }

    //
    // Mark that there is a release queue in progress and drop the spinlock.
    //

    fdoExtension->ReleaseQueueInProgress = TRUE;
    if (ReleaseQueueIrp) {
        irp = ReleaseQueueIrp;
    } else {
        irp = fdoExtension->PrivateFdoData->ReleaseQueueIrp;
    }
    srb = &(fdoExtension->ReleaseQueueSrb);

    KeReleaseSpinLockFromDpcLevel(&(fdoExtension->ReleaseQueueSpinLock));

    ASSERT(irp != NULL);

    irpStack = IoGetNextIrpStackLocation(irp);

    irpStack->MajorFunction = IRP_MJ_SCSI;

    srb->OriginalRequest = irp;

    //
    // Store the SRB address in next stack for port driver.
    //

    irpStack->Parameters.Scsi.Srb = srb;

    //
    // If this device is removable then flush the queue.  This will also
    // release it.
    //

    if (TEST_FLAG(Fdo->Characteristics, FILE_REMOVABLE_MEDIA)){
       srb->Function = SRB_FUNCTION_FLUSH_QUEUE;
    }
    else {
       srb->Function = SRB_FUNCTION_RELEASE_QUEUE;
    }

    ClassAcquireRemoveLock(Fdo, irp);

    IoSetCompletionRoutine(irp,
                           ClassReleaseQueueCompletion,
                           Fdo,
                           TRUE,
                           TRUE,
                           TRUE);

    IoCallDriver(lowerDevice, irp);

    KeLowerIrql(currentIrql);

    return;

} // end ClassReleaseQueue()

Referenced by ClassReleaseQueue(), and ClassReleaseQueueCompletion().

ClasspRetryDpcTimer()

VOID NTAPI ClasspRetryDpcTimer

(

IN PCLASS_PRIVATE_FDO_DATA

FdoData

)

Definition at line 8913 of file class.c.

{
    LARGE_INTEGER fire;

    ASSERT(FdoData->Retry.Tick.QuadPart != (LONGLONG)0);
    ASSERT(FdoData->Retry.ListHead      != NULL);  // never fire an empty list

    //
    // fire == (CurrentTick - now) * (100ns per tick)
    //
    // NOTE: Overflow is nearly impossible and is ignored here
    //

    KeQueryTickCount(&fire);
    fire.QuadPart =  FdoData->Retry.Tick.QuadPart - fire.QuadPart;
    fire.QuadPart *= FdoData->Retry.Granularity;

    //
    // fire is now multiples of 100ns until should fire the timer.
    // if timer should already have expired, or would fire too quickly,
    // fire it in some arbitrary number of ticks to prevent infinitely
    // recursing.
    //

    if (fire.QuadPart < MINIMUM_RETRY_UNITS) {
        fire.QuadPart = MINIMUM_RETRY_UNITS;
    }

    DebugPrint((ClassDebugDelayedRetry,
                "ClassRetry: ======= %I64x ticks\n",
                fire.QuadPart));

    //
    // must use negative to specify relative time to fire
    //

    fire.QuadPart = fire.QuadPart * ((LONGLONG)-1);

    //
    // set the timer, since this is the first addition
    //

    KeSetTimerEx(&FdoData->Retry.Timer, fire, 0, &FdoData->Retry.Dpc);

    return;
} // end ClasspRetryDpcTimer()

Referenced by ClasspRetryRequestDpc(), and ClassRetryRequest().

ClasspScanForClassHacks()

VOID NTAPI ClasspScanForClassHacks	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN ULONG_PTR	Data
	)

Definition at line 9083 of file class.c.

{
    PAGED_CODE();

    //
    // remove invalid flags and save
    //

    CLEAR_FLAG(Data, FDO_HACK_INVALID_FLAGS);
    SET_FLAG(FdoExtension->PrivateFdoData->HackFlags, Data);
    return;
}

Referenced by ClassPnpStartDevice().

ClasspScanForSpecialInRegistry()

VOID NTAPI ClasspScanForSpecialInRegistry

(

IN PFUNCTIONAL_DEVICE_EXTENSION

FdoExtension

)

Definition at line 9101 of file class.c.

{
    HANDLE             deviceParameterHandle; // device instance key
    HANDLE             classParameterHandle; // classpnp subkey
    OBJECT_ATTRIBUTES  objectAttributes;
    UNICODE_STRING     subkeyName;
    NTSTATUS           status;

    //
    // seeded in the ENUM tree by ClassInstaller
    //
    ULONG deviceHacks;
    RTL_QUERY_REGISTRY_TABLE queryTable[2]; // null terminated array

    PAGED_CODE();

    deviceParameterHandle = NULL;
    classParameterHandle = NULL;
    deviceHacks = 0;

    status = IoOpenDeviceRegistryKey(FdoExtension->LowerPdo,
                                     PLUGPLAY_REGKEY_DEVICE,
                                     KEY_WRITE,
                                     &deviceParameterHandle
                                     );

    if (!NT_SUCCESS(status)) {
        goto cleanupScanForSpecial;
    }

    RtlInitUnicodeString(&subkeyName, CLASSP_REG_SUBKEY_NAME);
    InitializeObjectAttributes(&objectAttributes,
                               &subkeyName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               deviceParameterHandle,
                               NULL
                               );

    status = ZwOpenKey( &classParameterHandle,
                        KEY_READ,
                        &objectAttributes
                        );

    if (!NT_SUCCESS(status)) {
        goto cleanupScanForSpecial;
    }

    //
    // Zero out the memory
    //

    RtlZeroMemory(&queryTable[0], 2*sizeof(RTL_QUERY_REGISTRY_TABLE));

    //
    // Setup the structure to read
    //

    queryTable[0].Flags         = RTL_QUERY_REGISTRY_DIRECT;
    queryTable[0].Name          = CLASSP_REG_HACK_VALUE_NAME;
    queryTable[0].EntryContext  = &deviceHacks;
    queryTable[0].DefaultType   = REG_DWORD;
    queryTable[0].DefaultData   = &deviceHacks;
    queryTable[0].DefaultLength = 0;

    //
    // read values
    //

    status = RtlQueryRegistryValues(RTL_REGISTRY_HANDLE,
                                    (PWSTR)classParameterHandle,
                                    &queryTable[0],
                                    NULL,
                                    NULL
                                    );
    if (!NT_SUCCESS(status)) {
        goto cleanupScanForSpecial;
    }

    //
    // remove unknown values and save...
    //

    KdPrintEx((DPFLTR_CLASSPNP_ID, DPFLTR_ERROR_LEVEL,
               "Classpnp => ScanForSpecial: HackFlags %#08x\n",
               deviceHacks));

    CLEAR_FLAG(deviceHacks, FDO_HACK_INVALID_FLAGS);
    SET_FLAG(FdoExtension->PrivateFdoData->HackFlags, deviceHacks);


cleanupScanForSpecial:

    if (deviceParameterHandle) {
        ZwClose(deviceParameterHandle);
    }

    if (classParameterHandle) {
        ZwClose(classParameterHandle);
    }

    //
    // we should modify the system hive to include another key for us to grab
    // settings from.  in this case:  Classpnp\HackFlags
    //
    // the use of a DWORD value for the HackFlags allows 32 hacks w/o
    // significant use of the registry, and also reduces OEM exposure.
    //
    // definition of bit flags:
    //   0x00000001 -- Device succeeds PREVENT_MEDIUM_REMOVAL, but
    //                 cannot actually prevent removal.
    //   0x00000002 -- Device hard-hangs or times out for GESN requests.
    //   0xfffffffc -- Currently reserved, may be used later.
    //

    return;
}

Referenced by ClassPnpStartDevice().

ClasspSendNotification()

VOID NTAPI ClasspSendNotification	(	IN PFUNCTIONAL_DEVICE_EXTENSION	FdoExtension,
		IN const GUID *	Guid,
		IN ULONG	ExtraDataSize,
		IN PVOID	ExtraData
	)

Definition at line 173 of file autorun.c.

{
    PTARGET_DEVICE_CUSTOM_NOTIFICATION notification;
    ULONG requiredSize;
        
    requiredSize =
        (sizeof(TARGET_DEVICE_CUSTOM_NOTIFICATION) - sizeof(UCHAR)) +
        ExtraDataSize;

    if (requiredSize > 0x0000ffff) {
        // MAX_USHORT, max total size for these events!
        KdPrintEx((DPFLTR_CLASSPNP_ID, ClassDebugWarning,
                   "Error sending event: size too large! (%x)\n",
                   requiredSize));
        return;
    }
    
    notification = ExAllocatePoolWithTag(NonPagedPool,
                                         requiredSize,
                                         'oNcS');
    
    //
    // 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;
    RtlCopyMemory(notification->CustomDataBuffer, ExtraData, ExtraDataSize);

    IoReportTargetDeviceChangeAsynchronous(FdoExtension->LowerPdo,
                                           notification,
                                           NULL, NULL);
    
    ExFreePool(notification);
    notification = NULL;
    return;
}

Referenced by ClassInterpretSenseInfo(), ClasspInternalSetMediaChangeState(), ClasspInterpretGesnData(), and ClassSendEjectionNotification().

ClassQueryPnpCapabilities()

NTSTATUS NTAPI ClassQueryPnpCapabilities	(	IN PDEVICE_OBJECT	PhysicalDeviceObject,
		IN PDEVICE_CAPABILITIES	Capabilities
	)

Definition at line 6863 of file class.c.

{
    PCLASS_DRIVER_EXTENSION driverExtension =
        ClassGetDriverExtension(DeviceObject->DriverObject);
    PCOMMON_DEVICE_EXTENSION commonExtension = DeviceObject->DeviceExtension;

    PCLASS_QUERY_PNP_CAPABILITIES queryRoutine = NULL;

    PAGED_CODE();

    ASSERT(DeviceObject);
    ASSERT(Capabilities);

    if(commonExtension->IsFdo) {
        queryRoutine = driverExtension->InitData.FdoData.ClassQueryPnpCapabilities;
    } else {
        queryRoutine = driverExtension->InitData.PdoData.ClassQueryPnpCapabilities;
    }

    if(queryRoutine) {
        return queryRoutine(DeviceObject,
                            Capabilities);
    } else {
        return STATUS_NOT_IMPLEMENTED;
    }
} // end ClassQueryPnpCapabilities()

Referenced by ClassDispatchPnp().

ClassRemoveChild()

PPHYSICAL_DEVICE_EXTENSION NTAPI ClassRemoveChild	(	IN PFUNCTIONAL_DEVICE_EXTENSION	Parent,
		IN PPHYSICAL_DEVICE_EXTENSION	Child,
		IN BOOLEAN	AcquireLock
	)

Definition at line 8628 of file class.c.

{
    if(AcquireLock) {
        ClassAcquireChildLock(Parent);
    }

    TRY {
        PCOMMON_DEVICE_EXTENSION previousChild = &Parent->CommonExtension;

        //
        // If the list is empty then bail out now.
        //

        if(Parent->CommonExtension.ChildList == NULL) {
            Child = NULL;
            LEAVE;
        }

        //
        // If the caller specified a child then find the child object before
        // it.  If none was specified then the FDO is the child object before
        // the one we want to remove.
        //

        if(Child != NULL) {

            //
            // Scan through the child list to find the entry which points to
            // this one.
            //

            do {
                ASSERT(previousChild != &Child->CommonExtension);

                if(previousChild->ChildList == Child) {
                    break;
                }

                previousChild = &previousChild->ChildList->CommonExtension;
            } while(previousChild != NULL);

            if(previousChild == NULL) {
                Child = NULL;
                LEAVE;
            }
        }

        //
        // Save the next child away then unlink it from the list.
        //

        Child = previousChild->ChildList;
        previousChild->ChildList = Child->CommonExtension.ChildList;
        Child->CommonExtension.ChildList = NULL;

    } FINALLY {
        if(AcquireLock) {
            ClassReleaseChildLock(Parent);
        }
    }
    return Child;
} // end ClassRemoveChild()

Referenced by ClassMarkChildMissing(), and ClassRemoveDevice().

ClassRetrieveDeviceRelations()

NTSTATUS NTAPI ClassRetrieveDeviceRelations	(	IN PDEVICE_OBJECT	Fdo,
		IN DEVICE_RELATION_TYPE	RelationType,
		OUT PDEVICE_RELATIONS *	DeviceRelations
	)

Definition at line 6709 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension = Fdo->DeviceExtension;

    ULONG count = 0;
    ULONG i;

    PPHYSICAL_DEVICE_EXTENSION nextChild;

    ULONG relationsSize;
    PDEVICE_RELATIONS deviceRelations = NULL;

    NTSTATUS status;

    PAGED_CODE();

    ClassAcquireChildLock(fdoExtension);

    nextChild = fdoExtension->CommonExtension.ChildList;

    //
    // Count the number of PDO's attached to this disk
    //

    while(nextChild != NULL) {
        PCOMMON_DEVICE_EXTENSION commonExtension;

        commonExtension = &(nextChild->CommonExtension);

        ASSERTMSG("ClassPnp internal error: missing child on active list\n",
                  (nextChild->IsMissing == FALSE));

        nextChild = commonExtension->ChildList;

        count++;
    };

    relationsSize = (sizeof(DEVICE_RELATIONS) +
                     (count * sizeof(PDEVICE_OBJECT)));

    deviceRelations = ExAllocatePoolWithTag(PagedPool, relationsSize, '5BcS');

    if(deviceRelations == NULL) {

        DebugPrint((1, "ClassRetrieveDeviceRelations: unable to allocate "
                       "%d bytes for device relations\n", relationsSize));

        ClassReleaseChildLock(fdoExtension);

        return STATUS_INSUFFICIENT_RESOURCES;
    }

    RtlZeroMemory(deviceRelations, relationsSize);

    nextChild = fdoExtension->CommonExtension.ChildList;
    i = count - 1;

    while(nextChild != NULL) {
        PCOMMON_DEVICE_EXTENSION commonExtension;

        commonExtension = &(nextChild->CommonExtension);

        ASSERTMSG("ClassPnp internal error: missing child on active list\n",
                  (nextChild->IsMissing == FALSE));

        deviceRelations->Objects[i--] = nextChild->DeviceObject;

        status = ObReferenceObjectByPointer(
                    nextChild->DeviceObject,
                    0,
                    NULL,
                    KernelMode);
        ASSERT(NT_SUCCESS(status));

        nextChild->IsEnumerated = TRUE;
        nextChild = commonExtension->ChildList;
    }

    ASSERTMSG("Child list has changed: ", i == -1);

    deviceRelations->Count = count;
    *DeviceRelations = deviceRelations;
    ClassReleaseChildLock(fdoExtension);
    return STATUS_SUCCESS;
} // end ClassRetrieveDeviceRelations()

Referenced by ClassPnpQueryFdoRelations().

ClassRetryRequest()

VOID NTAPI ClassRetryRequest	(	IN PDEVICE_OBJECT	SelfDeviceObject,
		IN PIRP	Irp,
		IN LARGE_INTEGER	TimeDelta100ns
	)

Definition at line 8780 of file class.c.

{
    PFUNCTIONAL_DEVICE_EXTENSION fdoExtension;
    PCLASS_PRIVATE_FDO_DATA fdoData;
    PCLASS_RETRY_INFO  retryInfo;
    //PCLASS_RETRY_INFO *previousNext;
    LARGE_INTEGER      delta;
    KIRQL irql;

    //
    // this checks we aren't destroying irps
    //
    ASSERT(sizeof(CLASS_RETRY_INFO) <= (4*sizeof(PVOID)));

    fdoExtension = SelfDeviceObject->DeviceExtension;