hivewrt.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Kernel
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Configuration Manager Library - Registry Syncing & Hive/Log/Alternate Writing
 * COPYRIGHT:   Copyright 2001 - 2005 Eric Kohl
 *              Copyright 2005 Filip Navara <navaraf@reactos.org>
 *              Copyright 2021 Max Korostil
 *              Copyright 2022 George Bișoc <george.bisoc@reactos.org>
 */
 
#include "cmlib.h"
#define NDEBUG
#include <debug.h>
 
/* DECLARATIONS *************************************************************/
 
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
BOOLEAN
NTAPI
IoSetThreadHardErrorMode(
    _In_ BOOLEAN HardErrorEnabled);
#endif
 
/* GLOBALS ******************************************************************/
 
/* PRIVATE FUNCTIONS ********************************************************/
 
static
VOID
HvpValidateBaseHeader(
    _In_ PHHIVE RegistryHive)
{
    PHBASE_BLOCK BaseBlock;
 
    /*
     * Cache the base block and validate it.
     * Especially...
     *
     * 1. It must must have a valid signature.
     * 2. It must have a valid format.
     * 3. It must be of an adequate major version,
     *    not anything else.
     */
    BaseBlock = RegistryHive->BaseBlock;
    ASSERT(BaseBlock->Signature == HV_HBLOCK_SIGNATURE);
    ASSERT(BaseBlock->Format == HBASE_FORMAT_MEMORY);
    ASSERT(BaseBlock->Major == HSYS_MAJOR);
}
 
static
BOOLEAN
CMAPI
HvpWriteLog(
    _In_ PHHIVE RegistryHive)
{
    BOOLEAN Success;
    ULONG FileOffset;
    ULONG BlockIndex;
    ULONG LastIndex;
    PVOID Block;
    UINT32 BitmapSize, BufferSize;
    PUCHAR HeaderBuffer, Ptr;
 
    /*
     * The hive log we are going to write data into
     * has to be writable and with a sane storage.
     */
    ASSERT(!RegistryHive->ReadOnly);
    ASSERT(RegistryHive->BaseBlock->Length ==
           RegistryHive->Storage[Stable].Length * HBLOCK_SIZE);
 
    /* Validate the base header before we go further */
    HvpValidateBaseHeader(RegistryHive);
 
    /*
     * The sequences can diverge during a forced system shutdown
     * occurrence, such as during a power failure, a hardware
     * failure or during a system crash, and when one of the
     * sequences have been modified during writing into the log
     * or hive. In such cases the hive needs a repair.
     */
    if (RegistryHive->BaseBlock->Sequence1 !=
        RegistryHive->BaseBlock->Sequence2)
    {
        DPRINT1("The sequences DO NOT MATCH (Sequence1 == 0x%x, Sequence2 == 0x%x)\n",
                RegistryHive->BaseBlock->Sequence1, RegistryHive->BaseBlock->Sequence2);
        return FALSE;
    }
 
    /*
     * FIXME: We must set a new file size for this log
     * here but ReactOS lacks the necessary code implementation
     * that manages the growing and shrinking of a hive's log
     * size. So for now don't set any new size for the log.
     */
 
    /*
     * Now calculate the bitmap and buffer sizes to hold up our
     * contents in a buffer.
     */
    BitmapSize = ROUND_UP(sizeof(ULONG) + RegistryHive->DirtyVector.SizeOfBitMap, HSECTOR_SIZE);
    BufferSize = HV_LOG_HEADER_SIZE + BitmapSize;
 
    /* Now allocate the base header block buffer */
    HeaderBuffer = RegistryHive->Allocate(BufferSize, TRUE, TAG_CM);
    if (!HeaderBuffer)
    {
        DPRINT1("Couldn't allocate buffer for base header block\n");
        return FALSE;
    }
 
    /* Great, now zero out the buffer */
    RtlZeroMemory(HeaderBuffer, BufferSize);
 
    /*
     * Update the base block of this hive and
     * increment the primary sequence number
     * as we are at the half of the work.
     */
    RegistryHive->BaseBlock->Type = HFILE_TYPE_LOG;
    RegistryHive->BaseBlock->Sequence1++;
    RegistryHive->BaseBlock->CheckSum = HvpHiveHeaderChecksum(RegistryHive->BaseBlock);
 
    /* Copy the base block header */
    RtlCopyMemory(HeaderBuffer, RegistryHive->BaseBlock, HV_LOG_HEADER_SIZE);
    Ptr = HeaderBuffer + HV_LOG_HEADER_SIZE;
 
    /* Copy the dirty vector */
    *((PULONG)Ptr) = HV_LOG_DIRTY_SIGNATURE;
    Ptr += sizeof(HV_LOG_DIRTY_SIGNATURE);
 
    /*
     * FIXME: In ReactOS a vector contains one bit per block
     * whereas in Windows each bit within a vector is per
     * sector. Furthermore, the dirty blocks within a respective
     * hive has to be marked as such in an appropriate function
     * for this purpose (probably HvMarkDirty or similar).
     *
     * For the moment being, mark the relevant dirty blocks
     * here.
     */
    BlockIndex = 0;
    while (BlockIndex < RegistryHive->Storage[Stable].Length)
    {
        /* Check if the block is clean or we're past the last block */
        LastIndex = BlockIndex;
        BlockIndex = RtlFindSetBits(&RegistryHive->DirtyVector, 1, BlockIndex);
        if (BlockIndex == ~HV_CLEAN_BLOCK || BlockIndex < LastIndex)
        {
            break;
        }
 
        /*
         * Mark this block as dirty and go to the next one.
         *
         * FIXME: We should rather use RtlSetBits but that crashes
         * the system with a bugckeck. So for now mark blocks manually
         * by hand.
         */
        Ptr[BlockIndex] = HV_LOG_DIRTY_BLOCK;
        BlockIndex++;
    }
 
    /* Now write the hive header and block bitmap into the log */
    FileOffset = 0;
    Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_LOG,
                                      &FileOffset, HeaderBuffer, BufferSize);
    RegistryHive->Free(HeaderBuffer, 0);
    if (!Success)
    {
        DPRINT1("Failed to write the hive header block to log (primary sequence)\n");
        return FALSE;
    }
 
    /* Now write the actual dirty data to log */
    FileOffset = BufferSize;
    BlockIndex = 0;
    while (BlockIndex < RegistryHive->Storage[Stable].Length)
    {
        /* Check if the block is clean or we're past the last block */
        LastIndex = BlockIndex;
        BlockIndex = RtlFindSetBits(&RegistryHive->DirtyVector, 1, BlockIndex);
        if (BlockIndex == ~HV_CLEAN_BLOCK || BlockIndex < LastIndex)
        {
            break;
        }
 
        /* Get the block */
        Block = (PVOID)RegistryHive->Storage[Stable].BlockList[BlockIndex].BlockAddress;
 
        /* Write it to log */
        Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_LOG,
                                          &FileOffset, Block, HBLOCK_SIZE);
        if (!Success)
        {
            DPRINT1("Failed to write dirty block to log (block 0x%p, block index 0x%x)\n", Block, BlockIndex);
            return FALSE;
        }
 
        /* Grow up the file offset as we go to the next block */
        BlockIndex++;
        FileOffset += HBLOCK_SIZE;
    }
 
    /*
     * We wrote the header and body of log with dirty,
     * data do a flush immediately.
     */
    Success = RegistryHive->FileFlush(RegistryHive, HFILE_TYPE_LOG, NULL, 0);
    if (!Success)
    {
        DPRINT1("Failed to flush the log\n");
        return FALSE;
    }
 
    /*
     * OK, we're now at 80% of the work done.
     * Increment the secondary sequence and flush
     * the log again. We can have a fully successful
     * transacted write of a log if the sequences
     * are synced up properly.
     */
    RegistryHive->BaseBlock->Sequence2++;
    RegistryHive->BaseBlock->CheckSum = HvpHiveHeaderChecksum(RegistryHive->BaseBlock);
 
    /* Write new stuff into log first */
    FileOffset = 0;
    Success = RegistryHive->FileWrite(RegistryHive, HFILE_TYPE_LOG,
                                      &FileOffset, RegistryHive->BaseBlock,
                                      HV_LOG_HEADER_SIZE);
    if (!Success)
    {
        DPRINT1("Failed to write the log file (secondary sequence)\n");
        return FALSE;
    }
 
    /* Flush it finally */
    Success = RegistryHive->FileFlush(RegistryHive, HFILE_TYPE_LOG, NULL, 0);
    if (!Success)
    {
        DPRINT1("Failed to flush the log\n");
        return FALSE;
    }
 
    return TRUE;
}
 
static
BOOLEAN
CMAPI
HvpWriteHive(
    _In_ PHHIVE RegistryHive,
    _In_ BOOLEAN OnlyDirty,
    _In_ ULONG FileType)
{
    BOOLEAN Success;
    ULONG FileOffset;
    ULONG BlockIndex;
    ULONG LastIndex;
    PVOID Block;
 
    ASSERT(!RegistryHive->ReadOnly);
    ASSERT(RegistryHive->BaseBlock->Length ==
           RegistryHive->Storage[Stable].Length * HBLOCK_SIZE);
    ASSERT(RegistryHive->BaseBlock->RootCell != HCELL_NIL);
 
    /* Validate the base header before we go further */
    HvpValidateBaseHeader(RegistryHive);
 
    /*
     * The sequences can diverge during a forced system shutdown
     * occurrence, such as during a power failure, a hardware
     * failure or during a system crash, and when one of the
     * sequences have been modified during writing into the log
     * or hive. In such cases the hive needs a repair.
     */
    if (RegistryHive->BaseBlock->Sequence1 !=
        RegistryHive->BaseBlock->Sequence2)
    {
        DPRINT1("The sequences DO NOT MATCH (Sequence1 == 0x%x, Sequence2 == 0x%x)\n",
                RegistryHive->BaseBlock->Sequence1, RegistryHive->BaseBlock->Sequence2);
        return FALSE;
    }
 
    /*
     * Update the primary sequence number and write
     * the base block to hive.
     */
    RegistryHive->BaseBlock->Type = HFILE_TYPE_PRIMARY;
    RegistryHive->BaseBlock->Sequence1++;
    RegistryHive->BaseBlock->CheckSum = HvpHiveHeaderChecksum(RegistryHive->BaseBlock);
 
    /* Write hive block */
    FileOffset = 0;
    Success = RegistryHive->FileWrite(RegistryHive, FileType,
                                      &FileOffset, RegistryHive->BaseBlock,
                                      sizeof(HBASE_BLOCK));
    if (!Success)
    {
        DPRINT1("Failed to write the base block header to primary hive (primary sequence)\n");
        return FALSE;
    }
 
    /* Write the whole primary hive, block by block */
    BlockIndex = 0;
    while (BlockIndex < RegistryHive->Storage[Stable].Length)
    {
        /*
         * If we have to synchronize the registry hive we
         * want to look for dirty blocks to reflect the new
         * updates done to the hive. Otherwise just write
         * all the blocks as if we were doing a regular
         * hive write.
         */
        if (OnlyDirty)
        {
            /* Check if the block is clean or we're past the last block */
            LastIndex = BlockIndex;
            BlockIndex = RtlFindSetBits(&RegistryHive->DirtyVector, 1, BlockIndex);
            if (BlockIndex == ~HV_CLEAN_BLOCK || BlockIndex < LastIndex)
            {
                break;
            }
        }
 
        /* Get the block and offset position */
        Block = (PVOID)RegistryHive->Storage[Stable].BlockList[BlockIndex].BlockAddress;
        FileOffset = (BlockIndex + 1) * HBLOCK_SIZE;
 
        /* Now write this block to primary hive file */
        Success = RegistryHive->FileWrite(RegistryHive, FileType,
                                          &FileOffset, Block, HBLOCK_SIZE);
        if (!Success)
        {
            DPRINT1("Failed to write hive block to primary hive file (block 0x%p, block index 0x%x)\n",
                    Block, BlockIndex);
            return FALSE;
        }
 
        /* Go to the next block */
        BlockIndex++;
    }
 
    /*
     * We wrote all the hive contents to the file, we
     * must flush the changes to disk now.
     */
    Success = RegistryHive->FileFlush(RegistryHive, FileType, NULL, 0);
    if (!Success)
    {
        DPRINT1("Failed to flush the primary hive\n");
        return FALSE;
    }
 
    /*
     * Increment the secondary sequence number and
     * update the checksum. A successful hive write
     * transaction is when both of sequences are the
     * same, indicating the write operation didn't
     * fail.
     */
    RegistryHive->BaseBlock->Sequence2++;
    RegistryHive->BaseBlock->CheckSum = HvpHiveHeaderChecksum(RegistryHive->BaseBlock);
 
    /* Write hive block */
    FileOffset = 0;
    Success = RegistryHive->FileWrite(RegistryHive, FileType,
                                      &FileOffset, RegistryHive->BaseBlock,
                                      sizeof(HBASE_BLOCK));
    if (!Success)
    {
        DPRINT1("Failed to write the base block header to primary hive (secondary sequence)\n");
        return FALSE;
    }
 
    /* Flush the hive immediately */
    Success = RegistryHive->FileFlush(RegistryHive, FileType, NULL, 0);
    if (!Success)
    {
        DPRINT1("Failed to flush the primary hive\n");
        return FALSE;
    }
 
    return TRUE;
}
 
/* PUBLIC FUNCTIONS ***********************************************************/
 
BOOLEAN
CMAPI
HvSyncHive(
    _In_ PHHIVE RegistryHive)
{
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
    BOOLEAN HardErrors;
#endif
 
    ASSERT(!RegistryHive->ReadOnly);
    ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
 
    /* Avoid any write operations on volatile hives */
    if (RegistryHive->HiveFlags & HIVE_VOLATILE)
    {
        DPRINT("Hive 0x%p is volatile\n", RegistryHive);
        return TRUE;
    }
 
    /*
     * Check if there's any dirty data in the vector.
     * A space with clean blocks would be pointless for
     * a log because we want to write dirty data in and
     * sync up, not clean data. So just consider our
     * job as done as there's literally nothing to do.
     */
    if (RtlFindSetBits(&RegistryHive->DirtyVector, 1, 0) == ~HV_CLEAN_BLOCK)
    {
        DPRINT("The dirty vector has clean data, nothing to do\n");
        return TRUE;
    }
 
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
    /* Disable hard errors before syncing the hive */
    HardErrors = IoSetThreadHardErrorMode(FALSE);
#endif
 
#if !defined(_BLDR_)
    /* Update hive header modification time */
    KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp);
#endif
 
    /* Update the hive log file if present */
    if (RegistryHive->Log)
    {
        if (!HvpWriteLog(RegistryHive))
        {
            DPRINT1("Failed to write a log whilst syncing the hive\n");
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
            IoSetThreadHardErrorMode(HardErrors);
#endif
            return FALSE;
        }
    }
 
    /* Update the primary hive file */
    if (!HvpWriteHive(RegistryHive, TRUE, HFILE_TYPE_PRIMARY))
    {
        DPRINT1("Failed to write the primary hive\n");
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
        IoSetThreadHardErrorMode(HardErrors);
#endif
        return FALSE;
    }
 
    /* Update the alternate hive file if present */
    if (RegistryHive->Alternate)
    {
        if (!HvpWriteHive(RegistryHive, TRUE, HFILE_TYPE_ALTERNATE))
        {
            DPRINT1("Failed to write the alternate hive\n");
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
            IoSetThreadHardErrorMode(HardErrors);
#endif
            return FALSE;
        }
    }
 
    /* Clear dirty bitmap. */
    RtlClearAllBits(&RegistryHive->DirtyVector);
    RegistryHive->DirtyCount = 0;
 
#if !defined(CMLIB_HOST) && !defined(_BLDR_)
    IoSetThreadHardErrorMode(HardErrors);
#endif
    return TRUE;
}
 
BOOLEAN
CMAPI
HvHiveWillShrink(
    _In_ PHHIVE RegistryHive)
{
    /* No shrinking yet */
    UNIMPLEMENTED_ONCE;
    return FALSE;
}
 
BOOLEAN
CMAPI
HvWriteHive(
    _In_ PHHIVE RegistryHive)
{
    ASSERT(!RegistryHive->ReadOnly);
    ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
 
#if !defined(_BLDR_)
    /* Update hive header modification time */
    KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp);
#endif
 
    /* Update hive file */
    if (!HvpWriteHive(RegistryHive, FALSE, HFILE_TYPE_PRIMARY))
    {
        DPRINT1("Failed to write the hive\n");
        return FALSE;
    }
 
    return TRUE;
}
 
BOOLEAN
CMAPI
HvWriteAlternateHive(
    _In_ PHHIVE RegistryHive)
{
    ASSERT(!RegistryHive->ReadOnly);
    ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
    ASSERT(RegistryHive->Alternate);
 
#if !defined(_BLDR_)
    /* Update hive header modification time */
    KeQuerySystemTime(&RegistryHive->BaseBlock->TimeStamp);
#endif
 
    /* Update hive file */
    if (!HvpWriteHive(RegistryHive, FALSE, HFILE_TYPE_ALTERNATE))
    {
        DPRINT1("Failed to write the alternate hive\n");
        return FALSE;
    }
 
    return TRUE;
}
 
BOOLEAN
CMAPI
HvSyncHiveFromRecover(
    _In_ PHHIVE RegistryHive)
{
    ASSERT(!RegistryHive->ReadOnly);
    ASSERT(RegistryHive->Signature == HV_HHIVE_SIGNATURE);
 
    /* Call the private API call to do the deed for us */
    return HvpWriteHive(RegistryHive, TRUE, HFILE_TYPE_PRIMARY);
}
 
/* EOF */