FxObject Class Reference

#include <fxobject.hpp>

Inheritance diagram for FxObject:

Collaboration diagram for FxObject:

Public Member Functions
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)

Static Public Member Functions
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
	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
static PVOID	_GetBase (__in FxObject *Object)

Protected Attributes
union {
CfxDeviceBase *   m_DeviceBase
CfxDevice *   m_Device
};

Private Member Functions
	FxObject (VOID)
	FX_DECLARE_VF_FUNCTION_P1 (VOID, VerifyConstruct, _In_ BOOLEAN)
VOID __inline	Construct (__in BOOLEAN Embedded)
VOID __inline	SetObjectStateLocked (__in FxObjectState NewState)
VOID	FinalRelease (VOID)
BOOLEAN	MarkDeleteCalledLocked (VOID)
BOOLEAN	IsPassiveCallbacksLocked (VOID)
BOOLEAN	IsPassiveDisposeLocked (VOID)
BOOLEAN	IsForceDisposeThreadLocked (VOID)
BOOLEAN	ShouldDeferDisposeLocked (__out_opt PKIRQL PreviousIrql=NULL)
VOID	ParentDeleteEvent (VOID)
BOOLEAN	PerformEarlyDispose (VOID)
	_Releases_lock_ (this->m_SpinLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) BOOLEAN PerformEarlyDisposeWorkerAndUnlock(__in __drv_restoresIRQL KIRQL OldIrql
	_Releases_lock_ (this->m_SpinLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) BOOLEAN PerformDisposingDisposeChildrenLocked(__in __drv_restoresIRQL KIRQL OldIrql
	_Releases_lock_ (this->m_SpinLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) BOOLEAN DeleteWorkerAndUnlock(__in __drv_restoresIRQL KIRQL OldIrql
VOID	QueueDeferredDisposeLocked (__in FxObjectState NewDeferedState)
VOID	DeferredDisposeWorkItem (VOID)
	_Releases_lock_ (this->m_SpinLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) BOOLEAN DisposeChildrenWorker(__in FxObjectState NewDeferedState
	_When_ (Unlock, _Releases_lock_(this->m_SpinLock.m_Lock)) __drv_when(Unlock
	__drv_requiresIRQL (DISPATCH_LEVEL)) VOID DeletedAndDisposedWorkerLocked(__in __drv_when(Unlock
_Must_inspect_result_ NTSTATUS	RemoveParentAssociation (VOID)
_Must_inspect_result_ NTSTATUS	AddChildObjectInternal (__in FxObject *ChildObject)
_Must_inspect_result_ NTSTATUS	RemoveChildObjectInternal (__in FxObject *ChildObject)
VOID	ProcessDestroy (VOID)
VOID	CallCleanupCallbacks (VOID)

Private Attributes
friend	UfxObject
friend	FxDisposeList
PVOID	m_COMWrapper
WDFTYPE	m_Type
USHORT	m_ObjectSize
LONG	m_Refcnt
PFX_DRIVER_GLOBALS	m_Globals
union {
USHORT   m_ObjectFlags
struct {
USHORT   PassiveCallbacks: 1
USHORT   NoDeleteDDI: 1
USHORT   DeleteCalled: 1
USHORT   Committed: 1
USHORT   PassiveDispose: 1
USHORT   ForceDisposeThread: 1
USHORT   Unused: 1
USHORT   HasDebug: 1
USHORT   EarlyDisposedExt: 1
USHORT   TraceState: 1
}   m_ObjectFlagsByName
};
USHORT	m_ObjectState
LIST_ENTRY	m_ChildListHead
MxLock	m_SpinLock
FxObject *	m_ParentObject
LIST_ENTRY	m_ChildEntry
SINGLE_LIST_ENTRY	m_DisposeSingleEntry
__in BOOLEAN	CanDefer
__in __drv_restoresIRQL KIRQL	OldIrql
__in __drv_restoresIRQL KIRQL __in BOOLEAN	CanDefer
__drv_restoresIRQL KIRQL	OldIrql
__drv_restoresIRQL KIRQL __in BOOLEAN	Unlock

Friends
VOID	GetTriageInfo (VOID)

Detailed Description

Definition at line 232 of file fxobject.hpp.

Constructor & Destructor Documentation

FxObject() [1/3]

FxObject::FxObject ( VOID  )

inlineprivate

Definition at line 333 of file fxobject.hpp.

    {
        // Always make the caller supply a type and size
    }

FxObject() [2/3]

FxObject::FxObject ( __in WDFTYPE  Type, __in USHORT  Size, __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in FxObjectType  ObjectType  )

protected

Definition at line 68 of file fxobject.cpp.

      :
    m_Type(Type),
    m_ObjectSize((USHORT) WDF_ALIGN_SIZE_UP(Size, MEMORY_ALLOCATION_ALIGNMENT)),
    m_Globals(FxDriverGlobals)
{
     if (ObjectType != FxObjectTypeEmbedded) {
         //
         // only for non embedded objects
         //
         ASSERT((((ULONG_PTR) this) & FxHandleFlagMask) == 0x0);
     }
 
    Construct(ObjectType == FxObjectTypeEmbedded ? TRUE : FALSE);
}

FxObject() [3/3]

FxObject::FxObject	(	__in WDFTYPE	Type,
		__in USHORT	Size,
		__in PFX_DRIVER_GLOBALS	FxDriverGlobals
	)

Definition at line 49 of file fxobject.cpp.

      :
    m_Type(Type),
    m_ObjectSize((USHORT) WDF_ALIGN_SIZE_UP(Size, MEMORY_ALLOCATION_ALIGNMENT)),
    m_Globals(FxDriverGlobals)
#if FX_CORE_MODE==FX_CORE_USER_MODE
#ifndef INLINE_WRAPPER_ALLOCATION
    ,m_COMWrapper(NULL)
#endif
#endif
{
    ASSERT((((ULONG_PTR) this) & FxHandleFlagMask) == 0x0);
 
    Construct(FALSE);
}

~FxObject()

FxObject::~FxObject ( VOID  )

virtual

Definition at line 88 of file fxobject.cpp.

{
    FxTagTracker *pTagTracker;
 
 
 
 
 
 
 
    pTagTracker = GetTagTracker();
 
    if (pTagTracker != NULL) {
        delete pTagTracker;
    }
 
    ASSERT(m_DisposeSingleEntry.Next == NULL);
 
    //
    // We need to ensure there are no leaked child objects, or
    // parent associations.
    //
    // This can occur if someone calls the C++ operator delete,
    // or Release() to destroy the object.
    //
    // This is generally invalid in the framework, though certain
    // objects may understand the underlying contract, but must
    // make sure there are no left over un-Disposed associations.
    //
    // Embedded FxObject's also don't have delete called on them,
    // and have to manually manage any child associations when
    // their parent object disposes by calling PerformEarlyDispose.
    //
    // They don't have an associated lifetime parent since they
    // are embedded.
    //
    if (m_ParentObject != NULL ||
        !IsListEmpty(&m_ChildListHead) || !IsListEmpty(&m_ChildEntry)) {
        PCSTR pHandleName;
 
        pHandleName = FxObjectTypeToHandleName(m_Type);
        if (pHandleName == NULL) {
            pHandleName = "WDFOBJECT";
        }
 
        ASSERTMSG(
            "Object was freed using WdfObjectDereference, not WdfObjectDelete\n",
            m_ParentObject == NULL &&
            IsListEmpty(&m_ChildEntry) &&
            IsListEmpty(&m_ChildListHead)
            );
 
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_FATAL, TRACINGOBJECT,
            "Handle %s %p (raw object %p) was freed using "
            "WdfObjectDereference(), not WdfObjectDelete()",
            pHandleName, GetObjectHandleUnchecked(), this);
 
        FxVerifierBugCheck(GetDriverGlobals(),
                           WDF_OBJECT_ERROR,
                           (ULONG_PTR) GetObjectHandleUnchecked(),
                           (ULONG_PTR) this);
    }
 
    //
    // This is called when the reference count goes to zero
    //
    SetObjectStateLocked(FxObjectStateDestroyed);
}

Member Function Documentation

__drv_requiresIRQL()

FxObject::__drv_requiresIRQL ( DISPATCH_LEVEL  )

private

_CleanupPointer()

static PFX_POOL_HEADER FxObject::_CleanupPointer ( __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in FxObject *  Object  )

inlinestatic

Definition at line 1273 of file fxobject.hpp.

    {
        PFX_POOL_HEADER pHeader;
        PVOID pObjectBase;
 
        pObjectBase = _GetBase(Object);
 
        pHeader = CONTAINING_RECORD(pObjectBase, FX_POOL_HEADER, AllocationStart);
 
        //
        // If PoolTracker is on then do....
        //
        if (FxDriverGlobals->IsPoolTrackingOn()) {
            //
            // Decommission this NonPaged Allocation tracker
            //
            FxPoolRemoveNonPagedAllocateTracker((PFX_POOL_TRACKER) pHeader->Base);
        }
 
        return pHeader;
    }

Referenced by FxLookasideList::_Reclaim(), FxDevice::FreeRequestMemory(), and FxRequestFromLookaside::SelfDestruct().

_DereferenceActual()

FxObject::_DereferenceActual ( __in WDFOBJECT  Object, __in_opt PVOID  Tag, __in LONG  Line, __in PSTR  File  )

inlinestatic

Definition at line 697 of file fxobject.hpp.

    {
        FxObject* pObject;
        WDFOBJECT_OFFSET offset;
 
        offset = 0;
        pObject = FxObject::_GetObjectFromHandle(Object, &offset);
 
        if (offset == 0) {
            pObject->Release(Tag, Line, File);
        }
        else {
            pObject->ReleaseOverride(offset, Tag, Line, File);
        }
    }

_FromDisposeEntry()

static FxObject * FxObject::_FromDisposeEntry ( __in PSINGLE_LIST_ENTRY  Entry )

inlinestatic

Definition at line 580 of file fxobject.hpp.

    {
        return CONTAINING_RECORD(Entry, FxObject, m_DisposeSingleEntry);
    }

Referenced by FxDisposeList::DrainListLocked().

_GetBase()

static PVOID FxObject::_GetBase ( __in FxObject *  Object )

inlinestaticprotected

Definition at line 418 of file fxobject.hpp.

    {
        if (Object->IsDebug()) {
            return _GetDebugBase(Object);
        }
        else {
            return (PVOID) Object;
        }
    }

Referenced by _CleanupPointer(), FxNPagedLookasideList::Allocate(), FxNPagedLookasideListFromPool::Allocate(), and FxPagedLookasideListFromPool::Allocate().

_GetDebugBase()

static PVOID FxObject::_GetDebugBase ( __in FxObject *  Object )

inlinestatic

Definition at line 806 of file fxobject.hpp.

    {
        return CONTAINING_RECORD(Object, FxObjectDebugExtension, AllocationStart);
    }

Referenced by _GetBase().

_GetEffectiveLock()

_Must_inspect_result_ NTSTATUS FxObject::_GetEffectiveLock ( __in FxObject *  Object, __in_opt IFxHasCallbacks *  Callbacks, __in BOOLEAN  AutomaticLocking, __in BOOLEAN  PassiveCallbacks, __out FxCallbackLock **  CallbackLock, __out_opt FxObject **  CallbackLockObject  )

static

Definition at line 1044 of file fxobject.cpp.

{
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
    WDF_EXECUTION_LEVEL parentLevel;
    WDF_SYNCHRONIZATION_SCOPE parentScope;
 
    pFxDriverGlobals = Object->GetDriverGlobals();
    *CallbackLock = NULL;
    *CallbackLockObject = NULL;
 
    //
    // No automatic locking, nothing to do
    //
    if (AutomaticLocking == FALSE) {
        return STATUS_SUCCESS;
    }
 
    //
    // Objects that have callback locks must support this interface.
    //
    if (Callbacks == NULL) {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    //
    // Get the callback constraints in effect for the object
    //
    Callbacks->GetConstraints(&parentLevel, &parentScope);
 
    if (parentScope == WdfSynchronizationScopeInheritFromParent ||
        parentScope == WdfSynchronizationScopeNone) {
        //
        // Do nothing, no synchronization specified
        //
        DO_NOTHING();
    }
    else {
        //
        // If the caller wants passive callbacks and the object does not support
        // it, failure.
        //
        // If the caller wants non passive callbacks and the object supports
        // passive only callbacks, failure.
        //
        if ((PassiveCallbacks && Object->IsPassiveCallbacks() == FALSE) ||
            (PassiveCallbacks == FALSE && Object->IsPassiveCallbacks())) {
            FxVerifierDbgBreakPoint(pFxDriverGlobals);
            return STATUS_WDF_INCOMPATIBLE_EXECUTION_LEVEL;
        }
 
        *CallbackLock = Callbacks->GetCallbackLockPtr(CallbackLockObject);
    }
 
    return STATUS_SUCCESS;
}

Referenced by FxDpc::Initialize(), FxTimer::Initialize(), FxWorkItem::Initialize(), and FxInterrupt::InitializeWorker().

_GetObjectFromHandle()

static FxObject * FxObject::_GetObjectFromHandle ( __in WDFOBJECT  Handle, __inout PWDFOBJECT_OFFSET  ObjectOffset  )

inlinestatic

Definition at line 613 of file fxobject.hpp.

    {
        ULONG_PTR handle, flags;
 
        handle = (ULONG_PTR) Handle;
 
        //
        // store the flags and then clear them off so we have a valid value
        //
        flags = FxHandleFlagMask & handle;
        handle &= ~FxHandleFlagMask;
 
        //
        // It is assumed the caller has already set the offset to zero
        //
        // *ObjectOffset = 0;
 
        //
        // We always apply the mask
        //
        handle = handle ^ FxHandleValueMask;
 
        if (flags & FxHandleFlagIsOffset) {
            //
            // The handle is a pointer to an offset value.  Return the offset
            // to the caller and then compute the object since the pointer
            // to the offset is part of the object we are returning.
            //
            *ObjectOffset = *(PWDFOBJECT_OFFSET) handle;
 
            return (FxObject*) (((PUCHAR) handle) - *ObjectOffset);
        }
        else {
            //
            // No offset, no verification.  We pass the FxObject as the handle
            //
            return (FxObject*) handle;
       }
    }

Referenced by _DereferenceActual(), _ReferenceActual(), FxObjectHandleGetPtr(), FxObjectHandleGetPtrOffset(), PerfEvtDeviceD0EntryStart(), PerfEvtDeviceD0ExitStart(), PerfEvtDevicePrepareHardwareStart(), PerfEvtDeviceReleaseHardwareStart(), PerfEvtIoStopStart(), PerfEvtIoStopStop(), PerfIoComplete(), PerfIoStart(), PerformanceAnalysisPowerProcess(), PerformanceGetDriverDeviceAdd(), VfAddContextToHandle(), and VfWdfObjectGetTypedContext().

_ObjectQuery()

_Must_inspect_result_ NTSTATUS FxObject::_ObjectQuery ( _In_ FxObject *  Object, _In_ CONST GUID *  Guid, _In_ ULONG  QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID  QueryBuffer  )

static

Definition at line 39 of file fxobjectkm.cpp.

{
    // PFX_DRIVER_GLOBALS pFxDriverGlobals = Object->GetDriverGlobals();
 
    //
    // Design Note: This interface does not look strongly typed
    // but it is. The GUID defines a specific strongly typed
    // contract for QueryBuffer and QueryBufferLength.
    //
 
#if DBG
 
    //
    // These operations are only available on checked builds for deep unit
    // testing, code coverage analysis, and model verification.
 
 
 
 
 
 
 
 
 
 
 
 
 
    //
 
    // Add code based on the GUID
 
    // IsEqualGUID(guid1, guid2), DEFINE_GUID, INITGUID, inc\wnet\guiddef.h
    UNREFERENCED_PARAMETER(Object);
    UNREFERENCED_PARAMETER(Guid);
    UNREFERENCED_PARAMETER(QueryBufferLength);
    UNREFERENCED_PARAMETER(QueryBuffer);
#else
    UNREFERENCED_PARAMETER(Object);
    UNREFERENCED_PARAMETER(Guid);
    UNREFERENCED_PARAMETER(QueryBufferLength);
    UNREFERENCED_PARAMETER(QueryBuffer);
#endif
 
    return STATUS_NOT_FOUND;
}

Referenced by __out_bcount().

_ReferenceActual()

FxObject::_ReferenceActual ( __in WDFOBJECT  Object, __in_opt PVOID  Tag, __in LONG  Line, __in PSTR  File  )

inlinestatic

Definition at line 673 of file fxobject.hpp.

    {
        FxObject* pObject;
        WDFOBJECT_OFFSET offset;
 
        offset = 0;
        pObject = FxObject::_GetObjectFromHandle(Object, &offset);
 
        if (offset == 0) {
            pObject->AddRef(Tag, Line, File);
        }
        else {
            pObject->AddRefOverride(offset, Tag, Line, File);
        }
    }

_Releases_lock_() [1/4]

FxObject::_Releases_lock_ ( this->m_SpinLock.  m_Lock )

private

_Releases_lock_() [2/4]

FxObject::_Releases_lock_ ( this->m_SpinLock.  m_Lock )

private

_Releases_lock_() [3/4]

FxObject::_Releases_lock_ ( this->m_SpinLock.  m_Lock )

private

_Releases_lock_() [4/4]

FxObject::_Releases_lock_ ( this->m_SpinLock.  m_Lock )

private

_ToHandle()

static PVOID __inline FxObject::_ToHandle ( __in FxObject *  Object )

inlinestatic

Definition at line 659 of file fxobject.hpp.

    {
        //
        // Always XOR the constant. Faster than checking
        // FxDriverGlobals->FxVerifierHandle.
        //
        return (PVOID) (((ULONG_PTR) Object) ^ FxHandleValueMask);
    }

Referenced by FxDevice::AllocateRequestMemory(), GetObjectHandleUnchecked(), and FxIoQueue::PostRequestCompletedCallback().

_When_()

FxObject::_When_ ( Unlock  , _Releases_lock_(this->m_SpinLock.m_Lock)    )

private

AddChildObjectInternal()

_Must_inspect_result_ NTSTATUS FxObject::AddChildObjectInternal ( __in FxObject *  ChildObject )

private

Definition at line 703 of file fxobject.cpp.

{
    KIRQL oldIrql;
 
    m_SpinLock.Acquire(&oldIrql);
 
    //
    // Can't add child if the current object is being deleted
    //
    if (m_ObjectState != FxObjectStateCreated) {
        TraceDroppedEvent(FxObjectDroppedEventAddChildObjectInternal);
        m_SpinLock.Release(oldIrql);
        return STATUS_DELETE_PENDING;
    }
 
    //
    // ChildObject can't already have a parent, and can't
    // be its own parent.
    //
    ASSERT(ChildObject->m_ParentObject == NULL);
    ASSERT(IsListEmpty(&ChildObject->m_ChildEntry));
    ASSERT(ChildObject != this);
 
    //
    // Add to our m_ChildList
    //
    InsertTailList(&m_ChildListHead, &ChildObject->m_ChildEntry);
 
    if (ChildObject->GetDeviceBase() == NULL) {
        //
        // Propagate the device base downward to the child
        //
        ChildObject->SetDeviceBase(GetDeviceBase());
    }
 
    m_SpinLock.Release(oldIrql);
 
    return STATUS_SUCCESS;
}

AddContext()

_Must_inspect_result_ NTSTATUS FxObject::AddContext	(	__in FxContextHeader *	Header,
		__in PVOID *	Context,
		__in PWDF_OBJECT_ATTRIBUTES	Attributes
	)

Definition at line 605 of file fxobject.cpp.

{
    FxContextHeader *pCur, **ppLast;
    NTSTATUS status;
    KIRQL irql;
 
    status = STATUS_UNSUCCESSFUL;
 
    pCur = GetContextHeader();
 
    //
    // This should never happen since all outward facing objects have a
    // context header; framework never calls this function on internal
    // objects.
    //
    ASSERT(pCur != NULL);
 
    //
    // Acquire the lock to lock the object's state.  A side affect of grabbing
    // the lock is that all updaters who want to add a context are serialized.
    // All callers who want to find a context do not need to acquire the lock
    // becuase they are not going to update the list, just read from it.
    //
    // Once a context has been added, it will not be removed until the object
    // has been deleted.
    //
    m_SpinLock.Acquire(&irql);
 
    if (m_ObjectState == FxObjectStateCreated && pCur != NULL) {
        //
        // Iterate over the list of contexts already on this object and see if
        // this type already is attached.
        //
        for (ppLast = &pCur->NextHeader;
             pCur != NULL;
             ppLast = &pCur->NextHeader, pCur = pCur->NextHeader) {
 
            if (pCur->ContextTypeInfo == Header->ContextTypeInfo) {
                //
                // Dupe found, return error but give the caller the context
                // pointer
                //
                if (Context != NULL) {
                    *Context = &pCur->Context[0];
                }
 
                status = STATUS_OBJECT_NAME_EXISTS;
                break;
            }
        }
 
        if (pCur == NULL) {
            //
            // By using the interlocked to update, we don't need to use a lock
            // when walking the list to find the context.   The only reason
            // we are holding the object lock is to lock the current state
            // (m_ObjectState) of the object.
            //
            InterlockedExchangePointer((PVOID*) ppLast, Header);
            status = STATUS_SUCCESS;
 
            if (Context != NULL) {
                *Context = &Header->Context[0];
            }
 
            //
            // FxContextHeaderInit does not set these callbacks.  If this were
            // the creation of the object itself, FxObject::Commit would have done
            // this assignment.
            //
            Header->EvtDestroyCallback = Attributes->EvtDestroyCallback;
 
            if (Attributes->EvtCleanupCallback != NULL) {
                Header->EvtCleanupCallback = Attributes->EvtCleanupCallback;
                m_ObjectFlags |= FXOBJECT_FLAGS_HAS_CLEANUP;
            }
 
        }
    }
    else {
        //
        // Object is being torn down, adding a context is a bad idea because we
        // cannot guarantee that the cleanup or destroy routines will be called
        //
        status = STATUS_DELETE_PENDING;
    }
 
    m_SpinLock.Release(irql);
 
    return status;
}

Referenced by VfAddContextToHandle().

AddRef()

ULONG __inline FxObject::AddRef ( __in_opt PVOID  Tag = NULL, __in LONG  Line = 0, __in_opt PSTR  File = NULL  )

inline

Definition at line 826 of file fxobject.hpp.

    {
        FxTagTracker* pTagTracker;
        ULONG c;
 
        c = InterlockedIncrement(&m_Refcnt);
 
        //
        // Catch the transition from 0 to 1.  Since the REF_OBJ starts off at 1,
        // we should never have to increment to get to this value.
        //
        ASSERT(c > 1);
 
        pTagTracker = GetTagTracker();
        if (pTagTracker != NULL) {
            pTagTracker->UpdateTagHistory(Tag, Line, File, TagAddRef, c);
        }
 
        return c;
    }

Referenced by _ReferenceActual(), FxMemoryObject::AddRef(), FxRequest::AddRefOverride(), AddRefOverride(), CMruNode::CMruNode(), FxPkgIo::EnqueueRequest(), and FxDmaPacketTransaction::StageTransfer().

AddRefOverride()

virtual ULONG FxObject::AddRefOverride ( __in WDFOBJECT_OFFSET  Offset, __in_opt PVOID  Tag = NULL, __in LONG  Line = 0, __in_opt PSTR  File = NULL  )

inlinevirtual

Definition at line 878 of file fxobject.hpp.

    {
        UNREFERENCED_PARAMETER(Offset);
 
        return AddRef(Tag, Line, File);
    }

Referenced by _ReferenceActual().

AllocateTagTracker()

VOID FxObject::AllocateTagTracker ( __in WDFTYPE  Type )

protected

Definition at line 273 of file fxobject.cpp.

{
    ASSERT(IsDebug());
 
    if (m_Globals->DebugExtension != NULL &&
        m_Globals->DebugExtension->ObjectDebugInfo != NULL &&
        FxVerifierGetTrackReferences(
            m_Globals->DebugExtension->ObjectDebugInfo,
            Type)) {
        //
        // Failure to CreateAndInitialize a tag tracker is no big deal, we just
        // don't track references.
        //
 
        (void) FxTagTracker::CreateAndInitialize(
            &GetDebugExtension()->TagTracker,
            m_Globals,
            FxTagTrackerTypeHandle,
            FALSE,
            this
            );
 
        //
        // For now we overload the requirement of a tag tracker as also tracing
        // state changes.
        //
        m_ObjectFlags |= FXOBJECT_FLAGS_TRACE_STATE;
    }
}

Referenced by FxMemoryObject::FxMemoryObject().

AssignParentObject()

_Must_inspect_result_ NTSTATUS FxObject::AssignParentObject

(

__in FxObject *

ParentObject

)

Definition at line 529 of file fxobject.cpp.

{
    KIRQL oldIrql;
    NTSTATUS status;
 
    m_SpinLock.Acquire(&oldIrql);
 
    //
    // Can't add a parent if the current object is being deleted
    //
    if (m_ObjectState != FxObjectStateCreated) {
        TraceDroppedEvent(FxObjectDroppedEventAssignParentObject);
        m_SpinLock.Release(oldIrql);
        return STATUS_DELETE_PENDING;
    }
 
    //
    // Current Object can't already have a parent, and can't
    // be its own parent.
    //
    if (m_ParentObject != NULL) {
        m_SpinLock.Release(oldIrql);
        return STATUS_WDF_PARENT_ALREADY_ASSIGNED;
    }
 
    if (m_ParentObject == this) {
        m_SpinLock.Release(oldIrql);
        return STATUS_WDF_PARENT_IS_SELF;
    }
 
    //
    // We don't allow a parent object to be assigned after
    // FxObject::Commit().
    //
    ASSERTMSG("Parent object can not be assigned after Commit()\n", !IsCommitted());
 
    ASSERT(IsListEmpty(&this->m_ChildEntry));
 
    status = ParentObject->AddChildObjectInternal(this);
 
    if (NT_SUCCESS(status)) {
        m_ParentObject = ParentObject;
    }
 
    m_SpinLock.Release(oldIrql);
 
    return status;
}

Referenced by FxIoResReqList::_CreateFromWdmList(), FxWmiIrpHandler::AddPowerPolicyProviderAndInstance(), FxIoResList::BuildFromWdmList(), FxCmResList::BuildFromWdmList(), and Commit().

CallCleanup()

__inline VOID FxObject::CallCleanup ( VOID  )

inline

Definition at line 815 of file fxobject.hpp.

    {
        if (m_ObjectFlags & FXOBJECT_FLAGS_HAS_CLEANUP) {
            CallCleanupCallbacks();
        }
    }

Referenced by FxDevice::Dispose(), FxMpDevice::Dispose(), FxIoTarget::Dispose(), and FxRequestBase::Dispose().

CallCleanupCallbacks()

VOID FxObject::CallCleanupCallbacks ( VOID  )

private

Definition at line 328 of file fxobject.cpp.

{
    FxContextHeader* pHeader;
    WDFOBJECT h;
 
    //
    // Deleted before Commit or it is an internal object
    //
    if (IsCommitted() == FALSE) {
        return;
    }
 
    //
    // We only should have an object handle when we have an external object
    //
    h = GetObjectHandle();
 
    for (pHeader = GetContextHeader();
         pHeader != NULL;
         pHeader = pHeader->NextHeader) {
        if (pHeader->EvtCleanupCallback != NULL) {
            pHeader->EvtCleanupCallback(h);
            pHeader->EvtCleanupCallback = NULL;
        }
    }
 
    m_ObjectFlags &= ~FXOBJECT_FLAGS_HAS_CLEANUP;
}

Referenced by CallCleanup().

ClearEvtCallbacks()

VOID FxObject::ClearEvtCallbacks

(

VOID

)

Definition at line 360 of file fxobject.cpp.

{
    FxContextHeader *pHeader;
 
    for (pHeader = GetContextHeader();
         pHeader != NULL;
         pHeader = pHeader->NextHeader) {
 
        pHeader->EvtDestroyCallback = NULL;
        pHeader->EvtCleanupCallback = NULL;
    }
 
    m_ObjectFlags &= ~FXOBJECT_FLAGS_HAS_CLEANUP;
}

Referenced by FxRequest::CompleteInternal(), DeleteFromFailedCreate(), and FxRequest::FreeRequest().

Commit()

_Must_inspect_result_ NTSTATUS FxObject::Commit	(	__in_opt PWDF_OBJECT_ATTRIBUTES	Attributes,
		__out_opt WDFOBJECT *	ObjectHandle,
		__in_opt FxObject *	Parent = NULL,
		__in BOOLEAN	AssignDriverAsDefaultParent = TRUE
	)

Definition at line 904 of file fxobject.cpp.

{
    NTSTATUS status;
    WDFOBJECT object;
    FxObject* parent;
 
    parent = NULL;
 
    if (m_ObjectSize == 0) {
        ASSERTMSG("Only external objects can call Commit()\n",
                  m_ObjectSize != 0);
        return STATUS_INVALID_HANDLE;
    }
 
    //
    // For an object to be committed into a handle, it needs to have an object
    // size.  Internal objects set their size to zero as the indication they
    // are internal and will not be converted into handles.
    //
    ASSERT(m_ObjectSize != 0);
 
    //
    // Caller has already validated basic WDF_OBJECT_ATTRIBUTES
    // with FxValidateObjectAttributes
    //
 
    //
    // Set object execution level constraint if specified
    //
    if (Attributes != NULL &&
        Attributes->ExecutionLevel == WdfExecutionLevelPassive) {
        MarkPassiveCallbacks();
    }
 
    //
    // Assign parent if supplied
    //
    if (Parent != NULL) {
        parent = Parent;
    }
    else if (Attributes != NULL && Attributes->ParentObject != NULL) {
        FxObjectHandleGetPtr(
            m_Globals,
            Attributes->ParentObject,
            FX_TYPE_OBJECT,
            (PVOID*)&parent
            );
    }
    else {
 
        //
        // If the object already does not have a parent, and
        // one has not been specified we default it to FxDriver.
        //
        // We check to ensure we are not FxDriver being created.
        //
        if (AssignDriverAsDefaultParent &&
            m_ParentObject == NULL) {
 
                //parent = FxToObjectItf::FxGetDriverAsDefaultParent(m_Globals, this);
 
 
                if (m_Globals->Driver != this) {
                    parent = m_Globals->Driver;
                }
 
        }
    }
 
    ASSERT(parent != this);
 
    if (parent != NULL) {
        //
        // Make it the parent of this object
        //
        status = AssignParentObject(parent);
 
        if (!NT_SUCCESS(status)) {
            return status;
        }
    }
 
    //
    // Now assign the optional EvtObjectCleanup, EvtObjectDestroy callbacks
    //
    if (Attributes != NULL) {
        FxContextHeader* pHeader;
 
        pHeader = GetContextHeader();
 
        if (Attributes->EvtDestroyCallback != NULL) {
            pHeader->EvtDestroyCallback = Attributes->EvtDestroyCallback;
        }
 
        if (Attributes->EvtCleanupCallback != NULL) {
            pHeader->EvtCleanupCallback = Attributes->EvtCleanupCallback;
            m_ObjectFlags |= FXOBJECT_FLAGS_HAS_CLEANUP;
        }
    }
 
    //
    // We mark the handle as committed so that we can create the handle.
    //
    MarkCommitted();
 
    //
    // Create the object handle, assign EvtObjectCleanup, EvtObjectDestroy
    //
    FxObjectHandleCreate(this, &object);
 
    if (ObjectHandle != NULL) {
        *ObjectHandle = object;
    }
 
    return STATUS_SUCCESS;
}

Referenced by FxDevice::_AllocAndQueryProperty(), FxDevice::_AllocAndQueryPropertyEx(), FxWmiProvider::_Create(), FxWmiInstanceExternal::_Create(), FxIoTargetRemote::_Create(), FxDmaScatterGatherTransaction::_Create(), FxDmaPacketTransaction::_Create(), FxDmaSystemTransaction::_Create(), FxDevice::_Create(), FxUserObject::_Create(), FxRequest::_Create(), FxInterrupt::_CreateAndInit(), FxRequest::_CreateForPackage(), FxDevice::_OpenKey(), FxDeviceBase::AllocateTarget(), FxPkgFdo::CreateDefaultDeviceList(), FxUsbDevice::CreateIsochUrb(), FxPkgIo::CreateQueue(), FxUsbDevice::CreateUrb(), if(), FxDpc::Initialize(), FxTimer::Initialize(), FxWorkItem::Initialize(), FxPkgFdo::Initialize(), FxPkgPnp::Initialize(), FxUsbInterface::MakeAndConfigurePipes(), FxPkgFdo::PnpFilterResourceRequirements(), FxPkgPdo::PnpQueryResourceRequirements(), FxPkgPdo::PnpQueryResources(), FxRequest::ProbeAndLockForRead(), FxRequest::ProbeAndLockForWrite(), FxUsbDevice::SelectConfig(), and FxUsbInterface::SelectSetting().

Construct()

VOID __inline FxObject::Construct ( __in BOOLEAN  Embedded )

inlineprivate

Definition at line 349 of file fxobject.hpp.

    {
        m_Refcnt = 1;
        m_ObjectState = FxObjectStateCreated;
        m_ObjectFlags = 0;
        m_ParentObject = NULL;
 
        InitializeListHead(&m_ChildListHead);
        InitializeListHead(&m_ChildEntry);
        m_DisposeSingleEntry.Next = NULL;
 
        m_DeviceBase = NULL;
 
        VerifyConstruct(m_Globals, Embedded);
    }

Referenced by FxObject().

DeferredDisposeWorkItem()

VOID FxObject::DeferredDisposeWorkItem ( VOID  )

private

Definition at line 696 of file fxobjectstatemachine.cpp.

{
    KIRQL oldIrql;
    BOOLEAN result, destroy;
 
    destroy = FALSE;
 
    m_SpinLock.Acquire(&oldIrql);
 
    ASSERT(oldIrql == PASSIVE_LEVEL);
 
    //
    // Perform the right action based on the objects current state
    //
    // DisposeChildrenWorker return result can be ignored because we are
    // guaranteed to be calling it at PASSIVE.
    //
    switch (m_ObjectState) {
    case FxObjectStateDeferedDisposing:
        //
        // This will drop the spinlock and move the object to the right state
        // before returning.
        //
        result = PerformDisposingDisposeChildrenLocked(oldIrql, FALSE);
 
        //
        // The substree should never defer to the dispose list if we pass FALSE.
        //
        ASSERT(result);
        UNREFERENCED_PARAMETER(result); //for fre build
 
        return;
 
    case FxObjectStateDeferedDeleting:
        SetObjectStateLocked(FxObjectStateDeletedDisposing);
        result = DisposeChildrenWorker(FxObjectStateDeferedDeleting, oldIrql, FALSE);
        ASSERT(result);
        UNREFERENCED_PARAMETER(result); //for fre build
 
        //
        // This will release the spinlock
        //
        DeletedAndDisposedWorkerLocked(oldIrql, FALSE);
        return;
 
    case FxObjectStateDeferedDestroy:
        // Perform final destroy actions now that we are at passive level
        destroy = TRUE;
        break;
 
    // These are bad states for this event
    case FxObjectStateDeletedAndDisposed:     // Do nothing
    case FxObjectStateDisposed:
    case FxObjectStateWaitingForParentDeleteAndDisposed: // Do nothing
    case FxObjectStateCreated:
    case FxObjectStateWaitingForEarlyDispose:
    case FxObjectStateInvalid:
    case FxObjectStateDestroyed:
 
    default:
        // Bad state
        ASSERT(FALSE);
        break;
    }
 
    m_SpinLock.Release(oldIrql);
 
    if (destroy) {
        ProcessDestroy();
    }
}

Referenced by FxDisposeList::DrainListLocked().

DeleteEarlyDisposedObject()

VOID FxObject::DeleteEarlyDisposedObject ( VOID  )

protected

Definition at line 172 of file fxobjectstatemachine.cpp.

{
    BOOLEAN result;
 
    ASSERT(m_ObjectFlags & FXOBJECT_FLAGS_EARLY_DISPOSED_EXT);
    ASSERT(m_ObjectState == FxObjectStateDisposed);
 
    result = MarkDeleteCalledLocked();
    ASSERT(result);
    UNREFERENCED_PARAMETER(result); //for fre build
 
    if (m_ParentObject != NULL) {
        NTSTATUS status;
        KIRQL irql;
 
        m_SpinLock.Acquire(&irql);
 
        if (m_ParentObject != NULL) {
            status = m_ParentObject->RemoveChildObjectInternal(this);
 
            if (status == STATUS_DELETE_PENDING) {
                SetObjectStateLocked(FxObjectStateWaitingForParentDeleteAndDisposed);
                m_SpinLock.Release(irql);
                return;
            }
            else {
                //
                // We no longer have a parent object
                //
                m_ParentObject = NULL;
            }
        }
 
        m_SpinLock.Release(irql);
    }
 
    //
    // This will release the spinlock
    //
    DeletedAndDisposedWorkerLocked(PASSIVE_LEVEL, FALSE);
}

Referenced by FxRequest::PostProcessCompletion().

DeleteFromFailedCreate()

VOID FxObject::DeleteFromFailedCreate

(

VOID

)

Definition at line 391 of file fxobject.cpp.

{
    ClearEvtCallbacks();
 
    //
    // After this call returns "this" is destroyed is not a valid pointer!
    //
    DeleteObject();
 
    //
    // "this" is now freed memory, do not touch it!
    //
}

Referenced by FxWmiProvider::_Create(), FxIoQueue::_Create(), FxWmiInstanceExternal::_Create(), FxDpc::_Create(), FxIoTargetRemote::_Create(), FxDmaScatterGatherTransaction::_Create(), FxDmaPacketTransaction::_Create(), FxDmaSystemTransaction::_Create(), FxTimer::_Create(), FxWorkItem::_Create(), FxUserObject::_Create(), FxRequest::_Create(), FxPkgFdo::_Create(), FxSystemThread::_CreateAndInit(), FxCmResList::_CreateAndInit(), FxIoResReqList::_CreateAndInit(), FxInterrupt::_CreateAndInit(), FxChildList::_CreateAndInit(), FxRequest::_CreateForPackage(), FxDevice::_OpenKey(), FxPkgPdo::AddEjectionDevice(), FxPkgPnp::AddRemovalDevice(), FxPkgPnp::AddUsageDevice(), FxDeviceBase::AllocateTarget(), FxUsbInterface::CleanUpAndDelete(), FxPkgFdo::CreateDefaultDeviceList(), FxUsbDevice::CreateIsochUrb(), FxPkgIo::CreateQueue(), FxUsbDevice::CreateUrb(), FxFileObject::DeleteFileObjectFromFailedCreate(), FxUsbPipeContinuousReader::FormatRepeater(), if(), FxPkgFdo::Initialize(), FxPkgPnp::Initialize(), FxUsbInterface::MakeAndConfigurePipes(), FxPkgGeneral::OnCreate(), FxRequest::ProbeAndLockForRead(), FxRequest::ProbeAndLockForWrite(), FxUsbDevice::SelectConfig(), and FxUsbInterface::SelectSetting().

DeleteObject()

VOID FxObject::DeleteObject ( VOID  )

virtual

Reimplemented in FxDevice, FxDriver, and FxInterrupt.

Definition at line 45 of file fxobjectstatemachine.cpp.

{
    NTSTATUS status;
    KIRQL oldIrql;
    BOOLEAN result;
 
    m_SpinLock.Acquire(&oldIrql);
 
    result = MarkDeleteCalledLocked();
 
    // This method should only be called once per object
    ASSERT(result);
    UNREFERENCED_PARAMETER(result); //for fre build
 
    //
    // Perform the right action based on the objects current state
    //
    switch(m_ObjectState) {
    case FxObjectStateCreated:
        //
        // If we have a parent object, notify it of our deletion
        //
        if (m_ParentObject != NULL) {
            //
            // We call this holding our spinlock, the hierachy is child->parent
            // when the lock is held across calls
            //
            status = m_ParentObject->RemoveChildObjectInternal(this);
 
            if (status == STATUS_DELETE_PENDING) {
 
                //
                // We won the race to ourselves (still FxObjectStateCreated),
                // but lost the race on the parent who is going to try and
                // dispose us through the ParentDeleteEvent().
                //
                // This is OK since the state machine protects us from
                // doing improper actions, but we must not rundown and
                // release our reference count till the parent object
                // eventually calls our ParentDeleteEvent().
                //
                // So we note the state, and return waiting for the
                // parent to dispose us.
                //
 
                //
                // Wait for our parent to come in and dispose us through
                // the ParentDeleteEvent().
                //
                SetObjectStateLocked(FxObjectStateWaitingForEarlyDispose);
                m_SpinLock.Release(oldIrql);
                break;
            }
            else {
                //
                // We no longer have a parent object
                //
                m_ParentObject = NULL;
            }
        }
 
        //
        // Start Dispose, do delete state machine
        // returns with m_SpinLock released
        //
        DeleteWorkerAndUnlock(oldIrql, TRUE);
        break;
 
    case FxObjectStateDisposed:
 
        if (m_ParentObject != NULL) {
            status = m_ParentObject->RemoveChildObjectInternal(this);
 
            if (status == STATUS_DELETE_PENDING) {
                SetObjectStateLocked(FxObjectStateWaitingForParentDeleteAndDisposed);
                m_SpinLock.Release(oldIrql);
                break;
            }
            else {
                //
                // We no longer have a parent object
                //
                m_ParentObject = NULL;
            }
        }
 
        //
        // This will release the spinlock
        //
        DeletedAndDisposedWorkerLocked(oldIrql);
        break;
 
    case FxObjectStateDisposingDisposeChildren:
    case FxObjectStateWaitingForEarlyDispose:
    case FxObjectStateDeletedDisposing: // Do nothing, workitem will move into disposed and deleted
    case FxObjectStateDeletedAndDisposed:     // Do nothing, already deleted
        TraceDroppedEvent(FxObjectDroppedEventDeleteObject);
        m_SpinLock.Release(oldIrql);
        break;
 
    // These are bad states for this event
    case FxObjectStateInvalid:
    case FxObjectStateDestroyed:
    case FxObjectStateWaitingForParentDeleteAndDisposed:
    default:
        TraceDroppedEvent(FxObjectDroppedEventDeleteObject);
        // Bad state
        ASSERT(FALSE);
        m_SpinLock.Release(oldIrql);
    }
}

Referenced by FxDevice::_AllocAndQueryProperty(), FxDevice::_AllocAndQueryPropertyEx(), FxIoResReqList::_CreateFromWdmList(), FxWmiIrpHandler::AddPowerPolicyProviderAndInstance(), FxUsbInterface::CleanUpAndDelete(), FxDevice::ControlDeviceDelete(), FxPkgPnp::CreatePowerThread(), FxDevice::DeleteObject(), FxDriver::DeleteObject(), FxInterrupt::DeleteObject(), FxDisposeList::Dispose(), FxIoQueue::Dispose(), FxTimer::FlushAndRundown(), FxInterrupt::FlushAndRundownInternal(), if(), FxPkgFdo::PnpFilterResourceRequirements(), FxPkgPdo::PnpQueryResourceRequirements(), FxPkgPdo::PnpQueryResources(), FxPkgPnp::ReleasePowerThread(), FxResourceCollection::RemoveAndDelete(), FxDeviceBase::~FxDeviceBase(), FxDriver::~FxDriver(), FxUsbPipeContinuousReader::~FxUsbPipeContinuousReader(), and WDFDEVICE_INIT::~WDFDEVICE_INIT().

DestroyChildren()

VOID __inline FxObject::DestroyChildren ( VOID  )

inlineprotected

Definition at line 464 of file fxobject.hpp.

    {
        PLIST_ENTRY ple;
        FxObject *pChild;
 
        while (!IsListEmpty(&m_ChildListHead)) {
            ple = RemoveHeadList(&m_ChildListHead);
 
            pChild = CONTAINING_RECORD(ple, FxObject, m_ChildEntry);
 
            //
            // Mark entry as unlinked
            //
            InitializeListHead(&pChild->m_ChildEntry);
 
            //
            // Inform child object of destruction. Object may be gone after return.
            //
            pChild->ParentDeleteEvent();
        }
    }

Referenced by FxRequest::CompleteInternal(), FxDevice::DeleteDeviceFromFailedCreateNoDelete(), FxDevice::Dispose(), FxMpDevice::Dispose(), FxPkgPnp::PnpEventRemovedCommonCode(), and FxRequest::PreProcessSendAndForget().

Dispose()

BOOLEAN FxObject::Dispose ( VOID  )

virtual

Reimplemented in FxCommonBuffer, FxDmaTransactionBase, FxDmaScatterGatherTransaction, FxDpc, FxChildList, FxDevice, FxMpDevice, FxDisposeList, FxDriver, FxInterrupt, FxIoQueue, FxIoTarget, FxPkgPnp, FxRequestBase, FxSystemWorkItem, FxTimer, FxUsbUrb, FxUsbDevice, FxUsbPipe, FxWmiInstance, FxWmiProvider, FxWorkItem, and FxDmaEnabler.

Definition at line 229 of file fxobjectstatemachine.cpp.

{
    return TRUE;
}

Referenced by FxDevice::Dispose(), FxDisposeList::Dispose(), FxDriver::Dispose(), FxIoQueue::Dispose(), FxPkgPnp::Dispose(), FxUsbUrb::Dispose(), FxWmiInstance::Dispose(), and FxWmiProvider::Dispose().

EarlyDispose()

BOOLEAN FxObject::EarlyDispose

(

VOID

)

Definition at line 375 of file fxobjectstatemachine.cpp.

{
    NTSTATUS status;
    KIRQL oldIrql;
    BOOLEAN result;
 
    //
    // By default, we assume a synchronous diposal
    //
    result = TRUE;
 
    m_SpinLock.Acquire(&oldIrql);
 
    switch(m_ObjectState) {
    case FxObjectStateCreated:
        //
        // If we have a parent object, notify it of our deletion
        //
        if (m_ParentObject != NULL) {
            //
            // We call this holding our spinlock, the hierachy is child->parent
            // when the lock is held across calls
            //
            status = m_ParentObject->RemoveChildObjectInternal(this);
 
            if (status == STATUS_DELETE_PENDING) {
 
                //
                // We won the race to ourselves (still FxObjectStateCreated),
                // but lost the race on the parent who is going to try and
                // dispose us through the PerformEarlyDipose().
                //
                // This is OK since the state machine protects us from
                // doing improper actions, but we must not rundown and
                // release our reference count till the parent object
                // eventually calls our ParentDeleteEvent().
                //
                // So we note the state, and return waiting for the
                // parent to dispose us.
                //
 
                //
                // Wait for our parent to come in and dispose us through
                // the PerformEarlyDipose().
                //
                SetObjectStateLocked(FxObjectStateWaitingForEarlyDispose);
                m_SpinLock.Release(oldIrql);
 
                return FALSE;
            }
            else {
                //
                // We no longer have a parent object
                //
                m_ParentObject = NULL;
            }
        }
 
        //
        // Mark that this object was early disposed externally wrt the
        // state machine.
        //
        m_ObjectFlags |= FXOBJECT_FLAGS_EARLY_DISPOSED_EXT;
 
        //
        // Start the dispose path.  This call will release the spinlock.
        //
        result = PerformEarlyDisposeWorkerAndUnlock(oldIrql, TRUE);
        break;
 
    default:
        //
        // Not in the right state for an early dispose
        //
        result = FALSE;
        m_SpinLock.Release(oldIrql);
    }
 
    return result;
}

Referenced by FxRequest::CompleteInternal(), FxDevice::DeleteDeviceFromFailedCreateNoDelete(), FxPkgPnp::PnpEventRemovedCommonCode(), and FxRequest::PreProcessSendAndForget().

FinalRelease()

VOID FxObject::FinalRelease ( VOID  )

private

Definition at line 207 of file fxobject.cpp.

{
 
 
 
 
 
 
 
 
 
 
 
 
    //
    // No other access, OK to test flag without grabbing spinlock
    // since it can only be set at create.
    //
    if (ShouldDeferDisposeLocked()) {
        //
        // If this is a passive level only object, ensure we only destroy
        // it from passive level.  No need to hold the object lock when
        // changing to this state since no other thread can change our
        // state.
        //
        SetObjectStateLocked(FxObjectStateDeferedDestroy);
 
        //
        // Note, we cannot be holding a lock while making this call b/c by
        // the time it returns, it could have freed the object and the
        // KeReleaseSpinLock call would have touched freed pool.
        //
 
        //FxToObjectItf::FxAddToDriverDisposeList(m_Globals, this);
 
 
        m_Globals->Driver->GetDisposeList()->Add(this);
 
    }
    else {
        ProcessDestroy();
    }
}

Referenced by Release().

FX_DECLARE_VF_FUNCTION_P1()

FxObject::FX_DECLARE_VF_FUNCTION_P1 ( VOID  , VerifyConstruct  , _In_  BOOLEAN  )

private

GetCOMWrapper()

PVOID FxObject::GetCOMWrapper ( )

inline

Definition at line 518 of file fxobject.hpp.

{ return m_COMWrapper; }

GetContextHeader()

__inline FxContextHeader * FxObject::GetContextHeader ( VOID  )

inline

Definition at line 720 of file fxobject.hpp.

    {
        if (m_ObjectSize == 0) {
            return NULL;
        }
        else {
            return GET_CONTEXT_HEADER();
        }
    }

Referenced by __drv_maxIRQL(), AddContext(), CallCleanupCallbacks(), ClearEvtCallbacks(), Commit(), FxDevice::CreateDevice(), ProcessDestroy(), and VfWdfObjectGetTypedContext().

GetDebugExtension()

FxObjectDebugExtension * FxObject::GetDebugExtension ( VOID  )

inlineprotected

Definition at line 401 of file fxobject.hpp.

    {
        return CONTAINING_RECORD(this, FxObjectDebugExtension, AllocationStart);
    }

Referenced by FxNonPagedObject::_Acquires_lock_(), FxNonPagedObject::_Releases_lock_(), FxNonPagedObject::_Requires_lock_held_(), AllocateTagTracker(), FxNonPagedObject::FxNonPagedObject(), ProcessDestroy(), SetObjectStateLocked(), and FxNonPagedObject::~FxNonPagedObject().

GetDevice()

CfxDevice * FxObject::GetDevice ( VOID  )

inline

Definition at line 781 of file fxobject.hpp.

    {
        return m_Device;
    }

Referenced by FxDmaPacketTransaction::AcquireDevice(), FxIoQueue::FxIoQueue(), and FxDmaPacketTransaction::ReleaseDevice().

GetDeviceBase()

CfxDeviceBase * FxObject::GetDeviceBase ( VOID  )

inline

Definition at line 789 of file fxobject.hpp.

    {
        return m_DeviceBase;
    }

Referenced by FxDeviceBase::_SearchForDevice(), AddChildObjectInternal(), and FxIoQueue::QueueDriverCreatedRequest().

GetDriverGlobals()

__inline PFX_DRIVER_GLOBALS FxObject::GetDriverGlobals ( VOID  )

inline

Definition at line 734 of file fxobject.hpp.

    {
        return m_Globals;
    }

Referenced by __drv_maxIRQL(), __drv_requiresIRQL(), __drv_when(), __in_bcount_opt(), FxUsbDevice::_Acquires_lock_(), FxDmaPacketTransaction::_AdapterControl(), FxDmaScatterGatherTransaction::_AdapterListControl(), FxFileObject::_CreateFileObject(), FxFileObject::_DestroyFileObject(), _Function_class_(), FxFileObject::_GetFileObjectFromWdm(), FxPkgPdo::_PnpEject(), FxPkgPdo::_PnpQueryDeviceText(), FxPkgPdo::_PnpQueryId(), FxPkgFdo::_PnpQueryInterface(), FxPkgFdo::_PnpStartDeviceCompletionRoutine(), FxDevicePwrRequirementMachine::_ProcessEventInner(), FxWakeInterruptMachine::_ProcessEventInner(), FxPkgPdo::_QueryCapsWorkItem(), FxUsbDevice::_Releases_lock_(), FxIoTarget::_RequestCancelled(), _Requires_lock_held_(), _Requires_lock_not_held_(), FxDeviceBase::_SearchForDevice(), FxInterrupt::AcquireLock(), FxPkgGeneral::AcquireRemoveLockForClose(), FxCollection::Add(), FxChildList::Add(), FxResourceCollection::AddAt(), FxPkgPnp::AddChildList(), FxPkgPnp::AddDmaEnabler(), FxPkgPdo::AddEjectionDevice(), FxWmiProvider::AddInstance(), FxWmiProvider::AddInstanceLocked(), FxDevice::AddIoTarget(), FxRequest::AddIrpReference(), FxWmiIrpHandler::AddPowerPolicyProviderAndInstance(), FxPkgPnp::AddQueryInterface(), FxPkgPnp::AddRemovalDevice(), FxPkgPnp::AddUsageDevice(), FxNPagedLookasideList::Allocate(), FxNPagedLookasideListFromPool::Allocate(), FxPagedLookasideListFromPool::Allocate(), FxDmaPacketTransaction::AllocateAdapterChannel(), FxCommonBuffer::AllocateCommonBuffer(), FxDmaEnabler::AllocateCommonBuffer(), FxPkgPnp::AllocateDmaEnablerList(), FxPkgPnp::AllocateEnumInfo(), FxDevice::AllocateRequestMemory(), FxIoQueue::AllocateReservedRequest(), FxDeviceBase::AllocateTarget(), FxString::Assign(), FxDevice::AssignProperty(), FxInterrupt::AssignResources(), FxChildList::BeginIteration(), FxChildList::BeginScan(), FxIoResList::BuildFromWdmList(), FxCmResList::BuildFromWdmList(), FxCmResList::BuildPortResourceTable(), FxCmResList::BuildRegisterResourceTable(), FxDmaScatterGatherTransaction::BuildScatterGatherList(), FxRequestBase::Cancel(), FxIoQueue::CancelForDriver(), FxDmaSystemTransaction::CancelMappedTransfer(), FxUsbPipeContinuousReader::CancelRepeaters(), FxDmaTransactionBase::CancelResourceAllocation(), FxIoTarget::CancelSentIo(), FxRequestBase::CancelTimer(), FxIoQueue::CanThreadDispatchEventsLocked(), FxCmResList::CheckForConnectionResources(), FxPkgPnp::ChildListNotifyRemove(), FxPkgPnp::CleanupStateMachines(), FxIoTarget::ClearCompletedRequestVerifierFlags(), FxPkgPdo::ClearEjectionDevicesList(), FxRequestBase::ClearFieldsForReuse(), FxPkgPnp::ClearRemovalDevicesList(), FxIoTargetRemote::ClearTargetPointers(), FxRequestBase::ClearVerifierFlags(), FxDeviceDescriptionEntry::Clone(), FxChildList::CloneEntryLocked(), FxIoTargetRemote::Close(), FxPkgPnp::CommitUsageNotification(), FxRequest::Complete(), FxIoTarget::CompleteCanceledRequest(), FxRequest::CompleteInternal(), FxRequestBase::CompleteSubmitted(), FxRequest::CompleteWithPriority(), FxWmiIrpHandler::CompleteWmiRequest(), FxUsbPipeContinuousReader::Config(), FxDmaEnabler::ConfigureBusMasterAdapters(), FxPkgGeneral::ConfigureConstraints(), FxDeviceBase::ConfigureConstraints(), FxIoQueue::ConfigureConstraints(), FxPkgIo::ConfigureDynamicDispatching(), FxPkgGeneral::ConfigureFileObjectClass(), FxPkgGeneral::ConfigureForwarding(), FxPkgIo::ConfigureForwarding(), FxDmaEnabler::ConfigureSystemAdapter(), FxInterrupt::Connect(), FxRequest::CopyCompletionParams(), FxPkgFdo::CreateDefaultDeviceList(), FxDevice::CreateDevice(), FxChildList::CreateDevice(), FxUsbDevice::CreateInterfaces(), FxUsbDevice::CreateIsochUrb(), FxPkgPnp::CreatePowerThread(), FxPkgIo::CreateQueue(), FxUsbInterface::CreateSettings(), FxSystemThread::CreateThread(), FxRequestBase::CreateTimer(), FxUsbDevice::CreateUrb(), FxInterrupt::CreateWakeInterruptMachine(), FxCmResList::CreateWdmList(), FxIoResReqList::CreateWdmList(), FxUsbDevice::CyclePort(), FxUsbDevice::Deconfig(), FxDevice::DeleteDeviceFromFailedCreateNoDelete(), FxDevice::DeleteObject(), FxWmiIrpHandler::Deregister(), FxDevice::Destroy(), FxInterrupt::Disconnect(), FxPkgPnp::DisconnectInterruptNP(), FxPkgPnp::Dispatch(), FxWmiIrpHandler::Dispatch(), FxPkgGeneral::Dispatch(), FxPkgIo::Dispatch(), FxPkgFdo::DispatchDeviceSetPower(), FxPkgPdo::DispatchDeviceSetPower(), FxIoQueue::DispatchRequestToDriver(), FxPkgIo::DispatchStep1(), FxPkgIo::DispatchStep2(), FxPkgPnp::DispatchWaitWake(), FxPkgIo::DispathToInCallerContextCallback(), FxDmaTransactionBase::Dispose(), FxIoQueue::Dispose(), FxPkgPnp::Dispose(), FxRequestBase::Dispose(), FxDmaTransactionBase::DmaCompleted(), FxDpc::DpcHandler(), FxInterrupt::DpcHandler(), FxIoTarget::DrainPendedRequestsLocked(), FxChildList::EndIteration(), FxChildList::EndScan(), FxWorkItem::Enqueue(), FxPkgIo::EnqueueRequest(), FxSystemWorkItem::EnqueueWorker(), FxEventQueue::EventQueueWorker(), FxDmaTransactionBase::Execute(), FxIoQueue::FatalError(), FxRequestBase::FatalError(), FxDevice::FdoInitialize(), FxPkgPnp::FilterResourceRequirements(), FxWmiInstance::FireEvent(), FxDmaPacketTransaction::FlushAdapterBuffers(), FxPkgIo::FlushAllQueuesByFileObject(), FxTimer::FlushAndRundown(), FxWorkItem::FlushAndWait(), FxInterrupt::ForceDisconnect(), FxInterrupt::ForceReconnect(), FxUsbPipe::FormatAbortRequest(), FxUsbDevice::FormatControlRequest(), FxIoTarget::FormatInternalIoctlOthersRequest(), FxIoTarget::FormatIoctlRequest(), FxIoTarget::FormatIoRequest(), FxUsbPipe::FormatResetRequest(), FxUsbDevice::FormatStringRequest(), FxUsbPipe::FormatTransferRequest(), FxIoQueue::ForwardRequest(), FxIoQueue::ForwardRequestToParent(), FxIoQueue::ForwardRequestWorker(), FxDmaPacketTransaction::FreeMapRegistersAndAdapter(), FxDmaSystemTransaction::FreeMapRegistersAndAdapter(), FxRequestBase::FreeMdls(), FxDevice::FreeRequestMemory(), FxNonPagedObject::FxNonPagedObject(), FxUsbPipeContinuousReader::FxUsbPipeRequestWorkItemHandler(), FxDevice::FxValidateInterfacePropertyData(), FxUsbInterface::GetConfiguredSettingIndex(), FxRequest::GetCurrentIrpStackLocation(), FxRequest::GetDeviceControlOutputMdl(), FxRequest::GetDeviceControlOutputMemoryObject(), FxMemoryObject::GetDriverGlobals(), FxRequestSystemBuffer::GetDriverGlobals(), FxRequestOutputBuffer::GetDriverGlobals(), FxRequest::GetFileObject(), FxRequest::GetInformation(), FxUsbDevice::GetInterfaceNumberFromInterface(), FxRequest::GetIrp(), FxRequest::GetMdl(), FxRequest::GetMemoryObject(), FxChildList::GetNextDevice(), FxRequest::GetParameters(), FxUsbDevice::GetPortStatus(), FxDriver::GetRegistryPath(), FxIoQueue::GetRequest(), FxRequest::GetRequestorMode(), FxRequest::GetStatus(), FxUsbDevice::GetString(), FxIoTargetRemote::GetTargetDeviceRelations(), FxVerifierLock::GetThreadTableEntry(), FxDmaTransactionBase::GetTransferInfo(), FxRequestBase::GetVerifierFlagsLocked(), FxIoTarget::GotoPurgeState(), FxUsbPipe::GotoPurgeState(), FxIoTarget::GotoRemoveState(), FxUsbPipe::GotoRemoveState(), FxIoTarget::GotoStartState(), FxIoTarget::GotoStopState(), FxUsbPipe::GotoStopState(), FxIoTarget::HandleFailedResubmit(), FxPkgPnp::HandleQueryBusInformation(), FxPkgPnp::HandleQueryBusRelations(), FxPkgFdo::HandleQueryCapabilities(), FxPkgFdo::HandleQueryCapabilitiesCompletion(), FxPkgPnp::HandleQueryDeviceRelations(), FxPkgPnp::HandleQueryInterface(), FxPkgFdo::HandleQueryPnpDeviceStateCompletion(), if(), FxRequest::Impersonate(), FxPowerIdleMachine::InDxIoIncrement(), FxIoTarget::Init(), FxUsbPipe::InitContinuousReader(), FxUsbDevice::InitDevice(), FxDriver::Initialize(), FxDmaTransactionBase::Initialize(), FxSystemWorkItem::Initialize(), FxDmaEnabler::Initialize(), FxIoQueue::Initialize(), FxDpc::Initialize(), FxTimer::Initialize(), FxWorkItem::Initialize(), FxPkgFdo::Initialize(), FxPkgGeneral::Initialize(), FxPkgPdo::Initialize(), FxPkgPnp::Initialize(), FxDevice::Initialize(), FxPagedLookasideListFromPool::Initialize(), FxDisposeList::Initialize(), FxPagedObject::Initialize(), FxPkgIo::InitializeDefaultQueue(), FxLookasideList::InitializeLookaside(), FxDmaEnabler::InitializeResources(), FxDmaScatterGatherTransaction::InitializeResources(), FxInterrupt::InitializeWorker(), FxLookasideList::InitObjectAlloc(), FxPagedLookasideListFromPool::InitPagedAlloc(), FxPowerPolicyMachine::InitUsbSS(), FxRequest::InsertHeadIrpQueue(), FxRequest::InsertTailIrpQueue(), FxPowerIdleMachine::IoDecrement(), FxDeviceDescriptionEntry::IsDeviceRemoved(), FxDevice::IsInterfaceRegistered(), FxUsbInterface::MakeAndConfigurePipes(), FxCmResList::MapIoSpaceWorker(), FxDmaPacketTransaction::MapTransfer(), FxChildList::NotifyDeviceRemove(), FxChildList::NotifyDeviceSurpriseRemove(), FxPkgPnp::NotifyResourceObjectsD0(), FxPkgPnp::NotifyResourceObjectsDx(), FxPkgPnp::NotifyResourceobjectsToReleaseResources(), FxPkgPnp::NotPowerPolicyOwnerEnterNewState(), FxPkgGeneral::OnCreate(), FxIoTargetRemoteNotificationCallback::OnQueryRemove(), FxIoTargetRemoteNotificationCallback::OnRemoveCanceled(), FxIoTargetRemoteNotificationCallback::OnRemoveComplete(), FxIoTargetRemote::Open(), FxIoTargetRemote::OpenTargetHandle(), FxDevice::PdoInitialize(), FxIoQueue::PeekRequest(), PerfEvtDeviceD0EntryStart(), PerfEvtDeviceD0ExitStart(), PerfEvtDevicePrepareHardwareStart(), PerfEvtDeviceReleaseHardwareStart(), PerfEvtIoStopStart(), PerfEvtIoStopStop(), PerfIoComplete(), PerfIoStart(), PerformanceAnalysisPowerProcess(), PerformanceGetDriverDeviceAdd(), FxPkgPnp::PnpDeviceUsageNotification(), FxPkgPnp::PnpDisableInterfaces(), FxPkgPnp::PnpEnableInterfacesAndRegisterWmi(), FxPkgPnp::PnpEnterNewState(), FxPkgPdo::PnpEventEjectHardwareOverload(), FxPkgPdo::PnpEventPdoRemovedOverload(), FxPkgPnp::PnpEventSurpriseRemovePendingOverload(), FxPkgFdo::PnpFilterResourceRequirements(), FxPkgPnp::PnpIncrementRestartCountLogic(), FxPkgPnp::PnpMatchResources(), FxPkgPnp::PnpProcessEvent(), FxPkgPnp::PnpProcessEventInner(), FxPkgPdo::PnpQueryCapabilities(), FxPkgFdo::PnpQueryDeviceRelations(), FxPkgPdo::PnpQueryDeviceRelations(), FxPkgPdo::PnpQueryResourceRequirements(), FxPkgPdo::PnpQueryResources(), FxPkgPnp::PnpReleaseHardware(), FxPkgFdo::PnpSendStartDeviceDownTheStackOverload(), FxPkgGeneral::PostCreateDeviceInitialize(), FxPkgFdo::PostCreateDeviceInitialize(), FxPkgPnp::PostCreateDeviceInitialize(), FxDevice::PostInitialize(), FxIoQueue::PostRequestCompletedCallback(), FxPkgPnp::PowerConnectInterruptFailed(), FxPkgPnp::PowerDmaEnableAndScan(), FxDmaEnabler::PowerDown(), FxPkgPnp::PowerEnterNewState(), FxPkgPnp::PowerGotoDx(), FxPkgPnp::PowerGotoDxIoStopped(), FxPkgPnp::PowerGotoDxIoStoppedNP(), FxPkgPnp::PowerMakeWakeRequestNonCancelable(), FxPkgPnp::PowerPolicyBlockChildrenPowerUp(), FxPkgPnp::PowerPolicyCancelWaitWake(), FxPkgPnp::PowerPolicyCanChildPowerUp(), FxPkgPnp::PowerPolicyCanIdlePowerDown(), FxPkgPnp::PowerPolicyChildPoweredDown(), FxPkgPnp::PowerPolicyChildrenCanPowerUp(), FxPkgPnp::PowerPolicyCompleteSystemPowerIrp(), FxPkgPnp::PowerPolicyDisarmWakeFromSx(), FxPkgPnp::PowerPolicyEnterNewState(), FxPkgPnp::PowerPolicyGetDeviceDeepestDeviceWakeState(), FxPkgPnp::PowerPolicyHandleSystemQueryPower(), FxPkgPnp::PowerPolicyPostParentToD0ToChildren(), FxPkgPnp::PowerPolicyProcessEvent(), FxPkgPnp::PowerPolicyProcessEventInner(), FxPkgPnp::PowerPolicySendDevicePowerRequest(), FxPkgPnp::PowerPolicySendWaitWakeRequest(), FxPkgPnp::PowerPolicySetS0IdleSettings(), FxPkgPnp::PowerPolicySetSxWakeSettings(), FxPkgPnp::PowerPolicySetSxWakeState(), FxPkgPnp::PowerPolicyUpdateSystemWakeSource(), FxPkgPnp::PowerProcessEvent(), FxPkgPnp::PowerProcessEventInner(), FxPowerIdleMachine::PowerReferenceWorker(), FxDmaEnabler::PowerUp(), FxPoxInterface::PoxRegisterDevice(), FxDmaSystemTransaction::PreMapTransfer(), FxRequest::PreProcessSendAndForget(), FxIoQueue::PreRequestCompletedCallback(), FxIoTarget::PrintDisposeMessage(), FxRequest::ProbeAndLockForRead(), FxRequest::ProbeAndLockForWrite(), FxChildList::ProcessBusRelations(), FxPkgPnp::ProcessDelayedDeletion(), FxDeviceDescriptionEntry::ProcessDeviceRemoved(), FxDevicePwrRequirementMachine::ProcessEvent(), FxSelfManagedIoMachine::ProcessEvent(), FxWakeInterruptMachine::ProcessEvent(), FxDevicePwrRequirementMachine::ProcessEventInner(), FxWakeInterruptMachine::ProcessEventInner(), FxPowerIdleMachine::ProcessEventLocked(), FxChildList::ProcessModificationsLocked(), FxIoTarget::Purge(), FxIoQueue::PutBackReservedRequest(), FxPkgPnp::QueryForCapabilities(), FxPkgPnp::QueryForD3ColdInterface(), FxUsbDevice::QueryUsbCapability(), FxIoQueue::QueueDrainSynchronously(), FxIoQueue::QueueDriverCreatedRequest(), FxIoQueue::QueueIdle(), FxIoQueue::QueueIdleSynchronously(), FxIoQueue::QueuePurge(), FxIoQueue::QueuePurgeSynchronously(), FxIoQueue::QueueRequest(), FxIoQueue::QueueRequestFromForward(), FxEventQueue::QueueToThreadWorker(), FxWorkItemEventQueue::QueueWorkItem(), FxUsbPipeContinuousReader::QueueWorkItemLocked(), FxPkgPnp::ReadStateFromRegistry(), FxIoQueue::ReadyNotify(), FxNPagedLookasideList::Reclaim(), FxNPagedLookasideListFromPool::Reclaim(), FxPagedLookasideListFromPool::Reclaim(), FxPagedLookasideListFromPool::ReclaimPool(), FxChildList::ReenumerateEntryLocked(), FxWmiIrpHandler::Register(), FxDmaPacketTransaction::ReleaseAdapter(), FxDmaTransactionBase::ReleaseForReuse(), FxRequest::ReleaseIrpReference(), FxInterrupt::ReleaseLock(), FxVerifierLock::ReleaseOrReplaceThreadTableEntry(), FxResourceCollection::RemoveAndDelete(), FxPkgPnp::RemoveChildList(), FxIoTarget::RemoveCompletedRequestLocked(), FxPkgPnp::RemoveDmaEnabler(), FxPkgPdo::RemoveEjectionDevice(), FxRequest::RemoveFromIrpQueue(), FxDevice::RemoveIoTarget(), FxIrpQueue::RemoveIrpFromQueueByContext(), FxPkgPnp::RemoveRemovalDevice(), FxPkgPnp::RemoveUsageDevice(), FxInterrupt::ReportActive(), FxInterrupt::ReportInactive(), FxIoQueue::RequestCancelable(), FxIoQueue::RequestCompletedCallback(), FxIoTarget::RequestCompletionRoutine(), FxIoQueue::Requeue(), FxDmaPacketTransaction::ReserveAdapter(), FxPowerIdleMachine::Reset(), FxUsbDevice::Reset(), FxUsbPipe::Reset(), FxPkgIo::ResetStateForRestart(), FxUsbPipeContinuousReader::ResubmitRepeater(), FxPkgIo::ResumeProcessingForPower(), FxDevice::RetrieveDeviceInfoRegistrySettings(), FxDevice::RetrieveDeviceRegistrySettings(), FxRequest::Reuse(), FxPkgPnp::SaveState(), FxUsbDevice::SelectConfig(), FxUsbDevice::SelectConfigDescriptor(), FxUsbDevice::SelectConfigInterfaces(), FxUsbDevice::SelectConfigMulti(), FxUsbDevice::SelectConfigSingle(), FxUsbInterface::SelectSetting(), FxUsbInterface::SelectSettingByDescriptor(), FxUsbInterface::SelectSettingByIndex(), FxRequestFromLookaside::SelfDestruct(), FxIoTargetSelf::Send(), FxUsbDevice::SendSyncRequest(), FxUsbDevice::SendSyncUmUrb(), FxRequest::SetCompletionState(), FxEventQueue::SetDelayedDeletion(), FxPkgPnp::SetDeviceFailed(), FxPkgIo::SetFilter(), FxDevice::SetFilterIoType(), FxDmaTransactionBase::SetImmediateExecution(), FxRequest::SetInformation(), FxPkgPnp::SetPendingPnpIrp(), FxInterrupt::SetPolicy(), FxPkgPnp::SetSpecialFileSupport(), FxIoQueue::SetState(), FxPkgPnp::SetUsageNotificationFlags(), FxRequestBase::SetVerifierFlags(), FxUsbInterface::SetWinUsbHandle(), FxDmaScatterGatherTransaction::StageTransfer(), FxDmaPacketTransaction::StageTransfer(), FxTimer::Start(), FxIoTarget::Start(), FxIoQueue::StartPowerTransitionOff(), FxDmaPacketTransaction::StartTransfer(), FxTimer::Stop(), FxIoTarget::Stop(), FxRequest::StopAcknowledge(), FxIoQueue::StopProcessingForPower(), FxPkgIo::StopProcessingForPower(), FxDmaSystemTransaction::StopTransfer(), FxIoTarget::SubmitLocked(), FxIoTarget::SubmitPendedRequest(), FxIoTarget::SubmitSync(), FxIoTarget::SubmitSyncRequestIgnoreTargetState(), FxPowerIdleMachine::TimedOutIoIncrement(), FxIoTarget::TimerCallback(), FxTimer::TimerHandler(), FxDmaPacketTransaction::TransferCompleted(), FxInterrupt::TryToAcquireLock(), FxWmiIrpHandler::UpdateGuids(), FxUsbInterface::UpdatePipeAttributes(), FxIoTarget::UpdateTargetIoType(), FxPkgPnp::UpdateWmiInstance(), FxCmResList::ValidateAndClearMapping(), FxPkgPnp::ValidateCmResource(), FxPkgPnp::ValidateInterruptResourceCm(), FxCmResList::ValidatePortAddressRange(), FxCmResList::ValidateRegisterPhysicalAddressRange(), FxCmResList::ValidateRegisterSystemAddressRange(), FxCmResList::ValidateRegisterSystemBaseAddress(), FxCmResList::ValidateResourceUnmap(), FxRequestBase::ValidateTarget(), FxRequestBase::VerifierClearFormatted(), FxPkgIo::VerifierFreeRequestToTestForwardProgess(), FxRequestBase::VerifierIsFormatted(), FxRequestBase::VerifierSetFormatted(), VfAddContextToHandle(), VfWdfObjectGetTypedContext(), FxIoTarget::WaitForDisposeEvent(), FxUsbPipe::WaitForSentIoToComplete(), FxInterrupt::WakeInterruptIsr(), FxSystemWorkItem::WorkItemHandler(), FxWorkItem::WorkItemHandler(), FxInterrupt::WorkItemHandler(), FxDevice::~FxDevice(), FxDpc::~FxDpc(), FxDriver::~FxDriver(), FxInterrupt::~FxInterrupt(), ~FxObject(), FxPkgIo::~FxPkgIo(), FxRequestBase::~FxRequestBase(), FxSystemWorkItem::~FxSystemWorkItem(), FxTimer::~FxTimer(), and FxWorkItem::~FxWorkItem().

GetObjectHandle()

PVOID __inline FxObject::GetObjectHandle ( VOID  )

inline

Definition at line 603 of file fxobject.hpp.

    {
        ASSERT(GetRefCnt() > 0);
        return GetObjectHandleUnchecked();
    }

Referenced by FxDeviceBase::_SearchForDevice(), FxUsbPipeContinuousReader::Config(), FxPkgGeneral::ConfigureForwarding(), FxIoQueue::DispatchRequestToDriver(), FxPkgIo::EnqueueRequest(), FxUsbPipeContinuousReader::FormatRepeater(), FxWorkItem::GetAssociatedObject(), FxDpc::GetObject(), FxTimer::GetObject(), if(), FxVerifierLock::Lock(), FxPkgGeneral::OnCreate(), FxIoTargetRemoteNotificationCallback::OnQueryRemove(), FxIoTargetRemoteNotificationCallback::OnRemoveCanceled(), FxIoTargetRemoteNotificationCallback::OnRemoveComplete(), and FxIoTargetSelf::Send().

GetObjectHandleUnchecked()

PVOID __inline FxObject::GetObjectHandleUnchecked ( VOID  )

inlineprotected

Definition at line 446 of file fxobject.hpp.

    {
        //
        // We don't support offset handles in the base FxObject implementation.
        // Offsets are specialized to internal objects of an FxObject
        //
        if (m_ObjectSize > 0) {
            return _ToHandle(this);
        }
        else {
            return NULL;
        }
    }

Referenced by FxDevice::DeleteDeviceFromFailedCreateNoDelete(), FxDevice::Destroy(), GetObjectHandle(), ProcessDestroy(), SetObjectStateLocked(), TraceDroppedEvent(), FxDevice::~FxDevice(), FxDpc::~FxDpc(), FxDriver::~FxDriver(), ~FxObject(), FxTimer::~FxTimer(), and FxWorkItem::~FxWorkItem().

GetObjectSize()

USHORT FxObject::GetObjectSize ( VOID  )

inline

Definition at line 750 of file fxobject.hpp.

    {
        return m_ObjectSize;
    }

Referenced by FxSpinLock::GetHistory().

GetParentObjectReferenced()

_Must_inspect_result_ FxObject * FxObject::GetParentObjectReferenced

(

__in PVOID

Tag

)

Definition at line 856 of file fxobject.cpp.

{
    KIRQL oldIrql;
    FxObject* parentObject;
 
    m_SpinLock.Acquire(&oldIrql);
 
    if (m_ObjectState == FxObjectStateCreated) {
        parentObject = m_ParentObject;
    }
    else {
        // Parent is disposing us, or we are being disposed
        parentObject = NULL;
    }
 
    if (parentObject != NULL) {
        parentObject->ADDREF(Tag);
    }
 
    m_SpinLock.Release(oldIrql);
 
    return parentObject;
}

Referenced by FxDeviceBase::_SearchForDevice().

GetRefCnt()

LONG FxObject::GetRefCnt ( VOID  )

inline

Definition at line 758 of file fxobject.hpp.

    {
        return m_Refcnt;
    }

Referenced by FxPkgIo::EnqueueRequest(), FxObjectHandleGetPtr(), FxObjectHandleGetPtrOffset(), GetObjectHandle(), FxPkgGeneral::OnCreate(), FxIoQueue::QueueRequest(), and FxRequest::Reuse().

GetTagTracker()

FxTagTracker * FxObject::GetTagTracker ( VOID  )

inline

Definition at line 766 of file fxobject.hpp.

    {
        if (IsDebug()) {
            return CONTAINING_RECORD(this,
                                     FxObjectDebugExtension,
                                     AllocationStart)->TagTracker;
        }
        else {
            return NULL;
        }
    }

Referenced by AddRef(), ProcessDestroy(), Release(), and ~FxObject().

GetType()

WDFTYPE FxObject::GetType ( VOID  )

inline

Definition at line 742 of file fxobject.hpp.

    {
        return m_Type;
    }

Referenced by FxCalculateTotalStringSize(), FxObjectHandleGetPtr(), FxObjectHandleGetPtrOffset(), FxVerifierLock::InitializeLockOrder(), FxDevice::IsFdo(), FxDevice::IsPdo(), and FxPkgPnp::PnpMatchResources().

IsCommitted()

BOOLEAN FxObject::IsCommitted ( VOID  )

inline

Definition at line 1087 of file fxobject.hpp.

    {
        //
        // No need to acquire the lock because it is assumed the caller is
        // calling on an object whose ref count has gone to zero so there are
        // no other callers to contend with who might set this flag or modify
        // m_ObjectFlags.
        //
        return FLAG_TO_BOOL(m_ObjectFlags, FXOBJECT_FLAGS_COMMITTED);
    }

Referenced by AssignParentObject(), CallCleanupCallbacks(), FxTagTracker::CheckForAbandondedTags(), FxIoQueue::Dispose(), and ProcessDestroy().

IsDebug()

BOOLEAN FxObject::IsDebug ( VOID  )

inlineprotected

Definition at line 409 of file fxobject.hpp.

    {
        return FLAG_TO_BOOL(m_ObjectFlags, FXOBJECT_FLAGS_HAS_DEBUG);
    }

Referenced by FxNonPagedObject::_Acquires_lock_(), FxNonPagedObject::_Releases_lock_(), FxNonPagedObject::_Requires_lock_held_(), AllocateTagTracker(), FxMemoryObject::FxMemoryObject(), FxNonPagedObject::FxNonPagedObject(), GetTagTracker(), SetObjectStateLocked(), and FxNonPagedObject::~FxNonPagedObject().

IsDisposed()

BOOLEAN FxObject::IsDisposed ( VOID  )

inline

Definition at line 1241 of file fxobject.hpp.

    {
        KIRQL   oldIrql;
        BOOLEAN disposed;
 
        if (m_Globals->FxVerifierOn &&
            m_Globals->FxVerifierHandle) {
            m_SpinLock.Acquire(&oldIrql);
 
            if (m_ObjectState == FxObjectStateCreated) {
                disposed = FALSE;
            }
            else {
                //
                // Parent is disposing us, or we are being disposed
                //
                disposed = TRUE;
            }
 
            m_SpinLock.Release(oldIrql);
 
            return disposed;
        }
        else {
            return TRUE;
        }
    }

Referenced by FxDevice::~FxDevice(), and FxDriver::~FxDriver().

IsForceDisposeThread()

BOOLEAN FxObject::IsForceDisposeThread ( __in BOOLEAN  AcquireLock = TRUE )

inline

Definition at line 1053 of file fxobject.hpp.

    {
        BOOLEAN result;
        KIRQL   oldIrql = PASSIVE_LEVEL;
 
        if (AcquireLock) {
            m_SpinLock.Acquire(&oldIrql);
        }
 
        result = IsForceDisposeThreadLocked();
 
        if (AcquireLock) {
            m_SpinLock.Release(oldIrql);
        }
 
        return result;
    }

IsForceDisposeThreadLocked()

BOOLEAN FxObject::IsForceDisposeThreadLocked ( VOID  )

inlineprivate

Definition at line 1375 of file fxobject.hpp.

    {
        return FLAG_TO_BOOL(m_ObjectFlags, FXOBJECT_FLAGS_FORCE_DISPOSE_THREAD);
    }

Referenced by IsForceDisposeThread(), and ShouldDeferDisposeLocked().

IsNoDeleteDDI()

BOOLEAN FxObject::IsNoDeleteDDI ( VOID  )

inline

Definition at line 1135 of file fxobject.hpp.

    {
        // No need for lock since its only set in constructor/init
        return FLAG_TO_BOOL(m_ObjectFlags, FXOBJECT_FLAGS_NODELETEDDI);
    }

Referenced by FxDevice::DeleteObject().

IsPassiveCallbacks()

BOOLEAN FxObject::IsPassiveCallbacks ( __in BOOLEAN  AcquireLock = TRUE )

inline

Definition at line 1011 of file fxobject.hpp.

    {
        BOOLEAN result;
        KIRQL   oldIrql = PASSIVE_LEVEL;
 
        if (AcquireLock) {
            m_SpinLock.Acquire(&oldIrql);
        }
 
        result = IsPassiveCallbacksLocked();
 
        if (AcquireLock) {
            m_SpinLock.Release(oldIrql);
        }
 
        return result;
    }

IsPassiveCallbacksLocked()

BOOLEAN FxObject::IsPassiveCallbacksLocked ( VOID  )

inlineprivate

Definition at line 1359 of file fxobject.hpp.

    {
        return FLAG_TO_BOOL(m_ObjectFlags, FXOBJECT_FLAGS_PASSIVE_CALLBACKS);
    }

Referenced by IsPassiveCallbacks().

IsPassiveDispose()

BOOLEAN FxObject::IsPassiveDispose ( __in BOOLEAN  AcquireLock = TRUE )

inline

Definition at line 1032 of file fxobject.hpp.

    {
        BOOLEAN result;
        KIRQL   oldIrql = PASSIVE_LEVEL;
 
        if (AcquireLock) {
            m_SpinLock.Acquire(&oldIrql);
        }
 
        result = IsPassiveDisposeLocked();
 
        if (AcquireLock) {
            m_SpinLock.Release(oldIrql);
        }
 
        return result;
    }

IsPassiveDisposeLocked()

BOOLEAN FxObject::IsPassiveDisposeLocked ( VOID  )

inlineprivate

Definition at line 1367 of file fxobject.hpp.

    {
        return FLAG_TO_BOOL(m_ObjectFlags, FXOBJECT_FLAGS_PASSIVE_DISPOSE);
    }

Referenced by IsPassiveDispose(), and ShouldDeferDisposeLocked().

IsTraceState()

BOOLEAN __inline FxObject::IsTraceState ( VOID  )

inline

Definition at line 921 of file fxobject.hpp.

    {
        return FLAG_TO_BOOL(m_ObjectFlags, FXOBJECT_FLAGS_TRACE_STATE);
    }

Referenced by TraceDroppedEvent().

MarkCommitted()

VOID FxObject::MarkCommitted ( VOID  )

inline

Definition at line 1074 of file fxobject.hpp.

    {
        //
        // Since no client code is accessing the handle yet, we don't need to
        // acquire the object state lock to set the flag since this will be
        // the only thread touching m_ObjectFlags.
        //
        m_ObjectFlags |= FXOBJECT_FLAGS_COMMITTED;
    }

Referenced by Commit().

MarkDeleteCalledLocked()

BOOLEAN FxObject::MarkDeleteCalledLocked ( VOID  )

inlineprivate

Definition at line 1345 of file fxobject.hpp.

    {
        BOOLEAN retval;
 
        retval = !(m_ObjectFlags & FXOBJECT_FLAGS_DELETECALLED);
 
        m_ObjectFlags |= FXOBJECT_FLAGS_DELETECALLED;
 
        return retval;
    }

Referenced by DeleteEarlyDisposedObject(), and DeleteObject().

MarkDisposeOverride()

VOID FxObject::MarkDisposeOverride ( __in FxObjectLockState  State = ObjectLock )

inline

Definition at line 1101 of file fxobject.hpp.

    {
        if (State == ObjectLock) {
            KIRQL irql;
 
            m_SpinLock.Acquire(&irql);
            m_ObjectFlags |= FXOBJECT_FLAGS_DISPOSE_OVERRIDE;
            m_SpinLock.Release(irql);
        }
        else {
            m_ObjectFlags |= FXOBJECT_FLAGS_DISPOSE_OVERRIDE;
        }
    }

Referenced by FxIoTarget::Construct(), FxRequestBase::EnableContextDisposeNotification(), FxChildList::FxChildList(), FxCommonBuffer::FxCommonBuffer(), FxDmaEnabler::FxDmaEnabler(), FxDmaTransactionBase::FxDmaTransactionBase(), FxDpc::FxDpc(), FxInterrupt::FxInterrupt(), FxMpDevice::FxMpDevice(), FxPkgPnp::FxPkgPnp(), FxRequestBase::FxRequestBase(), FxTimer::FxTimer(), FxUsbDevice::FxUsbDevice(), FxUsbUrb::FxUsbUrb(), FxWmiInstance::FxWmiInstance(), FxWmiProvider::FxWmiProvider(), FxWorkItem::FxWorkItem(), FxDriver::Initialize(), FxSystemWorkItem::Initialize(), FxIoQueue::Initialize(), FxDevice::Initialize(), and FxDisposeList::Initialize().

MarkForceDisposeThread()

VOID FxObject::MarkForceDisposeThread ( __in FxObjectLockState  State = ObjectLock )

inline

Definition at line 989 of file fxobject.hpp.

    {
        //
        // Object must always be disposed in a separate thread
        // to allow waiting for some outstanding async
        // operation to complete.
        //
        if (State == ObjectLock) {
            KIRQL   oldIrql;
 
            m_SpinLock.Acquire(&oldIrql);
            m_ObjectFlags |= FXOBJECT_FLAGS_FORCE_DISPOSE_THREAD;
            m_SpinLock.Release(oldIrql);
        }
        else {
            m_ObjectFlags |= FXOBJECT_FLAGS_FORCE_DISPOSE_THREAD;
        }
    }

MarkNoDeleteDDI()

VOID FxObject::MarkNoDeleteDDI ( __in FxObjectLockState  State = ObjectLock )

inline

Definition at line 1118 of file fxobject.hpp.

    {
        if (State == ObjectLock) {
            KIRQL irql;
 
            m_SpinLock.Acquire(&irql);
            m_ObjectFlags |= FXOBJECT_FLAGS_NODELETEDDI;
            m_SpinLock.Release(irql);
        }
        else {
            m_ObjectFlags |= FXOBJECT_FLAGS_NODELETEDDI;
        }
    }

Referenced by FxChildList::Add(), FxPkgIo::ConfigureForwarding(), FxDevice::FdoInitialize(), FxFileObject::FxFileObject(), FxInterrupt::FxInterrupt(), FxResourceCollection::FxResourceCollection(), FxUsbInterface::FxUsbInterface(), FxUsbPipe::FxUsbPipe(), FxWmiProvider::FxWmiProvider(), FxDriver::Initialize(), FxChildList::Initialize(), FxDevice::PdoInitialize(), and FxIoQueue::SetInterruptQueue().

MarkPassiveCallbacks()

VOID FxObject::MarkPassiveCallbacks ( __in FxObjectLockState  State = ObjectLock )

inline

Definition at line 972 of file fxobject.hpp.

    {
        if (State == ObjectLock) {
            KIRQL   oldIrql;
 
            m_SpinLock.Acquire(&oldIrql);
            m_ObjectFlags |= FXOBJECT_FLAGS_PASSIVE_CALLBACKS | FXOBJECT_FLAGS_PASSIVE_DISPOSE;
            m_SpinLock.Release(oldIrql);
        }
        else {
            m_ObjectFlags |= FXOBJECT_FLAGS_PASSIVE_CALLBACKS | FXOBJECT_FLAGS_PASSIVE_DISPOSE;
        }
    }

Referenced by Commit(), FxPkgGeneral::ConfigureConstraints(), FxDriver::ConfigureConstraints(), FxIoQueue::ConfigureConstraints(), FxPagedLookasideListFromPool::FxPagedLookasideListFromPool(), FxPagedObject::FxPagedObject(), FxWorkItem::FxWorkItem(), and FxSystemWorkItem::Initialize().

MarkPassiveDispose()

VOID FxObject::MarkPassiveDispose ( __in FxObjectLockState  State = ObjectLock )

inline

Definition at line 944 of file fxobject.hpp.

    {
        //
        // Object which can have > passive level locks, but needs to be Dispose()'d
        // at passive level.  This means that the object's client cleanup
        // routines will also be guaranteed to run at passive.
        //
        if (State == ObjectLock) {
            KIRQL   oldIrql;
 
            m_SpinLock.Acquire(&oldIrql);
            m_ObjectFlags |= FXOBJECT_FLAGS_PASSIVE_DISPOSE;
            m_SpinLock.Release(oldIrql);
        }
        else {
            m_ObjectFlags |= FXOBJECT_FLAGS_PASSIVE_DISPOSE;
        }
    }

Referenced by FxIoTarget::Construct(), FxDeviceBase::FxDeviceBase(), FxDpc::FxDpc(), FxInterrupt::FxInterrupt(), FxIoQueue::FxIoQueue(), FxString::FxString(), and FxTimer::FxTimer().

MarkTraceState()

VOID FxObject::MarkTraceState ( VOID  )

inline

Definition at line 912 of file fxobject.hpp.

    {
        m_ObjectFlags |= FXOBJECT_FLAGS_TRACE_STATE;
    }

operator delete()

VOID FxObject::operator delete

(

__in PVOID

Memory

)

Definition at line 306 of file fxobject.cpp.

{
    ASSERT(Memory != NULL);
 
 
 
 
 
 
 
 
 
 
 
 
 
    FxPoolFree(_GetBase((FxObject*) Memory));
}

operator new() [1/2]

PVOID __inline FxObject::operator new ( __in size_t  Size, __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in FxObjectType  Type  )

inline

Definition at line 538 of file fxobject.hpp.

    {
        UNREFERENCED_PARAMETER(Type);
 
        return FxObjectHandleAlloc(FxDriverGlobals,
                                   NonPagedPool,
                                   Size,
                                   0,
                                   WDF_NO_OBJECT_ATTRIBUTES,
                                   0,
                                   Type);
    }

operator new() [2/2]

PVOID __inline FxObject::operator new ( __in size_t  Size, __in PFX_DRIVER_GLOBALS  FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES  Attributes, __in USHORT  ExtraSize = 0  )

inline

Definition at line 557 of file fxobject.hpp.

    {
        return FxObjectHandleAlloc(FxDriverGlobals,
                                   NonPagedPool,
                                   Size,
                                   0,
                                   Attributes,
                                   ExtraSize,
                                   FxObjectTypeExternal);
    }

ParentDeleteEvent()

VOID FxObject::ParentDeleteEvent ( VOID  )

private

Definition at line 611 of file fxobjectstatemachine.cpp.

{
    KIRQL oldIrql;
 
    //
    // Note: It's ok for an object to already be in the delete
    //       state since there can be an allowed race between
    //       parent disposing an object, and the DeleteObject()
    //       call on the object itself.
    //
    m_SpinLock.Acquire(&oldIrql);
 
    //
    // We no longer have a parent object
    //
    m_ParentObject = NULL;
 
    //
    // Perform the right action based on the objects current state
    //
    switch(m_ObjectState) {
    case FxObjectStateWaitingForParentDeleteAndDisposed:
    case FxObjectStateDisposed:
        //
        // This will release the spinlock
        //
        DeletedAndDisposedWorkerLocked(oldIrql, TRUE);
        break;
 
    case FxObjectStateDeletedDisposing:
        //
        // Do nothing, workitem will move into disposed
        //
        TraceDroppedEvent(FxObjectDroppedEventParentDeleteEvent);
        m_SpinLock.Release(oldIrql);
        break;
 
    case FxObjectStateDeletedAndDisposed:     // Do nothing, already deleted
        m_SpinLock.Release(oldIrql);
        break;
 
    case FxObjectStateDisposingDisposeChildren:
        //
        // In the process of deleting, ignore it
        //
        m_SpinLock.Release(oldIrql);
        break;
 
    // These are bad states for this event
 
 
 
 
 
    case FxObjectStateCreated:
    case FxObjectStateWaitingForEarlyDispose:
 
    case FxObjectStateInvalid:
    case FxObjectStateDestroyed:
    default:
        //
        // Bad state
        //
        ASSERT(FALSE);
        m_SpinLock.Release(oldIrql);
        break;
    }
}

Referenced by DestroyChildren().

PerformEarlyDispose()

BOOLEAN FxObject::PerformEarlyDispose ( VOID  )

private

Definition at line 476 of file fxobjectstatemachine.cpp.

{
    KIRQL oldIrql;
    BOOLEAN result;
 
    //
    // By default we assume that the dispose was synchronous
    //
    result = TRUE;
 
 
    //
    // It's OK for an object to already be disposing due to
    // a parent delete call.
    //
    // To check for verifier errors in which two calls to
    // PerformEarlyDispose() occur, a separate flag is used
    // rather than complicating the state machine.
    //
    m_SpinLock.Acquire(&oldIrql);
 
    //
    // Perform the right action based on the objects current state
    //
    switch(m_ObjectState) {
    case FxObjectStateCreated:
        //
        // Start dispose, move into Disposing state
        // returns with m_SpinLock released
        //
        result = PerformEarlyDisposeWorkerAndUnlock(oldIrql, FALSE);
        break;
 
    case FxObjectStateWaitingForEarlyDispose:
        //
        // Start the dispose path.
        //
        result = PerformEarlyDisposeWorkerAndUnlock(oldIrql, FALSE);
        break;
 
    case FxObjectStateDeferedDisposing:
        //
        // We should only get an early dispose in this state once we have thunked
        // to passive level via the dispose list.
        //
        result = PerformDisposingDisposeChildrenLocked(oldIrql, FALSE);
        break;
 
    case FxObjectStateWaitingForParentDeleteAndDisposed: // Do nothing, parent object will delete and dispose
    case FxObjectStateDisposed:               // Do nothing
    case FxObjectStateDisposingEarly:         // Do nothing
    case FxObjectStateDeletedDisposing:       // Do nothing, workitem will moved into disposed
    case FxObjectStateDeletedAndDisposed:
        TraceDroppedEvent(FxObjectDroppedEventPerformEarlyDispose);
        m_SpinLock.Release(oldIrql);
        break;
 
    // These are bad states for this event
    case FxObjectStateInvalid:
    case FxObjectStateDestroyed:
 
    default:
        TraceDroppedEvent(FxObjectDroppedEventPerformEarlyDispose);
        // Bad state
        ASSERT(FALSE);
        m_SpinLock.Release(oldIrql);
        break;
    }
 
    return result;
}

ProcessDestroy()

VOID FxObject::ProcessDestroy ( VOID  )

private

Definition at line 251 of file fxobjectstatemachine.cpp.

{
    FxTagTracker* pTagTracker;
 
    //
    // Set the debug info to NULL so that we don't use it after the
    // SelfDestruct call.  Setting the DestroyFunction to NULL
    // will also prevent reuse of the REF_OBJ after it has been destroyed.
    //
    pTagTracker = GetTagTracker();
 
    //
    // We will free debug info later.  It useful to hang on to the debug
    // info after the destructor has been called for debugging purposes.
    //
    if (pTagTracker != NULL) {
        pTagTracker->CheckForAbandondedTags();
    }
 
    //
    // Call the destroy callback *before* any desctructor is called.  This
    // way the callback has access to a full fledged object that hasn't been
    // cleaned up yet.
    //
    // We only do this for committed objects.  A non committed object will
    // *NOT* have additional contexts to free.
    //
    if (m_ObjectSize > 0 && IsCommitted()) {
        FxContextHeader* pHeader, *pNext;
        WDFOBJECT h;
        BOOLEAN first;
 
        //
        // We are getting the object handle when the ref count is zero.  We
        // don't want to ASSERT in this case.
        //
        h = GetObjectHandleUnchecked();
 
 
 
 
 
 
 
 
 
 
 
 
 
        for (pHeader = GetContextHeader();
             pHeader != NULL;
             pHeader = pHeader->NextHeader) {
 
            //
            // Cleanup *may* have been called earlier in the objects
            // destruction, and in this case the EvtCleanupCallback will
            // be set to NULL. Ensuring its always called provides
            // symmetry to the framework.
            //
 
            //
            // No need to interlockexchange out the value of
            // EvtCleanupCallback because any codepath that might be calling
            // CallCleanup must have a valid reference and no longer have
            // any outstanding references
            //
            if (pHeader->EvtCleanupCallback != NULL) {
                pHeader->EvtCleanupCallback(h);
                pHeader->EvtCleanupCallback = NULL;
            }
 
            if (pHeader->EvtDestroyCallback != NULL) {
                pHeader->EvtDestroyCallback(h);
                pHeader->EvtDestroyCallback = NULL;
            }
        }
 
        first = TRUE;
        for (pHeader = GetContextHeader(); pHeader != NULL; pHeader = pNext) {
 
            pNext = pHeader->NextHeader;
 
            //
            // The first header is embedded, so it will be freed with the
            // object
            //
            if (first == FALSE) {
                FxPoolFree(pHeader);
            }
 
            first = FALSE;
        }
    }
 
 
 
 
 
 
 
 
 
 
    //
    // NOTE:  The delete of the tag tracker *MUST* occur before the SelfDestruct()
    // of this object.  The tag tracker has a back pointer to this object which
    // it dereferences in its own destructor.  If SelfDestruct() is called
    // first, then ~FxTagTracker will touch freed pool and bugcheck.
    //
    if (pTagTracker != NULL) {
        GetDebugExtension()->TagTracker = NULL;
        delete pTagTracker;
    }
 
    //
    // See NOTE above.
    //
    SelfDestruct();
}

Referenced by DeferredDisposeWorkItem(), and FinalRelease().

QueryInterface()

_Must_inspect_result_ NTSTATUS FxObject::QueryInterface ( __in FxQueryInterfaceParams *  Params )

virtual

Reimplemented in FxFileObject, FxIoQueue, FxIoTargetRemote, FxRequest, FxRequestMemory, and FxUserObject.

Definition at line 255 of file fxobject.cpp.

{
    NTSTATUS status;
 
    if (Params->Type == FX_TYPE_OBJECT) {
        *Params->Object = this;
        status = STATUS_SUCCESS;
    }
    else {
        status = STATUS_NOINTERFACE;
    }
 
    return status;
}

Referenced by AutoComplete_LoadList(), CBDAPinControl_fnConstructor(), FxFileObject::QueryInterface(), FxIoQueue::QueryInterface(), FxRequest::QueryInterface(), FxUserObject::QueryInterface(), FxDeviceBase::QueryInterface(), FxDriver::QueryInterface(), FxIoTarget::QueryInterface(), FxMemoryObject::QueryInterface(), and FxSystemWorkItem::QueryInterface().

QueueDeferredDisposeLocked()

VOID FxObject::QueueDeferredDisposeLocked ( __in FxObjectState  NewDeferedState )

private

Definition at line 958 of file fxobjectstatemachine.cpp.

{
    //
    // Queue workitem, which will run DisposeChildrenWorker()
    //
    ASSERT(m_Globals != NULL);
    ASSERT(m_Globals->Driver != NULL);
 
    SetObjectStateLocked(NewDeferedState);
 
    //FxToObjectItf::FxAddToDisposeList(m_DeviceBase, m_Globals, this);
    if (m_DeviceBase != NULL) {
        m_DeviceBase->AddToDisposeList(this);
    }
    else {
        m_Globals->Driver->GetDisposeList()->Add(this);
    }
}

Release()

virtual ULONG FxObject::Release ( __in_opt PVOID  Tag = NULL, __in LONG  Line = 0, __in_opt PSTR  File = NULL  )

inlinevirtual

Definition at line 853 of file fxobject.hpp.

    {
        FxTagTracker* pTagTracker;
        ULONG c;
 
        pTagTracker = GetTagTracker();
        if (pTagTracker != NULL) {
            pTagTracker->UpdateTagHistory(Tag, Line, File, TagRelease, m_Refcnt - 1);
        }
 
        c = InterlockedDecrement(&m_Refcnt);
 
        if (c == 0) {
            FinalRelease();
        }
 
        return c;
    }

Referenced by FxSystemWorkItem::_Create(), _DereferenceActual(), CicBridge::ActivateIMMX(), CBDADeviceControl_fnConstructor(), CBDAPinControl_fnConstructor(), CicBridge::ConfigureGeneral(), CicBridge::ConfigureRegisterWord(), CKsProxy::CreateClockInstance(), FxPkgIo::EnqueueRequest(), FxDriver::GetRegistryPath(), CKsAllocator::KsCreateAllocatorAndGetHandle(), MRUList_DataList_0(), MRUList_DataList_1(), MRUList_DataList_2(), MRUList_PidlList_0(), FxMemoryObject::Release(), FxRequest::Release(), FxRequest::ReleaseOverride(), and CKsProxy::SetSyncSource().

ReleaseOverride()

virtual ULONG FxObject::ReleaseOverride ( __in WDFOBJECT_OFFSET  Offset, __in_opt PVOID  Tag = NULL, __in LONG  Line = 0, __in_opt PSTR  File = NULL  )

inlinevirtual

Definition at line 892 of file fxobject.hpp.

    {
        UNREFERENCED_PARAMETER(Offset);
 
        return Release(Tag, Line, File);
    }

Referenced by _DereferenceActual().

RemoveChildObjectInternal()

_Must_inspect_result_ NTSTATUS FxObject::RemoveChildObjectInternal ( __in FxObject *  ChildObject )

private

Definition at line 770 of file fxobject.cpp.

{
    KIRQL oldIrql;
 
    m_SpinLock.Acquire(&oldIrql);
 
    //
    // Object is already being deleted, this object will be removed as a child
    // by the parents Dispose()
    //
    if (m_ObjectState != FxObjectStateCreated) {
        TraceDroppedEvent(FxObjectDroppedEventRemoveChildObjectInternal);
        m_SpinLock.Release(oldIrql);
        return STATUS_DELETE_PENDING;
    }
 
    //
    // We should be the child object's parent
    //
    ASSERT(ChildObject->m_ParentObject == this);
 
    //
    // Child should be on our list
    //
    ASSERT(!IsListEmpty(&ChildObject->m_ChildEntry));
 
    //
    // We should have entries if someone wants to remove from our list
    //
    ASSERT(!IsListEmpty(&m_ChildListHead));
 
    RemoveEntryList(&ChildObject->m_ChildEntry);
 
    //
    // Mark it removed
    //
    InitializeListHead(&ChildObject->m_ChildEntry);
 
    //
    // We did not take a reference on the child object when it
    // was added to the list, so we do not dereference it
    // on the remove call.
    //
    // Note: We only dereference child objects when we are deleted
    //       ourselves, not when the child object manually breaks the
    //       association by calling this method.
    //
    m_SpinLock.Release(oldIrql);
 
    return STATUS_SUCCESS;
}

Referenced by DeleteEarlyDisposedObject(), DeleteObject(), EarlyDispose(), and RemoveParentAssignment().

RemoveParentAssignment()

_Must_inspect_result_ NTSTATUS FxObject::RemoveParentAssignment

(

VOID

)

Definition at line 566 of file fxobjectstatemachine.cpp.

{
    KIRQL oldIrql;
    NTSTATUS status;
 
    m_SpinLock.Acquire(&oldIrql);
 
    //
    // Object is already being deleted, this object will be removed as a child
    // by the parents Dispose()
    //
    if (m_ObjectState != FxObjectStateCreated) {
        TraceDroppedEvent(FxObjectDroppedEventRemoveParentAssignment);
        m_SpinLock.Release(oldIrql);
        return STATUS_DELETE_PENDING;
    }
 
    // We should have a parent
    ASSERT(m_ParentObject != NULL);
 
    status = m_ParentObject->RemoveChildObjectInternal(this);
    if (NT_SUCCESS(status)) {
        m_ParentObject = NULL;
    }
 
    m_SpinLock.Release(oldIrql);
 
    return status;
}

RemoveParentAssociation()

_Must_inspect_result_ NTSTATUS FxObject::RemoveParentAssociation ( VOID  )

private

SelfDestruct()

virtual VOID FxObject::SelfDestruct ( VOID  )

inlineprotectedvirtual

Reimplemented in FxMemoryBufferFromLookaside, FxMemoryBufferFromPoolLookaside, and FxRequestFromLookaside.

Definition at line 437 of file fxobject.hpp.

    {
        delete this;
    }

Referenced by ProcessDestroy().

SetCOMWrapper()

void FxObject::SetCOMWrapper ( __drv_aliasesMem PVOID  Wrapper )

inline

Definition at line 520 of file fxobject.hpp.

{ m_COMWrapper = Wrapper; }

SetDeviceBase()

VOID FxObject::SetDeviceBase ( __in CfxDeviceBase *  DeviceBase )

inline

Definition at line 797 of file fxobject.hpp.

    {
        m_DeviceBase = DeviceBase;
    }

Referenced by FxDevice::_OpenKey(), FxDeviceBase::FxDeviceBase(), FxMemoryPagedBufferFromPool::FxMemoryPagedBufferFromPool(), FxPagedLookasideListFromPool::FxPagedLookasideListFromPool(), FxIoTarget::Init(), FxIoTargetRemote::InitRemote(), and FxIoQueue::QueueDriverCreatedRequest().

SetNoContextHeader()

VOID FxObject::SetNoContextHeader ( VOID  )

inline

Definition at line 594 of file fxobject.hpp.

    {
        m_ObjectSize = 0;
    }

SetObjectStateLocked()

VOID __inline FxObject::SetObjectStateLocked ( __in FxObjectState  NewState )

inlineprivate

Definition at line 369 of file fxobject.hpp.

    {
        if (m_ObjectFlags & FXOBJECT_FLAGS_TRACE_STATE) {
            DoTraceLevelMessage(
                m_Globals, TRACE_LEVEL_VERBOSE, TRACINGOBJECT,
                "Object %p, WDFOBJECT %p transitioning from %!FxObjectState! to "
                "%!FxObjectState!", this, GetObjectHandleUnchecked(),
                m_ObjectState, NewState);
            if (IsDebug()) {
                FxObjectDebugExtension* pExtension;
 
                pExtension = GetDebugExtension();
                pExtension->StateHistory[
                    InterlockedIncrement(&pExtension->StateHistoryIndex)] =
                    (BYTE) NewState;
            }
        }
 
        m_ObjectState = (USHORT) NewState;
    }

Referenced by DeferredDisposeWorkItem(), DeleteEarlyDisposedObject(), DeleteObject(), EarlyDispose(), FinalRelease(), QueueDeferredDisposeLocked(), and ~FxObject().

ShouldDeferDisposeLocked()

BOOLEAN FxObject::ShouldDeferDisposeLocked ( __out_opt PKIRQL  PreviousIrql = NULL )

inlineprivate

Definition at line 1383 of file fxobject.hpp.

    {
        if (IsForceDisposeThreadLocked()) {
            return TRUE;
        }
        else if (IsPassiveDisposeLocked()) {
            //
            // Only call KeGetCurrentIrql() if absolutely necessary.  It is an
            // expensive call and we want to minimize the cycles required when
            // destroying an object  that requires passive rundown
            //
 
            //
            // Cases:
            // 1)  Caller does not know the current IRQL, so we must query for it
            //
            // 2)  Caller knew prev IRQL, so we used the caller's value
            //
            if (PreviousIrql == NULL) {                  // case 1
                if (Mx::MxGetCurrentIrql() != PASSIVE_LEVEL) {
                    return TRUE;
                }
            }
            else if (*PreviousIrql != PASSIVE_LEVEL) {   // case 2
                return TRUE;
            }
        }
 
        return FALSE;
    }

Referenced by FinalRelease().

TraceDroppedEvent()

VOID __inline FxObject::TraceDroppedEvent ( __in FxObjectDroppedEvent  Event )

inline

Definition at line 930 of file fxobject.hpp.

    {
        if (IsTraceState()) {
            DoTraceLevelMessage(
                m_Globals, TRACE_LEVEL_INFORMATION, TRACINGOBJECT,
                "Object %p, WDFOBJECT %p, state %!FxObjectState! dropping event"
                " %!FxObjectDroppedEvent!",
                this, GetObjectHandleUnchecked(), m_ObjectState, Event);
        }
    }

Referenced by AddChildObjectInternal(), AssignParentObject(), DeleteObject(), ParentDeleteEvent(), PerformEarlyDispose(), RemoveChildObjectInternal(), and RemoveParentAssignment().

Friends And Related Function Documentation

GetTriageInfo

VOID GetTriageInfo ( VOID  )

friend

Definition at line 75 of file fxlibrarycommon.cpp.

{
    // Object
    _WdfObjectTriageInfo.RawObjectSize = sizeof(FxObject);
    _WdfObjectTriageInfo.ObjectType = FIELD_OFFSET(FxObject, m_Type);
    _WdfObjectTriageInfo.TotalObjectSize = FIELD_OFFSET(FxObject, m_ObjectSize);
    _WdfObjectTriageInfo.ChildListHead = FIELD_OFFSET(FxObject, m_ChildListHead);
    _WdfObjectTriageInfo.ChildEntry = FIELD_OFFSET(FxObject, m_ChildEntry);
    _WdfObjectTriageInfo.Globals = FIELD_OFFSET(FxObject, m_Globals);
    _WdfObjectTriageInfo.ParentObject = FIELD_OFFSET(FxObject, m_ParentObject);
 
    // Context Triage Info
    _WdfContextTriageInfo.HeaderSize = sizeof(FxContextHeader);
    _WdfContextTriageInfo.NextHeader = FIELD_OFFSET(FxContextHeader, NextHeader);
    _WdfContextTriageInfo.Object = FIELD_OFFSET(FxContextHeader, Object);
    _WdfContextTriageInfo.TypeInfoPtr = FIELD_OFFSET(FxContextHeader, ContextTypeInfo);
    _WdfContextTriageInfo.Context = FIELD_OFFSET(FxContextHeader, Context);
 
    // Context type Triage info
    _WdfContextTypeTriageInfo.TypeInfoSize = sizeof(WDF_OBJECT_CONTEXT_TYPE_INFO);
    _WdfContextTypeTriageInfo.ContextSize = FIELD_OFFSET(WDF_OBJECT_CONTEXT_TYPE_INFO, ContextSize);
    _WdfContextTypeTriageInfo.ContextName = FIELD_OFFSET(WDF_OBJECT_CONTEXT_TYPE_INFO, ContextName);
 
    // WdfRequest Queue
    _WdfQueueTriageInfo.QueueSize = sizeof(FxIoQueue);
    _WdfQueueTriageInfo.IrpQueue1 = FIELD_OFFSET(FxIoQueue, m_Queue);
    _WdfQueueTriageInfo.IrpQueue2 = FIELD_OFFSET(FxIoQueue, m_DriverCancelable);
    _WdfQueueTriageInfo.RequestList1 = FIELD_OFFSET(FxIoQueue, m_Cancelled);
    _WdfQueueTriageInfo.RequestList2 = FIELD_OFFSET(FxIoQueue, m_CanceledOnQueueList);
    _WdfQueueTriageInfo.FwdProgressContext = FIELD_OFFSET(FxIoQueue, m_FwdProgContext);
    _WdfQueueTriageInfo.PkgIo = FIELD_OFFSET(FxIoQueue, m_PkgIo);
 
    // Forward Progress
    _WdfFwdProgressTriageInfo.ReservedRequestList =
        FIELD_OFFSET(FXIO_FORWARD_PROGRESS_CONTEXT, m_ReservedRequestList);
    _WdfFwdProgressTriageInfo.ReservedRequestInUseList =
        FIELD_OFFSET(FXIO_FORWARD_PROGRESS_CONTEXT, m_ReservedRequestInUseList);
    _WdfFwdProgressTriageInfo.PendedIrpList =
        FIELD_OFFSET(FXIO_FORWARD_PROGRESS_CONTEXT, m_PendedIrpList);
 
    // Irp Queue
    _WdfIrpQueueTriageInfo.IrpQueueSize = sizeof(FxIrpQueue);
    _WdfIrpQueueTriageInfo.IrpListHeader = FIELD_OFFSET(FxIrpQueue, m_Queue);
    _WdfIrpQueueTriageInfo.IrpListEntry = FIELD_OFFSET(IRP, Tail.Overlay.ListEntry);
    _WdfIrpQueueTriageInfo.IrpContext = FIELD_OFFSET(IRP,
        Tail.Overlay.DriverContext[FX_IRP_QUEUE_CSQ_CONTEXT_ENTRY]);
 
    // WdfRequest
    _WdfRequestTriageInfo.RequestSize = sizeof(FxRequest);
    _WdfRequestTriageInfo.CsqContext = FIELD_OFFSET(FxRequest, m_CsqContext);
    _WdfRequestTriageInfo.FxIrp = FIELD_OFFSET(FxRequest, m_Irp);
    _WdfRequestTriageInfo.ListEntryQueueOwned =
        FIELD_OFFSET(FxRequest, m_OwnerListEntry);
    _WdfRequestTriageInfo.ListEntryQueueOwned2 =
        FIELD_OFFSET(FxRequest, m_OwnerListEntry2);
    _WdfRequestTriageInfo.RequestListEntry =
        FIELD_OFFSET(FxRequest, m_ListEntry);
    _WdfRequestTriageInfo.FwdProgressList =
        FIELD_OFFSET(FxRequest, m_ForwardProgressList);
 
    // WdfDevice
    _WdfDeviceTriageInfo.DeviceInitSize = sizeof(WDFDEVICE_INIT);
    _WdfDeviceTriageInfo.DeviceDriver = FIELD_OFFSET(FxDevice, m_Driver);
 
    // FxIrp
    _WdfIrpTriageInfo.FxIrpSize = sizeof(FxIrp);
    _WdfIrpTriageInfo.IrpPtr = FIELD_OFFSET(FxIrp, m_Irp);
}

Member Data Documentation

union { ... } FxObject::@4770

union { ... } FxObject::@4772

CanDefer [1/2]

__in BOOLEAN FxObject::CanDefer

private

Definition at line 1431 of file fxobject.hpp.

CanDefer [2/2]

__in __drv_restoresIRQL KIRQL __in BOOLEAN FxObject::CanDefer

private

Definition at line 1466 of file fxobject.hpp.

Committed

USHORT FxObject::Committed

Definition at line 276 of file fxobject.hpp.

DeleteCalled

USHORT FxObject::DeleteCalled

Definition at line 275 of file fxobject.hpp.

EarlyDisposedExt

USHORT FxObject::EarlyDisposedExt

Definition at line 281 of file fxobject.hpp.

ForceDisposeThread

USHORT FxObject::ForceDisposeThread

Definition at line 278 of file fxobject.hpp.

FxDisposeList

friend FxObject::FxDisposeList

private

Definition at line 236 of file fxobject.hpp.

HasDebug

USHORT FxObject::HasDebug

Definition at line 280 of file fxobject.hpp.

m_ChildEntry

LIST_ENTRY FxObject::m_ChildEntry

private

Definition at line 311 of file fxobject.hpp.

Referenced by AssignParentObject(), Construct(), DestroyChildren(), and ~FxObject().

m_ChildListHead

LIST_ENTRY FxObject::m_ChildListHead

private

Definition at line 293 of file fxobject.hpp.

Referenced by AddChildObjectInternal(), Construct(), DestroyChildren(), RemoveChildObjectInternal(), and ~FxObject().

m_COMWrapper

PVOID FxObject::m_COMWrapper

private

Definition at line 243 of file fxobject.hpp.

Referenced by GetCOMWrapper(), and SetCOMWrapper().

m_Device

CfxDevice* FxObject::m_Device

Definition at line 329 of file fxobject.hpp.

Referenced by __drv_when(), FxPkgPdo::_PnpEject(), FxPkgFdo::_PnpPassDown(), FxPkgPdo::_PnpQueryBusInformation(), FxPkgPdo::_PnpQueryDeviceText(), FxPkgPdo::_PnpQueryId(), FxPkgPdo::_PnpSetLock(), FxPkgFdo::_PowerPassDown(), FxPkgPdo::_QueryCapsWorkItem(), FxPkgGeneral::AcquireRemoveLockForClose(), FxPkgPdo::AddEjectionDevice(), FxPkgPnp::AddRemovalDevice(), FxPkgPnp::AddUsageDevice(), FxPkgPnp::AllocateEnumInfo(), FxIoQueue::AllocateReservedRequest(), FxInterrupt::AssignResources(), FxDmaSystemTransaction::CallEvtDmaCompleted(), FxPkgPnp::CleanupStateMachines(), FxPkgPnp::CommitUsageNotification(), FxPkgPnp::CompletePnpRequest(), FxPkgPnp::CompletePowerRequest(), FxUsbPipeContinuousReader::Config(), FxPkgGeneral::ConfigureConstraints(), FxIoQueue::ConfigureConstraints(), FxPkgGeneral::ConfigureFileObjectClass(), FxInterrupt::Connect(), FxInterrupt::ConnectInternal(), FxPkgGeneral::CreateCompleted(), FxPkgFdo::CreateDefaultDeviceList(), FxChildList::CreateDevice(), FxPkgPnp::CreatePowerThread(), FxPkgPnp::CreatePowerThreadIfNeeded(), FxPkgIo::CreateQueue(), FxInterrupt::CreateWakeInterruptMachine(), FxPkgGeneral::DecrementOpenHandleCount(), FxPkgPnp::DeleteDevice(), FxFileObject::DeleteFileObjectFromFailedCreate(), FxInterrupt::DeleteObject(), FxPkgFdo::DeleteSymbolicLinkOverload(), FxPkgPdo::DeleteSymbolicLinkOverload(), FxInterrupt::Disconnect(), FxInterrupt::DisconnectInternal(), FxPkgPnp::DisconnectInterruptNP(), FxDefaultIrpHandler::Dispatch(), FxPkgPnp::Dispatch(), FxWmiIrpHandler::Dispatch(), FxPkgGeneral::Dispatch(), FxPkgIo::Dispatch(), FxPkgFdo::DispatchDeviceSetPower(), FxPkgPdo::DispatchDeviceSetPower(), FxPkgIo::DispatchStep1(), FxPkgIo::DispatchStep2(), FxPkgFdo::DispatchSystemSetPower(), FxPkgPdo::DispatchSystemSetPower(), FxPkgPnp::DispatchWaitWake(), FxPkgIo::DispathToInCallerContextCallback(), FxChildList::Dispose(), FxInterrupt::DpcHandler(), FxChildList::EndScan(), FxPkgPnp::FilterResourceRequirements(), FxInterrupt::FlushAndRundown(), FxInterrupt::ForceDisconnect(), FxInterrupt::ForceReconnect(), FxPkgGeneral::ForwardCreateRequest(), FxIoQueue::ForwardRequestToParent(), FxChildList::FxChildList(), FxFileObject::FxFileObject(), FxIoQueue::FxIoQueue(), FxPackage::FxPackage(), FxPkgIo::FxPkgIo(), FxChildList::GetDevice(), FxFileObject::GetDevice(), FxInterrupt::GetDevice(), FxIoQueue::GetDevice(), GetDevice(), FxPackage::GetDevice(), FxPkgIo::GetDevice(), FxRequest::GetDevice(), FxIoTarget::GetDeviceHandle(), FxIoTargetSelf::GetDispatchQueue(), FxPkgIo::GetDriver(), FxPkgIo::GetIoQueueListLocked(), FxPkgPnp::HandleQueryBusInformation(), FxPkgPnp::HandleQueryBusRelations(), FxPkgPnp::HandleQueryDeviceRelations(), FxPkgPnp::HandleQueryInterface(), FxPkgFdo::HandleQueryPnpDeviceStateCompletion(), if(), FxInterrupt::Initialize(), FxChildList::Initialize(), FxIoQueue::Initialize(), FxTimer::Initialize(), FxWorkItem::Initialize(), FxPkgFdo::Initialize(), FxPkgPdo::Initialize(), FxPkgPnp::Initialize(), FxInterrupt::InitializeWorker(), FxInterrupt::InterruptDisableInvokeCallback(), FxInterrupt::InterruptEnableInvokeCallback(), FxUsbDevice::IsObjectDisposedOnRemove(), FxUsbInterface::MakeAndConfigurePipes(), FxPkgPnp::NotPowerPolicyOwnerEnterNewState(), FxPkgGeneral::OnCleanup(), FxPkgGeneral::OnClose(), FxPkgGeneral::OnCreate(), FxPkgGeneral::OnShutdown(), FxPkgPnp::PnpCheckAndIncrementRestartCount(), FxPkgPnp::PnpCleanupForRemove(), FxPkgPnp::PnpDeviceUsageNotification(), FxPkgPnp::PnpEnableInterfacesAndRegisterWmi(), FxPkgPnp::PnpEnterNewState(), FxPkgPdo::PnpEventEjectHardwareOverload(), FxPkgPdo::PnpEventPdoRemovedOverload(), FxPkgPnp::PnpEventRemovedCommonCode(), FxPkgFdo::PnpFilterResourceRequirements(), FxPkgPnp::PnpMatchResources(), FxPkgPnp::PnpProcessEvent(), FxPkgPnp::PnpProcessEventInner(), FxPkgPdo::PnpQueryCapabilities(), FxPkgPdo::PnpQueryDeviceRelations(), FxPkgPdo::PnpQueryResourceRequirements(), FxPkgPdo::PnpQueryResources(), FxPkgPnp::PnpReleaseHardware(), FxPkgFdo::PnpSendStartDeviceDownTheStackOverload(), FxPkgGeneral::PostCreateDeviceInitialize(), FxPkgFdo::PostCreateDeviceInitialize(), FxPkgPdo::PowerCheckParentOverload(), FxPkgPnp::PowerConnectInterruptFailed(), FxPkgPdo::PowerDisableWakeAtBusOverload(), FxPkgPdo::PowerEnableWakeAtBusOverload(), FxPkgPnp::PowerEnterNewState(), FxPkgPnp::PowerGotoDx(), FxPkgPnp::PowerGotoDxIoStopped(), FxPkgPnp::PowerGotoDxIoStoppedNP(), FxPkgPnp::PowerMakeWakeRequestNonCancelable(), FxPkgPdo::PowerNotifyParentChildWakeArmed(), FxPkgPdo::PowerNotifyParentChildWakeDisarmed(), FxPkgPdo::PowerParentPowerDereference(), FxPkgPnp::PowerPolicyCanIdlePowerDown(), FxPkgPnp::PowerPolicyDisarmWakeFromSx(), FxPkgPnp::PowerPolicyEnterNewState(), FxPkgPnp::PowerPolicyProcessEvent(), FxPkgPnp::PowerPolicyProcessEventInner(), FxPkgPnp::PowerPolicySendDevicePowerRequest(), FxPkgPnp::PowerPolicySendWaitWakeRequest(), FxPkgPnp::PowerPolicySetS0IdleSettings(), FxPkgPnp::PowerPolicyUpdateSystemWakeSource(), FxPkgPnp::PowerProcessEvent(), FxPkgPnp::PowerProcessEventInner(), FxPkgPnp::PowerSetDevicePowerState(), FxChildList::ProcessBusRelations(), FxPkgPnp::ProcessDelayedDeletion(), FxChildList::ProcessModificationsLocked(), FxPkgFdo::ProcessRemoveDeviceOverload(), FxPkgPdo::ProcessRemoveDeviceOverload(), FxPkgPnp::QueryForCapabilities(), FxPkgPnp::QueryForD3ColdInterface(), FxPkgFdo::QueryForPowerThread(), FxPkgFdo::QueryForReenumerationInterface(), FxIoQueue::QueueDriverCreatedRequest(), FxPkgFdo::RaiseDevicePower(), FxPkgPnp::ReadRegistryS0Idle(), FxPkgPnp::ReadRegistrySxWake(), FxPkgPnp::ReadStateFromRegistry(), FxInterrupt::ReportActive(), FxInterrupt::ReportInactive(), FxPkgIo::ResetStateForRestart(), FxPkgIo::ResumeProcessingForPower(), FxPkgPnp::RevertUsageNotificationFlags(), FxPkgPnp::SaveState(), FxUsbDevice::SelectConfig(), FxUsbInterface::SelectSetting(), FxIoTargetSelf::Send(), FxPkgFdo::SendIrpSynchronously(), FxPkgPnp::SetDeviceFailed(), FxPkgPnp::SetInternalFailure(), FxPkgPnp::SetPendingPnpIrp(), FxIoQueue::SetTransitionFromEmpty(), FxPkgPnp::SetUsageNotificationFlags(), FxPkgIo::StopProcessingForPower(), FxPkgPnp::UpdateWmiInstance(), FxPkgPnp::ValidateCmResource(), FxPkgPnp::ValidateInterruptResourceCm(), FxInterrupt::WorkItemHandler(), FxInterrupt::~FxInterrupt(), FxPkgIo::~FxPkgIo(), and FxPkgPnp::~FxPkgPnp().

m_DeviceBase

CfxDeviceBase* FxObject::m_DeviceBase

Definition at line 328 of file fxobject.hpp.

Referenced by FxDmaScatterGatherTransaction::_AdapterListControl(), Construct(), FxPkgIo::CreateQueue(), FxIoTarget::Dispose(), FxUsbDevice::Dispose(), FxDmaEnabler::Dispose(), GetDeviceBase(), FxDmaEnabler::GetDeviceHandle(), FxDmaEnabler::Initialize(), FxDpc::Initialize(), FxTimer::Initialize(), FxWorkItem::Initialize(), FxInterrupt::InitializeWorker(), FxDmaSystemTransaction::PreMapTransfer(), QueueDeferredDisposeLocked(), SetDeviceBase(), and FxDmaPacketTransaction::StageTransfer().

m_DisposeSingleEntry

SINGLE_LIST_ENTRY FxObject::m_DisposeSingleEntry

private

Definition at line 316 of file fxobject.hpp.

Referenced by _FromDisposeEntry(), Construct(), and ~FxObject().

m_Globals

PFX_DRIVER_GLOBALS FxObject::m_Globals

private

Definition at line 259 of file fxobject.hpp.

Referenced by AllocateTagTracker(), Commit(), Construct(), FinalRelease(), GetDriverGlobals(), IsDisposed(), QueueDeferredDisposeLocked(), SetObjectStateLocked(), and TraceDroppedEvent().

m_ObjectFlags

USHORT FxObject::m_ObjectFlags

Definition at line 263 of file fxobject.hpp.

Referenced by AddContext(), AllocateTagTracker(), CallCleanup(), CallCleanupCallbacks(), ClearEvtCallbacks(), Commit(), Construct(), DeleteEarlyDisposedObject(), EarlyDispose(), IsCommitted(), IsDebug(), IsForceDisposeThreadLocked(), IsNoDeleteDDI(), IsPassiveCallbacksLocked(), IsPassiveDisposeLocked(), IsTraceState(), MarkCommitted(), MarkDeleteCalledLocked(), MarkDisposeOverride(), MarkForceDisposeThread(), MarkNoDeleteDDI(), MarkPassiveCallbacks(), MarkPassiveDispose(), MarkTraceState(), and SetObjectStateLocked().

struct { ... } FxObject::m_ObjectFlagsByName

m_ObjectSize

USHORT FxObject::m_ObjectSize

private

Definition at line 254 of file fxobject.hpp.

Referenced by Commit(), GetContextHeader(), GetObjectHandleUnchecked(), GetObjectSize(), ProcessDestroy(), and SetNoContextHeader().

m_ObjectState

USHORT FxObject::m_ObjectState

private

Definition at line 290 of file fxobject.hpp.

Referenced by AddChildObjectInternal(), AddContext(), AssignParentObject(), Construct(), DeferredDisposeWorkItem(), DeleteEarlyDisposedObject(), DeleteObject(), EarlyDispose(), GetParentObjectReferenced(), IsDisposed(), ParentDeleteEvent(), PerformEarlyDispose(), RemoveChildObjectInternal(), RemoveParentAssignment(), SetObjectStateLocked(), and TraceDroppedEvent().

m_ParentObject

FxObject* FxObject::m_ParentObject

private

Definition at line 303 of file fxobject.hpp.

Referenced by AssignParentObject(), Commit(), Construct(), DeleteEarlyDisposedObject(), DeleteObject(), EarlyDispose(), GetParentObjectReferenced(), ParentDeleteEvent(), RemoveParentAssignment(), and ~FxObject().

m_Refcnt

LONG FxObject::m_Refcnt

private

Definition at line 257 of file fxobject.hpp.

Referenced by AddRef(), Construct(), GetRefCnt(), and Release().

m_SpinLock

MxLock FxObject::m_SpinLock

private

Definition at line 296 of file fxobject.hpp.

Referenced by AddChildObjectInternal(), AddContext(), AssignParentObject(), DeferredDisposeWorkItem(), DeleteEarlyDisposedObject(), DeleteObject(), EarlyDispose(), GetParentObjectReferenced(), IsDisposed(), IsForceDisposeThread(), IsPassiveCallbacks(), IsPassiveDispose(), MarkDisposeOverride(), MarkForceDisposeThread(), MarkNoDeleteDDI(), MarkPassiveCallbacks(), MarkPassiveDispose(), ParentDeleteEvent(), PerformEarlyDispose(), RemoveChildObjectInternal(), and RemoveParentAssignment().

m_Type

WDFTYPE FxObject::m_Type

private

Definition at line 247 of file fxobject.hpp.

Referenced by GetType(), and ~FxObject().

NoDeleteDDI

USHORT FxObject::NoDeleteDDI

Definition at line 274 of file fxobject.hpp.

OldIrql [1/2]

__in __drv_restoresIRQL KIRQL FxObject::OldIrql

private

Definition at line 1465 of file fxobject.hpp.

Referenced by FxDmaPacketTransaction::_Acquires_lock_(), FxDmaPacketTransaction::_Requires_lock_held_(), FxWmiIrpHandler::AddProviderLocked(), and FxWmiIrpHandler::DeferUpdateLocked().

OldIrql [2/2]

__drv_restoresIRQL KIRQL FxObject::OldIrql

private

Definition at line 1473 of file fxobject.hpp.

PassiveCallbacks

USHORT FxObject::PassiveCallbacks

Definition at line 273 of file fxobject.hpp.

Referenced by _GetEffectiveLock().

PassiveDispose

USHORT FxObject::PassiveDispose

Definition at line 277 of file fxobject.hpp.

TraceState

USHORT FxObject::TraceState

Definition at line 282 of file fxobject.hpp.

UfxObject

friend FxObject::UfxObject

private

Definition at line 234 of file fxobject.hpp.

Unlock

__drv_restoresIRQL KIRQL __in BOOLEAN FxObject::Unlock

private

Initial value:

= TRUE
        )

Definition at line 1474 of file fxobject.hpp.

Referenced by __drv_requiresIRQL(), FxFileObject::_CreateFileObject(), FxFileObject::_DestroyFileObject(), FxFileObject::_GetFileObjectFromWdm(), FxIoQueue::_Releases_lock_(), FxIoTarget::_RequestCancelled(), _Requires_lock_held_(), FxDmaPacketTransaction::_Requires_lock_held_(), FxDisposeList::_WorkItemThunk(), FxDisposeList::Add(), FxResourceCollection::AddAt(), FxWmiProvider::AddInstance(), FxPkgIo::AddIoQueue(), FxRequest::AddIrpReference(), FxWmiIrpHandler::AddPowerPolicyProviderAndInstance(), FxWmiIrpHandler::AddProvider(), FxPkgPnp::AddRemovalDevice(), FxPkgPnp::AddUsageDevice(), FxPkgPnp::AllocateDmaEnablerList(), FxPkgPnp::AllocateEnumInfo(), FxIoTarget::CancelSentIo(), FxSystemThread::CancelWorkItem(), FxWmiIrpHandler::Cleanup(), FxUsbInterface::CleanUpAndDelete(), FxUsbDevice::CleanupInterfacePipesAndDelete(), FxDevice::ClearCallbackFlags(), FxRequestBase::ClearVerifierFlags(), FxIoTargetRemote::Close(), FxIoTarget::CompleteCanceledRequest(), FxPkgGeneral::ConfigureForwarding(), FxPkgIo::ConfigureForwarding(), FxIoQueue::DeferredDispatchRequestsFromDpc(), FxIoQueue::DeferredDispatchRequestsFromWorkerThread(), FxFileObject::DeleteFileObjectFromFailedCreate(), FxDevice::DeleteObject(), FxWmiIrpHandler::Deregister(), FxWmiIrpHandler::Dispatch(), FxSystemWorkItem::Dispose(), FxTimer::Dispose(), FxWorkItem::Dispose(), FxDisposeList::DrainListLocked(), FxWorkItem::Enqueue(), FxSystemWorkItem::EnqueueWorker(), FxSystemThread::ExitThread(), FxSystemThread::ExitThreadAsync(), FxWmiIrpHandler::FindProviderReferenced(), FxPkgIo::FlushAllQueuesByFileObject(), FxIoQueue::ForwardRequestWorker(), FX_VF_METHOD(), FxUsbPipeContinuousReader::FxUsbPipeRequestWorkItemHandler(), FxDevice::GetCallbackFlags(), FxRequest::GetCurrentIrpStackLocation(), FxRequest::GetDeviceControlOutputMdl(), FxRequest::GetDeviceControlOutputMemoryObject(), FxRequest::GetFileObject(), FxRequest::GetInformation(), FxWmiProvider::GetInstanceIndex(), FxWmiProvider::GetInstanceReferenced(), FxRequest::GetIrp(), FxRequest::GetMdl(), FxRequest::GetMemoryObject(), FxRequest::GetParameters(), FxPkgPnp::GetPnpCapsInternal(), FxPkgPnp::GetPnpStateInternal(), FxIoQueue::GetRequest(), FxRequest::GetRequestorMode(), FxRequest::GetStatus(), FxRequestBase::GetVerifierFlags(), FxIoTarget::GotoPurgeState(), FxUsbPipe::GotoPurgeState(), FxIoTarget::GotoRemoveState(), FxUsbPipe::GotoRemoveState(), FxIoTarget::GotoStartState(), FxIoTarget::GotoStopState(), FxUsbPipe::GotoStopState(), FxIoTarget::HandleFailedResubmit(), if(), FxSystemThread::Initialize(), FxIoQueue::InsertNewRequestLocked(), FxIoTargetRemote::Open(), FxIoQueue::PeekRequest(), FxUsbDevice::PipesGotoRemoveState(), FxIoQueue::PreRequestCompletedCallback(), FxIoTarget::Purge(), FxUsbDevice::Purge(), FxIoQueue::QueueIdle(), FxIoQueue::QueuePurge(), FxIoQueue::QueueRequest(), FxIoQueue::QueueRequestFromForward(), FxSystemThread::QueueWorkItem(), FxIoQueue::ReadyNotify(), FxSystemThread::Reaper(), FxWmiIrpHandler::Register(), FxResourceCollection::RemoveAndDelete(), FxWmiProvider::RemoveInstance(), FxPkgIo::RemoveIoQueue(), FxWmiIrpHandler::RemoveProvider(), FxIoQueue::RequestCancelable(), FxIoTarget::RequestCompletionRoutine(), FxWmiIrpHandler::ResetStateForPdoRestart(), FxIoQueue::ResetStateForRestart(), FxPkgIo::ResetStateForRestart(), FxUsbPipeContinuousReader::ResubmitRepeater(), FxPkgIo::ResumeProcessingForPower(), FxIoQueue::ResumeProcessingForPower(), FxRequest::Reuse(), FxDevice::SetCallbackFlags(), FxRequest::SetInformation(), FxPkgPnp::SetPnpCaps(), FxPkgPnp::SetPnpState(), FxRequestBase::SetVerifierFlags(), FxTimer::Start(), FxUsbDevice::Start(), FxTimer::Stop(), FxIoTarget::Stop(), FxUsbDevice::Stop(), FxIoQueue::StopProcessingForPower(), FxPkgIo::StopProcessingForPower(), FxIoTarget::Submit(), FxIoTarget::SubmitSync(), FxSystemThread::Thread(), FxIoTarget::TimerCallback(), FxIrpQueue::UnlockFromCancel(), VerifyRequestComplete(), VerifyWdfRequestIsCanceled(), FxDisposeList::WaitForEmpty(), FxSystemWorkItem::WorkItemHandler(), and FxWorkItem::WorkItemHandler().

Unused

USHORT FxObject::Unused

Definition at line 279 of file fxobject.hpp.

---

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

• sdk/lib/drivers/wdf/shared/inc/private/common/fxobject.hpp
• sdk/lib/drivers/wdf/shared/object/fxobject.cpp
• sdk/lib/drivers/wdf/shared/object/fxobjectapi.cpp
• sdk/lib/drivers/wdf/shared/object/fxobjectstatemachine.cpp
• sdk/lib/drivers/wdf/shared/object/km/fxobjectkm.cpp
• sdk/lib/drivers/wdf/shared/object/um/fxobjectum.cpp