transaction.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Arbitrartion Library
 * LICENSE:     MIT (https://spdx.org/licenses/MIT)
 * PURPOSE:     Test/retest/commit/rollback transaction support
 * 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>
 
/* TRANSACTION SUPPORT ********************************************************/
 
CODE_SEG("PAGE")
static
NTSTATUS
ArbpBuildAlternative(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PIO_RESOURCE_DESCRIPTOR Descriptor,
    _Out_ PARBITER_ALTERNATIVE Alternative)
{
    UINT64 Length, Alignment;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    /*
     * UnpackRequirement always writes 64-bit Length/Alignment; ARBITER_ALTERNATIVE
     * narrows them to 32 bits pre-Vista, so decode through 64-bit temporaries and
     * assign, just to keep both versions in source.
     */
    Alternative->Descriptor = Descriptor;
    Status = Arbiter->UnpackRequirement(Descriptor,
                                        &Alternative->Minimum,
                                        &Alternative->Maximum,
                                        &Length,
                                        &Alignment);
    if (!NT_SUCCESS(Status))
        return Status;
 
#if (NTDDI_VERSION >= NTDDI_VISTA) || defined(__REACTOS__)
    Alternative->Length = Length;
    Alternative->Alignment = Alignment;
#else
    Alternative->Length = (UINT32)Length;
    Alternative->Alignment = (UINT32)Alignment;
#endif
 
    if (Alignment != 0 && (Alternative->Minimum % Alignment) != 0)
        Alternative->Minimum += Alignment - (Alternative->Minimum % Alignment);
 
    Alternative->Flags = 0;
    Alternative->Priority = ARBITER_PRIORITY_NULL;
 
    if (Descriptor->ShareDisposition == CmResourceShareShared)
        Alternative->Flags |= ARBITER_ALTERNATIVE_FLAG_SHARED;
 
    if (Alternative->Maximum < Alternative->Minimum)
        Alternative->Flags |= ARBITER_ALTERNATIVE_FLAG_BADRANGE;
    else if ((Alternative->Maximum - Alternative->Minimum + 1) == Alternative->Length)
        Alternative->Flags |= ARBITER_ALTERNATIVE_FLAG_FIXED;
 
    if ((Descriptor->Type == CmResourceTypeMemory ||
         Descriptor->Type == CmResourceTypeMemoryLarge) &&
        (Descriptor->Flags & CM_RESOURCE_MEMORY_COMPAT_FOR_INACCESSIBLE_RANGE))
    {
        Alternative->Flags |= ARBITER_ALTERNATIVE_FLAG_INACCESSIBLE_OK;
    }
 
    return STATUS_SUCCESS;
}
 
CODE_SEG("PAGE")
static
NTSTATUS
ArbpBuildAllocationStack(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PLIST_ENTRY ArbitrationList,
    _In_ ULONG EntryCount)
{
    PARBITER_ALLOCATION_STATE State;
    PARBITER_ALTERNATIVE Alternative;
    PLIST_ENTRY ListEntry;
    ULONG StateCount = EntryCount + 1;  /* + NULL terminator */
    ULONG AlternativeCount = 0;
    ULONG Size;
 
    PAGED_CODE();
 
    for (ListEntry = ArbitrationList->Flink;
         ListEntry != ArbitrationList;
         ListEntry = ListEntry->Flink)
    {
        PARBITER_LIST_ENTRY Entry = CONTAINING_RECORD(ListEntry, ARBITER_LIST_ENTRY, ListEntry);
 
        if (Entry->AlternativeCount == 0)
            StateCount--;  /* an empty entry contributes no state */
        else
            AlternativeCount += Entry->AlternativeCount;
    }
 
    Size = StateCount * sizeof(ARBITER_ALLOCATION_STATE) +
           AlternativeCount * sizeof(ARBITER_ALTERNATIVE);
 
    if (Arbiter->AllocationStackMaxSize < Size)
    {
        PARBITER_ALLOCATION_STATE NewStack;
 
        NewStack = ExAllocatePoolWithTag(PagedPool, Size, TAG_ARBITER);
        if (NewStack == NULL)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        if (Arbiter->AllocationStack != NULL)
            ExFreePoolWithTag(Arbiter->AllocationStack, TAG_ARBITER);
 
        Arbiter->AllocationStack = NewStack;
        Arbiter->AllocationStackMaxSize = Size;
    }
    RtlZeroMemory(Arbiter->AllocationStack, Size);
 
    State = Arbiter->AllocationStack;
    Alternative = (PARBITER_ALTERNATIVE)&Arbiter->AllocationStack[StateCount];
 
    for (ListEntry = ArbitrationList->Flink;
         ListEntry != ArbitrationList;
         ListEntry = ListEntry->Flink)
    {
        PARBITER_LIST_ENTRY Entry = CONTAINING_RECORD(ListEntry, ARBITER_LIST_ENTRY, ListEntry);
        ULONG Index;
 
        if (Entry->AlternativeCount == 0)
            continue;
 
        State->Entry = Entry;
        State->AlternativeCount = Entry->AlternativeCount;
        State->Alternatives = Alternative;
        State->Start = 1;  /* Start(1) > End(0): nothing chosen yet */
 
        for (Index = 0; Index < Entry->AlternativeCount; ++Index)
        {
            NTSTATUS Status = ArbpBuildAlternative(Arbiter, &Entry->Alternatives[Index], Alternative);
            if (!NT_SUCCESS(Status))
                return Status;
            Alternative++;
        }
        State++;
    }
 
    return STATUS_SUCCESS;
}
 
CODE_SEG("PAGE")
static
NTSTATUS
ArbpTestAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PLIST_ENTRY ArbitrationList)
{
    PLIST_ENTRY ListEntry;
    PVOID PreviousOwner = NULL;
    ULONG EntryCount = 0;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    /* Start the tentative allocation as a copy of the committed one. */
    RtlFreeRangeList(Arbiter->PossibleAllocation);
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
    Status = RtlCopyRangeList(Arbiter->PossibleAllocation, Arbiter->Allocation);
    if (!NT_SUCCESS(Status))
        goto Failure;
 
    for (ListEntry = ArbitrationList->Flink;
         ListEntry != ArbitrationList;
         ListEntry = ListEntry->Flink)
    {
        PARBITER_LIST_ENTRY Entry = CONTAINING_RECORD(ListEntry, ARBITER_LIST_ENTRY, ListEntry);
        ULONG Index;
 
        EntryCount++;
 
        /*
         * Everything a device on the arbitration list already owns is up for
         * reassignment - remove it from the working list so the device does not
         * conflict with itself (its boot config in particular).
         */
        if (Entry->PhysicalDeviceObject != PreviousOwner)
        {
            PreviousOwner = Entry->PhysicalDeviceObject;
            RtlDeleteOwnersRanges(Arbiter->PossibleAllocation, Entry->PhysicalDeviceObject);
        }
 
        /* Score each entry: the sum of its alternatives' constrainedness. */
        Entry->WorkSpace = 0;
        if (Arbiter->ScoreRequirement != NULL)
        {
            for (Index = 0; Index < Entry->AlternativeCount; ++Index)
            {
                INT32 Score = Arbiter->ScoreRequirement(&Entry->Alternatives[Index]);
                if (Score < 0)
                {
                    Status = STATUS_DEVICE_CONFIGURATION_ERROR;
                    goto Failure;
                }
                Entry->WorkSpace += Score;
            }
        }
    }
 
    ArbiterLibSortArbitrationList(ArbitrationList);
 
    Status = ArbpBuildAllocationStack(Arbiter, ArbitrationList, EntryCount);
    if (!NT_SUCCESS(Status))
        goto Failure;
 
    Status = Arbiter->AllocateEntry(Arbiter, Arbiter->AllocationStack);
    if (!NT_SUCCESS(Status))
        goto Failure;
 
    return STATUS_SUCCESS;
 
Failure:
    RtlFreeRangeList(Arbiter->PossibleAllocation);
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
    return Status;
}
 
CODE_SEG("PAGE")
static
NTSTATUS
ArbpRetestAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PLIST_ENTRY ArbitrationList)
{
    ARBITER_ALLOCATION_STATE State;
    ARBITER_ALTERNATIVE Alternative;
    PLIST_ENTRY ListEntry;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    RtlZeroMemory(&State, sizeof(State));
    RtlZeroMemory(&Alternative, sizeof(Alternative));
    State.Alternatives = &Alternative;
    State.CurrentAlternative = &Alternative;
    State.AlternativeCount = 1;
 
    /*
     * Rebuild the tentative allocation from the committed one
     * minus everything the listed devices already own.
     */
    RtlFreeRangeList(Arbiter->PossibleAllocation);
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
    Status = RtlCopyRangeList(Arbiter->PossibleAllocation, Arbiter->Allocation);
    if (!NT_SUCCESS(Status))
        goto Failure;
 
    for (ListEntry = ArbitrationList->Flink;
         ListEntry != ArbitrationList;
         ListEntry = ListEntry->Flink)
    {
        PARBITER_LIST_ENTRY Entry = CONTAINING_RECORD(ListEntry, ARBITER_LIST_ENTRY, ListEntry);
 
        Status = RtlDeleteOwnersRanges(Arbiter->PossibleAllocation,
                                       Entry->PhysicalDeviceObject);
        if (!NT_SUCCESS(Status))
            goto Failure;
    }
 
    for (ListEntry = ArbitrationList->Flink;
         ListEntry != ArbitrationList;
         ListEntry = ListEntry->Flink)
    {
        PARBITER_LIST_ENTRY Entry = CONTAINING_RECORD(ListEntry, ARBITER_LIST_ENTRY, ListEntry);
        UINT64 Length;
 
        if (Entry->Result == ArbiterResultNullRequest)
            continue;
 
        /* A retest without a preceding successful test is a caller bug. */
        if (Entry->SelectedAlternative == NULL || Entry->Assignment == NULL)
        {
            Status = STATUS_INVALID_PARAMETER;
            goto Failure;
        }
 
        Status = ArbpBuildAlternative(Arbiter, Entry->SelectedAlternative, &Alternative);
        if (!NT_SUCCESS(Status))
            goto Failure;
 
        State.Entry = Entry;
        State.WorkSpace = 0;
 
        Status = Arbiter->UnpackResource(Entry->Assignment, &State.Start, &Length);
        if (!NT_SUCCESS(Status))
            goto Failure;
        State.End = State.Start + Length - 1;
 
        Status = Arbiter->PreprocessEntry(Arbiter, &State);
        if (!NT_SUCCESS(Status))
            goto Failure;
 
        if (Length != 0)
            Arbiter->AddAllocation(Arbiter, &State);
 
        if (State.Flags & ARBITER_STATE_FLAG_WORKSPACE)
        {
            ExFreePoolWithTag((PVOID)State.WorkSpace, TAG_ARBITER);
            State.WorkSpace = 0;
            State.Flags &= ~ARBITER_STATE_FLAG_WORKSPACE;
        }
    }
 
    return STATUS_SUCCESS;
 
Failure:
    if (State.Flags & ARBITER_STATE_FLAG_WORKSPACE)
    {
        ExFreePoolWithTag((PVOID)State.WorkSpace, TAG_ARBITER);
        State.WorkSpace = 0;
        State.Flags &= ~ARBITER_STATE_FLAG_WORKSPACE;
    }
    RtlFreeRangeList(Arbiter->PossibleAllocation);
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
    return Status;
}
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
#if (NTDDI_VERSION >= NTDDI_VISTA)
ArbiterLibTestAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_TEST_ALLOCATION_PARAMETERS Parameters)
{
    PAGED_CODE();
    return ArbpTestAllocation(Arbiter, Parameters->ArbitrationList);
}
#else
ArbiterLibTestAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PLIST_ENTRY ArbitrationList)
{
    PAGED_CODE();
    return ArbpTestAllocation(Arbiter, ArbitrationList);
}
#endif
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
#if (NTDDI_VERSION >= NTDDI_VISTA)
ArbiterLibRetestAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_RETEST_ALLOCATION_PARAMETERS Parameters)
{
    PAGED_CODE();
    return ArbpRetestAllocation(Arbiter, Parameters->ArbitrationList);
}
#else
ArbiterLibRetestAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PLIST_ENTRY ArbitrationList)
{
    PAGED_CODE();
    return ArbpRetestAllocation(Arbiter, ArbitrationList);
}
#endif
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
ArbiterLibCommitAllocation(
    _In_ PARBITER_INSTANCE Arbiter)
{
    PRTL_RANGE_LIST Old = Arbiter->Allocation;
 
    PAGED_CODE();
 
    RtlFreeRangeList(Old);
    RtlInitializeRangeList(Old);
    Arbiter->Allocation = Arbiter->PossibleAllocation;
    Arbiter->PossibleAllocation = Old;
    return STATUS_SUCCESS;
}
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
ArbiterLibRollbackAllocation(
    _In_ PARBITER_INSTANCE Arbiter)
{
    PAGED_CODE();
 
    RtlFreeRangeList(Arbiter->PossibleAllocation);
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
    return STATUS_SUCCESS;
}
 
/* BOOT ALLOCATION ************************************************************/
 
CODE_SEG("PAGE")
static
NTSTATUS
ArbpBootAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PLIST_ENTRY ArbitrationList)
{
    PLIST_ENTRY ListEntry;
    ARBITER_ALLOCATION_STATE State;
    ARBITER_ALTERNATIVE Alternative;
    PRTL_RANGE_LIST Old;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    /* Stage the additions in PossibleAllocation, then swap them in. */
    RtlFreeRangeList(Arbiter->PossibleAllocation);
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
    Status = RtlCopyRangeList(Arbiter->PossibleAllocation, Arbiter->Allocation);
    if (!NT_SUCCESS(Status))
    {
        RtlFreeRangeList(Arbiter->PossibleAllocation);
        RtlInitializeRangeList(Arbiter->PossibleAllocation);
        return Status;
    }
 
    for (ListEntry = ArbitrationList->Flink;
         ListEntry != ArbitrationList;
         ListEntry = ListEntry->Flink)
    {
        PARBITER_LIST_ENTRY Entry = CONTAINING_RECORD(ListEntry, ARBITER_LIST_ENTRY, ListEntry);
 
        if (Entry->AlternativeCount == 0)
            continue;
 
        RtlZeroMemory(&State, sizeof(State));
        RtlZeroMemory(&Alternative, sizeof(Alternative));
 
        if (!NT_SUCCESS(ArbpBuildAlternative(Arbiter, &Entry->Alternatives[0], &Alternative)))
            continue;
 
        /* Only sane, fixed single-placement configurations are reserved. */
        if (Alternative.Length == 0 ||
            Alternative.Alignment == 0 ||
            (Alternative.Flags & ARBITER_ALTERNATIVE_FLAG_BADRANGE) ||
            !(Alternative.Flags & ARBITER_ALTERNATIVE_FLAG_FIXED) ||
            (Alternative.Minimum % Alternative.Alignment) != 0)
        {
            continue;
        }
 
        State.Entry = Entry;
        State.AlternativeCount = 1;
        State.Alternatives = &Alternative;
        State.CurrentAlternative = &Alternative;
        State.Flags = ARBITER_STATE_FLAG_BOOT;
        State.RangeAttributes = ARBITER_RANGE_BOOT_ALLOCATED;
        State.Start = State.CurrentMinimum = Alternative.Minimum;
        State.End = State.CurrentMaximum = Alternative.Maximum;
 
        if (!NT_SUCCESS(Arbiter->PreprocessEntry(Arbiter, &State)))
            continue;
 
        Arbiter->AddAllocation(Arbiter, &State);
 
        /*
         * The reservation is also written back into the device's
         * Assignment, or it is left holding an unfilled one.
         */
        if (Arbiter->PackResource != NULL && Entry->Assignment != NULL)
        {
            (VOID)Arbiter->PackResource(Alternative.Descriptor,
                                        State.Start,
                                        Entry->Assignment);
        }
    }
 
    Old = Arbiter->Allocation;
    RtlFreeRangeList(Old);
    RtlInitializeRangeList(Old);
    Arbiter->Allocation = Arbiter->PossibleAllocation;
    Arbiter->PossibleAllocation = Old;
 
    return STATUS_SUCCESS;
}
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
#if (NTDDI_VERSION >= NTDDI_VISTA)
ArbiterLibBootAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_BOOT_ALLOCATION_PARAMETERS Parameters)
{
    PAGED_CODE();
    return ArbpBootAllocation(Arbiter, Parameters->ArbitrationList);
}
#else
ArbiterLibBootAllocation(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PLIST_ENTRY ArbitrationList)
{
    PAGED_CODE();
    return ArbpBootAllocation(Arbiter, ArbitrationList);
}
#endif
 
/* CONFLICT QUERIES ***********************************************************/
 
CODE_SEG("PAGE")
static
BOOLEAN
NTAPI
ArbpQueryConflictCallback(
    _In_ PVOID Context,
    _In_ PRTL_RANGE Range)
{
    PAGED_CODE();
    *(PRTL_RANGE *)Context = Range;
    return FALSE;
}
 
CODE_SEG("PAGE")
static
NTSTATUS
ArbpQueryConflict(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PDEVICE_OBJECT PhysicalDeviceObject,
    _In_ PIO_RESOURCE_DESCRIPTOR ConflictingResource,
    _Out_ PULONG ConflictCount,
    _Out_ PARBITER_CONFLICT_INFO *Conflicts)
{
    PRTL_CONFLICT_RANGE_CALLBACK SavedCallback = Arbiter->ConflictCallback;
    PVOID SavedContext = Arbiter->ConflictCallbackContext;
    PRTL_RANGE ConflictingRange = NULL;
    ARBITER_ALLOCATION_STATE State;
    ARBITER_LIST_ENTRY Entry;
    ARBITER_ALTERNATIVE Alternative;
    PARBITER_CONFLICT_INFO List;
    ULONG Count = 0;
    ULONG Capacity = 10;
    ULONG ResultLength;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    *ConflictCount = 0;
    *Conflicts = NULL;
 
    RtlZeroMemory(&State, sizeof(State));
 
    Arbiter->ConflictCallback = ArbpQueryConflictCallback;
    Arbiter->ConflictCallbackContext = &ConflictingRange;
 
    RtlFreeRangeList(Arbiter->PossibleAllocation);
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
    Status = RtlCopyRangeList(Arbiter->PossibleAllocation, Arbiter->Allocation);
    if (!NT_SUCCESS(Status))
        goto Cleanup;
 
    Status = ArbpBuildAlternative(Arbiter, ConflictingResource, &Alternative);
    if (!NT_SUCCESS(Status))
        goto Cleanup;
 
    RtlZeroMemory(&Entry, sizeof(Entry));
    State.Start = State.CurrentMinimum = Alternative.Minimum;
    State.End = State.CurrentMaximum = Alternative.Maximum;
    State.CurrentAlternative = State.Alternatives = &Alternative;
    State.AlternativeCount = 1;
    State.Entry = &Entry;
    Entry.RequestSource = ArbiterRequestPnpEnumerated;
    Entry.PhysicalDeviceObject = PhysicalDeviceObject;
    if (!NT_SUCCESS(IoGetDeviceProperty(PhysicalDeviceObject,
                                        DevicePropertyLegacyBusType,
                                        sizeof(Entry.InterfaceType),
                                        &Entry.InterfaceType,
                                        &ResultLength)))
    {
        Entry.InterfaceType = Isa;
    }
    if (!NT_SUCCESS(IoGetDeviceProperty(PhysicalDeviceObject, DevicePropertyBusNumber,
                                        sizeof(Entry.BusNumber), &Entry.BusNumber, &ResultLength)))
    {
        Entry.BusNumber = 0;
    }
 
    List = ExAllocatePoolWithTag(PagedPool, Capacity * sizeof(*List), TAG_ARBITER);
    if (List == NULL)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Cleanup;
    }
 
    Status = Arbiter->PreprocessEntry(Arbiter, &State);
    if (!NT_SUCCESS(Status))
    {
        ExFreePoolWithTag(List, TAG_ARBITER);
        goto Cleanup;
    }
 
    /* The requester's own ranges are not conflicts. */
    RtlDeleteOwnersRanges(Arbiter->PossibleAllocation, PhysicalDeviceObject);
 
    for (;;)
    {
        ConflictingRange = NULL;
        State.CurrentMinimum = State.Start;
        State.CurrentMaximum = State.End;
 
        if (Arbiter->FindSuitableRange(Arbiter, &State))
            break;      /* placeable now: no more conflicts */
 
        if (Count == Capacity)
        {
            PARBITER_CONFLICT_INFO Grown =
                ExAllocatePoolWithTag(PagedPool,
                                      (Capacity + 5) * sizeof(*Grown),
                                      TAG_ARBITER);
            if (Grown == NULL)
            {
                Status = STATUS_INSUFFICIENT_RESOURCES;
                ExFreePoolWithTag(List, TAG_ARBITER);
                goto Cleanup;
            }
            RtlCopyMemory(Grown, List, Count * sizeof(ARBITER_CONFLICT_INFO));
            ExFreePoolWithTag(List, TAG_ARBITER);
            List = Grown;
            Capacity += 5;
        }
 
        if (ConflictingRange == NULL)
        {
            /* Blocked, but no specific owner: report one whole-range conflict. */
            List[Count].OwningObject = NULL;
            List[Count].Start = 0;
            List[Count].End = ARBITER_MAXIMUM_ADDRESS;
            ++Count;
            break;
        }
 
        List[Count].OwningObject = (PDEVICE_OBJECT)ConflictingRange->Owner;
        List[Count].Start = ConflictingRange->Start;
        List[Count].End = ConflictingRange->End;
        ++Count;
 
        /* Remove that owner and look for the next conflict. */
        Status = RtlDeleteOwnersRanges(Arbiter->PossibleAllocation, ConflictingRange->Owner);
        if (!NT_SUCCESS(Status))
        {
            ExFreePoolWithTag(List, TAG_ARBITER);
            goto Cleanup;
        }
    }
 
    *Conflicts = List;
    *ConflictCount = Count;
    Status = STATUS_SUCCESS;
 
Cleanup:
    if (State.Flags & ARBITER_STATE_FLAG_WORKSPACE)
    {
        ExFreePoolWithTag((PVOID)State.WorkSpace, TAG_ARBITER);
        State.WorkSpace = 0;
        State.Flags &= ~ARBITER_STATE_FLAG_WORKSPACE;
    }
    RtlFreeRangeList(Arbiter->PossibleAllocation);
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
    Arbiter->ConflictCallback = SavedCallback;
    Arbiter->ConflictCallbackContext = SavedContext;
    return Status;
}
 
CODE_SEG("PAGE")
NTSTATUS
NTAPI
#if (NTDDI_VERSION >= NTDDI_VISTA)
ArbiterLibQueryConflict(
    _In_ PARBITER_INSTANCE Arbiter,
    _Inout_ PARBITER_QUERY_CONFLICT_PARAMETERS Parameters)
{
    PAGED_CODE();
    return ArbpQueryConflict(Arbiter,
                             Parameters->PhysicalDeviceObject,
                             Parameters->ConflictingResource,
                             Parameters->ConflictCount,
                             Parameters->Conflicts);
}
#else
ArbiterLibQueryConflict(
    _In_ PARBITER_INSTANCE Arbiter,
    _In_ PDEVICE_OBJECT PhysicalDeviceObject,
    _In_ PIO_RESOURCE_DESCRIPTOR ConflictingResource,
    _Out_ PULONG ConflictCount,
    _Out_ PARBITER_CONFLICT_INFO *Conflicts)
{
    PAGED_CODE();
    return ArbpQueryConflict(Arbiter, PhysicalDeviceObject, ConflictingResource,
                             ConflictCount, Conflicts);
}
#endif