#include <fxdriver.hpp>

Inheritance diagram for FxDriver:

[legend]

Collaboration diagram for FxDriver:

[legend]

Public Member Functions
	FxDriver (__in MdDriverObject DriverObject, __in PWDF_DRIVER_CONFIG DriverConfig, __in PFX_DRIVER_GLOBALS FxDriverGlobals)

	~FxDriver ()

_Must_inspect_result_ NTSTATUS	AllocateDriverObjectExtensionAndStoreFxDriver (VOID)

__inline WDFDRIVER	GetHandle (VOID)

_Must_inspect_result_ NTSTATUS	AddDevice (__in MdDeviceObject PhysicalDeviceObject)

VOID	InitializeInternal (VOID)

_Must_inspect_result_ FxString *	GetRegistryPath (VOID)

PUNICODE_STRING	GetRegistryPathUnicodeString (VOID)

__inline MdDriverObject	GetDriverObject (VOID)

_Must_inspect_result_ NTSTATUS	Initialize (__in PCUNICODE_STRING RegistryPath, __in PWDF_DRIVER_CONFIG Config, __in_opt PWDF_OBJECT_ATTRIBUTES DriverAttributes)

VOID	ConfigureConstraints (__in_opt PWDF_OBJECT_ATTRIBUTES DriverAttributes)

virtual VOID	GetConstraints (__out WDF_EXECUTION_LEVEL ExecutionLevel, __out WDF_SYNCHRONIZATION_SCOPE SynchronizationScope)

virtual FxCallbackLock *	GetCallbackLockPtr (__deref_out FxObject **LockObject)

virtual NTSTATUS	QueryInterface (__inout FxQueryInterfaceParams *Params)

virtual VOID	DeleteObject (VOID)

virtual BOOLEAN	Dispose (VOID)

__inline FxDisposeList *	GetDisposeList ()

__inline PFN_WDF_DRIVER_DEVICE_ADD	GetDriverDeviceAddMethod ()

VOID	SetDriverObjectFlag (_In_ FxDriverObjectUmFlags Flag)

BOOLEAN	IsDriverObjectFlagSet (_In_ FxDriverObjectUmFlags Flag)

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 IFxHasCallbacks
virtual VOID	GetConstraints (__out WDF_EXECUTION_LEVEL ExecutionLevel, __out WDF_SYNCHRONIZATION_SCOPE SynchronizationScope)=0

virtual _Must_inspect_result_ FxCallbackLock *	GetCallbackLockPtr (__out_opt FxObject **LockObject)=0

Static Public Member Functions
static VOID	_InitializeDriverName (__in PFX_DRIVER_GLOBALS Globals, __in PCUNICODE_STRING RegistryPath)

static VOID	_InitializeTag (__in PFX_DRIVER_GLOBALS Globals, __in PWDF_DRIVER_CONFIG Config)

static FxDriver *	GetFxDriver (__in MdDriverObject DriverObject)

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
FxDriverUnload	m_DriverUnload

Static Public Attributes
static MdDriverUnloadType	Unload

Static Private Attributes
static MdDriverAddDeviceType	AddDevice

Friends
class	FxDevice

class	FxPackage

class	FxWmiIrpHandler

Additional Inherited Members
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)

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

};

Detailed Description

Definition at line 54 of file fxdriver.hpp.

Constructor & Destructor Documentation

◆ FxDriver()

FxDriver::FxDriver	(	__in MdDriverObject	DriverObject,
		__in PWDF_DRIVER_CONFIG	DriverConfig,
		__in PFX_DRIVER_GLOBALS	FxDriverGlobals
	)

Definition at line 33 of file fxdriver.cpp.

      :
    FxNonPagedObject(FX_TYPE_DRIVER, sizeof(FxDriver), FxDriverGlobals),
    m_DriverObject(ArgDriverObject),
    m_CallbackMutexLock(FxDriverGlobals)
{
    RtlInitUnicodeString(&m_RegistryPath, NULL);
 
 
 
 
 
 
#if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
    m_ExecutionLevel = WdfExecutionLevelDispatch;
#else
    m_ExecutionLevel = WdfExecutionLevelPassive;
#endif
 
    m_SynchronizationScope = WdfSynchronizationScopeNone;
 
    m_CallbackLockPtr = NULL;
    m_CallbackLockObjectPtr = NULL;
 
    m_DisposeList = NULL;
 
    //
    // These are initialized up front so that sub objects
    // can have the right configuration
    //
    WDF_DRIVER_CONFIG_INIT(&m_Config, NULL);
 
    // Only copy the smallest of what is specified and our size
    RtlCopyMemory(&m_Config, DriverConfig, min(sizeof(m_Config), DriverConfig->Size) );
 
    m_DebuggerConnected = FALSE;
 
#if FX_IS_USER_MODE
    m_DriverParametersKey = NULL;
#endif
}

◆ ~FxDriver()

FxDriver::~FxDriver ( )

Definition at line 78 of file fxdriver.cpp.

{
    // Make it always present right now even on free builds
    if (IsDisposed() == FALSE) {
        DoTraceLevelMessage(
            GetDriverGlobals(), TRACE_LEVEL_FATAL, TRACINGDRIVER,
            "FxDriver 0x%p not disposed: this maybe a driver reference count "
            "problem with WDFDRIVER 0x%p", this, GetObjectHandleUnchecked());
 
        FxVerifierBugCheck(GetDriverGlobals(),
                           WDF_OBJECT_ERROR,
                           (ULONG_PTR) GetObjectHandleUnchecked(),
                           (ULONG_PTR) this);
    }
 
    //
    // Free the memory for the registry path if required.
    //
    if (m_RegistryPath.Buffer) {
        FxPoolFree(m_RegistryPath.Buffer);
    }
 
    if (m_DisposeList != NULL) {
        m_DisposeList->DeleteObject();
    }
 
#if FX_IS_USER_MODE
    //
    // Close the R/W handle to the driver's service parameters key
    // that we opened during Initialize.
    //
    if (m_DriverParametersKey != NULL) {
        NTSTATUS status = FxRegKey::_Close(m_DriverParametersKey);
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(GetDriverGlobals(), TRACE_LEVEL_ERROR, TRACINGDRIVER,
                                "Cannot close Driver Parameters key %!STATUS!",
                                status);
        }
        m_DriverParametersKey = NULL;
    }
 
    //
    // The host-created driver object holds a reference to this
    // FxDriver object. Clear it, since this object was deleted.
    //
    ClearDriverObjectFxDriver();
#endif
}

Member Function Documentation

◆ _InitializeDriverName()

FxDriver::_InitializeDriverName	(	__in PFX_DRIVER_GLOBALS	Globals,
		__in PCUNICODE_STRING	RegistryPath
	)

static

Definition at line 180 of file fxdriver.cpp.

{
    PWCHAR pCur, pBegin, pEnd;
 
    RtlZeroMemory(&FxDriverGlobals->Public.DriverName[0],
                  sizeof(FxDriverGlobals->Public.DriverName) );
 
    if (RegistryPath == NULL) {
        return;
    }
 
    pBegin = RegistryPath->Buffer;
 
    //
    // pEnd is one past the end of the string, while pCur is a pointer to the
    // last character of the string.  We will decrement pCur down towards the
    // beginning of the string.
    //
    pEnd = pBegin + (RegistryPath->Length / sizeof(WCHAR));
    pCur = pEnd - 1;
 
    for ( ; *pCur != L'\\' && pCur != pBegin; pCur--) {
        DO_NOTHING();
    }
 
    if (pCur != pBegin && *pCur == L'\\') {
        size_t regLen;
        ULONG i;
 
        pCur++;
 
        //
        // Can't use wcslen becuase this is a UNICODE_STRING which means that it
        // does not necessarily have a terminating NULL in the buffer.
        //
        regLen = pEnd - pCur;
        if (regLen > WDF_DRIVER_GLOBALS_NAME_LEN-1) {
            regLen = WDF_DRIVER_GLOBALS_NAME_LEN-1;
        }
 
 
        for (i = 0; i < regLen; i++) {
            FxDriverGlobals->Public.DriverName[i] = (CHAR) pCur[i];
        }
    }
    else {
        NTSTATUS status;
 
#if FX_CORE_MODE==FX_CORE_KERNEL_MODE
        status = RtlStringCbCopyA(FxDriverGlobals->Public.DriverName,
                                  sizeof(FxDriverGlobals->Public.DriverName),
                                  "WDF");
#else // USER_MODE
        HRESULT hr;
        hr = StringCbCopyA(FxDriverGlobals->Public.DriverName,
                           sizeof(FxDriverGlobals->Public.DriverName),
                           "WDF");
        if (HRESULT_FACILITY(hr) == FACILITY_WIN32) {
            status = WinErrorToNtStatus(HRESULT_CODE(hr));
        }
        else {
            status = SUCCEEDED(hr) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
        }
#endif
 
        UNREFERENCED_PARAMETER(status);
        ASSERT(NT_SUCCESS(status));
    }
}

◆ _InitializeTag()

VOID FxDriver::_InitializeTag	(	__in PFX_DRIVER_GLOBALS	Globals,
		__in PWDF_DRIVER_CONFIG	Config
	)

static

Definition at line 266 of file fxdriver.cpp.

{
    PCHAR  pBegin;
    size_t length;
 
    UNREFERENCED_PARAMETER(Config);
 
    length = strlen(FxDriverGlobals->Public.DriverName);
    pBegin = &FxDriverGlobals->Public.DriverName[0];
 
    if (length >= 3) {
        //
        // If the driver name begins with "WDF" (case insensitive), start after
        // "WDF"
        //
        if ((pBegin[0] == 'w' || pBegin[0] == 'W') &&
            (pBegin[1] == 'd' || pBegin[1] == 'D') &&
            (pBegin[2] == 'f' || pBegin[2] == 'F')) {
            length -=3;
            pBegin += 3;
        }
    }
 
    if (length <= 2) {
        //
        // 2 or less characters is not a unique enough tag, just use the default
        // tag.
        //
        FxDriverGlobals->Tag = FX_TAG;
    }
    else {
 
        if (length > sizeof(ULONG)) {
            length = sizeof(ULONG);
        }
 
        //
        // This copies the bytes in the right order (so that they appear correct
        // when dumped as a sequence of chars)
        //
        RtlCopyMemory(&FxDriverGlobals->Tag,
                      pBegin,
                      length);
 
        FxDriverGlobals->Public.DriverTag = FxDriverGlobals->Tag;
    }
}

◆ AddDevice()

_Must_inspect_result_ NTSTATUS FxDriver::AddDevice ( __in MdDeviceObject PhysicalDeviceObject )

◆ AllocateDriverObjectExtensionAndStoreFxDriver()

_Must_inspect_result_ NTSTATUS FxDriver::AllocateDriverObjectExtensionAndStoreFxDriver ( VOID )

Definition at line 130 of file fxdriverkm.cpp.

{
    NTSTATUS status;
    FxDriver** ppDriver;
 
    //
    // Prefast is much happier if we take the size of the type rather then
    // the size of the variable.
    //
    status = Mx::MxAllocateDriverObjectExtension( m_DriverObject.GetObject(),
                                                  FX_DRIVER_ID,
                                                  sizeof(FxDriver**),
                                                  (PVOID*)&ppDriver);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // If we succeeded in creating the driver object extension,
    // then store our FxDriver pointer in the DriverObjectExtension.
    //
    *ppDriver = this;
 
    return STATUS_SUCCESS;
}

Referenced by Initialize().

◆ ConfigureConstraints()

VOID FxDriver::ConfigureConstraints ( __in_opt PWDF_OBJECT_ATTRIBUTES DriverAttributes )

Definition at line 564 of file fxdriver.cpp.

{
    BOOLEAN automaticLockingRequired;
 
    automaticLockingRequired = FALSE;
 
    // Initialize the mutex lock
    m_CallbackMutexLock.Initialize(this);
 
 
 
 
 
 
 
 
 
    MarkPassiveCallbacks(ObjectDoNotLock);
 
    m_CallbackLockPtr = &m_CallbackMutexLock;
    m_CallbackLockObjectPtr = this;
 
    //
    // Use the caller supplied scope and level only if they are not
    // InheritFromParent.
    //
    if (DriverAttributes != NULL) {
 
        if (DriverAttributes->ExecutionLevel !=
                WdfExecutionLevelInheritFromParent) {
            m_ExecutionLevel = DriverAttributes->ExecutionLevel;
        }
 
        if (DriverAttributes->SynchronizationScope !=
                WdfSynchronizationScopeInheritFromParent) {
            m_SynchronizationScope = DriverAttributes->SynchronizationScope;
        }
    }
 
    //
    // If the driver asks for any synchronization, we synchronize the
    // WDFDRIVER object's own callbacks as well.
    //
    // (No option to extend synchronization for regular operations
    //  across all WDFDEVICE objects)
    //
    if (m_SynchronizationScope == WdfSynchronizationScopeDevice ||
        m_SynchronizationScope == WdfSynchronizationScopeQueue) {
 
        automaticLockingRequired = TRUE;
    }
 
    //
    // No FxDriver events are delivered from a thread that is
    // not already at PASSIVE_LEVEL, so we don't need to
    // allocate an FxSystemWorkItem if the execution level
    // constraint is WdfExecutionLevelPassive.
    //
    // If any events are added FxDriver that could occur on a thread
    // that is above PASSIVE_LEVEL, then an FxSystemWorkItem would
    // need to be allocated to deliver those events similar to the
    // code in FxIoQueue.
    //
 
    //
    // Configure FxDriver event callback locks
    //
    if (automaticLockingRequired) {
        m_DriverDeviceAdd.SetCallbackLockPtr(m_CallbackLockPtr);
    }
    else {
        m_DriverDeviceAdd.SetCallbackLockPtr(NULL);
    }
}

Referenced by Initialize().

◆ DeleteObject()

virtual VOID FxDriver::DeleteObject ( VOID )

inlinevirtual

Reimplemented from FxObject.

Definition at line 332 of file fxdriver.hpp.

    {
        //
        // If diposed at > PASSIVE, we will cause a deadlock in FxDriver::Dispose
        // when we call into  the dispose list to wait for empty when we are in
        // the context of the dispose list's work item.
        //
        ASSERT(Mx::MxGetCurrentIrql() == PASSIVE_LEVEL);
 
        FxNonPagedObject::DeleteObject(); // __super call
    }

Referenced by FxLibraryCommonUnregisterClient().

◆ Dispose()

BOOLEAN FxDriver::Dispose ( VOID )

virtual

Reimplemented from FxObject.

Definition at line 128 of file fxdriver.cpp.

{
    if (m_DisposeList != NULL) {
        m_DisposeList->WaitForEmpty();
    }
 
    return FxNonPagedObject::Dispose(); // __super call
}

◆ GetCallbackLockPtr()

virtual FxCallbackLock * FxDriver::GetCallbackLockPtr ( __deref_out FxObject ** LockObject )

inlinevirtual

Definition at line 298 of file fxdriver.hpp.

          {
 
        if (LockObject != NULL) {
            *LockObject = m_CallbackLockObjectPtr;
        }
 
        return m_CallbackLockPtr;
    }

◆ GetConstraints()

virtual VOID FxDriver::GetConstraints	(	__out WDF_EXECUTION_LEVEL *	ExecutionLevel,
		__out WDF_SYNCHRONIZATION_SCOPE *	SynchronizationScope
	)

inlinevirtual

Implements IFxHasCallbacks.

Definition at line 282 of file fxdriver.hpp.

          {
 
        if (ExecutionLevel != NULL) {
            *ExecutionLevel = m_ExecutionLevel;
        }
 
        if (SynchronizationScope != NULL) {
            *SynchronizationScope = m_SynchronizationScope;
        }
    }

Referenced by FxDeviceBase::ConfigureConstraints().

◆ GetDisposeList()

__inline FxDisposeList * FxDriver::GetDisposeList ( )

inline

Definition at line 354 of file fxdriver.hpp.

    {
        return m_DisposeList;
    }

Referenced by FxObject::FinalRelease(), and FxObject::QueueDeferredDisposeLocked().

◆ GetDriverDeviceAddMethod()

__inline PFN_WDF_DRIVER_DEVICE_ADD FxDriver::GetDriverDeviceAddMethod ( )

inline

Definition at line 362 of file fxdriver.hpp.

    {
        return m_DriverDeviceAdd.Method;
    }

Referenced by __drv_maxIRQL(), PerfEvtDeviceD0EntryStart(), PerfEvtDeviceD0ExitStart(), PerfEvtDevicePrepareHardwareStart(), PerfEvtDeviceReleaseHardwareStart(), PerfEvtIoStopStart(), PerfEvtIoStopStop(), PerfIoComplete(), PerfIoStart(), PerformanceAnalysisPowerProcess(), and PerformanceGetDriverDeviceAdd().

◆ GetDriverObject()

__inline MdDriverObject FxDriver::GetDriverObject ( VOID )

inline

Definition at line 252 of file fxdriver.hpp.

    {
        return m_DriverObject.GetObject();
    }

Referenced by FxMessageDispatch::GetDriverObject(), GetIoMgrObjectForWorkItemAllocation(), FxWorkItem::Initialize(), FxWorkItemEventQueue::QueueWorkItem(), FxIoTargetRemote::RegisterForPnpNotification(), and WdfDriverMiniportUnload().

◆ GetFxDriver()

FxDriver * FxDriver::GetFxDriver ( __in MdDriverObject DriverObject )

static

Definition at line 159 of file fxdriverkm.cpp.

{
    FxDriver* objExt;
    objExt = *(FxDriver **)Mx::MxGetDriverObjectExtension(DriverObject,
                                                       FX_DRIVER_ID);
    ASSERT(objExt != NULL);
 
    return objExt;
}

◆ GetHandle()

__inline WDFDRIVER FxDriver::GetHandle ( VOID )

inline

Definition at line 202 of file fxdriver.hpp.

    {
        return (WDFDRIVER) GetObjectHandle();
    }

Referenced by FxPkgGeneral::ConfigureConstraints(), FxPkgGeneral::ConfigureFileObjectClass(), and FxPkgGeneral::OnCreate().

◆ GetRegistryPath()

_Must_inspect_result_ FxString * FxDriver::GetRegistryPath ( VOID )

Definition at line 539 of file fxdriver.cpp.

{
    FxString *pString;
 
    pString = new(GetDriverGlobals(), WDF_NO_OBJECT_ATTRIBUTES)
        FxString(GetDriverGlobals());
 
    if (pString != NULL) {
        NTSTATUS status;
 
        status = pString->Assign(m_RegistryPath.Buffer);
 
        if (!NT_SUCCESS(status)) {
            pString->Release();
            pString = NULL;
        }
    }
 
    return pString;
}

◆ GetRegistryPathUnicodeString()

PUNICODE_STRING FxDriver::GetRegistryPathUnicodeString ( VOID )

inline

Definition at line 243 of file fxdriver.hpp.

    {
        return &m_RegistryPath;
    }

Referenced by FxWmiIrpHandler::_RegInfo(), and if().

◆ Initialize()

_Must_inspect_result_ NTSTATUS FxDriver::Initialize	(	__in PCUNICODE_STRING	RegistryPath,
		__in PWDF_DRIVER_CONFIG	Config,
		__in_opt PWDF_OBJECT_ATTRIBUTES	DriverAttributes
	)

Definition at line 334 of file fxdriver.cpp.

{
    PFX_DRIVER_GLOBALS FxDriverGlobals = GetDriverGlobals();
    NTSTATUS status;
 
    // WDFDRIVER can not be deleted by the device driver
    MarkNoDeleteDDI();
 
    MarkDisposeOverride(ObjectDoNotLock);
 
    //
    // Configure Constraints
    //
    ConfigureConstraints(DriverAttributes);
 
    if (m_DriverObject.GetObject() == NULL) {
        return STATUS_UNSUCCESSFUL;
    }
 
    // Allocate FxDisposeList
    status = FxDisposeList::_Create(FxDriverGlobals, m_DriverObject.GetObject(), &m_DisposeList);
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Store FxDriver in Driver object extension
    //
    status = AllocateDriverObjectExtensionAndStoreFxDriver();
    if (!NT_SUCCESS(status)) {
        return status;
    }
 
    //
    // Store away the callback functions.
    //
    if ((Config->DriverInitFlags & WdfDriverInitNoDispatchOverride) == 0) {
        //
        // Caller doesn't want to override the dispatch table.  That
        // means that they want to create everything and still be in
        // control (or at least the port driver will take over)
        //
        m_DriverDeviceAdd.Method  = Config->EvtDriverDeviceAdd;
        m_DriverUnload.Method     = Config->EvtDriverUnload;
    }
 
    if (ArgRegistryPath != NULL) {
        USHORT length;
 
        length = ArgRegistryPath->Length + sizeof(UNICODE_NULL);
 
        m_RegistryPath.Length = ArgRegistryPath->Length;
        m_RegistryPath.MaximumLength = length;
        m_RegistryPath.Buffer = (PWSTR) FxPoolAllocate(
            GetDriverGlobals(), PagedPool, length);
 
        if (m_RegistryPath.Buffer != NULL) {
            RtlCopyMemory(m_RegistryPath.Buffer,
                          ArgRegistryPath->Buffer,
                          ArgRegistryPath->Length);
 
            //
            // other parts of WDF assumes m_RegistryPath.Buffer is
            // a null terminated string.  make sure it is.
            //
            m_RegistryPath.Buffer[length/sizeof(WCHAR)- 1] = UNICODE_NULL;
        }
        else {
            //
            // We failed to allocate space for the registry path
            // so set the length to 0.
            //
            m_RegistryPath.Length = 0;
            m_RegistryPath.MaximumLength = 0;
 
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    if (NT_SUCCESS(status)) {
        if ((Config->DriverInitFlags & WdfDriverInitNoDispatchOverride) == 0) {
            UCHAR i;
 
            //
            // Set up dispatch routines.
            //
            if (Config->DriverInitFlags & WdfDriverInitNonPnpDriver) {
                //
                // NT4 style drivers must clear the AddDevice field in the
                // driver object so that they can be unloaded while still
                // having device objects around.
                //
                // If AddDevice is set, NT considers the driver a pnp driver
                // and will not allow net stop to unload the driver.
                //
                m_DriverObject.SetDriverExtensionAddDevice(NULL);
 
                //
                // Unload for an NT4 driver is still optional if the driver
                // does not want to be stopped (through net stop for
                // instance).
                //
                if (Config->EvtDriverUnload != NULL) {
                    m_DriverObject.SetDriverUnload(Unload);
                }
                else {
                    m_DriverObject.SetDriverUnload(NULL);
                }
 
            }
            else {
                //
                // PnP driver, set our routines up
                //
                m_DriverObject.SetDriverExtensionAddDevice(AddDevice);
                m_DriverObject.SetDriverUnload(Unload);
            }
 
            //
            // For any major control code that we use a remove lock, the
            // following locations must be updated:
            //
            // 1)  FxDevice::_RequiresRemLock() which decides if the remlock
            //          is required
            // 2)  FxDefaultIrpHandler::Dispatch might need to be changed if
            //          there is catchall generic post processing that must be done
            // 3)  Whereever the major code irp handler completes the irp or
            //          sends it down the stack.  A good design would have all
            //          spots in the irp handler where this is done to call a
            //          common function.
            //
            WDFCASSERT(IRP_MN_REMOVE_DEVICE != 0x0);
 
#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
            for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) {
                if (FxDevice::_RequiresRemLock(i, 0x0) == FxDeviceRemLockNotRequired) {
                    m_DriverObject.SetMajorFunction(i, FxDevice::Dispatch);
                }
                else {
                    m_DriverObject.SetMajorFunction(i, FxDevice::DispatchWithLock);
                }
            }
#else // USER_MODE
            for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) {
                if (FxDevice::_RequiresRemLock(i, 0x0) == FxDeviceRemLockNotRequired) {
                    m_DriverObject.SetMajorFunction(i, FxDevice::DispatchUm);
                }
                else {
                    m_DriverObject.SetMajorFunction(i, FxDevice::DispatchWithLockUm);
                }
            }
#endif
        }
 
        //
        // Determine if the debugger is connected.
        //
#if ((FX_CORE_MODE)==(FX_CORE_KERNEL_MODE))
        if (KD_DEBUGGER_ENABLED == TRUE && KD_DEBUGGER_NOT_PRESENT == FALSE) {
            m_DebuggerConnected = TRUE;
        }
#endif
 
        //
        // Log this notable event after tracing has been initialized.
        //
 
 
 
 
 
 
        if ((Config->DriverInitFlags & WdfDriverInitNonPnpDriver) &&
            Config->EvtDriverUnload == NULL) {
 
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_INFORMATION, TRACINGDRIVER,
                "Driver Object %p, reg path %wZ cannot be "
                "unloaded, no DriverUnload routine specified",
                m_DriverObject.GetObject(), &m_RegistryPath);
        }
 
#if FX_IS_USER_MODE
        //
        // Open a R/W handle to the driver's service parameters key
        //
        status = OpenParametersKey();
        if (!NT_SUCCESS(status)) {
            DoTraceLevelMessage(
                FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDRIVER,
                "Cannot open Driver Parameters key %!STATUS!",
                status);
        }
#endif
    }
 
    return status;
}

Referenced by if().

◆ InitializeInternal()

VOID FxDriver::InitializeInternal ( VOID )

◆ IsDriverObjectFlagSet()

BOOLEAN FxDriver::IsDriverObjectFlagSet ( _In_ FxDriverObjectUmFlags Flag )

inline

Definition at line 411 of file fxdriver.hpp.

    {
        return m_DriverObject.IsDriverObjectFlagSet(Flag);
    }

◆ QueryInterface()

virtual NTSTATUS FxDriver::QueryInterface ( __inout FxQueryInterfaceParams * Params )

inlinevirtual

Definition at line 314 of file fxdriver.hpp.

    {
        switch (Params->Type) {
        case FX_TYPE_DRIVER:
            *Params->Object = (FxDriver*) this;
            break;
 
        default:
            return FxNonPagedObject::QueryInterface(Params); // __super call
        }
 
        return STATUS_SUCCESS;
    }

◆ SetDriverObjectFlag()

VOID FxDriver::SetDriverObjectFlag ( _In_ FxDriverObjectUmFlags Flag )

inline

Definition at line 403 of file fxdriver.hpp.

    {
        m_DriverObject.SetDriverObjectFlag(Flag);
    }

Friends And Related Function Documentation

◆ FxDevice

friend class FxDevice

friend

Definition at line 56 of file fxdriver.hpp.

◆ FxPackage

friend class FxPackage

friend

Definition at line 57 of file fxdriver.hpp.

◆ FxWmiIrpHandler

friend class FxWmiIrpHandler

friend

Definition at line 58 of file fxdriver.hpp.

Member Data Documentation

◆ AddDevice

_Must_inspect_result_ NTSTATUS FxDriver::AddDevice

staticprivate

Definition at line 125 of file fxdriver.hpp.

Referenced by Initialize().

◆ m_CallbackLockObjectPtr

FxObject* FxDriver::m_CallbackLockObjectPtr

private

Definition at line 101 of file fxdriver.hpp.

Referenced by ConfigureConstraints(), FxDriver(), and GetCallbackLockPtr().

◆ m_CallbackLockPtr

FxCallbackLock* FxDriver::m_CallbackLockPtr

private

Definition at line 100 of file fxdriver.hpp.

Referenced by ConfigureConstraints(), FxDriver(), and GetCallbackLockPtr().

◆ m_CallbackMutexLock

FxCallbackMutexLock FxDriver::m_CallbackMutexLock

private

Definition at line 93 of file fxdriver.hpp.

Referenced by ConfigureConstraints().

◆ m_Config

WDF_DRIVER_CONFIG FxDriver::m_Config

private

Definition at line 106 of file fxdriver.hpp.

Referenced by FxDriver().

◆ m_DebuggerConnected

BOOLEAN FxDriver::m_DebuggerConnected

private

Definition at line 65 of file fxdriver.hpp.

Referenced by FxDriver(), and Initialize().

◆ m_DisposeList

FxDisposeList* FxDriver::m_DisposeList

private

Definition at line 111 of file fxdriver.hpp.

Referenced by Dispose(), FxDriver(), GetDisposeList(), Initialize(), and ~FxDriver().

◆ m_DriverDeviceAdd

FxDriverDeviceAdd FxDriver::m_DriverDeviceAdd

private

Definition at line 70 of file fxdriver.hpp.

Referenced by ConfigureConstraints(), GetDriverDeviceAddMethod(), and Initialize().

◆ m_DriverObject

MxDriverObject FxDriver::m_DriverObject

private

Definition at line 62 of file fxdriver.hpp.

Referenced by AllocateDriverObjectExtensionAndStoreFxDriver(), FxDevice::CreateDevice(), GetDriverObject(), Initialize(), IsDriverObjectFlagSet(), and SetDriverObjectFlag().

◆ m_DriverUnload

FxDriverUnload FxDriver::m_DriverUnload

Definition at line 130 of file fxdriver.hpp.

Referenced by Initialize().

◆ m_ExecutionLevel

WDF_EXECUTION_LEVEL FxDriver::m_ExecutionLevel

private

Definition at line 77 of file fxdriver.hpp.

Referenced by ConfigureConstraints(), FxDriver(), and GetConstraints().

◆ m_RegistryPath

UNICODE_STRING FxDriver::m_RegistryPath

private

Definition at line 63 of file fxdriver.hpp.

Referenced by FxDriver(), GetRegistryPath(), GetRegistryPathUnicodeString(), Initialize(), and ~FxDriver().

◆ m_SynchronizationScope

WDF_SYNCHRONIZATION_SCOPE FxDriver::m_SynchronizationScope

private

Definition at line 78 of file fxdriver.hpp.

Referenced by ConfigureConstraints(), FxDriver(), and GetConstraints().

◆ Unload

VOID FxDriver::Unload

static

Definition at line 369 of file fxdriver.hpp.

Referenced by Initialize(), and WdfDriverMiniportUnload().

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

sdk/lib/drivers/wdf/shared/inc/private/common/fxdriver.hpp
sdk/lib/drivers/wdf/shared/core/fxdriver.cpp
sdk/lib/drivers/wdf/shared/core/fxdriverapi.cpp
sdk/lib/drivers/wdf/shared/core/km/fxdriverapikm.cpp
sdk/lib/drivers/wdf/shared/core/km/fxdriverkm.cpp
sdk/lib/drivers/wdf/shared/core/um/fxdriverum.cpp

Private Attributes
MxDriverObject	m_DriverObject

UNICODE_STRING	m_RegistryPath

BOOLEAN	m_DebuggerConnected

FxDriverDeviceAdd	m_DriverDeviceAdd

WDF_EXECUTION_LEVEL	m_ExecutionLevel

WDF_SYNCHRONIZATION_SCOPE	m_SynchronizationScope

FxCallbackMutexLock	m_CallbackMutexLock

FxCallbackLock *	m_CallbackLockPtr

FxObject *	m_CallbackLockObjectPtr

WDF_DRIVER_CONFIG	m_Config

FxDisposeList *	m_DisposeList

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Private Attributes

Static Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ FxDriver()

◆ ~FxDriver()

Member Function Documentation

◆ _InitializeDriverName()

◆ _InitializeTag()

◆ AddDevice()

◆ AllocateDriverObjectExtensionAndStoreFxDriver()

◆ ConfigureConstraints()

◆ DeleteObject()

◆ Dispose()

◆ GetCallbackLockPtr()

◆ GetConstraints()

◆ GetDisposeList()

◆ GetDriverDeviceAddMethod()

◆ GetDriverObject()

◆ GetFxDriver()

◆ GetHandle()

◆ GetRegistryPath()

◆ GetRegistryPathUnicodeString()

◆ Initialize()

◆ InitializeInternal()

◆ IsDriverObjectFlagSet()

◆ QueryInterface()

◆ SetDriverObjectFlag()

Friends And Related Function Documentation

◆ FxDevice

◆ FxPackage

◆ FxWmiIrpHandler

Member Data Documentation

◆ AddDevice

◆ m_CallbackLockObjectPtr

◆ m_CallbackLockPtr

◆ m_CallbackMutexLock

◆ m_Config

◆ m_DebuggerConnected

◆ m_DisposeList

◆ m_DriverDeviceAdd

◆ m_DriverObject

◆ m_DriverUnload

◆ m_ExecutionLevel

◆ m_RegistryPath

◆ m_SynchronizationScope

◆ Unload