加入收藏 | 设为首页 | 会员中心 | 我要投稿 李大同 （https://www.lidatong.com.cn/）- 科技、建站、经验、云计算、5G、大数据,站长网!
当前位置： 首页 > 百科 > 正文

ReactOS-Freeldr注册表HIVE文件格式

发布时间：2020-12-15 03:32:36 所属栏目：百科 来源：网络整理
导读：ReactOS的注册表信息存储在ReactOS/System32/CONFIG/SYSTEM文件中。注册表文件使用的一种特殊的格式——HIVE。 HIVE文件主要由BASE_BLOCK/BIN/CELL三部分组成的。BASE_BLOCK是文件头，大小为4KB，里面存储了整个文件的一些全局信息。BIN是以4KB对其的一段空
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. typedefstruct _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; ULONG Cluster; // BaseBlock占用的Cluster数量,总为1
  17. BOOLEAN Flat; // 初始化HIVE时是否使用了HINIT_FLAT标志
  18. BOOLEAN ReadOnly; // 是否只读
  19. BOOLEAN Log; BOOLEAN DirtyFlag; ULONG HvBinHeadersUse;
  20. ULONG HvFreeCellsUse;
  21. ULONG HvUsedcellsUse;
  22. ULONG CmUsedCellsUse;
  23. ULONG HiveFlags; // Hive标志
  24. ULONG LogSize;
  25. ULONG RefreshCount;
  26. ULONG StorageTypeCount; // Storage数组的大小(2)
  27. ULONG Version;
  28. DUAL Storage[HTYPE_COUNT]; // 管理Block的数组,Stable和Volatile各一个元素
  29. } 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),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. return STATUS_NO_MEMORY;
  53. }
  54. Hive->Storage[Stable].BlockList[BlockIndex].BinAddress =(ULONG_PTR)NewBin;
  55. Hive->Storage[Stable].BlockList[BlockIndex].BlockAddress =(ULONG_PTR)NewBin;
  56. RtlCopyMemory(NewBin,Bin,Bin->Size);
  57. /* 每个BIN管理若干block */
  58. if(Bin->Size > HV_BLOCK_SIZE)
  59. {
  60. for(i =1; i < Bin->Size / HV_BLOCK_SIZE; i++)
  61. {
  62. Hive->Storage[Stable].BlockList[BlockIndex + i].BinAddress =(ULONG_PTR)NewBin;
  63. Hive->Storage[Stable].BlockList[BlockIndex + i].BlockAddress =
  64. ((ULONG_PTR)NewBin +(i * HV_BLOCK_SIZE));
  65. }
  66. }
  68. /* 下一个BIN */
  69. BlockIndex += Bin->Size / HV_BLOCK_SIZE;
  70. }
  71. /* 初始化空闲CELL表 */
  72. if(HvpCreateHiveFreeCellList(Hive))
  73. {
  74. HvpFreeHiveBins(Hive);
  75. Hive->Free(Hive->BaseBlock,0); font-style:normal!important; text-decoration:none!important"> /* 初始化Hive->DirtyVector位图 */
  76. BitmapSize = ROUND_UP(Hive->Storage[Stable].Length,
  77. sizeof(ULONG)*8)/8;
  78. BitmapBuffer =(PULONG)Hive->Allocate(BitmapSize,TAG_CM);
  79. if(BitmapBuffer ==NULL)
  80. {
  81. HvpFreeHiveBins(Hive);
  82. Hive->Free(Hive->BaseBlock,0);
  83. return STATUS_NO_MEMORY;
  84. }
  85. RtlInitializeBitMap(&Hive->DirtyVector,BitmapBuffer,BitmapSize *8);
  86. RtlClearAllBits(&Hive->DirtyVector);
  87. return STATUS_SUCCESS;
  88. }
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. typedefstruct _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. typedefstruct _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. typedefstruct _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. typedefstruct _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. staticNTSTATUS 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文件如何增长等等。

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!
    相关内容
      推荐文章
        站长推荐
        热点阅读

          【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱bqsm@foxmail.com我们将及时予以处理。

          建议您使用1920×1080分辨率、谷歌浏览器Google Chrome、Microsoft Edge以获得本站的最佳浏览效果

          Copygight © 2008-2022 https://www.lidatong.com.cn/ All Rights Reserved. 李大同