| 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/string_tokenizer.h" | |
| 11 #include "base/strings/utf_string_conversions.h" | |
| 12 #include "base/trace_event/trace_event.h" | |
| 13 #include "base/trace_event/trace_event_impl.h" | |
| 14 | |
| 15 // The GetProcAddress technique is borrowed from | |
| 16 // https://github.com/google/UIforETW/tree/master/ETWProviders | |
| 17 // | |
| 18 // EVNTAPI is used in evntprov.h which is included by chrome_events_win.h. | |
| 19 // We define EVNTAPI without the DECLSPEC_IMPORT specifier so that we can | |
| 20 // implement these functions locally instead of using the import library, and | |
| 21 // can therefore still run on Windows XP. | |
| 22 #define EVNTAPI __stdcall | |
| 23 // Include the event register/write/unregister macros compiled from the manifest | |
| 24 // file. Note that this includes evntprov.h which requires a Vista+ Windows SDK. | |
| 25 // | |
| 26 // In SHARED_INTERMEDIATE_DIR. | |
| 27 #include "base/trace_event/etw_manifest/chrome_events_win.h" // NOLINT | |
| 28 | |
| 29 namespace { | |
| 30 // Typedefs for use with GetProcAddress | |
| 31 typedef ULONG(__stdcall* tEventRegister)(LPCGUID ProviderId, | |
| 32 PENABLECALLBACK EnableCallback, | |
| 33 PVOID CallbackContext, | |
| 34 PREGHANDLE RegHandle); | |
| 35 typedef ULONG(__stdcall* tEventWrite)(REGHANDLE RegHandle, | |
| 36 PCEVENT_DESCRIPTOR EventDescriptor, | |
| 37 ULONG UserDataCount, | |
| 38 PEVENT_DATA_DESCRIPTOR UserData); | |
| 39 typedef ULONG(__stdcall* tEventUnregister)(REGHANDLE RegHandle); | |
| 40 | |
| 41 tEventRegister EventRegisterProc = nullptr; | |
| 42 tEventWrite EventWriteProc = nullptr; | |
| 43 tEventUnregister EventUnregisterProc = nullptr; | |
| 44 | |
| 45 // |filtered_event_group_names| contains the event categories that can be | |
| 46 // exported individually. These categories can be enabled by passing the correct | |
| 47 // keyword when starting the trace. A keyword is a 64-bit flag and we attribute | |
| 48 // one bit per category. We can therefore enable a particular category by | |
| 49 // setting its corresponding bit in the keyword. For events that are not present | |
| 50 // in |filtered_event_group_names|, we have two bits that control their | |
| 51 // behaviour. When bit 61 is enabled, any event that is not disabled by default | |
| 52 // (ie. doesn't start with disabled-by-default-) will be exported. Likewise, | |
| 53 // when bit 62 is enabled, any event that is disabled by default will be | |
| 54 // exported. | |
| 55 // | |
| 56 // Note that bit 63 (MSB) must always be set, otherwise tracing will be disabled | |
| 57 // by ETW. Therefore, the keyword will always be greater than | |
| 58 // 0x8000000000000000. | |
| 59 // | |
| 60 // Examples of passing keywords to the provider using xperf: | |
| 61 // # This exports "benchmark" and "cc" events | |
| 62 // xperf -start chrome -on Chrome:0x8000000000000009 | |
| 63 // | |
| 64 // # This exports "gpu", "netlog" and all other events that are not disabled by | |
| 65 // # default | |
| 66 // xperf -start chrome -on Chrome:0xA0000000000000A0 | |
| 67 // | |
| 68 // More info about starting a trace and keyword can be obtained by using the | |
| 69 // help section of xperf (xperf -help start). Note that xperf documentation | |
| 70 // refers to keywords as flags and there are two ways to enable them, using | |
| 71 // group names or the hex representation. We only support the latter. Also, we | |
| 72 // ignore the level. | |
| 73 const char* const filtered_event_group_names[] = { | |
| 74 "benchmark", // 0x1 | |
| 75 "blink", // 0x2 | |
| 76 "browser", // 0x4 | |
| 77 "cc", // 0x8 | |
| 78 "evdev", // 0x10 | |
| 79 "gpu", // 0x20 | |
| 80 "input", // 0x40 | |
| 81 "netlog", // 0x80 | |
| 82 "renderer.scheduler", // 0x100 | |
| 83 "toplevel", // 0x200 | |
| 84 "v8", // 0x400 | |
| 85 "disabled-by-default-cc.debug", // 0x800 | |
| 86 "disabled-by-default-cc.debug.picture", // 0x1000 | |
| 87 "disabled-by-default-toplevel.flow"}; // 0x2000 | |
| 88 const char* other_events_group_name = "__OTHER_EVENTS"; // 0x2000000000000000 | |
| 89 const char* disabled_other_events_group_name = | |
| 90 "__DISABLED_OTHER_EVENTS"; // 0x4000000000000000 | |
| 91 uint64 other_events_keyword_bit = 1ULL << 61; | |
| 92 uint64 disabled_other_events_keyword_bit = 1ULL << 62; | |
| 93 } // namespace | |
| 94 | |
| 95 // Redirector function for EventRegister. Called by macros in | |
| 96 // chrome_events_win.h | |
| 97 ULONG EVNTAPI EventRegister(LPCGUID ProviderId, | |
| 98 PENABLECALLBACK EnableCallback, | |
| 99 PVOID CallbackContext, | |
| 100 PREGHANDLE RegHandle) { | |
| 101 if (EventRegisterProc) | |
| 102 return EventRegisterProc(ProviderId, EnableCallback, CallbackContext, | |
| 103 RegHandle); | |
| 104 *RegHandle = 0; | |
| 105 return 0; | |
| 106 } | |
| 107 | |
| 108 // Redirector function for EventWrite. Called by macros in | |
| 109 // chrome_events_win.h | |
| 110 ULONG EVNTAPI EventWrite(REGHANDLE RegHandle, | |
| 111 PCEVENT_DESCRIPTOR EventDescriptor, | |
| 112 ULONG UserDataCount, | |
| 113 PEVENT_DATA_DESCRIPTOR UserData) { | |
| 114 if (EventWriteProc) | |
| 115 return EventWriteProc(RegHandle, EventDescriptor, UserDataCount, UserData); | |
| 116 return 0; | |
| 117 } | |
| 118 | |
| 119 // Redirector function for EventUnregister. Called by macros in | |
| 120 // chrome_events_win.h | |
| 121 ULONG EVNTAPI EventUnregister(REGHANDLE RegHandle) { | |
| 122 if (EventUnregisterProc) | |
| 123 return EventUnregisterProc(RegHandle); | |
| 124 return 0; | |
| 125 } | |
| 126 | |
| 127 namespace base { | |
| 128 namespace trace_event { | |
| 129 | |
| 130 TraceEventETWExport::TraceEventETWExport() | |
| 131 : etw_export_enabled_(false), etw_match_any_keyword_(0ULL) { | |
| 132 // Find Advapi32.dll. This should always succeed. | |
| 133 HMODULE AdvapiDLL = ::LoadLibraryW(L"Advapi32.dll"); | |
| 134 if (AdvapiDLL) { | |
| 135 // Try to find the ETW functions. This will fail on XP. | |
| 136 EventRegisterProc = reinterpret_cast<tEventRegister>( | |
| 137 ::GetProcAddress(AdvapiDLL, "EventRegister")); | |
| 138 EventWriteProc = reinterpret_cast<tEventWrite>( | |
| 139 ::GetProcAddress(AdvapiDLL, "EventWrite")); | |
| 140 EventUnregisterProc = reinterpret_cast<tEventUnregister>( | |
| 141 ::GetProcAddress(AdvapiDLL, "EventUnregister")); | |
| 142 | |
| 143 // Register the ETW provider. If registration fails then the event logging | |
| 144 // calls will fail (on XP this call will do nothing). | |
| 145 EventRegisterChrome(); | |
| 146 | |
| 147 UpdateEnabledCategories(); | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 TraceEventETWExport::~TraceEventETWExport() { | |
| 152 EventUnregisterChrome(); | |
| 153 } | |
| 154 | |
| 155 // static | |
| 156 TraceEventETWExport* TraceEventETWExport::GetInstance() { | |
| 157 return Singleton<TraceEventETWExport, | |
| 158 StaticMemorySingletonTraits<TraceEventETWExport>>::get(); | |
| 159 } | |
| 160 | |
| 161 // static | |
| 162 void TraceEventETWExport::EnableETWExport() { | |
| 163 if (GetInstance()) | |
| 164 GetInstance()->etw_export_enabled_ = true; | |
| 165 } | |
| 166 | |
| 167 // static | |
| 168 void TraceEventETWExport::DisableETWExport() { | |
| 169 if (GetInstance()) | |
| 170 GetInstance()->etw_export_enabled_ = false; | |
| 171 } | |
| 172 | |
| 173 // static | |
| 174 bool TraceEventETWExport::IsETWExportEnabled() { | |
| 175 return (GetInstance() && GetInstance()->etw_export_enabled_); | |
| 176 } | |
| 177 | |
| 178 // static | |
| 179 void TraceEventETWExport::AddEvent( | |
| 180 char phase, | |
| 181 const unsigned char* category_group_enabled, | |
| 182 const char* name, | |
| 183 unsigned long long id, | |
| 184 int num_args, | |
| 185 const char** arg_names, | |
| 186 const unsigned char* arg_types, | |
| 187 const unsigned long long* arg_values, | |
| 188 const scoped_refptr<ConvertableToTraceFormat>* convertable_values) { | |
| 189 // We bail early in case exporting is disabled or no consumer is listening. | |
| 190 if (!GetInstance() || !GetInstance()->etw_export_enabled_ || | |
| 191 !EventEnabledChromeEvent()) | |
| 192 return; | |
| 193 | |
| 194 const char* phase_string = nullptr; | |
| 195 // Space to store the phase identifier and null-terminator, when needed. | |
| 196 char phase_buffer[2]; | |
| 197 switch (phase) { | |
| 198 case TRACE_EVENT_PHASE_BEGIN: | |
| 199 phase_string = "Begin"; | |
| 200 break; | |
| 201 case TRACE_EVENT_PHASE_END: | |
| 202 phase_string = "End"; | |
| 203 break; | |
| 204 case TRACE_EVENT_PHASE_COMPLETE: | |
| 205 phase_string = "Complete"; | |
| 206 break; | |
| 207 case TRACE_EVENT_PHASE_INSTANT: | |
| 208 phase_string = "Instant"; | |
| 209 break; | |
| 210 case TRACE_EVENT_PHASE_ASYNC_BEGIN: | |
| 211 phase_string = "Async Begin"; | |
| 212 break; | |
| 213 case TRACE_EVENT_PHASE_ASYNC_STEP_INTO: | |
| 214 phase_string = "Async Step Into"; | |
| 215 break; | |
| 216 case TRACE_EVENT_PHASE_ASYNC_STEP_PAST: | |
| 217 phase_string = "Async Step Past"; | |
| 218 break; | |
| 219 case TRACE_EVENT_PHASE_ASYNC_END: | |
| 220 phase_string = "Async End"; | |
| 221 break; | |
| 222 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN: | |
| 223 phase_string = "Nestable Async Begin"; | |
| 224 break; | |
| 225 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_END: | |
| 226 phase_string = "Nestable Async End"; | |
| 227 break; | |
| 228 case TRACE_EVENT_PHASE_NESTABLE_ASYNC_INSTANT: | |
| 229 phase_string = "Nestable Async Instant"; | |
| 230 break; | |
| 231 case TRACE_EVENT_PHASE_FLOW_BEGIN: | |
| 232 phase_string = "Phase Flow Begin"; | |
| 233 break; | |
| 234 case TRACE_EVENT_PHASE_FLOW_STEP: | |
| 235 phase_string = "Phase Flow Step"; | |
| 236 break; | |
| 237 case TRACE_EVENT_PHASE_FLOW_END: | |
| 238 phase_string = "Phase Flow End"; | |
| 239 break; | |
| 240 case TRACE_EVENT_PHASE_METADATA: | |
| 241 phase_string = "Phase Metadata"; | |
| 242 break; | |
| 243 case TRACE_EVENT_PHASE_COUNTER: | |
| 244 phase_string = "Phase Counter"; | |
| 245 break; | |
| 246 case TRACE_EVENT_PHASE_SAMPLE: | |
| 247 phase_string = "Phase Sample"; | |
| 248 break; | |
| 249 case TRACE_EVENT_PHASE_CREATE_OBJECT: | |
| 250 phase_string = "Phase Create Object"; | |
| 251 break; | |
| 252 case TRACE_EVENT_PHASE_SNAPSHOT_OBJECT: | |
| 253 phase_string = "Phase Snapshot Object"; | |
| 254 break; | |
| 255 case TRACE_EVENT_PHASE_DELETE_OBJECT: | |
| 256 phase_string = "Phase Delete Object"; | |
| 257 break; | |
| 258 default: | |
| 259 phase_buffer[0] = phase; | |
| 260 phase_buffer[1] = 0; | |
| 261 phase_string = phase_buffer; | |
| 262 break; | |
| 263 } | |
| 264 | |
| 265 std::string arg_values_string[3]; | |
| 266 for (int i = 0; i < num_args; i++) { | |
| 267 if (arg_types[i] == TRACE_VALUE_TYPE_CONVERTABLE) { | |
| 268 // Temporarily do nothing here. This function consumes 1/3 to 1/2 of | |
| 269 // *total* process CPU time when ETW tracing, and many of the strings | |
| 270 // created exceed WPA's 4094 byte limit and are shown as: | |
| 271 // "Unable to parse data". See crbug.com/488257 | |
| 272 // convertable_values[i]->AppendAsTraceFormat(arg_values_string + i); | |
| 273 } else { | |
| 274 TraceEvent::TraceValue trace_event; | |
| 275 trace_event.as_uint = arg_values[i]; | |
| 276 TraceEvent::AppendValueAsJSON(arg_types[i], trace_event, | |
| 277 arg_values_string + i); | |
| 278 } | |
| 279 } | |
| 280 | |
| 281 EventWriteChromeEvent( | |
| 282 name, phase_string, num_args > 0 ? arg_names[0] : "", | |
| 283 arg_values_string[0].c_str(), num_args > 1 ? arg_names[1] : "", | |
| 284 arg_values_string[1].c_str(), num_args > 2 ? arg_names[2] : "", | |
| 285 arg_values_string[2].c_str()); | |
| 286 } | |
| 287 | |
| 288 // static | |
| 289 void TraceEventETWExport::AddCustomEvent(const char* name, | |
| 290 char const* phase, | |
| 291 const char* arg_name_1, | |
| 292 const char* arg_value_1, | |
| 293 const char* arg_name_2, | |
| 294 const char* arg_value_2, | |
| 295 const char* arg_name_3, | |
| 296 const char* arg_value_3) { | |
| 297 if (!GetInstance() || !GetInstance()->etw_export_enabled_ || | |
| 298 !EventEnabledChromeEvent()) | |
| 299 return; | |
| 300 | |
| 301 EventWriteChromeEvent(name, phase, arg_name_1, arg_value_1, arg_name_2, | |
| 302 arg_value_2, arg_name_3, arg_value_3); | |
| 303 } | |
| 304 | |
| 305 // static | |
| 306 bool TraceEventETWExport::IsCategoryGroupEnabled( | |
| 307 const char* category_group_name) { | |
| 308 DCHECK(category_group_name); | |
| 309 auto instance = GetInstance(); | |
| 310 if (instance == nullptr) | |
| 311 return false; | |
| 312 | |
| 313 if (!instance->IsETWExportEnabled()) | |
| 314 return false; | |
| 315 | |
| 316 CStringTokenizer category_group_tokens( | |
| 317 category_group_name, category_group_name + strlen(category_group_name), | |
| 318 ","); | |
| 319 while (category_group_tokens.GetNext()) { | |
| 320 std::string category_group_token = category_group_tokens.token(); | |
| 321 if (instance->IsCategoryEnabled(category_group_token.c_str())) { | |
| 322 return true; | |
| 323 } | |
| 324 } | |
| 325 return false; | |
| 326 } | |
| 327 | |
| 328 bool TraceEventETWExport::UpdateEnabledCategories() { | |
| 329 if (etw_match_any_keyword_ == CHROME_Context.MatchAnyKeyword) | |
| 330 return false; | |
| 331 | |
| 332 // If the keyword has changed, update each category. | |
| 333 // Chrome_Context.MatchAnyKeyword is set by UIforETW (or other ETW trace | |
| 334 // recording tools) using the ETW infrastructure. This value will be set in | |
| 335 // all Chrome processes that have registered their ETW provider. | |
| 336 etw_match_any_keyword_ = CHROME_Context.MatchAnyKeyword; | |
| 337 for (int i = 0; i < ARRAYSIZE(filtered_event_group_names); i++) { | |
| 338 if (etw_match_any_keyword_ & (1ULL << i)) { | |
| 339 categories_status_[filtered_event_group_names[i]] = true; | |
| 340 } else { | |
| 341 categories_status_[filtered_event_group_names[i]] = false; | |
| 342 } | |
| 343 } | |
| 344 | |
| 345 // Also update the two default categories. | |
| 346 if (etw_match_any_keyword_ & other_events_keyword_bit) { | |
| 347 categories_status_[other_events_group_name] = true; | |
| 348 } else { | |
| 349 categories_status_[other_events_group_name] = false; | |
| 350 } | |
| 351 if (etw_match_any_keyword_ & disabled_other_events_keyword_bit) { | |
| 352 categories_status_[disabled_other_events_group_name] = true; | |
| 353 } else { | |
| 354 categories_status_[disabled_other_events_group_name] = false; | |
| 355 } | |
| 356 | |
| 357 return true; | |
| 358 } | |
| 359 | |
| 360 bool TraceEventETWExport::IsCategoryEnabled(const char* category_name) const { | |
| 361 // Try to find the category and return its status if found | |
| 362 auto it = categories_status_.find(category_name); | |
| 363 if (it != categories_status_.end()) | |
| 364 return it->second; | |
| 365 | |
| 366 // Otherwise return the corresponding default status by first checking if the | |
| 367 // category is disabled by default. | |
| 368 if (StringPiece(category_name).starts_with("disabled-by-default")) { | |
| 369 DCHECK(categories_status_.find(disabled_other_events_group_name) != | |
| 370 categories_status_.end()); | |
| 371 return categories_status_.find(disabled_other_events_group_name)->second; | |
| 372 } else { | |
| 373 DCHECK(categories_status_.find(other_events_group_name) != | |
| 374 categories_status_.end()); | |
| 375 return categories_status_.find(other_events_group_name)->second; | |
| 376 } | |
| 377 } | |
| 378 | |
| 379 } // namespace trace_event | |
| 380 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
