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

Include dependency graph for cmalloc.c:

Macros
#define	NDEBUG

Variables
BOOLEAN	CmpAllocInited

KGUARDED_MUTEX	CmpAllocBucketLock

LIST_ENTRY	CmpFreeKCBListHead

KGUARDED_MUTEX	CmpDelayAllocBucketLock

LIST_ENTRY	CmpFreeDelayItemsListHead

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 12 of file cmalloc.c.

Function Documentation

◆ CmpAllocateDelayItem()

PVOID NTAPI CmpAllocateDelayItem ( VOID )

Definition at line 199 of file cmalloc.c.

{
    PCM_DELAY_ALLOC Entry;
    PCM_ALLOC_PAGE AllocPage;
    ULONG i;
    PLIST_ENTRY NextEntry;
    PAGED_CODE();
 
    /* Lock the allocation buckets */
    KeAcquireGuardedMutex(&CmpDelayAllocBucketLock);
 
    /* Look for an item on the free list */
SearchList:
    if (!IsListEmpty(&CmpFreeDelayItemsListHead))
    {
        /* Get the current entry in the list */
        NextEntry = RemoveHeadList(&CmpFreeDelayItemsListHead);
 
        /* Grab the item */
        Entry = CONTAINING_RECORD(NextEntry, CM_DELAY_ALLOC, ListEntry);
 
        /* Clear the list */
        Entry->ListEntry.Flink = Entry->ListEntry.Blink = NULL;
 
        /* Grab the alloc page */
        AllocPage = CmpGetAllocPageFromDelayAlloc(Entry);
 
        /* Decrease free entries */
        ASSERT(AllocPage->FreeCount != 0);
        AllocPage->FreeCount--;
 
        /* Release the lock */
        KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
        return Entry;
    }
 
    /* Allocate an allocation page */
    AllocPage = CmpAllocate(PAGE_SIZE, TRUE, TAG_CM);
    if (AllocPage)
    {
        /* Set default entries */
        AllocPage->FreeCount = CM_DELAYS_PER_PAGE;
 
        /* Loop each entry */
        for (i = 0; i < CM_DELAYS_PER_PAGE; i++)
        {
            /* Get this entry and link it */
            Entry = (PVOID)((ULONG_PTR)AllocPage +
                            FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
                            i * sizeof(CM_DELAY_ALLOC));
            InsertTailList(&CmpFreeDelayItemsListHead,
                           &Entry->ListEntry);
 
            /* Clear the KCB pointer */
            Entry->Kcb = NULL;
        }
 
        /* Do the search again */
        goto SearchList;
    }
 
    /* Release the lock */
    KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
    return NULL;
}

Referenced by CmpAddToDelayedClose(), and CmpDelayDerefKeyControlBlock().

◆ CmpAllocateKeyControlBlock()

PCM_KEY_CONTROL_BLOCK NTAPI CmpAllocateKeyControlBlock ( VOID )

Definition at line 111 of file cmalloc.c.

{
    PLIST_ENTRY NextEntry;
    PCM_KEY_CONTROL_BLOCK CurrentKcb;
    PCM_ALLOC_PAGE AllocPage;
    ULONG i;
    PAGED_CODE();
 
    /* Check if private allocations are initialized */
    if (CmpAllocInited)
    {
        /* They are, acquire the bucket lock */
        KeAcquireGuardedMutex(&CmpAllocBucketLock);
 
        /* See if there's something on the free KCB list */
SearchKcbList:
        if (!IsListEmpty(&CmpFreeKCBListHead))
        {
            /* Remove the entry */
            NextEntry = RemoveHeadList(&CmpFreeKCBListHead);
 
            /* Get the KCB */
            CurrentKcb = CONTAINING_RECORD(NextEntry,
                                           CM_KEY_CONTROL_BLOCK,
                                           FreeListEntry);
 
            /* Get the allocation page */
            AllocPage = CmpGetAllocPageFromKcb(CurrentKcb);
 
            /* Decrease the free count */
            ASSERT(AllocPage->FreeCount != 0);
            AllocPage->FreeCount--;
 
            /* Make sure this KCB is privately allocated */
            ASSERT(CurrentKcb->PrivateAlloc == 1);
 
            /* Release the allocation lock */
            KeReleaseGuardedMutex(&CmpAllocBucketLock);
 
            /* Return the KCB */
            return CurrentKcb;
        }
 
        /* Allocate an allocation page */
        AllocPage = CmpAllocate(PAGE_SIZE, TRUE, TAG_KCB);
        if (AllocPage)
        {
            /* Set default entries */
            AllocPage->FreeCount = CM_KCBS_PER_PAGE;
 
            /* Loop each entry */
            for (i = 0; i < CM_KCBS_PER_PAGE; i++)
            {
                /* Get this entry */
                CurrentKcb = (PVOID)((ULONG_PTR)AllocPage +
                                     FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
                                     i * sizeof(CM_KEY_CONTROL_BLOCK));
 
                /* Set it up */
                CurrentKcb->PrivateAlloc = TRUE;
                CurrentKcb->DelayCloseEntry = NULL;
                InsertTailList(&CmpFreeKCBListHead,
                               &CurrentKcb->FreeListEntry);
            }
 
            /* Now go back and search the list */
            goto SearchKcbList;
        }
 
        /* Release the allocation lock */
        KeReleaseGuardedMutex(&CmpAllocBucketLock);
    }
 
    /* Allocate a KCB only */
    CurrentKcb = CmpAllocate(sizeof(CM_KEY_CONTROL_BLOCK), TRUE, TAG_KCB);
    if (CurrentKcb)
    {
        /* Set it up */
        CurrentKcb->PrivateAlloc = 0;
        CurrentKcb->DelayCloseEntry = NULL;
    }
 
    /* Return it */
    return CurrentKcb;
}

Referenced by CmpCreateKeyControlBlock().

◆ CmpFreeDelayItem()

VOID NTAPI CmpFreeDelayItem ( PVOID Entry )

Definition at line 267 of file cmalloc.c.

{
    PCM_DELAY_ALLOC AllocEntry = (PCM_DELAY_ALLOC)Entry;
    PCM_ALLOC_PAGE AllocPage;
    ULONG i;
    PAGED_CODE();
 
    /* Lock the table */
    KeAcquireGuardedMutex(&CmpDelayAllocBucketLock);
 
    /* Add the entry at the end */
    InsertTailList(&CmpFreeDelayItemsListHead, &AllocEntry->ListEntry);
 
    /* Get the alloc page */
    AllocPage = CmpGetAllocPageFromDelayAlloc(Entry);
    ASSERT(AllocPage->FreeCount != CM_DELAYS_PER_PAGE);
 
    /* Increase the number of free items */
    if (++AllocPage->FreeCount == CM_DELAYS_PER_PAGE)
    {
        /* Page is totally free now, loop each entry */
        for (i = 0; i < CM_DELAYS_PER_PAGE; i++)
        {
            /* Get the entry and unlink it */
            AllocEntry = (PVOID)((ULONG_PTR)AllocPage +
                                 FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
                                 i * sizeof(CM_DELAY_ALLOC));
            RemoveEntryList(&AllocEntry->ListEntry);
        }
 
        /* Now free the page */
        CmpFree(AllocPage, TAG_CM);
    }
 
    /* Release the lock */
    KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
}

Referenced by _Function_class_(), and CmpRemoveFromDelayedClose().

◆ CmpFreeKeyControlBlock()

VOID NTAPI CmpFreeKeyControlBlock ( IN PCM_KEY_CONTROL_BLOCK Kcb )

Definition at line 53 of file cmalloc.c.

{
    ULONG i;
    PCM_ALLOC_PAGE AllocPage;
    PAGED_CODE();
 
    /* Sanity checks */
    ASSERT(IsListEmpty(&Kcb->KeyBodyListHead) == TRUE);
    for (i = 0; i < 4; i++) ASSERT(Kcb->KeyBodyArray[i] == NULL);
 
    /* Check if it wasn't privately allocated */
    if (!Kcb->PrivateAlloc)
    {
        /* Free it from the pool */
        CmpFree(Kcb, TAG_KCB);
        return;
    }
 
    /* Acquire the private allocation lock */
    KeAcquireGuardedMutex(&CmpAllocBucketLock);
 
    /* Sanity check on lock ownership */
    CMP_ASSERT_HASH_ENTRY_LOCK(Kcb->ConvKey);
 
    /* Add us to the free list */
    InsertTailList(&CmpFreeKCBListHead, &Kcb->FreeListEntry);
 
    /* Get the allocation page */
    AllocPage = CmpGetAllocPageFromKcb(Kcb);
 
    /* Sanity check */
    ASSERT(AllocPage->FreeCount != CM_KCBS_PER_PAGE);
 
    /* Increase free count */
    if (++AllocPage->FreeCount == CM_KCBS_PER_PAGE)
    {
        /* Loop all the entries */
        for (i = 0; i < CM_KCBS_PER_PAGE; i++)
        {
            /* Get the KCB */
            Kcb = (PVOID)((ULONG_PTR)AllocPage +
                          FIELD_OFFSET(CM_ALLOC_PAGE, AllocPage) +
                          i * sizeof(CM_KEY_CONTROL_BLOCK));
 
            /* Remove the entry */
            RemoveEntryList(&Kcb->FreeListEntry);
        }
 
        /* Free the page */
        CmpFree(AllocPage, TAG_KCB);
    }
 
    /* Release the lock */
    KeReleaseGuardedMutex(&CmpAllocBucketLock);
}

Referenced by CmpCleanUpKcbCacheWithLock(), and CmpCreateKeyControlBlock().

◆ CmpInitCmPrivateAlloc()

VOID NTAPI CmpInitCmPrivateAlloc ( VOID )

Definition at line 29 of file cmalloc.c.

{
    /* Make sure we didn't already do this */
    if (!CmpAllocInited)
    {
        /* Setup the lock and list */
        KeInitializeGuardedMutex(&CmpAllocBucketLock);
        InitializeListHead(&CmpFreeKCBListHead);
        CmpAllocInited = TRUE;
    }
}

Referenced by CmInitSystem1().

◆ CmpInitCmPrivateDelayAlloc()

VOID NTAPI CmpInitCmPrivateDelayAlloc ( VOID )

Definition at line 44 of file cmalloc.c.

{
    /* Initialize the delay allocation list and lock */
    KeInitializeGuardedMutex(&CmpDelayAllocBucketLock);
    InitializeListHead(&CmpFreeDelayItemsListHead);
}

Referenced by CmInitSystem1().

Variable Documentation

◆ CmpAllocBucketLock

KGUARDED_MUTEX CmpAllocBucketLock

Definition at line 18 of file cmalloc.c.

Referenced by CmpAllocateKeyControlBlock(), CmpFreeKeyControlBlock(), and CmpInitCmPrivateAlloc().

◆ CmpAllocInited

BOOLEAN CmpAllocInited

Definition at line 17 of file cmalloc.c.

Referenced by CmpAllocateKeyControlBlock(), and CmpInitCmPrivateAlloc().

◆ CmpDelayAllocBucketLock

KGUARDED_MUTEX CmpDelayAllocBucketLock

Definition at line 21 of file cmalloc.c.

Referenced by CmpAllocateDelayItem(), CmpFreeDelayItem(), and CmpInitCmPrivateDelayAlloc().

◆ CmpFreeDelayItemsListHead

LIST_ENTRY CmpFreeDelayItemsListHead

Definition at line 22 of file cmalloc.c.