#include <ntddk.h>

Include dependency graph for wdfldr.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	_WDF_INTERFACE_HEADER

struct	_WDF_CLASS_VERSION

struct	_WDF_CLASS_BIND_INFO

struct	_WDF_CLASS_LIBRARY_INFO

Typedefs
typedef ULONG	WDF_MAJOR_VERSION

typedef ULONG	WDF_MINOR_VERSION

typedef ULONG	WDF_BUILD_NUMBER

typedef struct _WDF_BIND_INFO *	PWDF_BIND_INFO

typedef struct _WDF_CLASS_BIND_INFO *	PWDF_CLASS_BIND_INFO

typedef struct _WDF_LIBRARY_INFO *	PWDF_LIBRARY_INFO

typedef PVOID	WDF_COMPONENT_GLOBALS

typedef PVOID *	PWDF_COMPONENT_GLOBALS

typedef NTSTATUS(NTAPI *	PWDF_LDR_DIAGNOSTICS_VALUE_BY_NAME_AS_ULONG) (_In_ PUNICODE_STRING ValueName, _Out_ PULONG Value)

typedef NTSTATUS(NTAPI *	PFN_CLASS_LIBRARY_INIT) (VOID)

typedef VOID(NTAPI *	PFN_CLASS_LIBRARY_DEINIT) (VOID)

typedef NTSTATUS(NTAPI *	PFN_CLASS_LIBRARY_BIND_CLIENT) (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _Out_ PWDF_COMPONENT_GLOBALS *Globals)

typedef VOID(NTAPI *	PFN_CLASS_LIBRARY_UNBIND_CLIENT) (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_COMPONENT_GLOBALS *Globals)

typedef NTSTATUS(NTAPI *	PFN_WDF_VERSION_BIND_CLASS) (_In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

typedef NTSTATUS(NTAPI *	PFN_CLIENT_BIND_CLASS) (_In_ PFN_WDF_VERSION_BIND_CLASS BindFunction, _In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

typedef VOID(NTAPI *	PFN_WDF_VERSION_UNBIND_CLASS) (_In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

typedef VOID(NTAPI *	PFN_CLIENT_UNBIND_CLASS) (_In_ PFN_WDF_VERSION_UNBIND_CLASS UnbindFunction, _In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

typedef struct _WDF_INTERFACE_HEADER	WDF_INTERFACE_HEADER

typedef struct _WDF_INTERFACE_HEADER *	PWDF_INTERFACE_HEADER

typedef struct _WDF_CLASS_VERSION	WDF_CLASS_VERSION

typedef struct _WDF_CLASS_VERSION *	PWDF_CLASS_VERSION

typedef struct _WDF_CLASS_BIND_INFO	WDF_CLASS_BIND_INFO

typedef struct _WDF_CLASS_LIBRARY_INFO	WDF_CLASS_LIBRARY_INFO

typedef struct _WDF_CLASS_LIBRARY_INFO *	PWDF_CLASS_LIBRARY_INFO

Functions
NTSTATUS NTAPI	WdfRegisterClassLibrary (_In_ PWDF_CLASS_LIBRARY_INFO ClassLibInfo, _In_ PUNICODE_STRING SourceString, _In_ PUNICODE_STRING ObjectName)
	Register class extension library (e.g., UCX)

NTSTATUS NTAPI	WdfLdrDiagnosticsValueByNameAsULONG (_In_ PUNICODE_STRING ValueName, _Out_ PULONG Value)
	Retrieves an ULONG value from KMDF diagnostics registry key.

NTSTATUS NTAPI	WdfRegisterLibrary (_In_ PWDF_LIBRARY_INFO LibraryInfo, _In_ PUNICODE_STRING ServicePath, _In_ PCUNICODE_STRING LibraryDeviceName)
	Register wdf01000 library.

VOID NTAPI	DllUnload (VOID)

NTSTATUS NTAPI	DllInitialize (_In_ PUNICODE_STRING RegistryPath)

NTSTATUS NTAPI	WdfVersionBind (_In_ PDRIVER_OBJECT DriverObject, _In_ PUNICODE_STRING RegistryPath, _Inout_ PWDF_BIND_INFO BindInfo, _Out_ PWDF_COMPONENT_GLOBALS *ComponentGlobals)
	Bind client driver with framework.

NTSTATUS NTAPI	WdfVersionUnbind (_In_ PUNICODE_STRING RegistryPath, _In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS ComponentGlobals)
	Unbind client driver from framework.

NTSTATUS NTAPI	WdfVersionBindClass (_In_ PWDF_BIND_INFO BindInfo, _Inout_ PWDF_COMPONENT_GLOBALS *Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

VOID NTAPI	WdfVersionUnbindClass (_In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

NTSTATUS NTAPI	WdfLdrQueryInterface (_In_ PWDF_INTERFACE_HEADER LoaderInterface)

Typedef Documentation

◆ PFN_CLASS_LIBRARY_BIND_CLIENT

typedef NTSTATUS(NTAPI * PFN_CLASS_LIBRARY_BIND_CLIENT) (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _Out_ PWDF_COMPONENT_GLOBALS *Globals)

Definition at line 41 of file wdfldr.h.

◆ PFN_CLASS_LIBRARY_DEINIT

typedef VOID(NTAPI * PFN_CLASS_LIBRARY_DEINIT) (VOID)

Definition at line 37 of file wdfldr.h.

◆ PFN_CLASS_LIBRARY_INIT

typedef NTSTATUS(NTAPI * PFN_CLASS_LIBRARY_INIT) (VOID)

Definition at line 33 of file wdfldr.h.

◆ PFN_CLASS_LIBRARY_UNBIND_CLIENT

typedef VOID(NTAPI * PFN_CLASS_LIBRARY_UNBIND_CLIENT) (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_COMPONENT_GLOBALS *Globals)

Definition at line 47 of file wdfldr.h.

◆ PFN_CLIENT_BIND_CLASS

typedef NTSTATUS(NTAPI * PFN_CLIENT_BIND_CLASS) (_In_ PFN_WDF_VERSION_BIND_CLASS BindFunction, _In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

Definition at line 60 of file wdfldr.h.

◆ PFN_CLIENT_UNBIND_CLASS

typedef VOID(NTAPI * PFN_CLIENT_UNBIND_CLASS) (_In_ PFN_WDF_VERSION_UNBIND_CLASS UnbindFunction, _In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

Definition at line 75 of file wdfldr.h.

◆ PFN_WDF_VERSION_BIND_CLASS

typedef NTSTATUS(NTAPI * PFN_WDF_VERSION_BIND_CLASS) (_In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

Definition at line 53 of file wdfldr.h.

◆ PFN_WDF_VERSION_UNBIND_CLASS

typedef VOID(NTAPI * PFN_WDF_VERSION_UNBIND_CLASS) (_In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo)

Definition at line 68 of file wdfldr.h.

◆ PWDF_BIND_INFO

typedef struct _WDF_BIND_INFO* PWDF_BIND_INFO

Definition at line 21 of file wdfldr.h.

◆ PWDF_CLASS_BIND_INFO

typedef struct _WDF_CLASS_BIND_INFO * PWDF_CLASS_BIND_INFO

Definition at line 22 of file wdfldr.h.

◆ PWDF_CLASS_LIBRARY_INFO

typedef struct _WDF_CLASS_LIBRARY_INFO * PWDF_CLASS_LIBRARY_INFO

◆ PWDF_CLASS_VERSION

typedef struct _WDF_CLASS_VERSION * PWDF_CLASS_VERSION

◆ PWDF_COMPONENT_GLOBALS

typedef PVOID * PWDF_COMPONENT_GLOBALS

Definition at line 24 of file wdfldr.h.

◆ PWDF_INTERFACE_HEADER

typedef struct _WDF_INTERFACE_HEADER * PWDF_INTERFACE_HEADER

◆ PWDF_LDR_DIAGNOSTICS_VALUE_BY_NAME_AS_ULONG

typedef NTSTATUS(NTAPI * PWDF_LDR_DIAGNOSTICS_VALUE_BY_NAME_AS_ULONG) (_In_ PUNICODE_STRING ValueName, _Out_ PULONG Value)

Definition at line 27 of file wdfldr.h.

◆ PWDF_LIBRARY_INFO

typedef struct _WDF_LIBRARY_INFO * PWDF_LIBRARY_INFO

Definition at line 23 of file wdfldr.h.

◆ WDF_BUILD_NUMBER

typedef ULONG WDF_BUILD_NUMBER

Definition at line 19 of file wdfldr.h.

◆ WDF_CLASS_BIND_INFO

typedef struct _WDF_CLASS_BIND_INFO WDF_CLASS_BIND_INFO

◆ WDF_CLASS_LIBRARY_INFO

typedef struct _WDF_CLASS_LIBRARY_INFO WDF_CLASS_LIBRARY_INFO

◆ WDF_CLASS_VERSION

typedef struct _WDF_CLASS_VERSION WDF_CLASS_VERSION

◆ WDF_COMPONENT_GLOBALS

typedef PVOID WDF_COMPONENT_GLOBALS

Definition at line 24 of file wdfldr.h.

◆ WDF_INTERFACE_HEADER

typedef struct _WDF_INTERFACE_HEADER WDF_INTERFACE_HEADER

◆ WDF_MAJOR_VERSION

typedef ULONG WDF_MAJOR_VERSION

Definition at line 17 of file wdfldr.h.

◆ WDF_MINOR_VERSION

typedef ULONG WDF_MINOR_VERSION

Definition at line 18 of file wdfldr.h.

Function Documentation

◆ DllInitialize()

NTSTATUS NTAPI DllInitialize ( _In_ PUNICODE_STRING RegistryPath )

Definition at line 105 of file wdfldr.c.

{
    NTSTATUS status;
    UNICODE_STRING dbgPrintOn = RTL_CONSTANT_STRING(L"DbgPrintOn");
    UNICODE_STRING verboseLogging = RTL_CONSTANT_STRING(L"VerboseLogging");
    UNICODE_STRING traceEntry = RTL_CONSTANT_STRING(L"TraceEntry");
    ULONG diagValue = 0;
 
    UNREFERENCED_PARAMETER(RegistryPath);
 
    if (gAlreadyInitialized)
    {
        return STATUS_SUCCESS;
    }
 
    gAlreadyInitialized = TRUE;
    RtlZeroMemory(&WdfLdrGlobals, sizeof(WdfLdrGlobals));
    RtlZeroMemory(&WdfLdrDiags, sizeof(WdfLdrDiags));
 
    InitializeListHead(&WdfLdrGlobals.LoadedModulesList);
    status = ExInitializeResourceLite(&WdfLdrGlobals.LoadedModulesListLock);
    if (!NT_SUCCESS(status))
    {
        DPRINT_ERROR(("ExInitializeResourceLite failed with Status 0x%x\n", status));
        return status;
    }
 
#if 0
    /* Force debugging everything */
    WdfLdrDiags.DiagFlags = DIAGFLAG_ENABLED | DIAGFLAG_VERBOSE_LOGGING |
                            DIAGFLAG_TRACE_FUNCTION_ENTRY | DIAGFLAG_TRACE_FUNCTION_EXIT |
                            DIAGFLAG_LOG_ERRORS | DIAGFLAG_LOG_WARNINGS;
#endif
    status = WdfLdrDiagnosticsValueByNameAsULONG(&dbgPrintOn, &diagValue);
    if (NT_SUCCESS(status) && diagValue != 0)
    {
        WdfLdrDiags.DiagFlags |= DIAGFLAG_ENABLED;
    }
 
    status = WdfLdrDiagnosticsValueByNameAsULONG(&verboseLogging, &diagValue);
    if (NT_SUCCESS(status) && diagValue != 0)
    {
        WdfLdrDiags.DiagFlags |= DIAGFLAG_VERBOSE_LOGGING;
    }
 
    status = WdfLdrDiagnosticsValueByNameAsULONG(&traceEntry, &diagValue);
    if (NT_SUCCESS(status) && diagValue != 0)
    {
        WdfLdrDiags.DiagFlags |= (DIAGFLAG_TRACE_FUNCTION_ENTRY | DIAGFLAG_TRACE_FUNCTION_EXIT);
    }
 
    status = AuxKlibInitialize();
    if (NT_SUCCESS(status))
    {
        RtlGetVersion((POSVERSIONINFOW)&WdfLdrGlobals.OsVersion);
        DPRINT(("Initialized WdfLdr - OS Version %d.%d.%d\n",
                WdfLdrGlobals.OsVersion.dwMajorVersion,
                WdfLdrGlobals.OsVersion.dwMinorVersion,
                WdfLdrGlobals.OsVersion.dwBuildNumber));
    }
    else
    {
        DPRINT_ERROR(("AuxKlibInitialize failed with Status 0x%x\n", status));
        ExDeleteResourceLite(&WdfLdrGlobals.LoadedModulesListLock);
        gAlreadyInitialized = FALSE;
        return status;
    }
 
 
    DPRINT(("WDF Loader initialization completed successfully\n"));
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

◆ DllUnload()

VOID NTAPI DllUnload ( VOID )

Definition at line 29 of file hidclass.c.

{
    return STATUS_SUCCESS;
}

◆ WdfLdrDiagnosticsValueByNameAsULONG()

NTSTATUS NTAPI WdfLdrDiagnosticsValueByNameAsULONG	(	_In_ PUNICODE_STRING	ValueName,
		_Out_ PULONG	Value
	)

Retrieves an ULONG value from KMDF diagnostics registry key.

Definition at line 54 of file wdfldr.c.

{
    HANDLE keyHandle = NULL;
    NTSTATUS status;
 
    if (ValueName == NULL || Value == NULL)
    {
        __DBGPRINT(("ERROR: Invalid Input Parameter\n"));
        return STATUS_INVALID_PARAMETER;
    }
 
    *Value = 0; // for compatibility
 
    if (KeGetCurrentIrql() > PASSIVE_LEVEL)
    {
        __DBGPRINT(("Not at PASSIVE_LEVEL\n"));
        return STATUS_INVALID_PARAMETER;
    }
 
    // open framework diagnostics key
    OBJECT_ATTRIBUTES attributes;
    static UNICODE_STRING diagPath = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Wdf\\Kmdf\\Diagnostics");
 
    InitializeObjectAttributes(&attributes,
                               &diagPath,
                               OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    status = ZwOpenKey(&keyHandle, KEY_QUERY_VALUE, &attributes);
 
    if (NT_SUCCESS(status))
    {
        status = FxLdrQueryUlong(keyHandle, ValueName, Value);
 
        __DBGPRINT(("Status %x, value 0x%x\n", status, *Value));
 
        ZwClose(keyHandle);
    }
    else
    {
        __DBGPRINT(("ERROR: ZwOpenKey failed with Status 0x%x\n", status));
    }
 
    return status;
}

Referenced by DllInitialize(), DriverEntry(), and WdfLdrQueryInterface().

◆ WdfLdrQueryInterface()

NTSTATUS NTAPI WdfLdrQueryInterface ( _In_ PWDF_INTERFACE_HEADER LoaderInterface )

Definition at line 222 of file wdfldr.c.

{
    DPRINT_TRACE_ENTRY();
 
    if (LoaderInterface == NULL)
    {
        DPRINT_ERROR(("LoaderInterface is NULL\n"));
        return STATUS_INVALID_PARAMETER;
    }
 
    if (LoaderInterface->InterfaceType == NULL)
    {
        DPRINT_ERROR(("InterfaceType is NULL\n"));
        return STATUS_INVALID_PARAMETER;
    }
 
    if (IsEqualGUID(LoaderInterface->InterfaceType, &GUID_WDF_LOADER_INTERFACE_STANDARD))
    {
        if (LoaderInterface->InterfaceSize < sizeof(WDF_LOADER_INTERFACE))
        {
            DPRINT_ERROR(("Interface size too small: %u, expected: %u\n",
                         LoaderInterface->InterfaceSize, sizeof(WDF_LOADER_INTERFACE)));
            return STATUS_INVALID_PARAMETER;
        }
 
        PWDF_LOADER_INTERFACE lInterface = (PWDF_LOADER_INTERFACE)LoaderInterface;
 
        lInterface->RegisterLibrary = WdfRegisterLibrary;
        lInterface->VersionBind = WdfVersionBind;
        lInterface->VersionUnbind = WdfVersionUnbind;
        lInterface->DiagnosticsValueByNameAsULONG = WdfLdrDiagnosticsValueByNameAsULONG;
 
        DPRINT_VERBOSE(("Provided standard WDF loader interface\n"));
        return STATUS_SUCCESS;
    }
    else if (IsEqualGUID(LoaderInterface->InterfaceType, &GUID_WDF_LOADER_INTERFACE_DIAGNOSTIC))
    {
        if (LoaderInterface->InterfaceSize < sizeof(WDF_LOADER_INTERFACE_DIAGNOSTIC))
        {
            DPRINT_ERROR(("Diagnostic interface size too small: %u, expected: %u\n",
                         LoaderInterface->InterfaceSize, sizeof(WDF_LOADER_INTERFACE_DIAGNOSTIC)));
            return STATUS_INVALID_PARAMETER;
        }
 
        PWDF_LOADER_INTERFACE_DIAGNOSTIC lInterface =
            (PWDF_LOADER_INTERFACE_DIAGNOSTIC)LoaderInterface;
 
        lInterface->DiagnosticsValueByNameAsULONG = WdfLdrDiagnosticsValueByNameAsULONG;
 
        DPRINT_VERBOSE(("Provided diagnostic interface\n"));
        return STATUS_SUCCESS;
    }
    else if (IsEqualGUID(LoaderInterface->InterfaceType, &GUID_WDF_LOADER_INTERFACE_CLASS_BIND))
    {
        if (LoaderInterface->InterfaceSize < sizeof(WDF_LOADER_INTERFACE_CLASS_BIND))
        {
            DPRINT_ERROR(("Class bind interface size too small: %u, expected: %u\n",
                         LoaderInterface->InterfaceSize, sizeof(WDF_LOADER_INTERFACE_CLASS_BIND)));
 
            return STATUS_INVALID_PARAMETER;
        }
 
        PWDF_LOADER_INTERFACE_CLASS_BIND lInterface =
            (PWDF_LOADER_INTERFACE_CLASS_BIND)LoaderInterface;
 
        lInterface->ClassBind = WdfVersionBindClass;
        lInterface->ClassUnbind = WdfVersionUnbindClass;
 
        DPRINT_VERBOSE(("Provided class bind interface\n"));
        return STATUS_SUCCESS;
    }
 
    DPRINT_ERROR(("Unknown interface type requested\n"));
    DPRINT_TRACE_EXIT();
    return STATUS_NOINTERFACE;
}

◆ WdfRegisterClassLibrary()

NTSTATUS NTAPI WdfRegisterClassLibrary	(	_In_ PWDF_CLASS_LIBRARY_INFO	ClassLibInfo,
		_In_ PUNICODE_STRING	SourceString,
		_In_ PUNICODE_STRING	ObjectName
	)

Register class extension library (e.g., UCX)

See also: http://redplait.blogspot.com/2013/03/ucxfunctionsidc.html

Parameters

ClassLibInfo	Class library information
SourceString	Service name of the class library
ObjectName	Device object name

Returns: STATUS_SUCCESS on success, error code otherwise

Definition at line 696 of file wdfldr.c.

{
    NTSTATUS status;
    PCLASS_MODULE pClassModule;
    PFN_CLASS_LIBRARY_INIT fnClassLibInit;
    PLIBRARY_MODULE libModule;
 
    PAGED_CODE();
 
    status = STATUS_SUCCESS;
    FxLdrAcquireLoadedModuleLock();
 
    // First, try to find an existing class module
    pClassModule = FindClassByServiceNameLocked(SourceString, &libModule);
 
    if (pClassModule)
    {
        /* Another behavior you can observe by running UCX */
        pClassModule->ClassLibraryInfo = ClassLibInfo;
    }
    else
    {
        status = FindModuleByClientService(SourceString, &libModule);
        if (!NT_SUCCESS(status))
        {
            if (WdfLdrDiags.DiagFlags & DIAGFLAG_ENABLED)
            {
                DPRINT_VERBOSE(("No library found for class module %wZ, status 0x%x\n",
                               SourceString, status));
            }
 
            /*
             * This ensures class modules are always searchable through library class lists
             * The behavior here can be observed from UCX
             */
            if (!IsListEmpty(&WdfLdrGlobals.LoadedModulesList))
            {
                PLIST_ENTRY entry = WdfLdrGlobals.LoadedModulesList.Flink;
                libModule = CONTAINING_RECORD(entry, LIBRARY_MODULE, LibraryListEntry);
                DPRINT(("Using default WDF library %wZ for class module %wZ\n",
                       &libModule->ServicePath, SourceString));
            }
            else
            {
                libModule = NULL;
            }
        }
 
        pClassModule = ClassCreate(ClassLibInfo, libModule, SourceString);
        if (pClassModule)
        {
            if (libModule)
                LibraryAddToClassListLocked(libModule, pClassModule);
            ClassAddReference(pClassModule);
        }
    }
    FxLdrReleaseLoadedModuleLock();
 
    if (!pClassModule)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    __DBGPRINT(("Class Library (%p)\n", pClassModule));
 
    status = ClassOpen(pClassModule, ObjectName);
 
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ERROR: ClassOpen(%wZ) failed, status 0x%x\n", ObjectName, status));
        ClassRemoveFromLibraryList(pClassModule);
        return status;
    }
 
    fnClassLibInit = pClassModule->ClassLibraryInfo->ClassLibraryInitialize;
    if (fnClassLibInit)
    {
        status = fnClassLibInit();
        if (!NT_SUCCESS(status))
        {
            __DBGPRINT(("ERROR: WdfRegisterClassLibrary: ClassLibraryInitialize failed, status 0x%x\n", status));
            pClassModule->ClassLibraryInfo = NULL;
            ClassClose(pClassModule);
        }
    }
 
    /* Classes always stay loaded after registration - (UCX, NDIS) */
    return status;
}

◆ WdfRegisterLibrary()

NTSTATUS NTAPI WdfRegisterLibrary	(	_In_ PWDF_LIBRARY_INFO	LibraryInfo,
		_In_ PUNICODE_STRING	ServicePath,
		_In_ PCUNICODE_STRING	LibraryDeviceName
	)

Register wdf01000 library.

Parameters

LibraryInfo	Information about the library being registered
ServicePath	Service path in registry
LibraryDeviceName	KMDF device name

Returns: STATUS_SUCCESS on success, error code otherwise

Definition at line 311 of file wdfldr.c.

{
    NTSTATUS status;
    PLIBRARY_MODULE pLibModule;
 
    PAGED_CODE();
 
    FxLdrAcquireLoadedModuleLock();
    pLibModule = FindLibraryByServicePathLocked(ServicePath);
 
    if (pLibModule != NULL)
    {
        // This happens when a driver which uses KMDF library is loaded before the library itself.
        // In such case, LibraryCreate(NULL, ...) was called in from WdfVersionBind
 
        ASSERT(pLibModule->ImplicitlyLoaded == TRUE);
        ASSERT(pLibModule->LibraryInfo == NULL);
 
        pLibModule->Version = LibraryInfo->Version;
        pLibModule->LibraryInfo = LibraryInfo;
 
        status = GetImageInfo(&pLibModule->ImageName,
                              &pLibModule->ImageAddress,
                              &pLibModule->ImageSize);
        if (!NT_SUCCESS(status))
        {
            __DBGPRINT(("ERROR: GetImageInfo(%wZ) failed with status 0x%x\n",
                        pLibModule->ImageName, status));
        }
    }
    else
    {
        status = LibraryCreate(LibraryInfo, ServicePath, &pLibModule);
    }
 
    // Reference the library while we're working on it
    if (pLibModule)
    {
        InterlockedIncrement(&pLibModule->LibraryRefCount);
    }
 
    FxLdrReleaseLoadedModuleLock();
 
    if (!pLibModule)
    {
        __DBGPRINT(("WdfRegisterLibrary: LibraryCreate(%wZ) failed, status %X\n",
                    ServicePath, status));
        return status;
    }
 
    __DBGPRINT(("Registering library(%p) %wZ\n", pLibModule, &pLibModule->ImageName));
 
    // WdfRegisterLibrary is called from the library itself so we're sure it is loaded
    // Now reference the library's device object
    status = LibraryOpen(pLibModule, LibraryDeviceName);
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ERROR: LibraryOpen(%wZ) failed with status %x\n", LibraryDeviceName, status));
        goto Failure;
    }
 
    // Now call the custom library callback
    status = pLibModule->LibraryInfo->LibraryCommission();
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ERROR: WdfRegisterLibrary: LibraryCommission failed status 0x%X\n", status));
        goto Failure;
    }
 
    // The work is finished
    LibraryDereference(pLibModule);
    return status;
 
Failure:
    // Dereference two times - the library should be cleaned up then
    // Setting LibraryInfo to NULL so ZwUnloadDriver is not called
    pLibModule->LibraryInfo = NULL;
    LibraryDereference(pLibModule);
 
    // If the library was created in WdfVersionBind, it will be dereferenced there
    if (pLibModule->ImplicitlyLoaded)
        LibraryDereference(pLibModule);
    return status;
}

Referenced by DriverEntry(), and WdfLdrQueryInterface().

◆ WdfVersionBind()

NTSTATUS NTAPI WdfVersionBind	(	_In_ PDRIVER_OBJECT	DriverObject,
		_In_ PUNICODE_STRING	ServicePath,
		_Inout_ PWDF_BIND_INFO	BindInfo,
		_Out_ PWDF_COMPONENT_GLOBALS *	ComponentGlobals
	)

Bind client driver with framework.

Parameters

DriverObject	Driver object
ServicePath	Registry service path
BindInfo	Client driver bind information
ComponentGlobals	Client driver global settings

Returns: STATUS_SUCCESS on success, error code otherwise

Definition at line 411 of file wdfldr.c.

{
    NTSTATUS status;
    PLIBRARY_MODULE pLibModule = NULL;
    PCLIENT_MODULE clientModule = NULL;
    UNICODE_STRING libraryServicePath = { 0 };
    CLIENT_INFO clientInfo;
    PVOID context = NULL;
 
    UNREFERENCED_PARAMETER(DriverObject);
    PAGED_CODE();
 
    DPRINT_TRACE_ENTRY();
 
    if (ComponentGlobals == NULL || BindInfo == NULL || BindInfo->FuncTable == NULL)
    {
        DPRINT_ERROR(("Invalid parameters: ComponentGlobals=%p, BindInfo=%p\n",
                     ComponentGlobals, BindInfo));
        status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }
 
    *ComponentGlobals = NULL;
 
    status = ReferenceVersion(BindInfo, &pLibModule);
    if (!NT_SUCCESS(status))
    {
        DPRINT_ERROR(("ReferenceVersion failed with status 0x%x\n", status));
        goto Exit;
    }
 
    DPRINT_VERBOSE(("Referenced library version for %wZ\n", &pLibModule->ServicePath));
 
 
    clientInfo.Size = sizeof(CLIENT_INFO);
    clientInfo.RegistryPath = ServicePath;
 
    status = LibraryLinkInClient(pLibModule, ServicePath, BindInfo, &clientInfo, &clientModule);
    if (!NT_SUCCESS(status))
    {
        DPRINT_ERROR(("LibraryLinkInClient failed with status 0x%x\n", status));
        LibraryDereference(pLibModule);
        goto Exit;
    }
 
    /* Dereference the library as LibraryLinkInClient has its own reference */
    LibraryDereference(pLibModule);
 
    BindInfo->Module = pLibModule;
 
    if (!pLibModule->LibraryInfo)
    {
        DPRINT_ERROR(("Library not properly initialized - LibraryInfo is NULL\n"));
        status = STATUS_INVALID_DEVICE_STATE;
        goto Cleanup;
    }
 
    if (!pLibModule->LibraryInfo->LibraryRegisterClient)
    {
        DPRINT_ERROR(("Library missing LibraryRegisterClient function pointer\n"));
        status = STATUS_INVALID_DEVICE_STATE;
        goto Cleanup;
    }
 
    DPRINT_VERBOSE(("Calling LibraryRegisterClient at %p for library %wZ\n",
                   pLibModule->LibraryInfo->LibraryRegisterClient, &pLibModule->ServicePath));
 
    status = pLibModule->LibraryInfo->LibraryRegisterClient(BindInfo, ComponentGlobals, &context);
    if (NT_SUCCESS(status))
    {
        clientModule->Globals = *ComponentGlobals;
        clientModule->Context = context; // Pointer to FX_DRIVER_GLOBALS
 
        DPRINT(("Successfully bound client %wZ to library %wZ\n",
               ServicePath, &libraryServicePath));
        goto Exit;
    }
 
    DPRINT_ERROR(("LibraryRegisterClient failed with status 0x%x\n", status));
 
Cleanup:
    WdfVersionUnbind(ServicePath, BindInfo, *ComponentGlobals);
 
Exit:
    if (libraryServicePath.Buffer)
    {
        RtlFreeUnicodeString(&libraryServicePath);
    }
 
    DPRINT_TRACE_EXIT();
    return status;
}

Referenced by FxDriverEntry(), and WdfLdrQueryInterface().

◆ WdfVersionBindClass()

NTSTATUS NTAPI WdfVersionBindClass	(	_In_ PWDF_BIND_INFO	BindInfo,
		_Inout_ PWDF_COMPONENT_GLOBALS *	Globals,
		_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo
	)

Definition at line 794 of file wdfldr.c.

{
    PCLASS_CLIENT_MODULE pClassClientModule = NULL;
    NTSTATUS status;
    PCLASS_MODULE pClassModule = NULL;
 
    DPRINT_TRACE_ENTRY();
 
    pClassClientModule = ClassClientCreate();
    if (pClassClientModule == NULL)
    {
        DPRINT_ERROR(("Could not create class client struct\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    status = ReferenceClassVersion(ClassBindInfo, BindInfo, &pClassModule);
    if (!NT_SUCCESS(status))
    {
        ExFreePoolWithTag(pClassClientModule, WDFLDR_TAG);
        return status;
    }
 
    status = ClassLinkInClient(pClassModule, ClassBindInfo, BindInfo, pClassClientModule);
    if (!NT_SUCCESS(status))
    {
        DPRINT_ERROR(("ClassLinkInClient failed 0x%x\n", status));
    }
    else
    {
        // Success - clear pClassClientModule so we don't free it
        pClassClientModule = NULL;
        status = pClassModule->ClassLibraryInfo->ClassLibraryBindClient(ClassBindInfo, ClientGlobals);
        if (NT_SUCCESS(status))
        {
            DPRINT_TRACE_EXIT();
            return status;
        }
 
        DPRINT_ERROR(("ClassLibraryBindClient failed, status 0x%x\n", status));
    }
 
    if (pClassModule != NULL)
        DereferenceClassVersion(ClassBindInfo, BindInfo, *ClientGlobals);
    if (pClassClientModule != NULL)
        ExFreePoolWithTag(pClassClientModule, WDFLDR_TAG);
 
    DPRINT_TRACE_EXIT();
    return status;
}

Referenced by WdfLdrQueryInterface().

◆ WdfVersionUnbind()

NTSTATUS NTAPI WdfVersionUnbind	(	_In_ PUNICODE_STRING	RegistryPath,
		_In_ PWDF_BIND_INFO	BindInfo,
		_In_ PWDF_COMPONENT_GLOBALS	ComponentGlobals
	)

Unbind client driver from framework.

Parameters

RegistryPath	Registry path
BindInfo	Client driver bind information
ComponentGlobals	Client driver global settings

Returns: STATUS_SUCCESS on success, error code otherwise

Definition at line 519 of file wdfldr.c.

{
    PLIBRARY_MODULE pLibModule;
    NTSTATUS status = STATUS_SUCCESS;
    NTSTATUS unregisterStatus = STATUS_SUCCESS;
 
    PAGED_CODE();
    DPRINT_TRACE_ENTRY();
 
    if (!BindInfo || !BindInfo->Module)
    {
        DPRINT_ERROR(("Invalid BindInfo or Module is NULL\n"));
        status = STATUS_INVALID_PARAMETER;
        goto Exit;
    }
 
    pLibModule = BindInfo->Module;
 
    /* Reference the module while working on it and unregister if globals are valid. */
    LibraryReference(pLibModule);
    if (ComponentGlobals != NULL && pLibModule->LibraryInfo &&
        pLibModule->LibraryInfo->LibraryUnregisterClient)
    {
        unregisterStatus = pLibModule->LibraryInfo->LibraryUnregisterClient(BindInfo, ComponentGlobals);
        if (!NT_SUCCESS(unregisterStatus))
        {
            DPRINT_ERROR(("LibraryUnregisterClient failed with status 0x%x\n", unregisterStatus));
        }
    }
 
    if (!LibraryUnlinkClient(pLibModule, BindInfo))
    {
        DPRINT_ERROR(("LibraryUnlinkClient failed for BindInfo %p\n", BindInfo));
    }
 
    LibraryDereference(pLibModule);
    BindInfo->Module = NULL;
 
    DPRINT_VERBOSE(("Successfully unbound client %wZ\n", RegistryPath));
 
Exit:
    DPRINT_TRACE_EXIT();
    return NT_SUCCESS(unregisterStatus) ? status : unregisterStatus;
}

Referenced by FxDriverUnloadCommon(), WdfLdrQueryInterface(), and WdfVersionBind().

◆ WdfVersionUnbindClass()

VOID NTAPI WdfVersionUnbindClass	(	_In_ PWDF_BIND_INFO	BindInfo,
		_In_ PWDF_COMPONENT_GLOBALS	Globals,
		_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo
	)

Definition at line 850 of file wdfldr.c.

{
    DereferenceClassVersion(ClassBindInfo, BindInfo, Globals);
}

Referenced by WdfLdrQueryInterface().

Classes

Typedefs

Functions

Typedef Documentation

◆ PFN_CLASS_LIBRARY_BIND_CLIENT

◆ PFN_CLASS_LIBRARY_DEINIT

◆ PFN_CLASS_LIBRARY_INIT

◆ PFN_CLASS_LIBRARY_UNBIND_CLIENT

◆ PFN_CLIENT_BIND_CLASS

◆ PFN_CLIENT_UNBIND_CLASS

◆ PFN_WDF_VERSION_BIND_CLASS

◆ PFN_WDF_VERSION_UNBIND_CLASS

◆ PWDF_BIND_INFO

◆ PWDF_CLASS_BIND_INFO

◆ PWDF_CLASS_LIBRARY_INFO

◆ PWDF_CLASS_VERSION

◆ PWDF_COMPONENT_GLOBALS

◆ PWDF_INTERFACE_HEADER

◆ PWDF_LDR_DIAGNOSTICS_VALUE_BY_NAME_AS_ULONG

◆ PWDF_LIBRARY_INFO

◆ WDF_BUILD_NUMBER

◆ WDF_CLASS_BIND_INFO

◆ WDF_CLASS_LIBRARY_INFO

◆ WDF_CLASS_VERSION

◆ WDF_COMPONENT_GLOBALS

◆ WDF_INTERFACE_HEADER

◆ WDF_MAJOR_VERSION

◆ WDF_MINOR_VERSION

Function Documentation

◆ DllInitialize()

◆ DllUnload()

◆ WdfLdrDiagnosticsValueByNameAsULONG()

◆ WdfLdrQueryInterface()

◆ WdfRegisterClassLibrary()

◆ WdfRegisterLibrary()

◆ WdfVersionBind()

◆ WdfVersionBindClass()

◆ WdfVersionUnbind()

◆ WdfVersionUnbindClass()