fxresource.hpp

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
Module Name:
 
    FxResource.hpp
 
Abstract:
 
    This module implements the resource object.
 
Author:
 
 
 
Environment:
 
    Both kernel and user mode
 
Revision History:
 
--*/
 
#ifndef _FXRESOURCE_H_
#define _FXRESOURCE_H_
 
extern "C" {
 
#if defined(EVENT_TRACING)
#include "FxResource.hpp.tmh"
#endif
 
}
 
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
 
struct FxRegisterResourceInfo : FxStump {
    //
    // start physical address of resource range assigned by pnp
    //
    PHYSICAL_ADDRESS m_StartPa;
 
    //
    // start of mapped system base address
    //
    PVOID m_StartSystemVa;
 
    //
    // end of mapped system base address
    //
    PVOID m_EndSystemVa;
 
    //
    // user-mode mapped address
    //
    PVOID m_StartUsermodeVa;
 
    //
    // Length of resource range assigned by pnp
    //
    SIZE_T m_Length;
 
    //
    // Length of mapped resource range
    //
    SIZE_T m_MappedLength;
 
    static
    NTSTATUS
    _CreateAndInit(
        _In_ PFX_DRIVER_GLOBALS DriverGlobals,
        _In_ ULONG Count,
        _Out_ FxRegisterResourceInfo** RegisterTable
        )
    {
        NTSTATUS status;
        FxRegisterResourceInfo* table;
 
        ASSERT(RegisterTable != NULL);
        *RegisterTable = NULL;
 
        table = new (DriverGlobals) FxRegisterResourceInfo[Count];
        if (table == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(
                DriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "Failed to allocate Resource table %!STATUS!", status);
            return status;
        }
 
        *RegisterTable = table;
        status = STATUS_SUCCESS;
 
        return status;
    }
 
    FxRegisterResourceInfo(
        VOID
        ):
        m_StartSystemVa(NULL),
        m_EndSystemVa(NULL),
        m_StartUsermodeVa(NULL),
        m_Length(0),
        m_MappedLength(0)
    {
        m_StartPa.QuadPart = 0;
    };
 
    ~FxRegisterResourceInfo(){;};
 
    VOID
    SetPhysicalAddress(
        __in PHYSICAL_ADDRESS StartPa,
        __in SIZE_T Length
        )
    {
        m_StartPa = StartPa;
        m_Length = Length;
    }
 
    VOID
    SetMappedAddress(
        __in PVOID SystemBaseAddress,
        __in SIZE_T MappedLength,
        __in PVOID UsermodeBaseAddress
        )
    {
        m_StartSystemVa = SystemBaseAddress;
        m_MappedLength = MappedLength;
        m_EndSystemVa = ((PUCHAR) m_StartSystemVa) + MappedLength - 1;
        m_StartUsermodeVa = UsermodeBaseAddress;
    };
 
    VOID
    ClearMappedAddress(
        VOID
        )
    {
        m_StartSystemVa = NULL;
        m_EndSystemVa = NULL;
        m_StartUsermodeVa = NULL;
        m_MappedLength = 0;
    };
 
};
 
struct FxPortResourceInfo : FxStump {
    //
    // start physical address
    //
    PHYSICAL_ADDRESS m_StartPa;
 
    //
    // end physical address
    //
    PHYSICAL_ADDRESS m_EndPa;
 
    //
    // Length of resource
    //
    SIZE_T m_Length;
 
    static
    NTSTATUS
    _CreateAndInit(
        _In_ PFX_DRIVER_GLOBALS DriverGlobals,
        _In_ ULONG Count,
        _Out_ FxPortResourceInfo** PortTable
        )
    {
        NTSTATUS status;
        FxPortResourceInfo* table;
 
        ASSERT(PortTable != NULL);
        *PortTable = NULL;
 
        table = new (DriverGlobals) FxPortResourceInfo[Count];
        if (table == NULL) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            DoTraceLevelMessage(
                DriverGlobals, TRACE_LEVEL_ERROR, TRACINGPNP,
                "Failed to allocate Resource table %!STATUS!", status);
            return status;
        }
 
        *PortTable = table;
        status = STATUS_SUCCESS;
 
        return status;
    }
 
    FxPortResourceInfo(
        VOID
        ):
        m_Length(0)
    {
        m_StartPa.QuadPart = 0;
        m_EndPa.QuadPart = 0;
    };
 
    ~FxPortResourceInfo(){;};
 
    VOID
    SetPhysicalAddress(
        __in PHYSICAL_ADDRESS StartPa,
        __in SIZE_T Length
        )
    {
        m_StartPa = StartPa;
        m_EndPa.QuadPart = StartPa.QuadPart + Length - 1;
        m_Length = Length;
    }
};
 
#endif
 
//
// Used in FilterResourceRequirements, and QueryResourceRequirements
//
 
class FxResourceIo : public FxObject {
public:
    IO_RESOURCE_DESCRIPTOR m_Descriptor;
 
    //
    // Clone of m_Descriptor which is returned to the driver writer when it
    // requests a descriptor pointer.  We clone the descriptor so that if the
    // driver writer attempts to modify the pointer in place, they modify the
    // clone and not the real descriptor.
    //
    IO_RESOURCE_DESCRIPTOR m_DescriptorClone;
 
public:
    FxResourceIo(
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in PIO_RESOURCE_DESCRIPTOR Resource
        ) : FxObject(FX_TYPE_RESOURCE_IO, 0, FxDriverGlobals)
    {
        RtlCopyMemory(&m_Descriptor, Resource, sizeof(m_Descriptor));
    }
 
    DECLARE_INTERNAL_NEW_OPERATOR();
};
 
//
// Used in StartDevice
//
class FxResourceCm : public FxObject {
public:
    CM_PARTIAL_RESOURCE_DESCRIPTOR m_Descriptor;
 
    //
    // Clone of m_Descriptor which is returned to the driver writer when it
    // requests a descriptor pointer.  We clone the descriptor so that if the
    // driver writer attempts to modify the pointer in place, they modify the
    // clone and not the real descriptor.
    //
    CM_PARTIAL_RESOURCE_DESCRIPTOR m_DescriptorClone;
 
public:
    FxResourceCm(
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in PCM_PARTIAL_RESOURCE_DESCRIPTOR Resource
        ) : FxObject(FX_TYPE_RESOURCE_CM, 0, FxDriverGlobals)
    {
        RtlCopyMemory(&m_Descriptor, Resource, sizeof(m_Descriptor));
    }
 
    DECLARE_INTERNAL_NEW_OPERATOR();
};
 
enum FxResourceAccessFlags {
    FxResourceNoAccess      = 0x0000,
    FxResourceAddAllowed    = 0x0001,
    FxResourceRemoveAllowed = 0x0002,
    FxResourceAllAccessAllowed = FxResourceAddAllowed | FxResourceRemoveAllowed,
};
 
class FxResourceCollection : public FxCollection {
protected:
    FxResourceCollection(
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in WDFTYPE Type,
        __in USHORT Size,
        __in UCHAR AccessFlags = FxResourceNoAccess
        ) : FxCollection(FxDriverGlobals, Type, Size),
            m_AccessFlags(AccessFlags), m_Changed(FALSE)
    {
        //
        // Driver cannot delete this or any of its derivations
        //
        MarkNoDeleteDDI();
    }
 
public:
 
    BOOLEAN
    RemoveAndDelete(
        __in ULONG Index
        );
 
    _Must_inspect_result_
    NTSTATUS
    AddAt(
        __in ULONG Index,
        __in FxObject* Object
        );
 
    BOOLEAN
    IsRemoveAllowed(
        VOID
        )
    {
        return FLAG_TO_BOOL(m_AccessFlags, FxResourceRemoveAllowed);
    }
 
    BOOLEAN
    IsAddAllowed(
        VOID
        )
    {
        return FLAG_TO_BOOL(m_AccessFlags, FxResourceAddAllowed);
    }
 
    VOID
    MarkChanged(
        VOID
        )
    {
        m_Changed = TRUE;
    }
 
    BOOLEAN
    IsChanged(
        VOID
        )
    {
        return m_Changed;
    }
 
public:
    UCHAR m_AccessFlags;
 
    BOOLEAN m_Changed;
};
 
class FxCmResList : public FxResourceCollection {
 
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
protected:
    //
    // Table of mapped register resources
    //
    FxRegisterResourceInfo* m_RegisterResourceTable;
    ULONG m_RegisterResourceTableSizeCe;
 
    //
    // Table of port resources
    //
    FxPortResourceInfo* m_PortResourceTable;
    ULONG m_PortResourceTableSizeCe;
 
    //
    // TRUE if we have at least one CmResourceTypeConnection resource.
    //
    BOOLEAN m_HasConnectionResources;
 
    //
    // Lock to serialize access to port/register resource table
    //
    MxLock m_ResourceTableLock;
 
#endif // FX_CORE_USER_MODE
 
protected:
    FxCmResList(
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in UCHAR AccessFlags
        ) : FxResourceCollection(FxDriverGlobals,
                                 FX_TYPE_CM_RES_LIST,
                                 sizeof(FxCmResList),
                                 AccessFlags)
    {
#if (FX_CORE_MODE==FX_CORE_USER_MODE)
        m_RegisterResourceTable = NULL;
        m_PortResourceTable = NULL;
        m_RegisterResourceTableSizeCe = 0;
        m_PortResourceTableSizeCe = 0;
        m_HasConnectionResources = FALSE;
#endif // FX_CORE_USER_MODE
    }
 
    ~FxCmResList();
 
public:
    static
    _Must_inspect_result_
    NTSTATUS
    _CreateAndInit(
        __in FxCmResList** ResourceList,
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in CfxDevice * Device,
        __in_opt PWDF_OBJECT_ATTRIBUTES ListAttributes,
        __in UCHAR AccessFlags
        )
    {
        NTSTATUS ntStatus;
        FxCmResList *resList = NULL;
 
        UNREFERENCED_PARAMETER(Device);
 
        //
        // Initialize
        //
        *ResourceList = NULL;
 
        //
        // Allocate a new resource list object
        //
        resList = new(FxDriverGlobals, ListAttributes)
            FxCmResList(FxDriverGlobals, AccessFlags);
 
        if (resList == NULL) {
 
            ntStatus = STATUS_INSUFFICIENT_RESOURCES;
 
            DoTraceLevelMessage(FxDriverGlobals, TRACE_LEVEL_ERROR,
                                TRACINGDEVICE,
                                "Failed to allocate FxCmResList, "
                                "returning %!STATUS!",
                                ntStatus);
            goto exit;
        }
 
        *ResourceList = resList;
        ntStatus = STATUS_SUCCESS;
 
    exit:
        if (!NT_SUCCESS(ntStatus)) {
            if (NULL != resList) {
                resList->DeleteFromFailedCreate();
            }
        }
        return ntStatus;
    }
 
    WDFCMRESLIST
    GetHandle(
        VOID
        )
    {
        return (WDFCMRESLIST) GetObjectHandle();
    }
 
    _Must_inspect_result_
    NTSTATUS
    BuildFromWdmList(
        __in PCM_RESOURCE_LIST ResourceList,
        __in UCHAR AccessFlags
        );
 
    _Must_inspect_result_
    PCM_RESOURCE_LIST
    CreateWdmList(
        __in __drv_strictTypeMatch(__drv_typeExpr) POOL_TYPE PoolType = PagedPool
        );
 
    ULONG
    GetCount(
        VOID
        );
 
    PCM_PARTIAL_RESOURCE_DESCRIPTOR
    GetDescriptor(
        __in ULONG Index
        );
 
#if (FX_CORE_MODE == FX_CORE_USER_MODE)
 
    //
    // Lock functions used internally
    //
    __inline
    void
#pragma prefast(suppress:__WARNING_UNEXPECTED_IRQL_CHANGE, "UM has no IRQL")
    LockResourceTable(
        )
    {
        KIRQL oldIrql;
 
        m_ResourceTableLock.Acquire(&oldIrql);
 
        UNREFERENCED_PARAMETER(oldIrql);
    }
 
    __inline
    void
#pragma prefast(suppress:__WARNING_UNEXPECTED_IRQL_CHANGE, "UM has no IRQL")
    UnlockResourceTable(
        )
    {
        m_ResourceTableLock.Release(PASSIVE_LEVEL);
    }
 
    NTSTATUS
    BuildRegisterResourceTable(
        VOID
        );
 
    NTSTATUS
    BuildPortResourceTable(
        VOID
        );
 
    VOID
    UpdateRegisterResourceEntryLocked(
        __in FxRegisterResourceInfo* Entry,
        __in PVOID SystemMappedAddress,
        __in SIZE_T NumberOfBytes,
        __in PVOID UsermodeMappedAddress
        );
 
    VOID
    ClearRegisterResourceEntryLocked(
        __in FxRegisterResourceInfo* Entry
        );
 
    HRESULT
    ValidateRegisterPhysicalAddressRange (
        __in PHYSICAL_ADDRESS PhysicalAddress,
        __in SIZE_T Size,
        __out FxRegisterResourceInfo** TableEntry
        );
 
    HRESULT
    ValidateRegisterSystemBaseAddress (
        __in PVOID Address,
        __out PVOID* UsermodeBaseAddress
        );
 
    HRESULT
    ValidateRegisterSystemAddressRange (
        __in PVOID SystemAddress,
        __in SIZE_T Length,
        __out_opt PVOID* UsermodeAddress
        );
 
    HRESULT
    ValidateAndClearMapping(
        __in PVOID Address,
        __in SIZE_T Length
        );
 
    HRESULT
    ValidatePortAddressRange(
        __in PVOID Address,
        __in SIZE_T Length
        );
 
    SIZE_T
    GetResourceLength(
        __in PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor,
        __out_opt PHYSICAL_ADDRESS* Start
        );
 
    HRESULT
    MapIoSpaceWorker(
        __in PHYSICAL_ADDRESS PhysicalAddress,
        __in SIZE_T NumberOfBytes,
        __in MEMORY_CACHING_TYPE  CacheType,
        __deref_out VOID** PseudoBaseAddress
        );
 
    VOID
    ValidateResourceUnmap(
        VOID
        );
 
    VOID
    DeleteRegisterResourceTable(
        VOID
        )
    {
        LockResourceTable();
        if (m_RegisterResourceTable != NULL) {
            delete [] m_RegisterResourceTable;
            m_RegisterResourceTable = NULL;
            m_RegisterResourceTableSizeCe = 0;
        }
        UnlockResourceTable();
    }
 
    VOID
    DeletePortResourceTable(
        VOID
        )
    {
        LockResourceTable();
        if (m_PortResourceTable != NULL) {
            delete [] m_PortResourceTable;
            m_PortResourceTable = NULL;
            m_PortResourceTableSizeCe = 0;
        }
        UnlockResourceTable();
    }
 
    _Must_inspect_result_
    NTSTATUS
    CheckForConnectionResources(
        VOID
        );
 
    BOOLEAN
    HasConnectionResources(
        VOID
        )
    {
        return m_HasConnectionResources;
    }
 
#endif // FX_CORE_USER_MODE
 
};
 
class FxIoResReqList : public FxResourceCollection {
protected:
    FxIoResReqList(
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in UCHAR AccessFlags = FxResourceNoAccess
        ) :
        FxResourceCollection(FxDriverGlobals,
                             FX_TYPE_IO_RES_REQ_LIST,
                             sizeof(FxIoResReqList),
                             AccessFlags),
        m_SlotNumber(0), m_InterfaceType(Internal)
    {
        m_AccessFlags = AccessFlags;
    }
 
public:
 
    static
    _Must_inspect_result_
    NTSTATUS
    _CreateAndInit(
        __in FxIoResReqList** ResourceReqList,
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in_opt PWDF_OBJECT_ATTRIBUTES ListAttributes,
        __in UCHAR AccessFlags
        )
    {
        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;
    }
 
    WDFIORESREQLIST
    GetHandle(
        VOID
        )
    {
        return (WDFIORESREQLIST) GetObjectHandle();
    }
 
    static
    _Must_inspect_result_
    FxIoResReqList*
    _CreateFromWdmList(
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in PIO_RESOURCE_REQUIREMENTS_LIST WdmRequirementsList,
        __in UCHAR AccessFlags
        );
 
    _Must_inspect_result_
    PIO_RESOURCE_REQUIREMENTS_LIST
    CreateWdmList(
        VOID
        );
 
public:
    ULONG m_SlotNumber;
 
    INTERFACE_TYPE m_InterfaceType;
};
 
class FxIoResList : public FxResourceCollection {
public:
    FxIoResList(
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in FxIoResReqList* RequirementsList
        ) :
        FxResourceCollection(FxDriverGlobals, FX_TYPE_IO_RES_LIST, sizeof(FxIoResList)),
        m_OwningList(RequirementsList)
    {
        m_AccessFlags = RequirementsList->m_AccessFlags;
    }
 
    WDFIORESLIST
    GetHandle(
        VOID
        )
    {
        return (WDFIORESLIST) GetObjectHandle();
    }
 
    _Must_inspect_result_
    NTSTATUS
    BuildFromWdmList(
        __deref_in PIO_RESOURCE_LIST* WdmResourceList
        );
 
public:
    FxIoResReqList* m_OwningList;
};
 
#endif // _FXRESOURCE_H_