windows-server-2003/base/fs/sis/groveler/logdrive.cpp

/*++

Copyright (c) 1998  Microsoft Corporation

Module Name:

    logdrive.cpp

Abstract:

    SIS Groveler logging drive class

Authors:

    John Douceur, 1998

Environment:

    User Mode


Revision History:


--*/

#include "all.hxx"

static const _TCHAR registry_parameter_path[] = _T("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Groveler\\Parameters");
static const _TCHAR *log_drive_key_name = _T("log drive");

LogDrive::LogDrive()
{
    _TCHAR *guid_name;

    part_initted = 0;
    registry_written = false;
    log_drive_index = 0;
    _TCHAR reg_name[MAX_PATH + 1];
    read_registry(reg_name,sizeof(reg_name));

    int partition_count = sis_drives.partition_count();
    ASSERT(partition_count > 0);

    part_initted = new bool[partition_count];
    for (int index = 0; index < partition_count; index++)
    {
        part_initted[index] = false;
    }

    for (index = 0; index < partition_count; index++)
    {
        guid_name = sis_drives.partition_guid_name(index);
        if (_tcsicmp(reg_name, guid_name) == 0)
        {
            log_drive_index = index;
            write_registry(_T(""));
            return;
        }
    }

    __int64 log_drive_space = 0;
    for (index = 0; index < partition_count; index++)
    {
        guid_name = sis_drives.partition_guid_name(index);
        ULARGE_INTEGER my_free_bytes;
        ULARGE_INTEGER total_bytes;
        ULARGE_INTEGER free_bytes;
        int ok = GetDiskFreeSpaceEx(
            guid_name, &my_free_bytes, &total_bytes, &free_bytes);
        if (ok)
        {
            __int64 space = free_bytes.QuadPart;
            if (space > log_drive_space)
            {
                log_drive_space = space;
                log_drive_index = index;
            }
        }
        else
        {
            DWORD err = GetLastError();
            PRINT_DEBUG_MSG((_T("GROVELER: GetDiskFreeSpaceEx() failed with error %d\n"),
                err));
        }
    }
    write_registry(_T(""));
}

LogDrive::~LogDrive()
{
    if (part_initted != 0)
    {
        delete[] part_initted;
        part_initted = 0;
    }
}

void
LogDrive::partition_initialized(
    int partition_index)
{
    if (!registry_written)
    {
        int partition_count = sis_drives.partition_count();
        ASSERT(partition_index >= 0);
        ASSERT(partition_index < partition_count);
        part_initted[partition_index] = true;
        for (int index = 0; index < partition_count; index++)
        {
            if (!part_initted[index])
            {
                return;
            }
        }
        write_registry(sis_drives.partition_guid_name(log_drive_index));
        registry_written = true;
    }
}

bool
LogDrive::read_registry(
    _TCHAR *name,
    DWORD size)
{
    DWORD type;
    try
    {
        HKEY path_key = 0;
        Registry::open_key_ex(HKEY_LOCAL_MACHINE,
            registry_parameter_path, REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS, &path_key);
        try
        {
            Registry::query_value_ex(path_key, log_drive_key_name, 0,
                &type, (BYTE *)name, &size);
        }
        catch (DWORD result)
        {
            ASSERT(result != ERROR_SUCCESS);
            PRINT_DEBUG_MSG((
                _T("GROVELER: Registry::query_value_ex() failed with error %d\n"),
                result));
            ASSERT(path_key != 0);
            Registry::close_key(path_key);
            path_key = 0;
            *name = 0;
            return false;
        }
        ASSERT(path_key != 0);
        Registry::close_key(path_key);
        path_key = 0;
    }
    catch (DWORD result)
    {
        ASSERT(result != ERROR_SUCCESS);
        PRINT_DEBUG_MSG((_T("GROVELER: Registry::open_key_ex() or Registry::close_key() ")
            _T("failed with error %d\n"), result));
        *name = 0;
        return false;
    }
    if (type != REG_EXPAND_SZ)
    {
        *name = 0;
        return false;
    }
    return true;
}

bool
LogDrive::write_registry(
    _TCHAR *name)
{
    try
    {
        HKEY path_key = 0;
        DWORD disp;
        Registry::create_key_ex(HKEY_LOCAL_MACHINE,
            registry_parameter_path, 0, 0, REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS, 0, &path_key, &disp);
        try
        {
            Registry::set_value_ex(path_key, log_drive_key_name, 0,
                REG_EXPAND_SZ, (BYTE *)name,
                (_tcslen(name) + 1) * sizeof(_TCHAR));
        }
        catch (DWORD result)
        {
            ASSERT(result != ERROR_SUCCESS);
            PRINT_DEBUG_MSG((
                _T("GROVELER: Registry::set_value_ex() failed with error %d\n"),
                result));
            ASSERT(path_key != 0);
            Registry::close_key(path_key);
            path_key = 0;
            return false;
        }
        ASSERT(path_key != 0);
        Registry::close_key(path_key);
        path_key = 0;
    }
    catch (DWORD result)
    {
        ASSERT(result != ERROR_SUCCESS);
        PRINT_DEBUG_MSG((_T("GROVELER: Registry::create_key_ex() or Registry::close_key() ")
            _T("failed with error %d\n"), result));
        return false;
    }
    return true;
}