This graph shows which files directly or indirectly include this file:

Classes
struct	_ARBITER_ALTERNATIVE

struct	_ARBITER_ALLOCATION_STATE

struct	_ARBITER_ORDERING

struct	_ARBITER_ORDERING_LIST

struct	_ARBITER_INSTANCE

Macros
#define	TAG_ARBITER 'ibrA'

#define	ARBITER_MAXIMUM_ADDRESS ((ULONGLONG)~0ULL)

#define	ARBITER_PRIORITY_NULL 0x00000000

#define	ARBITER_PRIORITY_PREFERRED_RESERVED 0x7FFFFFFD

#define	ARBITER_PRIORITY_RESERVED 0x7FFFFFFE

#define	ARBITER_PRIORITY_EXHAUSTED 0x7FFFFFFF

#define	ARBITER_ALTERNATIVE_FLAG_SHARED 0x00000001

#define	ARBITER_ALTERNATIVE_FLAG_FIXED 0x00000002

#define	ARBITER_ALTERNATIVE_FLAG_BADRANGE 0x00000004

#define	ARBITER_ALTERNATIVE_FLAG_INACCESSIBLE_OK 0x00000008

#define	ARBITER_RANGE_BOOT_ALLOCATED 0x01

#define	ARBITER_RANGE_SHARED_DRIVER 0x02

#define	ARBITER_RANGE_PORT_ALIAS 0x10

#define	ARBITER_RANGE_INACCESSIBLE 0x40

#define	ARBITER_STATE_FLAG_BOOT 0x0004

#define	ARBITER_STATE_FLAG_NULL_CONFLICT_OK 0x0008

#define	ARBITER_STATE_FLAG_WORKSPACE 0x0010

#define	ARBITER_STATE_FLAG_MCFG_CONFLICT 0x0020

Typedefs
typedef struct _ARBITER_ALTERNATIVE	ARBITER_ALTERNATIVE

typedef struct _ARBITER_ALTERNATIVE *	PARBITER_ALTERNATIVE

typedef struct _ARBITER_ALLOCATION_STATE	ARBITER_ALLOCATION_STATE

typedef struct _ARBITER_ALLOCATION_STATE *	PARBITER_ALLOCATION_STATE

typedef struct _ARBITER_ORDERING	ARBITER_ORDERING

typedef struct _ARBITER_ORDERING *	PARBITER_ORDERING

typedef struct _ARBITER_ORDERING_LIST	ARBITER_ORDERING_LIST

typedef struct _ARBITER_ORDERING_LIST *	PARBITER_ORDERING_LIST

typedef struct _ARBITER_INSTANCE *	PARBITER_INSTANCE

typedef NTSTATUS(NTAPI *	PARB_UNPACK_REQUIREMENT) (_In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor, _Out_ PUINT64 OutMinimumAddress, _Out_ PUINT64 OutMaximumAddress, _Out_ PUINT64 OutLength, _Out_ PUINT64 OutAlignment)

typedef NTSTATUS(NTAPI *	PARB_PACK_RESOURCE) (_In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor, _In_ UINT64 Start, _Out_ PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor)

typedef NTSTATUS(NTAPI *	PARB_UNPACK_RESOURCE) (_In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor, _Out_ PUINT64 Start, _Out_ PUINT64 OutLength)

typedef INT32(NTAPI *	PARB_SCORE_REQUIREMENT) (_In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor)

typedef NTSTATUS(NTAPI *	PARB_TEST_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_TEST_ALLOCATION_PARAMETERS Parameters)

typedef NTSTATUS(NTAPI *	PARB_RETEST_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_RETEST_ALLOCATION_PARAMETERS Parameters)

typedef NTSTATUS(NTAPI *	PARB_BOOT_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_BOOT_ALLOCATION_PARAMETERS Parameters)

typedef NTSTATUS(NTAPI *	PARB_QUERY_ARBITRATE) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_QUERY_ARBITRATE_PARAMETERS Parameters)

typedef NTSTATUS(NTAPI *	PARB_QUERY_CONFLICT) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_QUERY_CONFLICT_PARAMETERS Parameters)

typedef NTSTATUS(NTAPI *	PARB_ADD_RESERVED) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ADD_RESERVED_PARAMETERS Parameters)

typedef NTSTATUS(NTAPI *	PARB_COMMIT_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter)

typedef NTSTATUS(NTAPI *	PARB_ROLLBACK_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter)

typedef NTSTATUS(NTAPI *	PARB_START_ARBITER) (_In_ PARBITER_INSTANCE Arbiter, _In_ PCM_RESOURCE_LIST StartResources)

typedef NTSTATUS(NTAPI *	PARB_PREPROCESS_ENTRY) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

typedef NTSTATUS(NTAPI *	PARB_ALLOCATE_ENTRY) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

typedef BOOLEAN(NTAPI *	PARB_GET_NEXT_ALLOCATION_RANGE) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

typedef BOOLEAN(NTAPI *	PARB_FIND_SUITABLE_RANGE) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

typedef VOID(NTAPI *	PARB_ADD_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

typedef VOID(NTAPI *	PARB_BACKTRACK_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

typedef BOOLEAN(NTAPI *	PARB_OVERRIDE_CONFLICT) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

typedef NTSTATUS(NTAPI *	PARB_TRANSLATE_ORDERING) (_Out_ PIO_RESOURCE_DESCRIPTOR OutIoDescriptor, _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor)

typedef NTSTATUS(NTAPI *	PARB_INITIALIZE_RANGE_LIST) (_In_ PARBITER_INSTANCE Arbiter, _In_ ULONG DescriptorCount, _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptors, _Inout_ PRTL_RANGE_LIST RangeList)

typedef struct _ARBITER_INSTANCE	ARBITER_INSTANCE

Functions
NTSTATUS NTAPI	ArbiterLibInitializeInstance (_Inout_ PARBITER_INSTANCE Arbiter, _In_ PDEVICE_OBJECT BusDeviceObject, _In_ CM_RESOURCE_TYPE ResourceType, _In_ PCWSTR ArbiterName, _In_ PCWSTR OrderName, _In_ PARB_TRANSLATE_ORDERING TranslateOrderingFunction)

VOID NTAPI	ArbiterLibDeleteInstance (_In_ PARBITER_INSTANCE Arbiter)

VOID NTAPI	ArbiterLibFreeOrderingList (_Inout_ PARBITER_ORDERING_LIST OrderingList)

NTSTATUS NTAPI	ArbiterLibAddOrdering (_Inout_ PARBITER_ORDERING_LIST OrderingList, _In_ UINT64 Start, _In_ UINT64 End)

NTSTATUS NTAPI	ArbiterLibDefaultAssignmentOrdering (_Inout_ PARBITER_INSTANCE Arbiter, _In_ PCWSTR AllocationOrderName, _In_ PCWSTR ReservedResourcesName, _In_opt_ PARB_TRANSLATE_ORDERING TranslateOrderingFunction)
	Builds the arbiter's allocation ordering from the registry policy, most-preferred window first.

NTSTATUS NTAPI	ArbiterLibHandler (_In_ PVOID Context, _In_ ARBITER_ACTION Action, _Inout_ PARBITER_PARAMETERS Parameters)
	The single ARBITER_ACTION dispatcher every exported ARBITER_INTERFACE points its ArbiterHandler at; Context is the ARBITER_INSTANCE.

NTSTATUS NTAPI	ArbiterLibTestAllocation (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_TEST_ALLOCATION_PARAMETERS Parameters)
	The TestAllocation action: tentatively places every entry of the arbitration list, leaving the solution in PossibleAllocation for a later commit or rollback.

NTSTATUS NTAPI	ArbiterLibRetestAllocation (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_RETEST_ALLOCATION_PARAMETERS Parameters)
	The RetestAllocation action: deterministically re-establishes the placements a previous test chose, without searching.

NTSTATUS NTAPI	ArbiterLibBootAllocation (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_BOOT_ALLOCATION_PARAMETERS Parameters)
	The BootAllocation action: records every entry's firmware boot configuration in the committed allocation.

NTSTATUS NTAPI	ArbiterLibQueryConflict (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_QUERY_CONFLICT_PARAMETERS Parameters)
	The QueryConflict action: reports which devices' committed ranges collide with a candidate resource.

NTSTATUS NTAPI	ArbiterLibCommitAllocation (_In_ PARBITER_INSTANCE Arbiter)
	The CommitAllocation action: the tentative PossibleAllocation becomes the committed Allocation, and the old committed list is recycled as the next scratch list.

NTSTATUS NTAPI	ArbiterLibRollbackAllocation (_In_ PARBITER_INSTANCE Arbiter)
	The RollbackAllocation action: discards the tentative allocation; the committed one is untouched.

BOOLEAN NTAPI	ArbiterLibGetNextAllocationRange (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)
	Moves the working window to the next candidate range, walking the entry's alternatives in priority order across the arbiter's ordering list.

BOOLEAN NTAPI	ArbiterLibFindSuitableRange (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)
	Finds a free range of the current candidate window in the arbiter's tentative allocation list.

VOID NTAPI	ArbiterLibAddAllocation (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)
	Records the chosen placement in the arbiter's tentative allocation list, owned by the requesting device.

VOID NTAPI	ArbiterLibBacktrackAllocation (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)
	Undoes the last AddAllocation performed for this entry.

NTSTATUS NTAPI	ArbiterLibPreprocessEntry (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)
	Per-entry hook invoked before each placement attempt. The library default does nothing and succeeds.

NTSTATUS NTAPI	ArbiterLibSortArbitrationList (_Inout_ PLIST_ENTRY ArbitrationList)
	Orders an arbitration list most-constrained first, so fixed requirements are placed before flexible ones can steal their ranges.

NTSTATUS NTAPI	ArbiterLibAllocateEntry (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)
	Places the whole stack of entries with backtracking: when an entry cannot be placed, the previous entry's tentative choice is withdrawn and varied, first lower within its window, then via its next window or alternative.

NTSTATUS NTAPI	ArbiterLibStartArbiter (_In_ PARBITER_INSTANCE Arbiter, _In_ PCM_RESOURCE_LIST StartResources)
	The StartArbiter action default: seeds the committed allocation with the windows the bus decodes, so arbitration starts from the hardware's real extent.

BOOLEAN NTAPI	ArbiterLibOverrideConflict (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)
	The OverrideConflict default, the last of the conflict escapes: grants a FIXED requirement whose window conflicts only with ranges the requesting device itself already owns.

NTSTATUS NTAPI	ArbiterLibAddInaccessibleAllocationRange (_In_ PARBITER_INSTANCE Arbiter, _In_ PCWSTR OrderingName, _Inout_ PRTL_RANGE_LIST RangeList)
	Carves the firmware-reported inaccessible ranges (Arbiters\InaccessibleRange<OrderingName>) out of a range list as unowned blocking ranges, so they are never handed to a device.

NTSTATUS NTAPI	ArbiterLibAddMmConfigRangeAsBootReserved (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PRTL_RANGE_LIST RangeList)
	Reserves the PCI-Express enhanced-config (MMCONFIG / ECAM) MMIO window (Arbiters\ReservedResources\MmConfigRange) in a range list, and records it for ArbiterLibIsConflictWithMmConfigRange.

BOOLEAN NTAPI	ArbiterLibIsConflictWithMmConfigRange (_In_ ULONGLONG Start, _In_ ULONGLONG End)
	Determines whether a range overlaps the recorded MMCONFIG window.

VOID NTAPI	ArbiterLibReserveRange (_In_ PARBITER_INSTANCE Arbiter, _In_ ULONGLONG Start, _In_ ULONGLONG End, _In_opt_ PVOID Owner, _In_ BOOLEAN Shared)
	Commits a single [Start, End] range into the arbiter as an ordinary allocation owned by Owner.

VOID NTAPI	ArbiterLibReleaseResources (_In_ PARBITER_INSTANCE Arbiter, _In_ PVOID Owner)
	Releases every committed range owned by Owner.

NTSTATUS NTAPI	ArbiterLibQueryArbitrate (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_QUERY_ARBITRATE_PARAMETERS Parameters)
	The QueryArbitrate action default: reports that this arbiter is willing to arbitrate the given list.

NTSTATUS NTAPI	ArbiterLibAddReserved (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ADD_RESERVED_PARAMETERS Parameters)
	The AddReserved action default: nothing to reserve.

NTSTATUS NTAPI	ArbiterLibInitializeRangeList (_In_ PARBITER_INSTANCE Arbiter, _In_ ULONG ResourceCount, _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Resources, _Inout_ PRTL_RANGE_LIST RangeList)
	The InitializeRangeList callback default.

Macro Definition Documentation

◆ ARBITER_ALTERNATIVE_FLAG_BADRANGE

#define ARBITER_ALTERNATIVE_FLAG_BADRANGE 0x00000004

Definition at line 33 of file arbiter.h.

◆ ARBITER_ALTERNATIVE_FLAG_FIXED

#define ARBITER_ALTERNATIVE_FLAG_FIXED 0x00000002

Definition at line 32 of file arbiter.h.

◆ ARBITER_ALTERNATIVE_FLAG_INACCESSIBLE_OK

#define ARBITER_ALTERNATIVE_FLAG_INACCESSIBLE_OK 0x00000008

Definition at line 34 of file arbiter.h.

◆ ARBITER_ALTERNATIVE_FLAG_SHARED

#define ARBITER_ALTERNATIVE_FLAG_SHARED 0x00000001

Definition at line 31 of file arbiter.h.

◆ ARBITER_MAXIMUM_ADDRESS

#define ARBITER_MAXIMUM_ADDRESS ((ULONGLONG)~0ULL)

Definition at line 13 of file arbiter.h.

◆ ARBITER_PRIORITY_EXHAUSTED

#define ARBITER_PRIORITY_EXHAUSTED 0x7FFFFFFF

Definition at line 28 of file arbiter.h.

◆ ARBITER_PRIORITY_NULL

#define ARBITER_PRIORITY_NULL 0x00000000

Definition at line 25 of file arbiter.h.

◆ ARBITER_PRIORITY_PREFERRED_RESERVED

#define ARBITER_PRIORITY_PREFERRED_RESERVED 0x7FFFFFFD

Definition at line 26 of file arbiter.h.

◆ ARBITER_PRIORITY_RESERVED

#define ARBITER_PRIORITY_RESERVED 0x7FFFFFFE

Definition at line 27 of file arbiter.h.

◆ ARBITER_RANGE_BOOT_ALLOCATED

#define ARBITER_RANGE_BOOT_ALLOCATED 0x01

Definition at line 53 of file arbiter.h.

◆ ARBITER_RANGE_INACCESSIBLE

#define ARBITER_RANGE_INACCESSIBLE 0x40

Definition at line 56 of file arbiter.h.

◆ ARBITER_RANGE_PORT_ALIAS

#define ARBITER_RANGE_PORT_ALIAS 0x10

Definition at line 55 of file arbiter.h.

◆ ARBITER_RANGE_SHARED_DRIVER

#define ARBITER_RANGE_SHARED_DRIVER 0x02

Definition at line 54 of file arbiter.h.

◆ ARBITER_STATE_FLAG_BOOT

#define ARBITER_STATE_FLAG_BOOT 0x0004

Definition at line 59 of file arbiter.h.

◆ ARBITER_STATE_FLAG_MCFG_CONFLICT

#define ARBITER_STATE_FLAG_MCFG_CONFLICT 0x0020

Definition at line 62 of file arbiter.h.

◆ ARBITER_STATE_FLAG_NULL_CONFLICT_OK

#define ARBITER_STATE_FLAG_NULL_CONFLICT_OK 0x0008

Definition at line 60 of file arbiter.h.

◆ ARBITER_STATE_FLAG_WORKSPACE

#define ARBITER_STATE_FLAG_WORKSPACE 0x0010

Definition at line 61 of file arbiter.h.

◆ TAG_ARBITER

#define TAG_ARBITER 'ibrA'

Definition at line 10 of file arbiter.h.

Typedef Documentation

◆ ARBITER_ALLOCATION_STATE

typedef struct _ARBITER_ALLOCATION_STATE ARBITER_ALLOCATION_STATE

◆ ARBITER_ALTERNATIVE

typedef struct _ARBITER_ALTERNATIVE ARBITER_ALTERNATIVE

◆ ARBITER_INSTANCE

typedef struct _ARBITER_INSTANCE ARBITER_INSTANCE

◆ ARBITER_ORDERING

typedef struct _ARBITER_ORDERING ARBITER_ORDERING

◆ ARBITER_ORDERING_LIST

typedef struct _ARBITER_ORDERING_LIST ARBITER_ORDERING_LIST

◆ PARB_ADD_ALLOCATION

typedef VOID(NTAPI * PARB_ADD_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

Definition at line 259 of file arbiter.h.

◆ PARB_ADD_RESERVED

typedef NTSTATUS(NTAPI * PARB_ADD_RESERVED) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ADD_RESERVED_PARAMETERS Parameters)

Definition at line 171 of file arbiter.h.

◆ PARB_ALLOCATE_ENTRY

typedef NTSTATUS(NTAPI * PARB_ALLOCATE_ENTRY) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

Definition at line 241 of file arbiter.h.

◆ PARB_BACKTRACK_ALLOCATION

typedef VOID(NTAPI * PARB_BACKTRACK_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

Definition at line 265 of file arbiter.h.

◆ PARB_BOOT_ALLOCATION

typedef NTSTATUS(NTAPI * PARB_BOOT_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_BOOT_ALLOCATION_PARAMETERS Parameters)

Definition at line 153 of file arbiter.h.

◆ PARB_COMMIT_ALLOCATION

typedef NTSTATUS(NTAPI * PARB_COMMIT_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter)

Definition at line 219 of file arbiter.h.

◆ PARB_FIND_SUITABLE_RANGE

typedef BOOLEAN(NTAPI * PARB_FIND_SUITABLE_RANGE) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

Definition at line 253 of file arbiter.h.

◆ PARB_GET_NEXT_ALLOCATION_RANGE

typedef BOOLEAN(NTAPI * PARB_GET_NEXT_ALLOCATION_RANGE) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

Definition at line 247 of file arbiter.h.

◆ PARB_INITIALIZE_RANGE_LIST

typedef NTSTATUS(NTAPI * PARB_INITIALIZE_RANGE_LIST) (_In_ PARBITER_INSTANCE Arbiter, _In_ ULONG DescriptorCount, _In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptors, _Inout_ PRTL_RANGE_LIST RangeList)

Definition at line 284 of file arbiter.h.

◆ PARB_OVERRIDE_CONFLICT

typedef BOOLEAN(NTAPI * PARB_OVERRIDE_CONFLICT) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

Definition at line 271 of file arbiter.h.

◆ PARB_PACK_RESOURCE

typedef NTSTATUS(NTAPI * PARB_PACK_RESOURCE) (_In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor, _In_ UINT64 Start, _Out_ PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor)

Definition at line 121 of file arbiter.h.

◆ PARB_PREPROCESS_ENTRY

typedef NTSTATUS(NTAPI * PARB_PREPROCESS_ENTRY) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_ALLOCATION_STATE ArbState)

Definition at line 235 of file arbiter.h.

◆ PARB_QUERY_ARBITRATE

typedef NTSTATUS(NTAPI * PARB_QUERY_ARBITRATE) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_QUERY_ARBITRATE_PARAMETERS Parameters)

Definition at line 159 of file arbiter.h.

◆ PARB_QUERY_CONFLICT

typedef NTSTATUS(NTAPI * PARB_QUERY_CONFLICT) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_QUERY_CONFLICT_PARAMETERS Parameters)

Definition at line 165 of file arbiter.h.

◆ PARB_RETEST_ALLOCATION

typedef NTSTATUS(NTAPI * PARB_RETEST_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_RETEST_ALLOCATION_PARAMETERS Parameters)

Definition at line 147 of file arbiter.h.

◆ PARB_ROLLBACK_ALLOCATION

typedef NTSTATUS(NTAPI * PARB_ROLLBACK_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter)

Definition at line 224 of file arbiter.h.

◆ PARB_SCORE_REQUIREMENT

typedef INT32(NTAPI * PARB_SCORE_REQUIREMENT) (_In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor)

Definition at line 135 of file arbiter.h.

◆ PARB_START_ARBITER

typedef NTSTATUS(NTAPI * PARB_START_ARBITER) (_In_ PARBITER_INSTANCE Arbiter, _In_ PCM_RESOURCE_LIST StartResources)

Definition at line 229 of file arbiter.h.

◆ PARB_TEST_ALLOCATION

typedef NTSTATUS(NTAPI * PARB_TEST_ALLOCATION) (_In_ PARBITER_INSTANCE Arbiter, _Inout_ PARBITER_TEST_ALLOCATION_PARAMETERS Parameters)

Definition at line 141 of file arbiter.h.

◆ PARB_TRANSLATE_ORDERING

typedef NTSTATUS(NTAPI * PARB_TRANSLATE_ORDERING) (_Out_ PIO_RESOURCE_DESCRIPTOR OutIoDescriptor, _In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor)

Definition at line 277 of file arbiter.h.

◆ PARB_UNPACK_REQUIREMENT

typedef NTSTATUS(NTAPI * PARB_UNPACK_REQUIREMENT) (_In_ PIO_RESOURCE_DESCRIPTOR IoDescriptor, _Out_ PUINT64 OutMinimumAddress, _Out_ PUINT64 OutMaximumAddress, _Out_ PUINT64 OutLength, _Out_ PUINT64 OutAlignment)

Definition at line 112 of file arbiter.h.

◆ PARB_UNPACK_RESOURCE

typedef NTSTATUS(NTAPI * PARB_UNPACK_RESOURCE) (_In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDescriptor, _Out_ PUINT64 Start, _Out_ PUINT64 OutLength)

Definition at line 128 of file arbiter.h.

◆ PARBITER_ALLOCATION_STATE

typedef struct _ARBITER_ALLOCATION_STATE * PARBITER_ALLOCATION_STATE

◆ PARBITER_ALTERNATIVE

typedef struct _ARBITER_ALTERNATIVE * PARBITER_ALTERNATIVE

◆ PARBITER_INSTANCE

typedef struct _ARBITER_INSTANCE * PARBITER_INSTANCE

Definition at line 110 of file arbiter.h.

◆ PARBITER_ORDERING

typedef struct _ARBITER_ORDERING * PARBITER_ORDERING

◆ PARBITER_ORDERING_LIST

typedef struct _ARBITER_ORDERING_LIST * PARBITER_ORDERING_LIST

Function Documentation

◆ ArbiterLibAddAllocation()

VOID NTAPI ArbiterLibAddAllocation	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	ArbState
	)

Records the chosen placement in the arbiter's tentative allocation list, owned by the requesting device.

Parameters

[in]	Arbiter	The arbiter instance whose PossibleAllocation list receives the range.
[in,out]	ArbState	The allocation state whose Start, End and RangeAttributes describe the placement. The range is owned by the entry's physical device object.

Remarks: ADD_IF_CONFLICT is required because override solutions intentionally overlap existing ranges.

Definition at line 828 of file range.c.

{
    ULONG Flags = RTL_RANGE_LIST_ADD_IF_CONFLICT;
 
    PAGED_CODE();
 
    if (ArbState->CurrentAlternative != NULL &&
        (ArbState->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED))
    {
        Flags |= RTL_RANGE_LIST_ADD_SHARED;
    }
 
    RtlAddRange(Arbiter->PossibleAllocation,
                ArbState->Start,
                ArbState->End,
                ArbState->RangeAttributes,
                Flags,
                NULL,
                ArbState->Entry ? ArbState->Entry->PhysicalDeviceObject : NULL);
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibAddInaccessibleAllocationRange()

NTSTATUS NTAPI ArbiterLibAddInaccessibleAllocationRange	(	_In_ PARBITER_INSTANCE	Arbiter,
		_In_ PCWSTR	OrderingName,
		_Inout_ PRTL_RANGE_LIST	RangeList
	)

Carves the firmware-reported inaccessible ranges (Arbiters\InaccessibleRange<OrderingName>) out of a range list as unowned blocking ranges, so they are never handed to a device.

Parameters

[in]	Arbiter	The arbiter instance the ranges are filtered for.
[in]	OrderingName	The InaccessibleRange value to read.
[in,out]	RangeList	The range list to carve the windows out of.

Returns: Returns STATUS_SUCCESS, including when nothing is recorded (an absent value reserves nothing).

Definition at line 634 of file ordering.c.

{
    PAGED_CODE();
    return ArbpForEachRegistryRange(Arbiter, L"InaccessibleRange", OrderingName,
                                    NULL, ArbpAddRangeCallback, RangeList);
}

◆ ArbiterLibAddMmConfigRangeAsBootReserved()

NTSTATUS NTAPI ArbiterLibAddMmConfigRangeAsBootReserved	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PRTL_RANGE_LIST	RangeList
	)

Reserves the PCI-Express enhanced-config (MMCONFIG / ECAM) MMIO window (Arbiters\ReservedResources\MmConfigRange) in a range list, and records it for ArbiterLibIsConflictWithMmConfigRange.

Parameters

[in]	Arbiter	The arbiter instance the window is filtered for.
[in,out]	RangeList	The range list to reserve the window in.

Returns: Returns STATUS_SUCCESS, including on a legacy pre-PCIe machine where the value is simply absent and nothing is reserved.

Definition at line 663 of file ordering.c.

{
    PAGED_CODE();
    return ArbpForEachRegistryRange(Arbiter, L"ReservedResources", L"MmConfigRange",
                                    NULL, ArbpMmConfigCallback, RangeList);
}

◆ ArbiterLibAddOrdering()

NTSTATUS NTAPI ArbiterLibAddOrdering	(	_Inout_ PARBITER_ORDERING_LIST	OrderingList,
		_In_ UINT64	Start,
		_In_ UINT64	End
	)

Definition at line 78 of file ordering.c.

{
    PAGED_CODE();
 
    if (End < Start)
        return STATUS_INVALID_PARAMETER;
 
    /* Double the array capacity when it fills up, up to the sanity cap. */
    if (OrderingList->Count == OrderingList->Maximum)
    {
        ULONG NewMaximum;
        PARBITER_ORDERING NewArray;
 
        NewMaximum = OrderingList->Maximum ? (ULONG)OrderingList->Maximum * 2
                                           : ARBITER_ORDERING_GRANULARITY;
        if (NewMaximum > ARBITER_ORDERING_LIMIT)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        NewArray = ExAllocatePoolWithTag(PagedPool,
                                         NewMaximum * sizeof(ARBITER_ORDERING),
                                         TAG_ARBITER);
        if (NewArray == NULL)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        if (OrderingList->Orderings != NULL)
        {
            RtlCopyMemory(NewArray, OrderingList->Orderings,
                          OrderingList->Count * sizeof(ARBITER_ORDERING));
            ExFreePoolWithTag(OrderingList->Orderings, TAG_ARBITER);
        }
 
        OrderingList->Maximum = (UINT16)NewMaximum;
        OrderingList->Orderings = NewArray;
    }
 
    OrderingList->Orderings[OrderingList->Count].Start = Start;
    OrderingList->Orderings[OrderingList->Count].End = End;
    OrderingList->Count++;
    return STATUS_SUCCESS;
}

Referenced by ArbiterLibDefaultAssignmentOrdering(), ArbpAddOrderingCallback(), ArbpAddReservedCallback(), and ArbpExcludeOrderingRange().

◆ ArbiterLibAddReserved()

NTSTATUS NTAPI ArbiterLibAddReserved	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ADD_RESERVED_PARAMETERS	Parameters
	)

The AddReserved action default: nothing to reserve.

Parameters

[in]	Arbiter	The arbiter instance the reservation was aimed at.
[in,out]	Parameters	The action parameters (pre-Vista builds receive the requirement and resource descriptors directly).

Returns: Returns STATUS_SUCCESS.

Definition at line 112 of file handler.c.

{
    PAGED_CODE();
    UNREFERENCED_PARAMETER(Arbiter);
    UNREFERENCED_PARAMETER(Parameters);
    return STATUS_SUCCESS;
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibAllocateEntry()

NTSTATUS NTAPI ArbiterLibAllocateEntry	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	ArbState
	)

Places the whole stack of entries with backtracking: when an entry cannot be placed, the previous entry's tentative choice is withdrawn and varied, first lower within its window, then via its next window or alternative.

Parameters

[in]	Arbiter	The arbiter instance whose walker callbacks (GetNextAllocationRange, FindSuitableRange, AddAllocation, BacktrackAllocation) drive each placement.
[in,out]	ArbState	The first ARBITER_ALLOCATION_STATE of the allocation stack, one per entry in most-constrained-first order, terminated by a state whose Entry is NULL.

Returns: Returns STATUS_SUCCESS once every entry has a placement (the results are packed into each entry's Assignment and Result), STATUS_UNSUCCESSFUL if even the first entry has no solution, or a PreprocessEntry / PackResource failure status.

Definition at line 223 of file entry.c.

{
    PARBITER_ALLOCATION_STATE Current = ArbState;
    BOOLEAN Backtracking = FALSE;
    BOOLEAN McfgConflict = FALSE;
    BOOLEAN DeadlineReported = FALSE;
    ULONGLONG Deadline;
    ULONGLONG HardDeadline;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    Deadline = KeQueryInterruptTime() + ARBITER_ALLOCATE_DEADLINE;
    HardDeadline = KeQueryInterruptTime() + ARBITER_ALLOCATE_HARD_DEADLINE;
 
    while (Current >= ArbState && Current->Entry != NULL)
    {
        BOOLEAN Found = FALSE;
        BOOLEAN RetrySameRange = FALSE;
 
        /*
         * A search that cannot terminate must fail rather than wedge the
         * machine.
         */
        if (KeQueryInterruptTime() > HardDeadline)
        {
            DPRINT1("Arbiter %ws: abandoning allocation at entry %u, the search "
                    "is not terminating\n",
                    Arbiter->Name ? Arbiter->Name : L"(unnamed)",
                    (ULONG)(Current - ArbState));
 
            if (ArbState->Entry != NULL)
                ArbState->Entry->Result = ArbiterResultExternalConflict;
 
            ArbpFreeAllocationWorkSpaces(ArbState);
            return STATUS_UNSUCCESSFUL;
        }
 
        Status = Arbiter->PreprocessEntry(Arbiter, Current);
        if (!NT_SUCCESS(Status))
        {
            ArbpFreeAllocationWorkSpaces(ArbState);
            return Status;
        }
 
        if (Backtracking)
        {
            PARBITER_ALTERNATIVE FailedAlternative = Current->CurrentAlternative;
 
            /*
             * The entry after this one could not be placed. Withdraw this
             * entry's tentative choice and vary it: first lower within the same
             * window, then via the next window / alternative.
             */
            (Current + 1)->CurrentAlternative = NULL;
            Backtracking = FALSE;
 
            if (FailedAlternative == NULL || FailedAlternative->Length == 0)
                goto Backtrack;  /* Nothing to vary here */
 
            Arbiter->BacktrackAllocation(Arbiter, Current);
 
            /*
             * Retrying one placement lower walks the window down an alignment
             * unit at a time, so it has to be bounded, or searching a bridge's
             * multi-gigabyte window will hang the system.
             */
            if (Current->Start > Current->CurrentMinimum &&
                !(FailedAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_FIXED))
            {
                if (KeQueryInterruptTime() <= Deadline)
                {
                    Current->CurrentMaximum = Current->Start - 1;
                    RetrySameRange = TRUE;
                }
                else if (!DeadlineReported)
                {
                    DeadlineReported = TRUE;
                    DPRINT1("Arbiter %ws: allocation deadline expired, giving up "
                            "range refinement\n",
                            Arbiter->Name ? Arbiter->Name : L"(unnamed)");
                }
            }
        }
 
        for (;;)
        {
            if (!RetrySameRange)
            {
                if (!Arbiter->GetNextAllocationRange(Arbiter, Current))
                    break;
            }
            RetrySameRange = FALSE;
 
            if (Arbiter->FindSuitableRange(Arbiter, Current))
            {
                Found = TRUE;
                break;
            }
        }
 
        if (Found)
        {
            if (Current->CurrentAlternative->Length != 0)
                Arbiter->AddAllocation(Arbiter, Current);
            else
                Current->Entry->Result = ArbiterResultNullRequest;
 
            Current++;
            continue;
        }
 
Backtrack:
        if (Current->Flags & ARBITER_STATE_FLAG_MCFG_CONFLICT)
            McfgConflict = TRUE;
 
        if (Current == ArbState)
        {
            /* Even the first entry has no solution. */
            if (Current->Entry != NULL)
                Current->Entry->Result = ArbiterResultExternalConflict;
 
            DPRINT1("Arbiter %ws: nowhere to put 0x%I64x..0x%I64x\n",
                    Arbiter->Name ? Arbiter->Name : L"(unnamed)",
                    Current->CurrentMinimum, Current->CurrentMaximum);
            ArbpReportConflictingRanges(Arbiter,
                                        Current->CurrentMinimum,
                                        Current->CurrentMaximum);
 
            ArbpFreeAllocationWorkSpaces(ArbState);
            return McfgConflict ? STATUS_BAD_MCFG_TABLE : STATUS_UNSUCCESSFUL;
        }
        Backtracking = TRUE;
        Current--;
    }
 
    /* Complete solution found; report it back to the requesters. */
    for (Current = ArbState; Current->Entry != NULL; ++Current)
    {
        Current->Entry->SelectedAlternative = Current->CurrentAlternative->Descriptor;
 
        if (Current->Entry->Assignment != NULL && Arbiter->PackResource != NULL)
        {
            Status = Arbiter->PackResource(Current->CurrentAlternative->Descriptor,
                                           Current->Start,
                                           Current->Entry->Assignment);
            if (!NT_SUCCESS(Status))
            {
                ArbpFreeAllocationWorkSpaces(ArbState);
                return Status;
            }
        }
 
        if (Current->Entry->Result != ArbiterResultNullRequest)
            Current->Entry->Result = ArbiterResultSuccess;
    }
 
    ArbpFreeAllocationWorkSpaces(ArbState);
    return STATUS_SUCCESS;
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibBacktrackAllocation()

VOID NTAPI ArbiterLibBacktrackAllocation	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	ArbState
	)

Undoes the last AddAllocation performed for this entry.

Parameters

[in]	Arbiter	The arbiter instance whose PossibleAllocation list the tentative range is deleted from.
[in,out]	ArbState	The allocation state whose Start and End describe the placement being removed sanity checked by the entry's physical device object.

Definition at line 866 of file range.c.

{
    PAGED_CODE();
 
    RtlDeleteRange(Arbiter->PossibleAllocation,
                   ArbState->Start,
                   ArbState->End,
                   ArbState->Entry ? ArbState->Entry->PhysicalDeviceObject : NULL);
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibBootAllocation()

NTSTATUS NTAPI ArbiterLibBootAllocation	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_BOOT_ALLOCATION_PARAMETERS	Parameters
	)

The BootAllocation action: records every entry's firmware boot configuration in the committed allocation.

Parameters

[in]	Arbiter	The arbiter instance performing the reservation.
[in,out]	Parameters	The action parameters carrying the arbitration list (pre-Vista builds receive the list directly).

Returns: Returns the ArbpBootAllocation status.

Definition at line 684 of file transaction.c.

{
    PAGED_CODE();
    return ArbpBootAllocation(Arbiter, Parameters->ArbitrationList);
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibCommitAllocation()

NTSTATUS NTAPI ArbiterLibCommitAllocation ( _In_ PARBITER_INSTANCE Arbiter )

The CommitAllocation action: the tentative PossibleAllocation becomes the committed Allocation, and the old committed list is recycled as the next scratch list.

Parameters

[in] Arbiter The arbiter instance whose transaction is committed.

Returns: Returns STATUS_SUCCESS.

Definition at line 515 of file transaction.c.

{
    PRTL_RANGE_LIST Old = Arbiter->Allocation;
 
    PAGED_CODE();
 
    RtlFreeRangeList(Old);
    RtlInitializeRangeList(Old);
    Arbiter->Allocation = Arbiter->PossibleAllocation;
    Arbiter->PossibleAllocation = Old;
    return STATUS_SUCCESS;
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibDefaultAssignmentOrdering()

NTSTATUS NTAPI ArbiterLibDefaultAssignmentOrdering	(	_Inout_ PARBITER_INSTANCE	Arbiter,
		_In_ PCWSTR	AllocationOrderName,
		_In_ PCWSTR	ReservedResourcesName,
		_In_opt_ PARB_TRANSLATE_ORDERING	TranslateOrderingFunction
	)

Builds the arbiter's allocation ordering from the registry policy, most-preferred window first.

Parameters

[in,out]	Arbiter	The arbiter instance whose OrderingList and ReservedList are (re)created. Callers may rebuild an existing ordering against a different policy table (see pcix!ario_ApplyBrokenVideoHack).
[in]	AllocationOrderName	The AllocationOrder value naming this arbiter's preferred windows. The engine walks the resulting list in index order, so index 0 is the most-preferred window.
[in]	ReservedResourcesName	The ReservedResources value naming this arbiter's last-resort windows: each is recorded in the ReservedList for the engine's final pass and pruned out of every ordering window, so it is only ever offered once all orderings fail.
[in]	TranslateOrderingFunction	Optional per-arbiter descriptor translation.

Returns: Returns STATUS_SUCCESS if the ordering was built. Absent registry policy is not a failure; the ordering then holds only the full-range fallback, so the arbiter can always search the whole space.

Definition at line 571 of file ordering.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    ArbiterLibFreeOrderingList(&Arbiter->OrderingList);
    ArbiterLibFreeOrderingList(&Arbiter->ReservedList);
 
    Status = ArbpCreateOrderingList(&Arbiter->OrderingList);
    if (!NT_SUCCESS(Status))
        return Status;
    Status = ArbpCreateOrderingList(&Arbiter->ReservedList);
    if (!NT_SUCCESS(Status))
    {
        ArbiterLibFreeOrderingList(&Arbiter->OrderingList);
        return Status;
    }
 
    ArbpForEachRegistryRange(Arbiter, L"AllocationOrder", AllocationOrderName,
                             TranslateOrderingFunction, ArbpAddOrderingCallback, NULL);
 
    Status = ArbiterLibAddOrdering(&Arbiter->OrderingList, 0, ARBITER_MAXIMUM_ADDRESS);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /*
     * The reserved windows come last, after the fallback is in place, so the
     * pruning punches them out of the fallback too. Otherwise the fallback
     * pass would hand them out like any other range.
     */
    return ArbpForEachRegistryRange(Arbiter, L"ReservedResources", ReservedResourcesName,
                                    TranslateOrderingFunction, ArbpAddReservedCallback,
                                    NULL);
}

Referenced by ArbiterLibInitializeInstance(), and ario_ApplyBrokenVideoHack().

◆ ArbiterLibDeleteInstance()

VOID NTAPI ArbiterLibDeleteInstance ( _In_ PARBITER_INSTANCE Arbiter )

Definition at line 22 of file arbiter.c.

{
    PAGED_CODE();
 
    if (Arbiter->PossibleAllocation)
    {
        RtlFreeRangeList(Arbiter->PossibleAllocation);
        ExFreePoolWithTag(Arbiter->PossibleAllocation, TAG_ARBITER);
        Arbiter->PossibleAllocation = NULL;
    }
 
    if (Arbiter->Allocation)
    {
        RtlFreeRangeList(Arbiter->Allocation);
        ExFreePoolWithTag(Arbiter->Allocation, TAG_ARBITER);
        Arbiter->Allocation = NULL;
    }
 
    if (Arbiter->AllocationStack)
    {
        ExFreePoolWithTag(Arbiter->AllocationStack, TAG_ARBITER);
        Arbiter->AllocationStack = NULL;
        Arbiter->AllocationStackMaxSize = 0;
    }
 
    ArbiterLibFreeOrderingList(&Arbiter->OrderingList);
    ArbiterLibFreeOrderingList(&Arbiter->ReservedList);
 
#if (NTDDI_VERSION >= NTDDI_VISTA)
    if (Arbiter->TransactionEvent)
    {
        ExFreePoolWithTag(Arbiter->TransactionEvent, TAG_ARBITER);
        Arbiter->TransactionEvent = NULL;
    }
#endif
 
    if (Arbiter->MutexEvent)
    {
        ExFreePoolWithTag(Arbiter->MutexEvent, TAG_ARBITER);
        Arbiter->MutexEvent = NULL;
    }
}

Referenced by ArbiterLibInitializeInstance(), and PciArbiterDestructor().

◆ ArbiterLibFindSuitableRange()

BOOLEAN NTAPI ArbiterLibFindSuitableRange	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	ArbState
	)

Finds a free range of the current candidate window in the arbiter's tentative allocation list.

Parameters

[in]	Arbiter	The arbiter instance whose PossibleAllocation list is searched.
[in,out]	ArbState	The allocation state of the entry being placed. On success, Start and End receive the chosen window.

Returns: Returns TRUE if a placement was found,FALSE if the window cannot satisfy the requirement.

Remarks: Legacy requests treat boot-allocated ranges as available. When RtlFindRange reports a conflict, a driver-exclusive requirement may still share the range (ArbpShareDriverExclusive), and failing that the arbiter's OverrideConflict callback gets a last-chance override. this is how a device is re-assigned its own boot configuration.

Definition at line 717 of file range.c.

{
    PARBITER_ALTERNATIVE Alternative = ArbState->CurrentAlternative;
    ULONG Flags = 0;
    NTSTATUS Status;
 
    PAGED_CODE();
 
    if (Alternative == NULL)
        return FALSE;
 
    if (ArbState->CurrentMinimum > ArbState->CurrentMaximum)
        return FALSE;
 
    if (Alternative->Length == 0)
    {
        ArbState->Start = ArbState->CurrentMinimum;
        ArbState->End = ArbState->CurrentMinimum;
        return TRUE;
    }
 
    /*
     * Interrupt retention: give the device back its firmware-routed vector rather
     * than letting the top-down search pick an untranslatable one
     */
    if (ArbpReuseOwnedInterrupt(Arbiter, ArbState))
        return TRUE;
 
    /* Legacy requests consider preallocated (boot) ranges available. */
    if (ArbState->Entry != NULL &&
        (ArbState->Entry->RequestSource == ArbiterRequestLegacyReported ||
         ArbState->Entry->RequestSource == ArbiterRequestLegacyAssigned))
    {
        ArbState->RangeAvailableAttributes |= ARBITER_RANGE_BOOT_ALLOCATED;
    }
 
    if (ArbState->Flags & ARBITER_STATE_FLAG_NULL_CONFLICT_OK)
        Flags |= RTL_RANGE_LIST_NULL_CONFLICT_OK;
    if (Alternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED)
        Flags |= RTL_RANGE_LIST_SHARED_OK;
    if (Alternative->Flags & ARBITER_ALTERNATIVE_FLAG_INACCESSIBLE_OK)
        ArbState->RangeAvailableAttributes |= ARBITER_RANGE_INACCESSIBLE;
 
    Status = RtlFindRange(Arbiter->PossibleAllocation,
                          ArbState->CurrentMinimum,
                          ArbState->CurrentMaximum,
                          Alternative->Length,
                          max(Alternative->Alignment, 1),
                          Flags,
                          ArbState->RangeAvailableAttributes,
                          Arbiter->ConflictCallbackContext,
                          Arbiter->ConflictCallback,
                          &ArbState->Start);
    if (!NT_SUCCESS(Status))
    {
        /*
         * The window is occupied.  A CmResourceShareDriverExclusive requirement
         * can still succeed by sharing the conflicting range with the same driver
         * or another root-enumerated device
         *
         * This matters a lot because HAL reverses quite a bit and marks it this.
         * This mechanism is how Windows "internally allows this".
         */
        if (ArbpShareDriverExclusive(Arbiter, ArbState))
            return TRUE;
        if (Arbiter->OverrideConflict != NULL &&
            Arbiter->OverrideConflict(Arbiter, ArbState))
        {
            return TRUE;
        }
 
        /*
         * A window that only fails because it runs into the MMCONFIG region
         * points at the firmware's MCFG table rather than at any device.
         */
        if (ArbiterLibIsConflictWithMmConfigRange(ArbState->CurrentMinimum,
                                                  ArbState->CurrentMaximum))
        {
            ArbState->Flags |= ARBITER_STATE_FLAG_MCFG_CONFLICT;
        }
 
        return FALSE;
    }
 
    ArbState->End = ArbState->Start + Alternative->Length - 1;
    return TRUE;
}

Referenced by ArbiterLibInitializeInstance(), IopArbMemFindSuitableRange(), and IopArbPortFindSuitableRange().

◆ ArbiterLibFreeOrderingList()

VOID NTAPI ArbiterLibFreeOrderingList ( _Inout_ PARBITER_ORDERING_LIST OrderingList )

Definition at line 60 of file ordering.c.

{
    PAGED_CODE();
 
    if (OrderingList->Orderings != NULL)
        ExFreePoolWithTag(OrderingList->Orderings, TAG_ARBITER);
 
    OrderingList->Orderings = NULL;
    OrderingList->Count = 0;
    OrderingList->Maximum = 0;
}

Referenced by ArbiterLibDefaultAssignmentOrdering(), ArbiterLibDeleteInstance(), ArbpExcludeOrderingRange(), and ario_ApplyBrokenVideoHack().

◆ ArbiterLibGetNextAllocationRange()

BOOLEAN NTAPI ArbiterLibGetNextAllocationRange	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	ArbState
	)

Moves the working window to the next candidate range, walking the entry's alternatives in priority order across the arbiter's ordering list.

Parameters

[in]	Arbiter	The arbiter instance whose ordering list supplies the candidate windows.
[in,out]	ArbState	The allocation state of the entry being placed. On success, CurrentMinimum, CurrentMaximum and CurrentAlternative describe the next window to search; the window is pre-trimmed so an aligned allocation of the required length fits inside it.

Returns: Returns TRUE if a new candidate window was produced, FALSE once every alternative is exhausted.

Definition at line 562 of file range.c.

{
    PARBITER_ALTERNATIVE Alternative;
    PARBITER_ALTERNATIVE Lowest;
    UINT64 Minimum, Maximum;
 
    PAGED_CODE();
 
    if (ArbState->AlternativeCount == 0)
        return FALSE;
 
    for (;;)
    {
        /* Advance the alternative we last worked on, or seed all on first entry. */
        if (ArbState->CurrentAlternative != NULL)
        {
            ArbpWritePriority(Arbiter, ArbState->CurrentAlternative);
        }
        else
        {
            for (Alternative = ArbState->Alternatives;
                 Alternative < &ArbState->Alternatives[ArbState->AlternativeCount];
                 ++Alternative)
            {
                Alternative->Priority = ARBITER_PRIORITY_NULL;
                ArbpWritePriority(Arbiter, Alternative);
            }
        }
 
        /* Pick the best (lowest-priority) alternative. */
        Lowest = ArbState->Alternatives;
        for (Alternative = ArbState->Alternatives + 1;
             Alternative < &ArbState->Alternatives[ArbState->AlternativeCount];
             ++Alternative)
        {
            if (Alternative->Priority < Lowest->Priority)
                Lowest = Alternative;
        }
 
        if (Lowest->Priority == ARBITER_PRIORITY_EXHAUSTED)
            return FALSE;
 
        if (Lowest->Priority == ARBITER_PRIORITY_RESERVED ||
            Lowest->Priority == ARBITER_PRIORITY_PREFERRED_RESERVED)
        {
            /*
             * Last-resort pass: the reserved windows in turn, then the whole
             * requirement window (see ArbpTakeReservedWindow).
             */
            if (!ArbpTakeReservedWindow(Arbiter, Lowest, &Minimum, &Maximum))
            {
                /*
                 * CurrentAlternative must be set before looping. While it is
                 * still NULL, the top of the loop re-seeds every alternative's
                 * priority back to ARBITER_PRIORITY_NULL, which would discard
                 * the EXHAUSTED just recorded and spin forever.
                 */
                Lowest->Priority = ARBITER_PRIORITY_EXHAUSTED;
                ArbState->CurrentAlternative = Lowest;
                continue;
            }
        }
        else
        {
            PARBITER_ORDERING Ordering;
            ULONG Index = (Lowest->Priority < 0) ? (ULONG)(-(Lowest->Priority + 1))
                                                 : (ULONG)(Lowest->Priority - 1);
            if (Index >= Arbiter->OrderingList.Count)
            {
                Lowest->Priority = ARBITER_PRIORITY_EXHAUSTED;
                ArbState->CurrentAlternative = Lowest;
                continue;
            }
            Ordering = &Arbiter->OrderingList.Orderings[Index];
            Minimum = max(Lowest->Minimum, Ordering->Start);
            Maximum = min(Lowest->Maximum, Ordering->End);
        }
 
        /*
         * Trim the window so an aligned allocation of the required length is
         * possible; skip the window entirely if it cannot hold one.
         */
        if (Lowest->Length != 0)
        {
            UINT64 Alignment = Lowest->Alignment ? Lowest->Alignment : 1;
            UINT64 LengthMinusOne = Lowest->Length - 1;
            UINT64 AlignedMax;
 
            Minimum += Alignment - 1;
            Minimum -= Minimum % Alignment;
 
            if (Minimum > Maximum || LengthMinusOne > Maximum - Minimum)
            {
                ArbState->CurrentAlternative = Lowest;  /* consume this priority */
                continue;
            }
 
            AlignedMax = Maximum - LengthMinusOne;
            AlignedMax -= AlignedMax % Alignment;
            if (AlignedMax < Minimum)
            {
                ArbState->CurrentAlternative = Lowest;  /* no aligned start fits */
                continue;
            }
            Maximum = AlignedMax + LengthMinusOne;
        }
        else
        {
            Minimum = Lowest->Minimum;
            Maximum = Lowest->Maximum;
        }
 
        if (Minimum != ArbState->CurrentMinimum ||
            Maximum != ArbState->CurrentMaximum ||
            ArbState->CurrentAlternative != Lowest)
        {
            ArbState->CurrentMinimum = Minimum;
            ArbState->CurrentMaximum = Maximum;
            ArbState->CurrentAlternative = Lowest;
            return TRUE;
        }
 
        ArbState->CurrentAlternative = Lowest;
    }
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibHandler()

NTSTATUS NTAPI ArbiterLibHandler	(	_In_ PVOID	Context,
		_In_ ARBITER_ACTION	Action,
		_Inout_ PARBITER_PARAMETERS	Parameters
	)

The single ARBITER_ACTION dispatcher every exported ARBITER_INTERFACE points its ArbiterHandler at; Context is the ARBITER_INSTANCE.

Parameters

[in]	Context	The ARBITER_INSTANCE the interface was created for.
[in]	Action	The ARBITER_ACTION to perform.
[in,out]	Parameters	The parameters union matching the action.

Returns: Returns the dispatched action's status, STATUS_NOT_IMPLEMENTED for a known but unrouted action, or STATUS_INVALID_PARAMETER for an unrecognized one.

Remarks: The call runs under the instance lock, so a Test and its later Commit or Rollback apply to the same transaction. On Vista+ the transaction event tracks that window: Test and Retest arm it, Commit and Rollback resolve it and wake waiters.

Definition at line 164 of file handler.c.

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

Referenced by PciArbiterConstructor().

◆ ArbiterLibInitializeInstance()

NTSTATUS NTAPI ArbiterLibInitializeInstance	(	_Inout_ PARBITER_INSTANCE	Arbiter,
		_In_ PDEVICE_OBJECT	BusDeviceObject,
		_In_ CM_RESOURCE_TYPE	ResourceType,
		_In_ PCWSTR	ArbiterName,
		_In_ PCWSTR	OrderName,
		_In_ PARB_TRANSLATE_ORDERING	TranslateOrderingFunction
	)

Definition at line 69 of file arbiter.c.

{
    NTSTATUS Status;
 
    PAGED_CODE();
 
    DPRINT("ArbiterLibInitializeInstance: '%S'\n", ArbiterName);
 
    ASSERT(Arbiter->UnpackRequirement != NULL);
    ASSERT(Arbiter->PackResource != NULL);
    ASSERT(Arbiter->UnpackResource != NULL);
    ASSERT(Arbiter->MutexEvent == NULL);
    ASSERT(Arbiter->Allocation == NULL);
    ASSERT(Arbiter->PossibleAllocation == NULL);
    ASSERT(Arbiter->AllocationStack == NULL);
 
    Arbiter->Signature = ARBITER_SIG;
    Arbiter->BusDeviceObject = BusDeviceObject;
    Arbiter->Name = ArbiterName;
    Arbiter->ResourceType = ResourceType;
    Arbiter->TransactionInProgress = FALSE;
#if (NTDDI_VERSION >= NTDDI_VISTA)
    Arbiter->OrderingName = OrderName;
#endif
 
    /* The per-instance lock: a signaled synchronization event used as a mutex. */
    Arbiter->MutexEvent = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_ARBITER);
    if (!Arbiter->MutexEvent)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }
    KeInitializeEvent(Arbiter->MutexEvent, SynchronizationEvent, TRUE);
 
#if (NTDDI_VERSION >= NTDDI_VISTA)
    /* Vista+: a notification event exposing whether a Test is outstanding. */
    Arbiter->TransactionEvent = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), TAG_ARBITER);
    if (!Arbiter->TransactionEvent)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }
    KeInitializeEvent(Arbiter->TransactionEvent, NotificationEvent, TRUE);
#endif
 
    Arbiter->AllocationStack = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, TAG_ARBITER);
    if (!Arbiter->AllocationStack)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }
    Arbiter->AllocationStackMaxSize = PAGE_SIZE;
    Arbiter->Allocation = ExAllocatePoolWithTag(PagedPool, sizeof(RTL_RANGE_LIST), TAG_ARBITER);
    if (!Arbiter->Allocation)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }
    RtlInitializeRangeList(Arbiter->Allocation);
 
    Arbiter->PossibleAllocation = ExAllocatePoolWithTag(PagedPool, sizeof(RTL_RANGE_LIST), TAG_ARBITER);
    if (!Arbiter->PossibleAllocation)
    {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Failure;
    }
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
 
    if (!Arbiter->TestAllocation)
        Arbiter->TestAllocation = ArbiterLibTestAllocation;
    if (!Arbiter->RetestAllocation)
        Arbiter->RetestAllocation = ArbiterLibRetestAllocation;
    if (!Arbiter->CommitAllocation)
        Arbiter->CommitAllocation = ArbiterLibCommitAllocation;
    if (!Arbiter->RollbackAllocation)
        Arbiter->RollbackAllocation = ArbiterLibRollbackAllocation;
    if (!Arbiter->BootAllocation)
        Arbiter->BootAllocation = ArbiterLibBootAllocation;
    if (!Arbiter->AddReserved)
        Arbiter->AddReserved = ArbiterLibAddReserved;
    if (!Arbiter->QueryConflict)
        Arbiter->QueryConflict = ArbiterLibQueryConflict;
    if (!Arbiter->QueryArbitrate)
        Arbiter->QueryArbitrate = ArbiterLibQueryArbitrate;
    if (!Arbiter->StartArbiter)
        Arbiter->StartArbiter = ArbiterLibStartArbiter;
    if (!Arbiter->PreprocessEntry)
        Arbiter->PreprocessEntry = ArbiterLibPreprocessEntry;
    if (!Arbiter->AllocateEntry)
        Arbiter->AllocateEntry = ArbiterLibAllocateEntry;
    if (!Arbiter->GetNextAllocationRange)
        Arbiter->GetNextAllocationRange = ArbiterLibGetNextAllocationRange;
    if (!Arbiter->FindSuitableRange)
        Arbiter->FindSuitableRange = ArbiterLibFindSuitableRange;
    if (!Arbiter->AddAllocation)
        Arbiter->AddAllocation = ArbiterLibAddAllocation;
    if (!Arbiter->BacktrackAllocation)
        Arbiter->BacktrackAllocation = ArbiterLibBacktrackAllocation;
    if (!Arbiter->OverrideConflict)
        Arbiter->OverrideConflict = ArbiterLibOverrideConflict;
#if (NTDDI_VERSION >= NTDDI_VISTA)
    if (!Arbiter->InitializeRangeList)
        Arbiter->InitializeRangeList = ArbiterLibInitializeRangeList;
#endif
 
    Status = ArbiterLibDefaultAssignmentOrdering(Arbiter, OrderName, OrderName, TranslateOrderingFunction);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("ArbiterLibInitializeInstance: ArbiterLibDefaultAssignmentOrdering failed, Status %X\n", Status);
        goto Failure;
    }
 
    return STATUS_SUCCESS;
 
Failure:
    DPRINT1("ArbiterLibInitializeInstance: '%S' failed, Status %X\n", ArbiterName, Status);
    ArbiterLibDeleteInstance(Arbiter);
    return Status;
}

Referenced by arbusno_Initializer(), ario_Initializer(), armem_Initializer(), IopArbBusNumberInitialize(), IopArbDmaInitialize(), IopArbIrqInitialize(), IopArbMemInitialize(), and IopArbPortInitialize().

◆ ArbiterLibInitializeRangeList()

NTSTATUS NTAPI ArbiterLibInitializeRangeList	(	_In_ PARBITER_INSTANCE	Arbiter,
		_In_ ULONG	ResourceCount,
		_In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR	Resources,
		_Inout_ PRTL_RANGE_LIST	RangeList
	)

The InitializeRangeList callback default.

Parameters

[in]	Arbiter	The arbiter instance the range list belongs to.
[in]	ResourceCount	The number of descriptors in Resources.
[in]	Resources	The CM partial resource descriptors describing the decoded windows.
[in,out]	RangeList	The range list to rebuild from the descriptors.

Returns: Returns STATUS_SUCCESS.

Definition at line 440 of file handler.c.

{
    PAGED_CODE();
    return ArbpSeedRangeList(Arbiter, ResourceCount, Resources, RangeList);
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibIsConflictWithMmConfigRange()

BOOLEAN NTAPI ArbiterLibIsConflictWithMmConfigRange	(	_In_ ULONGLONG	Start,
		_In_ ULONGLONG	End
	)

Determines whether a range overlaps the recorded MMCONFIG window.

Parameters

[in]	Start	The inclusive start of the range to test.
[in]	End	The inclusive end of the range to test.

Returns: Returns TRUE if [Start, End] overlaps the recorded window, FALSE otherwise or when no window was ever recorded.

Definition at line 689 of file ordering.c.

{
    if (ArbpMmConfigStart > ArbpMmConfigEnd)
        return FALSE;  /* No MMCONFIG window recorded */
 
    return (BOOLEAN)(Start <= ArbpMmConfigEnd && ArbpMmConfigStart <= End);
}

Referenced by ArbiterLibFindSuitableRange().

◆ ArbiterLibOverrideConflict()

BOOLEAN NTAPI ArbiterLibOverrideConflict	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	ArbState
	)

The OverrideConflict default, the last of the conflict escapes: grants a FIXED requirement whose window conflicts only with ranges the requesting device itself already owns.

Parameters

[in]	Arbiter	The arbiter instance whose tentative allocation list is walked.
[in,out]	ArbState	The allocation state of the requirement. On a grant, Start and End receive the requested window.

Returns: Returns TRUE if at least one conflicting range was found and every one of them is owned by the requesting device, FALSE if any conflict belongs to someone else (or to no one).

Remarks: A fixed requirement has one possible placement, so when re-arbitration finds that window occupied by the device's own earlier reservation, there is nowhere else to move it and the self-conflict has to be allowed.

Definition at line 48 of file range.c.

{
    RTL_RANGE_LIST_ITERATOR Iterator;
    PRTL_RANGE Range;
    BOOLEAN SelfConflictOnly = FALSE;
 
    PAGED_CODE();
 
    /*
     * Only a fixed requirement may reclaim its window. Anything else still
     * has other placements to try, and letting it overlap would hide
     * real conflicts.
     */
    if (ArbState->CurrentAlternative == NULL ||
        !(ArbState->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_FIXED))
    {
        return FALSE;
    }
 
    if (ArbState->Entry == NULL || ArbState->Entry->PhysicalDeviceObject == NULL)
        return FALSE;
 
    if (!NT_SUCCESS(RtlGetFirstRange(Arbiter->PossibleAllocation, &Iterator, &Range)))
        return FALSE;
 
    while (Range != NULL)
    {
        /* A range that overlaps the window and is not made available. */
        if (Range->Start <= ArbState->CurrentMaximum &&
            Range->End >= ArbState->CurrentMinimum &&
            !(Range->Attributes & ArbState->RangeAvailableAttributes))
        {
            if ((PDEVICE_OBJECT)Range->Owner != ArbState->Entry->PhysicalDeviceObject)
                return FALSE;
 
            SelfConflictOnly = TRUE;
            ArbState->Start = ArbState->CurrentMinimum;
            ArbState->End = ArbState->CurrentMaximum;
        }
 
        if (!NT_SUCCESS(RtlGetNextRange(&Iterator, &Range, TRUE)))
            break;
    }
 
    return SelfConflictOnly;
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibPreprocessEntry()

NTSTATUS NTAPI ArbiterLibPreprocessEntry	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_ALLOCATION_STATE	ArbState
	)

Per-entry hook invoked before each placement attempt. The library default does nothing and succeeds.

Parameters

[in]	Arbiter	The arbiter instance placing the entry.
[in,out]	ArbState	The allocation state of the entry about to be placed.

Returns: Returns STATUS_SUCCESS.

Definition at line 38 of file entry.c.

{
    PAGED_CODE();
 
    UNREFERENCED_PARAMETER(Arbiter);
    UNREFERENCED_PARAMETER(ArbState);
    return STATUS_SUCCESS;
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibQueryArbitrate()

NTSTATUS NTAPI ArbiterLibQueryArbitrate	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_QUERY_ARBITRATE_PARAMETERS	Parameters
	)

The QueryArbitrate action default: reports that this arbiter is willing to arbitrate the given list.

Parameters

[in]	Arbiter	The arbiter instance being queried.
[in,out]	Parameters	The action parameters carrying the arbitration list (pre-Vista builds receive the list directly).

Returns: Returns STATUS_SUCCESS.

Definition at line 73 of file handler.c.

{
    PAGED_CODE();
    UNREFERENCED_PARAMETER(Arbiter);
    UNREFERENCED_PARAMETER(Parameters);
    return STATUS_SUCCESS;
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibQueryConflict()

NTSTATUS NTAPI ArbiterLibQueryConflict	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_QUERY_CONFLICT_PARAMETERS	Parameters
	)

The QueryConflict action: reports which devices' committed ranges collide with a candidate resource.

Parameters

[in]	Arbiter	The arbiter instance performing the query.
[in,out]	Parameters	The action parameters carrying the device, the candidate resource and the output slots (pre-Vista builds receive them directly).

Returns: Returns the ArbpQueryConflict status.

Definition at line 937 of file transaction.c.

{
    PAGED_CODE();
    return ArbpQueryConflict(Arbiter,
                             Parameters->PhysicalDeviceObject,
                             Parameters->ConflictingResource,
                             Parameters->ConflictCount,
                             Parameters->Conflicts);
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibReleaseResources()

VOID NTAPI ArbiterLibReleaseResources	(	_In_ PARBITER_INSTANCE	Arbiter,
		_In_ PVOID	Owner
	)

Releases every committed range owned by Owner.

Parameters

[in]	Arbiter	The arbiter instance to release the ranges from.
[in]	Owner	The owning device object (a removed device's PDO).

Remarks: Without this a torn-down device's ranges stay reserved forever and later devices see phantom conflicts.

Definition at line 561 of file handler.c.

{
    PAGED_CODE();
 
    ArbpAcquireLock(Arbiter);
    RtlDeleteOwnersRanges(Arbiter->Allocation, Owner);
    ArbpReleaseLock(Arbiter);
}

◆ ArbiterLibReserveRange()

VOID NTAPI ArbiterLibReserveRange	(	_In_ PARBITER_INSTANCE	Arbiter,
		_In_ ULONGLONG	Start,
		_In_ ULONGLONG	End,
		_In_opt_ PVOID	Owner,
		_In_ BOOLEAN	Shared
	)

Commits a single [Start, End] range into the arbiter as an ordinary allocation owned by Owner.

Parameters

[in]	Arbiter	The arbiter instance to reserve the range in.
[in]	Start	The first address (or unit) of the range.
[in]	End	The last address (or unit) of the range, inclusive.
[in]	Owner	The owning device object, or NULL for a system reservation.
[in]	Shared	TRUE if the range may be shared with other shareable owners.

Remarks: Used to record resources assigned outside the PnP transaction (e.g. a legacy device's IoAssignResources), so later arbitration sees them. Unlike a boot reservation this carries no BOOT_ALLOCATED attribute, so it is not treated as reclaimable.

Definition at line 528 of file handler.c.

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

◆ ArbiterLibRetestAllocation()

NTSTATUS NTAPI ArbiterLibRetestAllocation	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_RETEST_ALLOCATION_PARAMETERS	Parameters
	)

The RetestAllocation action: deterministically re-establishes the placements a previous test chose, without searching.

Parameters

[in]	Arbiter	The arbiter instance performing the retest.
[in,out]	Parameters	The action parameters carrying the arbitration list (pre-Vista builds receive the list directly).

Returns: Returns the ArbpRetestAllocation status.

Definition at line 483 of file transaction.c.

{
    PAGED_CODE();
    return ArbpRetestAllocation(Arbiter, Parameters->ArbitrationList);
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibRollbackAllocation()

NTSTATUS NTAPI ArbiterLibRollbackAllocation ( _In_ PARBITER_INSTANCE Arbiter )

The RollbackAllocation action: discards the tentative allocation; the committed one is untouched.

Parameters

[in] Arbiter The arbiter instance whose transaction is rolled back.

Returns: Returns STATUS_SUCCESS.

Definition at line 543 of file transaction.c.

{
    PAGED_CODE();
 
    RtlFreeRangeList(Arbiter->PossibleAllocation);
    RtlInitializeRangeList(Arbiter->PossibleAllocation);
    return STATUS_SUCCESS;
}

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibSortArbitrationList()

NTSTATUS NTAPI ArbiterLibSortArbitrationList ( _Inout_ PLIST_ENTRY ArbitrationList )

Orders an arbitration list most-constrained first, so fixed requirements are placed before flexible ones can steal their ranges.

Parameters

[in,out] ArbitrationList The list of ARBITER_LIST_ENTRY nodes to sort, keyed on the WorkSpace constrainedness score in ascending order. The sort is stable: equally scored entries keep their relative order.

Returns: Returns STATUS_SUCCESS.

Remarks: Without this ordering a wide requirement placed first keeps landing on the one range a later fixed requirement must have, forcing a backtrack for every such collision.

Definition at line 71 of file entry.c.

{
    LIST_ENTRY Sorted;
 
    PAGED_CODE();
 
    InitializeListHead(&Sorted);
 
    while (!IsListEmpty(ArbitrationList))
    {
        PLIST_ENTRY ListEntry = RemoveHeadList(ArbitrationList);
        PARBITER_LIST_ENTRY Entry = CONTAINING_RECORD(ListEntry, ARBITER_LIST_ENTRY, ListEntry);
        PLIST_ENTRY Position;
 
        for (Position = Sorted.Flink; Position != &Sorted; Position = Position->Flink)
        {
            if (CONTAINING_RECORD(Position, ARBITER_LIST_ENTRY, ListEntry)->WorkSpace >
                Entry->WorkSpace)
            {
                break;
            }
        }
 
        InsertTailList(Position, ListEntry);  /* Insert before Position */
    }
 
    /* Return the data back to ArbitrationList! */
    if (!IsListEmpty(&Sorted))
    {
        ArbitrationList->Flink = Sorted.Flink;
        Sorted.Flink->Blink = ArbitrationList;
        ArbitrationList->Blink = Sorted.Blink;
        Sorted.Blink->Flink = ArbitrationList;
    }
 
    return STATUS_SUCCESS;
}

Referenced by ArbpTestAllocation().

◆ ArbiterLibStartArbiter()

NTSTATUS NTAPI ArbiterLibStartArbiter	(	_In_ PARBITER_INSTANCE	Arbiter,
		_In_ PCM_RESOURCE_LIST	StartResources
	)

The StartArbiter action default: seeds the committed allocation with the windows the bus decodes, so arbitration starts from the hardware's real extent.

Parameters

[in]	Arbiter	The arbiter instance being started.
[in]	StartResources	The bus's decoded resources; NULL or empty means nothing to seed.

Returns: Returns the range-list initialization status.

Definition at line 470 of file handler.c.

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

Referenced by ArbiterLibInitializeInstance().

◆ ArbiterLibTestAllocation()

NTSTATUS NTAPI ArbiterLibTestAllocation	(	_In_ PARBITER_INSTANCE	Arbiter,
		_Inout_ PARBITER_TEST_ALLOCATION_PARAMETERS	Parameters
	)

The TestAllocation action: tentatively places every entry of the arbitration list, leaving the solution in PossibleAllocation for a later commit or rollback.

Parameters

[in]	Arbiter	The arbiter instance performing the test.
[in,out]	Parameters	The action parameters carrying the arbitration list (pre-Vista builds receive the list directly).

Returns: Returns the ArbpTestAllocation status.

Definition at line 447 of file transaction.c.

{
    PAGED_CODE();
    return ArbpTestAllocation(Arbiter, Parameters->ArbitrationList);
}

Referenced by ArbiterLibInitializeInstance().

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ ARBITER_ALTERNATIVE_FLAG_BADRANGE

◆ ARBITER_ALTERNATIVE_FLAG_FIXED

◆ ARBITER_ALTERNATIVE_FLAG_INACCESSIBLE_OK

◆ ARBITER_ALTERNATIVE_FLAG_SHARED

◆ ARBITER_MAXIMUM_ADDRESS

◆ ARBITER_PRIORITY_EXHAUSTED

◆ ARBITER_PRIORITY_NULL

◆ ARBITER_PRIORITY_PREFERRED_RESERVED

◆ ARBITER_PRIORITY_RESERVED

◆ ARBITER_RANGE_BOOT_ALLOCATED

◆ ARBITER_RANGE_INACCESSIBLE

◆ ARBITER_RANGE_PORT_ALIAS

◆ ARBITER_RANGE_SHARED_DRIVER

◆ ARBITER_STATE_FLAG_BOOT

◆ ARBITER_STATE_FLAG_MCFG_CONFLICT

◆ ARBITER_STATE_FLAG_NULL_CONFLICT_OK

◆ ARBITER_STATE_FLAG_WORKSPACE

◆ TAG_ARBITER

Typedef Documentation

◆ ARBITER_ALLOCATION_STATE

◆ ARBITER_ALTERNATIVE

◆ ARBITER_INSTANCE

◆ ARBITER_ORDERING

◆ ARBITER_ORDERING_LIST

◆ PARB_ADD_ALLOCATION

◆ PARB_ADD_RESERVED

◆ PARB_ALLOCATE_ENTRY

◆ PARB_BACKTRACK_ALLOCATION

◆ PARB_BOOT_ALLOCATION

◆ PARB_COMMIT_ALLOCATION

◆ PARB_FIND_SUITABLE_RANGE

◆ PARB_GET_NEXT_ALLOCATION_RANGE

◆ PARB_INITIALIZE_RANGE_LIST

◆ PARB_OVERRIDE_CONFLICT

◆ PARB_PACK_RESOURCE

◆ PARB_PREPROCESS_ENTRY

◆ PARB_QUERY_ARBITRATE

◆ PARB_QUERY_CONFLICT

◆ PARB_RETEST_ALLOCATION

◆ PARB_ROLLBACK_ALLOCATION

◆ PARB_SCORE_REQUIREMENT

◆ PARB_START_ARBITER

◆ PARB_TEST_ALLOCATION

◆ PARB_TRANSLATE_ORDERING

◆ PARB_UNPACK_REQUIREMENT

◆ PARB_UNPACK_RESOURCE

◆ PARBITER_ALLOCATION_STATE

◆ PARBITER_ALTERNATIVE

◆ PARBITER_INSTANCE

◆ PARBITER_ORDERING

◆ PARBITER_ORDERING_LIST

Function Documentation

◆ ArbiterLibAddAllocation()

◆ ArbiterLibAddInaccessibleAllocationRange()

◆ ArbiterLibAddMmConfigRangeAsBootReserved()

◆ ArbiterLibAddOrdering()

◆ ArbiterLibAddReserved()

◆ ArbiterLibAllocateEntry()

◆ ArbiterLibBacktrackAllocation()

◆ ArbiterLibBootAllocation()

◆ ArbiterLibCommitAllocation()

◆ ArbiterLibDefaultAssignmentOrdering()

◆ ArbiterLibDeleteInstance()

◆ ArbiterLibFindSuitableRange()

◆ ArbiterLibFreeOrderingList()

◆ ArbiterLibGetNextAllocationRange()

◆ ArbiterLibHandler()

◆ ArbiterLibInitializeInstance()

◆ ArbiterLibInitializeRangeList()

◆ ArbiterLibIsConflictWithMmConfigRange()

◆ ArbiterLibOverrideConflict()

◆ ArbiterLibPreprocessEntry()

◆ ArbiterLibQueryArbitrate()

◆ ArbiterLibQueryConflict()

◆ ArbiterLibReleaseResources()