Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/ntos/io/pnpres.c
Microsoft 45f4a58588 First commit
2020-09-30 17:12:32 +02:00

8408 lines
257 KiB
C
Raw Blame History

/*++
Copyright (c) 1995 Microsoft Corporation
Module Name:
pnpres.c
Abstract:
This module contains the plug-and-play resource allocation and translation routines
Author:
Shie-Lin Tzong (shielint) 1-Mar-1997
Environment:
Kernel mode
Revision History:
25-Sept-1998 SantoshJ Made IopAssign non-recursive.
01-Oct-1998 SantoshJ Replaced "complex (broken)" hypercube code and replaced with
cascading counters. Simple, faster, smaller code.
Added timeouts to IopAssign.
Added more self-debugging capability by generating more
meaningful debug spew.
03-Feb-1999 SantoshJ Do allocation one device at a time.
Do devices with BOOT config before others.
Optimize IopFindBusDeviceNode.
--*/
#include "iop.h"
#pragma hdrstop
#define MYDBG 0
#ifdef POOL_TAGGING
#undef ExAllocatePool
#define ExAllocatePool(a,b) ExAllocatePoolWithTag(a,b,'erpP')
#endif // POOL_TAGGING
#if MYDBG
#define ExAllocatePoolAT(a,b) ExAllocatePoolWithTag(a,b,'0rpP')
#define ExAllocatePoolRD(a,b) ExAllocatePoolWithTag(a,b,'1rpP')
#define ExAllocatePoolCMRL(a,b) ExAllocatePoolWithTag(a,b,'2rpP')
#define ExAllocatePoolCMRR(a,b) ExAllocatePoolWithTag(a,b,'3rpP')
#define ExAllocatePoolAE(a,b) ExAllocatePoolWithTag(a,b,'4rpP')
#define ExAllocatePoolTE(a,b) ExAllocatePoolWithTag(a,b,'5rpP')
#define ExAllocatePoolPRD(a,b) ExAllocatePoolWithTag(a,b,'6rpP')
#define ExAllocatePoolIORD(a,b) ExAllocatePoolWithTag(a,b,'7rpP')
#define ExAllocatePool1RD(a,b) ExAllocatePoolWithTag(a,b,'8rpP')
#define ExAllocatePoolPDO(a,b) ExAllocatePoolWithTag(a,b,'9rpP')
#define ExAllocatePoolIORR(a,b) ExAllocatePoolWithTag(a,b,'ArpP')
#define ExAllocatePoolIORL(a,b) ExAllocatePoolWithTag(a,b,'BrpP')
#define ExAllocatePoolIORRR(a,b) ExAllocatePoolWithTag(a,b,'CrpP')
#else // MYDBG
#define ExAllocatePoolAT(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolRD(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolCMRL(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolCMRR(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolAE(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolTE(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolPRD(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolIORD(a,b) ExAllocatePool(a,b)
#define ExAllocatePool1RD(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolPDO(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolIORR(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolIORL(a,b) ExAllocatePool(a,b)
#define ExAllocatePoolIORRR(a,b) ExAllocatePool(a,b)
#endif // MYDBG
// Forward typedefs.
typedef struct _REQ_DESC
REQ_DESC, *PREQ_DESC;
typedef struct _REQ_ALTERNATIVE
REQ_ALTERNATIVE, *PREQ_ALTERNATIVE;
typedef struct _REQ_LIST
REQ_LIST, *PREQ_LIST;
// An IO_RESOURCE_REQUIREMENTS_LIST is translated into a tree of these data strucures:
// REQ_LIST
// REQ_ALTERNATIVE
// REQ_DESC
// which are easier to manipulate while exploring the solution space.
struct _REQ_DESC {
BOOLEAN ArbitrationRequired;
UCHAR Reserved[3];
INTERFACE_TYPE InterfaceType;
ULONG BusNumber;
PREQ_ALTERNATIVE ReqAlternative; // REQ_ALTERNATIVE back pointer
ULONG ReqDescIndex; // REQ_ALTERNATIVE.ReqDescTable[] index
ULONG DevicePrivateCount; // DevicePrivate info for the LogConf
PIO_RESOURCE_DESCRIPTOR DevicePrivate; // (DevicePrivate is per-LogConf)
PREQ_DESC TranslatedReqDesc; // Stack pointer for translated REQ_DESC
union {
PPI_RESOURCE_ARBITER_ENTRY Arbiter; // Used in Original REQ_DESC
PPI_RESOURCE_TRANSLATOR_ENTRY Translator; // Used in translated/adjusted REQ_DESC
} u;
ARBITER_LIST_ENTRY AlternativeTable;
CM_PARTIAL_RESOURCE_DESCRIPTOR Allocation;
// This two fields are just a place holder
// They have to be copied back to AlternativeTable
// and Allocation to be useful.
ARBITER_LIST_ENTRY BestAlternativeTable;
CM_PARTIAL_RESOURCE_DESCRIPTOR BestAllocation;
};
struct _REQ_ALTERNATIVE {
PREQ_LIST ReqList; // Containing REQ_LIST
ULONG ReqAlternativeIndex; // Containing REQ_LIST.ReqAlternativeTable[] index
ULONG Priority;
ULONG ReqDescCount;
PREQ_DESC *ReqDescTableEnd;
PREQ_DESC ReqDescTable[1]; // Variable length
};
struct _REQ_LIST {
PIOP_RESOURCE_REQUEST AssignEntry;
PDEVICE_OBJECT PhysicalDevice;
INTERFACE_TYPE InterfaceType;
ULONG BusNumber;
PREQ_ALTERNATIVE *SelectedAlternative; // Alternative under processed.
ULONG ReqAlternativeCount;
PREQ_ALTERNATIVE *ReqBestAlternative; // Best alternative so far.
// (Initialize it to the end of the table)
PREQ_ALTERNATIVE ReqAlternativeTable[1]; // Variable length
};
// Structure to represent a cascading counter.
typedef struct _Counter {
ULONG Count; // Current counter value.
ULONG ResetValue; // Reset value for this counter.
ULONG MaximumValue; // Maximum value for this counter.
} COUNTER, *PCOUNTER;
#define IS_TRANSLATED_REQ_DESC(r) ((r)->ReqAlternative ? FALSE : TRUE)
// IopReleaseBootResources can only be called for non ROOT enumerated devices
#define IopReleaseBootResources(DeviceNode) \
ASSERT(((DeviceNode)->Flags & DNF_MADEUP) == 0); \
IopReleaseResourcesInternal(DeviceNode); \
(DeviceNode)->Flags &= ~DNF_HAS_BOOT_CONFIG; \
(DeviceNode)->Flags &= ~DNF_BOOT_CONFIG_RESERVED; \
if ((DeviceNode)->BootResources) { \
ExFreePool((DeviceNode)->BootResources); \
(DeviceNode)->BootResources = NULL; \
}
// Duplicate_detection_Context
typedef struct _DUPLICATE_DETECTION_CONTEXT {
PCM_RESOURCE_LIST TranslatedResources;
PDEVICE_NODE Duplicate;
} DUPLICATE_DETECTION_CONTEXT, *PDUPLICATE_DETECTION_CONTEXT;
// Reused device node fields
#define NextDeviceNode Sibling
#define PreviousDeviceNode Child
// Macros and definitions
#define STRUCTURE_ALIGNMENT 1 // disable the structure alignment.
// Pool Management macros
typedef struct _IOP_POOL {
PUCHAR PoolStart;
PUCHAR PoolEnd;
ULONG PoolSize;
} IOP_POOL, *PIOP_POOL;
#define IopInitPool( \
/* IN PIOP_POOL */ Pool, \
/* IN PUCHAR */ Start, \
/* IN ULONG */ Size \
) \
{ \
(Pool)->PoolStart = (Start); \
(Pool)->PoolEnd = (Start) + (Size); \
(Pool)->PoolSize = (Size); \
RtlZeroMemory(Start, Size); \
}
#define IopAllocPoolAligned( \
/* OUT PUCHAR */ Memory, \
/* IN PIOP_POOL */ Pool, \
/* IN ULONG */ Size \
) \
(Pool)->PoolStart = (PUCHAR) \
(((ULONG_PTR) (Pool)->PoolStart + STRUCTURE_ALIGNMENT - 1) \
& ~(STRUCTURE_ALIGNMENT - 1)); \
IopAllocPool(Memory, Pool, Size);
#define IopAllocPool( \
/* OUT PUCHAR */ Memory, \
/* IN PIOP_POOL */ Pool, \
/* IN ULONG */ Size \
) \
*(Memory) = (PVOID) (Pool)->PoolStart; \
(Pool)->PoolStart += (Size); \
ASSERT((Pool)->PoolStart <= (Pool)->PoolEnd);
// static variables
LIST_ENTRY PiActiveArbiterList; // The List of arbiters being processed.
LIST_ENTRY PiBestArbiterList; // The list of arbiters for the best alternative so far
ULONG PiBestPriority; // The best score so far
PIOP_RESOURCE_REQUEST PiAssignTable;
ULONG PiAssignTableCount;
PDEVICE_NODE IopLegacyDeviceNode; // head pointer of the list of made up device node for
// IoAssignResources and IoReportResourceUsage
BOOLEAN PiNoRetest;
#if DBG
BOOLEAN PiUseTimeout = FALSE;
#else
BOOLEAN PiUseTimeout = TRUE;
#endif
// Timeout value for IopAssign in milliseconds.
#define FIND_BEST_ASSIGNMENT_TIMEOUT 5000
// External references
extern WCHAR IopWstrTranslated[];
extern WCHAR IopWstrRaw[];
// Debug support
#if DBG_SCOPE
#define DUMP_ERROR 0x0001
#define DUMP_INFO 0x0002
#define DUMP_DETAIL 0x0004
#define STOP_ERROR 0x1000
//ULONG PnpResDebugLevel = DUMP_INFO + DUMP_ERROR;
ULONG PnpResDebugLevel = 0;
#define DebugMessage(Level,Message) \
if (PnpResDebugLevel & (Level)) { \
DbgPrint Message; \
}
typedef struct {
PDEVICE_NODE devnode;
CM_PARTIAL_RESOURCE_DESCRIPTOR resource;
} PNPRESDEBUGTRANSLATIONFAILURE;
ULONG PnpResDebugTranslationFailureCount = 32; // get count in both this line and the next.
PNPRESDEBUGTRANSLATIONFAILURE PnpResDebugTranslationFailureArray[32];
PNPRESDEBUGTRANSLATIONFAILURE *PnpResDebugTranslationFailure = PnpResDebugTranslationFailureArray;
#else
#define DebugMessage(Level,Message)
#endif
// Internal/Forward function references
PCM_RESOURCE_LIST
IopCreateCmResourceList(
IN PCM_RESOURCE_LIST ResourceList,
IN INTERFACE_TYPE InterfaceType,
IN ULONG BusNumber,
OUT PCM_RESOURCE_LIST *RemainingList
);
PCM_RESOURCE_LIST
IopCombineCmResourceList(
IN PCM_RESOURCE_LIST ResourceListA,
IN PCM_RESOURCE_LIST ResourceListB
);
VOID
IopRemoveLegacyDeviceNode (
IN PDEVICE_OBJECT DeviceObject OPTIONAL,
IN PDEVICE_NODE LegacyDeviceNode
);
NTSTATUS
IopFindLegacyDeviceNode (
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT DeviceObject OPTIONAL,
OUT PDEVICE_NODE *LegacyDeviceNode,
OUT PDEVICE_OBJECT *LegacyPDO
);
PDEVICE_NODE
IopFindBusDeviceNodeInternal (
IN PDEVICE_NODE DeviceNode,
IN INTERFACE_TYPE InterfaceType,
IN ULONG BusNumber
);
NTSTATUS
IopGetResourceRequirementsForAssignTable(
IN PIOP_RESOURCE_REQUEST AssignTable,
IN PIOP_RESOURCE_REQUEST AssignTableEnd,
OUT PULONG DeviceCount
);
NTSTATUS
IopResourceRequirementsListToReqList(
IN ARBITER_REQUEST_SOURCE AllocationType,
IN PIO_RESOURCE_REQUIREMENTS_LIST IoResources,
IN PDEVICE_OBJECT PhysicalDevice,
OUT PVOID *ResReqList
);
VOID
IopRearrangeReqList (
IN PREQ_LIST ReqList
);
VOID
IopRearrangeAssignTable (
IN PIOP_RESOURCE_REQUEST AssignTable,
IN ULONG Count
);
int
__cdecl
IopComparePriority(
const void *arg1,
const void *arg2
);
VOID
IopFreeResourceRequirementsForAssignTable(
IN PIOP_RESOURCE_REQUEST AssignTable,
IN PIOP_RESOURCE_REQUEST AssignTableEnd
);
VOID
IopFreeReqAlternative (
IN PREQ_ALTERNATIVE ReqAlternative
);
VOID
IopFreeReqList (
IN PREQ_LIST ReqList
);
NTSTATUS
IopAssign(
IN ULONG AssignTableCount,
IN PIOP_RESOURCE_REQUEST AssignTable,
IN BOOLEAN Rebalance
);
VOID
IopBuildCmResourceLists(
IN PIOP_RESOURCE_REQUEST AssignTable,
IN PIOP_RESOURCE_REQUEST AssignTableEnd
);
VOID
IopBuildCmResourceList (
IN PIOP_RESOURCE_REQUEST AssignEntry
);
NTSTATUS
IopAssignInner(
IN ULONG AssignTableCount,
IN PIOP_RESOURCE_REQUEST AssignTable,
IN BOOLEAN Rebalance
);
NTSTATUS
IopPlacement(
IN ARBITER_ACTION ArbiterAction,
IN BOOLEAN Rebalance
);
VOID
IopAddReqDescsToArbiters (
IN ULONG ReqDescCount,
IN PREQ_DESC *ReqDescTable
);
VOID
IopRemoveReqDescsFromArbiters (
ULONG ReqDescCount,
PREQ_DESC *ReqDescTable
);
BOOLEAN
IopIsBestConfiguration(
IN VOID
);
VOID
IopSaveCurrentConfiguration (
IN VOID
);
VOID
IopRestoreBestConfiguration(
IN VOID
);
BOOLEAN
IopFindResourceHandlerInfo(
IN RESOURCE_HANDLER_TYPE HandlerType,
IN PDEVICE_NODE DeviceNode,
IN UCHAR ResourceType,
OUT PVOID *HandlerEntry
);
NTSTATUS
IopSetupArbiterAndTranslators(
IN PREQ_DESC ReqDesc
);
NTSTATUS
IopParentToRawTranslation(
IN OUT PREQ_DESC ReqDesc
);
NTSTATUS
IopChildToRootTranslation(
IN PDEVICE_NODE DeviceNode, OPTIONAL
IN INTERFACE_TYPE InterfaceType,
IN ULONG BusNumber,
IN ARBITER_REQUEST_SOURCE ArbiterRequestSource,
IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Source,
OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR *Target
);
NTSTATUS
IopTranslateAndAdjustReqDesc(
IN PREQ_DESC ReqDesc,
IN PPI_RESOURCE_TRANSLATOR_ENTRY TranslatorEntry,
OUT PREQ_DESC *TranslatedReqDesc
);
NTSTATUS
IopCallArbiter(
PPI_RESOURCE_ARBITER_ENTRY ArbiterEntry,
ARBITER_ACTION Command,
PVOID Input1,
PVOID Input2,
PVOID Input3
);
VOID
IopQueryRebalance (
IN PDEVICE_NODE DeviceNode,
IN ULONG Phase,
IN PULONG RebalanceCount,
IN PDEVICE_OBJECT **DeviceTable
);
VOID
IopQueryRebalanceWorker (
IN PDEVICE_NODE DeviceNode,
IN ULONG RebalancePhase,
IN PULONG RebalanceCount,
IN PDEVICE_OBJECT **DeviceTable
);
VOID
IopTestForReconfiguration (
IN PDEVICE_NODE DeviceNode,
IN ULONG RebalancePhase,
IN PULONG RebalanceCount,
IN PDEVICE_OBJECT **DeviceTable
);
NTSTATUS
IopPlacementForRebalance (
IN PDEVICE_NODE DeviceNode,
IN ARBITER_ACTION ArbiterAction
);
NTSTATUS
IopArbitrateDeviceResources (
IN PDEVICE_NODE DeviceNode,
IN ARBITER_ACTION ArbiterAction
);
NTSTATUS
IopRebalance (
IN ULONG AssignTableCont,
IN PIOP_RESOURCE_REQUEST AssignTable
);
NTSTATUS
IopFindResourcesForArbiter (
IN PDEVICE_NODE DeviceNode,
IN UCHAR ResourceType,
OUT ULONG *Count,
OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR *CmDesc
);
VOID
IopReleaseResourcesInternal (
IN PDEVICE_NODE DeviceNode
);
VOID
IopReleaseResources (
IN PDEVICE_NODE DeviceNode
);
NTSTATUS
IopRestoreResourcesInternal (
IN PDEVICE_NODE DeviceNode
);
VOID
IopSetLegacyDeviceInstance (
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_NODE DeviceNode
);
PCM_RESOURCE_LIST
IopCombineLegacyResources (
IN PDEVICE_NODE DeviceNode
);
NTSTATUS
IopPlacementForReservation(
VOID
);
NTSTATUS
IopReserve(
IN PREQ_LIST ReqList
);
NTSTATUS
IopReserveBootResourcesInternal (
IN ARBITER_REQUEST_SOURCE ArbiterRequestSource,
IN PDEVICE_OBJECT DeviceObject,
IN PCM_RESOURCE_LIST BootResources
);
BOOLEAN
IopNeedToReleaseBootResources(
IN PDEVICE_NODE DeviceNode,
IN PCM_RESOURCE_LIST AllocatedResources
);
VOID
IopReleaseFilteredBootResources(
IN PIOP_RESOURCE_REQUEST AssignTable,
IN PIOP_RESOURCE_REQUEST AssignTableEnd
);
#if DBG_SCOPE
VOID
IopDumpResourceRequirementsList(
IN PIO_RESOURCE_REQUIREMENTS_LIST IoResources
);
VOID
IopDumpResourceDescriptor (
IN PUCHAR Indent,
IN PIO_RESOURCE_DESCRIPTOR Desc
);
#endif
#if DBG_SCOPE
VOID
IopCheckDataStructures (
IN PDEVICE_NODE DeviceNode
);
VOID
IopCheckDataStructuresWorker (
IN PDEVICE_NODE Device
);
#endif
NTSTATUS
IopQueryConflictListInternal(
PDEVICE_OBJECT PhysicalDeviceObject,
IN PCM_RESOURCE_LIST ResourceList,
IN ULONG ResourceListSize,
OUT PPLUGPLAY_CONTROL_CONFLICT_LIST ConflictList,
IN ULONG ConflictListSize,
IN ULONG Flags
);
NTSTATUS
IopQueryConflictFillConflicts(
PDEVICE_OBJECT PhysicalDeviceObject,
IN ULONG ConflictCount,
IN PARBITER_CONFLICT_INFO ConflictInfoList,
OUT PPLUGPLAY_CONTROL_CONFLICT_LIST ConflictList,
IN ULONG ConflictListSize,
IN ULONG Flags
);
NTSTATUS
IopQueryConflictFillString(
IN PDEVICE_OBJECT DeviceObject,
IN PWSTR Buffer,
IN OUT PULONG Length,
IN OUT PULONG Flags
);
BOOLEAN
IopEliminateBogusConflict(
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN PDEVICE_OBJECT ConflictDeviceObject
);
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, IopAllocateResources)
#pragma alloc_text(PAGE, IopGetResourceRequirementsForAssignTable)
#pragma alloc_text(PAGE, IopResourceRequirementsListToReqList)
#pragma alloc_text(PAGE, IopComparePriority)
#pragma alloc_text(PAGE, IopRearrangeReqList)
#pragma alloc_text(PAGE, IopRearrangeAssignTable)
#pragma alloc_text(PAGE, IopFreeResourceRequirementsForAssignTable)
#pragma alloc_text(PAGE, IopFreeReqList)
#pragma alloc_text(PAGE, IopFreeReqAlternative)
#pragma alloc_text(PAGE, IopAssign)
#pragma alloc_text(PAGE, IopBuildCmResourceLists)
#pragma alloc_text(PAGE, IopBuildCmResourceList)
#pragma alloc_text(PAGE, IopAssignInner)
#pragma alloc_text(PAGE, IopPlacement)
#pragma alloc_text(PAGE, IopAddReqDescsToArbiters)
#pragma alloc_text(PAGE, IopRemoveReqDescsFromArbiters)
#pragma alloc_text(PAGE, IopIsBestConfiguration)
#pragma alloc_text(PAGE, IopSaveCurrentConfiguration)
#pragma alloc_text(PAGE, IopRestoreBestConfiguration)
#pragma alloc_text(PAGE, IopFindResourceHandlerInfo)
#pragma alloc_text(PAGE, IopSetupArbiterAndTranslators)
#pragma alloc_text(PAGE, IopParentToRawTranslation)
#pragma alloc_text(PAGE, IopChildToRootTranslation)
#pragma alloc_text(PAGE, IopTranslateAndAdjustReqDesc)
#pragma alloc_text(PAGE, IopCallArbiter)
#pragma alloc_text(PAGE, IopQueryRebalance)
#pragma alloc_text(PAGE, IopTestForReconfiguration)
#pragma alloc_text(PAGE, IopPlacementForRebalance)
#pragma alloc_text(PAGE, IopArbitrateDeviceResources)
#pragma alloc_text(PAGE, IopRebalance)
#pragma alloc_text(PAGE, IopFindResourcesForArbiter)
//#pragma alloc_text(PAGE, IopLegacyResourceAllocation)
#pragma alloc_text(PAGE, IopFindLegacyDeviceNode)
#pragma alloc_text(PAGE, IopRemoveLegacyDeviceNode)
#pragma alloc_text(PAGE, IopFindBusDeviceNode)
#pragma alloc_text(PAGE, IopFindBusDeviceNodeInternal)
#pragma alloc_text(PAGE, IopDuplicateDetection)
#pragma alloc_text(PAGE, IopReleaseResourcesInternal)
#pragma alloc_text(PAGE, IopRestoreResourcesInternal)
#pragma alloc_text(PAGE, IopSetLegacyDeviceInstance)
#pragma alloc_text(PAGE, IopCombineLegacyResources)
#pragma alloc_text(PAGE, IopReserve)
#pragma alloc_text(PAGE, IopPlacementForReservation)
#pragma alloc_text(PAGE, IopAllocateBootResources)
#pragma alloc_text(PAGE, IopReserveBootResourcesInternal)
#pragma alloc_text(PAGE, IopReleaseResources)
#pragma alloc_text(PAGE, IopReallocateResources)
#pragma alloc_text(PAGE, IopReleaseFilteredBootResources)
#pragma alloc_text(PAGE, IopNeedToReleaseBootResources)
#pragma alloc_text(PAGE, IopQueryConflictList)
#pragma alloc_text(PAGE, IopQueryConflictListInternal)
#pragma alloc_text(PAGE, IopQueryConflictFillConflicts)
#pragma alloc_text(PAGE, IopQueryConflictFillString)
#pragma alloc_text(PAGE, IopEliminateBogusConflict)
#pragma alloc_text(PAGE, IopCreateCmResourceList)
#pragma alloc_text(PAGE, IopCombineCmResourceList)
#pragma alloc_text(INIT, IopReserveLegacyBootResources)
#pragma alloc_text(INIT, IopReserveBootResources)
#if DBG_SCOPE
#pragma alloc_text(PAGE, IopCheckDataStructures)
#pragma alloc_text(PAGE, IopCheckDataStructuresWorker)
#pragma alloc_text(PAGE, IopDumpResourceRequirementsList)
#pragma alloc_text(PAGE, IopDumpResourceDescriptor)
#endif
#endif
NTSTATUS
IopAllocateResources(
IN PULONG DeviceCountP,
IN OUT PIOP_RESOURCE_REQUEST *AssignTablePP,
IN BOOLEAN Locked,
IN BOOLEAN BootConfigsOK
)
/*++
Routine Description:
For each AssignTable entry, this routine queries device's IO resource requirements
list and converts it to our internal REQ_LIST format; calls worker routine to perform
the resources assignment.
Parameters:
AssignTable - supplies a pointer to the first entry of a IOP_RESOURCE_REQUEST table.
AssignTableEnd - supplies a pointer to the end of IOP_RESOURCE_REQUEST table.
Locked - Indicates whether the IopRegistrySemaphore is acquired by the caller.
BootConfigsOK - Indicates whether we should assign BOOT configs.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PIOP_RESOURCE_REQUEST AssignTable;
PIOP_RESOURCE_REQUEST AssignTableEnd;
PIOP_RESOURCE_REQUEST AssignTableTail;
PIOP_RESOURCE_REQUEST AssignEntry;
PIOP_RESOURCE_REQUEST AssignEntryOriginal;
ULONG AssignTableCount;
ULONG DeviceCount;
NTSTATUS Status;
BOOLEAN FreeAssignTable;
BOOLEAN tryRebalance;
PAGED_CODE();
DeviceCount = *DeviceCountP;
FreeAssignTable = FALSE;
tryRebalance = TRUE;
AssignTable = *AssignTablePP;
AssignTableEnd = AssignTable + DeviceCount;
// If legacy device resource allocation, don't rebalance on failure,
// if the resource they want is already assigned, what they are looking
// for isn't there.
if ((DeviceCount == 1) && (AssignTable->Flags & IOP_ASSIGN_NO_REBALANCE)) {
tryRebalance = FALSE;
}
// Grab the IO registry semaphore to make sure no other device is
// reporting it's resource usage while we are searching for conflicts.
if (!Locked) {
KeEnterCriticalRegion();
Status = KeWaitForSingleObject( &IopRegistrySemaphore,
DelayExecution,
KernelMode,
FALSE,
NULL );
if (!NT_SUCCESS(Status)) {
DebugMessage(DUMP_ERROR, ("IopAllocateResources: Get RegistrySemaphore failed. Status %x\n", Status));
KeLeaveCriticalRegion();
return Status;
}
}
// Get the resource requirements.
Status = IopGetResourceRequirementsForAssignTable(AssignTable, AssignTableEnd, &DeviceCount);
if (DeviceCount == 0) {
DebugMessage(DUMP_INFO, ("IopAllocateResources: Get Requirements for Assign Table found nothing. status %x\n", Status));
if (!Locked) {
KeReleaseSemaphore(&IopRegistrySemaphore, 0, 1, FALSE);
KeLeaveCriticalRegion();
}
return Status;
}
// Check if it is OK to assign resources to devices with BOOT configs.
if (BootConfigsOK) {
if (!IopBootConfigsReserved) {
// Process devices with BOOT configs or no requirements first.
for (AssignEntry = AssignTable; AssignEntry < AssignTableEnd; AssignEntry++) {
PDEVICE_NODE deviceNode = (PDEVICE_NODE)AssignEntry->PhysicalDevice->DeviceObjectExtension->DeviceNode;
if (deviceNode->Flags & DNF_HAS_BOOT_CONFIG) {
break;
}
}
if (AssignEntry != AssignTableEnd) {
// There are devices with BOOT config.
for (AssignEntry = AssignTable; AssignEntry < AssignTableEnd; AssignEntry++) {
PDEVICE_NODE deviceNode = (PDEVICE_NODE)AssignEntry->PhysicalDevice->DeviceObjectExtension->DeviceNode;
if ( !(AssignEntry->Flags & IOP_ASSIGN_IGNORE) && !(deviceNode->Flags & DNF_HAS_BOOT_CONFIG) && AssignEntry->ResourceRequirements && AssignEntry->AllocationType != ArbiterRequestPnpDetected) {
DeviceCount--;
DebugMessage(DUMP_INFO, ("Delaying non BOOT config device %ws...\n", deviceNode->InstancePath.Buffer));
AssignEntry->Status = STATUS_RETRY;
AssignEntry->Flags |= IOP_ASSIGN_IGNORE;
IopFreeResourceRequirementsForAssignTable(AssignEntry, AssignEntry + 1);
}
}
}
if (DeviceCount == 0) {
if (!Locked) {
KeReleaseSemaphore(&IopRegistrySemaphore, 0, 1, FALSE);
KeLeaveCriticalRegion();
}
return Status;
}
}
// Check if we need to allocate a new table.
if (DeviceCount != *DeviceCountP) {
// Allocate a new table.
AssignTable = (PIOP_RESOURCE_REQUEST) ExAllocatePoolAT( PagedPool, sizeof(IOP_RESOURCE_REQUEST) * DeviceCount);
if (AssignTable == NULL) {
IopFreeResourceRequirementsForAssignTable(*AssignTablePP, AssignTableEnd);
if (!Locked) {
KeReleaseSemaphore(&IopRegistrySemaphore, 0, 1, FALSE);
KeLeaveCriticalRegion();
}
return STATUS_INSUFFICIENT_RESOURCES;
}
FreeAssignTable = TRUE;
// Process the AssignTable to remove any entry which is marked as IOP_ASSIGN_IGNORE.
AssignEntryOriginal = *AssignTablePP;
AssignTableEnd = AssignTable + DeviceCount;
for (AssignEntry = AssignTable; AssignEntry < AssignTableEnd;) {
if (!(AssignEntryOriginal->Flags & IOP_ASSIGN_IGNORE)) {
*AssignEntry = *AssignEntryOriginal;
AssignEntry++;
}
AssignEntryOriginal++;
}
}
} else {
// Only process devices with no resource requirements. Rest get STATUS_RETRY.
for (AssignEntry = AssignTable; AssignEntry < AssignTableEnd; AssignEntry++) {
if ( !(AssignEntry->Flags & IOP_ASSIGN_IGNORE) &&
AssignEntry->ResourceRequirements) {
PDEVICE_NODE deviceNode = (PDEVICE_NODE)AssignEntry->PhysicalDevice->DeviceObjectExtension->DeviceNode;
DebugMessage(DUMP_INFO, ("Delaying resources requiring device %ws...\n", deviceNode->InstancePath.Buffer));
IopFreeResourceRequirementsForAssignTable(AssignEntry, AssignEntry + 1);
AssignEntry->Status = STATUS_RETRY;
}
}
// Release the I/O Registry Semaphore
if (!Locked) {
KeReleaseSemaphore(&IopRegistrySemaphore, 0, 1, FALSE);
KeLeaveCriticalRegion();
}
return Status;
}
AssignTableCount = (ULONG)(AssignTableEnd - AssignTable);
ASSERT(AssignTableCount == DeviceCount);
// Sort the AssignTable
IopRearrangeAssignTable(AssignTable, DeviceCount);
for (AssignEntry = AssignTable; AssignEntry < AssignTableEnd; AssignEntry++) {
PDEVICE_NODE deviceNode = (PDEVICE_NODE)AssignEntry->PhysicalDevice->DeviceObjectExtension->DeviceNode;
DebugMessage(DUMP_INFO, ("Pnpres: Trying to allocate resources for %ws.\n", deviceNode->InstancePath.Buffer));
Status = IopAssignInner(1, AssignEntry, FALSE);
if (NT_SUCCESS(Status)) {
IopBuildCmResourceLists(AssignEntry, AssignEntry + 1);
if (AssignEntry->AllocationType == ArbiterRequestPnpEnumerated) {
IopReleaseFilteredBootResources(AssignEntry, AssignEntry + 1);
}
} else if (Status == STATUS_INSUFFICIENT_RESOURCES) {
DebugMessage(DUMP_ERROR, ("IopAllocateResource: Failed to allocate Pool.\n"));
break;
} else if (tryRebalance) {
DebugMessage(DUMP_INFO, ("IopAllocateResources: Initiating REBALANCE...\n"));
deviceNode->Flags |= DNF_NEEDS_REBALANCE;
Status = IopRebalance(1, AssignEntry);
deviceNode->Flags &= ~DNF_NEEDS_REBALANCE;
if (!NT_SUCCESS(Status)) {
AssignEntry->Status = STATUS_CONFLICTING_ADDRESSES;
}
} else {
AssignEntry->Status = STATUS_CONFLICTING_ADDRESSES;
}
}
// IF we did not go through the entire table without any error,
// mark remaining entries as RETRY.
for (; AssignEntry < AssignTableEnd; AssignEntry++) {
AssignEntry->Status = STATUS_RETRY;
}
IopFreeResourceRequirementsForAssignTable(AssignTable, AssignTableEnd);
// Release the I/O Registry Semaphore
if (!Locked) {
KeReleaseSemaphore( &IopRegistrySemaphore, 0, 1, FALSE );
KeLeaveCriticalRegion( );
}
// Copy the information in our own AssignTable to caller's AssignTable
if (FreeAssignTable) {
AssignEntryOriginal = *AssignTablePP;
for (AssignEntry = AssignTable; AssignEntry < AssignTableEnd;) {
if (AssignEntryOriginal->Flags & (IOP_ASSIGN_IGNORE | IOP_ASSIGN_RETRY)) {
AssignEntryOriginal++;
continue;
}
*AssignEntryOriginal = *AssignEntry;
AssignEntry++;
AssignEntryOriginal++;
}
ASSERT(AssignEntryOriginal <= *AssignTablePP + *DeviceCountP);
ExFreePool(AssignTable);
}
AssignEntry = *AssignTablePP;
while (AssignEntry < *AssignTablePP + *DeviceCountP) {
if (AssignEntry->Flags & (IOP_ASSIGN_IGNORE | IOP_ASSIGN_RETRY)) {
AssignEntry++;
continue;
}
if ((AssignEntry->Flags & IOP_ASSIGN_EXCLUDE) || AssignEntry->ResourceAssignment == NULL) {
AssignEntry->Status = STATUS_CONFLICTING_ADDRESSES;
}
AssignEntry++;
}
return Status;
}
NTSTATUS
IopGetResourceRequirementsForAssignTable(
IN PIOP_RESOURCE_REQUEST AssignTable,
IN PIOP_RESOURCE_REQUEST AssignTableEnd,
OUT PULONG DeviceCount
)
/*++
Routine Description:
For each AssignTable entry, this routine queries device's IO resource requirements
list and converts it to our internal REQ_LIST format.
Parameters:
AssignTable - supplies a pointer to the first entry of a IOP_RESOURCE_REQUEST table.
AssignTableEnd - supplies a pointer to the end of IOP_RESOURCE_REQUEST table.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
NTSTATUS Status, FinalStatus = STATUS_UNSUCCESSFUL;
PIOP_RESOURCE_REQUEST AssignEntry;
PDEVICE_OBJECT PhysicalDevice;
PDEVICE_NODE DeviceNode;
ULONG Length, Count = 0;
PAGED_CODE();
// Go thru each entry, if the io resource requirements is not established,
// we will first see if the device node contains an io resreq, if yes, we will
// use it. Otherwise, we will query resource requirements from the driver and cache
// it in our device node structure.
for (AssignEntry = AssignTable; AssignEntry < AssignTableEnd; ++AssignEntry) {
AssignEntry->ReqList = NULL;
if (AssignEntry->Flags & IOP_ASSIGN_IGNORE) {
FinalStatus = STATUS_SUCCESS;
continue;
}
AssignEntry->ResourceAssignment = NULL;
AssignEntry->TranslatedResourceAssignment = NULL;
PhysicalDevice = AssignEntry->PhysicalDevice;
DeviceNode = (PDEVICE_NODE)PhysicalDevice->DeviceObjectExtension->DeviceNode;
if (DeviceNode->Flags & DNF_RESOURCE_REQUIREMENTS_CHANGED) {
if (DeviceNode->ResourceRequirements) {
ExFreePool(DeviceNode->ResourceRequirements);
DeviceNode->ResourceRequirements = NULL;
// Mark that we need to cleare the resource requirements changed flag when
// succeed.
AssignEntry->Flags |= IOP_ASSIGN_CLEAR_RESOURCE_REQUIREMENTS_CHANGE_FLAG;
DeviceNode->Flags &= ~DNF_RESOURCE_REQUIREMENTS_NEED_FILTERED;
//DeviceNode->Flags &= ~DNF_RESOURCE_REQUIREMENTS_CHANGED;
}
}
if (!AssignEntry->ResourceRequirements) {
if (DeviceNode->ResourceRequirements &&
!(DeviceNode->Flags & DNF_RESOURCE_REQUIREMENTS_NEED_FILTERED)) {
DebugMessage(DUMP_DETAIL, ("Pnpres: Resource requirements list already exists for %ws\n", DeviceNode->InstancePath.Buffer));
AssignEntry->ResourceRequirements = DeviceNode->ResourceRequirements;
AssignEntry->AllocationType = ArbiterRequestPnpEnumerated;
} else {
DebugMessage(DUMP_INFO,("Pnpres: Query Resource requirements list for %ws...\n", DeviceNode->InstancePath.Buffer));
Status = IopQueryDeviceResources (PhysicalDevice,
QUERY_RESOURCE_REQUIREMENTS,
&AssignEntry->ResourceRequirements,
&Length
);
if (!NT_SUCCESS(Status)) {
AssignEntry->Flags |= IOP_ASSIGN_IGNORE;
AssignEntry->Status = Status;
continue;
} else if (AssignEntry->ResourceRequirements == NULL) {
// Status Success with NULL ResourceRequirements means
// no resource required.
AssignEntry->Flags |= IOP_ASSIGN_IGNORE;
AssignEntry->Status = Status;
continue;
}
if (DeviceNode->ResourceRequirements) {
ExFreePool(DeviceNode->ResourceRequirements);
DeviceNode->Flags &= ~DNF_RESOURCE_REQUIREMENTS_NEED_FILTERED;
}
DeviceNode->ResourceRequirements = AssignEntry->ResourceRequirements;
}
}
// For non-stop case, even though the res req list has changed, we need
// to guarantee that it still get its current setting, if possible.
// Note, if the new resreq list does not cover the old setting. It's bus
// drivers' responsibility to guarantee that non of their child would be
// affected. Otherwise, the bus drivers should not ask for non-stop.
if (AssignEntry->Flags & IOP_ASSIGN_KEEP_CURRENT_CONFIG) {
PIO_RESOURCE_REQUIREMENTS_LIST filteredList;
BOOLEAN exactMatch;
Status = IopFilterResourceRequirementsList (
AssignEntry->ResourceRequirements,
DeviceNode->ResourceList,
&filteredList,
&exactMatch
);
if (NT_SUCCESS(Status)) {
// Do not free the original AssignEntry->ResourceRequirements.
// It is used by deviceNode->ResourceRequirements.
AssignEntry->ResourceRequirements = filteredList;
} else {
AssignEntry->Flags &= ~IOP_ASSIGN_KEEP_CURRENT_CONFIG;
}
}
#if DBG_SCOPE
if (PnpResDebugLevel & DUMP_INFO) {
IopDumpResourceRequirementsList(AssignEntry->ResourceRequirements);
}
#endif
// Convert Io resource requirements list to our internal representation.
Status = IopResourceRequirementsListToReqList(
AssignEntry->AllocationType,
AssignEntry->ResourceRequirements,
PhysicalDevice,
&AssignEntry->ReqList);
if (!NT_SUCCESS(Status) || AssignEntry->ReqList == NULL) {
AssignEntry->Flags |= IOP_ASSIGN_IGNORE;
AssignEntry->Status = Status;
continue;
} else {
PREQ_LIST ReqList;
ReqList = (PREQ_LIST)AssignEntry->ReqList;
ReqList->AssignEntry = AssignEntry;
// Sort the ReqList such that the higher priority Alternative list are
// placed in the front of the list.
IopRearrangeReqList(ReqList);
if (ReqList->ReqBestAlternative == NULL) {
AssignEntry->Flags |= IOP_ASSIGN_IGNORE;
AssignEntry->Status = STATUS_DEVICE_CONFIGURATION_ERROR;
IopFreeResourceRequirementsForAssignTable(AssignEntry, AssignEntry + 1);
continue;
} else if (ReqList->ReqAlternativeCount < 3) {
AssignEntry->Priority = 0;
} else {
AssignEntry->Priority = ReqList->ReqAlternativeCount;
}
}
AssignEntry->Status = STATUS_SUCCESS;
Count++;
// As long as there is one entry established, we will return success.
FinalStatus = STATUS_SUCCESS;
}
*DeviceCount = Count;
return FinalStatus;
}
NTSTATUS
IopResourceRequirementsListToReqList(
IN ARBITER_REQUEST_SOURCE AllocationType,
IN PIO_RESOURCE_REQUIREMENTS_LIST IoResources,
IN PDEVICE_OBJECT PhysicalDevice,
OUT PVOID *ResReqList
)
/*++
Routine Description:
This routine processes the input Io resource requirements list and
generates an internal REQ_LIST and its related structures.
Parameters:
IoResources - supplies a pointer to the Io resource requirements List.
PhysicalDevice - supplies a pointer to the physical device object requesting
the resources.
ReqList - supplies a pointer to a variable to receive the returned REQ_LIST.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
NTSTATUS status;
PIO_RESOURCE_LIST IoResourceList = IoResources->List;
PIO_RESOURCE_DESCRIPTOR IoResourceDescriptor, BaseDescriptor, firstDescriptor;
PIO_RESOURCE_DESCRIPTOR IoResourceDescriptorEnd;
LONG IoResourceListCount = (LONG) IoResources->AlternativeLists;
PUCHAR CoreEnd = (PUCHAR) IoResources + IoResources->ListSize;
ULONG ReqAlternativeCount = IoResourceListCount;
ULONG ReqDescAlternativeCount = 0;
ULONG AlternativeDescriptorCount = 0; // count of descriptors with IO_RESOURCE_ALTERNATIVE flag set
PREQ_LIST ReqList;
BOOLEAN NoAlternativeDescriptor;
INTERFACE_TYPE interfaceType;
ULONG busNumber;
NTSTATUS failureStatus = STATUS_UNSUCCESSFUL;
NTSTATUS finalStatus = STATUS_SUCCESS;
PAGED_CODE();
*ResReqList = NULL;
// Make sure there is some resource requirements to be fulfilled.
if (IoResourceListCount == 0) {
DebugMessage(DUMP_INFO, ("PnpRes: No ResReqList to convert to ReqList\n"));
return STATUS_SUCCESS;
}
// ***** Phase 1 *****
// Parse the IO ResReq list to make sure it is valid and to determine the sizes of
// internal structures.
while (--IoResourceListCount >= 0) {
IoResourceDescriptor = firstDescriptor = IoResourceList->Descriptors;
IoResourceDescriptorEnd = IoResourceDescriptor + IoResourceList->Count;
if (IoResourceDescriptor == IoResourceDescriptorEnd) {
// An alternative list with zero descriptor count
return STATUS_SUCCESS;
}
// Perform sanity check. We have not allocated any pool space.
// If failed, simply return failure status.
if ((PUCHAR) IoResourceDescriptor > CoreEnd) {
// The structure header (excluding the variable length Descriptors array) is
// invalid.
DebugMessage(DUMP_ERROR, ("PnpRes: Invalid ResReqList\n"));
goto InvalidParameter;
}
if (IoResourceDescriptor > IoResourceDescriptorEnd ||
(PUCHAR) IoResourceDescriptorEnd > CoreEnd) {
// IoResourceDescriptorEnd is the result of arithmetic overflow;
// or, the descriptor array is outside of the valid memory.
DebugMessage(DUMP_ERROR, ("PnpRes: Invalid ResReqList\n"));
goto InvalidParameter;
}
if (IoResourceDescriptor->Type == CmResourceTypeConfigData) {
IoResourceDescriptor++;
firstDescriptor++;
}
NoAlternativeDescriptor = TRUE;
while (IoResourceDescriptor < IoResourceDescriptorEnd) {
switch (IoResourceDescriptor->Type) {
case CmResourceTypeConfigData:
#if DBG_SCOPE
if (PnpResDebugLevel & DUMP_ERROR) {
DbgPrint("PnPRes: Invalid ResReq list !!!\n");
DbgPrint(" ConfigData descriptors are per-LogConf and\n");
DbgPrint(" should be at the beginning of an AlternativeList\n");
ASSERT(0);
}
#endif
goto InvalidParameter;
case CmResourceTypeDevicePrivate:
while (IoResourceDescriptor < IoResourceDescriptorEnd &&
IoResourceDescriptor->Type == CmResourceTypeDevicePrivate) {
if (IoResourceDescriptor == firstDescriptor) {
#if DBG_SCOPE
if (PnpResDebugLevel & DUMP_ERROR) {
DbgPrint("PnPRes: Invalid ResReq list !!!\n");
DbgPrint(" The first descriptor of a LogConf can not be\n");
DbgPrint(" a DevicePrivate descriptor.\n");
ASSERT(0);
}
#endif
goto InvalidParameter;
}
ReqDescAlternativeCount++; // Count number of descriptors
IoResourceDescriptor++;
}
NoAlternativeDescriptor = TRUE;
break;
default:
++ReqDescAlternativeCount; // Count number of descriptors
// For non-arbitrated resource type, set its Option to preferred such
// that we won't get confused.
if ((IoResourceDescriptor->Type & CmResourceTypeNonArbitrated) ||
(IoResourceDescriptor->Type == CmResourceTypeNull)) {
if (IoResourceDescriptor->Type == CmResourceTypeReserved) {
--ReqDescAlternativeCount;
}
IoResourceDescriptor->Option = IO_RESOURCE_PREFERRED;
IoResourceDescriptor++;
NoAlternativeDescriptor = TRUE;
break;
}
if (IoResourceDescriptor->Option & IO_RESOURCE_ALTERNATIVE) {
if (NoAlternativeDescriptor) {
#if DBG_SCOPE
if (PnpResDebugLevel & DUMP_ERROR) {
DbgPrint("PnPRes: Invalid ResReq list !!!\n");
DbgPrint(" Alternative descriptor without Default or Preferred descriptor.\n");
ASSERT(0);
}
#endif
goto InvalidParameter;
}
++AlternativeDescriptorCount; // Count number of Alternative descriptors
} else {
NoAlternativeDescriptor = FALSE;
}
IoResourceDescriptor++;
break;
}
}
ASSERT(IoResourceDescriptor == IoResourceDescriptorEnd);
IoResourceList = (PIO_RESOURCE_LIST) IoResourceDescriptorEnd;
}
// ***** Phase 2 *****
// Allocate structures and initialize them according to caller's Io ResReq list.
{
ULONG ReqDescCount = ReqDescAlternativeCount - AlternativeDescriptorCount;
PUCHAR PoolStart;
ULONG PoolSize;
IOP_POOL OuterPool;
IOP_POOL ReqAlternativePool;
IOP_POOL ReqDescPool;
PREQ_ALTERNATIVE ReqAlternative;
PREQ_ALTERNATIVE *ReqAlternativePP;
#if DBG
PREQ_ALTERNATIVE *ReqAlternativeEndPP;
#endif
PREQ_DESC ReqDesc;
PREQ_DESC *ReqDescPP;
ULONG ReqAlternativeIndex;
ULONG ReqDescIndex;
// Each structure in the list has a variable length array.
// Those arrays are declared in their typedefs as arrays with one element,
// that extra element is not being substracted because it provides an
// extra 4 bytes of memory that is 50% (statistically) wasted and 50%
// (statistically) used to allow for 8 byte alignment of all the structures.
// Allocate the pool and fail if the allocation failed.
{
ULONG ReqListPoolSize =
(FIELD_OFFSET(REQ_LIST, ReqAlternativeTable) +
sizeof(PVOID) * ReqAlternativeCount + STRUCTURE_ALIGNMENT - 1) &
~(STRUCTURE_ALIGNMENT - 1);
ULONG ReqAlternativePoolSize = (ReqAlternativeCount *
(FIELD_OFFSET(REQ_ALTERNATIVE, ReqDescTable) +
+ sizeof(PVOID) * ReqDescCount + STRUCTURE_ALIGNMENT - 1))
& ~(STRUCTURE_ALIGNMENT - 1);
ULONG ReqDescPoolSize = (ReqDescCount * (sizeof(REQ_DESC) + STRUCTURE_ALIGNMENT - 1))
& ~(STRUCTURE_ALIGNMENT - 1);
PoolSize = ReqListPoolSize + ReqAlternativePoolSize + ReqDescPoolSize;
PoolStart = ExAllocatePoolRD(PagedPool, PoolSize);
if (!PoolStart) {
return STATUS_INSUFFICIENT_RESOURCES;
}
IopInitPool(&OuterPool, PoolStart, PoolSize);
// Partition the OuterPool into inner pools.
IopAllocPoolAligned(&ReqList, &OuterPool, ReqListPoolSize);
IopAllocPoolAligned(&PoolStart, &OuterPool, ReqAlternativePoolSize);
IopInitPool(&ReqAlternativePool, PoolStart, ReqAlternativePoolSize);
IopAllocPoolAligned(&PoolStart, &OuterPool, ReqDescPoolSize);
IopInitPool(&ReqDescPool, PoolStart, ReqDescPoolSize);
}
// Convert the IO_RESOURCE_REQUIREMENTS_LIST into the REQ_LIST.
ReqAlternativePP = ReqList->ReqAlternativeTable;
RtlZeroMemory(ReqAlternativePP, ReqAlternativeCount * sizeof(PREQ_ALTERNATIVE));
#if DBG
ReqAlternativeEndPP = ReqAlternativePP + ReqAlternativeCount;
#endif
ReqList->ReqAlternativeCount = ReqAlternativeCount;
ReqList->PhysicalDevice = PhysicalDevice;
ReqList->InterfaceType = IoResources->InterfaceType;
if (ReqList->InterfaceType == InterfaceTypeUndefined) {
ReqList->InterfaceType = PnpDefaultInterfaceType;
}
ReqList->BusNumber = IoResources->BusNumber;
ReqList->SelectedAlternative = NULL;
ReqAlternativeIndex = 0;
interfaceType = IoResources->InterfaceType;
if (interfaceType == InterfaceTypeUndefined) {
interfaceType = PnpDefaultInterfaceType;
}
busNumber = IoResources->BusNumber;
IoResourceList = IoResources->List;
IoResourceListCount = IoResources->AlternativeLists;
while (--IoResourceListCount >= 0) {
ULONG arbiterFlag;
IoResourceDescriptor = IoResourceList->Descriptors;
IoResourceDescriptorEnd = IoResourceDescriptor + IoResourceList->Count;
// For each Io alternate list, we create a REQ_ALTERNATE table
IopAllocPoolAligned(&ReqAlternative, &ReqAlternativePool, FIELD_OFFSET(REQ_ALTERNATIVE, ReqDescTable));
ReqAlternative->ReqList = ReqList;
ReqAlternative->ReqAlternativeIndex = ReqAlternativeIndex++;
ASSERT(ReqAlternativePP < ReqAlternativeEndPP);
*ReqAlternativePP++ = ReqAlternative;
ReqAlternative->ReqDescCount = 0;
ReqAlternative->ReqDescTableEnd = ReqAlternative->ReqDescTable;
// If the first descriptor of the alternative is a CmResourceTypeConfigData
// it contains priority information.
if (IoResourceDescriptor->Type == CmResourceTypeConfigData) {
ReqAlternative->Priority = IoResourceDescriptor->u.ConfigData.Priority;
IoResourceDescriptor++;
} else {
ReqAlternative->Priority = LCPRI_NORMAL;
}
if (ReqAlternative->Priority == LCPRI_BOOTCONFIG) {
arbiterFlag = ARBITER_FLAG_BOOT_CONFIG;
} else {
arbiterFlag = 0;
}
ReqDescPP = ReqAlternative->ReqDescTable;
ReqDescIndex = 0;
while (IoResourceDescriptor < IoResourceDescriptorEnd) {
PARBITER_LIST_ENTRY ArbiterListEntry;
if (IoResourceDescriptor->Type == CmResourceTypeReserved) {
interfaceType = IoResourceDescriptor->u.DevicePrivate.Data[0];
if (interfaceType == InterfaceTypeUndefined) {
interfaceType = PnpDefaultInterfaceType;
}
busNumber = IoResourceDescriptor->u.DevicePrivate.Data[1];
IoResourceDescriptor++;
} else {
IopAllocPoolAligned(&ReqDesc, &ReqDescPool, sizeof(REQ_DESC));
ReqDesc->ArbitrationRequired =
(IoResourceDescriptor->Type & CmResourceTypeNonArbitrated ||
IoResourceDescriptor->Type == CmResourceTypeNull) ? FALSE : TRUE;
ReqDesc->ReqAlternative = ReqAlternative;
ReqDesc->ReqDescIndex = ReqDescIndex++;
ReqDesc->DevicePrivateCount = 0;
ReqDesc->DevicePrivate = NULL;
ReqDesc->InterfaceType = interfaceType;
ReqDesc->BusNumber = busNumber;
IopAllocPool(&PoolStart, &ReqAlternativePool, sizeof(PVOID));
ASSERT(PoolStart == (PUCHAR) ReqDescPP);
*ReqDescPP++ = ReqDesc;
++ReqAlternative->ReqDescCount;
++ReqAlternative->ReqDescTableEnd;
ReqDesc->TranslatedReqDesc = ReqDesc; // TranslatedReqDesc points to itself.
ArbiterListEntry = &ReqDesc->AlternativeTable;
InitializeListHead(&ArbiterListEntry->ListEntry);
ArbiterListEntry->AlternativeCount = 0;
ArbiterListEntry->Alternatives = IoResourceDescriptor;
ArbiterListEntry->PhysicalDeviceObject = PhysicalDevice;
ArbiterListEntry->RequestSource = AllocationType;
ArbiterListEntry->Flags = arbiterFlag;
ArbiterListEntry->WorkSpace = 0;
ArbiterListEntry->InterfaceType = interfaceType;
ArbiterListEntry->SlotNumber = IoResources->SlotNumber;
ArbiterListEntry->BusNumber = IoResources->BusNumber;
ArbiterListEntry->Assignment = &ReqDesc->Allocation;
ArbiterListEntry->Result = ArbiterResultUndefined;
if (ReqDesc->ArbitrationRequired) {
// The BestAlternativeTable and BestAllocation are not initialized.
// They will be initialized when needed.
// Initialize the Cm partial resource descriptor to NOT_ALLOCATED.
ReqDesc->Allocation.Type = CmResourceTypeMaximum;
ASSERT((IoResourceDescriptor->Option & IO_RESOURCE_ALTERNATIVE) == 0);
ArbiterListEntry->AlternativeCount++;
IoResourceDescriptor++;
while (IoResourceDescriptor < IoResourceDescriptorEnd) {
if (IoResourceDescriptor->Type == CmResourceTypeDevicePrivate) {
ReqDesc->DevicePrivate = IoResourceDescriptor;
while (IoResourceDescriptor < IoResourceDescriptorEnd &&
IoResourceDescriptor->Type == CmResourceTypeDevicePrivate) {
ReqDesc->DevicePrivateCount++;
++IoResourceDescriptor;
}
break;
}
if (IoResourceDescriptor->Option & IO_RESOURCE_ALTERNATIVE) {
ArbiterListEntry->AlternativeCount++;
IoResourceDescriptor++;
} else {
break;
}
}
// Next query Arbiter and Translator interfaces for the resource desc.
status = IopSetupArbiterAndTranslators(ReqDesc);
if (!NT_SUCCESS(status)) {
DebugMessage(DUMP_ERROR, ("PnpRes: Unable to setup Arbiter and Translators\n"));
ReqAlternativeIndex--;
ReqAlternativePP--;
ReqList->ReqAlternativeCount--;
IopFreeReqAlternative(ReqAlternative);
failureStatus = status;
break;
}
} else {
ReqDesc->Allocation.Type = IoResourceDescriptor->Type;
ReqDesc->Allocation.ShareDisposition = IoResourceDescriptor->ShareDisposition;
ReqDesc->Allocation.Flags = IoResourceDescriptor->Flags;
ReqDesc->Allocation.u.DevicePrivate.Data[0] =
IoResourceDescriptor->u.DevicePrivate.Data[0];
ReqDesc->Allocation.u.DevicePrivate.Data[1] =
IoResourceDescriptor->u.DevicePrivate.Data[1];
ReqDesc->Allocation.u.DevicePrivate.Data[2] =
IoResourceDescriptor->u.DevicePrivate.Data[2];
IoResourceDescriptor++;
}
}
if (IoResourceDescriptor >= IoResourceDescriptorEnd) break;
}
IoResourceList = (PIO_RESOURCE_LIST) IoResourceDescriptorEnd;
}
if (ReqAlternativeIndex == 0) {
finalStatus = failureStatus;
IopFreeReqList(ReqList);
}
}
if (finalStatus == STATUS_SUCCESS) {
*ResReqList = ReqList;
}
return finalStatus;
InvalidParameter:
return STATUS_INVALID_PARAMETER;
}
int
__cdecl
IopComparePriority(
const void *arg1,
const void *arg2
)
/*++
Routine Description:
This routine compares the priority of arg1 and arg1. It is used in C run time sort.
Parameters:
Arg1, arg2 - a pointer to PREQ_ALTERNATIVE
Return Value:
< 0 if arg1 < arg2
= 0 if arg1 = arg2
> 0 if arg1 > arg2
--*/
{
PREQ_ALTERNATIVE RA1 = *(PREQ_ALTERNATIVE *)arg1;
PREQ_ALTERNATIVE RA2 = *(PREQ_ALTERNATIVE *)arg2;
PAGED_CODE();
if (RA1->Priority == RA2->Priority) {
if ((ULONG_PTR)RA1 < (ULONG_PTR)RA2) {
return -1;
} else {
return 1;
}
}
if (RA1->Priority > RA2->Priority) {
return 1;
} else {
return -1;
}
}
int
__cdecl
IopCompareAlternativeCount(
const void *arg1,
const void *arg2
)
/*++
Routine Description:
This routine compares the priority of arg1 and arg1. It is used in C run time sort.
Parameters:
Arg1, arg2 - a pointer to PREQ_ALTERNATIVE
Return Value:
< 0 if arg1 < arg2
= 0 if arg1 = arg2
> 0 if arg1 > arg2
--*/
{
PIOP_RESOURCE_REQUEST RR1 = (PIOP_RESOURCE_REQUEST)arg1;
PIOP_RESOURCE_REQUEST RR2 = (PIOP_RESOURCE_REQUEST)arg2;
PAGED_CODE();
if (RR1->Priority == RR2->Priority) {
if ((ULONG_PTR)RR1 < (ULONG_PTR)RR2) {
return -1;
} else {
return 1;
}
}
if (RR1->Priority > RR2->Priority) {
return 1;
} else {
return -1;
}
}
VOID
IopRearrangeReqList (
IN PREQ_LIST ReqList
)
/*++
Routine Description:
This routine sorts the REQ_ALTERNATIVE lists of REQ_LIST in increasing order (in terms of
priority value.) Priority 1 is considered better than priority 2.
So, the better choice is placed in front of the list.
Parameters:
ReqList - Supplies a pointer to a REQ_LIST.
Return Value:
None.
--*/
{
PREQ_ALTERNATIVE *alternative;
PREQ_ALTERNATIVE *lastAlternative;
PAGED_CODE();
if (ReqList->ReqAlternativeCount > 1) {
qsort( (void *)ReqList->ReqAlternativeTable,
ReqList->ReqAlternativeCount,
sizeof(PREQ_ALTERNATIVE),
IopComparePriority);
}
// Set the BestAlternative so that we try alternatives with priority <= LCPRI_LASTSOFTCONFIG.
alternative = &ReqList->ReqAlternativeTable[0];
for (lastAlternative = alternative + ReqList->ReqAlternativeCount; alternative < lastAlternative; alternative++) {
if ((*alternative)->Priority > LCPRI_LASTSOFTCONFIG) {
break;
}
}
if (alternative == &ReqList->ReqAlternativeTable[0]) {
PDEVICE_NODE deviceNode = (PDEVICE_NODE)ReqList->PhysicalDevice->DeviceObjectExtension->DeviceNode;
DebugMessage(DUMP_ERROR, ("PNPRES: Invalid priorities in the logical configs for %ws\n", deviceNode->InstancePath.Buffer));
// ASSERT(alternative != &ReqList->ReqAlternativeTable[0]);
ReqList->ReqBestAlternative = NULL;
} else {
ReqList->ReqBestAlternative = alternative;
}
}
VOID
IopRearrangeAssignTable (
IN PIOP_RESOURCE_REQUEST AssignTable,
IN ULONG Count
)
/*++
Routine Description:
This routine sorts the REQ_ALTERNATIVE lists of REQ_LIST in increasing order (in terms of
priority value.) Priority 1 is considered better than priority 2.
So, the better choice is placed in front of the list.
Parameters:
ReqList - Supplies a pointer to a REQ_LIST.
Return Value:
None.
--*/
{
PAGED_CODE();
if (Count == 1 || Count == 0) {
// Most ReqLists only have one alternative...
return;
}
qsort((void *)AssignTable,
Count,
sizeof(IOP_RESOURCE_REQUEST),
IopCompareAlternativeCount
);
}
VOID
IopFreeReqAlternative (
IN PREQ_ALTERNATIVE ReqAlternative
)
{
PREQ_DESC reqDesc, reqDescx;
ULONG i;
PAGED_CODE();
if (ReqAlternative) {
for (i = 0; i < ReqAlternative->ReqDescCount; i++) {
reqDesc = ReqAlternative->ReqDescTable[i];
reqDescx = reqDesc->TranslatedReqDesc;
while (reqDescx && IS_TRANSLATED_REQ_DESC(reqDescx)) {
reqDesc = reqDescx;
if (reqDescx->AlternativeTable.Alternatives) {
ExFreePool(reqDescx->AlternativeTable.Alternatives);
}
reqDescx = reqDescx->TranslatedReqDesc;
ExFreePool(reqDesc);
}
}
}
}
VOID
IopFreeReqList (
IN PREQ_LIST ReqList
)
/*++
Routine Description:
This routine release the ReqList associated with a resource requirements list
Parameters:
ReqList - supplies a pointer to the REQ_LIST.
Return Value:
None.
--*/
{
ULONG i;
PAGED_CODE();
if (ReqList) {
// First we need to free all the *extra* req descs for translators.
// The default Req Desc will be freed when the ReqList is freed.
for (i = 0; i < ReqList->ReqAlternativeCount; i++) {
IopFreeReqAlternative(ReqList->ReqAlternativeTable[i]);
}
ExFreePool(ReqList);
}
}
VOID
IopFreeResourceRequirementsForAssignTable(
IN PIOP_RESOURCE_REQUEST AssignTable,
IN PIOP_RESOURCE_REQUEST AssignTableEnd
)
/*++
Routine Description:
For each AssignTable entry, this routine frees its attached REQ_LIST.
Parameters:
AssignTable - supplies a pointer to the first entry of a IOP_RESOURCE_REQUEST table.
AssignTableEnd - supplies a pointer to the end of IOP_RESOURCE_REQUEST table.
Return Value:
None.
--*/
{
PIOP_RESOURCE_REQUEST AssignEntry;
PAGED_CODE();
for (AssignEntry = AssignTable; AssignEntry < AssignTableEnd; ++AssignEntry) {
IopFreeReqList(AssignEntry->ReqList);
AssignEntry->ReqList = NULL;
if (AssignEntry->Flags & IOP_ASSIGN_KEEP_CURRENT_CONFIG &&
AssignEntry->ResourceRequirements) {
// The REAL resreq list is cached in DeviceNode->ResourceRequirements.
// We need to free the filtered list.
ExFreePool(AssignEntry->ResourceRequirements);
AssignEntry->ResourceRequirements = NULL;
}
}
}
VOID
IopBuildCmResourceList (
IN PIOP_RESOURCE_REQUEST AssignEntry
)
/*++
Routine Description:
This routine walks REQ_LIST of the AssignEntry to build a corresponding
Cm Resource lists. It also reports the resources to ResourceMap.
Parameters:
AssignEntry - Supplies a pointer to an IOP_ASSIGN_REQUEST structure
Return Value:
None. The ResourceAssignment in AssignEntry is initialized.
--*/
{
NTSTATUS status;
HANDLE resourceMapKey;
PDEVICE_OBJECT physicalDevice;
PREQ_LIST reqList = AssignEntry->ReqList;
PREQ_ALTERNATIVE reqAlternative;
PREQ_DESC reqDesc, reqDescx;
PIO_RESOURCE_DESCRIPTOR privateData;
ULONG count = 0, size, i;
PCM_RESOURCE_LIST cmResources, cmResourcesRaw;
PCM_FULL_RESOURCE_DESCRIPTOR cmFullResource, cmFullResourceRaw;
PCM_PARTIAL_RESOURCE_LIST cmPartialList, cmPartialListRaw;
PCM_PARTIAL_RESOURCE_DESCRIPTOR cmDescriptor, cmDescriptorRaw, assignment, tAssignment;
#if DBG
PCM_PARTIAL_RESOURCE_DESCRIPTOR cmDescriptorEnd, cmDescriptorEndRaw;
#endif
PAGED_CODE();
// Determine the size of the CmResourceList
// Determine the size of the CmResourceList
reqAlternative = *reqList->SelectedAlternative;
for (i = 0; i < reqAlternative->ReqDescCount; i++) {
reqDesc = reqAlternative->ReqDescTable[i];
count += reqDesc->DevicePrivateCount + 1;
}
size = sizeof(CM_RESOURCE_LIST) + sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * (count - 1);
cmResources = (PCM_RESOURCE_LIST) ExAllocatePoolCMRL(PagedPool, size);
if (!cmResources) {
// If we can not find memory, the resources will not be committed by arbiter.
DebugMessage(DUMP_ERROR, ("PnpRes: Not enough memory to build Translated CmResourceList\n"));
AssignEntry->Status = STATUS_INSUFFICIENT_RESOURCES;
AssignEntry->ResourceAssignment = NULL;
AssignEntry->TranslatedResourceAssignment = NULL;
return;
}
cmResourcesRaw = (PCM_RESOURCE_LIST) ExAllocatePoolCMRR(PagedPool, size);
if (!cmResourcesRaw) {
DebugMessage(DUMP_ERROR, ("PnpRes: Not enough memory to build Raw CmResourceList\n"));
ExFreePool(cmResources);
AssignEntry->Status = STATUS_INSUFFICIENT_RESOURCES;
AssignEntry->ResourceAssignment = NULL;
AssignEntry->TranslatedResourceAssignment = NULL;
return;
}
cmResources->Count = 1;
cmFullResource = cmResources->List;
// The CmResourceList we build here does not distinguish the
// Interface Type on descriptor level. This should be fine because
// for IoReportResourceUsage we ignore the CmResourceList we build
// here.
cmFullResource->InterfaceType = reqList->InterfaceType;
cmFullResource->BusNumber = reqList->BusNumber;
cmPartialList = &cmFullResource->PartialResourceList;
cmPartialList->Version = 0;
cmPartialList->Revision = 0;
cmPartialList->Count = count;
cmDescriptor = cmPartialList->PartialDescriptors;
#if DBG
cmDescriptorEnd = cmDescriptor + count;
#endif
cmResourcesRaw->Count = 1;
cmFullResourceRaw = cmResourcesRaw->List;
cmFullResourceRaw->InterfaceType = reqList->InterfaceType;
cmFullResourceRaw->BusNumber = reqList->BusNumber;
cmPartialListRaw = &cmFullResourceRaw->PartialResourceList;
cmPartialListRaw->Version = 0;
cmPartialListRaw->Revision = 0;
cmPartialListRaw->Count = count;
cmDescriptorRaw = cmPartialListRaw->PartialDescriptors;
#if DBG
cmDescriptorEndRaw = cmDescriptorRaw + count;
#endif
for (i = 0; i < reqAlternative->ReqDescCount; i++) {
reqDesc = reqAlternative->ReqDescTable[i];
if (reqDesc->ArbitrationRequired) {
// Get raw assignment and copy it to our raw resource list
reqDescx = reqDesc->TranslatedReqDesc;
if (reqDescx->AlternativeTable.Result != ArbiterResultNullRequest) {
status = IopParentToRawTranslation(reqDescx);
if (!NT_SUCCESS(status)) {
DebugMessage(DUMP_ERROR, ("PnpRes: Parent To Raw translation failed\n"));
ExFreePool(cmResources);
ExFreePool(cmResourcesRaw);
AssignEntry->Status = STATUS_INSUFFICIENT_RESOURCES;
AssignEntry->ResourceAssignment = NULL;
return;
}
assignment = reqDesc->AlternativeTable.Assignment;
} else {
assignment = reqDescx->AlternativeTable.Assignment;
}
*cmDescriptorRaw = *assignment;
cmDescriptorRaw++;
// Translate assignment and copy it to our translated resource list
if (reqDescx->AlternativeTable.Result != ArbiterResultNullRequest) {
status = IopChildToRootTranslation(
(PDEVICE_NODE)reqDesc->AlternativeTable.PhysicalDeviceObject->DeviceObjectExtension->DeviceNode,
reqDesc->InterfaceType,
reqDesc->BusNumber,
reqDesc->AlternativeTable.RequestSource,
&reqDesc->Allocation,
&tAssignment
);
if (!NT_SUCCESS(status)) {
DebugMessage(DUMP_ERROR, ("PnpRes: Child to Root translation failed\n"));
ExFreePool(cmResources);
ExFreePool(cmResourcesRaw);
AssignEntry->Status = STATUS_INSUFFICIENT_RESOURCES;
AssignEntry->ResourceAssignment = NULL;
return;
}
*cmDescriptor = *tAssignment;
ExFreePool(tAssignment);
} else {
*cmDescriptor = *(reqDescx->AlternativeTable.Assignment);
}
cmDescriptor++;
} else {
*cmDescriptorRaw = reqDesc->Allocation;
*cmDescriptor = reqDesc->Allocation;
cmDescriptorRaw++;
cmDescriptor++;
}
// Next copy the device private descriptors to CmResourceLists
count = reqDesc->DevicePrivateCount;
privateData = reqDesc->DevicePrivate;
while (count != 0) {
cmDescriptor->Type = cmDescriptorRaw->Type = CmResourceTypeDevicePrivate;
cmDescriptor->ShareDisposition = cmDescriptorRaw->ShareDisposition =
CmResourceShareDeviceExclusive;
cmDescriptor->Flags = cmDescriptorRaw->Flags = privateData->Flags;
RtlMoveMemory(&cmDescriptorRaw->u.DevicePrivate,
&privateData->u.DevicePrivate,
sizeof(cmDescriptorRaw->u.DevicePrivate.Data)
);
RtlMoveMemory(&cmDescriptor->u.DevicePrivate,
&privateData->u.DevicePrivate,
sizeof(cmDescriptor->u.DevicePrivate.Data)
);
privateData++;
cmDescriptorRaw++;
cmDescriptor++;
count--;
ASSERT(cmDescriptorRaw <= cmDescriptorEndRaw);
ASSERT(cmDescriptor <= cmDescriptorEnd);
}
ASSERT(cmDescriptor <= cmDescriptorEnd);
ASSERT(cmDescriptorRaw <= cmDescriptorEndRaw);
}
// report assigned resources to ResourceMap
physicalDevice = AssignEntry->PhysicalDevice;
// Open ResourceMap key
status = IopCreateRegistryKeyEx( &resourceMapKey,
(HANDLE) NULL,
&CmRegistryMachineHardwareResourceMapName,
KEY_READ | KEY_WRITE,
REG_OPTION_VOLATILE,
NULL
);
if (NT_SUCCESS(status )) {
WCHAR DeviceBuffer[256];
POBJECT_NAME_INFORMATION NameInformation;
ULONG NameLength;
UNICODE_STRING UnicodeClassName;
UNICODE_STRING UnicodeDriverName;
UNICODE_STRING UnicodeDeviceName;
RtlInitUnicodeString(&UnicodeClassName, PNPMGR_STR_PNP_MANAGER);
RtlInitUnicodeString(&UnicodeDriverName, REGSTR_KEY_PNP_DRIVER);
NameInformation = (POBJECT_NAME_INFORMATION) DeviceBuffer;
status = ObQueryNameString( physicalDevice,
NameInformation,
sizeof( DeviceBuffer ),
&NameLength );
if (NT_SUCCESS(status)) {
NameInformation->Name.MaximumLength = sizeof(DeviceBuffer) - sizeof(OBJECT_NAME_INFORMATION);
if (NameInformation->Name.Length == 0) {
NameInformation->Name.Buffer = (PVOID)((ULONG_PTR)DeviceBuffer + sizeof(OBJECT_NAME_INFORMATION));
}
UnicodeDeviceName = NameInformation->Name;
RtlAppendUnicodeToString(&UnicodeDeviceName, IopWstrRaw);
// IopWriteResourceList should remove all the device private and device
// specifiec descriptors.
status = IopWriteResourceList(
resourceMapKey,
&UnicodeClassName,
&UnicodeDriverName,
&UnicodeDeviceName,
cmResourcesRaw,
size
);
if (NT_SUCCESS(status)) {
UnicodeDeviceName = NameInformation->Name;
RtlAppendUnicodeToString (&UnicodeDeviceName, IopWstrTranslated);
status = IopWriteResourceList(
resourceMapKey,
&UnicodeClassName,
&UnicodeDriverName,
&UnicodeDeviceName,
cmResources,
size
);
}
}
ZwClose(resourceMapKey);
}
#if 0 // Ignore the registry writing status.
if (!NT_SUCCESS(status)) {
ExFreePool(cmResources);
ExFreePool(cmResourcesRaw);
cmResources = NULL;
cmResourcesRaw = NULL;
}
#endif
AssignEntry->ResourceAssignment = cmResourcesRaw;
AssignEntry->TranslatedResourceAssignment = cmResources;
}
VOID
IopBuildCmResourceLists(
IN PIOP_RESOURCE_REQUEST AssignTable,
IN PIOP_RESOURCE_REQUEST AssignTableEnd
)
/*++
Routine Description:
For each AssignTable entry, this routine queries device's IO resource requirements
list and converts it to our internal REQ_LIST format.
Parameters:
AssignTable - supplies a pointer to the first entry of a IOP_RESOURCE_REQUEST table.
AssignTableEnd - supplies a pointer to the end of IOP_RESOURCE_REQUEST table.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
NTSTATUS status;
PIOP_RESOURCE_REQUEST assignEntry;
PDEVICE_OBJECT physicalDevice;
PDEVICE_NODE deviceNode;
PAGED_CODE();
// Go thru each entry, for each Physical device object, we build a CmResourceList
// from its ListOfAssignedResources.
for (assignEntry = AssignTable; assignEntry < AssignTableEnd; ++assignEntry) {
assignEntry->ResourceAssignment = NULL;
if (assignEntry->Flags & IOP_ASSIGN_IGNORE || assignEntry->Flags & IOP_ASSIGN_RETRY) {
continue;
}
if (assignEntry->Flags & IOP_ASSIGN_EXCLUDE) {
assignEntry->Status = STATUS_UNSUCCESSFUL;
continue;
}
assignEntry->Status = STATUS_SUCCESS;
IopBuildCmResourceList (assignEntry);
if (assignEntry->ResourceAssignment) {
physicalDevice = assignEntry->PhysicalDevice;
deviceNode = (PDEVICE_NODE)physicalDevice->DeviceObjectExtension->DeviceNode;
IopWriteAllocatedResourcesToRegistry(
deviceNode,
assignEntry->ResourceAssignment,
IopDetermineResourceListSize(assignEntry->ResourceAssignment)
);
#if DBG_SCOPE
DebugMessage(DUMP_INFO,("Pnpres: Building CM resource lists for %ws...\n", deviceNode->InstancePath.Buffer));
if (PnpResDebugLevel & DUMP_INFO) {
DbgPrint("Raw resources ");
IopDumpCmResourceList(assignEntry->ResourceAssignment);
DbgPrint("Translated resources ");
IopDumpCmResourceList(assignEntry->TranslatedResourceAssignment);
}
#endif
}
}
}
BOOLEAN
IopNeedToReleaseBootResources(
IN PDEVICE_NODE DeviceNode,
IN PCM_RESOURCE_LIST AllocatedResources
)
/*++
Routine Description:
This routine checks the AllocatedResources against boot allocated resources.
If the allocated resources do not cover all the resource types in boot resources,
in another words some types of boot resources have not been released by arbiter,
we will return TRUE to indicate we need to release the boot resources manually.
Parameters:
DeviceNode - A device node
AllocatedResources - the resources assigned to the devicenode by arbiters.
Return Value:
TRUE or FALSE.
--*/
{
PCM_FULL_RESOURCE_DESCRIPTOR cmFullDesc_a, cmFullDesc_b;
PCM_PARTIAL_RESOURCE_DESCRIPTOR cmDescriptor_a, cmDescriptor_b;
ULONG size_a, size_b, i, j, k;
BOOLEAN returnValue = FALSE, found;
PCM_RESOURCE_LIST bootResources;
PAGED_CODE();
bootResources = DeviceNode->BootResources;
if (AllocatedResources->Count == 1 && bootResources && bootResources->Count != 0) {
cmFullDesc_a = &AllocatedResources->List[0];
cmFullDesc_b = &bootResources->List[0];
for (i = 0; i < bootResources->Count; i++) {
cmDescriptor_b = &cmFullDesc_b->PartialResourceList.PartialDescriptors[0];
for (j = 0; j < cmFullDesc_b->PartialResourceList.Count; j++) {
size_b = 0;
switch (cmDescriptor_b->Type) {
case CmResourceTypeNull:
break;
case CmResourceTypeDeviceSpecific:
size_b = cmDescriptor_b->u.DeviceSpecificData.DataSize;
break;
default:
if (cmDescriptor_b->Type < CmResourceTypeMaximum) {
found = FALSE;
cmDescriptor_a = &cmFullDesc_a->PartialResourceList.PartialDescriptors[0];
for (k = 0; k < cmFullDesc_a->PartialResourceList.Count; k++) {
size_a = 0;
if (cmDescriptor_a->Type == CmResourceTypeDeviceSpecific) {
size_a = cmDescriptor_a->u.DeviceSpecificData.DataSize;
} else if (cmDescriptor_b->Type == cmDescriptor_a->Type) {
found = TRUE;
break;
}
cmDescriptor_a++;
cmDescriptor_a = (PCM_PARTIAL_RESOURCE_DESCRIPTOR) ((PUCHAR)cmDescriptor_a + size_a);
}
if (found == FALSE) {
returnValue = TRUE;
goto exit;
}
}
}
cmDescriptor_b++;
cmDescriptor_b = (PCM_PARTIAL_RESOURCE_DESCRIPTOR) ((PUCHAR)cmDescriptor_b + size_b);
}
cmFullDesc_b = (PCM_FULL_RESOURCE_DESCRIPTOR)cmDescriptor_b;
}
}
exit:
return returnValue;
}
VOID
IopReleaseFilteredBootResources(
IN PIOP_RESOURCE_REQUEST AssignTable,
IN PIOP_RESOURCE_REQUEST AssignTableEnd
)
/*++
Routine Description:
For each AssignTable entry, this routine checks if we need to manually release the device's
boot resources.
Parameters:
AssignTable - supplies a pointer to the first entry of a IOP_RESOURCE_REQUEST table.
AssignTableEnd - supplies a pointer to the end of IOP_RESOURCE_REQUEST table.
Return Value:
None.
--*/
{
NTSTATUS status;
PIOP_RESOURCE_REQUEST assignEntry;
PDEVICE_OBJECT physicalDevice;
PDEVICE_NODE deviceNode;
PAGED_CODE();
// Go thru each entry, for each Physical device object, we build a CmResourceList
// from its ListOfAssignedResources.
for (assignEntry = AssignTable; assignEntry < AssignTableEnd; ++assignEntry) {
if (assignEntry->ResourceAssignment) {
physicalDevice = assignEntry->PhysicalDevice;
deviceNode = (PDEVICE_NODE)physicalDevice->DeviceObjectExtension->DeviceNode;
// Release the device's boot resources if desired
// (If a driver filters its res req list and removes some boot resources, after arbiter satisfies
// the new res req list, the filtered out boot resources do not get
// released by arbiters. Because they no longer passed to arbiters. )
// I am not 100% sure we should release the filtered boot resources. But that's what arbiters try
// to achieve. So, we will do it.
if (IopNeedToReleaseBootResources(deviceNode, assignEntry->ResourceAssignment)) {
IopReleaseResourcesInternal(deviceNode);
IopReserveBootResourcesInternal(
ArbiterRequestPnpEnumerated,
physicalDevice,
assignEntry->ResourceAssignment);
deviceNode->Flags &= ~DNF_BOOT_CONFIG_RESERVED; // Keep DeviceNode->BootResources
deviceNode->ResourceList = assignEntry->ResourceAssignment;
status = IopRestoreResourcesInternal(deviceNode);
ASSERT(status == STATUS_SUCCESS);
if (!NT_SUCCESS(status)) {
// BUGBUG - according to arbiter design, we should bugcheck.
assignEntry->Flags = IOP_ASSIGN_EXCLUDE;
assignEntry->Status = status;
ExFreePool(assignEntry->ResourceAssignment);
assignEntry->ResourceAssignment = NULL;
}
deviceNode->ResourceList = NULL;
}
}
}
}
NTSTATUS
IopPlacement(
IN ARBITER_ACTION ArbiterAction,
IN BOOLEAN Rebalance
)
/*++
Routine Description:
This routine examines each arbiter if its resreq list changed its test function will be
called.
Parameters:
ArbiterAction - supplies an arbiter action code to perform TEST or RETEST.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PLIST_ENTRY listEntry;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
NTSTATUS status;
ASSERT((ArbiterAction == ArbiterActionTestAllocation) ||
(ArbiterAction == ArbiterActionRetestAllocation) ||
(ArbiterAction == ArbiterActionCommitAllocation));
if (Rebalance) {
// For rebalance case, we always start from the root and work our way up.
status = IopPlacementForRebalance (IopRootDeviceNode, ArbiterAction);
} else {
listEntry = PiActiveArbiterList.Flink;
while (listEntry != &PiActiveArbiterList) {
arbiterEntry = CONTAINING_RECORD(listEntry, PI_RESOURCE_ARBITER_ENTRY, ActiveArbiterList);
listEntry = listEntry->Flink;
ASSERT(IsListEmpty(&arbiterEntry->ResourceList) == FALSE);
if (arbiterEntry->ResourcesChanged == FALSE) {
// If the resource requirements are the same and it failed before, we know it
// won't be able to succeed. So, return failure.
if (arbiterEntry->State & PI_ARBITER_TEST_FAILED) {
return STATUS_UNSUCCESSFUL;
}
} else {
// If the resource requirements are changed, we need to call arbiter to test it.
status = IopCallArbiter(arbiterEntry,
ArbiterAction,
&arbiterEntry->ResourceList,
0,
NULL
);
if (!NT_SUCCESS(status)) {
ASSERT(ArbiterAction == ArbiterActionTestAllocation);
arbiterEntry->State |= PI_ARBITER_TEST_FAILED;
return status;
} else {
arbiterEntry->State &= ~PI_ARBITER_TEST_FAILED;
arbiterEntry->ResourcesChanged = FALSE;
if (ArbiterAction == ArbiterActionTestAllocation) {
arbiterEntry->State |= PI_ARBITER_HAS_SOMETHING;
} else {
if (ArbiterAction == ArbiterActionRetestAllocation) {
status = IopCallArbiter(arbiterEntry, ArbiterActionCommitAllocation, NULL, NULL, NULL);
ASSERT(status == STATUS_SUCCESS);
}
arbiterEntry->State = 0;
InitializeListHead(&arbiterEntry->ActiveArbiterList);
InitializeListHead(&arbiterEntry->BestConfig);
InitializeListHead(&arbiterEntry->ResourceList);
InitializeListHead(&arbiterEntry->BestResourceList);
}
}
}
}
status = STATUS_SUCCESS;
}
return status;
}
NTSTATUS
IopPlacementForReservation(
VOID
)
/*++
Routine Description:
This routine examines each arbiter if its resreq list changed its test function will be
called.
Parameters:
None.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PLIST_ENTRY listEntry;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
NTSTATUS status, returnStatus = STATUS_SUCCESS;
listEntry = PiActiveArbiterList.Flink;
while (listEntry != &PiActiveArbiterList) {
arbiterEntry = CONTAINING_RECORD(listEntry, PI_RESOURCE_ARBITER_ENTRY, ActiveArbiterList);
listEntry = listEntry->Flink;
ASSERT(IsListEmpty(&arbiterEntry->ResourceList) == FALSE);
if (arbiterEntry->ResourcesChanged) {
// If the resource requirements are changed, we need to call arbiter to reserve it.
status = IopCallArbiter(arbiterEntry,
ArbiterActionBootAllocation,
&arbiterEntry->ResourceList,
0,
NULL
);
if (!NT_SUCCESS(status)) {
#if MYDBG
PARBITER_LIST_ENTRY arbiterListEntry = (PARBITER_LIST_ENTRY) arbiterEntry->ResourceList.Flink;
DbgPrint("Allocate Boot Resources Failed ::\n");
DbgPrint(" Count = %x, PDO = %x\n",
arbiterListEntry->AlternativeCount, arbiterListEntry->PhysicalDeviceObject);
IopDumpResourceDescriptor(
" ",
arbiterListEntry->Alternatives);
#endif
returnStatus = status;
}
arbiterEntry->ResourcesChanged = FALSE;
arbiterEntry->State = 0;
InitializeListHead(&arbiterEntry->ActiveArbiterList);
InitializeListHead(&arbiterEntry->BestConfig);
InitializeListHead(&arbiterEntry->ResourceList);
InitializeListHead(&arbiterEntry->BestResourceList);
}
}
return returnStatus;
}
VOID
IopAddReqDescsToArbiters (
IN ULONG ReqDescCount,
IN PREQ_DESC *ReqDescTable
)
/*++
Routine Description:
This routine adds a list of a req descriptors to their arbiters.
Parameters:
P1 -
Return Value:
None.
--*/
{
PREQ_DESC reqDesc;
PREQ_DESC reqDescTranslated;
PLIST_ENTRY listHead;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
PREQ_DESC *reqDescTableEnd;
for (reqDescTableEnd = ReqDescTable + ReqDescCount; ReqDescTable < reqDescTableEnd; ReqDescTable++) {
// For each req desc, find its arbiter, link the translated req desc to its arbiter.
reqDesc = *ReqDescTable;
if (reqDesc->ArbitrationRequired) {
reqDescTranslated = reqDesc->TranslatedReqDesc; // Could be reqDesc itself
InitializeListHead(&reqDescTranslated->AlternativeTable.ListEntry);
arbiterEntry = reqDesc->u.Arbiter;
ASSERT(arbiterEntry);
listHead = &arbiterEntry->ResourceList;
InsertTailList(listHead, &reqDescTranslated->AlternativeTable.ListEntry);
arbiterEntry->ResourcesChanged = TRUE;
if (arbiterEntry->State & PI_ARBITER_HAS_SOMETHING) {
IopCallArbiter(arbiterEntry, ArbiterActionRollbackAllocation, NULL, NULL, NULL);
arbiterEntry->State &= ~PI_ARBITER_HAS_SOMETHING;
}
// Link the arbiter entry to our active arbiter list if it has not been
if (IsListEmpty(&arbiterEntry->ActiveArbiterList)) {
InsertTailList(&PiActiveArbiterList, &arbiterEntry->ActiveArbiterList);
}
}
}
}
VOID
IopRemoveReqDescsFromArbiters (
ULONG ReqDescCount,
PREQ_DESC *ReqDescTable
)
/*++
Routine Description:
This routine removes a list of a req descriptors from their arbiters.
Parameters:
P1 -
Return Value:
None.
--*/
{
PREQ_DESC reqDesc;
PREQ_DESC reqDescTranslated;
PLIST_ENTRY listHead;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
PREQ_DESC *reqDescTableEnd;
for (reqDescTableEnd = ReqDescTable + ReqDescCount; ReqDescTable < reqDescTableEnd; ReqDescTable++) {
// For each req desc, find its arbiter, remove the req desc from its arbiter.
reqDesc = *ReqDescTable;
if (reqDesc->ArbitrationRequired) {
reqDescTranslated = reqDesc->TranslatedReqDesc;
arbiterEntry = reqDesc->u.Arbiter;
ASSERT(IsListEmpty(&arbiterEntry->ResourceList) == FALSE);
arbiterEntry->ResourcesChanged = TRUE;
if (arbiterEntry->State & PI_ARBITER_HAS_SOMETHING) {
IopCallArbiter(arbiterEntry, ArbiterActionRollbackAllocation, NULL, NULL, NULL);
arbiterEntry->State &= ~PI_ARBITER_HAS_SOMETHING;
}
RemoveEntryList(&reqDescTranslated->AlternativeTable.ListEntry);
InitializeListHead(&reqDescTranslated->AlternativeTable.ListEntry);
listHead = &arbiterEntry->ResourceList;
if (IsListEmpty(listHead)) {
// Remove the arbiter entry from our active arbiter list if it has no resource
// to arbitrate.
RemoveEntryList(&arbiterEntry->ActiveArbiterList);
InitializeListHead(&arbiterEntry->ActiveArbiterList);
}
}
}
}
BOOLEAN
IopIsBestConfiguration(
IN VOID
)
/*++
Routine Description:
This routine checks if the current resource assignment yields the best score.
If yes, this routine updates the static variable to reflect the best score.
Parameters:
None.
Return Value:
TRUE or FALSE.
--*/
{
ULONG i, priority = 0;
PREQ_ALTERNATIVE reqAlternative;
PIOP_RESOURCE_REQUEST assignEntry;
// If PiNoRetest is set. There is only one. So, it is the best.
if (PiNoRetest) {
return TRUE;
}
// Go thru all the assign tables to collect priority
for (i = 0; i < PiAssignTableCount; i++) {
assignEntry = PiAssignTable + i;
if (!(assignEntry->Flags & IOP_ASSIGN_EXCLUDE)) {
reqAlternative = *((PREQ_LIST)assignEntry->ReqList)->SelectedAlternative;
priority += reqAlternative->Priority;
}
}
// If the new priority is better than current best priority.
// Update the current best.
if (priority < PiBestPriority) {
PiBestPriority = priority;
return TRUE;
} else {
return FALSE;
}
}
VOID
IopSaveCurrentConfiguration(
IN VOID
)
/*++
Routine Description:
This routine goes thru every resource requirememts list to save the current
best resource assignments.
Parameters:
None.
Return Value:
None.
--*/
{
PREQ_ALTERNATIVE reqAlternative;
PIOP_RESOURCE_REQUEST assignEntry;
PREQ_DESC reqDesc, *reqDescpp;
PREQ_LIST reqList;
PLIST_ENTRY listEntry;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
ULONG i;
// If PiNoRetest is set, do nothing. We don't need to save/restore
if (PiNoRetest) {
PiBestArbiterList = PiActiveArbiterList;
return;
}
// Go thru all the assign tables to save the current assignment and mark
// it as the current best selection.
for (i = 0; i < PiAssignTableCount; i++) {
assignEntry = PiAssignTable + i;
if (!(assignEntry->Flags & IOP_ASSIGN_EXCLUDE)) {
reqList = assignEntry->ReqList;
// Save the current selected Alternative as the BestAlternative.
reqAlternative = *reqList->SelectedAlternative;
reqList->ReqBestAlternative = reqList->SelectedAlternative;
// For each REQ_DESC in the best alternative list, save its arbiter list entry
// and its assignments.
for (reqDescpp = reqAlternative->ReqDescTable;
reqDescpp < reqAlternative->ReqDescTableEnd;
reqDescpp++) {
if ((*reqDescpp)->ArbitrationRequired) {
reqDesc = (*reqDescpp)->TranslatedReqDesc;
reqDesc->BestAlternativeTable = reqDesc->AlternativeTable;
reqDesc->BestAllocation = reqDesc->Allocation;
}
}
}
}
// Go throught the active arbiter list to save the current assignment
// for retest.
listEntry = PiActiveArbiterList.Flink;
while (listEntry != &PiActiveArbiterList) {
arbiterEntry = CONTAINING_RECORD(listEntry, PI_RESOURCE_ARBITER_ENTRY, ActiveArbiterList);
arbiterEntry->BestResourceList = arbiterEntry->ResourceList;
arbiterEntry->BestConfig = arbiterEntry->ActiveArbiterList;
listEntry = listEntry->Flink;
}
PiBestArbiterList = PiActiveArbiterList;
}
VOID
IopRestoreBestConfiguration(
IN VOID
)
/*++
Routine Description:
This routine restores the arbiters info and all the resources requirements
info to prepare arbiter restest.
Parameters:
None.
Return Value:
None.
--*/
{
PREQ_ALTERNATIVE reqAlternative;
PIOP_RESOURCE_REQUEST assignEntry;
PREQ_DESC reqDesc, *reqDescpp;
PREQ_LIST reqList;
PLIST_ENTRY listEntry;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
ULONG i;
if (PiNoRetest == FALSE) {
// Go thru all the assign tables to save the current configuration.
for (i = 0; i < PiAssignTableCount; i++) {
assignEntry = PiAssignTable + i;
if (!(assignEntry->Flags & IOP_ASSIGN_EXCLUDE)) {
reqList = assignEntry->ReqList;
// Set the BestAlternative as the current selection.
reqAlternative = *reqList->ReqBestAlternative;
reqList->SelectedAlternative = reqList->ReqBestAlternative;
// For each REQ_DESC in the best alternative list, restore its arbiter list entry
// and its assignments from saved area.
for (reqDescpp = reqAlternative->ReqDescTable;
reqDescpp < reqAlternative->ReqDescTableEnd;
reqDescpp++) {
if ((*reqDescpp)->ArbitrationRequired) {
reqDesc = (*reqDescpp)->TranslatedReqDesc;
reqDesc->AlternativeTable = reqDesc->BestAlternativeTable;
reqDesc->Allocation = reqDesc->BestAllocation;
}
}
}
}
PiActiveArbiterList = PiBestArbiterList;
}
// Go throught the active arbiter list to restore the current configuration
// for retest.
listEntry = PiActiveArbiterList.Flink;
while (listEntry != &PiActiveArbiterList) {
arbiterEntry = CONTAINING_RECORD(listEntry, PI_RESOURCE_ARBITER_ENTRY, ActiveArbiterList);
if (PiNoRetest == FALSE) {
arbiterEntry->ResourceList = arbiterEntry->BestResourceList;
arbiterEntry->ActiveArbiterList = arbiterEntry->BestConfig;
}
arbiterEntry->ResourcesChanged = TRUE;
listEntry = listEntry->Flink;
}
}
NTSTATUS
IopAssign(
IN ULONG AssignTableCount,
IN PIOP_RESOURCE_REQUEST AssignTable,
IN BOOLEAN Rebalance
)
/*++
Routine Description:
This routine performs the resource allocation for the passed in AssignTables.
Parameters:
AssignTableCount - supplies the number of AssignTable
AssignTable - supplies a pointer to the first AssignTable.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
NTSTATUS status = STATUS_INSUFFICIENT_RESOURCES;
LONG tableIndex;
PREQ_LIST reqList;
PREQ_ALTERNATIVE reqAlternative;
PDEVICE_NODE deviceNode;
LARGE_INTEGER startTime;
BOOLEAN timeoutExpired;
ULONG spewCount = 0;
PAGED_CODE();
timeoutExpired = FALSE;
// Initialize our starting time.
KeQuerySystemTime(&startTime);
// Initialize the selected alternative for each entry to the first
// possible alternative.
for (tableIndex = 0; tableIndex < (LONG)AssignTableCount; tableIndex++) {
if (!(AssignTable[tableIndex].Flags & IOP_ASSIGN_EXCLUDE)) {
reqList = AssignTable[tableIndex].ReqList;
reqList->SelectedAlternative = &reqList->ReqAlternativeTable[0];
}
}
// Go through all possible combinations of req alternatives for all devices.
while (tableIndex >= 0) {
// Add the currently selected alternative to the arbiters iff
// it has changed since the last time.
for (tableIndex = AssignTableCount - 1; tableIndex >= 0;) {
if (AssignTable[tableIndex].Flags & IOP_ASSIGN_EXCLUDE) {
tableIndex--;
} else {
reqList = AssignTable[tableIndex].ReqList;
reqAlternative = *reqList->SelectedAlternative;
deviceNode = (PDEVICE_NODE)AssignTable[tableIndex].PhysicalDevice->DeviceObjectExtension->DeviceNode;
DebugMessage(DUMP_DETAIL, ("PnpRes: Adding %d/%d req alt to the arbiters for %ws.\n", reqAlternative->ReqAlternativeIndex + 1, reqList->ReqAlternativeCount, deviceNode->InstancePath.Buffer));
IopAddReqDescsToArbiters( reqAlternative->ReqDescCount,
reqAlternative->ReqDescTable);
if (reqList->SelectedAlternative == &reqList->ReqAlternativeTable[0]) {
tableIndex--;
} else {
break;
}
}
}
// Test this configuration.
status = IopPlacement(ArbiterActionTestAllocation, Rebalance);
if (NT_SUCCESS(status)) {
// Compute priority and update best configuration if needed.
if (IopIsBestConfiguration()) {
// This assignment gets the best score. Update its ReqBestAlternative
// and return.
DebugMessage(DUMP_DETAIL, ("PnpRes: Found a best assignment. Save it\n"));
IopSaveCurrentConfiguration();
// The reqList->ReqBestAlternative will be set to reqAlternative, i.e.
// reqList->ReqBestAlternative = reqAlternative;
// in IopSaveCurrentConfiguration().
// This will cause the control to exit the for-loop.
}
// Do we need to stop?
if (PiNoRetest) {
break;
}
}
// Algorithm to select the next alternative.
// We go through the table in the reverse direction.
// We first remove the currently selected alternative.
// We update the selected alternative to the next possible
// alternative. If we roll over, we go to the next entry in
// the table.
for (tableIndex = AssignTableCount - 1; tableIndex >= 0; ) {
if (AssignTable[tableIndex].Flags & IOP_ASSIGN_EXCLUDE) {
tableIndex--;
} else {
reqList = AssignTable[tableIndex].ReqList;
reqAlternative = *reqList->SelectedAlternative;
deviceNode = (PDEVICE_NODE)AssignTable[tableIndex].PhysicalDevice->DeviceObjectExtension->DeviceNode;
DebugMessage(DUMP_DETAIL, ("PnpRes: Removing %d/%d req alt from the arbiters for %ws.\n", reqAlternative->ReqAlternativeIndex + 1, reqList->ReqAlternativeCount, deviceNode->InstancePath.Buffer));
IopRemoveReqDescsFromArbiters( reqAlternative->ReqDescCount,
reqAlternative->ReqDescTable);
if (++reqList->SelectedAlternative < reqList->ReqBestAlternative && !timeoutExpired) {
break;
} else {
reqList->SelectedAlternative = &reqList->ReqAlternativeTable[0];
tableIndex--;
}
}
}
// Check if timeout has expired.
if (tableIndex >= 0) {
LARGE_INTEGER currentTime;
ULONG timeDiff;
// Compute time difference in milliseconds.
KeQuerySystemTime(&currentTime);
timeDiff = (ULONG)((currentTime.QuadPart - startTime.QuadPart) / 10000);
// We are done if timeout has expired.
if (timeDiff >= FIND_BEST_ASSIGNMENT_TIMEOUT)
{
if (PiUseTimeout) {
DebugMessage(DUMP_ERROR, ("PnpRes: Timeout expired, bailing out!\n"));
timeoutExpired = TRUE;
} else {
spewCount = (spewCount + 1) % 50;
if (spewCount == 0) {
DbgPrint("PnpRes: Timeout expired.\n");
}
}
}
}
}
return (status);
}
NTSTATUS
IopAssignInner(
IN ULONG AssignTableCount,
IN PIOP_RESOURCE_REQUEST AssignTable,
IN BOOLEAN Rebalance
)
/*++
Routine Description:
This routine sets up static variables and invokes the real resource allocation
routine.
Parameters:
AssignTableCount - supplies the number of AssignTable
AssignTable - supplies a pointer to the first AssignTable.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
NTSTATUS status;
ARBITER_ACTION arbiterAction;
// Initialize static variable
InitializeListHead(&PiBestArbiterList);
InitializeListHead(&PiActiveArbiterList);
PiAssignTableCount = AssignTableCount;
PiAssignTable = AssignTable;
PiBestPriority = (ULONG) -1;
if (AssignTableCount == 1) {
PiNoRetest = TRUE;
arbiterAction = ArbiterActionCommitAllocation;
} else {
PiNoRetest = FALSE;
arbiterAction = ArbiterActionRetestAllocation;
}
// Try to solve the inner NP-complete problem.
IopAssign(AssignTableCount, AssignTable, Rebalance);
#if DBG_SCOPE
if ((PnpResDebugLevel & STOP_ERROR) && PiNoRetest == FALSE) {
IopCheckDataStructures(IopRootDeviceNode);
}
#endif
if (IsListEmpty(&PiBestArbiterList)) {
DebugMessage(DUMP_DETAIL, ("PnpRes: IoAssignInner failed to find an assignment.\n"));
status = STATUS_UNSUCCESSFUL;
} else {
if (Rebalance) {
DebugMessage(DUMP_DETAIL, ("PnpRes: Restore the best assignment.\n"));
} else {
DebugMessage(DUMP_DETAIL, ("PnpRes: Restore the best assignment and commit it.\n"));
}
IopRestoreBestConfiguration();
status = IopPlacement(arbiterAction, Rebalance);
#if DBG_SCOPE
if (!Rebalance) {
if (PnpResDebugLevel & STOP_ERROR) {
IopCheckDataStructures(IopRootDeviceNode);
}
}
#endif
ASSERT(status == STATUS_SUCCESS);
}
PiNoRetest = FALSE;
return status;
}
NTSTATUS
IopReserve(
IN PREQ_LIST ReqList
)
/*++
Routine Description:
This routine performs the resource allocation for the passed in AssignTables.
Parameters:
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
NTSTATUS status;
PREQ_ALTERNATIVE RA;
PREQ_ALTERNATIVE *reqAlternative;
PAGED_CODE();
// Initialize static variable
InitializeListHead(&PiBestArbiterList);
InitializeListHead(&PiActiveArbiterList);
reqAlternative = ReqList->ReqAlternativeTable;
RA = *reqAlternative;
ReqList->SelectedAlternative = reqAlternative;
IopAddReqDescsToArbiters(RA->ReqDescCount, RA->ReqDescTable);
status = IopPlacementForReservation();
#if DBG_SCOPE
if (PnpResDebugLevel & STOP_ERROR) {
IopCheckDataStructures(IopRootDeviceNode);
}
#endif
return status;
}
BOOLEAN
IopFindResourceHandlerInfo(
IN RESOURCE_HANDLER_TYPE HandlerType,
IN PDEVICE_NODE DeviceNode,
IN UCHAR ResourceType,
OUT PVOID *HandlerEntry
)
/*++
Routine Description:
This routine finds the desired resource handler interface for the specified
resource type in the specified Device node.
Parameters:
HandlerType - Specifies the type of handler needed.
DeviceNode - specifies the device node from where to search for handler
ResourceTYpe - specifies the type of resource.
HandlerEntry - supplies a pointer to a variable to receive the handler.
Return Value:
TRUE + non-null HandlerEntry : Find handler info and there is a handler
TRUE + NULL HandlerEntry : Find handler info and there is NO handler
FALSE + NULL HandlerEntry : No handler info found.
--*/
{
USHORT resourceMask;
USHORT noHandlerMask, queryHandlerMask;
PLIST_ENTRY listHead, nextEntry;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
*HandlerEntry = NULL;
switch (HandlerType) {
case ResourceArbiter:
noHandlerMask = DeviceNode->NoArbiterMask;
queryHandlerMask = DeviceNode->QueryArbiterMask;
listHead = &DeviceNode->DeviceArbiterList;
break;
case ResourceTranslator:
noHandlerMask = DeviceNode->NoTranslatorMask;
queryHandlerMask = DeviceNode->QueryTranslatorMask;
listHead = &DeviceNode->DeviceTranslatorList;
break;
default:
return FALSE;
}
resourceMask = 1 << ResourceType;
if (noHandlerMask & resourceMask) {
// There is no desired handler for the resource type in this device node
return TRUE;
}
if (queryHandlerMask & resourceMask) {
// Has handler for the resource type in this device node.
// look for it ...
nextEntry = listHead->Flink;
for (; nextEntry != listHead; nextEntry = nextEntry->Flink) {
arbiterEntry = CONTAINING_RECORD(nextEntry, PI_RESOURCE_ARBITER_ENTRY, DeviceArbiterList);
if (arbiterEntry->ResourceType == ResourceType) {
break;
}
}
ASSERT(nextEntry != listHead); // There must be one ...
*HandlerEntry = arbiterEntry;
return TRUE;
} else {
// If we are here there are two cases:
// We have not query the desired interface yet or
// the resource type is out of the range we are tracking using masks.
// In this case, we need to go thru the link list.
if (ResourceType > PI_MAXIMUM_RESOURCE_TYPE_TRACKED) {
nextEntry = listHead->Flink;
for (; nextEntry != listHead; nextEntry = nextEntry->Flink) {
arbiterEntry = CONTAINING_RECORD(nextEntry, PI_RESOURCE_ARBITER_ENTRY, DeviceArbiterList);
if (arbiterEntry->ResourceType == ResourceType) {
if (arbiterEntry->ArbiterInterface) {
*HandlerEntry = arbiterEntry;
}
return TRUE;
}
}
}
return FALSE;
}
}
NTSTATUS
IopSetupArbiterAndTranslators(
IN PREQ_DESC ReqDesc
)
/*++
Routine Description:
This routine searches the arbiter and translators which arbitrates and translate
the resources for the specified device. This routine tries to find all the
translator on the path of current device node to root device node
Parameters:
ReqDesc - supplies a pointer to REQ_DESC which contains all the required information
Return Value:
NTSTATUS value to indicate success or failure.
--*/
{
PLIST_ENTRY listHead, nextEntry;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
PDEVICE_OBJECT deviceObject = ReqDesc->AlternativeTable.PhysicalDeviceObject;
PDEVICE_NODE deviceNode;
PREQ_DESC reqDesc = ReqDesc, translatedReqDesc;
BOOLEAN found, arbiterFound = FALSE, restartedAlready;
BOOLEAN searchTranslator = TRUE, translatorFound = FALSE;
NTSTATUS status;
PPI_RESOURCE_TRANSLATOR_ENTRY translatorEntry;
UCHAR resourceType = ReqDesc->TranslatedReqDesc->AlternativeTable.Alternatives->Type;
PINTERFACE interface;
USHORT resourceMask;
if ((ReqDesc->AlternativeTable.RequestSource == ArbiterRequestHalReported) &&
(ReqDesc->InterfaceType == Internal)) {
// Trust hal if it says internal bus.
restartedAlready = TRUE;
} else {
restartedAlready = FALSE;
}
// If ReqDesc contains DeviceObject, this is for regular resources allocation
// or boot resources preallocation. Otherwise, it is for resources reservation.
if (deviceObject && ReqDesc->AlternativeTable.RequestSource != ArbiterRequestHalReported) {
deviceNode = (PDEVICE_NODE)deviceObject->DeviceObjectExtension->DeviceNode;
// We want to start with the deviceNode instead of its parent. Because the
// deviceNode may provide a translator interface.
// deviceNode = deviceNode->Parent;
} else {
// For resource reservation, we always need to find the arbiter and translators
// so set the device node to Root.
deviceNode = IopRootDeviceNode;
}
while (deviceNode) {
if ((deviceNode == IopRootDeviceNode) && (translatorFound == FALSE)) {
// If we reach the root and have not find any translator, the device is on the
// wrong way.
if (restartedAlready == FALSE) {
restartedAlready = TRUE;
deviceNode = IopFindBusDeviceNode (
IopRootDeviceNode,
ReqDesc->InterfaceType,
ReqDesc->BusNumber,
0
);
// If we did not find a PDO, try again with InterfaceType == Isa. This allows
// drivers that request Internal to get resources even if there is no PDO
// that is Internal. (but if there is an Internal PDO, they get that one)
if ((deviceNode == IopRootDeviceNode) &&
(ReqDesc->ReqAlternative->ReqList->InterfaceType == Internal)) {
deviceNode = IopFindBusDeviceNode(
IopRootDeviceNode,
Isa,
0,
0
);
}
//if ((PVOID)deviceNode == deviceObject->DeviceObjectExtension->DeviceNode) {
// deviceNode = IopRootDeviceNode;
//} else {
continue;
//}
}
}
// Check is there an arbiter for the device node?
// if yes, set up ReqDesc->u.Arbiter and set ArbiterFound to true.
// else move up to the parent of current device node.
if ((arbiterFound == FALSE) && (deviceNode->PhysicalDeviceObject != deviceObject)) {
found = IopFindResourceHandlerInfo(
ResourceArbiter,
deviceNode,
resourceType,
&arbiterEntry);
if (found == FALSE) {
// no information found on arbiter. Try to query translator interface ...
if (resourceType <= PI_MAXIMUM_RESOURCE_TYPE_TRACKED) {
resourceMask = 1 << resourceType;
} else {
resourceMask = 0;
}
status = IopQueryResourceHandlerInterface(ResourceArbiter,
deviceNode->PhysicalDeviceObject,
resourceType,
&interface);
deviceNode->QueryArbiterMask |= resourceMask;
if (!NT_SUCCESS(status)) {
deviceNode->NoArbiterMask |= resourceMask;
if (resourceType <= PI_MAXIMUM_RESOURCE_TYPE_TRACKED) {
found = TRUE;
} else {
interface = NULL;
}
}
if (found == FALSE) {
arbiterEntry = (PPI_RESOURCE_ARBITER_ENTRY)ExAllocatePoolAE(
PagedPool,
sizeof(PI_RESOURCE_ARBITER_ENTRY));
if (!arbiterEntry) {
status = STATUS_INSUFFICIENT_RESOURCES;
return status;
}
InitializeListHead(&arbiterEntry->ActiveArbiterList);
InitializeListHead(&arbiterEntry->DeviceArbiterList);
InitializeListHead(&arbiterEntry->BestConfig);
InitializeListHead(&arbiterEntry->ResourceList);
InitializeListHead(&arbiterEntry->BestResourceList);
arbiterEntry->ResourceType =resourceType;
arbiterEntry->State = 0;
arbiterEntry->ResourcesChanged = FALSE;
listHead = &deviceNode->DeviceArbiterList;
InsertTailList(listHead, &arbiterEntry->DeviceArbiterList);
arbiterEntry->ArbiterInterface = (PARBITER_INTERFACE)interface;
if (!interface) {
// if interface is NULL we really don't have translator.
arbiterEntry = NULL;
}
}
}
// If there is an desired resourcetype arbiter in the device node, make sure
// it handle this resource requriements.
if (arbiterEntry) {
arbiterFound = TRUE;
if (arbiterEntry->ArbiterInterface->Flags & ARBITER_PARTIAL) {
// If the arbiter is partial, ask if it handles the resources
// if not, goto its parent.
status = IopCallArbiter(
arbiterEntry,
ArbiterActionQueryArbitrate,
ReqDesc->TranslatedReqDesc,
NULL,
NULL
);
if (!NT_SUCCESS(status)) {
arbiterFound = FALSE;
}
}
}
if (arbiterFound) {
ReqDesc->u.Arbiter = arbiterEntry;
// Initialize the arbiter entry
arbiterEntry->State = 0;
arbiterEntry->ResourcesChanged = FALSE;
}
}
if (searchTranslator) {
// First, check if there is a translator for the device node?
// If yes, translate the req desc and link it to the front of ReqDesc->TranslatedReqDesc
// else do nothing.
found = IopFindResourceHandlerInfo(
ResourceTranslator,
deviceNode,
resourceType,
&translatorEntry);
if (found == FALSE) {
// no information found on translator. Try to query translator interface ...
if (resourceType <= PI_MAXIMUM_RESOURCE_TYPE_TRACKED) {
resourceMask = 1 << resourceType;
} else {
resourceMask = 0;
}
status = IopQueryResourceHandlerInterface(ResourceTranslator,
deviceNode->PhysicalDeviceObject,
resourceType,
&interface);
deviceNode->QueryTranslatorMask |= resourceMask;
if (!NT_SUCCESS(status)) {
deviceNode->NoTranslatorMask |= resourceMask;
if (resourceType <= PI_MAXIMUM_RESOURCE_TYPE_TRACKED) {
found = TRUE;
} else {
interface = NULL;
}
}
if (found == FALSE) {
translatorEntry = (PPI_RESOURCE_TRANSLATOR_ENTRY)ExAllocatePoolTE(
PagedPool,
sizeof(PI_RESOURCE_TRANSLATOR_ENTRY));
if (!translatorEntry) {
status = STATUS_INSUFFICIENT_RESOURCES;
return status;
}
translatorEntry->ResourceType = resourceType;
InitializeListHead(&translatorEntry->DeviceTranslatorList);
translatorEntry->TranslatorInterface = (PTRANSLATOR_INTERFACE)interface;
translatorEntry->DeviceNode = deviceNode;
listHead = &deviceNode->DeviceTranslatorList;
InsertTailList(listHead, &translatorEntry->DeviceTranslatorList);
if (!interface) {
// if interface is NULL we really don't have translator.
translatorEntry = NULL;
}
}
}
if (translatorEntry) {
translatorFound = TRUE;
}
if ((arbiterFound == FALSE) && translatorEntry) {
// Find a translator to translate the req desc ... Translate it and link it to
// the front of ReqDesc->TranslatedReqDesc such that the first in the list is for
// the Arbiter to use.
reqDesc = ReqDesc->TranslatedReqDesc;
status = IopTranslateAndAdjustReqDesc(
reqDesc,
translatorEntry,
&translatedReqDesc);
if (NT_SUCCESS(status)) {
ASSERT(translatedReqDesc);
resourceType = translatedReqDesc->AlternativeTable.Alternatives->Type;
translatedReqDesc->TranslatedReqDesc = ReqDesc->TranslatedReqDesc;
ReqDesc->TranslatedReqDesc = translatedReqDesc;
// If the translator is non-hierarchial and performs a complete
// translation to root (eg ISA interrups for PCI devices) then
// don't pass translations to parent.
if (status == STATUS_TRANSLATION_COMPLETE) {
searchTranslator = FALSE;
}
} else {
DebugMessage(DUMP_INFO, ("PnpResr: resreq list TranslationAndAdjusted failed\n"));
return status;
}
}
}
// Move up to current device node's parent
deviceNode = deviceNode->Parent;
}
if (arbiterFound) {
return STATUS_SUCCESS;
} else {
// We should BugCheck in this case.
DebugMessage(DUMP_ERROR, ("PnpResr: can not find resource type %x arbiter\n", resourceType));
ASSERT(0);
return STATUS_UNSUCCESSFUL;
}
}
NTSTATUS
IopParentToRawTranslation(
IN OUT PREQ_DESC ReqDesc
)
/*++
Routine Description:
This routine translates an CmPartialResourceDescriptors
from their translated form to their raw counterparts..
Parameters:
ReqDesc - supplies a translated ReqDesc to be translated back to its raw form
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PTRANSLATOR_INTERFACE translator;
NTSTATUS status = STATUS_SUCCESS;
PREQ_DESC rawReqDesc;
if (ReqDesc->AlternativeTable.AlternativeCount == 0 ||
ReqDesc->Allocation.Type == CmResourceTypeMaximum) {
DebugMessage(DUMP_ERROR, ("PnpRes : Invalid ReqDesc for parent-to-raw translation.\n"));
return STATUS_INVALID_PARAMETER;
}
// If this ReqDesc is the raw reqDesc then we are done.
// Else call its translator to translate the resource and leave the result
// in its raw (next level) reqdesc.
if (IS_TRANSLATED_REQ_DESC(ReqDesc)) {
rawReqDesc = ReqDesc->TranslatedReqDesc;
translator = ReqDesc->u.Translator->TranslatorInterface;
status = (translator->TranslateResources)(
translator->Context,
ReqDesc->AlternativeTable.Assignment,
TranslateParentToChild,
rawReqDesc->AlternativeTable.AlternativeCount,
rawReqDesc->AlternativeTable.Alternatives,
rawReqDesc->AlternativeTable.PhysicalDeviceObject,
rawReqDesc->AlternativeTable.Assignment
);
if (NT_SUCCESS(status)) {
// If the translator is non-hierarchial and performs a complete
// translation to root (eg ISA interrups for PCI devices) then
// don't pass translations to parent.
ASSERT(status != STATUS_TRANSLATION_COMPLETE);
status = IopParentToRawTranslation(rawReqDesc);
}
}
return status;
}
NTSTATUS
IopChildToRootTranslation(
IN PDEVICE_NODE DeviceNode, OPTIONAL
IN INTERFACE_TYPE InterfaceType,
IN ULONG BusNumber,
IN ARBITER_REQUEST_SOURCE ArbiterRequestSource,
IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Source,
OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR *Target
)
/*++
Routine Description:
This routine translates a CmPartialResourceDescriptors from
their intermediate translated form to their final translated form.
The translated CM_PARTIAL_RESOURCE_DESCRIPTOR is returned via Target variable.
The caller is responsible to release the translated descriptor.
Parameters:
DeviceNode - Specified the device object. If The DeviceNode is specified,
the InterfaceType and BusNumber are ignored and we will
use DeviceNode as a starting point to find various translators to
translate the Source descriptor. If DeviceNode is not specified,
the InterfaceType and BusNumber must be specified.
InterfaceType, BusNumber - must be supplied if DeviceNode is not specified.
Source - A pointer to the resource descriptor to be translated.
Target - Supplies an address to receive the translated resource descriptor.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PDEVICE_NODE deviceNode;
PLIST_ENTRY listHead, nextEntry;
PCM_PARTIAL_RESOURCE_DESCRIPTOR target, source, tmp;
PPI_RESOURCE_TRANSLATOR_ENTRY translatorEntry;
PTRANSLATOR_INTERFACE translator;
NTSTATUS status = STATUS_SUCCESS;
BOOLEAN done = FALSE, foundTranslator = FALSE, restartedAlready;
if (ArbiterRequestSource == ArbiterRequestHalReported) {
restartedAlready = TRUE;
} else {
restartedAlready = FALSE;
}
source = (PCM_PARTIAL_RESOURCE_DESCRIPTOR) ExAllocatePoolPRD(
PagedPool,
sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR)
);
if (source == NULL) {
return STATUS_INSUFFICIENT_RESOURCES;
}
target = (PCM_PARTIAL_RESOURCE_DESCRIPTOR) ExAllocatePoolPRD(
PagedPool,
sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR)
);
if (target == NULL) {
ExFreePool(source);
return STATUS_INSUFFICIENT_RESOURCES;
}
*source = *Source;
// Move up to current device node's parent to start translation
if (!ARGUMENT_PRESENT(DeviceNode)) {
deviceNode = IopFindBusDeviceNode (IopRootDeviceNode, InterfaceType, BusNumber, 0);
} else {
// We want to start with the deviceNode instead of its parent. Because the
// deviceNode may provide a translator interface.
deviceNode = DeviceNode;
}
while (deviceNode && !done) {
if ((deviceNode == IopRootDeviceNode) && (foundTranslator == FALSE)) {
if (restartedAlready == FALSE) {
restartedAlready = TRUE;
deviceNode = IopFindBusDeviceNode (IopRootDeviceNode, InterfaceType, BusNumber, 0);
// If we did not find a PDO, try again with InterfaceType == Isa. This allows
// drivers that request Internal to get resources even if there is no PDO
// that is Internal. (but if there is an Internal PDO, they get that one)
if ((deviceNode == IopRootDeviceNode) && (InterfaceType == Internal)) {
deviceNode = IopFindBusDeviceNode(IopRootDeviceNode, Isa, 0, 0);
}
continue;
}
}
// First, check if there is a translator for the device node?
// If yes, translate the req desc and link it to the front of ReqDesc->TranslatedReqDesc
// else do nothing.
listHead = &deviceNode->DeviceTranslatorList;
nextEntry = listHead->Flink;
for (; nextEntry != listHead; nextEntry = nextEntry->Flink) {
translatorEntry = CONTAINING_RECORD(nextEntry, PI_RESOURCE_TRANSLATOR_ENTRY, DeviceTranslatorList);
if (translatorEntry->ResourceType == Source->Type) {
if (translator = translatorEntry->TranslatorInterface) {
// Find a translator to translate the req desc ... Translate it and link it to
// the front of ReqDesc->TranslatedReqDesc.
doitagain:
status = (translator->TranslateResources) (
translator->Context,
source,
TranslateChildToParent,
0,
NULL,
DeviceNode ? DeviceNode->PhysicalDeviceObject : NULL,
target
);
if (NT_SUCCESS(status)) {
tmp = source;
source = target;
target = tmp;
// If the translator is non-hierarchial and performs a complete
// translation to root (eg ISA interrups for PCI devices) then
// don't pass translations to parent.
if (status == STATUS_TRANSLATION_COMPLETE) {
done = TRUE;
}
} else {
#if DBG_SCOPE
// DebugMessage(DUMP_ERROR, ("PnpRes: Child to Root Translation failed\n"));
DbgPrint("PnpRes: Child to Root Translation failed\n");
if (DeviceNode) {
DbgPrint(
" DeviceNode %08x (PDO %08x)\n",
DeviceNode,
DeviceNode->PhysicalDeviceObject
);
}
DbgPrint(
" Resource Type %02x Data %08x %08x %08x\n",
source->Type,
source->u.DevicePrivate.Data[0],
source->u.DevicePrivate.Data[1],
source->u.DevicePrivate.Data[2]
);
if (PnpResDebugTranslationFailureCount) {
PnpResDebugTranslationFailureCount--;
PnpResDebugTranslationFailure->devnode = DeviceNode;
PnpResDebugTranslationFailure->resource = *source;
PnpResDebugTranslationFailure++;
}
if (PnpResDebugLevel & STOP_ERROR) {
DbgBreakPoint();
goto doitagain;
}
#endif
goto exit;
}
}
break;
}
}
// Move up to current device node's parent
deviceNode = deviceNode->Parent;
}
*Target = source;
ExFreePool(target);
return status;
exit:
ExFreePool(source);
ExFreePool(target);
return status;
}
NTSTATUS
IopTranslateAndAdjustReqDesc(
IN PREQ_DESC ReqDesc,
IN PPI_RESOURCE_TRANSLATOR_ENTRY TranslatorEntry,
OUT PREQ_DESC *TranslatedReqDesc
)
/*++
Routine Description:
This routine translates and adjusts ReqDesc IoResourceDescriptors to
their translated and adjusted form.
Parameters:
ReqDesc - supplies a pointer to the REQ_DESC to be translated.
TranslatorEntry - supplies a pointer to the translator infor structure.
TranslatedReqDesc - supplies a pointer to a variable to receive the
translated REQ_DESC.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
ULONG i, total = 0, *targetCount;
PTRANSLATOR_INTERFACE translator = TranslatorEntry->TranslatorInterface;
PIO_RESOURCE_DESCRIPTOR ioDesc, *target, tIoDesc;
PREQ_DESC tReqDesc;
PARBITER_LIST_ENTRY arbiterEntry;
NTSTATUS status, returnStatus = STATUS_SUCCESS;
BOOLEAN reqTranslated = FALSE;
if (ReqDesc->AlternativeTable.AlternativeCount == 0) {
return STATUS_INVALID_PARAMETER;
}
*TranslatedReqDesc = NULL;
target = (PIO_RESOURCE_DESCRIPTOR *) ExAllocatePoolIORD(
PagedPool,
sizeof(PIO_RESOURCE_DESCRIPTOR) * ReqDesc->AlternativeTable.AlternativeCount
);
if (target == NULL) {
DebugMessage(DUMP_ERROR, ("PnpRes: Not Enough memory to perform resreqlist adjustment\n"));
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(target, sizeof(PIO_RESOURCE_DESCRIPTOR) * ReqDesc->AlternativeTable.AlternativeCount);
targetCount = (PULONG) ExAllocatePool(
PagedPool,
sizeof(ULONG) * ReqDesc->AlternativeTable.AlternativeCount
);
if (targetCount == NULL) {
DebugMessage(DUMP_ERROR, ("PnpRes: Not Enough memory to perform resreqlist adjustment\n"));
ExFreePool(target);
return STATUS_INSUFFICIENT_RESOURCES;
}
RtlZeroMemory(targetCount, sizeof(ULONG) * ReqDesc->AlternativeTable.AlternativeCount);
// Determine the number of IO_RESOURCE_DESCRIPTORs after translation.
ioDesc = ReqDesc->AlternativeTable.Alternatives;
for (i = 0; i < ReqDesc->AlternativeTable.AlternativeCount; i++) {
status = (translator->TranslateResourceRequirements)(
translator->Context,
ioDesc,
ReqDesc->AlternativeTable.PhysicalDeviceObject,
&targetCount[i],
&target[i]
);
if (!NT_SUCCESS(status) || targetCount[i] == 0) {
DebugMessage(DUMP_ERROR, ("PnpRes:Translator failed to adjust resreqlist\n"));
target[i] = ioDesc;
targetCount[i] = 0;
total++;
} else {
total += targetCount[i];
reqTranslated = TRUE;
}
ioDesc++;
if (NT_SUCCESS(status) && (returnStatus != STATUS_TRANSLATION_COMPLETE)) {
returnStatus = status;
}
}
if (!reqTranslated) {
DebugMessage(DUMP_ERROR, ("PnpRes:Failed to translate any requirement for %ws!\n", ((PDEVICE_NODE)(ReqDesc->AlternativeTable.PhysicalDeviceObject->DeviceObjectExtension->DeviceNode))->InstancePath.Buffer));
returnStatus = status;
}
// Allocate memory for the adjusted/translated resources descriptors
tIoDesc = (PIO_RESOURCE_DESCRIPTOR) ExAllocatePoolIORD(
PagedPool,
total * sizeof(IO_RESOURCE_DESCRIPTOR));
if (!tIoDesc) {
DebugMessage(DUMP_ERROR, ("PnpRes: Not Enough memory to perform resreqlist adjustment\n"));
returnStatus = STATUS_INSUFFICIENT_RESOURCES;
goto exit;
}
tReqDesc = (PREQ_DESC) ExAllocatePool1RD (PagedPool, sizeof(REQ_DESC));
if (tReqDesc == NULL) {
DebugMessage(DUMP_ERROR, ("PnpRes: Not Enough memory to perform resreqlist adjustment\n"));
ExFreePool(tIoDesc);
returnStatus = STATUS_INSUFFICIENT_RESOURCES;
goto exit;
}
// Create and initialize a new REQ_DESC for the translated/adjusted io resources
RtlMoveMemory(tReqDesc, ReqDesc, sizeof(REQ_DESC));
// Set the translated req desc's ReqAlternative to NULL to indicated this
// is not the original req desc.
tReqDesc->ReqAlternative = NULL;
tReqDesc->u.Translator = TranslatorEntry;
tReqDesc->TranslatedReqDesc = NULL;
arbiterEntry = &tReqDesc->AlternativeTable;
InitializeListHead(&arbiterEntry->ListEntry);
arbiterEntry->AlternativeCount = total;
arbiterEntry->Alternatives = tIoDesc;
arbiterEntry->Assignment = &tReqDesc->Allocation;
ioDesc = ReqDesc->AlternativeTable.Alternatives;
for (i = 0; i < ReqDesc->AlternativeTable.AlternativeCount; i++) {
if (targetCount[i] != 0) {
RtlMoveMemory(tIoDesc, target[i], targetCount[i] * sizeof(IO_RESOURCE_DESCRIPTOR));
tIoDesc += targetCount[i];
} else {
// Make it become impossible to satisfy.
RtlMoveMemory(tIoDesc, ioDesc, sizeof(IO_RESOURCE_DESCRIPTOR));
switch (tIoDesc->Type) {
case CmResourceTypePort:
case CmResourceTypeMemory:
tIoDesc->u.Port.MinimumAddress.LowPart = 2;
tIoDesc->u.Port.MinimumAddress.HighPart = 0;
tIoDesc->u.Port.MaximumAddress.LowPart = 1;
tIoDesc->u.Port.MaximumAddress.HighPart = 0;
break;
case CmResourceTypeBusNumber:
tIoDesc->u.BusNumber.MinBusNumber = 2;
tIoDesc->u.BusNumber.MaxBusNumber = 1;
break;
case CmResourceTypeInterrupt:
tIoDesc->u.Interrupt.MinimumVector = 2;
tIoDesc->u.Interrupt.MaximumVector = 1;
break;
case CmResourceTypeDma:
tIoDesc->u.Dma.MinimumChannel = 2;
tIoDesc->u.Dma.MaximumChannel = 1;
break;
default:
ASSERT(0);
break;
}
tIoDesc += 1;
}
ioDesc++;
}
#if DBG
// Verify the adjusted resource descriptors are valid
ioDesc = arbiterEntry->Alternatives;
ASSERT((ioDesc->Option & IO_RESOURCE_ALTERNATIVE) == 0);
ioDesc++;
for (i = 1; i < total; i++) {
ASSERT(ioDesc->Option & IO_RESOURCE_ALTERNATIVE);
ioDesc++;
}
#endif
*TranslatedReqDesc = tReqDesc;
exit:
for (i = 0; i < ReqDesc->AlternativeTable.AlternativeCount; i++) {
if (targetCount[i] != 0) {
ASSERT(target[i]);
ExFreePool(target[i]);
}
}
ExFreePool(target);
ExFreePool(targetCount);
return returnStatus;
}
NTSTATUS
IopCallArbiter(
PPI_RESOURCE_ARBITER_ENTRY ArbiterEntry,
ARBITER_ACTION Command,
PVOID Input1,
PVOID Input2,
PVOID Input3
)
/*++
Routine Description:
This routine builds a Parameter block from Input structure and calls specified
arbiter to carry out the Command.
Parameters:
ArbiterEntry - Supplies a pointer to our PI_RESOURCE_ARBITER_ENTRY such that
we know everything about the arbiter.
Command - Supplies the Action code for the arbiter.
Input - Supplies a PVOID pointer to a structure.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
ARBITER_PARAMETERS parameters;
PARBITER_INTERFACE arbiterInterface = ArbiterEntry->ArbiterInterface;
NTSTATUS status;
PARBITER_LIST_ENTRY arbiterListEntry;
LIST_ENTRY listHead;
PVOID *ExtParams;
switch (Command) {
case ArbiterActionTestAllocation:
case ArbiterActionRetestAllocation:
// For ArbiterActionTestAllocation, the Input is a pointer to the doubly
// linked list of ARBITER_LIST_ENTRY's.
parameters.Parameters.TestAllocation.ArbitrationList = (PLIST_ENTRY)Input1;
parameters.Parameters.TestAllocation.AllocateFromCount = (ULONG)((ULONG_PTR)Input2);
parameters.Parameters.TestAllocation.AllocateFrom =
(PCM_PARTIAL_RESOURCE_DESCRIPTOR)Input3;
status = (arbiterInterface->ArbiterHandler)(
arbiterInterface->Context,
Command,
&parameters
);
break;
case ArbiterActionBootAllocation:
// For ArbiterActionBootAllocation, the input is a pointer to the doubly
// linked list of ARBITER_LIST_ENTRY'S.
parameters.Parameters.BootAllocation.ArbitrationList = (PLIST_ENTRY)Input1;
status = (arbiterInterface->ArbiterHandler)(
arbiterInterface->Context,
Command,
&parameters
);
break;
case ArbiterActionQueryArbitrate:
// For QueryArbiter, the input is a pointer to REQ_DESC
arbiterListEntry = &((PREQ_DESC)Input1)->AlternativeTable;
ASSERT(IsListEmpty(&arbiterListEntry->ListEntry));
listHead = arbiterListEntry->ListEntry;
arbiterListEntry->ListEntry.Flink = arbiterListEntry->ListEntry.Blink = &listHead;
parameters.Parameters.QueryArbitrate.ArbitrationList = &listHead;
status = (arbiterInterface->ArbiterHandler)(
arbiterInterface->Context,
Command,
&parameters
);
arbiterListEntry->ListEntry = listHead;
break;
case ArbiterActionCommitAllocation:
case ArbiterActionRollbackAllocation:
case ArbiterActionWriteReservedResources:
// Commit, Rollback and WriteReserved do not have parmater.
status = (arbiterInterface->ArbiterHandler)(
arbiterInterface->Context,
Command,
NULL
);
break;
case ArbiterActionQueryAllocatedResources:
status = STATUS_NOT_IMPLEMENTED;
break;
case ArbiterActionQueryConflict:
// For QueryConflict
// Ex0 is PDO
// Ex1 is PIO_RESOURCE_DESCRIPTOR
// Ex2 is PULONG
// Ex3 is PARBITER_CONFLICT_INFO *
ExtParams = (PVOID*)Input1;
parameters.Parameters.QueryConflict.PhysicalDeviceObject = (PDEVICE_OBJECT)ExtParams[0];
parameters.Parameters.QueryConflict.ConflictingResource = (PIO_RESOURCE_DESCRIPTOR)ExtParams[1];
parameters.Parameters.QueryConflict.ConflictCount = (PULONG)ExtParams[2];
parameters.Parameters.QueryConflict.Conflicts = (PARBITER_CONFLICT_INFO *)ExtParams[3];
status = (arbiterInterface->ArbiterHandler)(
arbiterInterface->Context,
Command,
&parameters
);
break;
default:
status = STATUS_INVALID_PARAMETER;
break;
}
return status;
}
#if DBG_SCOPE
VOID
IopDumpResourceRequirementsList(
IN PIO_RESOURCE_REQUIREMENTS_LIST IoResources
)
/*++
Routine Description:
This routine dumps IoResources
Parameters:
IoResources - supplies a pointer to the IO resource requirements list
Return Value:
None.
--*/
{
PIO_RESOURCE_LIST IoResourceList;
PIO_RESOURCE_DESCRIPTOR IoResourceDescriptor;
PIO_RESOURCE_DESCRIPTOR IoResourceDescriptorEnd;
LONG IoResourceListCount;
if (IoResources == NULL) {
return;
}
IoResourceList = IoResources->List;
IoResourceListCount = (LONG) IoResources->AlternativeLists;
// For old IO resource requirements list there is no assigned resources associated with
// it. We simply free the memory.
DbgPrint("** ResReqList: Interface: %x, Bus: %x, Slot: %x, AlternativeLists: %x\n",
IoResources->InterfaceType,
IoResources->BusNumber,
IoResources->SlotNumber,
IoResources->AlternativeLists);
while (--IoResourceListCount >= 0) {
DbgPrint (" Alternative List: DescCount: %x\n", IoResourceList->Count);
IoResourceDescriptor = IoResourceList->Descriptors;
IoResourceDescriptorEnd = IoResourceDescriptor + IoResourceList->Count;
for (; IoResourceDescriptor < IoResourceDescriptorEnd; ++IoResourceDescriptor) {
IopDumpResourceDescriptor(" ", IoResourceDescriptor);
}
IoResourceList = (PIO_RESOURCE_LIST) IoResourceDescriptorEnd;
}
DbgPrint("\n");
}
VOID
IopDumpResourceDescriptor (
IN PUCHAR Indent,
IN PIO_RESOURCE_DESCRIPTOR Desc
)
{
DbgPrint("%sOpt: %x, Share: %x\t", Indent, Desc->Option, Desc->ShareDisposition);
switch (Desc->Type) {
case CmResourceTypePort:
DbgPrint ("IO Min: %x:%08x, Max: %x:%08x, Algn: %x, Len %x\n",
Desc->u.Port.MinimumAddress.HighPart, Desc->u.Port.MinimumAddress.LowPart,
Desc->u.Port.MaximumAddress.HighPart, Desc->u.Port.MaximumAddress.LowPart,
Desc->u.Port.Alignment,
Desc->u.Port.Length
);
break;
case CmResourceTypeMemory:
DbgPrint ("MEM Min: %x:%08x, Max: %x:%08x, Algn: %x, Len %x\n",
Desc->u.Memory.MinimumAddress.HighPart, Desc->u.Memory.MinimumAddress.LowPart,
Desc->u.Memory.MaximumAddress.HighPart, Desc->u.Memory.MaximumAddress.LowPart,
Desc->u.Memory.Alignment,
Desc->u.Memory.Length
);
break;
case CmResourceTypeInterrupt:
DbgPrint ("INT Min: %x, Max: %x\n",
Desc->u.Interrupt.MinimumVector,
Desc->u.Interrupt.MaximumVector
);
break;
case CmResourceTypeDma:
DbgPrint ("DMA Min: %x, Max: %x\n",
Desc->u.Dma.MinimumChannel,
Desc->u.Dma.MaximumChannel
);
break;
case CmResourceTypeDevicePrivate:
DbgPrint ("DevicePrivate Data: %x, %x, %x\n",
Desc->u.DevicePrivate.Data[0],
Desc->u.DevicePrivate.Data[1],
Desc->u.DevicePrivate.Data[2]
);
break;
default:
DbgPrint ("Unknown Descriptor type %x\n",
Desc->Type
);
break;
}
}
#endif
VOID
IopQueryRebalance (
IN PDEVICE_NODE DeviceNode,
IN ULONG Phase,
IN PULONG RebalanceCount,
IN PDEVICE_OBJECT **DeviceTable
)
/*++
Routine Description:
This routine walks hardware tree depth first. For each device node it visits,
it call IopQueryReconfigureDevice to query-stop device for resource
reconfiguration.
Note, Under rebalancing situation, all the participated devices will be asked to
stop. Even they support non-stopped rebalancing.
Parameters:
DeviceNode - supplies a pionter a device node which is the root of the tree to
be tested.
Phase - Supplies a value to specify the phase of the rebalance.
RebalanceCount - supplies a pointer to a variable to receive the number of devices
participating the rebalance.
Return Value:
None.
--*/
{
LONG oldState;
PDEVICE_OBJECT *deviceList, *deviceTable, *device;
ULONG count;
PDEVICE_NODE deviceNode;
// Call worker routine to get a list of devices to be rebalanced.
deviceTable = *DeviceTable;
IopQueryRebalanceWorker (DeviceNode, Phase, RebalanceCount, DeviceTable);
count = *RebalanceCount;
if (count != 0 && Phase == 0) {
// At phase 0, we did not actually query-stop the device.
// We need to do it now.
deviceList = (PDEVICE_OBJECT *)ExAllocatePoolPDO(PagedPool, count * sizeof(PDEVICE_OBJECT));
if (deviceList == NULL) {
*RebalanceCount = 0;
return;
}
RtlMoveMemory(deviceList, deviceTable, sizeof(PDEVICE_OBJECT) * count);
// Rebuild the returned device list
*RebalanceCount = 0;
*DeviceTable = deviceTable;
for (device = deviceList; device < (deviceList + count); device++) {
deviceNode = (PDEVICE_NODE)((*device)->DeviceObjectExtension->DeviceNode);
IopQueryRebalanceWorker (deviceNode, 1, RebalanceCount, DeviceTable);
}
ExFreePool(deviceList);
}
return;
}
VOID
IopQueryRebalanceWorker (
IN PDEVICE_NODE DeviceNode,
IN ULONG Phase,
IN PULONG RebalanceCount,
IN PDEVICE_OBJECT **DeviceTable
)
/*++
Routine Description:
This routine walks hardware tree depth first. For each device node it visits,
it call IopQueryReconfigureDevice to query-stop and stop device for resource
reconfiguration.
Parameters:
DeviceNode - supplies a pionter a device node which is the root of the tree to
be tested.
Phase - Supplies a value to specify the phase of the rebalance.
RebalanceCount - supplies a pointer to a variable to receive the number of devices
participating the rebalance.
Return Value:
None.
--*/
{
PDEVICE_NODE node;
if (DeviceNode == NULL)
{
ASSERT(DeviceNode);
return;
}
// Include Insufficient_resources checking. THis is because a driver (scsiminiport) may call
// IoReportResourceUsage to perform detection and cause the (Isapnp) enumerated device
// insufficient_resources to start. At this point, the enumerated device resources should be locked down
// for the detected instance.
if (((DeviceNode->Flags & DNF_ASYNC_REQUEST_PENDING) ||
(DeviceNode->Flags & DNF_STOPPED) ||
(IopDoesDevNodeHaveProblem(DeviceNode)) ||
(DeviceNode->Flags & DNF_LEGACY_DRIVER) ||
(DeviceNode->Flags & DNF_ASSIGNING_RESOURCES)) &&
!(DeviceNode->Flags & DNF_NEEDS_REBALANCE)) {
node = DeviceNode->Sibling;
} else {
node = DeviceNode;
}
for (; node; node = node->Sibling) {
if (node->Child) {
// If this subtree is not being removed, wait for current enumeration to complete.
if (node->LockCount == 0) {
KeWaitForSingleObject( &node->EnumerationMutex,
Executive,
KernelMode,
FALSE,
NULL);
IopQueryRebalanceWorker (node->Child, Phase, RebalanceCount, DeviceTable);
KeSetEvent(&node->EnumerationMutex, 0, FALSE);
}
}
}
for (node = DeviceNode; node; node = node->Sibling) {
if (node->LockCount == 0) {
IopTestForReconfiguration (node, Phase, RebalanceCount, DeviceTable);
} else {
DebugMessage(DUMP_ERROR, ("PNPRES: %ws enum lock is taken, skipping during REBALANCE!\n", node->InstancePath.Buffer));
}
}
}
VOID
IopTestForReconfiguration (
IN PDEVICE_NODE DeviceNode,
IN ULONG Phase,
IN PULONG RebalanceCount,
IN PDEVICE_OBJECT **DeviceTable
)
/*++
Routine Description:
This routine query-stops a device which is started and owns resources.
Note the resources for the device are not released at this point.
Parameters:
DeviceNode - supplies a pointer to the device node to be tested for reconfiguration.
Phase - Supplies a value to specify the phase of the rebalance.
RebalanceCount - supplies a pointer to a variable to receive the number of devices
participating the rebalance.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PDEVICE_NODE nodex;
NTSTATUS status;
BOOLEAN addToList = FALSE;
// We still need to perform the test for sibling nodes.
if ((DeviceNode->Flags & DNF_ASYNC_REQUEST_PENDING) ||
(DeviceNode->Flags & DNF_STOPPED) ||
(IopDoesDevNodeHaveProblem(DeviceNode)) ||
(DeviceNode->Flags & DNF_LEGACY_DRIVER) ||
(DeviceNode->Flags & DNF_ASSIGNING_RESOURCES)) {
return;
}
if (Phase == 0) {
// At phase zero, this routine only wants to find out which devices's resource
// requirements lists chagned. No one actually gets stopped.
if (DeviceNode->Flags & DNF_RESOURCE_REQUIREMENTS_CHANGED &&
!(DeviceNode->Flags & DNF_NON_STOPPED_REBALANCE) ) {
// It's too hard to handle non-stop rebalancing devices during rebalance.
// So, We will skip it.
addToList = TRUE;
} else {
if (DeviceNode->Flags & DNF_STARTED) {
status = IopQueryReconfiguration (IRP_MN_QUERY_STOP_DEVICE, DeviceNode->PhysicalDeviceObject);
if (NT_SUCCESS(status)) {
if (status == STATUS_RESOURCE_REQUIREMENTS_CHANGED) {
// If we find out a device's resource requirements changed this way,
// it will be stopped and reassigned resources even if it supports
// non-stopped rebalance.
DeviceNode->Flags |= DNF_RESOURCE_REQUIREMENTS_CHANGED;
addToList = TRUE;
}
}
IopQueryReconfiguration (IRP_MN_CANCEL_STOP_DEVICE, DeviceNode->PhysicalDeviceObject);
}
}
if (addToList) {
*RebalanceCount = *RebalanceCount + 1;
**DeviceTable = DeviceNode->PhysicalDeviceObject;
*DeviceTable = *DeviceTable + 1;
}
} else {
// Phase 1
if (DeviceNode->Flags & DNF_STARTED) {
// Make sure all the resources required children of the DeviceNode are stopped.
nodex = DeviceNode->Child;
while (nodex) {
if (!(nodex->Flags & (DNF_STARTED | DNF_ASSIGNING_RESOURCES)) ||
(nodex->Flags & DNF_STOPPED) ||
(nodex->Flags & DNF_NEEDS_REBALANCE)) {
nodex = nodex->Sibling;
} else {
break;
}
}
if (nodex) {
// If any resource required child of the DeviceNode does not stopped,
// we won't ask the DeviceNode to stop.
// BUGBUG: We may want to restart the stopped subtrees.
DebugMessage(DUMP_INFO, ("Rebalance: Child %ws not stopped for %ws\n", nodex->InstancePath.Buffer, DeviceNode->InstancePath.Buffer));
return;
}
} else if ((DeviceNode->Flags & DNF_HAS_BOOT_CONFIG) == 0 ||
!(DeviceNode->Flags & DNF_ADDED) ||
DeviceNode->Flags & DNF_MADEUP) {
// The device is not started and has no boot config. There is no need to query-stop it.
// Or if the device has BOOT config but there is no driver installed for it. We don't query
// stop it. (There may be legacy drivers are using the resources.)
// We also don't want to query stop root enumerated devices (for performance reason.)
// BUGBUG - We really want to query stop the root enumerated devices which do not have
// Boot Config and have resource requirement alternatives. (But today some legacy
// driver installers do not create boot resources.)
return;
}
status = IopQueryReconfiguration (IRP_MN_QUERY_STOP_DEVICE, DeviceNode->PhysicalDeviceObject);
if (NT_SUCCESS(status)) {
DebugMessage(DUMP_INFO, ("Rebalance: %ws succeeded QueryStop\n", DeviceNode->InstancePath.Buffer));
if (DeviceNode->Flags & DNF_STARTED) {
//DeviceNode->Flags &= ~DNF_STARTED;
DeviceNode->Flags |= DNF_STOPPED;
*RebalanceCount = *RebalanceCount + 1;
**DeviceTable = DeviceNode->PhysicalDeviceObject;
// Add a reference to the device object such that it won't disapear during rebalance.
ObReferenceObject(DeviceNode->PhysicalDeviceObject);
*DeviceTable = *DeviceTable + 1;
} else {
// We need to release the device's prealloc boot config. This device will NOT
// participate in resource rebalancing.
ASSERT(DeviceNode->Flags & DNF_HAS_BOOT_CONFIG);
status = IopQueryReconfiguration (IRP_MN_STOP_DEVICE, DeviceNode->PhysicalDeviceObject);
ASSERT(NT_SUCCESS(status));
IopReleaseBootResources(DeviceNode);
// Reset BOOT CONFIG flags. DO NOT set DNF_STOPPED.
DeviceNode->Flags &= ~(DNF_HAS_BOOT_CONFIG + DNF_BOOT_CONFIG_RESERVED);
}
} else {
IopQueryReconfiguration (IRP_MN_CANCEL_STOP_DEVICE, DeviceNode->PhysicalDeviceObject);
}
}
}
NTSTATUS
IopPlacementForRebalance (
IN PDEVICE_NODE DeviceNode,
IN ARBITER_ACTION ArbiterAction
)
/*++
Routine Description:
This routine walks the device tree bredth-first to arbitrate resources for
device node it visits.
Parameters:
DeviceNode - supplies a pointer to a device node whoes subtree needs to be rebalanced.
ArbiterAction - specifies TEST or RETEST.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_NODE node;
// Perform breadth-first. Arbitrate resource for the current device node;
// Place resources for its sibling subtree and then child subtree.
node = DeviceNode;
while (node) {
// Arbitrate device resources iff its not locked for remove.
if (node->LockCount == 0) {
status = IopArbitrateDeviceResources (node, ArbiterAction);
if (!NT_SUCCESS(status)) {
return status;
}
}
node = node->Sibling;
}
node = DeviceNode;
while (node) {
// If this subtree is not being removed, then process it.
if (node->Child && node->LockCount == 0) {
status = IopPlacementForRebalance (node->Child, ArbiterAction);
if (!NT_SUCCESS(status)) {
return status;
}
}
node = node->Sibling;
}
return status;
}
NTSTATUS
IopArbitrateDeviceResources (
IN PDEVICE_NODE DeviceNode,
IN ARBITER_ACTION ArbiterAction
)
/*++
Routine Description:
This routine
Parameters:
P1 -
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PLIST_ENTRY listEntry, listHead;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
ULONG count = 0;
PCM_PARTIAL_RESOURCE_DESCRIPTOR cmDesc = NULL;
NTSTATUS status;
ASSERT((ArbiterAction == ArbiterActionTestAllocation) ||
(ArbiterAction == ArbiterActionRetestAllocation) ||
(ArbiterAction == ArbiterActionCommitAllocation));
listHead = &DeviceNode->DeviceArbiterList;
listEntry = listHead->Flink;
while (listEntry != listHead) {
arbiterEntry = CONTAINING_RECORD(listEntry, PI_RESOURCE_ARBITER_ENTRY, DeviceArbiterList);
listEntry = listEntry->Flink;
if (IsListEmpty(&arbiterEntry->ResourceList) == FALSE) {
if (ArbiterAction == ArbiterActionCommitAllocation) {
status = IopCallArbiter(arbiterEntry, ArbiterActionCommitAllocation, NULL, NULL, NULL);
ASSERT(status == STATUS_SUCCESS);
arbiterEntry->State = 0;
InitializeListHead(&arbiterEntry->ActiveArbiterList);
InitializeListHead(&arbiterEntry->BestConfig);
InitializeListHead(&arbiterEntry->ResourceList);
InitializeListHead(&arbiterEntry->BestResourceList);
} else if (arbiterEntry->ResourcesChanged == FALSE) {
// If the resource requirements are the same and it failed before, we know it
// won't be able to succeed. So, return failure.
if (arbiterEntry->State & PI_ARBITER_TEST_FAILED) {
return STATUS_UNSUCCESSFUL;
}
} else {
// If the resource requirements are changed, we need to call arbiter to test it.
// First find out what resources *could* be owned by the arbiter.
// And then call the Arbiter to try to satisfy the request from the resources
// it *could* have.
status = IopFindResourcesForArbiter(
DeviceNode,
arbiterEntry->ResourceType,
&count,
&cmDesc
);
if (!NT_SUCCESS(status)) {
DebugMessage(DUMP_ERROR, ("Rebalance: Failed to find required resources for Arbiter\n"));
return status;
}
status = IopCallArbiter(arbiterEntry,
ArbiterAction,
&arbiterEntry->ResourceList,
(PVOID)ULongToPtr(count),
cmDesc
);
if (cmDesc) {
ExFreePool(cmDesc);
}
if (!NT_SUCCESS(status)) {
arbiterEntry->State |= PI_ARBITER_TEST_FAILED;
return status;
} else {
arbiterEntry->State &= ~PI_ARBITER_TEST_FAILED;
arbiterEntry->ResourcesChanged = FALSE;
if (ArbiterAction == ArbiterActionTestAllocation) {
arbiterEntry->State |= PI_ARBITER_HAS_SOMETHING;
}
}
}
}
}
return STATUS_SUCCESS;
}
NTSTATUS
IopFindResourcesForArbiter (
IN PDEVICE_NODE DeviceNode,
IN UCHAR ResourceType,
OUT ULONG *Count,
OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR *CmDesc
)
/*++
Routine Description:
This routine returns the resources required by the ResourceType arbiter in DeviceNode.
Parameters:
DeviceNode -specifies the device node whose ResourceType arbiter is requesting for resources
ResourceType - specifies the resource type
Count - specifies a pointer to a varaible to receive the count of Cm descriptors returned
CmDesc - specifies a pointer to a varibble to receive the returned cm descriptor.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PIOP_RESOURCE_REQUEST assignEntry;
PREQ_ALTERNATIVE reqAlternative;
PREQ_DESC reqDesc;
ULONG i, count = 0;
PCM_PARTIAL_RESOURCE_DESCRIPTOR cmDescriptor;
*Count = 0;
*CmDesc = NULL;
if (DeviceNode->Flags & DNF_STARTED) {
return STATUS_SUCCESS;
}
// Find this device node's IOP_RESOURCE_REQUEST structure first
for (assignEntry = PiAssignTable + PiAssignTableCount - 1;
assignEntry >= PiAssignTable;
assignEntry--) {
if (assignEntry->PhysicalDevice == DeviceNode->PhysicalDeviceObject) {
break;
}
}
if (assignEntry < PiAssignTable) {
DebugMessage(DUMP_ERROR, ("Rebalance: No resreqlist for Arbiter? Can not find Arbiter assign table entry\n"));
return STATUS_UNSUCCESSFUL;
}
reqAlternative = *((PREQ_LIST)assignEntry->ReqList)->SelectedAlternative;
for (i = 0; i < reqAlternative->ReqDescCount; i++) {
reqDesc = reqAlternative->ReqDescTable[i]->TranslatedReqDesc;
if (reqDesc->Allocation.Type == ResourceType) {
count++;
}
}
cmDescriptor = (PCM_PARTIAL_RESOURCE_DESCRIPTOR) ExAllocatePoolPRD(
PagedPool,
sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * count
);
if (!cmDescriptor) {
// If we can not find memory, the resources will not be committed by arbiter.
DebugMessage(DUMP_ERROR, ("Rebalance: Not enough memory to perform rebalance\n"));
return STATUS_INSUFFICIENT_RESOURCES;
}
*Count = count;
*CmDesc = cmDescriptor;
for (i = 0; i < reqAlternative->ReqDescCount; i++) {
reqDesc = reqAlternative->ReqDescTable[i]->TranslatedReqDesc;
if (reqDesc->Allocation.Type == ResourceType) {
*cmDescriptor = reqDesc->Allocation;
cmDescriptor++;
}
}
return STATUS_SUCCESS;
}
NTSTATUS
IopRebalance (
IN ULONG AssignTableCount,
IN PIOP_RESOURCE_REQUEST AssignTable
)
/*++
Routine Description:
This routine performs rebalancing operation. There are two rebalance phases:
In the phase 0, we only consider the devices whoes resource requirements changed
and their children; in phase 1, we consider anyone who succeeds the query-stop.
Parameters:
AssignTableCount,
AssignTable - Supplies the number of origianl AssignTableCout and AssignTable which
triggers the rebalance operation.
(if AssignTableCount == 0, we are processing device state change.)
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
ULONG count, i;
PIOP_RESOURCE_REQUEST table = NULL, tableEnd, newEntry;
PIOP_RESOURCE_REQUEST requestTable = NULL, requestTableEnd, entry1, entry2;
ULONG phase0RebalanceCount = 0, rebalanceCount = 0, deviceCount;
NTSTATUS status, statusx;
PDEVICE_OBJECT *deviceTable, *deviceTablex;
PDEVICE_NODE deviceNode;
ULONG rebalancePhase = 0;
// Query all the device nodes to see who are willing to participate the rebalance
// process.
deviceTable = (PDEVICE_OBJECT *) ExAllocatePoolPDO(
PagedPool,
sizeof(PDEVICE_OBJECT) * IopNumberDeviceNodes);
if (deviceTable == NULL) {
DebugMessage(DUMP_ERROR, ("Rebalance: Not enough memory to perform rebalance\n"));
return STATUS_INSUFFICIENT_RESOURCES;
}
tryAgain:
deviceTablex = deviceTable + phase0RebalanceCount;
// Walk device node tree depth-first to query-stop and stop devices.
// At this point the resources of the stopped devices are not released yet.
// Also, the leaf nodes are in the front of the device table and non leaf nodes
// are at the end of the table.
IopQueryRebalance (IopRootDeviceNode, rebalancePhase, &rebalanceCount, &deviceTablex);
if (rebalanceCount == 0) {
// If no one is interested and we are not processing resources req change,
// move to next phase.
if (rebalancePhase == 0 && AssignTableCount != 0) {
rebalancePhase = 1;
goto tryAgain;
}
DebugMessage(DUMP_INFO, ("Rebalance: No device participates in rebalance phase %x\n", rebalancePhase));
ExFreePool(deviceTable);
deviceTable = NULL;
status = STATUS_UNSUCCESSFUL;
goto exit;
}
if (rebalanceCount == phase0RebalanceCount) {
// Phase 0 failed and no new device participates. failed the rebalance.
status = STATUS_UNSUCCESSFUL;
goto exit;
}
if (rebalancePhase == 0) {
phase0RebalanceCount = rebalanceCount;
}
// Allocate pool for the new reconfiguration requests and the original requests.
table = (PIOP_RESOURCE_REQUEST) ExAllocatePoolIORR(
PagedPool,
sizeof(IOP_RESOURCE_REQUEST) * (AssignTableCount + rebalanceCount)
);
if (table == NULL) {
DebugMessage(DUMP_ERROR, ("Rebalance: Not enough memory to perform rebalance\n"));
status = STATUS_INSUFFICIENT_RESOURCES;
goto exit;
}
tableEnd = table + AssignTableCount + rebalanceCount;
// Build a new resource request table. The original requests will be at the beginning
// of the table and new requests (reconfigured devices) are at the end.
// After the new request table is built, the leaf nodes will be in front of the table,
// and non leaf nodes will be close to the end of the table. This is for optimization.
// Copy the original request to the front of our new request table.
if (AssignTableCount != 0) {
RtlMoveMemory(table, AssignTable, sizeof(IOP_RESOURCE_REQUEST) * AssignTableCount);
}
// Initialize all the new entries of our new request table,
newEntry = table + AssignTableCount;
RtlZeroMemory(newEntry, sizeof(IOP_RESOURCE_REQUEST) * rebalanceCount);
for (i = 0, deviceTablex = deviceTable; i < rebalanceCount; i++, deviceTablex++) {
newEntry[i].AllocationType = ArbiterRequestPnpEnumerated;
newEntry[i].PhysicalDevice = *deviceTablex;
}
status = IopGetResourceRequirementsForAssignTable(
newEntry,
tableEnd ,
&deviceCount);
if (!NT_SUCCESS(status) || deviceCount == 0) {
DebugMessage(DUMP_ERROR, ("Rebalance: GetResourceRequirementsForAssignTable failed\n"));
status = NT_SUCCESS(status)? STATUS_UNSUCCESSFUL : status;
goto exit;
}
// Process the AssignTable to remove any entry which is marked as IOP_ASSIGN_IGNORE
if (deviceCount != rebalanceCount) {
deviceCount += AssignTableCount;
requestTable = (PIOP_RESOURCE_REQUEST) ExAllocatePoolIORR(
PagedPool,
sizeof(IOP_RESOURCE_REQUEST) * deviceCount
);
if (requestTable == NULL) {
IopFreeResourceRequirementsForAssignTable(newEntry, tableEnd);
status = STATUS_INSUFFICIENT_RESOURCES;
goto exit;
}
for (entry1 = table, entry2 = requestTable; entry1 < tableEnd; entry1++) {
if (!(entry1->Flags & IOP_ASSIGN_IGNORE)) {
*entry2 = *entry1;
entry2++;
} else {
// BUGBUG!!! ??? (jamiehun)
// if this assert fails, parts of this code are broken
ASSERT(entry1 >= newEntry);
}
}
requestTableEnd = requestTable + deviceCount;
} else {
requestTable = table;
requestTableEnd = tableEnd;
deviceCount += AssignTableCount;
}
// DO NOT Sort the AssignTable
//IopRearrangeAssignTable(requestTable, deviceCount);
#if 0
// We are about to perform rebalance. Release the resources of the reconfiguration devices
for (entry1 = newEntry; entry1 < tableEnd; entry1++) {
if (!(entry1->Flags & IOP_ASSIGN_IGNORE) &&
!(entry1->Flags & IOP_ASSIGN_RESOURCES_RELEASED)) {
deviceNode = (PDEVICE_NODE)entry1->PhysicalDevice->DeviceObjectExtension->DeviceNode;
if (deviceNode->ResourceList) {
// Call IopReleaseResourcesInternal instead of IopReleaseResources such that
// the pool for devicenode->ResourceList is not freed. We need it to restart
// the reconfigured devices in case rebalance failed.
IopReleaseResourcesInternal(deviceNode);
entry1->Flags |= IOP_ASSIGN_RESOURCES_RELEASED;
}
}
}
#endif
// Assign the resources. If we succeed, or if
// there is a memory shortage return immediately.
status = IopAssignInner(deviceCount, requestTable, TRUE);
if (NT_SUCCESS(status)) {
// If the rebalance succeeded, we need to restart all the reconfigured devices.
// For the original devices, we will return and let IopAllocateResources to deal
// with them.
IopBuildCmResourceLists(requestTable, requestTableEnd);
// Copy the new status back to the original AssignTable.
if (AssignTableCount != 0) {
RtlMoveMemory(AssignTable, requestTable, sizeof(IOP_RESOURCE_REQUEST) * AssignTableCount);
}
// free resource requirements we allocated while here
IopFreeResourceRequirementsForAssignTable(requestTable+AssignTableCount, requestTableEnd);
if (table != requestTable) {
// If we switched request table ... copy the contents of new table back to
// the old table.
for (entry1 = table, entry2 = requestTable; entry2 < requestTableEnd;) {
if (entry1->Flags & IOP_ASSIGN_IGNORE) {
entry1++;
continue;
}
*entry1 = *entry2;
if (entry2->Flags & IOP_ASSIGN_EXCLUDE) {
entry1->Status = STATUS_CONFLICTING_ADDRESSES;
}
entry2++;
entry1++;
}
}
// Go thru the origianl request table to stop each query-stopped/reconfigured device.
DebugMessage(DUMP_DETAIL, ("PnpRes: STOP reconfigured devices during REBALANCE.\n"));
for (entry1 = newEntry; entry1 < tableEnd; entry1++) {
if (NT_SUCCESS(entry1->Status)) {
IopQueryReconfiguration (IRP_MN_STOP_DEVICE, entry1->PhysicalDevice);
} else {
IopQueryReconfiguration (IRP_MN_CANCEL_STOP_DEVICE, entry1->PhysicalDevice);
deviceNode = (PDEVICE_NODE)entry1->PhysicalDevice->DeviceObjectExtension->DeviceNode;
deviceNode->Flags &= ~DNF_STOPPED;
}
}
// Commit the allocation AFTER stopping rebalance candidates.
DebugMessage(DUMP_DETAIL, ("PnpRes: Commit the new allocation during REBALANCE.\n"));
IopPlacement(ArbiterActionCommitAllocation, TRUE);
#if DBG_SCOPE
if (PnpResDebugLevel & STOP_ERROR) {
IopCheckDataStructures(IopRootDeviceNode);
}
#endif
// Go thru the origianl request table to start each stopped/reconfigured device.
for (entry1 = tableEnd - 1; entry1 >= newEntry; entry1--) {
deviceNode = (PDEVICE_NODE)entry1->PhysicalDevice->DeviceObjectExtension->DeviceNode;
if (NT_SUCCESS(entry1->Status)) {
// We need to release the pool space for ResourceList and ResourceListTranslated.
// Because the earlier IopReleaseResourcesInternal does not release the pool.
if (deviceNode->ResourceList) {
ExFreePool(deviceNode->ResourceList);
}
deviceNode->ResourceList = entry1->ResourceAssignment;
if (deviceNode->ResourceListTranslated) {
ExFreePool(deviceNode->ResourceListTranslated);
}
deviceNode->ResourceListTranslated = entry1->TranslatedResourceAssignment;
if (deviceNode->ResourceList) {
deviceNode->Flags |= DNF_RESOURCE_ASSIGNED;
deviceNode->Flags &= ~DNF_RESOURCE_REPORTED;
} else {
deviceNode->Flags |= DNF_NO_RESOURCE_REQUIRED;
}
if (entry1->Flags & IOP_ASSIGN_CLEAR_RESOURCE_REQUIREMENTS_CHANGE_FLAG) {
// If we are processing the resource requirements change request,
// clear its related flags.
deviceNode->Flags &= ~(DNF_RESOURCE_REQUIREMENTS_CHANGED | DNF_NON_STOPPED_REBALANCE);
}
// Some drivers (like ndis) may want to do resource allocation during START.
// So let go of the IopRegistrySemaphore during the start.
KeReleaseSemaphore(&IopRegistrySemaphore, 0, 1, FALSE);
KeLeaveCriticalRegion();
IopStartDevice(entry1->PhysicalDevice);
KeEnterCriticalRegion();
KeWaitForSingleObject( &IopRegistrySemaphore,
DelayExecution,
KernelMode,
FALSE,
NULL );
}
}
// Finally release the references of the reconfigured device objects
for (deviceTablex = (deviceTable + rebalanceCount - 1);
deviceTablex >= deviceTable;
deviceTablex--) {
ObDereferenceObject(*deviceTablex);
}
status = STATUS_SUCCESS;
} else {
// Rebalance failed. Free our internal representation of the rebalance
// candidates' resource requirements lists.
// BugBug - should optimize the code.
IopFreeResourceRequirementsForAssignTable(requestTable + AssignTableCount, requestTableEnd);
if (rebalancePhase == 0) {
rebalancePhase++;
if (requestTable) {
ExFreePool(requestTable);
}
if (table && (table != requestTable)) {
ExFreePool(table);
}
table = requestTable = NULL;
goto tryAgain;
}
// Rebalance failed. Restore the resources for the reconfiguration participated devices.
// Note, for some devices, their resource requirements may already changed. In this
// case, the resources we restore do not reflect the new requirements.
for (deviceTablex = (deviceTable + rebalanceCount - 1);
deviceTablex >= deviceTable;
deviceTablex--) {
deviceNode = (PDEVICE_NODE)((*deviceTablex)->DeviceObjectExtension->DeviceNode);
#if 0
statusx = IopRestoreResourcesInternal(deviceNode);
if (NT_SUCCESS(statusx)) {
IopQueryReconfiguration (IRP_MN_CANCEL_STOP_DEVICE, *deviceTablex);
deviceNode->Flags &= ~DNF_STOPPED;
} else {
ASSERT(0);
IopRequestDeviceRemoval(*deviceTablex);
}
#else
IopQueryReconfiguration (IRP_MN_CANCEL_STOP_DEVICE, *deviceTablex);
deviceNode->Flags &= ~DNF_STOPPED;
#endif
ObDereferenceObject(*deviceTablex);
}
}
ExFreePool(deviceTable);
deviceTable = NULL;
exit:
if (!NT_SUCCESS(status) && deviceTable) {
// If we failed before trying to perform resource assignment,
// we will end up here.
DebugMessage(DUMP_INFO, ("Rebalance: Rebalance failed\n"));
// Somehow we failed to start the rebalance operation.
// We will cancel the query-stop request for the query-stopped devices bredth first.
for (deviceTablex = (deviceTable + rebalanceCount - 1);
deviceTablex >= deviceTable;
deviceTablex--) {
deviceNode = (PDEVICE_NODE)((*deviceTablex)->DeviceObjectExtension->DeviceNode);
IopQueryReconfiguration (IRP_MN_CANCEL_STOP_DEVICE, *deviceTablex);
deviceNode->Flags &= ~DNF_STOPPED;
ObDereferenceObject(*deviceTablex);
}
}
if (deviceTable) {
ExFreePool(deviceTable);
}
if (requestTable) {
ExFreePool(requestTable);
}
if (table && (table != requestTable)) {
ExFreePool(table);
}
return status;
}
NTSTATUS
IopRestoreResourcesInternal (
IN PDEVICE_NODE DeviceNode
)
/*++
Routine Description:
This routine reassigns the released resources for device specified by DeviceNode.
Parameters:
DeviceNode - specifies the device node whose resources are goint to be released.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
IOP_RESOURCE_REQUEST requestTable;
NTSTATUS status;
if (DeviceNode->ResourceList == NULL) {
return STATUS_SUCCESS;
}
requestTable.ResourceRequirements =
IopCmResourcesToIoResources (0, DeviceNode->ResourceList, LCPRI_FORCECONFIG);
if (requestTable.ResourceRequirements == NULL) {
DebugMessage(DUMP_ERROR, ("PnpRes: Not enough memory to clean up rebalance failure\n"));
return STATUS_INSUFFICIENT_RESOURCES;
}
requestTable.Priority = 0;
requestTable.Flags = 0;
requestTable.AllocationType = ArbiterRequestPnpEnumerated;
requestTable.PhysicalDevice = DeviceNode->PhysicalDeviceObject;
requestTable.ReqList = NULL;
requestTable.ResourceAssignment = NULL;
requestTable.TranslatedResourceAssignment = NULL;
requestTable.Status = 0;
// rebuild internal representation of the resource requirements list
status = IopResourceRequirementsListToReqList(
requestTable.AllocationType,
requestTable.ResourceRequirements,
requestTable.PhysicalDevice,
&requestTable.ReqList);
if (!NT_SUCCESS(status) || requestTable.ReqList == NULL) {
DebugMessage(DUMP_ERROR, ("PnpRes: Not enough memory to restore previous resources\n"));
ExFreePool (requestTable.ResourceRequirements);
return status;
} else {
PREQ_LIST reqList;
reqList = (PREQ_LIST)requestTable.ReqList;
reqList->AssignEntry = &requestTable;
// Sort the ReqList such that the higher priority Alternative list are
// placed in the front of the list.
IopRearrangeReqList(reqList);
if (reqList->ReqBestAlternative == NULL) {
IopFreeResourceRequirementsForAssignTable(&requestTable, (&requestTable) + 1);
return STATUS_DEVICE_CONFIGURATION_ERROR;
}
}
status = IopAssignInner(1, &requestTable, FALSE);
IopFreeResourceRequirementsForAssignTable(&requestTable, (&requestTable) + 1);
if (!NT_SUCCESS(status)) {
DbgPrint("IopRestoreResourcesInternal: BOOT conflict for %ws\n", DeviceNode->InstancePath.Buffer);
ASSERT(NT_SUCCESS(status));
}
if (requestTable.ResourceAssignment) {
ExFreePool(requestTable.ResourceAssignment);
}
if (requestTable.TranslatedResourceAssignment) {
ExFreePool(requestTable.TranslatedResourceAssignment);
}
IopWriteAllocatedResourcesToRegistry (
DeviceNode,
DeviceNode->ResourceList,
IopDetermineResourceListSize(DeviceNode->ResourceList)
);
return status;
}
VOID
IopReleaseResourcesInternal (
IN PDEVICE_NODE DeviceNode
)
/*++
Routine Description:
This routine releases the assigned resources for device specified by DeviceNode.
Note, this routine does not reset the resource related fields in DeviceNode structure.
Parameters:
DeviceNode - specifies the device node whose resources are goint to be released.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PDEVICE_NODE device;
PLIST_ENTRY listHead, listEntry;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
ARBITER_LIST_ENTRY arbiterListEntry;
INTERFACE_TYPE interfaceType;
ULONG busNumber, listCount, i, j, size;
PCM_RESOURCE_LIST resourceList;
PCM_FULL_RESOURCE_DESCRIPTOR cmFullDesc;
PCM_PARTIAL_RESOURCE_DESCRIPTOR cmPartDesc;
BOOLEAN search = TRUE;
#if DBG
NTSTATUS status;
#endif
InitializeListHead(&arbiterListEntry.ListEntry);
arbiterListEntry.AlternativeCount = 0;
arbiterListEntry.Alternatives = NULL;
arbiterListEntry.PhysicalDeviceObject = DeviceNode->PhysicalDeviceObject;
arbiterListEntry.Flags = 0;
arbiterListEntry.WorkSpace = 0;
arbiterListEntry.Assignment = NULL;
arbiterListEntry.RequestSource = ArbiterRequestPnpEnumerated;
resourceList = DeviceNode->ResourceList;
if (resourceList == NULL) {
resourceList = DeviceNode->BootResources;
}
if (resourceList && resourceList->Count > 0) {
listCount = resourceList->Count;
cmFullDesc = &resourceList->List[0];
} else {
listCount = 1;
resourceList = NULL;
}
for (i = 0; i < listCount; i++) {
if (resourceList) {
interfaceType = cmFullDesc->InterfaceType;
busNumber = cmFullDesc->BusNumber;
if (interfaceType == InterfaceTypeUndefined) {
interfaceType = PnpDefaultInterfaceType;
}
} else {
interfaceType = PnpDefaultInterfaceType;
busNumber = 0;
}
device = DeviceNode->Parent;
while (device) {
if ((device == IopRootDeviceNode) && search) {
device = IopFindBusDeviceNode (
IopRootDeviceNode,
interfaceType,
busNumber,
0
);
// If we did not find a PDO, try again with InterfaceType == Isa. This allows
// drivers that request Internal to get resources even if there is no PDO
// that is Internal. (but if there is an Internal PDO, they get that one)
if ((device == IopRootDeviceNode) && (interfaceType == Internal)) {
device = IopFindBusDeviceNode(IopRootDeviceNode, Isa, 0, 0);
}
search = FALSE;
}
listHead = &device->DeviceArbiterList;
listEntry = listHead->Flink;
while (listEntry != listHead) {
arbiterEntry = CONTAINING_RECORD(listEntry, PI_RESOURCE_ARBITER_ENTRY, DeviceArbiterList);
if (arbiterEntry->ArbiterInterface != NULL) {
search = FALSE;
ASSERT(IsListEmpty(&arbiterEntry->ResourceList));
InitializeListHead(&arbiterEntry->ResourceList); // Recover from assert
InsertTailList(&arbiterEntry->ResourceList, &arbiterListEntry.ListEntry);
#if DBG
status =
#endif
IopCallArbiter(arbiterEntry,
ArbiterActionTestAllocation,
&arbiterEntry->ResourceList,
NULL,
NULL
);
#if DBG
ASSERT(status == STATUS_SUCCESS);
status =
#endif
IopCallArbiter(arbiterEntry,
ArbiterActionCommitAllocation,
NULL,
NULL,
NULL
);
#if DBG
ASSERT(status == STATUS_SUCCESS);
#endif
RemoveEntryList(&arbiterListEntry.ListEntry);
InitializeListHead(&arbiterListEntry.ListEntry);
}
listEntry = listEntry->Flink;
}
device = device->Parent;
}
// If there are more than 1 list, move to next list
if (listCount > 1) {
cmPartDesc = &cmFullDesc->PartialResourceList.PartialDescriptors[0];
for (j = 0; j < cmFullDesc->PartialResourceList.Count; j++) {
size = 0;
switch (cmPartDesc->Type) {
case CmResourceTypeDeviceSpecific:
size = cmPartDesc->u.DeviceSpecificData.DataSize;
break;
}
cmPartDesc++;
cmPartDesc = (PCM_PARTIAL_RESOURCE_DESCRIPTOR) ((PUCHAR)cmPartDesc + size);
}
cmFullDesc = (PCM_FULL_RESOURCE_DESCRIPTOR)cmPartDesc;
}
}
IopWriteAllocatedResourcesToRegistry (DeviceNode, NULL, 0);
}
NTSTATUS
IopFindLegacyDeviceNode (
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT DeviceObject OPTIONAL,
OUT PDEVICE_NODE *LegacyDeviceNode,
OUT PDEVICE_OBJECT *LegacyPDO
)
/*++
Routine Description:
This routine searches for the device node and device object created for legacy resource
allocation for the DriverObject and DeviceObject.
Parameters:
DriverObject - specifies the driver object doing the legacy allocation.
DeviceObject - specifies the device object.
LegacyDeviceNode - receives the pointer to the legacy device node if found.
LegacyDeviceObject - receives the pointer to the legacy device object if found.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
NTSTATUS status = STATUS_UNSUCCESSFUL;
PDEVICE_NODE deviceNode;
ASSERT(LegacyDeviceNode && LegacyPDO);
// Use the device object if it exists.
if (DeviceObject) {
deviceNode = (PDEVICE_NODE)DeviceObject->DeviceObjectExtension->DeviceNode;
if (deviceNode) {
*LegacyPDO = DeviceObject;
*LegacyDeviceNode = deviceNode;
status = STATUS_SUCCESS;
} else if (!(DeviceObject->Flags & DO_BUS_ENUMERATED_DEVICE)) {
deviceNode = IopAllocateDeviceNode(DeviceObject);
if (deviceNode) {
deviceNode->Flags |= DNF_LEGACY_RESOURCE_DEVICENODE;
IopSetLegacyDeviceInstance (DriverObject, deviceNode);
*LegacyPDO = DeviceObject;
*LegacyDeviceNode = deviceNode;
status = STATUS_SUCCESS;
} else {
DebugMessage(DUMP_ERROR, ("PNPRES: Failed to allocate device node for PDO %08X\n", DeviceObject));
status = STATUS_INSUFFICIENT_RESOURCES;
}
} else {
DebugMessage(DUMP_ERROR, ("PNPRES: %08X PDO without a device node!\n", DeviceObject));
ASSERT(DeviceObject->DeviceObjectExtension->DeviceNode);
}
} else {
// Search our list of legacy device nodes.
for ( deviceNode = IopLegacyDeviceNode;
deviceNode && deviceNode->DuplicatePDO != (PDEVICE_OBJECT)DriverObject;
deviceNode = deviceNode->NextDeviceNode);
if (deviceNode) {
*LegacyPDO = deviceNode->PhysicalDeviceObject;
*LegacyDeviceNode = deviceNode;
status = STATUS_SUCCESS;
} else {
WCHAR buffer[60];
UNICODE_STRING deviceName;
LARGE_INTEGER tickCount;
ULONG length;
PDEVICE_OBJECT pdo;
// We are seeing this for the first time.
// Create a madeup device node.
KeQueryTickCount(&tickCount);
length = _snwprintf(buffer, sizeof(buffer) / sizeof(WCHAR), L"\\Device\\Resource%04u%x", IopNumberDeviceNodes, tickCount.LowPart);
deviceName.MaximumLength = sizeof(buffer);
deviceName.Length = (USHORT)(length * sizeof(WCHAR));
deviceName.Buffer = buffer;
DebugMessage(DUMP_INFO, ("PNPRES: Creating dummy PDO %ws\n", deviceName.Buffer));
status = IoCreateDevice( IoPnpDriverObject,
sizeof(IOPNP_DEVICE_EXTENSION),
&deviceName,
FILE_DEVICE_CONTROLLER,
0,
FALSE,
&pdo);
if (NT_SUCCESS(status)) {
pdo->Flags |= DO_BUS_ENUMERATED_DEVICE;
deviceNode = IopAllocateDeviceNode(pdo);
if (deviceNode) {
// Change driver object to the caller even though the owner
// of the pdo is IoPnpDriverObject. This is to support
// DriverExclusive for legacy interface.
pdo->DriverObject = DriverObject;
deviceNode->Flags = DNF_MADEUP | DNF_PROCESSED | DNF_LEGACY_RESOURCE_DEVICENODE;
deviceNode->DuplicatePDO = (PDEVICE_OBJECT)DriverObject;
IopSetLegacyDeviceInstance (DriverObject, deviceNode);
// Add it to our list of legacy device nodes rather than adding it to the HW tree.
deviceNode->NextDeviceNode = IopLegacyDeviceNode;
if (IopLegacyDeviceNode) {
IopLegacyDeviceNode->PreviousDeviceNode = deviceNode;
}
IopLegacyDeviceNode = deviceNode;
*LegacyPDO = pdo;
*LegacyDeviceNode = deviceNode;
} else {
DebugMessage(DUMP_ERROR, ("PNPRES: Failed to allocate device node for PDO %08X\n", pdo));
IoDeleteDevice(pdo);
status = STATUS_INSUFFICIENT_RESOURCES;
}
} else {
DebugMessage(DUMP_ERROR, ("PNPRES: IoCreateDevice failed for %ws with status %08X\n", deviceName.Buffer, status));
}
}
}
return status;
}
VOID
IopRemoveLegacyDeviceNode (
IN PDEVICE_OBJECT DeviceObject OPTIONAL,
IN PDEVICE_NODE LegacyDeviceNode
)
/*++
Routine Description:
This routine removes the device node and device object created for legacy resource
allocation for the DeviceObject.
Parameters:
DeviceObject - specifies the device object.
LegacyDeviceNode - receives the pointer to the legacy device node if found.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
ASSERT(LegacyDeviceNode);
if (!DeviceObject) {
if (LegacyDeviceNode->DuplicatePDO) {
LegacyDeviceNode->DuplicatePDO = NULL;
if (LegacyDeviceNode->PreviousDeviceNode) {
LegacyDeviceNode->PreviousDeviceNode->NextDeviceNode = LegacyDeviceNode->NextDeviceNode;
}
if (LegacyDeviceNode->NextDeviceNode) {
LegacyDeviceNode->NextDeviceNode->PreviousDeviceNode = LegacyDeviceNode->PreviousDeviceNode;
}
if (IopLegacyDeviceNode == LegacyDeviceNode) {
IopLegacyDeviceNode = LegacyDeviceNode->NextDeviceNode;
}
} else {
DebugMessage(DUMP_ERROR, ("PNPRES: %ws does not have a duplicate PDO\n", LegacyDeviceNode->InstancePath.Buffer));
ASSERT(LegacyDeviceNode->DuplicatePDO);
return;
}
}
if (!(DeviceObject && (DeviceObject->Flags & DO_BUS_ENUMERATED_DEVICE))) {
PDEVICE_NODE resourceDeviceNode;
PDEVICE_OBJECT pdo;
for ( resourceDeviceNode = (PDEVICE_NODE)LegacyDeviceNode->OverUsed1.LegacyDeviceNode;
resourceDeviceNode;
resourceDeviceNode = resourceDeviceNode->OverUsed2.NextResourceDeviceNode) {
if (resourceDeviceNode->OverUsed2.NextResourceDeviceNode == LegacyDeviceNode) {
resourceDeviceNode->OverUsed2.NextResourceDeviceNode = LegacyDeviceNode->OverUsed2.NextResourceDeviceNode;
break;
}
}
LegacyDeviceNode->Parent = LegacyDeviceNode->Sibling =
LegacyDeviceNode->Child = LegacyDeviceNode->LastChild = NULL;
// Delete the dummy PDO and device node.
pdo = LegacyDeviceNode->PhysicalDeviceObject;
IopDestroyDeviceNode(LegacyDeviceNode);
if (!DeviceObject) {
pdo->DriverObject = IoPnpDriverObject;
IoDeleteDevice(pdo);
}
}
}
NTSTATUS
IopLegacyResourceAllocation (
IN ARBITER_REQUEST_SOURCE AllocationType,
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT DeviceObject OPTIONAL,
IN PIO_RESOURCE_REQUIREMENTS_LIST ResourceRequirements,
IN OUT PCM_RESOURCE_LIST *AllocatedResources OPTIONAL
)
/*++
Routine Description:
This routine handles legacy interface IoAssignResources and IoReportResourcesUsage,
It converts the request to call IopAllocateResources.
Parameters:
AllocationType - Allocation type for the legacy request.
DriverObject - Driver object doing the legacy allocation.
DeviceObject - Device object.
ResourceRequirements - Legacy resource requirements. If NULL, caller want to free resources.
AllocatedResources - Pointer to a variable that receives pointer to allocated resources.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PDEVICE_OBJECT pdo;
PDEVICE_NODE deviceNode;
PDEVICE_NODE legacyDeviceNode;
NTSTATUS status;
PCM_RESOURCE_LIST combinedResources;
KIRQL irql;
ASSERT(DriverObject);
// Grab the IO registry semaphore to make sure no other device is
// reporting it's resource usage while we are searching for conflicts.
KeEnterCriticalRegion();
status = KeWaitForSingleObject( &IopRegistrySemaphore,
DelayExecution,
KernelMode,
FALSE,
NULL);
if (NT_SUCCESS(status)) {
status = IopFindLegacyDeviceNode(DriverObject, DeviceObject, &deviceNode, &pdo);
if (NT_SUCCESS(status)) {
legacyDeviceNode = NULL;
if (!deviceNode->Parent && ResourceRequirements) {
// Make IopRootDeviceNode the bus pdo so we will search the right bus pdo
// on resource descriptor level.
if (ResourceRequirements->InterfaceType == InterfaceTypeUndefined) {
ResourceRequirements->InterfaceType = PnpDefaultInterfaceType;
}
deviceNode->Parent = IopRootDeviceNode;
}
// Release resources for this device node.
if ( (!ResourceRequirements && deviceNode->Parent) ||
(deviceNode->Flags & (DNF_RESOURCE_REPORTED | DNF_RESOURCE_ASSIGNED))) {
IopReleaseResources(deviceNode);
}
if (ResourceRequirements) {
IOP_RESOURCE_REQUEST requestTable;
IOP_RESOURCE_REQUEST *requestTablep;
ULONG count;
// Try to allocate these resource requirements.
count = 1;
RtlZeroMemory(&requestTable, sizeof(IOP_RESOURCE_REQUEST));
requestTable.ResourceRequirements = ResourceRequirements;
requestTable.PhysicalDevice = pdo;
requestTable.Flags = IOP_ASSIGN_NO_REBALANCE;
requestTable.AllocationType = AllocationType;
deviceNode->Flags |= DNF_ASSIGNING_RESOURCES;
requestTablep = &requestTable;
IopAllocateResources(&count, &requestTablep, TRUE, TRUE);
deviceNode->Flags &= ~DNF_ASSIGNING_RESOURCES;
status = requestTable.Status;
if (NT_SUCCESS(status)) {
deviceNode->Flags |= DNF_RESOURCE_REPORTED;
//deviceNode->Flags &= ~DNF_INSUFFICIENT_RESOURCES;
deviceNode->ResourceListTranslated = requestTable.TranslatedResourceAssignment;
count = IopDetermineResourceListSize((*AllocatedResources) ? *AllocatedResources : requestTable.ResourceAssignment);
deviceNode->ResourceList = ExAllocatePoolIORL(PagedPool, count);
if (deviceNode->ResourceList) {
if (*AllocatedResources) {
// We got called from IoReportResourceUsage.
ASSERT(requestTable.ResourceAssignment);
ExFreePool(requestTable.ResourceAssignment);
} else {
// We got called from IoAssignResources.
*AllocatedResources = requestTable.ResourceAssignment;
}
RtlCopyMemory(deviceNode->ResourceList, *AllocatedResources, count);
legacyDeviceNode = (PDEVICE_NODE)deviceNode->OverUsed1.LegacyDeviceNode;
} else {
deviceNode->ResourceList = requestTable.ResourceAssignment;
IopReleaseResources(deviceNode);
status = STATUS_INSUFFICIENT_RESOURCES;
}
}
// Remove the madeup PDO and device node if there was some error.
if (!NT_SUCCESS(status)) {
IopRemoveLegacyDeviceNode(DeviceObject, deviceNode);
}
} else {
// Caller wants to release resources.
legacyDeviceNode = (PDEVICE_NODE)deviceNode->OverUsed1.LegacyDeviceNode;
IopRemoveLegacyDeviceNode(DeviceObject, deviceNode);
}
if (NT_SUCCESS(status)) {
if (legacyDeviceNode) {
// After the resource is modified, update the allocated resource list
// for the Root\Legacy_xxxx\0000 device instance.
combinedResources = IopCombineLegacyResources(legacyDeviceNode);
if (combinedResources) {
IopWriteAllocatedResourcesToRegistry( legacyDeviceNode,
combinedResources,
IopDetermineResourceListSize(combinedResources));
ExFreePool(combinedResources);
}
}
// BUGBUG: Santoshj 10/01/99
// Since IoReportDetectedDevice always uses IoPnpDriverObject instead of the one
// passed in, we put in this hack so that we dont taint ourselves. Other bugs need
// to be fixed before removing this hack (dont do resource allocation if this
// was already reported).
if (AllocationType != ArbiterRequestPnpDetected && DriverObject != IoPnpDriverObject) {
// Modify the DRVOBJ flags.
ExAcquireFastLock(&IopDatabaseLock, &irql);
if (ResourceRequirements) {
// Once tainted, a driver can never lose it's legacy history
// (unless unloaded). This is because the device object
// field is optional, and we don't bother counting here...
DriverObject->Flags |= DRVO_LEGACY_RESOURCES;
}
ExReleaseFastLock(&IopDatabaseLock, irql);
}
}
}
KeReleaseSemaphore(&IopRegistrySemaphore, 0, 1, FALSE);
} else {
DebugMessage(DUMP_ERROR, ("PNPRES: IopLegacyResourceAllocation: Failed to acquire registry semaphore, status %08X\n", status));
}
KeLeaveCriticalRegion();
return status;
}
PDEVICE_NODE
IopFindBusDeviceNode (
IN PDEVICE_NODE DeviceNode,
IN INTERFACE_TYPE InterfaceType,
IN ULONG BusNumber,
IN ULONG SlotNumber
)
/*++
Routine Description:
This routine finds the bus PDO which performs translation and arbitration for the
specified InterfaceType, BusNumber and SlotNumber.
Parameters:
DeviceNode - the root of the PDO to start our search
InterfaceType - Specifies the PDO's interface type.
BusNumber - specifies the PDO's bus number.
SlotNumber - specified the PDO's slot number (UNUSED).
Return Value:
A pointer to the BUS PDO.
--*/
{
PDEVICE_NODE busDeviceNode = NULL;
UNREFERENCED_PARAMETER(SlotNumber);
if (DeviceNode && InterfaceType != InterfaceTypeUndefined) {
if (InterfaceType == PNPBus) {
// if we specified PnpBus as InterfaceType, we know nobody specifies such a bus
// don't waste time looking for BusNumber because it doesn't exist
busDeviceNode = NULL;
} else {
// search for bus (recursive)
busDeviceNode = IopFindBusDeviceNodeInternal(DeviceNode, (InterfaceType == Eisa) ? Isa : InterfaceType, BusNumber);
}
if (busDeviceNode == NULL && DeviceNode == IopRootDeviceNode) {
DebugMessage(DUMP_DETAIL, ("IopFindBusDeviceNode: Found %ws with interface=%08X & bus=%08X\n", DeviceNode->InstancePath.Buffer, InterfaceType, BusNumber));
return DeviceNode;
}
if (busDeviceNode) {
DebugMessage(DUMP_DETAIL, ("IopFindBusDeviceNode: Found %ws with interface=%08X & bus=%08X\n", busDeviceNode->InstancePath.Buffer, InterfaceType, BusNumber));
}
}
return busDeviceNode;
}
PDEVICE_NODE
IopFindBusDeviceNodeInternal (
IN PDEVICE_NODE DeviceNode,
IN INTERFACE_TYPE InterfaceType,
IN ULONG BusNumber
)
/*++
Routine Description:
This worker routine finds the bus PDO which performs translation and arbitration for the
specified InterfaceType and BusNumber.
Parameters:
DeviceNode - the root of the PDO to start our search
InterfaceType - Specifies the PDO's interface type.
BusNumber - specifies the PDO's bus number.
Return Value:
A pointer to the BUS PDO.
--*/
{
PDEVICE_NODE current;
for (current = DeviceNode; current; current = current->Sibling) {
if ( BusNumber == current->BusNumber &&
(InterfaceType == current->InterfaceType ||
(InterfaceType == Isa && current->InterfaceType == Eisa))) {
return current;
}
if (current->Child) {
PDEVICE_NODE busDeviceNode = IopFindBusDeviceNodeInternal(current->Child, InterfaceType, BusNumber);
if (busDeviceNode) {
return busDeviceNode;
}
}
}
return NULL;
}
NTSTATUS
IopDuplicateDetection (
IN INTERFACE_TYPE LegacyBusType,
IN ULONG BusNumber,
IN ULONG SlotNumber,
OUT PDEVICE_NODE *DeviceNode
)
/*++
Routine Description:
This routine searches for the bus device driver for a given legacy device,
sends a query interface IRP for legacy device detection, and if the driver
implements this interface, requests the PDO for the given legacy device.
Parameters:
LegacyBusType - The legacy device's interface type.
BusNumber - The legacy device's bus number.
SlotNumber - The legacy device's slot number.
DeviceNode - specifies a pointer to a variable to receive the duplicated device node
Return Value:
NTSTATUS code.
--*/
{
PDEVICE_NODE deviceNode;
PDEVICE_OBJECT busDeviceObject;
PLEGACY_DEVICE_DETECTION_INTERFACE interface;
NTSTATUS status;
PDEVICE_OBJECT deviceObject;
// Initialize return parameter to "not found".
*DeviceNode = NULL;
// Search the device tree for the bus of the legacy device.
deviceNode = IopFindBusDeviceNode(
IopRootDeviceNode,
LegacyBusType,
BusNumber,
SlotNumber
);
// Either a bus driver does not exist (or more likely, the legacy bus
// type and bus number were unspecified). Either way, we can't make
// any further progress.
if (deviceNode == NULL) {
return STATUS_INVALID_DEVICE_REQUEST;
}
// We found the legacy device's bus driver. Query it to determine
// whether it implements the LEGACY_DEVICE_DETECTION interface.
busDeviceObject = deviceNode->PhysicalDeviceObject;
status = IopQueryResourceHandlerInterface(
ResourceLegacyDeviceDetection,
busDeviceObject,
0,
(PINTERFACE *)&interface
);
// If it doesn't, we're stuck.
if (!NT_SUCCESS(status) || interface == NULL) {
return STATUS_INVALID_DEVICE_REQUEST;
}
// Invoke the bus driver's legacy device detection method.
status = (*interface->LegacyDeviceDetection)(
interface->Context,
LegacyBusType,
BusNumber,
SlotNumber,
&deviceObject
);
// If it found a legacy device, update the return parameter.
if (NT_SUCCESS(status) && deviceObject != NULL) {
*DeviceNode =
(PDEVICE_NODE)deviceObject->DeviceObjectExtension->DeviceNode;
status = STATUS_SUCCESS;
} else {
status = STATUS_INVALID_DEVICE_REQUEST;
}
// Free the interface.
(*interface->InterfaceDereference)(interface->Context);
ExFreePool(interface);
return status;
}
VOID
IopSetLegacyDeviceInstance (
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_NODE DeviceNode
)
/*++
Routine Description:
This routine sets the Root\Legacy_xxxx\0000 device instance path to the
madeup PDO (i.e. DeviceNode) which is created only for legacy resource allocation.
This routine also links the madeup PDO to the Root\Legacy_xxxx\0000 device node
to keep track what resources are assigned to the driver which services the
root\legacy_xxxx\0000 device.
Parameters:
P1 -
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
NTSTATUS status;
UNICODE_STRING instancePath, rootString;
HANDLE handle;
PDEVICE_NODE legacyDeviceNode;
PDEVICE_OBJECT legacyPdo;
PAGED_CODE();
DeviceNode->OverUsed1.LegacyDeviceNode = 0;
instancePath.Length = 0;
instancePath.Buffer = NULL;
status = IopServiceInstanceToDeviceInstance (
NULL,
&DriverObject->DriverExtension->ServiceKeyName,
0,
&instancePath,
&handle,
KEY_READ
);
if (NT_SUCCESS(status) && (instancePath.Length != 0)) {
RtlInitUnicodeString(&rootString, L"ROOT\\LEGACY");
if (RtlPrefixUnicodeString(&rootString, &instancePath, TRUE) == FALSE) {
RtlFreeUnicodeString(&instancePath);
} else {
DeviceNode->InstancePath = instancePath;
legacyPdo = IopDeviceObjectFromDeviceInstance (handle, NULL);
if (legacyPdo) {
legacyDeviceNode = (PDEVICE_NODE)legacyPdo->DeviceObjectExtension->DeviceNode;
DeviceNode->OverUsed2.NextResourceDeviceNode =
legacyDeviceNode->OverUsed2.NextResourceDeviceNode;
legacyDeviceNode->OverUsed2.NextResourceDeviceNode = DeviceNode;
DeviceNode->OverUsed1.LegacyDeviceNode = legacyDeviceNode;
}
}
ZwClose(handle);
}
}
PCM_RESOURCE_LIST
IopCombineLegacyResources (
IN PDEVICE_NODE DeviceNode
)
/*++
Routine Description:
This routine sets the Root\Legacy_xxxx\0000 device instance path to the
madeup PDO (i.e. DeviceNode) which is created only for legacy resource allocation.
This routine also links the madeup PDO to the Root\Legacy_xxxx\0000 device node
to keep track what resources are assigned to the driver which services the
root\legacy_xxxx\0000 device.
Parameters:
DeviceNode - The legacy device node whose resources need to be combined.
Return Value:
Return the combined resource list.
--*/
{
NTSTATUS status;
PCM_RESOURCE_LIST combinedList = NULL;
PDEVICE_NODE devNode = DeviceNode;
ULONG size = 0;
PUCHAR p;
PAGED_CODE();
if (DeviceNode) {
// First determine how much memory is needed for the new combined list.
while (devNode) {
if (devNode->ResourceList) {
size += IopDetermineResourceListSize(devNode->ResourceList);
}
devNode = (PDEVICE_NODE)devNode->OverUsed2.NextResourceDeviceNode;
}
if (size != 0) {
combinedList = (PCM_RESOURCE_LIST) ExAllocatePoolCMRL(PagedPool, size);
devNode = DeviceNode;
if (combinedList) {
combinedList->Count = 0;
p = (PUCHAR)combinedList;
p += sizeof(ULONG); // Skip Count
while (devNode) {
if (devNode->ResourceList) {
size = IopDetermineResourceListSize(devNode->ResourceList);
if (size != 0) {
size -= sizeof(ULONG);
RtlMoveMemory(
p,
devNode->ResourceList->List,
size
);
p += size;
combinedList->Count += devNode->ResourceList->Count;
}
}
devNode = (PDEVICE_NODE)devNode->OverUsed2.NextResourceDeviceNode;
}
}
}
}
return combinedList;
}
PCM_RESOURCE_LIST
IopCreateCmResourceList(
IN PCM_RESOURCE_LIST ResourceList,
IN INTERFACE_TYPE InterfaceType,
IN ULONG BusNumber,
OUT PCM_RESOURCE_LIST *RemainingList
)
{
PCM_RESOURCE_LIST newList = NULL;
ULONG i, j;
ULONG totalSize, matchSize, remainingSize, listSize;
PCM_FULL_RESOURCE_DESCRIPTOR fullResourceDesc, newFullResourceDesc, remainingFullResourceDesc;
PCM_PARTIAL_RESOURCE_DESCRIPTOR partialDescriptor;
// Determine the size of memory to be allocated for the matching resource list.
fullResourceDesc = &ResourceList->List[0];
totalSize = FIELD_OFFSET(CM_RESOURCE_LIST, List);
matchSize = 0;
for (i = 0; i < ResourceList->Count; i++) {
// Add the size of this descriptor.
listSize = FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR,
PartialResourceList) +
FIELD_OFFSET(CM_PARTIAL_RESOURCE_LIST,
PartialDescriptors);
partialDescriptor = &fullResourceDesc->PartialResourceList.PartialDescriptors[0];
for (j = 0; j < fullResourceDesc->PartialResourceList.Count; j++) {
ULONG descriptorSize = sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
if (partialDescriptor->Type == CmResourceTypeDeviceSpecific) {
descriptorSize += partialDescriptor->u.DeviceSpecificData.DataSize;
}
listSize += descriptorSize;
partialDescriptor = (PCM_PARTIAL_RESOURCE_DESCRIPTOR)
((PUCHAR)partialDescriptor + descriptorSize);
}
if ( fullResourceDesc->InterfaceType == InterfaceType &&
fullResourceDesc->BusNumber == BusNumber) {
matchSize += listSize;
}
totalSize += listSize;
fullResourceDesc = (PCM_FULL_RESOURCE_DESCRIPTOR)
((PUCHAR)fullResourceDesc + listSize);
}
if (totalSize) {
if (matchSize) {
matchSize += FIELD_OFFSET(CM_RESOURCE_LIST, List);
}
if (matchSize == totalSize) {
*RemainingList = NULL;
newList = ResourceList;
} else if (matchSize == 0) {
*RemainingList = ResourceList;
} else {
// Allocate memory for both lists.
newList = (PCM_RESOURCE_LIST)ExAllocatePoolIORRR(PagedPool, matchSize);
if (newList) {
*RemainingList = (PCM_RESOURCE_LIST)ExAllocatePoolIORRR(PagedPool, totalSize - matchSize + FIELD_OFFSET(CM_RESOURCE_LIST, List));
if (*RemainingList) {
newList->Count = 0;
(*RemainingList)->Count = 0;
newFullResourceDesc = &newList->List[0];
remainingFullResourceDesc = &(*RemainingList)->List[0];
fullResourceDesc = &ResourceList->List[0];
for (i = 0; i < ResourceList->Count; i++) {
listSize = FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR,
PartialResourceList) +
FIELD_OFFSET(CM_PARTIAL_RESOURCE_LIST,
PartialDescriptors);
partialDescriptor = &fullResourceDesc->PartialResourceList.PartialDescriptors[0];
for (j = 0; j < fullResourceDesc->PartialResourceList.Count; j++) {
ULONG descriptorSize = sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
if (partialDescriptor->Type == CmResourceTypeDeviceSpecific) {
descriptorSize += partialDescriptor->u.DeviceSpecificData.DataSize;
}
listSize += descriptorSize;
partialDescriptor = (PCM_PARTIAL_RESOURCE_DESCRIPTOR)
((PUCHAR)partialDescriptor + descriptorSize);
}
if ( fullResourceDesc->InterfaceType == InterfaceType &&
fullResourceDesc->BusNumber == BusNumber) {
newList->Count++;
RtlMoveMemory(newFullResourceDesc, fullResourceDesc, listSize);
newFullResourceDesc = (PCM_FULL_RESOURCE_DESCRIPTOR)
((PUCHAR)newFullResourceDesc + listSize);
} else {
(*RemainingList)->Count++;
RtlMoveMemory(remainingFullResourceDesc, fullResourceDesc, listSize);
remainingFullResourceDesc = (PCM_FULL_RESOURCE_DESCRIPTOR)
((PUCHAR)remainingFullResourceDesc + listSize);
}
fullResourceDesc = (PCM_FULL_RESOURCE_DESCRIPTOR)
((PUCHAR)fullResourceDesc + listSize);
}
} else {
ExFreePool(newList);
newList = NULL;
}
} else {
*RemainingList = NULL;
}
}
}
return newList;
}
PCM_RESOURCE_LIST
IopCombineCmResourceList(
IN PCM_RESOURCE_LIST ResourceListA,
IN PCM_RESOURCE_LIST ResourceListB
)
{
PCM_RESOURCE_LIST newList = NULL;
ULONG sizeA, sizeB, size;
if (ResourceListA == NULL) {
return ResourceListB;
}
if (ResourceListB == NULL) {
return ResourceListA;
}
sizeA = IopDetermineResourceListSize(ResourceListA);
sizeB = IopDetermineResourceListSize(ResourceListB);
if (sizeA && sizeB) {
size = sizeA + sizeB - (sizeof(CM_RESOURCE_LIST) - sizeof(CM_FULL_RESOURCE_DESCRIPTOR));
newList = (PCM_RESOURCE_LIST)ExAllocatePoolIORRR(PagedPool, size);
if (newList) {
RtlMoveMemory(newList, ResourceListA, sizeA);
RtlMoveMemory( (PUCHAR)newList + sizeA,
(PUCHAR)ResourceListB + (sizeof(CM_RESOURCE_LIST) - sizeof(CM_FULL_RESOURCE_DESCRIPTOR)),
sizeB - (sizeof(CM_RESOURCE_LIST) - sizeof(CM_FULL_RESOURCE_DESCRIPTOR)));
newList->Count += ResourceListB->Count;
}
}
return newList;
}
NTSTATUS
IopReserveLegacyBootResources(
IN INTERFACE_TYPE InterfaceType,
IN ULONG BusNumber
)
/*++
Routine Description:
This routine is called to reserve legacy BOOT resources for the specified InterfaceType
and BusNumber. This is done everytime a new bus with a legacy InterfaceType gets enumerated.
Arguments:
InterfaceType - Legacy InterfaceType.
BusNumber - Legacy BusNumber
Return Value:
The status returned is the final completion status of the operation.
--*/
{
NTSTATUS status;
PIOP_RESERVED_RESOURCES_RECORD resourceRecord, prevRecord;
PCM_RESOURCE_LIST newList, remainingList;
if (IopInitHalDeviceNode && IopInitHalResources) {
remainingList = NULL;
newList = IopCreateCmResourceList(IopInitHalResources, InterfaceType, BusNumber, &remainingList);
if (newList) {
if (remainingList == NULL) {
// Full match. Check for error.
ASSERT(newList == IopInitHalResources);
} else {
// Partial match. Check for error.
ASSERT(IopInitHalResources != newList);
ASSERT(IopInitHalResources != remainingList);
}
DebugMessage(DUMP_INFO, ("IopReserveLegacyBootResources: Allocating HAL BOOT config for interface %08X and bus %08X...\n", InterfaceType, BusNumber));
if (PnpResDebugLevel & DUMP_INFO) {
IopDumpCmResourceList(newList);
}
if (remainingList) {
ExFreePool(IopInitHalResources);
}
IopInitHalResources = remainingList;
remainingList = IopInitHalDeviceNode->BootResources;
IopInitHalDeviceNode->Flags |= DNF_HAS_BOOT_CONFIG;
status = IopAllocateBootResources( ArbiterRequestHalReported,
IopInitHalDeviceNode->PhysicalDeviceObject,
newList);
ASSERT(NT_SUCCESS(status));
IopInitHalDeviceNode->BootResources = IopCombineCmResourceList(remainingList, newList);
ASSERT(IopInitHalDeviceNode->BootResources);
// Free previous BOOT config if any.
if (remainingList) {
ExFreePool(remainingList);
}
} else {
// No match. Check that there was no error.
ASSERT(remainingList && remainingList == IopInitHalResources);
}
}
for (prevRecord = NULL, resourceRecord = IopInitReservedResourceList; resourceRecord;) {
if ( resourceRecord->ReservedResources &&
resourceRecord->ReservedResources->List[0].InterfaceType == InterfaceType &&
resourceRecord->ReservedResources->List[0].BusNumber == BusNumber) {
DebugMessage(DUMP_INFO, ("IopReserveLegacyBootResources: Allocating BOOT config...\n"));
if (PnpResDebugLevel & DUMP_INFO) {
IopDumpCmResourceList(resourceRecord->ReservedResources);
}
status = IopAllocateBootResources( ArbiterRequestPnpEnumerated,
resourceRecord->DeviceObject,
resourceRecord->ReservedResources);
if (!NT_SUCCESS(status)) {
DbgPrint("IopReserveLegacyBootResources: IopAllocateBootResources failed with status = %08X\n", status);
ASSERT(NT_SUCCESS(status));
}
if (resourceRecord->DeviceObject == NULL) {
ExFreePool(resourceRecord->ReservedResources);
}
if (prevRecord) {
prevRecord->Next = resourceRecord->Next;
} else {
IopInitReservedResourceList = resourceRecord->Next;
}
ExFreePool(resourceRecord);
resourceRecord = (prevRecord)? prevRecord->Next : IopInitReservedResourceList;
} else {
prevRecord = resourceRecord;
resourceRecord = resourceRecord->Next;
}
}
return STATUS_SUCCESS;
}
NTSTATUS
IopAllocateBootResources (
IN ARBITER_REQUEST_SOURCE ArbiterRequestSource,
IN PDEVICE_OBJECT DeviceObject,
IN PCM_RESOURCE_LIST BootResources
)
/*++
Routine Description:
This routine reports boot resources for the specified device to
arbiters.
Arguments:
DeviceObject - Supplies a pointer to the device object, could be NULL
if DeviceObject is NULL, the BootResources are reserved and will not be given
to a device unless there is no other choice. The caller must release the
pool for BootResources.
if DeviceObject is NON_NULL, BootResources are BOOT reserved (preallocated.)
BootResources - Supplies a pointer to the Boot resources.
Return Value:
None.
--*/
{
NTSTATUS status;
PAGED_CODE();
KeEnterCriticalRegion( );
status = KeWaitForSingleObject( &IopRegistrySemaphore,
DelayExecution,
KernelMode,
FALSE,
NULL );
if (NT_SUCCESS(status)) {
status = IopReserveBootResourcesInternal(ArbiterRequestSource, DeviceObject, BootResources);
KeReleaseSemaphore(&IopRegistrySemaphore, 0, 1, FALSE);
} else {
DebugMessage(DUMP_ERROR, ("IopReserveBootResources: Get RegustrySemaphore failed. Status %x\n", status));
}
KeLeaveCriticalRegion();
return status;
}
NTSTATUS
IopReserveBootResourcesInternal (
IN ARBITER_REQUEST_SOURCE ArbiterRequestSource,
IN PDEVICE_OBJECT DeviceObject,
IN PCM_RESOURCE_LIST BootResources
)
/*++
Routine Description:
This routine reports boot resources for the specified device to
arbiters.
Arguments:
DeviceObject - Supplies a pointer to the device object, could be NULL
if DeviceObject is NULL, the BootResources are reserved and will not be given
to a device unless there is no other choice. The caller must release the
pool for BootResources.
if DeviceObject is NON_NULL, BootResources are BOOT reserved (preallocated.)
BootResources - Supplies a pointer to the Boot resources.
Return Value:
None.
--*/
{
PIO_RESOURCE_REQUIREMENTS_LIST ioResources;
PREQ_LIST reqList;
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_NODE deviceNode;
PAGED_CODE();
if (DeviceObject) {
deviceNode = (PDEVICE_NODE)DeviceObject->DeviceObjectExtension->DeviceNode;
}
ioResources = IopCmResourcesToIoResources(0, BootResources, LCPRI_BOOTCONFIG);
if (ioResources) {
#if MYDBG
if (deviceNode) {
DbgPrint("\n===================================\n");
DbgPrint("PreAllocate Resource List for %wZ :: \n", &deviceNode->InstancePath);
} else {
DbgPrint("Reserve Resource List :: ");
}
IopDumpResourceRequirementsList(ioResources);
DbgPrint(" ++++++++++++++++++++++++++++++\n");
#endif
status = IopResourceRequirementsListToReqList(
ArbiterRequestSource,
ioResources,
DeviceObject,
&reqList);
if (NT_SUCCESS(status) && reqList) {
IopReserve(reqList);
if (DeviceObject) {
deviceNode->Flags |= DNF_BOOT_CONFIG_RESERVED;
if (deviceNode->BootResources == NULL) {
ULONG size;
// If we have not remember the root enumerated device's boot resources
// do it now. We always need to pre-allocate boot config for root enumerated
// devices when their resources are released.
size = IopDetermineResourceListSize (BootResources);
deviceNode->BootResources = ExAllocatePoolIORL(PagedPool, size);
if (deviceNode->BootResources) {
RtlMoveMemory(deviceNode->BootResources, BootResources, size);
} else {
status = STATUS_INSUFFICIENT_RESOURCES;
}
}
}
IopFreeReqList(reqList);
} else {
#if MYDBG
ASSERT(0); // For now
#endif
}
ExFreePool(ioResources);
}
return status;
}
NTSTATUS
IopReserveBootResources (
IN ARBITER_REQUEST_SOURCE ArbiterRequestSource,
IN PDEVICE_OBJECT DeviceObject,
IN PCM_RESOURCE_LIST BootResources
)
/*++
Routine Description:
This routine reports boot resources for the specified device to
arbiters. Since the real resource pre-alloc routine can only be called after
all the arbiters and translators are present, all the calls to pre-alloc resources
before the preallocation routine is available will be routed to this routine.
Arguments:
DeviceObject - Supplies a pointer to the device object. If present, caller wants to
preallocate BOOT resources for a device object. If NULL, caller wants to reserved
resources for some unknown devices.
BootResources - Supplies a pointer to the Boot resources.
Return Value:
None.
--*/
{
PIOP_RESERVED_RESOURCES_RECORD resourceRecord;
PDEVICE_NODE deviceNode;
ULONG size;
NTSTATUS status;
status = STATUS_SUCCESS;;
size = IopDetermineResourceListSize(BootResources);
if (size != 0) {
deviceNode = (PDEVICE_NODE)((DeviceObject)? DeviceObject->DeviceObjectExtension->DeviceNode : NULL);
// Pre-allocate BOOT configs right away for non-madeup devices.
if (DeviceObject && !(deviceNode->Flags & DNF_MADEUP)) {
return IopAllocateBootResources(ArbiterRequestSource, DeviceObject, BootResources);
}
if (DeviceObject) {
ASSERT(deviceNode);
deviceNode->BootResources = ExAllocatePoolIORL(PagedPool, size);
if (deviceNode->BootResources) {
RtlMoveMemory(deviceNode->BootResources, BootResources, size);
} else {
return STATUS_INSUFFICIENT_RESOURCES;
}
}
resourceRecord = (PIOP_RESERVED_RESOURCES_RECORD) ExAllocatePoolIORRR( PagedPool,
sizeof(IOP_RESERVED_RESOURCES_RECORD));
if (resourceRecord) {
resourceRecord->ReservedResources = (DeviceObject)? deviceNode->BootResources : BootResources;
resourceRecord->DeviceObject = DeviceObject;
resourceRecord->Next = IopInitReservedResourceList;
IopInitReservedResourceList = resourceRecord;
} else {
if (deviceNode && deviceNode->BootResources) {
ExFreePool(deviceNode->BootResources);
}
return STATUS_INSUFFICIENT_RESOURCES;
}
}
return status;
}
VOID
IopReleaseResources (
IN PDEVICE_NODE DeviceNode
)
/*++
Routine Description:
IopReleaseResources releases resources owned by the device and release
the memory pool. We also release the cached resource requirements list.
If the device is a root enumerated device with BOOT config, we will preallocate
boot config resources for this device.
NOTE, this is a routine INTERNAL to this file. NO one should call this function
outside of this file. Outside of this file, IopReleaseDeviceResources should be
used.
Arguments:
DeviceNode - Supplies a pointer to the device node.object. If present, caller wants to
Return Value:
None.
--*/
{
// Release the resources owned by the device
IopReleaseResourcesInternal(DeviceNode);
DeviceNode->Flags &= ~DNF_RESOURCE_ASSIGNED;
DeviceNode->Flags &= ~DNF_RESOURCE_REPORTED;
#if DBG_SCOPE
if (DeviceNode->PreviousResourceList) {
ExFreePool(DeviceNode->PreviousResourceList);
DeviceNode->PreviousResourceList = NULL;
}
if (DeviceNode->PreviousResourceRequirements) {
ExFreePool(DeviceNode->PreviousResourceRequirements);
DeviceNode->PreviousResourceRequirements = NULL;
}
#endif
if (DeviceNode->ResourceList) {
#if DBG_SCOPE
if (!NT_SUCCESS(DeviceNode->FailureStatus)) {
DeviceNode->PreviousResourceList = DeviceNode->ResourceList;
} else {
ExFreePool(DeviceNode->ResourceList);
}
#else
ExFreePool(DeviceNode->ResourceList);
#endif
DeviceNode->ResourceList = NULL;
}
if (DeviceNode->ResourceListTranslated) {
ExFreePool(DeviceNode->ResourceListTranslated);
DeviceNode->ResourceListTranslated = NULL;
}
// If this device is a root enumerated device, preallocate its BOOT resources
if ((DeviceNode->Flags & (DNF_MADEUP | DNF_DEVICE_GONE)) == DNF_MADEUP) {
if (DeviceNode->Flags & DNF_HAS_BOOT_CONFIG && DeviceNode->BootResources) {
IopReserveBootResourcesInternal(ArbiterRequestPnpEnumerated,
DeviceNode->PhysicalDeviceObject,
DeviceNode->BootResources);
}
} else {
DeviceNode->Flags &= ~(DNF_HAS_BOOT_CONFIG | DNF_BOOT_CONFIG_RESERVED);
if (DeviceNode->BootResources) {
ExFreePool(DeviceNode->BootResources);
DeviceNode->BootResources = NULL;
}
}
}
VOID
IopReallocateResources (
IN PDEVICE_OBJECT DeviceObject
)
/*++
Routine Description:
This routine performs the real work for IoInvalidateDeviceState - ResourceRequirementsChanged.
Arguments:
DeviceObject - Supplies a pointer to the device object.
Return Value:
None.
--*/
{
PDEVICE_NODE deviceNode = (PDEVICE_NODE)DeviceObject->DeviceObjectExtension->DeviceNode;
IOP_RESOURCE_REQUEST requestTable, *requestTablep;
ULONG deviceCount, oldFlags;
NTSTATUS status;
PAGED_CODE();
// Grab the IO registry semaphore to make sure no other device is
// reporting it's resource usage while we are searching for conflicts.
KeEnterCriticalRegion();
status = KeWaitForSingleObject( &IopRegistrySemaphore,
DelayExecution,
KernelMode,
FALSE,
NULL);
if (NT_SUCCESS(status)) {
// Acquire the tree lock so we block remove for this device node.
ExAcquireResourceShared(&IopDeviceTreeLock, TRUE);
// Check the flags after acquiring the semaphore.
if (deviceNode->Flags & DNF_RESOURCE_REQUIREMENTS_CHANGED) {
// Save the flags which we may have to restore in case of failure.
oldFlags = deviceNode->Flags & DNF_HAS_RESOURCE;
deviceNode->Flags &= ~(DNF_HAS_RESOURCE);
if (deviceNode->Flags & DNF_NON_STOPPED_REBALANCE) {
IopAcquireEnumerationLock(deviceNode);
// Set up parameters to call real routine
deviceNode->Flags |= DNF_ASSIGNING_RESOURCES;
RtlZeroMemory(&requestTable, sizeof(IOP_RESOURCE_REQUEST));
requestTable.PhysicalDevice = DeviceObject;
requestTablep = &requestTable;
requestTable.Flags |= IOP_ASSIGN_NO_REBALANCE + IOP_ASSIGN_KEEP_CURRENT_CONFIG;
status = IopGetResourceRequirementsForAssignTable( requestTablep,
requestTablep + 1,
&deviceCount);
if (NT_SUCCESS(status) && deviceCount) {
// Release the current resources to the arbiters.
// Memory for ResourceList is not released.
if (deviceNode->ResourceList) {
IopReleaseResourcesInternal(deviceNode);
}
// Try to do the assignment.
status = IopAssignInner(deviceCount, requestTablep, FALSE);
if (NT_SUCCESS(status)) {
deviceNode->Flags &= ~(DNF_RESOURCE_REQUIREMENTS_CHANGED | DNF_NON_STOPPED_REBALANCE);
IopBuildCmResourceLists(requestTablep, requestTablep + 1);
// We need to release the pool space for ResourceList and ResourceListTranslated.
// Because the earlier IopReleaseResourcesInternal does not release the pool.
if (deviceNode->ResourceList) {
ExFreePool(deviceNode->ResourceList);
}
if (deviceNode->ResourceListTranslated) {
ExFreePool(deviceNode->ResourceListTranslated);
}
deviceNode->ResourceList = requestTablep->ResourceAssignment;
deviceNode->ResourceListTranslated = requestTablep->TranslatedResourceAssignment;
deviceNode->Flags |= DNF_RESOURCE_ASSIGNED;
deviceNode->Flags &= ~DNF_RESOURCE_REPORTED;
IopStartDevice(deviceNode->PhysicalDeviceObject);
} else {
NTSTATUS restoreResourcesStatus;
restoreResourcesStatus = IopRestoreResourcesInternal(deviceNode);
if (!NT_SUCCESS(restoreResourcesStatus)) {
ASSERT(NT_SUCCESS(restoreResourcesStatus));
IopRequestDeviceRemoval(DeviceObject, CM_PROB_NORMAL_CONFLICT);
}
// BUGBUG - once we failed, what will trigger us to try again?
}
IopFreeResourceRequirementsForAssignTable(requestTablep, requestTablep + 1);
} else {
status = NT_SUCCESS(status)? STATUS_UNSUCCESSFUL : status;
}
deviceNode->Flags &= ~DNF_ASSIGNING_RESOURCES;
IopReleaseEnumerationLock(deviceNode);
} else {
// The device needs to be stopped to change resources.
status = IopRebalance(0, NULL);
}
// Restore the flags in case of failure.
if (!NT_SUCCESS(status)) {
deviceNode->Flags &= ~DNF_HAS_RESOURCE;
deviceNode->Flags |= oldFlags;
}
} else {
DebugMessage(DUMP_ERROR, ("PNPRES: Resource requirements not changed in IopReallocateResources, returning error!\n"));
}
ExReleaseResource(&IopDeviceTreeLock);
KeReleaseSemaphore(&IopRegistrySemaphore, 0, 1, FALSE);
} else {
DebugMessage(DUMP_ERROR, ("PNPRES: IopReallocateResources failed to acquire Registry semaphore, status %08X\n", status));
}
KeLeaveCriticalRegion();
}
#if DBG_SCOPE
VOID
IopCheckDataStructures (
IN PDEVICE_NODE DeviceNode
)
{
if (DeviceNode) {
IopCheckDataStructuresWorker (DeviceNode);
IopCheckDataStructures (DeviceNode->Sibling);
IopCheckDataStructures (DeviceNode->Child);
}
}
VOID
IopCheckDataStructuresWorker (
IN PDEVICE_NODE Device
)
/*++
Routine Description:
This routine releases the assigned resources for device specified by DeviceNode.
Note, this routine does not reset the resource related fields in DeviceNode structure.
Parameters:
DeviceNode - specifies the device node whose resources are goint to be released.
Return Value:
Status code that indicates whether or not the function was successful.
--*/
{
PLIST_ENTRY listHead, listEntry;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
listHead = &Device->DeviceArbiterList;
listEntry = listHead->Flink;
while (listEntry != listHead) {
arbiterEntry = CONTAINING_RECORD(listEntry, PI_RESOURCE_ARBITER_ENTRY, DeviceArbiterList);
if (arbiterEntry->ArbiterInterface != NULL) {
ASSERT(IsListEmpty(&arbiterEntry->ResourceList));
ASSERT(IsListEmpty(&arbiterEntry->ActiveArbiterList));
InitializeListHead(&arbiterEntry->ActiveArbiterList);
InitializeListHead(&arbiterEntry->ResourceList);
}
listEntry = listEntry->Flink;
}
}
#endif
NTSTATUS
IopQueryConflictList(
PDEVICE_OBJECT PhysicalDeviceObject,
IN PCM_RESOURCE_LIST ResourceList,
IN ULONG ResourceListSize,
OUT PPLUGPLAY_CONTROL_CONFLICT_LIST ConflictList,
IN ULONG ConflictListSize,
IN ULONG Flags
)
/*++
Routine Description:
This routine performs the querying of device conflicts
returning data in ConflictList
Arguments:
PhysicalDeviceObject PDO of device to Query
ResourceList CM resource list containing single resource to query
ResourceListSize Size of ResourceList
ConflictList Conflict list to fill query details in
ConflictListSize Size of buffer that we can fill with Conflict information
Flags Currently unused (zero) for future passing of flags
Return Value:
Should be success in most cases
--*/
{
NTSTATUS status;
PAGED_CODE();
KeEnterCriticalRegion( );
status = KeWaitForSingleObject( &IopRegistrySemaphore, DelayExecution, KernelMode, FALSE, NULL );
if (!NT_SUCCESS( status )) {
DebugMessage(DUMP_ERROR, ("IopQueryConflictList: Get RegustrySemaphore failed. Status %x\n", status));
KeLeaveCriticalRegion( );
return status;
} else {
status = IopQueryConflictListInternal(PhysicalDeviceObject, ResourceList, ResourceListSize, ConflictList, ConflictListSize, Flags);
KeReleaseSemaphore( &IopRegistrySemaphore, 0, 1, FALSE );
KeLeaveCriticalRegion( );
}
return status;
}
BOOLEAN
IopEliminateBogusConflict(
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN PDEVICE_OBJECT ConflictDeviceObject
)
/*++
Routine Description:
Determine if we're really conflicting with ourselves
if this is the case, we ignore it
Arguments:
PhysicalDeviceObject PDO we're performing the test for
ConflictDeviceObject The object we've determined is conflicting
Return Value:
TRUE to eliminate the conflict
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_NODE deviceNode;
PDRIVER_OBJECT driverObject;
KIRQL irql;
PDEVICE_OBJECT attachedDevice;
PAGED_CODE();
// simple cases
if (PhysicalDeviceObject == NULL || ConflictDeviceObject == NULL) {
return FALSE;
}
// if ConflictDeviceObject is on PDO's stack, this is a non-conflict
// nb at least PDO has to be checked
ExAcquireFastLock( &IopDatabaseLock, &irql );
for (attachedDevice = PhysicalDeviceObject;
attachedDevice;
attachedDevice = attachedDevice->AttachedDevice) {
if (attachedDevice == ConflictDeviceObject) {
ExReleaseFastLock( &IopDatabaseLock, irql );
return TRUE;
}
}
ExReleaseFastLock( &IopDatabaseLock, irql );
// legacy case
deviceNode = PhysicalDeviceObject->DeviceObjectExtension->DeviceNode;
ASSERT(deviceNode);
if (deviceNode->Flags & DNF_LEGACY_DRIVER) {
// hmmm, let's see if our ConflictDeviceObject is resources associated with a legacy device
if (ConflictDeviceObject->Flags & DO_BUS_ENUMERATED_DEVICE) {
// if not, we have a legacy conflicting with non-legacy, we're interested!
return FALSE;
}
// FDO, report driver name
driverObject = ConflictDeviceObject->DriverObject;
if(driverObject == NULL) {
// should not be NULL
ASSERT(driverObject);
return FALSE;
}
// compare deviceNode->Service with driverObject->Service
if (deviceNode->ServiceName.Length != 0 &&
deviceNode->ServiceName.Length == driverObject->DriverExtension->ServiceKeyName.Length &&
RtlCompareUnicodeString(&deviceNode->ServiceName,&driverObject->DriverExtension->ServiceKeyName,TRUE)==0) {
// the driver's service name is the same that this PDO is associated with
// by ignoring it we could end up ignoring conflicts of simular types of legacy devices
// but since these have to be hand-config'd anyhow, it's prob better than having false conflicts
// (jamiehun)
return TRUE;
}
}
return FALSE;
}
NTSTATUS
IopQueryConflictFillString(
IN PDEVICE_OBJECT DeviceObject,
IN PWSTR Buffer,
IN OUT PULONG Length,
IN OUT PULONG Flags
)
/*++
Routine Description:
Obtain string or string-length for details of conflicting device
Arguments:
DeviceObject Device object we want Device-Instance-String or Service Name
Buffer Buffer to Fill, NULL if we just want length
Length Filled with length of Buffer, including terminated NULL (Words)
Flags Apropriate flags set describing what the string represents
Return Value:
Should be success in most cases
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_NODE deviceNode;
PDRIVER_OBJECT driverObject;
PUNICODE_STRING infoString = NULL;
ULONG MaxLength = 0; // words
ULONG ReqLength = 0; // words
ULONG flags = 0;
PAGED_CODE();
if (Length != NULL) {
MaxLength = *Length;
}
if (Flags != NULL) {
flags = *Flags;
}
if (DeviceObject == NULL) {
// unknown
goto final;
}
if ((DeviceObject->Flags & DO_BUS_ENUMERATED_DEVICE) == 0 ) {
// FDO, report driver name
driverObject = DeviceObject->DriverObject;
if(driverObject == NULL) {
// should not be NULL
ASSERT(driverObject);
goto final;
}
infoString = & (driverObject->DriverName);
flags |= PNP_CE_LEGACY_DRIVER;
goto final;
}
// we should in actual fact have a PDO
if (DeviceObject->DeviceObjectExtension == NULL) {
// should not be NULL
ASSERT(DeviceObject->DeviceObjectExtension);
goto final;
}
deviceNode = (PDEVICE_NODE)DeviceObject->DeviceObjectExtension->DeviceNode;
if (deviceNode == NULL) {
// should not be NULL
ASSERT(deviceNode);
goto final;
}
if (deviceNode == IopRootDeviceNode) {
// owned by root device
flags |= PNP_CE_ROOT_OWNED;
} else if (deviceNode -> Parent == NULL) {
// faked out PDO - must be legacy device
driverObject = (PDRIVER_OBJECT)(deviceNode->DuplicatePDO);
if(driverObject == NULL) {
// should not be NULL
ASSERT(driverObject);
goto final;
}
infoString = & (driverObject->DriverName);
flags |= PNP_CE_LEGACY_DRIVER;
goto final;
}
// we should be happy with what we have
infoString = &deviceNode->InstancePath;
final:
if (infoString != NULL) {
// we have a string to copy
if ((Buffer != NULL) && (MaxLength*sizeof(WCHAR) > infoString->Length)) {
RtlCopyMemory(Buffer, infoString->Buffer, infoString->Length);
}
ReqLength += infoString->Length / sizeof(WCHAR);
}
if ((Buffer != NULL) && (MaxLength > ReqLength)) {
Buffer[ReqLength] = 0;
}
ReqLength++;
if (Length != NULL) {
*Length = ReqLength;
}
if (Flags != NULL) {
*Flags = flags;
}
return status;
}
NTSTATUS
IopQueryConflictFillConflicts(
PDEVICE_OBJECT PhysicalDeviceObject,
IN ULONG ConflictCount,
IN PARBITER_CONFLICT_INFO ConflictInfoList,
OUT PPLUGPLAY_CONTROL_CONFLICT_LIST ConflictList,
IN ULONG ConflictListSize,
IN ULONG Flags
)
/*++
Routine Description:
Fill ConflictList with information on as many conflicts as possible
Arguments:
PhysicalDeviceObject The PDO we're performing the test on
ConflictCount Number of Conflicts.
ConflictInfoList List of conflicting device info, can be NULL if ConflictCount is 0
ConflictList Structure to fill in with conflicts
ConflictListSize Size of Conflict List
Flags if non-zero, dummy conflict is created
Return Value:
Should be success in most cases
--*/
{
NTSTATUS status = STATUS_SUCCESS;
ULONG ConflictListIdealSize;
ULONG ConflictListBaseSize;
ULONG ConflictListCount;
ULONG Index;
ULONG ConflictIndex;
ULONG EntrySize;
ULONG ConflictStringsOffset;
ULONG stringSize;
ULONG stringTotalSize;
ULONG DummyCount;
PPLUGPLAY_CONTROL_CONFLICT_STRINGS ConfStrings;
PAGED_CODE();
// determine how many conflicts we can
// for each conflict
// translate to bus/resource/address in respect to conflicting device
// add to conflict list
// preprocessing - given our ConflictInfoList and ConflictCount
// remove any that appear to be bogus - ie, that are the same device that we are testing against
// this stops mostly legacy issues
for(Index = 0;Index < ConflictCount; Index++) {
if (IopEliminateBogusConflict(PhysicalDeviceObject,ConflictInfoList[Index].OwningObject)) {
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: eliminating \"identical\" PDO %08x conflicting with self (%08x)\n",
ConflictInfoList[Index].OwningObject,PhysicalDeviceObject));
// move the last listed conflict into this space
if (Index+1 < ConflictCount) {
RtlCopyMemory(&ConflictInfoList[Index],&ConflictInfoList[ConflictCount-1],sizeof(ARBITER_CONFLICT_INFO));
}
// account for deleting this item
ConflictCount--;
Index--;
}
}
// preprocessing - in our conflict list, we may have PDO's for legacy devices, and resource nodes for the same
// or other duplicate entities (we only ever want to report a conflict once, even if there's multiple conflicting ranges)
RestartScan:
for(Index = 0;Index < ConflictCount; Index++) {
if (ConflictInfoList[Index].OwningObject != NULL) {
ULONG Index2;
for (Index2 = Index+1; Index2 < ConflictCount; Index2++) {
if (IopEliminateBogusConflict(ConflictInfoList[Index].OwningObject,ConflictInfoList[Index2].OwningObject)) {
// Index2 is considered a dup of Index
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: eliminating \"identical\" PDO %08x conflicting with PDO %08x\n",
ConflictInfoList[Index2].OwningObject,ConflictInfoList[Index].OwningObject));
// move the last listed conflict into this space
if (Index2+1 < ConflictCount) {
RtlCopyMemory(&ConflictInfoList[Index2],&ConflictInfoList[ConflictCount-1],sizeof(ARBITER_CONFLICT_INFO));
}
// account for deleting this item
ConflictCount--;
Index2--;
} else if (IopEliminateBogusConflict(ConflictInfoList[Index2].OwningObject,ConflictInfoList[Index].OwningObject)) {
// Index is considered a dup of Index2 (some legacy case)
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: eliminating \"identical\" PDO %08x conflicting with PDO %08x\n",
ConflictInfoList[Index2].OwningObject,ConflictInfoList[Index].OwningObject));
// move the one we want (Index2) into the space occupied by Index
RtlCopyMemory(&ConflictInfoList[Index],&ConflictInfoList[Index2],sizeof(ARBITER_CONFLICT_INFO));
// move the last listed conflict into the space we just created
if (Index2+1 < ConflictCount) {
RtlCopyMemory(&ConflictInfoList[Index2],&ConflictInfoList[ConflictCount-1],sizeof(ARBITER_CONFLICT_INFO));
}
// account for deleting this item
ConflictCount--;
// but as this is quirky, restart the scan
goto RestartScan;
}
}
}
}
// preprocessing - if we have any known reported conflicts, don't report back any unknown
for(Index = 0;Index < ConflictCount; Index++) {
// find first unknown
if (ConflictInfoList[Index].OwningObject == NULL) {
// eliminate all other unknowns
ULONG Index2;
for (Index2 = Index+1; Index2 < ConflictCount; Index2++) {
if (ConflictInfoList[Index2].OwningObject == NULL) {
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: eliminating extra unknown\n"));
// move the last listed conflict into this space
if (Index2+1 < ConflictCount) {
RtlCopyMemory(&ConflictInfoList[Index2],&ConflictInfoList[ConflictCount-1],sizeof(ARBITER_CONFLICT_INFO));
}
// account for deleting this item
ConflictCount--;
Index2--;
}
}
if(ConflictCount != 1) {
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: eliminating first unknown\n"));
// there were others, so ignore the unknown
if (Index+1 < ConflictCount) {
RtlCopyMemory(&ConflictInfoList[Index],&ConflictInfoList[ConflictCount-1],sizeof(ARBITER_CONFLICT_INFO));
}
ConflictCount --;
}
break;
}
}
// set number of actual and listed conflicts
ConflictListIdealSize = (sizeof(PLUGPLAY_CONTROL_CONFLICT_LIST) - sizeof(PLUGPLAY_CONTROL_CONFLICT_ENTRY)) + sizeof(PLUGPLAY_CONTROL_CONFLICT_STRINGS);
ConflictListCount = 0;
stringTotalSize = 0;
DummyCount = 0;
ASSERT(ConflictListSize >= ConflictListIdealSize); // we should have checked to see if buffer is at least this big
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: Detected %d conflicts\n", ConflictCount));
// estimate sizes
if (Flags) {
// flags entry required (ie resource not available for some specified reason)
stringSize = 1; // null-length string
DummyCount ++;
EntrySize = sizeof(PLUGPLAY_CONTROL_CONFLICT_ENTRY);
EntrySize += sizeof(WCHAR) * stringSize;
if((ConflictListIdealSize+EntrySize) <= ConflictListSize) {
// we can fit this one in
ConflictListCount++;
stringTotalSize += stringSize;
}
ConflictListIdealSize += EntrySize;
}
// report conflicts
for(Index = 0; Index < ConflictCount; Index ++) {
stringSize = 0;
IopQueryConflictFillString(ConflictInfoList[Index].OwningObject,NULL,&stringSize,NULL);
// account for entry
EntrySize = sizeof(PLUGPLAY_CONTROL_CONFLICT_ENTRY);
EntrySize += sizeof(WCHAR) * stringSize;
if((ConflictListIdealSize+EntrySize) <= ConflictListSize) {
// we can fit this one in
ConflictListCount++;
stringTotalSize += stringSize;
}
ConflictListIdealSize += EntrySize;
}
ConflictList->ConflictsCounted = ConflictCount+DummyCount; // number of conflicts detected including any dummy conflict
ConflictList->ConflictsListed = ConflictListCount; // how many we could fit in
ConflictList->RequiredBufferSize = ConflictListIdealSize; // how much buffer space to supply on next call
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: Listing %d conflicts\n", ConflictListCount));
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: Need %08x bytes to list all conflicts\n", ConflictListIdealSize));
ConfStrings = (PPLUGPLAY_CONTROL_CONFLICT_STRINGS)&(ConflictList->ConflictEntry[ConflictListCount]);
ConfStrings->NullDeviceInstance = (ULONG)(-1);
ConflictStringsOffset = 0;
for(ConflictIndex = 0; ConflictIndex < DummyCount; ConflictIndex++) {
// flags entry required (ie resource not available for some specified reason)
if (Flags && ConflictIndex == 0) {
ConflictList->ConflictEntry[ConflictIndex].DeviceInstance = ConflictStringsOffset;
ConflictList->ConflictEntry[ConflictIndex].DeviceFlags = Flags;
ConflictList->ConflictEntry[ConflictIndex].ResourceType = 0;
ConflictList->ConflictEntry[ConflictIndex].ResourceStart = 0;
ConflictList->ConflictEntry[ConflictIndex].ResourceEnd = 0;
ConflictList->ConflictEntry[ConflictIndex].ResourceFlags = 0;
ConfStrings->DeviceInstanceStrings[ConflictStringsOffset] = 0; // null string
stringTotalSize --;
ConflictStringsOffset ++;
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: Listing flags %08x\n", Flags));
}
}
// get/fill in details for all those we can fit into the buffer
for(Index = 0; ConflictIndex < ConflictListCount ; Index ++, ConflictIndex++) {
ASSERT(Index < ConflictCount);
// assign conflict information
ConflictList->ConflictEntry[ConflictIndex].DeviceInstance = ConflictStringsOffset;
ConflictList->ConflictEntry[ConflictIndex].DeviceFlags = 0;
ConflictList->ConflictEntry[ConflictIndex].ResourceType = 0; // BUGBUG!!! (jamiehun) remember to do this (post NT5)!
ConflictList->ConflictEntry[ConflictIndex].ResourceStart = (ULONGLONG)(1); // for now, return totally invalid range (1-0)
ConflictList->ConflictEntry[ConflictIndex].ResourceEnd = 0;
ConflictList->ConflictEntry[ConflictIndex].ResourceFlags = 0;
// fill string details
stringSize = stringTotalSize;
IopQueryConflictFillString(ConflictInfoList[Index].OwningObject,
&(ConfStrings->DeviceInstanceStrings[ConflictStringsOffset]),
&stringSize,
&(ConflictList->ConflictEntry[ConflictIndex].DeviceFlags));
stringTotalSize -= stringSize;
DebugMessage(DUMP_DETAIL, ("IopQueryConflictFillConflicts: Listing \"%S\"\n", &(ConfStrings->DeviceInstanceStrings[ConflictStringsOffset])));
ConflictStringsOffset += stringSize;
}
// another NULL at end of strings (this is accounted for in the PPLUGPLAY_CONTROL_CONFLICT_STRINGS structure)
ConfStrings->DeviceInstanceStrings[ConflictStringsOffset] = 0;
//Clean0:
;
return status;
}
NTSTATUS
IopQueryConflictListInternal(
PDEVICE_OBJECT PhysicalDeviceObject,
IN PCM_RESOURCE_LIST ResourceList,
IN ULONG ResourceListSize,
OUT PPLUGPLAY_CONTROL_CONFLICT_LIST ConflictList,
IN ULONG ConflictListSize,
IN ULONG Flags
)
/*++
Routine Description:
Version of IopQueryConflictList without the locking
--*/
{
NTSTATUS status = STATUS_SUCCESS;
PDEVICE_NODE deviceNode = NULL;
PIO_RESOURCE_REQUIREMENTS_LIST ioResources;
PREQ_LIST reqList;
PREQ_DESC reqDesc, reqDescTranslated;
PLIST_ENTRY listHead;
PPI_RESOURCE_ARBITER_ENTRY arbiterEntry;
PREQ_ALTERNATIVE RA;
PREQ_ALTERNATIVE *reqAlternative;
ULONG ConflictCount = 0;
PARBITER_CONFLICT_INFO ConflictInfoList = NULL;
PIO_RESOURCE_DESCRIPTOR ConflictDesc = NULL;
ULONG ReqDescCount = 0;
PREQ_DESC *ReqDescTable = NULL;
PIO_RESOURCE_REQUIREMENTS_LIST pIoReqList = NULL;
PVOID ExtParams[4];
PAGED_CODE();
ASSERT(PhysicalDeviceObject);
ASSERT(ResourceList);
ASSERT(ResourceListSize);
// these parameters were generated by umpnpmgr
// so should be correct - one resource, and one resource only
ASSERT(ResourceList->Count == 1);
ASSERT(ResourceList->List[0].PartialResourceList.Count == 1);
if (ConflictList == NULL || (ConflictListSize < (sizeof(PLUGPLAY_CONTROL_CONFLICT_LIST) - sizeof(PLUGPLAY_CONTROL_CONFLICT_ENTRY)) + sizeof(PLUGPLAY_CONTROL_CONFLICT_STRINGS))) {
// sanity check
status = STATUS_BUFFER_TOO_SMALL;
goto Clean0;
}
// whatever other error we return, ensure that ConflictList is interpretable
ConflictList->ConflictsCounted = 0;
ConflictList->ConflictsListed = 0;
ConflictList->RequiredBufferSize = (sizeof(PLUGPLAY_CONTROL_CONFLICT_LIST) - sizeof(PLUGPLAY_CONTROL_CONFLICT_ENTRY)) + sizeof(PLUGPLAY_CONTROL_CONFLICT_STRINGS);
// Retrieve the devnode from the PDO
deviceNode = (PDEVICE_NODE)PhysicalDeviceObject->DeviceObjectExtension->DeviceNode;
if (!deviceNode) {
status = STATUS_NO_SUCH_DEVICE;
goto Clean0;
}
// type-specific validation
switch(ResourceList->List[0].PartialResourceList.PartialDescriptors[0].Type) {
case CmResourceTypePort:
case CmResourceTypeMemory:
if(ResourceList->List[0].PartialResourceList.PartialDescriptors[0].u.Generic.Length == 0) {
// zero-range resource can never conflict
status = STATUS_SUCCESS;
goto Clean0;
}
break;
case CmResourceTypeInterrupt:
case CmResourceTypeDma:
break;
default:
ASSERT(0);
status = STATUS_INVALID_PARAMETER;
goto Clean0;
}
// apply bus details from node
if (deviceNode->ChildInterfaceType == InterfaceTypeUndefined) {
// we have to grovel around to find real Interface Type
pIoReqList = deviceNode->ResourceRequirements;
if (pIoReqList != NULL && pIoReqList->InterfaceType != InterfaceTypeUndefined) {
ResourceList->List[0].InterfaceType = pIoReqList->InterfaceType;
} else {
// BUGBUG!!! (jamiehun)
// we should never get here
// if we do, I need to look at this more
#if MYDBG
ASSERT(0);
#endif
ResourceList->List[0].InterfaceType = PnpDefaultInterfaceType;
}
} else {
// we trust the deviceNode to tell us Interface Type
ResourceList->List[0].InterfaceType = deviceNode->ChildInterfaceType;
}
// HACKHACK!!! (jamiehun) some bus-types we are better off considered as default
switch(ResourceList->List[0].InterfaceType) {
case InterfaceTypeUndefined:
case PCMCIABus:
ResourceList->List[0].InterfaceType = PnpDefaultInterfaceType;
}
if ((deviceNode->ChildBusNumber & 0x80000000) == 0x80000000) {
// we have to grovel around to find real Bus Number
pIoReqList = deviceNode->ResourceRequirements;
if (pIoReqList != NULL && (pIoReqList->BusNumber & 0x80000000) != 0x80000000) {
ResourceList->List[0].BusNumber = pIoReqList->BusNumber;
} else {
// a resonable default, but assert is here so I remember to look at this more
// BUGBUG!!! (jamiehun)
#if MYDBG
ASSERT(0);
#endif
ResourceList->List[0].BusNumber = 0;
}
} else {
// we trust the deviceNode to tell us Bus Number
ResourceList->List[0].BusNumber = deviceNode->ChildBusNumber;
}
// from our CM Resource List, obtain an IO Resource Requirements List
ioResources = IopCmResourcesToIoResources(0, ResourceList, LCPRI_FORCECONFIG);
if (!ioResources) {
status = STATUS_INVALID_PARAMETER;
goto Clean0;
}
// Convert ioResources to a Request list
// and in the processess, determine any Arbiters/Translators to use
status = IopResourceRequirementsListToReqList(
ArbiterRequestUndefined, // BUGBUG!!! (jamiehun) better alternative???
ioResources,
PhysicalDeviceObject,
&reqList);
// get arbitrator/translator for current device/bus
if (NT_SUCCESS(status) && reqList) {
reqAlternative = reqList->ReqAlternativeTable;
RA = *reqAlternative;
reqList->SelectedAlternative = reqAlternative;
ReqDescCount = RA->ReqDescCount;
ReqDescTable = RA->ReqDescTable;
// we should have got only one descriptor, use only the first one
if (ReqDescCount>0) {
// get first descriptor & it's arbitor
reqDesc = *ReqDescTable;
if (reqDesc->ArbitrationRequired) {
reqDescTranslated = reqDesc->TranslatedReqDesc; // Could be reqDesc itself
arbiterEntry = reqDesc->u.Arbiter;
ASSERT(arbiterEntry);
// the descriptor of interest - translated, first alternative in the table
ConflictDesc = reqDescTranslated->AlternativeTable.Alternatives;
// skip special descriptor
// to get to the actual descriptor
if(ConflictDesc->Type == CmResourceTypeConfigData || ConflictDesc->Type == CmResourceTypeReserved)
ConflictDesc++;
// finally we can call the arbiter to get a conflict list (returning PDO's and Global Address Ranges)
ExtParams[0] = PhysicalDeviceObject;
ExtParams[1] = ConflictDesc;
ExtParams[2] = &ConflictCount;
ExtParams[3] = &ConflictInfoList;
status = IopCallArbiter(arbiterEntry, ArbiterActionQueryConflict , ExtParams, NULL , NULL);
if (NT_SUCCESS(status)) {
// fill in user-memory buffer with conflict
status = IopQueryConflictFillConflicts(PhysicalDeviceObject,ConflictCount,ConflictInfoList,ConflictList,ConflictListSize,0);
if(ConflictInfoList != NULL) {
ExFreePool(ConflictInfoList);
}
}
else if(status == STATUS_RANGE_NOT_FOUND) {
// fill in with flag indicating bad range (this means range is not available)
// ConflictInfoList should not be allocated
status = IopQueryConflictFillConflicts(NULL,0,NULL,ConflictList,ConflictListSize,PNP_CE_TRANSLATE_FAILED);
}
} else {
#if MYDBG
ASSERT(0); // For now
#endif
status = STATUS_INVALID_PARAMETER; // if we failed, it's prob because ResourceList was invalid
}
} else {
#if MYDBG
ASSERT(0); // For now
#endif
status = STATUS_INVALID_PARAMETER; // if we failed, it's prob because ResourceList was invalid
}
#if DBG_SCOPE
if (PnpResDebugLevel & STOP_ERROR) {
IopCheckDataStructures(IopRootDeviceNode);
}
#endif
IopFreeReqList(reqList);
} else {
#if MYDBG
ASSERT(0); // For now
#endif
if(NT_SUCCESS(status)) {
// it was NULL because we had a zero resource count, must be invalid parameter
status = STATUS_INVALID_PARAMETER;
}
}
ExFreePool(ioResources);
Clean0:
;
return status;
}
Reference in New Issue View Git Blame Copy Permalink