wdfloader.h File Reference

#include <fxldr.h>
#include <aux_klib.h>
#include <ntintsafe.h>
#include <ntstrsafe.h>

Include dependency graph for wdfloader.h:

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

Go to the source code of this file.

Classes
struct	_WDF_LDR_GLOBALS
struct	_WDFLDR_DIAGS
struct	_LIBRARY_MODULE
struct	_WDF_LOADER_INTERFACE_DIAGNOSTIC
struct	_WDF_LOADER_INTERFACE_CLASS_BIND
struct	_CLIENT_MODULE
struct	_CLASS_MODULE
struct	_CLASS_CLIENT_MODULE

Macros
#define	WDFLDR_TAG   'LfdW'
#define	__PrintUnfiltered(...)    DbgPrintEx(DPFLTR_DEFAULT_ID, DPFLTR_ERROR_LEVEL, __VA_ARGS__)
#define	DPRINT(_x_)
#define	DPRINT_VERBOSE(_x_)
#define	DPRINT_ERROR(_x_)
#define	DPRINT_TRACE_ENTRY()
#define	DPRINT_TRACE_EXIT()
#define	__DBGPRINT(_x_)
#define	DIAGFLAG_ENABLED   0x00000001
#define	DIAGFLAG_VERBOSE_LOGGING   0x00000002
#define	DIAGFLAG_TRACE_FUNCTION_ENTRY   0x00000004
#define	DIAGFLAG_TRACE_FUNCTION_EXIT   0x00000008
#define	DIAGFLAG_LOG_ERRORS   0x00000010
#define	DIAGFLAG_LOG_WARNINGS   0x00000020

Typedefs
typedef struct _WDF_LDR_GLOBALS	WDF_LDR_GLOBALS
typedef struct _WDF_LDR_GLOBALS *	PWDF_LDR_GLOBALS
typedef struct _WDFLDR_DIAGS	WDFLDR_DIAGS
typedef struct _WDFLDR_DIAGS *	PWDFLDR_DIAGS
typedef struct _LIBRARY_MODULE	LIBRARY_MODULE
typedef struct _LIBRARY_MODULE *	PLIBRARY_MODULE
typedef NTSTATUS(NTAPI *	PWDF_CLASS_BIND) (PWDF_BIND_INFO BindInfo, PWDF_COMPONENT_GLOBALS *Globals, PWDF_CLASS_BIND_INFO ClassBindInfo)
typedef VOID(NTAPI *	PWDF_CLASS_UNBIND) (PWDF_BIND_INFO BindInfo, PWDF_COMPONENT_GLOBALS Globals, PWDF_CLASS_BIND_INFO ClassBindInfo)
typedef struct _WDF_LOADER_INTERFACE_DIAGNOSTIC	WDF_LOADER_INTERFACE_DIAGNOSTIC
typedef struct _WDF_LOADER_INTERFACE_DIAGNOSTIC *	PWDF_LOADER_INTERFACE_DIAGNOSTIC
typedef struct _WDF_LOADER_INTERFACE_CLASS_BIND	WDF_LOADER_INTERFACE_CLASS_BIND
typedef struct _WDF_LOADER_INTERFACE_CLASS_BIND *	PWDF_LOADER_INTERFACE_CLASS_BIND
typedef struct _CLIENT_MODULE	CLIENT_MODULE
typedef struct _CLIENT_MODULE *	PCLIENT_MODULE
typedef struct _CLASS_MODULE	CLASS_MODULE
typedef struct _CLASS_MODULE *	PCLASS_MODULE
typedef struct _CLASS_CLIENT_MODULE	CLASS_CLIENT_MODULE
typedef struct _CLASS_CLIENT_MODULE *	PCLASS_CLIENT_MODULE

Functions
PCLASS_MODULE	ClassCreate (_In_ PWDF_CLASS_LIBRARY_INFO ClassLibInfo, _In_ PLIBRARY_MODULE LibModule, _In_ PUNICODE_STRING ServiceName)
NTSTATUS	ClassOpen (_Inout_ PCLASS_MODULE ClassModule, _In_ PUNICODE_STRING ObjectName)
PLIST_ENTRY	LibraryAddToClassListLocked (_In_ PLIBRARY_MODULE LibModule, _In_ PCLASS_MODULE ClassModule)
VOID	ClassRemoveFromLibraryList (_In_ PCLASS_MODULE ClassModule)
PLIST_ENTRY	LibraryUnloadClasses (_In_ PLIBRARY_MODULE LibModule)
PCLASS_CLIENT_MODULE	ClassClientCreate ()
NTSTATUS	ReferenceClassVersion (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_BIND_INFO BindInfo, _Out_ PCLASS_MODULE *ClassModule)
VOID	DereferenceClassVersion (_In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_BIND_INFO BindInfo, _In_ PWDF_COMPONENT_GLOBALS Globals)
NTSTATUS	ClassLinkInClient (_In_ PCLASS_MODULE ClassModule, _In_ PWDF_CLASS_BIND_INFO ClassBindInfo, _In_ PWDF_BIND_INFO BindInfo, _Out_ PCLASS_CLIENT_MODULE ClassClientModule)
PCLASS_MODULE	FindClassByServiceNameLocked (_In_ PUNICODE_STRING Path, _Out_ PLIBRARY_MODULE *LibModule)
VOID NTAPI	ClassAddReference (_In_ PCLASS_MODULE ClassModule)
VOID	ClassClose (_In_ PCLASS_MODULE ClassModule)
VOID	ClassReleaseClientReference (_In_ PCLASS_MODULE ClassModule)
VOID	FxLdrAcquireLoadedModuleLock (VOID)
VOID	FxLdrReleaseLoadedModuleLock (VOID)
NTSTATUS	GetImageInfo (_In_ PCUNICODE_STRING ImageName, _Out_ PVOID *ImageBase, _Out_ PULONG ImageSize)
NTSTATUS	GetImageName (_In_ PCUNICODE_STRING ServicePath, _In_ PUNICODE_STRING ImageName)
VOID	GetNameFromPath (_In_ PCUNICODE_STRING Path, _Out_ PUNICODE_STRING Name)
NTSTATUS	LibraryCreate (_In_opt_ PWDF_LIBRARY_INFO LibraryInfo, _In_ PCUNICODE_STRING ServicePath, _Out_ PLIBRARY_MODULE *OutLibraryModule)
NTSTATUS	LibraryOpen (_Inout_ PLIBRARY_MODULE LibModule, _In_ PCUNICODE_STRING ObjectName)
	Opens KMDF library's driver object by its name and fills some library structure data.
VOID	LibraryClose (_Inout_ PLIBRARY_MODULE LibModule)
	Dereferences KMDF library's device object.
NTSTATUS	LibraryFindOrLoad (_In_ PCUNICODE_STRING ServicePath, _Out_ PLIBRARY_MODULE *LibModule)
VOID	LibraryReference (_In_ PLIBRARY_MODULE LibModule)
VOID	LibraryDereference (_In_ PLIBRARY_MODULE LibModule)
VOID	LibraryUnload (_In_ PLIBRARY_MODULE LibModule)
VOID	LibraryFree (_In_ PLIBRARY_MODULE LibModule)
BOOLEAN	LibraryAcquireClientLock (_In_ PLIBRARY_MODULE LibModule)
VOID	LibraryReleaseClientLock (_In_ PLIBRARY_MODULE LibModule)
NTSTATUS	LibraryLinkInClient (_In_ PLIBRARY_MODULE LibModule, _In_ PUNICODE_STRING ServicePath, _In_ PWDF_BIND_INFO BindInfo, _In_ PVOID Context, _Out_ PCLIENT_MODULE *OutClientModule)
	Create client module and add it to library client list.
BOOLEAN	LibraryUnlinkClient (_In_ PLIBRARY_MODULE LibModule, _In_ PWDF_BIND_INFO BindInfo)
PLIBRARY_MODULE	FindLibraryByServicePathLocked (_In_ PCUNICODE_STRING ServicePath)
VOID NTAPI	LibraryReleaseReference (_In_ PLIBRARY_MODULE LibModule)
	Release a reference to a library module.
NTSTATUS NTAPI	FindModuleByClientService (_In_ PUNICODE_STRING RegistryPath, _Out_ PLIBRARY_MODULE *Library)
NTSTATUS NTAPI	ReferenceVersion (_In_ PWDF_BIND_INFO Info, _Out_ PLIBRARY_MODULE *Module)
	Reference a WDF library version.
NTSTATUS NTAPI	DereferenceVersion (_In_ PWDF_BIND_INFO Info, _In_opt_ PWDF_COMPONENT_GLOBALS Globals)
	Dereference a WDF library version.
NTSTATUS	BuildServicePath (_In_ PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation, _In_ PUNICODE_STRING ServicePath)
NTSTATUS	GetVersionServicePath (_In_ PWDF_BIND_INFO BindInfo, _Out_ PUNICODE_STRING ServicePath)
	Get service path from bind info and registry.
BOOLEAN	ServiceCheckBootStart (_In_ PUNICODE_STRING Service)
NTSTATUS	FxLdrQueryUlong (_In_ HANDLE KeyHandle, _In_ PUNICODE_STRING ValueName, _Out_ PULONG Value)
NTSTATUS	FxLdrQueryData (_In_ HANDLE KeyHandle, _In_ PUNICODE_STRING ValueName, _In_ ULONG Tag, _Out_ PKEY_VALUE_PARTIAL_INFORMATION *KeyValPartialInfo)

Variables
WDFLDR_DIAGS	WdfLdrDiags
WDF_LDR_GLOBALS	WdfLdrGlobals

Macro Definition Documentation

__DBGPRINT

#define __DBGPRINT

(

_x_

)

Value:

do {                                                                           \
    if (WdfLdrDiags.DiagFlags & DIAGFLAG_ENABLED) {                            \
        DbgPrint("Wdfldr: %s - ", __FUNCTION__);                               \
        __PrintUnfiltered _x_;                                                 \
    }                                                                          \
} while (0)

Definition at line 62 of file wdfloader.h.

__PrintUnfiltered

#define __PrintUnfiltered

(

...

)

DbgPrintEx(DPFLTR_DEFAULT_ID, DPFLTR_ERROR_LEVEL, __VA_ARGS__)

Definition at line 20 of file wdfloader.h.

DIAGFLAG_ENABLED

#define DIAGFLAG_ENABLED   0x00000001

Definition at line 79 of file wdfloader.h.

DIAGFLAG_LOG_ERRORS

#define DIAGFLAG_LOG_ERRORS   0x00000010

Definition at line 83 of file wdfloader.h.

DIAGFLAG_LOG_WARNINGS

#define DIAGFLAG_LOG_WARNINGS   0x00000020

Definition at line 84 of file wdfloader.h.

DIAGFLAG_TRACE_FUNCTION_ENTRY

#define DIAGFLAG_TRACE_FUNCTION_ENTRY   0x00000004

Definition at line 81 of file wdfloader.h.

DIAGFLAG_TRACE_FUNCTION_EXIT

#define DIAGFLAG_TRACE_FUNCTION_EXIT   0x00000008

Definition at line 82 of file wdfloader.h.

DIAGFLAG_VERBOSE_LOGGING

#define DIAGFLAG_VERBOSE_LOGGING   0x00000002

Definition at line 80 of file wdfloader.h.

DPRINT

#define DPRINT

(

_x_

)

Value:

do {                                                                           \
    if (WdfLdrDiags.DiagFlags & DIAGFLAG_ENABLED) {                            \
        DbgPrint("WdfLdr: %s - ", __FUNCTION__);                               \
        __PrintUnfiltered _x_;                                                 \
    }                                                                          \
} while (0)

Definition at line 23 of file wdfloader.h.

DPRINT_ERROR

#define DPRINT_ERROR

(

_x_

)

Value:

do {                                                                           \
    if (WdfLdrDiags.DiagFlags & DIAGFLAG_LOG_ERRORS) {                         \
        DbgPrint("WdfLdr: ERROR: %s - ", __FUNCTION__);                        \
        __PrintUnfiltered _x_;                                                 \
    }                                                                          \
} while (0)

Definition at line 39 of file wdfloader.h.

DPRINT_TRACE_ENTRY

DPRINT_TRACE_ENTRY

(

)

Value:

do {                                                                           \
    if (WdfLdrDiags.DiagFlags & DIAGFLAG_TRACE_FUNCTION_ENTRY) {               \
        DbgPrint("WdfLdr: ENTER: %s\n", __FUNCTION__);                         \
    }                                                                          \
} while (0)

Definition at line 47 of file wdfloader.h.

Referenced by DereferenceVersion(), DllUnload(), ReferenceVersion(), WdfLdrQueryInterface(), WdfVersionBind(), WdfVersionBindClass(), and WdfVersionUnbind().

DPRINT_TRACE_EXIT

DPRINT_TRACE_EXIT

(

)

Value:

do {                                                                           \
    if (WdfLdrDiags.DiagFlags & DIAGFLAG_TRACE_FUNCTION_EXIT) {                \
        DbgPrint("WdfLdr: EXIT: %s\n", __FUNCTION__);                          \
    }                                                                          \
} while (0)

Definition at line 54 of file wdfloader.h.

Referenced by DereferenceVersion(), DllUnload(), ReferenceVersion(), WdfLdrQueryInterface(), WdfVersionBind(), WdfVersionBindClass(), and WdfVersionUnbind().

DPRINT_VERBOSE

#define DPRINT_VERBOSE

(

_x_

)

Value:

do {                                                                           \
    if (WdfLdrDiags.DiagFlags & DIAGFLAG_VERBOSE_LOGGING) {                    \
        DbgPrint("WdfLdr: %s - ", __FUNCTION__);                               \
        __PrintUnfiltered _x_;                                                 \
    }                                                                          \
} while (0)

Definition at line 31 of file wdfloader.h.

WDFLDR_TAG

#define WDFLDR_TAG   'LfdW'

Definition at line 17 of file wdfloader.h.

Typedef Documentation

CLASS_CLIENT_MODULE

typedef struct _CLASS_CLIENT_MODULE CLASS_CLIENT_MODULE

CLASS_MODULE

typedef struct _CLASS_MODULE CLASS_MODULE

CLIENT_MODULE

typedef struct _CLIENT_MODULE CLIENT_MODULE

LIBRARY_MODULE

typedef struct _LIBRARY_MODULE LIBRARY_MODULE

PCLASS_CLIENT_MODULE

typedef struct _CLASS_CLIENT_MODULE * PCLASS_CLIENT_MODULE

PCLASS_MODULE

typedef struct _CLASS_MODULE * PCLASS_MODULE

PCLIENT_MODULE

typedef struct _CLIENT_MODULE * PCLIENT_MODULE

PLIBRARY_MODULE

typedef struct _LIBRARY_MODULE * PLIBRARY_MODULE

PWDF_CLASS_BIND

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

Definition at line 130 of file wdfloader.h.

PWDF_CLASS_UNBIND

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

Definition at line 137 of file wdfloader.h.

PWDF_LDR_GLOBALS

typedef struct _WDF_LDR_GLOBALS * PWDF_LDR_GLOBALS

PWDF_LOADER_INTERFACE_CLASS_BIND

typedef struct _WDF_LOADER_INTERFACE_CLASS_BIND * PWDF_LOADER_INTERFACE_CLASS_BIND

PWDF_LOADER_INTERFACE_DIAGNOSTIC

typedef struct _WDF_LOADER_INTERFACE_DIAGNOSTIC * PWDF_LOADER_INTERFACE_DIAGNOSTIC

PWDFLDR_DIAGS

typedef struct _WDFLDR_DIAGS * PWDFLDR_DIAGS

WDF_LDR_GLOBALS

typedef struct _WDF_LDR_GLOBALS WDF_LDR_GLOBALS

WDF_LOADER_INTERFACE_CLASS_BIND

typedef struct _WDF_LOADER_INTERFACE_CLASS_BIND WDF_LOADER_INTERFACE_CLASS_BIND

WDF_LOADER_INTERFACE_DIAGNOSTIC

typedef struct _WDF_LOADER_INTERFACE_DIAGNOSTIC WDF_LOADER_INTERFACE_DIAGNOSTIC

WDFLDR_DIAGS

typedef struct _WDFLDR_DIAGS WDFLDR_DIAGS

Function Documentation

BuildServicePath()

NTSTATUS BuildServicePath	(	_In_ PKEY_VALUE_PARTIAL_INFORMATION	KeyValueInformation,
		_In_ PUNICODE_STRING	ServicePath
	)

Definition at line 338 of file registry.c.

{
    NTSTATUS status;
    PWCHAR buffer;
    PWCHAR lastChar;
    UNICODE_STRING name;
    CONST WCHAR regPath[] = L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\%wZ";
 
    if (KeyValueInformation->Type != REG_SZ &&
        KeyValueInformation->Type != REG_EXPAND_SZ)
    {
        status = STATUS_OBJECT_TYPE_MISMATCH;
        __DBGPRINT(("ERROR: BuildServicePath failed with status 0x%x\n", status));
        return status;
    }
 
    if (KeyValueInformation->DataLength == 0 ||
        KeyValueInformation->DataLength > 0xFFFF)
    {
        status = STATUS_INVALID_PARAMETER;
        __DBGPRINT(("ERROR: BuildServicePath failed with status 0x%x\n", status));
        return status;
    }
 
    name.Buffer = (PWCH)KeyValueInformation->Data;
    name.Length = (USHORT)KeyValueInformation->DataLength;
    name.MaximumLength = (USHORT)KeyValueInformation->DataLength;
 
    lastChar = (PWCHAR)KeyValueInformation->Data + KeyValueInformation->DataLength / sizeof(WCHAR);
    if (KeyValueInformation->DataLength >= sizeof(WCHAR) && *lastChar == UNICODE_NULL)
    {
        name.Length = (USHORT)KeyValueInformation->DataLength - sizeof(WCHAR);
    }
 
    buffer = ExAllocatePoolZero(PagedPool, name.Length + sizeof(regPath), WDFLDR_TAG);
    if (buffer != NULL)
    {
        ServicePath->Length = 0;
        ServicePath->MaximumLength = name.Length + sizeof(L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\");//106;
        ServicePath->Buffer = buffer;
        status = RtlUnicodeStringPrintf(ServicePath, regPath, &name);
 
        if (!NT_SUCCESS(status))
        {
            ExFreePoolWithTag(buffer, WDFLDR_TAG);
            ServicePath->Length = 0;
            ServicePath->Buffer = NULL;
        }
    }
    else
    {
        status = STATUS_INSUFFICIENT_RESOURCES;
        __DBGPRINT(("ERROR: ExAllocatePoolWithTag failed with Status 0x%x\n", status));
    }
 
    return status;
}

Referenced by GetClassServicePath(), and GetVersionServicePath().

ClassAddReference()

VOID NTAPI ClassAddReference

(

_In_ PCLASS_MODULE

ClassModule

)

Definition at line 761 of file class.c.

{
    InterlockedIncrement(&ClassModule->ClassRefCount);
    DPRINT_VERBOSE(("Added reference to class %wZ, RefCount=%d\n",
                   &ClassModule->Service, ClassModule->ClassRefCount));
}

Referenced by WdfRegisterClassLibrary().

ClassClientCreate()

PCLASS_CLIENT_MODULE ClassClientCreate

(

)

Definition at line 137 of file class.c.

{
    PCLASS_CLIENT_MODULE pNewClassClientModule;
 
    pNewClassClientModule = ExAllocatePoolZero(NonPagedPool, sizeof(*pNewClassClientModule), WDFLDR_TAG);
    if (pNewClassClientModule != NULL)
    {
        InitializeListHead(&pNewClassClientModule->ClassLinkage);
        InitializeListHead(&pNewClassClientModule->ClientLinkage);
    }
 
    return pNewClassClientModule;
}

Referenced by WdfVersionBindClass().

ClassClose()

VOID ClassClose

(

_In_ PCLASS_MODULE

ClassModule

)

Definition at line 48 of file class.c.

{
    if (ClassModule->ClassFileObject != NULL)
    {
        ObDereferenceObject(ClassModule->ClassFileObject);
        ClassModule->ClassFileObject = NULL;
    }
}

ClassCreate()

PCLASS_MODULE ClassCreate	(	_In_ PWDF_CLASS_LIBRARY_INFO	ClassLibInfo,
		_In_ PLIBRARY_MODULE	LibModule,
		_In_ PUNICODE_STRING	ServiceName
	)

Definition at line 75 of file class.c.

{
    PCLASS_MODULE pNewClassModule;
    NTSTATUS status;
 
    pNewClassModule = ExAllocatePoolZero(NonPagedPool, sizeof(*pNewClassModule), WDFLDR_TAG);
    if (pNewClassModule == NULL)
        return NULL;
 
    if (ClassLibInfo != NULL)
    {
        pNewClassModule->ImplicitlyLoaded = TRUE;
        pNewClassModule->ClassLibraryInfo = ClassLibInfo;
        pNewClassModule->Version.Major = ClassLibInfo->Version.Major;
        pNewClassModule->Version.Minor = ClassLibInfo->Version.Minor;
        pNewClassModule->Version.Build = ClassLibInfo->Version.Build;
    }
 
    pNewClassModule->ClassRefCount = 1;
    pNewClassModule->Library = LibModule;
    ExInitializeResourceLite(&pNewClassModule->ClientsListLock);
    InitializeListHead(&pNewClassModule->ClientsListHead);
    InitializeListHead(&pNewClassModule->LibraryLinkage);
 
    pNewClassModule->Service.Buffer = ExAllocatePoolZero(PagedPool, ServiceName->MaximumLength, WDFLDR_TAG);
    if (pNewClassModule->Service.Buffer == NULL)
    {
        goto clean;
    }
    pNewClassModule->Service.MaximumLength = ServiceName->MaximumLength;
    RtlCopyUnicodeString(&pNewClassModule->Service, ServiceName);
    status = GetImageName(ServiceName, &pNewClassModule->ImageName);
 
    if (!NT_SUCCESS(status))
    {
        goto clean;
    }
 
    pNewClassModule->IsBootDriver = ServiceCheckBootStart(&pNewClassModule->Service);
    status = GetImageInfo(&pNewClassModule->ImageName,
                          &pNewClassModule->ImageAddress,
                          &pNewClassModule->ImageSize);
 
    if (NT_SUCCESS(status))
    {
        return pNewClassModule;
    }
    else
    {
        __DBGPRINT(("GetImageBase failed\n"));
    }
 
clean:
    ClassCleanupAndFree(pNewClassModule);
 
    return NULL;
}

ClassLinkInClient()

NTSTATUS ClassLinkInClient	(	_In_ PCLASS_MODULE	ClassModule,
		_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo,
		_In_ PWDF_BIND_INFO	BindInfo,
		_Out_ PCLASS_CLIENT_MODULE	ClassClientModule
	)

Definition at line 170 of file class.c.

{
    PCLIENT_MODULE pClienInfo;
    NTSTATUS status;
 
    ClassClientModule->Class = ClassModule;
    ClassClientModule->ClientClassBindInfo = ClassBindInfo;
    LibraryAcquireClientLock(ClassModule->Library);
    pClienInfo = LibraryFindClientLocked(ClassModule->Library, BindInfo);
 
    if (pClienInfo != NULL)
    {
        ClassClientModule->Client = pClienInfo;
        InsertTailList(&pClienInfo->ClassListHead, &ClassClientModule->ClassLinkage);
    }
 
    LibraryReleaseClientLock(ClassModule->Library);
 
    if (pClienInfo != NULL)
    {
        ClassAcquireClientLock(&ClassModule->ClientsListLock);
        InsertTailList(&ClassModule->ClientsListHead, &ClassClientModule->ClientLinkage);
        ClassReleaseClientLock(&ClassModule->ClientsListLock);
        status = STATUS_SUCCESS;
    }
    else
    {
        status = STATUS_INVALID_DEVICE_STATE;
        __DBGPRINT(("ERROR: Could not locate client from Info %p, status 0x%x\n", BindInfo, status));
    }
 
    return status;
}

Referenced by WdfVersionBindClass().

ClassOpen()

NTSTATUS ClassOpen	(	_Inout_ PCLASS_MODULE	ClassModule,
		_In_ PUNICODE_STRING	ObjectName
	)

Definition at line 29 of file class.c.

{
    NTSTATUS status;
    PDEVICE_OBJECT deviceObject;
 
    if (!ObjectName)
        return STATUS_SUCCESS;
 
    status = IoGetDeviceObjectPointer(ObjectName, FILE_READ_DATA, &ClassModule->ClassFileObject, &deviceObject);
 
    if (NT_SUCCESS(status))
        ClassModule->ClassDriverObject = deviceObject->DriverObject;
 
    return status;
}

Referenced by WdfRegisterClassLibrary().

ClassReleaseClientReference()

VOID ClassReleaseClientReference

(

_In_ PCLASS_MODULE

ClassModule

)

Definition at line 770 of file class.c.

{
    int refs;
 
    __DBGPRINT(("Dereference module %wZ\n", &ClassModule->Service));
    refs = InterlockedDecrement(&ClassModule->ClientRefCount);
 
    if (refs <= 0)
    {
        ClassUnload(ClassModule, TRUE);
    }
    else
    {
        __DBGPRINT(("Dereference module %wZ still has %d references\n",
                   &ClassModule->Service, refs));
    }
}

Referenced by DereferenceClassVersion().

ClassRemoveFromLibraryList()

VOID ClassRemoveFromLibraryList

(

_In_ PCLASS_MODULE

ClassModule

)

Definition at line 692 of file class.c.

{
    PLIST_ENTRY libLinkEntry;
    BOOLEAN removed;
 
    FxLdrAcquireLoadedModuleLock();
    libLinkEntry = &ClassModule->LibraryLinkage;
 
    if (IsListEmpty(libLinkEntry))
    {
        removed = FALSE;
    }
    else
    {
        RemoveEntryList(libLinkEntry);
        InitializeListHead(libLinkEntry);
        removed = TRUE;
    }
    FxLdrReleaseLoadedModuleLock();
 
    if (removed)
    {
        if (InterlockedExchangeAdd(&ClassModule->ClassRefCount, -1) == 1)
            ClassCleanupAndFree(ClassModule);
    }
}

Referenced by ClassUnload(), and WdfRegisterClassLibrary().

DereferenceClassVersion()

VOID DereferenceClassVersion	(	_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo,
		_In_ PWDF_BIND_INFO	BindInfo,
		_In_ PWDF_COMPONENT_GLOBALS	Globals
	)

Definition at line 790 of file class.c.

{
    PCLASS_MODULE pClassModule;
 
    UNREFERENCED_PARAMETER(BindInfo);
    pClassModule = ClassBindInfo->ClassModule;
 
    if (pClassModule)
    {
        if (pClassModule->ClassLibraryInfo &&
            pClassModule->ClassLibraryInfo->ClassLibraryUnbindClient)
        {
            pClassModule->ClassLibraryInfo->ClassLibraryUnbindClient(ClassBindInfo, &Globals);
        }
        ClassUnlinkClient(pClassModule, ClassBindInfo);
        ClassReleaseClientReference(pClassModule);
        ClassBindInfo->ClassModule = NULL;
    }
}

Referenced by WdfVersionBindClass(), and WdfVersionUnbindClass().

DereferenceVersion()

NTSTATUS NTAPI DereferenceVersion	(	_In_ PWDF_BIND_INFO	Info,
		_In_opt_ PWDF_COMPONENT_GLOBALS	Globals
	)

Dereference a WDF library version.

Parameters

Info	Binding information
Globals	Component globals to clean up

Returns

NTSTATUS Success or failure status

Definition at line 630 of file wdfldr.c.

{
    NTSTATUS status = STATUS_SUCCESS;
    NTSTATUS unregisterStatus = STATUS_SUCCESS;
    PLIBRARY_MODULE pLibModule;
 
    DPRINT_TRACE_ENTRY();
 
    if (!Info || !Info->Module)
    {
        DPRINT_ERROR(("Invalid Info or Module is NULL\n"));
        return STATUS_INVALID_PARAMETER;
    }
 
    pLibModule = Info->Module;
 
    // Unregister the client if we have globals
    if (Globals && pLibModule->LibraryInfo &&
        pLibModule->LibraryInfo->LibraryUnregisterClient)
    {
        unregisterStatus = pLibModule->LibraryInfo->LibraryUnregisterClient(Info, Globals);
        if (!NT_SUCCESS(unregisterStatus))
        {
            DPRINT_ERROR(("LibraryUnregisterClient failed with status 0x%x\n", unregisterStatus));
            if (WdfLdrDiags.DiagFlags & DIAGFLAG_ENABLED)
            {
                DPRINT_VERBOSE(("LibraryUnregisterClient failed\n"));
            }
        }
    }
 
    // Unlink the client
    if (!LibraryUnlinkClient(pLibModule, Info))
    {
        DPRINT_ERROR(("LibraryUnlinkClient failed\n"));
        if (WdfLdrDiags.DiagFlags & DIAGFLAG_ENABLED)
        {
            DPRINT_VERBOSE(("LibraryUnlinkClient failed\n"));
        }
    }
 
    // Release the reference
    LibraryReleaseReference(pLibModule);
 
    // Clear the module reference
    Info->Module = NULL;
 
    DPRINT_TRACE_EXIT();
    return NT_SUCCESS(unregisterStatus) ? status : unregisterStatus;
}

FindClassByServiceNameLocked()

PCLASS_MODULE FindClassByServiceNameLocked	(	_In_ PUNICODE_STRING	Path,
		_Out_ PLIBRARY_MODULE *	LibModule
	)

Definition at line 585 of file class.c.

{
    PLIST_ENTRY libEntry;
    PLIBRARY_MODULE pLibModule;
    PLIST_ENTRY classEntry;
    PCLASS_MODULE pClassModule;
    UNICODE_STRING needleName;
 
    GetNameFromPath(ServicePath, &needleName);
 
    if (IsListEmpty(&WdfLdrGlobals.LoadedModulesList))
    {
        goto end;
    }
 
    for (libEntry = WdfLdrGlobals.LoadedModulesList.Flink;
         libEntry != &WdfLdrGlobals.LoadedModulesList;
         libEntry = libEntry->Flink)
    {
        pLibModule = CONTAINING_RECORD(libEntry, LIBRARY_MODULE, LibraryListEntry);
 
        for (classEntry = pLibModule->ClassListHead.Flink;
             classEntry != &pLibModule->ClassListHead;
             classEntry = classEntry->Flink)
        {
            UNICODE_STRING haystackName;
            pClassModule = CONTAINING_RECORD(classEntry, CLASS_MODULE, LibraryLinkage);
            GetNameFromPath(&pClassModule->Service, &haystackName);
 
            if (RtlEqualUnicodeString(&needleName, &haystackName, TRUE))
            {
                if (LibModule != NULL)
                {
                    *LibModule = pLibModule;
                }
 
                return pClassModule;
            }
        }
    }
 
end:
    if (LibModule != NULL)
        *LibModule = NULL;
 
    return NULL;
}

Referenced by ReferenceClassVersion(), and WdfRegisterClassLibrary().

FindLibraryByServicePathLocked()

PLIBRARY_MODULE FindLibraryByServicePathLocked

(

_In_ PCUNICODE_STRING

ServicePath

)

Referenced by LibraryFindOrLoad(), and WdfRegisterLibrary().

FindModuleByClientService()

NTSTATUS NTAPI FindModuleByClientService	(	_In_ PUNICODE_STRING	RegistryPath,
		_Out_ PLIBRARY_MODULE *	Library
	)

Referenced by WdfRegisterClassLibrary().

FxLdrAcquireLoadedModuleLock()

VOID FxLdrAcquireLoadedModuleLock

(

VOID

)

Definition at line 13 of file common.c.

{
    KeEnterCriticalRegion();
    ExAcquireResourceExclusiveLite(&WdfLdrGlobals.LoadedModulesListLock, TRUE);
}

Referenced by ClassRemoveFromLibraryList(), LibraryDereference(), LibraryFindOrLoad(), LibraryReference(), ReferenceClassVersion(), WdfRegisterClassLibrary(), and WdfRegisterLibrary().

FxLdrQueryData()

NTSTATUS FxLdrQueryData	(	_In_ HANDLE	KeyHandle,
		_In_ PUNICODE_STRING	ValueName,
		_In_ ULONG	Tag,
		_Out_ PKEY_VALUE_PARTIAL_INFORMATION *	KeyValPartialInfo
	)

Definition at line 267 of file registry.c.

{
    PKEY_VALUE_PARTIAL_INFORMATION pKeyInfo;
    NTSTATUS status;
    ULONG resultLength;
 
    *KeyValPartialInfo = NULL;
    for (;;)
    {
        status = ZwQueryValueKey(KeyHandle, ValueName, KeyValuePartialInformation, NULL, 0, &resultLength);
        if (status != STATUS_BUFFER_TOO_SMALL)
        {
            if (!NT_SUCCESS(status))
            {
                __DBGPRINT(("ERROR: ZwQueryValueKey failed with status 0x%x\n", status));
            }
 
            return status;
        }
 
        status = RtlULongAdd(resultLength, 0xCu, &resultLength);
        if (!NT_SUCCESS(status))
        {
            __DBGPRINT(("ERROR: Computing length of data under %wZ failed with status 0x%x\n", ValueName, status));
 
            return status;
        }
 
        pKeyInfo = ExAllocatePoolWithTag(PagedPool, resultLength, Tag);
 
        if (pKeyInfo == NULL)
        {
            break;
        }
 
        RtlZeroMemory(pKeyInfo, resultLength);
        status = ZwQueryValueKey(
            KeyHandle,
            ValueName,
            KeyValuePartialInformation,
            pKeyInfo,
            resultLength,
            &resultLength);
 
        if (NT_SUCCESS(status))
        {
            *KeyValPartialInfo = pKeyInfo;
            return status;
        }
 
        ExFreePoolWithTag(pKeyInfo, WDFLDR_TAG);
 
        if (status != STATUS_BUFFER_TOO_SMALL)
        {
            __DBGPRINT(("ERROR: ZwQueryValueKey (%wZ) failed with Status 0x%x\n", ValueName, status));
 
            return status;
        }
    }
 
    __DBGPRINT(("ERROR: ExAllocatePoolWithTag failed with Status 0x%x\n", STATUS_INSUFFICIENT_RESOURCES));
 
    return STATUS_INSUFFICIENT_RESOURCES;
}

Referenced by GetClassServicePath(), GetImageName(), and GetVersionServicePath().

FxLdrQueryUlong()

NTSTATUS FxLdrQueryUlong	(	_In_ HANDLE	KeyHandle,
		_In_ PUNICODE_STRING	ValueName,
		_Out_ PULONG	Value
	)

Definition at line 231 of file registry.c.

{
    NTSTATUS status;
    ULONG resultLength;
    KEY_VALUE_PARTIAL_INFORMATION keyValue;
 
    keyValue.DataLength = 0;
    keyValue.TitleIndex = 0;
    keyValue.Type = 0;
    keyValue.Data[0] = 0;
    status = ZwQueryValueKey(KeyHandle, ValueName, KeyValuePartialInformation, &keyValue, sizeof(keyValue), &resultLength);
    if (NT_SUCCESS(status))
    {
        if (keyValue.Type != REG_DWORD || keyValue.DataLength != sizeof(*Value))
        {
            status = STATUS_INVALID_BUFFER_SIZE;
        }
        else
        {
            *Value = keyValue.Data[0];
            status = STATUS_SUCCESS;
        }
    }
    else
    {
        __DBGPRINT(("ERROR: ZwQueryValueKey failed with Status 0x%x\n", status));
    }
 
    return status;
}

Referenced by ServiceCheckBootStart(), and WdfLdrDiagnosticsValueByNameAsULONG().

FxLdrReleaseLoadedModuleLock()

VOID FxLdrReleaseLoadedModuleLock

(

VOID

)

Definition at line 20 of file common.c.

{
    ExReleaseResourceLite(&WdfLdrGlobals.LoadedModulesListLock);
    KeLeaveCriticalRegion();
}

Referenced by ClassRemoveFromLibraryList(), LibraryDereference(), LibraryFindOrLoad(), LibraryReference(), ReferenceClassVersion(), WdfRegisterClassLibrary(), and WdfRegisterLibrary().

GetImageInfo()

NTSTATUS GetImageInfo	(	_In_ PCUNICODE_STRING	ImageName,
		_Out_ PVOID *	ImageBase,
		_Out_ PULONG	ImageSize
	)

Definition at line 182 of file common.c.

{
    ANSI_STRING ansiImageName;
    NTSTATUS status;
 
    status = RtlUnicodeStringToAnsiString(&ansiImageName, ImageName, TRUE);
 
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ERROR: RtlUnicodeStringToAnsiString failed with Status 0x%x\n", status));
        return status;
    }
 
    PAUX_MODULE_EXTENDED_INFO modulesBuffer;
    ULONG modulesSize;
    for (;;)
    {
        status = AuxKlibQueryModuleInformation(&modulesSize,
                                               sizeof(AUX_MODULE_EXTENDED_INFO),
                                               NULL);
        if (!NT_SUCCESS(status))
        {
            goto clean;
        }
 
        modulesBuffer = ExAllocatePoolZero(PagedPool, modulesSize, WDFLDR_TAG);
        if (modulesBuffer == NULL)
        {
            status = STATUS_INSUFFICIENT_RESOURCES;
            __DBGPRINT(("ERROR: ExAllocatePoolWithTag failed\n"));
 
            goto clean;
        }
 
        status = AuxKlibQueryModuleInformation(&modulesSize,
                                               sizeof(AUX_MODULE_EXTENDED_INFO),
                                               modulesBuffer);
        if (status == STATUS_BUFFER_TOO_SMALL)
        {
            ExFreePoolWithTag(modulesBuffer, WDFLDR_TAG);
            continue;
        }
        else
        {
            break;
        }
    }
 
    if (NT_SUCCESS(status))
    {
        for (SIZE_T i = 0; i < modulesSize / sizeof(AUX_MODULE_EXTENDED_INFO); i++)
        {
            // Compare our image name to names returned by AuxKlib
            if (modulesBuffer[i].FileNameOffset < AUX_KLIB_MODULE_PATH_LEN &&
                _strnicmp(&modulesBuffer[i].FullPathName[modulesBuffer[i].FileNameOffset],
                          ansiImageName.Buffer, ansiImageName.Length) == 0)
            {
                *ImageBase = modulesBuffer[i].BasicInfo.ImageBase;
                *ImageSize = modulesBuffer[i].ImageSize;
                break;
            }
        }
    }
    else
    {
        __DBGPRINT(("ERROR: AuxKlibQueryModuleInformation failed with Status 0x%x\n", status));
    }
 
    ExFreePoolWithTag(modulesBuffer, WDFLDR_TAG);
 
clean:
    RtlFreeAnsiString(&ansiImageName);
    return status;
}

Referenced by ClassCreate(), DECLARE_INTERFACE_(), LibraryLinkInClient(), and WdfRegisterLibrary().

GetImageName()

NTSTATUS GetImageName	(	_In_ PCUNICODE_STRING	ServicePath,
		_In_ PUNICODE_STRING	ImageName
	)

GetNameFromPath()

VOID GetNameFromPath	(	_In_ PCUNICODE_STRING	Path,
		_Out_ PUNICODE_STRING	Name
	)

Definition at line 54 of file fxtelemetry.cpp.

{
    BOOLEAN foundSlash;
 
    ASSERT(Path != NULL);
 
    //
    // Ideally a check of Path->Length == 0 would be sufficient except that
    // PreFAST thinks that Length can be odd, so it thinks Length == 1 is possible.
    // Comparing Length < sizeof(WCHAR) satisfies PreFAST and keeps the logic
    // at runtime correct.
    //
    if (Path->Length < sizeof(WCHAR)) {
        RtlZeroMemory(Name, sizeof(UNICODE_STRING));
        return;
    }
 
    //
    // Initialize Name to point to the last WCHAR of the buffer and we will work
    // our way backwards to the beginning of the string or a '\'
    //
 
    Name->Buffer = WDF_PTR_ADD_OFFSET_TYPE(Path->Buffer,
                                           Path->Length - sizeof(WCHAR),
                                           PWCH);
    Name->Length = sizeof(WCHAR);
    foundSlash = FALSE;
 
    while (Name->Buffer >= Path->Buffer) {
        if (*Name->Buffer == L'\\') {
            //
            // Skip the \ in the buffer moving forward a character and adjusting
            // the length
            //
            foundSlash = TRUE;
            Name->Buffer++;
            Name->Length -= sizeof(WCHAR);
            break;
        }
 
        //
        // Move backwards in the string
        //
        Name->Buffer--;
        Name->Length += sizeof(WCHAR);
    }
 
    if (foundSlash && Name->Length == 0) {
        //
        // Handle the case where a slash was found and it is the only character
        //
        Name->Buffer = NULL;
    }
    else if (foundSlash == FALSE) {
        //
        // Handle the case where no slash was found. In this case, Name->Buffer
        // points to one WCHAR before the beginning of the string.
        //
        Name->Length -= sizeof(WCHAR);
        Name->Buffer++;
    }
 
    //
    // Need to set MaximumLength to the same value as Length so that the struct
    // format is valid.
    //
    Name->MaximumLength = Name->Length;
}

Referenced by GetImageName().

GetVersionServicePath()

NTSTATUS GetVersionServicePath	(	_In_ PWDF_BIND_INFO	BindInfo,
		_Out_ PUNICODE_STRING	ServicePath
	)

Get service path from bind info and registry.

Parameters

BindInfo	Bind information
ServicePath	Service path in registry

Returns

STATUS_SUCCESS on success, error code otherwise

Definition at line 141 of file registry.c.

{
    NTSTATUS status;
    PKEY_VALUE_PARTIAL_INFORMATION pKeyVal = NULL;
    HANDLE handleRegKey = NULL;
    UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"Service");
 
    status = GetVersionRegistryHandle(BindInfo, &handleRegKey);
 
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("ERROR: GetVersionRegistryHandle failed with Status 0x%x\n", status));
    }
    else
    {
        // get service name
        status = FxLdrQueryData(handleRegKey, &ValueName, WDFLDR_TAG, &pKeyVal);
 
        if (!NT_SUCCESS(status))
        {
            __DBGPRINT(("ERROR: QueryData failed with status 0x%x\n", status));
        }
        else
        {
            status = BuildServicePath(pKeyVal, ServicePath);
        }
    }
 
    if (!NT_SUCCESS(status))
    {
        status = GetDefaultServiceName(BindInfo, ServicePath);
 
        if (!NT_SUCCESS(status))
        {
            __DBGPRINT(("ERROR: GetVersionServicePath failed with Status 0x%x\n", status));
        }
    }
    else
    {
        __DBGPRINT(("(%wZ)\n", ServicePath));
    }
 
    if (handleRegKey != NULL)
        ZwClose(handleRegKey);
    if (pKeyVal != NULL)
        ExFreePoolWithTag(pKeyVal, WDFLDR_TAG);
 
    return status;
}

Referenced by ReferenceVersion().

LibraryAcquireClientLock()

BOOLEAN LibraryAcquireClientLock

(

_In_ PLIBRARY_MODULE

LibModule

)

Definition at line 365 of file library.c.

{
    KeEnterCriticalRegion();
    return ExAcquireResourceExclusiveLite(&LibModule->ClientsListLock, TRUE);
}

Referenced by ClassLinkInClient(), ClassUnlinkClient(), LibraryLinkInClient(), and LibraryUnlinkClient().

LibraryAddToClassListLocked()

PLIST_ENTRY LibraryAddToClassListLocked	(	_In_ PLIBRARY_MODULE	LibModule,
		_In_ PCLASS_MODULE	ClassModule
	)

Definition at line 673 of file class.c.

{
    PLIST_ENTRY result;
 
    if (!LibModule || !ClassModule)
        return NULL;
 
    result = &ClassModule->LibraryLinkage;
    InsertHeadList(&LibModule->ClassListHead, &ClassModule->LibraryLinkage);
 
    DPRINT_VERBOSE(("Added class %wZ to library %wZ\n",
                   &ClassModule->Service, &LibModule->ServicePath));
 
    return result;
}

Referenced by ReferenceClassVersion(), and WdfRegisterClassLibrary().

LibraryClose()

VOID LibraryClose

(

_Inout_ PLIBRARY_MODULE

LibModule

)

Dereferences KMDF library's device object.

Definition at line 195 of file library.c.

{
    if (LibModule->LibraryFileObject != NULL)
    {
        ObDereferenceObject(LibModule->LibraryFileObject);
        LibModule->LibraryFileObject = NULL;
    }
}

Referenced by DllUnload(), LibraryDereference(), and LibraryUnload().

LibraryCreate()

NTSTATUS LibraryCreate	(	_In_opt_ PWDF_LIBRARY_INFO	LibraryInfo,
		_In_ PCUNICODE_STRING	ServicePath,
		_Out_ PLIBRARY_MODULE *	OutLibraryModule
	)

Referenced by LibraryFindOrLoad(), and WdfRegisterLibrary().

LibraryDereference()

VOID LibraryDereference

(

_In_ PLIBRARY_MODULE

LibModule

)

Definition at line 300 of file library.c.

{
    BOOLEAN cleanupNeeded = FALSE;
 
    FxLdrAcquireLoadedModuleLock();
    if (InterlockedDecrement(&LibModule->LibraryRefCount) == 0)
    {
        if (!IsListEmpty(&LibModule->LibraryListEntry))
        {
            RemoveEntryList(&LibModule->LibraryListEntry);
            InitializeListHead(&LibModule->LibraryListEntry); // Indicate removal process
            cleanupNeeded = TRUE;
        }
    }
    FxLdrReleaseLoadedModuleLock();
 
    if (cleanupNeeded)
    {
        if (LibModule->LibraryInfo)
            LibraryUnload(LibModule);
        else
            LibraryClose(LibModule);
        LibraryFree(LibModule);
    }
}

Referenced by LibraryFindOrLoad(), WdfRegisterLibrary(), WdfVersionBind(), and WdfVersionUnbind().

LibraryFindOrLoad()

NTSTATUS LibraryFindOrLoad	(	_In_ PCUNICODE_STRING	ServicePath,
		_Out_ PLIBRARY_MODULE *	LibModule
	)

Definition at line 206 of file library.c.

{
    BOOLEAN loadNeeded = FALSE;
    NTSTATUS status;
 
    FxLdrAcquireLoadedModuleLock();
    PLIBRARY_MODULE pLibModule = FindLibraryByServicePathLocked(ServicePath);
 
    if (pLibModule == NULL)
    {
        // Client driver is loaded before the library, we need to create it here
        status = LibraryCreate(NULL, ServicePath, &pLibModule);
        if (NT_SUCCESS(status))
        {
            loadNeeded = TRUE;
        }
    }
    else
    {
        status = STATUS_SUCCESS;
    }
 
    // Reference the library
    if (pLibModule)
        InterlockedIncrement(&pLibModule->LibraryRefCount);
 
    FxLdrReleaseLoadedModuleLock();
 
    // We've just created a library, time to load the actual driver
    if (loadNeeded)
    {
        // This will call WdfRegisterLibrary (as part of KMDF's DriverEntry)
        status = ZwLoadDriver((PUNICODE_STRING)ServicePath);
        if (NT_SUCCESS(status) && !pLibModule->LibraryInfo)
        {
            __DBGPRINT(("ZwLoadDriver(%wZ) succeeded but Libray information was returned\n",
                        ServicePath));
            status = STATUS_NOT_SAFE_MODE_DRIVER;
        }
        else if (!NT_SUCCESS(status))
        {
            __DBGPRINT(("ZwLoadDriver(%wZ) failed with status %x\n", ServicePath, status));
        }
 
        if (!NT_SUCCESS(status))
        {
            LibraryDereference(pLibModule);
            // Cleanup created library
            ASSERT(pLibModule->LibraryInfo == NULL);
            LibraryDereference(pLibModule);
            pLibModule = NULL;
        }
    }
 
    *LibModule = pLibModule;
    return status;
}

Referenced by ReferenceVersion().

LibraryFree()

VOID LibraryFree

(

_In_ PLIBRARY_MODULE

LibModule

)

Definition at line 13 of file library.c.

{
    DPRINT_TRACE_ENTRY();
 
    if (!LibModule)
    {
        DPRINT_ERROR(("LibModule is NULL\n"));
        return;
    }
 
    if (LibModule->ServicePath.Buffer)
    {
        RtlFreeUnicodeString(&LibModule->ServicePath);
        LibModule->ServicePath.Buffer = NULL;
    }
 
    if (LibModule->ImageName.Buffer)
    {
        RtlFreeUnicodeString(&LibModule->ImageName);
        LibModule->ImageName.Buffer = NULL;
    }
 
    ExDeleteResourceLite(&LibModule->ClientsListLock);
    RtlZeroMemory(LibModule, sizeof(*LibModule));
    ExFreePoolWithTag(LibModule, WDFLDR_TAG);
 
    DPRINT_TRACE_EXIT();
}

Referenced by DllUnload(), LibraryDereference(), and LibraryUnload().

LibraryLinkInClient()

NTSTATUS LibraryLinkInClient	(	_In_ PLIBRARY_MODULE	LibModule,
		_In_ PUNICODE_STRING	ServicePath,
		_In_ PWDF_BIND_INFO	BindInfo,
		_In_ PVOID	Context,
		_Out_ PCLIENT_MODULE *	OutClientModule
	)

Create client module and add it to library client list.

Parameters

LibModule	Library that client is being added to
ServicePath	Client driver service registry path
BindInfo	Bind information
Context	Client context
OutClientModule	Created client module added to library clients list

Returns

STATUS_SUCCESS on success, error code otherwise

Definition at line 404 of file library.c.

{
    PCLIENT_MODULE clientModule;
    NTSTATUS status;
 
    clientModule = ExAllocatePoolWithTag(NonPagedPool, sizeof(*clientModule), WDFLDR_TAG);
 
    if (clientModule == NULL)
    {
        __DBGPRINT(("ERROR: ExAllocatePoolWithTag failed\n"));
        __DBGPRINT(("ERROR: Client module NOT linked\n"));
 
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    *clientModule = (CLIENT_MODULE){
        .Context = Context,
        .Info = BindInfo
    };
 
    InitializeListHead(&clientModule->ClassListHead);
    InitializeListHead(&clientModule->LibListEntry);
 
    status = GetImageName(ServicePath, &clientModule->ImageName);
    if (NT_SUCCESS(status))
    {
        __DBGPRINT(("Client Image Name: %wZ\n", &clientModule->ImageName));
 
        status = GetImageInfo(&clientModule->ImageName,
                              &clientModule->ImageAddr,
                              &clientModule->ImageSize);
        if (!NT_SUCCESS(status))
        {
            __DBGPRINT(("GetImageInfo failed with status 0x%x\n", status));
            __DBGPRINT(("ERROR: Client module NOT linked\n"));
            ClientFree(clientModule);
 
            return status;
        }
    }
 
    LibraryAcquireClientLock(LibModule);
    InsertHeadList(&LibModule->ClientsListHead, &clientModule->LibListEntry);
    InterlockedIncrement(&LibModule->ClientRefCount);
    LibraryReleaseClientLock(LibModule);
 
    *OutClientModule = clientModule;
    return STATUS_SUCCESS;
}

Referenced by WdfVersionBind().

LibraryOpen()

NTSTATUS LibraryOpen	(	_Inout_ PLIBRARY_MODULE	LibModule,
		_In_ PCUNICODE_STRING	ObjectName
	)

Opens KMDF library's driver object by its name and fills some library structure data.

Parameters

LibModule	Library module to update
ObjectName	Device object name

Returns

STATUS_SUCCESS on success, error code otherwise

Definition at line 167 of file library.c.

{
    PDEVICE_OBJECT deviceObject;
 
    if (ObjectName == NULL)
    {
        return STATUS_SUCCESS;
    }
 
    NTSTATUS status = IoGetDeviceObjectPointer((PUNICODE_STRING)ObjectName,
                                               FILE_READ_DATA,
                                               &LibModule->LibraryFileObject,
                                               &deviceObject);
 
    if (NT_SUCCESS(status))
    {
        LibModule->LibraryDriverObject = deviceObject->DriverObject;
    }
 
    return status;
}

Referenced by WdfRegisterLibrary().

LibraryReference()

VOID LibraryReference

(

_In_ PLIBRARY_MODULE

LibModule

)

Definition at line 267 of file library.c.

{
    FxLdrAcquireLoadedModuleLock();
    InterlockedIncrement(&LibModule->LibraryRefCount);
    FxLdrReleaseLoadedModuleLock();
}

Referenced by WdfVersionUnbind().

LibraryReleaseClientLock()

VOID LibraryReleaseClientLock

(

_In_ PLIBRARY_MODULE

LibModule

)

Definition at line 373 of file library.c.

{
    ExReleaseResourceLite(&LibModule->ClientsListLock);
    KeLeaveCriticalRegion();
}

Referenced by ClassLinkInClient(), ClassUnlinkClient(), LibraryLinkInClient(), and LibraryUnlinkClient().

LibraryReleaseReference()

VOID NTAPI LibraryReleaseReference

(

_In_ PLIBRARY_MODULE

LibModule

)

Release a reference to a library module.

Definition at line 280 of file library.c.

{
    LONG refCount;
    DPRINT_TRACE_ENTRY();
 
    refCount = InterlockedDecrement(&LibModule->LibraryRefCount);
    DPRINT_VERBOSE(("Released reference to library %wZ, RefCount=%d\n",
                   &LibModule->ServicePath, refCount));
 
    if (refCount <= 0)
    {
        DPRINT(("Library %wZ reference count reached zero, unloading\n", &LibModule->ServicePath));
        LibraryUnload(LibModule);
    }
 
    DPRINT_TRACE_EXIT();
}

Referenced by DereferenceVersion().

LibraryUnlinkClient()

BOOLEAN LibraryUnlinkClient	(	_In_ PLIBRARY_MODULE	LibModule,
		_In_ PWDF_BIND_INFO	BindInfo
	)

Definition at line 475 of file library.c.

{
    LibraryAcquireClientLock(LibModule);
 
    // search in library clients entry to remove
    BOOLEAN found = FALSE;
    PCLIENT_MODULE clientModule;
    for (PLIST_ENTRY entry = LibModule->ClientsListHead.Flink;
         entry != &LibModule->ClientsListHead;
         entry = entry->Flink)
    {
        clientModule = CONTAINING_RECORD(entry, CLIENT_MODULE, LibListEntry);
        if (clientModule->Info == BindInfo)
        {
            found = TRUE;
            break;
        }
    }
 
    if (found)
    {
        RemoveEntryList(&clientModule->LibListEntry);
        LibraryClientDereference(LibModule);
    }
 
    LibraryReleaseClientLock(LibModule);
 
    if (found)
    {
        InitializeListHead(&clientModule->LibListEntry);
        ClientFree(clientModule);
        return TRUE;
    }
 
    __DBGPRINT(("ERROR: Client module %p, bind %p NOT found\n", LibModule, BindInfo));
    return FALSE;
}

Referenced by DereferenceVersion(), and WdfVersionUnbind().

LibraryUnload()

VOID LibraryUnload

(

_In_ PLIBRARY_MODULE

LibModule

)

Definition at line 328 of file library.c.

{
    NTSTATUS status;
 
    /* This occurs because of how WDF ClassDrivers behave. */
    if (LibModule->IsBootDriver)
        return;
 
    ASSERT(LibModule->LibraryInfo);
 
    status = LibModule->LibraryInfo->LibraryDecommission();
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("LibraryDecommission failed %X\n", status));
    }
 
    LibModule->LibraryInfo = NULL;
 
    __DBGPRINT(("Unloading library %wZ\n", &LibModule->ServicePath));
 
    LibraryClose(LibModule);
 
    status = ZwUnloadDriver(&LibModule->ServicePath);
    if (!NT_SUCCESS(status))
    {
        __DBGPRINT(("unload of %wZ returned 0x%x (this may not be a true error if someone else attempted to stop"
            " the service first)\n",
            &LibModule->ServicePath,
            status));
    }
 
    // Free the library module directly - caller handles the cleanup sequence
    LibraryFree(LibModule);
}

LibraryUnloadClasses()

PLIST_ENTRY LibraryUnloadClasses

(

_In_ PLIBRARY_MODULE

LibModule

)

Definition at line 636 of file class.c.

{
    PLIST_ENTRY classListHead;
    PLIST_ENTRY entry;
    PCLASS_MODULE pClassModule;
    LIST_ENTRY removedList;
 
    InitializeListHead(&removedList);
    classListHead = &LibModule->ClassListHead;
 
    if (IsListEmpty(classListHead))
        return classListHead;
 
    while (!IsListEmpty(classListHead))
    {
        entry = RemoveHeadList(classListHead);
        InsertTailList(&removedList, entry);
    }
 
    while (!IsListEmpty(&removedList))
    {
        entry = RemoveHeadList(&removedList);
        InitializeListHead(entry);
        pClassModule = CONTAINING_RECORD(entry, CLASS_MODULE, LibraryLinkage);
 
        __DBGPRINT(("Unload class library %wZ (%p)\n", &pClassModule->Service, pClassModule));
 
        ClassUnload(pClassModule, 0);
        if (InterlockedExchangeAdd(&pClassModule->ClassRefCount, -1) == 1)
            ClassCleanupAndFree(pClassModule);
    }
 
    return classListHead;
}

Referenced by DllUnload().

ReferenceClassVersion()

NTSTATUS ReferenceClassVersion	(	_In_ PWDF_CLASS_BIND_INFO	ClassBindInfo,
		_In_ PWDF_BIND_INFO	BindInfo,
		_Out_ PCLASS_MODULE *	ClassModule
	)

Definition at line 423 of file class.c.

{
    PWDF_BIND_INFO pBindInfo;
    PCLASS_MODULE pClassModule;
    UNICODE_STRING driverServiceName;
    PLIBRARY_MODULE pLibModule;
    BOOLEAN created;
    NTSTATUS status;
 
    *ClassModule = NULL;
    pBindInfo = BindInfo;
    created = FALSE;
    status = GetClassServicePath(ClassBindInfo, BindInfo, &driverServiceName);
 
    if (!NT_SUCCESS(status))
    {
        RtlFreeUnicodeString(&driverServiceName);
        return status;
    }
    FxLdrAcquireLoadedModuleLock();
    pClassModule = FindClassByServiceNameLocked(&driverServiceName, &pLibModule);
 
    if (!pLibModule)
    {
        pLibModule = pBindInfo->Module;
    }
 
    if (pLibModule == pBindInfo->Module)
    {
        if (pClassModule)
        {
            InterlockedExchangeAdd(&pClassModule->ClassRefCount, 1);
        }
        else
        {
            pClassModule = ClassCreate(NULL, pLibModule, &driverServiceName);
 
            if (pClassModule)
            {
                InterlockedExchangeAdd(&pClassModule->ClassRefCount, 1);
                LibraryAddToClassListLocked(pLibModule, pClassModule);
                created = TRUE;
            }
            else
            {
                status = STATUS_INSUFFICIENT_RESOURCES;
            }
        }
    }
    else
    {
        status = STATUS_REVISION_MISMATCH;
 
        __DBGPRINT(("class %S bound to library %p,client bound to library %p, status 0x%x\n",
                ClassBindInfo->ClassName,
                pLibModule,
                pBindInfo->Module,
                status));
    }
    FxLdrReleaseLoadedModuleLock();
 
    if (!created)
    {
        if (!NT_SUCCESS(status))
            goto clean;
 
        ClassBindInfo->ClassModule = pClassModule;
        *ClassModule = pClassModule;
    }
 
    /* Class logic: Only call ZwLoadDriver if:
     * 1. Class module was newly created, OR
     * 2. Class module exists but has no ClassLibraryInfo
     */
    if (created || (pClassModule && !pClassModule->ClassLibraryInfo))
    {
 
        status = ZwLoadDriver(&driverServiceName);
        if (!NT_SUCCESS(status))
        {
 
            if (status == STATUS_OBJECT_PATH_NOT_FOUND ||
                status == STATUS_OBJECT_NAME_NOT_FOUND ||
                status == STATUS_IMAGE_ALREADY_LOADED)
            {
                /* Driver might already be loaded as boot driver - UCX*/
                status = STATUS_SUCCESS;
            }
        }
        else if (pClassModule && !pClassModule->ClassLibraryInfo)
        {
            status = STATUS_DRIVER_INTERNAL_ERROR;
        }
    }
    else
    {
        /* Class module exists and has ClassLibraryInfo - skip ZwLoadDriver */
        status = STATUS_SUCCESS;
    }
 
    /* Always set the class module regardless of ZwLoadDriver result (Again.. UCX) */
    if (pClassModule && NT_SUCCESS(status))
    {
        ClassBindInfo->ClassModule = pClassModule;
        *ClassModule = pClassModule;
 
        InterlockedExchangeAdd(&pClassModule->ClientRefCount, 1);
        goto exit_success;
    }
 
clean:
    if (pClassModule && InterlockedExchangeAdd(&pClassModule->ClassRefCount, -1) == 1)
        ClassCleanupAndFree(pClassModule);
 
exit_success:
 
    RtlFreeUnicodeString(&driverServiceName);
 
    return status;
}

Referenced by WdfVersionBindClass().

ReferenceVersion()

NTSTATUS NTAPI ReferenceVersion	(	_In_ PWDF_BIND_INFO	Info,
		_Out_ PLIBRARY_MODULE *	Module
	)

Reference a WDF library version.

Parameters

Info	Binding information containing version details
Module	Pointer to receive the library module

Returns

NTSTATUS Success or failure status

Definition at line 576 of file wdfldr.c.

{
    NTSTATUS status;
    UNICODE_STRING libraryServicePath = { 0 };
 
    DPRINT_TRACE_ENTRY();
 
    if (!Info || !Module)
    {
        DPRINT_ERROR(("Invalid parameters: Info=%p, Module=%p\n", Info, Module));
        return STATUS_INVALID_PARAMETER;
    }
 
    *Module = NULL;
    /* Multiple ways to find the correct library - once again UCX stresses this extensively */
    status = GetVersionServicePath(Info, &libraryServicePath);
    if (!NT_SUCCESS(status))
    {
        DPRINT_ERROR(("GetVersionServicePath failed with status 0x%x\n", status));
        goto Exit;
    }
 
    status = LibraryFindOrLoad(&libraryServicePath, Module);
    if (NT_SUCCESS(status))
    {
        Info->Module = *Module;
        DPRINT_VERBOSE(("Referenced version for library %wZ\n", &libraryServicePath));
    }
    else
    {
        DPRINT_ERROR(("LibraryFindOrLoad failed with status 0x%x\n", status));
    }
 
Exit:
    if (libraryServicePath.Buffer)
    {
        RtlFreeUnicodeString(&libraryServicePath);
    }
 
    DPRINT_TRACE_EXIT();
    return status;
}

Referenced by WdfVersionBind().

ServiceCheckBootStart()

BOOLEAN ServiceCheckBootStart

(

_In_ PUNICODE_STRING

Service

)

Definition at line 194 of file registry.c.

{
    NTSTATUS status;
    OBJECT_ATTRIBUTES objectAttributes;
    HANDLE keyHandle = NULL;
    BOOLEAN result = FALSE;
    ULONG value;
    UNICODE_STRING valueName = RTL_CONSTANT_STRING(L"Start");
 
    InitializeObjectAttributes(&objectAttributes, Service, OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE, NULL, NULL);
    status = ZwOpenKey(&keyHandle, KEY_READ, &objectAttributes);
 
    if (status != STATUS_OBJECT_NAME_NOT_FOUND)
    {
        if (NT_SUCCESS(status))
        {
            status = FxLdrQueryUlong(keyHandle, &valueName, &value);
            if (NT_SUCCESS(status))
            {
                result = value == 0;
            }
        }
        else
        {
            __DBGPRINT(("ZwOpenKey(%wZ) failed: %08X\n", Service, status));
        }
    }
 
    if (keyHandle)
        ZwClose(keyHandle);
 
    return result;
}

Referenced by ClassCreate().

Variable Documentation

WdfLdrDiags

WDFLDR_DIAGS WdfLdrDiags

extern

Definition at line 27 of file wdfldr.c.

Referenced by DereferenceVersion(), DllInitialize(), and WdfRegisterClassLibrary().

WdfLdrGlobals

WDF_LDR_GLOBALS WdfLdrGlobals

extern

Definition at line 28 of file wdfldr.c.

Referenced by _Requires_lock_held_(), DllInitialize(), DllUnload(), FindClassByServiceNameLocked(), FxLdrAcquireLoadedModuleLock(), FxLdrReleaseLoadedModuleLock(), if(), and WdfRegisterClassLibrary().