hivesync.c File Reference

#include "cmp.h"

Go to the source code of this file.

Defines
#define	DumpDirtyVector(Hive)
Functions
BOOLEAN	HvpWriteLog (PHHIVE Hive)
BOOLEAN	HvpFindNextDirtyBlock (PHHIVE Hive, PRTL_BITMAP BitMap, PULONG Current, PUCHAR *Address, PULONG Length, PULONG Offset)
VOID	HvpDiscardBins (PHHIVE Hive)
VOID	HvpTruncateBins (PHHIVE Hive)
VOID	HvRefreshHive (PHHIVE Hive)
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)
BOOLEAN	HvpGrowLog1 (PHHIVE Hive, ULONG Count)
BOOLEAN	HvpGrowLog2 (PHHIVE Hive, ULONG Size)
BOOLEAN	HvSyncHive (PHHIVE Hive)
BOOLEAN	HvpDoWriteHive (PHHIVE Hive, ULONG FileType)
NTSTATUS	HvWriteHive (PHHIVE Hive)
VOID	HvpDiscardBins (IN PHHIVE Hive)
VOID	HvpTruncateBins (IN PHHIVE Hive)
Variables
BOOLEAN	HvShutdownComplete

---

Define Documentation

#define DumpDirtyVector (  Hive   )

Definition at line 52 of file hivesync.c. Referenced by HvSyncHive().

---

Function Documentation

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 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(), _HBIN::Signature, _HHIVE::Signature, _HCELL::Size, _HBIN::Size, 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); }

VOID HvpDiscardBins (  IN PHHIVE  Hive  )

Definition at line 1885 of file hivesync.c. References ASSERT, ASSERT_LISTENTRY, Bin, _HMAP_ENTRY::BinAddress, ExFreePool(), _FREE_HBIN::FileOffset, _FREE_HBIN::Flags, FREE_HBIN_DISCARDABLE, Hive, HMAP_BASE, HMAP_DISCARDABLE, HvpGetCellMap(), List, Stable, and VALIDATE_CELL_MAP. Referenced by HvSyncHive(). : Walks through the dirty bins in a hive to see if any are marked discardable. If so, they are discarded and the map is updated to reflect this. Arguments: Hive - Supplies the hive control structure. Return Value: None. --*/ { PHBIN Bin; PHMAP_ENTRY Map; PHMAP_ENTRY PreviousMap; PHMAP_ENTRY NextMap; PFREE_HBIN FreeBin; PFREE_HBIN PreviousFreeBin; PFREE_HBIN NextFreeBin; PLIST_ENTRY List; List = Hive->Storage[Stable].FreeBins.Flink; while (List != &Hive->Storage[Stable].FreeBins) { ASSERT_LISTENTRY(List); FreeBin = CONTAINING_RECORD(List, FREE_HBIN, ListEntry); if (FreeBin->Flags & FREE_HBIN_DISCARDABLE) { Map = HvpGetCellMap(Hive, FreeBin->FileOffset); VALIDATE_CELL_MAP(__LINE__,Map,Hive,FreeBin->FileOffset); Bin = (PHBIN)(Map->BinAddress & HMAP_BASE); ASSERT(Map->BinAddress & HMAP_DISCARDABLE); // // Note we use ExFreePool directly here to avoid // giving back the quota for this bin. By charging // registry quota for discarded bins, we prevent // sparse hives from requiring more quota after // a reboot than on a running system. // ExFreePool(Bin); FreeBin->Flags &= ~FREE_HBIN_DISCARDABLE; } List=List->Flink; } }

VOID HvpDiscardBins (  PHHIVE  Hive  )

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, _HHIVE::Cluster, _HBASE_BLOCK::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, _HBASE_BLOCK::TimeStamp, _HBIN::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; }

BOOLEAN HvpFindNextDirtyBlock (  PHHIVE  Hive, PRTL_BITMAP  BitMap, PULONG  Current, PUCHAR *  Address, PULONG  Length, PULONG  Offset )

Definition at line 1233 of file hivesync.c. References ASSERT, _HMAP_ENTRY::BinAddress, BitMap, _HMAP_ENTRY::BlockAddress, CML_FLOW, CMLOG, CMS_IO, End, FALSE, _FREE_HBIN::FileOffset, HBIN_SIGNATURE, HBLOCK_SIZE, HCELL_INDEX, HCELL_OFFSET_MASK, Hive, HMAP_BASE, HMAP_DISCARDABLE, HSECTOR_COUNT, HSECTOR_SIZE, HvpGetCellMap(), NULL, Offset, ROUND_UP, Start, TRUE, and VALIDATE_CELL_MAP. Referenced by HvpDoWriteHive(), HvpWriteLog(), and HvRefreshHive(). : This routine finds and reports the largest run of dirty logical sectors in the hive, which are contiguous in memory and on disk. Arguments: Hive - pointer to Hive of interest. BitMap - supplies a pointer to a bitmap structure, which describes what is dirty. Current - supplies a pointer to a varible that tracks position in the bitmap. It is a bitnumber. It is updated by this call. Address - supplies a pointer to a variable to receive a pointer to the area in memory to be written out. Length - supplies a pointer to a variable to receive the length of the region to read/write Offset - supplies a pointer to a variable to receive the offset in the backing file to which the data should be written. (not valid for log files) Return Value: TRUE - more to write, ret values good FALSE - all data has been written --*/ { ULONG i; ULONG EndOfBitMap; ULONG Start; ULONG End; HCELL_INDEX FileBaseAddress; HCELL_INDEX FileEndAddress; PHMAP_ENTRY Me; PUCHAR Block; PUCHAR StartBlock; PUCHAR NextBlock; ULONG RunSpan; ULONG RunLength; ULONG FileLength; PFREE_HBIN FreeBin; CMLOG(CML_FLOW, CMS_IO) { KdPrint(("HvpFindNextDirtyBlock:\n\t")); KdPrint(("Hive:%08lx Current:%08lx\n", Hive, *Current)); } EndOfBitMap = BitMap->SizeOfBitMap; if (*Current >= EndOfBitMap) { return FALSE; } // // Find next run of set bits // for (i = *Current; i < EndOfBitMap; i++) { if (RtlCheckBit(BitMap, i) == 1) { break; } } Start = i; for ( ; i < EndOfBitMap; i++) { if (RtlCheckBit(BitMap, i) == 0) { break; } } End = i; // // Compute hive virtual addresses, beginning file address, memory address // FileBaseAddress = Start * HSECTOR_SIZE; FileEndAddress = End * HSECTOR_SIZE; FileLength = FileEndAddress - FileBaseAddress; if (FileLength == 0) { *Address = NULL; *Current = 0xffffffff; *Length = 0; return FALSE; } Me = HvpGetCellMap(Hive, FileBaseAddress); VALIDATE_CELL_MAP(__LINE__,Me,Hive,FileBaseAddress); if (Me->BinAddress & HMAP_DISCARDABLE) { FreeBin = (PFREE_HBIN)Me->BlockAddress; StartBlock = (PUCHAR)((Me->BinAddress & HMAP_BASE) + FileBaseAddress - FreeBin->FileOffset ); } else { StartBlock = (PUCHAR)Me->BlockAddress; } Block = StartBlock; ASSERT(((PHBIN)(Me->BinAddress & HMAP_BASE))->Signature == HBIN_SIGNATURE); *Address = Block + (FileBaseAddress & HCELL_OFFSET_MASK); *Offset = FileBaseAddress + HBLOCK_SIZE; // // Build up length. First, account for sectors in first block. // RunSpan = HSECTOR_COUNT - (Start % HSECTOR_COUNT); if ((End - Start) <= RunSpan) { // // Entire length is in first block, return it // *Length = FileLength; *Current = End; return TRUE; } else { RunLength = RunSpan * HSECTOR_SIZE; FileBaseAddress = ROUND_UP(FileBaseAddress+1, HBLOCK_SIZE); } // // Scan forward through blocks, filling up length as we go. // // NOTE: This loop grows forward 1 block at time. If we were // really clever we'd fill forward a bin at time, since // bins are always contiguous. But most bins will be // one block long anyway, so we won't bother for now. // while (RunLength < FileLength) { Me = HvpGetCellMap(Hive, FileBaseAddress); VALIDATE_CELL_MAP(__LINE__,Me,Hive,FileBaseAddress); ASSERT(((PHBIN)(Me->BinAddress & HMAP_BASE))->Signature == HBIN_SIGNATURE); if (Me->BinAddress & HMAP_DISCARDABLE) { FreeBin = (PFREE_HBIN)Me->BlockAddress; NextBlock = (PUCHAR)((Me->BinAddress & HMAP_BASE) + FileBaseAddress - FreeBin->FileOffset ); } else { NextBlock = (PUCHAR)Me->BlockAddress; } if ( (NextBlock - Block) != HBLOCK_SIZE) { // // We've hit a discontinuity in memory. RunLength is // as long as it's going to get. // break; } if ((FileEndAddress - FileBaseAddress) <= HBLOCK_SIZE) { // // We've reached the tail block, all is contiguous, // fill up to end and return. // *Length = FileLength; *Current = End; return TRUE; } // // Just another contiguous block, fill forward // RunLength += HBLOCK_SIZE; RunSpan += HSECTOR_COUNT; FileBaseAddress += HBLOCK_SIZE; Block = NextBlock; } // // We either hit a discontinuity, OR, we're at the end of the range // we're trying to fill. In either case, return. // *Length = RunLength; *Current = Start + RunSpan; return TRUE; }

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; }

VOID HvpTruncateBins (  IN PHHIVE  Hive  )

Definition at line 1946 of file hivesync.c. References _HMAP_ENTRY::BinAddress, _HMAP_ENTRY::BlockAddress, _FREE_HBIN::FileOffset, HBLOCK_SIZE, HCELL_TYPE_MASK, Hive, HMAP_DISCARDABLE, HSTORAGE_TYPE, HTYPE_COUNT, HvFreeHivePartial(), HvpGetCellMap(), and VALIDATE_CELL_MAP. Referenced by HvSyncHive(). : Attempts to shrink the hive by truncating any bins that are discardable at the end of the hive. Applies to both stable and volatile storage. Arguments: Hive - Supplies the hive to be truncated. Return Value: None. --*/ { HSTORAGE_TYPE i; PHMAP_ENTRY Map; ULONG NewLength; PFREE_HBIN FreeBin; // // stable and volatile // for (i=0;i<HTYPE_COUNT;i++) { // // find the last in-use bin in the hive // NewLength = Hive->Storage[i].Length; while (NewLength > 0) { Map = HvpGetCellMap(Hive, (NewLength - HBLOCK_SIZE) + (i*HCELL_TYPE_MASK)); VALIDATE_CELL_MAP(__LINE__,Map,Hive,(NewLength - HBLOCK_SIZE) + (i*HCELL_TYPE_MASK)); if (Map->BinAddress & HMAP_DISCARDABLE) { FreeBin = (PFREE_HBIN)Map->BlockAddress; NewLength = FreeBin->FileOffset; } else { break; } } if (NewLength < Hive->Storage[i].Length) { // // There are some free bins to truncate. // HvFreeHivePartial(Hive, NewLength, i); } } }

VOID HvpTruncateBins (  PHHIVE  Hive  )

BOOLEAN HvpWriteLog (  PHHIVE  Hive  )

Definition at line 1025 of file hivesync.c. References ASSERT, _HHIVE::BaseBlock, BitMap, _HBASE_BLOCK::CheckSum, _HBASE_BLOCK::Cluster, _HHIVE::Cluster, CML_MINOR, CMLOG, 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, HFILE_TYPE_LOG, Hive, HLOG_DV_SIGNATURE, HLOG_HEADER_SIZE, HSECTOR_SIZE, HSYS_MAJOR, HvpFindNextDirtyBlock(), HvpHeaderCheckSum(), KeQuerySystemTime(), _HBASE_BLOCK::Major, NULL, Offset, PagedPool, PCMP_OFFSET_ARRAY, _HHIVE::ReadOnly, ROUND_UP, RtlNumberOfSetBits(), _HBASE_BLOCK::Sequence1, _HBASE_BLOCK::Sequence2, _HBASE_BLOCK::Signature, _HBASE_BLOCK::TimeStamp, TRUE, and _HBASE_BLOCK::Type. Referenced by HvSyncHive(). : Write a header, the DirtyVector, and all the dirty data into the log file. Do flushes at the right places. Update the header. Arguments: Hive - pointer to Hive for which dirty data is to be logged. Return Value: TRUE - it worked FALSE - it failed --*/ { PHBASE_BLOCK BaseBlock; ULONG Offset; PUCHAR Address; ULONG Length; BOOLEAN rc; ULONG Current; ULONG junk; ULONG ClusterSize; ULONG HeaderLength; PRTL_BITMAP BitMap; ULONG DirtyVectorSignature = HLOG_DV_SIGNATURE; LARGE_INTEGER systemtime; PCMP_OFFSET_ARRAY offsetArray; CMP_OFFSET_ARRAY offsetElement; ULONG Count; ULONG SetBitCount; CMLOG(CML_MINOR, CMS_IO) { KdPrint(("HvpWriteLog:\n\t")); KdPrint(("Hive:%08lx\n", Hive)); } BitMap = &Hive->DirtyVector; // // --- Write out header first time, flush --- // BaseBlock = Hive->BaseBlock; 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->Sequence1++; KeQuerySystemTime(&systemtime); BaseBlock->TimeStamp = systemtime; BaseBlock->Type = HFILE_TYPE_LOG; ClusterSize = Hive->Cluster * HSECTOR_SIZE; HeaderLength = ROUND_UP(HLOG_HEADER_SIZE, ClusterSize); 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, HFILE_TYPE_LOG, &offsetElement, 1, &Offset ); if (rc == FALSE) { return FALSE; } Offset = ROUND_UP(Offset, HeaderLength); if ( ! (Hive->FileFlush)(Hive, HFILE_TYPE_LOG)) { return FALSE; } // // --- Write out dirty vector --- // ASSERT(sizeof(ULONG) == sizeof(DirtyVectorSignature)); // See GrowLog1 above offsetElement.FileOffset = Offset; offsetElement.DataBuffer = (PVOID) &DirtyVectorSignature; offsetElement.DataLength = sizeof(DirtyVectorSignature); rc = (Hive->FileWrite)( Hive, HFILE_TYPE_LOG, &offsetElement, 1, &Offset ); if (rc == FALSE) { return FALSE; } Length = Hive->DirtyVector.SizeOfBitMap / 8; Address = (PUCHAR)(Hive->DirtyVector.Buffer); offsetElement.FileOffset = Offset; offsetElement.DataBuffer = (PVOID) Address; offsetElement.DataLength = Length; rc = (Hive->FileWrite)( Hive, HFILE_TYPE_LOG, &offsetElement, 1, &Offset ); if (rc == FALSE) { return FALSE; } Offset = ROUND_UP(Offset, ClusterSize); // // --- Write out body of log --- // SetBitCount = RtlNumberOfSetBits(BitMap); offsetArray = (PCMP_OFFSET_ARRAY) ExAllocatePool(PagedPool, sizeof(CMP_OFFSET_ARRAY) * SetBitCount); if (offsetArray == NULL) { return FALSE; } Count = 0; Current = 0; while (HvpFindNextDirtyBlock( Hive, BitMap, &Current, &Address, &Length, &junk ) == 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 % ClusterSize) == 0); } rc = (Hive->FileWrite)( Hive, HFILE_TYPE_LOG, 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, HFILE_TYPE_LOG)) { 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, HFILE_TYPE_LOG, &offsetElement, 1, &Offset ); if (rc == FALSE) { return FALSE; } if ( ! (Hive->FileFlush)(Hive, HFILE_TYPE_LOG)) { return FALSE; } return TRUE; }

VOID HvRefreshHive (  PHHIVE  Hive  )

Referenced by CmpWorker().

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; }

---

Variable Documentation

BOOLEAN HvShutdownComplete

Definition at line 27 of file hivesync.c. Referenced by CmpLazyFlushWorker(), CmShutdownSystem(), HvSyncHive(), and HvWriteHive().

---