reactos/sdk/lib/drivers/wdf/shared/core/fxdisposelist.cpp

/*++

Copyright (c) Microsoft Corporation

Module Name:

    FxDisposeList.hpp

Abstract:

    This class implements a Disposal list for deferring Dispose
    processing from dispatch to passive level.

    It works tightly with FxObject, and is a friend class.

Author:






Environment:

    Both kernel and user mode

Revision History:


--*/

#include "coreprivshared.hpp"

#include "fxdisposelist.hpp"

// Tracing support
extern "C" {
// #include "FxDisposeList.tmh"
}

FxDisposeList::FxDisposeList(
    PFX_DRIVER_GLOBALS FxDriverGlobals
    ) :
    FxNonPagedObject(FX_TYPE_DISPOSELIST, 0, FxDriverGlobals)
{
   m_List.Next = NULL;
   m_ListEnd = &m_List.Next;

   m_SystemWorkItem = NULL;
   m_WorkItemThread = NULL;
}

FxDisposeList::~FxDisposeList()
{
    ASSERT(m_List.Next == NULL);
}

NTSTATUS
FxDisposeList::_Create(
    PFX_DRIVER_GLOBALS FxDriverGlobals,
    PVOID              WdmObject,
    FxDisposeList**    pObject
    )
{
    FxDisposeList* list;
    NTSTATUS status;

    *pObject = NULL;

    list = new(FxDriverGlobals) FxDisposeList(FxDriverGlobals);

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

    status = list->Initialize(WdmObject);

    if (NT_SUCCESS(status)) {
        *pObject = list;
    }
    else {
        list->DeleteFromFailedCreate();
    }

    return status;
}

NTSTATUS
FxDisposeList::Initialize(
    PVOID          WdmObject
    )
{
    NTSTATUS status;
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();

    MarkDisposeOverride(ObjectDoNotLock);

    status = FxSystemWorkItem::_Create(FxDriverGlobals,
                                      WdmObject,
                                      &m_SystemWorkItem
                                      );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIO,
                            "Could not allocate workitem: %!STATUS!", status);
        return status;
    }

    m_WdmObject = WdmObject;

    return STATUS_SUCCESS;
}

BOOLEAN
FxDisposeList::Dispose(
    )
{
    if (m_SystemWorkItem != NULL) {
        m_SystemWorkItem->DeleteObject();
        m_SystemWorkItem = NULL;
    }

    ASSERT(m_List.Next == NULL);

    FxNonPagedObject::Dispose(); // __super call

    return TRUE;
}

VOID
FxDisposeList::Add(
    FxObject* Object
    )

/*++

Routine Description:

    Add an object to the cleanup list.







    The caller is expected to manage any reference counts on
    the object while on the cleanup list

Arguments:

    object - Object to cleanup at passive level

Returns:

    None

--*/

{
    KIRQL irql;
    BOOLEAN previouslyEmpty;

    Lock(&irql);

    ASSERT(Object->m_DisposeSingleEntry.Next == NULL);

    previouslyEmpty = m_List.Next == NULL ? TRUE : FALSE;

    //
    // Add to the end of m_List
    //
    *m_ListEnd = &Object->m_DisposeSingleEntry;

    //
    // Update the end
    //
    m_ListEnd = &Object->m_DisposeSingleEntry.Next;

    if (previouslyEmpty) {
        m_SystemWorkItem->TryToEnqueue(_WorkItemThunk, this);
    }

    Unlock(irql);
}

VOID
FxDisposeList::DrainListLocked(
    PKIRQL PreviousIrql
    )
{
    FxObject* pObject;
    PSINGLE_LIST_ENTRY pEntry;

    //
    // Process items on the list until it is empty
    //
    while (m_List.Next != NULL) {
        pEntry = m_List.Next;

        //
        // Remove pEntry from the list
        //
        m_List.Next = pEntry->Next;

        //
        // Indicate pEntry is no longer in the list
        //
        pEntry->Next = NULL;

        //
        // Convert back to the object
        //
        pObject = FxObject::_FromDisposeEntry(pEntry);

        //
        // If the list is empty, we just popped off the entry and we need to
        // update m_ListEnd to a head of the list so it points to valid pool.
        //
        if (m_List.Next == NULL) {
            m_ListEnd = &m_List.Next;
        }

        Unlock(*PreviousIrql);

        //
        // Invoke the objects deferred dispose entry
        //
        pObject->DeferredDisposeWorkItem();

        //
        // pObject may be invalid at this point due to its dereferencing itself
        //
        Lock(PreviousIrql);
    }
}

VOID
FxDisposeList::_WorkItemThunk(
    __in PVOID Parameter
    )
{
    FxDisposeList* pThis;
    KIRQL irql;

    pThis = (FxDisposeList*) Parameter;

    pThis->Lock(&irql);

    pThis->DrainListLocked(&irql);

    pThis->Unlock(irql);
}

VOID
FxDisposeList::WaitForEmpty(
    )

/*++

Routine Description:

    Wait until the list goes empty with no items.

    Note, on wakeup, new items could have been added, only the assurance
    is that the list at least went empty for a moment.

    This allows a waiter to wait for all previous Add() items to
    finishing processing before return.

Arguments:

Returns:

--*/

{
    KIRQL irql;
    BOOLEAN wait;

    Lock(&irql);

    wait = TRUE;

    if (m_WorkItemThread == Mx::MxGetCurrentThread()) {







        ASSERT(FALSE);
        DrainListLocked(&irql);
        wait = FALSE;
    }

    Unlock(irql);

    if (wait) {
        m_SystemWorkItem->WaitForExit();
    }

    // Should only be true for an empty list
    ASSERT(m_List.Next == NULL);
}