ReactOS-Freeldr注册表HIVE文件格式

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文件在内存中的结构
  1. typedef struct _HHIVE
  2. {
  3.     ULONG Signature;                            // HV_SIGNATURE(0x66676572) 标志位
  4.     PGET_CELL_ROUTINE GetCellRoutine;           // 根据index获得cell的函数指针
  5.     PRELEASE_CELL_ROUTINE ReleaseCellRoutine;   // 释放cell指针
  6.     PALLOCATE_ROUTINE Allocate;                 // 申请内存的指针
  7.     PFREE_ROUTINE Free;                         // 释放内存的指针
  8.     PFILE_READ_ROUTINE FileRead;                // 读HIVE文件指针
  9.     PFILE_WRITE_ROUTINE FileWrite;              // 写HIVE文件
  10.     PFILE_SET_SIZE_ROUTINE FileSetSize;         // 获得HIVE文件大小
  11.     PFILE_FLUSH_ROUTINE FileFlush;              // 刷新HIVE
  12.     PHBASE_BLOCK BaseBlock;                     // BASE_BLOCK的内存指针
  13.     RTL_BITMAP DirtyVector;                     // 标志哪个块(4kb)被修改过的位图
  14.     ULONG DirtyCount;                           // 被修改块的数量?
  15.     ULONG DirtyAlloc;                           // ?
  16.     ULONG BaseBlockAlloc;                       // ?
  17.     ULONG Cluster;                              // BaseBlock占用的Cluster数量, 总为1
  18.     BOOLEAN Flat;                               // 初始化HIVE时是否使用了HINIT_FLAT标志
  19.     BOOLEAN ReadOnly;                           // 是否只读
  20.     BOOLEAN Log;                                // ?
  21.     BOOLEAN DirtyFlag;                          // ?
  22.     ULONG HvBinHeadersUse;
  23.     ULONG HvFreeCellsUse;
  24.     ULONG HvUsedcellsUse;
  25.     ULONG CmUsedCellsUse;
  26.     ULONG HiveFlags;                            // Hive标志
  27.     ULONG LogSize;
  28.     ULONG RefreshCount;
  29.     ULONG StorageTypeCount;                     // Storage数组的大小(2)
  30.     ULONG Version;
  31.     DUAL Storage[HTYPE_COUNT];                  // 管理Block的数组, Stable和Volatile各一个元素
  32. } 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
  1. NTSTATUS CMAPI HvpInitializeMemoryHive(PHHIVE Hive, PVOID ChunkBase)
  2. {
  3.    SIZE_T BlockIndex;
  4.    PHBIN Bin, NewBin;
  5.    ULONG i;
  6.    ULONG BitmapSize;
  7.    PULONG BitmapBuffer;
  8.    SIZE_T ChunkSize;
  9.    /* 得到HIVE文件大小, 并且将HBASE_BLOCK.Length改为块大小4kb */
  10.    ChunkSize = ((PHBASE_BLOCK)ChunkBase)->Length;
  11.    ((PHBASE_BLOCK)ChunkBase)->Length = HV_BLOCK_SIZE;
  12.    /* 如果文件小于HBASE_BLOCK或者头部校验失败, 数据不合法 */
  13.    if (ChunkSize < sizeof(HBASE_BLOCK) ||
  14.        !HvpVerifyHiveHeader((PHBASE_BLOCK)ChunkBase))
  15.    {
  16.       return STATUS_REGISTRY_CORRUPT;
  17.    }
  18.    /* 生成Hive->BaseBlock中生成空间, 将ChunkBase的头部复制进去 */
  19.    Hive->BaseBlock = Hive->Allocate(sizeof(HBASE_BLOCK), FALSE, TAG_CM);
  20.    if (Hive->BaseBlock == NULL)
  21.    {
  22.       return STATUS_NO_MEMORY;
  23.    }
  24.    RtlCopyMemory(Hive->BaseBlock, ChunkBase, sizeof(HBASE_BLOCK));
  25.    /* 除文件头的每个BLOCK(4kb)准备一个HMAP_ENTRY结构, 存放在Hive.Storage[Stable]中 */
  26.    Hive->Storage[Stable].Length = (ULONG)(ChunkSize / HV_BLOCK_SIZE) - 1;
  27.    Hive->Storage[Stable].BlockList =
  28.       Hive->Allocate(Hive->Storage[Stable].Length *
  29.                      sizeof(HMAP_ENTRY), FALSE, TAG_CM);
  30.    if (Hive->Storage[Stable].BlockList == NULL)
  31.    {
  32.       Hive->Free(Hive->BaseBlock, 0);
  33.       return STATUS_NO_MEMORY;
  34.    }
  35.    /* 每个BIN循环一次 这个循环初始化HMAP_ENTRY数组 */
  36.    for (BlockIndex = 0; BlockIndex < Hive->Storage[Stable].Length; )
  37.    {
  38.       /* 获得BIN结构 */
  39.       Bin = (PHBIN)((ULONG_PTR)ChunkBase + (BlockIndex + 1) * HV_BLOCK_SIZE);
  40.       if (Bin->Signature != HV_BIN_SIGNATURE ||
  41.           (Bin->Size % HV_BLOCK_SIZE) != 0)
  42.       {
  43.          Hive->Free(Hive->BaseBlock, 0);
  44.          Hive->Free(Hive->Storage[Stable].BlockList, 0);
  45.          return STATUS_REGISTRY_CORRUPT;
  46.       }
  47.       /* 赋值一份BIN到本地 */
  48.       NewBin = Hive->Allocate(Bin->Size, TRUE, TAG_CM);
  49.       if (NewBin == NULL)
  50.       {
  51.          Hive->Free(Hive->BaseBlock, 0);
  52.          Hive->Free(Hive->Storage[Stable].BlockList, 0);
  53.          return STATUS_NO_MEMORY;
  54.       }
  55.       Hive->Storage[Stable].BlockList[BlockIndex].BinAddress = (ULONG_PTR)NewBin;
  56.       Hive->Storage[Stable].BlockList[BlockIndex].BlockAddress = (ULONG_PTR)NewBin;
  57.       RtlCopyMemory(NewBin, Bin, Bin->Size);
  58.       /* 每个BIN管理若干block */
  59.       if (Bin->Size > HV_BLOCK_SIZE)
  60.       {
  61.          for (i = 1; i < Bin->Size / HV_BLOCK_SIZE; i++)
  62.          {
  63.             Hive->Storage[Stable].BlockList[BlockIndex + i].BinAddress = (ULONG_PTR)NewBin;
  64.             Hive->Storage[Stable].BlockList[BlockIndex + i].BlockAddress =
  65.                ((ULONG_PTR)NewBin + (i * HV_BLOCK_SIZE));
  66.          }
  67.       }
  68.      
  69.       /* 下一个BIN */
  70.       BlockIndex += Bin->Size / HV_BLOCK_SIZE;
  71.    }
  72.    /* 初始化空闲CELL表 */
  73.    if (HvpCreateHiveFreeCellList(Hive))
  74.    {
  75.       HvpFreeHiveBins(Hive);
  76.       Hive->Free(Hive->BaseBlock, 0);
  77.       return STATUS_NO_MEMORY;
  78.    }
  79.    /* 初始化Hive->DirtyVector位图 */
  80.    BitmapSize = ROUND_UP(Hive->Storage[Stable].Length,
  81.                          sizeof(ULONG) * 8) / 8;
  82.    BitmapBuffer = (PULONG)Hive->Allocate(BitmapSize, TRUE, TAG_CM);
  83.    if (BitmapBuffer == NULL)
  84.    {
  85.       HvpFreeHiveBins(Hive);
  86.       Hive->Free(Hive->BaseBlock, 0);
  87.       return STATUS_NO_MEMORY;
  88.    }
  89.    RtlInitializeBitMap(&Hive->DirtyVector, BitmapBuffer, BitmapSize * 8);
  90.    RtlClearAllBits(&Hive->DirtyVector);
  91.    return STATUS_SUCCESS;
  92. }
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各占用一个元素。
  1. typedef struct _DUAL
  2. {
  3.     ULONG Length;
  4.     PHMAP_DIRECTORY Map;
  5.     PHMAP_ENTRY BlockList; // PHMAP_TABLE SmallDir;
  6.     ULONG Guard;
  7.     HCELL_INDEX FreeDisplay[24]; //FREE_DISPLAY FreeDisplay[24];
  8.     ULONG FreeSummary;
  9.     LIST_ENTRY FreeBins;
  10. } DUAL, *PDUAL;
freeldr中主要用到了Length、BlockList和FreeDIsplay三个元素。FreeDisplay用作快速查找空闲CELL,这个一会儿再说。Length代表这个DUAL维护了多少个Block。每个Block会有一个对应的HMAP_ENTRY结构。BlockList指向HMAP_ENTRY数组的地址。
HMAP_ENTRY结构为
  1. typedef struct _HMAP_ENTRY
  2. {
  3.     ULONG_PTR BlockAddress;
  4.     ULONG_PTR BinAddress;
  5.     struct _CM_VIEW_OF_FILE *CmView;
  6.     ULONG MemAlloc;
  7. } 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的头部。
  1. typedef struct _HBIN
  2. {
  3.    ULONG Signature;
  4.    HCELL_INDEX FileOffset;   // BIN在文件中的偏移
  5.    ULONG Size;               // BIN的大小, 是4kb的整倍数
  6.    ULONG Reserved1[2];
  7.    LARGE_INTEGER TimeStamp;
  8.    ULONG Spare;
  9. } 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和紧接着的一段内存。
  1. typedef struct _HCELL
  2. {
  3.    /* <0 if used, >0 if free */
  4.    LONG Size;
  5. } 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
  1. NTSTATUS CMAPI HvpCreateHiveFreeCellList(PHHIVE Hive)
  2. {   ......
  3.    /* 初始化Storage中的FreeDisplay为空 */
  4.    for (Index = 0; Index < 24; Index++)
  5.    {
  6.       Hive->Storage[Stable].FreeDisplay[Index] = HCELL_NIL;
  7.       Hive->Storage[Volatile].FreeDisplay[Index] = HCELL_NIL;
  8.    }
  9.    BlockOffset = 0;
  10.    BlockIndex = 0;
  11.    /* 按Block开始循环 */
  12.    while (BlockIndex < Hive->Storage[Stable].Length)
  13.    {  /* 获得BIN结构 */
  14.       Bin = (PHBIN)Hive->Storage[Stable].BlockList[BlockIndex].BinAddress;
  15.       /* 一个BIN里面每个CELL循环一次 */
  16.       FreeOffset = sizeof(HBIN);
  17.       while (FreeOffset < Bin->Size)
  18.       {  /* 获得HCELL指针 */
  19.          FreeBlock = (PHCELL)((ULONG_PTR)Bin + FreeOffset);
  20.          /* Size > 0 说明空闲, 调用HvpAddFree把这个CELL加入空闲列表 */
  21.          if (FreeBlock->Size > 0)
  22.          {
  23.             Status = HvpAddFree(Hive, FreeBlock, Bin->FileOffset + FreeOffset);
  24.             if (!NT_SUCCESS(Status))
  25.                return Status;
  26.             /* 下一个HCELL的地址 */
  27.             FreeOffset += FreeBlock->Size;
  28.          }
  29.          else
  30.          {  /* 下一个HCELL的地址 */
  31.             FreeOffset -= FreeBlock->Size;
  32.          }
  33.       }
  34.       /* 下一个BIN */
  35.       BlockIndex += Bin->Size / HV_BLOCK_SIZE;
  36.       BlockOffset += Bin->Size;
  37.    }
  38.    return STATUS_SUCCESS;
  39. }
首先初始化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
  1. static NTSTATUS CMAPI HvpAddFree(PHHIVE RegistryHive, PHCELL FreeBlock, HCELL_INDEX FreeIndex)
  2. {
  3.    PHCELL_INDEX FreeBlockData;
  4.    HSTORAGE_TYPE Storage;
  5.    ULONG Index;
  6.    /* index的最高位代表Storage类型, 1为Volatile, 0为Stable */
  7.    Storage = (FreeIndex & HCELL_TYPE_MASK) >> HCELL_TYPE_SHIFT;
  8.    /* 计算出应该插入的FreeDisplay表项 */
  9.    Index = HvpComputeFreeListIndex((ULONG)FreeBlock->Size);
  10.    /* 插入以FreeDisplay[index]为表头的链表 */
  11.    FreeBlockData = (PHCELL_INDEX)(FreeBlock + 1);
  12.    *FreeBlockData = RegistryHive->Storage[Storage].FreeDisplay[Index];
  13.    RegistryHive->Storage[Storage].FreeDisplay[Index] = FreeIndex;
  14.    /* FIXME: Eventually get rid of free bins. */
  15.    /* 这里应该去除所有CELL都是free的BIN */
  16.    return STATUS_SUCCESS;
  17. }
第三个参数还有一个特殊含义, 最高位表示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文件如何增长等等。

你可能感兴趣的:(ReactOS代码精读)