//**********************************************************************` //* This is an include file generated by Message Compiler. *` //* *` //* Copyright (c) Microsoft Corporation. All Rights Reserved. *` //**********************************************************************` #pragma once //***************************************************************************** // // Notes on the ETW event code generated by MC: // // - Structures and arrays of structures are treated as an opaque binary blob. // The caller is responsible for packing the data for the structure into a // single region of memory, with no padding between values. The macro will // have an extra parameter for the length of the blob. // - Arrays of nul-terminated strings must be packed by the caller into a // single binary blob containing the correct number of strings, with a nul // after each string. The size of the blob is specified in characters, and // includes the final nul. // - Arrays of SID are treated as a single binary blob. The caller is // responsible for packing the SID values into a single region of memory with // no padding. // - The length attribute on the data element in the manifest is significant // for values with intype win:UnicodeString, win:AnsiString, or win:Binary. // The length attribute must be specified for win:Binary, and is optional for // win:UnicodeString and win:AnsiString (if no length is given, the strings // are assumed to be nul-terminated). For win:UnicodeString, the length is // measured in characters, not bytes. // - For an array of win:UnicodeString, win:AnsiString, or win:Binary, the // length attribute applies to every value in the array, so every value in // the array must have the same length. The values in the array are provided // to the macro via a single pointer -- the caller is responsible for packing // all of the values into a single region of memory with no padding between // values. // - Values of type win:CountedUnicodeString, win:CountedAnsiString, and // win:CountedBinary can be generated and collected on Vista or later. // However, they may not decode properly without the Windows 10 2018 Fall // Update. // - Arrays of type win:CountedUnicodeString, win:CountedAnsiString, and // win:CountedBinary must be packed by the caller into a single region of // memory. The format for each item is a UINT16 byte-count followed by that // many bytes of data. When providing the array to the generated macro, you // must provide the total size of the packed array data, including the UINT16 // sizes for each item. In the case of win:CountedUnicodeString, the data // size is specified in WCHAR (16-bit) units. In the case of // win:CountedAnsiString and win:CountedBinary, the data size is specified in // bytes. // //***************************************************************************** #include #include #include #ifndef ETW_INLINE #ifdef _ETW_KM_ // In kernel mode, save stack space by never inlining templates. #define ETW_INLINE DECLSPEC_NOINLINE __inline #else // In user mode, save code size by inlining templates as appropriate. #define ETW_INLINE __inline #endif #endif // ETW_INLINE #if defined(__cplusplus) extern "C" { #endif // // MCGEN_DISABLE_PROVIDER_CODE_GENERATION macro: // Define this macro to have the compiler skip the generated functions in this // header. // #ifndef MCGEN_DISABLE_PROVIDER_CODE_GENERATION // // MCGEN_USE_KERNEL_MODE_APIS macro: // Controls whether the generated code uses kernel-mode or user-mode APIs. // - Set to 0 to use Windows user-mode APIs such as EventRegister. // - Set to 1 to use Windows kernel-mode APIs such as EtwRegister. // Default is based on whether the _ETW_KM_ macro is defined (i.e. by wdm.h). // Note that the APIs can also be overridden directly, e.g. by setting the // MCGEN_EVENTWRITETRANSFER or MCGEN_EVENTREGISTER macros. // #ifndef MCGEN_USE_KERNEL_MODE_APIS #ifdef _ETW_KM_ #define MCGEN_USE_KERNEL_MODE_APIS 1 #else #define MCGEN_USE_KERNEL_MODE_APIS 0 #endif #endif // MCGEN_USE_KERNEL_MODE_APIS // // MCGEN_HAVE_EVENTSETINFORMATION macro: // Controls how McGenEventSetInformation uses the EventSetInformation API. // - Set to 0 to disable the use of EventSetInformation // (McGenEventSetInformation will always return an error). // - Set to 1 to directly invoke MCGEN_EVENTSETINFORMATION. // - Set to 2 to to locate EventSetInformation at runtime via GetProcAddress // (user-mode) or MmGetSystemRoutineAddress (kernel-mode). // Default is determined as follows: // - If MCGEN_EVENTSETINFORMATION has been customized, set to 1 // (i.e. use MCGEN_EVENTSETINFORMATION). // - Else if the target OS version has EventSetInformation, set to 1 // (i.e. use MCGEN_EVENTSETINFORMATION). // - Else set to 2 (i.e. try to dynamically locate EventSetInformation). // Note that an McGenEventSetInformation function will only be generated if one // or more provider in a manifest has provider traits. // #ifndef MCGEN_HAVE_EVENTSETINFORMATION #ifdef MCGEN_EVENTSETINFORMATION // if MCGEN_EVENTSETINFORMATION has been customized, #define MCGEN_HAVE_EVENTSETINFORMATION 1 // directly invoke MCGEN_EVENTSETINFORMATION(...). #elif MCGEN_USE_KERNEL_MODE_APIS // else if using kernel-mode APIs, #if NTDDI_VERSION >= 0x06040000 // if target OS is Windows 10 or later, #define MCGEN_HAVE_EVENTSETINFORMATION 1 // directly invoke MCGEN_EVENTSETINFORMATION(...). #else // else #define MCGEN_HAVE_EVENTSETINFORMATION 2 // find "EtwSetInformation" via MmGetSystemRoutineAddress. #endif // else (using user-mode APIs) #else // if target OS and SDK is Windows 8 or later, #if WINVER >= 0x0602 && defined(EVENT_FILTER_TYPE_SCHEMATIZED) #define MCGEN_HAVE_EVENTSETINFORMATION 1 // directly invoke MCGEN_EVENTSETINFORMATION(...). #else // else #define MCGEN_HAVE_EVENTSETINFORMATION 2 // find "EventSetInformation" via GetModuleHandleExW/GetProcAddress. #endif #endif #endif // MCGEN_HAVE_EVENTSETINFORMATION // // MCGEN Override Macros // // The following override macros may be defined before including this header // to control the APIs used by this header: // // - MCGEN_EVENTREGISTER // - MCGEN_EVENTUNREGISTER // - MCGEN_EVENTSETINFORMATION // - MCGEN_EVENTWRITETRANSFER // // If the the macro is undefined, the MC implementation will default to the // corresponding ETW APIs. For example, if the MCGEN_EVENTREGISTER macro is // undefined, the EventRegister[MyProviderName] macro will use EventRegister // in user mode and will use EtwRegister in kernel mode. // // To prevent issues from conflicting definitions of these macros, the value // of the override macro will be used as a suffix in certain internal function // names. Because of this, the override macros must follow certain rules: // // - The macro must be defined before any MC-generated header is included and // must not be undefined or redefined after any MC-generated header is // included. Different translation units (i.e. different .c or .cpp files) // may set the macros to different values, but within a translation unit // (within a single .c or .cpp file), the macro must be set once and not // changed. // - The override must be an object-like macro, not a function-like macro // (i.e. the override macro must not have a parameter list). // - The override macro's value must be a simple identifier, i.e. must be // something that starts with a letter or '_' and contains only letters, // numbers, and '_' characters. // - If the override macro's value is the name of a second object-like macro, // the second object-like macro must follow the same rules. (The override // macro's value can also be the name of a function-like macro, in which // case the function-like macro does not need to follow the same rules.) // // For example, the following will cause compile errors: // // #define MCGEN_EVENTWRITETRANSFER MyNamespace::MyClass::MyFunction // Value has non-identifier characters (colon). // #define MCGEN_EVENTWRITETRANSFER GetEventWriteFunctionPointer(7) // Value has non-identifier characters (parentheses). // #define MCGEN_EVENTWRITETRANSFER(h,e,a,r,c,d) EventWrite(h,e,c,d) // Override is defined as a function-like macro. // #define MY_OBJECT_LIKE_MACRO MyNamespace::MyClass::MyEventWriteFunction // #define MCGEN_EVENTWRITETRANSFER MY_OBJECT_LIKE_MACRO // Evaluates to something with non-identifier characters (colon). // // The following would be ok: // // #define MCGEN_EVENTWRITETRANSFER MyEventWriteFunction1 // OK, suffix will be "MyEventWriteFunction1". // #define MY_OBJECT_LIKE_MACRO MyEventWriteFunction2 // #define MCGEN_EVENTWRITETRANSFER MY_OBJECT_LIKE_MACRO // OK, suffix will be "MyEventWriteFunction2". // #define MY_FUNCTION_LIKE_MACRO(h,e,a,r,c,d) MyNamespace::MyClass::MyEventWriteFunction3(h,e,c,d) // #define MCGEN_EVENTWRITETRANSFER MY_FUNCTION_LIKE_MACRO // OK, suffix will be "MY_FUNCTION_LIKE_MACRO". // #ifndef MCGEN_EVENTREGISTER #if MCGEN_USE_KERNEL_MODE_APIS #define MCGEN_EVENTREGISTER EtwRegister #else #define MCGEN_EVENTREGISTER EventRegister #endif #endif // MCGEN_EVENTREGISTER #ifndef MCGEN_EVENTUNREGISTER #if MCGEN_USE_KERNEL_MODE_APIS #define MCGEN_EVENTUNREGISTER EtwUnregister #else #define MCGEN_EVENTUNREGISTER EventUnregister #endif #endif // MCGEN_EVENTUNREGISTER #ifndef MCGEN_EVENTSETINFORMATION #if MCGEN_USE_KERNEL_MODE_APIS #define MCGEN_EVENTSETINFORMATION EtwSetInformation #else #define MCGEN_EVENTSETINFORMATION EventSetInformation #endif #endif // MCGEN_EVENTSETINFORMATION #ifndef MCGEN_EVENTWRITETRANSFER #if MCGEN_USE_KERNEL_MODE_APIS #define MCGEN_EVENTWRITETRANSFER EtwWriteTransfer #else #define MCGEN_EVENTWRITETRANSFER EventWriteTransfer #endif #endif // MCGEN_EVENTWRITETRANSFER // // MCGEN_EVENT_ENABLED macro: // Override to control how the EventWrite[EventName] macros determine whether // an event is enabled. The default behavior is for EventWrite[EventName] to // use the EventEnabled[EventName] macros. // #ifndef MCGEN_EVENT_ENABLED #define MCGEN_EVENT_ENABLED(EventName) EventEnabled##EventName() #endif // // MCGEN_EVENT_ENABLED_FORCONTEXT macro: // Override to control how the EventWrite[EventName]_ForContext macros // determine whether an event is enabled. The default behavior is for // EventWrite[EventName]_ForContext to use the // EventEnabled[EventName]_ForContext macros. // #ifndef MCGEN_EVENT_ENABLED_FORCONTEXT #define MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, EventName) EventEnabled##EventName##_ForContext(pContext) #endif // // MCGEN_ENABLE_CHECK macro: // Determines whether the specified event would be considered as enabled // based on the state of the specified context. Slightly faster than calling // McGenEventEnabled directly. // #ifndef MCGEN_ENABLE_CHECK #define MCGEN_ENABLE_CHECK(Context, Descriptor) (Context.IsEnabled && McGenEventEnabled(&Context, &Descriptor)) #endif #if !defined(MCGEN_TRACE_CONTEXT_DEF) #define MCGEN_TRACE_CONTEXT_DEF // This structure is for use by MC-generated code and should not be used directly. typedef struct _MCGEN_TRACE_CONTEXT { TRACEHANDLE RegistrationHandle; TRACEHANDLE Logger; // Used as pointer to provider traits. ULONGLONG MatchAnyKeyword; ULONGLONG MatchAllKeyword; ULONG Flags; ULONG IsEnabled; UCHAR Level; UCHAR Reserve; USHORT EnableBitsCount; PULONG EnableBitMask; const ULONGLONG* EnableKeyWords; const UCHAR* EnableLevel; } MCGEN_TRACE_CONTEXT, *PMCGEN_TRACE_CONTEXT; #endif // MCGEN_TRACE_CONTEXT_DEF #if !defined(MCGEN_LEVEL_KEYWORD_ENABLED_DEF) #define MCGEN_LEVEL_KEYWORD_ENABLED_DEF // // Determines whether an event with a given Level and Keyword would be // considered as enabled based on the state of the specified context. // Note that you may want to use MCGEN_ENABLE_CHECK instead of calling this // function directly. // FORCEINLINE BOOLEAN McGenLevelKeywordEnabled( _In_ PMCGEN_TRACE_CONTEXT EnableInfo, _In_ UCHAR Level, _In_ ULONGLONG Keyword ) { // // Check if the event Level is lower than the level at which // the channel is enabled. // If the event Level is 0 or the channel is enabled at level 0, // all levels are enabled. // if ((Level <= EnableInfo->Level) || // This also covers the case of Level == 0. (EnableInfo->Level == 0)) { // // Check if Keyword is enabled // if ((Keyword == (ULONGLONG)0) || ((Keyword & EnableInfo->MatchAnyKeyword) && ((Keyword & EnableInfo->MatchAllKeyword) == EnableInfo->MatchAllKeyword))) { return TRUE; } } return FALSE; } #endif // MCGEN_LEVEL_KEYWORD_ENABLED_DEF #if !defined(MCGEN_EVENT_ENABLED_DEF) #define MCGEN_EVENT_ENABLED_DEF // // Determines whether the specified event would be considered as enabled based // on the state of the specified context. Note that you may want to use // MCGEN_ENABLE_CHECK instead of calling this function directly. // FORCEINLINE BOOLEAN McGenEventEnabled( _In_ PMCGEN_TRACE_CONTEXT EnableInfo, _In_ PCEVENT_DESCRIPTOR EventDescriptor ) { return McGenLevelKeywordEnabled(EnableInfo, EventDescriptor->Level, EventDescriptor->Keyword); } #endif // MCGEN_EVENT_ENABLED_DEF #if !defined(MCGEN_CONTROL_CALLBACK) #define MCGEN_CONTROL_CALLBACK // This function is for use by MC-generated code and should not be used directly. DECLSPEC_NOINLINE __inline VOID __stdcall McGenControlCallbackV2( _In_ LPCGUID SourceId, _In_ ULONG ControlCode, _In_ UCHAR Level, _In_ ULONGLONG MatchAnyKeyword, _In_ ULONGLONG MatchAllKeyword, _In_opt_ PEVENT_FILTER_DESCRIPTOR FilterData, _Inout_opt_ PVOID CallbackContext ) /*++ Routine Description: This is the notification callback for Windows Vista and later. Arguments: SourceId - The GUID that identifies the session that enabled the provider. ControlCode - The parameter indicates whether the provider is being enabled or disabled. Level - The level at which the event is enabled. MatchAnyKeyword - The bitmask of keywords that the provider uses to determine the category of events that it writes. MatchAllKeyword - This bitmask additionally restricts the category of events that the provider writes. FilterData - The provider-defined data. CallbackContext - The context of the callback that is defined when the provider called EtwRegister to register itself. Remarks: ETW calls this function to notify provider of enable/disable --*/ { PMCGEN_TRACE_CONTEXT Ctx = (PMCGEN_TRACE_CONTEXT)CallbackContext; ULONG Ix; #ifndef MCGEN_PRIVATE_ENABLE_CALLBACK_V2 UNREFERENCED_PARAMETER(SourceId); UNREFERENCED_PARAMETER(FilterData); #endif if (Ctx == NULL) { return; } switch (ControlCode) { case EVENT_CONTROL_CODE_ENABLE_PROVIDER: Ctx->Level = Level; Ctx->MatchAnyKeyword = MatchAnyKeyword; Ctx->MatchAllKeyword = MatchAllKeyword; Ctx->IsEnabled = EVENT_CONTROL_CODE_ENABLE_PROVIDER; for (Ix = 0; Ix < Ctx->EnableBitsCount; Ix += 1) { if (McGenLevelKeywordEnabled(Ctx, Ctx->EnableLevel[Ix], Ctx->EnableKeyWords[Ix]) != FALSE) { Ctx->EnableBitMask[Ix >> 5] |= (1 << (Ix % 32)); } else { Ctx->EnableBitMask[Ix >> 5] &= ~(1 << (Ix % 32)); } } break; case EVENT_CONTROL_CODE_DISABLE_PROVIDER: Ctx->IsEnabled = EVENT_CONTROL_CODE_DISABLE_PROVIDER; Ctx->Level = 0; Ctx->MatchAnyKeyword = 0; Ctx->MatchAllKeyword = 0; if (Ctx->EnableBitsCount > 0) { #pragma warning(suppress: 26451) // Arithmetic overflow cannot occur, no matter the value of EnableBitCount RtlZeroMemory(Ctx->EnableBitMask, (((Ctx->EnableBitsCount - 1) / 32) + 1) * sizeof(ULONG)); } break; default: break; } #ifdef MCGEN_PRIVATE_ENABLE_CALLBACK_V2 // // Call user defined callback // MCGEN_PRIVATE_ENABLE_CALLBACK_V2( SourceId, ControlCode, Level, MatchAnyKeyword, MatchAllKeyword, FilterData, CallbackContext ); #endif // MCGEN_PRIVATE_ENABLE_CALLBACK_V2 return; } #endif // MCGEN_CONTROL_CALLBACK #ifndef _mcgen_PENABLECALLBACK #if MCGEN_USE_KERNEL_MODE_APIS #define _mcgen_PENABLECALLBACK PETWENABLECALLBACK #else #define _mcgen_PENABLECALLBACK PENABLECALLBACK #endif #endif // _mcgen_PENABLECALLBACK #if !defined(_mcgen_PASTE2) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_PASTE2(a, b) _mcgen_PASTE2_imp(a, b) #define _mcgen_PASTE2_imp(a, b) a##b #endif // _mcgen_PASTE2 #if !defined(_mcgen_PASTE3) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_PASTE3(a, b, c) _mcgen_PASTE3_imp(a, b, c) #define _mcgen_PASTE3_imp(a, b, c) a##b##_##c #endif // _mcgen_PASTE3 // // Macro validation // // Validate MCGEN_EVENTREGISTER: // Trigger an error if MCGEN_EVENTREGISTER is not an unqualified (simple) identifier: struct _mcgen_PASTE2(MCGEN_EVENTREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTREGISTER); // Trigger an error if MCGEN_EVENTREGISTER is redefined: typedef struct _mcgen_PASTE2(MCGEN_EVENTREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTREGISTER) MCGEN_EVENTREGISTER_must_not_be_redefined_between_headers; // Trigger an error if MCGEN_EVENTREGISTER is defined as a function-like macro: typedef void MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTREGISTER; typedef int _mcgen_PASTE2(MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_, MCGEN_EVENTREGISTER); // Validate MCGEN_EVENTUNREGISTER: // Trigger an error if MCGEN_EVENTUNREGISTER is not an unqualified (simple) identifier: struct _mcgen_PASTE2(MCGEN_EVENTUNREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTUNREGISTER); // Trigger an error if MCGEN_EVENTUNREGISTER is redefined: typedef struct _mcgen_PASTE2(MCGEN_EVENTUNREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTUNREGISTER) MCGEN_EVENTUNREGISTER_must_not_be_redefined_between_headers; // Trigger an error if MCGEN_EVENTUNREGISTER is defined as a function-like macro: typedef void MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTUNREGISTER; typedef int _mcgen_PASTE2(MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_, MCGEN_EVENTUNREGISTER); // Validate MCGEN_EVENTSETINFORMATION: // Trigger an error if MCGEN_EVENTSETINFORMATION is not an unqualified (simple) identifier: struct _mcgen_PASTE2(MCGEN_EVENTSETINFORMATION_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTSETINFORMATION); // Trigger an error if MCGEN_EVENTSETINFORMATION is redefined: typedef struct _mcgen_PASTE2(MCGEN_EVENTSETINFORMATION_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTSETINFORMATION) MCGEN_EVENTSETINFORMATION_must_not_be_redefined_between_headers; // Trigger an error if MCGEN_EVENTSETINFORMATION is defined as a function-like macro: typedef void MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_MCGEN_EVENTSETINFORMATION; typedef int _mcgen_PASTE2(MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_, MCGEN_EVENTSETINFORMATION); // Validate MCGEN_EVENTWRITETRANSFER: // Trigger an error if MCGEN_EVENTWRITETRANSFER is not an unqualified (simple) identifier: struct _mcgen_PASTE2(MCGEN_EVENTWRITETRANSFER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTWRITETRANSFER); // Trigger an error if MCGEN_EVENTWRITETRANSFER is redefined: typedef struct _mcgen_PASTE2(MCGEN_EVENTWRITETRANSFER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTWRITETRANSFER) MCGEN_EVENTWRITETRANSFER_must_not_be_redefined_between_headers;; // Trigger an error if MCGEN_EVENTWRITETRANSFER is defined as a function-like macro: typedef void MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_MCGEN_EVENTWRITETRANSFER; typedef int _mcgen_PASTE2(MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_, MCGEN_EVENTWRITETRANSFER); #ifndef McGenEventWrite_def #define McGenEventWrite_def // This macro is for use by MC-generated code and should not be used directly. #define McGenEventWrite _mcgen_PASTE2(McGenEventWrite_, MCGEN_EVENTWRITETRANSFER) // This function is for use by MC-generated code and should not be used directly. DECLSPEC_NOINLINE __inline ULONG __stdcall McGenEventWrite( _In_ PMCGEN_TRACE_CONTEXT Context, _In_ PCEVENT_DESCRIPTOR Descriptor, _In_opt_ LPCGUID ActivityId, _In_range_(1, 128) ULONG EventDataCount, _Pre_cap_(EventDataCount) EVENT_DATA_DESCRIPTOR* EventData ) { const USHORT UNALIGNED* Traits; // Some customized MCGEN_EVENTWRITETRANSFER macros might ignore ActivityId. UNREFERENCED_PARAMETER(ActivityId); Traits = (const USHORT UNALIGNED*)(UINT_PTR)Context->Logger; if (Traits == NULL) { EventData[0].Ptr = 0; EventData[0].Size = 0; EventData[0].Reserved = 0; } else { EventData[0].Ptr = (ULONG_PTR)Traits; EventData[0].Size = *Traits; EventData[0].Reserved = 2; // EVENT_DATA_DESCRIPTOR_TYPE_PROVIDER_METADATA } return MCGEN_EVENTWRITETRANSFER( Context->RegistrationHandle, Descriptor, ActivityId, NULL, EventDataCount, EventData); } #endif // McGenEventWrite_def #if !defined(McGenEventRegisterUnregister) #define McGenEventRegisterUnregister // This macro is for use by MC-generated code and should not be used directly. #define McGenEventRegister _mcgen_PASTE2(McGenEventRegister_, MCGEN_EVENTREGISTER) #pragma warning(push) #pragma warning(disable:6103) // This function is for use by MC-generated code and should not be used directly. DECLSPEC_NOINLINE __inline ULONG __stdcall McGenEventRegister( _In_ LPCGUID ProviderId, _In_opt_ _mcgen_PENABLECALLBACK EnableCallback, _In_opt_ PVOID CallbackContext, _Inout_ PREGHANDLE RegHandle ) /*++ Routine Description: This function registers the provider with ETW. Arguments: ProviderId - Provider ID to register with ETW. EnableCallback - Callback to be used. CallbackContext - Context for the callback. RegHandle - Pointer to registration handle. Remarks: Should not be called if the provider is already registered (i.e. should not be called if *RegHandle != 0). Repeatedly registering a provider is a bug and may indicate a race condition. However, for compatibility with previous behavior, this function will return SUCCESS in this case. --*/ { ULONG Error; if (*RegHandle != 0) { Error = 0; // ERROR_SUCCESS } else { Error = MCGEN_EVENTREGISTER(ProviderId, EnableCallback, CallbackContext, RegHandle); } return Error; } #pragma warning(pop) // This macro is for use by MC-generated code and should not be used directly. #define McGenEventUnregister _mcgen_PASTE2(McGenEventUnregister_, MCGEN_EVENTUNREGISTER) // This function is for use by MC-generated code and should not be used directly. DECLSPEC_NOINLINE __inline ULONG __stdcall McGenEventUnregister(_Inout_ PREGHANDLE RegHandle) /*++ Routine Description: Unregister from ETW and set *RegHandle = 0. Arguments: RegHandle - the pointer to the provider registration handle Remarks: If provider has not been registered (i.e. if *RegHandle == 0), return SUCCESS. It is safe to call McGenEventUnregister even if the call to McGenEventRegister returned an error. --*/ { ULONG Error; if(*RegHandle == 0) { Error = 0; // ERROR_SUCCESS } else { Error = MCGEN_EVENTUNREGISTER(*RegHandle); *RegHandle = (REGHANDLE)0; } return Error; } #endif // McGenEventRegisterUnregister #ifndef _mcgen_EVENT_BIT_SET #if defined(_M_IX86) || defined(_M_X64) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_EVENT_BIT_SET(EnableBits, BitPosition) ((((const unsigned char*)EnableBits)[BitPosition >> 3] & (1u << (BitPosition & 7))) != 0) #else // CPU type // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_EVENT_BIT_SET(EnableBits, BitPosition) ((EnableBits[BitPosition >> 5] & (1u << (BitPosition & 31))) != 0) #endif // CPU type #endif // _mcgen_EVENT_BIT_SET #endif // MCGEN_DISABLE_PROVIDER_CODE_GENERATION //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Provider "Microsoft-Windows-Kernel-Pep" event count 7 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // Provider GUID = 5412704e-b2e1-4624-8ffd-55777b8f7373 EXTERN_C __declspec(selectany) const GUID POP_PEP_ETW_PROVIDER = {0x5412704e, 0xb2e1, 0x4624, {0x8f, 0xfd, 0x55, 0x77, 0x7b, 0x8f, 0x73, 0x73}}; #ifndef POP_PEP_ETW_PROVIDER_Traits #define POP_PEP_ETW_PROVIDER_Traits NULL #endif // POP_PEP_ETW_PROVIDER_Traits // // Channel // #define POP_PEP_ETW_PROVIDER_CHANNEL_chidPepPower 0x10 #define POP_PEP_ETW_PROVIDER_CHANNEL_chidPepPower_KEYWORD 0x8000000000000000 // // Tasks // #define POP_PEP_ETW_TASK_RAILRUNDOWN 0x1 #define POP_PEP_ETW_TASK_DEVICERUNDOWN 0x2 #define POP_PEP_ETW_TASK_COMPONENTRUNDOWN 0x3 #define POP_PEP_ETW_TASK_RAILVOLTAGECHANGE 0x4 #define POP_PEP_ETW_TASK_COMPONENTFREQUENCYCHANGE 0x5 #define POP_PEP_ETW_TASK_PLATFORMIDLERESIDENCY 0x6 #define POP_PEP_ETW_TASK_PLATFORMIDLETRANSITION 0x7 // // Keyword // #define POP_PEP_ETW_KEYWORD_POWER 0x1 // // Event Descriptors // EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR POP_PEP_ETW_RAIL_RUNDOWN = {0x1, 0x0, 0x10, 0x4, 0x0, 0x1, 0x8000000000000001}; #define POP_PEP_ETW_RAIL_RUNDOWN_value 0x1 EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR POP_PEP_ETW_DEVICE_RUNDOWN = {0x2, 0x0, 0x10, 0x4, 0x0, 0x2, 0x8000000000000001}; #define POP_PEP_ETW_DEVICE_RUNDOWN_value 0x2 EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR POP_PEP_ETW_COMPONENT_RUNDOWN = {0x3, 0x0, 0x10, 0x4, 0x0, 0x3, 0x8000000000000001}; #define POP_PEP_ETW_COMPONENT_RUNDOWN_value 0x3 EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR POP_PEP_ETW_RAIL_VOLTAGE_CHANGE = {0x4, 0x0, 0x10, 0x4, 0x0, 0x4, 0x8000000000000001}; #define POP_PEP_ETW_RAIL_VOLTAGE_CHANGE_value 0x4 EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE = {0x5, 0x0, 0x10, 0x4, 0x0, 0x5, 0x8000000000000001}; #define POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE_value 0x5 EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY = {0x6, 0x0, 0x10, 0x4, 0x0, 0x6, 0x8000000000000001}; #define POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY_value 0x6 EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR POP_PEP_ETW_PLATFORM_IDLE_TRANSITION = {0x7, 0x0, 0x10, 0x4, 0x0, 0x7, 0x8000000000000001}; #define POP_PEP_ETW_PLATFORM_IDLE_TRANSITION_value 0x7 // // MCGEN_DISABLE_PROVIDER_CODE_GENERATION macro: // Define this macro to have the compiler skip the generated functions in this // header. // #ifndef MCGEN_DISABLE_PROVIDER_CODE_GENERATION // // Event Enablement Bits // These variables are for use by MC-generated code and should not be used directly. // EXTERN_C __declspec(selectany) DECLSPEC_CACHEALIGN ULONG Microsoft_Windows_Kernel_PepEnableBits[1]; EXTERN_C __declspec(selectany) const ULONGLONG Microsoft_Windows_Kernel_PepKeywords[1] = {0x8000000000000001}; EXTERN_C __declspec(selectany) const unsigned char Microsoft_Windows_Kernel_PepLevels[1] = {4}; // // Provider context // EXTERN_C __declspec(selectany) MCGEN_TRACE_CONTEXT POP_PEP_ETW_PROVIDER_Context = {0, (ULONG_PTR)POP_PEP_ETW_PROVIDER_Traits, 0, 0, 0, 0, 0, 0, 1, Microsoft_Windows_Kernel_PepEnableBits, Microsoft_Windows_Kernel_PepKeywords, Microsoft_Windows_Kernel_PepLevels}; // // Provider REGHANDLE // #define Microsoft_Windows_Kernel_PepHandle (POP_PEP_ETW_PROVIDER_Context.RegistrationHandle) // // This macro is set to 1, indicating that the EventWrite[Name] macros // have an Activity parameter. This is controlled by the -km and -um options. // #define POP_PEP_ETW_PROVIDER_EventWriteActivity 1 // // Register with ETW using the control GUID specified in the manifest. // Invoke this macro during module initialization (i.e. program startup, // DLL process attach, or driver load) to initialize the provider. // Note that if this function returns an error, the error means that // will not work, but no action needs to be taken -- even if EventRegister // returns an error, it is generally safe to use EventWrite and // EventUnregister macros (they will be no-ops if EventRegister failed). // #ifndef EventRegisterMicrosoft_Windows_Kernel_Pep #define EventRegisterMicrosoft_Windows_Kernel_Pep() McGenEventRegister(&POP_PEP_ETW_PROVIDER, McGenControlCallbackV2, &POP_PEP_ETW_PROVIDER_Context, &Microsoft_Windows_Kernel_PepHandle) #endif // // Register with ETW using a specific control GUID (i.e. a GUID other than what // is specified in the manifest). Advanced scenarios only. // #ifndef EventRegisterByGuidMicrosoft_Windows_Kernel_Pep #define EventRegisterByGuidMicrosoft_Windows_Kernel_Pep(Guid) McGenEventRegister(&(Guid), McGenControlCallbackV2, &POP_PEP_ETW_PROVIDER_Context, &Microsoft_Windows_Kernel_PepHandle) #endif // // Unregister with ETW and close the provider. // Invoke this macro during module shutdown (i.e. program exit, DLL process // detach, or driver unload) to unregister the provider. // Note that you MUST call EventUnregister before DLL or driver unload // (not optional): failure to unregister a provider before DLL or driver unload // will result in crashes. // #ifndef EventUnregisterMicrosoft_Windows_Kernel_Pep #define EventUnregisterMicrosoft_Windows_Kernel_Pep() McGenEventUnregister(&Microsoft_Windows_Kernel_PepHandle) #endif // // MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION macro: // Define this macro to enable support for caller-allocated provider context. // #ifdef MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION // // Advanced scenarios: Caller-allocated provider context. // Use when multiple differently-configured provider handles are needed, // e.g. for container-aware drivers, one context per container. // // Usage: // // - Caller enables the feature before including this header, e.g. // #define MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION 1 // - Caller allocates memory, e.g. pContext = malloc(sizeof(McGenContext_Microsoft_Windows_Kernel_Pep)); // - Caller registers the provider, e.g. EventRegisterMicrosoft_Windows_Kernel_Pep_ForContext(pContext); // - Caller writes events, e.g. EventWriteMyEvent_ForContext(pContext, ...); // - Caller unregisters, e.g. EventUnregisterMicrosoft_Windows_Kernel_Pep_ForContext(pContext); // - Caller frees memory, e.g. free(pContext); // typedef struct tagMcGenContext_Microsoft_Windows_Kernel_Pep { // The fields of this structure are subject to change and should // not be accessed directly. To access the provider's REGHANDLE, // use Microsoft_Windows_Kernel_PepHandle_ForContext(pContext). MCGEN_TRACE_CONTEXT Context; ULONG EnableBits[1]; } McGenContext_Microsoft_Windows_Kernel_Pep; #define EventRegisterMicrosoft_Windows_Kernel_Pep_ForContext(pContext) _mcgen_PASTE2(_mcgen_RegisterForContext_Microsoft_Windows_Kernel_Pep_, MCGEN_EVENTREGISTER)(&POP_PEP_ETW_PROVIDER, pContext) #define EventRegisterByGuidMicrosoft_Windows_Kernel_Pep_ForContext(Guid, pContext) _mcgen_PASTE2(_mcgen_RegisterForContext_Microsoft_Windows_Kernel_Pep_, MCGEN_EVENTREGISTER)(&(Guid), pContext) #define EventUnregisterMicrosoft_Windows_Kernel_Pep_ForContext(pContext) McGenEventUnregister(&(pContext)->Context.RegistrationHandle) // // Provider REGHANDLE for caller-allocated context. // #define Microsoft_Windows_Kernel_PepHandle_ForContext(pContext) ((pContext)->Context.RegistrationHandle) // This function is for use by MC-generated code and should not be used directly. // Initialize and register the caller-allocated context. __inline ULONG __stdcall _mcgen_PASTE2(_mcgen_RegisterForContext_Microsoft_Windows_Kernel_Pep_, MCGEN_EVENTREGISTER)( _In_ LPCGUID pProviderId, _Out_ McGenContext_Microsoft_Windows_Kernel_Pep* pContext) { RtlZeroMemory(pContext, sizeof(*pContext)); pContext->Context.Logger = (ULONG_PTR)POP_PEP_ETW_PROVIDER_Traits; pContext->Context.EnableBitsCount = 1; pContext->Context.EnableBitMask = pContext->EnableBits; pContext->Context.EnableKeyWords = Microsoft_Windows_Kernel_PepKeywords; pContext->Context.EnableLevel = Microsoft_Windows_Kernel_PepLevels; return McGenEventRegister( pProviderId, McGenControlCallbackV2, &pContext->Context, &pContext->Context.RegistrationHandle); } // This function is for use by MC-generated code and should not be used directly. // Trigger a compile error if called with the wrong parameter type. FORCEINLINE _Ret_ McGenContext_Microsoft_Windows_Kernel_Pep* _mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(_In_ McGenContext_Microsoft_Windows_Kernel_Pep* pContext) { return pContext; } #endif // MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION // // Enablement check macro for event "POP_PEP_ETW_RAIL_RUNDOWN" // #define EventEnabledPOP_PEP_ETW_RAIL_RUNDOWN() _mcgen_EVENT_BIT_SET(Microsoft_Windows_Kernel_PepEnableBits, 0) #define EventEnabledPOP_PEP_ETW_RAIL_RUNDOWN_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->EnableBits, 0) // // Event write macros for event "POP_PEP_ETW_RAIL_RUNDOWN" // #define EventWritePOP_PEP_ETW_RAIL_RUNDOWN(Activity, VoltageRailId, VoltageRailName, CurrentVoltageMv, MaxVoltageMv) \ MCGEN_EVENT_ENABLED(POP_PEP_ETW_RAIL_RUNDOWN) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_RUNDOWN(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_RAIL_RUNDOWN, Activity, VoltageRailId, VoltageRailName, CurrentVoltageMv, MaxVoltageMv) : 0 #define EventWritePOP_PEP_ETW_RAIL_RUNDOWN_AssumeEnabled(VoltageRailId, VoltageRailName, CurrentVoltageMv, MaxVoltageMv) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_RUNDOWN(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_RAIL_RUNDOWN, NULL, VoltageRailId, VoltageRailName, CurrentVoltageMv, MaxVoltageMv) #define EventWritePOP_PEP_ETW_RAIL_RUNDOWN_ForContext(pContext, Activity, VoltageRailId, VoltageRailName, CurrentVoltageMv, MaxVoltageMv) \ MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, POP_PEP_ETW_RAIL_RUNDOWN) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_RUNDOWN(&(pContext)->Context, &POP_PEP_ETW_RAIL_RUNDOWN, Activity, VoltageRailId, VoltageRailName, CurrentVoltageMv, MaxVoltageMv) : 0 #define EventWritePOP_PEP_ETW_RAIL_RUNDOWN_ForContextAssumeEnabled(pContext, VoltageRailId, VoltageRailName, CurrentVoltageMv, MaxVoltageMv) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_RUNDOWN(&_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->Context, &POP_PEP_ETW_RAIL_RUNDOWN, NULL, VoltageRailId, VoltageRailName, CurrentVoltageMv, MaxVoltageMv) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_RUNDOWN _mcgen_PASTE2(McTemplateK0qzqq_, MCGEN_EVENTWRITETRANSFER) // // Enablement check macro for event "POP_PEP_ETW_DEVICE_RUNDOWN" // #define EventEnabledPOP_PEP_ETW_DEVICE_RUNDOWN() _mcgen_EVENT_BIT_SET(Microsoft_Windows_Kernel_PepEnableBits, 0) #define EventEnabledPOP_PEP_ETW_DEVICE_RUNDOWN_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->EnableBits, 0) // // Event write macros for event "POP_PEP_ETW_DEVICE_RUNDOWN" // #define EventWritePOP_PEP_ETW_DEVICE_RUNDOWN(Activity, DeviceId, DeviceName, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency) \ MCGEN_EVENT_ENABLED(POP_PEP_ETW_DEVICE_RUNDOWN) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_DEVICE_RUNDOWN(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_DEVICE_RUNDOWN, Activity, DeviceId, DeviceName, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency) : 0 #define EventWritePOP_PEP_ETW_DEVICE_RUNDOWN_AssumeEnabled(DeviceId, DeviceName, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_DEVICE_RUNDOWN(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_DEVICE_RUNDOWN, NULL, DeviceId, DeviceName, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency) #define EventWritePOP_PEP_ETW_DEVICE_RUNDOWN_ForContext(pContext, Activity, DeviceId, DeviceName, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency) \ MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, POP_PEP_ETW_DEVICE_RUNDOWN) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_DEVICE_RUNDOWN(&(pContext)->Context, &POP_PEP_ETW_DEVICE_RUNDOWN, Activity, DeviceId, DeviceName, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency) : 0 #define EventWritePOP_PEP_ETW_DEVICE_RUNDOWN_ForContextAssumeEnabled(pContext, DeviceId, DeviceName, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_DEVICE_RUNDOWN(&_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->Context, &POP_PEP_ETW_DEVICE_RUNDOWN, NULL, DeviceId, DeviceName, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_TEMPLATE_FOR_POP_PEP_ETW_DEVICE_RUNDOWN _mcgen_PASTE2(McTemplateK0pzqNR2_, MCGEN_EVENTWRITETRANSFER) // // Enablement check macro for event "POP_PEP_ETW_COMPONENT_RUNDOWN" // #define EventEnabledPOP_PEP_ETW_COMPONENT_RUNDOWN() _mcgen_EVENT_BIT_SET(Microsoft_Windows_Kernel_PepEnableBits, 0) #define EventEnabledPOP_PEP_ETW_COMPONENT_RUNDOWN_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->EnableBits, 0) // // Event write macros for event "POP_PEP_ETW_COMPONENT_RUNDOWN" // #define EventWritePOP_PEP_ETW_COMPONENT_RUNDOWN(Activity, VoltageRailId, DeviceId, ComponentIndex, CurrentFrequencyKHz, MaxFrequencyKHz, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency, ComponentDescriptionLength, ComponentDescription) \ MCGEN_EVENT_ENABLED(POP_PEP_ETW_COMPONENT_RUNDOWN) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_RUNDOWN(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_COMPONENT_RUNDOWN, Activity, VoltageRailId, DeviceId, ComponentIndex, CurrentFrequencyKHz, MaxFrequencyKHz, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency, ComponentDescriptionLength, ComponentDescription) : 0 #define EventWritePOP_PEP_ETW_COMPONENT_RUNDOWN_AssumeEnabled(VoltageRailId, DeviceId, ComponentIndex, CurrentFrequencyKHz, MaxFrequencyKHz, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency, ComponentDescriptionLength, ComponentDescription) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_RUNDOWN(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_COMPONENT_RUNDOWN, NULL, VoltageRailId, DeviceId, ComponentIndex, CurrentFrequencyKHz, MaxFrequencyKHz, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency, ComponentDescriptionLength, ComponentDescription) #define EventWritePOP_PEP_ETW_COMPONENT_RUNDOWN_ForContext(pContext, Activity, VoltageRailId, DeviceId, ComponentIndex, CurrentFrequencyKHz, MaxFrequencyKHz, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency, ComponentDescriptionLength, ComponentDescription) \ MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, POP_PEP_ETW_COMPONENT_RUNDOWN) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_RUNDOWN(&(pContext)->Context, &POP_PEP_ETW_COMPONENT_RUNDOWN, Activity, VoltageRailId, DeviceId, ComponentIndex, CurrentFrequencyKHz, MaxFrequencyKHz, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency, ComponentDescriptionLength, ComponentDescription) : 0 #define EventWritePOP_PEP_ETW_COMPONENT_RUNDOWN_ForContextAssumeEnabled(pContext, VoltageRailId, DeviceId, ComponentIndex, CurrentFrequencyKHz, MaxFrequencyKHz, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency, ComponentDescriptionLength, ComponentDescription) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_RUNDOWN(&_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->Context, &POP_PEP_ETW_COMPONENT_RUNDOWN, NULL, VoltageRailId, DeviceId, ComponentIndex, CurrentFrequencyKHz, MaxFrequencyKHz, PlatformStateDependencyCount, PlatformStateDependency_Len_, PlatformStateDependency, ComponentDescriptionLength, ComponentDescription) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_RUNDOWN _mcgen_PASTE2(McTemplateK0qpqqqqNR5qzr7_, MCGEN_EVENTWRITETRANSFER) // // Enablement check macro for event "POP_PEP_ETW_RAIL_VOLTAGE_CHANGE" // #define EventEnabledPOP_PEP_ETW_RAIL_VOLTAGE_CHANGE() _mcgen_EVENT_BIT_SET(Microsoft_Windows_Kernel_PepEnableBits, 0) #define EventEnabledPOP_PEP_ETW_RAIL_VOLTAGE_CHANGE_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->EnableBits, 0) // // Event write macros for event "POP_PEP_ETW_RAIL_VOLTAGE_CHANGE" // #define EventWritePOP_PEP_ETW_RAIL_VOLTAGE_CHANGE(Activity, VoltageRailId, OldRailVoltageMv, NewRailVoltageMv) \ MCGEN_EVENT_ENABLED(POP_PEP_ETW_RAIL_VOLTAGE_CHANGE) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_VOLTAGE_CHANGE(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_RAIL_VOLTAGE_CHANGE, Activity, VoltageRailId, OldRailVoltageMv, NewRailVoltageMv) : 0 #define EventWritePOP_PEP_ETW_RAIL_VOLTAGE_CHANGE_AssumeEnabled(VoltageRailId, OldRailVoltageMv, NewRailVoltageMv) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_VOLTAGE_CHANGE(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_RAIL_VOLTAGE_CHANGE, NULL, VoltageRailId, OldRailVoltageMv, NewRailVoltageMv) #define EventWritePOP_PEP_ETW_RAIL_VOLTAGE_CHANGE_ForContext(pContext, Activity, VoltageRailId, OldRailVoltageMv, NewRailVoltageMv) \ MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, POP_PEP_ETW_RAIL_VOLTAGE_CHANGE) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_VOLTAGE_CHANGE(&(pContext)->Context, &POP_PEP_ETW_RAIL_VOLTAGE_CHANGE, Activity, VoltageRailId, OldRailVoltageMv, NewRailVoltageMv) : 0 #define EventWritePOP_PEP_ETW_RAIL_VOLTAGE_CHANGE_ForContextAssumeEnabled(pContext, VoltageRailId, OldRailVoltageMv, NewRailVoltageMv) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_VOLTAGE_CHANGE(&_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->Context, &POP_PEP_ETW_RAIL_VOLTAGE_CHANGE, NULL, VoltageRailId, OldRailVoltageMv, NewRailVoltageMv) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_TEMPLATE_FOR_POP_PEP_ETW_RAIL_VOLTAGE_CHANGE _mcgen_PASTE2(McTemplateK0qqq_, MCGEN_EVENTWRITETRANSFER) // // Enablement check macro for event "POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE" // #define EventEnabledPOP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE() _mcgen_EVENT_BIT_SET(Microsoft_Windows_Kernel_PepEnableBits, 0) #define EventEnabledPOP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->EnableBits, 0) // // Event write macros for event "POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE" // #define EventWritePOP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE(Activity, DeviceId, ComponentIndex, OldComponentFrequencyKHz, NewComponentFrequencyKHz) \ MCGEN_EVENT_ENABLED(POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE, Activity, DeviceId, ComponentIndex, OldComponentFrequencyKHz, NewComponentFrequencyKHz) : 0 #define EventWritePOP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE_AssumeEnabled(DeviceId, ComponentIndex, OldComponentFrequencyKHz, NewComponentFrequencyKHz) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE, NULL, DeviceId, ComponentIndex, OldComponentFrequencyKHz, NewComponentFrequencyKHz) #define EventWritePOP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE_ForContext(pContext, Activity, DeviceId, ComponentIndex, OldComponentFrequencyKHz, NewComponentFrequencyKHz) \ MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE(&(pContext)->Context, &POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE, Activity, DeviceId, ComponentIndex, OldComponentFrequencyKHz, NewComponentFrequencyKHz) : 0 #define EventWritePOP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE_ForContextAssumeEnabled(pContext, DeviceId, ComponentIndex, OldComponentFrequencyKHz, NewComponentFrequencyKHz) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE(&_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->Context, &POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE, NULL, DeviceId, ComponentIndex, OldComponentFrequencyKHz, NewComponentFrequencyKHz) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_TEMPLATE_FOR_POP_PEP_ETW_COMPONENT_FREQUENCE_CHANGE _mcgen_PASTE2(McTemplateK0pqqq_, MCGEN_EVENTWRITETRANSFER) // // Enablement check macro for event "POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY" // #define EventEnabledPOP_PEP_ETW_PLATFORM_IDLE_RESIDENCY() _mcgen_EVENT_BIT_SET(Microsoft_Windows_Kernel_PepEnableBits, 0) #define EventEnabledPOP_PEP_ETW_PLATFORM_IDLE_RESIDENCY_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->EnableBits, 0) // // Event write macros for event "POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY" // #define EventWritePOP_PEP_ETW_PLATFORM_IDLE_RESIDENCY(Activity, PlatformStateCount, PlatformIdleStateResidency_Len_, PlatformIdleStateResidency) \ MCGEN_EVENT_ENABLED(POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY, Activity, PlatformStateCount, PlatformIdleStateResidency_Len_, PlatformIdleStateResidency) : 0 #define EventWritePOP_PEP_ETW_PLATFORM_IDLE_RESIDENCY_AssumeEnabled(PlatformStateCount, PlatformIdleStateResidency_Len_, PlatformIdleStateResidency) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY, NULL, PlatformStateCount, PlatformIdleStateResidency_Len_, PlatformIdleStateResidency) #define EventWritePOP_PEP_ETW_PLATFORM_IDLE_RESIDENCY_ForContext(pContext, Activity, PlatformStateCount, PlatformIdleStateResidency_Len_, PlatformIdleStateResidency) \ MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY(&(pContext)->Context, &POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY, Activity, PlatformStateCount, PlatformIdleStateResidency_Len_, PlatformIdleStateResidency) : 0 #define EventWritePOP_PEP_ETW_PLATFORM_IDLE_RESIDENCY_ForContextAssumeEnabled(pContext, PlatformStateCount, PlatformIdleStateResidency_Len_, PlatformIdleStateResidency) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY(&_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->Context, &POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY, NULL, PlatformStateCount, PlatformIdleStateResidency_Len_, PlatformIdleStateResidency) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_RESIDENCY _mcgen_PASTE2(McTemplateK0qNR0_, MCGEN_EVENTWRITETRANSFER) // // Enablement check macro for event "POP_PEP_ETW_PLATFORM_IDLE_TRANSITION" // #define EventEnabledPOP_PEP_ETW_PLATFORM_IDLE_TRANSITION() _mcgen_EVENT_BIT_SET(Microsoft_Windows_Kernel_PepEnableBits, 0) #define EventEnabledPOP_PEP_ETW_PLATFORM_IDLE_TRANSITION_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->EnableBits, 0) // // Event write macros for event "POP_PEP_ETW_PLATFORM_IDLE_TRANSITION" // #define EventWritePOP_PEP_ETW_PLATFORM_IDLE_TRANSITION(Activity, OldPlatformState, NewPlatformState) \ MCGEN_EVENT_ENABLED(POP_PEP_ETW_PLATFORM_IDLE_TRANSITION) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_TRANSITION(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_PLATFORM_IDLE_TRANSITION, Activity, OldPlatformState, NewPlatformState) : 0 #define EventWritePOP_PEP_ETW_PLATFORM_IDLE_TRANSITION_AssumeEnabled(OldPlatformState, NewPlatformState) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_TRANSITION(&POP_PEP_ETW_PROVIDER_Context, &POP_PEP_ETW_PLATFORM_IDLE_TRANSITION, NULL, OldPlatformState, NewPlatformState) #define EventWritePOP_PEP_ETW_PLATFORM_IDLE_TRANSITION_ForContext(pContext, Activity, OldPlatformState, NewPlatformState) \ MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, POP_PEP_ETW_PLATFORM_IDLE_TRANSITION) \ ? _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_TRANSITION(&(pContext)->Context, &POP_PEP_ETW_PLATFORM_IDLE_TRANSITION, Activity, OldPlatformState, NewPlatformState) : 0 #define EventWritePOP_PEP_ETW_PLATFORM_IDLE_TRANSITION_ForContextAssumeEnabled(pContext, OldPlatformState, NewPlatformState) \ _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_TRANSITION(&_mcgen_CheckContextType_Microsoft_Windows_Kernel_Pep(pContext)->Context, &POP_PEP_ETW_PLATFORM_IDLE_TRANSITION, NULL, OldPlatformState, NewPlatformState) // This macro is for use by MC-generated code and should not be used directly. #define _mcgen_TEMPLATE_FOR_POP_PEP_ETW_PLATFORM_IDLE_TRANSITION _mcgen_PASTE2(McTemplateK0qq_, MCGEN_EVENTWRITETRANSFER) #endif // MCGEN_DISABLE_PROVIDER_CODE_GENERATION // // MCGEN_DISABLE_PROVIDER_CODE_GENERATION macro: // Define this macro to have the compiler skip the generated functions in this // header. // #ifndef MCGEN_DISABLE_PROVIDER_CODE_GENERATION // // Template Functions // // // Function for template "tidPepComponentFrequencyChange" (and possibly others). // This function is for use by MC-generated code and should not be used directly. // #ifndef McTemplateK0pqqq_def #define McTemplateK0pqqq_def ETW_INLINE ULONG _mcgen_PASTE2(McTemplateK0pqqq_, MCGEN_EVENTWRITETRANSFER)( _In_ PMCGEN_TRACE_CONTEXT Context, _In_ PCEVENT_DESCRIPTOR Descriptor, _In_opt_ const GUID* Activity, _In_opt_ const void* _Arg0, _In_ const unsigned int _Arg1, _In_ const unsigned int _Arg2, _In_ const unsigned int _Arg3 ) { #define McTemplateK0pqqq_ARGCOUNT 4 EVENT_DATA_DESCRIPTOR EventData[McTemplateK0pqqq_ARGCOUNT + 1]; EventDataDescCreate(&EventData[1],&_Arg0, sizeof(const void*) ); EventDataDescCreate(&EventData[2],&_Arg1, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[3],&_Arg2, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[4],&_Arg3, sizeof(const unsigned int) ); return McGenEventWrite(Context, Descriptor, Activity, McTemplateK0pqqq_ARGCOUNT + 1, EventData); } #endif // McTemplateK0pqqq_def // // Function for template "tidPepDeviceRundown" (and possibly others). // This function is for use by MC-generated code and should not be used directly. // #ifndef McTemplateK0pzqNR2_def #define McTemplateK0pzqNR2_def ETW_INLINE ULONG _mcgen_PASTE2(McTemplateK0pzqNR2_, MCGEN_EVENTWRITETRANSFER)( _In_ PMCGEN_TRACE_CONTEXT Context, _In_ PCEVENT_DESCRIPTOR Descriptor, _In_opt_ const GUID* Activity, _In_opt_ const void* _Arg0, _In_opt_ PCWSTR _Arg1, _In_ const unsigned int _Arg2, _In_ ULONG _Arg3_Len_, _In_ const void* _Arg3 ) { #define McTemplateK0pzqNR2_ARGCOUNT 4 EVENT_DATA_DESCRIPTOR EventData[McTemplateK0pzqNR2_ARGCOUNT + 1]; EventDataDescCreate(&EventData[1],&_Arg0, sizeof(const void*) ); EventDataDescCreate(&EventData[2], (_Arg1 != NULL) ? _Arg1 : L"NULL", (_Arg1 != NULL) ? (ULONG)((wcslen(_Arg1) + 1) * sizeof(WCHAR)) : (ULONG)sizeof(L"NULL")); EventDataDescCreate(&EventData[3],&_Arg2, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[4],_Arg3, _Arg2 * _Arg3_Len_); return McGenEventWrite(Context, Descriptor, Activity, McTemplateK0pzqNR2_ARGCOUNT + 1, EventData); } #endif // McTemplateK0pzqNR2_def // // Function for template "tidPepPlatformIdleResidency" (and possibly others). // This function is for use by MC-generated code and should not be used directly. // #ifndef McTemplateK0qNR0_def #define McTemplateK0qNR0_def ETW_INLINE ULONG _mcgen_PASTE2(McTemplateK0qNR0_, MCGEN_EVENTWRITETRANSFER)( _In_ PMCGEN_TRACE_CONTEXT Context, _In_ PCEVENT_DESCRIPTOR Descriptor, _In_opt_ const GUID* Activity, _In_ const unsigned int _Arg0, _In_ ULONG _Arg1_Len_, _In_ const void* _Arg1 ) { #define McTemplateK0qNR0_ARGCOUNT 2 EVENT_DATA_DESCRIPTOR EventData[McTemplateK0qNR0_ARGCOUNT + 1]; EventDataDescCreate(&EventData[1],&_Arg0, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[2],_Arg1, _Arg0 * _Arg1_Len_); return McGenEventWrite(Context, Descriptor, Activity, McTemplateK0qNR0_ARGCOUNT + 1, EventData); } #endif // McTemplateK0qNR0_def // // Function for template "tidPepComponentRundown" (and possibly others). // This function is for use by MC-generated code and should not be used directly. // #ifndef McTemplateK0qpqqqqNR5qzr7_def #define McTemplateK0qpqqqqNR5qzr7_def ETW_INLINE ULONG _mcgen_PASTE2(McTemplateK0qpqqqqNR5qzr7_, MCGEN_EVENTWRITETRANSFER)( _In_ PMCGEN_TRACE_CONTEXT Context, _In_ PCEVENT_DESCRIPTOR Descriptor, _In_opt_ const GUID* Activity, _In_ const unsigned int _Arg0, _In_opt_ const void* _Arg1, _In_ const unsigned int _Arg2, _In_ const unsigned int _Arg3, _In_ const unsigned int _Arg4, _In_ const unsigned int _Arg5, _In_ ULONG _Arg6_Len_, _In_ const void* _Arg6, _In_ const unsigned int _Arg7, _In_reads_(_Arg7) const WCHAR* _Arg8 ) { #define McTemplateK0qpqqqqNR5qzr7_ARGCOUNT 9 EVENT_DATA_DESCRIPTOR EventData[McTemplateK0qpqqqqNR5qzr7_ARGCOUNT + 1]; EventDataDescCreate(&EventData[1],&_Arg0, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[2],&_Arg1, sizeof(const void*) ); EventDataDescCreate(&EventData[3],&_Arg2, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[4],&_Arg3, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[5],&_Arg4, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[6],&_Arg5, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[7],_Arg6, _Arg5 * _Arg6_Len_); EventDataDescCreate(&EventData[8],&_Arg7, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[9],_Arg8, (ULONG)(sizeof(WCHAR)*_Arg7)); return McGenEventWrite(Context, Descriptor, Activity, McTemplateK0qpqqqqNR5qzr7_ARGCOUNT + 1, EventData); } #endif // McTemplateK0qpqqqqNR5qzr7_def // // Function for template "tidPepPlatformIdleTransition" (and possibly others). // This function is for use by MC-generated code and should not be used directly. // #ifndef McTemplateK0qq_def #define McTemplateK0qq_def ETW_INLINE ULONG _mcgen_PASTE2(McTemplateK0qq_, MCGEN_EVENTWRITETRANSFER)( _In_ PMCGEN_TRACE_CONTEXT Context, _In_ PCEVENT_DESCRIPTOR Descriptor, _In_opt_ const GUID* Activity, _In_ const unsigned int _Arg0, _In_ const unsigned int _Arg1 ) { #define McTemplateK0qq_ARGCOUNT 2 EVENT_DATA_DESCRIPTOR EventData[McTemplateK0qq_ARGCOUNT + 1]; EventDataDescCreate(&EventData[1],&_Arg0, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[2],&_Arg1, sizeof(const unsigned int) ); return McGenEventWrite(Context, Descriptor, Activity, McTemplateK0qq_ARGCOUNT + 1, EventData); } #endif // McTemplateK0qq_def // // Function for template "tidPepRailVoltageChange" (and possibly others). // This function is for use by MC-generated code and should not be used directly. // #ifndef McTemplateK0qqq_def #define McTemplateK0qqq_def ETW_INLINE ULONG _mcgen_PASTE2(McTemplateK0qqq_, MCGEN_EVENTWRITETRANSFER)( _In_ PMCGEN_TRACE_CONTEXT Context, _In_ PCEVENT_DESCRIPTOR Descriptor, _In_opt_ const GUID* Activity, _In_ const unsigned int _Arg0, _In_ const unsigned int _Arg1, _In_ const unsigned int _Arg2 ) { #define McTemplateK0qqq_ARGCOUNT 3 EVENT_DATA_DESCRIPTOR EventData[McTemplateK0qqq_ARGCOUNT + 1]; EventDataDescCreate(&EventData[1],&_Arg0, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[2],&_Arg1, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[3],&_Arg2, sizeof(const unsigned int) ); return McGenEventWrite(Context, Descriptor, Activity, McTemplateK0qqq_ARGCOUNT + 1, EventData); } #endif // McTemplateK0qqq_def // // Function for template "tidPepRailRundown" (and possibly others). // This function is for use by MC-generated code and should not be used directly. // #ifndef McTemplateK0qzqq_def #define McTemplateK0qzqq_def ETW_INLINE ULONG _mcgen_PASTE2(McTemplateK0qzqq_, MCGEN_EVENTWRITETRANSFER)( _In_ PMCGEN_TRACE_CONTEXT Context, _In_ PCEVENT_DESCRIPTOR Descriptor, _In_opt_ const GUID* Activity, _In_ const unsigned int _Arg0, _In_opt_ PCWSTR _Arg1, _In_ const unsigned int _Arg2, _In_ const unsigned int _Arg3 ) { #define McTemplateK0qzqq_ARGCOUNT 4 EVENT_DATA_DESCRIPTOR EventData[McTemplateK0qzqq_ARGCOUNT + 1]; EventDataDescCreate(&EventData[1],&_Arg0, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[2], (_Arg1 != NULL) ? _Arg1 : L"NULL", (_Arg1 != NULL) ? (ULONG)((wcslen(_Arg1) + 1) * sizeof(WCHAR)) : (ULONG)sizeof(L"NULL")); EventDataDescCreate(&EventData[3],&_Arg2, sizeof(const unsigned int) ); EventDataDescCreate(&EventData[4],&_Arg3, sizeof(const unsigned int) ); return McGenEventWrite(Context, Descriptor, Activity, McTemplateK0qzqq_ARGCOUNT + 1, EventData); } #endif // McTemplateK0qzqq_def #endif // MCGEN_DISABLE_PROVIDER_CODE_GENERATION #if defined(__cplusplus) } #endif #define MSG_PepProviderName 0x90000001L