1// Licensed to the .NET Foundation under one or more agreements.
2// The .NET Foundation licenses this file to you under the MIT license.
3// See the LICENSE file in the project root for more information.
4
5/******************************************************************
6
7DO NOT MODIFY. AUTOGENERATED FILE.
8This file is generated using the logic from <root>/src/scripts/genEventPipe.py
9
10******************************************************************/
11
12
13#include "/workspace/coreclr/src/vm/common.h"
14#include "/workspace/coreclr/src/vm/eventpipeprovider.h"
15#include "/workspace/coreclr/src/vm/eventpipeevent.h"
16#include "/workspace/coreclr/src/vm/eventpipe.h"
17
18#if defined(FEATURE_PAL)
19#define wcslen PAL_wcslen
20#endif
21
22bool ResizeBuffer(char *&buffer, size_t& size, size_t currLen, size_t newSize, bool &fixedBuffer);
23bool WriteToBuffer(PCWSTR str, char *&buffer, size_t& offset, size_t& size, bool &fixedBuffer);
24bool WriteToBuffer(const char *str, char *&buffer, size_t& offset, size_t& size, bool &fixedBuffer);
25bool WriteToBuffer(const BYTE *src, size_t len, char *&buffer, size_t& offset, size_t& size, bool &fixedBuffer);
26
27template <typename T>
28bool WriteToBuffer(const T &value, char *&buffer, size_t& offset, size_t& size, bool &fixedBuffer)
29{
30 if (sizeof(T) + offset > size)
31 {
32 if (!ResizeBuffer(buffer, size, offset, size + sizeof(T), fixedBuffer))
33 return false;
34 }
35
36 memcpy(buffer + offset, (char *)&value, sizeof(T));
37 offset += sizeof(T);
38 return true;
39}
40
41const WCHAR* DotNETRuntimeName = W("Microsoft-Windows-DotNETRuntime");
42EventPipeProvider *EventPipeProviderDotNETRuntime = nullptr;
43EventPipeEvent *EventPipeEventGCStart = nullptr;
44EventPipeEvent *EventPipeEventGCStart_V1 = nullptr;
45EventPipeEvent *EventPipeEventGCStart_V2 = nullptr;
46EventPipeEvent *EventPipeEventGCEnd = nullptr;
47EventPipeEvent *EventPipeEventGCEnd_V1 = nullptr;
48EventPipeEvent *EventPipeEventGCRestartEEEnd = nullptr;
49EventPipeEvent *EventPipeEventGCRestartEEEnd_V1 = nullptr;
50EventPipeEvent *EventPipeEventGCHeapStats = nullptr;
51EventPipeEvent *EventPipeEventGCHeapStats_V1 = nullptr;
52EventPipeEvent *EventPipeEventGCCreateSegment = nullptr;
53EventPipeEvent *EventPipeEventGCCreateSegment_V1 = nullptr;
54EventPipeEvent *EventPipeEventGCFreeSegment = nullptr;
55EventPipeEvent *EventPipeEventGCFreeSegment_V1 = nullptr;
56EventPipeEvent *EventPipeEventGCRestartEEBegin = nullptr;
57EventPipeEvent *EventPipeEventGCRestartEEBegin_V1 = nullptr;
58EventPipeEvent *EventPipeEventGCSuspendEEEnd = nullptr;
59EventPipeEvent *EventPipeEventGCSuspendEEEnd_V1 = nullptr;
60EventPipeEvent *EventPipeEventGCSuspendEEBegin = nullptr;
61EventPipeEvent *EventPipeEventGCSuspendEEBegin_V1 = nullptr;
62EventPipeEvent *EventPipeEventGCAllocationTick = nullptr;
63EventPipeEvent *EventPipeEventGCAllocationTick_V1 = nullptr;
64EventPipeEvent *EventPipeEventGCAllocationTick_V2 = nullptr;
65EventPipeEvent *EventPipeEventGCAllocationTick_V3 = nullptr;
66EventPipeEvent *EventPipeEventGCCreateConcurrentThread = nullptr;
67EventPipeEvent *EventPipeEventGCCreateConcurrentThread_V1 = nullptr;
68EventPipeEvent *EventPipeEventGCTerminateConcurrentThread = nullptr;
69EventPipeEvent *EventPipeEventGCTerminateConcurrentThread_V1 = nullptr;
70EventPipeEvent *EventPipeEventGCFinalizersEnd = nullptr;
71EventPipeEvent *EventPipeEventGCFinalizersEnd_V1 = nullptr;
72EventPipeEvent *EventPipeEventGCFinalizersBegin = nullptr;
73EventPipeEvent *EventPipeEventGCFinalizersBegin_V1 = nullptr;
74EventPipeEvent *EventPipeEventBulkType = nullptr;
75EventPipeEvent *EventPipeEventGCBulkRootEdge = nullptr;
76EventPipeEvent *EventPipeEventGCBulkRootConditionalWeakTableElementEdge = nullptr;
77EventPipeEvent *EventPipeEventGCBulkNode = nullptr;
78EventPipeEvent *EventPipeEventGCBulkEdge = nullptr;
79EventPipeEvent *EventPipeEventGCSampledObjectAllocationHigh = nullptr;
80EventPipeEvent *EventPipeEventGCBulkSurvivingObjectRanges = nullptr;
81EventPipeEvent *EventPipeEventGCBulkMovedObjectRanges = nullptr;
82EventPipeEvent *EventPipeEventGCGenerationRange = nullptr;
83EventPipeEvent *EventPipeEventGCMarkStackRoots = nullptr;
84EventPipeEvent *EventPipeEventGCMarkFinalizeQueueRoots = nullptr;
85EventPipeEvent *EventPipeEventGCMarkHandles = nullptr;
86EventPipeEvent *EventPipeEventGCMarkOlderGenerationRoots = nullptr;
87EventPipeEvent *EventPipeEventFinalizeObject = nullptr;
88EventPipeEvent *EventPipeEventSetGCHandle = nullptr;
89EventPipeEvent *EventPipeEventDestroyGCHandle = nullptr;
90EventPipeEvent *EventPipeEventGCSampledObjectAllocationLow = nullptr;
91EventPipeEvent *EventPipeEventPinObjectAtGCTime = nullptr;
92EventPipeEvent *EventPipeEventGCTriggered = nullptr;
93EventPipeEvent *EventPipeEventGCBulkRootCCW = nullptr;
94EventPipeEvent *EventPipeEventGCBulkRCW = nullptr;
95EventPipeEvent *EventPipeEventGCBulkRootStaticVar = nullptr;
96EventPipeEvent *EventPipeEventGCDynamicEvent = nullptr;
97EventPipeEvent *EventPipeEventWorkerThreadCreate = nullptr;
98EventPipeEvent *EventPipeEventWorkerThreadTerminate = nullptr;
99EventPipeEvent *EventPipeEventWorkerThreadRetire = nullptr;
100EventPipeEvent *EventPipeEventWorkerThreadUnretire = nullptr;
101EventPipeEvent *EventPipeEventIOThreadCreate = nullptr;
102EventPipeEvent *EventPipeEventIOThreadCreate_V1 = nullptr;
103EventPipeEvent *EventPipeEventIOThreadTerminate = nullptr;
104EventPipeEvent *EventPipeEventIOThreadTerminate_V1 = nullptr;
105EventPipeEvent *EventPipeEventIOThreadRetire = nullptr;
106EventPipeEvent *EventPipeEventIOThreadRetire_V1 = nullptr;
107EventPipeEvent *EventPipeEventIOThreadUnretire = nullptr;
108EventPipeEvent *EventPipeEventIOThreadUnretire_V1 = nullptr;
109EventPipeEvent *EventPipeEventThreadpoolSuspensionSuspendThread = nullptr;
110EventPipeEvent *EventPipeEventThreadpoolSuspensionResumeThread = nullptr;
111EventPipeEvent *EventPipeEventThreadPoolWorkerThreadStart = nullptr;
112EventPipeEvent *EventPipeEventThreadPoolWorkerThreadStop = nullptr;
113EventPipeEvent *EventPipeEventThreadPoolWorkerThreadRetirementStart = nullptr;
114EventPipeEvent *EventPipeEventThreadPoolWorkerThreadRetirementStop = nullptr;
115EventPipeEvent *EventPipeEventThreadPoolWorkerThreadAdjustmentSample = nullptr;
116EventPipeEvent *EventPipeEventThreadPoolWorkerThreadAdjustmentAdjustment = nullptr;
117EventPipeEvent *EventPipeEventThreadPoolWorkerThreadAdjustmentStats = nullptr;
118EventPipeEvent *EventPipeEventThreadPoolWorkerThreadWait = nullptr;
119EventPipeEvent *EventPipeEventThreadPoolWorkingThreadCount = nullptr;
120EventPipeEvent *EventPipeEventThreadPoolEnqueue = nullptr;
121EventPipeEvent *EventPipeEventThreadPoolDequeue = nullptr;
122EventPipeEvent *EventPipeEventThreadPoolIOEnqueue = nullptr;
123EventPipeEvent *EventPipeEventThreadPoolIODequeue = nullptr;
124EventPipeEvent *EventPipeEventThreadPoolIOPack = nullptr;
125EventPipeEvent *EventPipeEventThreadCreating = nullptr;
126EventPipeEvent *EventPipeEventThreadRunning = nullptr;
127EventPipeEvent *EventPipeEventExceptionThrown = nullptr;
128EventPipeEvent *EventPipeEventExceptionThrown_V1 = nullptr;
129EventPipeEvent *EventPipeEventExceptionCatchStart = nullptr;
130EventPipeEvent *EventPipeEventExceptionCatchStop = nullptr;
131EventPipeEvent *EventPipeEventExceptionFinallyStart = nullptr;
132EventPipeEvent *EventPipeEventExceptionFinallyStop = nullptr;
133EventPipeEvent *EventPipeEventExceptionFilterStart = nullptr;
134EventPipeEvent *EventPipeEventExceptionFilterStop = nullptr;
135EventPipeEvent *EventPipeEventExceptionThrownStop = nullptr;
136EventPipeEvent *EventPipeEventContention = nullptr;
137EventPipeEvent *EventPipeEventContentionStart_V1 = nullptr;
138EventPipeEvent *EventPipeEventContentionStop = nullptr;
139EventPipeEvent *EventPipeEventCLRStackWalk = nullptr;
140EventPipeEvent *EventPipeEventAppDomainMemAllocated = nullptr;
141EventPipeEvent *EventPipeEventAppDomainMemSurvived = nullptr;
142EventPipeEvent *EventPipeEventThreadCreated = nullptr;
143EventPipeEvent *EventPipeEventThreadTerminated = nullptr;
144EventPipeEvent *EventPipeEventThreadDomainEnter = nullptr;
145EventPipeEvent *EventPipeEventILStubGenerated = nullptr;
146EventPipeEvent *EventPipeEventILStubCacheHit = nullptr;
147EventPipeEvent *EventPipeEventDCStartCompleteV2 = nullptr;
148EventPipeEvent *EventPipeEventDCEndCompleteV2 = nullptr;
149EventPipeEvent *EventPipeEventMethodDCStartV2 = nullptr;
150EventPipeEvent *EventPipeEventMethodDCEndV2 = nullptr;
151EventPipeEvent *EventPipeEventMethodDCStartVerboseV2 = nullptr;
152EventPipeEvent *EventPipeEventMethodDCEndVerboseV2 = nullptr;
153EventPipeEvent *EventPipeEventMethodLoad = nullptr;
154EventPipeEvent *EventPipeEventMethodLoad_V1 = nullptr;
155EventPipeEvent *EventPipeEventMethodLoad_V2 = nullptr;
156EventPipeEvent *EventPipeEventMethodUnload = nullptr;
157EventPipeEvent *EventPipeEventMethodUnload_V1 = nullptr;
158EventPipeEvent *EventPipeEventMethodUnload_V2 = nullptr;
159EventPipeEvent *EventPipeEventMethodLoadVerbose = nullptr;
160EventPipeEvent *EventPipeEventMethodLoadVerbose_V1 = nullptr;
161EventPipeEvent *EventPipeEventMethodLoadVerbose_V2 = nullptr;
162EventPipeEvent *EventPipeEventMethodUnloadVerbose = nullptr;
163EventPipeEvent *EventPipeEventMethodUnloadVerbose_V1 = nullptr;
164EventPipeEvent *EventPipeEventMethodUnloadVerbose_V2 = nullptr;
165EventPipeEvent *EventPipeEventMethodJittingStarted = nullptr;
166EventPipeEvent *EventPipeEventMethodJittingStarted_V1 = nullptr;
167EventPipeEvent *EventPipeEventMethodJitInliningSucceeded = nullptr;
168EventPipeEvent *EventPipeEventMethodJitInliningFailedAnsi = nullptr;
169EventPipeEvent *EventPipeEventMethodJitTailCallSucceeded = nullptr;
170EventPipeEvent *EventPipeEventMethodJitTailCallFailedAnsi = nullptr;
171EventPipeEvent *EventPipeEventMethodILToNativeMap = nullptr;
172EventPipeEvent *EventPipeEventMethodJitTailCallFailed = nullptr;
173EventPipeEvent *EventPipeEventMethodJitInliningFailed = nullptr;
174EventPipeEvent *EventPipeEventModuleDCStartV2 = nullptr;
175EventPipeEvent *EventPipeEventModuleDCEndV2 = nullptr;
176EventPipeEvent *EventPipeEventDomainModuleLoad = nullptr;
177EventPipeEvent *EventPipeEventDomainModuleLoad_V1 = nullptr;
178EventPipeEvent *EventPipeEventModuleLoad = nullptr;
179EventPipeEvent *EventPipeEventModuleLoad_V1 = nullptr;
180EventPipeEvent *EventPipeEventModuleLoad_V2 = nullptr;
181EventPipeEvent *EventPipeEventModuleUnload = nullptr;
182EventPipeEvent *EventPipeEventModuleUnload_V1 = nullptr;
183EventPipeEvent *EventPipeEventModuleUnload_V2 = nullptr;
184EventPipeEvent *EventPipeEventAssemblyLoad = nullptr;
185EventPipeEvent *EventPipeEventAssemblyLoad_V1 = nullptr;
186EventPipeEvent *EventPipeEventAssemblyUnload = nullptr;
187EventPipeEvent *EventPipeEventAssemblyUnload_V1 = nullptr;
188EventPipeEvent *EventPipeEventAppDomainLoad = nullptr;
189EventPipeEvent *EventPipeEventAppDomainLoad_V1 = nullptr;
190EventPipeEvent *EventPipeEventAppDomainUnload = nullptr;
191EventPipeEvent *EventPipeEventAppDomainUnload_V1 = nullptr;
192EventPipeEvent *EventPipeEventModuleRangeLoad = nullptr;
193EventPipeEvent *EventPipeEventStrongNameVerificationStart = nullptr;
194EventPipeEvent *EventPipeEventStrongNameVerificationStart_V1 = nullptr;
195EventPipeEvent *EventPipeEventStrongNameVerificationStop = nullptr;
196EventPipeEvent *EventPipeEventStrongNameVerificationStop_V1 = nullptr;
197EventPipeEvent *EventPipeEventAuthenticodeVerificationStart = nullptr;
198EventPipeEvent *EventPipeEventAuthenticodeVerificationStart_V1 = nullptr;
199EventPipeEvent *EventPipeEventAuthenticodeVerificationStop = nullptr;
200EventPipeEvent *EventPipeEventAuthenticodeVerificationStop_V1 = nullptr;
201EventPipeEvent *EventPipeEventRuntimeInformationStart = nullptr;
202EventPipeEvent *EventPipeEventIncreaseMemoryPressure = nullptr;
203EventPipeEvent *EventPipeEventDecreaseMemoryPressure = nullptr;
204EventPipeEvent *EventPipeEventGCMarkWithType = nullptr;
205EventPipeEvent *EventPipeEventGCJoin_V2 = nullptr;
206EventPipeEvent *EventPipeEventGCPerHeapHistory_V3 = nullptr;
207EventPipeEvent *EventPipeEventGCGlobalHeapHistory_V2 = nullptr;
208EventPipeEvent *EventPipeEventDebugIPCEventStart = nullptr;
209EventPipeEvent *EventPipeEventDebugIPCEventEnd = nullptr;
210EventPipeEvent *EventPipeEventDebugExceptionProcessingStart = nullptr;
211EventPipeEvent *EventPipeEventDebugExceptionProcessingEnd = nullptr;
212EventPipeEvent *EventPipeEventCodeSymbols = nullptr;
213EventPipeEvent *EventPipeEventEventSource = nullptr;
214BOOL EventPipeEventEnabledGCStart()
215{
216 return EventPipeEventGCStart->IsEnabled();
217}
218
219extern "C" ULONG EventPipeWriteEventGCStart(
220 const unsigned int Count,
221 const unsigned int Reason)
222{
223 if (!EventPipeEventEnabledGCStart())
224 return ERROR_SUCCESS;
225
226 char stackBuffer[32];
227 char *buffer = stackBuffer;
228 size_t offset = 0;
229 size_t size = 32;
230 bool fixedBuffer = true;
231
232 bool success = true;
233 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
234 success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
235
236 if (!success)
237 {
238 if (!fixedBuffer)
239 delete[] buffer;
240 return ERROR_WRITE_FAULT;
241 }
242
243 EventPipe::WriteEvent(*EventPipeEventGCStart, (BYTE *)buffer, (unsigned int)offset);
244
245 if (!fixedBuffer)
246 delete[] buffer;
247
248 return ERROR_SUCCESS;
249}
250
251BOOL EventPipeEventEnabledGCStart_V1()
252{
253 return EventPipeEventGCStart_V1->IsEnabled();
254}
255
256extern "C" ULONG EventPipeWriteEventGCStart_V1(
257 const unsigned int Count,
258 const unsigned int Depth,
259 const unsigned int Reason,
260 const unsigned int Type,
261 const unsigned short ClrInstanceID)
262{
263 if (!EventPipeEventEnabledGCStart_V1())
264 return ERROR_SUCCESS;
265
266 char stackBuffer[32];
267 char *buffer = stackBuffer;
268 size_t offset = 0;
269 size_t size = 32;
270 bool fixedBuffer = true;
271
272 bool success = true;
273 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
274 success &= WriteToBuffer(Depth, buffer, offset, size, fixedBuffer);
275 success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
276 success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);
277 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
278
279 if (!success)
280 {
281 if (!fixedBuffer)
282 delete[] buffer;
283 return ERROR_WRITE_FAULT;
284 }
285
286 EventPipe::WriteEvent(*EventPipeEventGCStart_V1, (BYTE *)buffer, (unsigned int)offset);
287
288 if (!fixedBuffer)
289 delete[] buffer;
290
291 return ERROR_SUCCESS;
292}
293
294BOOL EventPipeEventEnabledGCStart_V2()
295{
296 return EventPipeEventGCStart_V2->IsEnabled();
297}
298
299extern "C" ULONG EventPipeWriteEventGCStart_V2(
300 const unsigned int Count,
301 const unsigned int Depth,
302 const unsigned int Reason,
303 const unsigned int Type,
304 const unsigned short ClrInstanceID,
305 const unsigned __int64 ClientSequenceNumber)
306{
307 if (!EventPipeEventEnabledGCStart_V2())
308 return ERROR_SUCCESS;
309
310 char stackBuffer[32];
311 char *buffer = stackBuffer;
312 size_t offset = 0;
313 size_t size = 32;
314 bool fixedBuffer = true;
315
316 bool success = true;
317 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
318 success &= WriteToBuffer(Depth, buffer, offset, size, fixedBuffer);
319 success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
320 success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);
321 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
322 success &= WriteToBuffer(ClientSequenceNumber, buffer, offset, size, fixedBuffer);
323
324 if (!success)
325 {
326 if (!fixedBuffer)
327 delete[] buffer;
328 return ERROR_WRITE_FAULT;
329 }
330
331 EventPipe::WriteEvent(*EventPipeEventGCStart_V2, (BYTE *)buffer, (unsigned int)offset);
332
333 if (!fixedBuffer)
334 delete[] buffer;
335
336 return ERROR_SUCCESS;
337}
338
339BOOL EventPipeEventEnabledGCEnd()
340{
341 return EventPipeEventGCEnd->IsEnabled();
342}
343
344extern "C" ULONG EventPipeWriteEventGCEnd(
345 const unsigned int Count,
346 const unsigned short Depth)
347{
348 if (!EventPipeEventEnabledGCEnd())
349 return ERROR_SUCCESS;
350
351 char stackBuffer[32];
352 char *buffer = stackBuffer;
353 size_t offset = 0;
354 size_t size = 32;
355 bool fixedBuffer = true;
356
357 bool success = true;
358 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
359 success &= WriteToBuffer(Depth, buffer, offset, size, fixedBuffer);
360
361 if (!success)
362 {
363 if (!fixedBuffer)
364 delete[] buffer;
365 return ERROR_WRITE_FAULT;
366 }
367
368 EventPipe::WriteEvent(*EventPipeEventGCEnd, (BYTE *)buffer, (unsigned int)offset);
369
370 if (!fixedBuffer)
371 delete[] buffer;
372
373 return ERROR_SUCCESS;
374}
375
376BOOL EventPipeEventEnabledGCEnd_V1()
377{
378 return EventPipeEventGCEnd_V1->IsEnabled();
379}
380
381extern "C" ULONG EventPipeWriteEventGCEnd_V1(
382 const unsigned int Count,
383 const unsigned int Depth,
384 const unsigned short ClrInstanceID)
385{
386 if (!EventPipeEventEnabledGCEnd_V1())
387 return ERROR_SUCCESS;
388
389 char stackBuffer[32];
390 char *buffer = stackBuffer;
391 size_t offset = 0;
392 size_t size = 32;
393 bool fixedBuffer = true;
394
395 bool success = true;
396 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
397 success &= WriteToBuffer(Depth, buffer, offset, size, fixedBuffer);
398 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
399
400 if (!success)
401 {
402 if (!fixedBuffer)
403 delete[] buffer;
404 return ERROR_WRITE_FAULT;
405 }
406
407 EventPipe::WriteEvent(*EventPipeEventGCEnd_V1, (BYTE *)buffer, (unsigned int)offset);
408
409 if (!fixedBuffer)
410 delete[] buffer;
411
412 return ERROR_SUCCESS;
413}
414
415BOOL EventPipeEventEnabledGCRestartEEEnd()
416{
417 return EventPipeEventGCRestartEEEnd->IsEnabled();
418}
419
420extern "C" ULONG EventPipeWriteEventGCRestartEEEnd()
421{
422 if (!EventPipeEventEnabledGCRestartEEEnd())
423 return ERROR_SUCCESS;
424 EventPipe::WriteEvent(*EventPipeEventGCRestartEEEnd, (BYTE*) nullptr, 0);
425
426 return ERROR_SUCCESS;
427}
428
429BOOL EventPipeEventEnabledGCRestartEEEnd_V1()
430{
431 return EventPipeEventGCRestartEEEnd_V1->IsEnabled();
432}
433
434extern "C" ULONG EventPipeWriteEventGCRestartEEEnd_V1(
435 const unsigned short ClrInstanceID)
436{
437 if (!EventPipeEventEnabledGCRestartEEEnd_V1())
438 return ERROR_SUCCESS;
439
440 char stackBuffer[32];
441 char *buffer = stackBuffer;
442 size_t offset = 0;
443 size_t size = 32;
444 bool fixedBuffer = true;
445
446 bool success = true;
447 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
448
449 if (!success)
450 {
451 if (!fixedBuffer)
452 delete[] buffer;
453 return ERROR_WRITE_FAULT;
454 }
455
456 EventPipe::WriteEvent(*EventPipeEventGCRestartEEEnd_V1, (BYTE *)buffer, (unsigned int)offset);
457
458 if (!fixedBuffer)
459 delete[] buffer;
460
461 return ERROR_SUCCESS;
462}
463
464BOOL EventPipeEventEnabledGCHeapStats()
465{
466 return EventPipeEventGCHeapStats->IsEnabled();
467}
468
469extern "C" ULONG EventPipeWriteEventGCHeapStats(
470 const unsigned __int64 GenerationSize0,
471 const unsigned __int64 TotalPromotedSize0,
472 const unsigned __int64 GenerationSize1,
473 const unsigned __int64 TotalPromotedSize1,
474 const unsigned __int64 GenerationSize2,
475 const unsigned __int64 TotalPromotedSize2,
476 const unsigned __int64 GenerationSize3,
477 const unsigned __int64 TotalPromotedSize3,
478 const unsigned __int64 FinalizationPromotedSize,
479 const unsigned __int64 FinalizationPromotedCount,
480 const unsigned int PinnedObjectCount,
481 const unsigned int SinkBlockCount,
482 const unsigned int GCHandleCount)
483{
484 if (!EventPipeEventEnabledGCHeapStats())
485 return ERROR_SUCCESS;
486
487 char stackBuffer[92];
488 char *buffer = stackBuffer;
489 size_t offset = 0;
490 size_t size = 92;
491 bool fixedBuffer = true;
492
493 bool success = true;
494 success &= WriteToBuffer(GenerationSize0, buffer, offset, size, fixedBuffer);
495 success &= WriteToBuffer(TotalPromotedSize0, buffer, offset, size, fixedBuffer);
496 success &= WriteToBuffer(GenerationSize1, buffer, offset, size, fixedBuffer);
497 success &= WriteToBuffer(TotalPromotedSize1, buffer, offset, size, fixedBuffer);
498 success &= WriteToBuffer(GenerationSize2, buffer, offset, size, fixedBuffer);
499 success &= WriteToBuffer(TotalPromotedSize2, buffer, offset, size, fixedBuffer);
500 success &= WriteToBuffer(GenerationSize3, buffer, offset, size, fixedBuffer);
501 success &= WriteToBuffer(TotalPromotedSize3, buffer, offset, size, fixedBuffer);
502 success &= WriteToBuffer(FinalizationPromotedSize, buffer, offset, size, fixedBuffer);
503 success &= WriteToBuffer(FinalizationPromotedCount, buffer, offset, size, fixedBuffer);
504 success &= WriteToBuffer(PinnedObjectCount, buffer, offset, size, fixedBuffer);
505 success &= WriteToBuffer(SinkBlockCount, buffer, offset, size, fixedBuffer);
506 success &= WriteToBuffer(GCHandleCount, buffer, offset, size, fixedBuffer);
507
508 if (!success)
509 {
510 if (!fixedBuffer)
511 delete[] buffer;
512 return ERROR_WRITE_FAULT;
513 }
514
515 EventPipe::WriteEvent(*EventPipeEventGCHeapStats, (BYTE *)buffer, (unsigned int)offset);
516
517 if (!fixedBuffer)
518 delete[] buffer;
519
520 return ERROR_SUCCESS;
521}
522
523BOOL EventPipeEventEnabledGCHeapStats_V1()
524{
525 return EventPipeEventGCHeapStats_V1->IsEnabled();
526}
527
528extern "C" ULONG EventPipeWriteEventGCHeapStats_V1(
529 const unsigned __int64 GenerationSize0,
530 const unsigned __int64 TotalPromotedSize0,
531 const unsigned __int64 GenerationSize1,
532 const unsigned __int64 TotalPromotedSize1,
533 const unsigned __int64 GenerationSize2,
534 const unsigned __int64 TotalPromotedSize2,
535 const unsigned __int64 GenerationSize3,
536 const unsigned __int64 TotalPromotedSize3,
537 const unsigned __int64 FinalizationPromotedSize,
538 const unsigned __int64 FinalizationPromotedCount,
539 const unsigned int PinnedObjectCount,
540 const unsigned int SinkBlockCount,
541 const unsigned int GCHandleCount,
542 const unsigned short ClrInstanceID)
543{
544 if (!EventPipeEventEnabledGCHeapStats_V1())
545 return ERROR_SUCCESS;
546
547 char stackBuffer[94];
548 char *buffer = stackBuffer;
549 size_t offset = 0;
550 size_t size = 94;
551 bool fixedBuffer = true;
552
553 bool success = true;
554 success &= WriteToBuffer(GenerationSize0, buffer, offset, size, fixedBuffer);
555 success &= WriteToBuffer(TotalPromotedSize0, buffer, offset, size, fixedBuffer);
556 success &= WriteToBuffer(GenerationSize1, buffer, offset, size, fixedBuffer);
557 success &= WriteToBuffer(TotalPromotedSize1, buffer, offset, size, fixedBuffer);
558 success &= WriteToBuffer(GenerationSize2, buffer, offset, size, fixedBuffer);
559 success &= WriteToBuffer(TotalPromotedSize2, buffer, offset, size, fixedBuffer);
560 success &= WriteToBuffer(GenerationSize3, buffer, offset, size, fixedBuffer);
561 success &= WriteToBuffer(TotalPromotedSize3, buffer, offset, size, fixedBuffer);
562 success &= WriteToBuffer(FinalizationPromotedSize, buffer, offset, size, fixedBuffer);
563 success &= WriteToBuffer(FinalizationPromotedCount, buffer, offset, size, fixedBuffer);
564 success &= WriteToBuffer(PinnedObjectCount, buffer, offset, size, fixedBuffer);
565 success &= WriteToBuffer(SinkBlockCount, buffer, offset, size, fixedBuffer);
566 success &= WriteToBuffer(GCHandleCount, buffer, offset, size, fixedBuffer);
567 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
568
569 if (!success)
570 {
571 if (!fixedBuffer)
572 delete[] buffer;
573 return ERROR_WRITE_FAULT;
574 }
575
576 EventPipe::WriteEvent(*EventPipeEventGCHeapStats_V1, (BYTE *)buffer, (unsigned int)offset);
577
578 if (!fixedBuffer)
579 delete[] buffer;
580
581 return ERROR_SUCCESS;
582}
583
584BOOL EventPipeEventEnabledGCCreateSegment()
585{
586 return EventPipeEventGCCreateSegment->IsEnabled();
587}
588
589extern "C" ULONG EventPipeWriteEventGCCreateSegment(
590 const unsigned __int64 Address,
591 const unsigned __int64 Size,
592 const unsigned int Type)
593{
594 if (!EventPipeEventEnabledGCCreateSegment())
595 return ERROR_SUCCESS;
596
597 char stackBuffer[32];
598 char *buffer = stackBuffer;
599 size_t offset = 0;
600 size_t size = 32;
601 bool fixedBuffer = true;
602
603 bool success = true;
604 success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
605 success &= WriteToBuffer(Size, buffer, offset, size, fixedBuffer);
606 success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);
607
608 if (!success)
609 {
610 if (!fixedBuffer)
611 delete[] buffer;
612 return ERROR_WRITE_FAULT;
613 }
614
615 EventPipe::WriteEvent(*EventPipeEventGCCreateSegment, (BYTE *)buffer, (unsigned int)offset);
616
617 if (!fixedBuffer)
618 delete[] buffer;
619
620 return ERROR_SUCCESS;
621}
622
623BOOL EventPipeEventEnabledGCCreateSegment_V1()
624{
625 return EventPipeEventGCCreateSegment_V1->IsEnabled();
626}
627
628extern "C" ULONG EventPipeWriteEventGCCreateSegment_V1(
629 const unsigned __int64 Address,
630 const unsigned __int64 Size,
631 const unsigned int Type,
632 const unsigned short ClrInstanceID)
633{
634 if (!EventPipeEventEnabledGCCreateSegment_V1())
635 return ERROR_SUCCESS;
636
637 char stackBuffer[32];
638 char *buffer = stackBuffer;
639 size_t offset = 0;
640 size_t size = 32;
641 bool fixedBuffer = true;
642
643 bool success = true;
644 success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
645 success &= WriteToBuffer(Size, buffer, offset, size, fixedBuffer);
646 success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);
647 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
648
649 if (!success)
650 {
651 if (!fixedBuffer)
652 delete[] buffer;
653 return ERROR_WRITE_FAULT;
654 }
655
656 EventPipe::WriteEvent(*EventPipeEventGCCreateSegment_V1, (BYTE *)buffer, (unsigned int)offset);
657
658 if (!fixedBuffer)
659 delete[] buffer;
660
661 return ERROR_SUCCESS;
662}
663
664BOOL EventPipeEventEnabledGCFreeSegment()
665{
666 return EventPipeEventGCFreeSegment->IsEnabled();
667}
668
669extern "C" ULONG EventPipeWriteEventGCFreeSegment(
670 const unsigned __int64 Address)
671{
672 if (!EventPipeEventEnabledGCFreeSegment())
673 return ERROR_SUCCESS;
674
675 char stackBuffer[32];
676 char *buffer = stackBuffer;
677 size_t offset = 0;
678 size_t size = 32;
679 bool fixedBuffer = true;
680
681 bool success = true;
682 success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
683
684 if (!success)
685 {
686 if (!fixedBuffer)
687 delete[] buffer;
688 return ERROR_WRITE_FAULT;
689 }
690
691 EventPipe::WriteEvent(*EventPipeEventGCFreeSegment, (BYTE *)buffer, (unsigned int)offset);
692
693 if (!fixedBuffer)
694 delete[] buffer;
695
696 return ERROR_SUCCESS;
697}
698
699BOOL EventPipeEventEnabledGCFreeSegment_V1()
700{
701 return EventPipeEventGCFreeSegment_V1->IsEnabled();
702}
703
704extern "C" ULONG EventPipeWriteEventGCFreeSegment_V1(
705 const unsigned __int64 Address,
706 const unsigned short ClrInstanceID)
707{
708 if (!EventPipeEventEnabledGCFreeSegment_V1())
709 return ERROR_SUCCESS;
710
711 char stackBuffer[32];
712 char *buffer = stackBuffer;
713 size_t offset = 0;
714 size_t size = 32;
715 bool fixedBuffer = true;
716
717 bool success = true;
718 success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
719 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
720
721 if (!success)
722 {
723 if (!fixedBuffer)
724 delete[] buffer;
725 return ERROR_WRITE_FAULT;
726 }
727
728 EventPipe::WriteEvent(*EventPipeEventGCFreeSegment_V1, (BYTE *)buffer, (unsigned int)offset);
729
730 if (!fixedBuffer)
731 delete[] buffer;
732
733 return ERROR_SUCCESS;
734}
735
736BOOL EventPipeEventEnabledGCRestartEEBegin()
737{
738 return EventPipeEventGCRestartEEBegin->IsEnabled();
739}
740
741extern "C" ULONG EventPipeWriteEventGCRestartEEBegin()
742{
743 if (!EventPipeEventEnabledGCRestartEEBegin())
744 return ERROR_SUCCESS;
745 EventPipe::WriteEvent(*EventPipeEventGCRestartEEBegin, (BYTE*) nullptr, 0);
746
747 return ERROR_SUCCESS;
748}
749
750BOOL EventPipeEventEnabledGCRestartEEBegin_V1()
751{
752 return EventPipeEventGCRestartEEBegin_V1->IsEnabled();
753}
754
755extern "C" ULONG EventPipeWriteEventGCRestartEEBegin_V1(
756 const unsigned short ClrInstanceID)
757{
758 if (!EventPipeEventEnabledGCRestartEEBegin_V1())
759 return ERROR_SUCCESS;
760
761 char stackBuffer[32];
762 char *buffer = stackBuffer;
763 size_t offset = 0;
764 size_t size = 32;
765 bool fixedBuffer = true;
766
767 bool success = true;
768 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
769
770 if (!success)
771 {
772 if (!fixedBuffer)
773 delete[] buffer;
774 return ERROR_WRITE_FAULT;
775 }
776
777 EventPipe::WriteEvent(*EventPipeEventGCRestartEEBegin_V1, (BYTE *)buffer, (unsigned int)offset);
778
779 if (!fixedBuffer)
780 delete[] buffer;
781
782 return ERROR_SUCCESS;
783}
784
785BOOL EventPipeEventEnabledGCSuspendEEEnd()
786{
787 return EventPipeEventGCSuspendEEEnd->IsEnabled();
788}
789
790extern "C" ULONG EventPipeWriteEventGCSuspendEEEnd()
791{
792 if (!EventPipeEventEnabledGCSuspendEEEnd())
793 return ERROR_SUCCESS;
794 EventPipe::WriteEvent(*EventPipeEventGCSuspendEEEnd, (BYTE*) nullptr, 0);
795
796 return ERROR_SUCCESS;
797}
798
799BOOL EventPipeEventEnabledGCSuspendEEEnd_V1()
800{
801 return EventPipeEventGCSuspendEEEnd_V1->IsEnabled();
802}
803
804extern "C" ULONG EventPipeWriteEventGCSuspendEEEnd_V1(
805 const unsigned short ClrInstanceID)
806{
807 if (!EventPipeEventEnabledGCSuspendEEEnd_V1())
808 return ERROR_SUCCESS;
809
810 char stackBuffer[32];
811 char *buffer = stackBuffer;
812 size_t offset = 0;
813 size_t size = 32;
814 bool fixedBuffer = true;
815
816 bool success = true;
817 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
818
819 if (!success)
820 {
821 if (!fixedBuffer)
822 delete[] buffer;
823 return ERROR_WRITE_FAULT;
824 }
825
826 EventPipe::WriteEvent(*EventPipeEventGCSuspendEEEnd_V1, (BYTE *)buffer, (unsigned int)offset);
827
828 if (!fixedBuffer)
829 delete[] buffer;
830
831 return ERROR_SUCCESS;
832}
833
834BOOL EventPipeEventEnabledGCSuspendEEBegin()
835{
836 return EventPipeEventGCSuspendEEBegin->IsEnabled();
837}
838
839extern "C" ULONG EventPipeWriteEventGCSuspendEEBegin(
840 const unsigned short Reason)
841{
842 if (!EventPipeEventEnabledGCSuspendEEBegin())
843 return ERROR_SUCCESS;
844
845 char stackBuffer[32];
846 char *buffer = stackBuffer;
847 size_t offset = 0;
848 size_t size = 32;
849 bool fixedBuffer = true;
850
851 bool success = true;
852 success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
853
854 if (!success)
855 {
856 if (!fixedBuffer)
857 delete[] buffer;
858 return ERROR_WRITE_FAULT;
859 }
860
861 EventPipe::WriteEvent(*EventPipeEventGCSuspendEEBegin, (BYTE *)buffer, (unsigned int)offset);
862
863 if (!fixedBuffer)
864 delete[] buffer;
865
866 return ERROR_SUCCESS;
867}
868
869BOOL EventPipeEventEnabledGCSuspendEEBegin_V1()
870{
871 return EventPipeEventGCSuspendEEBegin_V1->IsEnabled();
872}
873
874extern "C" ULONG EventPipeWriteEventGCSuspendEEBegin_V1(
875 const unsigned int Reason,
876 const unsigned int Count,
877 const unsigned short ClrInstanceID)
878{
879 if (!EventPipeEventEnabledGCSuspendEEBegin_V1())
880 return ERROR_SUCCESS;
881
882 char stackBuffer[32];
883 char *buffer = stackBuffer;
884 size_t offset = 0;
885 size_t size = 32;
886 bool fixedBuffer = true;
887
888 bool success = true;
889 success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
890 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
891 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
892
893 if (!success)
894 {
895 if (!fixedBuffer)
896 delete[] buffer;
897 return ERROR_WRITE_FAULT;
898 }
899
900 EventPipe::WriteEvent(*EventPipeEventGCSuspendEEBegin_V1, (BYTE *)buffer, (unsigned int)offset);
901
902 if (!fixedBuffer)
903 delete[] buffer;
904
905 return ERROR_SUCCESS;
906}
907
908BOOL EventPipeEventEnabledGCAllocationTick()
909{
910 return EventPipeEventGCAllocationTick->IsEnabled();
911}
912
913extern "C" ULONG EventPipeWriteEventGCAllocationTick(
914 const unsigned int AllocationAmount,
915 const unsigned int AllocationKind)
916{
917 if (!EventPipeEventEnabledGCAllocationTick())
918 return ERROR_SUCCESS;
919
920 char stackBuffer[32];
921 char *buffer = stackBuffer;
922 size_t offset = 0;
923 size_t size = 32;
924 bool fixedBuffer = true;
925
926 bool success = true;
927 success &= WriteToBuffer(AllocationAmount, buffer, offset, size, fixedBuffer);
928 success &= WriteToBuffer(AllocationKind, buffer, offset, size, fixedBuffer);
929
930 if (!success)
931 {
932 if (!fixedBuffer)
933 delete[] buffer;
934 return ERROR_WRITE_FAULT;
935 }
936
937 EventPipe::WriteEvent(*EventPipeEventGCAllocationTick, (BYTE *)buffer, (unsigned int)offset);
938
939 if (!fixedBuffer)
940 delete[] buffer;
941
942 return ERROR_SUCCESS;
943}
944
945BOOL EventPipeEventEnabledGCAllocationTick_V1()
946{
947 return EventPipeEventGCAllocationTick_V1->IsEnabled();
948}
949
950extern "C" ULONG EventPipeWriteEventGCAllocationTick_V1(
951 const unsigned int AllocationAmount,
952 const unsigned int AllocationKind,
953 const unsigned short ClrInstanceID)
954{
955 if (!EventPipeEventEnabledGCAllocationTick_V1())
956 return ERROR_SUCCESS;
957
958 char stackBuffer[32];
959 char *buffer = stackBuffer;
960 size_t offset = 0;
961 size_t size = 32;
962 bool fixedBuffer = true;
963
964 bool success = true;
965 success &= WriteToBuffer(AllocationAmount, buffer, offset, size, fixedBuffer);
966 success &= WriteToBuffer(AllocationKind, buffer, offset, size, fixedBuffer);
967 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
968
969 if (!success)
970 {
971 if (!fixedBuffer)
972 delete[] buffer;
973 return ERROR_WRITE_FAULT;
974 }
975
976 EventPipe::WriteEvent(*EventPipeEventGCAllocationTick_V1, (BYTE *)buffer, (unsigned int)offset);
977
978 if (!fixedBuffer)
979 delete[] buffer;
980
981 return ERROR_SUCCESS;
982}
983
984BOOL EventPipeEventEnabledGCAllocationTick_V2()
985{
986 return EventPipeEventGCAllocationTick_V2->IsEnabled();
987}
988
989extern "C" ULONG EventPipeWriteEventGCAllocationTick_V2(
990 const unsigned int AllocationAmount,
991 const unsigned int AllocationKind,
992 const unsigned short ClrInstanceID,
993 const unsigned __int64 AllocationAmount64,
994 const void* TypeID,
995 PCWSTR TypeName,
996 const unsigned int HeapIndex)
997{
998 if (!EventPipeEventEnabledGCAllocationTick_V2())
999 return ERROR_SUCCESS;
1000
1001 char stackBuffer[94];
1002 char *buffer = stackBuffer;
1003 size_t offset = 0;
1004 size_t size = 94;
1005 bool fixedBuffer = true;
1006
1007 bool success = true;
1008 success &= WriteToBuffer(AllocationAmount, buffer, offset, size, fixedBuffer);
1009 success &= WriteToBuffer(AllocationKind, buffer, offset, size, fixedBuffer);
1010 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1011 success &= WriteToBuffer(AllocationAmount64, buffer, offset, size, fixedBuffer);
1012 success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
1013 success &= WriteToBuffer(TypeName, buffer, offset, size, fixedBuffer);
1014 success &= WriteToBuffer(HeapIndex, buffer, offset, size, fixedBuffer);
1015
1016 if (!success)
1017 {
1018 if (!fixedBuffer)
1019 delete[] buffer;
1020 return ERROR_WRITE_FAULT;
1021 }
1022
1023 EventPipe::WriteEvent(*EventPipeEventGCAllocationTick_V2, (BYTE *)buffer, (unsigned int)offset);
1024
1025 if (!fixedBuffer)
1026 delete[] buffer;
1027
1028 return ERROR_SUCCESS;
1029}
1030
1031BOOL EventPipeEventEnabledGCAllocationTick_V3()
1032{
1033 return EventPipeEventGCAllocationTick_V3->IsEnabled();
1034}
1035
1036extern "C" ULONG EventPipeWriteEventGCAllocationTick_V3(
1037 const unsigned int AllocationAmount,
1038 const unsigned int AllocationKind,
1039 const unsigned short ClrInstanceID,
1040 const unsigned __int64 AllocationAmount64,
1041 const void* TypeID,
1042 PCWSTR TypeName,
1043 const unsigned int HeapIndex,
1044 const void* Address)
1045{
1046 if (!EventPipeEventEnabledGCAllocationTick_V3())
1047 return ERROR_SUCCESS;
1048
1049 char stackBuffer[102];
1050 char *buffer = stackBuffer;
1051 size_t offset = 0;
1052 size_t size = 102;
1053 bool fixedBuffer = true;
1054
1055 bool success = true;
1056 success &= WriteToBuffer(AllocationAmount, buffer, offset, size, fixedBuffer);
1057 success &= WriteToBuffer(AllocationKind, buffer, offset, size, fixedBuffer);
1058 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1059 success &= WriteToBuffer(AllocationAmount64, buffer, offset, size, fixedBuffer);
1060 success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
1061 success &= WriteToBuffer(TypeName, buffer, offset, size, fixedBuffer);
1062 success &= WriteToBuffer(HeapIndex, buffer, offset, size, fixedBuffer);
1063 success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
1064
1065 if (!success)
1066 {
1067 if (!fixedBuffer)
1068 delete[] buffer;
1069 return ERROR_WRITE_FAULT;
1070 }
1071
1072 EventPipe::WriteEvent(*EventPipeEventGCAllocationTick_V3, (BYTE *)buffer, (unsigned int)offset);
1073
1074 if (!fixedBuffer)
1075 delete[] buffer;
1076
1077 return ERROR_SUCCESS;
1078}
1079
1080BOOL EventPipeEventEnabledGCCreateConcurrentThread()
1081{
1082 return EventPipeEventGCCreateConcurrentThread->IsEnabled();
1083}
1084
1085extern "C" ULONG EventPipeWriteEventGCCreateConcurrentThread()
1086{
1087 if (!EventPipeEventEnabledGCCreateConcurrentThread())
1088 return ERROR_SUCCESS;
1089 EventPipe::WriteEvent(*EventPipeEventGCCreateConcurrentThread, (BYTE*) nullptr, 0);
1090
1091 return ERROR_SUCCESS;
1092}
1093
1094BOOL EventPipeEventEnabledGCCreateConcurrentThread_V1()
1095{
1096 return EventPipeEventGCCreateConcurrentThread_V1->IsEnabled();
1097}
1098
1099extern "C" ULONG EventPipeWriteEventGCCreateConcurrentThread_V1(
1100 const unsigned short ClrInstanceID)
1101{
1102 if (!EventPipeEventEnabledGCCreateConcurrentThread_V1())
1103 return ERROR_SUCCESS;
1104
1105 char stackBuffer[32];
1106 char *buffer = stackBuffer;
1107 size_t offset = 0;
1108 size_t size = 32;
1109 bool fixedBuffer = true;
1110
1111 bool success = true;
1112 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1113
1114 if (!success)
1115 {
1116 if (!fixedBuffer)
1117 delete[] buffer;
1118 return ERROR_WRITE_FAULT;
1119 }
1120
1121 EventPipe::WriteEvent(*EventPipeEventGCCreateConcurrentThread_V1, (BYTE *)buffer, (unsigned int)offset);
1122
1123 if (!fixedBuffer)
1124 delete[] buffer;
1125
1126 return ERROR_SUCCESS;
1127}
1128
1129BOOL EventPipeEventEnabledGCTerminateConcurrentThread()
1130{
1131 return EventPipeEventGCTerminateConcurrentThread->IsEnabled();
1132}
1133
1134extern "C" ULONG EventPipeWriteEventGCTerminateConcurrentThread()
1135{
1136 if (!EventPipeEventEnabledGCTerminateConcurrentThread())
1137 return ERROR_SUCCESS;
1138 EventPipe::WriteEvent(*EventPipeEventGCTerminateConcurrentThread, (BYTE*) nullptr, 0);
1139
1140 return ERROR_SUCCESS;
1141}
1142
1143BOOL EventPipeEventEnabledGCTerminateConcurrentThread_V1()
1144{
1145 return EventPipeEventGCTerminateConcurrentThread_V1->IsEnabled();
1146}
1147
1148extern "C" ULONG EventPipeWriteEventGCTerminateConcurrentThread_V1(
1149 const unsigned short ClrInstanceID)
1150{
1151 if (!EventPipeEventEnabledGCTerminateConcurrentThread_V1())
1152 return ERROR_SUCCESS;
1153
1154 char stackBuffer[32];
1155 char *buffer = stackBuffer;
1156 size_t offset = 0;
1157 size_t size = 32;
1158 bool fixedBuffer = true;
1159
1160 bool success = true;
1161 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1162
1163 if (!success)
1164 {
1165 if (!fixedBuffer)
1166 delete[] buffer;
1167 return ERROR_WRITE_FAULT;
1168 }
1169
1170 EventPipe::WriteEvent(*EventPipeEventGCTerminateConcurrentThread_V1, (BYTE *)buffer, (unsigned int)offset);
1171
1172 if (!fixedBuffer)
1173 delete[] buffer;
1174
1175 return ERROR_SUCCESS;
1176}
1177
1178BOOL EventPipeEventEnabledGCFinalizersEnd()
1179{
1180 return EventPipeEventGCFinalizersEnd->IsEnabled();
1181}
1182
1183extern "C" ULONG EventPipeWriteEventGCFinalizersEnd(
1184 const unsigned int Count)
1185{
1186 if (!EventPipeEventEnabledGCFinalizersEnd())
1187 return ERROR_SUCCESS;
1188
1189 char stackBuffer[32];
1190 char *buffer = stackBuffer;
1191 size_t offset = 0;
1192 size_t size = 32;
1193 bool fixedBuffer = true;
1194
1195 bool success = true;
1196 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
1197
1198 if (!success)
1199 {
1200 if (!fixedBuffer)
1201 delete[] buffer;
1202 return ERROR_WRITE_FAULT;
1203 }
1204
1205 EventPipe::WriteEvent(*EventPipeEventGCFinalizersEnd, (BYTE *)buffer, (unsigned int)offset);
1206
1207 if (!fixedBuffer)
1208 delete[] buffer;
1209
1210 return ERROR_SUCCESS;
1211}
1212
1213BOOL EventPipeEventEnabledGCFinalizersEnd_V1()
1214{
1215 return EventPipeEventGCFinalizersEnd_V1->IsEnabled();
1216}
1217
1218extern "C" ULONG EventPipeWriteEventGCFinalizersEnd_V1(
1219 const unsigned int Count,
1220 const unsigned short ClrInstanceID)
1221{
1222 if (!EventPipeEventEnabledGCFinalizersEnd_V1())
1223 return ERROR_SUCCESS;
1224
1225 char stackBuffer[32];
1226 char *buffer = stackBuffer;
1227 size_t offset = 0;
1228 size_t size = 32;
1229 bool fixedBuffer = true;
1230
1231 bool success = true;
1232 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
1233 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1234
1235 if (!success)
1236 {
1237 if (!fixedBuffer)
1238 delete[] buffer;
1239 return ERROR_WRITE_FAULT;
1240 }
1241
1242 EventPipe::WriteEvent(*EventPipeEventGCFinalizersEnd_V1, (BYTE *)buffer, (unsigned int)offset);
1243
1244 if (!fixedBuffer)
1245 delete[] buffer;
1246
1247 return ERROR_SUCCESS;
1248}
1249
1250BOOL EventPipeEventEnabledGCFinalizersBegin()
1251{
1252 return EventPipeEventGCFinalizersBegin->IsEnabled();
1253}
1254
1255extern "C" ULONG EventPipeWriteEventGCFinalizersBegin()
1256{
1257 if (!EventPipeEventEnabledGCFinalizersBegin())
1258 return ERROR_SUCCESS;
1259 EventPipe::WriteEvent(*EventPipeEventGCFinalizersBegin, (BYTE*) nullptr, 0);
1260
1261 return ERROR_SUCCESS;
1262}
1263
1264BOOL EventPipeEventEnabledGCFinalizersBegin_V1()
1265{
1266 return EventPipeEventGCFinalizersBegin_V1->IsEnabled();
1267}
1268
1269extern "C" ULONG EventPipeWriteEventGCFinalizersBegin_V1(
1270 const unsigned short ClrInstanceID)
1271{
1272 if (!EventPipeEventEnabledGCFinalizersBegin_V1())
1273 return ERROR_SUCCESS;
1274
1275 char stackBuffer[32];
1276 char *buffer = stackBuffer;
1277 size_t offset = 0;
1278 size_t size = 32;
1279 bool fixedBuffer = true;
1280
1281 bool success = true;
1282 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1283
1284 if (!success)
1285 {
1286 if (!fixedBuffer)
1287 delete[] buffer;
1288 return ERROR_WRITE_FAULT;
1289 }
1290
1291 EventPipe::WriteEvent(*EventPipeEventGCFinalizersBegin_V1, (BYTE *)buffer, (unsigned int)offset);
1292
1293 if (!fixedBuffer)
1294 delete[] buffer;
1295
1296 return ERROR_SUCCESS;
1297}
1298
1299BOOL EventPipeEventEnabledBulkType()
1300{
1301 return EventPipeEventBulkType->IsEnabled();
1302}
1303
1304extern "C" ULONG EventPipeWriteEventBulkType(
1305 const unsigned int Count,
1306 const unsigned short ClrInstanceID,
1307 int Values_ElementSize,
1308 const void* Values)
1309{
1310 if (!EventPipeEventEnabledBulkType())
1311 return ERROR_SUCCESS;
1312
1313 char stackBuffer[38];
1314 char *buffer = stackBuffer;
1315 size_t offset = 0;
1316 size_t size = 38;
1317 bool fixedBuffer = true;
1318
1319 bool success = true;
1320 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
1321 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1322 success &= WriteToBuffer((const BYTE *)Values, (int)(Values_ElementSize), buffer, offset, size, fixedBuffer);
1323
1324 if (!success)
1325 {
1326 if (!fixedBuffer)
1327 delete[] buffer;
1328 return ERROR_WRITE_FAULT;
1329 }
1330
1331 EventPipe::WriteEvent(*EventPipeEventBulkType, (BYTE *)buffer, (unsigned int)offset);
1332
1333 if (!fixedBuffer)
1334 delete[] buffer;
1335
1336 return ERROR_SUCCESS;
1337}
1338
1339BOOL EventPipeEventEnabledGCBulkRootEdge()
1340{
1341 return EventPipeEventGCBulkRootEdge->IsEnabled();
1342}
1343
1344extern "C" ULONG EventPipeWriteEventGCBulkRootEdge(
1345 const unsigned int Index,
1346 const unsigned int Count,
1347 const unsigned short ClrInstanceID,
1348 int Values_ElementSize,
1349 const void* Values)
1350{
1351 if (!EventPipeEventEnabledGCBulkRootEdge())
1352 return ERROR_SUCCESS;
1353
1354 char stackBuffer[42];
1355 char *buffer = stackBuffer;
1356 size_t offset = 0;
1357 size_t size = 42;
1358 bool fixedBuffer = true;
1359
1360 bool success = true;
1361 success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
1362 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
1363 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1364 success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);
1365
1366 if (!success)
1367 {
1368 if (!fixedBuffer)
1369 delete[] buffer;
1370 return ERROR_WRITE_FAULT;
1371 }
1372
1373 EventPipe::WriteEvent(*EventPipeEventGCBulkRootEdge, (BYTE *)buffer, (unsigned int)offset);
1374
1375 if (!fixedBuffer)
1376 delete[] buffer;
1377
1378 return ERROR_SUCCESS;
1379}
1380
1381BOOL EventPipeEventEnabledGCBulkRootConditionalWeakTableElementEdge()
1382{
1383 return EventPipeEventGCBulkRootConditionalWeakTableElementEdge->IsEnabled();
1384}
1385
1386extern "C" ULONG EventPipeWriteEventGCBulkRootConditionalWeakTableElementEdge(
1387 const unsigned int Index,
1388 const unsigned int Count,
1389 const unsigned short ClrInstanceID,
1390 int Values_ElementSize,
1391 const void* Values)
1392{
1393 if (!EventPipeEventEnabledGCBulkRootConditionalWeakTableElementEdge())
1394 return ERROR_SUCCESS;
1395
1396 char stackBuffer[42];
1397 char *buffer = stackBuffer;
1398 size_t offset = 0;
1399 size_t size = 42;
1400 bool fixedBuffer = true;
1401
1402 bool success = true;
1403 success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
1404 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
1405 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1406 success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);
1407
1408 if (!success)
1409 {
1410 if (!fixedBuffer)
1411 delete[] buffer;
1412 return ERROR_WRITE_FAULT;
1413 }
1414
1415 EventPipe::WriteEvent(*EventPipeEventGCBulkRootConditionalWeakTableElementEdge, (BYTE *)buffer, (unsigned int)offset);
1416
1417 if (!fixedBuffer)
1418 delete[] buffer;
1419
1420 return ERROR_SUCCESS;
1421}
1422
1423BOOL EventPipeEventEnabledGCBulkNode()
1424{
1425 return EventPipeEventGCBulkNode->IsEnabled();
1426}
1427
1428extern "C" ULONG EventPipeWriteEventGCBulkNode(
1429 const unsigned int Index,
1430 const unsigned int Count,
1431 const unsigned short ClrInstanceID,
1432 int Values_ElementSize,
1433 const void* Values)
1434{
1435 if (!EventPipeEventEnabledGCBulkNode())
1436 return ERROR_SUCCESS;
1437
1438 char stackBuffer[42];
1439 char *buffer = stackBuffer;
1440 size_t offset = 0;
1441 size_t size = 42;
1442 bool fixedBuffer = true;
1443
1444 bool success = true;
1445 success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
1446 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
1447 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1448 success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);
1449
1450 if (!success)
1451 {
1452 if (!fixedBuffer)
1453 delete[] buffer;
1454 return ERROR_WRITE_FAULT;
1455 }
1456
1457 EventPipe::WriteEvent(*EventPipeEventGCBulkNode, (BYTE *)buffer, (unsigned int)offset);
1458
1459 if (!fixedBuffer)
1460 delete[] buffer;
1461
1462 return ERROR_SUCCESS;
1463}
1464
1465BOOL EventPipeEventEnabledGCBulkEdge()
1466{
1467 return EventPipeEventGCBulkEdge->IsEnabled();
1468}
1469
1470extern "C" ULONG EventPipeWriteEventGCBulkEdge(
1471 const unsigned int Index,
1472 const unsigned int Count,
1473 const unsigned short ClrInstanceID,
1474 int Values_ElementSize,
1475 const void* Values)
1476{
1477 if (!EventPipeEventEnabledGCBulkEdge())
1478 return ERROR_SUCCESS;
1479
1480 char stackBuffer[42];
1481 char *buffer = stackBuffer;
1482 size_t offset = 0;
1483 size_t size = 42;
1484 bool fixedBuffer = true;
1485
1486 bool success = true;
1487 success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
1488 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
1489 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1490 success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);
1491
1492 if (!success)
1493 {
1494 if (!fixedBuffer)
1495 delete[] buffer;
1496 return ERROR_WRITE_FAULT;
1497 }
1498
1499 EventPipe::WriteEvent(*EventPipeEventGCBulkEdge, (BYTE *)buffer, (unsigned int)offset);
1500
1501 if (!fixedBuffer)
1502 delete[] buffer;
1503
1504 return ERROR_SUCCESS;
1505}
1506
1507BOOL EventPipeEventEnabledGCSampledObjectAllocationHigh()
1508{
1509 return EventPipeEventGCSampledObjectAllocationHigh->IsEnabled();
1510}
1511
1512extern "C" ULONG EventPipeWriteEventGCSampledObjectAllocationHigh(
1513 const void* Address,
1514 const void* TypeID,
1515 const unsigned int ObjectCountForTypeSample,
1516 const unsigned __int64 TotalSizeForTypeSample,
1517 const unsigned short ClrInstanceID)
1518{
1519 if (!EventPipeEventEnabledGCSampledObjectAllocationHigh())
1520 return ERROR_SUCCESS;
1521
1522 char stackBuffer[32];
1523 char *buffer = stackBuffer;
1524 size_t offset = 0;
1525 size_t size = 32;
1526 bool fixedBuffer = true;
1527
1528 bool success = true;
1529 success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
1530 success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
1531 success &= WriteToBuffer(ObjectCountForTypeSample, buffer, offset, size, fixedBuffer);
1532 success &= WriteToBuffer(TotalSizeForTypeSample, buffer, offset, size, fixedBuffer);
1533 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1534
1535 if (!success)
1536 {
1537 if (!fixedBuffer)
1538 delete[] buffer;
1539 return ERROR_WRITE_FAULT;
1540 }
1541
1542 EventPipe::WriteEvent(*EventPipeEventGCSampledObjectAllocationHigh, (BYTE *)buffer, (unsigned int)offset);
1543
1544 if (!fixedBuffer)
1545 delete[] buffer;
1546
1547 return ERROR_SUCCESS;
1548}
1549
1550BOOL EventPipeEventEnabledGCBulkSurvivingObjectRanges()
1551{
1552 return EventPipeEventGCBulkSurvivingObjectRanges->IsEnabled();
1553}
1554
1555extern "C" ULONG EventPipeWriteEventGCBulkSurvivingObjectRanges(
1556 const unsigned int Index,
1557 const unsigned int Count,
1558 const unsigned short ClrInstanceID,
1559 int Values_ElementSize,
1560 const void* Values)
1561{
1562 if (!EventPipeEventEnabledGCBulkSurvivingObjectRanges())
1563 return ERROR_SUCCESS;
1564
1565 char stackBuffer[42];
1566 char *buffer = stackBuffer;
1567 size_t offset = 0;
1568 size_t size = 42;
1569 bool fixedBuffer = true;
1570
1571 bool success = true;
1572 success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
1573 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
1574 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1575 success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);
1576
1577 if (!success)
1578 {
1579 if (!fixedBuffer)
1580 delete[] buffer;
1581 return ERROR_WRITE_FAULT;
1582 }
1583
1584 EventPipe::WriteEvent(*EventPipeEventGCBulkSurvivingObjectRanges, (BYTE *)buffer, (unsigned int)offset);
1585
1586 if (!fixedBuffer)
1587 delete[] buffer;
1588
1589 return ERROR_SUCCESS;
1590}
1591
1592BOOL EventPipeEventEnabledGCBulkMovedObjectRanges()
1593{
1594 return EventPipeEventGCBulkMovedObjectRanges->IsEnabled();
1595}
1596
1597extern "C" ULONG EventPipeWriteEventGCBulkMovedObjectRanges(
1598 const unsigned int Index,
1599 const unsigned int Count,
1600 const unsigned short ClrInstanceID,
1601 int Values_ElementSize,
1602 const void* Values)
1603{
1604 if (!EventPipeEventEnabledGCBulkMovedObjectRanges())
1605 return ERROR_SUCCESS;
1606
1607 char stackBuffer[42];
1608 char *buffer = stackBuffer;
1609 size_t offset = 0;
1610 size_t size = 42;
1611 bool fixedBuffer = true;
1612
1613 bool success = true;
1614 success &= WriteToBuffer(Index, buffer, offset, size, fixedBuffer);
1615 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
1616 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1617 success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);
1618
1619 if (!success)
1620 {
1621 if (!fixedBuffer)
1622 delete[] buffer;
1623 return ERROR_WRITE_FAULT;
1624 }
1625
1626 EventPipe::WriteEvent(*EventPipeEventGCBulkMovedObjectRanges, (BYTE *)buffer, (unsigned int)offset);
1627
1628 if (!fixedBuffer)
1629 delete[] buffer;
1630
1631 return ERROR_SUCCESS;
1632}
1633
1634BOOL EventPipeEventEnabledGCGenerationRange()
1635{
1636 return EventPipeEventGCGenerationRange->IsEnabled();
1637}
1638
1639extern "C" ULONG EventPipeWriteEventGCGenerationRange(
1640 const unsigned char Generation,
1641 const void* RangeStart,
1642 const unsigned __int64 RangeUsedLength,
1643 const unsigned __int64 RangeReservedLength,
1644 const unsigned short ClrInstanceID)
1645{
1646 if (!EventPipeEventEnabledGCGenerationRange())
1647 return ERROR_SUCCESS;
1648
1649 char stackBuffer[32];
1650 char *buffer = stackBuffer;
1651 size_t offset = 0;
1652 size_t size = 32;
1653 bool fixedBuffer = true;
1654
1655 bool success = true;
1656 success &= WriteToBuffer(Generation, buffer, offset, size, fixedBuffer);
1657 success &= WriteToBuffer(RangeStart, buffer, offset, size, fixedBuffer);
1658 success &= WriteToBuffer(RangeUsedLength, buffer, offset, size, fixedBuffer);
1659 success &= WriteToBuffer(RangeReservedLength, buffer, offset, size, fixedBuffer);
1660 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1661
1662 if (!success)
1663 {
1664 if (!fixedBuffer)
1665 delete[] buffer;
1666 return ERROR_WRITE_FAULT;
1667 }
1668
1669 EventPipe::WriteEvent(*EventPipeEventGCGenerationRange, (BYTE *)buffer, (unsigned int)offset);
1670
1671 if (!fixedBuffer)
1672 delete[] buffer;
1673
1674 return ERROR_SUCCESS;
1675}
1676
1677BOOL EventPipeEventEnabledGCMarkStackRoots()
1678{
1679 return EventPipeEventGCMarkStackRoots->IsEnabled();
1680}
1681
1682extern "C" ULONG EventPipeWriteEventGCMarkStackRoots(
1683 const unsigned int HeapNum,
1684 const unsigned short ClrInstanceID)
1685{
1686 if (!EventPipeEventEnabledGCMarkStackRoots())
1687 return ERROR_SUCCESS;
1688
1689 char stackBuffer[32];
1690 char *buffer = stackBuffer;
1691 size_t offset = 0;
1692 size_t size = 32;
1693 bool fixedBuffer = true;
1694
1695 bool success = true;
1696 success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
1697 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1698
1699 if (!success)
1700 {
1701 if (!fixedBuffer)
1702 delete[] buffer;
1703 return ERROR_WRITE_FAULT;
1704 }
1705
1706 EventPipe::WriteEvent(*EventPipeEventGCMarkStackRoots, (BYTE *)buffer, (unsigned int)offset);
1707
1708 if (!fixedBuffer)
1709 delete[] buffer;
1710
1711 return ERROR_SUCCESS;
1712}
1713
1714BOOL EventPipeEventEnabledGCMarkFinalizeQueueRoots()
1715{
1716 return EventPipeEventGCMarkFinalizeQueueRoots->IsEnabled();
1717}
1718
1719extern "C" ULONG EventPipeWriteEventGCMarkFinalizeQueueRoots(
1720 const unsigned int HeapNum,
1721 const unsigned short ClrInstanceID)
1722{
1723 if (!EventPipeEventEnabledGCMarkFinalizeQueueRoots())
1724 return ERROR_SUCCESS;
1725
1726 char stackBuffer[32];
1727 char *buffer = stackBuffer;
1728 size_t offset = 0;
1729 size_t size = 32;
1730 bool fixedBuffer = true;
1731
1732 bool success = true;
1733 success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
1734 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1735
1736 if (!success)
1737 {
1738 if (!fixedBuffer)
1739 delete[] buffer;
1740 return ERROR_WRITE_FAULT;
1741 }
1742
1743 EventPipe::WriteEvent(*EventPipeEventGCMarkFinalizeQueueRoots, (BYTE *)buffer, (unsigned int)offset);
1744
1745 if (!fixedBuffer)
1746 delete[] buffer;
1747
1748 return ERROR_SUCCESS;
1749}
1750
1751BOOL EventPipeEventEnabledGCMarkHandles()
1752{
1753 return EventPipeEventGCMarkHandles->IsEnabled();
1754}
1755
1756extern "C" ULONG EventPipeWriteEventGCMarkHandles(
1757 const unsigned int HeapNum,
1758 const unsigned short ClrInstanceID)
1759{
1760 if (!EventPipeEventEnabledGCMarkHandles())
1761 return ERROR_SUCCESS;
1762
1763 char stackBuffer[32];
1764 char *buffer = stackBuffer;
1765 size_t offset = 0;
1766 size_t size = 32;
1767 bool fixedBuffer = true;
1768
1769 bool success = true;
1770 success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
1771 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1772
1773 if (!success)
1774 {
1775 if (!fixedBuffer)
1776 delete[] buffer;
1777 return ERROR_WRITE_FAULT;
1778 }
1779
1780 EventPipe::WriteEvent(*EventPipeEventGCMarkHandles, (BYTE *)buffer, (unsigned int)offset);
1781
1782 if (!fixedBuffer)
1783 delete[] buffer;
1784
1785 return ERROR_SUCCESS;
1786}
1787
1788BOOL EventPipeEventEnabledGCMarkOlderGenerationRoots()
1789{
1790 return EventPipeEventGCMarkOlderGenerationRoots->IsEnabled();
1791}
1792
1793extern "C" ULONG EventPipeWriteEventGCMarkOlderGenerationRoots(
1794 const unsigned int HeapNum,
1795 const unsigned short ClrInstanceID)
1796{
1797 if (!EventPipeEventEnabledGCMarkOlderGenerationRoots())
1798 return ERROR_SUCCESS;
1799
1800 char stackBuffer[32];
1801 char *buffer = stackBuffer;
1802 size_t offset = 0;
1803 size_t size = 32;
1804 bool fixedBuffer = true;
1805
1806 bool success = true;
1807 success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
1808 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1809
1810 if (!success)
1811 {
1812 if (!fixedBuffer)
1813 delete[] buffer;
1814 return ERROR_WRITE_FAULT;
1815 }
1816
1817 EventPipe::WriteEvent(*EventPipeEventGCMarkOlderGenerationRoots, (BYTE *)buffer, (unsigned int)offset);
1818
1819 if (!fixedBuffer)
1820 delete[] buffer;
1821
1822 return ERROR_SUCCESS;
1823}
1824
1825BOOL EventPipeEventEnabledFinalizeObject()
1826{
1827 return EventPipeEventFinalizeObject->IsEnabled();
1828}
1829
1830extern "C" ULONG EventPipeWriteEventFinalizeObject(
1831 const void* TypeID,
1832 const void* ObjectID,
1833 const unsigned short ClrInstanceID)
1834{
1835 if (!EventPipeEventEnabledFinalizeObject())
1836 return ERROR_SUCCESS;
1837
1838 char stackBuffer[32];
1839 char *buffer = stackBuffer;
1840 size_t offset = 0;
1841 size_t size = 32;
1842 bool fixedBuffer = true;
1843
1844 bool success = true;
1845 success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
1846 success &= WriteToBuffer(ObjectID, buffer, offset, size, fixedBuffer);
1847 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1848
1849 if (!success)
1850 {
1851 if (!fixedBuffer)
1852 delete[] buffer;
1853 return ERROR_WRITE_FAULT;
1854 }
1855
1856 EventPipe::WriteEvent(*EventPipeEventFinalizeObject, (BYTE *)buffer, (unsigned int)offset);
1857
1858 if (!fixedBuffer)
1859 delete[] buffer;
1860
1861 return ERROR_SUCCESS;
1862}
1863
1864BOOL EventPipeEventEnabledSetGCHandle()
1865{
1866 return EventPipeEventSetGCHandle->IsEnabled();
1867}
1868
1869extern "C" ULONG EventPipeWriteEventSetGCHandle(
1870 const void* HandleID,
1871 const void* ObjectID,
1872 const unsigned int Kind,
1873 const unsigned int Generation,
1874 const unsigned __int64 AppDomainID,
1875 const unsigned short ClrInstanceID)
1876{
1877 if (!EventPipeEventEnabledSetGCHandle())
1878 return ERROR_SUCCESS;
1879
1880 char stackBuffer[34];
1881 char *buffer = stackBuffer;
1882 size_t offset = 0;
1883 size_t size = 34;
1884 bool fixedBuffer = true;
1885
1886 bool success = true;
1887 success &= WriteToBuffer(HandleID, buffer, offset, size, fixedBuffer);
1888 success &= WriteToBuffer(ObjectID, buffer, offset, size, fixedBuffer);
1889 success &= WriteToBuffer(Kind, buffer, offset, size, fixedBuffer);
1890 success &= WriteToBuffer(Generation, buffer, offset, size, fixedBuffer);
1891 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
1892 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1893
1894 if (!success)
1895 {
1896 if (!fixedBuffer)
1897 delete[] buffer;
1898 return ERROR_WRITE_FAULT;
1899 }
1900
1901 EventPipe::WriteEvent(*EventPipeEventSetGCHandle, (BYTE *)buffer, (unsigned int)offset);
1902
1903 if (!fixedBuffer)
1904 delete[] buffer;
1905
1906 return ERROR_SUCCESS;
1907}
1908
1909BOOL EventPipeEventEnabledDestroyGCHandle()
1910{
1911 return EventPipeEventDestroyGCHandle->IsEnabled();
1912}
1913
1914extern "C" ULONG EventPipeWriteEventDestroyGCHandle(
1915 const void* HandleID,
1916 const unsigned short ClrInstanceID)
1917{
1918 if (!EventPipeEventEnabledDestroyGCHandle())
1919 return ERROR_SUCCESS;
1920
1921 char stackBuffer[32];
1922 char *buffer = stackBuffer;
1923 size_t offset = 0;
1924 size_t size = 32;
1925 bool fixedBuffer = true;
1926
1927 bool success = true;
1928 success &= WriteToBuffer(HandleID, buffer, offset, size, fixedBuffer);
1929 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1930
1931 if (!success)
1932 {
1933 if (!fixedBuffer)
1934 delete[] buffer;
1935 return ERROR_WRITE_FAULT;
1936 }
1937
1938 EventPipe::WriteEvent(*EventPipeEventDestroyGCHandle, (BYTE *)buffer, (unsigned int)offset);
1939
1940 if (!fixedBuffer)
1941 delete[] buffer;
1942
1943 return ERROR_SUCCESS;
1944}
1945
1946BOOL EventPipeEventEnabledGCSampledObjectAllocationLow()
1947{
1948 return EventPipeEventGCSampledObjectAllocationLow->IsEnabled();
1949}
1950
1951extern "C" ULONG EventPipeWriteEventGCSampledObjectAllocationLow(
1952 const void* Address,
1953 const void* TypeID,
1954 const unsigned int ObjectCountForTypeSample,
1955 const unsigned __int64 TotalSizeForTypeSample,
1956 const unsigned short ClrInstanceID)
1957{
1958 if (!EventPipeEventEnabledGCSampledObjectAllocationLow())
1959 return ERROR_SUCCESS;
1960
1961 char stackBuffer[32];
1962 char *buffer = stackBuffer;
1963 size_t offset = 0;
1964 size_t size = 32;
1965 bool fixedBuffer = true;
1966
1967 bool success = true;
1968 success &= WriteToBuffer(Address, buffer, offset, size, fixedBuffer);
1969 success &= WriteToBuffer(TypeID, buffer, offset, size, fixedBuffer);
1970 success &= WriteToBuffer(ObjectCountForTypeSample, buffer, offset, size, fixedBuffer);
1971 success &= WriteToBuffer(TotalSizeForTypeSample, buffer, offset, size, fixedBuffer);
1972 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
1973
1974 if (!success)
1975 {
1976 if (!fixedBuffer)
1977 delete[] buffer;
1978 return ERROR_WRITE_FAULT;
1979 }
1980
1981 EventPipe::WriteEvent(*EventPipeEventGCSampledObjectAllocationLow, (BYTE *)buffer, (unsigned int)offset);
1982
1983 if (!fixedBuffer)
1984 delete[] buffer;
1985
1986 return ERROR_SUCCESS;
1987}
1988
1989BOOL EventPipeEventEnabledPinObjectAtGCTime()
1990{
1991 return EventPipeEventPinObjectAtGCTime->IsEnabled();
1992}
1993
1994extern "C" ULONG EventPipeWriteEventPinObjectAtGCTime(
1995 const void* HandleID,
1996 const void* ObjectID,
1997 const unsigned __int64 ObjectSize,
1998 PCWSTR TypeName,
1999 const unsigned short ClrInstanceID)
2000{
2001 if (!EventPipeEventEnabledPinObjectAtGCTime())
2002 return ERROR_SUCCESS;
2003
2004 char stackBuffer[90];
2005 char *buffer = stackBuffer;
2006 size_t offset = 0;
2007 size_t size = 90;
2008 bool fixedBuffer = true;
2009
2010 bool success = true;
2011 success &= WriteToBuffer(HandleID, buffer, offset, size, fixedBuffer);
2012 success &= WriteToBuffer(ObjectID, buffer, offset, size, fixedBuffer);
2013 success &= WriteToBuffer(ObjectSize, buffer, offset, size, fixedBuffer);
2014 success &= WriteToBuffer(TypeName, buffer, offset, size, fixedBuffer);
2015 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2016
2017 if (!success)
2018 {
2019 if (!fixedBuffer)
2020 delete[] buffer;
2021 return ERROR_WRITE_FAULT;
2022 }
2023
2024 EventPipe::WriteEvent(*EventPipeEventPinObjectAtGCTime, (BYTE *)buffer, (unsigned int)offset);
2025
2026 if (!fixedBuffer)
2027 delete[] buffer;
2028
2029 return ERROR_SUCCESS;
2030}
2031
2032BOOL EventPipeEventEnabledGCTriggered()
2033{
2034 return EventPipeEventGCTriggered->IsEnabled();
2035}
2036
2037extern "C" ULONG EventPipeWriteEventGCTriggered(
2038 const unsigned int Reason,
2039 const unsigned short ClrInstanceID)
2040{
2041 if (!EventPipeEventEnabledGCTriggered())
2042 return ERROR_SUCCESS;
2043
2044 char stackBuffer[32];
2045 char *buffer = stackBuffer;
2046 size_t offset = 0;
2047 size_t size = 32;
2048 bool fixedBuffer = true;
2049
2050 bool success = true;
2051 success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
2052 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2053
2054 if (!success)
2055 {
2056 if (!fixedBuffer)
2057 delete[] buffer;
2058 return ERROR_WRITE_FAULT;
2059 }
2060
2061 EventPipe::WriteEvent(*EventPipeEventGCTriggered, (BYTE *)buffer, (unsigned int)offset);
2062
2063 if (!fixedBuffer)
2064 delete[] buffer;
2065
2066 return ERROR_SUCCESS;
2067}
2068
2069BOOL EventPipeEventEnabledGCBulkRootCCW()
2070{
2071 return EventPipeEventGCBulkRootCCW->IsEnabled();
2072}
2073
2074extern "C" ULONG EventPipeWriteEventGCBulkRootCCW(
2075 const unsigned int Count,
2076 const unsigned short ClrInstanceID,
2077 int Values_ElementSize,
2078 const void* Values)
2079{
2080 if (!EventPipeEventEnabledGCBulkRootCCW())
2081 return ERROR_SUCCESS;
2082
2083 char stackBuffer[38];
2084 char *buffer = stackBuffer;
2085 size_t offset = 0;
2086 size_t size = 38;
2087 bool fixedBuffer = true;
2088
2089 bool success = true;
2090 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
2091 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2092 success &= WriteToBuffer((const BYTE *)Values, (int)(Values_ElementSize), buffer, offset, size, fixedBuffer);
2093
2094 if (!success)
2095 {
2096 if (!fixedBuffer)
2097 delete[] buffer;
2098 return ERROR_WRITE_FAULT;
2099 }
2100
2101 EventPipe::WriteEvent(*EventPipeEventGCBulkRootCCW, (BYTE *)buffer, (unsigned int)offset);
2102
2103 if (!fixedBuffer)
2104 delete[] buffer;
2105
2106 return ERROR_SUCCESS;
2107}
2108
2109BOOL EventPipeEventEnabledGCBulkRCW()
2110{
2111 return EventPipeEventGCBulkRCW->IsEnabled();
2112}
2113
2114extern "C" ULONG EventPipeWriteEventGCBulkRCW(
2115 const unsigned int Count,
2116 const unsigned short ClrInstanceID,
2117 int Values_ElementSize,
2118 const void* Values)
2119{
2120 if (!EventPipeEventEnabledGCBulkRCW())
2121 return ERROR_SUCCESS;
2122
2123 char stackBuffer[38];
2124 char *buffer = stackBuffer;
2125 size_t offset = 0;
2126 size_t size = 38;
2127 bool fixedBuffer = true;
2128
2129 bool success = true;
2130 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
2131 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2132 success &= WriteToBuffer((const BYTE *)Values, (int)(Values_ElementSize), buffer, offset, size, fixedBuffer);
2133
2134 if (!success)
2135 {
2136 if (!fixedBuffer)
2137 delete[] buffer;
2138 return ERROR_WRITE_FAULT;
2139 }
2140
2141 EventPipe::WriteEvent(*EventPipeEventGCBulkRCW, (BYTE *)buffer, (unsigned int)offset);
2142
2143 if (!fixedBuffer)
2144 delete[] buffer;
2145
2146 return ERROR_SUCCESS;
2147}
2148
2149BOOL EventPipeEventEnabledGCBulkRootStaticVar()
2150{
2151 return EventPipeEventGCBulkRootStaticVar->IsEnabled();
2152}
2153
2154extern "C" ULONG EventPipeWriteEventGCBulkRootStaticVar(
2155 const unsigned int Count,
2156 const unsigned __int64 AppDomainID,
2157 const unsigned short ClrInstanceID,
2158 int Values_ElementSize,
2159 const void* Values)
2160{
2161 if (!EventPipeEventEnabledGCBulkRootStaticVar())
2162 return ERROR_SUCCESS;
2163
2164 char stackBuffer[46];
2165 char *buffer = stackBuffer;
2166 size_t offset = 0;
2167 size_t size = 46;
2168 bool fixedBuffer = true;
2169
2170 bool success = true;
2171 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
2172 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
2173 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2174 success &= WriteToBuffer((const BYTE *)Values, (int)(Values_ElementSize), buffer, offset, size, fixedBuffer);
2175
2176 if (!success)
2177 {
2178 if (!fixedBuffer)
2179 delete[] buffer;
2180 return ERROR_WRITE_FAULT;
2181 }
2182
2183 EventPipe::WriteEvent(*EventPipeEventGCBulkRootStaticVar, (BYTE *)buffer, (unsigned int)offset);
2184
2185 if (!fixedBuffer)
2186 delete[] buffer;
2187
2188 return ERROR_SUCCESS;
2189}
2190
2191BOOL EventPipeEventEnabledGCDynamicEvent()
2192{
2193 return EventPipeEventGCDynamicEvent->IsEnabled();
2194}
2195
2196extern "C" ULONG EventPipeWriteEventGCDynamicEvent(
2197 PCWSTR Name,
2198 const unsigned int DataSize,
2199 const BYTE* Data,
2200 const unsigned short ClrInstanceID)
2201{
2202 if (!EventPipeEventEnabledGCDynamicEvent())
2203 return ERROR_SUCCESS;
2204
2205 char stackBuffer[71];
2206 char *buffer = stackBuffer;
2207 size_t offset = 0;
2208 size_t size = 71;
2209 bool fixedBuffer = true;
2210
2211 bool success = true;
2212 success &= WriteToBuffer(Name, buffer, offset, size, fixedBuffer);
2213 success &= WriteToBuffer(DataSize, buffer, offset, size, fixedBuffer);
2214 success &= WriteToBuffer((const BYTE *)Data, sizeof(const BYTE) * (int)DataSize, buffer, offset, size, fixedBuffer);
2215 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2216
2217 if (!success)
2218 {
2219 if (!fixedBuffer)
2220 delete[] buffer;
2221 return ERROR_WRITE_FAULT;
2222 }
2223
2224 EventPipe::WriteEvent(*EventPipeEventGCDynamicEvent, (BYTE *)buffer, (unsigned int)offset);
2225
2226 if (!fixedBuffer)
2227 delete[] buffer;
2228
2229 return ERROR_SUCCESS;
2230}
2231
2232BOOL EventPipeEventEnabledWorkerThreadCreate()
2233{
2234 return EventPipeEventWorkerThreadCreate->IsEnabled();
2235}
2236
2237extern "C" ULONG EventPipeWriteEventWorkerThreadCreate(
2238 const unsigned int WorkerThreadCount,
2239 const unsigned int RetiredWorkerThreads)
2240{
2241 if (!EventPipeEventEnabledWorkerThreadCreate())
2242 return ERROR_SUCCESS;
2243
2244 char stackBuffer[32];
2245 char *buffer = stackBuffer;
2246 size_t offset = 0;
2247 size_t size = 32;
2248 bool fixedBuffer = true;
2249
2250 bool success = true;
2251 success &= WriteToBuffer(WorkerThreadCount, buffer, offset, size, fixedBuffer);
2252 success &= WriteToBuffer(RetiredWorkerThreads, buffer, offset, size, fixedBuffer);
2253
2254 if (!success)
2255 {
2256 if (!fixedBuffer)
2257 delete[] buffer;
2258 return ERROR_WRITE_FAULT;
2259 }
2260
2261 EventPipe::WriteEvent(*EventPipeEventWorkerThreadCreate, (BYTE *)buffer, (unsigned int)offset);
2262
2263 if (!fixedBuffer)
2264 delete[] buffer;
2265
2266 return ERROR_SUCCESS;
2267}
2268
2269BOOL EventPipeEventEnabledWorkerThreadTerminate()
2270{
2271 return EventPipeEventWorkerThreadTerminate->IsEnabled();
2272}
2273
2274extern "C" ULONG EventPipeWriteEventWorkerThreadTerminate(
2275 const unsigned int WorkerThreadCount,
2276 const unsigned int RetiredWorkerThreads)
2277{
2278 if (!EventPipeEventEnabledWorkerThreadTerminate())
2279 return ERROR_SUCCESS;
2280
2281 char stackBuffer[32];
2282 char *buffer = stackBuffer;
2283 size_t offset = 0;
2284 size_t size = 32;
2285 bool fixedBuffer = true;
2286
2287 bool success = true;
2288 success &= WriteToBuffer(WorkerThreadCount, buffer, offset, size, fixedBuffer);
2289 success &= WriteToBuffer(RetiredWorkerThreads, buffer, offset, size, fixedBuffer);
2290
2291 if (!success)
2292 {
2293 if (!fixedBuffer)
2294 delete[] buffer;
2295 return ERROR_WRITE_FAULT;
2296 }
2297
2298 EventPipe::WriteEvent(*EventPipeEventWorkerThreadTerminate, (BYTE *)buffer, (unsigned int)offset);
2299
2300 if (!fixedBuffer)
2301 delete[] buffer;
2302
2303 return ERROR_SUCCESS;
2304}
2305
2306BOOL EventPipeEventEnabledWorkerThreadRetire()
2307{
2308 return EventPipeEventWorkerThreadRetire->IsEnabled();
2309}
2310
2311extern "C" ULONG EventPipeWriteEventWorkerThreadRetire(
2312 const unsigned int WorkerThreadCount,
2313 const unsigned int RetiredWorkerThreads)
2314{
2315 if (!EventPipeEventEnabledWorkerThreadRetire())
2316 return ERROR_SUCCESS;
2317
2318 char stackBuffer[32];
2319 char *buffer = stackBuffer;
2320 size_t offset = 0;
2321 size_t size = 32;
2322 bool fixedBuffer = true;
2323
2324 bool success = true;
2325 success &= WriteToBuffer(WorkerThreadCount, buffer, offset, size, fixedBuffer);
2326 success &= WriteToBuffer(RetiredWorkerThreads, buffer, offset, size, fixedBuffer);
2327
2328 if (!success)
2329 {
2330 if (!fixedBuffer)
2331 delete[] buffer;
2332 return ERROR_WRITE_FAULT;
2333 }
2334
2335 EventPipe::WriteEvent(*EventPipeEventWorkerThreadRetire, (BYTE *)buffer, (unsigned int)offset);
2336
2337 if (!fixedBuffer)
2338 delete[] buffer;
2339
2340 return ERROR_SUCCESS;
2341}
2342
2343BOOL EventPipeEventEnabledWorkerThreadUnretire()
2344{
2345 return EventPipeEventWorkerThreadUnretire->IsEnabled();
2346}
2347
2348extern "C" ULONG EventPipeWriteEventWorkerThreadUnretire(
2349 const unsigned int WorkerThreadCount,
2350 const unsigned int RetiredWorkerThreads)
2351{
2352 if (!EventPipeEventEnabledWorkerThreadUnretire())
2353 return ERROR_SUCCESS;
2354
2355 char stackBuffer[32];
2356 char *buffer = stackBuffer;
2357 size_t offset = 0;
2358 size_t size = 32;
2359 bool fixedBuffer = true;
2360
2361 bool success = true;
2362 success &= WriteToBuffer(WorkerThreadCount, buffer, offset, size, fixedBuffer);
2363 success &= WriteToBuffer(RetiredWorkerThreads, buffer, offset, size, fixedBuffer);
2364
2365 if (!success)
2366 {
2367 if (!fixedBuffer)
2368 delete[] buffer;
2369 return ERROR_WRITE_FAULT;
2370 }
2371
2372 EventPipe::WriteEvent(*EventPipeEventWorkerThreadUnretire, (BYTE *)buffer, (unsigned int)offset);
2373
2374 if (!fixedBuffer)
2375 delete[] buffer;
2376
2377 return ERROR_SUCCESS;
2378}
2379
2380BOOL EventPipeEventEnabledIOThreadCreate()
2381{
2382 return EventPipeEventIOThreadCreate->IsEnabled();
2383}
2384
2385extern "C" ULONG EventPipeWriteEventIOThreadCreate(
2386 const unsigned int IOThreadCount,
2387 const unsigned int RetiredIOThreads)
2388{
2389 if (!EventPipeEventEnabledIOThreadCreate())
2390 return ERROR_SUCCESS;
2391
2392 char stackBuffer[32];
2393 char *buffer = stackBuffer;
2394 size_t offset = 0;
2395 size_t size = 32;
2396 bool fixedBuffer = true;
2397
2398 bool success = true;
2399 success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
2400 success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
2401
2402 if (!success)
2403 {
2404 if (!fixedBuffer)
2405 delete[] buffer;
2406 return ERROR_WRITE_FAULT;
2407 }
2408
2409 EventPipe::WriteEvent(*EventPipeEventIOThreadCreate, (BYTE *)buffer, (unsigned int)offset);
2410
2411 if (!fixedBuffer)
2412 delete[] buffer;
2413
2414 return ERROR_SUCCESS;
2415}
2416
2417BOOL EventPipeEventEnabledIOThreadCreate_V1()
2418{
2419 return EventPipeEventIOThreadCreate_V1->IsEnabled();
2420}
2421
2422extern "C" ULONG EventPipeWriteEventIOThreadCreate_V1(
2423 const unsigned int IOThreadCount,
2424 const unsigned int RetiredIOThreads,
2425 const unsigned short ClrInstanceID)
2426{
2427 if (!EventPipeEventEnabledIOThreadCreate_V1())
2428 return ERROR_SUCCESS;
2429
2430 char stackBuffer[32];
2431 char *buffer = stackBuffer;
2432 size_t offset = 0;
2433 size_t size = 32;
2434 bool fixedBuffer = true;
2435
2436 bool success = true;
2437 success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
2438 success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
2439 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2440
2441 if (!success)
2442 {
2443 if (!fixedBuffer)
2444 delete[] buffer;
2445 return ERROR_WRITE_FAULT;
2446 }
2447
2448 EventPipe::WriteEvent(*EventPipeEventIOThreadCreate_V1, (BYTE *)buffer, (unsigned int)offset);
2449
2450 if (!fixedBuffer)
2451 delete[] buffer;
2452
2453 return ERROR_SUCCESS;
2454}
2455
2456BOOL EventPipeEventEnabledIOThreadTerminate()
2457{
2458 return EventPipeEventIOThreadTerminate->IsEnabled();
2459}
2460
2461extern "C" ULONG EventPipeWriteEventIOThreadTerminate(
2462 const unsigned int IOThreadCount,
2463 const unsigned int RetiredIOThreads)
2464{
2465 if (!EventPipeEventEnabledIOThreadTerminate())
2466 return ERROR_SUCCESS;
2467
2468 char stackBuffer[32];
2469 char *buffer = stackBuffer;
2470 size_t offset = 0;
2471 size_t size = 32;
2472 bool fixedBuffer = true;
2473
2474 bool success = true;
2475 success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
2476 success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
2477
2478 if (!success)
2479 {
2480 if (!fixedBuffer)
2481 delete[] buffer;
2482 return ERROR_WRITE_FAULT;
2483 }
2484
2485 EventPipe::WriteEvent(*EventPipeEventIOThreadTerminate, (BYTE *)buffer, (unsigned int)offset);
2486
2487 if (!fixedBuffer)
2488 delete[] buffer;
2489
2490 return ERROR_SUCCESS;
2491}
2492
2493BOOL EventPipeEventEnabledIOThreadTerminate_V1()
2494{
2495 return EventPipeEventIOThreadTerminate_V1->IsEnabled();
2496}
2497
2498extern "C" ULONG EventPipeWriteEventIOThreadTerminate_V1(
2499 const unsigned int IOThreadCount,
2500 const unsigned int RetiredIOThreads,
2501 const unsigned short ClrInstanceID)
2502{
2503 if (!EventPipeEventEnabledIOThreadTerminate_V1())
2504 return ERROR_SUCCESS;
2505
2506 char stackBuffer[32];
2507 char *buffer = stackBuffer;
2508 size_t offset = 0;
2509 size_t size = 32;
2510 bool fixedBuffer = true;
2511
2512 bool success = true;
2513 success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
2514 success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
2515 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2516
2517 if (!success)
2518 {
2519 if (!fixedBuffer)
2520 delete[] buffer;
2521 return ERROR_WRITE_FAULT;
2522 }
2523
2524 EventPipe::WriteEvent(*EventPipeEventIOThreadTerminate_V1, (BYTE *)buffer, (unsigned int)offset);
2525
2526 if (!fixedBuffer)
2527 delete[] buffer;
2528
2529 return ERROR_SUCCESS;
2530}
2531
2532BOOL EventPipeEventEnabledIOThreadRetire()
2533{
2534 return EventPipeEventIOThreadRetire->IsEnabled();
2535}
2536
2537extern "C" ULONG EventPipeWriteEventIOThreadRetire(
2538 const unsigned int IOThreadCount,
2539 const unsigned int RetiredIOThreads)
2540{
2541 if (!EventPipeEventEnabledIOThreadRetire())
2542 return ERROR_SUCCESS;
2543
2544 char stackBuffer[32];
2545 char *buffer = stackBuffer;
2546 size_t offset = 0;
2547 size_t size = 32;
2548 bool fixedBuffer = true;
2549
2550 bool success = true;
2551 success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
2552 success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
2553
2554 if (!success)
2555 {
2556 if (!fixedBuffer)
2557 delete[] buffer;
2558 return ERROR_WRITE_FAULT;
2559 }
2560
2561 EventPipe::WriteEvent(*EventPipeEventIOThreadRetire, (BYTE *)buffer, (unsigned int)offset);
2562
2563 if (!fixedBuffer)
2564 delete[] buffer;
2565
2566 return ERROR_SUCCESS;
2567}
2568
2569BOOL EventPipeEventEnabledIOThreadRetire_V1()
2570{
2571 return EventPipeEventIOThreadRetire_V1->IsEnabled();
2572}
2573
2574extern "C" ULONG EventPipeWriteEventIOThreadRetire_V1(
2575 const unsigned int IOThreadCount,
2576 const unsigned int RetiredIOThreads,
2577 const unsigned short ClrInstanceID)
2578{
2579 if (!EventPipeEventEnabledIOThreadRetire_V1())
2580 return ERROR_SUCCESS;
2581
2582 char stackBuffer[32];
2583 char *buffer = stackBuffer;
2584 size_t offset = 0;
2585 size_t size = 32;
2586 bool fixedBuffer = true;
2587
2588 bool success = true;
2589 success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
2590 success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
2591 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2592
2593 if (!success)
2594 {
2595 if (!fixedBuffer)
2596 delete[] buffer;
2597 return ERROR_WRITE_FAULT;
2598 }
2599
2600 EventPipe::WriteEvent(*EventPipeEventIOThreadRetire_V1, (BYTE *)buffer, (unsigned int)offset);
2601
2602 if (!fixedBuffer)
2603 delete[] buffer;
2604
2605 return ERROR_SUCCESS;
2606}
2607
2608BOOL EventPipeEventEnabledIOThreadUnretire()
2609{
2610 return EventPipeEventIOThreadUnretire->IsEnabled();
2611}
2612
2613extern "C" ULONG EventPipeWriteEventIOThreadUnretire(
2614 const unsigned int IOThreadCount,
2615 const unsigned int RetiredIOThreads)
2616{
2617 if (!EventPipeEventEnabledIOThreadUnretire())
2618 return ERROR_SUCCESS;
2619
2620 char stackBuffer[32];
2621 char *buffer = stackBuffer;
2622 size_t offset = 0;
2623 size_t size = 32;
2624 bool fixedBuffer = true;
2625
2626 bool success = true;
2627 success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
2628 success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
2629
2630 if (!success)
2631 {
2632 if (!fixedBuffer)
2633 delete[] buffer;
2634 return ERROR_WRITE_FAULT;
2635 }
2636
2637 EventPipe::WriteEvent(*EventPipeEventIOThreadUnretire, (BYTE *)buffer, (unsigned int)offset);
2638
2639 if (!fixedBuffer)
2640 delete[] buffer;
2641
2642 return ERROR_SUCCESS;
2643}
2644
2645BOOL EventPipeEventEnabledIOThreadUnretire_V1()
2646{
2647 return EventPipeEventIOThreadUnretire_V1->IsEnabled();
2648}
2649
2650extern "C" ULONG EventPipeWriteEventIOThreadUnretire_V1(
2651 const unsigned int IOThreadCount,
2652 const unsigned int RetiredIOThreads,
2653 const unsigned short ClrInstanceID)
2654{
2655 if (!EventPipeEventEnabledIOThreadUnretire_V1())
2656 return ERROR_SUCCESS;
2657
2658 char stackBuffer[32];
2659 char *buffer = stackBuffer;
2660 size_t offset = 0;
2661 size_t size = 32;
2662 bool fixedBuffer = true;
2663
2664 bool success = true;
2665 success &= WriteToBuffer(IOThreadCount, buffer, offset, size, fixedBuffer);
2666 success &= WriteToBuffer(RetiredIOThreads, buffer, offset, size, fixedBuffer);
2667 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2668
2669 if (!success)
2670 {
2671 if (!fixedBuffer)
2672 delete[] buffer;
2673 return ERROR_WRITE_FAULT;
2674 }
2675
2676 EventPipe::WriteEvent(*EventPipeEventIOThreadUnretire_V1, (BYTE *)buffer, (unsigned int)offset);
2677
2678 if (!fixedBuffer)
2679 delete[] buffer;
2680
2681 return ERROR_SUCCESS;
2682}
2683
2684BOOL EventPipeEventEnabledThreadpoolSuspensionSuspendThread()
2685{
2686 return EventPipeEventThreadpoolSuspensionSuspendThread->IsEnabled();
2687}
2688
2689extern "C" ULONG EventPipeWriteEventThreadpoolSuspensionSuspendThread(
2690 const unsigned int ClrThreadID,
2691 const unsigned int CpuUtilization)
2692{
2693 if (!EventPipeEventEnabledThreadpoolSuspensionSuspendThread())
2694 return ERROR_SUCCESS;
2695
2696 char stackBuffer[32];
2697 char *buffer = stackBuffer;
2698 size_t offset = 0;
2699 size_t size = 32;
2700 bool fixedBuffer = true;
2701
2702 bool success = true;
2703 success &= WriteToBuffer(ClrThreadID, buffer, offset, size, fixedBuffer);
2704 success &= WriteToBuffer(CpuUtilization, buffer, offset, size, fixedBuffer);
2705
2706 if (!success)
2707 {
2708 if (!fixedBuffer)
2709 delete[] buffer;
2710 return ERROR_WRITE_FAULT;
2711 }
2712
2713 EventPipe::WriteEvent(*EventPipeEventThreadpoolSuspensionSuspendThread, (BYTE *)buffer, (unsigned int)offset);
2714
2715 if (!fixedBuffer)
2716 delete[] buffer;
2717
2718 return ERROR_SUCCESS;
2719}
2720
2721BOOL EventPipeEventEnabledThreadpoolSuspensionResumeThread()
2722{
2723 return EventPipeEventThreadpoolSuspensionResumeThread->IsEnabled();
2724}
2725
2726extern "C" ULONG EventPipeWriteEventThreadpoolSuspensionResumeThread(
2727 const unsigned int ClrThreadID,
2728 const unsigned int CpuUtilization)
2729{
2730 if (!EventPipeEventEnabledThreadpoolSuspensionResumeThread())
2731 return ERROR_SUCCESS;
2732
2733 char stackBuffer[32];
2734 char *buffer = stackBuffer;
2735 size_t offset = 0;
2736 size_t size = 32;
2737 bool fixedBuffer = true;
2738
2739 bool success = true;
2740 success &= WriteToBuffer(ClrThreadID, buffer, offset, size, fixedBuffer);
2741 success &= WriteToBuffer(CpuUtilization, buffer, offset, size, fixedBuffer);
2742
2743 if (!success)
2744 {
2745 if (!fixedBuffer)
2746 delete[] buffer;
2747 return ERROR_WRITE_FAULT;
2748 }
2749
2750 EventPipe::WriteEvent(*EventPipeEventThreadpoolSuspensionResumeThread, (BYTE *)buffer, (unsigned int)offset);
2751
2752 if (!fixedBuffer)
2753 delete[] buffer;
2754
2755 return ERROR_SUCCESS;
2756}
2757
2758BOOL EventPipeEventEnabledThreadPoolWorkerThreadStart()
2759{
2760 return EventPipeEventThreadPoolWorkerThreadStart->IsEnabled();
2761}
2762
2763extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadStart(
2764 const unsigned int ActiveWorkerThreadCount,
2765 const unsigned int RetiredWorkerThreadCount,
2766 const unsigned short ClrInstanceID)
2767{
2768 if (!EventPipeEventEnabledThreadPoolWorkerThreadStart())
2769 return ERROR_SUCCESS;
2770
2771 char stackBuffer[32];
2772 char *buffer = stackBuffer;
2773 size_t offset = 0;
2774 size_t size = 32;
2775 bool fixedBuffer = true;
2776
2777 bool success = true;
2778 success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
2779 success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
2780 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2781
2782 if (!success)
2783 {
2784 if (!fixedBuffer)
2785 delete[] buffer;
2786 return ERROR_WRITE_FAULT;
2787 }
2788
2789 EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadStart, (BYTE *)buffer, (unsigned int)offset);
2790
2791 if (!fixedBuffer)
2792 delete[] buffer;
2793
2794 return ERROR_SUCCESS;
2795}
2796
2797BOOL EventPipeEventEnabledThreadPoolWorkerThreadStop()
2798{
2799 return EventPipeEventThreadPoolWorkerThreadStop->IsEnabled();
2800}
2801
2802extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadStop(
2803 const unsigned int ActiveWorkerThreadCount,
2804 const unsigned int RetiredWorkerThreadCount,
2805 const unsigned short ClrInstanceID)
2806{
2807 if (!EventPipeEventEnabledThreadPoolWorkerThreadStop())
2808 return ERROR_SUCCESS;
2809
2810 char stackBuffer[32];
2811 char *buffer = stackBuffer;
2812 size_t offset = 0;
2813 size_t size = 32;
2814 bool fixedBuffer = true;
2815
2816 bool success = true;
2817 success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
2818 success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
2819 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2820
2821 if (!success)
2822 {
2823 if (!fixedBuffer)
2824 delete[] buffer;
2825 return ERROR_WRITE_FAULT;
2826 }
2827
2828 EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadStop, (BYTE *)buffer, (unsigned int)offset);
2829
2830 if (!fixedBuffer)
2831 delete[] buffer;
2832
2833 return ERROR_SUCCESS;
2834}
2835
2836BOOL EventPipeEventEnabledThreadPoolWorkerThreadRetirementStart()
2837{
2838 return EventPipeEventThreadPoolWorkerThreadRetirementStart->IsEnabled();
2839}
2840
2841extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadRetirementStart(
2842 const unsigned int ActiveWorkerThreadCount,
2843 const unsigned int RetiredWorkerThreadCount,
2844 const unsigned short ClrInstanceID)
2845{
2846 if (!EventPipeEventEnabledThreadPoolWorkerThreadRetirementStart())
2847 return ERROR_SUCCESS;
2848
2849 char stackBuffer[32];
2850 char *buffer = stackBuffer;
2851 size_t offset = 0;
2852 size_t size = 32;
2853 bool fixedBuffer = true;
2854
2855 bool success = true;
2856 success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
2857 success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
2858 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2859
2860 if (!success)
2861 {
2862 if (!fixedBuffer)
2863 delete[] buffer;
2864 return ERROR_WRITE_FAULT;
2865 }
2866
2867 EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadRetirementStart, (BYTE *)buffer, (unsigned int)offset);
2868
2869 if (!fixedBuffer)
2870 delete[] buffer;
2871
2872 return ERROR_SUCCESS;
2873}
2874
2875BOOL EventPipeEventEnabledThreadPoolWorkerThreadRetirementStop()
2876{
2877 return EventPipeEventThreadPoolWorkerThreadRetirementStop->IsEnabled();
2878}
2879
2880extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadRetirementStop(
2881 const unsigned int ActiveWorkerThreadCount,
2882 const unsigned int RetiredWorkerThreadCount,
2883 const unsigned short ClrInstanceID)
2884{
2885 if (!EventPipeEventEnabledThreadPoolWorkerThreadRetirementStop())
2886 return ERROR_SUCCESS;
2887
2888 char stackBuffer[32];
2889 char *buffer = stackBuffer;
2890 size_t offset = 0;
2891 size_t size = 32;
2892 bool fixedBuffer = true;
2893
2894 bool success = true;
2895 success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
2896 success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
2897 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2898
2899 if (!success)
2900 {
2901 if (!fixedBuffer)
2902 delete[] buffer;
2903 return ERROR_WRITE_FAULT;
2904 }
2905
2906 EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadRetirementStop, (BYTE *)buffer, (unsigned int)offset);
2907
2908 if (!fixedBuffer)
2909 delete[] buffer;
2910
2911 return ERROR_SUCCESS;
2912}
2913
2914BOOL EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentSample()
2915{
2916 return EventPipeEventThreadPoolWorkerThreadAdjustmentSample->IsEnabled();
2917}
2918
2919extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadAdjustmentSample(
2920 const double Throughput,
2921 const unsigned short ClrInstanceID)
2922{
2923 if (!EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentSample())
2924 return ERROR_SUCCESS;
2925
2926 char stackBuffer[32];
2927 char *buffer = stackBuffer;
2928 size_t offset = 0;
2929 size_t size = 32;
2930 bool fixedBuffer = true;
2931
2932 bool success = true;
2933 success &= WriteToBuffer(Throughput, buffer, offset, size, fixedBuffer);
2934 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2935
2936 if (!success)
2937 {
2938 if (!fixedBuffer)
2939 delete[] buffer;
2940 return ERROR_WRITE_FAULT;
2941 }
2942
2943 EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadAdjustmentSample, (BYTE *)buffer, (unsigned int)offset);
2944
2945 if (!fixedBuffer)
2946 delete[] buffer;
2947
2948 return ERROR_SUCCESS;
2949}
2950
2951BOOL EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentAdjustment()
2952{
2953 return EventPipeEventThreadPoolWorkerThreadAdjustmentAdjustment->IsEnabled();
2954}
2955
2956extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadAdjustmentAdjustment(
2957 const double AverageThroughput,
2958 const unsigned int NewWorkerThreadCount,
2959 const unsigned int Reason,
2960 const unsigned short ClrInstanceID)
2961{
2962 if (!EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentAdjustment())
2963 return ERROR_SUCCESS;
2964
2965 char stackBuffer[32];
2966 char *buffer = stackBuffer;
2967 size_t offset = 0;
2968 size_t size = 32;
2969 bool fixedBuffer = true;
2970
2971 bool success = true;
2972 success &= WriteToBuffer(AverageThroughput, buffer, offset, size, fixedBuffer);
2973 success &= WriteToBuffer(NewWorkerThreadCount, buffer, offset, size, fixedBuffer);
2974 success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
2975 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
2976
2977 if (!success)
2978 {
2979 if (!fixedBuffer)
2980 delete[] buffer;
2981 return ERROR_WRITE_FAULT;
2982 }
2983
2984 EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadAdjustmentAdjustment, (BYTE *)buffer, (unsigned int)offset);
2985
2986 if (!fixedBuffer)
2987 delete[] buffer;
2988
2989 return ERROR_SUCCESS;
2990}
2991
2992BOOL EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentStats()
2993{
2994 return EventPipeEventThreadPoolWorkerThreadAdjustmentStats->IsEnabled();
2995}
2996
2997extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadAdjustmentStats(
2998 const double Duration,
2999 const double Throughput,
3000 const double ThreadWave,
3001 const double ThroughputWave,
3002 const double ThroughputErrorEstimate,
3003 const double AverageThroughputErrorEstimate,
3004 const double ThroughputRatio,
3005 const double Confidence,
3006 const double NewControlSetting,
3007 const unsigned short NewThreadWaveMagnitude,
3008 const unsigned short ClrInstanceID)
3009{
3010 if (!EventPipeEventEnabledThreadPoolWorkerThreadAdjustmentStats())
3011 return ERROR_SUCCESS;
3012
3013 char stackBuffer[76];
3014 char *buffer = stackBuffer;
3015 size_t offset = 0;
3016 size_t size = 76;
3017 bool fixedBuffer = true;
3018
3019 bool success = true;
3020 success &= WriteToBuffer(Duration, buffer, offset, size, fixedBuffer);
3021 success &= WriteToBuffer(Throughput, buffer, offset, size, fixedBuffer);
3022 success &= WriteToBuffer(ThreadWave, buffer, offset, size, fixedBuffer);
3023 success &= WriteToBuffer(ThroughputWave, buffer, offset, size, fixedBuffer);
3024 success &= WriteToBuffer(ThroughputErrorEstimate, buffer, offset, size, fixedBuffer);
3025 success &= WriteToBuffer(AverageThroughputErrorEstimate, buffer, offset, size, fixedBuffer);
3026 success &= WriteToBuffer(ThroughputRatio, buffer, offset, size, fixedBuffer);
3027 success &= WriteToBuffer(Confidence, buffer, offset, size, fixedBuffer);
3028 success &= WriteToBuffer(NewControlSetting, buffer, offset, size, fixedBuffer);
3029 success &= WriteToBuffer(NewThreadWaveMagnitude, buffer, offset, size, fixedBuffer);
3030 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3031
3032 if (!success)
3033 {
3034 if (!fixedBuffer)
3035 delete[] buffer;
3036 return ERROR_WRITE_FAULT;
3037 }
3038
3039 EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadAdjustmentStats, (BYTE *)buffer, (unsigned int)offset);
3040
3041 if (!fixedBuffer)
3042 delete[] buffer;
3043
3044 return ERROR_SUCCESS;
3045}
3046
3047BOOL EventPipeEventEnabledThreadPoolWorkerThreadWait()
3048{
3049 return EventPipeEventThreadPoolWorkerThreadWait->IsEnabled();
3050}
3051
3052extern "C" ULONG EventPipeWriteEventThreadPoolWorkerThreadWait(
3053 const unsigned int ActiveWorkerThreadCount,
3054 const unsigned int RetiredWorkerThreadCount,
3055 const unsigned short ClrInstanceID)
3056{
3057 if (!EventPipeEventEnabledThreadPoolWorkerThreadWait())
3058 return ERROR_SUCCESS;
3059
3060 char stackBuffer[32];
3061 char *buffer = stackBuffer;
3062 size_t offset = 0;
3063 size_t size = 32;
3064 bool fixedBuffer = true;
3065
3066 bool success = true;
3067 success &= WriteToBuffer(ActiveWorkerThreadCount, buffer, offset, size, fixedBuffer);
3068 success &= WriteToBuffer(RetiredWorkerThreadCount, buffer, offset, size, fixedBuffer);
3069 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3070
3071 if (!success)
3072 {
3073 if (!fixedBuffer)
3074 delete[] buffer;
3075 return ERROR_WRITE_FAULT;
3076 }
3077
3078 EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkerThreadWait, (BYTE *)buffer, (unsigned int)offset);
3079
3080 if (!fixedBuffer)
3081 delete[] buffer;
3082
3083 return ERROR_SUCCESS;
3084}
3085
3086BOOL EventPipeEventEnabledThreadPoolWorkingThreadCount()
3087{
3088 return EventPipeEventThreadPoolWorkingThreadCount->IsEnabled();
3089}
3090
3091extern "C" ULONG EventPipeWriteEventThreadPoolWorkingThreadCount(
3092 const unsigned int Count,
3093 const unsigned short ClrInstanceID)
3094{
3095 if (!EventPipeEventEnabledThreadPoolWorkingThreadCount())
3096 return ERROR_SUCCESS;
3097
3098 char stackBuffer[32];
3099 char *buffer = stackBuffer;
3100 size_t offset = 0;
3101 size_t size = 32;
3102 bool fixedBuffer = true;
3103
3104 bool success = true;
3105 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
3106 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3107
3108 if (!success)
3109 {
3110 if (!fixedBuffer)
3111 delete[] buffer;
3112 return ERROR_WRITE_FAULT;
3113 }
3114
3115 EventPipe::WriteEvent(*EventPipeEventThreadPoolWorkingThreadCount, (BYTE *)buffer, (unsigned int)offset);
3116
3117 if (!fixedBuffer)
3118 delete[] buffer;
3119
3120 return ERROR_SUCCESS;
3121}
3122
3123BOOL EventPipeEventEnabledThreadPoolEnqueue()
3124{
3125 return EventPipeEventThreadPoolEnqueue->IsEnabled();
3126}
3127
3128extern "C" ULONG EventPipeWriteEventThreadPoolEnqueue(
3129 const void* WorkID,
3130 const unsigned short ClrInstanceID)
3131{
3132 if (!EventPipeEventEnabledThreadPoolEnqueue())
3133 return ERROR_SUCCESS;
3134
3135 char stackBuffer[32];
3136 char *buffer = stackBuffer;
3137 size_t offset = 0;
3138 size_t size = 32;
3139 bool fixedBuffer = true;
3140
3141 bool success = true;
3142 success &= WriteToBuffer(WorkID, buffer, offset, size, fixedBuffer);
3143 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3144
3145 if (!success)
3146 {
3147 if (!fixedBuffer)
3148 delete[] buffer;
3149 return ERROR_WRITE_FAULT;
3150 }
3151
3152 EventPipe::WriteEvent(*EventPipeEventThreadPoolEnqueue, (BYTE *)buffer, (unsigned int)offset);
3153
3154 if (!fixedBuffer)
3155 delete[] buffer;
3156
3157 return ERROR_SUCCESS;
3158}
3159
3160BOOL EventPipeEventEnabledThreadPoolDequeue()
3161{
3162 return EventPipeEventThreadPoolDequeue->IsEnabled();
3163}
3164
3165extern "C" ULONG EventPipeWriteEventThreadPoolDequeue(
3166 const void* WorkID,
3167 const unsigned short ClrInstanceID)
3168{
3169 if (!EventPipeEventEnabledThreadPoolDequeue())
3170 return ERROR_SUCCESS;
3171
3172 char stackBuffer[32];
3173 char *buffer = stackBuffer;
3174 size_t offset = 0;
3175 size_t size = 32;
3176 bool fixedBuffer = true;
3177
3178 bool success = true;
3179 success &= WriteToBuffer(WorkID, buffer, offset, size, fixedBuffer);
3180 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3181
3182 if (!success)
3183 {
3184 if (!fixedBuffer)
3185 delete[] buffer;
3186 return ERROR_WRITE_FAULT;
3187 }
3188
3189 EventPipe::WriteEvent(*EventPipeEventThreadPoolDequeue, (BYTE *)buffer, (unsigned int)offset);
3190
3191 if (!fixedBuffer)
3192 delete[] buffer;
3193
3194 return ERROR_SUCCESS;
3195}
3196
3197BOOL EventPipeEventEnabledThreadPoolIOEnqueue()
3198{
3199 return EventPipeEventThreadPoolIOEnqueue->IsEnabled();
3200}
3201
3202extern "C" ULONG EventPipeWriteEventThreadPoolIOEnqueue(
3203 const void* NativeOverlapped,
3204 const void* Overlapped,
3205 const BOOL MultiDequeues,
3206 const unsigned short ClrInstanceID)
3207{
3208 if (!EventPipeEventEnabledThreadPoolIOEnqueue())
3209 return ERROR_SUCCESS;
3210
3211 char stackBuffer[32];
3212 char *buffer = stackBuffer;
3213 size_t offset = 0;
3214 size_t size = 32;
3215 bool fixedBuffer = true;
3216
3217 bool success = true;
3218 success &= WriteToBuffer(NativeOverlapped, buffer, offset, size, fixedBuffer);
3219 success &= WriteToBuffer(Overlapped, buffer, offset, size, fixedBuffer);
3220 success &= WriteToBuffer(MultiDequeues, buffer, offset, size, fixedBuffer);
3221 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3222
3223 if (!success)
3224 {
3225 if (!fixedBuffer)
3226 delete[] buffer;
3227 return ERROR_WRITE_FAULT;
3228 }
3229
3230 EventPipe::WriteEvent(*EventPipeEventThreadPoolIOEnqueue, (BYTE *)buffer, (unsigned int)offset);
3231
3232 if (!fixedBuffer)
3233 delete[] buffer;
3234
3235 return ERROR_SUCCESS;
3236}
3237
3238BOOL EventPipeEventEnabledThreadPoolIODequeue()
3239{
3240 return EventPipeEventThreadPoolIODequeue->IsEnabled();
3241}
3242
3243extern "C" ULONG EventPipeWriteEventThreadPoolIODequeue(
3244 const void* NativeOverlapped,
3245 const void* Overlapped,
3246 const unsigned short ClrInstanceID)
3247{
3248 if (!EventPipeEventEnabledThreadPoolIODequeue())
3249 return ERROR_SUCCESS;
3250
3251 char stackBuffer[32];
3252 char *buffer = stackBuffer;
3253 size_t offset = 0;
3254 size_t size = 32;
3255 bool fixedBuffer = true;
3256
3257 bool success = true;
3258 success &= WriteToBuffer(NativeOverlapped, buffer, offset, size, fixedBuffer);
3259 success &= WriteToBuffer(Overlapped, buffer, offset, size, fixedBuffer);
3260 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3261
3262 if (!success)
3263 {
3264 if (!fixedBuffer)
3265 delete[] buffer;
3266 return ERROR_WRITE_FAULT;
3267 }
3268
3269 EventPipe::WriteEvent(*EventPipeEventThreadPoolIODequeue, (BYTE *)buffer, (unsigned int)offset);
3270
3271 if (!fixedBuffer)
3272 delete[] buffer;
3273
3274 return ERROR_SUCCESS;
3275}
3276
3277BOOL EventPipeEventEnabledThreadPoolIOPack()
3278{
3279 return EventPipeEventThreadPoolIOPack->IsEnabled();
3280}
3281
3282extern "C" ULONG EventPipeWriteEventThreadPoolIOPack(
3283 const void* NativeOverlapped,
3284 const void* Overlapped,
3285 const unsigned short ClrInstanceID)
3286{
3287 if (!EventPipeEventEnabledThreadPoolIOPack())
3288 return ERROR_SUCCESS;
3289
3290 char stackBuffer[32];
3291 char *buffer = stackBuffer;
3292 size_t offset = 0;
3293 size_t size = 32;
3294 bool fixedBuffer = true;
3295
3296 bool success = true;
3297 success &= WriteToBuffer(NativeOverlapped, buffer, offset, size, fixedBuffer);
3298 success &= WriteToBuffer(Overlapped, buffer, offset, size, fixedBuffer);
3299 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3300
3301 if (!success)
3302 {
3303 if (!fixedBuffer)
3304 delete[] buffer;
3305 return ERROR_WRITE_FAULT;
3306 }
3307
3308 EventPipe::WriteEvent(*EventPipeEventThreadPoolIOPack, (BYTE *)buffer, (unsigned int)offset);
3309
3310 if (!fixedBuffer)
3311 delete[] buffer;
3312
3313 return ERROR_SUCCESS;
3314}
3315
3316BOOL EventPipeEventEnabledThreadCreating()
3317{
3318 return EventPipeEventThreadCreating->IsEnabled();
3319}
3320
3321extern "C" ULONG EventPipeWriteEventThreadCreating(
3322 const void* ID,
3323 const unsigned short ClrInstanceID)
3324{
3325 if (!EventPipeEventEnabledThreadCreating())
3326 return ERROR_SUCCESS;
3327
3328 char stackBuffer[32];
3329 char *buffer = stackBuffer;
3330 size_t offset = 0;
3331 size_t size = 32;
3332 bool fixedBuffer = true;
3333
3334 bool success = true;
3335 success &= WriteToBuffer(ID, buffer, offset, size, fixedBuffer);
3336 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3337
3338 if (!success)
3339 {
3340 if (!fixedBuffer)
3341 delete[] buffer;
3342 return ERROR_WRITE_FAULT;
3343 }
3344
3345 EventPipe::WriteEvent(*EventPipeEventThreadCreating, (BYTE *)buffer, (unsigned int)offset);
3346
3347 if (!fixedBuffer)
3348 delete[] buffer;
3349
3350 return ERROR_SUCCESS;
3351}
3352
3353BOOL EventPipeEventEnabledThreadRunning()
3354{
3355 return EventPipeEventThreadRunning->IsEnabled();
3356}
3357
3358extern "C" ULONG EventPipeWriteEventThreadRunning(
3359 const void* ID,
3360 const unsigned short ClrInstanceID)
3361{
3362 if (!EventPipeEventEnabledThreadRunning())
3363 return ERROR_SUCCESS;
3364
3365 char stackBuffer[32];
3366 char *buffer = stackBuffer;
3367 size_t offset = 0;
3368 size_t size = 32;
3369 bool fixedBuffer = true;
3370
3371 bool success = true;
3372 success &= WriteToBuffer(ID, buffer, offset, size, fixedBuffer);
3373 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3374
3375 if (!success)
3376 {
3377 if (!fixedBuffer)
3378 delete[] buffer;
3379 return ERROR_WRITE_FAULT;
3380 }
3381
3382 EventPipe::WriteEvent(*EventPipeEventThreadRunning, (BYTE *)buffer, (unsigned int)offset);
3383
3384 if (!fixedBuffer)
3385 delete[] buffer;
3386
3387 return ERROR_SUCCESS;
3388}
3389
3390BOOL EventPipeEventEnabledExceptionThrown()
3391{
3392 return EventPipeEventExceptionThrown->IsEnabled();
3393}
3394
3395extern "C" ULONG EventPipeWriteEventExceptionThrown()
3396{
3397 if (!EventPipeEventEnabledExceptionThrown())
3398 return ERROR_SUCCESS;
3399 EventPipe::WriteEvent(*EventPipeEventExceptionThrown, (BYTE*) nullptr, 0);
3400
3401 return ERROR_SUCCESS;
3402}
3403
3404BOOL EventPipeEventEnabledExceptionThrown_V1()
3405{
3406 return EventPipeEventExceptionThrown_V1->IsEnabled();
3407}
3408
3409extern "C" ULONG EventPipeWriteEventExceptionThrown_V1(
3410 PCWSTR ExceptionType,
3411 PCWSTR ExceptionMessage,
3412 const void* ExceptionEIP,
3413 const unsigned int ExceptionHRESULT,
3414 const unsigned short ExceptionFlags,
3415 const unsigned short ClrInstanceID)
3416{
3417 if (!EventPipeEventEnabledExceptionThrown_V1())
3418 return ERROR_SUCCESS;
3419
3420 char stackBuffer[144];
3421 char *buffer = stackBuffer;
3422 size_t offset = 0;
3423 size_t size = 144;
3424 bool fixedBuffer = true;
3425
3426 bool success = true;
3427 success &= WriteToBuffer(ExceptionType, buffer, offset, size, fixedBuffer);
3428 success &= WriteToBuffer(ExceptionMessage, buffer, offset, size, fixedBuffer);
3429 success &= WriteToBuffer(ExceptionEIP, buffer, offset, size, fixedBuffer);
3430 success &= WriteToBuffer(ExceptionHRESULT, buffer, offset, size, fixedBuffer);
3431 success &= WriteToBuffer(ExceptionFlags, buffer, offset, size, fixedBuffer);
3432 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3433
3434 if (!success)
3435 {
3436 if (!fixedBuffer)
3437 delete[] buffer;
3438 return ERROR_WRITE_FAULT;
3439 }
3440
3441 EventPipe::WriteEvent(*EventPipeEventExceptionThrown_V1, (BYTE *)buffer, (unsigned int)offset);
3442
3443 if (!fixedBuffer)
3444 delete[] buffer;
3445
3446 return ERROR_SUCCESS;
3447}
3448
3449BOOL EventPipeEventEnabledExceptionCatchStart()
3450{
3451 return EventPipeEventExceptionCatchStart->IsEnabled();
3452}
3453
3454extern "C" ULONG EventPipeWriteEventExceptionCatchStart(
3455 const unsigned __int64 EntryEIP,
3456 const unsigned __int64 MethodID,
3457 PCWSTR MethodName,
3458 const unsigned short ClrInstanceID)
3459{
3460 if (!EventPipeEventEnabledExceptionCatchStart())
3461 return ERROR_SUCCESS;
3462
3463 char stackBuffer[82];
3464 char *buffer = stackBuffer;
3465 size_t offset = 0;
3466 size_t size = 82;
3467 bool fixedBuffer = true;
3468
3469 bool success = true;
3470 success &= WriteToBuffer(EntryEIP, buffer, offset, size, fixedBuffer);
3471 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
3472 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
3473 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3474
3475 if (!success)
3476 {
3477 if (!fixedBuffer)
3478 delete[] buffer;
3479 return ERROR_WRITE_FAULT;
3480 }
3481
3482 EventPipe::WriteEvent(*EventPipeEventExceptionCatchStart, (BYTE *)buffer, (unsigned int)offset);
3483
3484 if (!fixedBuffer)
3485 delete[] buffer;
3486
3487 return ERROR_SUCCESS;
3488}
3489
3490BOOL EventPipeEventEnabledExceptionCatchStop()
3491{
3492 return EventPipeEventExceptionCatchStop->IsEnabled();
3493}
3494
3495extern "C" ULONG EventPipeWriteEventExceptionCatchStop()
3496{
3497 if (!EventPipeEventEnabledExceptionCatchStop())
3498 return ERROR_SUCCESS;
3499 EventPipe::WriteEvent(*EventPipeEventExceptionCatchStop, (BYTE*) nullptr, 0);
3500
3501 return ERROR_SUCCESS;
3502}
3503
3504BOOL EventPipeEventEnabledExceptionFinallyStart()
3505{
3506 return EventPipeEventExceptionFinallyStart->IsEnabled();
3507}
3508
3509extern "C" ULONG EventPipeWriteEventExceptionFinallyStart(
3510 const unsigned __int64 EntryEIP,
3511 const unsigned __int64 MethodID,
3512 PCWSTR MethodName,
3513 const unsigned short ClrInstanceID)
3514{
3515 if (!EventPipeEventEnabledExceptionFinallyStart())
3516 return ERROR_SUCCESS;
3517
3518 char stackBuffer[82];
3519 char *buffer = stackBuffer;
3520 size_t offset = 0;
3521 size_t size = 82;
3522 bool fixedBuffer = true;
3523
3524 bool success = true;
3525 success &= WriteToBuffer(EntryEIP, buffer, offset, size, fixedBuffer);
3526 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
3527 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
3528 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3529
3530 if (!success)
3531 {
3532 if (!fixedBuffer)
3533 delete[] buffer;
3534 return ERROR_WRITE_FAULT;
3535 }
3536
3537 EventPipe::WriteEvent(*EventPipeEventExceptionFinallyStart, (BYTE *)buffer, (unsigned int)offset);
3538
3539 if (!fixedBuffer)
3540 delete[] buffer;
3541
3542 return ERROR_SUCCESS;
3543}
3544
3545BOOL EventPipeEventEnabledExceptionFinallyStop()
3546{
3547 return EventPipeEventExceptionFinallyStop->IsEnabled();
3548}
3549
3550extern "C" ULONG EventPipeWriteEventExceptionFinallyStop()
3551{
3552 if (!EventPipeEventEnabledExceptionFinallyStop())
3553 return ERROR_SUCCESS;
3554 EventPipe::WriteEvent(*EventPipeEventExceptionFinallyStop, (BYTE*) nullptr, 0);
3555
3556 return ERROR_SUCCESS;
3557}
3558
3559BOOL EventPipeEventEnabledExceptionFilterStart()
3560{
3561 return EventPipeEventExceptionFilterStart->IsEnabled();
3562}
3563
3564extern "C" ULONG EventPipeWriteEventExceptionFilterStart(
3565 const unsigned __int64 EntryEIP,
3566 const unsigned __int64 MethodID,
3567 PCWSTR MethodName,
3568 const unsigned short ClrInstanceID)
3569{
3570 if (!EventPipeEventEnabledExceptionFilterStart())
3571 return ERROR_SUCCESS;
3572
3573 char stackBuffer[82];
3574 char *buffer = stackBuffer;
3575 size_t offset = 0;
3576 size_t size = 82;
3577 bool fixedBuffer = true;
3578
3579 bool success = true;
3580 success &= WriteToBuffer(EntryEIP, buffer, offset, size, fixedBuffer);
3581 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
3582 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
3583 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3584
3585 if (!success)
3586 {
3587 if (!fixedBuffer)
3588 delete[] buffer;
3589 return ERROR_WRITE_FAULT;
3590 }
3591
3592 EventPipe::WriteEvent(*EventPipeEventExceptionFilterStart, (BYTE *)buffer, (unsigned int)offset);
3593
3594 if (!fixedBuffer)
3595 delete[] buffer;
3596
3597 return ERROR_SUCCESS;
3598}
3599
3600BOOL EventPipeEventEnabledExceptionFilterStop()
3601{
3602 return EventPipeEventExceptionFilterStop->IsEnabled();
3603}
3604
3605extern "C" ULONG EventPipeWriteEventExceptionFilterStop()
3606{
3607 if (!EventPipeEventEnabledExceptionFilterStop())
3608 return ERROR_SUCCESS;
3609 EventPipe::WriteEvent(*EventPipeEventExceptionFilterStop, (BYTE*) nullptr, 0);
3610
3611 return ERROR_SUCCESS;
3612}
3613
3614BOOL EventPipeEventEnabledExceptionThrownStop()
3615{
3616 return EventPipeEventExceptionThrownStop->IsEnabled();
3617}
3618
3619extern "C" ULONG EventPipeWriteEventExceptionThrownStop()
3620{
3621 if (!EventPipeEventEnabledExceptionThrownStop())
3622 return ERROR_SUCCESS;
3623 EventPipe::WriteEvent(*EventPipeEventExceptionThrownStop, (BYTE*) nullptr, 0);
3624
3625 return ERROR_SUCCESS;
3626}
3627
3628BOOL EventPipeEventEnabledContention()
3629{
3630 return EventPipeEventContention->IsEnabled();
3631}
3632
3633extern "C" ULONG EventPipeWriteEventContention()
3634{
3635 if (!EventPipeEventEnabledContention())
3636 return ERROR_SUCCESS;
3637 EventPipe::WriteEvent(*EventPipeEventContention, (BYTE*) nullptr, 0);
3638
3639 return ERROR_SUCCESS;
3640}
3641
3642BOOL EventPipeEventEnabledContentionStart_V1()
3643{
3644 return EventPipeEventContentionStart_V1->IsEnabled();
3645}
3646
3647extern "C" ULONG EventPipeWriteEventContentionStart_V1(
3648 const unsigned char ContentionFlags,
3649 const unsigned short ClrInstanceID)
3650{
3651 if (!EventPipeEventEnabledContentionStart_V1())
3652 return ERROR_SUCCESS;
3653
3654 char stackBuffer[32];
3655 char *buffer = stackBuffer;
3656 size_t offset = 0;
3657 size_t size = 32;
3658 bool fixedBuffer = true;
3659
3660 bool success = true;
3661 success &= WriteToBuffer(ContentionFlags, buffer, offset, size, fixedBuffer);
3662 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3663
3664 if (!success)
3665 {
3666 if (!fixedBuffer)
3667 delete[] buffer;
3668 return ERROR_WRITE_FAULT;
3669 }
3670
3671 EventPipe::WriteEvent(*EventPipeEventContentionStart_V1, (BYTE *)buffer, (unsigned int)offset);
3672
3673 if (!fixedBuffer)
3674 delete[] buffer;
3675
3676 return ERROR_SUCCESS;
3677}
3678
3679BOOL EventPipeEventEnabledContentionStop()
3680{
3681 return EventPipeEventContentionStop->IsEnabled();
3682}
3683
3684extern "C" ULONG EventPipeWriteEventContentionStop(
3685 const unsigned char ContentionFlags,
3686 const unsigned short ClrInstanceID)
3687{
3688 if (!EventPipeEventEnabledContentionStop())
3689 return ERROR_SUCCESS;
3690
3691 char stackBuffer[32];
3692 char *buffer = stackBuffer;
3693 size_t offset = 0;
3694 size_t size = 32;
3695 bool fixedBuffer = true;
3696
3697 bool success = true;
3698 success &= WriteToBuffer(ContentionFlags, buffer, offset, size, fixedBuffer);
3699 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3700
3701 if (!success)
3702 {
3703 if (!fixedBuffer)
3704 delete[] buffer;
3705 return ERROR_WRITE_FAULT;
3706 }
3707
3708 EventPipe::WriteEvent(*EventPipeEventContentionStop, (BYTE *)buffer, (unsigned int)offset);
3709
3710 if (!fixedBuffer)
3711 delete[] buffer;
3712
3713 return ERROR_SUCCESS;
3714}
3715
3716BOOL EventPipeEventEnabledCLRStackWalk()
3717{
3718 return EventPipeEventCLRStackWalk->IsEnabled();
3719}
3720
3721extern "C" ULONG EventPipeWriteEventCLRStackWalk(
3722 const unsigned short ClrInstanceID,
3723 const unsigned char Reserved1,
3724 const unsigned char Reserved2,
3725 const unsigned int FrameCount,
3726 const void** Stack)
3727{
3728 if (!EventPipeEventEnabledCLRStackWalk())
3729 return ERROR_SUCCESS;
3730
3731 char stackBuffer[32];
3732 char *buffer = stackBuffer;
3733 size_t offset = 0;
3734 size_t size = 32;
3735 bool fixedBuffer = true;
3736
3737 bool success = true;
3738 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3739 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
3740 success &= WriteToBuffer(Reserved2, buffer, offset, size, fixedBuffer);
3741 success &= WriteToBuffer(FrameCount, buffer, offset, size, fixedBuffer);
3742 success &= WriteToBuffer(Stack, buffer, offset, size, fixedBuffer);
3743
3744 if (!success)
3745 {
3746 if (!fixedBuffer)
3747 delete[] buffer;
3748 return ERROR_WRITE_FAULT;
3749 }
3750
3751 EventPipe::WriteEvent(*EventPipeEventCLRStackWalk, (BYTE *)buffer, (unsigned int)offset);
3752
3753 if (!fixedBuffer)
3754 delete[] buffer;
3755
3756 return ERROR_SUCCESS;
3757}
3758
3759BOOL EventPipeEventEnabledAppDomainMemAllocated()
3760{
3761 return EventPipeEventAppDomainMemAllocated->IsEnabled();
3762}
3763
3764extern "C" ULONG EventPipeWriteEventAppDomainMemAllocated(
3765 const unsigned __int64 AppDomainID,
3766 const unsigned __int64 Allocated,
3767 const unsigned short ClrInstanceID)
3768{
3769 if (!EventPipeEventEnabledAppDomainMemAllocated())
3770 return ERROR_SUCCESS;
3771
3772 char stackBuffer[32];
3773 char *buffer = stackBuffer;
3774 size_t offset = 0;
3775 size_t size = 32;
3776 bool fixedBuffer = true;
3777
3778 bool success = true;
3779 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
3780 success &= WriteToBuffer(Allocated, buffer, offset, size, fixedBuffer);
3781 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3782
3783 if (!success)
3784 {
3785 if (!fixedBuffer)
3786 delete[] buffer;
3787 return ERROR_WRITE_FAULT;
3788 }
3789
3790 EventPipe::WriteEvent(*EventPipeEventAppDomainMemAllocated, (BYTE *)buffer, (unsigned int)offset);
3791
3792 if (!fixedBuffer)
3793 delete[] buffer;
3794
3795 return ERROR_SUCCESS;
3796}
3797
3798BOOL EventPipeEventEnabledAppDomainMemSurvived()
3799{
3800 return EventPipeEventAppDomainMemSurvived->IsEnabled();
3801}
3802
3803extern "C" ULONG EventPipeWriteEventAppDomainMemSurvived(
3804 const unsigned __int64 AppDomainID,
3805 const unsigned __int64 Survived,
3806 const unsigned __int64 ProcessSurvived,
3807 const unsigned short ClrInstanceID)
3808{
3809 if (!EventPipeEventEnabledAppDomainMemSurvived())
3810 return ERROR_SUCCESS;
3811
3812 char stackBuffer[32];
3813 char *buffer = stackBuffer;
3814 size_t offset = 0;
3815 size_t size = 32;
3816 bool fixedBuffer = true;
3817
3818 bool success = true;
3819 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
3820 success &= WriteToBuffer(Survived, buffer, offset, size, fixedBuffer);
3821 success &= WriteToBuffer(ProcessSurvived, buffer, offset, size, fixedBuffer);
3822 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3823
3824 if (!success)
3825 {
3826 if (!fixedBuffer)
3827 delete[] buffer;
3828 return ERROR_WRITE_FAULT;
3829 }
3830
3831 EventPipe::WriteEvent(*EventPipeEventAppDomainMemSurvived, (BYTE *)buffer, (unsigned int)offset);
3832
3833 if (!fixedBuffer)
3834 delete[] buffer;
3835
3836 return ERROR_SUCCESS;
3837}
3838
3839BOOL EventPipeEventEnabledThreadCreated()
3840{
3841 return EventPipeEventThreadCreated->IsEnabled();
3842}
3843
3844extern "C" ULONG EventPipeWriteEventThreadCreated(
3845 const unsigned __int64 ManagedThreadID,
3846 const unsigned __int64 AppDomainID,
3847 const unsigned int Flags,
3848 const unsigned int ManagedThreadIndex,
3849 const unsigned int OSThreadID,
3850 const unsigned short ClrInstanceID)
3851{
3852 if (!EventPipeEventEnabledThreadCreated())
3853 return ERROR_SUCCESS;
3854
3855 char stackBuffer[32];
3856 char *buffer = stackBuffer;
3857 size_t offset = 0;
3858 size_t size = 32;
3859 bool fixedBuffer = true;
3860
3861 bool success = true;
3862 success &= WriteToBuffer(ManagedThreadID, buffer, offset, size, fixedBuffer);
3863 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
3864 success &= WriteToBuffer(Flags, buffer, offset, size, fixedBuffer);
3865 success &= WriteToBuffer(ManagedThreadIndex, buffer, offset, size, fixedBuffer);
3866 success &= WriteToBuffer(OSThreadID, buffer, offset, size, fixedBuffer);
3867 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3868
3869 if (!success)
3870 {
3871 if (!fixedBuffer)
3872 delete[] buffer;
3873 return ERROR_WRITE_FAULT;
3874 }
3875
3876 EventPipe::WriteEvent(*EventPipeEventThreadCreated, (BYTE *)buffer, (unsigned int)offset);
3877
3878 if (!fixedBuffer)
3879 delete[] buffer;
3880
3881 return ERROR_SUCCESS;
3882}
3883
3884BOOL EventPipeEventEnabledThreadTerminated()
3885{
3886 return EventPipeEventThreadTerminated->IsEnabled();
3887}
3888
3889extern "C" ULONG EventPipeWriteEventThreadTerminated(
3890 const unsigned __int64 ManagedThreadID,
3891 const unsigned __int64 AppDomainID,
3892 const unsigned short ClrInstanceID)
3893{
3894 if (!EventPipeEventEnabledThreadTerminated())
3895 return ERROR_SUCCESS;
3896
3897 char stackBuffer[32];
3898 char *buffer = stackBuffer;
3899 size_t offset = 0;
3900 size_t size = 32;
3901 bool fixedBuffer = true;
3902
3903 bool success = true;
3904 success &= WriteToBuffer(ManagedThreadID, buffer, offset, size, fixedBuffer);
3905 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
3906 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3907
3908 if (!success)
3909 {
3910 if (!fixedBuffer)
3911 delete[] buffer;
3912 return ERROR_WRITE_FAULT;
3913 }
3914
3915 EventPipe::WriteEvent(*EventPipeEventThreadTerminated, (BYTE *)buffer, (unsigned int)offset);
3916
3917 if (!fixedBuffer)
3918 delete[] buffer;
3919
3920 return ERROR_SUCCESS;
3921}
3922
3923BOOL EventPipeEventEnabledThreadDomainEnter()
3924{
3925 return EventPipeEventThreadDomainEnter->IsEnabled();
3926}
3927
3928extern "C" ULONG EventPipeWriteEventThreadDomainEnter(
3929 const unsigned __int64 ManagedThreadID,
3930 const unsigned __int64 AppDomainID,
3931 const unsigned short ClrInstanceID)
3932{
3933 if (!EventPipeEventEnabledThreadDomainEnter())
3934 return ERROR_SUCCESS;
3935
3936 char stackBuffer[32];
3937 char *buffer = stackBuffer;
3938 size_t offset = 0;
3939 size_t size = 32;
3940 bool fixedBuffer = true;
3941
3942 bool success = true;
3943 success &= WriteToBuffer(ManagedThreadID, buffer, offset, size, fixedBuffer);
3944 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
3945 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3946
3947 if (!success)
3948 {
3949 if (!fixedBuffer)
3950 delete[] buffer;
3951 return ERROR_WRITE_FAULT;
3952 }
3953
3954 EventPipe::WriteEvent(*EventPipeEventThreadDomainEnter, (BYTE *)buffer, (unsigned int)offset);
3955
3956 if (!fixedBuffer)
3957 delete[] buffer;
3958
3959 return ERROR_SUCCESS;
3960}
3961
3962BOOL EventPipeEventEnabledILStubGenerated()
3963{
3964 return EventPipeEventILStubGenerated->IsEnabled();
3965}
3966
3967extern "C" ULONG EventPipeWriteEventILStubGenerated(
3968 const unsigned short ClrInstanceID,
3969 const unsigned __int64 ModuleID,
3970 const unsigned __int64 StubMethodID,
3971 const unsigned int StubFlags,
3972 const unsigned int ManagedInteropMethodToken,
3973 PCWSTR ManagedInteropMethodNamespace,
3974 PCWSTR ManagedInteropMethodName,
3975 PCWSTR ManagedInteropMethodSignature,
3976 PCWSTR NativeMethodSignature,
3977 PCWSTR StubMethodSignature,
3978 PCWSTR StubMethodILCode)
3979{
3980 if (!EventPipeEventEnabledILStubGenerated())
3981 return ERROR_SUCCESS;
3982
3983 char stackBuffer[410];
3984 char *buffer = stackBuffer;
3985 size_t offset = 0;
3986 size_t size = 410;
3987 bool fixedBuffer = true;
3988
3989 bool success = true;
3990 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
3991 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
3992 success &= WriteToBuffer(StubMethodID, buffer, offset, size, fixedBuffer);
3993 success &= WriteToBuffer(StubFlags, buffer, offset, size, fixedBuffer);
3994 success &= WriteToBuffer(ManagedInteropMethodToken, buffer, offset, size, fixedBuffer);
3995 success &= WriteToBuffer(ManagedInteropMethodNamespace, buffer, offset, size, fixedBuffer);
3996 success &= WriteToBuffer(ManagedInteropMethodName, buffer, offset, size, fixedBuffer);
3997 success &= WriteToBuffer(ManagedInteropMethodSignature, buffer, offset, size, fixedBuffer);
3998 success &= WriteToBuffer(NativeMethodSignature, buffer, offset, size, fixedBuffer);
3999 success &= WriteToBuffer(StubMethodSignature, buffer, offset, size, fixedBuffer);
4000 success &= WriteToBuffer(StubMethodILCode, buffer, offset, size, fixedBuffer);
4001
4002 if (!success)
4003 {
4004 if (!fixedBuffer)
4005 delete[] buffer;
4006 return ERROR_WRITE_FAULT;
4007 }
4008
4009 EventPipe::WriteEvent(*EventPipeEventILStubGenerated, (BYTE *)buffer, (unsigned int)offset);
4010
4011 if (!fixedBuffer)
4012 delete[] buffer;
4013
4014 return ERROR_SUCCESS;
4015}
4016
4017BOOL EventPipeEventEnabledILStubCacheHit()
4018{
4019 return EventPipeEventILStubCacheHit->IsEnabled();
4020}
4021
4022extern "C" ULONG EventPipeWriteEventILStubCacheHit(
4023 const unsigned short ClrInstanceID,
4024 const unsigned __int64 ModuleID,
4025 const unsigned __int64 StubMethodID,
4026 const unsigned int ManagedInteropMethodToken,
4027 PCWSTR ManagedInteropMethodNamespace,
4028 PCWSTR ManagedInteropMethodName,
4029 PCWSTR ManagedInteropMethodSignature)
4030{
4031 if (!EventPipeEventEnabledILStubCacheHit())
4032 return ERROR_SUCCESS;
4033
4034 char stackBuffer[214];
4035 char *buffer = stackBuffer;
4036 size_t offset = 0;
4037 size_t size = 214;
4038 bool fixedBuffer = true;
4039
4040 bool success = true;
4041 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4042 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4043 success &= WriteToBuffer(StubMethodID, buffer, offset, size, fixedBuffer);
4044 success &= WriteToBuffer(ManagedInteropMethodToken, buffer, offset, size, fixedBuffer);
4045 success &= WriteToBuffer(ManagedInteropMethodNamespace, buffer, offset, size, fixedBuffer);
4046 success &= WriteToBuffer(ManagedInteropMethodName, buffer, offset, size, fixedBuffer);
4047 success &= WriteToBuffer(ManagedInteropMethodSignature, buffer, offset, size, fixedBuffer);
4048
4049 if (!success)
4050 {
4051 if (!fixedBuffer)
4052 delete[] buffer;
4053 return ERROR_WRITE_FAULT;
4054 }
4055
4056 EventPipe::WriteEvent(*EventPipeEventILStubCacheHit, (BYTE *)buffer, (unsigned int)offset);
4057
4058 if (!fixedBuffer)
4059 delete[] buffer;
4060
4061 return ERROR_SUCCESS;
4062}
4063
4064BOOL EventPipeEventEnabledDCStartCompleteV2()
4065{
4066 return EventPipeEventDCStartCompleteV2->IsEnabled();
4067}
4068
4069extern "C" ULONG EventPipeWriteEventDCStartCompleteV2()
4070{
4071 if (!EventPipeEventEnabledDCStartCompleteV2())
4072 return ERROR_SUCCESS;
4073 EventPipe::WriteEvent(*EventPipeEventDCStartCompleteV2, (BYTE*) nullptr, 0);
4074
4075 return ERROR_SUCCESS;
4076}
4077
4078BOOL EventPipeEventEnabledDCEndCompleteV2()
4079{
4080 return EventPipeEventDCEndCompleteV2->IsEnabled();
4081}
4082
4083extern "C" ULONG EventPipeWriteEventDCEndCompleteV2()
4084{
4085 if (!EventPipeEventEnabledDCEndCompleteV2())
4086 return ERROR_SUCCESS;
4087 EventPipe::WriteEvent(*EventPipeEventDCEndCompleteV2, (BYTE*) nullptr, 0);
4088
4089 return ERROR_SUCCESS;
4090}
4091
4092BOOL EventPipeEventEnabledMethodDCStartV2()
4093{
4094 return EventPipeEventMethodDCStartV2->IsEnabled();
4095}
4096
4097extern "C" ULONG EventPipeWriteEventMethodDCStartV2(
4098 const unsigned __int64 MethodID,
4099 const unsigned __int64 ModuleID,
4100 const unsigned __int64 MethodStartAddress,
4101 const unsigned int MethodSize,
4102 const unsigned int MethodToken,
4103 const unsigned int MethodFlags)
4104{
4105 if (!EventPipeEventEnabledMethodDCStartV2())
4106 return ERROR_SUCCESS;
4107
4108 char stackBuffer[36];
4109 char *buffer = stackBuffer;
4110 size_t offset = 0;
4111 size_t size = 36;
4112 bool fixedBuffer = true;
4113
4114 bool success = true;
4115 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4116 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4117 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4118 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4119 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4120 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4121
4122 if (!success)
4123 {
4124 if (!fixedBuffer)
4125 delete[] buffer;
4126 return ERROR_WRITE_FAULT;
4127 }
4128
4129 EventPipe::WriteEvent(*EventPipeEventMethodDCStartV2, (BYTE *)buffer, (unsigned int)offset);
4130
4131 if (!fixedBuffer)
4132 delete[] buffer;
4133
4134 return ERROR_SUCCESS;
4135}
4136
4137BOOL EventPipeEventEnabledMethodDCEndV2()
4138{
4139 return EventPipeEventMethodDCEndV2->IsEnabled();
4140}
4141
4142extern "C" ULONG EventPipeWriteEventMethodDCEndV2(
4143 const unsigned __int64 MethodID,
4144 const unsigned __int64 ModuleID,
4145 const unsigned __int64 MethodStartAddress,
4146 const unsigned int MethodSize,
4147 const unsigned int MethodToken,
4148 const unsigned int MethodFlags)
4149{
4150 if (!EventPipeEventEnabledMethodDCEndV2())
4151 return ERROR_SUCCESS;
4152
4153 char stackBuffer[36];
4154 char *buffer = stackBuffer;
4155 size_t offset = 0;
4156 size_t size = 36;
4157 bool fixedBuffer = true;
4158
4159 bool success = true;
4160 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4161 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4162 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4163 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4164 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4165 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4166
4167 if (!success)
4168 {
4169 if (!fixedBuffer)
4170 delete[] buffer;
4171 return ERROR_WRITE_FAULT;
4172 }
4173
4174 EventPipe::WriteEvent(*EventPipeEventMethodDCEndV2, (BYTE *)buffer, (unsigned int)offset);
4175
4176 if (!fixedBuffer)
4177 delete[] buffer;
4178
4179 return ERROR_SUCCESS;
4180}
4181
4182BOOL EventPipeEventEnabledMethodDCStartVerboseV2()
4183{
4184 return EventPipeEventMethodDCStartVerboseV2->IsEnabled();
4185}
4186
4187extern "C" ULONG EventPipeWriteEventMethodDCStartVerboseV2(
4188 const unsigned __int64 MethodID,
4189 const unsigned __int64 ModuleID,
4190 const unsigned __int64 MethodStartAddress,
4191 const unsigned int MethodSize,
4192 const unsigned int MethodToken,
4193 const unsigned int MethodFlags,
4194 PCWSTR MethodNamespace,
4195 PCWSTR MethodName,
4196 PCWSTR MethodSignature)
4197{
4198 if (!EventPipeEventEnabledMethodDCStartVerboseV2())
4199 return ERROR_SUCCESS;
4200
4201 char stackBuffer[228];
4202 char *buffer = stackBuffer;
4203 size_t offset = 0;
4204 size_t size = 228;
4205 bool fixedBuffer = true;
4206
4207 bool success = true;
4208 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4209 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4210 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4211 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4212 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4213 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4214 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4215 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4216 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4217
4218 if (!success)
4219 {
4220 if (!fixedBuffer)
4221 delete[] buffer;
4222 return ERROR_WRITE_FAULT;
4223 }
4224
4225 EventPipe::WriteEvent(*EventPipeEventMethodDCStartVerboseV2, (BYTE *)buffer, (unsigned int)offset);
4226
4227 if (!fixedBuffer)
4228 delete[] buffer;
4229
4230 return ERROR_SUCCESS;
4231}
4232
4233BOOL EventPipeEventEnabledMethodDCEndVerboseV2()
4234{
4235 return EventPipeEventMethodDCEndVerboseV2->IsEnabled();
4236}
4237
4238extern "C" ULONG EventPipeWriteEventMethodDCEndVerboseV2(
4239 const unsigned __int64 MethodID,
4240 const unsigned __int64 ModuleID,
4241 const unsigned __int64 MethodStartAddress,
4242 const unsigned int MethodSize,
4243 const unsigned int MethodToken,
4244 const unsigned int MethodFlags,
4245 PCWSTR MethodNamespace,
4246 PCWSTR MethodName,
4247 PCWSTR MethodSignature)
4248{
4249 if (!EventPipeEventEnabledMethodDCEndVerboseV2())
4250 return ERROR_SUCCESS;
4251
4252 char stackBuffer[228];
4253 char *buffer = stackBuffer;
4254 size_t offset = 0;
4255 size_t size = 228;
4256 bool fixedBuffer = true;
4257
4258 bool success = true;
4259 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4260 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4261 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4262 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4263 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4264 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4265 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4266 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4267 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4268
4269 if (!success)
4270 {
4271 if (!fixedBuffer)
4272 delete[] buffer;
4273 return ERROR_WRITE_FAULT;
4274 }
4275
4276 EventPipe::WriteEvent(*EventPipeEventMethodDCEndVerboseV2, (BYTE *)buffer, (unsigned int)offset);
4277
4278 if (!fixedBuffer)
4279 delete[] buffer;
4280
4281 return ERROR_SUCCESS;
4282}
4283
4284BOOL EventPipeEventEnabledMethodLoad()
4285{
4286 return EventPipeEventMethodLoad->IsEnabled();
4287}
4288
4289extern "C" ULONG EventPipeWriteEventMethodLoad(
4290 const unsigned __int64 MethodID,
4291 const unsigned __int64 ModuleID,
4292 const unsigned __int64 MethodStartAddress,
4293 const unsigned int MethodSize,
4294 const unsigned int MethodToken,
4295 const unsigned int MethodFlags)
4296{
4297 if (!EventPipeEventEnabledMethodLoad())
4298 return ERROR_SUCCESS;
4299
4300 char stackBuffer[36];
4301 char *buffer = stackBuffer;
4302 size_t offset = 0;
4303 size_t size = 36;
4304 bool fixedBuffer = true;
4305
4306 bool success = true;
4307 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4308 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4309 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4310 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4311 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4312 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4313
4314 if (!success)
4315 {
4316 if (!fixedBuffer)
4317 delete[] buffer;
4318 return ERROR_WRITE_FAULT;
4319 }
4320
4321 EventPipe::WriteEvent(*EventPipeEventMethodLoad, (BYTE *)buffer, (unsigned int)offset);
4322
4323 if (!fixedBuffer)
4324 delete[] buffer;
4325
4326 return ERROR_SUCCESS;
4327}
4328
4329BOOL EventPipeEventEnabledMethodLoad_V1()
4330{
4331 return EventPipeEventMethodLoad_V1->IsEnabled();
4332}
4333
4334extern "C" ULONG EventPipeWriteEventMethodLoad_V1(
4335 const unsigned __int64 MethodID,
4336 const unsigned __int64 ModuleID,
4337 const unsigned __int64 MethodStartAddress,
4338 const unsigned int MethodSize,
4339 const unsigned int MethodToken,
4340 const unsigned int MethodFlags,
4341 const unsigned short ClrInstanceID)
4342{
4343 if (!EventPipeEventEnabledMethodLoad_V1())
4344 return ERROR_SUCCESS;
4345
4346 char stackBuffer[38];
4347 char *buffer = stackBuffer;
4348 size_t offset = 0;
4349 size_t size = 38;
4350 bool fixedBuffer = true;
4351
4352 bool success = true;
4353 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4354 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4355 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4356 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4357 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4358 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4359 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4360
4361 if (!success)
4362 {
4363 if (!fixedBuffer)
4364 delete[] buffer;
4365 return ERROR_WRITE_FAULT;
4366 }
4367
4368 EventPipe::WriteEvent(*EventPipeEventMethodLoad_V1, (BYTE *)buffer, (unsigned int)offset);
4369
4370 if (!fixedBuffer)
4371 delete[] buffer;
4372
4373 return ERROR_SUCCESS;
4374}
4375
4376BOOL EventPipeEventEnabledMethodLoad_V2()
4377{
4378 return EventPipeEventMethodLoad_V2->IsEnabled();
4379}
4380
4381extern "C" ULONG EventPipeWriteEventMethodLoad_V2(
4382 const unsigned __int64 MethodID,
4383 const unsigned __int64 ModuleID,
4384 const unsigned __int64 MethodStartAddress,
4385 const unsigned int MethodSize,
4386 const unsigned int MethodToken,
4387 const unsigned int MethodFlags,
4388 const unsigned short ClrInstanceID,
4389 const unsigned __int64 ReJITID)
4390{
4391 if (!EventPipeEventEnabledMethodLoad_V2())
4392 return ERROR_SUCCESS;
4393
4394 char stackBuffer[46];
4395 char *buffer = stackBuffer;
4396 size_t offset = 0;
4397 size_t size = 46;
4398 bool fixedBuffer = true;
4399
4400 bool success = true;
4401 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4402 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4403 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4404 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4405 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4406 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4407 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4408 success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);
4409
4410 if (!success)
4411 {
4412 if (!fixedBuffer)
4413 delete[] buffer;
4414 return ERROR_WRITE_FAULT;
4415 }
4416
4417 EventPipe::WriteEvent(*EventPipeEventMethodLoad_V2, (BYTE *)buffer, (unsigned int)offset);
4418
4419 if (!fixedBuffer)
4420 delete[] buffer;
4421
4422 return ERROR_SUCCESS;
4423}
4424
4425BOOL EventPipeEventEnabledMethodUnload()
4426{
4427 return EventPipeEventMethodUnload->IsEnabled();
4428}
4429
4430extern "C" ULONG EventPipeWriteEventMethodUnload(
4431 const unsigned __int64 MethodID,
4432 const unsigned __int64 ModuleID,
4433 const unsigned __int64 MethodStartAddress,
4434 const unsigned int MethodSize,
4435 const unsigned int MethodToken,
4436 const unsigned int MethodFlags)
4437{
4438 if (!EventPipeEventEnabledMethodUnload())
4439 return ERROR_SUCCESS;
4440
4441 char stackBuffer[36];
4442 char *buffer = stackBuffer;
4443 size_t offset = 0;
4444 size_t size = 36;
4445 bool fixedBuffer = true;
4446
4447 bool success = true;
4448 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4449 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4450 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4451 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4452 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4453 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4454
4455 if (!success)
4456 {
4457 if (!fixedBuffer)
4458 delete[] buffer;
4459 return ERROR_WRITE_FAULT;
4460 }
4461
4462 EventPipe::WriteEvent(*EventPipeEventMethodUnload, (BYTE *)buffer, (unsigned int)offset);
4463
4464 if (!fixedBuffer)
4465 delete[] buffer;
4466
4467 return ERROR_SUCCESS;
4468}
4469
4470BOOL EventPipeEventEnabledMethodUnload_V1()
4471{
4472 return EventPipeEventMethodUnload_V1->IsEnabled();
4473}
4474
4475extern "C" ULONG EventPipeWriteEventMethodUnload_V1(
4476 const unsigned __int64 MethodID,
4477 const unsigned __int64 ModuleID,
4478 const unsigned __int64 MethodStartAddress,
4479 const unsigned int MethodSize,
4480 const unsigned int MethodToken,
4481 const unsigned int MethodFlags,
4482 const unsigned short ClrInstanceID)
4483{
4484 if (!EventPipeEventEnabledMethodUnload_V1())
4485 return ERROR_SUCCESS;
4486
4487 char stackBuffer[38];
4488 char *buffer = stackBuffer;
4489 size_t offset = 0;
4490 size_t size = 38;
4491 bool fixedBuffer = true;
4492
4493 bool success = true;
4494 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4495 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4496 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4497 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4498 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4499 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4500 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4501
4502 if (!success)
4503 {
4504 if (!fixedBuffer)
4505 delete[] buffer;
4506 return ERROR_WRITE_FAULT;
4507 }
4508
4509 EventPipe::WriteEvent(*EventPipeEventMethodUnload_V1, (BYTE *)buffer, (unsigned int)offset);
4510
4511 if (!fixedBuffer)
4512 delete[] buffer;
4513
4514 return ERROR_SUCCESS;
4515}
4516
4517BOOL EventPipeEventEnabledMethodUnload_V2()
4518{
4519 return EventPipeEventMethodUnload_V2->IsEnabled();
4520}
4521
4522extern "C" ULONG EventPipeWriteEventMethodUnload_V2(
4523 const unsigned __int64 MethodID,
4524 const unsigned __int64 ModuleID,
4525 const unsigned __int64 MethodStartAddress,
4526 const unsigned int MethodSize,
4527 const unsigned int MethodToken,
4528 const unsigned int MethodFlags,
4529 const unsigned short ClrInstanceID,
4530 const unsigned __int64 ReJITID)
4531{
4532 if (!EventPipeEventEnabledMethodUnload_V2())
4533 return ERROR_SUCCESS;
4534
4535 char stackBuffer[46];
4536 char *buffer = stackBuffer;
4537 size_t offset = 0;
4538 size_t size = 46;
4539 bool fixedBuffer = true;
4540
4541 bool success = true;
4542 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4543 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4544 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4545 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4546 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4547 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4548 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4549 success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);
4550
4551 if (!success)
4552 {
4553 if (!fixedBuffer)
4554 delete[] buffer;
4555 return ERROR_WRITE_FAULT;
4556 }
4557
4558 EventPipe::WriteEvent(*EventPipeEventMethodUnload_V2, (BYTE *)buffer, (unsigned int)offset);
4559
4560 if (!fixedBuffer)
4561 delete[] buffer;
4562
4563 return ERROR_SUCCESS;
4564}
4565
4566BOOL EventPipeEventEnabledMethodLoadVerbose()
4567{
4568 return EventPipeEventMethodLoadVerbose->IsEnabled();
4569}
4570
4571extern "C" ULONG EventPipeWriteEventMethodLoadVerbose(
4572 const unsigned __int64 MethodID,
4573 const unsigned __int64 ModuleID,
4574 const unsigned __int64 MethodStartAddress,
4575 const unsigned int MethodSize,
4576 const unsigned int MethodToken,
4577 const unsigned int MethodFlags,
4578 PCWSTR MethodNamespace,
4579 PCWSTR MethodName,
4580 PCWSTR MethodSignature)
4581{
4582 if (!EventPipeEventEnabledMethodLoadVerbose())
4583 return ERROR_SUCCESS;
4584
4585 char stackBuffer[228];
4586 char *buffer = stackBuffer;
4587 size_t offset = 0;
4588 size_t size = 228;
4589 bool fixedBuffer = true;
4590
4591 bool success = true;
4592 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4593 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4594 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4595 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4596 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4597 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4598 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4599 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4600 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4601
4602 if (!success)
4603 {
4604 if (!fixedBuffer)
4605 delete[] buffer;
4606 return ERROR_WRITE_FAULT;
4607 }
4608
4609 EventPipe::WriteEvent(*EventPipeEventMethodLoadVerbose, (BYTE *)buffer, (unsigned int)offset);
4610
4611 if (!fixedBuffer)
4612 delete[] buffer;
4613
4614 return ERROR_SUCCESS;
4615}
4616
4617BOOL EventPipeEventEnabledMethodLoadVerbose_V1()
4618{
4619 return EventPipeEventMethodLoadVerbose_V1->IsEnabled();
4620}
4621
4622extern "C" ULONG EventPipeWriteEventMethodLoadVerbose_V1(
4623 const unsigned __int64 MethodID,
4624 const unsigned __int64 ModuleID,
4625 const unsigned __int64 MethodStartAddress,
4626 const unsigned int MethodSize,
4627 const unsigned int MethodToken,
4628 const unsigned int MethodFlags,
4629 PCWSTR MethodNamespace,
4630 PCWSTR MethodName,
4631 PCWSTR MethodSignature,
4632 const unsigned short ClrInstanceID)
4633{
4634 if (!EventPipeEventEnabledMethodLoadVerbose_V1())
4635 return ERROR_SUCCESS;
4636
4637 char stackBuffer[230];
4638 char *buffer = stackBuffer;
4639 size_t offset = 0;
4640 size_t size = 230;
4641 bool fixedBuffer = true;
4642
4643 bool success = true;
4644 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4645 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4646 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4647 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4648 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4649 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4650 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4651 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4652 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4653 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4654
4655 if (!success)
4656 {
4657 if (!fixedBuffer)
4658 delete[] buffer;
4659 return ERROR_WRITE_FAULT;
4660 }
4661
4662 EventPipe::WriteEvent(*EventPipeEventMethodLoadVerbose_V1, (BYTE *)buffer, (unsigned int)offset);
4663
4664 if (!fixedBuffer)
4665 delete[] buffer;
4666
4667 return ERROR_SUCCESS;
4668}
4669
4670BOOL EventPipeEventEnabledMethodLoadVerbose_V2()
4671{
4672 return EventPipeEventMethodLoadVerbose_V2->IsEnabled();
4673}
4674
4675extern "C" ULONG EventPipeWriteEventMethodLoadVerbose_V2(
4676 const unsigned __int64 MethodID,
4677 const unsigned __int64 ModuleID,
4678 const unsigned __int64 MethodStartAddress,
4679 const unsigned int MethodSize,
4680 const unsigned int MethodToken,
4681 const unsigned int MethodFlags,
4682 PCWSTR MethodNamespace,
4683 PCWSTR MethodName,
4684 PCWSTR MethodSignature,
4685 const unsigned short ClrInstanceID,
4686 const unsigned __int64 ReJITID)
4687{
4688 if (!EventPipeEventEnabledMethodLoadVerbose_V2())
4689 return ERROR_SUCCESS;
4690
4691 char stackBuffer[238];
4692 char *buffer = stackBuffer;
4693 size_t offset = 0;
4694 size_t size = 238;
4695 bool fixedBuffer = true;
4696
4697 bool success = true;
4698 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4699 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4700 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4701 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4702 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4703 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4704 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4705 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4706 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4707 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4708 success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);
4709
4710 if (!success)
4711 {
4712 if (!fixedBuffer)
4713 delete[] buffer;
4714 return ERROR_WRITE_FAULT;
4715 }
4716
4717 EventPipe::WriteEvent(*EventPipeEventMethodLoadVerbose_V2, (BYTE *)buffer, (unsigned int)offset);
4718
4719 if (!fixedBuffer)
4720 delete[] buffer;
4721
4722 return ERROR_SUCCESS;
4723}
4724
4725BOOL EventPipeEventEnabledMethodUnloadVerbose()
4726{
4727 return EventPipeEventMethodUnloadVerbose->IsEnabled();
4728}
4729
4730extern "C" ULONG EventPipeWriteEventMethodUnloadVerbose(
4731 const unsigned __int64 MethodID,
4732 const unsigned __int64 ModuleID,
4733 const unsigned __int64 MethodStartAddress,
4734 const unsigned int MethodSize,
4735 const unsigned int MethodToken,
4736 const unsigned int MethodFlags,
4737 PCWSTR MethodNamespace,
4738 PCWSTR MethodName,
4739 PCWSTR MethodSignature)
4740{
4741 if (!EventPipeEventEnabledMethodUnloadVerbose())
4742 return ERROR_SUCCESS;
4743
4744 char stackBuffer[228];
4745 char *buffer = stackBuffer;
4746 size_t offset = 0;
4747 size_t size = 228;
4748 bool fixedBuffer = true;
4749
4750 bool success = true;
4751 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4752 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4753 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4754 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4755 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4756 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4757 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4758 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4759 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4760
4761 if (!success)
4762 {
4763 if (!fixedBuffer)
4764 delete[] buffer;
4765 return ERROR_WRITE_FAULT;
4766 }
4767
4768 EventPipe::WriteEvent(*EventPipeEventMethodUnloadVerbose, (BYTE *)buffer, (unsigned int)offset);
4769
4770 if (!fixedBuffer)
4771 delete[] buffer;
4772
4773 return ERROR_SUCCESS;
4774}
4775
4776BOOL EventPipeEventEnabledMethodUnloadVerbose_V1()
4777{
4778 return EventPipeEventMethodUnloadVerbose_V1->IsEnabled();
4779}
4780
4781extern "C" ULONG EventPipeWriteEventMethodUnloadVerbose_V1(
4782 const unsigned __int64 MethodID,
4783 const unsigned __int64 ModuleID,
4784 const unsigned __int64 MethodStartAddress,
4785 const unsigned int MethodSize,
4786 const unsigned int MethodToken,
4787 const unsigned int MethodFlags,
4788 PCWSTR MethodNamespace,
4789 PCWSTR MethodName,
4790 PCWSTR MethodSignature,
4791 const unsigned short ClrInstanceID)
4792{
4793 if (!EventPipeEventEnabledMethodUnloadVerbose_V1())
4794 return ERROR_SUCCESS;
4795
4796 char stackBuffer[230];
4797 char *buffer = stackBuffer;
4798 size_t offset = 0;
4799 size_t size = 230;
4800 bool fixedBuffer = true;
4801
4802 bool success = true;
4803 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4804 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4805 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4806 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4807 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4808 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4809 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4810 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4811 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4812 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4813
4814 if (!success)
4815 {
4816 if (!fixedBuffer)
4817 delete[] buffer;
4818 return ERROR_WRITE_FAULT;
4819 }
4820
4821 EventPipe::WriteEvent(*EventPipeEventMethodUnloadVerbose_V1, (BYTE *)buffer, (unsigned int)offset);
4822
4823 if (!fixedBuffer)
4824 delete[] buffer;
4825
4826 return ERROR_SUCCESS;
4827}
4828
4829BOOL EventPipeEventEnabledMethodUnloadVerbose_V2()
4830{
4831 return EventPipeEventMethodUnloadVerbose_V2->IsEnabled();
4832}
4833
4834extern "C" ULONG EventPipeWriteEventMethodUnloadVerbose_V2(
4835 const unsigned __int64 MethodID,
4836 const unsigned __int64 ModuleID,
4837 const unsigned __int64 MethodStartAddress,
4838 const unsigned int MethodSize,
4839 const unsigned int MethodToken,
4840 const unsigned int MethodFlags,
4841 PCWSTR MethodNamespace,
4842 PCWSTR MethodName,
4843 PCWSTR MethodSignature,
4844 const unsigned short ClrInstanceID,
4845 const unsigned __int64 ReJITID)
4846{
4847 if (!EventPipeEventEnabledMethodUnloadVerbose_V2())
4848 return ERROR_SUCCESS;
4849
4850 char stackBuffer[238];
4851 char *buffer = stackBuffer;
4852 size_t offset = 0;
4853 size_t size = 238;
4854 bool fixedBuffer = true;
4855
4856 bool success = true;
4857 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4858 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4859 success &= WriteToBuffer(MethodStartAddress, buffer, offset, size, fixedBuffer);
4860 success &= WriteToBuffer(MethodSize, buffer, offset, size, fixedBuffer);
4861 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4862 success &= WriteToBuffer(MethodFlags, buffer, offset, size, fixedBuffer);
4863 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4864 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4865 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4866 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4867 success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);
4868
4869 if (!success)
4870 {
4871 if (!fixedBuffer)
4872 delete[] buffer;
4873 return ERROR_WRITE_FAULT;
4874 }
4875
4876 EventPipe::WriteEvent(*EventPipeEventMethodUnloadVerbose_V2, (BYTE *)buffer, (unsigned int)offset);
4877
4878 if (!fixedBuffer)
4879 delete[] buffer;
4880
4881 return ERROR_SUCCESS;
4882}
4883
4884BOOL EventPipeEventEnabledMethodJittingStarted()
4885{
4886 return EventPipeEventMethodJittingStarted->IsEnabled();
4887}
4888
4889extern "C" ULONG EventPipeWriteEventMethodJittingStarted(
4890 const unsigned __int64 MethodID,
4891 const unsigned __int64 ModuleID,
4892 const unsigned int MethodToken,
4893 const unsigned int MethodILSize,
4894 PCWSTR MethodNamespace,
4895 PCWSTR MethodName,
4896 PCWSTR MethodSignature)
4897{
4898 if (!EventPipeEventEnabledMethodJittingStarted())
4899 return ERROR_SUCCESS;
4900
4901 char stackBuffer[216];
4902 char *buffer = stackBuffer;
4903 size_t offset = 0;
4904 size_t size = 216;
4905 bool fixedBuffer = true;
4906
4907 bool success = true;
4908 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4909 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4910 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4911 success &= WriteToBuffer(MethodILSize, buffer, offset, size, fixedBuffer);
4912 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4913 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4914 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4915
4916 if (!success)
4917 {
4918 if (!fixedBuffer)
4919 delete[] buffer;
4920 return ERROR_WRITE_FAULT;
4921 }
4922
4923 EventPipe::WriteEvent(*EventPipeEventMethodJittingStarted, (BYTE *)buffer, (unsigned int)offset);
4924
4925 if (!fixedBuffer)
4926 delete[] buffer;
4927
4928 return ERROR_SUCCESS;
4929}
4930
4931BOOL EventPipeEventEnabledMethodJittingStarted_V1()
4932{
4933 return EventPipeEventMethodJittingStarted_V1->IsEnabled();
4934}
4935
4936extern "C" ULONG EventPipeWriteEventMethodJittingStarted_V1(
4937 const unsigned __int64 MethodID,
4938 const unsigned __int64 ModuleID,
4939 const unsigned int MethodToken,
4940 const unsigned int MethodILSize,
4941 PCWSTR MethodNamespace,
4942 PCWSTR MethodName,
4943 PCWSTR MethodSignature,
4944 const unsigned short ClrInstanceID)
4945{
4946 if (!EventPipeEventEnabledMethodJittingStarted_V1())
4947 return ERROR_SUCCESS;
4948
4949 char stackBuffer[218];
4950 char *buffer = stackBuffer;
4951 size_t offset = 0;
4952 size_t size = 218;
4953 bool fixedBuffer = true;
4954
4955 bool success = true;
4956 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
4957 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
4958 success &= WriteToBuffer(MethodToken, buffer, offset, size, fixedBuffer);
4959 success &= WriteToBuffer(MethodILSize, buffer, offset, size, fixedBuffer);
4960 success &= WriteToBuffer(MethodNamespace, buffer, offset, size, fixedBuffer);
4961 success &= WriteToBuffer(MethodName, buffer, offset, size, fixedBuffer);
4962 success &= WriteToBuffer(MethodSignature, buffer, offset, size, fixedBuffer);
4963 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
4964
4965 if (!success)
4966 {
4967 if (!fixedBuffer)
4968 delete[] buffer;
4969 return ERROR_WRITE_FAULT;
4970 }
4971
4972 EventPipe::WriteEvent(*EventPipeEventMethodJittingStarted_V1, (BYTE *)buffer, (unsigned int)offset);
4973
4974 if (!fixedBuffer)
4975 delete[] buffer;
4976
4977 return ERROR_SUCCESS;
4978}
4979
4980BOOL EventPipeEventEnabledMethodJitInliningSucceeded()
4981{
4982 return EventPipeEventMethodJitInliningSucceeded->IsEnabled();
4983}
4984
4985extern "C" ULONG EventPipeWriteEventMethodJitInliningSucceeded(
4986 PCWSTR MethodBeingCompiledNamespace,
4987 PCWSTR MethodBeingCompiledName,
4988 PCWSTR MethodBeingCompiledNameSignature,
4989 PCWSTR InlinerNamespace,
4990 PCWSTR InlinerName,
4991 PCWSTR InlinerNameSignature,
4992 PCWSTR InlineeNamespace,
4993 PCWSTR InlineeName,
4994 PCWSTR InlineeNameSignature,
4995 const unsigned short ClrInstanceID)
4996{
4997 if (!EventPipeEventEnabledMethodJitInliningSucceeded())
4998 return ERROR_SUCCESS;
4999
5000 char stackBuffer[578];
5001 char *buffer = stackBuffer;
5002 size_t offset = 0;
5003 size_t size = 578;
5004 bool fixedBuffer = true;
5005
5006 bool success = true;
5007 success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
5008 success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
5009 success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
5010 success &= WriteToBuffer(InlinerNamespace, buffer, offset, size, fixedBuffer);
5011 success &= WriteToBuffer(InlinerName, buffer, offset, size, fixedBuffer);
5012 success &= WriteToBuffer(InlinerNameSignature, buffer, offset, size, fixedBuffer);
5013 success &= WriteToBuffer(InlineeNamespace, buffer, offset, size, fixedBuffer);
5014 success &= WriteToBuffer(InlineeName, buffer, offset, size, fixedBuffer);
5015 success &= WriteToBuffer(InlineeNameSignature, buffer, offset, size, fixedBuffer);
5016 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5017
5018 if (!success)
5019 {
5020 if (!fixedBuffer)
5021 delete[] buffer;
5022 return ERROR_WRITE_FAULT;
5023 }
5024
5025 EventPipe::WriteEvent(*EventPipeEventMethodJitInliningSucceeded, (BYTE *)buffer, (unsigned int)offset);
5026
5027 if (!fixedBuffer)
5028 delete[] buffer;
5029
5030 return ERROR_SUCCESS;
5031}
5032
5033BOOL EventPipeEventEnabledMethodJitInliningFailedAnsi()
5034{
5035 return EventPipeEventMethodJitInliningFailedAnsi->IsEnabled();
5036}
5037
5038extern "C" ULONG EventPipeWriteEventMethodJitInliningFailedAnsi(
5039 PCWSTR MethodBeingCompiledNamespace,
5040 PCWSTR MethodBeingCompiledName,
5041 PCWSTR MethodBeingCompiledNameSignature,
5042 PCWSTR InlinerNamespace,
5043 PCWSTR InlinerName,
5044 PCWSTR InlinerNameSignature,
5045 PCWSTR InlineeNamespace,
5046 PCWSTR InlineeName,
5047 PCWSTR InlineeNameSignature,
5048 const BOOL FailAlways,
5049 LPCSTR FailReason,
5050 const unsigned short ClrInstanceID)
5051{
5052 if (!EventPipeEventEnabledMethodJitInliningFailedAnsi())
5053 return ERROR_SUCCESS;
5054
5055 char stackBuffer[614];
5056 char *buffer = stackBuffer;
5057 size_t offset = 0;
5058 size_t size = 614;
5059 bool fixedBuffer = true;
5060
5061 bool success = true;
5062 success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
5063 success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
5064 success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
5065 success &= WriteToBuffer(InlinerNamespace, buffer, offset, size, fixedBuffer);
5066 success &= WriteToBuffer(InlinerName, buffer, offset, size, fixedBuffer);
5067 success &= WriteToBuffer(InlinerNameSignature, buffer, offset, size, fixedBuffer);
5068 success &= WriteToBuffer(InlineeNamespace, buffer, offset, size, fixedBuffer);
5069 success &= WriteToBuffer(InlineeName, buffer, offset, size, fixedBuffer);
5070 success &= WriteToBuffer(InlineeNameSignature, buffer, offset, size, fixedBuffer);
5071 success &= WriteToBuffer(FailAlways, buffer, offset, size, fixedBuffer);
5072 success &= WriteToBuffer(FailReason, buffer, offset, size, fixedBuffer);
5073 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5074
5075 if (!success)
5076 {
5077 if (!fixedBuffer)
5078 delete[] buffer;
5079 return ERROR_WRITE_FAULT;
5080 }
5081
5082 EventPipe::WriteEvent(*EventPipeEventMethodJitInliningFailedAnsi, (BYTE *)buffer, (unsigned int)offset);
5083
5084 if (!fixedBuffer)
5085 delete[] buffer;
5086
5087 return ERROR_SUCCESS;
5088}
5089
5090BOOL EventPipeEventEnabledMethodJitTailCallSucceeded()
5091{
5092 return EventPipeEventMethodJitTailCallSucceeded->IsEnabled();
5093}
5094
5095extern "C" ULONG EventPipeWriteEventMethodJitTailCallSucceeded(
5096 PCWSTR MethodBeingCompiledNamespace,
5097 PCWSTR MethodBeingCompiledName,
5098 PCWSTR MethodBeingCompiledNameSignature,
5099 PCWSTR CallerNamespace,
5100 PCWSTR CallerName,
5101 PCWSTR CallerNameSignature,
5102 PCWSTR CalleeNamespace,
5103 PCWSTR CalleeName,
5104 PCWSTR CalleeNameSignature,
5105 const BOOL TailPrefix,
5106 const unsigned int TailCallType,
5107 const unsigned short ClrInstanceID)
5108{
5109 if (!EventPipeEventEnabledMethodJitTailCallSucceeded())
5110 return ERROR_SUCCESS;
5111
5112 char stackBuffer[586];
5113 char *buffer = stackBuffer;
5114 size_t offset = 0;
5115 size_t size = 586;
5116 bool fixedBuffer = true;
5117
5118 bool success = true;
5119 success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
5120 success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
5121 success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
5122 success &= WriteToBuffer(CallerNamespace, buffer, offset, size, fixedBuffer);
5123 success &= WriteToBuffer(CallerName, buffer, offset, size, fixedBuffer);
5124 success &= WriteToBuffer(CallerNameSignature, buffer, offset, size, fixedBuffer);
5125 success &= WriteToBuffer(CalleeNamespace, buffer, offset, size, fixedBuffer);
5126 success &= WriteToBuffer(CalleeName, buffer, offset, size, fixedBuffer);
5127 success &= WriteToBuffer(CalleeNameSignature, buffer, offset, size, fixedBuffer);
5128 success &= WriteToBuffer(TailPrefix, buffer, offset, size, fixedBuffer);
5129 success &= WriteToBuffer(TailCallType, buffer, offset, size, fixedBuffer);
5130 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5131
5132 if (!success)
5133 {
5134 if (!fixedBuffer)
5135 delete[] buffer;
5136 return ERROR_WRITE_FAULT;
5137 }
5138
5139 EventPipe::WriteEvent(*EventPipeEventMethodJitTailCallSucceeded, (BYTE *)buffer, (unsigned int)offset);
5140
5141 if (!fixedBuffer)
5142 delete[] buffer;
5143
5144 return ERROR_SUCCESS;
5145}
5146
5147BOOL EventPipeEventEnabledMethodJitTailCallFailedAnsi()
5148{
5149 return EventPipeEventMethodJitTailCallFailedAnsi->IsEnabled();
5150}
5151
5152extern "C" ULONG EventPipeWriteEventMethodJitTailCallFailedAnsi(
5153 PCWSTR MethodBeingCompiledNamespace,
5154 PCWSTR MethodBeingCompiledName,
5155 PCWSTR MethodBeingCompiledNameSignature,
5156 PCWSTR CallerNamespace,
5157 PCWSTR CallerName,
5158 PCWSTR CallerNameSignature,
5159 PCWSTR CalleeNamespace,
5160 PCWSTR CalleeName,
5161 PCWSTR CalleeNameSignature,
5162 const BOOL TailPrefix,
5163 LPCSTR FailReason,
5164 const unsigned short ClrInstanceID)
5165{
5166 if (!EventPipeEventEnabledMethodJitTailCallFailedAnsi())
5167 return ERROR_SUCCESS;
5168
5169 char stackBuffer[614];
5170 char *buffer = stackBuffer;
5171 size_t offset = 0;
5172 size_t size = 614;
5173 bool fixedBuffer = true;
5174
5175 bool success = true;
5176 success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
5177 success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
5178 success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
5179 success &= WriteToBuffer(CallerNamespace, buffer, offset, size, fixedBuffer);
5180 success &= WriteToBuffer(CallerName, buffer, offset, size, fixedBuffer);
5181 success &= WriteToBuffer(CallerNameSignature, buffer, offset, size, fixedBuffer);
5182 success &= WriteToBuffer(CalleeNamespace, buffer, offset, size, fixedBuffer);
5183 success &= WriteToBuffer(CalleeName, buffer, offset, size, fixedBuffer);
5184 success &= WriteToBuffer(CalleeNameSignature, buffer, offset, size, fixedBuffer);
5185 success &= WriteToBuffer(TailPrefix, buffer, offset, size, fixedBuffer);
5186 success &= WriteToBuffer(FailReason, buffer, offset, size, fixedBuffer);
5187 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5188
5189 if (!success)
5190 {
5191 if (!fixedBuffer)
5192 delete[] buffer;
5193 return ERROR_WRITE_FAULT;
5194 }
5195
5196 EventPipe::WriteEvent(*EventPipeEventMethodJitTailCallFailedAnsi, (BYTE *)buffer, (unsigned int)offset);
5197
5198 if (!fixedBuffer)
5199 delete[] buffer;
5200
5201 return ERROR_SUCCESS;
5202}
5203
5204BOOL EventPipeEventEnabledMethodILToNativeMap()
5205{
5206 return EventPipeEventMethodILToNativeMap->IsEnabled();
5207}
5208
5209extern "C" ULONG EventPipeWriteEventMethodILToNativeMap(
5210 const unsigned __int64 MethodID,
5211 const unsigned __int64 ReJITID,
5212 const unsigned char MethodExtent,
5213 const unsigned short CountOfMapEntries,
5214 const unsigned int* ILOffsets,
5215 const unsigned int* NativeOffsets,
5216 const unsigned short ClrInstanceID)
5217{
5218 if (!EventPipeEventEnabledMethodILToNativeMap())
5219 return ERROR_SUCCESS;
5220
5221 char stackBuffer[32];
5222 char *buffer = stackBuffer;
5223 size_t offset = 0;
5224 size_t size = 32;
5225 bool fixedBuffer = true;
5226
5227 bool success = true;
5228 success &= WriteToBuffer(MethodID, buffer, offset, size, fixedBuffer);
5229 success &= WriteToBuffer(ReJITID, buffer, offset, size, fixedBuffer);
5230 success &= WriteToBuffer(MethodExtent, buffer, offset, size, fixedBuffer);
5231 success &= WriteToBuffer(CountOfMapEntries, buffer, offset, size, fixedBuffer);
5232 success &= WriteToBuffer((const BYTE *)ILOffsets, sizeof(const unsigned int) * (int)CountOfMapEntries, buffer, offset, size, fixedBuffer);
5233 success &= WriteToBuffer((const BYTE *)NativeOffsets, sizeof(const unsigned int) * (int)CountOfMapEntries, buffer, offset, size, fixedBuffer);
5234 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5235
5236 if (!success)
5237 {
5238 if (!fixedBuffer)
5239 delete[] buffer;
5240 return ERROR_WRITE_FAULT;
5241 }
5242
5243 EventPipe::WriteEvent(*EventPipeEventMethodILToNativeMap, (BYTE *)buffer, (unsigned int)offset);
5244
5245 if (!fixedBuffer)
5246 delete[] buffer;
5247
5248 return ERROR_SUCCESS;
5249}
5250
5251BOOL EventPipeEventEnabledMethodJitTailCallFailed()
5252{
5253 return EventPipeEventMethodJitTailCallFailed->IsEnabled();
5254}
5255
5256extern "C" ULONG EventPipeWriteEventMethodJitTailCallFailed(
5257 PCWSTR MethodBeingCompiledNamespace,
5258 PCWSTR MethodBeingCompiledName,
5259 PCWSTR MethodBeingCompiledNameSignature,
5260 PCWSTR CallerNamespace,
5261 PCWSTR CallerName,
5262 PCWSTR CallerNameSignature,
5263 PCWSTR CalleeNamespace,
5264 PCWSTR CalleeName,
5265 PCWSTR CalleeNameSignature,
5266 const BOOL TailPrefix,
5267 PCWSTR FailReason,
5268 const unsigned short ClrInstanceID)
5269{
5270 if (!EventPipeEventEnabledMethodJitTailCallFailed())
5271 return ERROR_SUCCESS;
5272
5273 char stackBuffer[646];
5274 char *buffer = stackBuffer;
5275 size_t offset = 0;
5276 size_t size = 646;
5277 bool fixedBuffer = true;
5278
5279 bool success = true;
5280 success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
5281 success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
5282 success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
5283 success &= WriteToBuffer(CallerNamespace, buffer, offset, size, fixedBuffer);
5284 success &= WriteToBuffer(CallerName, buffer, offset, size, fixedBuffer);
5285 success &= WriteToBuffer(CallerNameSignature, buffer, offset, size, fixedBuffer);
5286 success &= WriteToBuffer(CalleeNamespace, buffer, offset, size, fixedBuffer);
5287 success &= WriteToBuffer(CalleeName, buffer, offset, size, fixedBuffer);
5288 success &= WriteToBuffer(CalleeNameSignature, buffer, offset, size, fixedBuffer);
5289 success &= WriteToBuffer(TailPrefix, buffer, offset, size, fixedBuffer);
5290 success &= WriteToBuffer(FailReason, buffer, offset, size, fixedBuffer);
5291 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5292
5293 if (!success)
5294 {
5295 if (!fixedBuffer)
5296 delete[] buffer;
5297 return ERROR_WRITE_FAULT;
5298 }
5299
5300 EventPipe::WriteEvent(*EventPipeEventMethodJitTailCallFailed, (BYTE *)buffer, (unsigned int)offset);
5301
5302 if (!fixedBuffer)
5303 delete[] buffer;
5304
5305 return ERROR_SUCCESS;
5306}
5307
5308BOOL EventPipeEventEnabledMethodJitInliningFailed()
5309{
5310 return EventPipeEventMethodJitInliningFailed->IsEnabled();
5311}
5312
5313extern "C" ULONG EventPipeWriteEventMethodJitInliningFailed(
5314 PCWSTR MethodBeingCompiledNamespace,
5315 PCWSTR MethodBeingCompiledName,
5316 PCWSTR MethodBeingCompiledNameSignature,
5317 PCWSTR InlinerNamespace,
5318 PCWSTR InlinerName,
5319 PCWSTR InlinerNameSignature,
5320 PCWSTR InlineeNamespace,
5321 PCWSTR InlineeName,
5322 PCWSTR InlineeNameSignature,
5323 const BOOL FailAlways,
5324 PCWSTR FailReason,
5325 const unsigned short ClrInstanceID)
5326{
5327 if (!EventPipeEventEnabledMethodJitInliningFailed())
5328 return ERROR_SUCCESS;
5329
5330 char stackBuffer[646];
5331 char *buffer = stackBuffer;
5332 size_t offset = 0;
5333 size_t size = 646;
5334 bool fixedBuffer = true;
5335
5336 bool success = true;
5337 success &= WriteToBuffer(MethodBeingCompiledNamespace, buffer, offset, size, fixedBuffer);
5338 success &= WriteToBuffer(MethodBeingCompiledName, buffer, offset, size, fixedBuffer);
5339 success &= WriteToBuffer(MethodBeingCompiledNameSignature, buffer, offset, size, fixedBuffer);
5340 success &= WriteToBuffer(InlinerNamespace, buffer, offset, size, fixedBuffer);
5341 success &= WriteToBuffer(InlinerName, buffer, offset, size, fixedBuffer);
5342 success &= WriteToBuffer(InlinerNameSignature, buffer, offset, size, fixedBuffer);
5343 success &= WriteToBuffer(InlineeNamespace, buffer, offset, size, fixedBuffer);
5344 success &= WriteToBuffer(InlineeName, buffer, offset, size, fixedBuffer);
5345 success &= WriteToBuffer(InlineeNameSignature, buffer, offset, size, fixedBuffer);
5346 success &= WriteToBuffer(FailAlways, buffer, offset, size, fixedBuffer);
5347 success &= WriteToBuffer(FailReason, buffer, offset, size, fixedBuffer);
5348 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5349
5350 if (!success)
5351 {
5352 if (!fixedBuffer)
5353 delete[] buffer;
5354 return ERROR_WRITE_FAULT;
5355 }
5356
5357 EventPipe::WriteEvent(*EventPipeEventMethodJitInliningFailed, (BYTE *)buffer, (unsigned int)offset);
5358
5359 if (!fixedBuffer)
5360 delete[] buffer;
5361
5362 return ERROR_SUCCESS;
5363}
5364
5365BOOL EventPipeEventEnabledModuleDCStartV2()
5366{
5367 return EventPipeEventModuleDCStartV2->IsEnabled();
5368}
5369
5370extern "C" ULONG EventPipeWriteEventModuleDCStartV2(
5371 const unsigned __int64 ModuleID,
5372 const unsigned __int64 AssemblyID,
5373 const unsigned int ModuleFlags,
5374 const unsigned int Reserved1,
5375 PCWSTR ModuleILPath,
5376 PCWSTR ModuleNativePath)
5377{
5378 if (!EventPipeEventEnabledModuleDCStartV2())
5379 return ERROR_SUCCESS;
5380
5381 char stackBuffer[152];
5382 char *buffer = stackBuffer;
5383 size_t offset = 0;
5384 size_t size = 152;
5385 bool fixedBuffer = true;
5386
5387 bool success = true;
5388 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5389 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5390 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5391 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5392 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5393 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5394
5395 if (!success)
5396 {
5397 if (!fixedBuffer)
5398 delete[] buffer;
5399 return ERROR_WRITE_FAULT;
5400 }
5401
5402 EventPipe::WriteEvent(*EventPipeEventModuleDCStartV2, (BYTE *)buffer, (unsigned int)offset);
5403
5404 if (!fixedBuffer)
5405 delete[] buffer;
5406
5407 return ERROR_SUCCESS;
5408}
5409
5410BOOL EventPipeEventEnabledModuleDCEndV2()
5411{
5412 return EventPipeEventModuleDCEndV2->IsEnabled();
5413}
5414
5415extern "C" ULONG EventPipeWriteEventModuleDCEndV2(
5416 const unsigned __int64 ModuleID,
5417 const unsigned __int64 AssemblyID,
5418 const unsigned int ModuleFlags,
5419 const unsigned int Reserved1,
5420 PCWSTR ModuleILPath,
5421 PCWSTR ModuleNativePath)
5422{
5423 if (!EventPipeEventEnabledModuleDCEndV2())
5424 return ERROR_SUCCESS;
5425
5426 char stackBuffer[152];
5427 char *buffer = stackBuffer;
5428 size_t offset = 0;
5429 size_t size = 152;
5430 bool fixedBuffer = true;
5431
5432 bool success = true;
5433 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5434 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5435 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5436 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5437 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5438 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5439
5440 if (!success)
5441 {
5442 if (!fixedBuffer)
5443 delete[] buffer;
5444 return ERROR_WRITE_FAULT;
5445 }
5446
5447 EventPipe::WriteEvent(*EventPipeEventModuleDCEndV2, (BYTE *)buffer, (unsigned int)offset);
5448
5449 if (!fixedBuffer)
5450 delete[] buffer;
5451
5452 return ERROR_SUCCESS;
5453}
5454
5455BOOL EventPipeEventEnabledDomainModuleLoad()
5456{
5457 return EventPipeEventDomainModuleLoad->IsEnabled();
5458}
5459
5460extern "C" ULONG EventPipeWriteEventDomainModuleLoad(
5461 const unsigned __int64 ModuleID,
5462 const unsigned __int64 AssemblyID,
5463 const unsigned __int64 AppDomainID,
5464 const unsigned int ModuleFlags,
5465 const unsigned int Reserved1,
5466 PCWSTR ModuleILPath,
5467 PCWSTR ModuleNativePath)
5468{
5469 if (!EventPipeEventEnabledDomainModuleLoad())
5470 return ERROR_SUCCESS;
5471
5472 char stackBuffer[160];
5473 char *buffer = stackBuffer;
5474 size_t offset = 0;
5475 size_t size = 160;
5476 bool fixedBuffer = true;
5477
5478 bool success = true;
5479 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5480 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5481 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
5482 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5483 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5484 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5485 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5486
5487 if (!success)
5488 {
5489 if (!fixedBuffer)
5490 delete[] buffer;
5491 return ERROR_WRITE_FAULT;
5492 }
5493
5494 EventPipe::WriteEvent(*EventPipeEventDomainModuleLoad, (BYTE *)buffer, (unsigned int)offset);
5495
5496 if (!fixedBuffer)
5497 delete[] buffer;
5498
5499 return ERROR_SUCCESS;
5500}
5501
5502BOOL EventPipeEventEnabledDomainModuleLoad_V1()
5503{
5504 return EventPipeEventDomainModuleLoad_V1->IsEnabled();
5505}
5506
5507extern "C" ULONG EventPipeWriteEventDomainModuleLoad_V1(
5508 const unsigned __int64 ModuleID,
5509 const unsigned __int64 AssemblyID,
5510 const unsigned __int64 AppDomainID,
5511 const unsigned int ModuleFlags,
5512 const unsigned int Reserved1,
5513 PCWSTR ModuleILPath,
5514 PCWSTR ModuleNativePath,
5515 const unsigned short ClrInstanceID)
5516{
5517 if (!EventPipeEventEnabledDomainModuleLoad_V1())
5518 return ERROR_SUCCESS;
5519
5520 char stackBuffer[162];
5521 char *buffer = stackBuffer;
5522 size_t offset = 0;
5523 size_t size = 162;
5524 bool fixedBuffer = true;
5525
5526 bool success = true;
5527 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5528 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5529 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
5530 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5531 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5532 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5533 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5534 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5535
5536 if (!success)
5537 {
5538 if (!fixedBuffer)
5539 delete[] buffer;
5540 return ERROR_WRITE_FAULT;
5541 }
5542
5543 EventPipe::WriteEvent(*EventPipeEventDomainModuleLoad_V1, (BYTE *)buffer, (unsigned int)offset);
5544
5545 if (!fixedBuffer)
5546 delete[] buffer;
5547
5548 return ERROR_SUCCESS;
5549}
5550
5551BOOL EventPipeEventEnabledModuleLoad()
5552{
5553 return EventPipeEventModuleLoad->IsEnabled();
5554}
5555
5556extern "C" ULONG EventPipeWriteEventModuleLoad(
5557 const unsigned __int64 ModuleID,
5558 const unsigned __int64 AssemblyID,
5559 const unsigned int ModuleFlags,
5560 const unsigned int Reserved1,
5561 PCWSTR ModuleILPath,
5562 PCWSTR ModuleNativePath)
5563{
5564 if (!EventPipeEventEnabledModuleLoad())
5565 return ERROR_SUCCESS;
5566
5567 char stackBuffer[152];
5568 char *buffer = stackBuffer;
5569 size_t offset = 0;
5570 size_t size = 152;
5571 bool fixedBuffer = true;
5572
5573 bool success = true;
5574 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5575 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5576 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5577 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5578 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5579 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5580
5581 if (!success)
5582 {
5583 if (!fixedBuffer)
5584 delete[] buffer;
5585 return ERROR_WRITE_FAULT;
5586 }
5587
5588 EventPipe::WriteEvent(*EventPipeEventModuleLoad, (BYTE *)buffer, (unsigned int)offset);
5589
5590 if (!fixedBuffer)
5591 delete[] buffer;
5592
5593 return ERROR_SUCCESS;
5594}
5595
5596BOOL EventPipeEventEnabledModuleLoad_V1()
5597{
5598 return EventPipeEventModuleLoad_V1->IsEnabled();
5599}
5600
5601extern "C" ULONG EventPipeWriteEventModuleLoad_V1(
5602 const unsigned __int64 ModuleID,
5603 const unsigned __int64 AssemblyID,
5604 const unsigned int ModuleFlags,
5605 const unsigned int Reserved1,
5606 PCWSTR ModuleILPath,
5607 PCWSTR ModuleNativePath,
5608 const unsigned short ClrInstanceID)
5609{
5610 if (!EventPipeEventEnabledModuleLoad_V1())
5611 return ERROR_SUCCESS;
5612
5613 char stackBuffer[154];
5614 char *buffer = stackBuffer;
5615 size_t offset = 0;
5616 size_t size = 154;
5617 bool fixedBuffer = true;
5618
5619 bool success = true;
5620 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5621 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5622 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5623 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5624 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5625 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5626 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5627
5628 if (!success)
5629 {
5630 if (!fixedBuffer)
5631 delete[] buffer;
5632 return ERROR_WRITE_FAULT;
5633 }
5634
5635 EventPipe::WriteEvent(*EventPipeEventModuleLoad_V1, (BYTE *)buffer, (unsigned int)offset);
5636
5637 if (!fixedBuffer)
5638 delete[] buffer;
5639
5640 return ERROR_SUCCESS;
5641}
5642
5643BOOL EventPipeEventEnabledModuleLoad_V2()
5644{
5645 return EventPipeEventModuleLoad_V2->IsEnabled();
5646}
5647
5648extern "C" ULONG EventPipeWriteEventModuleLoad_V2(
5649 const unsigned __int64 ModuleID,
5650 const unsigned __int64 AssemblyID,
5651 const unsigned int ModuleFlags,
5652 const unsigned int Reserved1,
5653 PCWSTR ModuleILPath,
5654 PCWSTR ModuleNativePath,
5655 const unsigned short ClrInstanceID,
5656 const GUID* ManagedPdbSignature,
5657 const unsigned int ManagedPdbAge,
5658 PCWSTR ManagedPdbBuildPath,
5659 const GUID* NativePdbSignature,
5660 const unsigned int NativePdbAge,
5661 PCWSTR NativePdbBuildPath)
5662{
5663 if (!EventPipeEventEnabledModuleLoad_V2())
5664 return ERROR_SUCCESS;
5665
5666 char stackBuffer[290];
5667 char *buffer = stackBuffer;
5668 size_t offset = 0;
5669 size_t size = 290;
5670 bool fixedBuffer = true;
5671
5672 bool success = true;
5673 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5674 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5675 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5676 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5677 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5678 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5679 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5680 success &= WriteToBuffer(*ManagedPdbSignature, buffer, offset, size, fixedBuffer);
5681 success &= WriteToBuffer(ManagedPdbAge, buffer, offset, size, fixedBuffer);
5682 success &= WriteToBuffer(ManagedPdbBuildPath, buffer, offset, size, fixedBuffer);
5683 success &= WriteToBuffer(*NativePdbSignature, buffer, offset, size, fixedBuffer);
5684 success &= WriteToBuffer(NativePdbAge, buffer, offset, size, fixedBuffer);
5685 success &= WriteToBuffer(NativePdbBuildPath, buffer, offset, size, fixedBuffer);
5686
5687 if (!success)
5688 {
5689 if (!fixedBuffer)
5690 delete[] buffer;
5691 return ERROR_WRITE_FAULT;
5692 }
5693
5694 EventPipe::WriteEvent(*EventPipeEventModuleLoad_V2, (BYTE *)buffer, (unsigned int)offset);
5695
5696 if (!fixedBuffer)
5697 delete[] buffer;
5698
5699 return ERROR_SUCCESS;
5700}
5701
5702BOOL EventPipeEventEnabledModuleUnload()
5703{
5704 return EventPipeEventModuleUnload->IsEnabled();
5705}
5706
5707extern "C" ULONG EventPipeWriteEventModuleUnload(
5708 const unsigned __int64 ModuleID,
5709 const unsigned __int64 AssemblyID,
5710 const unsigned int ModuleFlags,
5711 const unsigned int Reserved1,
5712 PCWSTR ModuleILPath,
5713 PCWSTR ModuleNativePath)
5714{
5715 if (!EventPipeEventEnabledModuleUnload())
5716 return ERROR_SUCCESS;
5717
5718 char stackBuffer[152];
5719 char *buffer = stackBuffer;
5720 size_t offset = 0;
5721 size_t size = 152;
5722 bool fixedBuffer = true;
5723
5724 bool success = true;
5725 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5726 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5727 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5728 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5729 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5730 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5731
5732 if (!success)
5733 {
5734 if (!fixedBuffer)
5735 delete[] buffer;
5736 return ERROR_WRITE_FAULT;
5737 }
5738
5739 EventPipe::WriteEvent(*EventPipeEventModuleUnload, (BYTE *)buffer, (unsigned int)offset);
5740
5741 if (!fixedBuffer)
5742 delete[] buffer;
5743
5744 return ERROR_SUCCESS;
5745}
5746
5747BOOL EventPipeEventEnabledModuleUnload_V1()
5748{
5749 return EventPipeEventModuleUnload_V1->IsEnabled();
5750}
5751
5752extern "C" ULONG EventPipeWriteEventModuleUnload_V1(
5753 const unsigned __int64 ModuleID,
5754 const unsigned __int64 AssemblyID,
5755 const unsigned int ModuleFlags,
5756 const unsigned int Reserved1,
5757 PCWSTR ModuleILPath,
5758 PCWSTR ModuleNativePath,
5759 const unsigned short ClrInstanceID)
5760{
5761 if (!EventPipeEventEnabledModuleUnload_V1())
5762 return ERROR_SUCCESS;
5763
5764 char stackBuffer[154];
5765 char *buffer = stackBuffer;
5766 size_t offset = 0;
5767 size_t size = 154;
5768 bool fixedBuffer = true;
5769
5770 bool success = true;
5771 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5772 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5773 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5774 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5775 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5776 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5777 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5778
5779 if (!success)
5780 {
5781 if (!fixedBuffer)
5782 delete[] buffer;
5783 return ERROR_WRITE_FAULT;
5784 }
5785
5786 EventPipe::WriteEvent(*EventPipeEventModuleUnload_V1, (BYTE *)buffer, (unsigned int)offset);
5787
5788 if (!fixedBuffer)
5789 delete[] buffer;
5790
5791 return ERROR_SUCCESS;
5792}
5793
5794BOOL EventPipeEventEnabledModuleUnload_V2()
5795{
5796 return EventPipeEventModuleUnload_V2->IsEnabled();
5797}
5798
5799extern "C" ULONG EventPipeWriteEventModuleUnload_V2(
5800 const unsigned __int64 ModuleID,
5801 const unsigned __int64 AssemblyID,
5802 const unsigned int ModuleFlags,
5803 const unsigned int Reserved1,
5804 PCWSTR ModuleILPath,
5805 PCWSTR ModuleNativePath,
5806 const unsigned short ClrInstanceID,
5807 const GUID* ManagedPdbSignature,
5808 const unsigned int ManagedPdbAge,
5809 PCWSTR ManagedPdbBuildPath,
5810 const GUID* NativePdbSignature,
5811 const unsigned int NativePdbAge,
5812 PCWSTR NativePdbBuildPath)
5813{
5814 if (!EventPipeEventEnabledModuleUnload_V2())
5815 return ERROR_SUCCESS;
5816
5817 char stackBuffer[290];
5818 char *buffer = stackBuffer;
5819 size_t offset = 0;
5820 size_t size = 290;
5821 bool fixedBuffer = true;
5822
5823 bool success = true;
5824 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
5825 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5826 success &= WriteToBuffer(ModuleFlags, buffer, offset, size, fixedBuffer);
5827 success &= WriteToBuffer(Reserved1, buffer, offset, size, fixedBuffer);
5828 success &= WriteToBuffer(ModuleILPath, buffer, offset, size, fixedBuffer);
5829 success &= WriteToBuffer(ModuleNativePath, buffer, offset, size, fixedBuffer);
5830 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5831 success &= WriteToBuffer(*ManagedPdbSignature, buffer, offset, size, fixedBuffer);
5832 success &= WriteToBuffer(ManagedPdbAge, buffer, offset, size, fixedBuffer);
5833 success &= WriteToBuffer(ManagedPdbBuildPath, buffer, offset, size, fixedBuffer);
5834 success &= WriteToBuffer(*NativePdbSignature, buffer, offset, size, fixedBuffer);
5835 success &= WriteToBuffer(NativePdbAge, buffer, offset, size, fixedBuffer);
5836 success &= WriteToBuffer(NativePdbBuildPath, buffer, offset, size, fixedBuffer);
5837
5838 if (!success)
5839 {
5840 if (!fixedBuffer)
5841 delete[] buffer;
5842 return ERROR_WRITE_FAULT;
5843 }
5844
5845 EventPipe::WriteEvent(*EventPipeEventModuleUnload_V2, (BYTE *)buffer, (unsigned int)offset);
5846
5847 if (!fixedBuffer)
5848 delete[] buffer;
5849
5850 return ERROR_SUCCESS;
5851}
5852
5853BOOL EventPipeEventEnabledAssemblyLoad()
5854{
5855 return EventPipeEventAssemblyLoad->IsEnabled();
5856}
5857
5858extern "C" ULONG EventPipeWriteEventAssemblyLoad(
5859 const unsigned __int64 AssemblyID,
5860 const unsigned __int64 AppDomainID,
5861 const unsigned int AssemblyFlags,
5862 PCWSTR FullyQualifiedAssemblyName)
5863{
5864 if (!EventPipeEventEnabledAssemblyLoad())
5865 return ERROR_SUCCESS;
5866
5867 char stackBuffer[84];
5868 char *buffer = stackBuffer;
5869 size_t offset = 0;
5870 size_t size = 84;
5871 bool fixedBuffer = true;
5872
5873 bool success = true;
5874 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5875 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
5876 success &= WriteToBuffer(AssemblyFlags, buffer, offset, size, fixedBuffer);
5877 success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
5878
5879 if (!success)
5880 {
5881 if (!fixedBuffer)
5882 delete[] buffer;
5883 return ERROR_WRITE_FAULT;
5884 }
5885
5886 EventPipe::WriteEvent(*EventPipeEventAssemblyLoad, (BYTE *)buffer, (unsigned int)offset);
5887
5888 if (!fixedBuffer)
5889 delete[] buffer;
5890
5891 return ERROR_SUCCESS;
5892}
5893
5894BOOL EventPipeEventEnabledAssemblyLoad_V1()
5895{
5896 return EventPipeEventAssemblyLoad_V1->IsEnabled();
5897}
5898
5899extern "C" ULONG EventPipeWriteEventAssemblyLoad_V1(
5900 const unsigned __int64 AssemblyID,
5901 const unsigned __int64 AppDomainID,
5902 const unsigned __int64 BindingID,
5903 const unsigned int AssemblyFlags,
5904 PCWSTR FullyQualifiedAssemblyName,
5905 const unsigned short ClrInstanceID)
5906{
5907 if (!EventPipeEventEnabledAssemblyLoad_V1())
5908 return ERROR_SUCCESS;
5909
5910 char stackBuffer[94];
5911 char *buffer = stackBuffer;
5912 size_t offset = 0;
5913 size_t size = 94;
5914 bool fixedBuffer = true;
5915
5916 bool success = true;
5917 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5918 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
5919 success &= WriteToBuffer(BindingID, buffer, offset, size, fixedBuffer);
5920 success &= WriteToBuffer(AssemblyFlags, buffer, offset, size, fixedBuffer);
5921 success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
5922 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
5923
5924 if (!success)
5925 {
5926 if (!fixedBuffer)
5927 delete[] buffer;
5928 return ERROR_WRITE_FAULT;
5929 }
5930
5931 EventPipe::WriteEvent(*EventPipeEventAssemblyLoad_V1, (BYTE *)buffer, (unsigned int)offset);
5932
5933 if (!fixedBuffer)
5934 delete[] buffer;
5935
5936 return ERROR_SUCCESS;
5937}
5938
5939BOOL EventPipeEventEnabledAssemblyUnload()
5940{
5941 return EventPipeEventAssemblyUnload->IsEnabled();
5942}
5943
5944extern "C" ULONG EventPipeWriteEventAssemblyUnload(
5945 const unsigned __int64 AssemblyID,
5946 const unsigned __int64 AppDomainID,
5947 const unsigned int AssemblyFlags,
5948 PCWSTR FullyQualifiedAssemblyName)
5949{
5950 if (!EventPipeEventEnabledAssemblyUnload())
5951 return ERROR_SUCCESS;
5952
5953 char stackBuffer[84];
5954 char *buffer = stackBuffer;
5955 size_t offset = 0;
5956 size_t size = 84;
5957 bool fixedBuffer = true;
5958
5959 bool success = true;
5960 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
5961 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
5962 success &= WriteToBuffer(AssemblyFlags, buffer, offset, size, fixedBuffer);
5963 success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
5964
5965 if (!success)
5966 {
5967 if (!fixedBuffer)
5968 delete[] buffer;
5969 return ERROR_WRITE_FAULT;
5970 }
5971
5972 EventPipe::WriteEvent(*EventPipeEventAssemblyUnload, (BYTE *)buffer, (unsigned int)offset);
5973
5974 if (!fixedBuffer)
5975 delete[] buffer;
5976
5977 return ERROR_SUCCESS;
5978}
5979
5980BOOL EventPipeEventEnabledAssemblyUnload_V1()
5981{
5982 return EventPipeEventAssemblyUnload_V1->IsEnabled();
5983}
5984
5985extern "C" ULONG EventPipeWriteEventAssemblyUnload_V1(
5986 const unsigned __int64 AssemblyID,
5987 const unsigned __int64 AppDomainID,
5988 const unsigned __int64 BindingID,
5989 const unsigned int AssemblyFlags,
5990 PCWSTR FullyQualifiedAssemblyName,
5991 const unsigned short ClrInstanceID)
5992{
5993 if (!EventPipeEventEnabledAssemblyUnload_V1())
5994 return ERROR_SUCCESS;
5995
5996 char stackBuffer[94];
5997 char *buffer = stackBuffer;
5998 size_t offset = 0;
5999 size_t size = 94;
6000 bool fixedBuffer = true;
6001
6002 bool success = true;
6003 success &= WriteToBuffer(AssemblyID, buffer, offset, size, fixedBuffer);
6004 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
6005 success &= WriteToBuffer(BindingID, buffer, offset, size, fixedBuffer);
6006 success &= WriteToBuffer(AssemblyFlags, buffer, offset, size, fixedBuffer);
6007 success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
6008 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6009
6010 if (!success)
6011 {
6012 if (!fixedBuffer)
6013 delete[] buffer;
6014 return ERROR_WRITE_FAULT;
6015 }
6016
6017 EventPipe::WriteEvent(*EventPipeEventAssemblyUnload_V1, (BYTE *)buffer, (unsigned int)offset);
6018
6019 if (!fixedBuffer)
6020 delete[] buffer;
6021
6022 return ERROR_SUCCESS;
6023}
6024
6025BOOL EventPipeEventEnabledAppDomainLoad()
6026{
6027 return EventPipeEventAppDomainLoad->IsEnabled();
6028}
6029
6030extern "C" ULONG EventPipeWriteEventAppDomainLoad(
6031 const unsigned __int64 AppDomainID,
6032 const unsigned int AppDomainFlags,
6033 PCWSTR AppDomainName)
6034{
6035 if (!EventPipeEventEnabledAppDomainLoad())
6036 return ERROR_SUCCESS;
6037
6038 char stackBuffer[76];
6039 char *buffer = stackBuffer;
6040 size_t offset = 0;
6041 size_t size = 76;
6042 bool fixedBuffer = true;
6043
6044 bool success = true;
6045 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
6046 success &= WriteToBuffer(AppDomainFlags, buffer, offset, size, fixedBuffer);
6047 success &= WriteToBuffer(AppDomainName, buffer, offset, size, fixedBuffer);
6048
6049 if (!success)
6050 {
6051 if (!fixedBuffer)
6052 delete[] buffer;
6053 return ERROR_WRITE_FAULT;
6054 }
6055
6056 EventPipe::WriteEvent(*EventPipeEventAppDomainLoad, (BYTE *)buffer, (unsigned int)offset);
6057
6058 if (!fixedBuffer)
6059 delete[] buffer;
6060
6061 return ERROR_SUCCESS;
6062}
6063
6064BOOL EventPipeEventEnabledAppDomainLoad_V1()
6065{
6066 return EventPipeEventAppDomainLoad_V1->IsEnabled();
6067}
6068
6069extern "C" ULONG EventPipeWriteEventAppDomainLoad_V1(
6070 const unsigned __int64 AppDomainID,
6071 const unsigned int AppDomainFlags,
6072 PCWSTR AppDomainName,
6073 const unsigned int AppDomainIndex,
6074 const unsigned short ClrInstanceID)
6075{
6076 if (!EventPipeEventEnabledAppDomainLoad_V1())
6077 return ERROR_SUCCESS;
6078
6079 char stackBuffer[82];
6080 char *buffer = stackBuffer;
6081 size_t offset = 0;
6082 size_t size = 82;
6083 bool fixedBuffer = true;
6084
6085 bool success = true;
6086 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
6087 success &= WriteToBuffer(AppDomainFlags, buffer, offset, size, fixedBuffer);
6088 success &= WriteToBuffer(AppDomainName, buffer, offset, size, fixedBuffer);
6089 success &= WriteToBuffer(AppDomainIndex, buffer, offset, size, fixedBuffer);
6090 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6091
6092 if (!success)
6093 {
6094 if (!fixedBuffer)
6095 delete[] buffer;
6096 return ERROR_WRITE_FAULT;
6097 }
6098
6099 EventPipe::WriteEvent(*EventPipeEventAppDomainLoad_V1, (BYTE *)buffer, (unsigned int)offset);
6100
6101 if (!fixedBuffer)
6102 delete[] buffer;
6103
6104 return ERROR_SUCCESS;
6105}
6106
6107BOOL EventPipeEventEnabledAppDomainUnload()
6108{
6109 return EventPipeEventAppDomainUnload->IsEnabled();
6110}
6111
6112extern "C" ULONG EventPipeWriteEventAppDomainUnload(
6113 const unsigned __int64 AppDomainID,
6114 const unsigned int AppDomainFlags,
6115 PCWSTR AppDomainName)
6116{
6117 if (!EventPipeEventEnabledAppDomainUnload())
6118 return ERROR_SUCCESS;
6119
6120 char stackBuffer[76];
6121 char *buffer = stackBuffer;
6122 size_t offset = 0;
6123 size_t size = 76;
6124 bool fixedBuffer = true;
6125
6126 bool success = true;
6127 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
6128 success &= WriteToBuffer(AppDomainFlags, buffer, offset, size, fixedBuffer);
6129 success &= WriteToBuffer(AppDomainName, buffer, offset, size, fixedBuffer);
6130
6131 if (!success)
6132 {
6133 if (!fixedBuffer)
6134 delete[] buffer;
6135 return ERROR_WRITE_FAULT;
6136 }
6137
6138 EventPipe::WriteEvent(*EventPipeEventAppDomainUnload, (BYTE *)buffer, (unsigned int)offset);
6139
6140 if (!fixedBuffer)
6141 delete[] buffer;
6142
6143 return ERROR_SUCCESS;
6144}
6145
6146BOOL EventPipeEventEnabledAppDomainUnload_V1()
6147{
6148 return EventPipeEventAppDomainUnload_V1->IsEnabled();
6149}
6150
6151extern "C" ULONG EventPipeWriteEventAppDomainUnload_V1(
6152 const unsigned __int64 AppDomainID,
6153 const unsigned int AppDomainFlags,
6154 PCWSTR AppDomainName,
6155 const unsigned int AppDomainIndex,
6156 const unsigned short ClrInstanceID)
6157{
6158 if (!EventPipeEventEnabledAppDomainUnload_V1())
6159 return ERROR_SUCCESS;
6160
6161 char stackBuffer[82];
6162 char *buffer = stackBuffer;
6163 size_t offset = 0;
6164 size_t size = 82;
6165 bool fixedBuffer = true;
6166
6167 bool success = true;
6168 success &= WriteToBuffer(AppDomainID, buffer, offset, size, fixedBuffer);
6169 success &= WriteToBuffer(AppDomainFlags, buffer, offset, size, fixedBuffer);
6170 success &= WriteToBuffer(AppDomainName, buffer, offset, size, fixedBuffer);
6171 success &= WriteToBuffer(AppDomainIndex, buffer, offset, size, fixedBuffer);
6172 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6173
6174 if (!success)
6175 {
6176 if (!fixedBuffer)
6177 delete[] buffer;
6178 return ERROR_WRITE_FAULT;
6179 }
6180
6181 EventPipe::WriteEvent(*EventPipeEventAppDomainUnload_V1, (BYTE *)buffer, (unsigned int)offset);
6182
6183 if (!fixedBuffer)
6184 delete[] buffer;
6185
6186 return ERROR_SUCCESS;
6187}
6188
6189BOOL EventPipeEventEnabledModuleRangeLoad()
6190{
6191 return EventPipeEventModuleRangeLoad->IsEnabled();
6192}
6193
6194extern "C" ULONG EventPipeWriteEventModuleRangeLoad(
6195 const unsigned short ClrInstanceID,
6196 const unsigned __int64 ModuleID,
6197 const unsigned int RangeBegin,
6198 const unsigned int RangeSize,
6199 const unsigned char RangeType)
6200{
6201 if (!EventPipeEventEnabledModuleRangeLoad())
6202 return ERROR_SUCCESS;
6203
6204 char stackBuffer[32];
6205 char *buffer = stackBuffer;
6206 size_t offset = 0;
6207 size_t size = 32;
6208 bool fixedBuffer = true;
6209
6210 bool success = true;
6211 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6212 success &= WriteToBuffer(ModuleID, buffer, offset, size, fixedBuffer);
6213 success &= WriteToBuffer(RangeBegin, buffer, offset, size, fixedBuffer);
6214 success &= WriteToBuffer(RangeSize, buffer, offset, size, fixedBuffer);
6215 success &= WriteToBuffer(RangeType, buffer, offset, size, fixedBuffer);
6216
6217 if (!success)
6218 {
6219 if (!fixedBuffer)
6220 delete[] buffer;
6221 return ERROR_WRITE_FAULT;
6222 }
6223
6224 EventPipe::WriteEvent(*EventPipeEventModuleRangeLoad, (BYTE *)buffer, (unsigned int)offset);
6225
6226 if (!fixedBuffer)
6227 delete[] buffer;
6228
6229 return ERROR_SUCCESS;
6230}
6231
6232BOOL EventPipeEventEnabledStrongNameVerificationStart()
6233{
6234 return EventPipeEventStrongNameVerificationStart->IsEnabled();
6235}
6236
6237extern "C" ULONG EventPipeWriteEventStrongNameVerificationStart(
6238 const unsigned int VerificationFlags,
6239 const unsigned int ErrorCode,
6240 PCWSTR FullyQualifiedAssemblyName)
6241{
6242 if (!EventPipeEventEnabledStrongNameVerificationStart())
6243 return ERROR_SUCCESS;
6244
6245 char stackBuffer[72];
6246 char *buffer = stackBuffer;
6247 size_t offset = 0;
6248 size_t size = 72;
6249 bool fixedBuffer = true;
6250
6251 bool success = true;
6252 success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
6253 success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
6254 success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
6255
6256 if (!success)
6257 {
6258 if (!fixedBuffer)
6259 delete[] buffer;
6260 return ERROR_WRITE_FAULT;
6261 }
6262
6263 EventPipe::WriteEvent(*EventPipeEventStrongNameVerificationStart, (BYTE *)buffer, (unsigned int)offset);
6264
6265 if (!fixedBuffer)
6266 delete[] buffer;
6267
6268 return ERROR_SUCCESS;
6269}
6270
6271BOOL EventPipeEventEnabledStrongNameVerificationStart_V1()
6272{
6273 return EventPipeEventStrongNameVerificationStart_V1->IsEnabled();
6274}
6275
6276extern "C" ULONG EventPipeWriteEventStrongNameVerificationStart_V1(
6277 const unsigned int VerificationFlags,
6278 const unsigned int ErrorCode,
6279 PCWSTR FullyQualifiedAssemblyName,
6280 const unsigned short ClrInstanceID)
6281{
6282 if (!EventPipeEventEnabledStrongNameVerificationStart_V1())
6283 return ERROR_SUCCESS;
6284
6285 char stackBuffer[74];
6286 char *buffer = stackBuffer;
6287 size_t offset = 0;
6288 size_t size = 74;
6289 bool fixedBuffer = true;
6290
6291 bool success = true;
6292 success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
6293 success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
6294 success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
6295 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6296
6297 if (!success)
6298 {
6299 if (!fixedBuffer)
6300 delete[] buffer;
6301 return ERROR_WRITE_FAULT;
6302 }
6303
6304 EventPipe::WriteEvent(*EventPipeEventStrongNameVerificationStart_V1, (BYTE *)buffer, (unsigned int)offset);
6305
6306 if (!fixedBuffer)
6307 delete[] buffer;
6308
6309 return ERROR_SUCCESS;
6310}
6311
6312BOOL EventPipeEventEnabledStrongNameVerificationStop()
6313{
6314 return EventPipeEventStrongNameVerificationStop->IsEnabled();
6315}
6316
6317extern "C" ULONG EventPipeWriteEventStrongNameVerificationStop(
6318 const unsigned int VerificationFlags,
6319 const unsigned int ErrorCode,
6320 PCWSTR FullyQualifiedAssemblyName)
6321{
6322 if (!EventPipeEventEnabledStrongNameVerificationStop())
6323 return ERROR_SUCCESS;
6324
6325 char stackBuffer[72];
6326 char *buffer = stackBuffer;
6327 size_t offset = 0;
6328 size_t size = 72;
6329 bool fixedBuffer = true;
6330
6331 bool success = true;
6332 success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
6333 success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
6334 success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
6335
6336 if (!success)
6337 {
6338 if (!fixedBuffer)
6339 delete[] buffer;
6340 return ERROR_WRITE_FAULT;
6341 }
6342
6343 EventPipe::WriteEvent(*EventPipeEventStrongNameVerificationStop, (BYTE *)buffer, (unsigned int)offset);
6344
6345 if (!fixedBuffer)
6346 delete[] buffer;
6347
6348 return ERROR_SUCCESS;
6349}
6350
6351BOOL EventPipeEventEnabledStrongNameVerificationStop_V1()
6352{
6353 return EventPipeEventStrongNameVerificationStop_V1->IsEnabled();
6354}
6355
6356extern "C" ULONG EventPipeWriteEventStrongNameVerificationStop_V1(
6357 const unsigned int VerificationFlags,
6358 const unsigned int ErrorCode,
6359 PCWSTR FullyQualifiedAssemblyName,
6360 const unsigned short ClrInstanceID)
6361{
6362 if (!EventPipeEventEnabledStrongNameVerificationStop_V1())
6363 return ERROR_SUCCESS;
6364
6365 char stackBuffer[74];
6366 char *buffer = stackBuffer;
6367 size_t offset = 0;
6368 size_t size = 74;
6369 bool fixedBuffer = true;
6370
6371 bool success = true;
6372 success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
6373 success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
6374 success &= WriteToBuffer(FullyQualifiedAssemblyName, buffer, offset, size, fixedBuffer);
6375 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6376
6377 if (!success)
6378 {
6379 if (!fixedBuffer)
6380 delete[] buffer;
6381 return ERROR_WRITE_FAULT;
6382 }
6383
6384 EventPipe::WriteEvent(*EventPipeEventStrongNameVerificationStop_V1, (BYTE *)buffer, (unsigned int)offset);
6385
6386 if (!fixedBuffer)
6387 delete[] buffer;
6388
6389 return ERROR_SUCCESS;
6390}
6391
6392BOOL EventPipeEventEnabledAuthenticodeVerificationStart()
6393{
6394 return EventPipeEventAuthenticodeVerificationStart->IsEnabled();
6395}
6396
6397extern "C" ULONG EventPipeWriteEventAuthenticodeVerificationStart(
6398 const unsigned int VerificationFlags,
6399 const unsigned int ErrorCode,
6400 PCWSTR ModulePath)
6401{
6402 if (!EventPipeEventEnabledAuthenticodeVerificationStart())
6403 return ERROR_SUCCESS;
6404
6405 char stackBuffer[72];
6406 char *buffer = stackBuffer;
6407 size_t offset = 0;
6408 size_t size = 72;
6409 bool fixedBuffer = true;
6410
6411 bool success = true;
6412 success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
6413 success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
6414 success &= WriteToBuffer(ModulePath, buffer, offset, size, fixedBuffer);
6415
6416 if (!success)
6417 {
6418 if (!fixedBuffer)
6419 delete[] buffer;
6420 return ERROR_WRITE_FAULT;
6421 }
6422
6423 EventPipe::WriteEvent(*EventPipeEventAuthenticodeVerificationStart, (BYTE *)buffer, (unsigned int)offset);
6424
6425 if (!fixedBuffer)
6426 delete[] buffer;
6427
6428 return ERROR_SUCCESS;
6429}
6430
6431BOOL EventPipeEventEnabledAuthenticodeVerificationStart_V1()
6432{
6433 return EventPipeEventAuthenticodeVerificationStart_V1->IsEnabled();
6434}
6435
6436extern "C" ULONG EventPipeWriteEventAuthenticodeVerificationStart_V1(
6437 const unsigned int VerificationFlags,
6438 const unsigned int ErrorCode,
6439 PCWSTR ModulePath,
6440 const unsigned short ClrInstanceID)
6441{
6442 if (!EventPipeEventEnabledAuthenticodeVerificationStart_V1())
6443 return ERROR_SUCCESS;
6444
6445 char stackBuffer[74];
6446 char *buffer = stackBuffer;
6447 size_t offset = 0;
6448 size_t size = 74;
6449 bool fixedBuffer = true;
6450
6451 bool success = true;
6452 success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
6453 success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
6454 success &= WriteToBuffer(ModulePath, buffer, offset, size, fixedBuffer);
6455 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6456
6457 if (!success)
6458 {
6459 if (!fixedBuffer)
6460 delete[] buffer;
6461 return ERROR_WRITE_FAULT;
6462 }
6463
6464 EventPipe::WriteEvent(*EventPipeEventAuthenticodeVerificationStart_V1, (BYTE *)buffer, (unsigned int)offset);
6465
6466 if (!fixedBuffer)
6467 delete[] buffer;
6468
6469 return ERROR_SUCCESS;
6470}
6471
6472BOOL EventPipeEventEnabledAuthenticodeVerificationStop()
6473{
6474 return EventPipeEventAuthenticodeVerificationStop->IsEnabled();
6475}
6476
6477extern "C" ULONG EventPipeWriteEventAuthenticodeVerificationStop(
6478 const unsigned int VerificationFlags,
6479 const unsigned int ErrorCode,
6480 PCWSTR ModulePath)
6481{
6482 if (!EventPipeEventEnabledAuthenticodeVerificationStop())
6483 return ERROR_SUCCESS;
6484
6485 char stackBuffer[72];
6486 char *buffer = stackBuffer;
6487 size_t offset = 0;
6488 size_t size = 72;
6489 bool fixedBuffer = true;
6490
6491 bool success = true;
6492 success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
6493 success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
6494 success &= WriteToBuffer(ModulePath, buffer, offset, size, fixedBuffer);
6495
6496 if (!success)
6497 {
6498 if (!fixedBuffer)
6499 delete[] buffer;
6500 return ERROR_WRITE_FAULT;
6501 }
6502
6503 EventPipe::WriteEvent(*EventPipeEventAuthenticodeVerificationStop, (BYTE *)buffer, (unsigned int)offset);
6504
6505 if (!fixedBuffer)
6506 delete[] buffer;
6507
6508 return ERROR_SUCCESS;
6509}
6510
6511BOOL EventPipeEventEnabledAuthenticodeVerificationStop_V1()
6512{
6513 return EventPipeEventAuthenticodeVerificationStop_V1->IsEnabled();
6514}
6515
6516extern "C" ULONG EventPipeWriteEventAuthenticodeVerificationStop_V1(
6517 const unsigned int VerificationFlags,
6518 const unsigned int ErrorCode,
6519 PCWSTR ModulePath,
6520 const unsigned short ClrInstanceID)
6521{
6522 if (!EventPipeEventEnabledAuthenticodeVerificationStop_V1())
6523 return ERROR_SUCCESS;
6524
6525 char stackBuffer[74];
6526 char *buffer = stackBuffer;
6527 size_t offset = 0;
6528 size_t size = 74;
6529 bool fixedBuffer = true;
6530
6531 bool success = true;
6532 success &= WriteToBuffer(VerificationFlags, buffer, offset, size, fixedBuffer);
6533 success &= WriteToBuffer(ErrorCode, buffer, offset, size, fixedBuffer);
6534 success &= WriteToBuffer(ModulePath, buffer, offset, size, fixedBuffer);
6535 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6536
6537 if (!success)
6538 {
6539 if (!fixedBuffer)
6540 delete[] buffer;
6541 return ERROR_WRITE_FAULT;
6542 }
6543
6544 EventPipe::WriteEvent(*EventPipeEventAuthenticodeVerificationStop_V1, (BYTE *)buffer, (unsigned int)offset);
6545
6546 if (!fixedBuffer)
6547 delete[] buffer;
6548
6549 return ERROR_SUCCESS;
6550}
6551
6552BOOL EventPipeEventEnabledRuntimeInformationStart()
6553{
6554 return EventPipeEventRuntimeInformationStart->IsEnabled();
6555}
6556
6557extern "C" ULONG EventPipeWriteEventRuntimeInformationStart(
6558 const unsigned short ClrInstanceID,
6559 const unsigned short Sku,
6560 const unsigned short BclMajorVersion,
6561 const unsigned short BclMinorVersion,
6562 const unsigned short BclBuildNumber,
6563 const unsigned short BclQfeNumber,
6564 const unsigned short VMMajorVersion,
6565 const unsigned short VMMinorVersion,
6566 const unsigned short VMBuildNumber,
6567 const unsigned short VMQfeNumber,
6568 const unsigned int StartupFlags,
6569 const unsigned char StartupMode,
6570 PCWSTR CommandLine,
6571 const GUID* ComObjectGuid,
6572 PCWSTR RuntimeDllPath)
6573{
6574 if (!EventPipeEventEnabledRuntimeInformationStart())
6575 return ERROR_SUCCESS;
6576
6577 char stackBuffer[153];
6578 char *buffer = stackBuffer;
6579 size_t offset = 0;
6580 size_t size = 153;
6581 bool fixedBuffer = true;
6582
6583 bool success = true;
6584 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6585 success &= WriteToBuffer(Sku, buffer, offset, size, fixedBuffer);
6586 success &= WriteToBuffer(BclMajorVersion, buffer, offset, size, fixedBuffer);
6587 success &= WriteToBuffer(BclMinorVersion, buffer, offset, size, fixedBuffer);
6588 success &= WriteToBuffer(BclBuildNumber, buffer, offset, size, fixedBuffer);
6589 success &= WriteToBuffer(BclQfeNumber, buffer, offset, size, fixedBuffer);
6590 success &= WriteToBuffer(VMMajorVersion, buffer, offset, size, fixedBuffer);
6591 success &= WriteToBuffer(VMMinorVersion, buffer, offset, size, fixedBuffer);
6592 success &= WriteToBuffer(VMBuildNumber, buffer, offset, size, fixedBuffer);
6593 success &= WriteToBuffer(VMQfeNumber, buffer, offset, size, fixedBuffer);
6594 success &= WriteToBuffer(StartupFlags, buffer, offset, size, fixedBuffer);
6595 success &= WriteToBuffer(StartupMode, buffer, offset, size, fixedBuffer);
6596 success &= WriteToBuffer(CommandLine, buffer, offset, size, fixedBuffer);
6597 success &= WriteToBuffer(*ComObjectGuid, buffer, offset, size, fixedBuffer);
6598 success &= WriteToBuffer(RuntimeDllPath, buffer, offset, size, fixedBuffer);
6599
6600 if (!success)
6601 {
6602 if (!fixedBuffer)
6603 delete[] buffer;
6604 return ERROR_WRITE_FAULT;
6605 }
6606
6607 EventPipe::WriteEvent(*EventPipeEventRuntimeInformationStart, (BYTE *)buffer, (unsigned int)offset);
6608
6609 if (!fixedBuffer)
6610 delete[] buffer;
6611
6612 return ERROR_SUCCESS;
6613}
6614
6615BOOL EventPipeEventEnabledIncreaseMemoryPressure()
6616{
6617 return EventPipeEventIncreaseMemoryPressure->IsEnabled();
6618}
6619
6620extern "C" ULONG EventPipeWriteEventIncreaseMemoryPressure(
6621 const unsigned __int64 BytesAllocated,
6622 const unsigned short ClrInstanceID)
6623{
6624 if (!EventPipeEventEnabledIncreaseMemoryPressure())
6625 return ERROR_SUCCESS;
6626
6627 char stackBuffer[32];
6628 char *buffer = stackBuffer;
6629 size_t offset = 0;
6630 size_t size = 32;
6631 bool fixedBuffer = true;
6632
6633 bool success = true;
6634 success &= WriteToBuffer(BytesAllocated, buffer, offset, size, fixedBuffer);
6635 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6636
6637 if (!success)
6638 {
6639 if (!fixedBuffer)
6640 delete[] buffer;
6641 return ERROR_WRITE_FAULT;
6642 }
6643
6644 EventPipe::WriteEvent(*EventPipeEventIncreaseMemoryPressure, (BYTE *)buffer, (unsigned int)offset);
6645
6646 if (!fixedBuffer)
6647 delete[] buffer;
6648
6649 return ERROR_SUCCESS;
6650}
6651
6652BOOL EventPipeEventEnabledDecreaseMemoryPressure()
6653{
6654 return EventPipeEventDecreaseMemoryPressure->IsEnabled();
6655}
6656
6657extern "C" ULONG EventPipeWriteEventDecreaseMemoryPressure(
6658 const unsigned __int64 BytesFreed,
6659 const unsigned short ClrInstanceID)
6660{
6661 if (!EventPipeEventEnabledDecreaseMemoryPressure())
6662 return ERROR_SUCCESS;
6663
6664 char stackBuffer[32];
6665 char *buffer = stackBuffer;
6666 size_t offset = 0;
6667 size_t size = 32;
6668 bool fixedBuffer = true;
6669
6670 bool success = true;
6671 success &= WriteToBuffer(BytesFreed, buffer, offset, size, fixedBuffer);
6672 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6673
6674 if (!success)
6675 {
6676 if (!fixedBuffer)
6677 delete[] buffer;
6678 return ERROR_WRITE_FAULT;
6679 }
6680
6681 EventPipe::WriteEvent(*EventPipeEventDecreaseMemoryPressure, (BYTE *)buffer, (unsigned int)offset);
6682
6683 if (!fixedBuffer)
6684 delete[] buffer;
6685
6686 return ERROR_SUCCESS;
6687}
6688
6689BOOL EventPipeEventEnabledGCMarkWithType()
6690{
6691 return EventPipeEventGCMarkWithType->IsEnabled();
6692}
6693
6694extern "C" ULONG EventPipeWriteEventGCMarkWithType(
6695 const unsigned int HeapNum,
6696 const unsigned short ClrInstanceID,
6697 const unsigned int Type,
6698 const unsigned __int64 Bytes)
6699{
6700 if (!EventPipeEventEnabledGCMarkWithType())
6701 return ERROR_SUCCESS;
6702
6703 char stackBuffer[32];
6704 char *buffer = stackBuffer;
6705 size_t offset = 0;
6706 size_t size = 32;
6707 bool fixedBuffer = true;
6708
6709 bool success = true;
6710 success &= WriteToBuffer(HeapNum, buffer, offset, size, fixedBuffer);
6711 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6712 success &= WriteToBuffer(Type, buffer, offset, size, fixedBuffer);
6713 success &= WriteToBuffer(Bytes, buffer, offset, size, fixedBuffer);
6714
6715 if (!success)
6716 {
6717 if (!fixedBuffer)
6718 delete[] buffer;
6719 return ERROR_WRITE_FAULT;
6720 }
6721
6722 EventPipe::WriteEvent(*EventPipeEventGCMarkWithType, (BYTE *)buffer, (unsigned int)offset);
6723
6724 if (!fixedBuffer)
6725 delete[] buffer;
6726
6727 return ERROR_SUCCESS;
6728}
6729
6730BOOL EventPipeEventEnabledGCJoin_V2()
6731{
6732 return EventPipeEventGCJoin_V2->IsEnabled();
6733}
6734
6735extern "C" ULONG EventPipeWriteEventGCJoin_V2(
6736 const unsigned int Heap,
6737 const unsigned int JoinTime,
6738 const unsigned int JoinType,
6739 const unsigned short ClrInstanceID,
6740 const unsigned int JoinID)
6741{
6742 if (!EventPipeEventEnabledGCJoin_V2())
6743 return ERROR_SUCCESS;
6744
6745 char stackBuffer[32];
6746 char *buffer = stackBuffer;
6747 size_t offset = 0;
6748 size_t size = 32;
6749 bool fixedBuffer = true;
6750
6751 bool success = true;
6752 success &= WriteToBuffer(Heap, buffer, offset, size, fixedBuffer);
6753 success &= WriteToBuffer(JoinTime, buffer, offset, size, fixedBuffer);
6754 success &= WriteToBuffer(JoinType, buffer, offset, size, fixedBuffer);
6755 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6756 success &= WriteToBuffer(JoinID, buffer, offset, size, fixedBuffer);
6757
6758 if (!success)
6759 {
6760 if (!fixedBuffer)
6761 delete[] buffer;
6762 return ERROR_WRITE_FAULT;
6763 }
6764
6765 EventPipe::WriteEvent(*EventPipeEventGCJoin_V2, (BYTE *)buffer, (unsigned int)offset);
6766
6767 if (!fixedBuffer)
6768 delete[] buffer;
6769
6770 return ERROR_SUCCESS;
6771}
6772
6773BOOL EventPipeEventEnabledGCPerHeapHistory_V3()
6774{
6775 return EventPipeEventGCPerHeapHistory_V3->IsEnabled();
6776}
6777
6778extern "C" ULONG EventPipeWriteEventGCPerHeapHistory_V3(
6779 const unsigned short ClrInstanceID,
6780 const void* FreeListAllocated,
6781 const void* FreeListRejected,
6782 const void* EndOfSegAllocated,
6783 const void* CondemnedAllocated,
6784 const void* PinnedAllocated,
6785 const void* PinnedAllocatedAdvance,
6786 const unsigned int RunningFreeListEfficiency,
6787 const unsigned int CondemnReasons0,
6788 const unsigned int CondemnReasons1,
6789 const unsigned int CompactMechanisms,
6790 const unsigned int ExpandMechanisms,
6791 const unsigned int HeapIndex,
6792 const void* ExtraGen0Commit,
6793 const unsigned int Count,
6794 int Values_ElementSize,
6795 const void* Values)
6796{
6797 if (!EventPipeEventEnabledGCPerHeapHistory_V3())
6798 return ERROR_SUCCESS;
6799
6800 char stackBuffer[118];
6801 char *buffer = stackBuffer;
6802 size_t offset = 0;
6803 size_t size = 118;
6804 bool fixedBuffer = true;
6805
6806 bool success = true;
6807 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6808 success &= WriteToBuffer(FreeListAllocated, buffer, offset, size, fixedBuffer);
6809 success &= WriteToBuffer(FreeListRejected, buffer, offset, size, fixedBuffer);
6810 success &= WriteToBuffer(EndOfSegAllocated, buffer, offset, size, fixedBuffer);
6811 success &= WriteToBuffer(CondemnedAllocated, buffer, offset, size, fixedBuffer);
6812 success &= WriteToBuffer(PinnedAllocated, buffer, offset, size, fixedBuffer);
6813 success &= WriteToBuffer(PinnedAllocatedAdvance, buffer, offset, size, fixedBuffer);
6814 success &= WriteToBuffer(RunningFreeListEfficiency, buffer, offset, size, fixedBuffer);
6815 success &= WriteToBuffer(CondemnReasons0, buffer, offset, size, fixedBuffer);
6816 success &= WriteToBuffer(CondemnReasons1, buffer, offset, size, fixedBuffer);
6817 success &= WriteToBuffer(CompactMechanisms, buffer, offset, size, fixedBuffer);
6818 success &= WriteToBuffer(ExpandMechanisms, buffer, offset, size, fixedBuffer);
6819 success &= WriteToBuffer(HeapIndex, buffer, offset, size, fixedBuffer);
6820 success &= WriteToBuffer(ExtraGen0Commit, buffer, offset, size, fixedBuffer);
6821 success &= WriteToBuffer(Count, buffer, offset, size, fixedBuffer);
6822 success &= WriteToBuffer((const BYTE *)Values, (int)Values_ElementSize * (int)Count, buffer, offset, size, fixedBuffer);
6823
6824 if (!success)
6825 {
6826 if (!fixedBuffer)
6827 delete[] buffer;
6828 return ERROR_WRITE_FAULT;
6829 }
6830
6831 EventPipe::WriteEvent(*EventPipeEventGCPerHeapHistory_V3, (BYTE *)buffer, (unsigned int)offset);
6832
6833 if (!fixedBuffer)
6834 delete[] buffer;
6835
6836 return ERROR_SUCCESS;
6837}
6838
6839BOOL EventPipeEventEnabledGCGlobalHeapHistory_V2()
6840{
6841 return EventPipeEventGCGlobalHeapHistory_V2->IsEnabled();
6842}
6843
6844extern "C" ULONG EventPipeWriteEventGCGlobalHeapHistory_V2(
6845 const unsigned __int64 FinalYoungestDesired,
6846 const signed int NumHeaps,
6847 const unsigned int CondemnedGeneration,
6848 const unsigned int Gen0ReductionCount,
6849 const unsigned int Reason,
6850 const unsigned int GlobalMechanisms,
6851 const unsigned short ClrInstanceID,
6852 const unsigned int PauseMode,
6853 const unsigned int MemoryPressure)
6854{
6855 if (!EventPipeEventEnabledGCGlobalHeapHistory_V2())
6856 return ERROR_SUCCESS;
6857
6858 char stackBuffer[38];
6859 char *buffer = stackBuffer;
6860 size_t offset = 0;
6861 size_t size = 38;
6862 bool fixedBuffer = true;
6863
6864 bool success = true;
6865 success &= WriteToBuffer(FinalYoungestDesired, buffer, offset, size, fixedBuffer);
6866 success &= WriteToBuffer(NumHeaps, buffer, offset, size, fixedBuffer);
6867 success &= WriteToBuffer(CondemnedGeneration, buffer, offset, size, fixedBuffer);
6868 success &= WriteToBuffer(Gen0ReductionCount, buffer, offset, size, fixedBuffer);
6869 success &= WriteToBuffer(Reason, buffer, offset, size, fixedBuffer);
6870 success &= WriteToBuffer(GlobalMechanisms, buffer, offset, size, fixedBuffer);
6871 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6872 success &= WriteToBuffer(PauseMode, buffer, offset, size, fixedBuffer);
6873 success &= WriteToBuffer(MemoryPressure, buffer, offset, size, fixedBuffer);
6874
6875 if (!success)
6876 {
6877 if (!fixedBuffer)
6878 delete[] buffer;
6879 return ERROR_WRITE_FAULT;
6880 }
6881
6882 EventPipe::WriteEvent(*EventPipeEventGCGlobalHeapHistory_V2, (BYTE *)buffer, (unsigned int)offset);
6883
6884 if (!fixedBuffer)
6885 delete[] buffer;
6886
6887 return ERROR_SUCCESS;
6888}
6889
6890BOOL EventPipeEventEnabledDebugIPCEventStart()
6891{
6892 return EventPipeEventDebugIPCEventStart->IsEnabled();
6893}
6894
6895extern "C" ULONG EventPipeWriteEventDebugIPCEventStart()
6896{
6897 if (!EventPipeEventEnabledDebugIPCEventStart())
6898 return ERROR_SUCCESS;
6899 EventPipe::WriteEvent(*EventPipeEventDebugIPCEventStart, (BYTE*) nullptr, 0);
6900
6901 return ERROR_SUCCESS;
6902}
6903
6904BOOL EventPipeEventEnabledDebugIPCEventEnd()
6905{
6906 return EventPipeEventDebugIPCEventEnd->IsEnabled();
6907}
6908
6909extern "C" ULONG EventPipeWriteEventDebugIPCEventEnd()
6910{
6911 if (!EventPipeEventEnabledDebugIPCEventEnd())
6912 return ERROR_SUCCESS;
6913 EventPipe::WriteEvent(*EventPipeEventDebugIPCEventEnd, (BYTE*) nullptr, 0);
6914
6915 return ERROR_SUCCESS;
6916}
6917
6918BOOL EventPipeEventEnabledDebugExceptionProcessingStart()
6919{
6920 return EventPipeEventDebugExceptionProcessingStart->IsEnabled();
6921}
6922
6923extern "C" ULONG EventPipeWriteEventDebugExceptionProcessingStart()
6924{
6925 if (!EventPipeEventEnabledDebugExceptionProcessingStart())
6926 return ERROR_SUCCESS;
6927 EventPipe::WriteEvent(*EventPipeEventDebugExceptionProcessingStart, (BYTE*) nullptr, 0);
6928
6929 return ERROR_SUCCESS;
6930}
6931
6932BOOL EventPipeEventEnabledDebugExceptionProcessingEnd()
6933{
6934 return EventPipeEventDebugExceptionProcessingEnd->IsEnabled();
6935}
6936
6937extern "C" ULONG EventPipeWriteEventDebugExceptionProcessingEnd()
6938{
6939 if (!EventPipeEventEnabledDebugExceptionProcessingEnd())
6940 return ERROR_SUCCESS;
6941 EventPipe::WriteEvent(*EventPipeEventDebugExceptionProcessingEnd, (BYTE*) nullptr, 0);
6942
6943 return ERROR_SUCCESS;
6944}
6945
6946BOOL EventPipeEventEnabledCodeSymbols()
6947{
6948 return EventPipeEventCodeSymbols->IsEnabled();
6949}
6950
6951extern "C" ULONG EventPipeWriteEventCodeSymbols(
6952 const unsigned __int64 ModuleId,
6953 const unsigned short TotalChunks,
6954 const unsigned short ChunkNumber,
6955 const unsigned int ChunkLength,
6956 const BYTE* Chunk,
6957 const unsigned short ClrInstanceID)
6958{
6959 if (!EventPipeEventEnabledCodeSymbols())
6960 return ERROR_SUCCESS;
6961
6962 char stackBuffer[32];
6963 char *buffer = stackBuffer;
6964 size_t offset = 0;
6965 size_t size = 32;
6966 bool fixedBuffer = true;
6967
6968 bool success = true;
6969 success &= WriteToBuffer(ModuleId, buffer, offset, size, fixedBuffer);
6970 success &= WriteToBuffer(TotalChunks, buffer, offset, size, fixedBuffer);
6971 success &= WriteToBuffer(ChunkNumber, buffer, offset, size, fixedBuffer);
6972 success &= WriteToBuffer(ChunkLength, buffer, offset, size, fixedBuffer);
6973 success &= WriteToBuffer((const BYTE *)Chunk, sizeof(const BYTE) * (int)ChunkLength, buffer, offset, size, fixedBuffer);
6974 success &= WriteToBuffer(ClrInstanceID, buffer, offset, size, fixedBuffer);
6975
6976 if (!success)
6977 {
6978 if (!fixedBuffer)
6979 delete[] buffer;
6980 return ERROR_WRITE_FAULT;
6981 }
6982
6983 EventPipe::WriteEvent(*EventPipeEventCodeSymbols, (BYTE *)buffer, (unsigned int)offset);
6984
6985 if (!fixedBuffer)
6986 delete[] buffer;
6987
6988 return ERROR_SUCCESS;
6989}
6990
6991BOOL EventPipeEventEnabledEventSource()
6992{
6993 return EventPipeEventEventSource->IsEnabled();
6994}
6995
6996extern "C" ULONG EventPipeWriteEventEventSource(
6997 const signed int EventID,
6998 PCWSTR EventName,
6999 PCWSTR EventSourceName,
7000 PCWSTR Payload)
7001{
7002 if (!EventPipeEventEnabledEventSource())
7003 return ERROR_SUCCESS;
7004
7005 char stackBuffer[196];
7006 char *buffer = stackBuffer;
7007 size_t offset = 0;
7008 size_t size = 196;
7009 bool fixedBuffer = true;
7010
7011 bool success = true;
7012 success &= WriteToBuffer(EventID, buffer, offset, size, fixedBuffer);
7013 success &= WriteToBuffer(EventName, buffer, offset, size, fixedBuffer);
7014 success &= WriteToBuffer(EventSourceName, buffer, offset, size, fixedBuffer);
7015 success &= WriteToBuffer(Payload, buffer, offset, size, fixedBuffer);
7016
7017 if (!success)
7018 {
7019 if (!fixedBuffer)
7020 delete[] buffer;
7021 return ERROR_WRITE_FAULT;
7022 }
7023
7024 EventPipe::WriteEvent(*EventPipeEventEventSource, (BYTE *)buffer, (unsigned int)offset);
7025
7026 if (!fixedBuffer)
7027 delete[] buffer;
7028
7029 return ERROR_SUCCESS;
7030}
7031
7032extern "C" void InitDotNETRuntime()
7033{
7034 EventPipeProviderDotNETRuntime = EventPipe::CreateProvider(SL(DotNETRuntimeName), EventPipeEtwCallbackDotNETRuntime);
7035 EventPipeEventGCStart = EventPipeProviderDotNETRuntime->AddEvent(1,1,0,EventPipeEventLevel::Informational);
7036 EventPipeEventGCStart_V1 = EventPipeProviderDotNETRuntime->AddEvent(1,1,1,EventPipeEventLevel::Informational);
7037 EventPipeEventGCStart_V2 = EventPipeProviderDotNETRuntime->AddEvent(1,1,2,EventPipeEventLevel::Informational);
7038 EventPipeEventGCEnd = EventPipeProviderDotNETRuntime->AddEvent(2,1,0,EventPipeEventLevel::Informational);
7039 EventPipeEventGCEnd_V1 = EventPipeProviderDotNETRuntime->AddEvent(2,1,1,EventPipeEventLevel::Informational);
7040 EventPipeEventGCRestartEEEnd = EventPipeProviderDotNETRuntime->AddEvent(3,1,0,EventPipeEventLevel::Informational);
7041 EventPipeEventGCRestartEEEnd_V1 = EventPipeProviderDotNETRuntime->AddEvent(3,1,1,EventPipeEventLevel::Informational);
7042 EventPipeEventGCHeapStats = EventPipeProviderDotNETRuntime->AddEvent(4,1,0,EventPipeEventLevel::Informational);
7043 EventPipeEventGCHeapStats_V1 = EventPipeProviderDotNETRuntime->AddEvent(4,1,1,EventPipeEventLevel::Informational);
7044 EventPipeEventGCCreateSegment = EventPipeProviderDotNETRuntime->AddEvent(5,1,0,EventPipeEventLevel::Informational);
7045 EventPipeEventGCCreateSegment_V1 = EventPipeProviderDotNETRuntime->AddEvent(5,1,1,EventPipeEventLevel::Informational);
7046 EventPipeEventGCFreeSegment = EventPipeProviderDotNETRuntime->AddEvent(6,1,0,EventPipeEventLevel::Informational);
7047 EventPipeEventGCFreeSegment_V1 = EventPipeProviderDotNETRuntime->AddEvent(6,1,1,EventPipeEventLevel::Informational);
7048 EventPipeEventGCRestartEEBegin = EventPipeProviderDotNETRuntime->AddEvent(7,1,0,EventPipeEventLevel::Informational);
7049 EventPipeEventGCRestartEEBegin_V1 = EventPipeProviderDotNETRuntime->AddEvent(7,1,1,EventPipeEventLevel::Informational);
7050 EventPipeEventGCSuspendEEEnd = EventPipeProviderDotNETRuntime->AddEvent(8,1,0,EventPipeEventLevel::Informational);
7051 EventPipeEventGCSuspendEEEnd_V1 = EventPipeProviderDotNETRuntime->AddEvent(8,1,1,EventPipeEventLevel::Informational);
7052 EventPipeEventGCSuspendEEBegin = EventPipeProviderDotNETRuntime->AddEvent(9,1,0,EventPipeEventLevel::Informational);
7053 EventPipeEventGCSuspendEEBegin_V1 = EventPipeProviderDotNETRuntime->AddEvent(9,1,1,EventPipeEventLevel::Informational);
7054 EventPipeEventGCAllocationTick = EventPipeProviderDotNETRuntime->AddEvent(10,1,0,EventPipeEventLevel::Verbose);
7055 EventPipeEventGCAllocationTick_V1 = EventPipeProviderDotNETRuntime->AddEvent(10,1,1,EventPipeEventLevel::Verbose);
7056 EventPipeEventGCAllocationTick_V2 = EventPipeProviderDotNETRuntime->AddEvent(10,1,2,EventPipeEventLevel::Verbose);
7057 EventPipeEventGCAllocationTick_V3 = EventPipeProviderDotNETRuntime->AddEvent(10,1,3,EventPipeEventLevel::Verbose);
7058 EventPipeEventGCCreateConcurrentThread = EventPipeProviderDotNETRuntime->AddEvent(11,1,0,EventPipeEventLevel::Informational);
7059 EventPipeEventGCCreateConcurrentThread_V1 = EventPipeProviderDotNETRuntime->AddEvent(11,65537,1,EventPipeEventLevel::Informational);
7060 EventPipeEventGCTerminateConcurrentThread = EventPipeProviderDotNETRuntime->AddEvent(12,1,0,EventPipeEventLevel::Informational);
7061 EventPipeEventGCTerminateConcurrentThread_V1 = EventPipeProviderDotNETRuntime->AddEvent(12,65537,1,EventPipeEventLevel::Informational);
7062 EventPipeEventGCFinalizersEnd = EventPipeProviderDotNETRuntime->AddEvent(13,1,0,EventPipeEventLevel::Informational);
7063 EventPipeEventGCFinalizersEnd_V1 = EventPipeProviderDotNETRuntime->AddEvent(13,1,1,EventPipeEventLevel::Informational);
7064 EventPipeEventGCFinalizersBegin = EventPipeProviderDotNETRuntime->AddEvent(14,1,0,EventPipeEventLevel::Informational);
7065 EventPipeEventGCFinalizersBegin_V1 = EventPipeProviderDotNETRuntime->AddEvent(14,1,1,EventPipeEventLevel::Informational);
7066 EventPipeEventBulkType = EventPipeProviderDotNETRuntime->AddEvent(15,524288,0,EventPipeEventLevel::Informational);
7067 EventPipeEventGCBulkRootEdge = EventPipeProviderDotNETRuntime->AddEvent(16,1048576,0,EventPipeEventLevel::Informational);
7068 EventPipeEventGCBulkRootConditionalWeakTableElementEdge = EventPipeProviderDotNETRuntime->AddEvent(17,1048576,0,EventPipeEventLevel::Informational);
7069 EventPipeEventGCBulkNode = EventPipeProviderDotNETRuntime->AddEvent(18,1048576,0,EventPipeEventLevel::Informational);
7070 EventPipeEventGCBulkEdge = EventPipeProviderDotNETRuntime->AddEvent(19,1048576,0,EventPipeEventLevel::Informational);
7071 EventPipeEventGCSampledObjectAllocationHigh = EventPipeProviderDotNETRuntime->AddEvent(20,2097152,0,EventPipeEventLevel::Informational);
7072 EventPipeEventGCBulkSurvivingObjectRanges = EventPipeProviderDotNETRuntime->AddEvent(21,4194304,0,EventPipeEventLevel::Informational);
7073 EventPipeEventGCBulkMovedObjectRanges = EventPipeProviderDotNETRuntime->AddEvent(22,4194304,0,EventPipeEventLevel::Informational);
7074 EventPipeEventGCGenerationRange = EventPipeProviderDotNETRuntime->AddEvent(23,4194304,0,EventPipeEventLevel::Informational);
7075 EventPipeEventGCMarkStackRoots = EventPipeProviderDotNETRuntime->AddEvent(25,1,0,EventPipeEventLevel::Informational);
7076 EventPipeEventGCMarkFinalizeQueueRoots = EventPipeProviderDotNETRuntime->AddEvent(26,1,0,EventPipeEventLevel::Informational);
7077 EventPipeEventGCMarkHandles = EventPipeProviderDotNETRuntime->AddEvent(27,1,0,EventPipeEventLevel::Informational);
7078 EventPipeEventGCMarkOlderGenerationRoots = EventPipeProviderDotNETRuntime->AddEvent(28,1,0,EventPipeEventLevel::Informational);
7079 EventPipeEventFinalizeObject = EventPipeProviderDotNETRuntime->AddEvent(29,1,0,EventPipeEventLevel::Verbose);
7080 EventPipeEventSetGCHandle = EventPipeProviderDotNETRuntime->AddEvent(30,2,0,EventPipeEventLevel::Informational);
7081 EventPipeEventDestroyGCHandle = EventPipeProviderDotNETRuntime->AddEvent(31,2,0,EventPipeEventLevel::Informational);
7082 EventPipeEventGCSampledObjectAllocationLow = EventPipeProviderDotNETRuntime->AddEvent(32,33554432,0,EventPipeEventLevel::Informational);
7083 EventPipeEventPinObjectAtGCTime = EventPipeProviderDotNETRuntime->AddEvent(33,1,0,EventPipeEventLevel::Verbose);
7084 EventPipeEventGCTriggered = EventPipeProviderDotNETRuntime->AddEvent(35,1,0,EventPipeEventLevel::Informational);
7085 EventPipeEventGCBulkRootCCW = EventPipeProviderDotNETRuntime->AddEvent(36,1048576,0,EventPipeEventLevel::Informational);
7086 EventPipeEventGCBulkRCW = EventPipeProviderDotNETRuntime->AddEvent(37,1048576,0,EventPipeEventLevel::Informational);
7087 EventPipeEventGCBulkRootStaticVar = EventPipeProviderDotNETRuntime->AddEvent(38,1048576,0,EventPipeEventLevel::Informational);
7088 EventPipeEventGCDynamicEvent = EventPipeProviderDotNETRuntime->AddEvent(39,66060291,0,EventPipeEventLevel::LogAlways);
7089 EventPipeEventWorkerThreadCreate = EventPipeProviderDotNETRuntime->AddEvent(40,65536,0,EventPipeEventLevel::Informational);
7090 EventPipeEventWorkerThreadTerminate = EventPipeProviderDotNETRuntime->AddEvent(41,65536,0,EventPipeEventLevel::Informational);
7091 EventPipeEventWorkerThreadRetire = EventPipeProviderDotNETRuntime->AddEvent(42,65536,0,EventPipeEventLevel::Informational);
7092 EventPipeEventWorkerThreadUnretire = EventPipeProviderDotNETRuntime->AddEvent(43,65536,0,EventPipeEventLevel::Informational);
7093 EventPipeEventIOThreadCreate = EventPipeProviderDotNETRuntime->AddEvent(44,65536,0,EventPipeEventLevel::Informational);
7094 EventPipeEventIOThreadCreate_V1 = EventPipeProviderDotNETRuntime->AddEvent(44,65536,1,EventPipeEventLevel::Informational);
7095 EventPipeEventIOThreadTerminate = EventPipeProviderDotNETRuntime->AddEvent(45,65536,0,EventPipeEventLevel::Informational);
7096 EventPipeEventIOThreadTerminate_V1 = EventPipeProviderDotNETRuntime->AddEvent(45,65536,1,EventPipeEventLevel::Informational);
7097 EventPipeEventIOThreadRetire = EventPipeProviderDotNETRuntime->AddEvent(46,65536,0,EventPipeEventLevel::Informational);
7098 EventPipeEventIOThreadRetire_V1 = EventPipeProviderDotNETRuntime->AddEvent(46,65536,1,EventPipeEventLevel::Informational);
7099 EventPipeEventIOThreadUnretire = EventPipeProviderDotNETRuntime->AddEvent(47,65536,0,EventPipeEventLevel::Informational);
7100 EventPipeEventIOThreadUnretire_V1 = EventPipeProviderDotNETRuntime->AddEvent(47,65536,1,EventPipeEventLevel::Informational);
7101 EventPipeEventThreadpoolSuspensionSuspendThread = EventPipeProviderDotNETRuntime->AddEvent(48,65536,0,EventPipeEventLevel::Informational);
7102 EventPipeEventThreadpoolSuspensionResumeThread = EventPipeProviderDotNETRuntime->AddEvent(49,65536,0,EventPipeEventLevel::Informational);
7103 EventPipeEventThreadPoolWorkerThreadStart = EventPipeProviderDotNETRuntime->AddEvent(50,65536,0,EventPipeEventLevel::Informational);
7104 EventPipeEventThreadPoolWorkerThreadStop = EventPipeProviderDotNETRuntime->AddEvent(51,65536,0,EventPipeEventLevel::Informational);
7105 EventPipeEventThreadPoolWorkerThreadRetirementStart = EventPipeProviderDotNETRuntime->AddEvent(52,65536,0,EventPipeEventLevel::Informational);
7106 EventPipeEventThreadPoolWorkerThreadRetirementStop = EventPipeProviderDotNETRuntime->AddEvent(53,65536,0,EventPipeEventLevel::Informational);
7107 EventPipeEventThreadPoolWorkerThreadAdjustmentSample = EventPipeProviderDotNETRuntime->AddEvent(54,65536,0,EventPipeEventLevel::Informational);
7108 EventPipeEventThreadPoolWorkerThreadAdjustmentAdjustment = EventPipeProviderDotNETRuntime->AddEvent(55,65536,0,EventPipeEventLevel::Informational);
7109 EventPipeEventThreadPoolWorkerThreadAdjustmentStats = EventPipeProviderDotNETRuntime->AddEvent(56,65536,0,EventPipeEventLevel::Verbose);
7110 EventPipeEventThreadPoolWorkerThreadWait = EventPipeProviderDotNETRuntime->AddEvent(57,65536,0,EventPipeEventLevel::Informational);
7111 EventPipeEventThreadPoolWorkingThreadCount = EventPipeProviderDotNETRuntime->AddEvent(60,65536,0,EventPipeEventLevel::Verbose);
7112 EventPipeEventThreadPoolEnqueue = EventPipeProviderDotNETRuntime->AddEvent(61,2147549184,0,EventPipeEventLevel::Verbose);
7113 EventPipeEventThreadPoolDequeue = EventPipeProviderDotNETRuntime->AddEvent(62,2147549184,0,EventPipeEventLevel::Verbose);
7114 EventPipeEventThreadPoolIOEnqueue = EventPipeProviderDotNETRuntime->AddEvent(63,2147549184,0,EventPipeEventLevel::Verbose);
7115 EventPipeEventThreadPoolIODequeue = EventPipeProviderDotNETRuntime->AddEvent(64,2147549184,0,EventPipeEventLevel::Verbose);
7116 EventPipeEventThreadPoolIOPack = EventPipeProviderDotNETRuntime->AddEvent(65,65536,0,EventPipeEventLevel::Verbose);
7117 EventPipeEventThreadCreating = EventPipeProviderDotNETRuntime->AddEvent(70,2147549184,0,EventPipeEventLevel::Informational);
7118 EventPipeEventThreadRunning = EventPipeProviderDotNETRuntime->AddEvent(71,2147549184,0,EventPipeEventLevel::Informational);
7119 EventPipeEventExceptionThrown = EventPipeProviderDotNETRuntime->AddEvent(80,0,0,EventPipeEventLevel::Informational);
7120 EventPipeEventExceptionThrown_V1 = EventPipeProviderDotNETRuntime->AddEvent(80,8589967360,1,EventPipeEventLevel::Error);
7121 EventPipeEventExceptionCatchStart = EventPipeProviderDotNETRuntime->AddEvent(250,32768,0,EventPipeEventLevel::Informational);
7122 EventPipeEventExceptionCatchStop = EventPipeProviderDotNETRuntime->AddEvent(251,32768,0,EventPipeEventLevel::Informational);
7123 EventPipeEventExceptionFinallyStart = EventPipeProviderDotNETRuntime->AddEvent(252,32768,0,EventPipeEventLevel::Informational);
7124 EventPipeEventExceptionFinallyStop = EventPipeProviderDotNETRuntime->AddEvent(253,32768,0,EventPipeEventLevel::Informational);
7125 EventPipeEventExceptionFilterStart = EventPipeProviderDotNETRuntime->AddEvent(254,32768,0,EventPipeEventLevel::Informational);
7126 EventPipeEventExceptionFilterStop = EventPipeProviderDotNETRuntime->AddEvent(255,32768,0,EventPipeEventLevel::Informational);
7127 EventPipeEventExceptionThrownStop = EventPipeProviderDotNETRuntime->AddEvent(256,32768,0,EventPipeEventLevel::Informational);
7128 EventPipeEventContention = EventPipeProviderDotNETRuntime->AddEvent(81,0,0,EventPipeEventLevel::Informational);
7129 EventPipeEventContentionStart_V1 = EventPipeProviderDotNETRuntime->AddEvent(81,16384,1,EventPipeEventLevel::Informational);
7130 EventPipeEventContentionStop = EventPipeProviderDotNETRuntime->AddEvent(91,16384,0,EventPipeEventLevel::Informational);
7131 EventPipeEventCLRStackWalk = EventPipeProviderDotNETRuntime->AddEvent(82,1073741824,0,EventPipeEventLevel::LogAlways);
7132 EventPipeEventAppDomainMemAllocated = EventPipeProviderDotNETRuntime->AddEvent(83,2048,0,EventPipeEventLevel::Informational);
7133 EventPipeEventAppDomainMemSurvived = EventPipeProviderDotNETRuntime->AddEvent(84,2048,0,EventPipeEventLevel::Informational);
7134 EventPipeEventThreadCreated = EventPipeProviderDotNETRuntime->AddEvent(85,67584,0,EventPipeEventLevel::Informational);
7135 EventPipeEventThreadTerminated = EventPipeProviderDotNETRuntime->AddEvent(86,67584,0,EventPipeEventLevel::Informational);
7136 EventPipeEventThreadDomainEnter = EventPipeProviderDotNETRuntime->AddEvent(87,67584,0,EventPipeEventLevel::Informational);
7137 EventPipeEventILStubGenerated = EventPipeProviderDotNETRuntime->AddEvent(88,8192,0,EventPipeEventLevel::Informational);
7138 EventPipeEventILStubCacheHit = EventPipeProviderDotNETRuntime->AddEvent(89,8192,0,EventPipeEventLevel::Informational);
7139 EventPipeEventDCStartCompleteV2 = EventPipeProviderDotNETRuntime->AddEvent(135,48,0,EventPipeEventLevel::Informational);
7140 EventPipeEventDCEndCompleteV2 = EventPipeProviderDotNETRuntime->AddEvent(136,48,0,EventPipeEventLevel::Informational);
7141 EventPipeEventMethodDCStartV2 = EventPipeProviderDotNETRuntime->AddEvent(137,48,0,EventPipeEventLevel::Informational);
7142 EventPipeEventMethodDCEndV2 = EventPipeProviderDotNETRuntime->AddEvent(138,48,0,EventPipeEventLevel::Informational);
7143 EventPipeEventMethodDCStartVerboseV2 = EventPipeProviderDotNETRuntime->AddEvent(139,48,0,EventPipeEventLevel::Informational);
7144 EventPipeEventMethodDCEndVerboseV2 = EventPipeProviderDotNETRuntime->AddEvent(140,48,0,EventPipeEventLevel::Informational);
7145 EventPipeEventMethodLoad = EventPipeProviderDotNETRuntime->AddEvent(141,48,0,EventPipeEventLevel::Informational);
7146 EventPipeEventMethodLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(141,48,1,EventPipeEventLevel::Informational);
7147 EventPipeEventMethodLoad_V2 = EventPipeProviderDotNETRuntime->AddEvent(141,48,2,EventPipeEventLevel::Informational);
7148 EventPipeEventMethodUnload = EventPipeProviderDotNETRuntime->AddEvent(142,48,0,EventPipeEventLevel::Informational);
7149 EventPipeEventMethodUnload_V1 = EventPipeProviderDotNETRuntime->AddEvent(142,48,1,EventPipeEventLevel::Informational);
7150 EventPipeEventMethodUnload_V2 = EventPipeProviderDotNETRuntime->AddEvent(142,48,2,EventPipeEventLevel::Informational);
7151 EventPipeEventMethodLoadVerbose = EventPipeProviderDotNETRuntime->AddEvent(143,48,0,EventPipeEventLevel::Informational);
7152 EventPipeEventMethodLoadVerbose_V1 = EventPipeProviderDotNETRuntime->AddEvent(143,48,1,EventPipeEventLevel::Informational);
7153 EventPipeEventMethodLoadVerbose_V2 = EventPipeProviderDotNETRuntime->AddEvent(143,48,2,EventPipeEventLevel::Informational);
7154 EventPipeEventMethodUnloadVerbose = EventPipeProviderDotNETRuntime->AddEvent(144,48,0,EventPipeEventLevel::Informational);
7155 EventPipeEventMethodUnloadVerbose_V1 = EventPipeProviderDotNETRuntime->AddEvent(144,48,1,EventPipeEventLevel::Informational);
7156 EventPipeEventMethodUnloadVerbose_V2 = EventPipeProviderDotNETRuntime->AddEvent(144,48,2,EventPipeEventLevel::Informational);
7157 EventPipeEventMethodJittingStarted = EventPipeProviderDotNETRuntime->AddEvent(145,16,0,EventPipeEventLevel::Verbose);
7158 EventPipeEventMethodJittingStarted_V1 = EventPipeProviderDotNETRuntime->AddEvent(145,16,1,EventPipeEventLevel::Verbose);
7159 EventPipeEventMethodJitInliningSucceeded = EventPipeProviderDotNETRuntime->AddEvent(185,4096,0,EventPipeEventLevel::Verbose);
7160 EventPipeEventMethodJitInliningFailedAnsi = EventPipeProviderDotNETRuntime->AddEvent(186,4096,0,EventPipeEventLevel::Verbose);
7161 EventPipeEventMethodJitTailCallSucceeded = EventPipeProviderDotNETRuntime->AddEvent(188,4096,0,EventPipeEventLevel::Verbose);
7162 EventPipeEventMethodJitTailCallFailedAnsi = EventPipeProviderDotNETRuntime->AddEvent(189,4096,0,EventPipeEventLevel::Verbose);
7163 EventPipeEventMethodILToNativeMap = EventPipeProviderDotNETRuntime->AddEvent(190,131072,0,EventPipeEventLevel::Verbose);
7164 EventPipeEventMethodJitTailCallFailed = EventPipeProviderDotNETRuntime->AddEvent(191,4096,0,EventPipeEventLevel::Verbose);
7165 EventPipeEventMethodJitInliningFailed = EventPipeProviderDotNETRuntime->AddEvent(192,4096,0,EventPipeEventLevel::Verbose);
7166 EventPipeEventModuleDCStartV2 = EventPipeProviderDotNETRuntime->AddEvent(149,8,0,EventPipeEventLevel::Informational);
7167 EventPipeEventModuleDCEndV2 = EventPipeProviderDotNETRuntime->AddEvent(150,8,0,EventPipeEventLevel::Informational);
7168 EventPipeEventDomainModuleLoad = EventPipeProviderDotNETRuntime->AddEvent(151,8,0,EventPipeEventLevel::Informational);
7169 EventPipeEventDomainModuleLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(151,8,1,EventPipeEventLevel::Informational);
7170 EventPipeEventModuleLoad = EventPipeProviderDotNETRuntime->AddEvent(152,8,0,EventPipeEventLevel::Informational);
7171 EventPipeEventModuleLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(152,536870920,1,EventPipeEventLevel::Informational);
7172 EventPipeEventModuleLoad_V2 = EventPipeProviderDotNETRuntime->AddEvent(152,536870920,2,EventPipeEventLevel::Informational);
7173 EventPipeEventModuleUnload = EventPipeProviderDotNETRuntime->AddEvent(153,8,0,EventPipeEventLevel::Informational);
7174 EventPipeEventModuleUnload_V1 = EventPipeProviderDotNETRuntime->AddEvent(153,536870920,1,EventPipeEventLevel::Informational);
7175 EventPipeEventModuleUnload_V2 = EventPipeProviderDotNETRuntime->AddEvent(153,536870920,2,EventPipeEventLevel::Informational);
7176 EventPipeEventAssemblyLoad = EventPipeProviderDotNETRuntime->AddEvent(154,8,0,EventPipeEventLevel::Informational);
7177 EventPipeEventAssemblyLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(154,8,1,EventPipeEventLevel::Informational);
7178 EventPipeEventAssemblyUnload = EventPipeProviderDotNETRuntime->AddEvent(155,8,0,EventPipeEventLevel::Informational);
7179 EventPipeEventAssemblyUnload_V1 = EventPipeProviderDotNETRuntime->AddEvent(155,8,1,EventPipeEventLevel::Informational);
7180 EventPipeEventAppDomainLoad = EventPipeProviderDotNETRuntime->AddEvent(156,8,0,EventPipeEventLevel::Informational);
7181 EventPipeEventAppDomainLoad_V1 = EventPipeProviderDotNETRuntime->AddEvent(156,8,1,EventPipeEventLevel::Informational);
7182 EventPipeEventAppDomainUnload = EventPipeProviderDotNETRuntime->AddEvent(157,8,0,EventPipeEventLevel::Informational);
7183 EventPipeEventAppDomainUnload_V1 = EventPipeProviderDotNETRuntime->AddEvent(157,8,1,EventPipeEventLevel::Informational);
7184 EventPipeEventModuleRangeLoad = EventPipeProviderDotNETRuntime->AddEvent(158,536870912,0,EventPipeEventLevel::Informational);
7185 EventPipeEventStrongNameVerificationStart = EventPipeProviderDotNETRuntime->AddEvent(181,1024,0,EventPipeEventLevel::Verbose);
7186 EventPipeEventStrongNameVerificationStart_V1 = EventPipeProviderDotNETRuntime->AddEvent(181,1024,1,EventPipeEventLevel::Verbose);
7187 EventPipeEventStrongNameVerificationStop = EventPipeProviderDotNETRuntime->AddEvent(182,1024,0,EventPipeEventLevel::Informational);
7188 EventPipeEventStrongNameVerificationStop_V1 = EventPipeProviderDotNETRuntime->AddEvent(182,1024,1,EventPipeEventLevel::Informational);
7189 EventPipeEventAuthenticodeVerificationStart = EventPipeProviderDotNETRuntime->AddEvent(183,1024,0,EventPipeEventLevel::Verbose);
7190 EventPipeEventAuthenticodeVerificationStart_V1 = EventPipeProviderDotNETRuntime->AddEvent(183,1024,1,EventPipeEventLevel::Verbose);
7191 EventPipeEventAuthenticodeVerificationStop = EventPipeProviderDotNETRuntime->AddEvent(184,1024,0,EventPipeEventLevel::Informational);
7192 EventPipeEventAuthenticodeVerificationStop_V1 = EventPipeProviderDotNETRuntime->AddEvent(184,1024,1,EventPipeEventLevel::Informational);
7193 EventPipeEventRuntimeInformationStart = EventPipeProviderDotNETRuntime->AddEvent(187,0,0,EventPipeEventLevel::Informational);
7194 EventPipeEventIncreaseMemoryPressure = EventPipeProviderDotNETRuntime->AddEvent(200,1,0,EventPipeEventLevel::Verbose);
7195 EventPipeEventDecreaseMemoryPressure = EventPipeProviderDotNETRuntime->AddEvent(201,1,0,EventPipeEventLevel::Verbose);
7196 EventPipeEventGCMarkWithType = EventPipeProviderDotNETRuntime->AddEvent(202,1,0,EventPipeEventLevel::Informational);
7197 EventPipeEventGCJoin_V2 = EventPipeProviderDotNETRuntime->AddEvent(203,1,2,EventPipeEventLevel::Verbose);
7198 EventPipeEventGCPerHeapHistory_V3 = EventPipeProviderDotNETRuntime->AddEvent(204,1,3,EventPipeEventLevel::Informational);
7199 EventPipeEventGCGlobalHeapHistory_V2 = EventPipeProviderDotNETRuntime->AddEvent(205,1,2,EventPipeEventLevel::Informational);
7200 EventPipeEventDebugIPCEventStart = EventPipeProviderDotNETRuntime->AddEvent(240,4294967296,0,EventPipeEventLevel::Informational);
7201 EventPipeEventDebugIPCEventEnd = EventPipeProviderDotNETRuntime->AddEvent(241,4294967296,0,EventPipeEventLevel::Informational);
7202 EventPipeEventDebugExceptionProcessingStart = EventPipeProviderDotNETRuntime->AddEvent(242,4294967296,0,EventPipeEventLevel::Informational);
7203 EventPipeEventDebugExceptionProcessingEnd = EventPipeProviderDotNETRuntime->AddEvent(243,4294967296,0,EventPipeEventLevel::Informational);
7204 EventPipeEventCodeSymbols = EventPipeProviderDotNETRuntime->AddEvent(260,17179869184,0,EventPipeEventLevel::Verbose);
7205 EventPipeEventEventSource = EventPipeProviderDotNETRuntime->AddEvent(270,34359738368,0,EventPipeEventLevel::Informational);
7206}
7207