#include <fxtransactionedlist.hpp>

Inheritance diagram for FxTransactionedList:

[legend]

Collaboration diagram for FxTransactionedList:

[legend]

Public Member Functions
	FxTransactionedList ()

	~FxTransactionedList ()

VOID	LockForEnum (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

VOID	UnlockFromEnum (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

NTSTATUS	Add (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxTransactionedEntry *Entry)

VOID	Remove (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxTransactionedEntry *Entry)

_Must_inspect_result_ FxTransactionedEntry *	GetNextEntry (__in_opt FxTransactionedEntry *Entry)

BOOLEAN	Deleting (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt MxEvent *DeleteDoneEvent)

Public Member Functions inherited from FxStump
PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

PVOID	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in POOL_TYPE PoolType)

VOID	operator delete (__in PVOID pointer)

PVOID	operator new[] (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

VOID	operator delete[] (__in PVOID pointer)

Protected Member Functions
virtual VOID	AcquireLock (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __out PKIRQL Irql)=0

virtual VOID	ReleaseLock (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in KIRQL Irql)=0

virtual _Must_inspect_result_ NTSTATUS	ProcessAdd (__in FxTransactionedEntry *Entry)

virtual VOID	EntryAdded (__in FxTransactionedEntry *Entry)

virtual VOID	EntryRemoved (__in FxTransactionedEntry *Entry)

virtual BOOLEAN	Compare (__in FxTransactionedEntry *Entry, __in PVOID Data)

VOID	SearchForAndRemove (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PVOID EntryData)

_Must_inspect_result_ FxTransactionedEntry *	GetNextEntryLocked (__in_opt FxTransactionedEntry *Entry)

BOOLEAN	RemoveLocked (__in FxTransactionedEntry *Entry)

VOID	ProcessTransactionList (__in PLIST_ENTRY ReleaseHead)

VOID	ProcessObjectsToRelease (__in PLIST_ENTRY ReleaseHead)

Protected Member Functions inherited from FxStump
	FxStump (VOID)

Protected Attributes
LIST_ENTRY	m_ListHead

LIST_ENTRY	m_TransactionHead

MxEvent *	m_DeletingDoneEvent

ULONG	m_ListLockedRecursionCount

BOOLEAN	m_DeleteOnRemove

BOOLEAN	m_Deleting

UCHAR	m_Retries

Detailed Description

Definition at line 90 of file fxtransactionedlist.hpp.

Constructor & Destructor Documentation

◆ FxTransactionedList()

FxTransactionedList::FxTransactionedList ( )

Definition at line 29 of file fxtransactionedlist.cpp.

{
    m_ListLockedRecursionCount = 0;
    m_DeleteOnRemove = FALSE;
    m_Deleting = FALSE;
    m_Retries = 0;
    m_DeletingDoneEvent = NULL;
 
    InitializeListHead(&m_ListHead);
    InitializeListHead(&m_TransactionHead);
}

◆ ~FxTransactionedList()

FxTransactionedList::~FxTransactionedList ( )

Definition at line 41 of file fxtransactionedlist.cpp.

{
    FxTransactionedEntry* pEntry;
    PLIST_ENTRY ple;
 
    //
    // If m_DeleteOnRemove is FALSE, there is no need to iterate over any of the
    // lists to free anything.
    //
    if (m_DeleteOnRemove == FALSE) {
        ASSERT(IsListEmpty(&m_ListHead));
        ASSERT(IsListEmpty(&m_TransactionHead));
        return;
    }
 
    ASSERT(m_ListLockedRecursionCount == 0);
 
    while (!IsListEmpty(&m_ListHead)) {
        ple = RemoveHeadList(&m_ListHead);
        InitializeListHead(ple);
 
        pEntry = FxTransactionedEntry::_FromEntry(ple);
 
        switch (pEntry->m_Transaction) {
        case FxTransactionActionNothing:
            //
            // Nothing to do, no pending transaction
            //
            break;
 
        case FxTransactionActionAdd:
            //
            // Should not have an add transaction and be on the main list at the
            // same time!
            //
            ASSERT(FALSE);
            break;
 
        case FxTransactionActionRemove:
            //
            // Make sure it is not on the transaction list
            //
            RemoveEntryList(&pEntry->m_TransactionLink);
            InitializeListHead(&pEntry->m_TransactionLink);
 
            //
            // When inserted as a remove transaction, we add this reference in
            // RemoveLocked
            //
            pEntry->GetTransactionedObject()->RELEASE(pEntry);
            break;
 
        }
 
        pEntry->GetTransactionedObject()->DeleteObject();
    }
 
    while (!IsListEmpty(&m_TransactionHead)) {
        ple = RemoveHeadList(&m_TransactionHead);
        InitializeListHead(ple);
 
        pEntry = CONTAINING_RECORD(ple, FxTransactionedEntry, m_TransactionLink);
 
        //
        // We yanked out all of the removes in the previous loop
        //
        ASSERT(pEntry->m_Transaction == FxTransactionActionAdd);
 
        //
        // Delete the object since this list owns it.
        //
        pEntry->GetTransactionedObject()->DeleteObject();
    }
}

Member Function Documentation

◆ AcquireLock()

virtual VOID FxTransactionedList::AcquireLock	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__out PKIRQL	Irql
	)

protectedpure virtual

Referenced by Add(), Deleting(), LockForEnum(), Remove(), SearchForAndRemove(), and UnlockFromEnum().

◆ Add()

_Must_inspect_result_ NTSTATUS FxTransactionedList::Add	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in FxTransactionedEntry *	Entry
	)

Definition at line 263 of file fxtransactionedlist.cpp.

{
    NTSTATUS status;
    KIRQL irql;
 
    AcquireLock(FxDriverGlobals, &irql);
 
    if (m_Deleting) {
        status = STATUS_INVALID_DEVICE_STATE;
    }
    else {
        status = ProcessAdd(Entry);
    }
 
    if (NT_SUCCESS(status)) {
        if (m_ListLockedRecursionCount == 0) {
            //
            // We can insert the entry now, do so
            //
            InsertTailList(&m_ListHead, &Entry->m_ListLink);
 
            EntryAdded(Entry);
        }
        else {
            //
            // List is locked, queue a transaction
            //
            Entry->m_Transaction = FxTransactionActionAdd;
            InsertTailList(&m_TransactionHead, &Entry->m_TransactionLink);
        }
    }
 
    ReleaseLock(FxDriverGlobals, irql);
 
    return status;
}

Referenced by FxRelatedDeviceList::Add(), FxPkgPnp::AddChildList(), FxPkgPnp::AddDmaEnabler(), and FxDevice::AddIoTarget().

◆ Compare()

virtual BOOLEAN FxTransactionedList::Compare	(	__in FxTransactionedEntry *	Entry,
		__in PVOID	Data
	)

inlineprotectedvirtual

Reimplemented in FxRelatedDeviceList.

Definition at line 177 of file fxtransactionedlist.hpp.

    {
        UNREFERENCED_PARAMETER(Entry);
        UNREFERENCED_PARAMETER(Data);
 
        return TRUE;
    }

Referenced by SearchForAndRemove().

◆ Deleting()

BOOLEAN FxTransactionedList::Deleting	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in_opt MxEvent *	DeleteDoneEvent
	)

Definition at line 238 of file fxtransactionedlist.cpp.

{
    KIRQL irql;
    BOOLEAN result;
 
    result = TRUE;
 
    AcquireLock(FxDriverGlobals, &irql);
    m_Deleting = TRUE;
 
    if (m_ListLockedRecursionCount != 0) {
        m_DeletingDoneEvent = DeleteDoneEvent;
        result = FALSE;
    }
 
    ReleaseLock(FxDriverGlobals, irql);
 
    return result;
}

◆ EntryAdded()

virtual VOID FxTransactionedList::EntryAdded ( __in FxTransactionedEntry * Entry )

inlineprotectedvirtual

Definition at line 159 of file fxtransactionedlist.hpp.

    {
        UNREFERENCED_PARAMETER(Entry);
    }

Referenced by Add(), and ProcessTransactionList().

◆ EntryRemoved()

virtual VOID FxTransactionedList::EntryRemoved ( __in FxTransactionedEntry * Entry )

inlineprotectedvirtual

Reimplemented in FxRelatedDeviceList.

Definition at line 168 of file fxtransactionedlist.hpp.

    {
        UNREFERENCED_PARAMETER(Entry);
    }

Referenced by ProcessTransactionList(), and RemoveLocked().

◆ GetNextEntry()

_Must_inspect_result_ FxTransactionedEntry * FxTransactionedList::GetNextEntry ( __in_opt FxTransactionedEntry * Entry )

Definition at line 432 of file fxtransactionedlist.cpp.

{
    //
    // The caller should have locked the list for enumeration
    //
    ASSERT(m_ListLockedRecursionCount > 0 || m_Deleting);
 
    return GetNextEntryLocked(Entry);
}

Referenced by FxPkgPnp::ChildListNotifyRemove(), FxRelatedDeviceList::GetNextEntry(), FxPkgPnp::NotifyResourceobjectsToReleaseResources(), FxPkgPnp::PnpEventSurpriseRemovePendingOverload(), FxPkgPnp::PowerDmaEnableAndScan(), FxPkgPnp::PowerPolicyDisarmWakeFromSx(), FxPkgPnp::PowerPolicyPostParentToD0ToChildren(), and FxDevice::SetFilterIoType().

◆ GetNextEntryLocked()

_Must_inspect_result_ FxTransactionedEntry * FxTransactionedList::GetNextEntryLocked ( __in_opt FxTransactionedEntry * Entry )

protected

Definition at line 458 of file fxtransactionedlist.cpp.

{
    PLIST_ENTRY ple;
 
    if (Entry == NULL) {
        ple = m_ListHead.Flink;
    }
    else {
        ple = Entry->m_ListLink.Flink;
    }
 
    //
    // Find the next entry which does not have a pending transaction on it
    //
    for ( ; ple != &m_ListHead; ple = ple->Flink) {
        FxTransactionedEntry* pNext;
 
        pNext = FxTransactionedEntry::_FromEntry(ple);
        if (pNext->m_Transaction == FxTransactionActionNothing) {
            return pNext;
        }
    }
 
    //
    // Reached the end of the list
    //
    return NULL;
}

Referenced by GetNextEntry(), FxRelatedDeviceList::ProcessAdd(), and SearchForAndRemove().

◆ LockForEnum()

VOID FxTransactionedList::LockForEnum ( __in PFX_DRIVER_GLOBALS FxDriverGlobals )

Definition at line 117 of file fxtransactionedlist.cpp.

{
    KIRQL irql;
 
    AcquireLock(FxDriverGlobals, &irql);
    m_ListLockedRecursionCount++;
    ReleaseLock(FxDriverGlobals, irql);
}

Referenced by FxPkgPnp::ChildListNotifyRemove(), FxRelatedDeviceList::LockForEnum(), FxPkgPnp::NotifyResourceobjectsToReleaseResources(), FxPkgPnp::PnpEventSurpriseRemovePendingOverload(), FxPkgPnp::PowerDmaEnableAndScan(), FxPkgPnp::PowerPolicyDisarmWakeFromSx(), FxPkgPnp::PowerPolicyPostParentToD0ToChildren(), and FxDevice::SetFilterIoType().

◆ ProcessAdd()

virtual _Must_inspect_result_ NTSTATUS FxTransactionedList::ProcessAdd ( __in FxTransactionedEntry * Entry )

inlineprotectedvirtual

Reimplemented in FxRelatedDeviceList.

Definition at line 148 of file fxtransactionedlist.hpp.

    {
        UNREFERENCED_PARAMETER(Entry);
 
        return STATUS_SUCCESS;
    }

Referenced by Add().

◆ ProcessObjectsToRelease()

VOID FxTransactionedList::ProcessObjectsToRelease ( __in PLIST_ENTRY ReleaseHead )

protected

Definition at line 209 of file fxtransactionedlist.cpp.

{
    LIST_ENTRY *ple;
    FxTransactionedEntry* pEntry;
 
    while (!IsListEmpty(ReleaseHead)) {
        ple = RemoveHeadList(ReleaseHead);
        InitializeListHead(ple);
 
        pEntry = CONTAINING_RECORD(ple, FxTransactionedEntry, m_TransactionLink);
 
        //
        // We always release our reference we took when we post the change
        // to the list
        //
        pEntry->GetTransactionedObject()->RELEASE(pEntry);
 
        //
        // 2ndary release if the list is set to do this
        //
        if (m_DeleteOnRemove) {
            pEntry->GetTransactionedObject()->DeleteObject();
        }
    }
}

Referenced by UnlockFromEnum().

◆ ProcessTransactionList()

VOID FxTransactionedList::ProcessTransactionList ( __in PLIST_ENTRY ReleaseHead )

protected

Definition at line 157 of file fxtransactionedlist.cpp.

{
    LIST_ENTRY *ple;
    FxTransactionedEntry* pEntry;
 
    //
    // If there are other iterators, do not process transactions until they are
    // done.
    //
    if (m_ListLockedRecursionCount != 0) {
        return;
    }
 
    while (!IsListEmpty(&m_TransactionHead)) {
        ple = RemoveHeadList(&m_TransactionHead);
        InitializeListHead(ple);
 
        pEntry = CONTAINING_RECORD(ple, FxTransactionedEntry, m_TransactionLink);
 
        ASSERT(pEntry->m_Transaction != FxTransactionActionNothing);
 
        if (pEntry->m_Transaction == FxTransactionActionAdd) {
            //
            // Add to the main list
            //
            InsertTailList(&m_ListHead, &pEntry->m_ListLink);
 
            //
            // Virtual notification of addition
            //
            EntryAdded(pEntry);
        }
        else if (pEntry->m_Transaction == FxTransactionActionRemove) {
            //
            // Remove it from the main list and move it to a free list
            //
            RemoveEntryList(&pEntry->m_ListLink);
            InsertTailList(ReleaseHead, &pEntry->m_TransactionLink);
 
            //
            // Virtual notification of removal
            //
            EntryRemoved(pEntry);
        }
 
        pEntry->m_Transaction = FxTransactionActionNothing;
    }
}

Referenced by UnlockFromEnum().

◆ ReleaseLock()

virtual VOID FxTransactionedList::ReleaseLock	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in KIRQL	Irql
	)

protectedpure virtual

Referenced by Add(), Deleting(), LockForEnum(), Remove(), SearchForAndRemove(), and UnlockFromEnum().

◆ Remove()

VOID FxTransactionedList::Remove	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in FxTransactionedEntry *	Entry
	)

Definition at line 364 of file fxtransactionedlist.cpp.

{
    BOOLEAN removed;
    KIRQL irql;
 
    AcquireLock(FxDriverGlobals, &irql);
    removed = RemoveLocked(Entry);
    ReleaseLock(FxDriverGlobals,irql);
 
    if (removed && m_DeleteOnRemove) {
        Entry->GetTransactionedObject()->DeleteObject();
    }
}

Referenced by FxPkgPnp::RemoveChildList(), FxPkgPnp::RemoveDmaEnabler(), and FxDevice::RemoveIoTarget().

◆ RemoveLocked()

BOOLEAN FxTransactionedList::RemoveLocked ( __in FxTransactionedEntry * Entry )

protected

Definition at line 382 of file fxtransactionedlist.cpp.

{
    BOOLEAN removed;
 
    removed = FALSE;
 
    if (Entry->m_Transaction == FxTransactionActionAdd) {
        //
        // Not yet added to the list proper, remove it from the transaction list
        //
        removed = TRUE;
        RemoveEntryList(&Entry->m_TransactionLink);
        InitializeListHead(&Entry->m_TransactionLink);
 
        Entry->m_Transaction = FxTransactionActionNothing;
    }
    else {
        ASSERT(!IsListEmpty(&Entry->m_ListLink));
 
        if (m_ListLockedRecursionCount == 0) {
            //
            // List is not locked, remove it now
            //
            RemoveEntryList(&Entry->m_ListLink);
            InitializeListHead(&Entry->m_ListLink);
 
            //
            // Virtual notification
            //
            EntryRemoved(Entry);
 
            removed = TRUE;
        }
        else {
            //
            // List is locked for enumeration, queue a transaction
            //
            Entry->m_Transaction = FxTransactionActionRemove;
            InsertTailList(&m_TransactionHead, &Entry->m_TransactionLink);
            Entry->GetTransactionedObject()->ADDREF(Entry);
        }
    }
 
    return removed;
}

Referenced by Remove(), and SearchForAndRemove().

◆ SearchForAndRemove()

VOID FxTransactionedList::SearchForAndRemove	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PVOID	EntryData
	)

protected

Definition at line 304 of file fxtransactionedlist.cpp.

{
    KIRQL irql;
    FxTransactionedEntry* pEntry;
    PLIST_ENTRY ple;
    BOOLEAN removed;
 
    removed = FALSE;
 
    AcquireLock(FxDriverGlobals, &irql);
 
    for (ple = m_TransactionHead.Flink;
         ple != &m_TransactionHead;
         ple = ple->Flink) {
 
        pEntry = CONTAINING_RECORD(ple, FxTransactionedEntry, m_TransactionLink);
 
        if (Compare(pEntry, EntryData)) {
            if (pEntry->GetTransactionAction() == FxTransactionActionAdd) {
                RemoveEntryList(&pEntry->m_TransactionLink);
                InitializeListHead(&pEntry->m_TransactionLink);
 
                removed = TRUE;
            }
            else {
                //
                // Already being removed, just return
                //
                ASSERT(pEntry->GetTransactionAction() ==
                                                    FxTransactionActionRemove);
            }
 
            goto Done;
        }
    }
 
    //
    // Walk the committed list
    //
    pEntry = NULL;
 
    while ((pEntry = GetNextEntryLocked(pEntry)) != NULL) {
        if (Compare(pEntry, EntryData)) {
            removed = RemoveLocked(pEntry);
            break;
        }
    }
 
Done:
    ReleaseLock(FxDriverGlobals, irql);
 
    if (removed && m_DeleteOnRemove) {
        pEntry->GetTransactionedObject()->DeleteObject();
    }
}

Referenced by FxRelatedDeviceList::Remove().

◆ UnlockFromEnum()

VOID FxTransactionedList::UnlockFromEnum ( __in PFX_DRIVER_GLOBALS FxDriverGlobals )

Definition at line 129 of file fxtransactionedlist.cpp.

{
    LIST_ENTRY releaseHead;
    KIRQL irql;
    MxEvent* event;
 
    InitializeListHead(&releaseHead);
    event = NULL;
    AcquireLock(FxDriverGlobals, &irql);
    m_ListLockedRecursionCount--;
    ProcessTransactionList(&releaseHead);
 
    if (m_ListLockedRecursionCount == 0 && m_Deleting) {
        event = m_DeletingDoneEvent;
        m_DeletingDoneEvent = NULL;
    }
    ReleaseLock(FxDriverGlobals, irql);
 
    ProcessObjectsToRelease(&releaseHead);
 
    if (event != NULL) {
        event->Set();
    }
}

Referenced by FxPkgPnp::ChildListNotifyRemove(), FxPkgPnp::NotifyResourceobjectsToReleaseResources(), FxPkgPnp::PnpEventSurpriseRemovePendingOverload(), FxPkgPnp::PowerDmaEnableAndScan(), FxPkgPnp::PowerPolicyDisarmWakeFromSx(), FxPkgPnp::PowerPolicyPostParentToD0ToChildren(), FxDevice::SetFilterIoType(), and FxRelatedDeviceList::UnlockFromEnum().

Member Data Documentation

◆ m_DeleteOnRemove

BOOLEAN FxTransactionedList::m_DeleteOnRemove

protected

Definition at line 224 of file fxtransactionedlist.hpp.

Referenced by FxRelatedDeviceList::FxRelatedDeviceList(), FxTransactionedList(), ProcessObjectsToRelease(), Remove(), SearchForAndRemove(), and ~FxTransactionedList().

◆ m_Deleting

BOOLEAN FxTransactionedList::m_Deleting

protected

Definition at line 226 of file fxtransactionedlist.hpp.

Referenced by Add(), Deleting(), FxTransactionedList(), GetNextEntry(), and UnlockFromEnum().

◆ m_DeletingDoneEvent

MxEvent* FxTransactionedList::m_DeletingDoneEvent

protected

Definition at line 220 of file fxtransactionedlist.hpp.

Referenced by Deleting(), FxTransactionedList(), and UnlockFromEnum().

◆ m_ListHead

LIST_ENTRY FxTransactionedList::m_ListHead

protected

Definition at line 216 of file fxtransactionedlist.hpp.

Referenced by Add(), FxTransactionedList(), GetNextEntryLocked(), ProcessTransactionList(), and ~FxTransactionedList().

◆ m_ListLockedRecursionCount

ULONG FxTransactionedList::m_ListLockedRecursionCount

protected

Definition at line 222 of file fxtransactionedlist.hpp.

Referenced by Add(), Deleting(), FxTransactionedList(), GetNextEntry(), LockForEnum(), ProcessTransactionList(), RemoveLocked(), UnlockFromEnum(), and ~FxTransactionedList().

◆ m_Retries

UCHAR FxTransactionedList::m_Retries

protected

Definition at line 233 of file fxtransactionedlist.hpp.

Referenced by FxTransactionedList(), FxRelatedDeviceList::IncrementRetries(), and FxRelatedDeviceList::ZeroRetries().

◆ m_TransactionHead

LIST_ENTRY FxTransactionedList::m_TransactionHead

protected

Definition at line 218 of file fxtransactionedlist.hpp.

Referenced by Add(), FxTransactionedList(), FxRelatedDeviceList::ProcessAdd(), ProcessTransactionList(), RemoveLocked(), SearchForAndRemove(), and ~FxTransactionedList().

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

sdk/lib/drivers/wdf/shared/inc/private/common/fxtransactionedlist.hpp
sdk/lib/drivers/wdf/shared/support/fxtransactionedlist.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FxTransactionedList()

◆ ~FxTransactionedList()

Member Function Documentation

◆ AcquireLock()

◆ Add()

◆ Compare()

◆ Deleting()

◆ EntryAdded()

◆ EntryRemoved()

◆ GetNextEntry()

◆ GetNextEntryLocked()

◆ LockForEnum()

◆ ProcessAdd()

◆ ProcessObjectsToRelease()

◆ ProcessTransactionList()

◆ ReleaseLock()

◆ Remove()

◆ RemoveLocked()

◆ SearchForAndRemove()

◆ UnlockFromEnum()

Member Data Documentation

◆ m_DeleteOnRemove

◆ m_Deleting

◆ m_DeletingDoneEvent

◆ m_ListHead

◆ m_ListLockedRecursionCount

◆ m_Retries

◆ m_TransactionHead