iorsrce.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:     Hardware resource management
 * COPYRIGHT:   Copyright 1998 David Welch <welch@mcmail.com>
 *              Copyright 2001 Eric Kohl <eric.kohl@reactos.org>
 *              Copyright 2004-2013 Alex Ionescu <alex.ionescu@reactos.org>
 *              Copyright 2010 Cameron Gutman <cameron.gutman@reactos.org>
 *              Copyright 2010 Pierre Schweitzer <pierre@reactos.org>
 */
 
/* INCLUDES *****************************************************************/
 
#include <ntoskrnl.h>
#define NDEBUG
#include <debug.h>
 
#ifndef NDEBUG
    #define IORSRCTRACE(...)    DbgPrint(__VA_ARGS__)
#else
    #if defined(_MSC_VER)
    #define IORSRCTRACE     __noop
    #else
    #define IORSRCTRACE(...)    do { if(0) { DbgPrint(__VA_ARGS__); } } while(0)
    #endif
#endif
 
/* GLOBALS *******************************************************************/
 
static CONFIGURATION_INFORMATION
_SystemConfigurationInformation = { 0, 0, 0, 0, 0, 0, 0, FALSE, FALSE, 0, 0 };
 
/* API parameters to pass to IopQueryBusDescription() */
typedef struct _IO_QUERY
{
    PINTERFACE_TYPE BusType;
    PULONG BusNumber;
    PCONFIGURATION_TYPE ControllerType;
    PULONG ControllerNumber;
    PCONFIGURATION_TYPE PeripheralType;
    PULONG PeripheralNumber;
    PIO_QUERY_DEVICE_ROUTINE CalloutRoutine;
    PVOID Context;
} IO_QUERY, *PIO_QUERY;
 
/* Strings corresponding to CONFIGURATION_TYPE */
PCWSTR ArcTypes[MaximumType + 1] =
{
    L"System",
    L"CentralProcessor",
    L"FloatingPointProcessor",
    L"PrimaryICache",
    L"PrimaryDCache",
    L"SecondaryICache",
    L"SecondaryDCache",
    L"SecondaryCache",
    L"EisaAdapter",
    L"TcAdapter",
    L"ScsiAdapter",
    L"DtiAdapter",
    L"MultifunctionAdapter",
    L"DiskController",
    L"TapeController",
    L"CdRomController",
    L"WormController",
    L"SerialController",
    L"NetworkController",
    L"DisplayController",
    L"ParallelController",
    L"PointerController",
    L"KeyboardController",
    L"AudioController",
    L"OtherController",
    L"DiskPeripheral",
    L"FloppyDiskPeripheral",
    L"TapePeripheral",
    L"ModemPeripheral",
    L"MonitorPeripheral",
    L"PrinterPeripheral",
    L"PointerPeripheral",
    L"KeyboardPeripheral",
    L"TerminalPeripheral",
    L"OtherPeripheral",
    L"LinePeripheral",
    L"NetworkPeripheral",
    L"SystemMemory",
    L"DockingInformation",
    L"RealModeIrqRoutingTable",
    L"RealModePCIEnumeration",
    L"Undefined"
};
 
/* Strings corresponding to IO_QUERY_DEVICE_DATA_FORMAT */
PCWSTR IoDeviceInfoNames[IoQueryDeviceMaxData] =
{
    L"Identifier",
    L"Configuration Data",
    L"Component Information"
};
 
/* PRIVATE FUNCTIONS **********************************************************/
 
static NTSTATUS
IopQueryDeviceDescription(
    _In_ PIO_QUERY Query,
    _In_ UNICODE_STRING RootKey,
    _In_ HANDLE RootKeyHandle,
    _In_ ULONG Bus,
    _In_ PKEY_VALUE_FULL_INFORMATION* BusInformation)
{
    NTSTATUS Status = STATUS_SUCCESS;
 
    /* Controller data */
    UNICODE_STRING ControllerString;
    UNICODE_STRING ControllerRootRegName = RootKey;
    UNICODE_STRING ControllerRegName;
    HANDLE ControllerKeyHandle;
    PKEY_FULL_INFORMATION ControllerFullInformation = NULL;
    PKEY_VALUE_FULL_INFORMATION ControllerInformation[IoQueryDeviceMaxData] =
        {NULL, NULL, NULL};
    ULONG ControllerNumber;
    ULONG ControllerLoop;
    ULONG MaximumControllerNumber;
 
    /* Peripheral data */
    UNICODE_STRING PeripheralString;
    HANDLE PeripheralKeyHandle;
    PKEY_FULL_INFORMATION PeripheralFullInformation;
    PKEY_VALUE_FULL_INFORMATION PeripheralInformation[IoQueryDeviceMaxData] =
        {NULL, NULL, NULL};
    ULONG PeripheralNumber;
    ULONG PeripheralLoop;
    ULONG MaximumPeripheralNumber;
 
    /* Global Registry data */
    OBJECT_ATTRIBUTES ObjectAttributes;
    ULONG LenFullInformation;
    ULONG LenKeyFullInformation;
    UNICODE_STRING TempString;
    WCHAR TempBuffer[14];
 
    IORSRCTRACE("\nIopQueryDeviceDescription(Query: 0x%p)\n"
                "    RootKey: '%wZ'\n"
                "    RootKeyHandle: 0x%p\n"
                "    Bus: %lu\n",
                Query,
                &RootKey, RootKeyHandle,
                Bus);
 
    /* Temporary string */
    RtlInitEmptyUnicodeString(&TempString, TempBuffer, sizeof(TempBuffer));
 
    /* Append controller name to string */
    RtlAppendUnicodeToString(&ControllerRootRegName, L"\\");
    RtlAppendUnicodeToString(&ControllerRootRegName, ArcTypes[*Query->ControllerType]);
 
    /* Set the controller number if specified */
    if (Query->ControllerNumber)
    {
        ControllerNumber = *(Query->ControllerNumber);
        MaximumControllerNumber = ControllerNumber + 1;
        IORSRCTRACE("    Getting controller #%lu\n", ControllerNumber);
    }
    else
    {
        IORSRCTRACE("    Enumerating controllers in '%wZ'...\n", &ControllerRootRegName);
 
        /* Find out how many controllers there are */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &ControllerRootRegName,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
 
        Status = ZwOpenKey(&ControllerKeyHandle, KEY_READ, &ObjectAttributes);
 
        if (NT_SUCCESS(Status))
        {
            /* Retrieve the necessary buffer space */
            ZwQueryKey(ControllerKeyHandle,
                       KeyFullInformation,
                       NULL, 0,
                       &LenFullInformation);
 
            /* Allocate it */
            ControllerFullInformation = ExAllocatePoolWithTag(PagedPool, LenFullInformation, TAG_IO_RESOURCE);
            if (!ControllerFullInformation)
            {
                ZwClose(ControllerKeyHandle);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
            /* Get the information */
            Status = ZwQueryKey(ControllerKeyHandle,
                                KeyFullInformation,
                                ControllerFullInformation,
                                LenFullInformation,
                                &LenFullInformation);
            ZwClose(ControllerKeyHandle);
            ControllerKeyHandle = NULL;
        }
 
        /* No controller was found, bail out */
        if (!NT_SUCCESS(Status))
        {
            if (ControllerFullInformation)
                ExFreePoolWithTag(ControllerFullInformation, TAG_IO_RESOURCE);
            return Status;
        }
 
        /* Find out the controllers */
        ControllerNumber = 0;
        MaximumControllerNumber = ControllerFullInformation->SubKeys;
 
        /* Cleanup */
        ExFreePoolWithTag(ControllerFullInformation, TAG_IO_RESOURCE);
        ControllerFullInformation = NULL;
    }
 
    /* Save string */
    ControllerRegName = ControllerRootRegName;
 
    /* Loop through controllers */
    for (; ControllerNumber < MaximumControllerNumber; ControllerNumber++)
    {
        /* Load string */
        ControllerRootRegName = ControllerRegName;
 
        /* Convert controller number to registry string */
        Status = RtlIntegerToUnicodeString(ControllerNumber, 10, &TempString);
 
        /* Create string */
        Status |= RtlAppendUnicodeToString(&ControllerRootRegName, L"\\");
        Status |= RtlAppendUnicodeStringToString(&ControllerRootRegName, &TempString);
 
        /* Something messed up */
        if (!NT_SUCCESS(Status))
            break;
 
        IORSRCTRACE("    Retrieving controller '%wZ'\n", &ControllerRootRegName);
 
        /* Open the registry key */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &ControllerRootRegName,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
 
        Status = ZwOpenKey(&ControllerKeyHandle, KEY_READ, &ObjectAttributes);
 
        /* Read the configuration data */
        if (NT_SUCCESS(Status))
        {
            for (ControllerLoop = 0; ControllerLoop < RTL_NUMBER_OF(IoDeviceInfoNames); ControllerLoop++)
            {
                /* Identifier string first */
                RtlInitUnicodeString(&ControllerString, IoDeviceInfoNames[ControllerLoop]);
 
                /* Retrieve the necessary buffer space */
                Status = ZwQueryValueKey(ControllerKeyHandle,
                                         &ControllerString,
                                         KeyValueFullInformation,
                                         NULL, 0,
                                         &LenKeyFullInformation);
 
                if (!NT_SUCCESS(Status) &&
                    (Status != STATUS_BUFFER_TOO_SMALL) &&
                    (Status != STATUS_BUFFER_OVERFLOW))
                {
                    ControllerInformation[ControllerLoop] = NULL;
                    continue;
                }
 
                /* Allocate it */
                ControllerInformation[ControllerLoop] = ExAllocatePoolWithTag(PagedPool, LenKeyFullInformation, TAG_IO_RESOURCE);
                if (!ControllerInformation[ControllerLoop])
                {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }
 
                /* Get the information */
                Status = ZwQueryValueKey(ControllerKeyHandle,
                                         &ControllerString,
                                         KeyValueFullInformation,
                                         ControllerInformation[ControllerLoop],
                                         LenKeyFullInformation,
                                         &LenKeyFullInformation);
            }
 
            /* Cleanup */
            ZwClose(ControllerKeyHandle);
            ControllerKeyHandle = NULL;
        }
 
        /* Something messed up */
        if (!NT_SUCCESS(Status))
            goto EndLoop;
 
        /* We now have bus *AND* controller information, is it enough? */
        if (!Query->PeripheralType || !(*Query->PeripheralType))
        {
            IORSRCTRACE("    --> Bus #%lu Controller #%lu Callout: '%wZ'\n",
                        Bus, ControllerNumber, &ControllerRootRegName);
 
            Status = Query->CalloutRoutine(Query->Context,
                                           &ControllerRootRegName,
                                           *Query->BusType,
                                           Bus,
                                           BusInformation,
                                           *Query->ControllerType,
                                           ControllerNumber,
                                           ControllerInformation,
                                           0,
                                           0,
                                           NULL);
            goto EndLoop;
        }
 
        /* Not enough: the caller also wants peripheral name */
        Status = RtlAppendUnicodeToString(&ControllerRootRegName, L"\\");
        Status |= RtlAppendUnicodeToString(&ControllerRootRegName, ArcTypes[*Query->PeripheralType]);
 
        /* Something messed up */
        if (!NT_SUCCESS(Status))
            goto EndLoop;
 
        /* Set the peripheral number if specified */
        if (Query->PeripheralNumber)
        {
            PeripheralNumber = *(Query->PeripheralNumber);
            MaximumPeripheralNumber = PeripheralNumber + 1;
            IORSRCTRACE("    Getting peripheral #%lu\n", PeripheralNumber);
        }
        else
        {
            IORSRCTRACE("    Enumerating peripherals in '%wZ'...\n", &ControllerRootRegName);
 
            /* Find out how many peripherals there are */
            InitializeObjectAttributes(&ObjectAttributes,
                                       &ControllerRootRegName,
                                       OBJ_CASE_INSENSITIVE,
                                       NULL,
                                       NULL);
 
            Status = ZwOpenKey(&PeripheralKeyHandle, KEY_READ, &ObjectAttributes);
 
            if (NT_SUCCESS(Status))
            {
                /* Retrieve the necessary buffer space */
                ZwQueryKey(PeripheralKeyHandle,
                           KeyFullInformation,
                           NULL, 0,
                           &LenFullInformation);
 
                /* Allocate it */
                PeripheralFullInformation = ExAllocatePoolWithTag(PagedPool, LenFullInformation, TAG_IO_RESOURCE);
                if (!PeripheralFullInformation)
                {
                    ZwClose(PeripheralKeyHandle);
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    goto EndLoop;
                }
 
                /* Get the information */
                Status = ZwQueryKey(PeripheralKeyHandle,
                                    KeyFullInformation,
                                    PeripheralFullInformation,
                                    LenFullInformation,
                                    &LenFullInformation);
                ZwClose(PeripheralKeyHandle);
                PeripheralKeyHandle = NULL;
            }
 
            /* No controller was found, cleanup and bail out */
            if (!NT_SUCCESS(Status))
            {
                Status = STATUS_SUCCESS;
                goto EndLoop;
            }
 
            /* Find out peripheral number */
            PeripheralNumber = 0;
            MaximumPeripheralNumber = PeripheralFullInformation->SubKeys;
 
            /* Cleanup */
            ExFreePoolWithTag(PeripheralFullInformation, TAG_IO_RESOURCE);
            PeripheralFullInformation = NULL;
        }
 
        /* Save name */
        ControllerRegName = ControllerRootRegName;
 
        /* Loop through peripherals */
        for (; PeripheralNumber < MaximumPeripheralNumber; PeripheralNumber++)
        {
            /* Restore name */
            ControllerRootRegName = ControllerRegName;
 
            /* Convert peripheral number to registry string */
            Status = RtlIntegerToUnicodeString(PeripheralNumber, 10, &TempString);
 
            /* Create string */
            Status |= RtlAppendUnicodeToString(&ControllerRootRegName, L"\\");
            Status |= RtlAppendUnicodeStringToString(&ControllerRootRegName, &TempString);
 
            /* Something messed up */
            if (!NT_SUCCESS(Status))
                break;
 
            IORSRCTRACE("    Retrieving peripheral '%wZ'\n", &ControllerRootRegName);
 
            /* Open the registry key */
            InitializeObjectAttributes(&ObjectAttributes,
                                       &ControllerRootRegName,
                                       OBJ_CASE_INSENSITIVE,
                                       NULL,
                                       NULL);
 
            Status = ZwOpenKey(&PeripheralKeyHandle, KEY_READ, &ObjectAttributes);
 
            if (NT_SUCCESS(Status))
            {
                for (PeripheralLoop = 0; PeripheralLoop < RTL_NUMBER_OF(IoDeviceInfoNames); PeripheralLoop++)
                {
                    /* Identifier string first */
                    RtlInitUnicodeString(&PeripheralString, IoDeviceInfoNames[PeripheralLoop]);
 
                    /* Retrieve the necessary buffer space */
                    Status = ZwQueryValueKey(PeripheralKeyHandle,
                                             &PeripheralString,
                                             KeyValueFullInformation,
                                             NULL, 0,
                                             &LenKeyFullInformation);
 
                    if (!NT_SUCCESS(Status) &&
                        (Status != STATUS_BUFFER_TOO_SMALL) &&
                        (Status != STATUS_BUFFER_OVERFLOW))
                    {
                        PeripheralInformation[PeripheralLoop] = NULL;
                        continue;
                    }
 
                    /* Allocate it */
                    PeripheralInformation[PeripheralLoop] = ExAllocatePoolWithTag(PagedPool, LenKeyFullInformation, TAG_IO_RESOURCE);
                    if (!PeripheralInformation[PeripheralLoop])
                    {
                        Status = STATUS_INSUFFICIENT_RESOURCES;
                        break;
                    }
 
                    /* Get the information */
                    Status = ZwQueryValueKey(PeripheralKeyHandle,
                                             &PeripheralString,
                                             KeyValueFullInformation,
                                             PeripheralInformation[PeripheralLoop],
                                             LenKeyFullInformation,
                                             &LenKeyFullInformation);
                }
 
                /* Cleanup */
                ZwClose(PeripheralKeyHandle);
                PeripheralKeyHandle = NULL;
 
                /* We now have everything the caller could possibly want */
                if (NT_SUCCESS(Status))
                {
                    IORSRCTRACE("    --> Bus #%lu Controller #%lu Peripheral #%lu Callout: '%wZ'\n",
                                Bus, ControllerNumber, PeripheralNumber, &ControllerRootRegName);
 
                    Status = Query->CalloutRoutine(Query->Context,
                                                   &ControllerRootRegName,
                                                   *Query->BusType,
                                                   Bus,
                                                   BusInformation,
                                                   *Query->ControllerType,
                                                   ControllerNumber,
                                                   ControllerInformation,
                                                   *Query->PeripheralType,
                                                   PeripheralNumber,
                                                   PeripheralInformation);
                }
 
                /* Free the allocated memory */
                for (PeripheralLoop = 0; PeripheralLoop < RTL_NUMBER_OF(IoDeviceInfoNames); PeripheralLoop++)
                {
                    if (PeripheralInformation[PeripheralLoop])
                    {
                        ExFreePoolWithTag(PeripheralInformation[PeripheralLoop], TAG_IO_RESOURCE);
                        PeripheralInformation[PeripheralLoop] = NULL;
                    }
                }
 
                /* Something messed up */
                if (!NT_SUCCESS(Status))
                    break;
            }
        }
 
EndLoop:
        /* Free the allocated memory */
        for (ControllerLoop = 0; ControllerLoop < RTL_NUMBER_OF(IoDeviceInfoNames); ControllerLoop++)
        {
            if (ControllerInformation[ControllerLoop])
            {
                ExFreePoolWithTag(ControllerInformation[ControllerLoop], TAG_IO_RESOURCE);
                ControllerInformation[ControllerLoop] = NULL;
            }
        }
 
        /* Something messed up */
        if (!NT_SUCCESS(Status))
            break;
    }
 
    return Status;
}
 
static NTSTATUS
IopQueryBusDescription(
    _In_ PIO_QUERY Query,
    _In_ UNICODE_STRING RootKey,
    _In_ HANDLE RootKeyHandle,
    _Inout_ PULONG Bus,
    _In_ BOOLEAN KeyIsRoot)
{
    NTSTATUS Status;
    ULONG BusLoop;
    UNICODE_STRING SubRootRegName;
    UNICODE_STRING BusString;
    UNICODE_STRING SubBusString;
    ULONG LenBasicInformation = 0;
    ULONG LenFullInformation;
    ULONG LenKeyFullInformation;
    ULONG LenKey;
    HANDLE SubRootKeyHandle;
    PKEY_FULL_INFORMATION FullInformation;
    PKEY_BASIC_INFORMATION BasicInformation = NULL;
    OBJECT_ATTRIBUTES ObjectAttributes;
    PKEY_VALUE_FULL_INFORMATION BusInformation[IoQueryDeviceMaxData] =
        {NULL, NULL, NULL};
 
    IORSRCTRACE("\nIopQueryBusDescription(Query: 0x%p)\n"
                "    RootKey: '%wZ'\n"
                "    RootKeyHandle: 0x%p\n"
                "    KeyIsRoot: %s\n"
                "    Bus: 0x%p (%lu)\n",
                Query,
                &RootKey, RootKeyHandle,
                KeyIsRoot ? "TRUE" : "FALSE",
                Bus, Bus ? *Bus : -1);
 
    /* Retrieve the necessary buffer space */
    Status = ZwQueryKey(RootKeyHandle,
                        KeyFullInformation,
                        NULL, 0,
                        &LenFullInformation);
 
    if (!NT_SUCCESS(Status) &&
        (Status != STATUS_BUFFER_TOO_SMALL) &&
        (Status != STATUS_BUFFER_OVERFLOW))
    {
        return Status;
    }
 
    /* Allocate it */
    FullInformation = ExAllocatePoolWithTag(PagedPool, LenFullInformation, TAG_IO_RESOURCE);
    if (!FullInformation)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Get the information */
    Status = ZwQueryKey(RootKeyHandle,
                        KeyFullInformation,
                        FullInformation,
                        LenFullInformation,
                        &LenFullInformation);
    if (NT_SUCCESS(Status))
    {
        /* Buffer needed for all the keys under this one */
        LenBasicInformation = FullInformation->MaxNameLen + sizeof(KEY_BASIC_INFORMATION);
 
        /* Allocate it */
        BasicInformation = ExAllocatePoolWithTag(PagedPool, LenBasicInformation, TAG_IO_RESOURCE);
        if (!BasicInformation)
        {
            ExFreePoolWithTag(FullInformation, TAG_IO_RESOURCE);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    /* Deallocate the old buffer */
    ExFreePoolWithTag(FullInformation, TAG_IO_RESOURCE);
 
    /* Try to find a bus */
    for (BusLoop = 0; NT_SUCCESS(Status); BusLoop++)
    {
        /* Bus parameter was passed and number was matched */
        if (Query->BusNumber && (*(Query->BusNumber) == *Bus))
            break;
 
        /* Enumerate the Key */
        Status = ZwEnumerateKey(RootKeyHandle,
                                BusLoop,
                                KeyBasicInformation,
                                BasicInformation,
                                LenBasicInformation,
                                &LenKey);
 
        /* Stop if everything was enumerated */
        if (!NT_SUCCESS(Status))
            break;
 
        IORSRCTRACE("    Seen: '%.*ws'\n", BasicInformation->NameLength/sizeof(WCHAR), BasicInformation->Name);
 
        /* What bus are we going to go down? (only check if this is a root key) */
        if (KeyIsRoot)
        {
            if (wcsncmp(BasicInformation->Name, L"MultifunctionAdapter", BasicInformation->NameLength / sizeof(WCHAR)) &&
                wcsncmp(BasicInformation->Name, L"EisaAdapter", BasicInformation->NameLength / sizeof(WCHAR)) &&
                wcsncmp(BasicInformation->Name, L"TcAdapter", BasicInformation->NameLength / sizeof(WCHAR)))
            {
                /* Nothing found, check next */
                continue;
            }
        }
 
        /* Enumerate the bus */
        BusString.Buffer = BasicInformation->Name;
        BusString.Length = (USHORT)BasicInformation->NameLength;
        BusString.MaximumLength = (USHORT)BasicInformation->NameLength;
 
        /* Open a handle to the root registry key */
        InitializeObjectAttributes(&ObjectAttributes,
                                   &BusString,
                                   OBJ_CASE_INSENSITIVE,
                                   RootKeyHandle,
                                   NULL);
 
        Status = ZwOpenKey(&SubRootKeyHandle, KEY_READ, &ObjectAttributes);
 
        /* Go on if we failed */
        if (!NT_SUCCESS(Status))
            continue;
 
        /* Key opened, create the path */
        SubRootRegName = RootKey;
        RtlAppendUnicodeToString(&SubRootRegName, L"\\");
        RtlAppendUnicodeStringToString(&SubRootRegName, &BusString);
 
        IORSRCTRACE("    SubRootRegName: '%wZ'\n", &SubRootRegName);
 
        if (!KeyIsRoot)
        {
            /* Parsing a sub-bus key */
            ULONG SubBusLoop;
            for (SubBusLoop = 0; SubBusLoop < RTL_NUMBER_OF(IoDeviceInfoNames); SubBusLoop++)
            {
                /* Identifier string first */
                RtlInitUnicodeString(&SubBusString, IoDeviceInfoNames[SubBusLoop]);
 
                IORSRCTRACE("    Getting bus value: '%wZ'\n", &SubBusString);
 
                /* Retrieve the necessary buffer space */
                ZwQueryValueKey(SubRootKeyHandle,
                                &SubBusString,
                                KeyValueFullInformation,
                                NULL, 0,
                                &LenKeyFullInformation);
 
                /* Allocate it */
                BusInformation[SubBusLoop] = ExAllocatePoolWithTag(PagedPool, LenKeyFullInformation, TAG_IO_RESOURCE);
                if (!BusInformation[SubBusLoop])
                {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    break;
                }
 
                /* Get the information */
                Status = ZwQueryValueKey(SubRootKeyHandle,
                                         &SubBusString,
                                         KeyValueFullInformation,
                                         BusInformation[SubBusLoop],
                                         LenKeyFullInformation,
                                         &LenKeyFullInformation);
            }
 
            if (NT_SUCCESS(Status))
            {
                PKEY_VALUE_FULL_INFORMATION BusConfigData =
                    BusInformation[IoQueryDeviceConfigurationData];
 
                /* Do we have something? */
                if (BusConfigData != NULL &&
                    BusConfigData->DataLength != 0 &&
                    /* Does it match what we want? */
                    (((PCM_FULL_RESOURCE_DESCRIPTOR)((ULONG_PTR)BusConfigData +
                        BusConfigData->DataOffset))->InterfaceType == *(Query->BusType)))
                {
                    /* Found a bus */
                    (*Bus)++;
 
                    /* Is it the bus we wanted? */
                    if (Query->BusNumber == NULL || *(Query->BusNumber) == *Bus)
                    {
                        if (Query->ControllerType == NULL)
                        {
                            IORSRCTRACE("    --> Bus #%lu Callout: '%wZ'\n", *Bus, &SubRootRegName);
 
                            /* We don't want controller information: call the callback */
                            Status = Query->CalloutRoutine(Query->Context,
                                                           &SubRootRegName,
                                                           *(Query->BusType),
                                                           *Bus,
                                                           BusInformation,
                                                           0,
                                                           0,
                                                           NULL,
                                                           0,
                                                           0,
                                                           NULL);
                        }
                        else
                        {
                            IORSRCTRACE("    --> Getting device on Bus #%lu : '%wZ'\n", *Bus, &SubRootRegName);
 
                            /* We want controller information: get it */
                            Status = IopQueryDeviceDescription(Query,
                                                               SubRootRegName,
                                                               RootKeyHandle,
                                                               *Bus,
                                                               (PKEY_VALUE_FULL_INFORMATION*)BusInformation);
                        }
                    }
                }
            }
 
            /* Free the allocated memory */
            for (SubBusLoop = 0; SubBusLoop < RTL_NUMBER_OF(IoDeviceInfoNames); SubBusLoop++)
            {
                if (BusInformation[SubBusLoop])
                {
                    ExFreePoolWithTag(BusInformation[SubBusLoop], TAG_IO_RESOURCE);
                    BusInformation[SubBusLoop] = NULL;
                }
            }
 
            /* Exit the loop if we found the bus */
            if (Query->BusNumber && (*(Query->BusNumber) == *Bus))
            {
                ZwClose(SubRootKeyHandle);
                SubRootKeyHandle = NULL;
                continue;
            }
        }
 
        /* Enumerate the buses below us recursively if we haven't found the bus yet */
        Status = IopQueryBusDescription(Query, SubRootRegName, SubRootKeyHandle, Bus, !KeyIsRoot);
 
        /* Everything enumerated */
        if (Status == STATUS_NO_MORE_ENTRIES)
            Status = STATUS_SUCCESS;
 
        ZwClose(SubRootKeyHandle);
        SubRootKeyHandle = NULL;
    }
 
    /* Free the last remaining allocated memory */
    if (BasicInformation)
        ExFreePoolWithTag(BasicInformation, TAG_IO_RESOURCE);
 
    return Status;
}
 
NTSTATUS
IopFetchConfigurationInformation(
    _Out_ PWSTR* SymbolicLinkList,
    _In_ GUID Guid,
    _In_ ULONG ExpectedInterfaces,
    _Out_ PULONG Interfaces)
{
    NTSTATUS Status;
    ULONG interfaces = 0;
    PWSTR symbolicLinkList;
 
    /* Get the associated enabled interfaces with the given GUID */
    Status = IoGetDeviceInterfaces(&Guid, NULL, 0, SymbolicLinkList);
    if (!NT_SUCCESS(Status))
    {
        /* Zero output and leave */
        if (SymbolicLinkList)
            *SymbolicLinkList = NULL;
 
        return STATUS_UNSUCCESSFUL;
    }
 
    symbolicLinkList = *SymbolicLinkList;
 
    /* Count the number of enabled interfaces by counting the number of symbolic links */
    while (*symbolicLinkList != UNICODE_NULL)
    {
        interfaces++;
        symbolicLinkList += (wcslen(symbolicLinkList) + 1);
    }
 
    /* Matching result will define the result */
    Status = (interfaces >= ExpectedInterfaces) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
    /* Finally, give back to the caller the number of found interfaces */
    *Interfaces = interfaces;
 
    return Status;
}
 
VOID
IopStoreSystemPartitionInformation(
    _In_ PUNICODE_STRING NtSystemPartitionDeviceName,
    _In_ PUNICODE_STRING OsLoaderPathName)
{
    NTSTATUS Status;
    UNICODE_STRING LinkTarget, KeyName;
    OBJECT_ATTRIBUTES ObjectAttributes;
    HANDLE LinkHandle, RegistryHandle, KeyHandle;
    WCHAR LinkTargetBuffer[256];
    UNICODE_STRING CmRegistryMachineSystemName = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM");
 
    ASSERT(NtSystemPartitionDeviceName->MaximumLength >= NtSystemPartitionDeviceName->Length + sizeof(WCHAR));
    ASSERT(NtSystemPartitionDeviceName->Buffer[NtSystemPartitionDeviceName->Length / sizeof(WCHAR)] == UNICODE_NULL);
    ASSERT(OsLoaderPathName->MaximumLength >= OsLoaderPathName->Length + sizeof(WCHAR));
    ASSERT(OsLoaderPathName->Buffer[OsLoaderPathName->Length / sizeof(WCHAR)] == UNICODE_NULL);
 
    /* First define needed stuff to open NtSystemPartitionDeviceName symbolic link */
    InitializeObjectAttributes(&ObjectAttributes,
                               NtSystemPartitionDeviceName,
                               OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
 
    /* Open NtSystemPartitionDeviceName symbolic link */
    Status = ZwOpenSymbolicLinkObject(&LinkHandle,
                                      SYMBOLIC_LINK_QUERY,
                                      &ObjectAttributes);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed to open symlink %wZ, Status=%lx\n", NtSystemPartitionDeviceName, Status);
        return;
    }
 
    /* Prepare the string that will receive where symbolic link points to.
     * We will zero the end of the string after having received it */
    RtlInitEmptyUnicodeString(&LinkTarget, LinkTargetBuffer,
                              sizeof(LinkTargetBuffer) - sizeof(UNICODE_NULL));
 
    /* Query target */
    Status = ZwQuerySymbolicLinkObject(LinkHandle, &LinkTarget, NULL);
 
    /* We are done with symbolic link */
    ObCloseHandle(LinkHandle, KernelMode);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed querying symlink %wZ, Status=%lx\n", NtSystemPartitionDeviceName, Status);
        return;
    }
 
    /* As promised, we zero the end */
    LinkTarget.Buffer[LinkTarget.Length / sizeof(WCHAR)] = UNICODE_NULL;
 
    /* Open registry to save data (HKLM\SYSTEM) */
    Status = IopOpenRegistryKeyEx(&RegistryHandle,
                                  NULL,
                                  &CmRegistryMachineSystemName,
                                  KEY_ALL_ACCESS);
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed to open HKLM\\SYSTEM, Status=%lx\n", Status);
        return;
    }
 
    /* Open or create the Setup subkey where we'll store in */
    RtlInitUnicodeString(&KeyName, L"Setup");
 
    Status = IopCreateRegistryKeyEx(&KeyHandle,
                                    RegistryHandle,
                                    &KeyName,
                                    KEY_ALL_ACCESS,
                                    REG_OPTION_NON_VOLATILE,
                                    NULL);
 
    /* We're done with HKLM\SYSTEM */
    ObCloseHandle(RegistryHandle, KernelMode);
 
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed opening/creating Setup key, Status=%lx\n", Status);
        return;
    }
 
    /* Prepare first data writing */
    RtlInitUnicodeString(&KeyName, L"SystemPartition");
 
    /* Write SystemPartition value which is the target of the symbolic link */
    Status = ZwSetValueKey(KeyHandle,
                           &KeyName,
                           0,
                           REG_SZ,
                           LinkTarget.Buffer,
                           LinkTarget.Length + sizeof(WCHAR));
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed writing SystemPartition value, Status=%lx\n", Status);
    }
 
    /* Prepare for second data writing */
    RtlInitUnicodeString(&KeyName, L"OsLoaderPath");
 
    /* Remove trailing slash if any (one slash only excepted) */
    if (OsLoaderPathName->Length > sizeof(WCHAR) &&
        OsLoaderPathName->Buffer[(OsLoaderPathName->Length / sizeof(WCHAR)) - 1] == OBJ_NAME_PATH_SEPARATOR)
    {
        OsLoaderPathName->Length -= sizeof(WCHAR);
        OsLoaderPathName->Buffer[OsLoaderPathName->Length / sizeof(WCHAR)] = UNICODE_NULL;
    }
 
    /* Then, write down data */
    Status = ZwSetValueKey(KeyHandle,
                           &KeyName,
                           0,
                           REG_SZ,
                           OsLoaderPathName->Buffer,
                           OsLoaderPathName->Length + sizeof(UNICODE_NULL));
    if (!NT_SUCCESS(Status))
    {
        DPRINT("Failed writing OsLoaderPath value, Status=%lx\n", Status);
    }
 
    /* We're finally done! */
    ObCloseHandle(KeyHandle, KernelMode);
}
 
/* PUBLIC FUNCTIONS ***********************************************************/
 
PCONFIGURATION_INFORMATION
NTAPI
IoGetConfigurationInformation(VOID)
{
    return &_SystemConfigurationInformation;
}
 
NTSTATUS
NTAPI
IoReportResourceUsage(
    _In_opt_ PUNICODE_STRING DriverClassName,
    _In_ PDRIVER_OBJECT DriverObject,
    _In_reads_bytes_opt_(DriverListSize) PCM_RESOURCE_LIST DriverList,
    _In_opt_ ULONG DriverListSize,
    _In_opt_ PDEVICE_OBJECT DeviceObject,
    _In_reads_bytes_opt_(DeviceListSize) PCM_RESOURCE_LIST DeviceList,
    _In_opt_ ULONG DeviceListSize,
    _In_ BOOLEAN OverrideConflict,
    _Out_ PBOOLEAN ConflictDetected)
{
    NTSTATUS Status;
    PCM_RESOURCE_LIST ResourceList;
 
    DPRINT1("IoReportResourceUsage is halfplemented!\n");
 
    if (!DriverList && !DeviceList)
        return STATUS_INVALID_PARAMETER;
 
    if (DeviceList)
        ResourceList = DeviceList;
    else
        ResourceList = DriverList;
 
    Status = IopDetectResourceConflict(ResourceList, FALSE, NULL);
    if (Status == STATUS_CONFLICTING_ADDRESSES)
    {
        *ConflictDetected = TRUE;
 
        if (!OverrideConflict)
        {
            DPRINT1("Denying an attempt to claim resources currently in use by another device!\n");
            return STATUS_CONFLICTING_ADDRESSES;
        }
        else
        {
            DPRINT1("Proceeding with conflicting resources\n");
        }
    }
    else if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    /* TODO: Claim resources in registry */
 
    *ConflictDetected = FALSE;
 
    return STATUS_SUCCESS;
}
 
static NTSTATUS
IopLegacyResourceAllocation(
    _In_ ARBITER_REQUEST_SOURCE AllocationType,
    _In_ PDRIVER_OBJECT DriverObject,
    _In_opt_ PDEVICE_OBJECT DeviceObject,
    _In_opt_ PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirements,
    _Inout_ PCM_RESOURCE_LIST* AllocatedResources)
{
    NTSTATUS Status;
 
    DPRINT1("IopLegacyResourceAllocation is halfplemented!\n");
 
    if (!ResourceRequirements)
    {
        /* We can get there by calling IoAssignResources() with RequestedResources = NULL.
         * TODO: not sure what we should do, but we shouldn't crash.
         */
        UNIMPLEMENTED;
        return STATUS_NOT_IMPLEMENTED;
    }
 
    Status = IopFixupResourceListWithRequirements(ResourceRequirements,
                                                  AllocatedResources);
    if (!NT_SUCCESS(Status))
    {
        if (Status == STATUS_CONFLICTING_ADDRESSES)
        {
            DPRINT1("Denying an attempt to claim resources currently in use by another device!\n");
        }
 
        return Status;
    }
 
    /* TODO: Claim resources in registry */
    return STATUS_SUCCESS;
}
 
/*
 * @implemented
 */
NTSTATUS
NTAPI
IoAssignResources(
    _In_ PUNICODE_STRING RegistryPath,
    _In_opt_ PUNICODE_STRING DriverClassName,
    _In_ PDRIVER_OBJECT DriverObject,
    _In_opt_ PDEVICE_OBJECT DeviceObject,
    _In_opt_ PIO_RESOURCE_REQUIREMENTS_LIST RequestedResources,
    _Inout_ PCM_RESOURCE_LIST* AllocatedResources)
{
    PDEVICE_NODE DeviceNode;
 
    UNREFERENCED_PARAMETER(RegistryPath);
    UNREFERENCED_PARAMETER(DriverClassName);
 
    /* Do we have a DO? */
    if (DeviceObject)
    {
        /* Get its device node */
        DeviceNode = IopGetDeviceNode(DeviceObject);
        if (DeviceNode && !(DeviceNode->Flags & DNF_LEGACY_RESOURCE_DEVICENODE))
        {
            /* New drivers should not call this API */
            KeBugCheckEx(PNP_DETECTED_FATAL_ERROR,
                         0x2,
                         (ULONG_PTR)DeviceObject,
                         (ULONG_PTR)DriverObject,
                         0);
        }
    }
 
    /* Did the driver supply resources? */
    if (RequestedResources)
    {
        /* Make sure there's actually something useful in them */
        if (!(RequestedResources->AlternativeLists) || !(RequestedResources->List[0].Count))
        {
            /* Empty resources are no resources */
            RequestedResources = NULL;
        }
    }
 
    /* Initialize output if given */
    if (AllocatedResources)
        *AllocatedResources = NULL;
 
    /* Call internal helper function */
    return IopLegacyResourceAllocation(ArbiterRequestLegacyAssigned,
                                       DriverObject,
                                       DeviceObject,
                                       RequestedResources,
                                       AllocatedResources);
}
 
NTSTATUS
NTAPI
IoQueryDeviceDescription(
    _In_opt_ PINTERFACE_TYPE BusType,
    _In_opt_ PULONG BusNumber,
    _In_opt_ PCONFIGURATION_TYPE ControllerType,
    _In_opt_ PULONG ControllerNumber,
    _In_opt_ PCONFIGURATION_TYPE PeripheralType,
    _In_opt_ PULONG PeripheralNumber,
    _In_ PIO_QUERY_DEVICE_ROUTINE CalloutRoutine,
    _In_opt_ PVOID Context)
{
    NTSTATUS Status;
    ULONG BusLoopNumber = -1; /* Root Bus */
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING RootRegKey;
    HANDLE RootRegHandle;
    IO_QUERY Query;
 
    IORSRCTRACE("\nIoQueryDeviceDescription()\n"
                "    BusType:          0x%p (%lu)\n"
                "    BusNumber:        0x%p (%lu)\n"
                "    ControllerType:   0x%p (%lu)\n"
                "    ControllerNumber: 0x%p (%lu)\n"
                "    PeripheralType:   0x%p (%lu)\n"
                "    PeripheralNumber: 0x%p (%lu)\n"
                "    CalloutRoutine:   0x%p\n"
                "    Context:          0x%p\n"
                "--> Query: 0x%p\n",
                BusType, BusType ? *BusType : -1,
                BusNumber, BusNumber ? *BusNumber : -1,
                ControllerType, ControllerType ? *ControllerType : -1,
                ControllerNumber, ControllerNumber ? *ControllerNumber : -1,
                PeripheralType, PeripheralType ? *PeripheralType : -1,
                PeripheralNumber, PeripheralNumber ? *PeripheralNumber : -1,
                CalloutRoutine, Context,
                &Query);
 
    if (!BusType)
        return STATUS_NOT_IMPLEMENTED;
 
    /* Set up the string */
    RootRegKey.Length = 0;
    RootRegKey.MaximumLength = 2048;
    RootRegKey.Buffer = ExAllocatePoolWithTag(PagedPool, RootRegKey.MaximumLength, TAG_IO_RESOURCE);
    if (!RootRegKey.Buffer)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    RtlAppendUnicodeToString(&RootRegKey, L"\\REGISTRY\\MACHINE\\HARDWARE\\DESCRIPTION\\SYSTEM");
 
    /* Open a handle to the Root Registry Key */
    InitializeObjectAttributes(&ObjectAttributes,
                               &RootRegKey,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    Status = ZwOpenKey(&RootRegHandle, KEY_READ, &ObjectAttributes);
 
    if (NT_SUCCESS(Status))
    {
        /* Use a helper function to loop though this key and get the information */
        Query.BusType = BusType;
        Query.BusNumber = BusNumber;
        Query.ControllerType = ControllerType;
        Query.ControllerNumber = ControllerNumber;
        Query.PeripheralType = PeripheralType;
        Query.PeripheralNumber = PeripheralNumber;
        Query.CalloutRoutine = CalloutRoutine;
        Query.Context = Context;
        Status = IopQueryBusDescription(&Query,
                                        RootRegKey,
                                        RootRegHandle,
                                        &BusLoopNumber,
                                        TRUE);
 
        /* Close registry key */
        ZwClose(RootRegHandle);
    }
 
    /* Cleanup */
    ExFreePoolWithTag(RootRegKey.Buffer, TAG_IO_RESOURCE);
 
    return Status;
}
 
NTSTATUS
NTAPI
IoReportHalResourceUsage(
    _In_ PUNICODE_STRING HalName,
    _In_ PCM_RESOURCE_LIST RawResourceList,
    _In_ PCM_RESOURCE_LIST TranslatedResourceList,
    _In_ ULONG ResourceListSize)
{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING Name;
    ULONG Disposition;
    HANDLE ResourceMapKey;
    HANDLE HalKey;
    HANDLE DescriptionKey;
 
    /* Open/Create 'RESOURCEMAP' key */
    RtlInitUnicodeString(&Name, L"\\Registry\\Machine\\HARDWARE\\RESOURCEMAP");
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
                               0,
                               NULL);
    Status = ZwCreateKey(&ResourceMapKey,
                         KEY_ALL_ACCESS,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         &Disposition);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Open/Create 'Hardware Abstraction Layer' key */
    RtlInitUnicodeString(&Name, L"Hardware Abstraction Layer");
    InitializeObjectAttributes(&ObjectAttributes,
                               &Name,
                               OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
                               ResourceMapKey,
                               NULL);
    Status = ZwCreateKey(&HalKey,
                         KEY_ALL_ACCESS,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         &Disposition);
    ZwClose(ResourceMapKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Create 'HalName' key */
    InitializeObjectAttributes(&ObjectAttributes,
                               HalName,
                               OBJ_CASE_INSENSITIVE,
                               HalKey,
                               NULL);
    Status = ZwCreateKey(&DescriptionKey,
                         KEY_ALL_ACCESS,
                         &ObjectAttributes,
                         0,
                         NULL,
                         REG_OPTION_VOLATILE,
                         &Disposition);
    ZwClose(HalKey);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Add '.Raw' value */
    RtlInitUnicodeString(&Name, L".Raw");
    Status = ZwSetValueKey(DescriptionKey,
                           &Name,
                           0,
                           REG_RESOURCE_LIST,
                           RawResourceList,
                           ResourceListSize);
    if (!NT_SUCCESS(Status))
    {
        ZwClose(DescriptionKey);
        return Status;
    }
 
    /* Add '.Translated' value */
    RtlInitUnicodeString(&Name, L".Translated");
    Status = ZwSetValueKey(DescriptionKey,
                           &Name,
                           0,
                           REG_RESOURCE_LIST,
                           TranslatedResourceList,
                           ResourceListSize);
    ZwClose(DescriptionKey);
 
    return Status;
}
 
/* EOF */