arbiter.c File Reference

#include "arbp.h"

Go to the source code of this file.

Defines
#define	ALLOW_BOOT_ALLOC_CONFLICTS   1
#define	PLUG_FEST_HACKS   0
#define	ARBITER_ALLOCATION_STATE_TAG   'AbrA'
#define	ARBITER_ORDERING_LIST_TAG   'LbrA'
#define	ARBITER_MISC_TAG   'MbrA'
#define	ARBITER_RANGE_LIST_TAG   'RbrA'
#define	ARBITER_CONFLICT_INFO_TAG   'CbrA'
#define	PATH_ARBITERS   L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Arbiters"
#define	KEY_ALLOCATIONORDER   L"AllocationOrder"
#define	KEY_RESERVEDRESOURCES   L"ReservedResources"
#define	ARBITER_ORDERING_GROW_SIZE   8
#define	FULL_INFO_DATA(k)   ((PCHAR)(k) + (k)->DataOffset)
#define	DISJOINT(s1, e1, s2, e2)
#define	ArbpWstrToUnicodeString(u, p)
#define	ORDERING_INDEX_FROM_PRIORITY(P)   ( (ULONG) ( (P) > 0 ? (P) - 1 : ((P) * -1) - 1) )
#define	ARBITER_ORDERING_LIST_INITIAL_SIZE   16
Functions
NTSTATUS	ArbpBuildAllocationStack (IN PARBITER_INSTANCE Arbiter, IN PLIST_ENTRY ArbitrationList, IN ULONG ArbitrationListCount)
NTSTATUS	ArbpGetRegistryValue (IN HANDLE KeyHandle, IN PWSTR ValueName, OUT PKEY_VALUE_FULL_INFORMATION *Information)
NTSTATUS	ArbpBuildAlternative (IN PARBITER_INSTANCE Arbiter, IN PIO_RESOURCE_DESCRIPTOR Requirement, OUT PARBITER_ALTERNATIVE Alternative)
VOID	ArbpUpdatePriority (PARBITER_INSTANCE Arbiter, PARBITER_ALTERNATIVE Alternative)
BOOLEAN	ArbpQueryConflictCallback (IN PVOID Context, IN PRTL_RANGE Range)
NTSTATUS	ArbInitializeArbiterInstance (OUT PARBITER_INSTANCE Arbiter, IN PDEVICE_OBJECT BusDeviceObject, IN CM_RESOURCE_TYPE ResourceType, IN PWSTR Name, IN PWSTR OrderingName, IN PARBITER_TRANSLATE_ALLOCATION_ORDER TranslateOrdering OPTIONAL)
VOID	ArbReferenceArbiterInstance (IN PARBITER_INSTANCE Arbiter)
VOID	ArbDereferenceArbiterInstance (IN PARBITER_INSTANCE Arbiter)
VOID	ArbDeleteArbiterInstance (IN PARBITER_INSTANCE Arbiter)
NTSTATUS	ArbTestAllocation (IN PARBITER_INSTANCE Arbiter, IN OUT PLIST_ENTRY ArbitrationList)
NTSTATUS	ArbSortArbitrationList (IN OUT PLIST_ENTRY ArbitrationList)
NTSTATUS	ArbCommitAllocation (PARBITER_INSTANCE Arbiter)
NTSTATUS	ArbRollbackAllocation (IN PARBITER_INSTANCE Arbiter)
NTSTATUS	ArbRetestAllocation (IN PARBITER_INSTANCE Arbiter, IN OUT PLIST_ENTRY ArbitrationList)
NTSTATUS	ArbBootAllocation (IN PARBITER_INSTANCE Arbiter, IN OUT PLIST_ENTRY ArbitrationList)
NTSTATUS	ArbArbiterHandler (IN PVOID Context, IN ARBITER_ACTION Action, IN OUT PARBITER_PARAMETERS Params)
NTSTATUS	ArbBuildAssignmentOrdering (IN OUT PARBITER_INSTANCE Arbiter, IN PWSTR AllocationOrderName, IN PWSTR ReservedResourcesName, IN PARBITER_TRANSLATE_ALLOCATION_ORDER Translate OPTIONAL)
BOOLEAN	ArbFindSuitableRange (PARBITER_INSTANCE Arbiter, PARBITER_ALLOCATION_STATE State)
VOID	ArbAddAllocation (IN PARBITER_INSTANCE Arbiter, IN PARBITER_ALLOCATION_STATE State)
VOID	ArbBacktrackAllocation (IN PARBITER_INSTANCE Arbiter, IN PARBITER_ALLOCATION_STATE State)
NTSTATUS	ArbPreprocessEntry (IN PARBITER_INSTANCE Arbiter, IN PARBITER_ALLOCATION_STATE State)
NTSTATUS	ArbAllocateEntry (IN PARBITER_INSTANCE Arbiter, IN PARBITER_ALLOCATION_STATE State)
BOOLEAN	ArbGetNextAllocationRange (IN PARBITER_INSTANCE Arbiter, IN OUT PARBITER_ALLOCATION_STATE State)
NTSTATUS	ArbInitializeOrderingList (IN OUT PARBITER_ORDERING_LIST List)
NTSTATUS	ArbCopyOrderingList (OUT PARBITER_ORDERING_LIST Destination, IN PARBITER_ORDERING_LIST Source)
NTSTATUS	ArbAddOrdering (OUT PARBITER_ORDERING_LIST List, IN ULONGLONG Start, IN ULONGLONG End)
NTSTATUS	ArbPruneOrdering (IN OUT PARBITER_ORDERING_LIST OrderingList, IN ULONGLONG Start, IN ULONGLONG End)
VOID	ArbFreeOrderingList (IN PARBITER_ORDERING_LIST List)
BOOLEAN	ArbOverrideConflict (IN PARBITER_INSTANCE Arbiter, IN PARBITER_ALLOCATION_STATE State)
NTSTATUS	ArbAddReserved (IN PARBITER_INSTANCE Arbiter, IN PIO_RESOURCE_DESCRIPTOR Requirement OPTIONAL, IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Resource OPTIONAL)
NTSTATUS	ArbQueryConflict (IN PARBITER_INSTANCE Arbiter, IN PDEVICE_OBJECT PhysicalDeviceObject, IN PIO_RESOURCE_DESCRIPTOR ConflictingResource, OUT PULONG ConflictCount, OUT PARBITER_CONFLICT_INFO *Conflicts)
NTSTATUS	ArbStartArbiter (IN PARBITER_INSTANCE Arbiter, IN PCM_RESOURCE_LIST StartResources)
VOID	ArbpIndent (IN ULONG Count)

---

Define Documentation

#define ALLOW_BOOT_ALLOC_CONFLICTS   1

Definition at line 32 of file arbiter.c.

#define ARBITER_ALLOCATION_STATE_TAG   'AbrA'

Definition at line 39 of file arbiter.c. Referenced by ArbInitializeArbiterInstance(), and ArbpBuildAllocationStack().

#define ARBITER_CONFLICT_INFO_TAG   'CbrA'

Definition at line 43 of file arbiter.c. Referenced by ArbQueryConflict().

#define ARBITER_MISC_TAG   'MbrA'

Definition at line 41 of file arbiter.c. Referenced by ArbInitializeArbiterInstance(), and ArbpGetRegistryValue().

#define ARBITER_ORDERING_GROW_SIZE   8

Definition at line 52 of file arbiter.c. Referenced by ArbAddOrdering().

#define ARBITER_ORDERING_LIST_INITIAL_SIZE   16

Definition at line 2924 of file arbiter.c. Referenced by ArbInitializeOrderingList().

#define ARBITER_ORDERING_LIST_TAG   'LbrA'

Definition at line 40 of file arbiter.c. Referenced by ArbAddOrdering(), ArbCopyOrderingList(), ArbInitializeOrderingList(), and ArbPruneOrdering().

#define ARBITER_RANGE_LIST_TAG   'RbrA'

Definition at line 42 of file arbiter.c. Referenced by ArbInitializeArbiterInstance().

#define ArbpWstrToUnicodeString (  u, p   )

Value: (u)->Length = ((u)->MaximumLength = \ (USHORT) (sizeof((p))) - sizeof(WCHAR)); \ (u)->Buffer = (p) Definition at line 92 of file arbiter.c. Referenced by ArbBuildAssignmentOrdering().

#define DISJOINT (  s1, e1, s2, e2   )

Value: ( ((s1) < (s2) && (e1) < (s2)) \ ||((s2) < (s1) && (e2) < (s1)) ) Definition at line 80 of file arbiter.c.

#define FULL_INFO_DATA (  k   )     ((PCHAR)(k) + (k)->DataOffset)

Definition at line 69 of file arbiter.c. Referenced by ArbBuildAssignmentOrdering().

#define KEY_ALLOCATIONORDER   L"AllocationOrder"

Definition at line 50 of file arbiter.c. Referenced by ArbBuildAssignmentOrdering().

#define KEY_RESERVEDRESOURCES   L"ReservedResources"

Definition at line 51 of file arbiter.c. Referenced by ArbBuildAssignmentOrdering().

#define ORDERING_INDEX_FROM_PRIORITY (  P   )     ( (ULONG) ( (P) > 0 ? (P) - 1 : ((P) * -1) - 1) )

Definition at line 104 of file arbiter.c. Referenced by ArbGetNextAllocationRange(), and ArbpUpdatePriority().

#define PATH_ARBITERS   L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Arbiters"

Definition at line 49 of file arbiter.c. Referenced by ArbBuildAssignmentOrdering().

#define PLUG_FEST_HACKS   0

Definition at line 33 of file arbiter.c.

---

Function Documentation

VOID ArbAddAllocation (  IN PARBITER_INSTANCE  Arbiter, IN PARBITER_ALLOCATION_STATE  State )

Definition at line 2189 of file arbiter.c. References ARBITER_ALTERNATIVE_FLAG_SHARED, ASSERT, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, and RtlAddRange(). Referenced by ArbInitializeArbiterInstance(). : This routine is called from AllocateEntry once we have found a possible solution (State->Start - State->End). It adds the ranges that will not be available if we commit to this solution to Arbiter->PossibleAllocation. Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: None. --*/ { NTSTATUS status; PAGED_CODE(); status = RtlAddRange( Arbiter->PossibleAllocation, State->Start, State->End, State->RangeAttributes, RTL_RANGE_LIST_ADD_IF_CONFLICT + (State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED ? RTL_RANGE_LIST_ADD_SHARED : 0), NULL, State->Entry->PhysicalDeviceObject ); ASSERT(NT_SUCCESS(status)); }

NTSTATUS ArbAddOrdering (  OUT PARBITER_ORDERING_LIST  List, IN ULONGLONG  Start, IN ULONGLONG  End )

Definition at line 3028 of file arbiter.c. References ARBITER_ORDERING, ARBITER_ORDERING_GROW_SIZE, ARBITER_ORDERING_LIST_TAG, ASSERT, End, ExAllocatePoolWithTag, ExFreePool(), List, PagedPool, and Start. Referenced by ArbBuildAssignmentOrdering(). : This routine adds the range Start-End to the end of the ordering list. No checking for overlaps or pruning is done (see ArbpPruneOrdering) Arguments: OrderingList - The list where the range should be added. Start - The start of the range to be added. End - The end of the range to be added. Return Value: Status code that indicates whether or not the function was successful. --*/ { // // Validate parameters // if (End < Start) { return STATUS_INVALID_PARAMETER; } // // Check if the buffer is full // if (List->Count == List->Maximum) { PARBITER_ORDERING temp; // // Out of space - grow the buffer // temp = ExAllocatePoolWithTag(PagedPool, (List->Count + ARBITER_ORDERING_GROW_SIZE) * sizeof(ARBITER_ORDERING), ARBITER_ORDERING_LIST_TAG ); if (!temp) { return STATUS_INSUFFICIENT_RESOURCES; } // // If we had any orderings copy them // if (List->Orderings) { RtlCopyMemory(temp, List->Orderings, List->Count * sizeof(ARBITER_ORDERING) ); ExFreePool(List->Orderings); } List->Maximum += ARBITER_ORDERING_GROW_SIZE; List->Orderings = temp; } // // Add the entry to the list // List->Orderings[List->Count].Start = Start; List->Orderings[List->Count].End = End; List->Count++; ASSERT(List->Count <= List->Maximum); return STATUS_SUCCESS; }

NTSTATUS ArbAddReserved (  IN PARBITER_INSTANCE  Arbiter, IN PIO_RESOURCE_DESCRIPTOR Requirement  OPTIONAL, IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Resource  OPTIONAL )

Definition at line 3630 of file arbiter.c. References PAGED_CODE. Referenced by ArbInitializeArbiterInstance(). { PAGED_CODE(); return STATUS_NOT_SUPPORTED; }

NTSTATUS ArbAllocateEntry (  IN PARBITER_INSTANCE  Arbiter, IN PARBITER_ALLOCATION_STATE  State )

Definition at line 2325 of file arbiter.c. References ARB_INDENT, ARB_PRINT, ARBITER_ALTERNATIVE_FLAG_SHARED, ArbiterResultNullRequest, ASSERT, _ARBITER_LIST_ENTRY::Assignment, _ARBITER_ALLOCATION_STATE::CurrentAlternative, _ARBITER_ALLOCATION_STATE::CurrentMaximum, _ARBITER_ALLOCATION_STATE::CurrentMinimum, _ARBITER_ALTERNATIVE::Descriptor, _ARBITER_ALLOCATION_STATE::End, _ARBITER_ALLOCATION_STATE::Entry, FALSE, _ARBITER_ALTERNATIVE::Flags, _ARBITER_ALTERNATIVE::Length, _ARBITER_ALTERNATIVE::Minimum, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, _ARBITER_LIST_ENTRY::PhysicalDeviceObject, _ARBITER_LIST_ENTRY::Result, _ARBITER_LIST_ENTRY::SelectedAlternative, _ARBITER_ALLOCATION_STATE::Start, and TRUE. Referenced by ArbInitializeArbiterInstance(). : This is the core arbitration routine and is called from TestAllocation to allocate resources for all of the entries in the allocation stack. It calls off to various helper routines (described above) to perform this task. Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: None. --*/ { NTSTATUS status; PARBITER_ALLOCATION_STATE currentState = State; BOOLEAN backtracking = FALSE; PAGED_CODE(); // // Have we reached the end of the list? If so then we have a working // allocation. // tryAllocation: while(currentState >= State && currentState->Entry != NULL) { // // Do any preprocessing that is required // status = Arbiter->PreprocessEntry(Arbiter,currentState); if (!NT_SUCCESS(status)) { return status; } // // If we need to backtrack do so! // if (backtracking) { ULONGLONG possibleCurrentMinimum; backtracking = FALSE; // // Clear the CurrentAlternative of the *next* alternative - this will // cause the priorities to be recalculated next time through so we // will attempt to explore the search space again // // The currentState+1 is guaranteed to be safe because the only way // we can get here is from where we currentState-- below. // (currentState + 1)->CurrentAlternative = NULL; // // We can't backtrack length 0 requests because there is nothing to // backtrack so we would get stuck in an inifinite loop... // if (currentState->CurrentAlternative->Length == 0) { goto failAllocation; } // // Backtrack // Arbiter->BacktrackAllocation(Arbiter, currentState); // // Reduce allocation window to not include the range we backtracked // and check that that doesn't underflow the minimum or wrap // possibleCurrentMinimum = currentState->Start - 1; if (possibleCurrentMinimum > currentState->CurrentMinimum // wrapped || possibleCurrentMinimum < currentState->CurrentAlternative->Minimum) { // // We have run out space in this alternative move on to the next // goto continueWithNextAllocationRange; } else { currentState->CurrentMaximum = possibleCurrentMinimum; // // Get back into arbitrating at the right point // goto continueWithNextSuitableRange; } } // // Try to allocate for this entry // continueWithNextAllocationRange: while (Arbiter->GetNextAllocationRange(Arbiter, currentState)) { ARB_INDENT(2, (ULONG)(currentState - State)); ARB_PRINT(2, ("Testing 0x%I64x-0x%I64x %s\n", currentState->CurrentMinimum, currentState->CurrentMaximum, currentState->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED ? "shared" : "non-shared" )); continueWithNextSuitableRange: while (Arbiter->FindSuitableRange(Arbiter, currentState)) { // // We found a possible solution // ARB_INDENT(2, (ULONG)(currentState - State)); if (currentState->CurrentAlternative->Length != 0) { ARB_PRINT(2, ("Possible solution for %p = 0x%I64x-0x%I64x, %s\n", currentState->Entry->PhysicalDeviceObject, currentState->Start, currentState->End, currentState->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED ? "shared" : "non-shared" )); // // Update the arbiter with the possible allocation // Arbiter->AddAllocation(Arbiter, currentState); } else { ARB_PRINT(2, ("Zero length solution solution for %p = 0x%I64x-0x%I64x, %s\n", currentState->Entry->PhysicalDeviceObject, currentState->Start, currentState->End, currentState->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED ? "shared" : "non-shared" )); // // Set the result in the arbiter appropriatley so that we // don't try and translate this zero requirement - it won't! // currentState->Entry->Result = ArbiterResultNullRequest; } // // Move on to the next entry // currentState++; goto tryAllocation; } } failAllocation: // // We couldn't allocate for this device // if (currentState == State) { // // We are at the top of the allocation stack to we can't backtrack - // *** GAME OVER *** // return STATUS_UNSUCCESSFUL; } else { // // Backtrack and try again // ARB_INDENT(2, (ULONG)(currentState - State)); ARB_PRINT(2, ("Allocation failed for %p - backtracking\n", currentState->Entry->PhysicalDeviceObject )); backtracking = TRUE; // // Pop the last state off the stack and try a different path // currentState--; goto tryAllocation; } } // // We have successfully allocated for all ranges so fill in the allocation // currentState = State; while (currentState->Entry != NULL) { status = Arbiter->PackResource( currentState->CurrentAlternative->Descriptor, currentState->Start, currentState->Entry->Assignment ); ASSERT(NT_SUCCESS(status)); // // Remember the alternative we chose from so we can retrieve it during retest // currentState->Entry->SelectedAlternative = currentState->CurrentAlternative->Descriptor; ARB_PRINT(2, ("Assigned - 0x%I64x-0x%I64x\n", currentState->Start, currentState->End )); currentState++; } return STATUS_SUCCESS; }

NTSTATUS ArbArbiterHandler (  IN PVOID  Context, IN ARBITER_ACTION  Action, IN OUT PARBITER_PARAMETERS  Params )

Definition at line 1414 of file arbiter.c. References Action, ARB_PRINT, ArbAcquireArbiterLock, ARBITER_ACTION, ARBITER_INSTANCE_SIGNATURE, ArbiterActionAddReserved, ArbiterActionBootAllocation, ArbiterActionCommitAllocation, ArbiterActionQueryAllocatedResources, ArbiterActionQueryArbitrate, ArbiterActionQueryConflict, ArbiterActionRetestAllocation, ArbiterActionRollbackAllocation, ArbiterActionTestAllocation, ArbiterActionWriteReservedResources, ArbpActionStrings, ArbReleaseArbiterLock, ArbReplayOnError, ArbStopOnError, ASSERT, FALSE, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PARBITER_INSTANCE, PARBITER_PARAMETERS, and TRUE. Referenced by IopPnPDispatch(). : This provides the default entry point to an arbiter. Parameters: Context - The context provided in the interface where this function was called from. This is converted to an ARBITER_INSTANCE using the ARBITER_CONTEXT_TO_INSTANCE macro which should be defined. Action - The action the arbiter should perform. Params - The parameters for the action. Return Value: Status code that indicates whether or not the function was successful. Note: The routines which implement each action are determined from the dispatch table in the arbiter instance. --*/ { NTSTATUS status; PARBITER_INSTANCE arbiter = Context; PAGED_CODE(); ASSERT(Context); ASSERT(Action >= 0 && Action <= ArbiterActionBootAllocation); ASSERT(arbiter->Signature == ARBITER_INSTANCE_SIGNATURE); // // Acquire the state lock // ArbAcquireArbiterLock(arbiter); // // Announce ourselves // ARB_PRINT(2, ("%s %S\n", ArbpActionStrings[Action], arbiter->Name )); // // Check the transaction flag // if (Action == ArbiterActionTestAllocation || Action == ArbiterActionRetestAllocation || Action == ArbiterActionBootAllocation) { ASSERT(!arbiter->TransactionInProgress); } else if (Action == ArbiterActionCommitAllocation || Action == ArbiterActionRollbackAllocation) { ASSERT(arbiter->TransactionInProgress); } #if ARB_DBG replay: #endif // // Do the appropriate thing // switch (Action) { case ArbiterActionTestAllocation: // // Suballocation can not occur for a root arbiter // BUGBUG - this should be generalised // ASSERT(Params->Parameters.TestAllocation.AllocateFromCount == 0); ASSERT(Params->Parameters.TestAllocation.AllocateFrom == NULL); status = arbiter->TestAllocation( arbiter, Params->Parameters.TestAllocation.ArbitrationList ); break; case ArbiterActionRetestAllocation: // // Suballocation can not occur for a root arbiter // BUGBUG - this should be generalised // ASSERT(Params->Parameters.TestAllocation.AllocateFromCount == 0); ASSERT(Params->Parameters.TestAllocation.AllocateFrom == NULL); status = arbiter->RetestAllocation( arbiter, Params->Parameters.TestAllocation.ArbitrationList ); break; case ArbiterActionCommitAllocation: status = arbiter->CommitAllocation(arbiter); break; case ArbiterActionRollbackAllocation: status = arbiter->RollbackAllocation(arbiter); break; case ArbiterActionBootAllocation: status = arbiter->BootAllocation( arbiter, Params->Parameters.BootAllocation.ArbitrationList ); break; case ArbiterActionQueryConflict: status = arbiter->QueryConflict( arbiter, Params->Parameters.QueryConflict.PhysicalDeviceObject, Params->Parameters.QueryConflict.ConflictingResource, Params->Parameters.QueryConflict.ConflictCount, Params->Parameters.QueryConflict.Conflicts ); break; case ArbiterActionQueryArbitrate: case ArbiterActionQueryAllocatedResources: case ArbiterActionWriteReservedResources: case ArbiterActionAddReserved: status = STATUS_NOT_IMPLEMENTED; break; default: status = STATUS_INVALID_PARAMETER; break; } #if ARB_DBG // // Check if we failed and want to stop or replay on errors // if (!NT_SUCCESS(status)) { ARB_PRINT(1, ("*** %s for %S FAILED status = %08x\n", ArbpActionStrings[Action], arbiter->Name, status )); if (ArbStopOnError) { DbgBreakPoint(); } if (ArbReplayOnError) { goto replay; } } #endif // ARB_DBG if (NT_SUCCESS(status)) { if (Action == ArbiterActionTestAllocation || Action == ArbiterActionRetestAllocation) { arbiter->TransactionInProgress = TRUE; } else if (Action == ArbiterActionCommitAllocation || Action == ArbiterActionRollbackAllocation) { arbiter->TransactionInProgress = FALSE; } } ArbReleaseArbiterLock(arbiter); return status; }

VOID ArbBacktrackAllocation (  IN PARBITER_INSTANCE  Arbiter, IN PARBITER_ALLOCATION_STATE  State )

Definition at line 2238 of file arbiter.c. References ARB_PRINT, ASSERT, NT_SUCCESS, NTSTATUS(), PAGED_CODE, and RtlDeleteRange(). Referenced by ArbInitializeArbiterInstance(), and IopPortBacktrackAllocation(). : This routine is called from AllocateEntry if the possible solution (State->Start - State->End) does not allow us to allocate resources to the rest of the devices being considered. It deletes the ranges that were added to Arbiter->PossibleAllocation by AddAllocation. Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: None. --*/ { NTSTATUS status; PAGED_CODE(); // // We couldn't allocate for the rest of the ranges then // backtrack // status = RtlDeleteRange( Arbiter->PossibleAllocation, State->Start, State->End, State->Entry->PhysicalDeviceObject ); ASSERT(NT_SUCCESS(status)); ARB_PRINT(2, ("\t\tBacktracking on 0x%I64x-0x%I64x for %p\n", State->Start, State->End, State->Entry->PhysicalDeviceObject )); }

NTSTATUS ArbBootAllocation (  IN PARBITER_INSTANCE  Arbiter, IN OUT PLIST_ENTRY  ArbitrationList )

Definition at line 1252 of file arbiter.c. References _ARBITER_ALTERNATIVE::Alignment, _ARBITER_ALLOCATION_STATE::AlternativeCount, _ARBITER_LIST_ENTRY::AlternativeCount, _ARBITER_ALLOCATION_STATE::Alternatives, _ARBITER_LIST_ENTRY::Alternatives, ARB_PRINT, ARBITER_ALTERNATIVE_FLAG_FIXED, ARBITER_ALTERNATIVE_FLAG_INVALID, ARBITER_ALTERNATIVE_FLAG_SHARED, ARBITER_RANGE_BOOT_ALLOCATED, ARBITER_STATE_FLAG_BOOT, ArbpBuildAlternative(), ASSERT, _ARBITER_ALLOCATION_STATE::CurrentAlternative, _ARBITER_ALLOCATION_STATE::End, _ARBITER_ALLOCATION_STATE::Entry, _ARBITER_ALLOCATION_STATE::Flags, _ARBITER_ALTERNATIVE::Flags, FOR_ALL_IN_LIST, _ARBITER_ALTERNATIVE::Length, LENGTH_OF, _ARBITER_ALTERNATIVE::Maximum, _ARBITER_ALTERNATIVE::Minimum, NT_SUCCESS, NTSTATUS(), _ARBITER_LIST_ENTRY::PhysicalDeviceObject, _ARBITER_ALLOCATION_STATE::RangeAttributes, _ARBITER_ALLOCATION_STATE::RangeAvailableAttributes, RtlCopyRangeList(), RtlFreeRangeList(), _ARBITER_ALLOCATION_STATE::Start, and _ARBITER_ALLOCATION_STATE::WorkSpace. Referenced by ArbInitializeArbiterInstance(). : This provides the default implementation of the BootAllocation action. It walks the arbitration list and updates the allocation to reflect the fact that the allocation entries in the list are in use. Parameters: Arbiter - The arbiter instance data for the arbiter being called. ArbitrationList - A list of ARBITER_LIST_ENTRY entries which contain the requirements and associated devices. Each device should have one and only one requirement reflecting the resources it is currently consuming. Return Value: Status code that indicates whether or not the function was successful. --*/ { NTSTATUS status; PARBITER_LIST_ENTRY current; PRTL_RANGE_LIST temp; ARBITER_ALLOCATION_STATE state; ARBITER_ALTERNATIVE alternative; // // Initialize the state // RtlZeroMemory(&state, sizeof(ARBITER_ALLOCATION_STATE)); RtlZeroMemory(&alternative, sizeof(ARBITER_ALTERNATIVE)); state.AlternativeCount = 1; state.Alternatives = &alternative; state.CurrentAlternative = &alternative; state.Flags = ARBITER_STATE_FLAG_BOOT; state.RangeAttributes = ARBITER_RANGE_BOOT_ALLOCATED; // // Work on the possible allocation list // status = RtlCopyRangeList(Arbiter->PossibleAllocation, Arbiter->Allocation); FOR_ALL_IN_LIST(ARBITER_LIST_ENTRY, ArbitrationList, current) { ASSERT(current->AlternativeCount == 1); ASSERT(current->PhysicalDeviceObject); // // Build an alternative and state structure for this allocation and // add it to the range list // state.Entry = current; // // Initialize the alternative // status = ArbpBuildAlternative(Arbiter, &current->Alternatives[0], &alternative ); ASSERT(NT_SUCCESS(status)); ASSERT(alternative.Flags & (ARBITER_ALTERNATIVE_FLAG_FIXED | ARBITER_ALTERNATIVE_FLAG_INVALID) ); state.Start = alternative.Minimum; state.End = alternative.Maximum; // // Blow away the old workspace and masks // state.WorkSpace = 0; state.RangeAvailableAttributes = 0; // // Validate the requirement // if (alternative.Length == 0 || alternative.Alignment == 0 || state.End < state.Start || state.Start % alternative.Alignment != 0 || LENGTH_OF(state.Start, state.End) != alternative.Length) { ARB_PRINT(1, ("Skipping invalid boot allocation 0x%I64x-0x%I64x L 0x%x A 0x%x for 0x%08x\n", state.Start, state.End, alternative.Length, alternative.Alignment, current->PhysicalDeviceObject )); continue; } #if PLUG_FEST_HACKS if (alternative.Flags & ARBITER_ALTERNATIVE_FLAG_SHARED) { ARB_PRINT(1, ("Skipping shared boot allocation 0x%I64x-0x%I64x L 0x%x A 0x%x for 0x%08x\n", state.Start, state.End, alternative.Length, alternative.Alignment, current->PhysicalDeviceObject )); continue; } #endif // // Do any preprocessing that is required // status = Arbiter->PreprocessEntry(Arbiter,&state); if (!NT_SUCCESS(status)) { goto cleanup;; } Arbiter->AddAllocation(Arbiter, &state); } // // Everything went OK so make this our allocated range // RtlFreeRangeList(Arbiter->Allocation); temp = Arbiter->Allocation; Arbiter->Allocation = Arbiter->PossibleAllocation; Arbiter->PossibleAllocation = temp; return STATUS_SUCCESS; cleanup: RtlFreeRangeList(Arbiter->PossibleAllocation); return status; }

NTSTATUS ArbBuildAssignmentOrdering (  IN OUT PARBITER_INSTANCE  Arbiter, IN PWSTR  AllocationOrderName, IN PWSTR  ReservedResourcesName, IN PARBITER_TRANSLATE_ALLOCATION_ORDER Translate  OPTIONAL )

Definition at line 1622 of file arbiter.c. References ARB_PRINT, ArbAcquireArbiterLock, ArbAddOrdering(), ArbFreeOrderingList(), ArbInitializeOrderingList(), ArbpGetRegistryValue(), ArbPruneOrdering(), ArbpWstrToUnicodeString, ArbReleaseArbiterLock, ASSERT, dummy(), _ARBITER_ORDERING::End, ExFreePool(), FOR_ALL_IN_ARRAY, FULL_INFO_DATA, KEY_ALLOCATIONORDER, KEY_RESERVEDRESOURCES, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PARBITER_ORDERING, PATH_ARBITERS, and _ARBITER_ORDERING::Start. Referenced by ArbInitializeArbiterInstance(). : This is called as part of arbiter initialization and extracts the allocation ordering and reserved information from the registry and combines them into an ordering list. The reserved ranges are put in Arbiter->ReservedList and the initial ordering in Arbiter->OrderingList. Parameters: Arbiter - The instance data of the arbiter to be initialized. AllocationOrderName - The name of the key under HKLM\System\ CurrentControlSet\Control\Arbiters\AllocationOrder the ordering information should be taken from. ReservedResourcesName - The name of the key under HKLM\System\ CurrentControlSet\Control\Arbiters\ReservedResources the reserved ranges information should be taken from. Translate - A function to be called for each range that will perform system dependant translations required for this system. Return Value: Status code that indicates whether or not the function was successful. --*/ { NTSTATUS status; HANDLE arbitersHandle = NULL, tempHandle = NULL; UNICODE_STRING unicodeString; PKEY_VALUE_FULL_INFORMATION info = NULL; ULONG dummy; PIO_RESOURCE_LIST resourceList; PIO_RESOURCE_DESCRIPTOR current; ULONGLONG start, end; OBJECT_ATTRIBUTES attributes; IO_RESOURCE_DESCRIPTOR translated; PAGED_CODE(); ArbAcquireArbiterLock(Arbiter); // // If we are reinitializing the orderings free the old ones // ArbFreeOrderingList(&Arbiter->OrderingList); ArbFreeOrderingList(&Arbiter->ReservedList); // // Initialize the orderings // status = ArbInitializeOrderingList(&Arbiter->OrderingList); if (!NT_SUCCESS(status)) { goto cleanup; } status = ArbInitializeOrderingList(&Arbiter->ReservedList); if (!NT_SUCCESS(status)) { goto cleanup; } // // Open HKLM\System\CurrentControlSet\Control\Arbiters // ArbpWstrToUnicodeString(&unicodeString, PATH_ARBITERS); InitializeObjectAttributes(&attributes, &unicodeString, OBJ_CASE_INSENSITIVE, NULL, (PSECURITY_DESCRIPTOR) NULL ); status = ZwOpenKey(&arbitersHandle, KEY_READ, &attributes ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Open AllocationOrder // ArbpWstrToUnicodeString(&unicodeString, KEY_ALLOCATIONORDER); InitializeObjectAttributes(&attributes, &unicodeString, OBJ_CASE_INSENSITIVE, arbitersHandle, (PSECURITY_DESCRIPTOR) NULL ); status = ZwOpenKey(&tempHandle, KEY_READ, &attributes ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Extract the value the user asked for // status = ArbpGetRegistryValue(tempHandle, AllocationOrderName, &info ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Check if the value we retrieved was a string and if so then it was a // short cut to a value of that name - open it. // if (info->Type == REG_SZ) { PKEY_VALUE_FULL_INFORMATION tempInfo; // BUGBUG - check this is a valid string... status = ArbpGetRegistryValue(tempHandle, (PWSTR) FULL_INFO_DATA(info), &tempInfo ); if (!NT_SUCCESS(status)) { goto cleanup; } ExFreePool(info); info = tempInfo; } ZwClose(tempHandle); // // We only support one level of short cuts so this should be a // REG_RESOURCE_REQUIREMENTS_LIST // if (info->Type != REG_RESOURCE_REQUIREMENTS_LIST) { status = STATUS_INVALID_PARAMETER; goto cleanup; } // // Extract the resource list // ASSERT(((PIO_RESOURCE_REQUIREMENTS_LIST) FULL_INFO_DATA(info)) ->AlternativeLists == 1); resourceList = (PIO_RESOURCE_LIST) &((PIO_RESOURCE_REQUIREMENTS_LIST) FULL_INFO_DATA(info))->List[0]; // // Convert the resource list into an ordering list // FOR_ALL_IN_ARRAY(resourceList->Descriptors, resourceList->Count, current) { // // Perform any translation that is necessary on the resources // if (ARGUMENT_PRESENT(Translate)) { status = (Translate)(&translated, current); if (!NT_SUCCESS(status)) { goto cleanup; } } else { translated = *current; } if (translated.Type == Arbiter->ResourceType) { status = Arbiter->UnpackRequirement(&translated, &start, &end, &dummy, //length &dummy //alignment ); if (!NT_SUCCESS(status)) { goto cleanup; } status = ArbAddOrdering(&Arbiter->OrderingList, start, end ); if (!NT_SUCCESS(status)) { goto cleanup; } } } // // We're finished with info... // ExFreePool(info); info = NULL; // // Open ReservedResources // ArbpWstrToUnicodeString(&unicodeString, KEY_RESERVEDRESOURCES); InitializeObjectAttributes(&attributes, &unicodeString, OBJ_CASE_INSENSITIVE, arbitersHandle, (PSECURITY_DESCRIPTOR) NULL ); status = ZwCreateKey(&tempHandle, KEY_READ, &attributes, 0, (PUNICODE_STRING) NULL, REG_OPTION_NON_VOLATILE, NULL ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Extract the arbiter's reserved resources // status = ArbpGetRegistryValue(tempHandle, ReservedResourcesName, &info ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Check if the value we retrieved was a string and if so then it was a // short cut to a value of that name - open it. // if (info->Type == REG_SZ) { PKEY_VALUE_FULL_INFORMATION tempInfo; // BUGBUG - check this is a valid string... status = ArbpGetRegistryValue(tempHandle, (PWSTR) FULL_INFO_DATA(info), &tempInfo ); if (!NT_SUCCESS(status)) { goto cleanup; } ExFreePool(info); info = tempInfo; } ZwClose(tempHandle); if (NT_SUCCESS(status)) { ASSERT(((PIO_RESOURCE_REQUIREMENTS_LIST) FULL_INFO_DATA(info)) ->AlternativeLists == 1); resourceList = (PIO_RESOURCE_LIST) &((PIO_RESOURCE_REQUIREMENTS_LIST) FULL_INFO_DATA(info))->List[0]; // // Apply the reserved ranges to the ordering // FOR_ALL_IN_ARRAY(resourceList->Descriptors, resourceList->Count, current) { // // Perform any translation that is necessary on the resources // if (ARGUMENT_PRESENT(Translate)) { status = (Translate)(&translated, current); if (!NT_SUCCESS(status)) { goto cleanup; } } else { translated = *current; } if (translated.Type == Arbiter->ResourceType) { status = Arbiter->UnpackRequirement(&translated, &start, &end, &dummy, //length &dummy //alignment ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Add the reserved range to the reserved ordering // status = ArbAddOrdering(&Arbiter->ReservedList, start, end); if (!NT_SUCCESS(status)) { goto cleanup; } // // Prune the reserved range from the current ordering // status = ArbPruneOrdering(&Arbiter->OrderingList, start, end); if (!NT_SUCCESS(status)) { goto cleanup; } } } ExFreePool(info); } // // All done! // ZwClose(arbitersHandle); #if ARB_DBG { PARBITER_ORDERING current; FOR_ALL_IN_ARRAY(Arbiter->OrderingList.Orderings, Arbiter->OrderingList.Count, current) { ARB_PRINT(2, ("Ordering: 0x%I64x-0x%I64x\n", current->Start, current->End )); } ARB_PRINT(2, ("\n")); FOR_ALL_IN_ARRAY(Arbiter->ReservedList.Orderings, Arbiter->ReservedList.Count, current) { ARB_PRINT(2, ("Reserved: 0x%I64x-0x%I64x\n", current->Start, current->End )); } } #endif ArbReleaseArbiterLock(Arbiter); return STATUS_SUCCESS; cleanup: if (arbitersHandle) { ZwClose(arbitersHandle); } if (tempHandle) { ZwClose(tempHandle); } if (info) { ExFreePool(info); } if (Arbiter->OrderingList.Orderings) { ExFreePool(Arbiter->OrderingList.Orderings); Arbiter->OrderingList.Count = 0; Arbiter->OrderingList.Maximum = 0; } if (Arbiter->ReservedList.Orderings) { ExFreePool(Arbiter->ReservedList.Orderings); Arbiter->ReservedList.Count = 0; Arbiter->ReservedList.Maximum = 0; } ArbReleaseArbiterLock(Arbiter); return status; }

NTSTATUS ArbCommitAllocation (  PARBITER_INSTANCE  Arbiter  )

Definition at line 1026 of file arbiter.c. References PAGED_CODE, and RtlFreeRangeList(). Referenced by ArbInitializeArbiterInstance(). : This provides the default implementation of the CommitAllocation action. It frees the old allocation and replaces it with the new allocation. Parameters: Arbiter - The arbiter instance data for the arbiter being called. Return Value: Status code that indicates whether or not the function was successful. --*/ { PRTL_RANGE_LIST temp; PAGED_CODE(); // // Free up the current allocation // RtlFreeRangeList(Arbiter->Allocation); // // Swap the allocated and duplicate lists // temp = Arbiter->Allocation; Arbiter->Allocation = Arbiter->PossibleAllocation; Arbiter->PossibleAllocation = temp; return STATUS_SUCCESS; }

NTSTATUS ArbCopyOrderingList (  OUT PARBITER_ORDERING_LIST  Destination, IN PARBITER_ORDERING_LIST  Source )

Definition at line 2971 of file arbiter.c. References ARBITER_ORDERING, ARBITER_ORDERING_LIST_TAG, ASSERT, ExAllocatePoolWithTag, NULL, PAGED_CODE, and PagedPool. : This routine copies an arbiter ordering list. Arguments: Destination - An uninitialized arbiter ordering list where the data should be copied from Source - Arbiter ordering list to be copied Return Value: Status code that indicates whether or not the function was successful. --*/ { PAGED_CODE() ASSERT(Source->Count <= Source->Maximum); ASSERT(Source->Maximum > 0); Destination->Orderings = ExAllocatePoolWithTag(PagedPool, Source->Maximum * sizeof(ARBITER_ORDERING), ARBITER_ORDERING_LIST_TAG ); if (Destination->Orderings == NULL) { return STATUS_INSUFFICIENT_RESOURCES; } Destination->Count = Source->Count; Destination->Maximum = Source->Maximum; if (Source->Count > 0) { RtlCopyMemory(Destination->Orderings, Source->Orderings, Source->Count * sizeof(ARBITER_ORDERING) ); } return STATUS_SUCCESS; }

VOID ArbDeleteArbiterInstance (  IN PARBITER_INSTANCE  Arbiter  )

Definition at line 469 of file arbiter.c. References ArbFreeOrderingList(), ARBITER_INSTANCE, ExFreePool(), PAGED_CODE, and RtlFreeRangeList(). Referenced by ArbDereferenceArbiterInstance(). { PAGED_CODE(); if (Arbiter->MutexEvent) { ExFreePool(Arbiter->MutexEvent); } if (Arbiter->Allocation) { RtlFreeRangeList(Arbiter->Allocation); ExFreePool(Arbiter->Allocation); } if (Arbiter->PossibleAllocation) { RtlFreeRangeList(Arbiter->PossibleAllocation); ExFreePool(Arbiter->PossibleAllocation); } if (Arbiter->AllocationStack) { ExFreePool(Arbiter->AllocationStack); } ArbFreeOrderingList(&Arbiter->OrderingList); ArbFreeOrderingList(&Arbiter->ReservedList); #if ARB_DBG RtlFillMemory(Arbiter, sizeof(ARBITER_INSTANCE), 'A'); #endif }

VOID ArbDereferenceArbiterInstance (  IN PARBITER_INSTANCE  Arbiter  )

Definition at line 457 of file arbiter.c. References ArbDeleteArbiterInstance(). { InterlockedDecrement(&Arbiter->ReferenceCount); if (Arbiter->ReferenceCount == 0) { ArbDeleteArbiterInstance(Arbiter); } }

BOOLEAN ArbFindSuitableRange (  PARBITER_INSTANCE  Arbiter, PARBITER_ALLOCATION_STATE  State )

Definition at line 2065 of file arbiter.c. References _ARBITER_ALTERNATIVE::Alignment, ARBITER_ALTERNATIVE_FLAG_SHARED, ARBITER_RANGE_BOOT_ALLOCATED, ARBITER_STATE_FLAG_NULL_CONFLICT_OK, ArbiterRequestLegacyAssigned, ArbiterRequestLegacyReported, ASSERT, _ARBITER_ALLOCATION_STATE::CurrentAlternative, _ARBITER_ALLOCATION_STATE::CurrentMaximum, _ARBITER_ALLOCATION_STATE::CurrentMinimum, _ARBITER_ALLOCATION_STATE::End, _ARBITER_ALLOCATION_STATE::Entry, FALSE, _ARBITER_ALLOCATION_STATE::Flags, _ARBITER_ALTERNATIVE::Flags, _ARBITER_ALTERNATIVE::Length, NT_SUCCESS, NTSTATUS(), PAGED_CODE, _ARBITER_ALLOCATION_STATE::RangeAvailableAttributes, _ARBITER_LIST_ENTRY::RequestSource, RtlFindRange(), _ARBITER_ALLOCATION_STATE::Start, and TRUE. Referenced by ArbInitializeArbiterInstance(), and IopMemFindSuitableRange(). : This routine is called from AllocateEntry once we have decided where we want to allocate from. It tries to find a free range that matches the requirements in State while restricting its possible solutions to the range State->CurrentMinimum to State->CurrentMaximum. On success State->Start and State->End represent this range. Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: TRUE if we found a range, FALSE otherwise. --*/ { NTSTATUS status; ULONG findRangeFlags = 0; PAGED_CODE(); ASSERT(State->CurrentAlternative); // // Catch the case where we backtrack and advance past the maximum // if (State->CurrentMinimum > State->CurrentMaximum) { return FALSE; } // // If we are asking for zero ports then trivially succeed with the minimum // value and remember that backtracking this is a recipe for infinite loops // if (State->CurrentAlternative->Length == 0) { State->End = State->Start = State->CurrentMinimum; return TRUE; } // // For legacy requests from IoAssignResources (directly or by way of // HalAssignSlotResources) or IoReportResourceUsage we consider preallocated // resources to be available for backward compatibility reasons. // // If we are allocating a devices boot config then we consider all other // boot configs to be available. BUGBUG(andrewth) - this behavior is bad! // if (State->Entry->RequestSource == ArbiterRequestLegacyReported || State->Entry->RequestSource == ArbiterRequestLegacyAssigned) { State->RangeAvailableAttributes |= ARBITER_RANGE_BOOT_ALLOCATED; } // // Check if null conflicts are OK... // if (State->Flags & ARBITER_STATE_FLAG_NULL_CONFLICT_OK) { findRangeFlags |= RTL_RANGE_LIST_NULL_CONFLICT_OK; } // // ...or we are shareable... // if (State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_SHARED) { findRangeFlags |= RTL_RANGE_LIST_SHARED_OK; } // // Select the first free alternative from the current alternative // status = RtlFindRange( Arbiter->PossibleAllocation, State->CurrentMinimum, State->CurrentMaximum, State->CurrentAlternative->Length, State->CurrentAlternative->Alignment, findRangeFlags, State->RangeAvailableAttributes, Arbiter->ConflictCallbackContext, Arbiter->ConflictCallback, &State->Start ); if (NT_SUCCESS(status)) { // // We found a suitable range // State->End = State->Start + State->CurrentAlternative->Length - 1; return TRUE; } else { // // We couldn't find any range so check if we will allow this conflict // - if so don'd fail! // return Arbiter->OverrideConflict(Arbiter, State); } }

VOID ArbFreeOrderingList (  IN PARBITER_ORDERING_LIST  List  )

Definition at line 3350 of file arbiter.c. References ASSERT, ExFreePool(), List, and NULL. : Frees storage associated with an ordering list. Reverses ArbInitializeOrderingList. Arguments: List - The list to be fred Return Value: None --*/ { if (List->Orderings) { ASSERT(List->Maximum); ExFreePool(List->Orderings); } List->Count = 0; List->Maximum = 0; List->Orderings = NULL; }

BOOLEAN ArbGetNextAllocationRange (  IN PARBITER_INSTANCE  Arbiter, IN OUT PARBITER_ALLOCATION_STATE  State )

Definition at line 2592 of file arbiter.c. References __max, __min, _ARBITER_ALTERNATIVE::Alignment, ARB_INDENT, ARB_PRINT, ARBITER_ALTERNATIVE_FLAG_FIXED, ARBITER_PRIORITY_EXHAUSTED, ARBITER_PRIORITY_NULL, ARBITER_PRIORITY_PREFERRED_RESERVED, ARBITER_PRIORITY_RESERVED, ArbpUpdatePriority(), ASSERT, _ARBITER_ORDERING::End, FALSE, _ARBITER_ALTERNATIVE::Flags, FOR_ALL_IN_ARRAY, INTERSECT, INTERSECT_SIZE, _ARBITER_ALTERNATIVE::Length, max, _ARBITER_ALTERNATIVE::Maximum, min, _ARBITER_ALTERNATIVE::Minimum, ORDERING_INDEX_FROM_PRIORITY, _ARBITER_ALTERNATIVE::Priority, _ARBITER_ORDERING::Start, and TRUE. Referenced by ArbInitializeArbiterInstance(). 02599 : 02600 02601 This routine attempts to find the next range where allocation should be 02602 tried. It updates State->CurrentMinimum, State->CurrentMaximum and 02603 State->CurrentAlternative to indicate this range. 02604 02605 Arguments: 02606 02607 Arbiter - The instance data of the arbiter 02608 02609 State - The state of the current arbitration 02610 02611 Return Value: 02612 02613 TRUE if a range to attemp allocation in is found, FALSE otherwise 02614 02615 --*/ 02616 02617 { 02618 02619 PARBITER_ALTERNATIVE current, lowestAlternative; 02620 ULONGLONG min, max; 02621 PARBITER_ORDERING ordering; 02622 02623 02624 for (;;) { 02625 02626 if (State->CurrentAlternative) { 02627 02628 // 02629 // Update the priority of the alternative we selected last time 02630 // 02631 02632 ArbpUpdatePriority(Arbiter, State->CurrentAlternative); 02633 02634 } else { 02635 02636 // 02637 // This is the first time we are looking at this alternative or a 02638 // backtrack - either way we need to update all the priorities 02639 // 02640 02641 FOR_ALL_IN_ARRAY(State->Alternatives, 02642 State->AlternativeCount, 02643 current) { 02644 02645 current->Priority = ARBITER_PRIORITY_NULL; 02646 ArbpUpdatePriority(Arbiter, current); 02647 02648 } 02649 } 02650 02651 // 02652 // Find the lowest priority of the alternatives 02653 // 02654 02655 lowestAlternative = State->Alternatives; 02656 02657 FOR_ALL_IN_ARRAY(State->Alternatives + 1, 02658 State->AlternativeCount - 1, 02659 current) { 02660 02661 if (current->Priority < lowestAlternative->Priority) { 02662 lowestAlternative = current; 02663 } 02664 } 02665 02666 ARB_INDENT(2, (ULONG)(State - Arbiter->AllocationStack)); 02667 02668 // 02669 // Check if we have run out of allocation ranges 02670 // 02671 02672 if (lowestAlternative->Priority == ARBITER_PRIORITY_EXHAUSTED) { 02673 02674 if (lowestAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_FIXED) { 02675 02676 ARB_PRINT(2,("Fixed alternative exhausted\n")); 02677 02678 } else { 02679 02680 ARB_PRINT(2,("Alternative exhausted\n")); 02681 } 02682 02683 return FALSE; 02684 02685 } else { 02686 02687 ARB_PRINT(2,( 02688 "LowestAlternative: [%i] 0x%I64x-0x%I64x L=0x%08x A=0x%08x\n", 02689 lowestAlternative->Priority, 02690 lowestAlternative->Minimum, 02691 lowestAlternative->Maximum, 02692 lowestAlternative->Length, 02693 lowestAlternative->Alignment 02694 )); 02695 02696 } 02697 02698 // 02699 // Check if we are now allowing reserved ranges 02700 // 02701 02702 if (lowestAlternative->Priority == ARBITER_PRIORITY_RESERVED 02703 || lowestAlternative->Priority == ARBITER_PRIORITY_PREFERRED_RESERVED) { 02704 02705 // 02706 // Set min and max to be the Minimum and Maximum that the descriptor 02707 // specified ignoring any reservations or orderings - this is our 02708 // last chance 02709 // 02710 02711 min = lowestAlternative->Minimum; 02712 max = lowestAlternative->Maximum; 02713 02714 ARB_INDENT(2, (ULONG)(State - Arbiter->AllocationStack)); 02715 02716 ARB_PRINT(2,("Allowing reserved ranges\n")); 02717 02718 } else { 02719 02720 ASSERT(ORDERING_INDEX_FROM_PRIORITY(lowestAlternative->Priority) >= 0 && 02721 ORDERING_INDEX_FROM_PRIORITY(lowestAlternative->Priority) < 02722 Arbiter->OrderingList.Count); 02723 02724 // 02725 // Locate the ordering we match 02726 // 02727 02728 ordering = &Arbiter->OrderingList.Orderings 02729 [ORDERING_INDEX_FROM_PRIORITY(lowestAlternative->Priority)]; 02730 02731 // 02732 // Make sure they overlap and are big enough - this is just paranoia 02733 // 02734 02735 ASSERT(INTERSECT(lowestAlternative->Minimum, 02736 lowestAlternative->Maximum, 02737 ordering->Start, 02738 ordering->End) 02739 && INTERSECT_SIZE(lowestAlternative->Minimum, 02740 lowestAlternative->Maximum, 02741 ordering->Start, 02742 ordering->End) >= lowestAlternative->Length); 02743 02744 // 02745 // Calculate the allocation range 02746 // 02747 02748 min = __max(lowestAlternative->Minimum, ordering->Start); 02749 02750 max = __min(lowestAlternative->Maximum, ordering->End); 02751 02752 } 02753 02754 // 02755 // If this is a length 0 requirement then succeed now and avoid much 02756 // trauma later 02757 // 02758 02759 if (lowestAlternative->Length == 0) { 02760 02761 min = lowestAlternative->Minimum; 02762 max = lowestAlternative->Maximum; 02763 02764 } else { 02765 02766 // 02767 // Trim range to match alignment. 02768 // 02769 02770 min += lowestAlternative->Alignment - 1; 02771 min -= min % lowestAlternative->Alignment; 02772 02773 if ((lowestAlternative->Length - 1) > (max - min)) { 02774 02775 ARB_INDENT(3, (ULONG)(State - Arbiter->AllocationStack)); 02776 ARB_PRINT(3, ("Range cannot be aligned ... Skipping\n")); 02777 02778 // 02779 // Set CurrentAlternative so we will update the priority of this 02780 // alternative 02781 // 02782 02783 State->CurrentAlternative = lowestAlternative; 02784 continue; 02785 } 02786 02787 max -= lowestAlternative->Length - 1; 02788 max -= max % lowestAlternative->Alignment; 02789 max += lowestAlternative->Length - 1; 02790 02791 } 02792 02793 // 02794 // Check if we handed back the same range last time, for the same 02795 // alternative, if so try to find another range 02796 // 02797 02798 if (min == State->CurrentMinimum 02799 && max == State->CurrentMaximum 02800 && State->CurrentAlternative == lowestAlternative) { 02801 02802 ARB_INDENT(2, (ULONG)(State - Arbiter->AllocationStack)); 02803 02804 ARB_PRINT(2, 02805 ("Skipping identical allocation range\n" 02806 )); 02807 02808 continue; 02809 } 02810 02811 State->CurrentMinimum = min; 02812 State->CurrentMaximum = max; 02813 State->CurrentAlternative = lowestAlternative; 02814 02815 ARB_INDENT(2, (ULONG)(State - Arbiter->AllocationStack)); 02816 ARB_PRINT(1, ("AllocationRange: 0x%I64x-0x%I64x\n", min, max)); 02817 02818 return TRUE; 02819 02820 } 02821 }

NTSTATUS ArbInitializeArbiterInstance (  OUT PARBITER_INSTANCE  Arbiter, IN PDEVICE_OBJECT  BusDeviceObject, IN CM_RESOURCE_TYPE  ResourceType, IN PWSTR  Name, IN PWSTR  OrderingName, IN PARBITER_TRANSLATE_ALLOCATION_ORDER TranslateOrdering  OPTIONAL )

Definition at line 192 of file arbiter.c. References ARB_PRINT, ArbAddAllocation(), ArbAddReserved(), ArbAllocateEntry(), ArbBacktrackAllocation(), ArbBootAllocation(), ArbBuildAssignmentOrdering(), ArbCommitAllocation(), ArbFindSuitableRange(), ArbGetNextAllocationRange(), ARBITER_ALLOCATION_STATE_TAG, ARBITER_INSTANCE_SIGNATURE, ARBITER_MISC_TAG, ARBITER_RANGE_LIST_TAG, ArbOverrideConflict(), ArbPreprocessEntry(), ArbQueryConflict(), ArbRetestAllocation(), ArbRollbackAllocation(), ArbStartArbiter(), ArbTestAllocation(), ASSERT, ExAllocatePoolWithTag, ExFreePool(), FALSE, INITIAL_ALLOCATION_STATE_SIZE, KeInitializeEvent, Name, NonPagedPool, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PagedPool, PARBITER_TRANSLATE_ALLOCATION_ORDER, RtlInitializeRangeList(), and TRUE. Referenced by IopBusNumberInitialize(), IopDmaInitialize(), IopIrqInitialize(), IopMemInitialize(), and IopPortInitialize(). : This routine initializes an arbiter instance and fills in any optional NULL dispatch table entries with system default functions. Parameters: Arbiter - A caller allocated arbiter instance structure. The UnpackRequirement, PackResource, UnpackResource and ScoreRequirement entries should be initialized with the appropriate routines as should any other entries if the default system routines are not sufficient. BusDeviceObject - The device object that exposes this arbiter - normally an FDO. ResourceType - The resource type this arbiter arbitrates. Name - A string used to identify the arbiter, used in debug messages and for registry storage OrderingName - The name of the preferred assignment ordering list under HKLM\System\CurrentControlSet\Control\SystemResources\AssignmentOrdering TranslateOrdering - Function that, if present, will be called to translate each descriptor from the ordering list Return Value: Status code that indicates whether or not the function was successful. Notes: --*/ { NTSTATUS status; PAGED_CODE(); ASSERT(Arbiter->UnpackRequirement); ASSERT(Arbiter->PackResource); ASSERT(Arbiter->UnpackResource); ARB_PRINT(2,("Initializing %S Arbiter...\n", Name)); // // Initialize all pool allocation pointers to NULL so we can cleanup // ASSERT(Arbiter->MutexEvent == NULL && Arbiter->Allocation == NULL && Arbiter->PossibleAllocation == NULL && Arbiter->AllocationStack == NULL ); // // We are an arbiter // Arbiter->Signature = ARBITER_INSTANCE_SIGNATURE; // // Remember the bus that produced us // Arbiter->BusDeviceObject = BusDeviceObject; // // Initialize state lock (KEVENT must be non-paged) // Arbiter->MutexEvent = ExAllocatePoolWithTag(NonPagedPool, sizeof(KEVENT), ARBITER_MISC_TAG ); if (!Arbiter->MutexEvent) { status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } KeInitializeEvent(Arbiter->MutexEvent, SynchronizationEvent, TRUE); // // Initialize the allocation stack to a reasonable size // Arbiter->AllocationStack = ExAllocatePoolWithTag(PagedPool, INITIAL_ALLOCATION_STATE_SIZE, ARBITER_ALLOCATION_STATE_TAG ); if (!Arbiter->AllocationStack) { status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } Arbiter->AllocationStackMaxSize = INITIAL_ALLOCATION_STATE_SIZE; // // Allocate buffers to hold the range lists // Arbiter->Allocation = ExAllocatePoolWithTag(PagedPool, sizeof(RTL_RANGE_LIST), ARBITER_RANGE_LIST_TAG ); if (!Arbiter->Allocation) { status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } Arbiter->PossibleAllocation = ExAllocatePoolWithTag(PagedPool, sizeof(RTL_RANGE_LIST), ARBITER_RANGE_LIST_TAG ); if (!Arbiter->PossibleAllocation) { status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } // // Initialize the range lists // RtlInitializeRangeList(Arbiter->Allocation); RtlInitializeRangeList(Arbiter->PossibleAllocation); // // Initialize the data fields // Arbiter->TransactionInProgress = FALSE; Arbiter->Name = Name; Arbiter->ResourceType = ResourceType; // // If the caller has not supplied the optional functions set them to the // defaults (If this were C++ we'd just inherit this loit but seeing as its // not we'll do it the old fashioned way...) // if (!Arbiter->TestAllocation) { Arbiter->TestAllocation = ArbTestAllocation; } if (!Arbiter->RetestAllocation) { Arbiter->RetestAllocation = ArbRetestAllocation; } if (!Arbiter->CommitAllocation) { Arbiter->CommitAllocation = ArbCommitAllocation; } if (!Arbiter->RollbackAllocation) { Arbiter->RollbackAllocation = ArbRollbackAllocation; } if (!Arbiter->AddReserved) { Arbiter->AddReserved = ArbAddReserved; } if (!Arbiter->PreprocessEntry) { Arbiter->PreprocessEntry = ArbPreprocessEntry; } if (!Arbiter->AllocateEntry) { Arbiter->AllocateEntry = ArbAllocateEntry; } if (!Arbiter->GetNextAllocationRange) { Arbiter->GetNextAllocationRange = ArbGetNextAllocationRange; } if (!Arbiter->FindSuitableRange) { Arbiter->FindSuitableRange = ArbFindSuitableRange; } if (!Arbiter->AddAllocation) { Arbiter->AddAllocation = ArbAddAllocation; } if (!Arbiter->BacktrackAllocation) { Arbiter->BacktrackAllocation = ArbBacktrackAllocation; } if (!Arbiter->OverrideConflict) { Arbiter->OverrideConflict = ArbOverrideConflict; } if (!Arbiter->BootAllocation) { Arbiter->BootAllocation = ArbBootAllocation; } if (!Arbiter->QueryConflict) { Arbiter->QueryConflict = ArbQueryConflict; } if (!Arbiter->StartArbiter) { Arbiter->StartArbiter = ArbStartArbiter; } // // Build the prefered assignment ordering - we assume that the reserved // ranges have the same name as the assignment ordering // status = ArbBuildAssignmentOrdering(Arbiter, OrderingName, OrderingName, TranslateOrdering ); if (!NT_SUCCESS(status)) { goto cleanup; } return STATUS_SUCCESS; cleanup: if (Arbiter->MutexEvent) { ExFreePool(Arbiter->MutexEvent); } if (Arbiter->Allocation) { ExFreePool(Arbiter->Allocation); } if (Arbiter->PossibleAllocation) { ExFreePool(Arbiter->PossibleAllocation); } if (Arbiter->AllocationStack) { ExFreePool(Arbiter->AllocationStack); } return status; }

NTSTATUS ArbInitializeOrderingList (  IN OUT PARBITER_ORDERING_LIST  List  )

Definition at line 2927 of file arbiter.c. References ARBITER_ORDERING, ARBITER_ORDERING_LIST_INITIAL_SIZE, ARBITER_ORDERING_LIST_TAG, ASSERT, ExAllocatePoolWithTag, List, PAGED_CODE, PagedPool, and PARBITER_ORDERING_LIST. Referenced by ArbBuildAssignmentOrdering(). : This routine inititialize an arbiter ordering list. Arguments: List - The list to be initialized Return Value: Status code that indicates whether or not the function was successful. --*/ { PAGED_CODE(); ASSERT(List); List->Orderings = ExAllocatePoolWithTag(PagedPool, ARBITER_ORDERING_LIST_INITIAL_SIZE * sizeof(ARBITER_ORDERING), ARBITER_ORDERING_LIST_TAG ); if (!List->Orderings) { List->Maximum = 0; List->Count = 0; return STATUS_INSUFFICIENT_RESOURCES; } List->Count = 0; List->Maximum = ARBITER_ORDERING_LIST_INITIAL_SIZE; return STATUS_SUCCESS; }

BOOLEAN ArbOverrideConflict (  IN PARBITER_INSTANCE  Arbiter, IN PARBITER_ALLOCATION_STATE  State )

Definition at line 3383 of file arbiter.c. References ARBITER_ALTERNATIVE_FLAG_FIXED, FALSE, INTERSECT, PAGED_CODE, and TRUE. Referenced by ArbInitializeArbiterInstance(). : This is the default implementation of override conflict which Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: TRUE if the conflict is allowable, false otherwise --*/ { PRTL_RANGE current; RTL_RANGE_LIST_ITERATOR iterator; BOOLEAN ok = FALSE; PAGED_CODE(); if (!(State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_FIXED)) { return FALSE; } FOR_ALL_RANGES(Arbiter->PossibleAllocation, &iterator, current) { // // Only test the overlapping ones // if (INTERSECT(current->Start, current->End, State->CurrentMinimum, State->CurrentMaximum)) { // // Check if we should ignore the range because of its attributes // if (current->Attributes & State->RangeAvailableAttributes) { // // We DON'T set ok to true because we are just ignoring the range, // as RtlFindRange would have and thus it can't be the cause of // RtlFindRange failing, so ignoring it can't fix the conflict. // continue; } // // Check if we are conflicting with ourselves AND the conflicting range // is a fixed requirement // if (current->Owner == State->Entry->PhysicalDeviceObject && State->CurrentAlternative->Flags & ARBITER_ALTERNATIVE_FLAG_FIXED) { State->Start=State->CurrentMinimum; State->End=State->CurrentMaximum; ok = TRUE; continue; } // // The conflict is still valid // return FALSE; } } return ok; }

NTSTATUS ArbpBuildAllocationStack (  IN PARBITER_INSTANCE  Arbiter, IN PLIST_ENTRY  ArbitrationList, IN ULONG  ArbitrationListCount )

Definition at line 786 of file arbiter.c. References _ARBITER_ALLOCATION_STATE::AlternativeCount, _ARBITER_LIST_ENTRY::AlternativeCount, _ARBITER_LIST_ENTRY::Alternatives, _ARBITER_ALLOCATION_STATE::Alternatives, ARBITER_ALLOCATION_STATE, ARBITER_ALLOCATION_STATE_TAG, ARBITER_ALTERNATIVE, ARBITER_PRIORITY_NULL, ArbpBuildAlternative(), ASSERT, _ARBITER_ALLOCATION_STATE::End, _ARBITER_ALLOCATION_STATE::Entry, ExAllocatePoolWithTag, ExFreePool(), FOR_ALL_IN_ARRAY, FOR_ALL_IN_LIST, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PagedPool, PARBITER_ALLOCATION_STATE, _ARBITER_ALTERNATIVE::Priority, and _ARBITER_ALLOCATION_STATE::Start. Referenced by ArbTestAllocation(). : This routine initializes the allocation stack for the requests in ArbitrationList. It overwrites any previous allocation stack and allocates additional memory if more is required. Arbiter->AllocationStack contains the initialized stack on success. Parameters: Arbiter - The arbiter instance data where the allocation stack should be placed. ArbitrationList - A list of ARBITER_LIST_ENTRY entries which contain the requirements and associated devices. ArbitrationListCount - The number of entries in the ArbitrationList Return Value: Status code that indicates whether or not the function was successful. --*/ { NTSTATUS status; PARBITER_LIST_ENTRY currentEntry; PARBITER_ALLOCATION_STATE currentState; ULONG stackSize = 0, allocationCount = ArbitrationListCount + 1; PARBITER_ALTERNATIVE currentAlternative; PIO_RESOURCE_DESCRIPTOR currentDescriptor; PAGED_CODE(); // // Calculate the size the stack needs to be and the // FOR_ALL_IN_LIST(ARBITER_LIST_ENTRY, ArbitrationList, currentEntry) { if (currentEntry->AlternativeCount > 0) { stackSize += currentEntry->AlternativeCount * sizeof(ARBITER_ALTERNATIVE); } else { allocationCount--; } } stackSize += allocationCount * sizeof(ARBITER_ALLOCATION_STATE); // // Make sure the allocation stack is large enough // if (Arbiter->AllocationStackMaxSize < stackSize) { PARBITER_ALLOCATION_STATE temp; // // Enlarge the allocation stack // temp = ExAllocatePoolWithTag(PagedPool, stackSize, ARBITER_ALLOCATION_STATE_TAG ); if (!temp) { return STATUS_INSUFFICIENT_RESOURCES; } ExFreePool(Arbiter->AllocationStack); Arbiter->AllocationStack = temp; } RtlZeroMemory(Arbiter->AllocationStack, stackSize); // // Fill in the locations // currentState = Arbiter->AllocationStack; currentAlternative = (PARBITER_ALTERNATIVE) (Arbiter->AllocationStack + ArbitrationListCount + 1); FOR_ALL_IN_LIST(ARBITER_LIST_ENTRY, ArbitrationList, currentEntry) { // // Do we need to allocate anything for this entry? // if (currentEntry->AlternativeCount > 0) { // // Initialize the stack location // currentState->Entry = currentEntry; currentState->AlternativeCount = currentEntry->AlternativeCount; currentState->Alternatives = currentAlternative; // // Initialize the start and end values to an invalid range so // that we don't skip the range 0-0 every time... // currentState->Start = 1; ASSERT(currentState->End == 0); // From RtlZeroMemory // // Initialize the alternatives table // FOR_ALL_IN_ARRAY(currentEntry->Alternatives, currentEntry->AlternativeCount, currentDescriptor) { status = ArbpBuildAlternative(Arbiter, currentDescriptor, currentAlternative ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Initialize the priority // currentAlternative->Priority = ARBITER_PRIORITY_NULL; // // Advance to the next alternative // currentAlternative++; } } currentState++; } // // Terminate the stack with NULL entry // currentState->Entry = NULL; return STATUS_SUCCESS; cleanup: // // We don't need to free the buffer as it is attached to the arbiter and // will be used next time // return status; }

NTSTATUS ArbpBuildAlternative (  IN PARBITER_INSTANCE  Arbiter, IN PIO_RESOURCE_DESCRIPTOR  Requirement, OUT PARBITER_ALTERNATIVE  Alternative )

Definition at line 689 of file arbiter.c. References ALIGN_ADDRESS_UP, ARBITER_ALTERNATIVE_FLAG_FIXED, ARBITER_ALTERNATIVE_FLAG_INVALID, ARBITER_ALTERNATIVE_FLAG_SHARED, ASSERT, NT_SUCCESS, NTSTATUS(), and PAGED_CODE. Referenced by ArbBootAllocation(), ArbpBuildAllocationStack(), ArbQueryConflict(), and ArbRetestAllocation(). : This routine initializes a arbiter alternative from a given resource requirement descriptor Parameters: Arbiter - The arbiter instance data where the allocation stack should be placed. Requirement - The requirement descriptor describing this requirement Alternative - The alternative to be initialized Return Value: Status code that indicates whether or not the function was successful. --*/ { NTSTATUS status; PAGED_CODE(); ASSERT(Alternative && Requirement); Alternative->Descriptor = Requirement; // // Unpack the requirement into the alternatives table // status = Arbiter->UnpackRequirement(Requirement, &Alternative->Minimum, &Alternative->Maximum, &Alternative->Length, &Alternative->Alignment ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Align the minimum if necessary // if (Alternative->Minimum % Alternative->Alignment != 0) { ALIGN_ADDRESS_UP(Alternative->Minimum, Alternative->Alignment ); } Alternative->Flags = 0; // // Check if this alternative is shared // if(Requirement->ShareDisposition == CmResourceShareShared) { Alternative->Flags |= ARBITER_ALTERNATIVE_FLAG_SHARED; } // // Check if this alternative is fixed // if (Alternative->Maximum - Alternative->Minimum + 1 == Alternative->Length) { Alternative->Flags |= ARBITER_ALTERNATIVE_FLAG_FIXED; } // // Check for validity // if (Alternative->Maximum < Alternative->Minimum) { Alternative->Flags |= ARBITER_ALTERNATIVE_FLAG_INVALID; } return STATUS_SUCCESS; cleanup: return status; }

NTSTATUS ArbpGetRegistryValue (  IN HANDLE  KeyHandle, IN PWSTR  ValueName, OUT PKEY_VALUE_FULL_INFORMATION *  Information )

Definition at line 2824 of file arbiter.c. References ARBITER_MISC_TAG, ExAllocatePoolWithTag, ExFreePool(), NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PagedPool, RtlInitUnicodeString(), and ValueName. Referenced by ArbBuildAssignmentOrdering(). : This routine is invoked to retrieve the data for a registry key's value. This is done by querying the value of the key with a zero-length buffer to determine the size of the value, and then allocating a buffer and actually querying the value into the buffer. It is the responsibility of the caller to free the buffer. Arguments: KeyHandle - Supplies the key handle whose value is to be queried ValueName - Supplies the null-terminated Unicode name of the value. Information - Returns a pointer to the allocated data buffer. Return Value: The function value is the final status of the query operation. Note: The same as IopGetRegistryValue - it allows us to share the arbiter code with pci.sys --*/ { UNICODE_STRING unicodeString; NTSTATUS status; PKEY_VALUE_FULL_INFORMATION infoBuffer; ULONG keyValueLength; PAGED_CODE(); RtlInitUnicodeString( &unicodeString, ValueName ); // // Figure out how big the data value is so that a buffer of the // appropriate size can be allocated. // status = ZwQueryValueKey( KeyHandle, &unicodeString, KeyValueFullInformationAlign64, (PVOID) NULL, 0, &keyValueLength ); if (status != STATUS_BUFFER_OVERFLOW && status != STATUS_BUFFER_TOO_SMALL) { return status; } // // Allocate a buffer large enough to contain the entire key data value. // infoBuffer = ExAllocatePoolWithTag( PagedPool, keyValueLength, ARBITER_MISC_TAG ); if (!infoBuffer) { return STATUS_INSUFFICIENT_RESOURCES; } // // Query the data for the key value. // status = ZwQueryValueKey( KeyHandle, &unicodeString, KeyValueFullInformationAlign64, infoBuffer, keyValueLength, &keyValueLength ); if (!NT_SUCCESS( status )) { ExFreePool( infoBuffer ); return status; } // // Everything worked, so simply return the address of the allocated // buffer to the caller, who is now responsible for freeing it. // *Information = infoBuffer; return STATUS_SUCCESS; }

VOID ArbpIndent (  IN ULONG  Count  )

Definition at line 4033 of file arbiter.c. References ASSERT, Count, and DbgPrint. { UCHAR spaces[80]; ASSERT(Count <= 80); RtlFillMemory(spaces, Count, '*'); spaces[Count] = 0; DbgPrint("%s", spaces); }

BOOLEAN ArbpQueryConflictCallback (  IN PVOID  Context, IN PRTL_RANGE  Range )

Definition at line 3642 of file arbiter.c. References ARB_PRINT, FALSE, and PAGED_CODE. Referenced by ArbQueryConflict(). : This call back is called from FindSuitableRange (via RtlFindRange) when we encounter an conflicting range. Arguments: Context - Actually a PRTL_RANGE * where we store the range we conflicted with. Range - The range we conflict with. Return Value: FALSE --*/ { PRTL_RANGE *conflictingRange = (PRTL_RANGE*)Context; PAGED_CODE(); ARB_PRINT(2,("Possible conflict: (%p) 0x%I64x-0x%I64x Owner: %p", Range, Range->Start, Range->End, Range->Owner )); // // Remember the conflicting range // *conflictingRange = Range; // // We want to allow the rest of FindSuitableRange to determine if this really // is a conflict. // return FALSE; }

NTSTATUS ArbPreprocessEntry (  IN PARBITER_INSTANCE  Arbiter, IN PARBITER_ALLOCATION_STATE  State )

Definition at line 2295 of file arbiter.c. References PAGED_CODE. Referenced by ArbInitializeArbiterInstance(). : This routine is called from AllocateEntry to allow preprocessing of entries Arguments: Arbiter - The instance data of the arbiter who was called. State - The state of the current arbitration. Return Value: None. --*/ { PAGED_CODE(); return STATUS_SUCCESS; }

NTSTATUS ArbPruneOrdering (  IN OUT PARBITER_ORDERING_LIST  OrderingList, IN ULONGLONG  Start, IN ULONGLONG  End )

Definition at line 3120 of file arbiter.c. References ARBITER_ORDERING, ARBITER_ORDERING_LIST_TAG, ASSERT, End, _ARBITER_ORDERING::End, ExAllocatePoolWithTag, ExFreePool(), FOR_ALL_IN_ARRAY, NTSTATUS(), NULL, PagedPool, Start, _ARBITER_ORDERING::Start, and USHORT. Referenced by ArbBuildAssignmentOrdering(). 03128 : 03129 03130 This routine removes the range Start-End from all entries in the ordering 03131 list, splitting ranges into two or deleting them as necessary. 03132 03133 Arguments: 03134 03135 OrderingList - The list to be pruned. 03136 03137 Start - The start of the range to be deleted. 03138 03139 End - The end of the range to be deleted. 03140 03141 Return Value: 03142 03143 Status code that indicates whether or not the function was successful. 03144 03145 Note: 03146 03147 In the comments below *** represents the range Start - End and --- the range 03148 current->Start - current->End. 03149 03150 --*/ 03151 03152 { 03153 03154 NTSTATUS status; 03155 PARBITER_ORDERING current, currentInsert, newOrdering = NULL, temp = NULL; 03156 USHORT count; 03157 03158 ASSERT(OrderingList); 03159 ASSERT(OrderingList->Orderings); 03160 03161 // 03162 // Validate parameters 03163 // 03164 03165 if (End < Start) { 03166 status = STATUS_INVALID_PARAMETER; 03167 goto cleanup; 03168 } 03169 03170 // 03171 // Allocate a buffer big enough for all eventualities 03172 // 03173 03174 newOrdering = ExAllocatePoolWithTag(PagedPool, 03175 (OrderingList->Count * 2 + 1) * 03176 sizeof(ARBITER_ORDERING), 03177 ARBITER_ORDERING_LIST_TAG 03178 ); 03179 03180 if (!newOrdering) { 03181 status = STATUS_INSUFFICIENT_RESOURCES; 03182 goto cleanup; 03183 } 03184 03185 currentInsert = newOrdering; 03186 03187 // 03188 // Do we have a current ordering? 03189 // 03190 03191 if (OrderingList->Count > 0) { 03192 03193 // 03194 // Iterate through the current ordering and prune accordingly 03195 // 03196 03197 FOR_ALL_IN_ARRAY(OrderingList->Orderings, OrderingList->Count, current) { 03198 03199 if (End < current->Start || Start > current->End) { 03200 03201 // 03202 // **** or **** 03203 // ---- ---- 03204 // 03205 // We don't overlap so copy the range unchanged 03206 // 03207 03208 *currentInsert++ = *current; 03209 03210 } else if (Start > current->Start) { 03211 03212 if (End < current->End) { 03213 03214 // 03215 // **** 03216 // -------- 03217 // 03218 // Split the range into two 03219 // 03220 03221 currentInsert->Start = End + 1; 03222 currentInsert->End = current->End; 03223 currentInsert++; 03224 03225 currentInsert->Start = current->Start; 03226 currentInsert->End = Start - 1; 03227 currentInsert++; 03228 03229 03230 } else { 03231 03232 // 03233 // **** or **** 03234 // -------- -------- 03235 // 03236 // Prune the end of the range 03237 // 03238 03239 ASSERT(End >= current->End); 03240 03241 currentInsert->Start = current->Start; 03242 currentInsert->End = Start - 1; 03243 currentInsert++; 03244 } 03245 } else { 03246 03247 ASSERT(Start <= current->Start); 03248 03249 if (End < current->End) { 03250 03251 // 03252 // **** or **** 03253 // -------- -------- 03254 // 03255 // Prune the start of the range 03256 // 03257 03258 currentInsert->Start = End + 1; 03259 currentInsert->End = current->End; 03260 currentInsert++; 03261 03262 } else { 03263 03264 ASSERT(End >= current->End); 03265 03266 // 03267 // ******** or ******** 03268 // ---- -------- 03269 // 03270 // Don't copy the range (ie. Delete it) 03271 // 03272 03273 } 03274 } 03275 } 03276 } 03277 03278 03279 ASSERT(currentInsert - newOrdering >= 0); 03280 03281 count = (USHORT)(currentInsert - newOrdering); 03282 03283 // 03284 // Check if we have any orderings left 03285 // 03286 03287 if (count > 0) { 03288 03289 if (count > OrderingList->Maximum) { 03290 03291 // 03292 // There isn't enough space so allocate a new buffer 03293 // 03294 03295 temp = 03296 ExAllocatePoolWithTag(PagedPool, 03297 count * sizeof(ARBITER_ORDERING), 03298 ARBITER_ORDERING_LIST_TAG 03299 ); 03300 03301 if (!temp) { 03302 status = STATUS_INSUFFICIENT_RESOURCES; 03303 goto cleanup; 03304 } 03305 03306 if (OrderingList->Orderings) { 03307 ExFreePool(OrderingList->Orderings); 03308 } 03309 03310 OrderingList->Orderings = temp; 03311 OrderingList->Maximum = count; 03312 03313 } 03314 03315 03316 // 03317 // Copy the new ordering 03318 // 03319 03320 RtlCopyMemory(OrderingList->Orderings, 03321 newOrdering, 03322 count * sizeof(ARBITER_ORDERING) 03323 ); 03324 } 03325 03326 // 03327 // Free our temporary buffer 03328 // 03329 03330 ExFreePool(newOrdering); 03331 03332 OrderingList->Count = count; 03333 03334 return STATUS_SUCCESS; 03335 03336 cleanup: 03337 03338 if (newOrdering) { 03339 ExFreePool(newOrdering); 03340 } 03341 03342 if (temp) { 03343 ExFreePool(temp); 03344 } 03345 03346 return status; 03347 03348 } VOID

VOID ArbpUpdatePriority (  PARBITER_INSTANCE  Arbiter, PARBITER_ALTERNATIVE  Alternative )

Definition at line 3468 of file arbiter.c. References ARBITER_ALTERNATIVE_FLAG_FIXED, ARBITER_PRIORITY_EXHAUSTED, ARBITER_PRIORITY_NULL, ARBITER_PRIORITY_PREFERRED_RESERVED, ARBITER_PRIORITY_RESERVED, ASSERT, _ARBITER_ALTERNATIVE::Descriptor, _ARBITER_ORDERING::End, _ARBITER_ALTERNATIVE::Flags, FOR_REST_IN_ARRAY, INTERSECT, INTERSECT_SIZE, _ARBITER_ALTERNATIVE::Length, _ARBITER_ALTERNATIVE::Maximum, _ARBITER_ALTERNATIVE::Minimum, ORDERING_INDEX_FROM_PRIORITY, PAGED_CODE, _ARBITER_ALTERNATIVE::Priority, and _ARBITER_ORDERING::Start. Referenced by ArbGetNextAllocationRange(). : This routine updates the priority of an arbiter alternative. Arguments: Arbiter - The arbiter we are operating on Alternative - The alternative currently being considered Return Value: Status code that indicates whether or not the function was successful. Note: The priorities are a LONG values organised as: <------Preferred priorities-----> <-----Ordinary Priorities-----> MINLONG--------------------------0-----------------------------MAXLONG ^ ^ ^ ^ | | | | NULL PREFERRED_RESERVED | | RESERVED | EXHAUSTED An ordinary priority is calculated the (index + 1) of the next ordering it intersects with (and has enough space for an allocation). A preferred priority is the ordinary priority * - 1 In this way by examining each of the alternatives in priority order (lowest first) we achieve the desired allocation order of: (1) Preferred alternative with non-reserved resources (2) Alternatives with non-reserved resources (3) Preferred reserved resources (4) Reserved Resources MAXLONG the worst priority indicates that there are no more allocation ranges left. --*/ { PARBITER_ORDERING ordering; BOOLEAN preferred; LONG priority; PAGED_CODE(); priority = Alternative->Priority; // // If we have already tried the reserved resources then we are out of luck! // if (priority == ARBITER_PRIORITY_RESERVED || priority == ARBITER_PRIORITY_PREFERRED_RESERVED) { Alternative->Priority = ARBITER_PRIORITY_EXHAUSTED; return; } // // Check if this is a preferred value - we treat them specially // preferred = Alternative->Descriptor->Option & IO_RESOURCE_PREFERRED; // // If priority is NULL then we haven't started calculating one so we // should start the search from the initial ordering // if (priority == ARBITER_PRIORITY_NULL) { ordering = Arbiter->OrderingList.Orderings; } else { // // If we are a fixed resource then there is no point // in trying to find another range - it will be the // same and thus still conflict. Mark this alternative as // exhausted // if (Alternative->Flags & ARBITER_ALTERNATIVE_FLAG_FIXED) { Alternative->Priority = ARBITER_PRIORITY_EXHAUSTED; return; } ASSERT(ORDERING_INDEX_FROM_PRIORITY(Alternative->Priority) >= 0 && ORDERING_INDEX_FROM_PRIORITY(Alternative->Priority) < Arbiter->OrderingList.Count); ordering = &Arbiter->OrderingList.Orderings [ORDERING_INDEX_FROM_PRIORITY(Alternative->Priority) + 1]; } // // Now find the first member of the assignent ordering for this arbiter // where we have an overlap big enough // FOR_REST_IN_ARRAY(Arbiter->OrderingList.Orderings, Arbiter->OrderingList.Count, ordering) { // // Is the ordering applicable? // if (INTERSECT(Alternative->Minimum, Alternative->Maximum, ordering->Start, ordering->End) && INTERSECT_SIZE(Alternative->Minimum, Alternative->Maximum, ordering->Start,ordering->End) >= Alternative->Length) { // // This is out guy, calculate his priority // Alternative->Priority = (LONG)(ordering - Arbiter->OrderingList.Orderings + 1); // // Preferred priorities are -ve // if (preferred) { Alternative->Priority *= -1; } return; } } // // We have runout of non-reserved resources so try the reserved ones // if (preferred) { Alternative->Priority = ARBITER_PRIORITY_PREFERRED_RESERVED; } else { Alternative->Priority = ARBITER_PRIORITY_RESERVED; } }

NTSTATUS ArbQueryConflict (  IN PARBITER_INSTANCE  Arbiter, IN PDEVICE_OBJECT  PhysicalDeviceObject, IN PIO_RESOURCE_DESCRIPTOR  ConflictingResource, OUT PULONG  ConflictCount, OUT PARBITER_CONFLICT_INFO *  Conflicts )

Definition at line 3695 of file arbiter.c. References _ARBITER_ALLOCATION_STATE::AlternativeCount, _ARBITER_ALLOCATION_STATE::Alternatives, ARB_PRINT, ARBITER_CONFLICT_INFO, ARBITER_CONFLICT_INFO_TAG, ARBITER_STATE_FLAG_CONFLICT, ArbiterRequestPnpEnumerated, ArbpBuildAlternative(), ArbpQueryConflictCallback(), ASSERT, _ARBITER_LIST_ENTRY::BusNumber, _ARBITER_ALLOCATION_STATE::CurrentAlternative, _ARBITER_ALLOCATION_STATE::CurrentMaximum, _ARBITER_ALLOCATION_STATE::CurrentMinimum, DevicePropertyBusNumber, DevicePropertyLegacyBusType, _ARBITER_ALLOCATION_STATE::End, _ARBITER_CONFLICT_INFO::End, _ARBITER_ALLOCATION_STATE::Entry, ExAllocatePoolWithTag, ExFreePool(), FALSE, _ARBITER_ALLOCATION_STATE::Flags, _ARBITER_LIST_ENTRY::InterfaceType, IoGetDeviceProperty(), _ARBITER_ALTERNATIVE::Maximum, _ARBITER_ALTERNATIVE::Minimum, NT_SUCCESS, NTSTATUS(), NULL, _ARBITER_CONFLICT_INFO::OwningObject, PAGED_CODE, PagedPool, PARBITER_CONFLICT_INFO, _ARBITER_LIST_ENTRY::PhysicalDeviceObject, _ARBITER_LIST_ENTRY::RequestSource, RtlCopyRangeList(), RtlDeleteOwnersRanges(), RtlDeleteRange(), RtlFreeRangeList(), RtlInitializeRangeList(), _ARBITER_ALLOCATION_STATE::Start, _ARBITER_CONFLICT_INFO::Start, and TRUE. Referenced by ArbInitializeArbiterInstance(). : This routine examines the arbiter state and returns a list of devices that conflict with ConflictingResource Arguments: Arbiter - The arbiter to examine conflicts in ConflictingResource - The resource we want to know the conflicts with ConflictCount - On success contains the number of conflicts detected ConflictList - On success contains a pointer to an array of conflicting devices Return Value: Status code that indicates whether or not the function was successful. --*/ { NTSTATUS status; RTL_RANGE_LIST backupAllocation; BOOLEAN backedUp = FALSE; ARBITER_LIST_ENTRY entry; ARBITER_ALLOCATION_STATE state; ARBITER_ALTERNATIVE alternative; ULONG count = 0, size = 10; PRTL_RANGE conflictingRange; PARBITER_CONFLICT_INFO conflictInfo = NULL; PVOID savedContext; PRTL_CONFLICT_RANGE_CALLBACK savedCallback; ULONG sz; PAGED_CODE(); ASSERT(PhysicalDeviceObject); ASSERT(ConflictingResource); ASSERT(ConflictCount); ASSERT(Conflicts); // // Set up our conflict callback // savedCallback = Arbiter->ConflictCallback; savedContext = Arbiter->ConflictCallbackContext; Arbiter->ConflictCallback = ArbpQueryConflictCallback; Arbiter->ConflictCallbackContext = &conflictingRange; // // If there is a transaction in progress then we need to backup the // the possible allocation so we can restore it when we are done. // if (Arbiter->TransactionInProgress) { RtlInitializeRangeList(&backupAllocation); status = RtlCopyRangeList(&backupAllocation, Arbiter->PossibleAllocation); if (!NT_SUCCESS(status)) { goto cleanup; } RtlFreeRangeList(Arbiter->PossibleAllocation); backedUp = TRUE; } // // Fake up the allocation state // status = RtlCopyRangeList(Arbiter->PossibleAllocation, Arbiter->Allocation); if (!NT_SUCCESS(status)) { goto cleanup; } status = ArbpBuildAlternative(Arbiter, ConflictingResource, &alternative); if (!NT_SUCCESS(status)) { goto cleanup; } RtlZeroMemory(&state, sizeof(ARBITER_ALLOCATION_STATE)); state.Start = alternative.Minimum; state.End = alternative.Maximum; state.CurrentMinimum = state.Start; state.CurrentMaximum = state.End; state.CurrentAlternative = &alternative; state.AlternativeCount = 1; state.Alternatives = &alternative; state.Flags = ARBITER_STATE_FLAG_CONFLICT; state.Entry = &entry; // // BUGBUG(andrewth) - need to fill in more of this false entry // RtlZeroMemory(&entry, sizeof(ARBITER_LIST_ENTRY)); entry.RequestSource = ArbiterRequestPnpEnumerated; entry.PhysicalDeviceObject = PhysicalDeviceObject; // // BUGBUG(jamiehun) - we didn't allow for passing interface type // now we have to live with the decision // this really only comes into being for PCI Translator AFAIK // upshot of not doing this is we get false conflicts when PCI Boot alloc // maps over top of ISA alias // IoGetDeviceProperty generally does the right thing for the times we have to use this info // if (!NT_SUCCESS(IoGetDeviceProperty(PhysicalDeviceObject,DevicePropertyLegacyBusType,sizeof(entry.InterfaceType),&entry.InterfaceType,&sz))) { entry.InterfaceType = Isa; // not what I want to do! However this has the right effect - good enough for conflict detection } if (!NT_SUCCESS(IoGetDeviceProperty(PhysicalDeviceObject,DevicePropertyBusNumber,sizeof(entry.InterfaceType),&entry.BusNumber,&sz))) { entry.BusNumber = 0; // not what I want to do! However this has the right effect - good enough for conflict detection } // // Initialize the return buffers // conflictInfo = ExAllocatePoolWithTag(PagedPool, size * sizeof(ARBITER_CONFLICT_INFO), ARBITER_CONFLICT_INFO_TAG ); if (!conflictInfo) { status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } // // Perform any necessary preprocessing // status = Arbiter->PreprocessEntry(Arbiter, &state); if (!NT_SUCCESS(status)) { goto cleanup; } // // Remove self from list of possible allocations // status may be set, but can be ignored // we take ourself out of test completely, so that a user can // pick new values in context of rest of the world // if we decide to use RtlDeleteRange instead // make sure we do it for every alias formed in PreprocessEntry // status = RtlDeleteOwnersRanges(Arbiter->PossibleAllocation, state.Entry->PhysicalDeviceObject ); // // Keep trying to find a suitable range and each time we fail remember why. // conflictingRange = NULL; state.CurrentMinimum = state.Start; state.CurrentMaximum = state.End; while (!Arbiter->FindSuitableRange(Arbiter, &state)) { if (count == size) { // // We need to resize the return buffer // PARBITER_CONFLICT_INFO temp = conflictInfo; size += 5; conflictInfo = ExAllocatePoolWithTag(PagedPool, size * sizeof(ARBITER_CONFLICT_INFO), ARBITER_CONFLICT_INFO_TAG ); if (!conflictInfo) { status = STATUS_INSUFFICIENT_RESOURCES; conflictInfo = temp; goto cleanup; } RtlCopyMemory(conflictInfo, temp, count * sizeof(ARBITER_CONFLICT_INFO) ); ExFreePool(temp); } if (conflictingRange != NULL) { conflictInfo[count].OwningObject = conflictingRange->Owner; conflictInfo[count].Start = conflictingRange->Start; conflictInfo[count].End = conflictingRange->End; // BUGBUG - maybe need some more info... count++; // // Delete the range we conflicted with so we don't loop forever // #if 0 status = RtlDeleteRange(Arbiter->PossibleAllocation, conflictingRange->Start, conflictingRange->End, conflictingRange->Owner ); #endif status = RtlDeleteOwnersRanges(Arbiter->PossibleAllocation, conflictingRange->Owner ); if (!NT_SUCCESS(status)) { goto cleanup; } } else { // // someone isn't playing by the rules (such as ACPI!) // ARB_PRINT(0,("Conflict detected - but someone hasn't set conflicting info\n")); conflictInfo[count].OwningObject = NULL; conflictInfo[count].Start = (ULONGLONG)0; conflictInfo[count].End = (ULONGLONG)(-1); // BUGBUG - maybe need some more info... count++; // // we daren't continue at risk of looping forever // break; } // // reset for next round // conflictingRange = NULL; state.CurrentMinimum = state.Start; state.CurrentMaximum = state.End; } RtlFreeRangeList(Arbiter->PossibleAllocation); if (Arbiter->TransactionInProgress) { status = RtlCopyRangeList(Arbiter->PossibleAllocation, &backupAllocation); if (!NT_SUCCESS(status)) { goto cleanup; } RtlFreeRangeList(&backupAllocation); } Arbiter->ConflictCallback = savedCallback; Arbiter->ConflictCallbackContext = savedContext; *Conflicts = conflictInfo; *ConflictCount = count; return STATUS_SUCCESS; cleanup: if (conflictInfo) { ExFreePool(conflictInfo); } RtlFreeRangeList(Arbiter->PossibleAllocation); if (Arbiter->TransactionInProgress && backedUp) { status = RtlCopyRangeList(Arbiter->PossibleAllocation, &backupAllocation); RtlFreeRangeList(&backupAllocation); } Arbiter->ConflictCallback = savedCallback; Arbiter->ConflictCallbackContext = savedContext; *Conflicts = NULL; return status; }

VOID ArbReferenceArbiterInstance (  IN PARBITER_INSTANCE  Arbiter  )

Definition at line 449 of file arbiter.c. { InterlockedIncrement(&Arbiter->ReferenceCount); }

NTSTATUS ArbRetestAllocation (  IN PARBITER_INSTANCE  Arbiter, IN OUT PLIST_ENTRY  ArbitrationList )

Definition at line 1105 of file arbiter.c. References _ARBITER_ALLOCATION_STATE::AlternativeCount, _ARBITER_ALLOCATION_STATE::Alternatives, ARB_PRINT, ARBITER_STATE_FLAG_RETEST, ArbpBuildAlternative(), ASSERT, _ARBITER_LIST_ENTRY::Assignment, _ARBITER_ALLOCATION_STATE::CurrentAlternative, _ARBITER_ALLOCATION_STATE::End, _ARBITER_ALLOCATION_STATE::Entry, _ARBITER_ALLOCATION_STATE::Flags, FOR_ALL_IN_LIST, NT_SUCCESS, NTSTATUS(), PAGED_CODE, _ARBITER_LIST_ENTRY::PhysicalDeviceObject, RtlCopyRangeList(), RtlDeleteOwnersRanges(), RtlFreeRangeList(), _ARBITER_LIST_ENTRY::SelectedAlternative, _ARBITER_ALLOCATION_STATE::Start, and _ARBITER_ALLOCATION_STATE::WorkSpace. Referenced by ArbInitializeArbiterInstance(). : This provides the default implementation of the RetestAllocation action. It walks the arbitration list and updates the possible allocation to reflect the allocation entries of the list. For these entries to be valid TestAllocation must have been performed on this arbitration list. Parameters: Arbiter - The arbiter instance data for the arbiter being called. ArbitrationList - A list of ARBITER_LIST_ENTRY entries which contain the requirements and associated devices. TestAllocation for this arbiter should have been called on this list. Return Value: Status code that indicates whether or not the function was successful. --*/ { NTSTATUS status; PARBITER_LIST_ENTRY current; ARBITER_ALLOCATION_STATE state; ARBITER_ALTERNATIVE alternative; ULONG length; PAGED_CODE(); // // Initialize the state // RtlZeroMemory(&state, sizeof(ARBITER_ALLOCATION_STATE)); RtlZeroMemory(&alternative, sizeof(ARBITER_ALTERNATIVE)); state.AlternativeCount = 1; state.Alternatives = &alternative; state.CurrentAlternative = &alternative; state.Flags = ARBITER_STATE_FLAG_RETEST; // // Copy the current allocation and reserved // ARB_PRINT(2, ("Retest: Copy current allocation\n")); status = RtlCopyRangeList(Arbiter->PossibleAllocation, Arbiter->Allocation); if (!NT_SUCCESS(status)) { goto cleanup; } // // Free all the resources currently allocated to all the devices we // are arbitrating for // FOR_ALL_IN_LIST(ARBITER_LIST_ENTRY, ArbitrationList, current) { ARB_PRINT(3, ("Retest: Delete 0x%08x's resources\n", current->PhysicalDeviceObject )); status = RtlDeleteOwnersRanges(Arbiter->PossibleAllocation, (PVOID) current->PhysicalDeviceObject ); if (!NT_SUCCESS(status)) { goto cleanup; } } // // Build an allocation state for the allocation and call AddAllocation to // update the range lists accordingly // FOR_ALL_IN_LIST(ARBITER_LIST_ENTRY, ArbitrationList, current) { ASSERT(current->Assignment && current->SelectedAlternative); state.WorkSpace = 0; state.Entry = current; // // Initialize the alternative // status = ArbpBuildAlternative(Arbiter, current->SelectedAlternative, &alternative ); ASSERT(NT_SUCCESS(status)); // // Update it with our allocation // status = Arbiter->UnpackResource(current->Assignment, &state.Start, &length ); ASSERT(NT_SUCCESS(status)); state.End = state.Start + length - 1; // // Do any preprocessing that is required // status = Arbiter->PreprocessEntry(Arbiter,&state); if (!NT_SUCCESS(status)) { goto cleanup; } // // If we had a requirement for length 0 then don't attemp to add the // range - it will fail! // if (length != 0) { Arbiter->AddAllocation(Arbiter, &state); } } return status; cleanup: RtlFreeRangeList(Arbiter->PossibleAllocation); return status; }

NTSTATUS ArbRollbackAllocation (  IN PARBITER_INSTANCE  Arbiter  )

Definition at line 1070 of file arbiter.c. References PAGED_CODE, and RtlFreeRangeList(). Referenced by ArbInitializeArbiterInstance(). : This provides the default implementation of the RollbackAllocation action. It frees the possible allocation the last TestAllocation provided. Parameters: Arbiter - The arbiter instance data for the arbiter being called. Return Value: Status code that indicates whether or not the function was successful. --*/ { PAGED_CODE(); // // Free up the possible allocation // RtlFreeRangeList(Arbiter->PossibleAllocation); return STATUS_SUCCESS; }

NTSTATUS ArbSortArbitrationList (  IN OUT PLIST_ENTRY  ArbitrationList  )

Definition at line 955 of file arbiter.c. References ARB_PRINT, FALSE, _ARBITER_LIST_ENTRY::ListEntry, PAGED_CODE, TRUE, and _ARBITER_LIST_ENTRY::WorkSpace. Referenced by ArbTestAllocation(). : This routine sorts the arbitration list in order of each entry's WorkSpace value. Parameters: ArbitrationList - The list to be sorted. Return Value: Status code that indicates whether or not the function was successful. --*/ { // // BUGBUG - maybe should use a get next type thing or a better sort! // BOOLEAN sorted = FALSE; PARBITER_LIST_ENTRY current, next; PAGED_CODE(); ARB_PRINT(3, ("IoSortArbiterList(%p)\n", ArbitrationList)); while (!sorted) { sorted = TRUE; for (current=(PARBITER_LIST_ENTRY) ArbitrationList->Flink, next=(PARBITER_LIST_ENTRY) current->ListEntry.Flink; (PLIST_ENTRY) current != ArbitrationList && (PLIST_ENTRY) next != ArbitrationList; current = (PARBITER_LIST_ENTRY) current->ListEntry.Flink, next = (PARBITER_LIST_ENTRY)current->ListEntry.Flink) { if (current->WorkSpace > next->WorkSpace) { PLIST_ENTRY before = current->ListEntry.Blink; PLIST_ENTRY after = next->ListEntry.Flink; // // Swap the locations of current and next // before->Flink = (PLIST_ENTRY) next; after->Blink = (PLIST_ENTRY) current; current->ListEntry.Flink = after; current->ListEntry.Blink = (PLIST_ENTRY) next; next->ListEntry.Flink = (PLIST_ENTRY) current; next->ListEntry.Blink = before; sorted = FALSE; } } } return STATUS_SUCCESS; }

NTSTATUS ArbStartArbiter (  IN PARBITER_INSTANCE  Arbiter, IN PCM_RESOURCE_LIST  StartResources )

Definition at line 3996 of file arbiter.c. References PAGED_CODE. Referenced by ArbInitializeArbiterInstance(). : This function is called by the driver that implements the arbiter once it has been started and knowns what resources it can allocate to its children. BUGBUG - It will eventually initialize the range lists correctly but for now it is just an overloadable place holder as that work is done elsewhere. Parameters: Arbiter - The instance of the arbiter being called. Return Value: Status code that indicates whether or not the function was successful. --*/ { PAGED_CODE(); return STATUS_SUCCESS; }

NTSTATUS ArbTestAllocation (  IN PARBITER_INSTANCE  Arbiter, IN OUT PLIST_ENTRY  ArbitrationList )

Definition at line 506 of file arbiter.c. References _ARBITER_LIST_ENTRY::AlternativeCount, _ARBITER_LIST_ENTRY::Alternatives, ARB_PRINT, ARBITER_LIST_ENTRY, ArbpBuildAllocationStack(), ArbSortArbitrationList(), ASSERT, FOR_ALL_IN_ARRAY, FOR_ALL_IN_LIST, NT_SUCCESS, NTSTATUS(), NULL, PAGED_CODE, PARBITER_LIST_ENTRY, _ARBITER_LIST_ENTRY::PhysicalDeviceObject, RtlCopyRangeList(), RtlDeleteOwnersRanges(), RtlFreeRangeList(), and _ARBITER_LIST_ENTRY::WorkSpace. Referenced by ArbInitializeArbiterInstance(). : This is the default implementation of the arbiter Test Allocation action. It takes a list of requests for resources for particular devices and attempts to satisfy them. Parameters: Arbiter - The instance of the arbiter being called. ArbitrationList - A list of ARBITER_LIST_ENTRY entries which contain the requirements and associated devices. Return Value: Status code that indicates whether or not the function was successful. These include: STATUS_SUCCESSFUL - Arbitration suceeded and an allocation has been made for all the entries in the arbitration list. STATUS_UNSUCCESSFUL - Arbitration failed to find an allocation for all entries. STATUS_ARBITRATION_UNHANDLED - If returning this error the arbiter is partial (and therefore must have set the ARBITER_PARTIAL flag in its interface.) This status indicates that this arbiter doesn't handle the resources requested and the next arbiter towards the root of the device tree should be asked instead. --*/ { NTSTATUS status; PARBITER_LIST_ENTRY current; PIO_RESOURCE_DESCRIPTOR alternative; ULONG count; PDEVICE_OBJECT previousOwner; PDEVICE_OBJECT currentOwner; LONG score; BOOLEAN performScoring; PAGED_CODE(); ASSERT(Arbiter); // // Copy the current allocation // ARB_PRINT(3, ("Copy current allocation\n")); status = RtlCopyRangeList(Arbiter->PossibleAllocation, Arbiter->Allocation); if (!NT_SUCCESS(status)) { goto cleanup; } // // Free all the resources currently allocated to all the devices we // are arbitrating for // count = 0; previousOwner = NULL; FOR_ALL_IN_LIST(ARBITER_LIST_ENTRY, ArbitrationList, current) { count++; currentOwner = current->PhysicalDeviceObject; if (previousOwner != currentOwner) { previousOwner = currentOwner; ARB_PRINT(3, ("Delete 0x%08x's resources\n", currentOwner )); status = RtlDeleteOwnersRanges(Arbiter->PossibleAllocation, (PVOID)currentOwner ); if (!NT_SUCCESS(status)) { goto cleanup; } } // // Score the entries in the arbitration list if a scoring function was // provided and this is not a legacy request (which is guaranteed to be // made of all fixed requests so sorting is pointless) // performScoring = Arbiter->ScoreRequirement != NULL; // BUGBUG - fix for rebalance being broken and not passing in flags... // && !LEGACY_REQUEST(current); current->WorkSpace = 0; if (performScoring) { FOR_ALL_IN_ARRAY(current->Alternatives, current->AlternativeCount, alternative) { ARB_PRINT(3, ("Scoring entry %p\n", currentOwner )); score = Arbiter->ScoreRequirement(alternative); // // Ensure the score is valid // if (score < 0) { status = STATUS_DEVICE_CONFIGURATION_ERROR; goto cleanup; } current->WorkSpace += score; } } } status = ArbSortArbitrationList(ArbitrationList); if (!NT_SUCCESS(status)) { goto cleanup; } // // Build the arbitration stack // status = ArbpBuildAllocationStack(Arbiter, ArbitrationList, count ); if (!NT_SUCCESS(status)) { goto cleanup; } // // Attempt allocation // status = Arbiter->AllocateEntry(Arbiter, Arbiter->AllocationStack); if (NT_SUCCESS(status)) { // // Success. // return status; } cleanup: // // We didn't succeed so empty the possible allocation list... // RtlFreeRangeList(Arbiter->PossibleAllocation); return status; }

---