arbmem.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Kernel
 * LICENSE:     MIT (https://spdx.org/licenses/MIT)
 * PURPOSE:     PnP manager Root Memory Arbiter
 * COPYRIGHT:   Copyright 2025-2026 Justin Miller <justin.miller@reactos.org>
 */
 
/* INCLUDES *****************************************************************/
 
#include <ntoskrnl.h>
#define NDEBUG
#include <debug.h>
 
/* GLOBALS *******************************************************************/
 
extern ARBITER_INSTANCE IopRootMemArbiter;
 
ULONGLONG
NTAPI
RtlIoDecodeMemIoResource(
    _In_ PIO_RESOURCE_DESCRIPTOR Descriptor,
    _Out_opt_ PULONGLONG Alignment,
    _Out_opt_ PULONGLONG MinimumAddress,
    _Out_opt_ PULONGLONG MaximumAddress);
 
ULONGLONG
NTAPI
RtlCmDecodeMemIoResource(
    _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
    _Out_opt_ PULONGLONG Start);
 
/* The last address a card that only wires up 24 address lines can reach. */
#define MEMORY_24_BIT_MAX_ADDRESS   0xFFFFFF
 
/* FUNCTIONS *****************************************************************/
 
static
NTSTATUS
IopArbMemTranslateAddress(
    _In_ UCHAR SourceType,
    _In_ PHYSICAL_ADDRESS SourceAddress,
    _Out_ PPHYSICAL_ADDRESS TranslatedAddress,
    _Out_ PUCHAR TranslatedType)
{
    ULONG AddressSpace;
 
    PAGED_CODE();
 
    if (SourceType == CmResourceTypeMemory || SourceType == CmResourceTypeMemoryLarge)
        AddressSpace = 0; /* System memory */
    else if (SourceType == CmResourceTypePort)
        AddressSpace = 1; /* I/O port space */
    else
        return STATUS_INVALID_PARAMETER;
 
    if (!HalTranslateBusAddress(Isa, 0, SourceAddress, &AddressSpace, TranslatedAddress))
        return STATUS_UNSUCCESSFUL;
 
    /* The HAL reports back the space it landed in; only these two are expected. */
    if (AddressSpace == 1)
    {
        *TranslatedType = CmResourceTypePort;
    }
    else if (AddressSpace == 0)
    {
        *TranslatedType = (SourceType == CmResourceTypeMemoryLarge)
                          ? CmResourceTypeMemoryLarge
                          : CmResourceTypeMemory;
    }
    else
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    return STATUS_SUCCESS;
}
 
static
NTSTATUS
NTAPI
IopArbMemUnpackRequirements(
    _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor,
    _Out_ PUINT64 OutMinimumAddress,
    _Out_ PUINT64 OutMaximumAddress,
    _Out_ PUINT64 OutLength,
    _Out_ PUINT64 OutAlignment)
{
    PAGED_CODE();
 
    *OutLength = RtlIoDecodeMemIoResource(IoDescriptor,
                                          OutAlignment,
                                          OutMinimumAddress,
                                          OutMaximumAddress);
 
    if (*OutAlignment == 0)
        *OutAlignment = 1;
 
    if (IoDescriptor->Type == CmResourceTypeMemory &&
        (IoDescriptor->Flags & CM_RESOURCE_MEMORY_24) &&
        *OutMaximumAddress > MEMORY_24_BIT_MAX_ADDRESS)
    {
        *OutMaximumAddress = MEMORY_24_BIT_MAX_ADDRESS;
    }
 
    return STATUS_SUCCESS;
}
 
static
NTSTATUS
NTAPI
IopArbMemPackResource(
    _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor,
    _In_ UINT64 Start,
    _Out_ PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor)
{
    PAGED_CODE();
 
    CmDescriptor->Type = IoDescriptor->Type;
    CmDescriptor->Flags = IoDescriptor->Flags;
    CmDescriptor->ShareDisposition = IoDescriptor->ShareDisposition;
 
    CmDescriptor->u.Generic.Start.QuadPart = Start;
    CmDescriptor->u.Generic.Length = IoDescriptor->u.Generic.Length;
 
    return STATUS_SUCCESS;
}
 
static
NTSTATUS
NTAPI
IopArbMemUnpackResource(
    _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor,
    _Out_ PUINT64 Start,
    _Out_ PUINT64 OutLength)
{
    PAGED_CODE();
 
    *OutLength = RtlCmDecodeMemIoResource(CmDescriptor, Start);
 
    return STATUS_SUCCESS;
}
 
static
INT32
NTAPI
IopArbMemScoreRequirement(
    _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor)
{
    UINT64 Length, Alignment;
    UINT64 Minimum, Maximum, AlignedMinimum;
    UINT64 Span, Placements;
 
    PAGED_CODE();
 
    Length = RtlIoDecodeMemIoResource(IoDescriptor, &Alignment, &Minimum, &Maximum);
 
    if (Alignment == 0)
        Alignment = 1;
 
    /* Round the window's base up to the first address the device can sit at. */
    AlignedMinimum = (Minimum + Alignment - 1) & ~(Alignment - 1);
    if (AlignedMinimum < Minimum || AlignedMinimum > Maximum)
        return -1;
 
    /* Count in addresses above the base, so a full-width window cannot overflow. */
    Span = Maximum - AlignedMinimum;
 
    if (Length != 0)
    {
        if (Length - 1 > Span)
            return -1;
 
        Span -= Length - 1;
    }
 
    Placements = Span / Alignment + 1;
    return (INT32)min(Placements, MAXLONG);
}
 
static
NTSTATUS
NTAPI
IopArbMemTranslateOrdering(
    _Out_ PIO_RESOURCE_DESCRIPTOR OutIoDescriptor,
    _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor)
{
    UCHAR SourceType;
    UCHAR MinimumType;
    UCHAR MaximumType;
 
    PAGED_CODE();
 
    *OutIoDescriptor = *IoDescriptor;
 
    SourceType = IoDescriptor->Type;
    if (SourceType != CmResourceTypePort &&
        SourceType != CmResourceTypeMemory &&
        SourceType != CmResourceTypeMemoryLarge)
    {
        return STATUS_SUCCESS;
    }
 
    MinimumType = SourceType;
    MaximumType = SourceType;
 
    if (!NT_SUCCESS(IopArbMemTranslateAddress(SourceType,
                                              IoDescriptor->u.Generic.MinimumAddress,
                                              &OutIoDescriptor->u.Generic.MinimumAddress,
                                              &MinimumType)) ||
        !NT_SUCCESS(IopArbMemTranslateAddress(SourceType,
                                              IoDescriptor->u.Generic.MaximumAddress,
                                              &OutIoDescriptor->u.Generic.MaximumAddress,
                                              &MaximumType)))
    {
        OutIoDescriptor->Type = CmResourceTypeNull;
    }
    else
    {
        OutIoDescriptor->Type = MaximumType;
    }
 
    return STATUS_SUCCESS;
}
 
static
BOOLEAN
NTAPI
IopArbMemFindSuitableRange(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_ALLOCATION_STATE ArbState)
{
    PAGED_CODE();
 
    if (ArbState->Entry != NULL && (ArbState->Entry->Flags & ARBITER_FLAG_BOOT_CONFIG))
        ArbState->RangeAvailableAttributes |= ARBITER_RANGE_BOOT_ALLOCATED;
 
    return ArbiterLibFindSuitableRange(Arbiter, ArbState);
}
 
NTSTATUS
NTAPI
IopArbMemInitialize(VOID)
{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    IopRootMemArbiter.Name = L"RootMemory";
    IopRootMemArbiter.UnpackRequirement = IopArbMemUnpackRequirements;
    IopRootMemArbiter.PackResource = IopArbMemPackResource;
    IopRootMemArbiter.UnpackResource = IopArbMemUnpackResource;
    IopRootMemArbiter.ScoreRequirement = IopArbMemScoreRequirement;
    IopRootMemArbiter.FindSuitableRange = IopArbMemFindSuitableRange;
 
    Status = ArbiterLibInitializeInstance(&IopRootMemArbiter,
                                          NULL,
                                          CmResourceTypeMemory,
                                          IopRootMemArbiter.Name,
                                          L"Root",
                                          IopArbMemTranslateOrdering);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbMemInitialize: Failed with %X\n", Status);
        return Status;
    }
 
    Status = RtlAddRange(IopRootMemArbiter.Allocation, 0ULL, 0xFFFULL, 0, 0, NULL, NULL);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("IopArbMemInitialize: Reserving page 0 failed with %X\n", Status);
    }
 
    return Status;
}