--- /dev/null
+/*++
+
+Copyright (c) Microsoft Corporation
+
+Module Name:
+
+ FxResourceCollection.cpp
+
+Abstract:
+
+ This module implements a base object for derived collection classes and
+ the derived collection classes.
+
+Author:
+
+
+
+Environment:
+
+ Both kernel and user mode
+
+Revision History:
+
+--*/
+
+#include "FxSupportPch.hpp"
+
+extern "C" {
+#if defined(EVENT_TRACING)
+#include "FxResourceCollection.tmh"
+#endif
+}
+
+BOOLEAN
+FxResourceCollection::RemoveAndDelete(
+ __in ULONG Index
+ )
+/*++
+
+Routine Description:
+ Removes an entry from the collection and then deletes it if found. The
+ caller must have removal permissions to perform this action.
+
+Arguments:
+ Index - zero based index into the collection at which to perform the removal
+
+Return Value:
+ TRUE if the item was found and deleted, FALSE otherwise
+
+ --*/
+{
+ FxObject* pObject;
+ FxCollectionEntry* pEntry;
+ KIRQL irql;
+
+ if (IsRemoveAllowed() == FALSE) {
+ DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
+ "Removes not allowed on handle %p, remove at index %d"
+ "failed", GetObjectHandle(), Index);
+
+ FxVerifierDbgBreakPoint(GetDriverGlobals());
+ return FALSE;
+ }
+
+ pObject = NULL;
+
+ Lock(&irql);
+
+ pEntry = FindEntry(Index);
+ if (pEntry != NULL) {
+
+ //
+ // Mark the list as changed so when we go to create a WDM resource list we
+ // know if a new list is needed.
+ //
+ MarkChanged();
+
+ pObject = pEntry->m_Object;
+
+ //
+ // Remove the entry
+ //
+ RemoveEntry(pEntry);
+ }
+ Unlock(irql);
+
+ if (pObject != NULL) {
+ //
+ // Delete the object since we created it
+ //
+ pObject->DeleteObject();
+ pObject = NULL;
+
+ return TRUE;
+ }
+ else {
+ return FALSE;
+ }
+}
+
+_Must_inspect_result_
+NTSTATUS
+FxResourceCollection::AddAt(
+ __in ULONG Index,
+ __in FxObject* Object
+ )
+/*++
+
+Routine Description:
+ Adds an object into the collection at the specified index.
+
+Arguments:
+ Index - zero baesd index in which to insert into the list. WDF_INSERT_AT_END
+ is a special value which indicates that the insertion is an append.
+
+ Object - object to add
+
+Return Value:
+ NTSTATUS
+
+ --*/
+{
+ FxCollectionEntry *pNew;
+ PLIST_ENTRY ple;
+ NTSTATUS status;
+ KIRQL irql;
+
+ if (IsAddAllowed() == FALSE) {
+ DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGPNP,
+ "Adds not allowed on handle %p, add at index %d"
+ "failed", GetObjectHandle(), Index);
+
+ FxVerifierDbgBreakPoint(GetDriverGlobals());
+
+ return STATUS_ACCESS_DENIED;
+ }
+
+ Lock(&irql);
+
+ ple = NULL;
+ status = STATUS_SUCCESS;
+
+ pNew = AllocateEntry(GetDriverGlobals());
+
+ if (pNew != NULL) {
+ //
+ // Inserting at the current count (i.e. one past the end) is the same
+ // as append.
+ //
+ if (Index == WDF_INSERT_AT_END || Index == Count()) {
+ ple = &m_ListHead;
+ }
+ else {
+ FxCollectionEntry* cur, *end;
+ ULONG i;
+
+ for (cur = Start(), end = End(), i = 0;
+ cur != end;
+ cur = cur->Next(), i++) {
+ if (i == Index) {
+ ple = &cur->m_ListEntry;
+ break;
+ }
+ }
+
+ if (ple == NULL) {
+ delete pNew;
+ status = STATUS_ARRAY_BOUNDS_EXCEEDED;
+ }
+ }
+ }
+ else {
+ status = STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ if (NT_SUCCESS(status)) {
+ PLIST_ENTRY blink;
+
+ // ple now points to the list entry which we will insert our node
+ // *before*
+
+ blink = ple->Blink;
+
+ // Link the previous with the new entry
+ blink->Flink = &pNew->m_ListEntry;
+ pNew->m_ListEntry.Blink = blink;
+
+ // Link the current with the new entry
+ pNew->m_ListEntry.Flink = ple;
+ ple->Blink = &pNew->m_ListEntry;
+
+ AddEntry(pNew, Object);
+
+ //
+ // Mark the list as changed so when we go to create a WDM resource list
+ // we know if a new list is needed.
+ //
+ MarkChanged();
+ }
+
+ Unlock(irql);
+
+ if (!NT_SUCCESS(status)) {
+ Object->DeleteFromFailedCreate();
+ }
+
+ return status;
+}
+
+_Must_inspect_result_
+NTSTATUS
+FxIoResList::BuildFromWdmList(
+ __deref_in PIO_RESOURCE_LIST* WdmResourceList
+ )
+/*++
+
+Routine Description:
+ Builds up the collection with FxResourceIo objects based on the passed in
+ WDM io resource list
+
+Arguments:
+ WdmResourceList - list which specifies the io resource objects to create
+
+Return Value:
+ NTSTATUS
+
+ --*/
+{
+ PIO_RESOURCE_DESCRIPTOR pWdmDescriptor;
+ ULONG i, count;
+ NTSTATUS status;
+
+ pWdmDescriptor = &(*WdmResourceList)->Descriptors[0];
+ count = (*WdmResourceList)->Count;
+ status = STATUS_SUCCESS;
+
+ for (i = 0; i < count; i++) {
+ //
+ // Now create a new resource object for each resource
+ // in our list.
+ //
+ FxResourceIo *pResource;
+
+ pResource = new(GetDriverGlobals())
+ FxResourceIo(GetDriverGlobals(), pWdmDescriptor);
+
+ if (pResource == NULL) {
+ //
+ // We failed, clean up, and exit. Since we are only
+ // keeping references on the master collection, if
+ // we free this, everything else will go away too.
+ //
+ status = STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ if (NT_SUCCESS(status)) {
+ status = pResource->AssignParentObject(this);
+
+ //
+ // See notes in previous AssignParentObject as to why
+ // we are asserting.
+ //
+ ASSERT(NT_SUCCESS(status));
+ UNREFERENCED_PARAMETER(status);
+
+ status = Add(pResource) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ if (!NT_SUCCESS(status)) {
+ break;
+ }
+
+ pWdmDescriptor++;
+ }
+
+ if (NT_SUCCESS(status)) {
+ status = m_OwningList->Add(this) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ if (NT_SUCCESS(status)) {
+ *WdmResourceList = (PIO_RESOURCE_LIST) pWdmDescriptor;
+ }
+
+ return status;
+}
+
+_Must_inspect_result_
+NTSTATUS
+FxCmResList::BuildFromWdmList(
+ __in PCM_RESOURCE_LIST WdmResourceList,
+ __in UCHAR AccessFlags
+ )
+/*++
+
+Routine Description:
+ Builds up the collection with FxResourceCm objects based on the passed in
+ WDM io resource list.
+
+Arguments:
+ WdmResourceList - list which specifies the io resource objects to create
+
+ AccessFlags - permissions to be associated with the list
+
+Return Value:
+ NTSTATUS
+
+ --*/
+{
+ NTSTATUS status;
+
+ //
+ // Predispose to success
+ //
+ status = STATUS_SUCCESS;
+
+ Clear();
+
+ m_AccessFlags = AccessFlags;
+
+ if (WdmResourceList != NULL) {
+ PCM_PARTIAL_RESOURCE_DESCRIPTOR pDescriptor;
+ ULONG count, i;
+
+ //
+ // We only expect to see one full resource descriptor.
+ //
+ ASSERT(WdmResourceList->Count == 1);
+
+ count = WdmResourceList->List[0].PartialResourceList.Count;
+ pDescriptor = WdmResourceList->List[0].PartialResourceList.PartialDescriptors;
+
+ for(i = 0; i < count; i++, pDescriptor++) {
+ FxResourceCm *pResource;
+
+ pResource = new(GetDriverGlobals())
+ FxResourceCm(GetDriverGlobals(), pDescriptor);
+
+ if (pResource == NULL) {
+ status = STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ if (NT_SUCCESS(status)) {
+ status = pResource->AssignParentObject(this);
+
+ //
+ // Since we control our own lifetime here, the assign should
+ // always work.
+ //
+ ASSERT(NT_SUCCESS(status));
+
+ status = Add(pResource) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
+ }
+
+ if (!NT_SUCCESS(status)) {
+ Clear();
+ break;
+ }
+ }
+ }
+
+ return status;
+}
+
+_Must_inspect_result_
+PCM_RESOURCE_LIST
+FxCmResList::CreateWdmList(
+ __in __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType
+ )
+/*++
+
+Routine Description:
+ Allocates and initializes a WDM CM resource list based off of the current
+ contents of this collection.
+
+Arguments:
+ PoolType - the pool type from which to allocate the resource list
+
+Return Value:
+ a new resource list upon success, NULL upon failure
+
+ --*/
+{
+ PCM_RESOURCE_LIST pWdmResourceList;
+ ULONG size;
+ PFX_DRIVER_GLOBALS pFxDriverGlobals;
+
+ pWdmResourceList = NULL;
+ pFxDriverGlobals = GetDriverGlobals();
+
+ if (Count()) {
+ //
+ // NOTE: This function assumes all resources are on the same bus
+ // and therefore there is only one FULL_RESOURCE_DESCRIPTOR.
+ //
+ size = sizeof(CM_RESOURCE_LIST) +
+ (sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * (Count() - 1));
+
+ pWdmResourceList = (PCM_RESOURCE_LIST)
+ MxMemory::MxAllocatePoolWithTag(PoolType, size, pFxDriverGlobals->Tag);
+
+ if (pWdmResourceList != NULL) {
+ PCM_PARTIAL_RESOURCE_DESCRIPTOR pDescriptor;
+ FxCollectionEntry *cur, *end;
+
+ RtlZeroMemory(pWdmResourceList, size);
+
+ pWdmResourceList->Count = 1; // We only return one full descriptor
+
+ pWdmResourceList->List[0].PartialResourceList.Version = 1;
+ pWdmResourceList->List[0].PartialResourceList.Revision = 1;
+ pWdmResourceList->List[0].PartialResourceList.Count = Count();
+
+ pDescriptor =
+ pWdmResourceList->List[0].PartialResourceList.PartialDescriptors;
+
+ end = End();
+ for (cur = Start(); cur != end; cur = cur->Next()) {
+ FxResourceCm *pResource;
+
+ pResource = (FxResourceCm*) cur->m_Object;
+
+ RtlCopyMemory(pDescriptor,
+ &pResource->m_Descriptor,
+ sizeof(pResource->m_Descriptor));
+ pDescriptor++;
+ }
+ }
+ }
+
+ return pWdmResourceList;
+}
+
+ULONG
+FxCmResList::GetCount(
+ VOID
+ )
+{
+ ULONG count;
+ KIRQL irql;
+
+ Lock(&irql);
+ count = Count();
+ Unlock(irql);
+
+ return count;
+}
+
+PCM_PARTIAL_RESOURCE_DESCRIPTOR
+FxCmResList::GetDescriptor(
+ __in ULONG Index
+ )
+{
+ FxResourceCm* pObject;
+ KIRQL irql;
+
+ Lock(&irql);
+ pObject = (FxResourceCm*) GetItem(Index);
+ Unlock(irql);
+
+ if (pObject == NULL) {
+ return NULL;
+ }
+ else {
+ //
+ // Copy the current descriptor to the clone and return it
+ //
+ RtlCopyMemory(&pObject->m_DescriptorClone,
+ &pObject->m_Descriptor,
+ sizeof(pObject->m_Descriptor));
+
+ return &pObject->m_DescriptorClone;
+ }
+}
+
+_Must_inspect_result_
+FxIoResReqList*
+FxIoResReqList::_CreateFromWdmList(
+ __in PFX_DRIVER_GLOBALS FxDriverGlobals,
+ __in PIO_RESOURCE_REQUIREMENTS_LIST WdmRequirementsList,
+ __in UCHAR AccessFlags
+ )
+/*++
+
+Routine Description:
+ Allocates and populates an FxIoResReqList based on the WDM resource
+ requirements list.
+
+Arguments:
+ WdmRequirementsList - a list of IO_RESOURCE_LISTs which will indicate how
+ to fill in the returned collection object
+
+ AccessFlags - permissions to associate with the newly created object
+
+Return Value:
+ a new object upon success, NULL upon failure
+
+ --*/
+
+{
+ 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;
+}
+
+_Must_inspect_result_
+PIO_RESOURCE_REQUIREMENTS_LIST
+FxIoResReqList::CreateWdmList(
+ VOID
+ )
+/*++
+
+Routine Description:
+ Creates a WDM io resource requirements list based off of the current
+ contents of the collection
+
+Arguments:
+ None
+
+Return Value:
+ new WDM io resource requirements list allocated out of paged pool upon success,
+ NULL upon failure or an empty list
+
+ --*/
+{
+ 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;
+}
projects / reactos.git / blobdiff