handler.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Arbitration Library
 * LICENSE:     MIT (https://spdx.org/licenses/MIT)
 * PURPOSE:     Action dispatch and arbiter startup
 * COPYRIGHT:   Copyright 2026 Justin Miller <justin.miller@reactos.org>
 */
 
/* INCLUDES *******************************************************************/
 
#include <ntifs.h>
#include <ndk/rtlfuncs.h>
#include "arbiter.h"
 
#define NDEBUG
#include <debug.h>
 
/* DISPATCH *******************************************************************/
 
CODE_SEG("PAGE")
static
VOID
ArbpAcquireLock(
    _In_ PARBITER_INSTANCE Arbiter)
{
    PAGED_CODE();
    KeWaitForSingleObject(Arbiter->MutexEvent, Executive, KernelMode, FALSE, NULL);
}
 
CODE_SEG("PAGE")
static
VOID
ArbpReleaseLock(
    _In_ PARBITER_INSTANCE Arbiter)
{
    PAGED_CODE();
    KeSetEvent(Arbiter->MutexEvent, IO_NO_INCREMENT, FALSE);
}
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
#if (NTDDI_VERSION >= NTDDI_VISTA)
ArbiterLibQueryArbitrate(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_QUERY_ARBITRATE_PARAMETERS Parameters)
{
    PAGED_CODE();
    UNREFERENCED_PARAMETER(Arbiter);
    UNREFERENCED_PARAMETER(Parameters);
    return STATUS_SUCCESS;
}
#else
ArbiterLibQueryArbitrate(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PLIST_ENTRY ArbitrationList)
{
    PAGED_CODE();
    UNREFERENCED_PARAMETER(Arbiter);
    UNREFERENCED_PARAMETER(ArbitrationList);
    return STATUS_SUCCESS;
}
#endif
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
#if (NTDDI_VERSION >= NTDDI_VISTA)
ArbiterLibAddReserved(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_ADD_RESERVED_PARAMETERS Parameters)
{
    PAGED_CODE();
    UNREFERENCED_PARAMETER(Arbiter);
    UNREFERENCED_PARAMETER(Parameters);
    return STATUS_SUCCESS;
}
#else
ArbiterLibAddReserved(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_opt_ PIO_RESOURCE_DESCRIPTOR Requirement,
    _In_opt_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Resource)
{
    PAGED_CODE();
    UNREFERENCED_PARAMETER(Arbiter);
    UNREFERENCED_PARAMETER(Requirement);
    UNREFERENCED_PARAMETER(Resource);
    return STATUS_SUCCESS;
}
#endif
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
ArbiterLibHandler(
    _In_ PVOID Context,
    _In_ ARBITER_ACTION Action,
    _Inout_ PARBITER_PARAMETERS Parameters)
{
    PARBITER_INSTANCE Arbiter = (PARBITER_INSTANCE)Context;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    ArbpAcquireLock(Arbiter);
 
    switch (Action)
    {
        case ArbiterActionTestAllocation:
#if (NTDDI_VERSION >= NTDDI_VISTA)
            Status = Arbiter->TestAllocation(Arbiter, &Parameters->Parameters.TestAllocation);
#else
            Status = Arbiter->TestAllocation(
                Arbiter,
                Parameters->Parameters.TestAllocation.ArbitrationList);
#endif
            break;
 
        case ArbiterActionRetestAllocation:
#if (NTDDI_VERSION >= NTDDI_VISTA)
            Status = Arbiter->RetestAllocation(Arbiter, &Parameters->Parameters.RetestAllocation);
#else
            Status = Arbiter->RetestAllocation(
                Arbiter,
                Parameters->Parameters.RetestAllocation.ArbitrationList);
#endif
            break;
 
        case ArbiterActionCommitAllocation:
            Status = Arbiter->CommitAllocation(Arbiter);
            break;
 
        case ArbiterActionRollbackAllocation:
            Status = Arbiter->RollbackAllocation(Arbiter);
            break;
 
        case ArbiterActionBootAllocation:
#if (NTDDI_VERSION >= NTDDI_VISTA)
            Status = Arbiter->BootAllocation(Arbiter, &Parameters->Parameters.BootAllocation);
#else
            Status = Arbiter->BootAllocation(
                Arbiter,
                Parameters->Parameters.BootAllocation.ArbitrationList);
#endif
            break;
 
        case ArbiterActionQueryConflict:
#if (NTDDI_VERSION >= NTDDI_VISTA)
            Status = Arbiter->QueryConflict(Arbiter, &Parameters->Parameters.QueryConflict);
#else
            Status = Arbiter->QueryConflict(
                Arbiter,
                Parameters->Parameters.QueryConflict.PhysicalDeviceObject,
                Parameters->Parameters.QueryConflict.ConflictingResource,
                Parameters->Parameters.QueryConflict.ConflictCount,
                Parameters->Parameters.QueryConflict.Conflicts);
#endif
            break;
 
        case ArbiterActionQueryArbitrate:
#if (NTDDI_VERSION >= NTDDI_VISTA)
            Status = Arbiter->QueryArbitrate(Arbiter, &Parameters->Parameters.QueryArbitrate);
#else
            Status = Arbiter->QueryArbitrate(
                Arbiter,
                Parameters->Parameters.QueryArbitrate.ArbitrationList);
#endif
            break;
 
        /*
         * Actions the interface defines but this arbiter does not carry
         * out. AddReserved is one: the instance slot exists and is
         * defaulted, but nothing routes to it.
         */
        case ArbiterActionQueryAllocatedResources:
        case ArbiterActionWriteReservedResources:
        case ArbiterActionAddReserved:
            Status = STATUS_NOT_IMPLEMENTED;
            break;
 
        default:
            Status = STATUS_INVALID_PARAMETER;
            break;
    }
 
#if (NTDDI_VERSION >= NTDDI_VISTA)
    /* Track the tested-but-not-yet-committed window for transaction waiters. */
    if (NT_SUCCESS(Status))
    {
        if (Action == ArbiterActionTestAllocation ||
            Action == ArbiterActionRetestAllocation)
        {
            Arbiter->TransactionInProgress = TRUE;
            KeClearEvent(Arbiter->TransactionEvent);
        }
        else if (Action == ArbiterActionCommitAllocation ||
                 Action == ArbiterActionRollbackAllocation)
        {
            Arbiter->TransactionInProgress = FALSE;
            KeSetEvent(Arbiter->TransactionEvent, IO_NO_INCREMENT, FALSE);
        }
    }
#endif
 
    ArbpReleaseLock(Arbiter);
    return Status;
}
 
/* STARTUP ********************************************************************/
 
typedef struct _ARBITER_SEED_WINDOW
{
    ULONGLONG Start;
    ULONGLONG End;
} ARBITER_SEED_WINDOW, *PARBITER_SEED_WINDOW;
 
CODE_SEG("PAGE")
static
NTSTATUS
ArbpSeedRangeList(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ ULONG ResourceCount,
    _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Resources,
    _Inout_ PRTL_RANGE_LIST RangeList)
{
    PARBITER_SEED_WINDOW Windows;
    ULONG WindowCount = 0;
    ULONGLONG Next;
    ULONG Index;
 
    PAGED_CODE();
 
    RtlFreeRangeList(RangeList);
    RtlInitializeRangeList(RangeList);
 
    if ((Arbiter->UnpackResource == NULL) || (ResourceCount == 0))
        return STATUS_SUCCESS;
 
    Windows = ExAllocatePoolWithTag(PagedPool,
                                    ResourceCount * sizeof(ARBITER_SEED_WINDOW),
                                    TAG_ARBITER);
    if (Windows == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Collect the windows of our own resource type, lowest first */
    for (Index = 0; Index < ResourceCount; ++Index)
    {
        ULONGLONG Start, Length;
        ULONG Insert;
 
        if (Resources[Index].Type != (UCHAR)Arbiter->ResourceType)
            continue;
 
        Arbiter->UnpackResource(&Resources[Index], &Start, &Length);
        if (Length == 0)
            continue;
 
        for (Insert = WindowCount; Insert > 0; --Insert)
        {
            if (Windows[Insert - 1].Start <= Start)
                break;
 
            Windows[Insert] = Windows[Insert - 1];
        }
 
        Windows[Insert].Start = Start;
        Windows[Insert].End = Start + Length - 1;
        WindowCount++;
    }
 
    /*
     * A bus that reports no window of this kind is not saying it decodes
     * nothing; it is saying it has nothing to add. Leaving the list empty
     * leaves every address available, which is how the root arbiters run.
     */
    if (WindowCount == 0)
    {
        ExFreePoolWithTag(Windows, TAG_ARBITER);
        return STATUS_SUCCESS;
    }
 
    /*
     * What goes in the list is what the arbiter may NOT hand out, so the
     * windows themselves are the gaps in it. Recording the windows instead
     * would wall off exactly the addresses the bus exists to give away.
     */
    Next = 0;
 
    for (Index = 0; Index < WindowCount; ++Index)
    {
        if (Windows[Index].Start > Next)
        {
            RtlAddRange(RangeList, Next, Windows[Index].Start - 1, 0,
                        RTL_RANGE_LIST_ADD_IF_CONFLICT, NULL, NULL);
        }
 
        /* Overlapping windows merge, so only ever move the mark forward */
        if (Windows[Index].End >= Next)
            Next = Windows[Index].End + 1;
 
        /* A window running to the top of the space leaves no tail to block */
        if (Windows[Index].End == ARBITER_MAXIMUM_ADDRESS)
        {
            ExFreePoolWithTag(Windows, TAG_ARBITER);
            return STATUS_SUCCESS;
        }
    }
 
    RtlAddRange(RangeList, Next, ARBITER_MAXIMUM_ADDRESS, 0,
                RTL_RANGE_LIST_ADD_IF_CONFLICT, NULL, NULL);
 
    ExFreePoolWithTag(Windows, TAG_ARBITER);
 
    return STATUS_SUCCESS;
}
 
#if (NTDDI_VERSION >= NTDDI_VISTA)
CODE_SEG("PAGE")
NTSTATUS
NTAPI
ArbiterLibInitializeRangeList(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ ULONG ResourceCount,
    _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Resources,
    _Inout_ PRTL_RANGE_LIST RangeList)
{
    PAGED_CODE();
    return ArbpSeedRangeList(Arbiter, ResourceCount, Resources, RangeList);
}
#endif
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
ArbiterLibStartArbiter(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PCM_RESOURCE_LIST StartResources)
{
    PCM_FULL_RESOURCE_DESCRIPTOR Full;
 
    PAGED_CODE();
 
    if (StartResources == NULL || StartResources->Count == 0)
        return STATUS_SUCCESS;
 
    Full = &StartResources->List[0];
 
#if (NTDDI_VERSION >= NTDDI_VISTA)
    /* Vista+ routes through the slot, so an arbiter may override the seeding. */
    return Arbiter->InitializeRangeList(Arbiter,
                                        Full->PartialResourceList.Count,
                                        Full->PartialResourceList.PartialDescriptors,
                                        Arbiter->Allocation);
#else
    return ArbpSeedRangeList(Arbiter,
                             Full->PartialResourceList.Count,
                             Full->PartialResourceList.PartialDescriptors,
                             Arbiter->Allocation);
#endif
}
 
/* EXTERNAL RESERVATIONS ******************************************************/
 
CODE_SEG("PAGE")
VOID
NTAPI
ArbiterLibReserveRange(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ ULONGLONG Start,
    _In_ ULONGLONG End,
    _In_opt_ PVOID Owner,
    _In_ BOOLEAN Shared)
{
    PAGED_CODE();
 
    ArbpAcquireLock(Arbiter);
    RtlAddRange(Arbiter->Allocation, Start, End, 0,
                RTL_RANGE_LIST_ADD_IF_CONFLICT | (Shared ? RTL_RANGE_LIST_ADD_SHARED : 0),
                NULL, Owner);
    ArbpReleaseLock(Arbiter);
}
 
CODE_SEG("PAGE")
VOID
NTAPI
ArbiterLibReleaseResources(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PVOID Owner)
{
    PAGED_CODE();
 
    ArbpAcquireLock(Arbiter);
    RtlDeleteOwnersRanges(Arbiter->Allocation, Owner);
    ArbpReleaseLock(Arbiter);
}