cmdelay.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for cmdelay.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
	_Function_class_ (KDEFERRED_ROUTINE)
	_Function_class_ (WORKER_THREAD_ROUTINE)
VOID NTAPI	CmpInitializeDelayedCloseTable (VOID)
VOID NTAPI	CmpInitDelayDerefKCBEngine (VOID)
VOID NTAPI	CmpDelayDerefKeyControlBlock (IN PCM_KEY_CONTROL_BLOCK Kcb)
VOID NTAPI	CmpArmDelayedCloseTimer (VOID)
VOID NTAPI	CmpAddToDelayedClose (IN PCM_KEY_CONTROL_BLOCK Kcb, IN BOOLEAN LockHeldExclusively)
VOID NTAPI	CmpRemoveFromDelayedClose (IN PCM_KEY_CONTROL_BLOCK Kcb)

Variables
WORK_QUEUE_ITEM	CmpDelayDerefKCBWorkItem
ULONG	CmpDelayedCloseSize = 2048
ULONG	CmpDelayedCloseElements
KGUARDED_MUTEX	CmpDelayedCloseTableLock
BOOLEAN	CmpDelayCloseWorkItemActive
WORK_QUEUE_ITEM	CmpDelayCloseWorkItem
LIST_ENTRY	CmpDelayedLRUListHead
ULONG	CmpDelayCloseIntervalInSeconds = 5
KDPC	CmpDelayCloseDpc
KTIMER	CmpDelayCloseTimer
KGUARDED_MUTEX	CmpDelayDerefKCBLock
BOOLEAN	CmpDelayDerefKCBWorkItemActive
LIST_ENTRY	CmpDelayDerefKCBListHead
ULONG	CmpDelayDerefKCBIntervalInSeconds = 5
KDPC	CmpDelayDerefKCBDpc
KTIMER	CmpDelayDerefKCBTimer

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file cmdelay.c.

Function Documentation

_Function_class_() [1/2]

_Function_class_

(

KDEFERRED_ROUTINE

)

Definition at line 38 of file cmdelay.c.

{
    /* Sanity check */
    ASSERT(CmpDelayCloseWorkItemActive);
 
    /* Queue the work item */
    ExQueueWorkItem(&CmpDelayCloseWorkItem, DelayedWorkQueue);
}

_Function_class_() [2/2]

_Function_class_

(

WORKER_THREAD_ROUTINE

)

Definition at line 53 of file cmdelay.c.

{
    PCM_DELAYED_CLOSE_ENTRY ListEntry;
    ULONG i, ConvKey;
    PAGED_CODE();
 
    /* Sanity check */
    ASSERT(CmpDelayCloseWorkItemActive);
 
    /* Lock the registry */
    CmpLockRegistry();
 
    /* Acquire the delayed close table lock */
    KeAcquireGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Iterate */
    for (i = 0; i < (CmpDelayedCloseSize >> 2); i++)
    {
        /* Break out of the loop if there is nothing to process */
        if (CmpDelayedCloseElements <= CmpDelayedCloseSize) break;
 
        /* Sanity check */
        ASSERT(!IsListEmpty(&CmpDelayedLRUListHead));
 
        /* Get the entry */
        ListEntry = CONTAINING_RECORD(CmpDelayedLRUListHead.Blink,
                                      CM_DELAYED_CLOSE_ENTRY,
                                      DelayedLRUList);
 
        /* Save the ConvKey value of the KCB */
        ConvKey = ListEntry->KeyControlBlock->ConvKey;
 
        /* Release the delayed close table lock */
        KeReleaseGuardedMutex(&CmpDelayedCloseTableLock);
 
        /* Acquire the KCB lock */
        CmpAcquireKcbLockExclusiveByKey(ConvKey);
 
        /* Reacquire the delayed close table lock */
        KeAcquireGuardedMutex(&CmpDelayedCloseTableLock);
 
        /* Get the entry */
        ListEntry = CONTAINING_RECORD(CmpDelayedLRUListHead.Blink,
                                      CM_DELAYED_CLOSE_ENTRY,
                                      DelayedLRUList);
 
        /* Is the entry we have still the first one? */
        if (CmpDelayedCloseElements <= CmpDelayedCloseSize)
        {
            /* No, someone already inserted an entry there */
            CmpReleaseKcbLockByKey(ConvKey);
            break;
        }
 
        /* Is it a different entry? */
        if (ConvKey != ListEntry->KeyControlBlock->ConvKey)
        {
            /* Release the delayed close table lock */
            KeReleaseGuardedMutex(&CmpDelayedCloseTableLock);
 
            /* Release the KCB lock */
            CmpReleaseKcbLockByKey(ConvKey);
 
            /* Reacquire the delayed close table lock */
            KeAcquireGuardedMutex(&CmpDelayedCloseTableLock);
 
            /* Iterate again */
            continue;
        }
 
        /* Remove it from the end of the list */
        ListEntry =
            (PCM_DELAYED_CLOSE_ENTRY)RemoveTailList(&CmpDelayedLRUListHead);
 
        /* Get the containing entry */
        ListEntry = CONTAINING_RECORD(ListEntry,
                                      CM_DELAYED_CLOSE_ENTRY,
                                      DelayedLRUList);
 
        /* Process the entry */
        if ((ListEntry->KeyControlBlock->RefCount) ||
            (ListEntry->KeyControlBlock->DelayedCloseIndex))
        {
            /* Add it to the beginning of the list */
            InsertHeadList(&CmpDelayedLRUListHead, &ListEntry->DelayedLRUList);
 
            /* Release the delayed close table lock */
            KeReleaseGuardedMutex(&CmpDelayedCloseTableLock);
        }
        else
        {
            /* Release the delayed close table lock */
            KeReleaseGuardedMutex(&CmpDelayedCloseTableLock);
 
            /* Zero out the DelayCloseEntry pointer */
            ListEntry->KeyControlBlock->DelayCloseEntry = NULL;
 
            /* Cleanup the KCB cache */
            CmpCleanUpKcbCacheWithLock(ListEntry->KeyControlBlock, FALSE);
 
            /* Free the delay item */
            CmpFreeDelayItem(ListEntry);
 
            /* Decrement delayed close elements count */
            InterlockedDecrement((PLONG)&CmpDelayedCloseElements);
        }
 
        /* Release the KCB lock */
        CmpReleaseKcbLockByKey(ConvKey);
 
        /* Reacquire the delayed close table lock */
        KeAcquireGuardedMutex(&CmpDelayedCloseTableLock);
    }
 
    if (CmpDelayedCloseElements <= CmpDelayedCloseSize)
    {
        /* We're not active anymore */
        CmpDelayCloseWorkItemActive = FALSE;
    }
    else
    {
        /* We didn't process all things, so reschedule for the next time */
        CmpArmDelayedCloseTimer();
    }
 
    /* Release the delayed close table lock */
    KeReleaseGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Unlock the registry */
    CmpUnlockRegistry();
}

CmpAddToDelayedClose()

VOID NTAPI CmpAddToDelayedClose	(	IN PCM_KEY_CONTROL_BLOCK	Kcb,
		IN BOOLEAN	LockHeldExclusively
	)

Definition at line 350 of file cmdelay.c.

{
    ULONG i;
    ULONG OldRefCount, NewRefCount;
    PCM_DELAYED_CLOSE_ENTRY Entry;
    PAGED_CODE();
 
    /* Sanity check */
    CMP_ASSERT_KCB_LOCK(Kcb);
 
    /* Make sure it's valid */
    if (Kcb->DelayedCloseIndex != CmpDelayedCloseSize) ASSERT(FALSE);
 
    /* Sanity checks */
    ASSERT(Kcb->RefCount == 0);
    ASSERT(IsListEmpty(&Kcb->KeyBodyListHead) == TRUE);
    for (i = 0; i < 4; i++) ASSERT(Kcb->KeyBodyArray[i] == NULL);
 
    /* Allocate a delay item */
    Entry = CmpAllocateDelayItem();
    if (!Entry)
    {
        /* Cleanup immediately */
        CmpCleanUpKcbCacheWithLock(Kcb, LockHeldExclusively);
        return;
    }
 
    /* Sanity check */
    if (Kcb->InDelayClose) ASSERT(FALSE);
 
    /* Get the previous reference count */
    OldRefCount = *(PLONG)&Kcb->InDelayClose;
    ASSERT(OldRefCount == 0);
 
    /* Write the new one */
    NewRefCount = 1;
    if (InterlockedCompareExchange((PLONG)&Kcb->InDelayClose,
                                   NewRefCount,
                                   OldRefCount) != OldRefCount)
    {
        /* Sanity check */
        ASSERT(FALSE);
    }
 
    /* Reset the delayed close index */
    Kcb->DelayedCloseIndex = 0;
 
    /* Set up the close entry */
    Kcb->DelayCloseEntry = Entry;
    Entry->KeyControlBlock = Kcb;
 
    /* Increase the number of elements */
    InterlockedIncrement((PLONG)&CmpDelayedCloseElements);
 
    /* Acquire the delayed close table lock */
    KeAcquireGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Insert the entry into the list */
    InsertHeadList(&CmpDelayedLRUListHead, &Entry->DelayedLRUList);
 
    /* Check if we need to enable anything */
    if ((CmpDelayedCloseElements > CmpDelayedCloseSize) &&
        !(CmpDelayCloseWorkItemActive))
    {
        /* Yes, we have too many elements to close, and no work item */
        CmpArmDelayedCloseTimer();
    }
 
    /* Release the table lock */
    KeReleaseGuardedMutex(&CmpDelayedCloseTableLock);
}

Referenced by CmpDereferenceKeyControlBlockWithLock().

CmpArmDelayedCloseTimer()

VOID NTAPI CmpArmDelayedCloseTimer

(

VOID

)

Definition at line 335 of file cmdelay.c.

{
    LARGE_INTEGER Timeout;
    PAGED_CODE();
 
    /* Set the worker active */
    CmpDelayCloseWorkItemActive = TRUE;
 
    /* Setup the interval */
    Timeout.QuadPart = CmpDelayCloseIntervalInSeconds * -10000000;
    KeSetTimer(&CmpDelayCloseTimer, Timeout, &CmpDelayCloseDpc);
}

Referenced by _Function_class_(), and CmpAddToDelayedClose().

CmpDelayDerefKeyControlBlock()

VOID NTAPI CmpDelayDerefKeyControlBlock

(

IN PCM_KEY_CONTROL_BLOCK

Kcb

)

Definition at line 286 of file cmdelay.c.

{
    LONG OldRefCount, NewRefCount;
    LARGE_INTEGER Timeout;
    PCM_DELAY_DEREF_KCB_ITEM Entry;
    PAGED_CODE();
    CMTRACE(CM_REFERENCE_DEBUG,
            "%s - Dereferencing KCB: %p\n", __FUNCTION__, Kcb);
 
    /* Get the previous reference count */
    OldRefCount = *(PLONG)&Kcb->RefCount;
    NewRefCount = OldRefCount - 1;
    if (((NewRefCount & 0xFFFF) > 0) &&
        (InterlockedCompareExchange((PLONG)&Kcb->RefCount,
                                    NewRefCount,
                                    OldRefCount) == OldRefCount))
    {
        /* KCB still had references, so we're done */
        return;
    }
 
    /* Allocate a delay item */
    Entry = CmpAllocateDelayItem();
    if (!Entry) return;
 
    /* Set the KCB */
    Entry->Kcb = Kcb;
 
    /* Acquire the delayed deref table lock */
    KeAcquireGuardedMutex(&CmpDelayDerefKCBLock);
 
    /* Insert the entry into the list */
    InsertTailList(&CmpDelayDerefKCBListHead, &Entry->ListEntry);
 
    /* Check if we need to enable anything */
    if (!CmpDelayDerefKCBWorkItemActive)
    {
        /* Yes, we have no work item, setup the interval */
        CmpDelayDerefKCBWorkItemActive = TRUE;
        Timeout.QuadPart = CmpDelayDerefKCBIntervalInSeconds * -10000000;
        KeSetTimer(&CmpDelayDerefKCBTimer, Timeout, &CmpDelayDerefKCBDpc);
    }
 
    /* Release the table lock */
    KeReleaseGuardedMutex(&CmpDelayDerefKCBLock);
}

Referenced by CmpCleanUpKcbCacheWithLock(), CmpCleanUpKcbValueCache(), and CmpDeleteKeyObject().

CmpInitDelayDerefKCBEngine()

VOID NTAPI CmpInitDelayDerefKCBEngine

(

VOID

)

Definition at line 268 of file cmdelay.c.

{
    /* Initialize lock and list */
    KeInitializeGuardedMutex(&CmpDelayDerefKCBLock);
    InitializeListHead(&CmpDelayDerefKCBListHead);
 
    /* Setup the work item */
    ExInitializeWorkItem(&CmpDelayDerefKCBWorkItem,
                         CmpDelayDerefKCBWorker,
                         NULL);
 
    /* Setup the DPC and timer for it */
    KeInitializeDpc(&CmpDelayDerefKCBDpc, CmpDelayDerefKCBDpcRoutine, NULL);
    KeInitializeTimer(&CmpDelayDerefKCBTimer);
}

Referenced by CmInitSystem1().

CmpInitializeDelayedCloseTable()

VOID NTAPI CmpInitializeDelayedCloseTable

(

VOID

)

Definition at line 191 of file cmdelay.c.

{
 
    /* Setup the delayed close lock */
    KeInitializeGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Setup the work item */
    ExInitializeWorkItem(&CmpDelayCloseWorkItem, CmpDelayCloseWorker, NULL);
 
    /* Setup the list head */
    InitializeListHead(&CmpDelayedLRUListHead);
 
    /* Setup the DPC and its timer */
    KeInitializeDpc(&CmpDelayCloseDpc, CmpDelayCloseDpcRoutine, NULL);
    KeInitializeTimer(&CmpDelayCloseTimer);
}

Referenced by CmpInitializeCache().

CmpRemoveFromDelayedClose()

VOID NTAPI CmpRemoveFromDelayedClose

(

IN PCM_KEY_CONTROL_BLOCK

Kcb

)

Definition at line 425 of file cmdelay.c.

{
    PCM_DELAYED_CLOSE_ENTRY Entry;
    ULONG NewRefCount, OldRefCount;
    PAGED_CODE();
 
    /* Sanity checks */
    CMP_ASSERT_KCB_LOCK(Kcb);
    if (Kcb->DelayedCloseIndex == CmpDelayedCloseSize) ASSERT(FALSE);
 
    /* Get the entry and lock the table */
    Entry = Kcb->DelayCloseEntry;
    ASSERT(Entry);
    KeAcquireGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Remove the entry */
    RemoveEntryList(&Entry->DelayedLRUList);
 
    /* Release the lock */
    KeReleaseGuardedMutex(&CmpDelayedCloseTableLock);
 
    /* Free the entry */
    CmpFreeDelayItem(Entry);
 
    /* Reduce the number of elements */
    InterlockedDecrement((PLONG)&CmpDelayedCloseElements);
 
    /* Sanity check */
    if (!Kcb->InDelayClose) ASSERT(FALSE);
 
    /* Get the previous reference count */
    OldRefCount = *(PLONG)&Kcb->InDelayClose;
    ASSERT(OldRefCount == 1);
 
    /* Write the new one */
    NewRefCount = 0;
    if (InterlockedCompareExchange((PLONG)&Kcb->InDelayClose,
                                   NewRefCount,
                                   OldRefCount) != OldRefCount)
    {
        /* Sanity check */
        ASSERT(FALSE);
    }
 
    /* Remove the link to the entry */
    Kcb->DelayCloseEntry = NULL;
 
    /* Set new delay size and remove the delete flag */
    Kcb->DelayedCloseIndex = CmpDelayedCloseSize;
}

Referenced by CmpEnumerateOpenSubKeys(), CmpLookInCache(), and CmpReferenceKeyControlBlock().

Variable Documentation

CmpDelayCloseDpc

KDPC CmpDelayCloseDpc

Definition at line 26 of file cmdelay.c.

Referenced by CmpArmDelayedCloseTimer(), and CmpInitializeDelayedCloseTable().

CmpDelayCloseIntervalInSeconds

ULONG CmpDelayCloseIntervalInSeconds = 5

Definition at line 25 of file cmdelay.c.

Referenced by CmpArmDelayedCloseTimer().

CmpDelayCloseTimer

KTIMER CmpDelayCloseTimer

Definition at line 27 of file cmdelay.c.

Referenced by CmpArmDelayedCloseTimer(), and CmpInitializeDelayedCloseTable().

CmpDelayCloseWorkItem

WORK_QUEUE_ITEM CmpDelayCloseWorkItem

Definition at line 23 of file cmdelay.c.

Referenced by _Function_class_(), and CmpInitializeDelayedCloseTable().

CmpDelayCloseWorkItemActive

BOOLEAN CmpDelayCloseWorkItemActive

Definition at line 22 of file cmdelay.c.

Referenced by _Function_class_(), CmpAddToDelayedClose(), and CmpArmDelayedCloseTimer().

CmpDelayDerefKCBDpc

KDPC CmpDelayDerefKCBDpc

Definition at line 33 of file cmdelay.c.

Referenced by CmpDelayDerefKeyControlBlock(), and CmpInitDelayDerefKCBEngine().

CmpDelayDerefKCBIntervalInSeconds

ULONG CmpDelayDerefKCBIntervalInSeconds = 5

Definition at line 32 of file cmdelay.c.

Referenced by CmpDelayDerefKeyControlBlock().

CmpDelayDerefKCBListHead

LIST_ENTRY CmpDelayDerefKCBListHead

Definition at line 31 of file cmdelay.c.

Referenced by CmpDelayDerefKeyControlBlock(), and CmpInitDelayDerefKCBEngine().

CmpDelayDerefKCBLock

KGUARDED_MUTEX CmpDelayDerefKCBLock

Definition at line 29 of file cmdelay.c.

Referenced by CmpDelayDerefKeyControlBlock(), and CmpInitDelayDerefKCBEngine().

CmpDelayDerefKCBTimer

KTIMER CmpDelayDerefKCBTimer

Definition at line 34 of file cmdelay.c.

Referenced by CmpDelayDerefKeyControlBlock(), and CmpInitDelayDerefKCBEngine().

CmpDelayDerefKCBWorkItem

WORK_QUEUE_ITEM CmpDelayDerefKCBWorkItem

Definition at line 17 of file cmdelay.c.

Referenced by CmpInitDelayDerefKCBEngine().

CmpDelayDerefKCBWorkItemActive

BOOLEAN CmpDelayDerefKCBWorkItemActive

Definition at line 30 of file cmdelay.c.

Referenced by CmpDelayDerefKeyControlBlock().

CmpDelayedCloseElements

ULONG CmpDelayedCloseElements

Definition at line 20 of file cmdelay.c.

Referenced by _Function_class_(), CmpAddToDelayedClose(), and CmpRemoveFromDelayedClose().

CmpDelayedCloseSize

ULONG CmpDelayedCloseSize = 2048

Definition at line 19 of file cmdelay.c.

Referenced by _Function_class_(), CmpAddToDelayedClose(), CmpCreateKeyControlBlock(), CmpReferenceKeyControlBlock(), and CmpRemoveFromDelayedClose().

CmpDelayedCloseTableLock

KGUARDED_MUTEX CmpDelayedCloseTableLock

Definition at line 21 of file cmdelay.c.

Referenced by _Function_class_(), CmpAddToDelayedClose(), CmpInitializeDelayedCloseTable(), and CmpRemoveFromDelayedClose().

CmpDelayedLRUListHead

LIST_ENTRY CmpDelayedLRUListHead

Definition at line 24 of file cmdelay.c.

Referenced by _Function_class_(), CmpAddToDelayedClose(), and CmpInitializeDelayedCloseTable().