blob: 2978412325c8774b04a48149360c979004712621 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
#ifndef __EVENTPIPE_H__
#define __EVENTPIPE_H__
#include "common.h"
class EventPipeJsonFile;
// The data fields common to every event.
struct CommonEventFields
{
// Timestamp generated by QueryPerformanceCounter.
LARGE_INTEGER TimeStamp;
// Thread ID.
DWORD ThreadID;
};
class StackContents
{
private:
const static unsigned int MAX_STACK_DEPTH = 100;
// Array of IP values from a stack crawl.
// Top of stack is at index 0.
UINT_PTR m_stackFrames[MAX_STACK_DEPTH];
// Parallel array of MethodDesc pointers.
// Used for debug-only stack printing.
MethodDesc* m_methods[MAX_STACK_DEPTH];
// The next available slot in StackFrames.
unsigned int m_nextAvailableFrame;
public:
StackContents()
{
LIMITED_METHOD_CONTRACT;
Reset();
}
void Reset()
{
LIMITED_METHOD_CONTRACT;
m_nextAvailableFrame = 0;
}
bool IsEmpty()
{
LIMITED_METHOD_CONTRACT;
return (m_nextAvailableFrame == 0);
}
unsigned int GetLength()
{
LIMITED_METHOD_CONTRACT;
return m_nextAvailableFrame;
}
UINT_PTR GetIP(unsigned int frameIndex)
{
LIMITED_METHOD_CONTRACT;
_ASSERTE(frameIndex < MAX_STACK_DEPTH);
if (frameIndex >= MAX_STACK_DEPTH)
{
return 0;
}
return m_stackFrames[frameIndex];
}
MethodDesc* GetMethod(unsigned int frameIndex)
{
LIMITED_METHOD_CONTRACT;
_ASSERTE(frameIndex < MAX_STACK_DEPTH);
if (frameIndex >= MAX_STACK_DEPTH)
{
return NULL;
}
return m_methods[frameIndex];
}
void Append(UINT_PTR controlPC, MethodDesc *pMethod)
{
LIMITED_METHOD_CONTRACT;
if(m_nextAvailableFrame < MAX_STACK_DEPTH)
{
m_stackFrames[m_nextAvailableFrame] = controlPC;
m_methods[m_nextAvailableFrame] = pMethod;
m_nextAvailableFrame++;
}
}
};
class EventPipe
{
public:
// Initialize the event pipe.
static void Initialize();
// Shutdown the event pipe.
static void Shutdown();
// Enable tracing from the start-up path based on COMPLUS variable.
static void EnableOnStartup();
// Enable tracing via the event pipe.
static void Enable();
// Disable tracing via the event pipe.
static void Disable();
// Determine whether or not the specified provider/keyword combination is enabled.
static bool EventEnabled(GUID& providerID, INT64 keyword);
// Write out an event. The event is identified by the providerID/eventID pair.
// Data is written as a serialized blob matching the ETW serialization conventions.
static void WriteEvent(GUID& providerID, INT64 eventID, BYTE *pData, size_t length, bool sampleStack);
// Write out a sample profile event with the specified stack.
static void WriteSampleProfileEvent(Thread *pThread, StackContents &stackContents);
// Get the managed call stack for the current thread.
static bool WalkManagedStackForCurrentThread(StackContents &stackContents);
// Get the managed call stack for the specified thread.
static bool WalkManagedStackForThread(Thread *pThread, StackContents &stackContents);
private:
// Callback function for the stack walker. For each frame walked, this callback is invoked.
static StackWalkAction StackWalkCallback(CrawlFrame *pCf, StackContents *pData);
static CrstStatic s_initCrst;
static bool s_tracingInitialized;
static bool s_tracingEnabled;
static EventPipeJsonFile *s_pJsonFile;
};
#endif // __EVENTPIPE_H__
|
