iorsrce.c File Reference

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

Include dependency graph for iorsrce.c:

Go to the source code of this file.

Classes
struct	_IO_QUERY

Macros
#define	NDEBUG
#define	IORSRCTRACE(...)   do { if(0) { DbgPrint(__VA_ARGS__); } } while(0)

Typedefs
typedef struct _IO_QUERY	IO_QUERY
typedef struct _IO_QUERY *	PIO_QUERY

Functions
static NTSTATUS	IopQueryDeviceDescription (_In_ PIO_QUERY Query, _In_ UNICODE_STRING RootKey, _In_ HANDLE RootKeyHandle, _In_ ULONG Bus, _In_ PKEY_VALUE_FULL_INFORMATION *BusInformation)
	Reads and returns Hardware information from the appropriate hardware registry key. Helper stub of IopQueryBusDescription().
static NTSTATUS	IopQueryBusDescription (_In_ PIO_QUERY Query, _In_ UNICODE_STRING RootKey, _In_ HANDLE RootKeyHandle, _Inout_ PULONG Bus, _In_ BOOLEAN KeyIsRoot)
	Reads and returns Hardware information from the appropriate hardware registry key. Helper stub of IoQueryDeviceDescription(). Has two modes of operation, either looking for root bus types or for sub-bus information.
NTSTATUS	IopFetchConfigurationInformation (_Out_ PWSTR *SymbolicLinkList, _In_ GUID Guid, _In_ ULONG ExpectedInterfaces, _Out_ PULONG Interfaces)
VOID	IopStoreSystemPartitionInformation (_In_ PUNICODE_STRING NtSystemPartitionDeviceName, _In_ PUNICODE_STRING OsLoaderPathName)
PCONFIGURATION_INFORMATION NTAPI	IoGetConfigurationInformation (VOID)
	Returns a pointer to the I/O manager's global configuration information structure.
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)
	Reports hardware resources in the \Registry\Machine\Hardware\ResourceMap tree, so that a subsequently loaded driver cannot attempt to use the same resources.
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 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)
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)
	Reads and returns Hardware information from the appropriate hardware registry key.
NTSTATUS NTAPI	IoReportHalResourceUsage (_In_ PUNICODE_STRING HalName, _In_ PCM_RESOURCE_LIST RawResourceList, _In_ PCM_RESOURCE_LIST TranslatedResourceList, _In_ ULONG ResourceListSize)
	Reports hardware resources of the HAL in the \Registry\Machine\Hardware\ResourceMap tree.

Variables
static CONFIGURATION_INFORMATION	_SystemConfigurationInformation = { 0, 0, 0, 0, 0, 0, 0, FALSE, FALSE, 0, 0 }
PCWSTR	ArcTypes [MaximumType+1]
PCWSTR	IoDeviceInfoNames [IoQueryDeviceMaxData]

Macro Definition Documentation

IORSRCTRACE

#define IORSRCTRACE

(

...

)

do { if(0) { DbgPrint(__VA_ARGS__); } } while(0)

Definition at line 24 of file iorsrce.c.

NDEBUG

#define NDEBUG

Definition at line 15 of file iorsrce.c.

Typedef Documentation

IO_QUERY

typedef struct _IO_QUERY IO_QUERY

PIO_QUERY

typedef struct _IO_QUERY * PIO_QUERY

Function Documentation

IoAssignResources()

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
	)

Definition at line 1134 of file iorsrce.c.

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

Referenced by PciAssignSlotResources(), and VideoPortGetAccessRanges().

IoGetConfigurationInformation()

PCONFIGURATION_INFORMATION NTAPI IoGetConfigurationInformation

(

VOID

)

Returns a pointer to the I/O manager's global configuration information structure.

This structure contains the current values for how many physical storage media, SCSI HBA, serial, and parallel devices have device objects created to represent them by drivers as they are loaded.

Definition at line 998 of file iorsrce.c.

{
    return &_SystemConfigurationInformation;
}

Referenced by AddControllers(), AddDeviceInternal(), DeviceEvtSelfManagedIoCleanup(), DeviceEvtSelfManagedIoInit(), DiskAddDevice(), DiskRemoveDevice(), DriverEntry(), FdoRemoveAdapter(), FdoStartAdapter(), InitializeConfiguration(), IoGetBootDiskInformation(), IopCreateArcNamesCd(), IopCreateArcNamesDisk(), QSI_DEF(), ScsiFlopAddDevice(), ScsiFlopRemoveDevice(), ScsiPortInitialize(), SerialAddDeviceInternal(), SpiConfigToResource(), SpiCreatePortConfig(), UniataFindBusMasterController(), VfdCreateDevice(), VfdDeleteDevice(), and xHalIoAssignDriveLetters().

IopFetchConfigurationInformation()

NTSTATUS IopFetchConfigurationInformation	(	_Out_ PWSTR *	SymbolicLinkList,
		_In_ GUID	Guid,
		_In_ ULONG	ExpectedInterfaces,
		_Out_ PULONG	Interfaces
	)

Definition at line 821 of file iorsrce.c.

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

Referenced by IopCreateArcNamesCd(), and IopCreateArcNamesDisk().

IopLegacyResourceAllocation()

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  )

static

Definition at line 1093 of file iorsrce.c.

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

Referenced by IoAssignResources().

IopQueryBusDescription()

static NTSTATUS IopQueryBusDescription ( _In_ PIO_QUERY  Query, _In_ UNICODE_STRING  RootKey, _In_ HANDLE  RootKeyHandle, _Inout_ PULONG  Bus, _In_ BOOLEAN  KeyIsRoot  )

static

Reads and returns Hardware information from the appropriate hardware registry key. Helper stub of IoQueryDeviceDescription(). Has two modes of operation, either looking for root bus types or for sub-bus information.

Parameters

[in]	Query	What the parent function wants.
[in]	RootKey	Which key to look in.
[in]	RootKeyHandle	Handle to the key.
[in,out]	Bus	Pointer to the current bus number.
[in]	KeyIsRoot	Whether we are looking for root bus types or information under them.

Returns

A status code.

Definition at line 566 of file iorsrce.c.

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

Referenced by IopQueryBusDescription(), and IoQueryDeviceDescription().

IopQueryDeviceDescription()

static NTSTATUS IopQueryDeviceDescription ( _In_ PIO_QUERY  Query, _In_ UNICODE_STRING  RootKey, _In_ HANDLE  RootKeyHandle, _In_ ULONG  Bus, _In_ PKEY_VALUE_FULL_INFORMATION *  BusInformation  )

static

Reads and returns Hardware information from the appropriate hardware registry key. Helper stub of IopQueryBusDescription().

Parameters

[in]	Query	What the parent function wants.
[in]	RootKey	Which key to look in.
[in]	RootKeyHandle	Handle to the key.
[in]	Bus	The bus number.
[in]	BusInformation	The configuration information being sent.

Returns

A status code.

Definition at line 126 of file iorsrce.c.

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

Referenced by IopQueryBusDescription().

IopStoreSystemPartitionInformation()

VOID IopStoreSystemPartitionInformation	(	_In_ PUNICODE_STRING	NtSystemPartitionDeviceName,
		_In_ PUNICODE_STRING	OsLoaderPathName
	)

Definition at line 860 of file iorsrce.c.

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

Referenced by IopCreateArcNames(), and IopCreateArcNamesDisk().

IoQueryDeviceDescription()

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
	)

Reads and returns Hardware information from the appropriate hardware registry key.

Parameters

[in]	BusType	Specifies the bus type, for example: MCA, ISA, EISA, etc.
[in]	BusNumber	The number of the specified bus type to query.
[in]	ControllerType	Specifies the controller type
[in]	ControllerNumber	The number of the specified controller type to query.
[in]	CalloutRoutine	A user-provided callback function to call for each valid query.
[in]	Context	A callback-specific context value.

Returns

A status code.

Definition at line 1213 of file iorsrce.c.

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

Referenced by AddControllers(), FdcFdoQueryBusRelations(), IntVideoPortEnumBuses(), and SpiCreatePortConfig().

IoReportHalResourceUsage()

NTSTATUS NTAPI IoReportHalResourceUsage	(	_In_ PUNICODE_STRING	HalName,
		_In_ PCM_RESOURCE_LIST	RawResourceList,
		_In_ PCM_RESOURCE_LIST	TranslatedResourceList,
		_In_ ULONG	ResourceListSize
	)

Reports hardware resources of the HAL in the \Registry\Machine\Hardware\ResourceMap tree.

Parameters

[in]	HalName	Descriptive name of the HAL.
[in]	RawResourceList	List of raw (bus specific) resources which should be claimed for the HAL.
[in]	TranslatedResourceList	List of translated (system wide) resources which should be claimed for the HAL.
[in]	ResourceListSize	Size in bytes of the raw and translated resource lists. Both lists have the same size.

Returns

A status code.

Definition at line 1321 of file iorsrce.c.

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

Referenced by HalpReportResourceUsage().

IoReportResourceUsage()

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
	)

Reports hardware resources in the \Registry\Machine\Hardware\ResourceMap tree, so that a subsequently loaded driver cannot attempt to use the same resources.

@halfplemented

Parameters

[in]	DriverClassName	The driver class under which the resource information should be stored.
[in]	DriverObject	The driver object that was provided to the DriverEntry routine.
[in]	DriverList	Resources claimed for the all the driver's devices, rather than per-device.
[in]	DriverListSize	Size in bytes of the DriverList.
[in]	DeviceObject	The device object for which resources should be claimed.
[in]	DeviceList	List of resources that should be claimed for the device.
[in]	DeviceListSize	Size of the per-device resource list in bytes.
[in]	OverrideConflict	TRUE if the resources should be claimed even if a conflict is found.
[out]	ConflictDetected	Points to a variable that receives TRUE if a conflict is detected with another driver.

Definition at line 1041 of file iorsrce.c.

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

Variable Documentation

_SystemConfigurationInformation

CONFIGURATION_INFORMATION _SystemConfigurationInformation = { 0, 0, 0, 0, 0, 0, 0, FALSE, FALSE, 0, 0 }

static

Definition at line 31 of file iorsrce.c.

Referenced by IoGetConfigurationInformation().

ArcTypes

PCWSTR ArcTypes[MaximumType+1]

Definition at line 47 of file iorsrce.c.

Referenced by IopQueryDeviceDescription().

IoDeviceInfoNames

PCWSTR IoDeviceInfoNames[IoQueryDeviceMaxData]

Initial value:

=
{
    L"Identifier",
    L"Configuration Data",
    L"Component Information"
}

Definition at line 94 of file iorsrce.c.

Referenced by IopQueryBusDescription(), and IopQueryDeviceDescription().