cmboot.c File Reference

#include <ntoskrnl.h>
#include <debug.h>

Include dependency graph for cmboot.c:

Go to the source code of this file.

Macros
#define	NDEBUG
#define	CM_BOOT_DEBUG   0x20
#define	IS_NULL_TERMINATED(Buffer, Size)    (((Size) >= sizeof(WCHAR)) && ((Buffer)[(Size) / sizeof(WCHAR) - 1] == UNICODE_NULL))

Functions
static BOOLEAN	CmpIsSafe (_In_ PHHIVE Hive, _In_ HCELL_INDEX SafeBootCell, _In_ HCELL_INDEX DriverCell)
HCELL_INDEX NTAPI	CmpFindControlSet (_In_ PHHIVE SystemHive, _In_ HCELL_INDEX RootCell, _In_ PCUNICODE_STRING SelectKeyName, _Out_ PBOOLEAN AutoSelect)
	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.
static ULONG	CmpFindTagIndex (_In_ PHHIVE Hive, _In_ HCELL_INDEX TagCell, _In_ HCELL_INDEX GroupOrderCell, _In_ PCUNICODE_STRING GroupName)
	Finds the index of the driver's "Tag" value in its corresponding group ordering list.
BOOLEAN NTAPI	CmpAddDriverToList (_In_ PHHIVE Hive, _In_ HCELL_INDEX DriverCell, _In_ HCELL_INDEX GroupOrderCell, _In_ PCUNICODE_STRING RegistryPath, _Inout_ PLIST_ENTRY DriverListHead)
	Inserts the specified driver entry into the driver list.
static BOOLEAN	CmpIsLoadType (_In_ PHHIVE Hive, _In_ HCELL_INDEX Cell, _In_ SERVICE_LOAD_TYPE LoadType)
	Checks whether the specified driver has the expected load type.
BOOLEAN NTAPI	CmpFindDrivers (_In_ PHHIVE Hive, _In_ HCELL_INDEX ControlSet, _In_ SERVICE_LOAD_TYPE LoadType, _In_opt_ PCWSTR BootFileSystem, _Inout_ PLIST_ENTRY DriverListHead)
	Enumerates all drivers within the given control set and load type, present in the "Services" sub-key, and inserts them into the driver list.
static BOOLEAN	CmpDoSort (_Inout_ PLIST_ENTRY DriverListHead, _In_ PCUNICODE_STRING OrderList)
	Performs the driver list sorting, according to the ordering list.
BOOLEAN NTAPI	CmpSortDriverList (_In_ PHHIVE Hive, _In_ HCELL_INDEX ControlSet, _Inout_ PLIST_ENTRY DriverListHead)
	Sorts the driver list, according to the drivers' group load ordering.
static BOOLEAN	CmpOrderGroup (_In_ PBOOT_DRIVER_NODE StartNode, _In_ PBOOT_DRIVER_NODE EndNode)
BOOLEAN NTAPI	CmpResolveDriverDependencies (_Inout_ PLIST_ENTRY DriverListHead)
	Removes potential circular dependencies (cycles) and sorts the driver list.
VOID NTAPI	CmpFreeDriverList (_In_ PHHIVE Hive, _Inout_ PLIST_ENTRY DriverListHead)
	Empties the driver list and frees all allocated driver nodes in it.

Macro Definition Documentation

CM_BOOT_DEBUG

#define CM_BOOT_DEBUG   0x20

Definition at line 39 of file cmboot.c.

IS_NULL_TERMINATED

#define IS_NULL_TERMINATED	(		Buffer,
			Size
	)		(((Size) >= sizeof(WCHAR)) && ((Buffer)[(Size) / sizeof(WCHAR) - 1] == UNICODE_NULL))

Definition at line 41 of file cmboot.c.

NDEBUG

#define NDEBUG

Definition at line 16 of file cmboot.c.

Function Documentation

CmpAddDriverToList()

BOOLEAN NTAPI CmpAddDriverToList	(	_In_ PHHIVE	Hive,
		_In_ HCELL_INDEX	DriverCell,
		_In_ HCELL_INDEX	GroupOrderCell,
		_In_ PCUNICODE_STRING	RegistryPath,
		_Inout_ PLIST_ENTRY	DriverListHead
	)

Inserts the specified driver entry into the driver list.

Parameters

[in]	Hive	The SYSTEM hive.
[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.
[in]	GroupOrderCell	The hive cell of the "Control\GroupOrderList" registry key inside the currently selected control set.
[in]	RegistryPath	Constant UNICODE_STRING pointing to "\\Registry\\Machine\\System\\CurrentControlSet\\Services\\".
[in,out]	DriverListHead	The driver list where to insert the driver entry.

Returns

TRUE if the driver has been inserted into the list, FALSE if not.

Definition at line 362 of file cmboot.c.

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

Referenced by CmpFindDrivers().

CmpDoSort()

static BOOLEAN CmpDoSort ( _Inout_ PLIST_ENTRY  DriverListHead, _In_ PCUNICODE_STRING  OrderList  )

static

Performs the driver list sorting, according to the ordering list.

Parameters

[in]	Hive	The SYSTEM hive.
[in]	ControlSet	The control set registry key's hive cell.
[in,out]	DriverListHead	The driver list to sort.

Returns

TRUE if sorting has been successfully done, FALSE if not.

Definition at line 826 of file cmboot.c.

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

Referenced by CmpSortDriverList().

CmpFindControlSet()

HCELL_INDEX NTAPI CmpFindControlSet	(	_In_ PHHIVE	SystemHive,
		_In_ HCELL_INDEX	RootCell,
		_In_ PCUNICODE_STRING	SelectKeyName,
		_Out_ PBOOLEAN	AutoSelect
	)

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.

Parameters

[in]	SystemHive	The SYSTEM hive.
[in]	RootCell	The root cell of the SYSTEM hive.
[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.
[out]	AutoSelect	Value of the "AutoSelect" registry value (unused).

Returns

The control set registry key's hive cell (if found), or HCELL_NIL.

Definition at line 82 of file cmboot.c.

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

Referenced by CmGetSystemControlValues(), CmGetSystemDriverList(), and RegInitCurrentControlSet().

CmpFindDrivers()

BOOLEAN NTAPI CmpFindDrivers	(	_In_ PHHIVE	Hive,
		_In_ HCELL_INDEX	ControlSet,
		_In_ SERVICE_LOAD_TYPE	LoadType,
		_In_opt_ PCWSTR	BootFileSystem,
		_Inout_ PLIST_ENTRY	DriverListHead
	)

Enumerates all drivers within the given control set and load type, present in the "Services" sub-key, and inserts them into the driver list.

Parameters

[in]	Hive	The SYSTEM hive.
[in]	ControlSet	The control set registry key's hive cell.
[in]	LoadType	The load type the driver should match.
[in]	BootFileSystem	Optional name of the boot file system, for which to insert its corresponding driver.
[in,out]	DriverListHead	The driver list where to insert the enumerated drivers.

Returns

TRUE if the drivers have been successfully enumerated and inserted, FALSE if not.

Definition at line 677 of file cmboot.c.

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

Referenced by CmGetSystemDriverList(), and WinLdrScanRegistry().

CmpFindTagIndex()

static ULONG CmpFindTagIndex ( _In_ PHHIVE  Hive, _In_ HCELL_INDEX  TagCell, _In_ HCELL_INDEX  GroupOrderCell, _In_ PCUNICODE_STRING  GroupName  )

static

Finds the index of the driver's "Tag" value in its corresponding group ordering list.

Parameters

[in]	Hive	The SYSTEM hive.
[in]	TagCell	The driver's "Tag" registry value's hive cell.
[in]	GroupOrderCell	The hive cell of the "Control\GroupOrderList" registry key inside the currently selected control set.
[in]	GroupName	The driver's group name.

Returns

The corresponding tag index, or -1 (last position), or -2 (next-to-last position).

Definition at line 213 of file cmboot.c.

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

Referenced by CmpAddDriverToList().

CmpFreeDriverList()

VOID NTAPI CmpFreeDriverList	(	_In_ PHHIVE	Hive,
		_Inout_ PLIST_ENTRY	DriverListHead
	)

Empties the driver list and frees all allocated driver nodes in it.

Parameters

[in]	Hive	The SYSTEM hive (used only for the Hive->Free() memory deallocator).
[in,out]	DriverListHead	The driver list to free.

Returns

None

Definition at line 1222 of file cmboot.c.

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

Referenced by CmGetSystemDriverList(), and WinLdrScanRegistry().

CmpIsLoadType()

static BOOLEAN CmpIsLoadType ( _In_ PHHIVE  Hive, _In_ HCELL_INDEX  Cell, _In_ SERVICE_LOAD_TYPE  LoadType  )

static

Checks whether the specified driver has the expected load type.

Parameters

[in]	Hive	The SYSTEM hive.
[in]	DriverCell	The registry key's hive cell of the driver, inside the "Services" sub-key of the currently selected control set.
[in]	LoadType	The load type the driver should match.

Returns

TRUE if the driver's load type matches, FALSE if not.

Definition at line 616 of file cmboot.c.

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

Referenced by CmpFindDrivers().

CmpIsSafe()

static BOOLEAN CmpIsSafe ( _In_ PHHIVE  Hive, _In_ HCELL_INDEX  SafeBootCell, _In_ HCELL_INDEX  DriverCell  )

static

Definition at line 1079 of file cmboot.c.

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

Referenced by CmpFindDrivers().

CmpOrderGroup()

static BOOLEAN CmpOrderGroup ( _In_ PBOOT_DRIVER_NODE  StartNode, _In_ PBOOT_DRIVER_NODE  EndNode  )

static

Definition at line 954 of file cmboot.c.

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

Referenced by CmpResolveDriverDependencies().

CmpResolveDriverDependencies()

BOOLEAN NTAPI CmpResolveDriverDependencies

(

_Inout_ PLIST_ENTRY

DriverListHead

)

Removes potential circular dependencies (cycles) and sorts the driver list.

Parameters

[in,out]

DriverListHead

The driver list to sort.

Returns

Always TRUE.

Definition at line 1028 of file cmboot.c.

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

Referenced by CmGetSystemDriverList(), and WinLdrScanRegistry().

CmpSortDriverList()

BOOLEAN NTAPI CmpSortDriverList	(	_In_ PHHIVE	Hive,
		_In_ HCELL_INDEX	ControlSet,
		_Inout_ PLIST_ENTRY	DriverListHead
	)

Sorts the driver list, according to the drivers' group load ordering.

Parameters

[in]	Hive	The SYSTEM hive.
[in]	ControlSet	The control set registry key's hive cell.
[in,out]	DriverListHead	The driver list to sort.

Returns

TRUE if sorting has been successfully done, FALSE if not.

Definition at line 900 of file cmboot.c.

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

Referenced by CmGetSystemDriverList(), and WinLdrScanRegistry().