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

Classes
struct	_RX_SCAVENGER_ENTRY

struct	_RDBSS_SCAVENGER

struct	_PURGE_SYNCHRONIZATION_CONTEXT

Macros
#define	RX_SCAVENGER_FINALIZATION_TIME_INTERVAL (10 * 1000 * 1000 * 10)

#define	RxInitializeScavengerEntry(ScavengerEntry)

#define	RxAcquireScavengerMutex() KeWaitForSingleObject(&RxScavengerMutex, Executive, KernelMode, FALSE, NULL)

#define	RxReleaseScavengerMutex() KeReleaseMutex(&RxScavengerMutex, FALSE)

#define	DONT_ATTEMPT_FINALIZE_ON_PURGE FALSE

#define	ATTEMPT_FINALIZE_ON_PURGE TRUE

#define	RxInitializeRdbssScavenger(Scavenger, ScavengerTimeLimit)

Typedefs
typedef struct _RX_SCAVENGER_ENTRY	RX_SCAVENGER_ENTRY

typedef struct _RX_SCAVENGER_ENTRY *	PRX_SCAVENGER_ENTRY

typedef enum _RDBSS_SCAVENGER_STATE	RDBSS_SCAVENGER_STATE

typedef enum _RDBSS_SCAVENGER_STATE *	PRDBSS_SCAVENGER_STATE

typedef struct _RDBSS_SCAVENGER	RDBSS_SCAVENGER

typedef struct _RDBSS_SCAVENGER *	PRDBSS_SCAVENGER

typedef struct _PURGE_SYNCHRONIZATION_CONTEXT	PURGE_SYNCHRONIZATION_CONTEXT

typedef struct _PURGE_SYNCHRONIZATION_CONTEXT *	PPURGE_SYNCHRONIZATION_CONTEXT

Enumerations
enum	_RDBSS_SCAVENGER_STATE { RDBSS_SCAVENGER_INACTIVE , RDBSS_SCAVENGER_DORMANT , RDBSS_SCAVENGER_ACTIVE , RDBSS_SCAVENGER_SUSPENDED }

Functions
VOID	RxMarkFobxOnCleanup (_In_ PFOBX pFobx, _Out_ PBOOLEAN NeedPurge)

VOID	RxMarkFobxOnClose (_In_ PFOBX Fobx)

NTSTATUS	RxPurgeRelatedFobxs (PNET_ROOT NetRoot, PRX_CONTEXT RxContext, BOOLEAN AttemptFinalization, PFCB PurgingFcb)

VOID	RxInitializePurgeSyncronizationContext (_In_ PPURGE_SYNCHRONIZATION_CONTEXT PurgeSyncronizationContext)

BOOLEAN	RxScavengeRelatedFobxs (_In_ PFCB Fcb)

VOID	RxScavengeFobxsForNetRoot (PNET_ROOT NetRoot, PFCB PurgingFcb, BOOLEAN SynchronizeWithScavenger)

VOID	RxpMarkInstanceForScavengedFinalization (PVOID Instance)

VOID	RxpUndoScavengerFinalizationMarking (_In_ PVOID Instance)

BOOLEAN	RxScavengeVNetRoots (_In_ PRDBSS_DEVICE_OBJECT RxDeviceObject)

VOID	RxSynchronizeWithScavenger (_In_ PRX_CONTEXT RxContext)

Variables
KMUTEX	RxScavengerMutex

Macro Definition Documentation

◆ ATTEMPT_FINALIZE_ON_PURGE

#define ATTEMPT_FINALIZE_ON_PURGE TRUE

Definition at line 46 of file scavengr.h.

◆ DONT_ATTEMPT_FINALIZE_ON_PURGE

#define DONT_ATTEMPT_FINALIZE_ON_PURGE FALSE

Definition at line 45 of file scavengr.h.

◆ RX_SCAVENGER_FINALIZATION_TIME_INTERVAL

#define RX_SCAVENGER_FINALIZATION_TIME_INTERVAL (10 * 1000 * 1000 * 10)

Definition at line 6 of file scavengr.h.

◆ RxAcquireScavengerMutex

#define RxAcquireScavengerMutex ( ) KeWaitForSingleObject(&RxScavengerMutex, Executive, KernelMode, FALSE, NULL)

Definition at line 26 of file scavengr.h.

◆ RxInitializeRdbssScavenger

#define RxInitializeRdbssScavenger	(	Scavenger,
		ScavengerTimeLimit
	)

Value:

    (Scavenger)->State = RDBSS_SCAVENGER_INACTIVE;                                                \
    (Scavenger)->SrvCallsToBeFinalized = 0;                                                       \
    (Scavenger)->NetRootsToBeFinalized = 0;                                                       \
    (Scavenger)->VNetRootsToBeFinalized = 0;                                                      \
    (Scavenger)->FcbsToBeFinalized = 0;                                                           \
    (Scavenger)->SrvOpensToBeFinalized = 0;                                                       \
    (Scavenger)->FobxsToBeFinalized = 0;                                                          \
    (Scavenger)->NumberOfDormantFiles = 0;                                                        \
    (Scavenger)->MaximumNumberOfDormantFiles = 50;                                                \
    (Scavenger)->CurrentFcbForClosePendingProcessing = NULL;                                      \
    (Scavenger)->CurrentNetRootForClosePendingProcessing = NULL;                                  \
    if ((ScavengerTimeLimit).QuadPart == 0)                                                       \
    {                                                                                             \
          (Scavenger)->TimeLimit.QuadPart = RX_SCAVENGER_FINALIZATION_TIME_INTERVAL;              \
    }                                                                                             \
    else                                                                                          \
    {                                                                                             \
          (Scavenger)->TimeLimit.QuadPart = (ScavengerTimeLimit).QuadPart;                        \
    }                                                                                             \
    KeInitializeEvent(&((Scavenger)->SyncEvent), NotificationEvent, FALSE);                       \
    KeInitializeEvent(&((Scavenger)->ScavengeEvent), SynchronizationEvent, TRUE);                 \
    KeInitializeEvent(&((Scavenger)->ClosePendingProcessingSyncEvent), NotificationEvent, FALSE); \
    InitializeListHead(&(Scavenger)->SrvCallFinalizationList);                                    \
    InitializeListHead(&(Scavenger)->NetRootFinalizationList);                                    \
    InitializeListHead(&(Scavenger)->VNetRootFinalizationList);                                   \
    InitializeListHead(&(Scavenger)->SrvOpenFinalizationList);                                    \
    InitializeListHead(&(Scavenger)->FcbFinalizationList);                                        \
    InitializeListHead(&(Scavenger)->FobxFinalizationList);                                       \
    InitializeListHead(&(Scavenger)->ClosePendingFobxsList)

Definition at line 84 of file scavengr.h.

◆ RxInitializeScavengerEntry

#define RxInitializeScavengerEntry ( ScavengerEntry )

Value:

    (ScavengerEntry)->State  = 0;                  \
    (ScavengerEntry)->Flags  = 0;                  \
    (ScavengerEntry)->Type   = 0;                  \
    (ScavengerEntry)->Operation = 0;               \
    InitializeListHead(&(ScavengerEntry)->List);   \
    (ScavengerEntry)->pContinuationEntry = NULL

Definition at line 18 of file scavengr.h.

◆ RxReleaseScavengerMutex

#define RxReleaseScavengerMutex ( ) KeReleaseMutex(&RxScavengerMutex, FALSE)

Definition at line 27 of file scavengr.h.

Typedef Documentation

◆ PPURGE_SYNCHRONIZATION_CONTEXT

typedef struct _PURGE_SYNCHRONIZATION_CONTEXT * PPURGE_SYNCHRONIZATION_CONTEXT

◆ PRDBSS_SCAVENGER

typedef struct _RDBSS_SCAVENGER * PRDBSS_SCAVENGER

◆ PRDBSS_SCAVENGER_STATE

typedef enum _RDBSS_SCAVENGER_STATE * PRDBSS_SCAVENGER_STATE

◆ PRX_SCAVENGER_ENTRY

typedef struct _RX_SCAVENGER_ENTRY * PRX_SCAVENGER_ENTRY

◆ PURGE_SYNCHRONIZATION_CONTEXT

typedef struct _PURGE_SYNCHRONIZATION_CONTEXT PURGE_SYNCHRONIZATION_CONTEXT

◆ RDBSS_SCAVENGER

typedef struct _RDBSS_SCAVENGER RDBSS_SCAVENGER

◆ RDBSS_SCAVENGER_STATE

typedef enum _RDBSS_SCAVENGER_STATE RDBSS_SCAVENGER_STATE

◆ RX_SCAVENGER_ENTRY

typedef struct _RX_SCAVENGER_ENTRY RX_SCAVENGER_ENTRY

Enumeration Type Documentation

◆ _RDBSS_SCAVENGER_STATE

enum _RDBSS_SCAVENGER_STATE

Enumerator
RDBSS_SCAVENGER_INACTIVE
RDBSS_SCAVENGER_DORMANT
RDBSS_SCAVENGER_ACTIVE
RDBSS_SCAVENGER_SUSPENDED

Definition at line 48 of file scavengr.h.

{
    RDBSS_SCAVENGER_INACTIVE,
    RDBSS_SCAVENGER_DORMANT,
    RDBSS_SCAVENGER_ACTIVE,
    RDBSS_SCAVENGER_SUSPENDED
} RDBSS_SCAVENGER_STATE, *PRDBSS_SCAVENGER_STATE;

Function Documentation

◆ RxInitializePurgeSyncronizationContext()

VOID RxInitializePurgeSyncronizationContext ( _In_ PPURGE_SYNCHRONIZATION_CONTEXT PurgeSyncronizationContext )

◆ RxMarkFobxOnCleanup()

VOID RxMarkFobxOnCleanup	(	_In_ PFOBX	pFobx,
		_Out_ PBOOLEAN	NeedPurge
	)

Referenced by RxCommonCleanup().

◆ RxMarkFobxOnClose()

VOID RxMarkFobxOnClose ( _In_ PFOBX Fobx )

Referenced by RxCloseAssociatedSrvOpen(), and RxCommonClose().

◆ RxpMarkInstanceForScavengedFinalization()

VOID RxpMarkInstanceForScavengedFinalization ( PVOID Instance )

Definition at line 6277 of file rxce.c.

{
    NODE_TYPE_CODE NodeType;
    PNODE_TYPE_AND_SIZE Node;
    PRDBSS_SCAVENGER Scavenger;
    PRDBSS_DEVICE_OBJECT DeviceObject;
    PLIST_ENTRY ScavengerHead, InstEntry;
 
    PAGED_CODE();
 
    /* If still referenced, don't mark it (broken caller) */
    Node = (PNODE_TYPE_AND_SIZE)Instance;
    if (Node->NodeReferenceCount > 1)
    {
        return;
    }
 
    DeviceObject = RxGetDeviceObjectOfInstance(Instance);
    Scavenger = DeviceObject->pRdbssScavenger;
 
    /* Mark the node */
    NodeType = NodeType(Instance);
    SetFlag(NodeType(Node), RX_SCAVENGER_MASK);
    DPRINT("Node %p has now the scavenger mark!\n", Instance);
 
    /* Increase the count in the scavenger, and queue it */
    ScavengerHead = NULL;
    switch (NodeType)
    {
        case RDBSS_NTC_FOBX:
            ++Scavenger->FobxsToBeFinalized;
            ScavengerHead = &Scavenger->FobxFinalizationList;
            InstEntry = &((PFOBX)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_SRVCALL:
            ++Scavenger->SrvCallsToBeFinalized;
            ScavengerHead = &Scavenger->SrvCallFinalizationList;
            InstEntry = &((PSRV_CALL)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_NETROOT:
            ++Scavenger->NetRootsToBeFinalized;
            ScavengerHead = &Scavenger->NetRootFinalizationList;
            InstEntry = &((PNET_ROOT)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_V_NETROOT:
            ++Scavenger->VNetRootsToBeFinalized;
            ScavengerHead = &Scavenger->VNetRootFinalizationList;
            InstEntry = &((PV_NET_ROOT)Instance)->ScavengerFinalizationList;
            break;
 
        case RDBSS_NTC_SRVOPEN:
            ++Scavenger->SrvOpensToBeFinalized;
            ScavengerHead = &Scavenger->SrvOpenFinalizationList;
            InstEntry = &((PSRV_OPEN)Instance)->ScavengerFinalizationList;
            break;
    }
 
    /* Extra ref for scavenger */
    InterlockedIncrement((volatile long *)&Node->NodeReferenceCount);
 
    /* If matching type */
    if (ScavengerHead != NULL)
    {
        /* Insert in the scavenger list */
        InsertTailList(ScavengerHead, InstEntry);
 
        /* And if it wasn't started, start it */
        if (Scavenger->State == RDBSS_SCAVENGER_INACTIVE)
        {
            Scavenger->State = RDBSS_SCAVENGER_DORMANT;
            RxPostOneShotTimerRequest(RxFileSystemDeviceObject, &Scavenger->WorkItem,
                                      RxScavengerTimerRoutine, DeviceObject, Scavenger->TimeLimit);
        }
    }
}

Referenced by RxDereference().

◆ RxpUndoScavengerFinalizationMarking()

VOID RxpUndoScavengerFinalizationMarking ( _In_ PVOID Instance )

◆ RxPurgeRelatedFobxs()

NTSTATUS RxPurgeRelatedFobxs	(	PNET_ROOT	NetRoot,
		PRX_CONTEXT	RxContext,
		BOOLEAN	AttemptFinalization,
		PFCB	PurgingFcb
	)

Definition at line 7133 of file rxce.c.

{
    PLIST_ENTRY Entry;
    ULONG SuccessfullPurge;
    PRDBSS_SCAVENGER Scavenger;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
    PPURGE_SYNCHRONIZATION_CONTEXT PurgeSyncCtx;
 
    PAGED_CODE();
 
    RxDeviceObject = RxContext->RxDeviceObject;
    Scavenger = RxDeviceObject->pRdbssScavenger;
    PurgeSyncCtx = &NetRoot->PurgeSyncronizationContext;
 
    RxAcquireScavengerMutex();
 
    /* If there's already a purge in progress */
    if (PurgeSyncCtx->PurgeInProgress)
    {
        /* Add our RX_CONTEXT to the current run */
        InsertTailList(&PurgeSyncCtx->ContextsAwaitingPurgeCompletion,
                       &RxContext->RxContextSerializationQLinks);
 
        /* And wait until it's done */
        RxReleaseScavengerMutex();
        RxWaitSync(RxContext);
        RxAcquireScavengerMutex();
    }
 
    /* Start the purge */
    PurgeSyncCtx->PurgeInProgress = TRUE;
 
    /* While the purge is still handling our NET_ROOT, do nothing but wait */
    while (Scavenger->CurrentNetRootForClosePendingProcessing == NetRoot)
    {
        RxReleaseScavengerMutex();
        KeWaitForSingleObject(&Scavenger->ClosePendingProcessingSyncEvent, Executive,
                              KernelMode, TRUE, NULL);
        RxAcquireScavengerMutex();
    }
 
    /* Now, for all the entries */
    SuccessfullPurge = 0;
    Entry = Scavenger->ClosePendingFobxsList.Flink;
    while (Entry != &Scavenger->ClosePendingFobxsList)
    {
        PFCB Fcb;
        PFOBX Fobx;
        BOOLEAN Success;
 
        Fobx = CONTAINING_RECORD(Entry, FOBX, ClosePendingList);
        DPRINT("Dealing with FOBX: %p\n", Fobx);
 
        Entry = Entry->Flink;
 
        /* If it's not matching our NET_ROOT, ignore */
        if (Fobx->pSrvOpen == NULL ||
            Fobx->pSrvOpen->pFcb == NULL ||
            ((PFCB)Fobx->pSrvOpen->pFcb)->VNetRoot == NULL ||
            (PNET_ROOT)((PFCB)Fobx->pSrvOpen->pFcb)->VNetRoot->pNetRoot != NetRoot)
        {
            continue;
        }
 
        /* Determine if it matches our FCB */
        Fcb = (PFCB)Fobx->pSrvOpen->pFcb;
        if (PurgingFcb != NULL && NodeType(PurgingFcb) != RDBSS_NTC_STORAGE_TYPE_DIRECTORY &&
            PurgingFcb != Fcb)
        {
            NTSTATUS Status;
 
            MINIRDR_CALL_THROUGH(Status, RxDeviceObject->Dispatch, MRxAreFilesAliased, (Fcb, PurgingFcb));
            if (Status == STATUS_SUCCESS)
            {
                continue;
            }
        }
 
        /* Matching, we'll purge it */
        RemoveEntryList(&Fobx->ClosePendingList);
 
        /* Reference it so that it doesn't disappear */
        RxReferenceNetFobx(Fobx);
 
        RxReleaseScavengerMutex();
 
        /* And purge */
        Success = RxPurgeFobx(Fobx);
        if (Success)
        {
            ++SuccessfullPurge;
        }
 
        /* If we don't have to finalize it (or if we cannot acquire lock exclusively
         * Just normally dereference
         */
        if ((AttemptFinalization == DONT_ATTEMPT_FINALIZE_ON_PURGE) ||
            RxAcquireExclusiveFcb(NULL, Fcb) != STATUS_SUCCESS)
        {
            RxDereferenceNetFobx(Fobx, LHS_LockNotHeld);
        }
        /* Otherwise, finalize */
        else
        {
            RxReferenceNetFcb(Fcb);
            RxDereferenceNetFobx(Fobx, LHS_ExclusiveLockHeld);
            if (!RxDereferenceAndFinalizeNetFcb(Fcb, NULL, FALSE, FALSE))
            {
                RxReleaseFcb(NULL, Fcb);
            }
        }
 
        if (!Success)
        {
            DPRINT1("Failed purging %p (%p)\n", Fcb, Fobx);
        }
 
        RxAcquireScavengerMutex();
    }
 
    /* If no contexts left, purge is not running */
    if (IsListEmpty(&PurgeSyncCtx->ContextsAwaitingPurgeCompletion))
    {
        PurgeSyncCtx->PurgeInProgress = FALSE;
    }
    /* Otherwise, notify a waiter it can start */
    else
    {
        PRX_CONTEXT Context;
 
        Entry = RemoveHeadList(&PurgeSyncCtx->ContextsAwaitingPurgeCompletion);
        Context = CONTAINING_RECORD(Entry, RX_CONTEXT, RxContextSerializationQLinks);
 
        RxSignalSynchronousWaiter(Context);
    }
 
    RxReleaseScavengerMutex();
 
    return (SuccessfullPurge > 0 ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}

Referenced by RxCommonCreate(), RxCommonSetInformation(), and RxCreateFromNetRoot().

◆ RxScavengeFobxsForNetRoot()

VOID RxScavengeFobxsForNetRoot	(	PNET_ROOT	NetRoot,
		PFCB	PurgingFcb,
		BOOLEAN	SynchronizeWithScavenger
	)

Definition at line 7798 of file rxce.c.

{
    PRDBSS_SCAVENGER Scavenger;
    PRDBSS_DEVICE_OBJECT RxDeviceObject;
 
    PAGED_CODE();
 
    RxDeviceObject = NetRoot->pSrvCall->RxDeviceObject;
    Scavenger = RxDeviceObject->pRdbssScavenger;
 
    /* Wait for the scavenger, if asked to */
    if (SynchronizeWithScavenger)
    {
        KeWaitForSingleObject(&Scavenger->ScavengeEvent, Executive, KernelMode, FALSE, NULL);
    }
 
    RxAcquireScavengerMutex();
 
    /* If there's nothing left to do... */
    if (Scavenger->FobxsToBeFinalized <= 0)
    {
        RxReleaseScavengerMutex();
    }
    else
    {
        PLIST_ENTRY Entry;
        LIST_ENTRY FobxToScavenge;
 
        InitializeListHead(&FobxToScavenge);
 
        /* Browse all the FOBXs to finalize */
        Entry = Scavenger->FobxFinalizationList.Flink;
        while (Entry != &Scavenger->FobxFinalizationList)
        {
            PFOBX Fobx;
 
            Fobx = CONTAINING_RECORD(Entry, FOBX, ScavengerFinalizationList);
            Entry = Entry->Flink;
 
            if (Fobx->SrvOpen != NULL)
            {
                PFCB Fcb;
 
                Fcb = (PFCB)Fobx->SrvOpen->pFcb;
 
                /* If it matches our NET_ROOT */
                if ((PNET_ROOT)Fcb->pNetRoot == NetRoot)
                {
                    NTSTATUS Status;
 
                    /* Check whether it matches our FCB */
                    Status = STATUS_MORE_PROCESSING_REQUIRED;
                    if (PurgingFcb != NULL && PurgingFcb != Fcb)
                    {
                        MINIRDR_CALL_THROUGH(Status, RxDeviceObject->Dispatch, MRxAreFilesAliased, (Fcb, PurgingFcb));
                    }
 
                    /* If so, add it to the list of the FOBXs to scavenge */
                    if (Status != STATUS_SUCCESS)
                    {
                        RxReferenceNetFobx(Fobx);
                        ASSERT(NodeType(Fobx) == RDBSS_NTC_FOBX);
 
                        RemoveEntryList(&Fobx->ScavengerFinalizationList);
                        InsertTailList(&FobxToScavenge, &Fobx->ScavengerFinalizationList);
                    }
                }
            }
        }
 
        RxReleaseScavengerMutex();
 
        /* Now, scavenge all the extracted FOBX */
        RxpScavengeFobxs(Scavenger, &FobxToScavenge);
    }
 
    if (SynchronizeWithScavenger)
    {
        KeSetEvent(&Scavenger->ScavengeEvent, IO_NO_INCREMENT, FALSE);
    }
}

Referenced by RxCommonCreate(), and RxCommonSetInformation().

◆ RxScavengeRelatedFobxs()

BOOLEAN RxScavengeRelatedFobxs ( _In_ PFCB Fcb )

Referenced by RxCommonClose(), and RxSearchForCollapsibleOpen().

◆ RxScavengeVNetRoots()

BOOLEAN RxScavengeVNetRoots ( _In_ PRDBSS_DEVICE_OBJECT RxDeviceObject )

Referenced by RxCreateTreeConnect().

◆ RxSynchronizeWithScavenger()

VOID RxSynchronizeWithScavenger ( _In_ PRX_CONTEXT RxContext )

Referenced by RxCommonClose().

Variable Documentation

◆ RxScavengerMutex

KMUTEX RxScavengerMutex

extern

Definition at line 608 of file rdbss.c.

Referenced by RxDriverEntry().

Classes

Macros

Typedefs

Enumerations

Functions

Variables