hive.h File Reference

#include "hivedata.h"

Go to the source code of this file.

Defines
#define	DHvCheckHive(a)
#define	DHvCheckBin(h, a)
#define	ROUND_UP(a, b)   ( ((ULONG)(a) + (ULONG)(b) - 1) & ~((ULONG)(b) - 1) )
#define	ASSERT_LISTENTRY(ListEntry)
#define	HINIT_CREATE   0
#define	HINIT_MEMORY   1
#define	HINIT_FILE   2
#define	HINIT_MEMORY_INPLACE   3
#define	HINIT_FLAT   4
#define	HIVE_VOLATILE   1
#define	HIVE_NOLAZYFLUSH   2
#define	HIVE_HAS_BEEN_REPLACED   4
#define	HvGetCell(Hive, Cell)   (((Hive)->GetCellRoutine)(Hive, Cell))
#define	HvpGetHCell(Hive, Cell)
Functions
PHBIN	HvpAddBin (PHHIVE Hive, ULONG NewSize, HSTORAGE_TYPE Type)
PHMAP_ENTRY	HvpGetCellMap (PHHIVE Hive, HCELL_INDEX Cell)
VOID	HvpFreeMap (PHHIVE Hive, PHMAP_DIRECTORY Dir, ULONG Start, ULONG End)
BOOLEAN	HvpAllocateMap (PHHIVE Hive, PHMAP_DIRECTORY Dir, ULONG Start, ULONG End)
BOOLEAN	HvpGrowLog1 (PHHIVE Hive, ULONG Count)
BOOLEAN	HvpGrowLog2 (PHHIVE Hive, ULONG Size)
ULONG	HvpHeaderCheckSum (PHBASE_BLOCK BaseBlock)
NTSTATUS	HvpBuildMap (PHHIVE Hive, PVOID Image, PHCELL_INDEX TailDisplay OPTIONAL)
NTSTATUS	HvpBuildMapAndCopy (PHHIVE Hive, PVOID Image, PHCELL_INDEX TailDisplay OPTIONAL)
NTSTATUS	HvpInitMap (PHHIVE Hive)
VOID	HvpCleanMap (PHHIVE Hive)
NTSTATUS	HvpEnlistBinInMap (PHHIVE Hive, ULONG Length, PHBIN Bin, ULONG Offset, PHCELL_INDEX TailDisplay OPTIONAL)
VOID	HvpFreeAllocatedBins (PHHIVE Hive)
BOOLEAN	HvpDoWriteHive (PHHIVE Hive, ULONG FileType)
_CELL_DATA *	HvpGetCellFlat (PHHIVE Hive, HCELL_INDEX Cell)
_CELL_DATA *	HvpGetCellPaged (PHHIVE Hive, HCELL_INDEX Cell)
VOID	HvpEnlistFreeCell (PHHIVE Hive, HCELL_INDEX Cell, ULONG Size, HSTORAGE_TYPE Type, BOOLEAN CoalesceForward, PHCELL_INDEX TailDisplay OPTIONAL)
BOOLEAN	HvpEnlistFreeCells (PHHIVE Hive, PHBIN Bin, ULONG BinOffset, PHCELL_INDEX TailDisplay OPTIONAL)
VOID	HvpDelistFreeCell (PHHIVE Hive, PHCELL Pcell, HSTORAGE_TYPE Type, PHCELL_INDEX TailDisplay OPTIONAL)
NTSTATUS	HvInitializeHive (PHHIVE Hive, ULONG OperationType, ULONG HiveFlags, ULONG FileTypes, PVOID HiveData OPTIONAL, PALLOCATE_ROUTINE AllocateRoutine, PFREE_ROUTINE FreeRoutine, PFILE_SET_SIZE_ROUTINE FileSetSizeRoutine, PFILE_WRITE_ROUTINE FileWriteRoutine, PFILE_READ_ROUTINE FileReadRoutine, PFILE_FLUSH_ROUTINE FileFlushRoutine, ULONG Cluster, PUNICODE_STRING FileName)
BOOLEAN	HvSyncHive (PHHIVE Hive)
NTSTATUS	HvWriteHive (PHHIVE Hive)
NTSTATUS	HvLoadHive (PHHIVE Hive, PHCELL_INDEX TailDisplay OPTIONAL)
VOID	HvRefreshHive (PHHIVE Hive)
NTSTATUS	HvReadInMemoryHive (PHHIVE Hive, PVOID *HiveImage)
ULONG	HvCheckHive (PHHIVE Hive, PULONG Storage OPTIONAL)
ULONG	HvCheckBin (PHHIVE Hive, PHBIN Bin, PULONG Storage)
BOOLEAN	HvMarkCellDirty (PHHIVE Hive, HCELL_INDEX Cell)
BOOLEAN	HvIsBinDirty (IN PHHIVE Hive, IN HCELL_INDEX Cell)
BOOLEAN	HvMarkDirty (PHHIVE Hive, HCELL_INDEX Start, ULONG Length)
BOOLEAN	HvMarkClean (PHHIVE Hive, HCELL_INDEX Start, ULONG Length)
LONG	HvGetCellSize (PHHIVE Hive, PVOID Address)
HCELL_INDEX	HvAllocateCell (PHHIVE Hive, ULONG NewSize, HSTORAGE_TYPE Type)
VOID	HvFreeCell (PHHIVE Hive, HCELL_INDEX Cell)
HCELL_INDEX	HvReallocateCell (PHHIVE Hive, HCELL_INDEX Cell, ULONG NewSize)
BOOLEAN	HvIsCellAllocated (PHHIVE Hive, HCELL_INDEX Cell)
VOID	HvFreeHive (PHHIVE Hive)
VOID	HvFreeHivePartial (PHHIVE Hive, HCELL_INDEX Start, HSTORAGE_TYPE Type)

---

Define Documentation

#define ASSERT_LISTENTRY (  ListEntry   )

Value: ASSERT((ListEntry)->Flink->Blink==ListEntry); \ ASSERT((ListEntry)->Blink->Flink==ListEntry); Definition at line 58 of file hive.h. Referenced by HvpAddBin(), and HvpDiscardBins().

#define DHvCheckBin (  h, a   )

Definition at line 46 of file hive.h. Referenced by HvFreeCell().

#define DHvCheckHive (  a   )

Definition at line 45 of file hive.h.

#define HINIT_CREATE   0

Definition at line 197 of file hive.h. Referenced by CmInitSystem1(), CmpCreateTemporaryHive(), CmpInitHiveFromFile(), CmpInitializeSystemHive(), CmpLoadHiveVolatile(), EhOpenHive(), HvInitializeHive(), and MyCmpInitHiveFromFile().

#define HINIT_FILE   2

Definition at line 199 of file hive.h. Referenced by CmpInitHiveFromFile(), CmpInitializeHive(), CmpLoadHiveVolatile(), CmpValidateAlternate(), CmRestoreKey(), EhOpenHive(), HvInitializeHive(), and MyCmpInitHiveFromFile().

#define HINIT_FLAT   4

Definition at line 201 of file hive.h. Referenced by CmGetSystemControlValues(), and HvInitializeHive().

#define HINIT_MEMORY   1

Definition at line 198 of file hive.h. Referenced by CmpInitializeHive(), CmpInitializeSystemHive(), and HvInitializeHive().

#define HINIT_MEMORY_INPLACE   3

Definition at line 200 of file hive.h. Referenced by CmpInitializeHive(), and HvInitializeHive().

#define HIVE_HAS_BEEN_REPLACED   4

Definition at line 205 of file hive.h. Referenced by CmReplaceKey().

#define HIVE_NOLAZYFLUSH   2

Definition at line 204 of file hive.h. Referenced by CmLoadKey(), CmpDoFlushAll(), CmpRefreshHive(), CmSaveKey(), CmSaveMergedKeys(), HvMarkDirty(), and HvRefreshHive().

#define HIVE_VOLATILE   1

Definition at line 203 of file hive.h. Referenced by CmGetSystemControlValues(), CmInitSystem1(), CmpAddToHiveFileList(), CmpCreateTemporaryHive(), CmpInitializeHive(), CmpInitializeHiveList(), CmpLoadHiveVolatile(), HvInitializeHive(), HvIsBinDirty(), HvMarkCellDirty(), HvMarkClean(), HvMarkDirty(), HvpAddBin(), and HvSyncHive().

#define HvGetCell (  Hive, Cell   )     (((Hive)->GetCellRoutine)(Hive, Cell))

Definition at line 290 of file hive.h. Referenced by CmDeleteValueKey(), CmEnumerateKey(), CmGetSystemControlValues(), CmpAddDriverToList(), CmpAddInfoAfterParseFailure(), CmpAddSubKey(), CmpAddToLeaf(), CmpAssignSecurityDescriptor(), CmpCheckKey(), CmpCheckRegistry2(), CmpCheckValueList(), CmpCopyCell(), CmpCopyKeyPartial(), CmpCopySyncTree2(), CmpCopyValue(), CmpCreateLinkNode(), CmpCreateRegistryRoot(), CmpCreateRootNode(), CmpDeleteTree(), CmpDestroyHive(), CmpDoCompareKeyName(), CmpDoCreate(), CmpDoCreateChild(), CmpDoFindSubKeyByNumber(), CmpFindControlSet(), CmpFindDrivers(), CmpFindMatchingDescriptorCell(), CmpFindNameInList(), CmpFindNLSData(), CmpFindProfileOption(), CmpFindSubKeyByName(), CmpFindSubKeyByNumber(), CmpFindSubKeyInRoot(), CmpFindTagIndex(), CmpFreeKeyBody(), CmpFreeKeyByCell(), CmpFreeKeyValues(), CmpFreeSecurityDescriptor(), CmpFreeValue(), CmpGetHiveName(), CmpGetKeySecurity(), CmpGetObjectSecurity(), CmpGetSymbolicLink(), CmpGetValueDataFromCache(), CmpGetValueKeyFromCache(), CmpGetValueListFromCache(), CmpInsertSecurityCellList(), CmpIsLoadType(), CmpLoadHiveVolatile(), CmpMarkIndexDirty(), CmpMarkKeyDirty(), CmpMarkKeyParentDirty(), CmpMarkKeyValuesDirty(), CmpMergeKeyValues(), CmpParseKey(), CmpQueryKeyData(), CmpQuerySecurityDescriptorInfo(), CmpRefreshHive(), CmpRemoveSecurityCellList(), CmpRemoveSubKey(), CmpReportNotify(), CmpSelectLeaf(), CmpSetCurrentProfile(), CmpSetSecurityDescriptorInfo(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), CmpSortDriverList(), CmpSplitLeaf(), CmpSyncKeyValues(), CmpSyncSubKeysAfterDelete(), CmpValidateHiveSecurityDescriptors(), CmpWalkPath(), CmQueryMultipleValueKey(), CmRestoreKey(), CmSaveKey(), CmSaveMergedKeys(), CmSetValueKey(), EhCreateChild(), EhOpenHive(), EhpAttachSecurity(), and HvRefreshHive().

#define HvpGetHCell (  Hive, Cell   )

Value: ( USE_OLD_CELL(Hive) ? \ CONTAINING_RECORD(HvGetCell(Hive,Cell), \ HCELL, \ u.OldCell.u.UserData) : \ CONTAINING_RECORD(HvGetCell(Hive,Cell), \ HCELL, \ u.NewCell.u.UserData)) Definition at line 292 of file hive.h. Referenced by HvFreeCell(), HvIsCellAllocated(), and HvMarkCellDirty().

#define ROUND_UP (  a, b   )     ( ((ULONG)(a) + (ULONG)(b) - 1) & ~((ULONG)(b) - 1) )

Definition at line 49 of file hive.h. Referenced by CmpSetValueKeyNew(), ExAllocatePool(), ExpGetProcessInformation(), HvMarkClean(), HvMarkDirty(), HvpAddBin(), HvpBuildMapAndCopy(), HvpDoWriteHive(), HvpFindNextDirtyBlock(), HvpGrowLog1(), HvpGrowLog2(), HvpInitMap(), HvpRecoverData(), HvpWriteLog(), HvWriteHive(), KeStartAllProcessors(), MmGetPageFileInformation(), MmGetVerifierInformation(), RtlCreateProcessParameters(), RtlpCopyProcString(), and RtlpCreateStack().

---

Function Documentation

HCELL_INDEX HvAllocateCell (  PHHIVE  Hive, ULONG  NewSize, HSTORAGE_TYPE  Type )

Definition at line 386 of file hivecell.c. Referenced by CmpAddSubKey(), CmpAssignSecurityDescriptor(), CmpCopyCell(), CmpCopyKeyPartial(), CmpCreateLinkNode(), CmpCreateRootNode(), CmpDoCreateChild(), CmpSetSecurityDescriptorInfo(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), CmpSplitLeaf(), CmpSyncKeyValues(), EhCreateChild(), and EhpAttachSecurity(). 00398 : 00399 00400 Allocates the space and the cell index for a new cell. 00401 00402 Arguments: 00403 00404 Hive - supplies a pointer to the hive control structure for the 00405 hive of interest 00406 00407 NewSize - size in bytes of the cell to allocate 00408 00409 Type - indicates whether Stable or Volatile storage is desired. 00410 00411 Return Value: 00412 00413 New HCELL_INDEX if success, HCELL_NIL if failure. 00414 00415 --*/ 00416 { 00417 HCELL_INDEX NewCell; 00418 00419 CMLOG(CML_MAJOR, CMS_HIVE) { 00420 KdPrint(("HvAllocateCell:\n")); 00421 KdPrint(("\tHive=%08lx NewSize=%08lx\n",Hive,NewSize)); 00422 } 00423 ASSERT(Hive->Signature == HHIVE_SIGNATURE); 00424 ASSERT(Hive->ReadOnly == FALSE); 00425 ASSERT_CM_LOCK_OWNED_EXCLUSIVE(); 00426 00427 // 00428 // Make room for overhead fields and round up to HCELL_PAD boundary 00429 // 00430 if (USE_OLD_CELL(Hive)) { 00431 NewSize += FIELD_OFFSET(HCELL, u.OldCell.u.UserData); 00432 } else { 00433 NewSize += FIELD_OFFSET(HCELL, u.NewCell.u.UserData); 00434 } 00435 NewSize = ROUND_UP(NewSize, HCELL_PAD(Hive)); 00436 00437 // 00438 // Adjust the size (an easy fix for granularity) 00439 // 00440 HvpAdjustCellSize(NewSize); 00441 // 00442 // reject impossible/unreasonable values 00443 // 00444 if (NewSize > HSANE_CELL_MAX) { 00445 return HCELL_NIL; 00446 } 00447 00448 // 00449 // Do the actual storage allocation 00450 // 00451 NewCell = HvpDoAllocateCell(Hive, NewSize, Type); 00452 00453 #if DBG 00454 if (NewCell != HCELL_NIL) { 00455 ASSERT(HvIsCellAllocated(Hive, NewCell)); 00456 } 00457 #endif 00458 00459 CMLOG(CML_FLOW, CMS_HIVE) {

ULONG HvCheckBin (  PHHIVE  Hive, PHBIN  Bin, PULONG  Storage )

Definition at line 175 of file hivechek.c. References Bin, HBIN_NIL, Hive, HvCheckBinDebug, L, _HBIN::Size, and USE_OLD_CELL. Referenced by HvCheckHive(). 00182 : 00183 00184 Step through all of the cells in the bin. Make sure that 00185 they are consistent with each other, and with the bin header. 00186 00187 Arguments: 00188 00189 Hive - pointer to the hive control structure 00190 00191 Bin - pointer to bin to check 00192 00193 Storage - pointer to a ulong to get allocated user data size 00194 00195 Return Value: 00196 00197 0 if Bin is OK. Number of test in procedure that failed if not. 00198 00199 RANGE: 1 - 1999 00200 00201 --*/ 00202 { 00203 PHCELL p; 00204 PHCELL np; 00205 PHCELL lp; 00206 ULONG freespace = 0L; 00207 ULONG allocated = 0L; 00208 ULONG userallocated = 0L; 00209 00210 HvCheckBinDebug.Bin = Bin; 00211 HvCheckBinDebug.Status = 0; 00212 HvCheckBinDebug.CellPoint = 0; 00213 00214 // 00215 // Scan all the cells in the bin, total free and allocated, check 00216 // for impossible pointers. 00217 // 00218 p = (PHCELL)((PUCHAR)Bin + sizeof(HBIN)); 00219 lp = p; 00220 00221 // DRAGOS: 00222 // The way allocated and freespace are computed implies the following invariants: 00223 // 1. allocated + freespace = p + p->Size - (Bin + sizeof(HBIN)). This is because p->Size is added either to allocated or to freespace. 00224 // So, assuming that allocated > Bin->Size , then 00225 // ==> p + p->Size - (Bin + sizeof(HBIN)) > Bin->Size. 00226 // ==> p + p->Size > Bin + Bin->Size + sizeof(HBIN) 00227 // ==> p + p->Size > Bin + Bin->Size 00228 // This proves that the test "NeverFail 1" (see bellow) will never fail, because when something is wrong, the test above it (namely "Fail 1") will fail 00229 // and the function will exit. 00230 // 00231 // The same logic applies to the test "NeverFail 2", so it can be removed also. 00232 // 00233 // 2. The new value of p is always calculated as p = p + p->Size. By the time this is done, the new value of p (ie. p + p->Size) is already checked against 00234 // Bin + Bin->Size (see tests "Fail 1" and "Fail 2"). So, if p > Bin + Bin->Size, either "Fail 1" or "Fail 2" will fail before asigning the new bogus value 00235 // to p. Therefore, the only possible path to exit the while loop (except a return 20 or return 40), is when p == Bin + Bin->Size. 00236 // ==> test "NeverFail 3" can be removed as it will never fail ! 00237 // 00238 // 3. Considering 1 (where p + p->Size became p) 00239 // ==> allocated + freespace = p - (Bin + sizeof(HBIN)) 00240 // But, Considering 2 (above), when the while loop exits, p = Bin + Bin->Size 00241 // ==> allocated + freespace = Bin + Bin->Size - (Bin + sizeof(HBIN)) 00242 // ==> allocated + freespace + sizeof(HBIN) = Bin->Size 00243 // This proves that test "NeverFail 4" (see bellow) will never fail as the expresion tested is always true (if the flow of execution reaches the test point). 00244 // 00245 00246 while (p < (PHCELL)((PUCHAR)Bin + Bin->Size)) { 00247 00248 // 00249 // Check last pointer 00250 // 00251 if (USE_OLD_CELL(Hive)) { 00252 if (lp == p) { 00253 if (p->u.OldCell.Last != HBIN_NIL) { 00254 KdPrint(("HvCheckBin 20: First cell has wrong last pointer\n")); 00255 KdPrint(("Bin = %08lx\n", Bin)); 00256 HvCheckBinDebug.Status = 20; 00257 HvCheckBinDebug.CellPoint = p; 00258 return 20; 00259 } 00260 } else { 00261 if ((PHCELL)(p->u.OldCell.Last + (PUCHAR)Bin) != lp) { 00262 KdPrint(("HvCheckBin 30: incorrect last pointer\n")); 00263 KdPrint(("Bin = %08lx\n", Bin)); 00264 KdPrint(("p = %08lx\n", (ULONG_PTR)p)); 00265 HvCheckBinDebug.Status = 30; 00266 HvCheckBinDebug.CellPoint = p; 00267 return 30; 00268 } 00269 } 00270 } 00271 00272 00273 // 00274 // Check size 00275 // 00276 if (p->Size < 0) { 00277 00278 // 00279 // allocated cell 00280 // 00281 00282 // DRAGOS: Fail 1 00283 // This test will alway fail prior to the failure of the bellow test 00284 // 00285 if ( ((ULONG)(p->Size * -1) > Bin->Size) || 00286 ( (PHCELL)((p->Size * -1) + (PUCHAR)p) > 00287 (PHCELL)((PUCHAR)Bin + Bin->Size) ) 00288 ) 00289 { 00290 KdPrint(("HvCheckBin 40: impossible allocation\n")); 00291 KdPrint(("Bin = %08lx\n", Bin)); 00292 HvCheckBinDebug.Status = 40; 00293 HvCheckBinDebug.CellPoint = p; 00294 return 40; 00295 } 00296 00297 allocated += (p->Size * -1); 00298 if (USE_OLD_CELL(Hive)) { 00299 userallocated += (p->Size * -1) - FIELD_OFFSET(HCELL, u.OldCell.u.UserData); 00300 } else { 00301 userallocated += (p->Size * -1) - FIELD_OFFSET(HCELL, u.NewCell.u.UserData); 00302 } 00303 00304 // 00305 // DRAGOS: NeverFail 1 00306 // This test will never fail. If a size is wrong the above test (Fail 1)will fail. We can remove this test (it's useless). 00307 // 00308 if (allocated > Bin->Size) { 00309 KdPrint(("HvCheckBin 50: allocated exceeds available\n")); 00310 KdPrint(("Bin = %08lx\n", Bin)); 00311 HvCheckBinDebug.Status = 50; 00312 HvCheckBinDebug.CellPoint = p; 00313 return 50; 00314 } 00315 00316 np = (PHCELL)((PUCHAR)p + (p->Size * -1)); 00317 00318 00319 00320 } else { 00321 00322 // 00323 // free cell 00324 // 00325 00326 // DRAGOS: Fail 2 00327 // This test will alway fail prior to the failure of the bellow test 00328 // 00329 if ( ((ULONG)p->Size > Bin->Size) || 00330 ( (PHCELL)(p->Size + (PUCHAR)p) > 00331 (PHCELL)((PUCHAR)Bin + Bin->Size) ) || 00332 (p->Size == 0) ) 00333 { 00334 KdPrint(("HvCheckBin 60: impossible free block\n")); 00335 KdPrint(("Bin = %08lx\n", Bin)); 00336 HvCheckBinDebug.Status = 60; 00337 HvCheckBinDebug.CellPoint = p; 00338 return 60; 00339 } 00340 00341 freespace = freespace + p->Size; 00342 00343 // 00344 // DRAGOS: NeverFail 2 00345 // This test will never fail. If a size is wrong the above test (Fail 2) will fail. We can remove this test (it's useless). 00346 // 00347 if (freespace > Bin->Size) { 00348 KdPrint(("HvCheckBin 70: free exceeds available\n")); 00349 KdPrint(("Bin = %08lx\n", Bin)); 00350 HvCheckBinDebug.Status = 70; 00351 HvCheckBinDebug.CellPoint = p; 00352 return 70; 00353 } 00354 00355 np = (PHCELL)((PUCHAR)p + p->Size); 00356 00357 } 00358 00359 lp = p; 00360 p = np; 00361 } 00362 00363 // DRAGOS: NeverFail 4 00364 // This test never fails. If the while loop exits, the condition tested here is always true!!! 00365 // We can remove this test (it's useless) 00366 // 00367 if ((freespace + allocated + sizeof(HBIN)) != Bin->Size) { 00368 KdPrint(("HvCheckBin 995: sizes do not add up\n")); 00369 KdPrint(("Bin = %08lx\n", Bin)); 00370 KdPrint(("freespace = %08lx ", freespace)); 00371 KdPrint(("allocated = %08lx ", allocated)); 00372 KdPrint(("size = %08lx\n", Bin->Size)); 00373 HvCheckBinDebug.Status = 995; 00374 return 995; 00375 } 00376 00377 // DRAGOS: NeverFail 3 00378 // This test never fails. The only way out of the while loop is when p == Bin + Bin->Size !!!!!!! 00379 // We can remove this test (it's useless) 00380 // 00381 if (p != (PHCELL)((PUCHAR)Bin + Bin->Size)) { 00382 KdPrint(("HvCheckBin 1000: last cell points off the end\n")); 00383 KdPrint(("Bin = %08lx\n", Bin)); 00384 HvCheckBinDebug.Status = 1000; 00385 return 1000; 00386 } 00387 00388 if (ARGUMENT_PRESENT(Storage)) { 00389 *Storage += userallocated; 00390 } 00391 return 0; 00392 } }

ULONG HvCheckHive (  PHHIVE  Hive, PULONG Storage  OPTIONAL )

Definition at line 54 of file hivechek.c. References Bin, _HBIN::FileOffset, HBIN_SIGNATURE, HCELL_INDEX, HCELL_NIL, Hive, HMAP_BASE, HMAP_DISCARDABLE, HvCheckBin(), HvCheckHiveDebug, HvpGetCellMap(), NULL, _HBIN::Signature, _HBIN::Size, _FREE_HBIN::Size, t(), and Volatile. Referenced by CmCheckRegistry(), and HvRefreshHive(). : Check the consistency of a hive. Apply CheckBin to bins, make sure all pointers in the cell map point to correct places. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest. Storage - supplies adddress of ULONG to receive size of allocated user data Return Value: 0 if Hive is OK. Error return indicator if not. Error value comes from one of the check procedures. RANGE: 2000 - 2999 --*/ { HCELL_INDEX p; ULONG Length; ULONG localstorage = 0; PHMAP_ENTRY t; PHBIN Bin; ULONG i; ULONG rc; PFREE_HBIN FreeBin; HvCheckHiveDebug.Hive = Hive; HvCheckHiveDebug.Status = 0; HvCheckHiveDebug.Space = (ULONG)-1; HvCheckHiveDebug.MapPoint = HCELL_NIL; HvCheckHiveDebug.BinPoint = 0; p = 0; // // one pass for Stable space, one pass for Volatile // for (i = 0; i <= Volatile; i++) { Length = Hive->Storage[i].Length; // // for each bin in the space // while (p < Length) { t = HvpGetCellMap(Hive, p); if (t == NULL) { KdPrint(("HvCheckHive:")); KdPrint(("\tBin@:%08lx invalid\n", Bin)); HvCheckHiveDebug.Status = 2005; HvCheckHiveDebug.Space = i; HvCheckHiveDebug.MapPoint = p; return 2005; } if ((t->BinAddress & HMAP_DISCARDABLE) == 0) { Bin = (PHBIN)((t->BinAddress) & HMAP_BASE); // // bin header valid? // if ( (Bin->Size > Length) || (Bin->Signature != HBIN_SIGNATURE) || (Bin->FileOffset != p) ) { KdPrint(("HvCheckHive:")); KdPrint(("\tBin@:%08lx invalid\n", Bin)); HvCheckHiveDebug.Status = 2010; HvCheckHiveDebug.Space = i; HvCheckHiveDebug.MapPoint = p; HvCheckHiveDebug.BinPoint = Bin; return 2010; } // // structure inside the bin valid? // rc = HvCheckBin(Hive, Bin, &localstorage); if (rc != 0) { HvCheckHiveDebug.Status = rc; HvCheckHiveDebug.Space = i; HvCheckHiveDebug.MapPoint = p; HvCheckHiveDebug.BinPoint = Bin; return rc; } p = (ULONG)p + Bin->Size; } else { // // Bin is not present, skip it and advance to the next one. // FreeBin = (PFREE_HBIN)t->BlockAddress; p+=FreeBin->Size; } } p = 0x80000000; // Beginning of Volatile space } if (ARGUMENT_PRESENT(Storage)) { *Storage = localstorage; } return 0; }

VOID HvFreeCell (  PHHIVE  Hive, HCELL_INDEX  Cell )

Definition at line 688 of file hivecell.c. References ASSERT, ASSERT_CM_LOCK_OWNED_EXCLUSIVE, Bin, _HMAP_ENTRY::BinAddress, Cell, CML_MINOR, CMLOG, CMS_HIVE, DHvCheckBin, FALSE, _HBIN::FileOffset, HCELL_FREE_FILL, HCELL_INDEX, HCELL_TYPE_MASK, Hive, HMAP_BASE, HvGetCellType, HvpEnlistFreeCell(), HvpGetCellMap(), HvpGetHCell, HvpIsFreeNeighbor(), NULL, _HHIVE::ReadOnly, _HCELL::Size, _HBIN::Size, TRUE, _HCELL::u, USE_OLD_CELL, VALIDATE_CELL_MAP, and VOID(). Referenced by CmDeleteValueKey(), CmpAddSubKey(), CmpAssignSecurityDescriptor(), CmpCopyKeyPartial(), CmpCopyValue(), CmpCreateLinkNode(), CmpDoCreateChild(), CmpFreeKeyBody(), CmpFreeKeyByCell(), CmpFreeKeyValues(), CmpFreeSecurityDescriptor(), CmpFreeValue(), CmpMergeKeyValues(), CmpRemoveSubKey(), CmpSetSecurityDescriptorInfo(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), CmpSplitLeaf(), and CmpSyncKeyValues(). : Frees the storage for a cell. NOTE: CALLER is expected to mark relevent data dirty, so as to allow this call to always succeed. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest Cell - HCELL_INDEX of Cell to free. Return Value: FALSE - failed, presumably for want of log space. TRUE - it worked --*/ { PHBIN Bin; PHCELL tmp; HCELL_INDEX newfreecell; PHCELL freebase; ULONG savesize; PHCELL neighbor; ULONG Type; PHMAP_ENTRY Me; CMLOG(CML_MINOR, CMS_HIVE) { KdPrint(("HvFreeCell:\n")); KdPrint(("\tHive=%08lx Cell=%08lx\n",Hive,Cell)); } ASSERT(Hive->ReadOnly == FALSE); ASSERT_CM_LOCK_OWNED_EXCLUSIVE(); // // Get sizes and addresses // Me = HvpGetCellMap(Hive, Cell); VALIDATE_CELL_MAP(__LINE__,Me,Hive,Cell); Type = HvGetCellType(Cell); Bin = (PHBIN)((Me->BinAddress) & HMAP_BASE); DHvCheckBin(Hive,Bin); freebase = HvpGetHCell(Hive, Cell); // // go do actual frees, cannot fail from this point on // ASSERT(freebase->Size < 0); freebase->Size *= -1; savesize = freebase->Size; // // Look for free neighbors and coalesce them. We will never travel // around this loop more than twice. // while ( HvpIsFreeNeighbor( Hive, Bin, freebase, &neighbor, Type ) == TRUE ) { if (neighbor > freebase) { // // Neighboring free cell is immediately above us in memory. // if (USE_OLD_CELL(Hive)) { tmp = (PHCELL)((PUCHAR)neighbor + neighbor->Size); if ( ((ULONG)((ULONG_PTR)tmp - (ULONG_PTR)Bin)) < Bin->Size) { tmp->u.OldCell.Last = (ULONG)((ULONG_PTR)freebase - (ULONG_PTR)Bin); } } freebase->Size += neighbor->Size; } else { // // Neighboring free cell is immediately below us in memory. // if (USE_OLD_CELL(Hive)) { tmp = (PHCELL)((PUCHAR)freebase + freebase->Size); if ( ((ULONG)((ULONG_PTR)tmp - (ULONG_PTR)Bin)) < Bin->Size ) { tmp->u.OldCell.Last = (ULONG)((ULONG_PTR)neighbor - (ULONG_PTR)Bin); } } neighbor->Size += freebase->Size; freebase = neighbor; } } // // freebase now points to the biggest free cell we could make, none // of which is on the free list. So put it on the list. // newfreecell = (Bin->FileOffset) + ((ULONG)((ULONG_PTR)freebase - (ULONG_PTR)Bin)) + (Type*HCELL_TYPE_MASK); ASSERT(HvpGetHCell(Hive, newfreecell) == freebase); #if DBG if (USE_OLD_CELL(Hive)) { RtlFillMemory( &(freebase->u.OldCell.u.UserData), (freebase->Size - FIELD_OFFSET(HCELL, u.OldCell.u.UserData)), HCELL_FREE_FILL ); } else { RtlFillMemory( &(freebase->u.NewCell.u.UserData), (freebase->Size - FIELD_OFFSET(HCELL, u.NewCell.u.UserData)), HCELL_FREE_FILL ); } #endif

VOID HvFreeHive (  PHHIVE  Hive  )

Definition at line 34 of file hivefree.c. References ASSERT, _HHIVE::BaseBlock, Bin, _HMAP_ENTRY::BinAddress, _HMAP_ENTRY::BlockAddress, CML_BIN, CMLOG, CmpFree(), CMS_BIN_MAP, _HHIVE::DirtyAlloc, _HHIVE::DirtyVector, FALSE, _HBASE_BLOCK::FileName, _FREE_HBIN::Flags, _HHIVE::Flat, _HHIVE::Free, FREE_HBIN_DISCARDABLE, HBLOCK_SIZE, HCELL_INDEX, HCELL_TYPE_MASK, Hive, HMAP_BASE, HMAP_DISCARDABLE, HMAP_NEWALLOC, HTABLE_SLOTS, HvpFreeMap(), HvpGetCellMap(), _HBIN::MemAlloc, NULL, _HHIVE::ReadOnly, _FREE_HBIN::Size, Stable, VALIDATE_CELL_MAP, and Volatile. Referenced by CmpDestroyTemporaryHive(), CmpInitializeHive(), CmpValidateAlternate(), CmReplaceKey(), and CmUnloadKey(). : Free all of the pieces of a hive. Arguments: Hive - supplies a pointer to hive control structure for hive to free. this structure itself will NOT be freed, but everything it points to will. Return Value: NONE. --*/ { PHMAP_DIRECTORY Dir; PHMAP_ENTRY Me; HCELL_INDEX Address; ULONG Type; ULONG Length; PHBIN Bin; ULONG Tables; PFREE_HBIN FreeBin; ASSERT(Hive->Flat == FALSE); ASSERT(Hive->ReadOnly == FALSE); ASSERT(Stable == 0); ASSERT(Volatile == 1); CMLOG(CML_BIN, CMS_BIN_MAP) { KdPrint(("HvFreeHive(%ws) :\n", Hive->BaseBlock->FileName)); } // // Iterate through both types of storage // for (Type = 0; Type <= Volatile; Type++) { Address = HCELL_TYPE_MASK * Type; Length = Hive->Storage[Type].Length + (HCELL_TYPE_MASK * Type); if (Length > (HCELL_TYPE_MASK * Type)) { // // Sweep through bin set // do { Me = HvpGetCellMap(Hive, Address); VALIDATE_CELL_MAP(__LINE__,Me,Hive,Address); if (Me->BinAddress & HMAP_DISCARDABLE) { // // hbin is either discarded or discardable, check the tombstone // FreeBin = (PFREE_HBIN)Me->BlockAddress; Address += FreeBin->Size; if (FreeBin->Flags & FREE_HBIN_DISCARDABLE) { CmpFree((PHBIN)(Me->BinAddress & HMAP_BASE), FreeBin->Size); } CmpFree(FreeBin, sizeof(FREE_HBIN)); } else { Bin = (PHBIN)(Me->BinAddress & HMAP_BASE); Address += Bin->MemAlloc; #if DBG // // Make sure that the next bin in the list is // actually the start of an alloc before freeing it // if (Address < Length) { Me = HvpGetCellMap(Hive, Address); VALIDATE_CELL_MAP(__LINE__,Me,Hive,Address); ASSERT(Me->BinAddress & HMAP_NEWALLOC); } #endif CMLOG(CML_BIN, CMS_BIN_MAP) { if( Type == Stable ) { KdPrint(("HvFreeHive: BinAddress = 0x%08lx\t Size = 0x%lx\n", Bin, Bin->MemAlloc)); } } CmpFree(Bin, Bin->MemAlloc); } } while (Address < Length); // // Free map table storage // ASSERT(Hive->Storage[Type].Length != (HCELL_TYPE_MASK * Type)); Tables = (((Hive->Storage[Type].Length) / HBLOCK_SIZE)-1) / HTABLE_SLOTS; Dir = Hive->Storage[Type].Map; HvpFreeMap(Hive, Dir, 0, Tables); if (Tables > 0) { CmpFree(Hive->Storage[Type].Map, sizeof(HMAP_DIRECTORY)); // free dir if it exists } } Hive->Storage[Type].Length = 0; } CMLOG(CML_BIN, CMS_BIN_MAP) { KdPrint(("\n")); } // // Free the base block // (Hive->Free)(Hive->BaseBlock, sizeof(HBASE_BLOCK)); Hive->BaseBlock = NULL; // // Free the dirty vector // if (Hive->DirtyVector.Buffer != NULL) { CmpFree((PVOID)(Hive->DirtyVector.Buffer), Hive->DirtyAlloc); } return; }

VOID HvFreeHivePartial (  PHHIVE  Hive, HCELL_INDEX  Start, HSTORAGE_TYPE  Type )

Definition at line 160 of file hivefree.c. References ASSERT, Bin, _HMAP_ENTRY::BinAddress, _HMAP_ENTRY::BlockAddress, CmpFree(), CmpReleaseGlobalQuota(), _HHIVE::DirtyCount, _HHIVE::DirtyVector, FALSE, _FREE_HBIN::Flags, _HHIVE::Flat, FREE_HBIN_DISCARDABLE, HBLOCK_SIZE, HCELL_INDEX, HCELL_TYPE_MASK, Hive, HMAP_BASE, HMAP_DISCARDABLE, HSECTOR_SIZE, HTABLE_SLOTS, HvpFreeMap(), HvpGetCellMap(), _FREE_HBIN::ListEntry, _HBIN::MemAlloc, _HHIVE::ReadOnly, RtlClearBits(), RtlNumberOfSetBits(), _FREE_HBIN::Size, Stable, Start, and VALIDATE_CELL_MAP. Referenced by HvpTruncateBins(), and HvRefreshHive(). 00167 : 00168 00169 Free the memory and associated maps for the end of a hive 00170 starting at Start. The baseblock, hive, etc will not be touched. 00171 00172 Arguments: 00173 00174 Hive - supplies a pointer to hive control structure for hive to 00175 partially free. 00176 00177 Start - HCELL_INDEX of first bin to free, will free from this 00178 bin (inclusive) to the end of the hives stable storage. 00179 00180 Type - Type of storage (Stable or Volatile) to be freed. 00181 00182 Return Value: 00183 00184 NONE. 00185 00186 --*/ 00187 { 00188 PHMAP_DIRECTORY Dir; 00189 PHMAP_ENTRY Me; 00190 HCELL_INDEX Address; 00191 ULONG StartTable; 00192 ULONG Length; 00193 PHBIN Bin; 00194 ULONG Tables; 00195 ULONG FirstBit; 00196 ULONG LastBit; 00197 PFREE_HBIN FreeBin; 00198 00199 ASSERT(Hive->Flat == FALSE); 00200 ASSERT(Hive->ReadOnly == FALSE); 00201 00202 Address = Start; 00203 Length = Hive->Storage[Type].Length; 00204 ASSERT(Address <= Length); 00205 00206 if (Address == Length) { 00207 return; 00208 } 00209 00210 // 00211 // Sweep through bin set 00212 // 00213 do { 00214 Me = HvpGetCellMap(Hive, Address + (Type*HCELL_TYPE_MASK)); 00215 VALIDATE_CELL_MAP(__LINE__,Me,Hive,Address + (Type*HCELL_TYPE_MASK)); 00216 if (Me->BinAddress & HMAP_DISCARDABLE) { 00217 FreeBin = (PFREE_HBIN)Me->BlockAddress; 00218 if (FreeBin->Flags & FREE_HBIN_DISCARDABLE) { 00219 CmpFree((PVOID)(Me->BinAddress & HMAP_BASE), FreeBin->Size); 00220 } else { 00221 // 00222 // The bin has been freed, but quota is still charged. 00223 // Since the file will now shrink, the quota must be 00224 // returned here. 00225 // 00226 CmpReleaseGlobalQuota(FreeBin->Size); 00227 } 00228 RemoveEntryList(&FreeBin->ListEntry); 00229 Address += FreeBin->Size; 00230 CmpFree(FreeBin, sizeof(FREE_HBIN)); 00231 00232 } else { 00233 Bin = (PHBIN)(Me->BinAddress & HMAP_BASE); 00234 00235 Address += Bin->MemAlloc; 00236 CmpFree(Bin, Bin->MemAlloc); 00237 } 00238 } while (Address < Length); 00239 00240 // 00241 // Free map table storage 00242 // 00243 Tables = (((Hive->Storage[Type].Length) / HBLOCK_SIZE) - 1) / HTABLE_SLOTS; 00244 Dir = Hive->Storage[Type].Map; 00245 if (Start > 0) { 00246 StartTable = ((Start-1) / HBLOCK_SIZE) / HTABLE_SLOTS; 00247 } else { 00248 StartTable = (ULONG)-1; 00249 } 00250 HvpFreeMap(Hive, Dir, StartTable+1, Tables); 00251 00252 Hive->Storage[Type].Length = Start; 00253 00254 if (Type==Stable) { 00255 // 00256 // Clear dirty vector for data past Hive->Storage[Stable].Length 00257 // 00258 FirstBit = Start / HSECTOR_SIZE; 00259 LastBit = Hive->DirtyVector.SizeOfBitMap; 00260 ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); 00261 RtlClearBits(&Hive->DirtyVector, FirstBit, LastBit-FirstBit); 00262 Hive->DirtyCount = RtlNumberOfSetBits(&Hive->DirtyVector); 00263 } 00264 00265 return; 00266 } }

LONG HvGetCellSize (  PHHIVE  Hive, PVOID  Address )

NTSTATUS HvInitializeHive (  PHHIVE  Hive, ULONG  OperationType, ULONG  HiveFlags, ULONG  FileTypes, PVOID HiveData  OPTIONAL, PALLOCATE_ROUTINE  AllocateRoutine, PFREE_ROUTINE  FreeRoutine, PFILE_SET_SIZE_ROUTINE  FileSetSizeRoutine, PFILE_WRITE_ROUTINE  FileWriteRoutine, PFILE_READ_ROUTINE  FileReadRoutine, PFILE_FLUSH_ROUTINE  FileFlushRoutine, ULONG  Cluster, PUNICODE_STRING  FileName )

Definition at line 158 of file hiveinit.c. References _HHIVE::Allocate, _HHIVE::Alternate, _HHIVE::BaseBlock, _HBASE_BLOCK::CheckSum, _HHIVE::Cluster, _HBASE_BLOCK::Cluster, CML_BIN, CML_MAJOR, CMLOG, CmpReleaseGlobalQuota(), CMS_BIN_MAP, CMS_INIT, _HHIVE::DirtyAlloc, _HHIVE::DirtyCount, _HHIVE::DirtyVector, FALSE, _HHIVE::FileFlush, FileName, _HHIVE::FileRead, _HHIVE::FileSetSize, _HHIVE::FileWrite, _HHIVE::Flat, _HBASE_BLOCK::Format, _HHIVE::Free, _HHIVE::GetCellRoutine, HBASE_BLOCK_SIGNATURE, HBASE_FORMAT_MEMORY, HBLOCK_SIZE, HCELL_INDEX, HCELL_NIL, HFILE_TYPE_ALTERNATE, HFILE_TYPE_LOG, HFILE_TYPE_PRIMARY, HHIVE_FREE_DISPLAY_SIZE, HHIVE_SIGNATURE, HINIT_CREATE, HINIT_FILE, HINIT_FLAT, HINIT_MEMORY, HINIT_MEMORY_INPLACE, Hive, HIVE_VOLATILE, _HHIVE::HiveFlags, HSECTOR_COUNT, HSECTOR_SIZE, HSYS_MAJOR, HSYS_MINOR, HTYPE_COUNT, HvLoadHive(), HvpBuildMap(), HvpBuildMapAndCopy(), HvpDoWriteHive(), HvpDumpFreeDisplay, HvpFillFileName(), HvpFreeAllocatedBins(), HvpGetCellFlat(), HvpGetCellPaged(), HvpHeaderCheckSum(), _HBASE_BLOCK::Length, _HHIVE::Log, _HHIVE::LogSize, _HBASE_BLOCK::Major, _HBASE_BLOCK::Minor, NT_SUCCESS, NTSTATUS(), NULL, PAGE_SIZE, _HHIVE::ReadOnly, _HHIVE::RefreshCount, _HBASE_BLOCK::RootCell, RtlClearAllBits(), RtlInitializeBitMap(), RtlSetAllBits(), _HBASE_BLOCK::Sequence1, _HBASE_BLOCK::Sequence2, _HHIVE::Signature, _HBASE_BLOCK::Signature, Stable, Status, _HHIVE::StorageTypeCount, _HBASE_BLOCK::TimeStamp, TRUE, _HBASE_BLOCK::Type, _HHIVE::Version, and Volatile. Referenced by CmGetSystemControlValues(), and CmpInitializeHive(). : Initialize a hive. Core HHive fields are always inited. File calls WILL be made BEFORE this call returns. Caller is expected to create/open files and store file handles in a way that can be derived from the hive pointer. Three kinds of initialization can be done, selected by OperationType: HINIT_CREATE Create a new hive from scratch. Will have 0 storage. [Used to do things like create HARDWARE hive and for parts of SaveKey and RestoreKey] HINIT_MEMORY_INPLACE Build a hive control structure which allows read only access to a contiguous in-memory image of a hive. No part of the image will be copied, but a map will be made. [Used by osloader.] HINIT_FLAT Support very limited (read-only, no checking code) operation against a hive image. HINIT_MEMORY Create a new hive, using a hive image already in memory, at address supplied by pointer HiveData. The data will be copied. Caller is expected to free HiveData. [Used for SYSTEM hive] HINIT_FILE Create a hive, reading its data from a file. Recovery processing via log file will be done if a log is available. If a log is recovered, flush and clear operation will proceed. NOTE: The HHive is not a completely opaque structure, because it is really only used by a limited set of code. Do not assume that only this routine sets all of these values. Arguments: Hive - supplies a pointer to hive control structure to be initialized to describe this hive. OperationType - specifies whether to create a new hive from scratch, from a memory image, or by reading a file from disk. HiveFlags - HIVE_VOLATILE - Entire hive is to be volatile, regardless of the types of cells allocated HIVE_NO_LAZY_FLUSH - Data in this hive is never written to disk except by an explicit FlushKey FileType - HFILE_TYPE_*, HFILE_TYPE_LOG or HFILE_TYPE_ALTERNATE set up for logging or alternate support respectively. HiveData - if present, supplies a pointer to an in memory image of from which to init the hive. Only useful when OperationType is set to HINIT_MEMORY. AllocateRoutine - supplies a pointer to routine called to allocate memory. WILL be called before this routine returns. FreeRoutine - supplies a pointer to routine called to free memory. CAN be called before this routine returns. FileSetSizeRoutine - supplies a pointer to a routine used to set the size of a file. CAN be called before this routine returns. FileWriteRoutine - supplies a pointer to routine called to write memory to a file. FileReadRoutine - supplies a pointer to routine called to read from a file into memory. CAN be called before this routine returns. FileFlushRoutine - supplies a pointer to routine called to flush a file. Cluster - clustering factor in HSECTOR_SIZE units. (i.e. Size of physical sector in media / HSECTOR_SIZE. 1 for 512 byte physical sectors (or smaller), 2 for 1024, 4 for 2048, etc. (Numbers greater than 8 won't work.) FileName - some path like "...\system32\config\system", last 32 or so characters will be copied into baseblock (and thus to disk) as a debugging aid. May be null. Return Value: NTSTATUS code. --*/ { BOOLEAN UseForIo; PHBASE_BLOCK BaseBlock = NULL; NTSTATUS Status; NTSTATUS Status2; PVOID Image; ULONG i; PHBIN Pbin; ULONG Alignment; // // this array stores the last elements in each free cell list for the stable storage // HCELL_INDEX TailDisplay[HHIVE_FREE_DISPLAY_SIZE]; CMLOG(CML_MAJOR, CMS_INIT) { KdPrint(("HvInitializeHive:\n")); KdPrint(("\tHive=%08lx\n", Hive)); } // // reject invalid parameter combinations // if ( (! ARGUMENT_PRESENT(HiveData)) && ((OperationType == HINIT_MEMORY) || (OperationType == HINIT_FLAT) || (OperationType == HINIT_MEMORY_INPLACE)) ) { return STATUS_INVALID_PARAMETER; } if ( ! ((OperationType == HINIT_CREATE) || (OperationType == HINIT_MEMORY) || (OperationType == HINIT_MEMORY_INPLACE) || (OperationType == HINIT_FLAT) || (OperationType == HINIT_FILE)) ) { return STATUS_INVALID_PARAMETER; } // // static and global control values // Hive->Signature = HHIVE_SIGNATURE; Hive->Allocate = AllocateRoutine; Hive->Free = FreeRoutine; Hive->FileSetSize = FileSetSizeRoutine; Hive->FileWrite = FileWriteRoutine; Hive->FileRead = FileReadRoutine; Hive->FileFlush = FileFlushRoutine; Hive->Log = (BOOLEAN)((FileType == HFILE_TYPE_LOG) ? TRUE : FALSE); Hive->Alternate = (BOOLEAN)((FileType == HFILE_TYPE_ALTERNATE) ? TRUE : FALSE); if ((Hive->Log || Hive->Alternate) && (HiveFlags & HIVE_VOLATILE)) { return STATUS_INVALID_PARAMETER; } Hive->HiveFlags = HiveFlags; if ((Cluster == 0) || (Cluster > HSECTOR_COUNT)) { return STATUS_INVALID_PARAMETER; } Hive->Cluster = Cluster; Hive->RefreshCount = 0; Hive->StorageTypeCount = HTYPE_COUNT; Hive->Storage[Volatile].Length = 0; Hive->Storage[Volatile].Map = NULL; Hive->Storage[Volatile].SmallDir = NULL; Hive->Storage[Volatile].Guard = (ULONG)-1; Hive->Storage[Volatile].FreeSummary = 0; InitializeListHead(&Hive->Storage[Volatile].FreeBins); for (i = 0; i < HHIVE_FREE_DISPLAY_SIZE; i++) { Hive->Storage[Volatile].FreeDisplay[i] = HCELL_NIL; } Hive->Storage[Stable].Length = 0; Hive->Storage[Stable].Map = NULL; Hive->Storage[Stable].SmallDir = NULL; Hive->Storage[Stable].Guard = (ULONG)-1; Hive->Storage[Stable].FreeSummary = 0; InitializeListHead(&Hive->Storage[Stable].FreeBins); for (i = 0; i < HHIVE_FREE_DISPLAY_SIZE; i++) { Hive->Storage[Stable].FreeDisplay[i] = HCELL_NIL; TailDisplay[i] = HCELL_NIL; } RtlInitializeBitMap(&(Hive->DirtyVector), NULL, 0); Hive->DirtyCount = 0; Hive->DirtyAlloc = 0; Hive->LogSize = 0; Hive->GetCellRoutine = HvpGetCellPaged; Hive->Flat = FALSE; Hive->ReadOnly = FALSE; UseForIo = (BOOLEAN)!(Hive->HiveFlags & HIVE_VOLATILE); // // new create case // if (OperationType == HINIT_CREATE) { BaseBlock = (PHBASE_BLOCK)((Hive->Allocate)(sizeof(HBASE_BLOCK), UseForIo)); if (BaseBlock == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } // // Make sure the buffer we got back is cluster-aligned. If not, try // harder to get an aligned buffer. // Alignment = Cluster * HSECTOR_SIZE - 1; if (((ULONG_PTR)BaseBlock & Alignment) != 0) { (Hive->Free)(BaseBlock, sizeof(HBASE_BLOCK)); BaseBlock = (PHBASE_BLOCK)((Hive->Allocate)(PAGE_SIZE, TRUE)); if (BaseBlock == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } // // Return the quota for the extra allocation, as we are not really using // it and it will not be accounted for later when we free it. // CmpReleaseGlobalQuota(PAGE_SIZE - sizeof(HBASE_BLOCK)); } BaseBlock->Signature = HBASE_BLOCK_SIGNATURE; BaseBlock->Sequence1 = 1; BaseBlock->Sequence2 = 1; BaseBlock->TimeStamp.HighPart = 0; BaseBlock->TimeStamp.LowPart = 0; BaseBlock->Major = HSYS_MAJOR; BaseBlock->Minor = HSYS_MINOR; BaseBlock->Type = HFILE_TYPE_PRIMARY; BaseBlock->Format = HBASE_FORMAT_MEMORY; BaseBlock->RootCell = HCELL_NIL; BaseBlock->Length = 0; BaseBlock->Cluster = Cluster; BaseBlock->CheckSum = 0; HvpFillFileName(BaseBlock, FileName); Hive->BaseBlock = BaseBlock; Hive->Version = HSYS_MINOR; return STATUS_SUCCESS; } // // flat image case // if (OperationType == HINIT_FLAT) { Hive->BaseBlock = (PHBASE_BLOCK)HiveData; Hive->Version = Hive->BaseBlock->Minor; Hive->Flat = TRUE; Hive->ReadOnly = TRUE; Hive->GetCellRoutine = HvpGetCellFlat; Hive->Storage[Stable].Length = Hive->BaseBlock->Length; Hive->StorageTypeCount = 1; return STATUS_SUCCESS; } // // readonly image case // if (OperationType == HINIT_MEMORY_INPLACE) { BaseBlock = (PHBASE_BLOCK)HiveData; if ( (BaseBlock->Signature != HBASE_BLOCK_SIGNATURE) || (BaseBlock->Type != HFILE_TYPE_PRIMARY) || (BaseBlock->Major != HSYS_MAJOR) || (BaseBlock->Minor > HSYS_MINOR) || (BaseBlock->Format != HBASE_FORMAT_MEMORY) || (BaseBlock->Sequence1 != BaseBlock->Sequence2) || (HvpHeaderCheckSum(BaseBlock) != (BaseBlock->CheckSum)) ) { return STATUS_REGISTRY_CORRUPT; } Hive->BaseBlock = BaseBlock; Hive->Version = BaseBlock->Minor; Hive->ReadOnly = TRUE; Hive->StorageTypeCount = 1; if (FileType == HFILE_TYPE_ALTERNATE) { // // Mark the baseblock with Type==HFILE_TYPE_ALTERNATE. This // case will never show up on disk, because we always flush // Type==HFILE_TYPE_PRIMARY to the alternate file. Any // baseblock with Type==HFILE_TYPE_ALTERNATE indicates that // the primary is corrupt and must be rewritten. // BaseBlock->Type=HFILE_TYPE_ALTERNATE; // // baseblock has changed, recompute the checksum. // BaseBlock->CheckSum=HvpHeaderCheckSum(BaseBlock); } if ( !NT_SUCCESS(HvpBuildMap( Hive, (PUCHAR)HiveData + HBLOCK_SIZE, TailDisplay ))) { return STATUS_REGISTRY_CORRUPT; } // debug-only HvpDumpFreeDisplay(Hive); return(STATUS_SUCCESS); } // // memory copy case // if (OperationType == HINIT_MEMORY) { BaseBlock = (PHBASE_BLOCK)HiveData; if ( (BaseBlock->Signature != HBASE_BLOCK_SIGNATURE) || ((BaseBlock->Type != HFILE_TYPE_PRIMARY) && (BaseBlock->Type != HFILE_TYPE_ALTERNATE)) || (BaseBlock->Format != HBASE_FORMAT_MEMORY) || (BaseBlock->Major != HSYS_MAJOR) || (BaseBlock->Minor > HSYS_MINOR) || (HvpHeaderCheckSum(BaseBlock) != (BaseBlock->CheckSum)) ) { return STATUS_REGISTRY_CORRUPT; } Hive->BaseBlock = (PHBASE_BLOCK)((Hive->Allocate)(sizeof(HBASE_BLOCK), UseForIo)); if (Hive->BaseBlock==NULL) { return(STATUS_INSUFFICIENT_RESOURCES); } // // Make sure the buffer we got back is cluster-aligned. If not, try // harder to get an aligned buffer. // Alignment = Cluster * HSECTOR_SIZE - 1; if (((ULONG_PTR)Hive->BaseBlock & Alignment) != 0) { (Hive->Free)(Hive->BaseBlock, sizeof(HBASE_BLOCK)); Hive->BaseBlock = (PHBASE_BLOCK)((Hive->Allocate)(PAGE_SIZE, TRUE)); if (Hive->BaseBlock == NULL) { return (STATUS_INSUFFICIENT_RESOURCES); } } RtlCopyMemory(Hive->BaseBlock, BaseBlock, HSECTOR_SIZE); Hive->Version = Hive->BaseBlock->Minor; if ( !NT_SUCCESS(HvpBuildMapAndCopy(Hive, (PUCHAR)HiveData + HBLOCK_SIZE, TailDisplay))) { (Hive->Free)(Hive->BaseBlock, sizeof(HBASE_BLOCK)); Hive->BaseBlock = NULL; return STATUS_REGISTRY_CORRUPT; } if (BaseBlock->Type == HFILE_TYPE_ALTERNATE) { // // Note that Type==HFILE_TYPE_ALTERNATE will NEVER occur in // an on-disk image. The only way this can show up in the // baseblock is when the osloader rejects the SYSTEM hive and // successfully loads SYSTEM.ALT. When this happens, it // forces HFILE_TYPE_ALTERNATE into the in-memory image of // the baseblock. // // We've booted from SYSTEM.ALT. Mark the whole hive dirty // so everything gets flushed to SYSTEM as soon as we can // do I/O. // RtlSetAllBits(&(Hive->DirtyVector)); Hive->DirtyCount=Hive->DirtyVector.SizeOfBitMap; } HvpFillFileName(Hive->BaseBlock, FileName); // debug - only HvpDumpFreeDisplay(Hive); return(STATUS_SUCCESS); } // // file read case // if (OperationType == HINIT_FILE) { CMLOG(CML_BIN, CMS_BIN_MAP) { KdPrint(("HvInitializeHive(%wZ,HINIT_FILE) :\n", FileName)); } // // get the file image (possible recovered via log) into memory // Status = HvLoadHive(Hive, TailDisplay); if ((Status != STATUS_SUCCESS) && (Status != STATUS_REGISTRY_RECOVERED)) { return Status; } CMLOG(CML_BIN, CMS_BIN_MAP) { KdPrint(("\n")); } if (Status == STATUS_REGISTRY_RECOVERED) { // // We have a good hive, with a log, and a dirty map, // all set up. Only problem is that we need to flush // the file so the log can be cleared and new writes // posted against the hive. Since we know we have // a good log in hand, we just write the hive image. // if ( ! HvpDoWriteHive(Hive, HFILE_TYPE_PRIMARY)) { // // DRAGOS: Here we need cleanup // Clean up the bins already allocated // HvpFreeAllocatedBins( Hive ); return STATUS_REGISTRY_IO_FAILED; } // // If we get here, we have recovered the hive, and // written it out to disk correctly. So we clear // the log here. // RtlClearAllBits(&(Hive->DirtyVector)); Hive->DirtyCount = 0; (Hive->FileSetSize)(Hive, HFILE_TYPE_LOG, 0); Hive->LogSize = 0; } // // slam debug name data into base block // HvpFillFileName(Hive->BaseBlock, FileName); // debug - only HvpDumpFreeDisplay(Hive); return STATUS_SUCCESS; } return STATUS_INVALID_PARAMETER; }

BOOLEAN HvIsBinDirty (  IN PHHIVE  Hive, IN HCELL_INDEX  Cell )

Definition at line 200 of file hivesync.c. References ASSERT, Bin, _HMAP_ENTRY::BinAddress, Cell, CML_MINOR, CMLOG, CMS_IO, _HHIVE::DirtyVector, FALSE, _HBIN::FileOffset, HHIVE_SIGNATURE, Hive, HIVE_VOLATILE, _HHIVE::HiveFlags, HMAP_BASE, HSECTOR_SIZE, HvGetCellType, HvpGetCellMap(), _HHIVE::ReadOnly, _HHIVE::Signature, _HBIN::Size, TRUE, VALIDATE_CELL_MAP, and Volatile. : Given a hive and a cell, checks whether the bin containing that cell has any dirty clusters or not. Arguments: Hive - Supplies a pointer to the hive control structure Cell - Supplies the HCELL_INDEX of the Cell. Return Value: TRUE - Bin contains dirty data. FALSE - Bin does not contain dirty data. --*/ { ULONG Type; PHCELL pcell; PRTL_BITMAP Bitmap; ULONG First; ULONG Last; ULONG i; PHMAP_ENTRY Map; PHBIN Bin; CMLOG(CML_MINOR, CMS_IO) { KdPrint(("HvIsBinDirty:\n\t")); KdPrint(("Hive:%08lx Cell:%08lx\n", Hive, Cell)); } ASSERT(Hive->Signature == HHIVE_SIGNATURE); ASSERT(Hive->ReadOnly == FALSE); Type = HvGetCellType(Cell); if ( (Hive->HiveFlags & HIVE_VOLATILE) || (Type == Volatile) ) { return FALSE; } Bitmap = &(Hive->DirtyVector); Map = HvpGetCellMap(Hive, Cell); VALIDATE_CELL_MAP(__LINE__,Map,Hive,Cell); Bin = (PHBIN)(Map->BinAddress & HMAP_BASE); First = Bin->FileOffset / HSECTOR_SIZE; Last = (Bin->FileOffset + Bin->Size - 1) / HSECTOR_SIZE; for (i=First; i<=Last; i++) { if (RtlCheckBit(Bitmap, i)==1) { return(TRUE); } } return(FALSE); }

BOOLEAN HvIsCellAllocated (  PHHIVE  Hive, HCELL_INDEX  Cell )

Definition at line 1453 of file hivecell.c. References ASSERT, Bin, _HMAP_ENTRY::BinAddress, Cell, FALSE, _HHIVE::Flat, HBIN_NIL, HCELL_PAD, HCELL_TYPE_MASK, HHIVE_SIGNATURE, Hive, HMAP_BASE, HvGetCellType, HvpGetCellMap(), HvpGetHCell, NULL, Offset, _HHIVE::Signature, Size, _HCELL::Size, _HBIN::Size, TRUE, _HCELL::u, and USE_OLD_CELL. Referenced by CmpCheckKey(), CmpCheckValueList(), CmpFindSubKeyByName(), CmpMarkIndexDirty(), CmpRemoveSubKey(), and CmpValidateHiveSecurityDescriptors(). 01464 : 01465 01466 Report whether the requested cell is allocated or not. 01467 01468 Arguments: 01469 01470 Hive - containing Hive. 01471 01472 Cell - cel of interest 01473 01474 Return Value: 01475 01476 TRUE if allocated, FALSE if not. 01477 01478 --*/ 01479 { 01480 ULONG Type; 01481 PHCELL Address; 01482 PHCELL Below; 01483 PHMAP_ENTRY Me; 01484 PHBIN Bin; 01485 ULONG Offset; 01486 LONG Size; 01487 01488 01489 ASSERT(Hive->Signature == HHIVE_SIGNATURE); 01490 01491 if (Hive->Flat == TRUE) { 01492 return TRUE; 01493 } 01494 01495 Type = HvGetCellType(Cell); 01496 01497 if ( ((Cell & ~HCELL_TYPE_MASK) > Hive->Storage[Type].Length) || // off end 01498 (Cell % HCELL_PAD(Hive) != 0) // wrong alignment 01499 ) 01500 { 01501 return FALSE; 01502 } 01503 01504 Address = HvpGetHCell(Hive, Cell); 01505 Me = HvpGetCellMap(Hive, Cell); 01506 if (Me == NULL) { 01507 return FALSE; 01508 } 01509 Bin = (PHBIN)((ULONG_PTR)(Me->BinAddress) & HMAP_BASE); 01510 Offset = (ULONG)((ULONG_PTR)Address - (ULONG_PTR)Bin); 01511 Size = Address->Size * -1; 01512 01513 if ( (Address->Size > 0) || // not allocated 01514 ((Offset + (ULONG)Size) > Bin->Size) || // runs off bin, or too big 01515 (Offset < sizeof(HBIN)) // pts into bin header 01516 ) 01517 { 01518 return FALSE; 01519 } 01520 01521 if (USE_OLD_CELL(Hive)) { 01522 if (Address->u.OldCell.Last != HBIN_NIL) { 01523 01524 if (Address->u.OldCell.Last > Bin->Size) { // bogus back pointer 01525 return FALSE; 01526 } 01527 01528 Below = (PHCELL)((PUCHAR)Bin + Address->u.OldCell.Last); 01529 Size = (Below->Size < 0) ? 01530 Below->Size * -1 : 01531 Below->Size; 01532 01533 if ( ((ULONG_PTR)Below + Size) != (ULONG_PTR)Address ) { // no pt back 01534 return FALSE; 01535 } 01536 } }

NTSTATUS HvLoadHive (  PHHIVE  Hive, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 100 of file hiveload.c. References ASSERT, _HHIVE::BaseBlock, _HHIVE::DirtyCount, Fail, FALSE, _HHIVE::Free, HFILE_TYPE_PRIMARY, HHIVE_SIGNATURE, Hive, HvpCleanMap(), HvpFreeAllocatedBins(), HvpGetHiveHeader(), HvpGetLogHeader(), HvpReadFileImageAndBuildMap(), HvpRecoverData(), _HBASE_BLOCK::Length, _HHIVE::Log, _HBASE_BLOCK::Minor, NoMemory, NotHive, NT_SUCCESS, NTSTATUS(), NULL, _HHIVE::ReadOnly, RecoverData, RecoverHeader, _HBASE_BLOCK::Sequence1, _HBASE_BLOCK::Sequence2, _HHIVE::Signature, TRUE, _HBASE_BLOCK::Type, and _HHIVE::Version. Referenced by HvInitializeHive(). : Hive must be fully initialized, in particular, file handles must be set up. This routine is not intended for loading hives from images already in memory. This routine will apply whatever fixes are available for errors in the hive image. In particular, if a log exists, and is applicable, this routine will automatically apply it. ALGORITHM: call HvpGetHiveHeader() if (NoMemory or NoHive) return failure if (RecoverData or RecoverHeader) and (no log) return falure if (RecoverHeader) call HvpGetLogHeader if (fail) return failure fix up baseblock Read Data if (RecoverData or RecoverHeader) HvpRecoverData return STATUS_REGISTRY_RECOVERED clean up sequence numbers return success OR STATUS_REGISTRY_RECOVERED If STATUS_REGISTRY_RECOVERED is returned, then If (Log) was used, DirtyVector and DirtyCount are set, caller is expected to flush the changes (using a NEW log file) Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest TailDisplay - array containing the tail ends of the free cell lists - optional Return Value: STATUS: STATUS_INSUFFICIENT_RESOURCES - memory alloc failure, etc STATUS_NOT_REGISTRY_FILE - bad signatures and the like STATUS_REGISTRY_CORRUPT - bad signatures in the log, bad stuff in both in alternate, inconsistent log STATUS_REGISTRY_IO_FAILED - data read failed STATUS_RECOVERED - successfully recovered the hive, a semi-flush of logged data is necessary. STATUS_SUCCESS - it worked, no recovery needed --*/ { PHBASE_BLOCK BaseBlock; ULONG result1; ULONG result2; NTSTATUS status; LARGE_INTEGER TimeStamp; ULONG FileOffset; PHBIN pbin; BOOLEAN ReadOnlyFlagCopy; ASSERT(Hive->Signature == HHIVE_SIGNATURE); BaseBlock = NULL; result1 = HvpGetHiveHeader(Hive, &BaseBlock, &TimeStamp); // // bomb out for total errors // if (result1 == NoMemory) { status = STATUS_INSUFFICIENT_RESOURCES; goto Exit1; } if (result1 == NotHive) { status = STATUS_NOT_REGISTRY_FILE; goto Exit1; } ReadOnlyFlagCopy = Hive->ReadOnly; // // if recovery needed, and no log, bomb out // if ( ((result1 == RecoverData) || (result1 == RecoverHeader)) ) { // // recovery needed // if(Hive->Log == FALSE) { // // no log ==> bomb out // status = STATUS_REGISTRY_CORRUPT; goto Exit1; } else { // // TRICK: simulate hive as read-only; Free cells will not // be enlisted in HvpReadFileImageAndBuildMap; Instead, they // will be enlisted in HvpRecoverData, when we are sure we have // the right info loaded up into memory // Hive->ReadOnly = TRUE; } } // // need to recover header using log, so try to get it from log // if (result1 == RecoverHeader) { result2 = HvpGetLogHeader(Hive, &BaseBlock, &TimeStamp); if (result2 == NoMemory) { status = STATUS_INSUFFICIENT_RESOURCES; goto Exit1; } if (result2 == Fail) { status = STATUS_REGISTRY_CORRUPT; goto Exit1; } BaseBlock->Type = HFILE_TYPE_PRIMARY; } Hive->BaseBlock = BaseBlock; Hive->Version = Hive->BaseBlock->Minor; // // at this point, we have a sane baseblock. we may or may not still // need to apply data recovery // status = HvpReadFileImageAndBuildMap(Hive,BaseBlock->Length,TailDisplay); // // if STATUS_REGISTRY_CORRUPT and RecoverData don't bail out, keep recovering // if( !NT_SUCCESS(status) && ((status != STATUS_REGISTRY_CORRUPT) || (result1 != RecoverData)) ) { goto Exit2; } // // apply data recovery if we need it // status = STATUS_SUCCESS; if ( (result1 == RecoverHeader) || // -> implies recover data (result1 == RecoverData) ) { // // recover data will enllist the free cells as well and // will restore the original read-only state of the hive // result2 = HvpRecoverData(Hive,ReadOnlyFlagCopy,TailDisplay); if (result2 == NoMemory) { status = STATUS_INSUFFICIENT_RESOURCES; goto Exit2; } if (result2 == Fail) { status = STATUS_REGISTRY_CORRUPT; goto Exit2; } status = STATUS_REGISTRY_RECOVERED; } BaseBlock->Sequence2 = BaseBlock->Sequence1; return status; Exit2: // // Clean up the bins already allocated // HvpFreeAllocatedBins( Hive ); // // Clean up the directory table // HvpCleanMap( Hive ); Exit1: if (BaseBlock != NULL) { (Hive->Free)(BaseBlock, sizeof(HBASE_BLOCK)); } Hive->BaseBlock = NULL; Hive->DirtyCount = 0; return status; }

BOOLEAN HvMarkCellDirty (  PHHIVE  Hive, HCELL_INDEX  Cell )

Definition at line 117 of file hivesync.c. References ASSERT, Bin, _HMAP_ENTRY::BinAddress, Cell, CML_MINOR, CMLOG, CMS_IO, _HHIVE::DirtyCount, _HHIVE::DirtyVector, FALSE, _HBIN::FileOffset, HBIN_SIGNATURE, HCELL_INDEX, HHIVE_SIGNATURE, Hive, HIVE_VOLATILE, _HHIVE::HiveFlags, HMAP_BASE, HvGetCellType, HvMarkDirty(), HvpGetCellMap(), HvpGetHCell, _HHIVE::ReadOnly, RtlNumberOfSetBits(), _HHIVE::Signature, _HBIN::Signature, Size, _HBIN::Size, _HCELL::Size, TRUE, USE_OLD_CELL, VALIDATE_CELL_MAP, and Volatile. Referenced by CmDeleteValueKey(), CmpAddToLeaf(), CmpAssignSecurityDescriptor(), CmpCheckKey(), CmpDoCreate(), CmpInsertSecurityCellList(), CmpMarkIndexDirty(), CmpMarkKeyDirty(), CmpMarkKeyParentDirty(), CmpMarkKeyValuesDirty(), CmpSelectLeaf(), CmpSetSecurityDescriptorInfo(), CmpSetValueKeyExisting(), CmpSetValueKeyNew(), CmpSplitLeaf(), CmSetLastWriteTimeKey(), and CmSetValueKey(). : Marks the data for the specified cell dirty. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest Cell - hcell_index of cell that is being edited Return Value: TRUE - it worked FALSE - could not allocate log space, failure! --*/ { ULONG Type; ULONG Size; PHCELL pCell; PHMAP_ENTRY Me; HCELL_INDEX Base; PHBIN Bin; CMLOG(CML_MINOR, CMS_IO) { KdPrint(("HvMarkCellDirty:\n\t")); KdPrint(("Hive:%08lx Cell:%08lx\n", Hive, Cell)); } ASSERT(Hive->Signature == HHIVE_SIGNATURE); ASSERT(Hive->ReadOnly == FALSE); ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); Type = HvGetCellType(Cell); if ( (Hive->HiveFlags & HIVE_VOLATILE) || (Type == Volatile) ) { return TRUE; } pCell = HvpGetHCell(Hive,Cell); #if DBG Me = HvpGetCellMap(Hive, Cell); VALIDATE_CELL_MAP(__LINE__,Me,Hive,Cell); Bin = (PHBIN)(Me->BinAddress & HMAP_BASE); ASSERT(Bin->Signature == HBIN_SIGNATURE); #endif // // If it's an old format hive, mark the entire // bin dirty, because the Last backpointers are // such a pain to deal with in the partial // alloc and free-coalescing cases. // if (USE_OLD_CELL(Hive)) { Me = HvpGetCellMap(Hive, Cell); VALIDATE_CELL_MAP(__LINE__,Me,Hive,Cell); Bin = (PHBIN)(Me->BinAddress & HMAP_BASE); Base = Bin->FileOffset; Size = Bin->Size; return HvMarkDirty(Hive, Base, Size); } else { if (pCell->Size < 0) { Size = -pCell->Size; } else { Size = pCell->Size; } ASSERT(Size < Bin->Size); return HvMarkDirty(Hive, Cell-FIELD_OFFSET(HCELL,u.NewCell), Size); } }

BOOLEAN HvMarkClean (  PHHIVE  Hive, HCELL_INDEX  Start, ULONG  Length )

Definition at line 401 of file hivesync.c. References ASSERT, BitMap, _HHIVE::Cluster, CML_MINOR, CMLOG, CMS_IO, _HHIVE::DirtyCount, _HHIVE::DirtyVector, FALSE, HHIVE_SIGNATURE, Hive, HIVE_VOLATILE, _HHIVE::HiveFlags, HSECTOR_SIZE, HvGetCellType, _HHIVE::ReadOnly, ROUND_UP, RtlClearBits(), RtlNumberOfSetBits(), _HHIVE::Signature, Start, TRUE, and Volatile. Referenced by HvpAddBin(). : Clears the dirty bits for a given portion of a hive. This is the inverse of HvMarkDirty, although it does not give up any file space in the primary or log that HvMarkDirty may have reserved. This is a noop for Volatile address range. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest Start - supplies a hive virtual address (i.e., an HCELL_INDEX or like form address) of the start of the area to mark dirty. Length - inclusive length in bytes of area to mark dirty. Return Value: TRUE - it worked --*/ { ULONG Type; PRTL_BITMAP BitMap; ULONG First; ULONG Last; ULONG i; ULONG Cluster; CMLOG(CML_MINOR, CMS_IO) { KdPrint(("HvMarkClean:\n\t")); KdPrint(("Hive:%08lx Start:%08lx Length:%08lx\n", Hive, Start, Length)); } ASSERT(Hive->Signature == HHIVE_SIGNATURE); ASSERT(Hive->ReadOnly == FALSE); ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); Type = HvGetCellType(Start); if ( (Hive->HiveFlags & HIVE_VOLATILE) || (Type == Volatile) ) { return TRUE; } BitMap = &(Hive->DirtyVector); First = Start / HSECTOR_SIZE; Last = (Start + Length - 1) / HSECTOR_SIZE; Cluster = Hive->Cluster; if (Cluster > 1) { // // Force Start down to base of cluster // Force End up to top of cluster // First = First & ~(Cluster - 1); Last = ROUND_UP(Last+1, Cluster) - 1; } if (Last >= BitMap->SizeOfBitMap) { Last = BitMap->SizeOfBitMap-1; } // // Subtract out the dirty count and // and clear the dirty bits. // for (i=First; i<=Last; i++) { if (RtlCheckBit(BitMap,i)==1) { --Hive->DirtyCount; RtlClearBits(BitMap, i, 1); } } ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); return(TRUE); }

BOOLEAN HvMarkDirty (  PHHIVE  Hive, HCELL_INDEX  Start, ULONG  Length )

Definition at line 270 of file hivesync.c. References ASSERT, BitMap, _HHIVE::Cluster, CML_MINOR, CMLOG, CmpLazyFlush(), CMS_IO, _HHIVE::DirtyCount, _HHIVE::DirtyVector, FALSE, HHIVE_SIGNATURE, Hive, HIVE_NOLAZYFLUSH, HIVE_VOLATILE, _HHIVE::HiveFlags, HSECTOR_SIZE, HvGetCellType, HvpGrowLog1(), HvpMarkBinReadWrite, _HHIVE::ReadOnly, ROUND_UP, RtlNumberOfSetBits(), RtlSetBits(), _HHIVE::Signature, Start, TRUE, and Volatile. Referenced by HvMarkCellDirty(), HvpAddBin(), and HvpRecoverData(). : Marks the relevent parts of a hive dirty, so that they will be flushed to backing store. If Hive->Cluster is not 1, then adjacent all logical sectors in the given cluster will be forced dirty (and log space allocated for them.) This must be done here rather than in HvSyncHive so that we can know how much to grow the log. This is a noop for Volatile address range. NOTE: Range will not be marked dirty if operation fails. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest Start - supplies a hive virtual address (i.e., an HCELL_INDEX or like form address) of the start of the area to mark dirty. Length - inclusive length in bytes of area to mark dirty. Return Value: TRUE - it worked FALSE - could not allocate log space, failure! --*/ { ULONG Type; PRTL_BITMAP BitMap; ULONG First; ULONG Last; ULONG i; ULONG Cluster; ULONG OriginalDirtyCount; ULONG DirtySectors; BOOLEAN Result = TRUE; CMLOG(CML_MINOR, CMS_IO) { KdPrint(("HvMarkDirty:\n\t")); KdPrint(("Hive:%08lx Start:%08lx Length:%08lx\n", Hive, Start, Length)); } ASSERT(Hive->Signature == HHIVE_SIGNATURE); ASSERT(Hive->ReadOnly == FALSE); ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); Type = HvGetCellType(Start); if ( (Hive->HiveFlags & HIVE_VOLATILE) || (Type == Volatile) ) { return TRUE; } BitMap = &(Hive->DirtyVector); OriginalDirtyCount = Hive->DirtyCount; First = Start / HSECTOR_SIZE; Last = (Start + Length - 1) / HSECTOR_SIZE; Cluster = Hive->Cluster; if (Cluster > 1) { // // Force Start down to base of cluster // Force End up to top of cluster // First = First & ~(Cluster - 1); Last = ROUND_UP(Last+1, Cluster) - 1; } if (Last >= BitMap->SizeOfBitMap) { Last = BitMap->SizeOfBitMap-1; } // // Try and grow the log enough to accomodate all the dirty sectors. // DirtySectors = 0; for (i = First; i <= Last; i++) { if (RtlCheckBit(BitMap, i)==0) { ++DirtySectors; } } if (DirtySectors != 0) { if (HvpGrowLog1(Hive, DirtySectors) == FALSE) { return(FALSE); } if ((OriginalDirtyCount == 0) && (First != 0)) { Result = HvMarkDirty(Hive, 0, sizeof(HBIN)); // force header of 1st bin dirty if (Result==FALSE) { return(FALSE); } } // // Log has been successfully grown, go ahead // and set the dirty bits. // ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); Hive->DirtyCount += DirtySectors; RtlSetBits(BitMap, First, Last-First+1); } // mark this bin as writable HvpMarkBinReadWrite(Hive,Start); if (!(Hive->HiveFlags & HIVE_NOLAZYFLUSH)) { CmpLazyFlush(); } ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); return(TRUE); }

PHBIN HvpAddBin (  PHHIVE  Hive, ULONG  NewSize, HSTORAGE_TYPE  Type )

BOOLEAN HvpAllocateMap (  PHHIVE  Hive, PHMAP_DIRECTORY  Dir, ULONG  Start, ULONG  End )

Definition at line 853 of file hivemap.c. References _HHIVE::Allocate, ASSERT, _HMAP_DIRECTORY::Directory, End, FALSE, Hive, NULL, Start, t(), and TRUE. Referenced by HvpAddBin(), HvpBuildMapAndCopy(), and HvpInitMap(). 00861 : 00862 00863 Sweeps through the directory Dir points to and allocates Tables. 00864 Will allocate Start-th through End-th entries, INCLUSIVE. 00865 00866 Does NOT clean up when out of memory, call HvpFreeMap to do that. 00867 Arguments: 00868 00869 Hive - supplies pointer to hive control block of interest 00870 00871 Dir - supplies address of an HMAP_DIRECTORY structure 00872 00873 Start - index of first map table pointer to allocate for 00874 00875 End - index of last map table pointer to allocate for 00876 00877 Return Value: 00878 00879 TRUE - it worked 00880 00881 FALSE - insufficient memory 00882 00883 --*/ 00884 { 00885 ULONG i; 00886 PVOID t; 00887 00888 for (i = Start; i <= End; i++) { 00889 ASSERT(Dir->Directory[i] == NULL); 00890 t = (PVOID)((Hive->Allocate)(sizeof(HMAP_TABLE), FALSE)); 00891 if (t == NULL) { 00892 return FALSE; 00893 } 00894 RtlZeroMemory(t, sizeof(HMAP_TABLE)); 00895 Dir->Directory[i] = (PHMAP_TABLE)t; 00896 } 00897 return TRUE; 00898 } }

NTSTATUS HvpBuildMap (  PHHIVE  Hive, PVOID  Image, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 536 of file hivemap.c. References Bin, CML_FLOW, CMLOG, CMS_HIVE, ErrorExit(), _HBIN::FileOffset, HBIN_SIGNATURE, HBLOCK_SIZE, Hive, HvCheckHiveDebug, HvpCleanMap(), HvpEnlistBinInMap(), HvpInitMap(), NT_SUCCESS, NTSTATUS(), Offset, _HBIN::Signature, _HBIN::Size, Stable, and Status. Referenced by HvInitializeHive(). : Creates the map for the Stable storage of the hive, and inits the map for the volatile storage. Following fields in hive must already be filled in: Allocate, Free Will initialize Storage structure of HHIVE. Arguments: Hive - Pointer to hive control structure to build map for. Image - pointer to in memory image of the hive Return Value: TRUE - it worked FALSE - either hive is corrupt or no memory for map --*/ { PHBIN Bin; ULONG Offset; NTSTATUS Status; ULONG Length; CMLOG(CML_FLOW, CMS_HIVE) { KdPrint(("HvpBuildMap:\n")); KdPrint(("\tHive=%08lx",Hive)); } // // Init the map // Status = HvpInitMap(Hive); if( !NT_SUCCESS(Status) ) { // // just return failure; HvpInitMap took care of cleanup // return Status; } // // Fill in the map // Offset = 0; Bin = (PHBIN)Image; Length = Hive->Storage[Stable].Length; while (Bin < (PHBIN)((PUCHAR)(Image) + Length)) { // // Check the validity of the bin header // if ( (Bin->Size > Length) || (Bin->Size < HBLOCK_SIZE) || (Bin->Signature != HBIN_SIGNATURE) || (Bin->FileOffset != Offset)) { // // Bin is bogus // Status = STATUS_REGISTRY_CORRUPT; HvCheckHiveDebug.Hive = Hive; HvCheckHiveDebug.Status = 0xA001; HvCheckHiveDebug.Space = Length; HvCheckHiveDebug.MapPoint = Offset; HvCheckHiveDebug.BinPoint = Bin; goto ErrorExit; } // // enlist this bin // Status = HvpEnlistBinInMap(Hive, Length, Bin, Offset, TailDisplay); if( !NT_SUCCESS(Status) ) { goto ErrorExit; } // // the next bin // Offset += Bin->Size; Bin = (PHBIN)((ULONG_PTR)Bin + Bin->Size); } return STATUS_SUCCESS; ErrorExit: // // Clean up the directory table // HvpCleanMap( Hive ); return Status; }

NTSTATUS HvpBuildMapAndCopy (  PHHIVE  Hive, PVOID  Image, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 47 of file hivemap.c. References _HHIVE::Allocate, _HHIVE::BaseBlock, Bin, _HMAP_ENTRY::BinAddress, _HMAP_ENTRY::BlockAddress, CML_FLOW, CMLOG, CMS_HIVE, _HHIVE::DirtyAlloc, _HHIVE::DirtyVector, FALSE, _HBIN::FileOffset, _HHIVE::Free, HBIN_SIGNATURE, HBLOCK_SIZE, Hive, HMAP_NEWALLOC, HSECTOR_SIZE, HTABLE_SLOTS, HvpAllocateMap(), HvpEnlistFreeCells(), HvpFreeMap(), HvpGetCellMap(), _HBASE_BLOCK::Length, _HBIN::MemAlloc, NTSTATUS(), NULL, Offset, PAGE_SIZE, _HHIVE::ReadOnly, ROUND_UP, RtlInitializeBitMap(), _HBIN::Signature, Size, _HBIN::Size, Stable, Status, t(), TRUE, and VALIDATE_CELL_MAP. Referenced by HvInitializeHive(). : Creates the map for the Stable storage of the hive, and inits the map for the volatile storage. Following fields in hive must already be filled in: Allocate, Free Will initialize Storage structure of HHIVE. The difference between this routine and HvpBuildMapAndCopy is that this routine will create a "sparse" map. As it copies the SourceImage to the newly allocated memory for the destination, it will avoid allocating space for HBINs that contain nothing but free space. The HBLOCKs in these HBINs will be marked as discarded, and HvGetCell will allocate memory for them if necessary. Arguments: Hive - Pointer to hive control structure to build map for. Image - pointer to flat memory image of original hive. Return Value: TRUE - it worked FALSE - either hive is corrupt or no memory for map --*/ { PHBASE_BLOCK BaseBlock; ULONG Length; ULONG MapSlots; ULONG Tables; PHMAP_TABLE t = NULL; PHMAP_DIRECTORY d = NULL; PHBIN Bin; PHBIN NewBins; PHBIN CurrentBin; ULONG Offset; ULONG_PTR Address; PHMAP_ENTRY Me; NTSTATUS Status; PULONG Vector; ULONG Size; CMLOG(CML_FLOW, CMS_HIVE) { KdPrint(("HvpBuildMap:\n")); KdPrint(("\tHive=%08lx",Hive)); } // // Compute size of data region to be mapped // BaseBlock = Hive->BaseBlock; Length = BaseBlock->Length; if ((Length % HBLOCK_SIZE) != 0 ) { Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit1; } MapSlots = Length / HBLOCK_SIZE; if( MapSlots > 0 ) { Tables = (MapSlots-1) / HTABLE_SLOTS; } else { Tables = 0; } Hive->Storage[Stable].Length = Length; // // allocate dirty vector if one is not already present (from HvpRecoverData) // if (Hive->DirtyVector.Buffer == NULL) { Vector = (PULONG)((Hive->Allocate)(ROUND_UP(Length/HSECTOR_SIZE/8,sizeof(ULONG)), TRUE)); if (Vector == NULL) { Status = STATUS_NO_MEMORY; goto ErrorExit1; } RtlZeroMemory(Vector, Length / HSECTOR_SIZE / 8); RtlInitializeBitMap(&Hive->DirtyVector, Vector, Length / HSECTOR_SIZE); Hive->DirtyAlloc = (Length/HSECTOR_SIZE/8); } // // allocate and build structure for map // if (Tables == 0) { // // Just 1 table, no need for directory // t = (Hive->Allocate)(sizeof(HMAP_TABLE), FALSE); if (t == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit1; } RtlZeroMemory(t, sizeof(HMAP_TABLE)); Hive->Storage[Stable].Map = (PHMAP_DIRECTORY)&(Hive->Storage[Stable].SmallDir); Hive->Storage[Stable].SmallDir = t; } else { // // Need directory and multiple tables // d = (PHMAP_DIRECTORY)(Hive->Allocate)(sizeof(HMAP_DIRECTORY), FALSE); if (d == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit1; } RtlZeroMemory(d, sizeof(HMAP_DIRECTORY)); // // Allocate tables and fill in dir // if (HvpAllocateMap(Hive, d, 0, Tables) == FALSE) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit2; } Hive->Storage[Stable].Map = d; Hive->Storage[Stable].SmallDir = 0; } // // Now we have to allocate the memory for the HBINs and fill in // the map appropriately. We are careful never to allocate less // than a page to avoid fragmenting pool. As long as the page // size is a multiple of HBLOCK_SIZE (a fairly good assumption as // long as HBLOCK_SIZE is 4k) this strategy will prevent pool // fragmentation. // // If we come across an HBIN that is entirely composed of a freed // HCELL, then we do not allocate memory, but mark its HBLOCKs in // the map as not present. HvAllocateCell will allocate memory for // the bin when it is needed. // Offset = 0; Size = 0; Bin = (PHBIN)Image; while (Bin < (PHBIN)((PUCHAR)(Image) + Length)) { if ( (Bin->Size > (Length-Offset)) || (Bin->Signature != HBIN_SIGNATURE) || (Bin->FileOffset != (Offset+Size)) ) { // // Bin is bogus // Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit2; } Size += Bin->Size; if ((Size < PAGE_SIZE) && (Size + Length - Offset > PAGE_SIZE)) { // // We haven't accumulated enough bins to fill up a page // yet, and there are still bins left, so group this one // in with the next one. // Bin = (PHBIN)((ULONG_PTR)Bin + Bin->Size); continue; } // // We now have a series of HBINs to group together in one // chunk of memory. // NewBins = (PHBIN)(Hive->Allocate)(Size, FALSE); if (NewBins==NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit2; //fixfix } RtlCopyMemory(NewBins, (PUCHAR)Image+Offset, Size); NewBins->MemAlloc = Size; // // create map entries for each block/page in bin // Address = (ULONG_PTR)NewBins; do { CurrentBin = (PHBIN)Address; do { Me = HvpGetCellMap(Hive, Offset); VALIDATE_CELL_MAP(__LINE__,Me,Hive,Offset); Me->BlockAddress = Address; Me->BinAddress = (ULONG_PTR)CurrentBin; if (CurrentBin == NewBins) { Me->BinAddress |= HMAP_NEWALLOC; } else { CurrentBin->MemAlloc = 0; } Address += HBLOCK_SIZE; Offset += HBLOCK_SIZE; } while ( Address < ((ULONG_PTR)CurrentBin + CurrentBin->Size )); if (Hive->ReadOnly == FALSE) { // // add free cells in the bin to the appropriate free lists // if ( ! HvpEnlistFreeCells(Hive, CurrentBin, CurrentBin->FileOffset, TailDisplay )) { Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit2; } } } while ( Address < (ULONG_PTR)NewBins + Size ); Bin = (PHBIN)((ULONG_PTR)Bin + Bin->Size); Size = 0; } return STATUS_SUCCESS; ErrorExit2: if (d != NULL) { // // directory was built and allocated, so clean it up // HvpFreeMap(Hive, d, 0, Tables); (Hive->Free)(d, sizeof(HMAP_DIRECTORY)); } ErrorExit1: return Status; }

VOID HvpCleanMap (  PHHIVE  Hive  )

Definition at line 751 of file hivemap.c. References _HHIVE::Free, HBLOCK_SIZE, Hive, HTABLE_SLOTS, HvpFreeMap(), NULL, and Stable. Referenced by HvLoadHive(), HvpBuildMap(), and HvpReadFileImageAndBuildMap(). : Cleans all the map allocations for the stable storage Arguments: Hive - Pointer to hive control structure to build map for. Return Value: None --*/ { ULONG Length; ULONG MapSlots; ULONG Tables; PHMAP_DIRECTORY d = NULL; // // Compute MapSlots and Tables based on the Length // Length = Hive->Storage[Stable].Length; MapSlots = Length / HBLOCK_SIZE; if( MapSlots > 0 ) { Tables = (MapSlots-1) / HTABLE_SLOTS; } else { Tables = 0; } if( Hive->Storage[Stable].SmallDir == 0 ) { // // directory was built and allocated, so clean it up // d = Hive->Storage[Stable].Map; if( d != NULL ) { HvpFreeMap(Hive, d, 0, Tables); (Hive->Free)(d, sizeof(HMAP_DIRECTORY)); } } else { // // no directory, just a smalldir // (Hive->Free)(Hive->Storage[Stable].SmallDir, sizeof(HMAP_TABLE)); } Hive->Storage[Stable].SmallDir = NULL; Hive->Storage[Stable].Map = NULL; }

VOID HvpDelistFreeCell (  PHHIVE  Hive, PHCELL  Pcell, HSTORAGE_TYPE  Type, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 1203 of file hivecell.c. 01216 : 01217 01218 Removes a free cell from its list, and clears the Summary 01219 bit for it if need be. 01220 01221 Arguments: 01222 01223 Hive - supplies a pointer to the hive control structure for the 01224 hive of interest 01225 01226 Pcell - supplies a pointer to the HCELL structure of interest 01227 01228 Type - Stable vs. Volatile 01229 01230 Return Value: 01231 01232 NONE. 01233 01234 --*/ 01235 { 01236 PHCELL_INDEX List; 01237 HCELL_INDEX Prev = HCELL_NIL; 01238 ULONG Index; 01239 01240 HvpComputeIndex(Index, Pcell->Size); 01241 List = &(Hive->Storage[Type].FreeDisplay[Index]); 01242 01243 // 01244 // Find previous cell on list 01245 // 01246 ASSERT(*List != HCELL_NIL); 01247 while (HvpGetHCell(Hive,*List) != Pcell) { 01248 Prev = *List; 01249 List = (PHCELL_INDEX)HvGetCell(Hive,*List); 01250 ASSERT(*List != HCELL_NIL); 01251 } 01252 01253 if (ARGUMENT_PRESENT(TailDisplay)) { 01254 // 01255 // This should only happen once, at boot time; Then, we want to sort the list ascedending 01256 // 01257 if( *List == TailDisplay[Index] ) { 01258 // 01259 // this cell is also the last cell on list; so it should be reset 01260 // 01261 01262 #if DBG 01263 // 01264 // consistency checks 01265 // 01266 if (USE_OLD_CELL(Hive)) { 01267 ASSERT(Pcell->u.OldCell.u.Next == HCELL_NIL); 01268 } else { 01269 ASSERT(Pcell->u.NewCell.u.Next == HCELL_NIL); 01270 } 01271 #endif 01272 01273 TailDisplay[Index] = Prev; 01274 } 01275 } 01276 01277 // 01278 // Remove Pcell from list. 01279 // 01280 if (USE_OLD_CELL(Hive)) { 01281 *List = Pcell->u.OldCell.u.Next; 01282 } else { 01283 *List = Pcell->u.NewCell.u.Next; 01284 } 01285 01286 if (Hive->Storage[Type].FreeDisplay[Index] == HCELL_NIL) { 01287 // 01288 // consistency check 01289 // 01290 ASSERT(Prev == HCELL_NIL); 01291 Hive->Storage[Type].FreeSummary &= ~(1 << Index);

BOOLEAN HvpDoWriteHive (  PHHIVE  Hive, ULONG  FileType )

Definition at line 775 of file hivesync.c. References ASSERT, _HHIVE::BaseBlock, Bin, BitMap, _HMAP_ENTRY::BlockAddress, _HBASE_BLOCK::CheckSum, _HBASE_BLOCK::Cluster, _HHIVE::Cluster, CML_MINOR, CMLOG, CmpDoFileSetSize(), CMS_IO, Count, CMP_OFFSET_ARRAY::DataBuffer, CMP_OFFSET_ARRAY::DataLength, _HHIVE::DirtyVector, ExAllocatePool, ExFreePool(), FALSE, _HHIVE::FileFlush, CMP_OFFSET_ARRAY::FileOffset, _HHIVE::FileWrite, _HBASE_BLOCK::Format, HBASE_BLOCK_SIGNATURE, HBASE_FORMAT_MEMORY, HBLOCK_SIZE, HFILE_TYPE_LOG, HFILE_TYPE_PRIMARY, Hive, HLOG_MINSIZE, HSECTOR_SIZE, HSYS_MAJOR, HvpFindNextDirtyBlock(), HvpGetCellMap(), HvpHeaderCheckSum(), _HBASE_BLOCK::Length, _HHIVE::Log, _HHIVE::LogSize, _HBASE_BLOCK::Major, NULL, Offset, PagedPool, PCMP_OFFSET_ARRAY, _HHIVE::ReadOnly, ROUND_UP, RtlNumberOfSetBits(), _HBASE_BLOCK::Sequence1, _HBASE_BLOCK::Sequence2, _HBASE_BLOCK::Signature, Stable, _HBIN::TimeStamp, _HBASE_BLOCK::TimeStamp, TRUE, _HBASE_BLOCK::Type, and VALIDATE_CELL_MAP. Referenced by HvInitializeHive(), HvSyncHive(), and HvWriteHive(). : Write dirty parts of the hive out to either its primary or alternate file. Write the header, flush, write all data, flush, update header, flush. Assume either logging or primary/alternate pairs used. NOTE: TimeStamp is not set, assumption is that HvpWriteLog set that. It is only used for checking if Logs correspond anyway. Arguments: Hive - pointer to Hive for which dirty data is to be written. FileType - indicated whether primary or alternate file should be written. Return Value: TRUE - it worked FALSE - it failed --*/ { PHBASE_BLOCK BaseBlock; ULONG Offset; PUCHAR Address; ULONG Length; BOOLEAN rc; ULONG Current; PRTL_BITMAP BitMap; PHMAP_ENTRY Me; PHBIN Bin; BOOLEAN ShrinkHive; PCMP_OFFSET_ARRAY offsetArray; CMP_OFFSET_ARRAY offsetElement; ULONG Count; ULONG SetBitCount; CMLOG(CML_MINOR, CMS_IO) { KdPrint(("HvpDoWriteHive:\n\t")); KdPrint(("Hive:%08lx FileType:%08lx\n", Hive, FileType)); } // // flush first, so that the filesystem structures get written to // disk if we have grown the file. // if (!(Hive->FileFlush)(Hive, FileType)) { return(FALSE); } BaseBlock = Hive->BaseBlock; if (BaseBlock->Length > Hive->Storage[Stable].Length) { ShrinkHive = TRUE; } else { ShrinkHive = FALSE; } // // --- Write out header first time, flush --- // ASSERT(BaseBlock->Signature == HBASE_BLOCK_SIGNATURE); ASSERT(BaseBlock->Major == HSYS_MAJOR); ASSERT(BaseBlock->Format == HBASE_FORMAT_MEMORY); ASSERT(Hive->ReadOnly == FALSE); if (BaseBlock->Sequence1 != BaseBlock->Sequence2) { // // Some previous log attempt failed, or this hive needs to // be recovered, so punt. // return FALSE; } BaseBlock->Length = Hive->Storage[Stable].Length; BaseBlock->Sequence1++; BaseBlock->Type = HFILE_TYPE_PRIMARY; BaseBlock->Cluster = Hive->Cluster; BaseBlock->CheckSum = HvpHeaderCheckSum(BaseBlock); Offset = 0; offsetElement.FileOffset = Offset; offsetElement.DataBuffer = (PVOID) BaseBlock; offsetElement.DataLength = HSECTOR_SIZE * Hive->Cluster; rc = (Hive->FileWrite)( Hive, FileType, &offsetElement, 1, &Offset ); if (rc == FALSE) { return FALSE; } if ( ! (Hive->FileFlush)(Hive, FileType)) { return FALSE; } Offset = ROUND_UP(Offset, HBLOCK_SIZE); // // --- Write out dirty data (only if there is any) --- // if (Hive->DirtyVector.Buffer != NULL) { // // First sector of first bin will always be dirty, write it out // with the TimeStamp value overlaid on its Link field. // BitMap = &(Hive->DirtyVector); ASSERT(RtlCheckBit(BitMap, 0) == 1); ASSERT(RtlCheckBit(BitMap, (Hive->Cluster - 1)) == 1); ASSERT(sizeof(LIST_ENTRY) >= sizeof(LARGE_INTEGER)); Me = HvpGetCellMap(Hive, 0); VALIDATE_CELL_MAP(__LINE__,Me,Hive,0); Address = (PUCHAR)Me->BlockAddress; Length = Hive->Cluster * HSECTOR_SIZE; Bin = (PHBIN)Address; Bin->TimeStamp = BaseBlock->TimeStamp; offsetElement.FileOffset = Offset; offsetElement.DataBuffer = (PVOID) Address; offsetElement.DataLength = Length; rc = (Hive->FileWrite)( Hive, FileType, &offsetElement, 1, &Offset ); ASSERT((Offset % (Hive->Cluster * HSECTOR_SIZE)) == 0); if (rc == FALSE) { return FALSE; } // // Write out the rest of the dirty data // Current = Hive->Cluster; // don't rewrite 1st bin or header SetBitCount = RtlNumberOfSetBits(BitMap); offsetArray = (PCMP_OFFSET_ARRAY) ExAllocatePool(PagedPool, sizeof(CMP_OFFSET_ARRAY) * SetBitCount); if (offsetArray == NULL) { return FALSE; } Count = 0; while (HvpFindNextDirtyBlock( Hive, BitMap, &Current, &Address, &Length, &Offset ) == TRUE) { // Gather data into array. ASSERT(Count < SetBitCount); offsetArray[Count].FileOffset = Offset; offsetArray[Count].DataBuffer = Address; offsetArray[Count].DataLength = Length; Offset += Length; Count++; ASSERT((Offset % (Hive->Cluster * HSECTOR_SIZE)) == 0); } rc = (Hive->FileWrite)( Hive, FileType, offsetArray, Count, &Offset // Just an OUT parameter which returns the point // in the file after the last write. ); ExFreePool(offsetArray); if (rc == FALSE) { return FALSE; } } if ( ! (Hive->FileFlush)(Hive, FileType)) { return FALSE; } // // --- Write header again to report completion --- // BaseBlock->Sequence2++; BaseBlock->CheckSum = HvpHeaderCheckSum(BaseBlock); Offset = 0; offsetElement.FileOffset = Offset; offsetElement.DataBuffer = (PVOID) BaseBlock; offsetElement.DataLength = HSECTOR_SIZE * Hive->Cluster; rc = (Hive->FileWrite)( Hive, FileType, &offsetElement, 1, &Offset ); if (rc == FALSE) { return FALSE; } if (ShrinkHive) { // // Hive has shrunk, give up the excess space. // CmpDoFileSetSize(Hive, FileType, Hive->Storage[Stable].Length + HBLOCK_SIZE); } if ( ! (Hive->FileFlush)(Hive, FileType)) { return FALSE; } if ((Hive->Log) && (Hive->LogSize > HLOG_MINSIZE(Hive))) { // // Shrink log back down, reserve at least two clusters // worth of space so that if all the disk space is // consumed, there will still be enough space prereserved // to allow a minimum of registry operations so the user // can log on. // CmpDoFileSetSize(Hive, HFILE_TYPE_LOG, HLOG_MINSIZE(Hive)); Hive->LogSize = HLOG_MINSIZE(Hive); } return TRUE; }

NTSTATUS HvpEnlistBinInMap (  PHHIVE  Hive, ULONG  Length, PHBIN  Bin, ULONG  Offset, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 437 of file hivemap.c. References ASSERT, Bin, _HMAP_ENTRY::BinAddress, _HMAP_ENTRY::BlockAddress, CML_BIN, CML_FLOW, CMLOG, CMS_BIN_MAP, CMS_HIVE, ErrorExit(), FALSE, HBLOCK_SIZE, Hive, HMAP_NEWALLOC, HvCheckHiveDebug, HvpEnlistFreeCells(), HvpGetCellMap(), _HBIN::MemAlloc, NTSTATUS(), Offset, _HHIVE::ReadOnly, _HBIN::Size, Status, and VALIDATE_CELL_MAP. Referenced by HvpBuildMap(), HvpReadFileImageAndBuildMap(), and HvpRecoverData(). : Creates map entries and enlist free cells for the specified bin Arguments: Hive - Pointer to hive control structure containing the target map Length - the Length of the hive image Bin - the bin to be enlisted Offset - the offset within the hive file TailDisplay - array containing the tail ends of the free cell lists - optional Return Value: STATUS_SUCCESS - it worked STATUS_REGISTRY_CORRUPT - the bin is inconsistent --*/ { NTSTATUS Status; ULONG BinOffset; ULONG_PTR Address; PHMAP_ENTRY Me; CMLOG(CML_FLOW, CMS_HIVE) { KdPrint(("HvpEnlistBinInMap:\n")); KdPrint(("\tHive=%08lx\t Offset=%08lx",Hive,Offset)); } // // memory was allocated for this bin // Bin->MemAlloc = Bin->Size; CMLOG(CML_BIN, CMS_BIN_MAP) { KdPrint(("HvpEnlistBinInMap: BinAddress = 0x%08lx\t Size = 0x%lx\n", Bin, Bin->Size)); } // // create map entries for each block/page in bin // BinOffset = Offset; for (Address = (ULONG_PTR)Bin; Address < ((ULONG_PTR)Bin + Bin->Size); Address += HBLOCK_SIZE ) { Me = HvpGetCellMap(Hive, Offset); VALIDATE_CELL_MAP(__LINE__,Me,Hive,Offset); Me->BlockAddress = Address; Me->BinAddress = (ULONG_PTR)Bin; if (Offset == BinOffset) { Me->BinAddress |= HMAP_NEWALLOC; } Offset += HBLOCK_SIZE; } if (Hive->ReadOnly == FALSE) { // // add free cells in the bin to the appropriate free lists // if ( ! HvpEnlistFreeCells(Hive, Bin, BinOffset,TailDisplay)) { HvCheckHiveDebug.Hive = Hive; HvCheckHiveDebug.Status = 0xA002; HvCheckHiveDebug.Space = Length; HvCheckHiveDebug.MapPoint = BinOffset; HvCheckHiveDebug.BinPoint = Bin; Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit; } } // // logical consistency check // ASSERT(Offset == (BinOffset + Bin->Size)); return STATUS_SUCCESS; ErrorExit: return Status; }

VOID HvpEnlistFreeCell (  PHHIVE  Hive, HCELL_INDEX  Cell, ULONG  Size, HSTORAGE_TYPE  Type, BOOLEAN  CoalesceForward, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 947 of file hivecell.c. References TRUE. Referenced by HvFreeCell(), and HvpEnlistFreeCells(). : Puts the newly freed cell on the appropriate list. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest Cell - supplies index of cell to enlist Size - size of cell Type - indicates whether Stable or Volatile storage is desired. CoalesceForward - indicates whether we can coalesce forward or not. For the case where we have not finished scanning the hive and enlisting free cells, we do not want to coalesce forward. Return Value: NONE. --*/ { PHCELL_INDEX Last; PHCELL_INDEX First; PHMAP_ENTRY Map; PHCELL pcell; PHCELL pcellLast; PHCELL FirstCell; ULONG Index; PHBIN Bin; HCELL_INDEX FreeCell; PFREE_HBIN FreeBin; PHBIN FirstBin; PHBIN LastBin; HvpComputeIndex(Index, Size); First = &(Hive->Storage[Type].FreeDisplay[Index]); pcell = HvpGetHCell(Hive, Cell); ASSERT(pcell->Size > 0); ASSERT(Size == (ULONG)pcell->Size); if (ARGUMENT_PRESENT(TailDisplay)) { // // This should only happen once, at boot time; Then, we want to sort the list ascedending // Last = &TailDisplay[Index]; if( *Last != HCELL_NIL ) { // // there is a last cell; insert current cell right after it. // and set the next cell pointer for the current cell to NIL // pcellLast = HvpGetHCell(Hive,*Last); ASSERT(pcellLast->Size > 0); if (USE_OLD_CELL(Hive)) { pcellLast->u.OldCell.u.Next = Cell; pcell->u.OldCell.u.Next = HCELL_NIL; } else { pcellLast->u.NewCell.u.Next = Cell; pcell->u.NewCell.u.Next = HCELL_NIL; } } else { // // No Last cell; Insert it at the begining and set the last cell pointing to it as well // Sanity check: First cell should be also NIL // ASSERT( *First == HCELL_NIL ); if (USE_OLD_CELL(Hive)) { pcell->u.OldCell.u.Next = *First; } else { pcell->u.NewCell.u.Next = *First; } *First = Cell; } // // The current cell becomes the last cell // *Last = Cell; } else { // // Normal case, insert the cell at the begining of the list (speed reasons). // if (USE_OLD_CELL(Hive)) { pcell->u.OldCell.u.Next = *First; } else { pcell->u.NewCell.u.Next = *First; } *First = Cell; } // // Check to see if this is the first cell in the bin and if the entire // bin consists just of this cell. // Map = HvpGetCellMap(Hive, Cell); VALIDATE_CELL_MAP(__LINE__,Map,Hive,Cell); Bin = (PHBIN)(Map->BinAddress & ~HMAP_NEWALLOC); if ((pcell == (PHCELL)(Bin + 1)) && (Size == Bin->Size-sizeof(HBIN))) { // // We have a bin that is entirely free. But we cannot do anything with it // unless the memalloc that contains the bin is entirely free. Walk the // bins backwards until we find the first one in the alloc, then walk forwards // until we find the last one. If any of the other bins in the memalloc // are not free, bail out. // FirstBin = Bin; while (FirstBin->MemAlloc == 0) { Map=HvpGetCellMap(Hive,(FirstBin->FileOffset - HBLOCK_SIZE) + (Type * HCELL_TYPE_MASK)); VALIDATE_CELL_MAP(__LINE__,Map,Hive,(FirstBin->FileOffset - HBLOCK_SIZE) +(Type * HCELL_TYPE_MASK)); FirstBin = (PHBIN)(Map->BinAddress & HMAP_BASE); FirstCell = (PHCELL)(FirstBin+1); if ((ULONG)(FirstCell->Size) != FirstBin->Size-sizeof(HBIN)) { // // The first cell in the bin is either allocated, or not the only // cell in the HBIN. We cannot free any HBINs. // goto Done; } } // // We can never discard the first bin of a hive as that always gets marked dirty // and written out. // if (FirstBin->FileOffset == 0) { goto Done; } LastBin = Bin; while (LastBin->FileOffset+LastBin->Size < FirstBin->FileOffset+FirstBin->MemAlloc) { if (!CoalesceForward) { // // We are at the end of what's been built up. Just return and this // will get freed up when the next HBIN is added. // goto Done; } Map = HvpGetCellMap(Hive, (LastBin->FileOffset+LastBin->Size) + (Type * HCELL_TYPE_MASK)); VALIDATE_CELL_MAP(__LINE__,Map,Hive,(LastBin->FileOffset+LastBin->Size) + (Type * HCELL_TYPE_MASK)); ASSERT(Map->BinAddress != 0); LastBin = (PHBIN)(Map->BinAddress & HMAP_BASE); FirstCell = (PHCELL)(LastBin + 1); if ((ULONG)(FirstCell->Size) != LastBin->Size-sizeof(HBIN)) { // // The first cell in the bin is either allocated, or not the only // cell in the HBIN. We cannot free any HBINs. // goto Done; } } // // All the bins in this alloc are freed. Coalesce all the bins into // one alloc-sized bin, then either discard the bin or mark it as // discardable. // if (FirstBin->Size != FirstBin->MemAlloc) { // // Mark the first HBLOCK of the first HBIN dirty, since // we will need to update the on disk field for the bin size // if (!HvMarkDirty(Hive, FirstBin->FileOffset + (Type * HCELL_TYPE_MASK), sizeof(HBIN) + sizeof(HCELL))) { goto Done; } } FreeBin = (Hive->Allocate)(sizeof(FREE_HBIN), FALSE); if (FreeBin == NULL) { goto Done; } // // Walk through the bins and delist each free cell // Bin = FirstBin; do { FirstCell = (PHCELL)(Bin+1); HvpDelistFreeCell(Hive, FirstCell, Type, TailDisplay); if (Bin==LastBin) { break; } Map = HvpGetCellMap(Hive, (Bin->FileOffset+Bin->Size)+ (Type * HCELL_TYPE_MASK)); VALIDATE_CELL_MAP(__LINE__,Map,Hive,(Bin->FileOffset+Bin->Size)+(Type * HCELL_TYPE_MASK)); Bin = (PHBIN)(Map->BinAddress & HMAP_BASE); } while ( TRUE ); // // Coalesce them all into one bin. // FirstBin->Size = FirstBin->MemAlloc; FreeBin->Size = FirstBin->Size; FreeBin->FileOffset = FirstBin->FileOffset; FirstCell = (PHCELL)(FirstBin+1); FirstCell->Size = FirstBin->Size - sizeof(HBIN); if (USE_OLD_CELL(Hive)) { FirstCell->u.OldCell.Last = (ULONG)HBIN_NIL; } InsertHeadList(&Hive->Storage[Type].FreeBins, &FreeBin->ListEntry); ASSERT_LISTENTRY(&FreeBin->ListEntry); ASSERT_LISTENTRY(FreeBin->ListEntry.Flink); FreeCell = FirstBin->FileOffset+(Type*HCELL_TYPE_MASK); FreeBin->Flags = FREE_HBIN_DISCARDABLE; while (FreeCell-FirstBin->FileOffset < FirstBin->Size) { Map = HvpGetCellMap(Hive, FreeCell); VALIDATE_CELL_MAP(__LINE__,Map,Hive,FreeCell); if (Map->BinAddress & HMAP_NEWALLOC) { Map->BinAddress = (ULONG_PTR)FirstBin | HMAP_DISCARDABLE | HMAP_NEWALLOC; } else { Map->BinAddress = (ULONG_PTR)FirstBin | HMAP_DISCARDABLE; } Map->BlockAddress = (ULONG_PTR)FreeBin; FreeCell += HBLOCK_SIZE; } }

BOOLEAN HvpEnlistFreeCells (  PHHIVE  Hive, PHBIN  Bin, ULONG  BinOffset, PHCELL_INDEX TailDisplay  OPTIONAL )

Definition at line 649 of file hivemap.c. References ASSERT, Bin, FALSE, HCELL_INDEX, HCELL_PAD, Hive, HvpEnlistFreeCell(), _HBIN::Size, _HCELL::Size, Stable, and TRUE. Referenced by HvpBuildMapAndCopy(), HvpEnlistBinInMap(), HvpRecoverData(), and HvRefreshHive(). : Scan through the cells in the bin, locating the free ones. Enlist them in the hive's free list set. N.B. Bin MUST already be mapped when this is called. Arguments: Hive - pointer to hive control structure map is being built for Bin - pointer to bin to enlist cells from BinOffset - offset of Bin in image Return Value: FALSE - registry is corrupt TRUE - it worked --*/ { PHCELL p; ULONG celloffset; ULONG size; HCELL_INDEX cellindex; // PERFNOTE -- Keep this in mind as a possible optimization for NT6. // Since now the hive is loaded in chunks of bins, we can drop the // bins that are entirely free!!!!!! // // // Scan all the cells in the bin, total free and allocated, check // for impossible pointers. // celloffset = sizeof(HBIN); p = (PHCELL)((PUCHAR)Bin + sizeof(HBIN)); while (p < (PHCELL)((PUCHAR)Bin + Bin->Size)) { // // if free cell, check it out, add it to free list for hive // if (p->Size >= 0) { size = (ULONG)p->Size; if ( (size > Bin->Size) || ( (PHCELL)(size + (PUCHAR)p) > (PHCELL)((PUCHAR)Bin + Bin->Size) ) || ((size % HCELL_PAD(Hive)) != 0) || (size == 0) ) { return FALSE; } // // cell is free, and is not obviously corrupt, add to free list // celloffset = (ULONG)((PUCHAR)p - (PUCHAR)Bin); cellindex = BinOffset + celloffset; // // Enlist this free cell, but do not coalesce with the next free cell // as we haven't gotten that far yet. // HvpEnlistFreeCell(Hive, cellindex, size, Stable, FALSE,TailDisplay); } else { size = (ULONG)(p->Size * -1); if ( (size > Bin->Size) || ( (PHCELL)(size + (PUCHAR)p) > (PHCELL)((PUCHAR)Bin + Bin->Size) ) || ((size % HCELL_PAD(Hive)) != 0) || (size == 0) ) { return FALSE; } } ASSERT(size >= 0); p = (PHCELL)((PUCHAR)p + size); } return TRUE; }

VOID HvpFreeAllocatedBins (  PHHIVE  Hive  )

Definition at line 85 of file hiveinit.c. References ASSERT, Bin, _HMAP_ENTRY::BinAddress, _HHIVE::Free, HBLOCK_SIZE, Hive, HMAP_BASE, HMAP_NEWALLOC, HTABLE_SLOTS, _HBIN::MemAlloc, Stable, and _HMAP_TABLE::Table. Referenced by HvInitializeHive(), and HvLoadHive(). : Free all the bins allocated for the specified hive. It applies only to stable storage. Not all bins are allocated. Those that are not allocated have BinAddress set to 0 Arguments: Hive - supplies a pointer to hive control structure for hive who's bin to free. Return Value: NONE. --*/ { ULONG Length; PHBIN Bin; ULONG MapSlots; ULONG Tables; PHMAP_ENTRY Me; PHMAP_TABLE Tab; ULONG i; ULONG j; // // calculate the number of tables in the map // Length = Hive->Storage[Stable].Length; MapSlots = Length / HBLOCK_SIZE; if( MapSlots > 0 ) { Tables = (MapSlots-1) / HTABLE_SLOTS; } else { Tables = 0; } if( Hive->Storage[Stable].Map ) { // // iterate through the directory // for (i = 0; i <= Tables; i++) { Tab = Hive->Storage[Stable].Map->Directory[i]; ASSERT(Tab); // // iterate through the slots in the directory // for(j=0;j<HTABLE_SLOTS;j++) { Me = &(Tab->Table[j]); // // BinAddress non-zero means allocated bin // if( Me->BinAddress ) { if( Me->BinAddress & HMAP_NEWALLOC ) { Bin = (PHBIN)(Me->BinAddress & HMAP_BASE); (Hive->Free)(Bin, Bin->MemAlloc); } Me->BinAddress = 0; } } } } }

VOID HvpFreeMap (  PHHIVE  Hive, PHMAP_DIRECTORY  Dir, ULONG  Start, ULONG  End )

Definition at line 807 of file hivemap.c. References _HMAP_DIRECTORY::Directory, End, _HHIVE::Free, HDIRECTORY_SLOTS, Hive, NULL, and Start. Referenced by HvFreeHive(), HvFreeHivePartial(), HvpAddBin(), HvpBuildMapAndCopy(), HvpCleanMap(), and HvpInitMap(). : Sweeps through the directory Dir points to and frees Tables. Will free Start-th through End-th entries, INCLUSIVE. Arguments: Hive - supplies pointer to hive control block of interest Dir - supplies address of an HMAP_DIRECTORY structure Start - index of first map table pointer to clean up End - index of last map table pointer to clean up Return Value: NONE. --*/ { ULONG i; if (End >= HDIRECTORY_SLOTS) { End = HDIRECTORY_SLOTS - 1; } for (i = Start; i <= End; i++) { if (Dir->Directory[i] != NULL) { (Hive->Free)(Dir->Directory[i], sizeof(HMAP_TABLE)); Dir->Directory[i] = NULL; } } return; }

struct _CELL_DATA* HvpGetCellFlat (  PHHIVE  Hive, HCELL_INDEX  Cell )

Definition at line 221 of file hivecell.c. Referenced by HvInitializeHive(). 00232 : 00233 00234 Returns the memory address for the specified Cell. Will never 00235 return failure, but may assert. Use HvIsCellAllocated to check 00236 validity of Cell. 00237 00238 This routine should never be called directly, always call it 00239 via the HvGetCell() macro. 00240 00241 This routine provides GetCell support for read only hives with 00242 single allocation flat images. Such hives do not have cell 00243 maps ("page tables"), instead, we compute addresses by 00244 arithmetic against the base image address. 00245 00246 Such hives cannot have volatile cells. 00247 00248 Arguments: 00249 00250 Hive - supplies a pointer to the hive control structure for the 00251 hive of interest 00252 00253 Cell - supplies HCELL_INDEX of cell to return address for 00254 00255 Return Value: 00256 00257 Address of Cell in memory. Assert or BugCheck if error. 00258 00259 --*/ 00260 { 00261 PUCHAR base; 00262 PHCELL pcell; 00263 00264 CMLOG(CML_FLOW, CMS_MAP) { 00265 KdPrint(("HvGetCellFlat:\n")); 00266 KdPrint(("\tHive=%08lx Cell=%08lx\n",Hive,Cell)); 00267 } 00268 ASSERT(Hive->Signature == HHIVE_SIGNATURE); 00269 ASSERT(Cell != HCELL_NIL); 00270 ASSERT(Hive->Flat == TRUE); 00271 ASSERT(HvGetCellType(Cell) == Stable); 00272 ASSERT(Cell >= sizeof(HBIN)); 00273 ASSERT(Cell < Hive->BaseBlock->Length); 00274 ASSERT((Cell & 0x7)==0); 00275 00276 // 00277 // Address is base of Hive image + Cell 00278 // 00279 base = (PUCHAR)(Hive->BaseBlock) + HBLOCK_SIZE; 00280 pcell = (PHCELL)(base + Cell); 00281 if (USE_OLD_CELL(Hive)) { return (struct _CELL_DATA *)&(pcell->u.OldCell.u.UserData);

PHMAP_ENTRY HvpGetCellMap (  PHHIVE  Hive, HCELL_INDEX  Cell )

Definition at line 285 of file hivecell.c. Referenced by HvCheckHive(), HvFreeCell(), HvFreeHive(), HvFreeHivePartial(), HvIsBinDirty(), HvIsCellAllocated(), HvMarkCellDirty(), HvpAddBin(), HvpBuildMapAndCopy(), HvpCoalesceDiscardedBins(), HvpDiscardBins(), HvpDoWriteHive(), HvpEnlistBinInMap(), HvpFindNextDirtyBlock(), HvpRecoverData(), HvpTruncateBins(), and HvRefreshHive(). 00296 : 00297 00298 Returns the address of the HMAP_ENTRY for the cell. 00299 00300 Arguments: 00301 00302 Hive - supplies a pointer to the hive control structure for the 00303 hive of interest 00304 00305 Cell - supplies HCELL_INDEX of cell to return map entry address for 00306 00307 Return Value: 00308 00309 Address of MAP_ENTRY in memory. NULL if no such cell or other error. 00310 00311 --*/ 00312 { 00313 ULONG Type; 00314 ULONG Table; 00315 ULONG Block; 00316 PHMAP_TABLE ptab; 00317 00318 CMLOG(CML_FLOW, CMS_MAP) { 00319 KdPrint(("HvpGetCellMapPaged:\n")); 00320 KdPrint(("\tHive=%08lx Cell=%08lx\n",Hive,Cell)); 00321 } 00322 ASSERT(Hive->Signature == HHIVE_SIGNATURE); 00323 ASSERT(Hive->Flat == FALSE); 00324 ASSERT((Cell & (HCELL_PAD(Hive)-1))==0); 00325 00326 Type = HvGetCellType(Cell); 00327 Table = (Cell & HCELL_TABLE_MASK) >> HCELL_TABLE_SHIFT; 00328 Block = (Cell & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT; 00329 00330 if ((Cell - (Type * HCELL_TYPE_MASK)) >= Hive->Storage[Type].Length) { 00331 return NULL; }

struct _CELL_DATA* HvpGetCellPaged (  PHHIVE  Hive, HCELL_INDEX  Cell )

Definition at line 146 of file hivecell.c. References ASSERT, ASSERT_CM_LOCK_OWNED, _HMAP_ENTRY::BinAddress, _HMAP_ENTRY::BlockAddress, Cell, CML_FLOW, CMLOG, CMS_MAP, FALSE, _HHIVE::Flat, HCELL_BLOCK_MASK, HCELL_BLOCK_SHIFT, HCELL_NIL, HCELL_OFFSET_MASK, HCELL_PAD, HCELL_TABLE_MASK, HCELL_TABLE_SHIFT, HCELL_TYPE_MASK, HHIVE_SIGNATURE, Hive, HMAP_BASE, HMAP_DISCARDABLE, HvGetCellType, Offset, _HHIVE::Signature, Stable, _HCELL::u, and USE_OLD_CELL. Referenced by HvInitializeHive(). 00157 : 00158 00159 Returns the memory address for the specified Cell. Will never 00160 return failure, but may assert. Use HvIsCellAllocated to check 00161 validity of Cell. 00162 00163 This routine should never be called directly, always call it 00164 via the HvGetCell() macro. 00165 00166 This routine provides GetCell support for hives with full maps. 00167 It is the normal version of the routine. 00168 00169 Arguments: 00170 00171 Hive - supplies a pointer to the hive control structure for the 00172 hive of interest 00173 00174 Cell - supplies HCELL_INDEX of cell to return address for 00175 00176 Return Value: 00177 00178 Address of Cell in memory. Assert or BugCheck if error. 00179 00180 --*/ 00181 { 00182 ULONG Type; 00183 ULONG Table; 00184 ULONG Block; 00185 ULONG Offset; 00186 PHCELL pcell; 00187 PHMAP_ENTRY Map; 00188 00189 CMLOG(CML_FLOW, CMS_MAP) { 00190 KdPrint(("HvGetCellPaged:\n")); 00191 KdPrint(("\tHive=%08lx Cell=%08lx\n",Hive,Cell)); 00192 } 00193 ASSERT(Hive->Signature == HHIVE_SIGNATURE); 00194 ASSERT(Cell != HCELL_NIL); 00195 ASSERT(Hive->Flat == FALSE); 00196 ASSERT((Cell & (HCELL_PAD(Hive)-1))==0); 00197 ASSERT_CM_LOCK_OWNED(); 00198 #if DBG 00199 if (HvGetCellType(Cell) == Stable) { 00200 ASSERT(Cell >= sizeof(HBIN)); 00201 } else { 00202 ASSERT(Cell >= (HCELL_TYPE_MASK + sizeof(HBIN))); 00203 } 00204 #endif 00205 00206 Type = HvGetCellType(Cell); 00207 Table = (Cell & HCELL_TABLE_MASK) >> HCELL_TABLE_SHIFT; 00208 Block = (Cell & HCELL_BLOCK_MASK) >> HCELL_BLOCK_SHIFT; 00209 Offset = (Cell & HCELL_OFFSET_MASK); 00210 00211 ASSERT((Cell - (Type * HCELL_TYPE_MASK)) < Hive->Storage[Type].Length); 00212 00213 Map = &((Hive->Storage[Type].Map)->Directory[Table]->Table[Block]); 00214 ASSERT((Map->BinAddress & HMAP_BASE) != 0); 00215 ASSERT((Map->BinAddress & HMAP_DISCARDABLE) == 0); 00216 pcell = (PHCELL)((ULONG_PTR)(Map->BlockAddress) + Offset); 00217 if (USE_OLD_CELL(Hive)) { return (struct _CELL_DATA *)&(pcell->u.OldCell.u.UserData);

BOOLEAN HvpGrowLog1 (  PHHIVE  Hive, ULONG  Count )

Definition at line 495 of file hivesync.c. References ASSERT, _HHIVE::Cluster, CML_MINOR, CMLOG, CMS_IO, Count, _HHIVE::DirtyCount, _HHIVE::DirtyVector, FALSE, _HHIVE::FileSetSize, HFILE_TYPE_LOG, Hive, HLOG_GROW, HSECTOR_SIZE, _HHIVE::Log, _HHIVE::LogSize, _HHIVE::ReadOnly, ROUND_UP, RtlNumberOfSetBits(), and TRUE. Referenced by HvMarkDirty(). : Adjust the log for growth in the number of sectors of dirty data that are desired. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest Count - number of additional logical sectors of log space needed Return Value: TRUE - it worked FALSE - could not allocate log space, failure! --*/ { ULONG ClusterSize; ULONG RequiredSize; ULONG tmp; CMLOG(CML_MINOR, CMS_IO) { KdPrint(("HvpGrowLog1:\n\t")); KdPrint(("Hive:%08lx Count:%08lx\n", Hive, Count)); } ASSERT(Hive->ReadOnly == FALSE); ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); // // If logging is off, tell caller world is OK. // if (Hive->Log == FALSE) { return TRUE; } ClusterSize = Hive->Cluster * HSECTOR_SIZE; tmp = Hive->DirtyVector.SizeOfBitMap / 8; // bytes tmp += sizeof(ULONG); // signature RequiredSize = ClusterSize + // 1 cluster for header ROUND_UP(tmp, ClusterSize) + ((Hive->DirtyCount + Count) * HSECTOR_SIZE); RequiredSize = ROUND_UP(RequiredSize, HLOG_GROW); ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); if ( ! (Hive->FileSetSize)(Hive, HFILE_TYPE_LOG, RequiredSize)) { return FALSE; } Hive->LogSize = RequiredSize; ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); return TRUE; }

BOOLEAN HvpGrowLog2 (  PHHIVE  Hive, ULONG  Size )

Definition at line 565 of file hivesync.c. References ASSERT, _HHIVE::Cluster, CML_MINOR, CMLOG, CMS_IO, _HHIVE::DirtyCount, _HHIVE::DirtyVector, FALSE, _HHIVE::FileSetSize, HFILE_TYPE_LOG, Hive, HLOG_GROW, HSECTOR_SIZE, _HHIVE::Log, _HHIVE::LogSize, _HHIVE::ReadOnly, ROUND_UP, RtlNumberOfSetBits(), Size, Stable, and TRUE. Referenced by HvpAddBin(). : Adjust the log for growth in the size of the hive, in particular, account for the increased space needed for a bigger dirty vector. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest Size - proposed growth in size in bytes. Return Value: TRUE - it worked FALSE - could not allocate log space, failure! --*/ { ULONG ClusterSize; ULONG RequiredSize; ULONG DirtyBytes; CMLOG(CML_MINOR, CMS_IO) { KdPrint(("HvpGrowLog2:\n\t")); KdPrint(("Hive:%08lx Size:%08lx\n", Hive, Size)); } ASSERT(Hive->ReadOnly == FALSE); ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); // // If logging is off, tell caller world is OK. // if (Hive->Log == FALSE) { return TRUE; } ASSERT( (Size % HSECTOR_SIZE) == 0 ); ClusterSize = Hive->Cluster * HSECTOR_SIZE; ASSERT( (((Hive->Storage[Stable].Length + Size) / HSECTOR_SIZE) % 8) == 0); DirtyBytes = (Hive->DirtyVector.SizeOfBitMap / 8) + ((Size / HSECTOR_SIZE) / 8) + sizeof(ULONG); // signature DirtyBytes = ROUND_UP(DirtyBytes, ClusterSize); RequiredSize = ClusterSize + // 1 cluster for header (Hive->DirtyCount * HSECTOR_SIZE) + DirtyBytes; RequiredSize = ROUND_UP(RequiredSize, HLOG_GROW); ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); if ( ! (Hive->FileSetSize)(Hive, HFILE_TYPE_LOG, RequiredSize)) { return FALSE; } Hive->LogSize = RequiredSize; ASSERT(Hive->DirtyCount == RtlNumberOfSetBits(&Hive->DirtyVector)); return TRUE; }

ULONG HvpHeaderCheckSum (  PHBASE_BLOCK  BaseBlock  )

Definition at line 31 of file hivesum.c. Referenced by DoDump(), HvInitializeHive(), HvpDoWriteHive(), HvpGetHiveHeader(), HvpGetLogHeader(), and HvpWriteLog(). 00036 : 00037 00038 Compute the checksum for a hive disk header. 00039 00040 Arguments: 00041 00042 BaseBlock - supplies pointer to the header to checksum 00043 00044 Return Value: 00045 00046 the check sum. 00047 00048 --*/ 00049 { 00050 ULONG sum; 00051 ULONG i; 00052 00053 sum = 0; 00054 for (i = 0; i < 127; i++) { 00055 sum ^= ((PULONG)BaseBlock)[i]; 00056 } 00057 if (sum == (ULONG)-1) { 00058 sum = (ULONG)-2; 00059 } 00060 if (sum == 0) { 00061 sum = 1; 00062 } 00063 return sum; 00064 } }

NTSTATUS HvpInitMap (  PHHIVE  Hive  )

Definition at line 304 of file hivemap.c. References _HHIVE::Allocate, _HHIVE::BaseBlock, CML_FLOW, CMLOG, CMS_HIVE, _HHIVE::DirtyAlloc, _HHIVE::DirtyVector, FALSE, _HHIVE::Free, HBLOCK_SIZE, Hive, HSECTOR_SIZE, HTABLE_SLOTS, HvpAllocateMap(), HvpFreeMap(), _HBASE_BLOCK::Length, NTSTATUS(), NULL, ROUND_UP, RtlInitializeBitMap(), Stable, Status, t(), and TRUE. Referenced by HvpBuildMap(), and HvpReadFileImageAndBuildMap(). : Initialize the map for the Stable Volatile storage of the hive. Following fields in hive must already be filled in: Allocate, Free Will initialize Storage structure of HHIVE. Arguments: Hive - Pointer to hive control structure to build map for. Return Value: STATUS_SUCCESS - it worked STATUS_xxx - the errorneous status --*/ { PHBASE_BLOCK BaseBlock; ULONG Length; ULONG MapSlots; ULONG Tables; PHMAP_TABLE t = NULL; PHMAP_DIRECTORY d = NULL; NTSTATUS Status; PULONG Vector; CMLOG(CML_FLOW, CMS_HIVE) { KdPrint(("HvpInitMap:\n")); KdPrint(("\tHive=%08lx",Hive)); } // // Compute size of data region to be mapped // BaseBlock = Hive->BaseBlock; Length = BaseBlock->Length; if ((Length % HBLOCK_SIZE) != 0) { Status = STATUS_REGISTRY_CORRUPT; goto ErrorExit1; } MapSlots = Length / HBLOCK_SIZE; if( MapSlots > 0 ) { Tables = (MapSlots-1) / HTABLE_SLOTS; } else { Tables = 0; } Hive->Storage[Stable].Length = Length; // // allocate dirty vector if one is not already present (from HvpRecoverData) // if (Hive->DirtyVector.Buffer == NULL) { Vector = (PULONG)((Hive->Allocate)(ROUND_UP(Length/HSECTOR_SIZE/8,sizeof(ULONG)), TRUE)); if (Vector == NULL) { Status = STATUS_NO_MEMORY; goto ErrorExit1; } RtlZeroMemory(Vector, Length / HSECTOR_SIZE / 8); RtlInitializeBitMap(&Hive->DirtyVector, Vector, Length / HSECTOR_SIZE); Hive->DirtyAlloc = (Length/HSECTOR_SIZE/8); } // // allocate and build structure for map // if (Tables == 0) { // // Just 1 table, no need for directory // t = (Hive->Allocate)(sizeof(HMAP_TABLE), FALSE); if (t == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit1; } RtlZeroMemory(t, sizeof(HMAP_TABLE)); Hive->Storage[Stable].Map = (PHMAP_DIRECTORY)&(Hive->Storage[Stable].SmallDir); Hive->Storage[Stable].SmallDir = t; } else { // // Need directory and multiple tables // d = (PHMAP_DIRECTORY)(Hive->Allocate)(sizeof(HMAP_DIRECTORY), FALSE); if (d == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit1; } RtlZeroMemory(d, sizeof(HMAP_DIRECTORY)); // // Allocate tables and fill in dir // if (HvpAllocateMap(Hive, d, 0, Tables) == FALSE) { Status = STATUS_INSUFFICIENT_RESOURCES; goto ErrorExit2; } Hive->Storage[Stable].Map = d; Hive->Storage[Stable].SmallDir = 0; } return STATUS_SUCCESS; ErrorExit2: if (d != NULL) { // // directory was built and allocated, so clean it up // HvpFreeMap(Hive, d, 0, Tables); (Hive->Free)(d, sizeof(HMAP_DIRECTORY)); } ErrorExit1: return Status; }

NTSTATUS HvReadInMemoryHive (  PHHIVE  Hive, PVOID *  HiveImage )

HCELL_INDEX HvReallocateCell (  PHHIVE  Hive, HCELL_INDEX  Cell, ULONG  NewSize )

Definition at line 1295 of file hivecell.c. Referenced by CmDeleteValueKey(), CmpAddToLeaf(), CmpMergeKeyValues(), CmpSetSecurityDescriptorInfo(), CmpSetValueKeyNew(), CmpSplitLeaf(), and CmRestoreKey(). 01307 : 01308 01309 Grows or shrinks a cell. 01310 01311 NOTE: 01312 01313 MUST NOT FAIL if the cell is being made smaller. Can be 01314 a noop, but must work. 01315 01316 WARNING: 01317 01318 If the cell is grown, it will get a NEW and DIFFERENT HCELL_INDEX!!! 01319 01320 Arguments: 01321 01322 Hive - supplies a pointer to the hive control structure for the 01323 hive of interest 01324 01325 Cell - supplies index of cell to grow or shrink 01326 01327 NewSize - desired size of cell (this is an absolute size, not an 01328 increment or decrement.) 01329 01330 Return Value: 01331 01332 New HCELL_INDEX for cell, or HCELL_NIL if failure. 01333 01334 If return is HCELL_NIL, either old cell did not exist, or it did exist 01335 and we could not make a new one. In either case, nothing has changed. 01336 01337 If return is NOT HCELL_NIL, then it is the HCELL_INDEX for the Cell, 01338 which very probably moved. 01339 01340 --*/ 01341 { 01342 PUCHAR oldaddress; 01343 LONG oldsize; 01344 ULONG oldalloc; 01345 HCELL_INDEX NewCell; // return value 01346 PUCHAR newaddress; 01347 ULONG Type; 01348 01349 CMLOG(CML_MAJOR, CMS_HIVE) { 01350 KdPrint(("HvReallocateCell:\n")); 01351 KdPrint(("\tHive=%08lx Cell=%08lx NewSize=%08lx\n",Hive,Cell,NewSize)); 01352 } 01353 ASSERT(Hive->Signature == HHIVE_SIGNATURE); 01354 ASSERT(Hive->ReadOnly == FALSE); 01355 ASSERT_CM_LOCK_OWNED_EXCLUSIVE(); 01356 01357 // 01358 // Make room for overhead fields and round up to HCELL_PAD boundary 01359 // 01360 if (USE_OLD_CELL(Hive)) { 01361 NewSize += FIELD_OFFSET(HCELL, u.OldCell.u.UserData); 01362 } else { 01363 NewSize += FIELD_OFFSET(HCELL, u.NewCell.u.UserData); 01364 } 01365 NewSize = ROUND_UP(NewSize, HCELL_PAD(Hive)); 01366 01367 // 01368 // Adjust the size (an easy fix for granularity) 01369 // 01370 HvpAdjustCellSize(NewSize); 01371 01372 // 01373 // reject impossible/unreasonable values 01374 // 01375 if (NewSize > HSANE_CELL_MAX) { 01376 CMLOG(CML_FLOW, CMS_HIVE) { 01377 KdPrint(("\tNewSize=%08lx\n", NewSize)); 01378 } 01379 return HCELL_NIL; 01380 } 01381 01382 // 01383 // Get sizes and addresses 01384 // 01385 oldaddress = (PUCHAR)HvGetCell(Hive, Cell); 01386 oldsize = HvGetCellSize(Hive, oldaddress); 01387 ASSERT(oldsize > 0); 01388 if (USE_OLD_CELL(Hive)) { 01389 oldalloc = (ULONG)(oldsize + FIELD_OFFSET(HCELL, u.OldCell.u.UserData)); 01390 } else { 01391 oldalloc = (ULONG)(oldsize + FIELD_OFFSET(HCELL, u.NewCell.u.UserData)); 01392 } 01393 Type = HvGetCellType(Cell); 01394 01395 DHvCheckHive(Hive); 01396 01397 if (NewSize == oldalloc) { 01398 01399 // 01400 // This is a noop, return the same cell 01401 // 01402 NewCell = Cell; 01403 01404 } else if (NewSize < oldalloc) { 01405 01406 // 01407 // This is a shrink. 01408 // 01409 // PERFNOTE - IMPLEMENT THIS. Do nothing for now. 01410 // 01411 NewCell = Cell; 01412 01413 } else { 01414 01415 // 01416 // This is a grow. 01417 // 01418 01419 // 01420 // PERFNOTE - Someday we want to detect that there is a free neighbor 01421 // above us and grow into that neighbor if possible. 01422 // For now, always do the allocate, copy, free gig. 01423 // 01424 01425 // 01426 // Allocate a new block of memory to hold the cell 01427 // 01428 01429 if ((NewCell = HvpDoAllocateCell(Hive, NewSize, Type)) == HCELL_NIL) { 01430 return HCELL_NIL; 01431 } 01432 ASSERT(HvIsCellAllocated(Hive, NewCell)); 01433 newaddress = (PUCHAR)HvGetCell(Hive, NewCell); 01434 01435 // 01436 // oldaddress points to the old data block for the cell, 01437 // newaddress points to the new data block, copy the data 01438 // 01439 RtlMoveMemory(newaddress, oldaddress, oldsize); 01440 01441 // 01442 // Free the old block of memory 01443 // 01444 HvFreeCell(Hive, Cell); }

VOID HvRefreshHive (  PHHIVE  Hive  )

Definition at line 1584 of file hivesync.c. References ASSERT, _HHIVE::BaseBlock, Bin, _HMAP_ENTRY::BinAddress, BitMap, _HMAP_ENTRY::BlockAddress, CmCheckRegistry(), _HHIVE::DirtyCount, _HHIVE::DirtyVector, End, FALSE, _HBIN::FileOffset, _FREE_HBIN::FileOffset, _HHIVE::FileRead, _HHIVE::FileSetSize, _CM_KEY_NODE::Flags, _FREE_HBIN::Flags, _HHIVE::Free, FREE_HBIN_DISCARDABLE, HBLOCK_SIZE, HCELL_INDEX, HCELL_NIL, HFILE_TYPE_PRIMARY, HHIVE_FREE_DISPLAY_SIZE, Hive, HIVE_NOLAZYFLUSH, _HHIVE::HiveFlags, HMAP_BASE, HMAP_DISCARDABLE, HMAP_NEWALLOC, HSECTOR_SIZE, HvCheckHive(), HvFreeHivePartial(), HvGetCell, HvpEnlistFreeCells(), HvpFindNextDirtyBlock(), HvpGetCellMap(), KeBugCheckEx(), KEY_HIVE_ENTRY, KEY_NO_DELETE, _HBASE_BLOCK::Length, List, _FREE_HBIN::ListEntry, _HBIN::MemAlloc, NULL, Offset, _CM_KEY_NODE::Parent, _HHIVE::RefreshCount, _HBASE_BLOCK::RootCell, RtlClearAllBits(), RtlClearBits(), _HBIN::Size, _FREE_HBIN::Size, Stable, Start, t(), TRUE, VALIDATE_CELL_MAP, and Volatile. : Undo the last sync. We do this by reading back all data which has been marked dirty from the file into memory. Update the free list. We will then clear the dirty vector. Any growth since the last sync will be discarded, and in fact, the size of the file will be set down. WARNNOTE: Failure will cause a bugcheck, as we cannot keep the hive consistent if we fail part way through. All I/O is done via HFILE_TYPE_PRIMARY. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest. Return Value: NONE. Either works or BugChecks. --*/ { ULONG Offset; ULONG ReadLength; ULONG checkstatus; PUCHAR Address; ULONG Current; PRTL_BITMAP BitMap; BOOLEAN rc; ULONG Start; ULONG End; ULONG BitLength; HCELL_INDEX TailStart; HCELL_INDEX p; PHMAP_ENTRY t; ULONG i; PHBIN Bin; PLIST_ENTRY List; PFREE_HBIN FreeBin; PHMAP_ENTRY Map; HCELL_INDEX RootCell; PCM_KEY_NODE RootNode; HCELL_INDEX LinkCell; // // this array stores the last elements in each free cell list for the stable storage // HCELL_INDEX TailDisplay[HHIVE_FREE_DISPLAY_SIZE]; // // noop or assert on various uninteresting or bogus conditions // if (Hive->DirtyCount == 0) { return; } ASSERT(Hive->HiveFlags & HIVE_NOLAZYFLUSH); ASSERT(Hive->Storage[Volatile].Length == 0); // // be sure the hive is not already trash // checkstatus = HvCheckHive(Hive, NULL); if (checkstatus != 0) { KeBugCheckEx(REGISTRY_ERROR,7,0,(ULONG_PTR)Hive,checkstatus); } Hive->RefreshCount++; // // Capture the LinkCell backpointer in the hive's root cell. We need this in case // the first bin is overwritten with what was on disk. // RootCell = Hive->BaseBlock->RootCell; RootNode = (PCM_KEY_NODE)HvGetCell(Hive, RootCell); LinkCell = RootNode->Parent; // // Any bins that have been marked as discardable, but not yet flushed to // disk, are going to be overwritten with old data. Bring them back into // memory and remove their FREE_HBIN marker from the list. // List = Hive->Storage[Stable].FreeBins.Flink; while (List != &Hive->Storage[Stable].FreeBins) { FreeBin = CONTAINING_RECORD(List, FREE_HBIN, ListEntry); List = List->Flink; if (FreeBin->Flags & FREE_HBIN_DISCARDABLE) { for (i=0; i<FreeBin->Size; i+=HBLOCK_SIZE) { Map = HvpGetCellMap(Hive, FreeBin->FileOffset+i); VALIDATE_CELL_MAP(__LINE__,Map,Hive,FreeBin->FileOffset+i); Map->BlockAddress = (Map->BinAddress & HMAP_BASE)+i; Map->BinAddress &= ~HMAP_DISCARDABLE; } RemoveEntryList(&FreeBin->ListEntry); (Hive->Free)(FreeBin, sizeof(FREE_HBIN)); } } // // OverRead base block. // Offset = 0; if ( (Hive->FileRead)( Hive, HFILE_TYPE_PRIMARY, &Offset, Hive->BaseBlock, HBLOCK_SIZE ) != TRUE) { KeBugCheckEx(REGISTRY_ERROR,7,1,0,0); } TailStart = (HCELL_INDEX)(Hive->BaseBlock->Length); // // Free "tail" memory and maps for it, update hive size pointers // HvFreeHivePartial(Hive, TailStart, Stable); // // Clear dirty vector for data past Hive->BaseBlock->Length // Start = Hive->BaseBlock->Length / HSECTOR_SIZE; End = Hive->DirtyVector.SizeOfBitMap; BitLength = End - Start; RtlClearBits(&(Hive->DirtyVector), Start, BitLength); // // Scan dirty blocks. Read contiguous blocks off disk into hive. // Stop when we get to reduced length. // BitMap = &(Hive->DirtyVector); Current = 0; while (HvpFindNextDirtyBlock( Hive, &Hive->DirtyVector, &Current, &Address, &ReadLength, &Offset )) { ASSERT(Offset < (Hive->BaseBlock->Length + sizeof(HBASE_BLOCK))); rc = (Hive->FileRead)( Hive, HFILE_TYPE_PRIMARY, &Offset, (PVOID)Address, ReadLength ); if (rc == FALSE) { KeBugCheckEx(REGISTRY_ERROR,7,2,(ULONG_PTR)&Offset,rc); } } // // If we read the start of any HBINs into memory, it is likely // their MemAlloc fields are invalid. Walk through the HBINs // and write valid MemAlloc values for any HBINs whose first // sector was reread. // p=0; while (p < Hive->Storage[Stable].Length) { t = HvpGetCellMap(Hive, p); VALIDATE_CELL_MAP(__LINE__,t,Hive,p); Bin = (PHBIN)(t->BlockAddress & HMAP_BASE); if ((t->BinAddress & HMAP_DISCARDABLE)==0) { if (RtlCheckBit(&Hive->DirtyVector, p / HSECTOR_SIZE)==1) { // // The first sector in the HBIN is dirty. // // Reset the BinAddress to the Block address to cover // the case where a few smaller bins have been coalesced // into a larger bin. We want the smaller bins back now. // t->BinAddress = (t->BinAddress & ~HMAP_BASE) | t->BlockAddress; // Check the map to see if this is the start // of a memory allocation or not. // if (t->BinAddress & HMAP_NEWALLOC) { // // Walk through the map to determine the length // of the allocation. // Bin->MemAlloc = 0; do { t = HvpGetCellMap(Hive, p+Bin->MemAlloc+HBLOCK_SIZE); Bin->MemAlloc += HBLOCK_SIZE; if (p+Bin->MemAlloc == Hive->Storage[Stable].Length) { // // Reached the end of the hive. // break; } VALIDATE_CELL_MAP(__LINE__,t,Hive,p+Bin->MemAlloc); } while ( (t->BinAddress & HMAP_NEWALLOC) == 0); } else { Bin->MemAlloc = 0; } } p += Bin->Size; } else { FreeBin = (PFREE_HBIN)t->BlockAddress; p += FreeBin->Size; } } // // be sure we haven't filled memory with trash // checkstatus = HvCheckHive(Hive, NULL); if (checkstatus != 0) { KeBugCheckEx(REGISTRY_ERROR,7,3,(ULONG_PTR)Hive,checkstatus); } // // reinit the free list // for (i = 0; i < HHIVE_FREE_DISPLAY_SIZE; i++) { Hive->Storage[Stable].FreeDisplay[i] = HCELL_NIL; TailDisplay[i] = HCELL_NIL; } Hive->Storage[Stable].FreeSummary = 0; // // rebuild the free list // p = 0; while (p < Hive->Storage[Stable].Length) { t = HvpGetCellMap(Hive, p); VALIDATE_CELL_MAP(__LINE__,t,Hive,p); if ((t->BinAddress & HMAP_DISCARDABLE) == 0) { Bin = (PHBIN)((t->BinAddress) & HMAP_BASE); if ( ! HvpEnlistFreeCells(Hive, Bin, Bin->FileOffset,TailDisplay)) { KeBugCheckEx(REGISTRY_ERROR,7,5,(ULONG_PTR)Bin,Bin->FileOffset); } p = (ULONG)p + Bin->Size; } else { FreeBin = (PFREE_HBIN)t->BlockAddress; p = (ULONG)p + FreeBin->Size; } } // // Finally we need to rewrite the parent field in the root hcell. This is // patched in at hive load time so the correct value could have just been // overwritten with whatever happened to be on disk. // RootNode = (PCM_KEY_NODE)HvGetCell(Hive, RootCell); RootNode->Parent = LinkCell; RootNode->Flags |= KEY_HIVE_ENTRY | KEY_NO_DELETE; // // be sure the structure of the thing is OK after all this // checkstatus = CmCheckRegistry((PCMHIVE)Hive, FALSE); if (checkstatus != 0) { KeBugCheckEx(REGISTRY_ERROR,7,6,(ULONG_PTR)Hive,checkstatus); } // // Clear dirty vector. // RtlClearAllBits(&(Hive->DirtyVector)); Hive->DirtyCount = 0; // // Adjust the file size, if this fails, ignore it, since it just // means the file is too big. // (Hive->FileSetSize)( Hive, HFILE_TYPE_PRIMARY, (Hive->BaseBlock->Length + HBLOCK_SIZE) ); return; }

BOOLEAN HvSyncHive (  PHHIVE  Hive  )

Definition at line 647 of file hivesync.c. References _HHIVE::Alternate, ASSERT, CML_BUGCHECK, CML_FLOW, CML_WORKER, CMLOG, CMS_IO, _HHIVE::DirtyCount, _HHIVE::DirtyVector, DumpDirtyVector, FALSE, HFILE_TYPE_ALTERNATE, HFILE_TYPE_PRIMARY, HHIVE_SIGNATURE, Hive, HIVE_VOLATILE, _HHIVE::HiveFlags, HvpDiscardBins(), HvpDoWriteHive(), HvpTruncateBins(), HvpWriteLog(), HvShutdownComplete, IoSetThreadHardErrorMode(), _HHIVE::Log, _HHIVE::ReadOnly, RtlClearAllBits(), _HHIVE::Signature, and TRUE. Referenced by CmFlushKey(), CmpDoFlushAll(), CmpInitializeHiveList(), EhCloseHive(), and EhOpenHive(). : Force backing store to match the memory image of the Stable part of the hive's space. Logs, primary, and alternate data can be written. Primary is always written. Normally either a log or an alternate, but not both, will also be written. It is possible to write only the primary. All dirty bits will be set clear. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest Return Value: TRUE - it worked FALSE - some failure. --*/ { BOOLEAN oldFlag; CMLOG(CML_WORKER, CMS_IO) { KdPrint(("HvSyncHive:\n\t")); KdPrint(("Hive:%08lx\n", Hive)); } ASSERT(Hive->Signature == HHIVE_SIGNATURE); ASSERT(Hive->ReadOnly == FALSE); // // Punt if post shutdown // if (HvShutdownComplete) { CMLOG(CML_BUGCHECK, CMS_IO) { KdPrint(("HvSyncHive: Attempt to sync AFTER SHUTDOWN\n")); } return FALSE; } // // If nothing dirty, do nothing // if (Hive->DirtyCount == 0) { return TRUE; } HvpTruncateBins(Hive); // // If hive is volatile, do nothing // if (Hive->HiveFlags & HIVE_VOLATILE) { return TRUE; } CMLOG(CML_FLOW, CMS_IO) { KdPrint(("\tDirtyCount:%08lx\n", Hive->DirtyCount)); KdPrint(("\tDirtyVector:")); DumpDirtyVector(Hive); } // // disable hard error popups, to avoid self deadlock on bogus devices // oldFlag = IoSetThreadHardErrorMode(FALSE); // // Write a log. // if (Hive->Log == TRUE) { if (HvpWriteLog(Hive) == FALSE) { IoSetThreadHardErrorMode(oldFlag); return FALSE; } } // // Write the primary // if (HvpDoWriteHive(Hive, HFILE_TYPE_PRIMARY) == FALSE) { IoSetThreadHardErrorMode(oldFlag); return FALSE; } // // Write an alternate // if (Hive->Alternate == TRUE) { if (HvpDoWriteHive(Hive, HFILE_TYPE_ALTERNATE) == FALSE) { IoSetThreadHardErrorMode(oldFlag); return FALSE; } } // // restore hard error popups mode // IoSetThreadHardErrorMode(oldFlag); // // Hive was successfully written out, discard any bins marked as // discardable. // HvpDiscardBins(Hive); // // Clear the dirty map // RtlClearAllBits(&(Hive->DirtyVector)); Hive->DirtyCount = 0; return TRUE; }

NTSTATUS HvWriteHive (  PHHIVE  Hive  )

Definition at line 1433 of file hivesync.c. References _HHIVE::Allocate, ASSERT, _HHIVE::BaseBlock, _HHIVE::Cluster, CML_BUGCHECK, CML_MAJOR, CMLOG, CmpDoFileSetSize(), CmpFree(), CmpReleaseGlobalQuota(), CMS_IO, _HHIVE::DirtyVector, FALSE, _HHIVE::Free, HFILE_TYPE_EXTERNAL, HHIVE_SIGNATURE, Hive, HSECTOR_SIZE, HvpDoWriteHive(), HvShutdownComplete, NT_SUCCESS, NTSTATUS(), NULL, PAGE_SIZE, _HHIVE::ReadOnly, ROUND_UP, RtlSetAllBits(), _HHIVE::Signature, Stable, and TRUE. Referenced by CmpInitializeHiveList(), CmSaveKey(), and CmSaveMergedKeys(). : Write the hive out. Write only to the Primary file, neither logs nor alternates will be updated. The hive will be written to the HFILE_TYPE_EXTERNAL handle. Intended for use in applications like SaveKey. Only Stable storage will be written (as for any hive.) Presumption is that layer above has set HFILE_TYPE_EXTERNAL handle to point to correct place. Applying this call to an active hive will generally hose integrity measures. HOW IT WORKS: Make a new DirtyVector. Fill it with 1s (all dirty). Make hive point at it. We now have what looks like a completely dirty hive. Call HvpWriteHive, which will write the whole thing to disk. Put back DirtyVector, and free the extra one we used. In failure case, force Sequence numbers in Hive and BaseBlock to match. Arguments: Hive - supplies a pointer to the hive control structure for the hive of interest. Return Value: Status. --*/ { PULONG SaveDirtyVector; ULONG SaveDirtyVectorSize; PULONG AltDirtyVector; ULONG AltDirtyVectorSize; PHBASE_BLOCK SaveBaseBlock; PHBASE_BLOCK AltBaseBlock; ULONG Alignment; NTSTATUS status; CMLOG(CML_MAJOR, CMS_IO) { KdPrint(("HvWriteHive: \n")); KdPrint(("\tHive = %08lx\n")); } ASSERT(Hive->Signature == HHIVE_SIGNATURE); ASSERT(Hive->ReadOnly == FALSE); // // Punt if post shutdown // if (HvShutdownComplete) { CMLOG(CML_BUGCHECK, CMS_IO) { KdPrint(("HvWriteHive: Attempt to write hive AFTER SHUTDOWN\n")); } return STATUS_REGISTRY_IO_FAILED; } // // Splice in a duplicate DirtyVector with all bits set. // SaveDirtyVector = Hive->DirtyVector.Buffer; SaveDirtyVectorSize = Hive->DirtyVector.SizeOfBitMap; SaveBaseBlock = Hive->BaseBlock; AltDirtyVectorSize = (Hive->Storage[Stable].Length / HSECTOR_SIZE) / 8; AltDirtyVector = (Hive->Allocate)(ROUND_UP(AltDirtyVectorSize,sizeof(ULONG)), FALSE); if (AltDirtyVector == NULL) { status = STATUS_INSUFFICIENT_RESOURCES; goto Exit1; } Hive->DirtyVector.Buffer = AltDirtyVector; Hive->DirtyVector.SizeOfBitMap = AltDirtyVectorSize * 8; RtlSetAllBits(&(Hive->DirtyVector)); // // Splice in a duplicate BaseBlock // AltBaseBlock = (Hive->Allocate)(sizeof(HBASE_BLOCK), TRUE); if (AltBaseBlock == NULL) { status = STATUS_INSUFFICIENT_RESOURCES; goto Exit2; } // // Make sure the buffer we got back is cluster-aligned. If not, try // harder to get an aligned buffer. // Alignment = Hive->Cluster * HSECTOR_SIZE - 1; if (((ULONG_PTR)AltBaseBlock & Alignment) != 0) { (Hive->Free)(AltBaseBlock, sizeof(HBASE_BLOCK)); AltBaseBlock = (PHBASE_BLOCK)((Hive->Allocate)(PAGE_SIZE, TRUE)); if (AltBaseBlock == NULL) { status = STATUS_INSUFFICIENT_RESOURCES; goto Exit2; } // // Return the quota for the extra allocation, as we are not really using // it and it will not be accounted for later when we free it. // CmpReleaseGlobalQuota(PAGE_SIZE - sizeof(HBASE_BLOCK)); } RtlMoveMemory(AltBaseBlock, SaveBaseBlock, HSECTOR_SIZE); Hive->BaseBlock = AltBaseBlock; // // Ensure the file can be made big enough, then do the deed // status = CmpDoFileSetSize(Hive, HFILE_TYPE_EXTERNAL, Hive->Storage[Stable].Length); if (NT_SUCCESS(status)) { if (!HvpDoWriteHive(Hive, HFILE_TYPE_EXTERNAL)) { status = STATUS_REGISTRY_IO_FAILED; } } // // Clean up, success or failure // CmpFree(AltBaseBlock, sizeof(HBASE_BLOCK)); Exit2: CmpFree(AltDirtyVector, ROUND_UP(AltDirtyVectorSize,sizeof(ULONG))); Exit1: Hive->DirtyVector.Buffer = SaveDirtyVector; Hive->DirtyVector.SizeOfBitMap = SaveDirtyVectorSize; Hive->BaseBlock = SaveBaseBlock; return status; }

---