fxtelemetrykm.hpp File Reference

#include "fxldr.h"

Include dependency graph for fxtelemetrykm.hpp:

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

Go to the source code of this file.

Classes
union	FxTelemetryDriverInfo

Macros
#define	KMDF_CENSUS_EVT_WRITE_DEVICE_START(TraceHandle, Globals, DriverConfig, SetupClass, BusEnum, HwID, Manafacturer)
#define	TraceLoggingKmdfDriverConfigInfo(info, fieldName)

Functions
VOID	RegistryWriteCurrentTime (_In_ PFX_DRIVER_GLOBALS DriverGlobals)
VOID	RegistryReadLastLoggedTime (_In_ PFX_DRIVER_GLOBALS DriverGlobals, _Out_ PLARGE_INTEGER CurrentTime)
NTSTATUS	GetHardwareIdAndSetupclassFromRegistry (_In_ FxDevice *Fdo, _Out_ PUNICODE_STRING HwIds, _Out_ PUNICODE_STRING SetupClass)
BOOLEAN	IsLoggingEnabledAndNeeded (_In_ PFX_DRIVER_GLOBALS DriverGlobals)
_Must_inspect_result_ NTSTATUS	FxQueryData (_In_ PFX_DRIVER_GLOBALS DriverGlobals, _In_ HANDLE Key, _In_ PCUNICODE_STRING ValueName, _In_ ULONG Tag, _Out_ PKEY_VALUE_PARTIAL_INFORMATION *Info)
VOID	GetDriverInfo (_In_ PFX_DRIVER_GLOBALS Globals, _In_opt_ FxDevice *Fdo, _Out_ FxTelemetryDriverInfo *DriverInfo)
VOID	FxGetDevicePropertyString (_In_ FxDevice *Fdo, _In_ DEVICE_REGISTRY_PROPERTY DeviceProperty, _Out_ PUNICODE_STRING PropertyString)
VOID	GetFirstHardwareId (_Inout_ PUNICODE_STRING HardwareIds)
_Must_inspect_result_	__drv_maxIRQL (PASSIVE_LEVEL) NTSTATUS QueryAndAllocString(_In_ HANDLE Key

Variables
_Must_inspect_result_ _In_ PFX_DRIVER_GLOBALS	Globals
_Must_inspect_result_ _In_ PFX_DRIVER_GLOBALS _In_ PCUNICODE_STRING	ValueName
_Must_inspect_result_ _In_ PFX_DRIVER_GLOBALS _In_ PCUNICODE_STRING _Out_ PKEY_VALUE_PARTIAL_INFORMATION *	Info

Macro Definition Documentation

KMDF_CENSUS_EVT_WRITE_DEVICE_START

#define KMDF_CENSUS_EVT_WRITE_DEVICE_START	(		TraceHandle,
			Globals,
			DriverConfig,
			SetupClass,
			BusEnum,
			HwID,
			Manafacturer
	)

Value:

            TraceLoggingWrite(TraceHandle,                                                                                  \
                "KmdfCensusEvtDeviceStart",                                                                                 \
                WDF_TELEMETRY_EVT_KEYWORDS,                                                                                 \
                WDF_CENSUS_EVT_DATA_COMMON(Globals),                                                                        \
                TraceLoggingString((Globals)->Public.DriverName,            "DriverServiceName"),                           \
                TraceLoggingKmdfDriverConfigInfo(DriverConfig,              "DriverConfigInfo"),                            \
                TraceLoggingWideString(SetupClass.m_UnicodeString.Buffer,   "SetupClass"),                                  \
                TraceLoggingWideString(BusEnum.m_UnicodeString.Buffer,      "BusEnumerator"),                               \
                TraceLoggingWideString(HwID.m_UnicodeString.Buffer,         "HardwareId"),                                  \
                TraceLoggingWideString(Manafacturer.m_UnicodeString.Buffer, "ManufacturerString")                           \
            );

Definition at line 47 of file fxtelemetrykm.hpp.

TraceLoggingKmdfDriverConfigInfo

#define TraceLoggingKmdfDriverConfigInfo	(		info,
			fieldName
	)

Value:

    \
    TraceLoggingStruct(23, fieldName),  \
    \
    TraceLoggingUInt8(info.bitmap.IsNonPnpDriver,                           "IsNonPnpDriver"                        ), \
    TraceLoggingUInt8(info.bitmap.IsNoDispatchOverride,                     "IsNoDispatchOverride"                  ), \
    TraceLoggingUInt8(info.bitmap.IsVerifierOn,                             "IsVerifierOn"                          ), \
    TraceLoggingUInt8(info.bitmap.IsEnhancedVerifierOn,                     "IsEnhancedVerifierOn"                  ), \
    TraceLoggingUInt8(info.bitmap.IsFilter,                                 "IsFilter"                              ), \
    \
    TraceLoggingUInt8(info.bitmap.IsUsingRemoveLockOption,                  "IsUsingRemoveLockOption"               ), \
    TraceLoggingUInt8(info.bitmap.IsUsingNonDefaultHardwareReleaseOrder,    "IsUsingNonDefaultHardwareReleaseOrder" ), \
    TraceLoggingUInt8(info.bitmap.IsPowerPolicyOwner,                       "IsPowerPolicyOwner"                    ), \
    TraceLoggingUInt8(info.bitmap.IsS0IdleWakeFromS0Enabled,                "IsS0IdleWakeFromS0Enabled"             ), \
    TraceLoggingUInt8(info.bitmap.IsS0IdleUsbSSEnabled,                     "IsS0IdleUsbSSEnabled"                  ), \
    \
    TraceLoggingUInt8(info.bitmap.IsS0IdleSystemManaged,                    "IsS0IdleSystemManaged"                 ), \
    TraceLoggingUInt8(info.bitmap.IsSxWakeEnabled,                          "IsSxWakeEnabled"                       ), \
    TraceLoggingUInt8(info.bitmap.IsUsingLevelTriggeredLineInterrupt,       "IsUsingLevelTriggeredLineInterrupt"    ), \
    TraceLoggingUInt8(info.bitmap.IsUsingEdgeTriggeredLineInterrupt,        "IsUsingEdgeTriggeredLineInterrupt"     ), \
    TraceLoggingUInt8(info.bitmap.IsUsingMsiXOrSingleMsi22Interrupt,        "IsUsingMsiXOrSingleMsi22Interrupt"     ), \
    \
    TraceLoggingUInt8(info.bitmap.IsUsingMsi22MultiMessageInterrupt,        "IsUsingMsi22MultiMessageInterrupt"     ), \
    TraceLoggingUInt8(info.bitmap.IsUsingMultipleInterrupt,                 "IsUsingMultipleInterrupt"              ), \
    TraceLoggingUInt8(info.bitmap.IsUsingPassiveLevelInterrupt,             "IsUsingPassiveLevelInterrupt"          ), \
    TraceLoggingUInt8(info.bitmap.IsUsingBusMasterDma,                      "IsUsingBusMasterDma"                   ), \
    TraceLoggingUInt8(info.bitmap.IsUsingSystemDma,                         "IsUsingSystemDma"                      ), \
    \
    TraceLoggingUInt8(info.bitmap.IsUsingSystemDmaDuplex,                   "IsUsingSystemDmaDuplex"                ), \
    TraceLoggingUInt8(info.bitmap.IsUsingStaticBusEnumration,               "IsUsingStaticBusEnumration"            ), \
    TraceLoggingUInt8(info.bitmap.IsUsingDynamicBusEnumeration,             "IsUsingDynamicBusEnumeration"          )  \

Definition at line 63 of file fxtelemetrykm.hpp.

Function Documentation

__drv_maxIRQL()

_Must_inspect_result_ __drv_maxIRQL

(

PASSIVE_LEVEL

)

FxGetDevicePropertyString()

VOID FxGetDevicePropertyString	(	_In_ FxDevice *	Fdo,
		_In_ DEVICE_REGISTRY_PROPERTY	DeviceProperty,
		_Out_ PUNICODE_STRING	PropertyString
	)

Definition at line 458 of file fxtelemetrykm.cpp.

{
    MdDeviceObject pdo;
    NTSTATUS status;
    PFX_DRIVER_GLOBALS pFxDriverGlobals = Fdo->GetDriverGlobals();
    ULONG length = 0;
    PVOID buffer = NULL;
 
    ASSERT(PropertyString != NULL);
    RtlZeroMemory(PropertyString, sizeof(UNICODE_STRING));
 
    pdo = Fdo->GetSafePhysicalDevice();
    if (pdo  == NULL) {
        status = STATUS_INVALID_DEVICE_REQUEST;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not get PDO from FDO WDFDEVICE 0x%p, %!STATUS!",
                            Fdo->GetHandle(), status);
        return;
    }
 
    status = FxDevice::_GetDeviceProperty(pdo, DeviceProperty, 0, NULL, &length);
    if (status != STATUS_BUFFER_TOO_SMALL) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not retrieve property %d length %d, %!STATUS!",
                            DeviceProperty, length, status);
        return;
    }
 
    buffer = FxPoolAllocate(pFxDriverGlobals, PagedPool, length);
    if (buffer == NULL) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                "Could not allocate memory for property %d length %d, %!STATUS!",
                DeviceProperty, length, status);
        return;
    }
 
    status = FxDevice::_GetDeviceProperty(pdo, DeviceProperty, length, buffer, &length);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGDEVICE,
                            "Could not query for full buffer, size %d, for "
                            "property %d, %!STATUS!",
                            length, DeviceProperty, status);
        FxPoolFree(buffer);
        return;
    }
 
    PropertyString->Buffer = (PWCH)buffer;
    PropertyString->Length = (USHORT) length - sizeof(UNICODE_NULL);
    PropertyString->MaximumLength = (USHORT) length;
 
    //
    // ensure it's null terminated
    //
    PropertyString->Buffer[PropertyString->Length/sizeof(WCHAR)] = UNICODE_NULL;
}

Referenced by LogDriverInfoStream().

FxQueryData()

_Must_inspect_result_ NTSTATUS FxQueryData	(	_In_ PFX_DRIVER_GLOBALS	DriverGlobals,
		_In_ HANDLE	Key,
		_In_ PCUNICODE_STRING	ValueName,
		_In_ ULONG	Tag,
		_Out_ PKEY_VALUE_PARTIAL_INFORMATION *	Info
	)

GetDriverInfo()

VOID GetDriverInfo	(	_In_ PFX_DRIVER_GLOBALS	Globals,
		_In_opt_ FxDevice *	Fdo,
		_Out_ FxTelemetryDriverInfo *	DriverInfo
	)

Definition at line 287 of file fxtelemetrykm.cpp.

{
    FxPkgPnp* pnpPkg;
    USHORT devInfo = 0;
 
    DriverInfo->bitmap.IsVerifierOn = Globals->FxVerifierOn;
    DriverInfo->bitmap.IsEnhancedVerifierOn = FLAG_TO_BOOL(Globals->FxEnhancedVerifierOptions, FxEnhancedVerifierFunctionTableHookMask);
 
    if (Fdo == NULL) {
        //
        // this is for non-pnp or noDispatchOverride.
        //
        DriverInfo->bitmap.IsNonPnpDriver = FLAG_TO_BOOL(Globals->Public.DriverFlags, WdfDriverInitNonPnpDriver);
        DriverInfo->bitmap.IsNoDispatchOverride = FLAG_TO_BOOL(Globals->Public.DriverFlags, WdfDriverInitNoDispatchOverride);
    }
    else {
        pnpPkg = Fdo->m_PkgPnp;
        devInfo = Fdo->GetDeviceTelemetryInfoFlags();
 
        DriverInfo->bitmap.IsFilter = Fdo->GetFdoPkg()->IsFilter();
        DriverInfo->bitmap.IsUsingRemoveLockOption = Fdo->IsRemoveLockEnabledForIo();
        DriverInfo->bitmap.IsUsingNonDefaultHardwareReleaseOrder = pnpPkg->IsDefaultReleaseHardwareOrder();
        DriverInfo->bitmap.IsPowerPolicyOwner = pnpPkg->IsPowerPolicyOwner();
        DriverInfo->bitmap.IsS0IdleWakeFromS0Enabled =  pnpPkg->IsS0IdleWakeFromS0Enabled();
        DriverInfo->bitmap.IsS0IdleUsbSSEnabled = pnpPkg->IsS0IdleUsbSSEnabled();
        DriverInfo->bitmap.IsS0IdleSystemManaged = pnpPkg->IsS0IdleSystemManaged();
        DriverInfo->bitmap.IsSxWakeEnabled = pnpPkg->IsSxWakeEnabled();
        DriverInfo->bitmap.IsUsingLevelTriggeredLineInterrupt = IsDeviceInfoFlagSet(devInfo, DeviceInfoLineBasedLevelTriggeredInterrupt);
        DriverInfo->bitmap.IsUsingEdgeTriggeredLineInterrupt = IsDeviceInfoFlagSet(devInfo, DeviceInfoLineBasedEdgeTriggeredInterrupt);
        DriverInfo->bitmap.IsUsingMsiXOrSingleMsi22Interrupt = IsDeviceInfoFlagSet(devInfo, DeviceInfoMsiXOrSingleMsi22Interrupt);
        DriverInfo->bitmap.IsUsingMsi22MultiMessageInterrupt = IsDeviceInfoFlagSet(devInfo, DeviceInfoMsi22MultiMessageInterrupt);
        DriverInfo->bitmap.IsUsingMultipleInterrupt = pnpPkg->HasMultipleInterrupts();
        DriverInfo->bitmap.IsUsingPassiveLevelInterrupt = IsDeviceInfoFlagSet(devInfo, DeviceInfoPassiveLevelInterrupt);
        DriverInfo->bitmap.IsUsingBusMasterDma = IsDeviceInfoFlagSet(devInfo, DeviceInfoDmaBusMaster);
        DriverInfo->bitmap.IsUsingSystemDma = IsDeviceInfoFlagSet(devInfo, DeviceInfoDmaSystem);
        DriverInfo->bitmap.IsUsingSystemDmaDuplex = IsDeviceInfoFlagSet(devInfo, DeviceInfoDmaSystemDuplex);
        DriverInfo->bitmap.IsUsingStaticBusEnumration = IsDeviceInfoFlagSet(devInfo, DeviceInfoHasStaticChildren);
        DriverInfo->bitmap.IsUsingDynamicBusEnumeration = IsDeviceInfoFlagSet(devInfo, DeviceInfoHasDynamicChildren);
    }
}

Referenced by LogDriverInfoStream().

GetFirstHardwareId()

VOID GetFirstHardwareId

(

_Inout_ PUNICODE_STRING

HardwareIds

)

Definition at line 229 of file fxtelemetrykm.cpp.

{
    PWCHAR curr;
    USHORT lengthCch;
 
    ASSERT(HardwareIds != NULL);
 
    curr = (PWCHAR) HardwareIds->Buffer;
    lengthCch = (HardwareIds->Length)/sizeof(WCHAR);
 
    //
    // if the caller supplied NULL buffer, then nothing to do.
    //
    if (curr == NULL) {
        RtlInitUnicodeString(HardwareIds, NULL);
        return;
    }
 
    //
    // if the first element is NULL then update the length
    //
    if (*curr == UNICODE_NULL) {
        HardwareIds->Length = 0;
        HardwareIds->MaximumLength = HardwareIds->Length + sizeof(UNICODE_NULL);
        return;
    }
 
    for (int i = 0; i < lengthCch; i++, curr++) {
 
        if (*curr == UNICODE_NULL) {
            //
            // We found the first string. Update size. We only want to keep the
            // first string.
            //
            HardwareIds->Length = (USHORT)(i * sizeof(WCHAR));
            HardwareIds->MaximumLength = HardwareIds->Length + sizeof(UNICODE_NULL);
            return;
        }
    }
}

Referenced by LogDriverInfoStream().

GetHardwareIdAndSetupclassFromRegistry()

NTSTATUS GetHardwareIdAndSetupclassFromRegistry	(	_In_ FxDevice *	Fdo,
		_Out_ PUNICODE_STRING	HwIds,
		_Out_ PUNICODE_STRING	SetupClass
	)

IsLoggingEnabledAndNeeded()

BOOLEAN IsLoggingEnabledAndNeeded

(

_In_ PFX_DRIVER_GLOBALS

DriverGlobals

)

Definition at line 109 of file fxtelemetrykm.cpp.

{
    LARGE_INTEGER lastLoggedTime;
    LARGE_INTEGER currentTime;
    LONGLONG delta;
 
    // If provider is not enabled exit.
    if (FALSE == FX_TELEMETRY_ENABLED(g_TelemetryProvider, DriverGlobals)) {
        return FALSE;
    }
 
    ASSERT(DriverGlobals->TelemetryContext);
 
    //
    // If we already fired an event during PnP start we are done. This avoids
    // repeatedly firing events during PnP rebalance.
    //
    if (InterlockedBitTestAndSet(
            &DriverGlobals->TelemetryContext->DoOnceFlagsBitmap,
            DeviceStartEventBit) != 0) {
        return FALSE;
    }
 
    //
    // log only if it has been MIN_HOURS_BEFORE_NEXT_LOG time since last log.
    // We don't log every time driver loads to avoid sending too much data
    // too many times in  case of a buggy driver going through load/unload cycle
    // or when a device is plugged in two many times.
    //
    lastLoggedTime.QuadPart = 0;
    RegistryReadLastLoggedTime(DriverGlobals, &lastLoggedTime);
 
    if (lastLoggedTime.QuadPart == 0) {
        //
        // driver is loading for first time ater install so need to log
        // event
        //
        return TRUE;
    }
 
    Mx::MxQuerySystemTime(&currentTime);
 
    delta = (currentTime.QuadPart - lastLoggedTime.QuadPart);
 
    DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGDRIVER,
        "lastlogged %I64x, current %I64x, delta %I64x",
        lastLoggedTime.QuadPart, currentTime.QuadPart, delta);
 
    //
    // KeQuerySystemTime returns time in 100-ns. We convert MIN_HOURS_BEFORE_NEXT_LOG
    // to 100-nano sec unit and then compare.
    //
    if (delta < WDF_ABS_TIMEOUT_IN_SEC(MIN_HOURS_BEFORE_NEXT_LOG * 60 * 60)) {
        return FALSE;
    }
 
    return TRUE;
}

Referenced by LogDeviceStartTelemetryEvent().

RegistryReadLastLoggedTime()

VOID RegistryReadLastLoggedTime	(	_In_ PFX_DRIVER_GLOBALS	DriverGlobals,
		_Out_ PLARGE_INTEGER	CurrentTime
	)

Definition at line 333 of file fxtelemetrykm.cpp.

{
    FxAutoRegKey hKey, hWdf;
    DECLARE_CONST_UNICODE_STRING(parametersPath, L"Parameters\\Wdf");
    DECLARE_CONST_UNICODE_STRING(valueName, WDF_LAST_TELEMETRY_LOG_TIME_VALUE);
    LARGE_INTEGER value;
    NTSTATUS status;
 
    ASSERT(LastLoggedTime != NULL);
    LastLoggedTime->QuadPart = 0;
 
    status = FxRegKey::_OpenKey(NULL,
                                DriverGlobals->Driver->GetRegistryPathUnicodeString(),
                                &hWdf.m_Key,
                                KEY_READ);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGDRIVER,
            "Unable to open driver's service key, status %!STATUS!", status);
        return;
    }
 
    status = FxRegKey::_OpenKey(hWdf.m_Key,
                                &parametersPath,
                                &hKey.m_Key,
                                KEY_READ);
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGDRIVER,
            "Unable to open driver's service parameters key, status %!STATUS!",
            status);
        return;
    }
 
    value.QuadPart = 0;
    status = FxRegKey::_QueryQuadWord(
        hKey.m_Key, &valueName, &value);
 
    //
    // Set value only on success.
    //
    if (NT_SUCCESS(status)) {
        LastLoggedTime->QuadPart = value.QuadPart;
    }
}

Referenced by IsLoggingEnabledAndNeeded().

RegistryWriteCurrentTime()

VOID RegistryWriteCurrentTime

(

_In_ PFX_DRIVER_GLOBALS

DriverGlobals

)

Definition at line 381 of file fxtelemetrykm.cpp.

{
    FxAutoRegKey hDriver, hParameters, hWdf;
    DECLARE_CONST_UNICODE_STRING(parametersPart, L"Parameters");
    DECLARE_CONST_UNICODE_STRING(wdfPart, L"Wdf");
    LARGE_INTEGER currentTime;
 
    //
    // Not defined with the macro because ZwSetValue doesn't use
    // PCUNICODE_STRING
    //
    UNICODE_STRING wdfTimeOfLastTelemetryLog;
    NTSTATUS status;
 
    RtlInitUnicodeString(&wdfTimeOfLastTelemetryLog, WDF_LAST_TELEMETRY_LOG_TIME_VALUE);
 
    status = FxRegKey::_OpenKey(NULL,
                                DriverGlobals->Driver->GetRegistryPathUnicodeString(),
                                &hDriver.m_Key,
                                KEY_WRITE | KEY_READ
                                );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGDRIVER,
            "Unable to open driver's service key, status %!STATUS!", status);
        return;
    }
    //
    //  Key creation, unlike user mode, must happen one level at a time, since
    //  create will also open take both steps instead of trying open first
    //
    status = FxRegKey::_Create(hDriver.m_Key,
                               &parametersPart,
                               &hParameters.m_Key,
                               KEY_WRITE | KEY_READ
                               );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGDRIVER,
            "Unable to write Parameters key, status %!STATUS!", status);
        return;
    }
 
    status = FxRegKey::_Create(hParameters.m_Key,
                               &wdfPart,
                               &hWdf.m_Key,
                               KEY_WRITE | KEY_READ
                               );
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGDRIVER,
            "Unable to write Parameters key, status %!STATUS!", status);
        return;
    }
 
    //
    //  Using ZwSetValueKey here to avoid having to change the implementation
    //  in FxRegKey of SetValue to a static / thiscall pair
    //
    currentTime.QuadPart = 0;
    Mx::MxQuerySystemTime(&currentTime);
 
    status = Mx::MxSetValueKey(hWdf.m_Key,
                           &wdfTimeOfLastTelemetryLog,
                           0,
                           REG_QWORD,
                           &currentTime.QuadPart,
                           sizeof(currentTime)
                           );
 
    if (!NT_SUCCESS(status)) {
        DoTraceLevelMessage(DriverGlobals, TRACE_LEVEL_ERROR, TRACINGDRIVER,
            "Failed to record current time for Telemetry log, status %!STATUS!",
            status);
    }
}

Referenced by LogDriverInfoStream().

Variable Documentation

Globals

_Must_inspect_result_ _In_ PFX_DRIVER_GLOBALS Globals

Definition at line 187 of file fxtelemetrykm.hpp.

Info

_Must_inspect_result_ _In_ PFX_DRIVER_GLOBALS _In_ PCUNICODE_STRING _Out_ PKEY_VALUE_PARTIAL_INFORMATION* Info

Definition at line 189 of file fxtelemetrykm.hpp.

ValueName

_Must_inspect_result_ _In_ PFX_DRIVER_GLOBALS _In_ PCUNICODE_STRING ValueName

Definition at line 188 of file fxtelemetrykm.hpp.