reactos/ntoskrnl/config/cmboot.c

1261 lines
39 KiB
C
Raw Normal View History

/*
* PROJECT: ReactOS Kernel
* LICENSE: BSD - See COPYING.ARM in the top level directory
* PURPOSE: Configuration Manager - Boot Initialization
* COPYRIGHT: Copyright 2007 Alex Ionescu (alex.ionescu@reactos.org)
* Copyright 2010 ReactOS Portable Systems Group
* Copyright 2022 Hermès Bélusca-Maïto
*
* NOTE: This module is shared by both the kernel and the bootloader.
*/
/* INCLUDES *******************************************************************/
#include <ntoskrnl.h>
#define NDEBUG
#include <debug.h>
#ifdef _BLDR_
#undef CODE_SEG
#define CODE_SEG(...)
#include <ntstrsafe.h>
#include <cmlib.h>
#include "internal/cmboot.h"
// HACK: This is part of non-NT-compatible SafeBoot support in kernel.
ULONG InitSafeBootMode = 0;
DBG_DEFAULT_CHANNEL(REGISTRY);
#define CMTRACE(x, fmt, ...) TRACE(fmt, ##__VA_ARGS__) // DPRINT
#endif /* _BLDR_ */
/* DEFINES ********************************************************************/
#define CM_BOOT_DEBUG 0x20
#define IS_NULL_TERMINATED(Buffer, Size) \
(((Size) >= sizeof(WCHAR)) && ((Buffer)[(Size) / sizeof(WCHAR) - 1] == UNICODE_NULL))
/* FUNCTIONS ******************************************************************/
// HACK: This is part of non-NT-compatible SafeBoot support in kernel.
extern ULONG InitSafeBootMode;
CODE_SEG("INIT")
static
BOOLEAN
CmpIsSafe(
_In_ PHHIVE Hive,
_In_ HCELL_INDEX SafeBootCell,
_In_ HCELL_INDEX DriverCell);
/**
* @brief
* Finds the corresponding "HKLM\SYSTEM\ControlSetXXX" system control set
* registry key, according to the "Current", "Default", or "LastKnownGood"
* values in the "HKLM\SYSTEM\Select" registry key.
*
* @param[in] SystemHive
* The SYSTEM hive.
*
* @param[in] RootCell
* The root cell of the SYSTEM hive.
*
* @param[in] SelectKeyName
* The control set to check for: either "Current", "Default", or
* "LastKnownGood", the value of which selects the corresponding
* "HKLM\SYSTEM\ControlSetXXX" control set registry key.
*
* @param[out] AutoSelect
* Value of the "AutoSelect" registry value (unused).
*
* @return
* The control set registry key's hive cell (if found), or HCELL_NIL.
**/
CODE_SEG("INIT")
HCELL_INDEX
NTAPI
CmpFindControlSet(
_In_ PHHIVE SystemHive,
_In_ HCELL_INDEX RootCell,
_In_ PCUNICODE_STRING SelectKeyName,
_Out_ PBOOLEAN AutoSelect)
{
UNICODE_STRING Name;
PCM_KEY_NODE Node;
HCELL_INDEX SelectCell, AutoSelectCell, SelectValueCell, ControlSetCell;
HCELL_INDEX CurrentValueCell;
PCM_KEY_VALUE Value;
ULONG Length;
NTSTATUS Status;
PULONG CurrentData;
PULONG ControlSetId;
WCHAR Buffer[128];
/* Sanity check: We shouldn't need to release any acquired cells */
ASSERT(SystemHive->ReleaseCellRoutine == NULL);
/* Get the Select key */
RtlInitUnicodeString(&Name, L"select");
Node = (PCM_KEY_NODE)HvGetCell(SystemHive, RootCell);
if (!Node) return HCELL_NIL;
SelectCell = CmpFindSubKeyByName(SystemHive, Node, &Name);
if (SelectCell == HCELL_NIL) return HCELL_NIL;
/* Get AutoSelect value */
RtlInitUnicodeString(&Name, L"AutoSelect");
Node = (PCM_KEY_NODE)HvGetCell(SystemHive, SelectCell);
if (!Node) return HCELL_NIL;
AutoSelectCell = CmpFindValueByName(SystemHive, Node, &Name);
if (AutoSelectCell == HCELL_NIL)
{
/* Assume TRUE if the value is missing */
*AutoSelect = TRUE;
}
else
{
/* Read the value */
Value = (PCM_KEY_VALUE)HvGetCell(SystemHive, AutoSelectCell);
if (!Value) return HCELL_NIL;
// if (Value->Type != REG_DWORD) return HCELL_NIL;
/* Convert it to a boolean */
CurrentData = (PULONG)CmpValueToData(SystemHive, Value, &Length);
if (!CurrentData) return HCELL_NIL;
// if (Length < sizeof(ULONG)) return HCELL_NIL;
*AutoSelect = *(PBOOLEAN)CurrentData;
}
/* Now find the control set being looked up */
Node = (PCM_KEY_NODE)HvGetCell(SystemHive, SelectCell);
if (!Node) return HCELL_NIL;
SelectValueCell = CmpFindValueByName(SystemHive, Node, SelectKeyName);
if (SelectValueCell == HCELL_NIL) return HCELL_NIL;
/* Read the value (corresponding to the CCS ID) */
Value = (PCM_KEY_VALUE)HvGetCell(SystemHive, SelectValueCell);
if (!Value) return HCELL_NIL;
if (Value->Type != REG_DWORD) return HCELL_NIL;
ControlSetId = (PULONG)CmpValueToData(SystemHive, Value, &Length);
if (!ControlSetId) return HCELL_NIL;
if (Length < sizeof(ULONG)) return HCELL_NIL;
/* Now build the CCS's Name */
Status = RtlStringCbPrintfW(Buffer, sizeof(Buffer),
L"ControlSet%03lu", *ControlSetId);
if (!NT_SUCCESS(Status)) return HCELL_NIL;
/* RtlStringCbPrintfW ensures the buffer to be NULL-terminated */
RtlInitUnicodeString(&Name, Buffer);
/* Now open it */
Node = (PCM_KEY_NODE)HvGetCell(SystemHive, RootCell);
if (!Node) return HCELL_NIL;
ControlSetCell = CmpFindSubKeyByName(SystemHive, Node, &Name);
if (ControlSetCell == HCELL_NIL) return HCELL_NIL;
/* Get the value of the "Current" CCS */
RtlInitUnicodeString(&Name, L"Current");
Node = (PCM_KEY_NODE)HvGetCell(SystemHive, SelectCell);
if (!Node) return HCELL_NIL;
CurrentValueCell = CmpFindValueByName(SystemHive, Node, &Name);
/* Make sure it exists */
if (CurrentValueCell != HCELL_NIL)
{
/* Get the current value and make sure it's a ULONG */
Value = (PCM_KEY_VALUE)HvGetCell(SystemHive, CurrentValueCell);
if (!Value) return HCELL_NIL;
if (Value->Type == REG_DWORD)
{
/* Get the data and update it */
CurrentData = (PULONG)CmpValueToData(SystemHive, Value, &Length);
if (!CurrentData) return HCELL_NIL;
if (Length < sizeof(ULONG)) return HCELL_NIL;
*CurrentData = *ControlSetId;
}
}
/* Return the CCS cell */
return ControlSetCell;
}
/**
* @brief
* Finds the index of the driver's "Tag" value
* in its corresponding group ordering list.
*
* @param[in] Hive
* The SYSTEM hive.
*
* @param[in] TagCell
* The driver's "Tag" registry value's hive cell.
*
* @param[in] GroupOrderCell
* The hive cell of the "Control\GroupOrderList" registry key
* inside the currently selected control set.
*
* @param[in] GroupName
* The driver's group name.
*
* @return
* The corresponding tag index, or -1 (last position),
* or -2 (next-to-last position).
**/
CODE_SEG("INIT")
static
ULONG
CmpFindTagIndex(
_In_ PHHIVE Hive,
_In_ HCELL_INDEX TagCell,
_In_ HCELL_INDEX GroupOrderCell,
_In_ PCUNICODE_STRING GroupName)
{
PCM_KEY_VALUE TagValue, Value;
PCM_KEY_NODE Node;
HCELL_INDEX OrderCell;
PULONG DriverTag, TagOrder;
ULONG CurrentTag, Length;
BOOLEAN BufferAllocated;
/* Sanity check: We shouldn't need to release any acquired cells */
ASSERT(Hive->ReleaseCellRoutine == NULL);
/* Get the tag */
Value = (PCM_KEY_VALUE)HvGetCell(Hive, TagCell);
if (!Value) return -2;
if (Value->Type != REG_DWORD) return -2;
DriverTag = (PULONG)CmpValueToData(Hive, Value, &Length);
if (!DriverTag) return -2;
if (Length < sizeof(ULONG)) return -2;
/* Get the order array */
Node = (PCM_KEY_NODE)HvGetCell(Hive, GroupOrderCell);
if (!Node) return -2;
OrderCell = CmpFindValueByName(Hive, Node, GroupName);
if (OrderCell == HCELL_NIL) return -2;
/* And read it */
TagValue = (PCM_KEY_VALUE)HvGetCell(Hive, OrderCell);
if (!TagValue) return -2;
if (!CmpGetValueData(Hive,
TagValue,
&Length,
(PVOID*)&TagOrder,
&BufferAllocated,
&OrderCell)
|| !TagOrder)
{
return -2;
}
/* Parse each tag */
for (CurrentTag = 1; CurrentTag <= TagOrder[0]; CurrentTag++)
{
/* Find a match */
if (TagOrder[CurrentTag] == *DriverTag)
{
/* Found it -- return the tag */
if (BufferAllocated) Hive->Free(TagOrder, Length);
return CurrentTag;
}
}
/* No matches, so assume next to last ordering */
if (BufferAllocated) Hive->Free(TagOrder, Length);
return -2;
}
#ifdef _BLDR_
/**
* @brief
* Checks whether the specified named driver is already in the driver list.
* Optionally returns its corresponding driver node.
*
* @remarks Used in bootloader only.
*
* @param[in] DriverListHead
* The driver list.
*
* @param[in] DriverName
* The name of the driver to search for.
*
* @param[out] FoundDriver
* Optional pointer that receives in output the address of the
* matching driver node, if any, or NULL if none has been found.
*
* @return
* TRUE if the driver has been found, FALSE if not.
**/
CODE_SEG("INIT")
BOOLEAN
NTAPI
CmpIsDriverInList(
_In_ PLIST_ENTRY DriverListHead,
_In_ PCUNICODE_STRING DriverName,
_Out_opt_ PBOOT_DRIVER_NODE* FoundDriver)
{
PLIST_ENTRY Entry;
PBOOT_DRIVER_NODE DriverNode;
for (Entry = DriverListHead->Flink;
Entry != DriverListHead;
Entry = Entry->Flink)
{
DriverNode = CONTAINING_RECORD(Entry,
BOOT_DRIVER_NODE,
ListEntry.Link);
if (RtlEqualUnicodeString(&DriverNode->Name,
DriverName,
TRUE))
{
/* The driver node has been found */
if (FoundDriver)
*FoundDriver = DriverNode;
return TRUE;
}
}
/* None has been found */
if (FoundDriver)
*FoundDriver = NULL;
return FALSE;
}
#endif /* _BLDR_ */
/**
* @brief
* Inserts the specified driver entry into the driver list.
*
* @param[in] Hive
* The SYSTEM hive.
*
* @param[in] DriverCell
* The registry key's hive cell of the driver to be added, inside
* the "Services" sub-key of the currently selected control set.
*
* @param[in] GroupOrderCell
* The hive cell of the "Control\GroupOrderList" registry key
* inside the currently selected control set.
*
* @param[in] RegistryPath
* Constant UNICODE_STRING pointing to
* "\\Registry\\Machine\\System\\CurrentControlSet\\Services\\".
*
* @param[in,out] DriverListHead
* The driver list where to insert the driver entry.
*
* @return
* TRUE if the driver has been inserted into the list, FALSE if not.
**/
CODE_SEG("INIT")
BOOLEAN
NTAPI
CmpAddDriverToList(
_In_ PHHIVE Hive,
_In_ HCELL_INDEX DriverCell,
_In_ HCELL_INDEX GroupOrderCell,
_In_ PCUNICODE_STRING RegistryPath,
_Inout_ PLIST_ENTRY DriverListHead)
{
PBOOT_DRIVER_NODE DriverNode;
PBOOT_DRIVER_LIST_ENTRY DriverEntry;
PCM_KEY_NODE Node;
PCM_KEY_VALUE Value;
ULONG Length;
USHORT NameLength;
HCELL_INDEX ValueCell, TagCell;
PUNICODE_STRING FilePath, RegistryString;
UNICODE_STRING Name;
PULONG ErrorControl;
PWCHAR Buffer;
/* Sanity check: We shouldn't need to release any acquired cells */
ASSERT(Hive->ReleaseCellRoutine == NULL);
/* Allocate a driver node and initialize it */
DriverNode = Hive->Allocate(sizeof(BOOT_DRIVER_NODE), FALSE, TAG_CM);
if (!DriverNode)
return FALSE;
RtlZeroMemory(DriverNode, sizeof(BOOT_DRIVER_NODE));
DriverEntry = &DriverNode->ListEntry;
/* Get the driver cell */
Node = (PCM_KEY_NODE)HvGetCell(Hive, DriverCell);
if (!Node)
goto Failure;
/* Get the name from the cell */
NameLength = (Node->Flags & KEY_COMP_NAME) ?
CmpCompressedNameSize(Node->Name, Node->NameLength) :
Node->NameLength;
if (NameLength < sizeof(WCHAR))
goto Failure;
/* Now allocate the buffer for it and copy the name */
RtlInitEmptyUnicodeString(&DriverNode->Name,
Hive->Allocate(NameLength, FALSE, TAG_CM),
NameLength);
if (!DriverNode->Name.Buffer)
goto Failure;
DriverNode->Name.Length = NameLength;
if (Node->Flags & KEY_COMP_NAME)
{
/* Compressed name */
CmpCopyCompressedName(DriverNode->Name.Buffer,
DriverNode->Name.Length,
Node->Name,
Node->NameLength);
}
else
{
/* Normal name */
RtlCopyMemory(DriverNode->Name.Buffer, Node->Name, Node->NameLength);
}
/* Now find the image path */
RtlInitUnicodeString(&Name, L"ImagePath");
ValueCell = CmpFindValueByName(Hive, Node, &Name);
if (ValueCell == HCELL_NIL)
{
/* Could not find it, so assume the drivers path */
Length = sizeof(L"System32\\Drivers\\") + NameLength + sizeof(L".sys");
/* Allocate the path name */
FilePath = &DriverEntry->FilePath;
RtlInitEmptyUnicodeString(FilePath,
Hive->Allocate(Length, FALSE, TAG_CM),
(USHORT)Length);
if (!FilePath->Buffer)
goto Failure;
/* Write the path name */
if (!NT_SUCCESS(RtlAppendUnicodeToString(FilePath, L"System32\\Drivers\\")) ||
!NT_SUCCESS(RtlAppendUnicodeStringToString(FilePath, &DriverNode->Name)) ||
!NT_SUCCESS(RtlAppendUnicodeToString(FilePath, L".sys")))
{
goto Failure;
}
}
else
{
/* Path name exists, so grab it */
Value = (PCM_KEY_VALUE)HvGetCell(Hive, ValueCell);
if (!Value)
goto Failure;
if ((Value->Type != REG_SZ) && (Value->Type != REG_EXPAND_SZ))
goto Failure;
Buffer = (PWCHAR)CmpValueToData(Hive, Value, &Length);
if (!Buffer)
goto Failure;
if (IS_NULL_TERMINATED(Buffer, Length))
Length -= sizeof(UNICODE_NULL);
if (Length < sizeof(WCHAR))
goto Failure;
/* Allocate and setup the path name */
FilePath = &DriverEntry->FilePath;
RtlInitEmptyUnicodeString(FilePath,
Hive->Allocate(Length, FALSE, TAG_CM),
(USHORT)Length);
if (!FilePath->Buffer)
goto Failure;
/* Transfer the data */
RtlCopyMemory(FilePath->Buffer, Buffer, Length);
FilePath->Length = (USHORT)Length;
}
/* Now build the registry path */
RegistryString = &DriverEntry->RegistryPath;
Length = RegistryPath->Length + NameLength;
RtlInitEmptyUnicodeString(RegistryString,
Hive->Allocate(Length, FALSE, TAG_CM),
(USHORT)Length);
if (!RegistryString->Buffer)
goto Failure;
/* Add the driver name to it */
if (!NT_SUCCESS(RtlAppendUnicodeStringToString(RegistryString, RegistryPath)) ||
!NT_SUCCESS(RtlAppendUnicodeStringToString(RegistryString, &DriverNode->Name)))
{
goto Failure;
}
/* The entry is done, add it */
InsertHeadList(DriverListHead, &DriverEntry->Link);
/* Now find error control settings */
RtlInitUnicodeString(&Name, L"ErrorControl");
ValueCell = CmpFindValueByName(Hive, Node, &Name);
if (ValueCell == HCELL_NIL)
{
/* Could not find it, so assume default */
DriverNode->ErrorControl = NormalError;
}
else
{
/* Otherwise, read whatever the data says */
Value = (PCM_KEY_VALUE)HvGetCell(Hive, ValueCell);
if (!Value)
goto Failure;
if (Value->Type != REG_DWORD)
goto Failure;
ErrorControl = (PULONG)CmpValueToData(Hive, Value, &Length);
if (!ErrorControl)
goto Failure;
if (Length < sizeof(ULONG))
goto Failure;
DriverNode->ErrorControl = *ErrorControl;
}
/* Next, get the group cell */
RtlInitUnicodeString(&Name, L"group");
ValueCell = CmpFindValueByName(Hive, Node, &Name);
if (ValueCell == HCELL_NIL)
{
/* Could not find it, so set an empty string */
RtlInitEmptyUnicodeString(&DriverNode->Group, NULL, 0);
}
else
{
/* Found it, read the group value */
Value = (PCM_KEY_VALUE)HvGetCell(Hive, ValueCell);
if (!Value)
goto Failure;
if (Value->Type != REG_SZ) // REG_EXPAND_SZ not really allowed there.
goto Failure;
/* Copy it into the node */
Buffer = (PWCHAR)CmpValueToData(Hive, Value, &Length);
if (!Buffer)
goto Failure;
if (IS_NULL_TERMINATED(Buffer, Length))
Length -= sizeof(UNICODE_NULL);
DriverNode->Group.Buffer = Buffer;
DriverNode->Group.Length = (USHORT)Length;
DriverNode->Group.MaximumLength = DriverNode->Group.Length;
}
/* Finally, find the tag */
RtlInitUnicodeString(&Name, L"Tag");
TagCell = CmpFindValueByName(Hive, Node, &Name);
if (TagCell == HCELL_NIL)
{
/* No tag, so load last */
DriverNode->Tag = -1;
}
else
{
/* Otherwise, decode it based on tag order */
DriverNode->Tag = CmpFindTagIndex(Hive,
TagCell,
GroupOrderCell,
&DriverNode->Group);
}
CMTRACE(CM_BOOT_DEBUG, "Adding boot driver: '%wZ', '%wZ'\n",
&DriverNode->Name, &DriverEntry->FilePath);
/* All done! */
return TRUE;
Failure:
if (DriverEntry->RegistryPath.Buffer)
{
Hive->Free(DriverEntry->RegistryPath.Buffer,
DriverEntry->RegistryPath.MaximumLength);
}
if (DriverEntry->FilePath.Buffer)
{
Hive->Free(DriverEntry->FilePath.Buffer,
DriverEntry->FilePath.MaximumLength);
}
if (DriverNode->Name.Buffer)
{
Hive->Free(DriverNode->Name.Buffer,
DriverNode->Name.MaximumLength);
}
Hive->Free(DriverNode, sizeof(BOOT_DRIVER_NODE));
return FALSE;
}
/**
* @brief
* Checks whether the specified driver has the expected load type.
*
* @param[in] Hive
* The SYSTEM hive.
*
* @param[in] DriverCell
* The registry key's hive cell of the driver, inside the
* "Services" sub-key of the currently selected control set.
*
* @param[in] LoadType
* The load type the driver should match.
*
* @return
* TRUE if the driver's load type matches, FALSE if not.
**/
CODE_SEG("INIT")
static
BOOLEAN
CmpIsLoadType(
_In_ PHHIVE Hive,
_In_ HCELL_INDEX Cell,
_In_ SERVICE_LOAD_TYPE LoadType)
{
PCM_KEY_NODE Node;
PCM_KEY_VALUE Value;
UNICODE_STRING Name = RTL_CONSTANT_STRING(L"Start");
HCELL_INDEX ValueCell;
ULONG Length;
PULONG Data;
/* Sanity check: We shouldn't need to release any acquired cells */
ASSERT(Hive->ReleaseCellRoutine == NULL);
/* Open the start cell */
Node = (PCM_KEY_NODE)HvGetCell(Hive, Cell);
if (!Node) return FALSE;
ValueCell = CmpFindValueByName(Hive, Node, &Name);
if (ValueCell == HCELL_NIL) return FALSE;
/* Read the start value */
Value = (PCM_KEY_VALUE)HvGetCell(Hive, ValueCell);
if (!Value) return FALSE;
if (Value->Type != REG_DWORD) return FALSE;
Data = (PULONG)CmpValueToData(Hive, Value, &Length);
if (!Data) return FALSE;
if (Length < sizeof(ULONG)) return FALSE;
/* Return if the type matches */
return (*Data == LoadType);
}
/**
* @brief
* Enumerates all drivers within the given control set and load type,
* present in the "Services" sub-key, and inserts them into the driver list.
*
* @param[in] Hive
* The SYSTEM hive.
*
* @param[in] ControlSet
* The control set registry key's hive cell.
*
* @param[in] LoadType
* The load type the driver should match.
*
* @param[in] BootFileSystem
* Optional name of the boot file system, for which to insert
* its corresponding driver.
*
* @param[in,out] DriverListHead
* The driver list where to insert the enumerated drivers.
*
* @return
* TRUE if the drivers have been successfully enumerated and inserted,
* FALSE if not.
**/
CODE_SEG("INIT")
BOOLEAN
NTAPI
CmpFindDrivers(
_In_ PHHIVE Hive,
_In_ HCELL_INDEX ControlSet,
_In_ SERVICE_LOAD_TYPE LoadType,
_In_opt_ PCWSTR BootFileSystem,
_Inout_ PLIST_ENTRY DriverListHead)
{
HCELL_INDEX ServicesCell, ControlCell, GroupOrderCell, DriverCell;
HCELL_INDEX SafeBootCell = HCELL_NIL;
ULONG i;
UNICODE_STRING Name;
UNICODE_STRING KeyPath;
PCM_KEY_NODE ControlNode, ServicesNode, Node;
PBOOT_DRIVER_NODE FsNode;
/* Sanity check: We shouldn't need to release any acquired cells */
ASSERT(Hive->ReleaseCellRoutine == NULL);
/* Open the control set key */
ControlNode = (PCM_KEY_NODE)HvGetCell(Hive, ControlSet);
if (!ControlNode) return FALSE;
/* Get services cell */
RtlInitUnicodeString(&Name, L"Services");
ServicesCell = CmpFindSubKeyByName(Hive, ControlNode, &Name);
if (ServicesCell == HCELL_NIL) return FALSE;
/* Open services key */
ServicesNode = (PCM_KEY_NODE)HvGetCell(Hive, ServicesCell);
if (!ServicesNode) return FALSE;
/* Get control cell */
RtlInitUnicodeString(&Name, L"Control");
ControlCell = CmpFindSubKeyByName(Hive, ControlNode, &Name);
if (ControlCell == HCELL_NIL) return FALSE;
/* Get the group order cell and read it */
Node = (PCM_KEY_NODE)HvGetCell(Hive, ControlCell);
if (!Node) return FALSE;
RtlInitUnicodeString(&Name, L"GroupOrderList");
GroupOrderCell = CmpFindSubKeyByName(Hive, Node, &Name);
if (GroupOrderCell == HCELL_NIL) return FALSE;
/* Get Safe Boot cell */
if (InitSafeBootMode)
{
/* Open the Safe Boot key */
RtlInitUnicodeString(&Name, L"SafeBoot");
Node = (PCM_KEY_NODE)HvGetCell(Hive, ControlCell);
if (!Node) return FALSE;
SafeBootCell = CmpFindSubKeyByName(Hive, Node, &Name);
if (SafeBootCell == HCELL_NIL) return FALSE;
/* Open the correct start key (depending on the mode) */
Node = (PCM_KEY_NODE)HvGetCell(Hive, SafeBootCell);
if (!Node) return FALSE;
switch (InitSafeBootMode)
{
/* NOTE: Assumes MINIMAL (1) and DSREPAIR (3) load same items */
case 1:
case 3: RtlInitUnicodeString(&Name, L"Minimal"); break;
case 2: RtlInitUnicodeString(&Name, L"Network"); break;
default: return FALSE;
}
SafeBootCell = CmpFindSubKeyByName(Hive, Node, &Name);
if (SafeBootCell == HCELL_NIL) return FALSE;
}
/* Build the root registry path */
RtlInitUnicodeString(&KeyPath, L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\");
/* Enumerate each sub-key */
i = 0;
DriverCell = CmpFindSubKeyByNumber(Hive, ServicesNode, i);
while (DriverCell != HCELL_NIL)
{
/* Make sure it's a driver of this start type AND is "safe" to load */
if (CmpIsLoadType(Hive, DriverCell, LoadType) &&
CmpIsSafe(Hive, SafeBootCell, DriverCell))
{
/* Add it to the list */
if (!CmpAddDriverToList(Hive,
DriverCell,
GroupOrderCell,
&KeyPath,
DriverListHead))
{
CMTRACE(CM_BOOT_DEBUG, " Failed to add boot driver\n");
}
}
/* Go to the next sub-key */
DriverCell = CmpFindSubKeyByNumber(Hive, ServicesNode, ++i);
}
/* Check if we have a boot file system */
if (BootFileSystem)
{
/* Find it */
RtlInitUnicodeString(&Name, BootFileSystem);
DriverCell = CmpFindSubKeyByName(Hive, ServicesNode, &Name);
if (DriverCell != HCELL_NIL)
{
CMTRACE(CM_BOOT_DEBUG, "Adding Boot FileSystem '%S'\n",
BootFileSystem);
/* Always add it to the list */
if (!CmpAddDriverToList(Hive,
DriverCell,
GroupOrderCell,
&KeyPath,
DriverListHead))
{
CMTRACE(CM_BOOT_DEBUG, " Failed to add boot driver\n");
}
else
{
/* Mark it as critical so it always loads */
FsNode = CONTAINING_RECORD(DriverListHead->Flink,
BOOT_DRIVER_NODE,
ListEntry.Link);
FsNode->ErrorControl = SERVICE_ERROR_CRITICAL;
}
}
}
/* We're done! */
return TRUE;
}
/**
* @brief
* Performs the driver list sorting, according to the ordering list.
*
* @param[in] Hive
* The SYSTEM hive.
*
* @param[in] ControlSet
* The control set registry key's hive cell.
*
* @param[in,out] DriverListHead
* The driver list to sort.
*
* @return
* TRUE if sorting has been successfully done, FALSE if not.
**/
CODE_SEG("INIT")
static
BOOLEAN
CmpDoSort(
_Inout_ PLIST_ENTRY DriverListHead,
_In_ PCUNICODE_STRING OrderList)
{
PWCHAR Current, End = NULL;
UNICODE_STRING GroupName;
PLIST_ENTRY NextEntry;
PBOOT_DRIVER_NODE CurrentNode;
/* We're going from end to start, so get to the last group and keep going */
Current = &OrderList->Buffer[OrderList->Length / sizeof(WCHAR)];
while (Current > OrderList->Buffer)
{
/* Scan the current string */
do
{
if (*Current == UNICODE_NULL) End = Current;
} while ((*(--Current - 1) != UNICODE_NULL) && (Current != OrderList->Buffer));
/* This is our cleaned up string for this specific group */
ASSERT(End != NULL);
GroupName.Length = (USHORT)(End - Current) * sizeof(WCHAR);
GroupName.MaximumLength = GroupName.Length;
GroupName.Buffer = Current;
/* Now loop the driver list */
NextEntry = DriverListHead->Flink;
while (NextEntry != DriverListHead)
{
/* Get this node */
CurrentNode = CONTAINING_RECORD(NextEntry,
BOOT_DRIVER_NODE,
ListEntry.Link);
/* Get the next entry now since we'll do a relink */
NextEntry = NextEntry->Flink;
/* Is there a group name and does it match the current group? */
if (CurrentNode->Group.Buffer &&
RtlEqualUnicodeString(&GroupName, &CurrentNode->Group, TRUE))
{
/* Remove from this location and re-link in the new one */
RemoveEntryList(&CurrentNode->ListEntry.Link);
InsertHeadList(DriverListHead, &CurrentNode->ListEntry.Link);
}
}
/* Move on */
--Current;
}
/* All done */
return TRUE;
}
/**
* @brief
* Sorts the driver list, according to the drivers' group load ordering.
*
* @param[in] Hive
* The SYSTEM hive.
*
* @param[in] ControlSet
* The control set registry key's hive cell.
*
* @param[in,out] DriverListHead
* The driver list to sort.
*
* @return
* TRUE if sorting has been successfully done, FALSE if not.
**/
CODE_SEG("INIT")
BOOLEAN
NTAPI
CmpSortDriverList(
_In_ PHHIVE Hive,
_In_ HCELL_INDEX ControlSet,
_Inout_ PLIST_ENTRY DriverListHead)
{
PCM_KEY_NODE Node;
PCM_KEY_VALUE ListValue;
HCELL_INDEX ControlCell, GroupOrder, ListCell;
UNICODE_STRING Name, OrderList;
ULONG Length;
/* Sanity check: We shouldn't need to release any acquired cells */
ASSERT(Hive->ReleaseCellRoutine == NULL);
/* Open the control key */
Node = (PCM_KEY_NODE)HvGetCell(Hive, ControlSet);
if (!Node) return FALSE;
RtlInitUnicodeString(&Name, L"Control");
ControlCell = CmpFindSubKeyByName(Hive, Node, &Name);
if (ControlCell == HCELL_NIL) return FALSE;
/* Open the service group order */
Node = (PCM_KEY_NODE)HvGetCell(Hive, ControlCell);
if (!Node) return FALSE;
RtlInitUnicodeString(&Name, L"ServiceGroupOrder");
GroupOrder = CmpFindSubKeyByName(Hive, Node, &Name);
if (GroupOrder == HCELL_NIL) return FALSE;
/* Open the list key */
Node = (PCM_KEY_NODE)HvGetCell(Hive, GroupOrder);
if (!Node) return FALSE;
RtlInitUnicodeString(&Name, L"list");
ListCell = CmpFindValueByName(Hive, Node, &Name);
if (ListCell == HCELL_NIL) return FALSE;
/* Read the actual list */
ListValue = (PCM_KEY_VALUE)HvGetCell(Hive, ListCell);
if (!ListValue) return FALSE;
if (ListValue->Type != REG_MULTI_SZ) return FALSE;
/* Copy it into a buffer */
OrderList.Buffer = (PWCHAR)CmpValueToData(Hive, ListValue, &Length);
if (!OrderList.Buffer) return FALSE;
if (!IS_NULL_TERMINATED(OrderList.Buffer, Length)) return FALSE;
OrderList.Length = (USHORT)Length - sizeof(UNICODE_NULL);
OrderList.MaximumLength = OrderList.Length;
/* And start the sort algorithm */
return CmpDoSort(DriverListHead, &OrderList);
}
CODE_SEG("INIT")
static
BOOLEAN
CmpOrderGroup(
_In_ PBOOT_DRIVER_NODE StartNode,
_In_ PBOOT_DRIVER_NODE EndNode)
{
PBOOT_DRIVER_NODE CurrentNode, PreviousNode;
PLIST_ENTRY ListEntry;
/* Base case, nothing to do */
if (StartNode == EndNode) return TRUE;
/* Loop the nodes */
CurrentNode = StartNode;
do
{
/* Save this as the previous node */
PreviousNode = CurrentNode;
/* And move to the next one */
ListEntry = CurrentNode->ListEntry.Link.Flink;
CurrentNode = CONTAINING_RECORD(ListEntry,
BOOT_DRIVER_NODE,
ListEntry.Link);
/* Check if the previous driver had a bigger tag */
if (PreviousNode->Tag > CurrentNode->Tag)
{
/* Check if we need to update the tail */
if (CurrentNode == EndNode)
{
/* Update the tail */
ListEntry = CurrentNode->ListEntry.Link.Blink;
EndNode = CONTAINING_RECORD(ListEntry,
BOOT_DRIVER_NODE,
ListEntry.Link);
}
/* Remove this driver since we need to move it */
RemoveEntryList(&CurrentNode->ListEntry.Link);
/* Keep looping until we find a driver with a lower tag than ours */
while ((PreviousNode->Tag > CurrentNode->Tag) && (PreviousNode != StartNode))
{
/* We'll be re-inserted at this spot */
ListEntry = PreviousNode->ListEntry.Link.Blink;
PreviousNode = CONTAINING_RECORD(ListEntry,
BOOT_DRIVER_NODE,
ListEntry.Link);
}
/* Do the insert in the new location */
InsertTailList(&PreviousNode->ListEntry.Link, &CurrentNode->ListEntry.Link);
/* Update the head, if needed */
if (PreviousNode == StartNode) StartNode = CurrentNode;
}
} while (CurrentNode != EndNode);
/* All done */
return TRUE;
}
/**
* @brief
* Removes potential circular dependencies (cycles) and sorts the driver list.
*
* @param[in,out] DriverListHead
* The driver list to sort.
*
* @return
* Always TRUE.
**/
CODE_SEG("INIT")
BOOLEAN
NTAPI
CmpResolveDriverDependencies(
_Inout_ PLIST_ENTRY DriverListHead)
{
PLIST_ENTRY NextEntry;
PBOOT_DRIVER_NODE StartNode, EndNode, CurrentNode;
/* Loop the list */
NextEntry = DriverListHead->Flink;
while (NextEntry != DriverListHead)
{
/* Find the first entry */
StartNode = CONTAINING_RECORD(NextEntry,
BOOT_DRIVER_NODE,
ListEntry.Link);
do
{
/* Find the last entry */
EndNode = CONTAINING_RECORD(NextEntry,
BOOT_DRIVER_NODE,
ListEntry.Link);
/* Get the next entry */
NextEntry = NextEntry->Flink;
CurrentNode = CONTAINING_RECORD(NextEntry,
BOOT_DRIVER_NODE,
ListEntry.Link);
/* If the next entry is back to the top, break out */
if (NextEntry == DriverListHead) break;
/* Otherwise, check if this entry is equal */
if (!RtlEqualUnicodeString(&StartNode->Group,
&CurrentNode->Group,
TRUE))
{
/* It is, so we've detected a cycle, break out */
break;
}
} while (NextEntry != DriverListHead);
/* Now we have the correct start and end pointers, so do the sort */
CmpOrderGroup(StartNode, EndNode);
}
/* We're done */
return TRUE;
}
CODE_SEG("INIT")
static
BOOLEAN
CmpIsSafe(
_In_ PHHIVE Hive,
_In_ HCELL_INDEX SafeBootCell,
_In_ HCELL_INDEX DriverCell)
{
PCM_KEY_NODE SafeBootNode;
PCM_KEY_NODE DriverNode;
PCM_KEY_VALUE KeyValue;
HCELL_INDEX CellIndex;
ULONG Length;
UNICODE_STRING Name;
PWCHAR Buffer;
/* Sanity check: We shouldn't need to release any acquired cells */
ASSERT(Hive->ReleaseCellRoutine == NULL);
/* Driver key node (mandatory) */
ASSERT(DriverCell != HCELL_NIL);
DriverNode = (PCM_KEY_NODE)HvGetCell(Hive, DriverCell);
if (!DriverNode) return FALSE;
/* Safe boot key node (optional but return TRUE if not present) */
if (SafeBootCell == HCELL_NIL) return TRUE;
SafeBootNode = (PCM_KEY_NODE)HvGetCell(Hive, SafeBootCell);
if (!SafeBootNode) return FALSE;
/* Search by the name from the group */
RtlInitUnicodeString(&Name, L"Group");
CellIndex = CmpFindValueByName(Hive, DriverNode, &Name);
if (CellIndex != HCELL_NIL)
{
KeyValue = (PCM_KEY_VALUE)HvGetCell(Hive, CellIndex);
if (!KeyValue) return FALSE;
if (KeyValue->Type == REG_SZ) // REG_EXPAND_SZ not really allowed there.
{
/* Compose the search 'key' */
Buffer = (PWCHAR)CmpValueToData(Hive, KeyValue, &Length);
if (!Buffer)
return FALSE;
if (IS_NULL_TERMINATED(Buffer, Length))
Length -= sizeof(UNICODE_NULL);
Name.Buffer = Buffer;
Name.Length = (USHORT)Length;
Name.MaximumLength = Name.Length;
/* Search for corresponding key in the Safe Boot key */
CellIndex = CmpFindSubKeyByName(Hive, SafeBootNode, &Name);
if (CellIndex != HCELL_NIL) return TRUE;
}
}
/* Group has not been found - find driver name */
Length = (DriverNode->Flags & KEY_COMP_NAME) ?
CmpCompressedNameSize(DriverNode->Name, DriverNode->NameLength) :
DriverNode->NameLength;
if (Length < sizeof(WCHAR))
return FALSE;
/* Now allocate the buffer for it and copy the name */
RtlInitEmptyUnicodeString(&Name,
Hive->Allocate(Length, FALSE, TAG_CM),
(USHORT)Length);
if (!Name.Buffer)
return FALSE;
Name.Length = (USHORT)Length;
if (DriverNode->Flags & KEY_COMP_NAME)
{
/* Compressed name */
CmpCopyCompressedName(Name.Buffer,
Name.Length,
DriverNode->Name,
DriverNode->NameLength);
}
else
{
/* Normal name */
RtlCopyMemory(Name.Buffer, DriverNode->Name, DriverNode->NameLength);
}
CellIndex = CmpFindSubKeyByName(Hive, SafeBootNode, &Name);
Hive->Free(Name.Buffer, Name.MaximumLength);
if (CellIndex != HCELL_NIL) return TRUE;
/* Not group or driver name - search by image name */
RtlInitUnicodeString(&Name, L"ImagePath");
CellIndex = CmpFindValueByName(Hive, DriverNode, &Name);
if (CellIndex != HCELL_NIL)
{
KeyValue = (PCM_KEY_VALUE)HvGetCell(Hive, CellIndex);
if (!KeyValue) return FALSE;
if ((KeyValue->Type == REG_SZ) || (KeyValue->Type == REG_EXPAND_SZ))
{
/* Compose the search 'key' */
Buffer = (PWCHAR)CmpValueToData(Hive, KeyValue, &Length);
if (!Buffer) return FALSE;
if (Length < sizeof(WCHAR)) return FALSE;
/* Get the base image file name */
// FIXME: wcsrchr() may fail if Buffer is *not* NULL-terminated!
Name.Buffer = wcsrchr(Buffer, OBJ_NAME_PATH_SEPARATOR);
if (!Name.Buffer) return FALSE;
++Name.Buffer;
/* Length of the base name must be >=1 WCHAR */
if (((ULONG_PTR)Name.Buffer - (ULONG_PTR)Buffer) >= Length)
return FALSE;
Length -= ((ULONG_PTR)Name.Buffer - (ULONG_PTR)Buffer);
if (IS_NULL_TERMINATED(Name.Buffer, Length))
Length -= sizeof(UNICODE_NULL);
if (Length < sizeof(WCHAR)) return FALSE;
Name.Length = (USHORT)Length;
Name.MaximumLength = Name.Length;
/* Search for corresponding key in the Safe Boot key */
CellIndex = CmpFindSubKeyByName(Hive, SafeBootNode, &Name);
if (CellIndex != HCELL_NIL) return TRUE;
}
}
/* Nothing found - nothing else to search */
return FALSE;
}
/**
* @brief
* Empties the driver list and frees all allocated driver nodes in it.
*
* @param[in] Hive
* The SYSTEM hive (used only for the Hive->Free() memory deallocator).
*
* @param[in,out] DriverListHead
* The driver list to free.
*
* @return None
**/
CODE_SEG("INIT")
VOID
NTAPI
CmpFreeDriverList(
_In_ PHHIVE Hive,
_Inout_ PLIST_ENTRY DriverListHead)
{
PLIST_ENTRY Entry;
PBOOT_DRIVER_NODE DriverNode;
/* Loop through the list and remove each driver node */
while (!IsListEmpty(DriverListHead))
{
/* Get the driver node */
Entry = RemoveHeadList(DriverListHead);
DriverNode = CONTAINING_RECORD(Entry,
BOOT_DRIVER_NODE,
ListEntry.Link);
/* Free any allocated string buffers, then the node */
if (DriverNode->ListEntry.RegistryPath.Buffer)
{
Hive->Free(DriverNode->ListEntry.RegistryPath.Buffer,
DriverNode->ListEntry.RegistryPath.MaximumLength);
}
if (DriverNode->ListEntry.FilePath.Buffer)
{
Hive->Free(DriverNode->ListEntry.FilePath.Buffer,
DriverNode->ListEntry.FilePath.MaximumLength);
}
if (DriverNode->Name.Buffer)
{
Hive->Free(DriverNode->Name.Buffer,
DriverNode->Name.MaximumLength);
}
Hive->Free(DriverNode, sizeof(BOOT_DRIVER_NODE));
}
}
/* EOF */