hivecell.c File Reference

#include "cmlib.h"
#include <debug.h>

Include dependency graph for hivecell.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	CELL_REF_INCREMENT   10

Functions
VOID NTAPI	CmpLazyFlush (VOID)
static __inline PHCELL CMAPI	HvpGetCellHeader (PHHIVE RegistryHive, HCELL_INDEX CellIndex)
BOOLEAN CMAPI	HvIsCellAllocated (IN PHHIVE RegistryHive, IN HCELL_INDEX CellIndex)
PCELL_DATA CMAPI	HvpGetCellData (_In_ PHHIVE Hive, _In_ HCELL_INDEX CellIndex)
static __inline LONG CMAPI	HvpGetCellFullSize (PHHIVE RegistryHive, PVOID Cell)
LONG CMAPI	HvGetCellSize (IN PHHIVE Hive, IN PVOID Address)
BOOLEAN CMAPI	HvMarkCellDirty (PHHIVE RegistryHive, HCELL_INDEX CellIndex, BOOLEAN HoldingLock)
BOOLEAN CMAPI	HvIsCellDirty (IN PHHIVE Hive, IN HCELL_INDEX Cell)
static __inline ULONG CMAPI	HvpComputeFreeListIndex (ULONG Size)
static NTSTATUS CMAPI	HvpAddFree (PHHIVE RegistryHive, PHCELL FreeBlock, HCELL_INDEX FreeIndex)
static VOID CMAPI	HvpRemoveFree (PHHIVE RegistryHive, PHCELL CellBlock, HCELL_INDEX CellIndex)
static HCELL_INDEX CMAPI	HvpFindFree (PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage)
NTSTATUS CMAPI	HvpCreateHiveFreeCellList (PHHIVE Hive)
HCELL_INDEX CMAPI	HvAllocateCell (PHHIVE RegistryHive, ULONG Size, HSTORAGE_TYPE Storage, HCELL_INDEX Vicinity)
HCELL_INDEX CMAPI	HvReallocateCell (PHHIVE RegistryHive, HCELL_INDEX CellIndex, ULONG Size)
VOID CMAPI	HvFreeCell (PHHIVE RegistryHive, HCELL_INDEX CellIndex)
BOOLEAN CMAPI	HvTrackCellRef (IN OUT PHV_TRACK_CELL_REF CellRef, IN PHHIVE Hive, IN HCELL_INDEX Cell)
VOID CMAPI	HvReleaseFreeCellRefArray (IN OUT PHV_TRACK_CELL_REF CellRef)

Macro Definition Documentation

CELL_REF_INCREMENT

#define CELL_REF_INCREMENT   10

Definition at line 550 of file hivecell.c.

NDEBUG

#define NDEBUG

Definition at line 9 of file hivecell.c.

Function Documentation

CmpLazyFlush()

VOID NTAPI CmpLazyFlush

(

VOID

)

Definition at line 157 of file cmlazy.c.

{
    LARGE_INTEGER DueTime;
    PAGED_CODE();
 
    /* Check if we should set the lazy flush timer */
    if (!CmpNoWrite && !CmpHoldLazyFlush)
    {
        /* Do it */
        DueTime.QuadPart = Int32x32To64(CmpLazyFlushIntervalInSeconds,
                                        -10 * 1000 * 1000);
        KeSetTimer(&CmpLazyFlushTimer, DueTime, &CmpLazyFlushDpc);
    }
}

Referenced by _Function_class_(), HvMarkCellDirty(), and NtInitializeRegistry().

HvAllocateCell()

HCELL_INDEX CMAPI HvAllocateCell	(	PHHIVE	RegistryHive,
		ULONG	Size,
		HSTORAGE_TYPE	Storage,
		HCELL_INDEX	Vicinity
	)

Definition at line 357 of file hivecell.c.

{
    PHCELL FreeCell;
    HCELL_INDEX FreeCellOffset;
    PHCELL NewCell;
    PHBIN Bin;
 
    ASSERT(RegistryHive->ReadOnly == FALSE);
 
    CMLTRACE(CMLIB_HCELL_DEBUG, "%s - Hive %p, Size %x, %s, Vicinity %08lx\n",
             __FUNCTION__, RegistryHive, Size, (Storage == 0) ? "Stable" : "Volatile", Vicinity);
 
    /* Round to 16 bytes multiple. */
    Size = ROUND_UP(Size + sizeof(HCELL), 16);
 
    /* First search in free blocks. */
    FreeCellOffset = HvpFindFree(RegistryHive, Size, Storage);
 
    /* If no free cell was found we need to extend the hive file. */
    if (FreeCellOffset == HCELL_NIL)
    {
        Bin = HvpAddBin(RegistryHive, Size, Storage);
        if (Bin == NULL)
            return HCELL_NIL;
        FreeCellOffset = Bin->FileOffset + sizeof(HBIN);
        FreeCellOffset |= Storage << HCELL_TYPE_SHIFT;
    }
 
    FreeCell = HvpGetCellHeader(RegistryHive, FreeCellOffset);
 
    /* Split the block in two parts */
 
    /* The free block that is created has to be at least
       sizeof(HCELL) + sizeof(HCELL_INDEX) big, so that free
       cell list code can work. Moreover we round cell sizes
       to 16 bytes, so creating a smaller block would result in
       a cell that would never be allocated. */
    if ((ULONG)FreeCell->Size > Size + 16)
    {
        NewCell = (PHCELL)((ULONG_PTR)FreeCell + Size);
        NewCell->Size = FreeCell->Size - Size;
        FreeCell->Size = Size;
        HvpAddFree(RegistryHive, NewCell, FreeCellOffset + Size);
        if (Storage == Stable)
            HvMarkCellDirty(RegistryHive, FreeCellOffset + Size, FALSE);
    }
 
    if (Storage == Stable)
        HvMarkCellDirty(RegistryHive, FreeCellOffset, FALSE);
 
    FreeCell->Size = -FreeCell->Size;
    RtlZeroMemory(FreeCell + 1, Size - sizeof(HCELL));
 
    CMLTRACE(CMLIB_HCELL_DEBUG, "%s - CellIndex %08lx\n",
             __FUNCTION__, FreeCellOffset);
 
    return FreeCellOffset;
}

Referenced by HvReallocateCell().

HvFreeCell()

VOID CMAPI HvFreeCell	(	PHHIVE	RegistryHive,
		HCELL_INDEX	CellIndex
	)

Definition at line 468 of file hivecell.c.

{
    PHCELL Free;
    PHCELL Neighbor;
    PHBIN Bin;
    ULONG CellType;
    ULONG CellBlock;
 
    ASSERT(RegistryHive->ReadOnly == FALSE);
 
    CMLTRACE(CMLIB_HCELL_DEBUG, "%s - Hive %p, CellIndex %08lx\n",
             __FUNCTION__, RegistryHive, CellIndex);
 
    Free = HvpGetCellHeader(RegistryHive, CellIndex);
 
    ASSERT(Free->Size < 0);
 
    Free->Size = -Free->Size;
 
    CellType = HvGetCellType(CellIndex);
    CellBlock = HvGetCellBlock(CellIndex);
 
    /* FIXME: Merge free blocks */
    Bin = (PHBIN)RegistryHive->Storage[CellType].BlockList[CellBlock].BinAddress;
 
    if ((CellIndex & ~HCELL_TYPE_MASK) + Free->Size <
        Bin->FileOffset + Bin->Size)
    {
        Neighbor = (PHCELL)((ULONG_PTR)Free + Free->Size);
        if (Neighbor->Size > 0)
        {
            HvpRemoveFree(RegistryHive, Neighbor,
                          ((HCELL_INDEX)((ULONG_PTR)Neighbor - (ULONG_PTR)Bin +
                            Bin->FileOffset)) | (CellIndex & HCELL_TYPE_MASK));
            Free->Size += Neighbor->Size;
        }
    }
 
    Neighbor = (PHCELL)(Bin + 1);
    while (Neighbor < Free)
    {
        if (Neighbor->Size > 0)
        {
            if ((ULONG_PTR)Neighbor + Neighbor->Size == (ULONG_PTR)Free)
            {
                HCELL_INDEX NeighborCellIndex =
                    ((HCELL_INDEX)((ULONG_PTR)Neighbor - (ULONG_PTR)Bin +
                     Bin->FileOffset)) | (CellIndex & HCELL_TYPE_MASK);
 
                if (HvpComputeFreeListIndex(Neighbor->Size) !=
                    HvpComputeFreeListIndex(Neighbor->Size + Free->Size))
                {
                   HvpRemoveFree(RegistryHive, Neighbor, NeighborCellIndex);
                   Neighbor->Size += Free->Size;
                   HvpAddFree(RegistryHive, Neighbor, NeighborCellIndex);
                }
                else
                    Neighbor->Size += Free->Size;
 
                if (CellType == Stable)
                    HvMarkCellDirty(RegistryHive, NeighborCellIndex, FALSE);
 
                return;
            }
            Neighbor = (PHCELL)((ULONG_PTR)Neighbor + Neighbor->Size);
        }
        else
        {
            Neighbor = (PHCELL)((ULONG_PTR)Neighbor - Neighbor->Size);
        }
    }
 
    /* Add block to the list of free blocks */
    HvpAddFree(RegistryHive, Free, CellIndex);
 
    if (CellType == Stable)
        HvMarkCellDirty(RegistryHive, CellIndex, FALSE);
}

Referenced by CmCreateRootNode(), CmiAddValueKey(), CmiCreateSubKey(), CmpCopyKeyValueList(), CmpCopyValue(), CmpDeepCopyKeyInternal(), CmpDoCreateChild(), CmpFreeKeyBody(), CmpFreeKeyByCell(), CmpFreeSecurityDescriptor(), CmpFreeValue(), CmpFreeValueData(), CmpRemoveSubKey(), CmpRemoveValueFromList(), CmpSetValueKeyNew(), CmpSplitLeaf(), HvReallocateCell(), and RegSetValueExW().

HvGetCellSize()

LONG CMAPI HvGetCellSize	(	IN PHHIVE	Hive,
		IN PVOID	Address
	)

Definition at line 94 of file hivecell.c.

{
    PHCELL CellHeader;
    LONG Size;
 
    UNREFERENCED_PARAMETER(Hive);
 
    CellHeader = (PHCELL)Address - 1;
    Size = CellHeader->Size * -1;
    Size -= sizeof(HCELL);
    return Size;
}

Referenced by HvReallocateCell().

HvIsCellAllocated()

BOOLEAN CMAPI HvIsCellAllocated	(	IN PHHIVE	RegistryHive,
		IN HCELL_INDEX	CellIndex
	)

Definition at line 53 of file hivecell.c.

{
    ULONG Type, Block;
 
    /* If it's a flat hive, the cell is always allocated */
    if (RegistryHive->Flat)
        return TRUE;
 
    /* Otherwise, get the type and make sure it's valid */
    Type = HvGetCellType(CellIndex);
    Block = HvGetCellBlock(CellIndex);
    if (Block >= RegistryHive->Storage[Type].Length)
        return FALSE;
 
    /* Try to get the cell block */
    if (RegistryHive->Storage[Type].BlockList[Block].BlockAddress)
        return TRUE;
 
    /* No valid block, fail */
    return FALSE;
}

Referenced by CmpValidateClass(), CmpValidateKey(), CmpValidateSubKeyList(), CmpValidateValueList(), and CmpValidateValueListByCount().

HvIsCellDirty()

BOOLEAN CMAPI HvIsCellDirty	(	IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell
	)

Definition at line 153 of file hivecell.c.

{
    BOOLEAN IsDirty = FALSE;
 
    /* Sanity checks */
    ASSERT(Hive->ReadOnly == FALSE);
 
    /* Volatile cells are always "dirty" */
    if (HvGetCellType(Cell) == Volatile)
        return TRUE;
 
    /* Check if the dirty bit is set */
    if (RtlCheckBit(&Hive->DirtyVector, Cell / HBLOCK_SIZE))
        IsDirty = TRUE;
 
    /* Return result as boolean*/
    return IsDirty;
}

Referenced by CmDeleteKey(), CmDeleteValueKey(), CmpAddValueToList(), CmpRemoveSubKey(), CmpRemoveValueFromList(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), RegDeleteKeyW(), and RegDeleteValueW().

HvMarkCellDirty()

BOOLEAN CMAPI HvMarkCellDirty	(	PHHIVE	RegistryHive,
		HCELL_INDEX	CellIndex,
		BOOLEAN	HoldingLock
	)

Definition at line 109 of file hivecell.c.

{
    ULONG CellBlock;
    ULONG CellLastBlock;
 
    ASSERT(RegistryHive->ReadOnly == FALSE);
 
    CMLTRACE(CMLIB_HCELL_DEBUG, "%s - Hive %p, CellIndex %08lx, HoldingLock %u\n",
             __FUNCTION__, RegistryHive, CellIndex, HoldingLock);
 
    if (HvGetCellType(CellIndex) != Stable)
        return TRUE;
 
    CellBlock     = HvGetCellBlock(CellIndex);
    CellLastBlock = HvGetCellBlock(CellIndex + HBLOCK_SIZE - 1);
 
    RtlSetBits(&RegistryHive->DirtyVector,
               CellBlock, CellLastBlock - CellBlock);
    RegistryHive->DirtyCount++;
 
    /*
     * FIXME: Querying a lazy flush operation is needed to
     * ensure that the dirty data is being flushed to disk
     * accordingly. However, this operation has to be done
     * in a helper like HvMarkDirty that marks specific parts
     * of the hive as dirty. Since we do not have such kind
     * of helper we have to perform an eventual lazy flush
     * when marking cells as dirty here for the moment being,
     * so that not only we flush dirty data but also write
     * logs.
     */
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
    if (!(RegistryHive->HiveFlags & HIVE_NOLAZYFLUSH))
    {
        CmpLazyFlush();
    }
#endif
    return TRUE;
}

Referenced by CmDeleteValueKey(), CmiAddSubKey(), CmiAddValueKey(), CmpAddSubKey(), CmpAddToLeaf(), CmpCreateLinkNode(), CmpDoCreate(), CmpMarkIndexDirty(), CmpMarkKeyDirty(), CmpMarkValueDataDirty(), CmpPurgeVolatiles(), CmpRemoveSubKeyInLeaf(), CmpRemoveSubkeyInRoot(), CmpRepairClassOfNodeKey(), CmpRepairKeyNodeSignature(), CmpRepairParentKey(), CmpRepairParentNode(), CmpRepairSubKeyCounts(), CmpRepairSubKeyList(), CmpRepairValueList(), CmpRepairValueListCount(), CmpSelectLeaf(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), CmpSplitLeaf(), CmpValidateClass(), CmSetValueKey(), HvAllocateCell(), HvFreeCell(), RegDeleteValueW(), and RegSetValueExW().

HvpAddFree()

static NTSTATUS CMAPI HvpAddFree ( PHHIVE  RegistryHive, PHCELL  FreeBlock, HCELL_INDEX  FreeIndex  )

static

Definition at line 202 of file hivecell.c.

{
    PHCELL_INDEX FreeBlockData;
    HSTORAGE_TYPE Storage;
    ULONG Index;
 
    ASSERT(RegistryHive != NULL);
    ASSERT(FreeBlock != NULL);
 
    Storage = HvGetCellType(FreeIndex);
    Index = HvpComputeFreeListIndex((ULONG)FreeBlock->Size);
 
    FreeBlockData = (PHCELL_INDEX)(FreeBlock + 1);
    *FreeBlockData = RegistryHive->Storage[Storage].FreeDisplay[Index];
    RegistryHive->Storage[Storage].FreeDisplay[Index] = FreeIndex;
 
    /* FIXME: Eventually get rid of free bins. */
 
    return STATUS_SUCCESS;
}

Referenced by HvAllocateCell(), HvFreeCell(), and HvpCreateHiveFreeCellList().

HvpComputeFreeListIndex()

static __inline ULONG CMAPI HvpComputeFreeListIndex ( ULONG  Size )

static

Definition at line 174 of file hivecell.c.

{
    ULONG Index;
    static CCHAR FindFirstSet[128] = {
        0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
        4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
        5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
        6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
 
    ASSERT(Size >= (1 << 3));
    Index = (Size >> 3) - 1;
    if (Index >= 16)
    {
        if (Index > 127)
            Index = 23;
        else
            Index = FindFirstSet[Index] + 16;
    }
 
    return Index;
}

Referenced by HvFreeCell(), HvpAddFree(), HvpFindFree(), and HvpRemoveFree().

HvpCreateHiveFreeCellList()

NTSTATUS CMAPI HvpCreateHiveFreeCellList

(

PHHIVE

Hive

)

Definition at line 306 of file hivecell.c.

{
    HCELL_INDEX BlockOffset;
    PHCELL FreeBlock;
    ULONG BlockIndex;
    ULONG FreeOffset;
    PHBIN Bin;
    NTSTATUS Status;
    ULONG Index;
 
    /* Initialize the free cell list */
    for (Index = 0; Index < 24; Index++)
    {
        Hive->Storage[Stable].FreeDisplay[Index] = HCELL_NIL;
        Hive->Storage[Volatile].FreeDisplay[Index] = HCELL_NIL;
    }
 
    BlockOffset = 0;
    BlockIndex = 0;
    while (BlockIndex < Hive->Storage[Stable].Length)
    {
        Bin = (PHBIN)Hive->Storage[Stable].BlockList[BlockIndex].BinAddress;
 
        /* Search free blocks and add to list */
        FreeOffset = sizeof(HBIN);
        while (FreeOffset < Bin->Size)
        {
            FreeBlock = (PHCELL)((ULONG_PTR)Bin + FreeOffset);
            if (FreeBlock->Size > 0)
            {
                Status = HvpAddFree(Hive, FreeBlock, Bin->FileOffset + FreeOffset);
                if (!NT_SUCCESS(Status))
                    return Status;
 
                FreeOffset += FreeBlock->Size;
            }
            else
            {
                FreeOffset -= FreeBlock->Size;
            }
        }
 
        BlockIndex += Bin->Size / HBLOCK_SIZE;
        BlockOffset += Bin->Size;
    }
 
    return STATUS_SUCCESS;
}

Referenced by HvpInitializeMemoryHive().

HvpFindFree()

static HCELL_INDEX CMAPI HvpFindFree ( PHHIVE  RegistryHive, ULONG  Size, HSTORAGE_TYPE  Storage  )

static

Definition at line 276 of file hivecell.c.

{
    PHCELL_INDEX FreeCellData;
    HCELL_INDEX FreeCellOffset;
    PHCELL_INDEX pFreeCellOffset;
    ULONG Index;
 
    for (Index = HvpComputeFreeListIndex(Size); Index < 24; Index++)
    {
        pFreeCellOffset = &RegistryHive->Storage[Storage].FreeDisplay[Index];
        while (*pFreeCellOffset != HCELL_NIL)
        {
            FreeCellData = (PHCELL_INDEX)HvGetCell(RegistryHive, *pFreeCellOffset);
            if ((ULONG)HvpGetCellFullSize(RegistryHive, FreeCellData) >= Size)
            {
                FreeCellOffset = *pFreeCellOffset;
                *pFreeCellOffset = *FreeCellData;
                return FreeCellOffset;
            }
            pFreeCellOffset = FreeCellData;
        }
    }
 
    return HCELL_NIL;
}

Referenced by HvAllocateCell().

HvpGetCellData()

PCELL_DATA CMAPI HvpGetCellData	(	_In_ PHHIVE	Hive,
		_In_ HCELL_INDEX	CellIndex
	)

Definition at line 77 of file hivecell.c.

{
    return (PCELL_DATA)(HvpGetCellHeader(Hive, CellIndex) + 1);
}

Referenced by HvInitialize().

HvpGetCellFullSize()

static __inline LONG CMAPI HvpGetCellFullSize ( PHHIVE  RegistryHive, PVOID  Cell  )

static

Definition at line 85 of file hivecell.c.

{
    UNREFERENCED_PARAMETER(RegistryHive);
    return ((PHCELL)Cell - 1)->Size;
}

Referenced by HvpFindFree().

HvpGetCellHeader()

static __inline PHCELL CMAPI HvpGetCellHeader ( PHHIVE  RegistryHive, HCELL_INDEX  CellIndex  )

static

Definition at line 23 of file hivecell.c.

{
    PVOID Block;
 
    CMLTRACE(CMLIB_HCELL_DEBUG, "%s - Hive %p, CellIndex %08lx\n",
             __FUNCTION__, RegistryHive, CellIndex);
 
    ASSERT(CellIndex != HCELL_NIL);
    if (!RegistryHive->Flat)
    {
        ULONG CellType   = HvGetCellType(CellIndex);
        ULONG CellBlock  = HvGetCellBlock(CellIndex);
        ULONG CellOffset = (CellIndex & HCELL_OFFSET_MASK) >> HCELL_OFFSET_SHIFT;
 
        ASSERT(CellBlock < RegistryHive->Storage[CellType].Length);
        Block = (PVOID)RegistryHive->Storage[CellType].BlockList[CellBlock].BlockAddress;
        ASSERT(Block != NULL);
        return (PHCELL)((ULONG_PTR)Block + CellOffset);
    }
    else
    {
        ASSERT(HvGetCellType(CellIndex) == Stable);
        return (PHCELL)((ULONG_PTR)RegistryHive->BaseBlock + HBLOCK_SIZE +
                        CellIndex);
    }
}

Referenced by HvAllocateCell(), HvFreeCell(), and HvpGetCellData().

HvpRemoveFree()

static VOID CMAPI HvpRemoveFree ( PHHIVE  RegistryHive, PHCELL  CellBlock, HCELL_INDEX  CellIndex  )

static

Definition at line 227 of file hivecell.c.

{
    PHCELL_INDEX FreeCellData;
    PHCELL_INDEX pFreeCellOffset;
    HSTORAGE_TYPE Storage;
    ULONG Index, FreeListIndex;
 
    ASSERT(RegistryHive->ReadOnly == FALSE);
 
    Storage = HvGetCellType(CellIndex);
    Index = HvpComputeFreeListIndex((ULONG)CellBlock->Size);
 
    pFreeCellOffset = &RegistryHive->Storage[Storage].FreeDisplay[Index];
    while (*pFreeCellOffset != HCELL_NIL)
    {
        FreeCellData = (PHCELL_INDEX)HvGetCell(RegistryHive, *pFreeCellOffset);
        if (*pFreeCellOffset == CellIndex)
        {
            *pFreeCellOffset = *FreeCellData;
            return;
        }
        pFreeCellOffset = FreeCellData;
    }
 
    /* Something bad happened, print a useful trace info and bugcheck */
    CMLTRACE(CMLIB_HCELL_DEBUG, "-- beginning of HvpRemoveFree trace --\n");
    CMLTRACE(CMLIB_HCELL_DEBUG, "block we are about to free: %08x\n", CellIndex);
    CMLTRACE(CMLIB_HCELL_DEBUG, "chosen free list index: %u\n", Index);
    for (FreeListIndex = 0; FreeListIndex < 24; FreeListIndex++)
    {
        CMLTRACE(CMLIB_HCELL_DEBUG, "free list [%u]: ", FreeListIndex);
        pFreeCellOffset = &RegistryHive->Storage[Storage].FreeDisplay[FreeListIndex];
        while (*pFreeCellOffset != HCELL_NIL)
        {
            CMLTRACE(CMLIB_HCELL_DEBUG, "%08x ", *pFreeCellOffset);
            FreeCellData = (PHCELL_INDEX)HvGetCell(RegistryHive, *pFreeCellOffset);
            pFreeCellOffset = FreeCellData;
        }
        CMLTRACE(CMLIB_HCELL_DEBUG, "\n");
    }
    CMLTRACE(CMLIB_HCELL_DEBUG, "-- end of HvpRemoveFree trace --\n");
 
    ASSERT(FALSE);
}

Referenced by HvFreeCell().

HvReallocateCell()

HCELL_INDEX CMAPI HvReallocateCell	(	PHHIVE	RegistryHive,
		HCELL_INDEX	CellIndex,
		ULONG	Size
	)

Definition at line 421 of file hivecell.c.

{
    PVOID OldCell;
    PVOID NewCell;
    LONG OldCellSize;
    HCELL_INDEX NewCellIndex;
    HSTORAGE_TYPE Storage;
 
    ASSERT(CellIndex != HCELL_NIL);
 
    CMLTRACE(CMLIB_HCELL_DEBUG, "%s - Hive %p, CellIndex %08lx, Size %x\n",
             __FUNCTION__, RegistryHive, CellIndex, Size);
 
    Storage = HvGetCellType(CellIndex);
 
    OldCell = HvGetCell(RegistryHive, CellIndex);
    OldCellSize = HvGetCellSize(RegistryHive, OldCell);
    ASSERT(OldCellSize > 0);
 
    /*
     * If new data size is larger than the current, destroy current
     * data block and allocate a new one.
     *
     * FIXME: Merge with adjacent free cell if possible.
     * FIXME: Implement shrinking.
     */
    if (Size > (ULONG)OldCellSize)
    {
        NewCellIndex = HvAllocateCell(RegistryHive, Size, Storage, HCELL_NIL);
        if (NewCellIndex == HCELL_NIL)
            return HCELL_NIL;
 
        NewCell = HvGetCell(RegistryHive, NewCellIndex);
        RtlCopyMemory(NewCell, OldCell, (SIZE_T)OldCellSize);
 
        HvFreeCell(RegistryHive, CellIndex);
 
        return NewCellIndex;
    }
 
    return CellIndex;
}

Referenced by CmpAddToLeaf(), CmpAddValueToList(), CmpRemoveValueFromList(), CmpSetValueKeyExisting(), and CmpSplitLeaf().

HvReleaseFreeCellRefArray()

VOID CMAPI HvReleaseFreeCellRefArray

(

IN OUT PHV_TRACK_CELL_REF

CellRef

)

Definition at line 634 of file hivecell.c.

{
    ULONG i;
 
    PAGED_CODE();
 
    ASSERT(CellRef);
 
    /* Any references in the static array? */
    if (CellRef->StaticCount > 0)
    {
        /* Sanity check */
        ASSERT(CellRef->StaticCount <= STATIC_CELL_PAIR_COUNT);
 
        /* Loop over them and release them */
        for (i = 0; i < CellRef->StaticCount; i++)
        {
            HvReleaseCell(CellRef->StaticArray[i].Hive,
                          CellRef->StaticArray[i].Cell);
        }
 
        /* We can reuse the static array */
        CellRef->StaticCount = 0;
    }
 
    /* Any references in the dynamic array? */
    if (CellRef->Count > 0)
    {
        /* Sanity checks */
        ASSERT(CellRef->Count <= CellRef->Max);
        ASSERT(CellRef->CellArray);
 
        /* Loop over them and release them */
        for (i = 0; i < CellRef->Count; i++)
        {
            HvReleaseCell(CellRef->CellArray[i].Hive,
                          CellRef->CellArray[i].Cell);
        }
 
        /* We can reuse the dynamic array */
        CmpFree(CellRef->CellArray, 0); // TAG_CM
        CellRef->CellArray = NULL;
        CellRef->Count = CellRef->Max = 0;
    }
}

Referenced by CmEnumerateKey(), and CmQueryKey().

HvTrackCellRef()

BOOLEAN CMAPI HvTrackCellRef	(	IN OUT PHV_TRACK_CELL_REF	CellRef,
		IN PHHIVE	Hive,
		IN HCELL_INDEX	Cell
	)

Definition at line 554 of file hivecell.c.

{
    PHV_HIVE_CELL_PAIR NewCellArray;
 
    PAGED_CODE();
 
    /* Sanity checks */
    ASSERT(CellRef);
    ASSERT(Hive);
    ASSERT(Cell != HCELL_NIL);
 
    /* NOTE: The hive cell is already referenced! */
 
    /* Less than 4? Use the static array */
    if (CellRef->StaticCount < STATIC_CELL_PAIR_COUNT)
    {
        /* Add the reference */
        CellRef->StaticArray[CellRef->StaticCount].Hive = Hive;
        CellRef->StaticArray[CellRef->StaticCount].Cell = Cell;
        CellRef->StaticCount++;
        return TRUE;
    }
 
    DPRINT("HvTrackCellRef: Static array full, use dynamic array.\n");
 
    /* Sanity checks */
    if (CellRef->Max == 0)
    {
        /* The dynamic array must not have been allocated already */
        ASSERT(CellRef->CellArray == NULL);
        ASSERT(CellRef->Count == 0);
    }
    else
    {
        /* The dynamic array must be allocated */
        ASSERT(CellRef->CellArray);
    }
    ASSERT(CellRef->Count <= CellRef->Max);
 
    if (CellRef->Count == CellRef->Max)
    {
        /* Allocate a new reference table */
        NewCellArray = CmpAllocate((CellRef->Max + CELL_REF_INCREMENT) * sizeof(HV_HIVE_CELL_PAIR),
                                   TRUE,
                                   TAG_CM);
        if (!NewCellArray)
        {
            DPRINT1("HvTrackCellRef: Cannot reallocate the reference table.\n");
            /* We failed, dereference the hive cell */
            HvReleaseCell(Hive, Cell);
            return FALSE;
        }
 
        /* Free the old reference table and use the new one */
        if (CellRef->CellArray)
        {
            /* Copy the handles from the old table to the new one */
            RtlCopyMemory(NewCellArray,
                          CellRef->CellArray,
                          CellRef->Max * sizeof(HV_HIVE_CELL_PAIR));
            CmpFree(CellRef->CellArray, 0); // TAG_CM
        }
        CellRef->CellArray = NewCellArray;
        CellRef->Max += CELL_REF_INCREMENT;
    }
 
    // ASSERT(CellRef->Count < CellRef->Max);
 
    /* Add the reference */
    CellRef->CellArray[CellRef->Count].Hive = Hive;
    CellRef->CellArray[CellRef->Count].Cell = Cell;
    CellRef->Count++;
    return TRUE;
}

Referenced by CmEnumerateKey(), and CmQueryKey().