#include <fxresource.hpp>

Inheritance diagram for FxIoResReqList:

[legend]

Collaboration diagram for FxIoResReqList:

[legend]

Public Member Functions
WDFIORESREQLIST	GetHandle (VOID)

_Must_inspect_result_ PIO_RESOURCE_REQUIREMENTS_LIST	CreateWdmList (VOID)

Public Member Functions inherited from FxResourceCollection
BOOLEAN	RemoveAndDelete (__in ULONG Index)

_Must_inspect_result_ NTSTATUS	AddAt (__in ULONG Index, __in FxObject *Object)

BOOLEAN	IsRemoveAllowed (VOID)

BOOLEAN	IsAddAllowed (VOID)

VOID	MarkChanged (VOID)

BOOLEAN	IsChanged (VOID)

Public Member Functions inherited from FxCollection
	FxCollection (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

	~FxCollection (VOID)

BOOLEAN	Add (__in FxObject *Item)

VOID	StealCollection (__in FxCollection *Collection)

Public Member Functions inherited from FxNonPagedObject
	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

	FxNonPagedObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

virtual	~FxNonPagedObject (VOID)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_maxIRQL(DISPATCH_LEVEL) __drv_setsIRQL(DISPATCH_LEVEL) VOID Lock(__out __drv_deref(__drv_savesIRQL) PKIRQL PreviousIrql)

	_Releases_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID Unlock(__in __drv_restoresIRQL KIRQL PreviousIrql)

	_Acquires_lock_ (this->m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) VOID LockAtDispatch(VOID)

	_Requires_lock_held_ (this->m_NPLock.m_Lock) _Releases_lock_(this -> m_NPLock.m_Lock) __drv_requiresIRQL(DISPATCH_LEVEL) __inline VOID UnlockFromDispatch(VOID)

Public Member Functions inherited from FxObject
PVOID	GetCOMWrapper ()

void	SetCOMWrapper (__drv_aliasesMem PVOID Wrapper)

	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

virtual	~FxObject (VOID)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType Type)

PVOID __inline	operator new (__in size_t Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __in USHORT ExtraSize=0)

VOID	operator delete (__in PVOID Memory)

VOID	SetNoContextHeader (VOID)

PVOID __inline	GetObjectHandle (VOID)

__inline FxContextHeader *	GetContextHeader (VOID)

__inline PFX_DRIVER_GLOBALS	GetDriverGlobals (VOID)

WDFTYPE	GetType (VOID)

USHORT	GetObjectSize (VOID)

LONG	GetRefCnt (VOID)

FxTagTracker *	GetTagTracker (VOID)

CfxDevice *	GetDevice (VOID)

CfxDeviceBase *	GetDeviceBase (VOID)

VOID	SetDeviceBase (__in CfxDeviceBase *DeviceBase)

__inline VOID	CallCleanup (VOID)

ULONG __inline	AddRef (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	Release (__in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	AddRefOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual ULONG	ReleaseOverride (__in WDFOBJECT_OFFSET Offset, __in_opt PVOID Tag=NULL, __in LONG Line=0, __in_opt PSTR File=NULL)

virtual _Must_inspect_result_ NTSTATUS	QueryInterface (__in FxQueryInterfaceParams *Params)

VOID	MarkTraceState (VOID)

BOOLEAN __inline	IsTraceState (VOID)

VOID __inline	TraceDroppedEvent (__in FxObjectDroppedEvent Event)

VOID	MarkPassiveDispose (__in FxObjectLockState State=ObjectLock)

VOID	MarkPassiveCallbacks (__in FxObjectLockState State=ObjectLock)

VOID	MarkForceDisposeThread (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsPassiveCallbacks (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsPassiveDispose (__in BOOLEAN AcquireLock=TRUE)

BOOLEAN	IsForceDisposeThread (__in BOOLEAN AcquireLock=TRUE)

VOID	MarkCommitted (VOID)

BOOLEAN	IsCommitted (VOID)

VOID	MarkDisposeOverride (__in FxObjectLockState State=ObjectLock)

VOID	MarkNoDeleteDDI (__in FxObjectLockState State=ObjectLock)

BOOLEAN	IsNoDeleteDDI (VOID)

_Must_inspect_result_ NTSTATUS	Commit (__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT ObjectHandle, __in_opt FxObject Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)

VOID	DeleteFromFailedCreate (VOID)

VOID	ClearEvtCallbacks (VOID)

BOOLEAN	EarlyDispose (VOID)

virtual VOID	DeleteObject (VOID)

virtual BOOLEAN	Dispose (VOID)

_Must_inspect_result_ NTSTATUS	AssignParentObject (__in FxObject *ParentObject)

_Must_inspect_result_ NTSTATUS	AddContext (__in FxContextHeader Header, __in PVOID Context, __in PWDF_OBJECT_ATTRIBUTES Attributes)

_Must_inspect_result_ NTSTATUS	RemoveParentAssignment (VOID)

_Must_inspect_result_ FxObject *	GetParentObjectReferenced (__in PVOID Tag)

BOOLEAN	IsDisposed (VOID)

Public Member Functions inherited from FxCollectionInternal
	FxCollectionInternal (VOID)

	~FxCollectionInternal (VOID)

_Must_inspect_result_ FxCollectionEntry *	FindEntry (__in ULONG Index)

_Must_inspect_result_ FxCollectionEntry *	FindEntryByObject (__in FxObject *Object)

ULONG	Count (VOID)

BOOLEAN	Add (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Item)

_Must_inspect_result_ FxObject *	GetItem (__in ULONG Index)

_Must_inspect_result_ FxObject *	GetFirstItem (VOID)

_Must_inspect_result_ FxObject *	GetLastItem (VOID)

NTSTATUS	Remove (__in ULONG Index)

VOID	CleanupEntry (__in FxCollectionEntry *Entry)

VOID	CleanupEntryObject (__in FxObject *Object)

NTSTATUS	RemoveEntry (__in FxCollectionEntry *Entry)

_Must_inspect_result_ NTSTATUS	RemoveItem (__in FxObject *Item)

_Must_inspect_result_ FxCollectionEntry *	Start (VOID)

_Must_inspect_result_ FxCollectionEntry *	End (VOID)

VOID	Clear (VOID)

Static Public Member Functions
static _Must_inspect_result_ NTSTATUS	_CreateAndInit (__in FxIoResReqList **ResourceReqList, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in_opt PWDF_OBJECT_ATTRIBUTES ListAttributes, __in UCHAR AccessFlags)

static _Must_inspect_result_ FxIoResReqList *	_CreateFromWdmList (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PIO_RESOURCE_REQUIREMENTS_LIST WdmRequirementsList, __in UCHAR AccessFlags)

Static Public Member Functions inherited from FxObject
static FxObject *	_FromDisposeEntry (__in PSINGLE_LIST_ENTRY Entry)

static FxObject *	_GetObjectFromHandle (__in WDFOBJECT Handle, __inout PWDFOBJECT_OFFSET ObjectOffset)

static PVOID __inline	_ToHandle (__in FxObject *Object)

static VOID __inline	_ReferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static VOID __inline	_DereferenceActual (__in WDFOBJECT Object, __in_opt PVOID Tag, __in LONG Line, __in PSTR File)

static PVOID	_GetDebugBase (__in FxObject *Object)

static PFX_POOL_HEADER	_CleanupPointer (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObject *Object)

static _Must_inspect_result_ NTSTATUS	_GetEffectiveLock (__in FxObject Object, __in_opt IFxHasCallbacks Callbacks, __in BOOLEAN AutomaticLocking, __in BOOLEAN PassiveCallbacks, __out FxCallbackLock CallbackLock, __out_opt FxObject CallbackLockObject)

static _Must_inspect_result_ NTSTATUS	_ObjectQuery (_In_ FxObject Object, _In_ CONST GUID Guid, _In_ ULONG QueryBufferLength, _Out_writes_bytes_(QueryBufferLength) PVOID QueryBuffer)

Public Attributes
ULONG	m_SlotNumber

INTERFACE_TYPE	m_InterfaceType

Public Attributes inherited from FxResourceCollection
UCHAR	m_AccessFlags

BOOLEAN	m_Changed

Protected Member Functions
	FxIoResReqList (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in UCHAR AccessFlags=FxResourceNoAccess)

Protected Member Functions inherited from FxResourceCollection
	FxResourceCollection (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFTYPE Type, __in USHORT Size, __in UCHAR AccessFlags=FxResourceNoAccess)

Protected Member Functions inherited from FxCollection
	FxCollection (__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFTYPE Type, __in USHORT Size)

Protected Member Functions inherited from FxObject
	FxObject (__in WDFTYPE Type, __in USHORT Size, __in PFX_DRIVER_GLOBALS FxDriverGlobals, __in FxObjectType ObjectType)

FxObjectDebugExtension *	GetDebugExtension (VOID)

BOOLEAN	IsDebug (VOID)

VOID	AllocateTagTracker (__in WDFTYPE Type)

virtual VOID	SelfDestruct (VOID)

PVOID __inline	GetObjectHandleUnchecked (VOID)

VOID __inline	DestroyChildren (VOID)

VOID	DeleteEarlyDisposedObject (VOID)

Protected Member Functions inherited from FxCollectionInternal
_Must_inspect_result_ FxCollectionEntry *	AllocateEntry (__in PFX_DRIVER_GLOBALS FxDriverGlobals)

VOID	AddEntry (__in FxCollectionEntry Node, __in FxObject Item)

Additional Inherited Members
Static Protected Member Functions inherited from FxObject
static PVOID	_GetBase (__in FxObject *Object)

Protected Attributes inherited from FxObject
union {
CfxDeviceBase * m_DeviceBase

CfxDevice * m_Device

};

Protected Attributes inherited from FxCollectionInternal
ULONG	m_Count

LIST_ENTRY	m_ListHead

Detailed Description

Definition at line 626 of file fxresource.hpp.

Constructor & Destructor Documentation

◆ FxIoResReqList()

FxIoResReqList::FxIoResReqList	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in UCHAR	AccessFlags = `FxResourceNoAccess`
	)

inlineprotected

Definition at line 628 of file fxresource.hpp.

          :
        FxResourceCollection(FxDriverGlobals,
                             FX_TYPE_IO_RES_REQ_LIST,
                             sizeof(FxIoResReqList),
                             AccessFlags),
        m_SlotNumber(0), m_InterfaceType(Internal)
    {
        m_AccessFlags = AccessFlags;
    }

Member Function Documentation

◆ _CreateAndInit()

static _Must_inspect_result_ NTSTATUS FxIoResReqList::_CreateAndInit	(	__in FxIoResReqList **	ResourceReqList,
		__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in_opt PWDF_OBJECT_ATTRIBUTES	ListAttributes,
		__in UCHAR	AccessFlags
	)

inlinestatic

Definition at line 646 of file fxresource.hpp.

    {
        NTSTATUS ntStatus;
        FxIoResReqList *resReqList = NULL;
 
        //
        // Initialize
        //
        *ResourceReqList = NULL;
 
        //
        // Allocate a new resource list object
        //
        resReqList = new(FxDriverGlobals, ListAttributes)
            FxIoResReqList(FxDriverGlobals, AccessFlags);
        if (resReqList == NULL) {
            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR,
                                TRACINGDEVICE,
                                "Failed to allocate FxIoResReqList, "
                                "returning %!STATUS!",
                                ntStatus);
 
            goto exit;
        }
 
        *ResourceReqList = resReqList;
        ntStatus = STATUS_SUCCESS;
 
        exit:
            if (!NT_SUCCESS(ntStatus)) {
                if (NULL != resReqList) {
                    resReqList->DeleteFromFailedCreate();
                }
            }
            return ntStatus;
    }

Referenced by FxPkgPdo::PnpQueryResourceRequirements().

◆ _CreateFromWdmList()

_Must_inspect_result_ FxIoResReqList * FxIoResReqList::_CreateFromWdmList	(	__in PFX_DRIVER_GLOBALS	FxDriverGlobals,
		__in PIO_RESOURCE_REQUIREMENTS_LIST	WdmRequirementsList,
		__in UCHAR	AccessFlags
	)

static

Definition at line 477 of file fxresourcecollection.cpp.

{
    FxIoResReqList* pIoResReqList;
    ULONG i;
 
    pIoResReqList = new(FxDriverGlobals, WDF_NO_OBJECT_ATTRIBUTES)
        FxIoResReqList(FxDriverGlobals, AccessFlags);
 
    if (pIoResReqList != NULL) {
        PIO_RESOURCE_LIST pWdmResourceList;
        NTSTATUS status;
 
        if (WdmRequirementsList == NULL) {
            return pIoResReqList;
        }
 
        status = STATUS_SUCCESS;
        pWdmResourceList = &WdmRequirementsList->List[0];
 
        pIoResReqList->m_InterfaceType = WdmRequirementsList->InterfaceType;
        pIoResReqList->m_SlotNumber = WdmRequirementsList->SlotNumber;
 
        for (i = 0; i < WdmRequirementsList->AlternativeLists; i++) {
            FxIoResList *pResList;
 
            pResList = new(FxDriverGlobals, WDF_NO_OBJECT_ATTRIBUTES)
                FxIoResList(FxDriverGlobals, pIoResReqList);
 
            if (pResList != NULL) {
                status = pResList->AssignParentObject(pIoResReqList);
 
                //
                // Since we control our own lifetime, assigning the parent should
                // never fail.
                //
                ASSERT(NT_SUCCESS(status));
 
                status = pResList->BuildFromWdmList(&pWdmResourceList);
            }
            else {
                //
                // We failed to allocate a child collection.  Clean up
                // and break out of the loop.
                //
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
 
            if (!NT_SUCCESS(status)) {
                break;
            }
        }
 
        if (!NT_SUCCESS(status)) {
            //
            // Cleanup and return a NULL object
            //
            pIoResReqList->DeleteObject();
            pIoResReqList = NULL;
        }
    }
 
    return pIoResReqList;
}

Referenced by FxPkgFdo::PnpFilterResourceRequirements().

◆ CreateWdmList()

_Must_inspect_result_ PIO_RESOURCE_REQUIREMENTS_LIST FxIoResReqList::CreateWdmList ( VOID )

Definition at line 564 of file fxresourcecollection.cpp.

{
    PIO_RESOURCE_REQUIREMENTS_LIST pRequirementsList;
    FxCollectionEntry *cur, *end;
    NTSTATUS status;
    ULONG totalDescriptors;
    ULONG size;
    ULONG count;
    ULONG tmp;
    PFX_DRIVER_GLOBALS pFxDriverGlobals;
 
    totalDescriptors = 0;
    pRequirementsList = NULL;
 
    count = Count();
    pFxDriverGlobals = GetDriverGlobals();
 
    if (count > 0) {
        //
        // The collection object should contain a set of child collections
        // with each of the various requirement lists.  Use the number of
        // these collections to determine the size of our requirements
        // list.
        //
        end = End();
        for (cur = Start(); cur != end; cur = cur->Next()) {
            status = RtlULongAdd(totalDescriptors,
                                 ((FxIoResList *) cur->m_Object)->Count(),
                                 &totalDescriptors);
 
            if (!NT_SUCCESS(status)) {
                goto Overflow;
            }
        }
 
        //
        // We now have enough information to determine how much memory we
        // need to allocate for our requirements list.
        //
        // size = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) +
        //        (sizeof(IO_RESOURCE_LIST) * (count - 1)) +
        //        (sizeof(IO_RESOURCE_DESCRIPTOR) * totalDescriptors) -
        //         (sizeof(IO_RESOURCE_DESCRIPTOR) * count);
        //
        // sizeof(IO_RESOURCE_DESCRIPTOR) * count is subtracted off because
        // each IO_RESOURCE_LIST has an embedded IO_RESOURCE_DESCRIPTOR in it
        // and we don't want to overallocated.
        //
 
        //
        // To handle overflow each mathematical operation is split out into an
        // overflow safe call.
        //
        size = sizeof(IO_RESOURCE_REQUIREMENTS_LIST);
 
        // sizeof(IO_RESOURCE_LIST) * (count - 1)
        status = RtlULongMult(sizeof(IO_RESOURCE_LIST), count - 1, &tmp);
        if (!NT_SUCCESS(status)) {
            goto Overflow;
        }
 
        status = RtlULongAdd(size, tmp, &size);
        if (!NT_SUCCESS(status)) {
            goto Overflow;
        }
 
        // (sizeof(IO_RESOURCE_DESCRIPTOR) * totalDescriptors)
        status = RtlULongMult(sizeof(IO_RESOURCE_DESCRIPTOR),
                              totalDescriptors,
                              &tmp);
        if (!NT_SUCCESS(status)) {
            goto Overflow;
        }
 
        status = RtlULongAdd(size, tmp, &size);
        if (!NT_SUCCESS(status)) {
            goto Overflow;
        }
 
        //  - sizeof(IO_RESOURCE_DESCRIPTOR) * Count() (note the subtraction!)
        status = RtlULongMult(sizeof(IO_RESOURCE_DESCRIPTOR), count, &tmp);
        if (!NT_SUCCESS(status)) {
            goto Overflow;
        }
 
        // Sub, not Add!
        status = RtlULongSub(size, tmp, &size);
        if (!NT_SUCCESS(status)) {
            goto Overflow;
        }
 
        pRequirementsList = (PIO_RESOURCE_REQUIREMENTS_LIST)
            MxMemory::MxAllocatePoolWithTag(PagedPool, size, pFxDriverGlobals->Tag);
 
        if (pRequirementsList != NULL) {
            PIO_RESOURCE_LIST pList;
            FxResourceIo *pResource;
 
            pList = pRequirementsList->List;
 
            //
            // Start by zero initializing our structure
            //
            RtlZeroMemory(pRequirementsList, size);
 
            //
            // InterfaceType and BusNumber are unused for WDM, but InterfaceType
            // is used by the arbiters.
            //
            pRequirementsList->InterfaceType = m_InterfaceType;
 
            pRequirementsList->SlotNumber = m_SlotNumber;
 
            //
            // Now populate the requirements list with the resources from
            // our collections.
            //
            pRequirementsList->ListSize = size;
            pRequirementsList->AlternativeLists = Count();
 
            end = End();
            for (cur = Start(); cur != end; cur = cur->Next()) {
                FxIoResList* pIoResList;
                PIO_RESOURCE_DESCRIPTOR pDescriptor;
                FxCollectionEntry *pIoResCur, *pIoResEnd;
 
                pIoResList = (FxIoResList*) cur->m_Object;
 
                pList->Version  = 1;
                pList->Revision = 1;
                pList->Count = pIoResList->Count();
 
                pDescriptor = pList->Descriptors;
 
                pIoResEnd = pIoResList->End();
                for (pIoResCur = pIoResList->Start();
                     pIoResCur != pIoResEnd;
                     pIoResCur = pIoResCur->Next()) {
 
                    pResource = (FxResourceIo *) pIoResCur->m_Object;
                    RtlCopyMemory(pDescriptor,
                                  &pResource->m_Descriptor,
                                  sizeof(pResource->m_Descriptor));
                    pDescriptor++;
                }
 
                pList = (PIO_RESOURCE_LIST) pDescriptor;
            }
        }
    }
 
    return pRequirementsList;
 
Overflow:
    DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                        "Integer overflow occured when computing size of "
                        "IO_RESOURCE_REQUIREMENTS_LIST");
 
    return NULL;
}

Referenced by FxPkgFdo::PnpFilterResourceRequirements(), and FxPkgPdo::PnpQueryResourceRequirements().

◆ GetHandle()

WDFIORESREQLIST FxIoResReqList::GetHandle ( VOID )

inline

Definition at line 691 of file fxresource.hpp.

    {
        return (WDFIORESREQLIST) GetObjectHandle();
    }

Referenced by FxPkgFdo::PnpFilterResourceRequirements().

Member Data Documentation

◆ m_InterfaceType

INTERFACE_TYPE FxIoResReqList::m_InterfaceType

Definition at line 716 of file fxresource.hpp.

Referenced by __drv_strictTypeMatch(), _CreateFromWdmList(), and CreateWdmList().

◆ m_SlotNumber

ULONG FxIoResReqList::m_SlotNumber

Definition at line 714 of file fxresource.hpp.

Referenced by _CreateFromWdmList(), and CreateWdmList().

The documentation for this class was generated from the following files:

sdk/lib/drivers/wdf/shared/inc/private/common/fxresource.hpp
sdk/lib/drivers/wdf/shared/support/fxresourcecollection.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Protected Member Functions

Additional Inherited Members