ReactOS-Freeldr注册表HIVE文件格式

来源：互联网发布：中国资本主义知乎编辑：程序博客网时间：2024/06/06 09:10

ReactOS的注册表信息存储在ReactOS/System32/CONFIG/SYSTEM文件中。注册表文件使用的一种特殊的格式——HIVE。

HIVE文件主要由BASE_BLOCK/BIN/CELL三部分组成的。BASE_BLOCK是文件头，大小为4KB，里面存储了整个文件的一些全局信息。BIN是以4KB对其的一段空间，里面管理了若干个CELL。CELL是一段用户自定义大小的空间，注册表的键值信息就是存储在一个个CELL里面。

整个HIVE文件就是一个BASE_BLOCK头和若干BIN，每个BIN中有若干CELL。当用户需要分配一个CELL，而HIVE文件中没有足够大的CELL时，需要在文件末尾增长一个BIN，再从这个BIN里面分别需要的CELL。

我们来看看整个HIVE文件在内存中的结构

typedef struct _HHIVE
{
ULONG Signature; // HV_SIGNATURE(0x66676572) 标志位
PGET_CELL_ROUTINE GetCellRoutine; // 根据index获得cell的函数指针
PRELEASE_CELL_ROUTINE ReleaseCellRoutine; // 释放cell指针
PALLOCATE_ROUTINE Allocate; // 申请内存的指针
PFREE_ROUTINE Free; // 释放内存的指针
PFILE_READ_ROUTINE FileRead; // 读HIVE文件指针
PFILE_WRITE_ROUTINE FileWrite; // 写HIVE文件
PFILE_SET_SIZE_ROUTINE FileSetSize; // 获得HIVE文件大小
PFILE_FLUSH_ROUTINE FileFlush; // 刷新HIVE
PHBASE_BLOCK BaseBlock; // BASE_BLOCK的内存指针
RTL_BITMAP DirtyVector; // 标志哪个块(4kb)被修改过的位图
ULONG DirtyCount; // 被修改块的数量?
ULONG DirtyAlloc; // ?
ULONG BaseBlockAlloc; // ?
ULONG Cluster; // BaseBlock占用的Cluster数量, 总为1
BOOLEAN Flat; // 初始化HIVE时是否使用了HINIT_FLAT标志
BOOLEAN ReadOnly; // 是否只读
BOOLEAN Log; // ?
BOOLEAN DirtyFlag; // ?
ULONG HvBinHeadersUse;
ULONG HvFreeCellsUse;
ULONG HvUsedcellsUse;
ULONG CmUsedCellsUse;
ULONG HiveFlags; // Hive标志
ULONG LogSize;
ULONG RefreshCount;
ULONG StorageTypeCount; // Storage数组的大小(2)
ULONG Version;
DUAL Storage[HTYPE_COUNT]; // 管理Block的数组, Stable和Volatile各一个元素
} HHIVE, *PHHIVE;

在freeldr中整个HIVE文件使用HHIVE数据结构来表示。这里面有一组函数指针，当HIVE需要分配内存、写文件等操作时会调用相应的指针。这些指针在HIVE的初始化函数中被赋值。GetCellRoutine可以根据CELL索引获取CELL指针，ReleaseCellRoutine会释放CELL指针。这两个指针在freeldr中没有使用。

初始化后BaseBlock指针将指向HIVE的文件头BASE_BLOCK结构。

DirtyVector是一个位图，标志着HIVE文件中的哪个块(4KB)被修改过了。

Cluster是BaseBlock占用的簇的数量，在reactos系统中这个值永远为1.

Flat代表初始化时是否使用了HINIT_FLAT标志，使用这个标志说明HHIVE所指向的内存都是初始化时分配好的，所以不需要它释放内存。ReadOnly代表注册表只读。

最后一个比较重要的域是StorageTypeCount和Storage数组。

HIVE中的数据分为两大类，易失的(Volatile)和非易失去的(Stable)，StorageTypeCount为2。Stable数据最后会被刷新到硬盘文件中，而Volatile数据关机之后就丢失了。HHIVE中Storage数组有两个元素，分别管理这两种数据的全部数据块，这里面存储了数据块位置，是否空闲等信息。之后我们会看到用户通过CELL索引获取CELL地址，这个转换就使用到了这个数组里面的信息。

下面我们看一个HIVE的初始化函数HvpInitializeMemoryHive

函数有两个参数：

Hive是HHIVE结构的指针

ChunkBase是从硬盘中读取的HIVE文件内容。

lib/cmlib/hiveinit.c

NTSTATUS CMAPI HvpInitializeMemoryHive(PHHIVE Hive, PVOID ChunkBase)
{
SIZE_T BlockIndex;
PHBIN Bin, NewBin;
ULONG i;
ULONG BitmapSize;
PULONG BitmapBuffer;
SIZE_T ChunkSize;
/* 得到HIVE文件大小, 并且将HBASE_BLOCK.Length改为块大小4kb */
ChunkSize = ((PHBASE_BLOCK)ChunkBase)->Length;
((PHBASE_BLOCK)ChunkBase)->Length = HV_BLOCK_SIZE;
/* 如果文件小于HBASE_BLOCK或者头部校验失败, 数据不合法 */
if (ChunkSize < sizeof(HBASE_BLOCK) ||
!HvpVerifyHiveHeader((PHBASE_BLOCK)ChunkBase))
{
return STATUS_REGISTRY_CORRUPT;
}
/* 生成Hive->BaseBlock中生成空间, 将ChunkBase的头部复制进去 */
Hive->BaseBlock = Hive->Allocate(sizeof(HBASE_BLOCK), FALSE, TAG_CM);
if (Hive->BaseBlock == NULL)
{
return STATUS_NO_MEMORY;
}
RtlCopyMemory(Hive->BaseBlock, ChunkBase, sizeof(HBASE_BLOCK));
/* 除文件头的每个BLOCK(4kb)准备一个HMAP_ENTRY结构, 存放在Hive.Storage[Stable]中 */
Hive->Storage[Stable].Length = (ULONG)(ChunkSize / HV_BLOCK_SIZE) - 1;
Hive->Storage[Stable].BlockList =
Hive->Allocate(Hive->Storage[Stable].Length *
sizeof(HMAP_ENTRY), FALSE, TAG_CM);
if (Hive->Storage[Stable].BlockList == NULL)
{
Hive->Free(Hive->BaseBlock, 0);
return STATUS_NO_MEMORY;
}
/* 每个BIN循环一次这个循环初始化HMAP_ENTRY数组 */
for (BlockIndex = 0; BlockIndex < Hive->Storage[Stable].Length; )
{
/* 获得BIN结构 */
Bin = (PHBIN)((ULONG_PTR)ChunkBase + (BlockIndex + 1) * HV_BLOCK_SIZE);
if (Bin->Signature != HV_BIN_SIGNATURE ||
(Bin->Size % HV_BLOCK_SIZE) != 0)
{
Hive->Free(Hive->BaseBlock, 0);
Hive->Free(Hive->Storage[Stable].BlockList, 0);
return STATUS_REGISTRY_CORRUPT;
}
/* 赋值一份BIN到本地 */
NewBin = Hive->Allocate(Bin->Size, TRUE, TAG_CM);
if (NewBin == NULL)
{
Hive->Free(Hive->BaseBlock, 0);
Hive->Free(Hive->Storage[Stable].BlockList, 0);
return STATUS_NO_MEMORY;
}
Hive->Storage[Stable].BlockList[BlockIndex].BinAddress = (ULONG_PTR)NewBin;
Hive->Storage[Stable].BlockList[BlockIndex].BlockAddress = (ULONG_PTR)NewBin;
RtlCopyMemory(NewBin, Bin, Bin->Size);
/* 每个BIN管理若干block */
if (Bin->Size > HV_BLOCK_SIZE)
{
for (i = 1; i < Bin->Size / HV_BLOCK_SIZE; i++)
{
Hive->Storage[Stable].BlockList[BlockIndex + i].BinAddress = (ULONG_PTR)NewBin;
Hive->Storage[Stable].BlockList[BlockIndex + i].BlockAddress =
((ULONG_PTR)NewBin + (i * HV_BLOCK_SIZE));
}
}
/* 下一个BIN */
BlockIndex += Bin->Size / HV_BLOCK_SIZE;
}
/* 初始化空闲CELL表 */
if (HvpCreateHiveFreeCellList(Hive))
{
HvpFreeHiveBins(Hive);
Hive->Free(Hive->BaseBlock, 0);
return STATUS_NO_MEMORY;
}
/* 初始化Hive->DirtyVector位图 */
BitmapSize = ROUND_UP(Hive->Storage[Stable].Length,
sizeof(ULONG) * 8) / 8;
BitmapBuffer = (PULONG)Hive->Allocate(BitmapSize, TRUE, TAG_CM);
if (BitmapBuffer == NULL)
{
HvpFreeHiveBins(Hive);
Hive->Free(Hive->BaseBlock, 0);
return STATUS_NO_MEMORY;
}
RtlInitializeBitMap(&Hive->DirtyVector, BitmapBuffer, BitmapSize * 8);
RtlClearAllBits(&Hive->DirtyVector);
return STATUS_SUCCESS;
}

HvpInitializeMemoryHive先生成HBASE_BLOCK所需空间赋值给HHIVE中的BaseBlock指针，并拷贝ChunkBase的头部到这段区域(9-24行)。

这里有个地方需要注意，在这里传入的HBASE_BLOCK.Length存储的是整个文件大小(HvLoadHive函数为它赋值)，而在HHIVE中的HBASE_BLOCK.Length应该是一个BLOCK的大小4kb，10-17行做了转换。reactos中称这是一个hack，可见这种做法并不标准。

之后26-34行需要为每一个BLOCK（4kb）提供一个HMAP_ENTRY结构，存储在Hive.Storage[Stable]中。

Hive.Storage是Dual结构数组，Stable和Volatile各占用一个元素。

typedef struct _DUAL
{
ULONG Length;
PHMAP_DIRECTORY Map;
PHMAP_ENTRY BlockList; // PHMAP_TABLE SmallDir;
ULONG Guard;
HCELL_INDEX FreeDisplay[24]; //FREE_DISPLAY FreeDisplay[24];
ULONG FreeSummary;
LIST_ENTRY FreeBins;
} DUAL, *PDUAL;

freeldr中主要用到了Length、BlockList和FreeDIsplay三个元素。FreeDisplay用作快速查找空闲CELL，这个一会儿再说。Length代表这个DUAL维护了多少个Block。每个Block会有一个对应的HMAP_ENTRY结构。BlockList指向HMAP_ENTRY数组的地址。

HMAP_ENTRY结构为

typedef struct _HMAP_ENTRY
{
ULONG_PTR BlockAddress;
ULONG_PTR BinAddress;
struct _CM_VIEW_OF_FILE *CmView;
ULONG MemAlloc;
} HMAP_ENTRY, *PHMAP_ENTRY;

BlockAddress就是一个Block的开始地址, BinAddress是这个Block所在的Bin结构的开始地址，一个Block的大小是4kb，所以这里不需要类似Length的数据。

我们回到HvpInitializeMemoryHive的26-67行。这里初始化了Storage[Stable]对应的DUAL结构。

26、27行首先计算出除HBASE_BLOCK外，还有多少个Block，Dual.Length记录了Block的数量，之后为每一个Block生成HMAP_ENTRY，数组的首地址赋值给BlockList指针。

36行开始一个循环，初始化刚刚生成的HMAP_ENTRY数组。

在HIVE文件中一个BIN占用若干，紧接着HBASE_BLOCK后应是一个个的HBIN结构，这是BIN的头部。

typedef struct _HBIN
{
ULONG Signature;
HCELL_INDEX FileOffset; // BIN在文件中的偏移
ULONG Size; // BIN的大小, 是4kb的整倍数
ULONG Reserved1[2];
LARGE_INTEGER TimeStamp;
ULONG Spare;
} HBIN, *PHBIN;

FileOffset说明了该BIN在HIVE文件中的偏移，Size是该BIN的大小，这个大小肯定是4kb的整倍数。

39-46行首先检测了HBIN的Signature和Size，确定这时一个合法的BIN结构。

之后生成空间并复制BIN的全部内容(48-57)。

由于BIN可能会占用几个BLOCK，所以之后有一个循环（59-67）初始化这个BIN占用的所有BlOCK的HMAP_ENTRY结构，BlockAddress是该Block的起始地址，BinAddress是该BIN的起始地址。70行获得下一个BIN的地址，再次开始循环。

可以看出BIN占用的内存空间是同时生成的，所以BIN中所有BLOCK的内存也是连续的。

循环完毕后HMAP_ENTRY被初始化完成，函数调用HvpCreateHiveFreeCellList初始化DUAL.FreeDisplay看先CELL链表，这个我们稍后看。

最后82-90初始化HIVE.DirtyVector，如果之后某一个块被更改了，位图中的相应位会被置位，注意每一个位都是按照Block（4kb）为单位进行管理的。初始化时这个位图全为0，说明没有任何更改。

现在来说说刚刚略过的HvpCreateHiveFreeCellList函数。

BIN是一大块连续的内存（4kb的整倍数），这段内存又被分为了一个个叫做CELL的结构。

一个CELL就是一个CELL头HCELL和紧接着的一段内存。

typedef struct _HCELL
{
/* <0 if used, >0 if free */
LONG Size;
} HCELL, *PHCELL;

HCELL只有一个元素Size，代表这个CELL的大小（包括HCELL本身和紧接着的内存）。不过这个Size有点特殊，当Size小于0时说明这个CELL已经被使用，它的绝对值是真正的大小。当Size大于0说明这个CELL空闲，Size本身就是大小。

所有空闲的CELL都被放到了Dual.FreeDisplay中，HvpCreateHiveFreeCellList就是这个初始化过程。

HvpCreateHiveFreeCellList以Hive指针作为参数，这时HIVE.Storage.BlockList已经初始化好了。

lib/cmlib/Hivecell.c

NTSTATUS CMAPI HvpCreateHiveFreeCellList(PHHIVE Hive)
{ ......
/* 初始化Storage中的FreeDisplay为空 */
for (Index = 0; Index < 24; Index++)
{
Hive->Storage[Stable].FreeDisplay[Index] = HCELL_NIL;
Hive->Storage[Volatile].FreeDisplay[Index] = HCELL_NIL;
}
BlockOffset = 0;
BlockIndex = 0;
/* 按Block开始循环 */
while (BlockIndex < Hive->Storage[Stable].Length)
{ /* 获得BIN结构 */
Bin = (PHBIN)Hive->Storage[Stable].BlockList[BlockIndex].BinAddress;
/* 一个BIN里面每个CELL循环一次 */
FreeOffset = sizeof(HBIN);
while (FreeOffset < Bin->Size)
{ /* 获得HCELL指针 */
FreeBlock = (PHCELL)((ULONG_PTR)Bin + FreeOffset);
/* Size > 0 说明空闲, 调用HvpAddFree把这个CELL加入空闲列表 */
if (FreeBlock->Size > 0)
{
Status = HvpAddFree(Hive, FreeBlock, Bin->FileOffset + FreeOffset);
if (!NT_SUCCESS(Status))
return Status;
/* 下一个HCELL的地址 */
FreeOffset += FreeBlock->Size;
}
else
{ /* 下一个HCELL的地址 */
FreeOffset -= FreeBlock->Size;
}
}
/* 下一个BIN */
BlockIndex += Bin->Size / HV_BLOCK_SIZE;
BlockOffset += Bin->Size;
}
return STATUS_SUCCESS;
}

首先初始化Storage.FreeDisplay,全部赋值为空（4-8行）。

12行开始遍历Storage[Stable].BlockList列表。

获得BIN结构后遍历里面一个个CELL，如果CELL.Size > 0 说明空闲，调用HvpAddFree加入空闲列表(14-33)。

完成后继续遍历下一个BIN(35-36)。

函数的关键在HvpAddFree中，这个函数有三个参数

Hive为HHIVE指针，

FreeBlock为空闲HCELL的指针，

FreeIndex是HCELL在文件中的偏移，这个参数之所以叫做FreeIndex是因为它也被用户当作这个CELL的索引（或句柄？）使用。

lib/cmlib/hivelcell.c

static NTSTATUS CMAPI HvpAddFree(PHHIVE RegistryHive, PHCELL FreeBlock, HCELL_INDEX FreeIndex)
{
PHCELL_INDEX FreeBlockData;
HSTORAGE_TYPE Storage;
ULONG Index;
/* index的最高位代表Storage类型, 1为Volatile, 0为Stable */
Storage = (FreeIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT;
/* 计算出应该插入的FreeDisplay表项 */
Index = HvpComputeFreeListIndex((ULONG)FreeBlock->Size);
/* 插入以FreeDisplay[index]为表头的链表 */
FreeBlockData = (PHCELL_INDEX)(FreeBlock + 1);
*FreeBlockData = RegistryHive->Storage[Storage].FreeDisplay[Index];
RegistryHive->Storage[Storage].FreeDisplay[Index] = FreeIndex;
/* FIXME: Eventually get rid of free bins. */
/* 这里应该去除所有CELL都是free的BIN */
return STATUS_SUCCESS;
}

第三个参数还有一个特殊含义, 最高位表示freecell的类型，因为HvpCreateHiveFreeCellList调用这个函数时是Stable类型的cell，所以最高位为0, 索引正好等于CELL在文件中开始的位置。

函数之后调用HvpComputeFreeListIndex根据大小计算出需要插入的FreeDisplay表头，这是是一个哈希函数，根据大小不同可以返回不同的Index值，但是唯一的Size每次返回的Index都相同，而且Index是随着Size递增的。这里就不仔细看了。这个函数把不同大小的空闲CELL按策略分配在24个FreeDisplay链表中。

之后把空闲的CELL插入到Storage[Storage].FreeDisplay[Index]中，这是一个单项链表, 连表中的空闲CELL需要存储下一个空闲CELL的Index, 最后一个空闲CELL将存储HCELL_NIL为结束标志。

至此初始化完毕，初始化有几大部分

1. HHIVE结构

2. HBASE_BLOCK

3. HMAP_ENTRY数组

4. 空闲CELL列表FreeDisplay

下一节我们就将看到如何分配CELL，如何通过INDEX找到CELL，HIVE文件如何增长等等。