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 |