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

Include dependency graph for cmalloc.c:

Macros
#define	NDEBUG

Functions
INIT_FUNCTION VOID NTAPI	CmpInitCmPrivateAlloc (VOID)

INIT_FUNCTION VOID NTAPI	CmpInitCmPrivateDelayAlloc (VOID)

VOID NTAPI	CmpFreeKeyControlBlock (IN PCM_KEY_CONTROL_BLOCK Kcb)

PCM_KEY_CONTROL_BLOCK NTAPI	CmpAllocateKeyControlBlock (VOID)

PVOID NTAPI	CmpAllocateDelayItem (VOID)

VOID NTAPI	CmpFreeDelayItem (PVOID Entry)

Variables
BOOLEAN	CmpAllocInited

KGUARDED_MUTEX	CmpAllocBucketLock

KGUARDED_MUTEX	CmpDelayAllocBucketLock

LIST_ENTRY	CmpFreeKCBListHead

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 196 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;
         }
     }
     else
     {
         /* Release the lock */
         KeReleaseGuardedMutex(&CmpDelayAllocBucketLock);
         return NULL;
     }
 
     /* Do the search again */
     goto SearchList;
 }

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;
         }
     }
 
     /* 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 266 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()

INIT_FUNCTION 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()

INIT_FUNCTION VOID NTAPI CmpInitCmPrivateDelayAlloc ( VOID )

Definition at line 44 of file cmalloc.c.

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