| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 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/google/UIforETW/tree/master/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 *RegHandle = 0; | |
| 55 return 0; | |
| 56 } | |
| 57 | |
| 58 // Redirector function for EventWrite. Called by macros in | |
| 59 // chrome_events_win.h | |
| 60 ULONG EVNTAPI EventWrite(REGHANDLE RegHandle, | |
| 61 PCEVENT_DESCRIPTOR EventDescriptor, | |
| 62 ULONG UserDataCount, | |
| 63 PEVENT_DATA_DESCRIPTOR UserData) { | |
| 64 if (EventWriteProc) | |
| 65 return EventWriteProc(RegHandle, EventDescriptor, UserDataCount, UserData); | |
| 66 return 0; | |
| 67 } | |
| 68 | |
| 69 // Redirector function for EventUnregister. Called by macros in | |
| 70 // chrome_events_win.h | |
| 71 ULONG EVNTAPI EventUnregister(REGHANDLE RegHandle) { | |
| 72 if (EventUnregisterProc) | |
| 73 return EventUnregisterProc(RegHandle); | |
| 74 return 0; | |
| 75 } | |
| 76 | |
| 77 namespace base { | |
| 78 namespace trace_event { | |
| 79 | |
| 80 TraceEventETWExport::TraceEventETWExport() : ETWExportEnabled_(false) { | |
| 81 // Find Advapi32.dll. This should always succeed. | |
| 82 HMODULE AdvapiDLL = ::LoadLibraryW(L"Advapi32.dll"); | |
| 83 if (AdvapiDLL) { | |
| 84 // Try to find the ETW functions. This will fail on XP. | |
| 85 EventRegisterProc = reinterpret_cast<tEventRegister>( | |
| 86 ::GetProcAddress(AdvapiDLL, "EventRegister")); | |
| 87 EventWriteProc = reinterpret_cast<tEventWrite>( | |
| 88 ::GetProcAddress(AdvapiDLL, "EventWrite")); | |
| 89 EventUnregisterProc = reinterpret_cast<tEventUnregister>( | |
| 90 ::GetProcAddress(AdvapiDLL, "EventUnregister")); | |
| 91 | |
| 92 // Register the ETW provider. If registration fails then the event logging | |
| 93 // calls will fail (on XP this call will do nothing). | |
| 94 EventRegisterChrome(); | |
| 95 } | |
| 96 } | |
| 97 | |
| 98 TraceEventETWExport::~TraceEventETWExport() { | |
| 99 EventUnregisterChrome(); | |
| 100 } | |
| 101 | |
| 102 // static | |
| 103 TraceEventETWExport* TraceEventETWExport::GetInstance() { | |
| 104 return Singleton<TraceEventETWExport, | |
| 105 StaticMemorySingletonTraits<TraceEventETWExport>>::get(); | |
| 106 } | |
| 107 | |
| 108 // static | |
| 109 void TraceEventETWExport::EnableETWExport() { | |
| 110 if (GetInstance()) | |
| 111 GetInstance()->ETWExportEnabled_ = true; | |
| 112 } | |
| 113 | |
| 114 // static | |
| 115 void TraceEventETWExport::DisableETWExport() { | |
| 116 if (GetInstance()) | |
| 117 GetInstance()->ETWExportEnabled_ = false; | |
| 118 } | |
| 119 | |
| 120 // static | |
| 121 void TraceEventETWExport::AddEvent( | |
| 122 char phase, | |
| 123 const unsigned char* category_group_enabled, | |
| 124 const char* name, | |
| 125 unsigned long long id, | |
| 126 int num_args, | |
| 127 const char** arg_names, | |
| 128 const unsigned char* arg_types, | |
| 129 const unsigned long long* arg_values, | |
| 130 const scoped_refptr<ConvertableToTraceFormat>* convertable_values) { | |
| 131 // We bail early in case exporting is disabled or no consumer is listening. | |
| 132 if (!GetInstance() || !GetInstance()->ETWExportEnabled_ || | |
| 133 !EventEnabledChromeEvent()) | |
| 134 return; | |
| 135 | |
| 136 const char* phase_string = nullptr; | |
| 137 // Space to store the phase identifier and null-terminator, when needed. | |
| 138 char phase_buffer[2]; | |
| 139 switch (phase) { | |
| 140 case TRACE_EVENT_PHASE_BEGIN: | |
| 141 phase_string = "Begin"; | |
| 142 break; | |
| 143 case TRACE_EVENT_PHASE_END: | |
| 144 phase_string = "End"; | |
| 145 break; | |
| 146 case TRACE_EVENT_PHASE_COMPLETE: | |
| 147 phase_string = "Complete"; | |
| 148 break; | |
| 149 case TRACE_EVENT_PHASE_INSTANT: | |
| 150 phase_string = "Instant"; | |
| 151 break; | |
| 152 case TRACE_EVENT_PHASE_ASYNC_BEGIN: | |
| 153 phase_string = "Async Begin"; | |
| 154 break; | |
| 155 case TRACE_EVENT_PHASE_ASYNC_STEP_INTO: | |
| 156 phase_string = "Async Step Into"; | |
| 157 break; | |
| 158 case TRACE_EVENT_PHASE_ASYNC_STEP_PAST: | |
| 159 phase_string = "Async Step Past"; | |
| 160 break; | |
| 161 case TRACE_EVENT_PHASE_ASYNC_END: | |
| 162 phase_string = "Async End"; | |
| 163 break; | |
| 164 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN: | |
| 165 phase_string = "Nestable Async Begin"; | |
| 166 break; | |
| 167 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_END: | |
| 168 phase_string = "Nestable Async End"; | |
| 169 break; | |
| 170 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT: | |
| 171 phase_string = "Nestable Async Instant"; | |
| 172 break; | |
| 173 case TRACE_EVENT_PHASE_FLOW_BEGIN: | |
| 174 phase_string = "Phase Flow Begin"; | |
| 175 break; | |
| 176 case TRACE_EVENT_PHASE_FLOW_STEP: | |
| 177 phase_string = "Phase Flow Step"; | |
| 178 break; | |
| 179 case TRACE_EVENT_PHASE_FLOW_END: | |
| 180 phase_string = "Phase Flow End"; | |
| 181 break; | |
| 182 case TRACE_EVENT_PHASE_METADATA: | |
| 183 phase_string = "Phase Metadata"; | |
| 184 break; | |
| 185 case TRACE_EVENT_PHASE_COUNTER: | |
| 186 phase_string = "Phase Counter"; | |
| 187 break; | |
| 188 case TRACE_EVENT_PHASE_SAMPLE: | |
| 189 phase_string = "Phase Sample"; | |
| 190 break; | |
| 191 case TRACE_EVENT_PHASE_CREATE_OBJECT: | |
| 192 phase_string = "Phase Create Object"; | |
| 193 break; | |
| 194 case TRACE_EVENT_PHASE_SNAPSHOT_OBJECT: | |
| 195 phase_string = "Phase Snapshot Object"; | |
| 196 break; | |
| 197 case TRACE_EVENT_PHASE_DELETE_OBJECT: | |
| 198 phase_string = "Phase Delete Object"; | |
| 199 break; | |
| 200 default: | |
| 201 phase_buffer[0] = phase; | |
| 202 phase_buffer[1] = 0; | |
| 203 phase_string = phase_buffer; | |
| 204 break; | |
| 205 } | |
| 206 | |
| 207 std::string arg_values_string[3]; | |
| 208 for (int i = 0; i < num_args; i++) { | |
| 209 if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE) { | |
| 210 // Temporarily do nothing here. This function consumes 1/3 to 1/2 of | |
| 211 // *total* process CPU time when ETW tracing, and many of the strings | |
| 212 // created exceed WPA's 4094 byte limit and are shown as: | |
| 213 // "Unable to parse data". See crbug.com/488257 | |
| 214 //convertable_values[i]->AppendAsTraceFormat(arg_values_string + i); | |
| 215 } else { | |
| 216 TraceEvent::TraceValue trace_event; | |
| 217 trace_event.as_uint = arg_values[i]; | |
| 218 TraceEvent::AppendValueAsJSON(arg_types[i], trace_event, | |
| 219 arg_values_string + i); | |
| 220 } | |
| 221 } | |
| 222 | |
| 223 EventWriteChromeEvent( | |
| 224 name, phase_string, num_args > 0 ? arg_names[0] : "", | |
| 225 arg_values_string[0].c_str(), num_args > 1 ? arg_names[1] : "", | |
| 226 arg_values_string[1].c_str(), num_args > 2 ? arg_names[2] : "", | |
| 227 arg_values_string[2].c_str()); | |
| 228 } | |
| 229 | |
| 230 // static | |
| 231 void TraceEventETWExport::AddCustomEvent(const char* name, | |
| 232 char const* phase, | |
| 233 const char* arg_name_1, | |
| 234 const char* arg_value_1, | |
| 235 const char* arg_name_2, | |
| 236 const char* arg_value_2, | |
| 237 const char* arg_name_3, | |
| 238 const char* arg_value_3) { | |
| 239 if (!GetInstance() || !GetInstance()->ETWExportEnabled_ || | |
| 240 !EventEnabledChromeEvent()) | |
| 241 return; | |
| 242 | |
| 243 EventWriteChromeEvent(name, phase, arg_name_1, arg_value_1, arg_name_2, | |
| 244 arg_value_2, arg_name_3, arg_value_3); | |
| 245 } | |
| 246 | |
| 247 void TraceEventETWExport::Resurrect() { | |
| 248 StaticMemorySingletonTraits<TraceEventETWExport>::Resurrect(); | |
| 249 } | |
| 250 | |
| 251 } // namespace trace_event | |
| 252 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1446363003:
Deleted OS_WIN and all Windows specific files from base. (Closed)
Base URL: https://github.com/domokit/mojo.git@base_tests