| 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/randomascii/main/tree/master/xperf/ETWProviders | |
| 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 // | |
| 25 // In SHARED_INTERMEDIATE_DIR. | |
| 26 #include "base/trace_event/etw_manifest/chrome_events_win.h" // NOLINT | |
| 27 | |
| 28 namespace { | |
| 29 // Typedefs for use with GetProcAddress | |
| 30 typedef ULONG(__stdcall* tEventRegister)(LPCGUID ProviderId, | |
| 31 PENABLECALLBACK EnableCallback, | |
| 32 PVOID CallbackContext, | |
| 33 PREGHANDLE RegHandle); | |
| 34 typedef ULONG(__stdcall* tEventWrite)(REGHANDLE RegHandle, | |
| 35 PCEVENT_DESCRIPTOR EventDescriptor, | |
| 36 ULONG UserDataCount, | |
| 37 PEVENT_DATA_DESCRIPTOR UserData); | |
| 38 typedef ULONG(__stdcall* tEventUnregister)(REGHANDLE RegHandle); | |
| 39 | |
| 40 tEventRegister EventRegisterProc = nullptr; | |
| 41 tEventWrite EventWriteProc = nullptr; | |
| 42 tEventUnregister EventUnregisterProc = nullptr; | |
| 43 } // namespace | |
| 44 | |
| 45 // Redirector function for EventRegister. Called by macros in | |
| 46 // chrome_events_win.h | |
| 47 ULONG EVNTAPI EventRegister(LPCGUID ProviderId, | |
| 48 PENABLECALLBACK EnableCallback, | |
| 49 PVOID CallbackContext, | |
| 50 PREGHANDLE RegHandle) { | |
| 51 if (EventRegisterProc) | |
| 52 return EventRegisterProc(ProviderId, EnableCallback, CallbackContext, | |
| 53 RegHandle); | |
| 54 return 0; | |
| 55 } | |
| 56 | |
| 57 // Redirector function for EventWrite. Called by macros in | |
| 58 // chrome_events_win.h | |
| 59 ULONG EVNTAPI EventWrite(REGHANDLE RegHandle, | |
| 60 PCEVENT_DESCRIPTOR EventDescriptor, | |
| 61 ULONG UserDataCount, | |
| 62 PEVENT_DATA_DESCRIPTOR UserData) { | |
| 63 if (EventWriteProc) | |
| 64 return EventWriteProc(RegHandle, EventDescriptor, UserDataCount, UserData); | |
| 65 return 0; | |
| 66 } | |
| 67 | |
| 68 // Redirector function for EventUnregister. Called by macros in | |
| 69 // chrome_events_win.h | |
| 70 ULONG EVNTAPI EventUnregister(REGHANDLE RegHandle) { | |
| 71 if (EventUnregisterProc) | |
| 72 return EventUnregisterProc(RegHandle); | |
| 73 return 0; | |
| 74 } | |
| 75 | |
| 76 namespace base { | |
| 77 namespace trace_event { | |
| 78 | |
| 79 TraceEventETWExport::TraceEventETWExport() : ETWExportEnabled_(false) { | |
| 80 // Find Advapi32.dll. This should always succeed. | |
| 81 HMODULE AdvapiDLL = ::LoadLibraryW(L"Advapi32.dll"); | |
| 82 if (AdvapiDLL) { | |
| 83 // Try to find the ETW functions. This will fail on XP. | |
| 84 EventRegisterProc = reinterpret_cast<tEventRegister>( | |
| 85 ::GetProcAddress(AdvapiDLL, "EventRegister")); | |
| 86 EventWriteProc = reinterpret_cast<tEventWrite>( | |
| 87 ::GetProcAddress(AdvapiDLL, "EventWrite")); | |
| 88 EventUnregisterProc = reinterpret_cast<tEventUnregister>( | |
| 89 ::GetProcAddress(AdvapiDLL, "EventUnregister")); | |
| 90 | |
| 91 // Register the ETW provider. If registration fails then the event logging | |
| 92 // calls will fail (on XP this call will do nothing). | |
| 93 EventRegisterChrome(); | |
| 94 } | |
| 95 } | |
| 96 | |
| 97 TraceEventETWExport::~TraceEventETWExport() { | |
| 98 EventUnregisterChrome(); | |
| 99 } | |
| 100 | |
| 101 // static | |
| 102 TraceEventETWExport* TraceEventETWExport::GetInstance() { | |
| 103 return Singleton<TraceEventETWExport, | |
| 104 StaticMemorySingletonTraits<TraceEventETWExport>>::get(); | |
| 105 } | |
| 106 | |
| 107 // static | |
| 108 void TraceEventETWExport::EnableETWExport() { | |
| 109 GetInstance()->ETWExportEnabled_ = true; | |
| 110 } | |
| 111 | |
| 112 // static | |
| 113 void TraceEventETWExport::DisableETWExport() { | |
| 114 GetInstance()->ETWExportEnabled_ = false; | |
| 115 } | |
| 116 | |
| 117 // static | |
| 118 void TraceEventETWExport::AddEvent( | |
| 119 char phase, | |
| 120 const unsigned char* category_group_enabled, | |
| 121 const char* name, | |
| 122 unsigned long long id, | |
| 123 int num_args, | |
| 124 const char** arg_names, | |
| 125 const unsigned char* arg_types, | |
| 126 const unsigned long long* arg_values, | |
| 127 const scoped_refptr<ConvertableToTraceFormat>* convertable_values) { | |
| 128 // We bail early in case exporting is disabled or no consumer is listening. | |
| 129 if (!GetInstance()->ETWExportEnabled_ || !EventEnabledChromeEvent()) | |
| 130 return; | |
| 131 | |
| 132 std::string phase_string; | |
| 133 switch (phase) { | |
| 134 case TRACE_EVENT_PHASE_BEGIN: | |
| 135 phase_string = "Begin"; | |
| 136 break; | |
| 137 case TRACE_EVENT_PHASE_END: | |
| 138 phase_string = "End"; | |
| 139 break; | |
| 140 case TRACE_EVENT_PHASE_COMPLETE: | |
| 141 phase_string = "Complete"; | |
| 142 break; | |
| 143 case TRACE_EVENT_PHASE_INSTANT: | |
| 144 phase_string = "Instant"; | |
| 145 break; | |
| 146 case TRACE_EVENT_PHASE_ASYNC_BEGIN: | |
| 147 phase_string = "Async Begin"; | |
| 148 break; | |
| 149 case TRACE_EVENT_PHASE_ASYNC_STEP_INTO: | |
| 150 phase_string = "Async Step Into"; | |
| 151 break; | |
| 152 case TRACE_EVENT_PHASE_ASYNC_STEP_PAST: | |
| 153 phase_string = "Async Step Past"; | |
| 154 break; | |
| 155 case TRACE_EVENT_PHASE_ASYNC_END: | |
| 156 phase_string = "Async End"; | |
| 157 break; | |
| 158 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN: | |
| 159 phase_string = "Nestable Async Begin"; | |
| 160 break; | |
| 161 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_END: | |
| 162 phase_string = "Nestable Async End"; | |
| 163 break; | |
| 164 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT: | |
| 165 phase_string = "Nestable Async Instant"; | |
| 166 break; | |
| 167 case TRACE_EVENT_PHASE_FLOW_BEGIN: | |
| 168 phase_string = "Phase Flow Begin"; | |
| 169 break; | |
| 170 case TRACE_EVENT_PHASE_FLOW_STEP: | |
| 171 phase_string = "Phase Flow Step"; | |
| 172 break; | |
| 173 case TRACE_EVENT_PHASE_FLOW_END: | |
| 174 phase_string = "Phase Flow End"; | |
| 175 break; | |
| 176 case TRACE_EVENT_PHASE_METADATA: | |
| 177 phase_string = "Phase Metadata"; | |
| 178 break; | |
| 179 case TRACE_EVENT_PHASE_COUNTER: | |
| 180 phase_string = "Phase Counter"; | |
| 181 break; | |
| 182 case TRACE_EVENT_PHASE_SAMPLE: | |
| 183 phase_string = "Phase Sample"; | |
| 184 break; | |
| 185 case TRACE_EVENT_PHASE_CREATE_OBJECT: | |
| 186 phase_string = "Phase Create Object"; | |
| 187 break; | |
| 188 case TRACE_EVENT_PHASE_SNAPSHOT_OBJECT: | |
| 189 phase_string = "Phase Snapshot Object"; | |
| 190 break; | |
| 191 case TRACE_EVENT_PHASE_DELETE_OBJECT: | |
| 192 phase_string = "Phase Delete Object"; | |
| 193 break; | |
| 194 default: | |
| 195 phase_string.push_back(phase); | |
| 196 break; | |
| 197 } | |
| 198 | |
| 199 std::string arg_values_string[3]; | |
| 200 for (int i = 0; i < num_args; i++) { | |
| 201 if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE) { | |
| 202 convertable_values[i]->AppendAsTraceFormat(arg_values_string + i); | |
| 203 } else { | |
| 204 TraceEvent::TraceValue trace_event; | |
| 205 trace_event.as_uint = arg_values[i]; | |
| 206 TraceEvent::AppendValueAsJSON(arg_types[i], trace_event, | |
| 207 arg_values_string + i); | |
| 208 } | |
| 209 } | |
| 210 | |
| 211 EventWriteChromeEvent( | |
| 212 name, phase_string.c_str(), num_args > 0 ? arg_names[0] : "", | |
| 213 arg_values_string[0].c_str(), num_args > 1 ? arg_names[1] : "", | |
| 214 arg_values_string[1].c_str(), num_args > 2 ? arg_names[2] : "", | |
| 215 arg_values_string[2].c_str()); | |
| 216 } | |
| 217 | |
| 218 // static | |
| 219 void TraceEventETWExport::AddCustomEvent(const char* name, | |
| 220 char const* phase, | |
| 221 const char* arg_name_1, | |
| 222 const char* arg_value_1, | |
| 223 const char* arg_name_2, | |
| 224 const char* arg_value_2, | |
| 225 const char* arg_name_3, | |
| 226 const char* arg_value_3) { | |
| 227 if (!GetInstance()->ETWExportEnabled_ || !EventEnabledChromeEvent()) | |
| 228 return; | |
| 229 | |
| 230 EventWriteChromeEvent(name, phase, arg_name_1, arg_value_1, arg_name_2, | |
| 231 arg_value_2, arg_name_3, arg_value_3); | |
| 232 } | |
| 233 | |
| 234 void TraceEventETWExport::Resurrect() { | |
| 235 StaticMemorySingletonTraits<TraceEventETWExport>::Resurrect(); | |
| 236 } | |
| 237 | |
| 238 } // namespace trace_event | |
| 239 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1087733002:
Revert "Add option to export tracing events to ETW." (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master