| 1 |
//**********************************************************************` |
| 2 |
//* This is an include file generated by Message Compiler. *` |
| 3 |
//* *` |
| 4 |
//* Copyright (c) Microsoft Corporation. All Rights Reserved. *` |
| 5 |
//**********************************************************************` |
| 6 |
#pragma once |
| 7 |
|
| 8 |
//***************************************************************************** |
| 9 |
// |
| 10 |
// Notes on the ETW event code generated by MC: |
| 11 |
// |
| 12 |
// - Structures and arrays of structures are treated as an opaque binary blob. |
| 13 |
// The caller is responsible for packing the data for the structure into a |
| 14 |
// single region of memory, with no padding between values. The macro will |
| 15 |
// have an extra parameter for the length of the blob. |
| 16 |
// - Arrays of nul-terminated strings must be packed by the caller into a |
| 17 |
// single binary blob containing the correct number of strings, with a nul |
| 18 |
// after each string. The size of the blob is specified in characters, and |
| 19 |
// includes the final nul. |
| 20 |
// - Arrays of SID are treated as a single binary blob. The caller is |
| 21 |
// responsible for packing the SID values into a single region of memory with |
| 22 |
// no padding. |
| 23 |
// - The length attribute on the data element in the manifest is significant |
| 24 |
// for values with intype win:UnicodeString, win:AnsiString, or win:Binary. |
| 25 |
// The length attribute must be specified for win:Binary, and is optional for |
| 26 |
// win:UnicodeString and win:AnsiString (if no length is given, the strings |
| 27 |
// are assumed to be nul-terminated). For win:UnicodeString, the length is |
| 28 |
// measured in characters, not bytes. |
| 29 |
// - For an array of win:UnicodeString, win:AnsiString, or win:Binary, the |
| 30 |
// length attribute applies to every value in the array, so every value in |
| 31 |
// the array must have the same length. The values in the array are provided |
| 32 |
// to the macro via a single pointer -- the caller is responsible for packing |
| 33 |
// all of the values into a single region of memory with no padding between |
| 34 |
// values. |
| 35 |
// - Values of type win:CountedUnicodeString, win:CountedAnsiString, and |
| 36 |
// win:CountedBinary can be generated and collected on Vista or later. |
| 37 |
// However, they may not decode properly without the Windows 10 2018 Fall |
| 38 |
// Update. |
| 39 |
// - Arrays of type win:CountedUnicodeString, win:CountedAnsiString, and |
| 40 |
// win:CountedBinary must be packed by the caller into a single region of |
| 41 |
// memory. The format for each item is a UINT16 byte-count followed by that |
| 42 |
// many bytes of data. When providing the array to the generated macro, you |
| 43 |
// must provide the total size of the packed array data, including the UINT16 |
| 44 |
// sizes for each item. In the case of win:CountedUnicodeString, the data |
| 45 |
// size is specified in WCHAR (16-bit) units. In the case of |
| 46 |
// win:CountedAnsiString and win:CountedBinary, the data size is specified in |
| 47 |
// bytes. |
| 48 |
// |
| 49 |
//***************************************************************************** |
| 50 |
|
| 51 |
#include <wmistr.h> |
| 52 |
#include <evntrace.h> |
| 53 |
#include <evntprov.h> |
| 54 |
|
| 55 |
#ifndef ETW_INLINE |
| 56 |
#ifdef _ETW_KM_ |
| 57 |
// In kernel mode, save stack space by never inlining templates. |
| 58 |
#define ETW_INLINE DECLSPEC_NOINLINE __inline |
| 59 |
#else |
| 60 |
// In user mode, save code size by inlining templates as appropriate. |
| 61 |
#define ETW_INLINE __inline |
| 62 |
#endif |
| 63 |
#endif // ETW_INLINE |
| 64 |
|
| 65 |
#if defined(__cplusplus) |
| 66 |
extern "C" { |
| 67 |
#endif |
| 68 |
|
| 69 |
// |
| 70 |
// MCGEN_DISABLE_PROVIDER_CODE_GENERATION macro: |
| 71 |
// Define this macro to have the compiler skip the generated functions in this |
| 72 |
// header. |
| 73 |
// |
| 74 |
#ifndef MCGEN_DISABLE_PROVIDER_CODE_GENERATION |
| 75 |
|
| 76 |
// |
| 77 |
// MCGEN_USE_KERNEL_MODE_APIS macro: |
| 78 |
// Controls whether the generated code uses kernel-mode or user-mode APIs. |
| 79 |
// - Set to 0 to use Windows user-mode APIs such as EventRegister. |
| 80 |
// - Set to 1 to use Windows kernel-mode APIs such as EtwRegister. |
| 81 |
// Default is based on whether the _ETW_KM_ macro is defined (i.e. by wdm.h). |
| 82 |
// Note that the APIs can also be overridden directly, e.g. by setting the |
| 83 |
// MCGEN_EVENTWRITETRANSFER or MCGEN_EVENTREGISTER macros. |
| 84 |
// |
| 85 |
#ifndef MCGEN_USE_KERNEL_MODE_APIS |
| 86 |
#ifdef _ETW_KM_ |
| 87 |
#define MCGEN_USE_KERNEL_MODE_APIS 1 |
| 88 |
#else |
| 89 |
#define MCGEN_USE_KERNEL_MODE_APIS 0 |
| 90 |
#endif |
| 91 |
#endif // MCGEN_USE_KERNEL_MODE_APIS |
| 92 |
|
| 93 |
// |
| 94 |
// MCGEN_HAVE_EVENTSETINFORMATION macro: |
| 95 |
// Controls how McGenEventSetInformation uses the EventSetInformation API. |
| 96 |
// - Set to 0 to disable the use of EventSetInformation |
| 97 |
// (McGenEventSetInformation will always return an error). |
| 98 |
// - Set to 1 to directly invoke MCGEN_EVENTSETINFORMATION. |
| 99 |
// - Set to 2 to to locate EventSetInformation at runtime via GetProcAddress |
| 100 |
// (user-mode) or MmGetSystemRoutineAddress (kernel-mode). |
| 101 |
// Default is determined as follows: |
| 102 |
// - If MCGEN_EVENTSETINFORMATION has been customized, set to 1 |
| 103 |
// (i.e. use MCGEN_EVENTSETINFORMATION). |
| 104 |
// - Else if the target OS version has EventSetInformation, set to 1 |
| 105 |
// (i.e. use MCGEN_EVENTSETINFORMATION). |
| 106 |
// - Else set to 2 (i.e. try to dynamically locate EventSetInformation). |
| 107 |
// Note that an McGenEventSetInformation function will only be generated if one |
| 108 |
// or more provider in a manifest has provider traits. |
| 109 |
// |
| 110 |
#ifndef MCGEN_HAVE_EVENTSETINFORMATION |
| 111 |
#ifdef MCGEN_EVENTSETINFORMATION // if MCGEN_EVENTSETINFORMATION has been customized, |
| 112 |
#define MCGEN_HAVE_EVENTSETINFORMATION 1 // directly invoke MCGEN_EVENTSETINFORMATION(...). |
| 113 |
#elif MCGEN_USE_KERNEL_MODE_APIS // else if using kernel-mode APIs, |
| 114 |
#if NTDDI_VERSION >= 0x06040000 // if target OS is Windows 10 or later, |
| 115 |
#define MCGEN_HAVE_EVENTSETINFORMATION 1 // directly invoke MCGEN_EVENTSETINFORMATION(...). |
| 116 |
#else // else |
| 117 |
#define MCGEN_HAVE_EVENTSETINFORMATION 2 // find "EtwSetInformation" via MmGetSystemRoutineAddress. |
| 118 |
#endif // else (using user-mode APIs) |
| 119 |
#else // if target OS and SDK is Windows 8 or later, |
| 120 |
#if WINVER >= 0x0602 && defined(EVENT_FILTER_TYPE_SCHEMATIZED) |
| 121 |
#define MCGEN_HAVE_EVENTSETINFORMATION 1 // directly invoke MCGEN_EVENTSETINFORMATION(...). |
| 122 |
#else // else |
| 123 |
#define MCGEN_HAVE_EVENTSETINFORMATION 2 // find "EventSetInformation" via GetModuleHandleExW/GetProcAddress. |
| 124 |
#endif |
| 125 |
#endif |
| 126 |
#endif // MCGEN_HAVE_EVENTSETINFORMATION |
| 127 |
|
| 128 |
// |
| 129 |
// MCGEN Override Macros |
| 130 |
// |
| 131 |
// The following override macros may be defined before including this header |
| 132 |
// to control the APIs used by this header: |
| 133 |
// |
| 134 |
// - MCGEN_EVENTREGISTER |
| 135 |
// - MCGEN_EVENTUNREGISTER |
| 136 |
// - MCGEN_EVENTSETINFORMATION |
| 137 |
// - MCGEN_EVENTWRITETRANSFER |
| 138 |
// |
| 139 |
// If the macro is undefined, the MC implementation will default to the |
| 140 |
// corresponding ETW APIs. For example, if the MCGEN_EVENTREGISTER macro is |
| 141 |
// undefined, the EventRegister[MyProviderName] macro will use EventRegister |
| 142 |
// in user mode and will use EtwRegister in kernel mode. |
| 143 |
// |
| 144 |
// To prevent issues from conflicting definitions of these macros, the value |
| 145 |
// of the override macro will be used as a suffix in certain internal function |
| 146 |
// names. Because of this, the override macros must follow certain rules: |
| 147 |
// |
| 148 |
// - The macro must be defined before any MC-generated header is included and |
| 149 |
// must not be undefined or redefined after any MC-generated header is |
| 150 |
// included. Different translation units (i.e. different .c or .cpp files) |
| 151 |
// may set the macros to different values, but within a translation unit |
| 152 |
// (within a single .c or .cpp file), the macro must be set once and not |
| 153 |
// changed. |
| 154 |
// - The override must be an object-like macro, not a function-like macro |
| 155 |
// (i.e. the override macro must not have a parameter list). |
| 156 |
// - The override macro's value must be a simple identifier, i.e. must be |
| 157 |
// something that starts with a letter or '_' and contains only letters, |
| 158 |
// numbers, and '_' characters. |
| 159 |
// - If the override macro's value is the name of a second object-like macro, |
| 160 |
// the second object-like macro must follow the same rules. (The override |
| 161 |
// macro's value can also be the name of a function-like macro, in which |
| 162 |
// case the function-like macro does not need to follow the same rules.) |
| 163 |
// |
| 164 |
// For example, the following will cause compile errors: |
| 165 |
// |
| 166 |
// #define MCGEN_EVENTWRITETRANSFER MyNamespace::MyClass::MyFunction // Value has non-identifier characters (colon). |
| 167 |
// #define MCGEN_EVENTWRITETRANSFER GetEventWriteFunctionPointer(7) // Value has non-identifier characters (parentheses). |
| 168 |
// #define MCGEN_EVENTWRITETRANSFER(h,e,a,r,c,d) EventWrite(h,e,c,d) // Override is defined as a function-like macro. |
| 169 |
// #define MY_OBJECT_LIKE_MACRO MyNamespace::MyClass::MyEventWriteFunction |
| 170 |
// #define MCGEN_EVENTWRITETRANSFER MY_OBJECT_LIKE_MACRO // Evaluates to something with non-identifier characters (colon). |
| 171 |
// |
| 172 |
// The following would be ok: |
| 173 |
// |
| 174 |
// #define MCGEN_EVENTWRITETRANSFER MyEventWriteFunction1 // OK, suffix will be "MyEventWriteFunction1". |
| 175 |
// #define MY_OBJECT_LIKE_MACRO MyEventWriteFunction2 |
| 176 |
// #define MCGEN_EVENTWRITETRANSFER MY_OBJECT_LIKE_MACRO // OK, suffix will be "MyEventWriteFunction2". |
| 177 |
// #define MY_FUNCTION_LIKE_MACRO(h,e,a,r,c,d) MyNamespace::MyClass::MyEventWriteFunction3(h,e,c,d) |
| 178 |
// #define MCGEN_EVENTWRITETRANSFER MY_FUNCTION_LIKE_MACRO // OK, suffix will be "MY_FUNCTION_LIKE_MACRO". |
| 179 |
// |
| 180 |
#ifndef MCGEN_EVENTREGISTER |
| 181 |
#if MCGEN_USE_KERNEL_MODE_APIS |
| 182 |
#define MCGEN_EVENTREGISTER EtwRegister |
| 183 |
#else |
| 184 |
#define MCGEN_EVENTREGISTER EventRegister |
| 185 |
#endif |
| 186 |
#endif // MCGEN_EVENTREGISTER |
| 187 |
#ifndef MCGEN_EVENTUNREGISTER |
| 188 |
#if MCGEN_USE_KERNEL_MODE_APIS |
| 189 |
#define MCGEN_EVENTUNREGISTER EtwUnregister |
| 190 |
#else |
| 191 |
#define MCGEN_EVENTUNREGISTER EventUnregister |
| 192 |
#endif |
| 193 |
#endif // MCGEN_EVENTUNREGISTER |
| 194 |
#ifndef MCGEN_EVENTSETINFORMATION |
| 195 |
#if MCGEN_USE_KERNEL_MODE_APIS |
| 196 |
#define MCGEN_EVENTSETINFORMATION EtwSetInformation |
| 197 |
#else |
| 198 |
#define MCGEN_EVENTSETINFORMATION EventSetInformation |
| 199 |
#endif |
| 200 |
#endif // MCGEN_EVENTSETINFORMATION |
| 201 |
#ifndef MCGEN_EVENTWRITETRANSFER |
| 202 |
#if MCGEN_USE_KERNEL_MODE_APIS |
| 203 |
#define MCGEN_EVENTWRITETRANSFER EtwWriteTransfer |
| 204 |
#else |
| 205 |
#define MCGEN_EVENTWRITETRANSFER EventWriteTransfer |
| 206 |
#endif |
| 207 |
#endif // MCGEN_EVENTWRITETRANSFER |
| 208 |
|
| 209 |
// |
| 210 |
// MCGEN_EVENT_ENABLED macro: |
| 211 |
// Override to control how the EventWrite[EventName] macros determine whether |
| 212 |
// an event is enabled. The default behavior is for EventWrite[EventName] to |
| 213 |
// use the EventEnabled[EventName] macros. |
| 214 |
// |
| 215 |
#ifndef MCGEN_EVENT_ENABLED |
| 216 |
#define MCGEN_EVENT_ENABLED(EventName) EventEnabled##EventName() |
| 217 |
#endif |
| 218 |
|
| 219 |
// |
| 220 |
// MCGEN_EVENT_ENABLED_FORCONTEXT macro: |
| 221 |
// Override to control how the EventWrite[EventName]_ForContext macros |
| 222 |
// determine whether an event is enabled. The default behavior is for |
| 223 |
// EventWrite[EventName]_ForContext to use the |
| 224 |
// EventEnabled[EventName]_ForContext macros. |
| 225 |
// |
| 226 |
#ifndef MCGEN_EVENT_ENABLED_FORCONTEXT |
| 227 |
#define MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, EventName) EventEnabled##EventName##_ForContext(pContext) |
| 228 |
#endif |
| 229 |
|
| 230 |
// |
| 231 |
// MCGEN_ENABLE_CHECK macro: |
| 232 |
// Determines whether the specified event would be considered as enabled |
| 233 |
// based on the state of the specified context. Slightly faster than calling |
| 234 |
// McGenEventEnabled directly. |
| 235 |
// |
| 236 |
#ifndef MCGEN_ENABLE_CHECK |
| 237 |
#define MCGEN_ENABLE_CHECK(Context, Descriptor) (Context.IsEnabled && McGenEventEnabled(&Context, &Descriptor)) |
| 238 |
#endif |
| 239 |
|
| 240 |
#if !defined(MCGEN_TRACE_CONTEXT_DEF) |
| 241 |
#define MCGEN_TRACE_CONTEXT_DEF |
| 242 |
// This structure is for use by MC-generated code and should not be used directly. |
| 243 |
typedef struct _MCGEN_TRACE_CONTEXT |
| 244 |
{ |
| 245 |
TRACEHANDLE RegistrationHandle; |
| 246 |
TRACEHANDLE Logger; // Used as pointer to provider traits. |
| 247 |
ULONGLONG MatchAnyKeyword; |
| 248 |
ULONGLONG MatchAllKeyword; |
| 249 |
ULONG Flags; |
| 250 |
ULONG IsEnabled; |
| 251 |
UCHAR Level; |
| 252 |
UCHAR Reserve; |
| 253 |
USHORT EnableBitsCount; |
| 254 |
PULONG EnableBitMask; |
| 255 |
const ULONGLONG* EnableKeyWords; |
| 256 |
const UCHAR* EnableLevel; |
| 257 |
} MCGEN_TRACE_CONTEXT, *PMCGEN_TRACE_CONTEXT; |
| 258 |
#endif // MCGEN_TRACE_CONTEXT_DEF |
| 259 |
|
| 260 |
#if !defined(MCGEN_LEVEL_KEYWORD_ENABLED_DEF) |
| 261 |
#define MCGEN_LEVEL_KEYWORD_ENABLED_DEF |
| 262 |
// |
| 263 |
// Determines whether an event with a given Level and Keyword would be |
| 264 |
// considered as enabled based on the state of the specified context. |
| 265 |
// Note that you may want to use MCGEN_ENABLE_CHECK instead of calling this |
| 266 |
// function directly. |
| 267 |
// |
| 268 |
FORCEINLINE |
| 269 |
BOOLEAN |
| 270 |
McGenLevelKeywordEnabled( |
| 271 |
_In_ PMCGEN_TRACE_CONTEXT EnableInfo, |
| 272 |
_In_ UCHAR Level, |
| 273 |
_In_ ULONGLONG Keyword |
| 274 |
) |
| 275 |
{ |
| 276 |
// |
| 277 |
// Check if the event Level is lower than the level at which |
| 278 |
// the channel is enabled. |
| 279 |
// If the event Level is 0 or the channel is enabled at level 0, |
| 280 |
// all levels are enabled. |
| 281 |
// |
| 282 |
|
| 283 |
if ((Level <= EnableInfo->Level) || // This also covers the case of Level == 0. |
| 284 |
(EnableInfo->Level == 0)) { |
| 285 |
|
| 286 |
// |
| 287 |
// Check if Keyword is enabled |
| 288 |
// |
| 289 |
|
| 290 |
if ((Keyword == (ULONGLONG)0) || |
| 291 |
((Keyword & EnableInfo->MatchAnyKeyword) && |
| 292 |
((Keyword & EnableInfo->MatchAllKeyword) == EnableInfo->MatchAllKeyword))) { |
| 293 |
return TRUE; |
| 294 |
} |
| 295 |
} |
| 296 |
|
| 297 |
return FALSE; |
| 298 |
} |
| 299 |
#endif // MCGEN_LEVEL_KEYWORD_ENABLED_DEF |
| 300 |
|
| 301 |
#if !defined(MCGEN_EVENT_ENABLED_DEF) |
| 302 |
#define MCGEN_EVENT_ENABLED_DEF |
| 303 |
// |
| 304 |
// Determines whether the specified event would be considered as enabled based |
| 305 |
// on the state of the specified context. Note that you may want to use |
| 306 |
// MCGEN_ENABLE_CHECK instead of calling this function directly. |
| 307 |
// |
| 308 |
FORCEINLINE |
| 309 |
BOOLEAN |
| 310 |
McGenEventEnabled( |
| 311 |
_In_ PMCGEN_TRACE_CONTEXT EnableInfo, |
| 312 |
_In_ PCEVENT_DESCRIPTOR EventDescriptor |
| 313 |
) |
| 314 |
{ |
| 315 |
return McGenLevelKeywordEnabled(EnableInfo, EventDescriptor->Level, EventDescriptor->Keyword); |
| 316 |
} |
| 317 |
#endif // MCGEN_EVENT_ENABLED_DEF |
| 318 |
|
| 319 |
#if !defined(MCGEN_CONTROL_CALLBACK) |
| 320 |
#define MCGEN_CONTROL_CALLBACK |
| 321 |
|
| 322 |
// This function is for use by MC-generated code and should not be used directly. |
| 323 |
DECLSPEC_NOINLINE __inline |
| 324 |
VOID |
| 325 |
__stdcall |
| 326 |
McGenControlCallbackV2( |
| 327 |
_In_ LPCGUID SourceId, |
| 328 |
_In_ ULONG ControlCode, |
| 329 |
_In_ UCHAR Level, |
| 330 |
_In_ ULONGLONG MatchAnyKeyword, |
| 331 |
_In_ ULONGLONG MatchAllKeyword, |
| 332 |
_In_opt_ PEVENT_FILTER_DESCRIPTOR FilterData, |
| 333 |
_Inout_opt_ PVOID CallbackContext |
| 334 |
) |
| 335 |
/*++ |
| 336 |
|
| 337 |
Routine Description: |
| 338 |
|
| 339 |
This is the notification callback for Windows Vista and later. |
| 340 |
|
| 341 |
Arguments: |
| 342 |
|
| 343 |
SourceId - The GUID that identifies the session that enabled the provider. |
| 344 |
|
| 345 |
ControlCode - The parameter indicates whether the provider |
| 346 |
is being enabled or disabled. |
| 347 |
|
| 348 |
Level - The level at which the event is enabled. |
| 349 |
|
| 350 |
MatchAnyKeyword - The bitmask of keywords that the provider uses to |
| 351 |
determine the category of events that it writes. |
| 352 |
|
| 353 |
MatchAllKeyword - This bitmask additionally restricts the category |
| 354 |
of events that the provider writes. |
| 355 |
|
| 356 |
FilterData - The provider-defined data. |
| 357 |
|
| 358 |
CallbackContext - The context of the callback that is defined when the provider |
| 359 |
called EtwRegister to register itself. |
| 360 |
|
| 361 |
Remarks: |
| 362 |
|
| 363 |
ETW calls this function to notify provider of enable/disable |
| 364 |
|
| 365 |
--*/ |
| 366 |
{ |
| 367 |
PMCGEN_TRACE_CONTEXT Ctx = (PMCGEN_TRACE_CONTEXT)CallbackContext; |
| 368 |
ULONG Ix; |
| 369 |
#ifndef MCGEN_PRIVATE_ENABLE_CALLBACK_V2 |
| 370 |
UNREFERENCED_PARAMETER(SourceId); |
| 371 |
UNREFERENCED_PARAMETER(FilterData); |
| 372 |
#endif |
| 373 |
|
| 374 |
if (Ctx == NULL) { |
| 375 |
return; |
| 376 |
} |
| 377 |
|
| 378 |
switch (ControlCode) { |
| 379 |
|
| 380 |
case EVENT_CONTROL_CODE_ENABLE_PROVIDER: |
| 381 |
Ctx->Level = Level; |
| 382 |
Ctx->MatchAnyKeyword = MatchAnyKeyword; |
| 383 |
Ctx->MatchAllKeyword = MatchAllKeyword; |
| 384 |
Ctx->IsEnabled = EVENT_CONTROL_CODE_ENABLE_PROVIDER; |
| 385 |
|
| 386 |
for (Ix = 0; Ix < Ctx->EnableBitsCount; Ix += 1) { |
| 387 |
if (McGenLevelKeywordEnabled(Ctx, Ctx->EnableLevel[Ix], Ctx->EnableKeyWords[Ix]) != FALSE) { |
| 388 |
Ctx->EnableBitMask[Ix >> 5] |= (1 << (Ix % 32)); |
| 389 |
} else { |
| 390 |
Ctx->EnableBitMask[Ix >> 5] &= ~(1 << (Ix % 32)); |
| 391 |
} |
| 392 |
} |
| 393 |
break; |
| 394 |
|
| 395 |
case EVENT_CONTROL_CODE_DISABLE_PROVIDER: |
| 396 |
Ctx->IsEnabled = EVENT_CONTROL_CODE_DISABLE_PROVIDER; |
| 397 |
Ctx->Level = 0; |
| 398 |
Ctx->MatchAnyKeyword = 0; |
| 399 |
Ctx->MatchAllKeyword = 0; |
| 400 |
if (Ctx->EnableBitsCount > 0) { |
| 401 |
#pragma warning(suppress: 26451) // Arithmetic overflow cannot occur, no matter the value of EnableBitCount |
| 402 |
RtlZeroMemory(Ctx->EnableBitMask, (((Ctx->EnableBitsCount - 1) / 32) + 1) * sizeof(ULONG)); |
| 403 |
} |
| 404 |
break; |
| 405 |
|
| 406 |
default: |
| 407 |
break; |
| 408 |
} |
| 409 |
|
| 410 |
#ifdef MCGEN_PRIVATE_ENABLE_CALLBACK_V2 |
| 411 |
// |
| 412 |
// Call user defined callback |
| 413 |
// |
| 414 |
MCGEN_PRIVATE_ENABLE_CALLBACK_V2( |
| 415 |
SourceId, |
| 416 |
ControlCode, |
| 417 |
Level, |
| 418 |
MatchAnyKeyword, |
| 419 |
MatchAllKeyword, |
| 420 |
FilterData, |
| 421 |
CallbackContext |
| 422 |
); |
| 423 |
#endif // MCGEN_PRIVATE_ENABLE_CALLBACK_V2 |
| 424 |
|
| 425 |
return; |
| 426 |
} |
| 427 |
|
| 428 |
#endif // MCGEN_CONTROL_CALLBACK |
| 429 |
|
| 430 |
#ifndef _mcgen_PENABLECALLBACK |
| 431 |
#if MCGEN_USE_KERNEL_MODE_APIS |
| 432 |
#define _mcgen_PENABLECALLBACK PETWENABLECALLBACK |
| 433 |
#else |
| 434 |
#define _mcgen_PENABLECALLBACK PENABLECALLBACK |
| 435 |
#endif |
| 436 |
#endif // _mcgen_PENABLECALLBACK |
| 437 |
|
| 438 |
#if !defined(_mcgen_PASTE2) |
| 439 |
// This macro is for use by MC-generated code and should not be used directly. |
| 440 |
#define _mcgen_PASTE2(a, b) _mcgen_PASTE2_imp(a, b) |
| 441 |
#define _mcgen_PASTE2_imp(a, b) a##b |
| 442 |
#endif // _mcgen_PASTE2 |
| 443 |
|
| 444 |
#if !defined(_mcgen_PASTE3) |
| 445 |
// This macro is for use by MC-generated code and should not be used directly. |
| 446 |
#define _mcgen_PASTE3(a, b, c) _mcgen_PASTE3_imp(a, b, c) |
| 447 |
#define _mcgen_PASTE3_imp(a, b, c) a##b##_##c |
| 448 |
#endif // _mcgen_PASTE3 |
| 449 |
|
| 450 |
// |
| 451 |
// Macro validation |
| 452 |
// |
| 453 |
|
| 454 |
// Validate MCGEN_EVENTREGISTER: |
| 455 |
|
| 456 |
// Trigger an error if MCGEN_EVENTREGISTER is not an unqualified (simple) identifier: |
| 457 |
struct _mcgen_PASTE2(MCGEN_EVENTREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTREGISTER); |
| 458 |
|
| 459 |
// Trigger an error if MCGEN_EVENTREGISTER is redefined: |
| 460 |
typedef struct _mcgen_PASTE2(MCGEN_EVENTREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTREGISTER) |
| 461 |
MCGEN_EVENTREGISTER_must_not_be_redefined_between_headers; |
| 462 |
|
| 463 |
// Trigger an error if MCGEN_EVENTREGISTER is defined as a function-like macro: |
| 464 |
typedef void MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTREGISTER; |
| 465 |
typedef int _mcgen_PASTE2(MCGEN_EVENTREGISTER_must_not_be_a_functionLike_macro_, MCGEN_EVENTREGISTER); |
| 466 |
|
| 467 |
// Validate MCGEN_EVENTUNREGISTER: |
| 468 |
|
| 469 |
// Trigger an error if MCGEN_EVENTUNREGISTER is not an unqualified (simple) identifier: |
| 470 |
struct _mcgen_PASTE2(MCGEN_EVENTUNREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTUNREGISTER); |
| 471 |
|
| 472 |
// Trigger an error if MCGEN_EVENTUNREGISTER is redefined: |
| 473 |
typedef struct _mcgen_PASTE2(MCGEN_EVENTUNREGISTER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTUNREGISTER) |
| 474 |
MCGEN_EVENTUNREGISTER_must_not_be_redefined_between_headers; |
| 475 |
|
| 476 |
// Trigger an error if MCGEN_EVENTUNREGISTER is defined as a function-like macro: |
| 477 |
typedef void MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_MCGEN_EVENTUNREGISTER; |
| 478 |
typedef int _mcgen_PASTE2(MCGEN_EVENTUNREGISTER_must_not_be_a_functionLike_macro_, MCGEN_EVENTUNREGISTER); |
| 479 |
|
| 480 |
// Validate MCGEN_EVENTSETINFORMATION: |
| 481 |
|
| 482 |
// Trigger an error if MCGEN_EVENTSETINFORMATION is not an unqualified (simple) identifier: |
| 483 |
struct _mcgen_PASTE2(MCGEN_EVENTSETINFORMATION_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTSETINFORMATION); |
| 484 |
|
| 485 |
// Trigger an error if MCGEN_EVENTSETINFORMATION is redefined: |
| 486 |
typedef struct _mcgen_PASTE2(MCGEN_EVENTSETINFORMATION_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTSETINFORMATION) |
| 487 |
MCGEN_EVENTSETINFORMATION_must_not_be_redefined_between_headers; |
| 488 |
|
| 489 |
// Trigger an error if MCGEN_EVENTSETINFORMATION is defined as a function-like macro: |
| 490 |
typedef void MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_MCGEN_EVENTSETINFORMATION; |
| 491 |
typedef int _mcgen_PASTE2(MCGEN_EVENTSETINFORMATION_must_not_be_a_functionLike_macro_, MCGEN_EVENTSETINFORMATION); |
| 492 |
|
| 493 |
// Validate MCGEN_EVENTWRITETRANSFER: |
| 494 |
|
| 495 |
// Trigger an error if MCGEN_EVENTWRITETRANSFER is not an unqualified (simple) identifier: |
| 496 |
struct _mcgen_PASTE2(MCGEN_EVENTWRITETRANSFER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTWRITETRANSFER); |
| 497 |
|
| 498 |
// Trigger an error if MCGEN_EVENTWRITETRANSFER is redefined: |
| 499 |
typedef struct _mcgen_PASTE2(MCGEN_EVENTWRITETRANSFER_definition_must_be_an_unqualified_identifier_, MCGEN_EVENTWRITETRANSFER) |
| 500 |
MCGEN_EVENTWRITETRANSFER_must_not_be_redefined_between_headers;; |
| 501 |
|
| 502 |
// Trigger an error if MCGEN_EVENTWRITETRANSFER is defined as a function-like macro: |
| 503 |
typedef void MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_MCGEN_EVENTWRITETRANSFER; |
| 504 |
typedef int _mcgen_PASTE2(MCGEN_EVENTWRITETRANSFER_must_not_be_a_functionLike_macro_, MCGEN_EVENTWRITETRANSFER); |
| 505 |
|
| 506 |
#ifndef McGenEventWrite_def |
| 507 |
#define McGenEventWrite_def |
| 508 |
|
| 509 |
// This macro is for use by MC-generated code and should not be used directly. |
| 510 |
#define McGenEventWrite _mcgen_PASTE2(McGenEventWrite_, MCGEN_EVENTWRITETRANSFER) |
| 511 |
|
| 512 |
// This function is for use by MC-generated code and should not be used directly. |
| 513 |
DECLSPEC_NOINLINE __inline |
| 514 |
ULONG __stdcall |
| 515 |
McGenEventWrite( |
| 516 |
_In_ PMCGEN_TRACE_CONTEXT Context, |
| 517 |
_In_ PCEVENT_DESCRIPTOR Descriptor, |
| 518 |
_In_opt_ LPCGUID ActivityId, |
| 519 |
_In_range_(1, 128) ULONG EventDataCount, |
| 520 |
_Pre_cap_(EventDataCount) EVENT_DATA_DESCRIPTOR* EventData |
| 521 |
) |
| 522 |
{ |
| 523 |
const USHORT UNALIGNED* Traits; |
| 524 |
|
| 525 |
// Some customized MCGEN_EVENTWRITETRANSFER macros might ignore ActivityId. |
| 526 |
UNREFERENCED_PARAMETER(ActivityId); |
| 527 |
|
| 528 |
Traits = (const USHORT UNALIGNED*)(UINT_PTR)Context->Logger; |
| 529 |
|
| 530 |
if (Traits == NULL) { |
| 531 |
EventData[0].Ptr = 0; |
| 532 |
EventData[0].Size = 0; |
| 533 |
EventData[0].Reserved = 0; |
| 534 |
} else { |
| 535 |
EventData[0].Ptr = (ULONG_PTR)Traits; |
| 536 |
EventData[0].Size = *Traits; |
| 537 |
EventData[0].Reserved = 2; // EVENT_DATA_DESCRIPTOR_TYPE_PROVIDER_METADATA |
| 538 |
} |
| 539 |
|
| 540 |
return MCGEN_EVENTWRITETRANSFER( |
| 541 |
Context->RegistrationHandle, |
| 542 |
Descriptor, |
| 543 |
ActivityId, |
| 544 |
NULL, |
| 545 |
EventDataCount, |
| 546 |
EventData); |
| 547 |
} |
| 548 |
#endif // McGenEventWrite_def |
| 549 |
|
| 550 |
#if !defined(McGenEventRegisterUnregister) |
| 551 |
#define McGenEventRegisterUnregister |
| 552 |
|
| 553 |
// This macro is for use by MC-generated code and should not be used directly. |
| 554 |
#define McGenEventRegister _mcgen_PASTE2(McGenEventRegister_, MCGEN_EVENTREGISTER) |
| 555 |
|
| 556 |
#pragma warning(push) |
| 557 |
#pragma warning(disable:6103) |
| 558 |
// This function is for use by MC-generated code and should not be used directly. |
| 559 |
DECLSPEC_NOINLINE __inline |
| 560 |
ULONG __stdcall |
| 561 |
McGenEventRegister( |
| 562 |
_In_ LPCGUID ProviderId, |
| 563 |
_In_opt_ _mcgen_PENABLECALLBACK EnableCallback, |
| 564 |
_In_opt_ PVOID CallbackContext, |
| 565 |
_Inout_ PREGHANDLE RegHandle |
| 566 |
) |
| 567 |
/*++ |
| 568 |
|
| 569 |
Routine Description: |
| 570 |
|
| 571 |
This function registers the provider with ETW. |
| 572 |
|
| 573 |
Arguments: |
| 574 |
|
| 575 |
ProviderId - Provider ID to register with ETW. |
| 576 |
|
| 577 |
EnableCallback - Callback to be used. |
| 578 |
|
| 579 |
CallbackContext - Context for the callback. |
| 580 |
|
| 581 |
RegHandle - Pointer to registration handle. |
| 582 |
|
| 583 |
Remarks: |
| 584 |
|
| 585 |
Should not be called if the provider is already registered (i.e. should not |
| 586 |
be called if *RegHandle != 0). Repeatedly registering a provider is a bug |
| 587 |
and may indicate a race condition. However, for compatibility with previous |
| 588 |
behavior, this function will return SUCCESS in this case. |
| 589 |
|
| 590 |
--*/ |
| 591 |
{ |
| 592 |
ULONG Error; |
| 593 |
|
| 594 |
if (*RegHandle != 0) |
| 595 |
{ |
| 596 |
Error = 0; // ERROR_SUCCESS |
| 597 |
} |
| 598 |
else |
| 599 |
{ |
| 600 |
Error = MCGEN_EVENTREGISTER(ProviderId, EnableCallback, CallbackContext, RegHandle); |
| 601 |
} |
| 602 |
|
| 603 |
return Error; |
| 604 |
} |
| 605 |
#pragma warning(pop) |
| 606 |
|
| 607 |
// This macro is for use by MC-generated code and should not be used directly. |
| 608 |
#define McGenEventUnregister _mcgen_PASTE2(McGenEventUnregister_, MCGEN_EVENTUNREGISTER) |
| 609 |
|
| 610 |
// This function is for use by MC-generated code and should not be used directly. |
| 611 |
DECLSPEC_NOINLINE __inline |
| 612 |
ULONG __stdcall |
| 613 |
McGenEventUnregister(_Inout_ PREGHANDLE RegHandle) |
| 614 |
/*++ |
| 615 |
|
| 616 |
Routine Description: |
| 617 |
|
| 618 |
Unregister from ETW and set *RegHandle = 0. |
| 619 |
|
| 620 |
Arguments: |
| 621 |
|
| 622 |
RegHandle - the pointer to the provider registration handle |
| 623 |
|
| 624 |
Remarks: |
| 625 |
|
| 626 |
If provider has not been registered (i.e. if *RegHandle == 0), |
| 627 |
return SUCCESS. It is safe to call McGenEventUnregister even if the |
| 628 |
call to McGenEventRegister returned an error. |
| 629 |
|
| 630 |
--*/ |
| 631 |
{ |
| 632 |
ULONG Error; |
| 633 |
|
| 634 |
if(*RegHandle == 0) |
| 635 |
{ |
| 636 |
Error = 0; // ERROR_SUCCESS |
| 637 |
} |
| 638 |
else |
| 639 |
{ |
| 640 |
Error = MCGEN_EVENTUNREGISTER(*RegHandle); |
| 641 |
*RegHandle = (REGHANDLE)0; |
| 642 |
} |
| 643 |
|
| 644 |
return Error; |
| 645 |
} |
| 646 |
|
| 647 |
#endif // McGenEventRegisterUnregister |
| 648 |
|
| 649 |
#ifndef _mcgen_EVENT_BIT_SET |
| 650 |
#if defined(_M_IX86) || defined(_M_X64) |
| 651 |
// This macro is for use by MC-generated code and should not be used directly. |
| 652 |
#define _mcgen_EVENT_BIT_SET(EnableBits, BitPosition) ((((const unsigned char*)EnableBits)[BitPosition >> 3] & (1u << (BitPosition & 7))) != 0) |
| 653 |
#else // CPU type |
| 654 |
// This macro is for use by MC-generated code and should not be used directly. |
| 655 |
#define _mcgen_EVENT_BIT_SET(EnableBits, BitPosition) ((EnableBits[BitPosition >> 5] & (1u << (BitPosition & 31))) != 0) |
| 656 |
#endif // CPU type |
| 657 |
#endif // _mcgen_EVENT_BIT_SET |
| 658 |
|
| 659 |
#endif // MCGEN_DISABLE_PROVIDER_CODE_GENERATION |
| 660 |
|
| 661 |
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 662 |
// Provider "microsoft-windows-mimalloc" event count 2 |
| 663 |
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ |
| 664 |
|
| 665 |
// Provider GUID = 138f4dbb-ee04-4899-aa0a-572ad4475779 |
| 666 |
EXTERN_C __declspec(selectany) const GUID ETW_MI_Provider = {0x138f4dbb, 0xee04, 0x4899, {0xaa, 0x0a, 0x57, 0x2a, 0xd4, 0x47, 0x57, 0x79}}; |
| 667 |
|
| 668 |
#ifndef ETW_MI_Provider_Traits |
| 669 |
#define ETW_MI_Provider_Traits NULL |
| 670 |
#endif // ETW_MI_Provider_Traits |
| 671 |
|
| 672 |
// |
| 673 |
// Event Descriptors |
| 674 |
// |
| 675 |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR ETW_MI_ALLOC = {0x64, 0x1, 0x0, 0x4, 0x0, 0x0, 0x0}; |
| 676 |
#define ETW_MI_ALLOC_value 0x64 |
| 677 |
EXTERN_C __declspec(selectany) const EVENT_DESCRIPTOR ETW_MI_FREE = {0x65, 0x1, 0x0, 0x4, 0x0, 0x0, 0x0}; |
| 678 |
#define ETW_MI_FREE_value 0x65 |
| 679 |
|
| 680 |
// |
| 681 |
// MCGEN_DISABLE_PROVIDER_CODE_GENERATION macro: |
| 682 |
// Define this macro to have the compiler skip the generated functions in this |
| 683 |
// header. |
| 684 |
// |
| 685 |
#ifndef MCGEN_DISABLE_PROVIDER_CODE_GENERATION |
| 686 |
|
| 687 |
// |
| 688 |
// Event Enablement Bits |
| 689 |
// These variables are for use by MC-generated code and should not be used directly. |
| 690 |
// |
| 691 |
EXTERN_C __declspec(selectany) DECLSPEC_CACHEALIGN ULONG microsoft_windows_mimallocEnableBits[1]; |
| 692 |
EXTERN_C __declspec(selectany) const ULONGLONG microsoft_windows_mimallocKeywords[1] = {0x0}; |
| 693 |
EXTERN_C __declspec(selectany) const unsigned char microsoft_windows_mimallocLevels[1] = {4}; |
| 694 |
|
| 695 |
// |
| 696 |
// Provider context |
| 697 |
// |
| 698 |
EXTERN_C __declspec(selectany) MCGEN_TRACE_CONTEXT ETW_MI_Provider_Context = {0, (ULONG_PTR)ETW_MI_Provider_Traits, 0, 0, 0, 0, 0, 0, 1, microsoft_windows_mimallocEnableBits, microsoft_windows_mimallocKeywords, microsoft_windows_mimallocLevels}; |
| 699 |
|
| 700 |
// |
| 701 |
// Provider REGHANDLE |
| 702 |
// |
| 703 |
#define microsoft_windows_mimallocHandle (ETW_MI_Provider_Context.RegistrationHandle) |
| 704 |
|
| 705 |
// |
| 706 |
// This macro is set to 0, indicating that the EventWrite[Name] macros do not |
| 707 |
// have an Activity parameter. This is controlled by the -km and -um options. |
| 708 |
// |
| 709 |
#define ETW_MI_Provider_EventWriteActivity 0 |
| 710 |
|
| 711 |
// |
| 712 |
// Register with ETW using the control GUID specified in the manifest. |
| 713 |
// Invoke this macro during module initialization (i.e. program startup, |
| 714 |
// DLL process attach, or driver load) to initialize the provider. |
| 715 |
// Note that if this function returns an error, the error means that |
| 716 |
// will not work, but no action needs to be taken -- even if EventRegister |
| 717 |
// returns an error, it is generally safe to use EventWrite and |
| 718 |
// EventUnregister macros (they will be no-ops if EventRegister failed). |
| 719 |
// |
| 720 |
#ifndef EventRegistermicrosoft_windows_mimalloc |
| 721 |
#define EventRegistermicrosoft_windows_mimalloc() McGenEventRegister(&ETW_MI_Provider, McGenControlCallbackV2, &ETW_MI_Provider_Context, µsoft_windows_mimallocHandle) |
| 722 |
#endif |
| 723 |
|
| 724 |
// |
| 725 |
// Register with ETW using a specific control GUID (i.e. a GUID other than what |
| 726 |
// is specified in the manifest). Advanced scenarios only. |
| 727 |
// |
| 728 |
#ifndef EventRegisterByGuidmicrosoft_windows_mimalloc |
| 729 |
#define EventRegisterByGuidmicrosoft_windows_mimalloc(Guid) McGenEventRegister(&(Guid), McGenControlCallbackV2, &ETW_MI_Provider_Context, µsoft_windows_mimallocHandle) |
| 730 |
#endif |
| 731 |
|
| 732 |
// |
| 733 |
// Unregister with ETW and close the provider. |
| 734 |
// Invoke this macro during module shutdown (i.e. program exit, DLL process |
| 735 |
// detach, or driver unload) to unregister the provider. |
| 736 |
// Note that you MUST call EventUnregister before DLL or driver unload |
| 737 |
// (not optional): failure to unregister a provider before DLL or driver unload |
| 738 |
// will result in crashes. |
| 739 |
// |
| 740 |
#ifndef EventUnregistermicrosoft_windows_mimalloc |
| 741 |
#define EventUnregistermicrosoft_windows_mimalloc() McGenEventUnregister(µsoft_windows_mimallocHandle) |
| 742 |
#endif |
| 743 |
|
| 744 |
// |
| 745 |
// MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION macro: |
| 746 |
// Define this macro to enable support for caller-allocated provider context. |
| 747 |
// |
| 748 |
#ifdef MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION |
| 749 |
|
| 750 |
// |
| 751 |
// Advanced scenarios: Caller-allocated provider context. |
| 752 |
// Use when multiple differently-configured provider handles are needed, |
| 753 |
// e.g. for container-aware drivers, one context per container. |
| 754 |
// |
| 755 |
// Usage: |
| 756 |
// |
| 757 |
// - Caller enables the feature before including this header, e.g. |
| 758 |
// #define MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION 1 |
| 759 |
// - Caller allocates memory, e.g. pContext = malloc(sizeof(McGenContext_microsoft_windows_mimalloc)); |
| 760 |
// - Caller registers the provider, e.g. EventRegistermicrosoft_windows_mimalloc_ForContext(pContext); |
| 761 |
// - Caller writes events, e.g. EventWriteMyEvent_ForContext(pContext, ...); |
| 762 |
// - Caller unregisters, e.g. EventUnregistermicrosoft_windows_mimalloc_ForContext(pContext); |
| 763 |
// - Caller frees memory, e.g. free(pContext); |
| 764 |
// |
| 765 |
|
| 766 |
typedef struct tagMcGenContext_microsoft_windows_mimalloc { |
| 767 |
// The fields of this structure are subject to change and should |
| 768 |
// not be accessed directly. To access the provider's REGHANDLE, |
| 769 |
// use microsoft_windows_mimallocHandle_ForContext(pContext). |
| 770 |
MCGEN_TRACE_CONTEXT Context; |
| 771 |
ULONG EnableBits[1]; |
| 772 |
} McGenContext_microsoft_windows_mimalloc; |
| 773 |
|
| 774 |
#define EventRegistermicrosoft_windows_mimalloc_ForContext(pContext) _mcgen_PASTE2(_mcgen_RegisterForContext_microsoft_windows_mimalloc_, MCGEN_EVENTREGISTER)(&ETW_MI_Provider, pContext) |
| 775 |
#define EventRegisterByGuidmicrosoft_windows_mimalloc_ForContext(Guid, pContext) _mcgen_PASTE2(_mcgen_RegisterForContext_microsoft_windows_mimalloc_, MCGEN_EVENTREGISTER)(&(Guid), pContext) |
| 776 |
#define EventUnregistermicrosoft_windows_mimalloc_ForContext(pContext) McGenEventUnregister(&(pContext)->Context.RegistrationHandle) |
| 777 |
|
| 778 |
// |
| 779 |
// Provider REGHANDLE for caller-allocated context. |
| 780 |
// |
| 781 |
#define microsoft_windows_mimallocHandle_ForContext(pContext) ((pContext)->Context.RegistrationHandle) |
| 782 |
|
| 783 |
// This function is for use by MC-generated code and should not be used directly. |
| 784 |
// Initialize and register the caller-allocated context. |
| 785 |
__inline |
| 786 |
ULONG __stdcall |
| 787 |
_mcgen_PASTE2(_mcgen_RegisterForContext_microsoft_windows_mimalloc_, MCGEN_EVENTREGISTER)( |
| 788 |
_In_ LPCGUID pProviderId, |
| 789 |
_Out_ McGenContext_microsoft_windows_mimalloc* pContext) |
| 790 |
{ |
| 791 |
RtlZeroMemory(pContext, sizeof(*pContext)); |
| 792 |
pContext->Context.Logger = (ULONG_PTR)ETW_MI_Provider_Traits; |
| 793 |
pContext->Context.EnableBitsCount = 1; |
| 794 |
pContext->Context.EnableBitMask = pContext->EnableBits; |
| 795 |
pContext->Context.EnableKeyWords = microsoft_windows_mimallocKeywords; |
| 796 |
pContext->Context.EnableLevel = microsoft_windows_mimallocLevels; |
| 797 |
return McGenEventRegister( |
| 798 |
pProviderId, |
| 799 |
McGenControlCallbackV2, |
| 800 |
&pContext->Context, |
| 801 |
&pContext->Context.RegistrationHandle); |
| 802 |
} |
| 803 |
|
| 804 |
// This function is for use by MC-generated code and should not be used directly. |
| 805 |
// Trigger a compile error if called with the wrong parameter type. |
| 806 |
FORCEINLINE |
| 807 |
_Ret_ McGenContext_microsoft_windows_mimalloc* |
| 808 |
_mcgen_CheckContextType_microsoft_windows_mimalloc(_In_ McGenContext_microsoft_windows_mimalloc* pContext) |
| 809 |
{ |
| 810 |
return pContext; |
| 811 |
} |
| 812 |
|
| 813 |
#endif // MCGEN_ENABLE_FORCONTEXT_CODE_GENERATION |
| 814 |
|
| 815 |
// |
| 816 |
// Enablement check macro for event "ETW_MI_ALLOC" |
| 817 |
// |
| 818 |
#define EventEnabledETW_MI_ALLOC() _mcgen_EVENT_BIT_SET(microsoft_windows_mimallocEnableBits, 0) |
| 819 |
#define EventEnabledETW_MI_ALLOC_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_microsoft_windows_mimalloc(pContext)->EnableBits, 0) |
| 820 |
|
| 821 |
// |
| 822 |
// Event write macros for event "ETW_MI_ALLOC" |
| 823 |
// |
| 824 |
#define EventWriteETW_MI_ALLOC(Address, Size) \ |
| 825 |
MCGEN_EVENT_ENABLED(ETW_MI_ALLOC) \ |
| 826 |
? _mcgen_TEMPLATE_FOR_ETW_MI_ALLOC(&ETW_MI_Provider_Context, &ETW_MI_ALLOC, Address, Size) : 0 |
| 827 |
#define EventWriteETW_MI_ALLOC_AssumeEnabled(Address, Size) \ |
| 828 |
_mcgen_TEMPLATE_FOR_ETW_MI_ALLOC(&ETW_MI_Provider_Context, &ETW_MI_ALLOC, Address, Size) |
| 829 |
#define EventWriteETW_MI_ALLOC_ForContext(pContext, Address, Size) \ |
| 830 |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, ETW_MI_ALLOC) \ |
| 831 |
? _mcgen_TEMPLATE_FOR_ETW_MI_ALLOC(&(pContext)->Context, &ETW_MI_ALLOC, Address, Size) : 0 |
| 832 |
#define EventWriteETW_MI_ALLOC_ForContextAssumeEnabled(pContext, Address, Size) \ |
| 833 |
_mcgen_TEMPLATE_FOR_ETW_MI_ALLOC(&_mcgen_CheckContextType_microsoft_windows_mimalloc(pContext)->Context, &ETW_MI_ALLOC, Address, Size) |
| 834 |
|
| 835 |
// This macro is for use by MC-generated code and should not be used directly. |
| 836 |
#define _mcgen_TEMPLATE_FOR_ETW_MI_ALLOC _mcgen_PASTE2(McTemplateU0xx_, MCGEN_EVENTWRITETRANSFER) |
| 837 |
|
| 838 |
// |
| 839 |
// Enablement check macro for event "ETW_MI_FREE" |
| 840 |
// |
| 841 |
#define EventEnabledETW_MI_FREE() _mcgen_EVENT_BIT_SET(microsoft_windows_mimallocEnableBits, 0) |
| 842 |
#define EventEnabledETW_MI_FREE_ForContext(pContext) _mcgen_EVENT_BIT_SET(_mcgen_CheckContextType_microsoft_windows_mimalloc(pContext)->EnableBits, 0) |
| 843 |
|
| 844 |
// |
| 845 |
// Event write macros for event "ETW_MI_FREE" |
| 846 |
// |
| 847 |
#define EventWriteETW_MI_FREE(Address, Size) \ |
| 848 |
MCGEN_EVENT_ENABLED(ETW_MI_FREE) \ |
| 849 |
? _mcgen_TEMPLATE_FOR_ETW_MI_FREE(&ETW_MI_Provider_Context, &ETW_MI_FREE, Address, Size) : 0 |
| 850 |
#define EventWriteETW_MI_FREE_AssumeEnabled(Address, Size) \ |
| 851 |
_mcgen_TEMPLATE_FOR_ETW_MI_FREE(&ETW_MI_Provider_Context, &ETW_MI_FREE, Address, Size) |
| 852 |
#define EventWriteETW_MI_FREE_ForContext(pContext, Address, Size) \ |
| 853 |
MCGEN_EVENT_ENABLED_FORCONTEXT(pContext, ETW_MI_FREE) \ |
| 854 |
? _mcgen_TEMPLATE_FOR_ETW_MI_FREE(&(pContext)->Context, &ETW_MI_FREE, Address, Size) : 0 |
| 855 |
#define EventWriteETW_MI_FREE_ForContextAssumeEnabled(pContext, Address, Size) \ |
| 856 |
_mcgen_TEMPLATE_FOR_ETW_MI_FREE(&_mcgen_CheckContextType_microsoft_windows_mimalloc(pContext)->Context, &ETW_MI_FREE, Address, Size) |
| 857 |
|
| 858 |
// This macro is for use by MC-generated code and should not be used directly. |
| 859 |
#define _mcgen_TEMPLATE_FOR_ETW_MI_FREE _mcgen_PASTE2(McTemplateU0xx_, MCGEN_EVENTWRITETRANSFER) |
| 860 |
|
| 861 |
#endif // MCGEN_DISABLE_PROVIDER_CODE_GENERATION |
| 862 |
|
| 863 |
// |
| 864 |
// MCGEN_DISABLE_PROVIDER_CODE_GENERATION macro: |
| 865 |
// Define this macro to have the compiler skip the generated functions in this |
| 866 |
// header. |
| 867 |
// |
| 868 |
#ifndef MCGEN_DISABLE_PROVIDER_CODE_GENERATION |
| 869 |
|
| 870 |
// |
| 871 |
// Template Functions |
| 872 |
// |
| 873 |
|
| 874 |
// |
| 875 |
// Function for template "ETW_CUSTOM_HEAP_ALLOC_DATA" (and possibly others). |
| 876 |
// This function is for use by MC-generated code and should not be used directly. |
| 877 |
// |
| 878 |
#ifndef McTemplateU0xx_def |
| 879 |
#define McTemplateU0xx_def |
| 880 |
ETW_INLINE |
| 881 |
ULONG |
| 882 |
_mcgen_PASTE2(McTemplateU0xx_, MCGEN_EVENTWRITETRANSFER)( |
| 883 |
_In_ PMCGEN_TRACE_CONTEXT Context, |
| 884 |
_In_ PCEVENT_DESCRIPTOR Descriptor, |
| 885 |
_In_ const unsigned __int64 _Arg0, |
| 886 |
_In_ const unsigned __int64 _Arg1 |
| 887 |
) |
| 888 |
{ |
| 889 |
#define McTemplateU0xx_ARGCOUNT 2 |
| 890 |
|
| 891 |
EVENT_DATA_DESCRIPTOR EventData[McTemplateU0xx_ARGCOUNT + 1]; |
| 892 |
|
| 893 |
EventDataDescCreate(&EventData[1],&_Arg0, sizeof(const unsigned __int64) ); |
| 894 |
|
| 895 |
EventDataDescCreate(&EventData[2],&_Arg1, sizeof(const unsigned __int64) ); |
| 896 |
|
| 897 |
return McGenEventWrite(Context, Descriptor, NULL, McTemplateU0xx_ARGCOUNT + 1, EventData); |
| 898 |
} |
| 899 |
#endif // McTemplateU0xx_def |
| 900 |
|
| 901 |
#endif // MCGEN_DISABLE_PROVIDER_CODE_GENERATION |
| 902 |
|
| 903 |
#if defined(__cplusplus) |
| 904 |
} |
| 905 |
#endif |