OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "base/trace_event/trace_event_etw_export_win.h" | |
6 | |
7 #include "base/command_line.h" | |
8 #include "base/logging.h" | |
9 #include "base/memory/singleton.h" | |
10 #include "base/strings/utf_string_conversions.h" | |
11 #include "base/trace_event/trace_event.h" | |
12 #include "base/trace_event/trace_event_impl.h" | |
13 | |
14 // The GetProcAddress technique is borrowed from | |
15 // https://github.com/someonegg/heap_monitor/tree/master/MultiProvider | |
brucedawson
2015/03/29 20:39:22
Can you update this reference to this address:
htt
Georges Khalil
2015/03/30 14:50:05
Oops, didn't know that it was copied, should have
| |
16 // | |
17 // EVNTAPI is used in evntprov.h which is included by chrome_events_win.h. | |
18 // We define EVNTAPI without the DECLSPEC_IMPORT specifier so that we can | |
19 // implement these functions locally instead of using the import library, and | |
20 // can therefore still run on Windows XP. | |
21 #define EVNTAPI __stdcall | |
22 // Include the event register/write/unregister macros compiled from the manifest | |
23 // file. Note that this includes evntprov.h which requires a Vista+ Windows SDK. | |
24 #include "base/trace_event/etw_manifest/chrome_events_win.h" // In SHARED_INTER MEDIATE_DIR. NOLINT. | |
brucedawson
2015/03/29 20:39:22
Move the comment to stay in line limits?
Georges Khalil
2015/03/30 14:50:05
Done.
- Moved In SHARED_INTERMEDIATE_DIR to earli
| |
25 | |
26 namespace { | |
27 // Typedefs for use with GetProcAddress | |
28 typedef ULONG(__stdcall* tEventRegister)(LPCGUID ProviderId, | |
29 PENABLECALLBACK EnableCallback, | |
30 PVOID CallbackContext, | |
31 PREGHANDLE RegHandle); | |
32 typedef ULONG(__stdcall* tEventWrite)(REGHANDLE RegHandle, | |
33 PCEVENT_DESCRIPTOR EventDescriptor, | |
34 ULONG UserDataCount, | |
35 PEVENT_DATA_DESCRIPTOR UserData); | |
36 typedef ULONG(__stdcall* tEventUnregister)(REGHANDLE RegHandle); | |
37 | |
38 tEventRegister EventRegisterProc = nullptr; | |
39 tEventWrite EventWriteProc = nullptr; | |
40 tEventUnregister EventUnregisterProc = nullptr; | |
41 } // namespace | |
42 | |
43 // Redirector function for EventRegister. Called by macros in | |
44 // chrome_events_win.h | |
45 ULONG EVNTAPI EventRegister(LPCGUID ProviderId, | |
46 PENABLECALLBACK EnableCallback, | |
47 PVOID CallbackContext, | |
48 PREGHANDLE RegHandle) { | |
49 if (EventRegisterProc) | |
50 return EventRegisterProc(ProviderId, EnableCallback, CallbackContext, | |
51 RegHandle); | |
52 return 0; | |
53 } | |
54 | |
55 // Redirector function for EventWrite. Called by macros in | |
56 // chrome_events_win.h | |
57 ULONG EVNTAPI EventWrite(REGHANDLE RegHandle, | |
58 PCEVENT_DESCRIPTOR EventDescriptor, | |
59 ULONG UserDataCount, | |
60 PEVENT_DATA_DESCRIPTOR UserData) { | |
61 if (EventWriteProc) | |
62 return EventWriteProc(RegHandle, EventDescriptor, UserDataCount, UserData); | |
63 return 0; | |
64 } | |
65 | |
66 // Redirector function for EventUnregister. Called by macros in | |
67 // chrome_events_win.h | |
68 ULONG EVNTAPI EventUnregister(REGHANDLE RegHandle) { | |
69 if (EventUnregisterProc) | |
70 return EventUnregisterProc(RegHandle); | |
71 return 0; | |
72 } | |
73 | |
74 namespace base { | |
75 namespace trace_event { | |
76 | |
77 TraceEventETWExport::TraceEventETWExport() : ETWExportEnabled_(false) { | |
78 // Find Advapi32.dll. This should always succeed. | |
79 HMODULE AdvapiDLL = ::LoadLibraryW(L"Advapi32.dll"); | |
80 if (AdvapiDLL) { | |
81 // Try to find the ETW functions. This will fail on XP. | |
82 EventRegisterProc = reinterpret_cast<tEventRegister>( | |
83 ::GetProcAddress(AdvapiDLL, "EventRegister")); | |
84 EventWriteProc = reinterpret_cast<tEventWrite>( | |
85 ::GetProcAddress(AdvapiDLL, "EventWrite")); | |
86 EventUnregisterProc = reinterpret_cast<tEventUnregister>( | |
87 ::GetProcAddress(AdvapiDLL, "EventUnregister")); | |
88 | |
89 // Register the ETW provider. If registration fails then the event logging | |
90 // calls will fail (on XP this call will do nothing). | |
91 EventRegisterChrome(); | |
92 } | |
93 } | |
94 | |
95 TraceEventETWExport::~TraceEventETWExport() { | |
96 EventUnregisterChrome(); | |
97 } | |
98 | |
99 // static | |
100 TraceEventETWExport* TraceEventETWExport::GetInstance() { | |
101 return Singleton<TraceEventETWExport, | |
102 StaticMemorySingletonTraits<TraceEventETWExport>>::get(); | |
103 } | |
104 | |
105 // static | |
106 void TraceEventETWExport::EnableETWExport() { | |
107 GetInstance()->ETWExportEnabled_ = true; | |
108 } | |
109 | |
110 // static | |
111 void TraceEventETWExport::DisableETWExport() { | |
112 GetInstance()->ETWExportEnabled_ = false; | |
113 } | |
114 | |
115 // static | |
116 void TraceEventETWExport::AddEvent( | |
117 char phase, | |
118 const unsigned char* category_group_enabled, | |
119 const char* name, | |
120 unsigned long long id, | |
121 int num_args, | |
122 const char** arg_names, | |
123 const unsigned char* arg_types, | |
124 const unsigned long long* arg_values, | |
125 const scoped_refptr<ConvertableToTraceFormat>* convertable_values) { | |
126 // We bail early in case exporting is disabled or no consumer is listening. | |
127 if (!GetInstance()->ETWExportEnabled_ || !EventEnabledChromeEvent()) | |
128 return; | |
129 | |
130 std::string phase_string; | |
131 switch (phase) { | |
132 case TRACE_EVENT_PHASE_BEGIN: | |
133 phase_string = "Begin"; | |
134 break; | |
135 case TRACE_EVENT_PHASE_END: | |
136 phase_string = "End"; | |
137 break; | |
138 case TRACE_EVENT_PHASE_COMPLETE: | |
139 phase_string = "Complete"; | |
140 break; | |
141 case TRACE_EVENT_PHASE_INSTANT: | |
142 phase_string = "Instant"; | |
143 break; | |
144 case TRACE_EVENT_PHASE_ASYNC_BEGIN: | |
145 phase_string = "Async Begin"; | |
146 break; | |
147 case TRACE_EVENT_PHASE_ASYNC_STEP_INTO: | |
148 phase_string = "Async Step Into"; | |
149 break; | |
150 case TRACE_EVENT_PHASE_ASYNC_STEP_PAST: | |
151 phase_string = "Async Step Past"; | |
152 break; | |
153 case TRACE_EVENT_PHASE_ASYNC_END: | |
154 phase_string = "Async End"; | |
155 break; | |
156 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN: | |
157 phase_string = "Nestable Async Begin"; | |
158 break; | |
159 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_END: | |
160 phase_string = "Nestable Async End"; | |
161 break; | |
162 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT: | |
163 phase_string = "Nestable Async Instant"; | |
164 break; | |
165 case TRACE_EVENT_PHASE_FLOW_BEGIN: | |
166 phase_string = "Phase Flow Begin"; | |
167 break; | |
168 case TRACE_EVENT_PHASE_FLOW_STEP: | |
169 phase_string = "Phase Flow Step"; | |
170 break; | |
171 case TRACE_EVENT_PHASE_FLOW_END: | |
172 phase_string = "Phase Flow End"; | |
173 break; | |
174 case TRACE_EVENT_PHASE_METADATA: | |
175 phase_string = "Phase Metadata"; | |
176 break; | |
177 case TRACE_EVENT_PHASE_COUNTER: | |
178 phase_string = "Phase Counter"; | |
179 break; | |
180 case TRACE_EVENT_PHASE_SAMPLE: | |
181 phase_string = "Phase Sample"; | |
182 break; | |
183 case TRACE_EVENT_PHASE_CREATE_OBJECT: | |
184 phase_string = "Phase Create Object"; | |
185 break; | |
186 case TRACE_EVENT_PHASE_SNAPSHOT_OBJECT: | |
187 phase_string = "Phase Snapshot Object"; | |
188 break; | |
189 case TRACE_EVENT_PHASE_DELETE_OBJECT: | |
190 phase_string = "Phase Delete Object"; | |
191 break; | |
192 default: | |
193 phase_string.push_back(phase); | |
194 break; | |
195 } | |
196 | |
197 std::string arg_values_string[3]; | |
198 for (int i = 0; i < num_args; i++) { | |
199 if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE) { | |
200 convertable_values[i]->AppendAsTraceFormat(arg_values_string + i); | |
201 } else { | |
202 TraceEvent::TraceValue trace_event; | |
203 trace_event.as_uint = arg_values[i]; | |
204 TraceEvent::AppendValueAsJSON(arg_types[i], trace_event, | |
205 arg_values_string + i); | |
206 } | |
207 } | |
208 | |
209 EventWriteChromeEvent( | |
210 name, phase_string.c_str(), num_args > 0 ? arg_names[0] : "", | |
211 arg_values_string[0].c_str(), num_args > 1 ? arg_names[1] : "", | |
212 arg_values_string[1].c_str(), num_args > 2 ? arg_names[2] : "", | |
213 arg_values_string[2].c_str()); | |
214 } | |
215 | |
216 // static | |
217 void TraceEventETWExport::AddCustomEvent(const char* name, | |
218 char const* phase, | |
219 const char* arg_name_1, | |
220 const char* arg_value_1, | |
221 const char* arg_name_2, | |
222 const char* arg_value_2, | |
223 const char* arg_name_3, | |
224 const char* arg_value_3) { | |
225 if (!GetInstance()->ETWExportEnabled_ || !EventEnabledChromeEvent()) | |
226 return; | |
227 | |
228 EventWriteChromeEvent(name, phase, arg_name_1, arg_value_1, arg_name_2, | |
229 arg_value_2, arg_name_3, arg_value_3); | |
230 } | |
231 | |
232 void TraceEventETWExport::Resurrect() { | |
233 StaticMemorySingletonTraits<TraceEventETWExport>::Resurrect(); | |
234 } | |
235 | |
236 } // namespace trace_event | |
237 } // namespace base | |
OLD | NEW |