FxPkgGeneral Class Reference

#include <fxpkggeneral.hpp>

Inheritance diagram for FxPkgGeneral:

Collaboration diagram for FxPkgGeneral:

Public Member Functions
	FxPkgGeneral (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device)
	~FxPkgGeneral ()
virtual _Must_inspect_result_ NTSTATUS	Dispatch (__inout MdIrp Irp)
_Must_inspect_result_ NTSTATUS	Initialize (__in PWDFDEVICE_INIT DeviceInit)
_Must_inspect_result_ NTSTATUS	PostCreateDeviceInitialize (__in PWDFDEVICE_INIT Init)
VOID	CreateCompleted (__in FxIrp *Irp)
_Must_inspect_result_ NTSTATUS	ConfigureForwarding (__in FxIoQueue *FxQueue)
BOOLEAN	CanDestroyControlDevice (VOID)
VOID	GetConstraintsHelper (__out_opt WDF_EXECUTION_LEVEL *ExecutionLevel, __out_opt WDF_SYNCHRONIZATION_SCOPE *SynchronizationScope)
FxCallbackLock *	GetCallbackLockPtrHelper (__deref_out_opt FxObject **LockObject)
__inline FxIoQueue *	GetDeafultInternalCreateQueue ()
Public Member Functions inherited from FxPackage
	FxPackage (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in CfxDevice *Device, __in WDFTYPE Type)
virtual NTSTATUS	Dispatch (__in MdIrp Irp)=0
__inline CfxDevice *	GetDevice (VOID)
	DECLARE_INTERNAL_NEW_OPERATOR ()
Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
virtual	~FxNonPagedObject (VOID)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)
	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)
	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)
	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)
Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()
void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)
virtual	~FxObject (VOID)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)
PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)
VOID	operator delete (__in PVOID Memory)
VOID	SetNoContextHeader (VOID)
PVOID __inline	GetObjectHandle (VOID)
__inline FxContextHeader *	GetContextHeader (VOID)
__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)
WDFTYPE	GetType (VOID)
USHORT	GetObjectSize (VOID)
LONG	GetRefCnt (VOID)
FxTagTracker *	GetTagTracker (VOID)
CfxDevice *	GetDevice (VOID)
CfxDeviceBase *	GetDeviceBase (VOID)
VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)
__inline VOID	CallCleanup (VOID)
ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)
virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)
VOID	MarkTraceState (VOID)
BOOLEAN __inline	IsTraceState (VOID)
VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)
VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)
VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)
VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)
BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)
VOID	MarkCommitted (VOID)
BOOLEAN	IsCommitted (VOID)
VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)
VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)
BOOLEAN	IsNoDeleteDDI (VOID)
_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT *ObjectHandle, __in_opt FxObject *Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)
VOID	DeleteFromFailedCreate (VOID)
VOID	ClearEvtCallbacks (VOID)
BOOLEAN	EarlyDispose (VOID)
virtual VOID	DeleteObject (VOID)
virtual BOOLEAN	Dispose (VOID)
_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)
_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader *Header, __in PVOID *Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)
_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)
_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)
BOOLEAN	IsDisposed (VOID)

Private Member Functions
_Must_inspect_result_ NTSTATUS	OnCreate (__inout FxIrp *FxIrp)
_Must_inspect_result_ NTSTATUS	OnClose (__inout FxIrp *FxIrp)
BOOLEAN	AcquireRemoveLockForClose (__inout FxIrp *FxIrp)
_Must_inspect_result_ NTSTATUS	OnCleanup (__inout FxIrp *FxIrp)
_Must_inspect_result_ NTSTATUS	OnShutdown (__inout FxIrp *FxIrp)
_Must_inspect_result_ NTSTATUS	ConfigureConstraints (__in PLIST_ENTRY FileObjInfoList)
_Must_inspect_result_ NTSTATUS	ConfigureFileObjectClass (__in PLIST_ENTRY FileObjInfoList)
VOID	DecrementOpenHandleCount (VOID)
_Must_inspect_result_ NTSTATUS	ForwardCreateRequest (__in FxIrp *FxIrp, __in MdCompletionRoutine CompletionRoutine, __in PVOID Context)

Private Attributes
LONG	m_OpenHandleCount
LIST_ENTRY	m_FileObjectInfoHeadList
FxIoQueue *	m_DefaultQueueForCreates
FxIoQueue *	m_DriverCreatedQueue
ULONG	m_Flags
WDF_EXECUTION_LEVEL	m_ExecutionLevel
WDF_SYNCHRONIZATION_SCOPE	m_SynchronizationScope
FxCallbackLock *	m_CallbackLockPtr
FxObject *	m_CallbackLockObjectPtr
FxShutDown	m_EvtDeviceShutdown

Static Private Attributes
static MdCompletionRoutineType	_CreateCompletionRoutine
static MdCompletionRoutineType	_CreateCompletionRoutine2

Additional Inherited Members
Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)
static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)
static PVOID __inline	_ToHandle (__in FxObject *Object)
static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)
static PVOID	_GetDebugBase (__in FxObject *Object)
static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)
static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject *Object, __in_opt IFxHasCallbacks *Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock **CallbackLock, __out_opt FxObject **CallbackLockObject)
static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject *Object, _In_ CONST GUID *Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)
Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)
FxObjectDebugExtension *	GetDebugExtension (VOID)
BOOLEAN	IsDebug (VOID)
VOID	AllocateTagTracker (__in WDFTYPE Type)
virtual VOID	SelfDestruct (VOID)
PVOID __inline	GetObjectHandleUnchecked (VOID)
VOID __inline	DestroyChildren (VOID)
VOID	DeleteEarlyDisposedObject (VOID)
Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)
Protected Attributes inherited from FxObject
union {
CfxDeviceBase *   m_DeviceBase
CfxDevice *   m_Device
};

Detailed Description

Definition at line 66 of file fxpkggeneral.hpp.

Constructor & Destructor Documentation

FxPkgGeneral()

FxPkgGeneral::FxPkgGeneral	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in CfxDevice *	Device
	)

Definition at line 44 of file fxpkggeneral.cpp.

      :
    FxPackage(FxDriverGlobals, Device, FX_TYPE_PACKAGE_GENERAL)
{
    //
    // The count is biased to one and not zero for control device objects.  When
    // a control devobj is deleted, we will decrement this bias out so that we
    // know when the last handle has been closed and it is now safe to free the
    // FxDevice.
    //
    m_OpenHandleCount = 1;

    //
    // List of file object info.
    //
    InitializeListHead(&m_FileObjectInfoHeadList);

    m_Flags = 0;
    m_ExecutionLevel = WdfExecutionLevelInheritFromParent;
    m_SynchronizationScope = WdfSynchronizationScopeInheritFromParent;
    m_CallbackLockPtr      = NULL;
    m_CallbackLockObjectPtr = NULL;
    m_DriverCreatedQueue = NULL;
    m_DefaultQueueForCreates = NULL;
}

~FxPkgGeneral()

FxPkgGeneral::~FxPkgGeneral

(

)

Definition at line 72 of file fxpkggeneral.cpp.

{
    PLIST_ENTRY next;

    ASSERT(m_OpenHandleCount <= 1);

    //
    // Delete the file object info list if present.
    //
    while (!IsListEmpty(&m_FileObjectInfoHeadList)) {
        next = RemoveHeadList(&m_FileObjectInfoHeadList);
        FxFileObjectInfo* info;
        info = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);
        InitializeListHead(next);
        delete info;
    }
}

Member Function Documentation

AcquireRemoveLockForClose()

BOOLEAN FxPkgGeneral::AcquireRemoveLockForClose ( __inout FxIrp *  FxIrp )

private

Definition at line 1850 of file fxpkggeneral.cpp.

{
    NTSTATUS status;
    BOOLEAN lockAcquired;
    FxWdmDeviceExtension * wdmExtension = FxDevice::_GetFxWdmExtension(
            m_Device->GetDeviceObject());

    //
    // Initialization
    //
    lockAcquired = FALSE;

    //
    // We attempt to acquire the remove lock only for PNP device objects
    //
    if (m_Device->IsPnp() == FALSE) {
        goto Done;
    }

    //
    // If driver has opted in for remove lock for I/O operations we have
    // already acquired remove lock for Close so no need to do it again.
    //
    if (wdmExtension->RemoveLockOptionFlags &
            WDF_REMOVE_LOCK_OPTION_ACQUIRE_FOR_IO) {
        goto Done;
    }

    status = Mx::MxAcquireRemoveLock(
                m_Device->GetRemoveLock(),
                FxIrp->GetIrp());
    if (NT_SUCCESS(status)) {
        //
        // Successfully acquired the remove lock
        //
        lockAcquired = TRUE;
    } else {
        //
        // This is likely to have failed because we got the remove IRP and
        // called IoReleaseRemoveLockAndWait on another thread. This would
        // happen if there's a bug in the driver above us in the stack that
        // caused it to forward us the remove IRP before we completed the close
        // IRP.
        //
        // There's not much we can do now, since we're already racing against
        // the remove IRP.
        //
        PFX_DRIVER_GLOBALS pFxDriverGlobals;

        pFxDriverGlobals = GetDriverGlobals();

        DoTraceLevelMessage(
                    pFxDriverGlobals,
                    TRACE_LEVEL_ERROR,
                    TRACINGIO,
                    "Unable to acquire remove lock while handling the close IRP"
                    " 0x%p, %!STATUS!",
                    FxIrp->GetIrp(), status);

        if (pFxDriverGlobals->IsVerificationEnabled(1,9, OkForDownLevel)) {
            FxVerifierDbgBreakPoint(pFxDriverGlobals);
        }
    }

Done:
    return lockAcquired;
}

Referenced by OnClose().

CanDestroyControlDevice()

BOOLEAN FxPkgGeneral::CanDestroyControlDevice

(

VOID

)

Definition at line 1986 of file fxpkggeneral.cpp.

{
    //
    // Remove the bias of one that we use to track if a control device should be
    // deleted.
    //
    if (InterlockedDecrement(&m_OpenHandleCount) == 0) {
        return TRUE;
    }
    else {
        return FALSE;
    }

}

Referenced by FxDevice::DeleteObject().

ConfigureConstraints()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::ConfigureConstraints ( __in PLIST_ENTRY  FileObjInfoList )

private

Definition at line 242 of file fxpkggeneral.cpp.

{
    WDF_EXECUTION_LEVEL         execLevel, parentExecLevel;
    WDF_SYNCHRONIZATION_SCOPE   synchScope, parentSynchScope;
    BOOLEAN                     automaticLockingRequired;
    PLIST_ENTRY                 next;
    FxFileObjectInfo           *fileObjInfo;
    NTSTATUS                    status;
    PFX_DRIVER_GLOBALS          fxDriverGlobals;

    automaticLockingRequired = FALSE;
    fxDriverGlobals = GetDriverGlobals();

    ASSERT(!IsListEmpty(FileObjInfoList));

    //
    // Get parent values.
    //
    m_Device->GetConstraints(&parentExecLevel, &parentSynchScope);

    //
    // Default constraints settings when driver uses WDF_NO_OBJECT_ATTRIBUTES:
    //
    // v1.9 and below:
    //     WdfExecutionLevelDispatch and WdfSynchronizationScopeNone
    //
    // v1.11 and above:
    //     WdfExecutionLevelPassive and WdfSynchronizationScopeNone
    //
    // In v1.9 and below if driver used WDF_NO_OBJECT_ATTRIBUTES for
    // the file object's attributes, the synchronization scope and execution
    // level were left uninitialized (i.e., zero), which means that WDF
    // defaulted to WdfSynchronizationScopeInvalid and WdfExecutionLevelInvalid,
    // WDF interpreted these values as no_passive and no_synchronization.
    //
    // This default execution level is used when disposing the device's
    // general package object and file object object.
    // Independently of these settings WDF guarantees that Create,
    // Cleanup and Close callbacks are always called at passive level.
    //
    m_ExecutionLevel = fxDriverGlobals->IsVersionGreaterThanOrEqualTo(1,11) ?
                        WdfExecutionLevelPassive :
                        WdfExecutionLevelDispatch;

    m_SynchronizationScope = WdfSynchronizationScopeNone;

    //
    // Make sure file object info chain follow these constrains:
    //  Cx's synch scope: none
    //
    for (next = FileObjInfoList->Blink;
         next != FileObjInfoList;
         next = next->Blink) {

        fileObjInfo = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);

        //
        // Size is zero if driver didn't specify any attributes.
        //
        if (0 == fileObjInfo->Attributes.Size) {
            continue;
        }

        //
        // Execution level checks.
        //
        execLevel = fileObjInfo->Attributes.ExecutionLevel;
        if (WdfExecutionLevelInheritFromParent == execLevel) {
            execLevel = parentExecLevel;
        }

        //
        // Passive level wins over DPC level.
        //
        if (WdfExecutionLevelPassive == execLevel) {
            m_ExecutionLevel = WdfExecutionLevelPassive;
        }

        //
        // Synchronization scope checks.
        //
        synchScope = fileObjInfo->Attributes.SynchronizationScope;
        if (WdfSynchronizationScopeInheritFromParent == synchScope) {
            synchScope = parentSynchScope;
        }

        //
        // Make sure the Cx's synch scope is none.
        //
        if (fileObjInfo->ClassExtension) {
            if (synchScope != WdfSynchronizationScopeNone) {
                status = STATUS_INVALID_DEVICE_REQUEST;
                DoTraceLevelMessage(
                    fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                    "Driver 0x%p - Device 0x%p - synchronization scope: "
                    "%!WDF_SYNCHRONIZATION_SCOPE! should be"
                    "WdfSynchronizationScopeNone, %!STATUS!",
                    m_Device->GetCxDriver(fileObjInfo->CxDeviceInfo)->GetHandle(),
                    m_Device->GetHandle(),
                    synchScope,
                    status
                    );

                FxVerifierDbgBreakPoint(fxDriverGlobals);
                goto Done;
            }
        }
        else {
            //
            // Always use client's synch scope for file object.
            //
            m_SynchronizationScope = synchScope;
        }
    }

    if(m_SynchronizationScope == WdfSynchronizationScopeQueue) {
        status = STATUS_INVALID_DEVICE_REQUEST;
        DoTraceLevelMessage(
            fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
            "WdfSynchronizationScopeQueue is not allowed on "
            "FileObject, %!STATUS!",
            status);
        goto Done;
    }

    if (m_ExecutionLevel == WdfExecutionLevelPassive) {

        //
        // Mark FxObject as passive level to ensure that Dispose and Destroy
        // callbacks are passive to the driver
        //
        MarkPassiveCallbacks(ObjectDoNotLock);
        //
        // We aren't going to use a workitem to  defer the invocation of fileevents
        // to passive-level if the caller is at DISPATCH_LEVEL because we wouldn't
        // be able to guarantee the caller's context for fileevents. It's up to the
        // driver writer to ensure that the layer above doesn't send create requests
        // at dispatch-level.
        //
    }

    if(m_SynchronizationScope == WdfSynchronizationScopeNone) {
        status = STATUS_SUCCESS;
        goto Done;
    }

    if(m_SynchronizationScope == WdfSynchronizationScopeDevice) {
        //
        // Since FileEvents can be invoked only at passive-level, we check the
        // parent executionlevel to see if it's set to passive. If not, we return an error
        // because we can't use the presentation lock of the device.
        //
        if(parentExecLevel != WdfExecutionLevelPassive) {
            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(
                fxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "WdfSynchronizationScopeDevice or "
                "WdfSynchronizationScopeInheritFromParent "
                "allowed only if the parent WDFDEVICE 0x%p, "
                "ExecutionLevel is passive, %!STATUS!",
                m_Device->GetHandle(), status);
            goto Done;
        }

        m_CallbackLockPtr = m_Device->GetCallbackLockPtr(&m_CallbackLockObjectPtr);
        automaticLockingRequired = TRUE;
    }

    //
    // Set lock constraint in client's callbacks object only.
    //
    if (automaticLockingRequired) {
        if (!IsListEmpty(FileObjInfoList)) {
            fileObjInfo = CONTAINING_RECORD(FileObjInfoList->Flink,
                                            FxFileObjectInfo,
                                            ListEntry);

            if (FALSE == fileObjInfo->ClassExtension) {
                fileObjInfo->EvtFileCreate.SetCallbackLockPtr(m_CallbackLockPtr);
                fileObjInfo->EvtFileCleanup.SetCallbackLockPtr(m_CallbackLockPtr);
                fileObjInfo->EvtFileClose.SetCallbackLockPtr(m_CallbackLockPtr);
            }
        }
    }

    status = STATUS_SUCCESS;

Done:
    return status;
}

Referenced by Initialize().

ConfigureFileObjectClass()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::ConfigureFileObjectClass ( __in PLIST_ENTRY  FileObjInfoList )

private

Definition at line 452 of file fxpkggeneral.cpp.

{
    PLIST_ENTRY                 next;
    FxFileObjectInfo*           fileObjInfo;
    NTSTATUS                    status;
    PFX_DRIVER_GLOBALS          fxDriverGlobals;
    WDF_FILEOBJECT_CLASS        fileObjClass;
    FxCxDeviceInfo*             previousCxInfo;

    fxDriverGlobals = GetDriverGlobals();
    fileObjClass = WdfFileObjectNotRequired;
    previousCxInfo = NULL;

    ASSERT(!IsListEmpty(FileObjInfoList));

    //
    // Compute the execution level and synchronization scope for all the chain.
    //
    for (next = FileObjInfoList->Blink;
         next != FileObjInfoList;
         next = next->Blink) {

        fileObjInfo = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);

        //
        // If not required, skip it.
        //
        if (WdfFileObjectNotRequired == fileObjInfo->FileObjectClass) {
            continue;
        }

        //
        // If the same, skip it.
        //
        if (fileObjClass == fileObjInfo->FileObjectClass) {
            continue;
        }

        //
        // If not set yet, use new value.
        //
        if (WdfFileObjectNotRequired == fileObjClass) {
            fileObjClass = fileObjInfo->FileObjectClass;
            previousCxInfo = fileObjInfo->CxDeviceInfo;
            continue;
        }

        //
        // Make sure optional flag is compatible.
        //
        if (FxIsFileObjectOptional(fileObjClass) !=
            FxIsFileObjectOptional(fileObjInfo->FileObjectClass)) {

            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(
                fxDriverGlobals,
                TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "Device 0x%p - "
                "Driver 0x%p - WdfFileObjectCanBeOptional (%d) is not "
                "compatible with wdf extension "
                "Driver 0x%p - WdfFileObjectCanBeOptional (%d), %!STATUS!",
                m_Device->GetHandle(),
                m_Device->GetCxDriver(fileObjInfo->CxDeviceInfo)->GetHandle(),
                FxIsFileObjectOptional(fileObjInfo->FileObjectClass) ? 1:0,
                previousCxInfo->Driver->GetHandle(),
                FxIsFileObjectOptional(fileObjClass) ? 1:0,
                status
                );

            FxVerifierDbgBreakPoint(fxDriverGlobals);
            goto Done;
        }

        //
        // Drivers do not agree on the location, set cannot use fx contexts.
        //
        fileObjClass = WdfFileObjectWdfCannotUseFsContexts;
        if (FxIsFileObjectOptional(fileObjInfo->FileObjectClass)) {
            fileObjClass = (WDF_FILEOBJECT_CLASS)
                ((ULONG)fileObjClass |  WdfFileObjectCanBeOptional);
        }

        DoTraceLevelMessage(
            fxDriverGlobals,
            TRACE_LEVEL_INFORMATION, TRACINGDEVICE,
            "Converting file object class for Driver 0x%p - Device 0x%p, "
            "from 0x%x to 0x%x",
            m_Device->GetCxDriver(fileObjInfo->CxDeviceInfo)->GetHandle(),
            m_Device->GetHandle(),
            fileObjInfo->FileObjectClass,
            fileObjClass
            );
    }

    //
    // Set the file object support level on the FxDevice
    //
    m_Device->SetFileObjectClass(fileObjClass);

    status = STATUS_SUCCESS;

Done:
    return status;
}

Referenced by Initialize().

ConfigureForwarding()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::ConfigureForwarding

(

__in FxIoQueue *

FxQueue

)

Definition at line 695 of file fxpkggeneral.cpp.

{
    NTSTATUS status;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    KIRQL irql;

    status = STATUS_SUCCESS;
    pFxDriverGlobals = GetDriverGlobals();

    if(TargetQueue->IsIoEventHandlerRegistered(WdfRequestTypeCreate) == FALSE){
        status = STATUS_INVALID_DEVICE_REQUEST;
        DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                "Must have EvtIoDefault registered to receive "
                "WdfRequestTypeCreate requests for WDFQUEUE 0x%p, "
                "%!STATUS!", TargetQueue->GetObjectHandle(), status);
        FxVerifierDbgBreakPoint(pFxDriverGlobals);
        return status;
    }

    Lock(&irql);

    if (m_DriverCreatedQueue) {
        status = STATUS_INVALID_PARAMETER;

        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
            "Another WDFQUEUE 0x%p is already configured for auto dispatching "
            "create request, %!STATUS!",
            m_DriverCreatedQueue->GetObjectHandle(), status);

        FxVerifierDbgBreakPoint(pFxDriverGlobals);
    }
    else {
        m_DriverCreatedQueue = TargetQueue;
    }

    Unlock(irql);

    return status;
}

Referenced by __drv_strictTypeMatch().

CreateCompleted()

VOID FxPkgGeneral::CreateCompleted

(

__in FxIrp *

Irp

)

Definition at line 1402 of file fxpkggeneral.cpp.

{
    NTSTATUS status = Irp->GetStatus();

    //
    // If the create is completed with error status,
    // we destroy the WDFFILEOBJECT since the IoMgr will destroy
    // the PFILE_OBJECT if the IRP_MJ_CREATE fails and wouldn't send
    // Cleanup or Close IRP.
    //
    if (!NT_SUCCESS(status)) {

        // Now destroy the WDFFILEOBJECT
        FxFileObject::_DestroyFileObject(
            m_Device,
            m_Device->GetFileObjectClass(),
            Irp->GetFileObject()
            );

        DecrementOpenHandleCount();
    }
}

Referenced by FxRequest::CompleteInternal().

DecrementOpenHandleCount()

VOID FxPkgGeneral::DecrementOpenHandleCount ( VOID  )

private

Definition at line 1976 of file fxpkggeneral.cpp.

{
    if (InterlockedDecrement(&m_OpenHandleCount) == 0 && m_Device->IsLegacy()) {
        m_Device->ControlDeviceDelete();
    }
}

Referenced by CreateCompleted(), OnClose(), and OnCreate().

Dispatch()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::Dispatch ( __inout MdIrp  Irp )

virtual

Definition at line 754 of file fxpkggeneral.cpp.

{
    NTSTATUS status;
    PFX_DRIVER_GLOBALS pFxDriverGlobals = GetDriverGlobals();
    FxIrp fxIrp(Irp);

    FX_TRACK_DRIVER(pFxDriverGlobals);

    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIO,
                        "WDFDEVICE 0x%p !devobj 0x%p %!IRPMJ! IRP 0x%p",
                        m_Device->GetHandle(), m_Device->GetDeviceObject(),
                        fxIrp.GetMajorFunction(), Irp);

    switch (fxIrp.GetMajorFunction()) {
    case IRP_MJ_CREATE:
        status = OnCreate(&fxIrp);
        break;

    case IRP_MJ_CLOSE:
        status = OnClose(&fxIrp);
        break;

    case IRP_MJ_CLEANUP:
        status = OnCleanup(&fxIrp);
        break;

    case IRP_MJ_SHUTDOWN:
        status = OnShutdown(&fxIrp);
        break;

    default:
        ASSERT(FALSE);
        status = STATUS_NOT_SUPPORTED;
        fxIrp.SetStatus(status);
        fxIrp.CompleteRequest(IO_NO_INCREMENT);
        break;
    }

    return status;
}

ForwardCreateRequest()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::ForwardCreateRequest ( __in FxIrp *  FxIrp, __in MdCompletionRoutine  CompletionRoutine, __in PVOID  Context  )

private

Definition at line 1384 of file fxpkggeneral.cpp.

{
    NTSTATUS status;

    Irp->CopyCurrentIrpStackLocationToNext();
    Irp->SetCompletionRoutineEx(m_Device->GetDeviceObject(),
                                 CompletionRoutine,
                                 Context);
    status = Irp->CallDriver(m_Device->GetAttachedDevice());

    return status;
}

Referenced by OnCreate().

GetCallbackLockPtrHelper()

FxCallbackLock * FxPkgGeneral::GetCallbackLockPtrHelper

(

__deref_out_opt FxObject **

LockObject

)

Definition at line 2032 of file fxpkggeneral.cpp.

{
    if (LockObject != NULL) {
        *LockObject = m_CallbackLockObjectPtr;
    }

    return m_CallbackLockPtr;
}

Referenced by FxFileObject::GetCallbackLockPtr().

GetConstraintsHelper()

VOID FxPkgGeneral::GetConstraintsHelper	(	__out_opt WDF_EXECUTION_LEVEL *	ExecutionLevel,
		__out_opt WDF_SYNCHRONIZATION_SCOPE *	SynchronizationScope
	)

Definition at line 2004 of file fxpkggeneral.cpp.

{
    if (ExecutionLevel != NULL) {
        *ExecutionLevel = m_ExecutionLevel;
    }

    if (SynchronizationScope != NULL) {
        *SynchronizationScope = m_SynchronizationScope;
    }
}

Referenced by FxFileObject::GetConstraints().

GetDeafultInternalCreateQueue()

__inline FxIoQueue* FxPkgGeneral::GetDeafultInternalCreateQueue ( )

inline

Definition at line 223 of file fxpkggeneral.hpp.

    {
        return m_DefaultQueueForCreates;
    }

Initialize()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::Initialize

(

__in PWDFDEVICE_INIT

DeviceInit

)

Definition at line 92 of file fxpkggeneral.cpp.

{
    NTSTATUS                    status;
    PLIST_ENTRY                 next;
    FxFileObjectInfo*           fileObjInfo;
    PFX_DRIVER_GLOBALS          fxDriverGlobals;

    fxDriverGlobals = GetDriverGlobals();

    //
    // Init file object info.
    //
    if (DeviceInit->FileObject.Set) {
        fileObjInfo = new(fxDriverGlobals) FxFileObjectInfo();
        if (fileObjInfo == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(fxDriverGlobals,
                                TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "Couldn't create object FileObjectInfo, "
                                "%!STATUS!", status);
            goto Done;
        }

        fileObjInfo->ClassExtension = FALSE;
        fileObjInfo->FileObjectClass = DeviceInit->FileObject.Class;
        fileObjInfo->Attributes = DeviceInit->FileObject.Attributes;

        fileObjInfo->AutoForwardCleanupClose =
            DeviceInit->FileObject.AutoForwardCleanupClose;

        fileObjInfo->EvtFileCreate.Method =
            DeviceInit->FileObject.Callbacks.EvtDeviceFileCreate;

        fileObjInfo->EvtFileCleanup.Method =
            DeviceInit->FileObject.Callbacks.EvtFileCleanup;

        fileObjInfo->EvtFileClose.Method =
            DeviceInit->FileObject.Callbacks.EvtFileClose;

        InsertTailList(&m_FileObjectInfoHeadList, &fileObjInfo->ListEntry);

        m_Flags |= FX_PKG_GENERAL_FLAG_CLIENT_INFO;

        if (fileObjInfo->EvtFileCreate.Method != NULL) {
            m_Flags |= FX_PKG_GENERAL_FLAG_CLIENT_CREATE;
        }
    }

    //
    // Build file object info chain for any class extension.
    //
    for (next = DeviceInit->CxDeviceInitListHead.Flink;
         next != &DeviceInit->CxDeviceInitListHead;
         next = next->Flink) {

        PWDFCXDEVICE_INIT cxInit;

        cxInit = CONTAINING_RECORD(next, WDFCXDEVICE_INIT, ListEntry);

        if (cxInit->FileObject.Set == FALSE) {
            continue;
        }

        fileObjInfo = new(fxDriverGlobals) FxFileObjectInfo();
        if (fileObjInfo == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(fxDriverGlobals,
                                TRACE_LEVEL_ERROR, TRACINGDEVICE,
                                "Couldn't create object FileObjectInfo, "
                                "%!STATUS!", status);
            goto Done;
        }

        fileObjInfo->ClassExtension = TRUE;
        fileObjInfo->FileObjectClass = cxInit->FileObject.Class;
        fileObjInfo->Attributes = cxInit->FileObject.Attributes;

        fileObjInfo->AutoForwardCleanupClose =
            cxInit->FileObject.AutoForwardCleanupClose;

        fileObjInfo->EvtCxFileCreate.Method =
            cxInit->FileObject.Callbacks.EvtCxDeviceFileCreate;

        fileObjInfo->EvtFileCleanup.Method =
            cxInit->FileObject.Callbacks.EvtFileCleanup;

        fileObjInfo->EvtFileClose.Method =
            cxInit->FileObject.Callbacks.EvtFileClose;

        fileObjInfo->CxDeviceInfo = cxInit->CxDeviceInfo;

        InsertTailList(&m_FileObjectInfoHeadList, &fileObjInfo->ListEntry);

        m_Flags |= FX_PKG_GENERAL_FLAG_CX_INFO;

        if (fileObjInfo->EvtCxFileCreate.Method != NULL) {
            m_Flags |= FX_PKG_GENERAL_FLAG_CX_CREATE;
        }
    }

    //
    // Nothing to do if list if empty.
    //
    if (IsListEmpty(&m_FileObjectInfoHeadList)) {
        status = STATUS_SUCCESS;
        goto Done;
    }

    //
    // We will enable this once the unlocking model is figured out.
    // It's not okay to sent request downstack with the presentation lock held.
    //
    status = ConfigureConstraints(&m_FileObjectInfoHeadList);
    if(!NT_SUCCESS(status)) {
        goto Done;
    }

    //
    // Configure file object class.
    //
    status = ConfigureFileObjectClass(&m_FileObjectInfoHeadList);
    if (!NT_SUCCESS(status)) {
        goto Done;
    }

    status = STATUS_SUCCESS;

Done:
    return status;
}

Referenced by FxDevice::CreateDevice().

OnCleanup()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::OnCleanup ( __inout FxIrp *  FxIrp )

private

Definition at line 1547 of file fxpkggeneral.cpp.

{
    NTSTATUS                status;
    FxFileObject*           pFxFO = NULL;
    WDFFILEOBJECT           hwdfFO = NULL;
    PLIST_ENTRY             next;
    FxFileObjectInfo*       fileObjInfo;
    MxFileObject            fileObject;






    //
    // Check to see if the fileobject represents a stream fileobject
    // created using IoCreateStreamFileObjectLite.
    //
    fileObject.SetFileObject(FxIrp->GetFileObject());
    if (FxIrp->GetFileObject() &&
        (fileObject.GetFlags() & FO_STREAM_FILE)){
        status = STATUS_SUCCESS;
        goto Passthru;
    }

    status = FxFileObject::_GetFileObjectFromWdm(
                 m_Device,
                 m_Device->GetFileObjectClass(),
                 FxIrp->GetFileObject(),
                 &pFxFO
                 );

    ASSERT(status == STATUS_SUCCESS);

    if (pFxFO != NULL && NT_SUCCESS(status)) {
        hwdfFO = pFxFO->GetHandle();
    }

    //
    // Invoke cleanup callbacks.
    //
    if (NULL == pFxFO) {
        //
        // Invoke cleanup callbacks of next layer (cx or client driver) based on the
        // autoforward setting of previous layer. (top to bottom).
        // AutoforwardCleanupClose set to FALSE with a not null create callback
        // means that create request was never forwarded to lower layer.
        //
        for (next = m_FileObjectInfoHeadList.Blink;
             next != &m_FileObjectInfoHeadList;
             next = next->Blink) {

             fileObjInfo = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);

             if (WdfFalse == fileObjInfo->AutoForwardCleanupClose &&
                 fileObjInfo->EvtCxFileCreate.Method != NULL) {
                 next = next->Blink; // one before the real start entry.
                 break;
             }
         }
     }
     else {
         //
         // 'OnCreate' sets this package context.
         //
         next = (PLIST_ENTRY) pFxFO->GetPkgCleanupCloseContext();
         if (NULL == next) {
             next = &m_FileObjectInfoHeadList;
         }
     }

    //
    // Invoke cleanup callbacks only if this layer (cx or client driver) had the
    // opprtunity to see the create request.
    //
    for (next = next->Flink;
         next != &m_FileObjectInfoHeadList;
         next = next->Flink) {

         fileObjInfo = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);
         fileObjInfo->EvtFileCleanup.Invoke(hwdfFO);
    }

    //
    // hwdfFO could be NULL depending on the FileObjectClass
    //

    //
    // Scan all the I/O queues associated with this device
    // and cancel the requests that matches with the handle
    // being closed. We will be able to cancel only requests that
    // are waiting to be dispatched. If the requests are already
    // presented to the driver then it's the responsibility of the
    // driver to complete them when the cleanup callback is invoked.
    //
    if(FxIrp->GetFileObject() != NULL ) {
        FxPkgIo*   pPkgIo;

        pPkgIo = (FxPkgIo*)m_Device->m_PkgIo;
        pPkgIo->FlushAllQueuesByFileObject(FxIrp->GetFileObject());
    }

Passthru:
    if (m_Device->m_AutoForwardCleanupClose) {
        FxIrp->SkipCurrentIrpStackLocation();
        status = FxIrp->CallDriver(m_Device->GetAttachedDevice());
    } else {
        FxIrp->SetStatus(status);
        FxIrp->SetInformation(0);
        FxIrp->CompleteRequest(IO_NO_INCREMENT);
    }

    return status;

}

Referenced by Dispatch().

OnClose()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::OnClose ( __inout FxIrp *  FxIrp )

private

Definition at line 1688 of file fxpkggeneral.cpp.

{
    NTSTATUS                status;
    FxFileObject*           pFxFO = NULL;
    WDFFILEOBJECT           hwdfFO = NULL;
    BOOLEAN                 isStreamFileObject = FALSE;
    BOOLEAN                 acquiredRemLock = FALSE;
    PLIST_ENTRY             next;
    FxFileObjectInfo*       fileObjInfo;
    MxFileObject            fileObject;
    MdIrp                   irp;

    //
    // FxIrp.CompleteRequest NULLs the m_Irp so store m_Irp separately
    // for use in ReleaseRemoveLock.
    //
    irp = FxIrp->GetIrp();

    //
    // Check to see if the fileobject represents a stream fileobject
    // created using IoCreateStreamFileObjectLite. If so, this is a
    // is spurious close sent by the I/O manager when it invalidates
    // the volumes (IopInvalidateVolumesForDevice).
    //
    fileObject.SetFileObject(FxIrp->GetFileObject());
    if (FxIrp->GetFileObject() &&
        (fileObject.GetFlags() & FO_STREAM_FILE)){
        isStreamFileObject = TRUE;
        status = STATUS_SUCCESS;
        goto Passthru;
    }

    status = FxFileObject::_GetFileObjectFromWdm(
        m_Device,
        m_Device->GetFileObjectClass(),
        FxIrp->GetFileObject(),
        &pFxFO
        );

    ASSERT(status == STATUS_SUCCESS);

    if (pFxFO != NULL && NT_SUCCESS(status)) {
        hwdfFO = pFxFO->GetHandle();
    }

    //
    // Invoke close callbacks.
    //
    if (NULL == pFxFO) {
        //
        // Invoke close callbacks of next layer (cx or client driver)  based on the autoforward
        // setting of previous layer. (top to bottom).
        // AutoforwardCleanupClose set to FALSE with a not null create callback
        // means that create request was never forwarded to lower layer.
        //
        for (next = m_FileObjectInfoHeadList.Blink;
             next != &m_FileObjectInfoHeadList;
             next = next->Blink) {

            fileObjInfo = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);

            if (WdfFalse == fileObjInfo->AutoForwardCleanupClose &&
                fileObjInfo->EvtCxFileCreate.Method != NULL) {
                next = next->Blink; // one before the real start entry.
                break;
            }
        }
    }
    else {
        //
        // 'OnCreate' sets this package context.
        //
        next = (PLIST_ENTRY) pFxFO->GetPkgCleanupCloseContext();
        if (NULL == next) {
            next = &m_FileObjectInfoHeadList;
        }
    }

    //
    // Invoke close callbacks only if this layer (cx or client driver) had the opprtunity
    // to see the create request.
    //
    for (next = next->Flink;
         next != &m_FileObjectInfoHeadList;
         next = next->Flink) {

         fileObjInfo = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);
         fileObjInfo->EvtFileClose.Invoke(hwdfFO);
    }

    //
    // Destroy the WDFFILEOBJECT. This will result in
    // fileobject EvtCleanup and EvtDestroy event.
    //
    FxFileObject::_DestroyFileObject(
        m_Device,
        m_Device->GetFileObjectClass(),
        FxIrp->GetFileObject()
        );

Passthru:

    if (m_Device->m_AutoForwardCleanupClose) {
        FxIrp->SkipCurrentIrpStackLocation();
        status = FxIrp->CallDriver(m_Device->GetAttachedDevice());
    } else {
        //
        // We're about to complete the request, but we need to decrement the
        // open handle count after we complete the request. However, completing
        // the request immediately opens the gate for the remove IRP to arrive
        // and run down the device. Hence we'll acquire the remove lock in order
        // to ensure that the device is not removed before we've decremented the
        // open handle count.
        //
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
        acquiredRemLock = AcquireRemoveLockForClose(FxIrp);
#endif
        FxIrp->SetStatus(status);
        FxIrp->SetInformation(0);
        FxIrp->CompleteRequest(IO_NO_INCREMENT);
    }

    if (isStreamFileObject == FALSE) {
        //
        // Note that after this call returns, this object may have been deleted!








        DecrementOpenHandleCount();
    }

    if (acquiredRemLock) {
        Mx::MxReleaseRemoveLock(m_Device->GetRemoveLock(),
                                irp);
    }

    return status;

}

Referenced by Dispatch().

OnCreate()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::OnCreate ( __inout FxIrp *  FxIrp )

private

Definition at line 813 of file fxpkggeneral.cpp.

{
    NTSTATUS                    status;
    FxFileObject*               pFxFO ;
    WDFFILEOBJECT               hwdfFO;
    FxRequest *                 pRequest;
    PFX_DRIVER_GLOBALS          pFxDriverGlobals;
    MdFileObject                fileObject;
    LONG                        count;
    BOOLEAN                     inCriticalRegion;
    BOOLEAN                     inDefaultQueue;
    FxFileObjectInfo*           fileObjInfo;
    WDF_OBJECT_ATTRIBUTES       attributes;
    PLIST_ENTRY                 next;

    pFxFO = NULL;
    hwdfFO = NULL;
    pRequest = NULL;
    inCriticalRegion = FALSE;
    inDefaultQueue = FALSE;
    pFxDriverGlobals = GetDriverGlobals();
    fileObject = FxIrp->GetFileObject();
    fileObjInfo = NULL;

    //
    // Check for exclusivity.
    //
    count = InterlockedIncrement(&m_OpenHandleCount);

    //
    // The count is biased by one to help track when to delete the control
    // device, so we need to check for 2, not 1.
    //
    if (m_Device->IsExclusive() && count > 2) {
       DoTraceLevelMessage(
           pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
           "Exclusive WDFDEVICE 0x%p, only one open handle is allowed",
           m_Device->GetHandle());
       status =  STATUS_ACCESS_DENIED;
       goto Error;
    }

    // ------------------------------------------------------------------------
    //
    // Create WDFFILEOBJECT. By default we allocate the root driver's file obj
    // context; then we attach the other file obj contexts.
    //

    //
    // Init the file obj's attributes. Use default if not present (legacy behavior).
    //
    WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
    if (!IsListEmpty(&m_FileObjectInfoHeadList)) {
        //
        // file obj info is set, use the top most driver's info, i.e., cx if present.
        //
        fileObjInfo = CONTAINING_RECORD(m_FileObjectInfoHeadList.Blink,
                                        FxFileObjectInfo,
                                        ListEntry);

        //
        // Use this layer's attributes if present.
        // Size is zero if driver didn't specify file object's attributes.
        //
        if (0 != fileObjInfo->Attributes.Size) {
            ASSERT(fileObjInfo->Attributes.Size == sizeof(WDF_OBJECT_ATTRIBUTES));
            attributes = fileObjInfo->Attributes;
        }

        //
        // Use computed constraint settings.
        //
        attributes.ExecutionLevel = m_ExecutionLevel;
        attributes.SynchronizationScope = m_SynchronizationScope;
    }

    //
    // Create the file object.
    //
    status = FxFileObject::_CreateFileObject(
        m_Device,
        FxIrp->GetIrp(),
        m_Device->GetFileObjectClass(),
        &attributes,
        fileObject,
        &pFxFO
        );

    if (!NT_SUCCESS(status) ) {
        DoTraceLevelMessage(
            pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
            "Could not create WDFFILEOBJECT for WDFDEVICE 0x%p, failing "
            "IRP_MJ_CREATE %!STATUS!", m_Device->GetHandle(), status);
        goto Error;
    }

    if (pFxFO != NULL) {
        hwdfFO = pFxFO->GetHandle();

        //
        // If any, attach the file obj's contexts of the other drivers in this chain.
        //
        for (next = m_FileObjectInfoHeadList.Blink->Blink; // skip one.
             next != &m_FileObjectInfoHeadList;
             next = next->Blink) {

            fileObjInfo = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);

            attributes = fileObjInfo->Attributes;

            //
            // Size is zero if driver didn't specify file object's attributes.
            //
            if (0 == attributes.Size) {
                continue;
            }

            //
            // Don't need these settings for extra contexts.
            //
            attributes.ExecutionLevel = WdfExecutionLevelInheritFromParent;
            attributes.SynchronizationScope = WdfSynchronizationScopeInheritFromParent;
            attributes.ParentObject = NULL;

            status = FxObjectAllocateContext(pFxFO,
                                             &attributes,
                                             TRUE,
                                             NULL);
            if(!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                    "Couldn't allocate file object context 0x%p for "
                    "device 0x%p - driver 0x%p, %!STATUS!",
                    &fileObjInfo->Attributes,
                    m_Device->GetHandle(),
                    m_Device->GetCxDriver(fileObjInfo->CxDeviceInfo)->GetHandle(),
                    status
                    );

                goto Error;
            }
        }
    }

    // ------------------------------------------------------------------------
    //
    // If there is no driver configured queue or m_EvtFileCreate is not registered,
    // complete the request with status-success. The reason for making this
    // check after creating the fileobject is to  allow WdfRequestGetFileObject even
    // if the driver hasn't registered any file-event callbacks.
    //
    if (m_DriverCreatedQueue == NULL &&
        (m_Flags & FX_PKG_GENERAL_FLAG_CREATE) == 0) {

        //
        // Check to see if the driver has opted to autoforward cleanup and close.
        // If so, we should forward create requests also. Else, we should
        // complete the request with STATUS_SUCCESS. Note, if the driver is
        // a filter driver, the default value of m_AutoForwardCleanupClose is TRUE.
        //
        //
        if (m_Device->m_AutoForwardCleanupClose) {
            status = ForwardCreateRequest(FxIrp, _CreateCompletionRoutine, this);
            //
            // _CreateCompletionRoutine will do the cleanup when the request is
            // completed with error status by the lower driver.
            //
        }
        else {
            status = STATUS_SUCCESS;
            FxIrp->SetStatus(status);
            FxIrp->SetInformation(0);
            FxIrp->CompleteRequest(IO_NO_INCREMENT);
        }

       goto RequestIsGone;
    }

    // ------------------------------------------------------------------------
    //
    // Create a FxRequest for this IRP. By default we allocate the top most driver's request
    // context; then we attach the other request contexts.
    //

    //
    // Init the request's attributes.
    //
    if (!IsListEmpty(&m_FileObjectInfoHeadList)) {
        //
        // file obj info is set, use the top most driver's info, i.e., cx if present.
        //
        fileObjInfo = CONTAINING_RECORD(m_FileObjectInfoHeadList.Blink,
                                        FxFileObjectInfo,
                                        ListEntry);
        if (fileObjInfo->ClassExtension) {
            attributes = fileObjInfo->CxDeviceInfo->RequestAttributes;
        }
        else {
            attributes = *m_Device->GetRequestAttributes();
        }
    }
    else {
        attributes = *m_Device->GetRequestAttributes();
    }

    if (m_Device->IsCxInIoPath()) {
        //
        // Apply cx's constrains for create requests:
        //
        attributes.ExecutionLevel = WdfExecutionLevelDispatch;
        attributes.SynchronizationScope = WdfSynchronizationScopeNone;
        attributes.ParentObject = NULL;
    }

    //
    // Create the request.
    //
    status = FxRequest::_CreateForPackage(m_Device,
                                          &attributes,
                                          FxIrp->GetIrp(),
                                          &pRequest);
    if(!NT_SUCCESS(status)) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Could not create request for WDFDEVICE 0x%p, %!STATUS!",
                            m_Device->GetHandle(), status);
        goto Error;
    }

    //
    // If any, attach the request's contexts of the other drivers in this chain.
    //
    for (next = m_FileObjectInfoHeadList.Blink->Blink; // skip one.
         next != &m_FileObjectInfoHeadList;
         next = next->Blink) {

        fileObjInfo = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);

        if (fileObjInfo->ClassExtension) {
            attributes = fileObjInfo->CxDeviceInfo->RequestAttributes;
        }
        else {
            attributes = *m_Device->GetRequestAttributes();
        }

        //
        // Size is zero if driver didn't specify request's attributes.
        //
        if (0 == attributes.Size) {
            continue;
        }

        //
        // Don't need these settings for extra contexts.
        //
        attributes.ExecutionLevel = WdfExecutionLevelInheritFromParent;
        attributes.SynchronizationScope = WdfSynchronizationScopeInheritFromParent;
        attributes.ParentObject = NULL;

        status = FxObjectAllocateContext(
                            pRequest,
                            &attributes,
                            TRUE,
                            NULL);

        if(!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                "Couldn't allocate request context for "
                "device 0x%p - driver 0x%p, %!STATUS!",
                m_Device->GetHandle(),
                m_Device->GetCxDriver(fileObjInfo->CxDeviceInfo)->GetHandle(),
                status
                );

            goto Error;
        }
    }

    //
    // Disable thread suspension beyond this point by entering critical region.
    //
    if (Mx::MxGetCurrentIrql() <= APC_LEVEL)
    {
        Mx::MxEnterCriticalRegion();
        inCriticalRegion = TRUE;
    }

    // ------------------------------------------------------------------------
    //
    // Queue request in default queue before invoking cx or client's create callbacks.
    //
    if ((m_Flags & FX_PKG_GENERAL_FLAG_CX_CREATE) ||
        m_DriverCreatedQueue == NULL) {

        FxRequest* outputRequest;

        ASSERT(m_Flags & FX_PKG_GENERAL_FLAG_CREATE);

        //
        // Make sure we are calling FileEvents at the right IRQL level.
        //
        if (m_ExecutionLevel ==  WdfExecutionLevelPassive &&
            Mx::MxGetCurrentIrql() >= DISPATCH_LEVEL) {

            status = STATUS_INVALID_DEVICE_REQUEST;
            DoTraceLevelMessage(
                pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                "WDFDEVICE 0x%p cannot handle create request at or above "
                "dispatch-level, fail the Irp: 0x%p, %!STATUS!",
                m_Device->GetObjectHandle(), FxIrp->GetIrp(), status);

            goto Error;
        }

        //
        // Now queue and immediately retrieve the request by FileObject.
        // QueueRequest will return an error if the queue is not accepting request
        // or the request is already cancelled. Either way, the request is completed by
        // the FxIoQueue.
        //
        status = m_DefaultQueueForCreates->QueueRequest(pRequest);
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                    "Couldn't forward request to the WDFQUEUE 0x%p, %!STATUS!",
                    m_DefaultQueueForCreates->GetObjectHandle(), status);
            goto RequestIsGone;
        }

        status = m_DefaultQueueForCreates->GetRequest(fileObject,
                                                      NULL,
                                                      &outputRequest);
        if (!NT_SUCCESS(status)) {
            //
            // Oops, request got cancelled and completed by another thread.
            //
            ASSERT(status == STATUS_NO_MORE_ENTRIES);
            status = STATUS_PENDING; // IRP was already marked pending.
            goto RequestIsGone;
        }

        ASSERT(outputRequest == pRequest);

        inDefaultQueue = TRUE;
    }

    // ------------------------------------------------------------------------
    //
    // Invoke Cx's create callbacks.  Here we add the cx's file obj and request contexts.
    //
    if (m_Flags & FX_PKG_GENERAL_FLAG_CX_CREATE) {

        //
        // Loop through all cx's file obj info.
        //
        for (next = m_FileObjectInfoHeadList.Blink;
             next != &m_FileObjectInfoHeadList;
             next = next->Blink) {

            //
            // Get ready to invoke next layer cx's create.
            //
            fileObjInfo = CONTAINING_RECORD(next, FxFileObjectInfo, ListEntry);

            //
            // Do not invoke the client driver's create callback (if any). For compatibility
            // we need to check first the driver 'create' queue.
            //
            if (FALSE == fileObjInfo->ClassExtension) {
                break;
            }

            ASSERT(fileObjInfo->EvtFileCreate.Method == NULL);
            ASSERT(fileObjInfo->EvtCxFileCreate.Method != NULL);

            //
            // Keep track where we stopped (end, not inclusive node).
            // Note that we cannot do this after the Invoke b/c File Object
            // may be gone by the time callback returns.
            //
            if (pFxFO) {
                pFxFO->SetPkgCleanupCloseContext(next->Blink);
            }

            //
            // Invoke knows how to handle NULL callbacks.
            //
            if (fileObjInfo->EvtCxFileCreate.Invoke(
                                m_Device->GetHandle(),
                                (WDFREQUEST)pRequest->GetObjectHandle(),
                                hwdfFO)) {
                //
                // Callback claimed the request.
                //
                status = STATUS_PENDING; // IRP was already marked pending.
                goto RequestIsGone;
            }
        }
    }

    //-------------------------------------------------------------------------
    //
    // First check for driver configured queue. If there is one, dispatch the request
    // to that queue.
    //
    if (m_DriverCreatedQueue != NULL) {
        if (inDefaultQueue) {
            ASSERT(m_Flags & FX_PKG_GENERAL_FLAG_CX_INFO);

            status = m_DefaultQueueForCreates->ForwardRequest(
                                m_DriverCreatedQueue,
                                pRequest);

            if(!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                    "Couldn't forward request to the WDFQUEUE 0x%p, %!STATUS!",
                    m_DriverCreatedQueue->GetObjectHandle(), status);

                pRequest->Complete(status);
            }

            status = STATUS_PENDING; // IRP was already marked pending.
            goto RequestIsGone;
        }
        else {
            ASSERT(pRequest->GetRefCnt() == 1);
            //
            // QueueRequest will return an error if the queue is not accepting request
            // or the request is already cancelled. Either way, the request is completed by
            // the FxIoQueue.
            //
            status = m_DriverCreatedQueue->QueueRequest(pRequest);
            if(!NT_SUCCESS(status)) {
                DoTraceLevelMessage(
                    pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                    "Couldn't forward request to the WDFQUEUE 0x%p, %!STATUS!",
                    m_DriverCreatedQueue->GetObjectHandle(), status);
            }

            goto RequestIsGone;
        }
    }

    //-------------------------------------------------------------------------
    //
    // At this point invoke the client driver callback if present.
    //
    if (m_Flags & FX_PKG_GENERAL_FLAG_CLIENT_CREATE) {
        ASSERT(m_Flags & FX_PKG_GENERAL_FLAG_CLIENT_INFO);
        ASSERT(TRUE == inDefaultQueue);
        ASSERT(fileObjInfo->EvtFileCreate.Method != NULL);
        ASSERT(fileObjInfo->EvtCxFileCreate.Method == NULL);

        //
        // Invoke the client driver create requests.
        //
        fileObjInfo->EvtFileCreate.Invoke(
                            m_Device->GetHandle(),
                            (WDFREQUEST)pRequest->GetObjectHandle(),
                            hwdfFO);
        //
        // QueueRequest has already marked the request pending.
        //
        status = STATUS_PENDING;
        goto RequestIsGone;
    }

    //
    // We should be here only if CX's create returned 'continue' but client didn't have
    // a create callback.
    //
    ASSERT(m_Flags & FX_PKG_GENERAL_FLAG_CX_INFO);

    //
    // Check to see if the driver has opted to autoforward cleanup and close.
    // If so, we should forward create requests to lower drivers. Else, we should
    // complete the request with STATUS_SUCCESS. Note, if the driver is
    // a filter driver, the default value of m_AutoForwardCleanupClose is TRUE.
    //
    if (m_Device->m_AutoForwardCleanupClose) {
        (void)ForwardCreateRequest(FxIrp, _CreateCompletionRoutine2, pRequest);
        //
        // _CreateCompletionRoutine2 will complete the WDF request.
        //
    }
    else {
        pRequest->Complete(STATUS_SUCCESS);
    }

    //
    // Done processing this request.
    //
    status = STATUS_PENDING; // IRP was already marked pending.
    goto RequestIsGone;

Error:
    if (pRequest != NULL) {
        pRequest->DeleteFromFailedCreate();
        pRequest = NULL;
    }

    ASSERT(!NT_SUCCESS(status));

    if (pFxFO != NULL) {
        pFxFO->DeleteFileObjectFromFailedCreate();
        pFxFO = NULL;
    }

    //
    // NOTE:  after this call, this object may have been deleted!
    //
    DecrementOpenHandleCount();

    FxIrp->SetStatus(status);
    FxIrp->SetInformation(0);
    FxIrp->CompleteRequest(IO_NO_INCREMENT);

    // fallthrough

RequestIsGone:

    //
    // We have lost the ownership of the request. We have either successfully
    // presented the request to the driver or the queue function we called to
    // present the request returned error but completed the FxRequest on its own.
    // Either way we don't need to worry about cleaning up the resources
    // (fileobject, handle-count, etc) because the FxRequest:Completion routine
    // will call FxPkgGeneral::CreateCompleted to post process IRP upon completion.
    //
    if (inCriticalRegion) {
        Mx::MxLeaveCriticalRegion();
    }

    return status;
}

Referenced by Dispatch().

OnShutdown()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::OnShutdown ( __inout FxIrp *  FxIrp )

private

Definition at line 1939 of file fxpkggeneral.cpp.

{
    NTSTATUS status;

    m_EvtDeviceShutdown.Invoke(m_Device->GetHandle());

    if(m_Device->IsFilter()) {
        FxIrp->SkipCurrentIrpStackLocation();
        status = FxIrp->CallDriver(m_Device->GetAttachedDevice());
    }
    else {
        status = STATUS_SUCCESS;
        FxIrp->SetStatus(status);
        FxIrp->SetInformation(0);
        FxIrp->CompleteRequest(IO_NO_INCREMENT);
    }

    return status;

}

Referenced by Dispatch().

PostCreateDeviceInitialize()

_Must_inspect_result_ NTSTATUS FxPkgGeneral::PostCreateDeviceInitialize

(

__in PWDFDEVICE_INIT

Init

)

Definition at line 591 of file fxpkggeneral.cpp.

{
    MdDeviceObject pDevice;
    NTSTATUS status;
    WDF_IO_QUEUE_CONFIG queueConfig;
    WDF_OBJECT_ATTRIBUTES attributes;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;

    pFxDriverGlobals = GetDriverGlobals();
    status = STATUS_SUCCESS;




#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
    if (Init->Control.Flags != 0) {
        pDevice = m_Device->GetDeviceObject();

        if (Init->Control.Flags & WdfDeviceShutdown) {
            status = IoRegisterShutdownNotification(pDevice);
        }

        if (NT_SUCCESS(status) &&
            (Init->Control.Flags & WdfDeviceLastChanceShutdown)) {
            status = IoRegisterLastChanceShutdownNotification(pDevice);

        }

        if (NT_SUCCESS(status)) {
            //
            // IoDeleteDevice will automatically unregister the shutdown
            // notifications if the device is deleted before the machine is
            // shutdown, so we don't need to track registration beyond this point.
            //
            m_EvtDeviceShutdown.m_Method = Init->Control.ShutdownNotification;
        }
        else {
            //
            // This unregisters both the normal and last chance notifications
            //
            IoUnregisterShutdownNotification(pDevice);
        }
    }
#else
    UNREFERENCED_PARAMETER(Init);
    UNREFERENCED_PARAMETER(pDevice);
#endif

    if (NT_SUCCESS(status) && (m_Flags & FX_PKG_GENERAL_FLAG_CREATE)) {
        //
        // Create an internal queue to track create requests presented to the driver.
        // This special queue is used so that we can invoke the events in the context
        // of the caller.
        //
        WDF_IO_QUEUE_CONFIG_INIT(&queueConfig, WdfIoQueueDispatchManual);

        //
        // non power managed queue because we don't anticipate drivers touching
        // hardware in the fileevent callbacks. If they do, then they should make sure
        // to power up the device.
        //
        queueConfig.PowerManaged = WdfFalse;

        //
        // Queue inherits the sync & exec level of fileobject.
        //
        WDF_OBJECT_ATTRIBUTES_INIT(&attributes);
        attributes.ExecutionLevel = m_ExecutionLevel;
        attributes.SynchronizationScope = m_SynchronizationScope;

        status = m_Device->m_PkgIo->CreateQueue(&queueConfig,
                                                &attributes,
                                                NULL,
                                                &m_DefaultQueueForCreates);

        if (!NT_SUCCESS(status)) {
           DoTraceLevelMessage(
               pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
               "Unable to create an internal queue for creates for WDFDEVICE "
               "0x%p, %!STATUS!", m_Device->GetHandle(), status);
           return status;
        }
    }

    return status;
}

Referenced by FxDevice::ControlDeviceInitialize(), FxDevice::FdoInitialize(), and FxDevice::PdoInitialize().

Member Data Documentation

_CreateCompletionRoutine

_Must_inspect_result_ NTSTATUS FxPkgGeneral::_CreateCompletionRoutine

staticprivate

Definition at line 161 of file fxpkggeneral.hpp.

Referenced by OnCreate().

_CreateCompletionRoutine2

_Must_inspect_result_ NTSTATUS FxPkgGeneral::_CreateCompletionRoutine2

staticprivate

Definition at line 164 of file fxpkggeneral.hpp.

Referenced by OnCreate().

m_CallbackLockObjectPtr

FxObject* FxPkgGeneral::m_CallbackLockObjectPtr

private

Definition at line 101 of file fxpkggeneral.hpp.

Referenced by ConfigureConstraints(), FxPkgGeneral(), and GetCallbackLockPtrHelper().

m_CallbackLockPtr

FxCallbackLock* FxPkgGeneral::m_CallbackLockPtr

private

Definition at line 100 of file fxpkggeneral.hpp.

Referenced by ConfigureConstraints(), FxPkgGeneral(), and GetCallbackLockPtrHelper().

m_DefaultQueueForCreates

FxIoQueue* FxPkgGeneral::m_DefaultQueueForCreates

private

Definition at line 80 of file fxpkggeneral.hpp.

Referenced by FxPkgGeneral(), GetDeafultInternalCreateQueue(), OnCreate(), and PostCreateDeviceInitialize().

m_DriverCreatedQueue

FxIoQueue* FxPkgGeneral::m_DriverCreatedQueue

private

Definition at line 81 of file fxpkggeneral.hpp.

Referenced by ConfigureForwarding(), FxPkgGeneral(), and OnCreate().

m_EvtDeviceShutdown

FxShutDown FxPkgGeneral::m_EvtDeviceShutdown

private

Definition at line 103 of file fxpkggeneral.hpp.

Referenced by OnShutdown(), and PostCreateDeviceInitialize().

m_ExecutionLevel

WDF_EXECUTION_LEVEL FxPkgGeneral::m_ExecutionLevel

private

Definition at line 91 of file fxpkggeneral.hpp.

Referenced by ConfigureConstraints(), FxPkgGeneral(), GetConstraintsHelper(), OnCreate(), and PostCreateDeviceInitialize().

m_FileObjectInfoHeadList

LIST_ENTRY FxPkgGeneral::m_FileObjectInfoHeadList

private

Definition at line 78 of file fxpkggeneral.hpp.

Referenced by FxPkgGeneral(), Initialize(), OnCleanup(), OnClose(), OnCreate(), and ~FxPkgGeneral().

m_Flags

ULONG FxPkgGeneral::m_Flags

private

Definition at line 86 of file fxpkggeneral.hpp.

Referenced by FxPkgGeneral(), Initialize(), OnCreate(), and PostCreateDeviceInitialize().

m_OpenHandleCount

LONG FxPkgGeneral::m_OpenHandleCount

private

Definition at line 73 of file fxpkggeneral.hpp.

Referenced by CanDestroyControlDevice(), DecrementOpenHandleCount(), FxPkgGeneral(), OnCreate(), and ~FxPkgGeneral().

m_SynchronizationScope

WDF_SYNCHRONIZATION_SCOPE FxPkgGeneral::m_SynchronizationScope

private

Definition at line 92 of file fxpkggeneral.hpp.

Referenced by ConfigureConstraints(), FxPkgGeneral(), GetConstraintsHelper(), OnCreate(), and PostCreateDeviceInitialize().

---

The documentation for this class was generated from the following files:

• sdk/lib/drivers/wdf/shared/inc/private/common/fxpkggeneral.hpp
• sdk/lib/drivers/wdf/shared/irphandlers/general/fxpkggeneral.cpp