[tracing] Add filtering mode in TraceLog

base/trace_event/trace_log.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/trace_event/trace_log.h"
 
 #include <algorithm>
 #include <cmath>
 #include <memory>
 #include <utility>
@@ skipping 447 matching lines @@
 TraceLogStatus::TraceLogStatus() : event_capacity(0), event_count(0) {}
 
 TraceLogStatus::~TraceLogStatus() {}
 
 // static
 TraceLog* TraceLog::GetInstance() {
   return Singleton<TraceLog, LeakySingletonTraits<TraceLog>>::get();
 }
 
 TraceLog::TraceLog()
-    : mode_(DISABLED),
+    : mode_(0),
       num_traces_recorded_(0),
       event_callback_(0),
       dispatching_to_observer_list_(false),
       process_sort_index_(0),
       process_id_hash_(0),
       process_id_(0),
       watch_category_(0),
       trace_options_(kInternalRecordUntilFull),
       sampling_thread_handle_(0),
       trace_config_(TraceConfig()),
@@ skipping 78 matching lines @@
 }
 
 const char* TraceLog::GetCategoryGroupName(
     const unsigned char* category_group_enabled) {
   return g_category_groups[GetCategoryIndex(category_group_enabled)];
 }
 
 void TraceLog::UpdateCategoryGroupEnabledFlag(size_t category_index) {
   unsigned char enabled_flag = 0;
   const char* category_group = g_category_groups[category_index];
-  if (mode_ == RECORDING_MODE &&
+  if (mode_ & RECORDING_MODE &&
       trace_config_.IsCategoryGroupEnabled(category_group)) {
     enabled_flag |= ENABLED_FOR_RECORDING;
   }
 
   if (event_callback_ &&
       event_callback_trace_config_.IsCategoryGroupEnabled(category_group)) {
     enabled_flag |= ENABLED_FOR_EVENT_CALLBACK;
   }
 
 #if defined(OS_WIN)
   if (base::trace_event::TraceEventETWExport::IsCategoryGroupEnabled(
           category_group)) {
     enabled_flag |= ENABLED_FOR_ETW_EXPORT;
   }
 #endif
 
   // TODO(primiano): this is a temporary workaround for catapult:#2341,
   // to guarantee that metadata events are always added even if the category
   // filter is "-*". See crbug.com/618054 for more details and long-term fix.
-  if (mode_ == RECORDING_MODE && !strcmp(category_group, "__metadata"))
+  if (mode_ & RECORDING_MODE && !strcmp(category_group, "__metadata"))
     enabled_flag |= ENABLED_FOR_RECORDING;
 
   uint32_t enabled_filters_bitmap = 0;
   int index = 0;
-  for (const auto& event_filter : trace_config_.event_filters()) {
+  for (const auto& event_filter : event_filters_enabled_) {
     if (event_filter.IsCategoryGroupEnabled(category_group)) {
       enabled_flag |= ENABLED_FOR_FILTERING;
       DCHECK(g_category_group_filters.Get()[index]);
       enabled_filters_bitmap |= 1 << index;
     }
     if (index++ >= MAX_TRACE_EVENT_FILTERS) {
       NOTREACHED();
       break;
     }
   }
   g_category_group_filters_enabled[category_index] = enabled_filters_bitmap;
 
   g_category_group_enabled[category_index] = enabled_flag;
 }
 
 void TraceLog::UpdateCategoryGroupEnabledFlags() {
   CreateFiltersForTraceConfig();
   size_t category_index = base::subtle::NoBarrier_Load(&g_category_index);
   for (size_t i = 0; i < category_index; i++)
     UpdateCategoryGroupEnabledFlag(i);
 }
 
 void TraceLog::CreateFiltersForTraceConfig() {
   // Filters were already added and tracing could be enabled. Filters list
   // cannot be changed when trace events are using them.
   if (g_category_group_filters.Get().size())
     return;
 
-  for (auto& event_filter : trace_config_.event_filters()) {
+  for (auto& event_filter : event_filters_enabled_) {
     if (g_category_group_filters.Get().size() >= MAX_TRACE_EVENT_FILTERS) {
       NOTREACHED()
           << "Too many trace event filters installed in the current session";
       break;
     }
 
     std::unique_ptr<TraceEventFilter> new_filter;
     if (event_filter.predicate_name() ==
         TraceEventFilter::kEventWhitelistPredicate) {
       new_filter = MakeUnique<EventNameFilter>(event_filter.filter_args());
@@ skipping 92 matching lines @@
 }
 
 void TraceLog::GetKnownCategoryGroups(
     std::vector<std::string>* category_groups) {
   AutoLock lock(lock_);
   size_t category_index = base::subtle::NoBarrier_Load(&g_category_index);
   for (size_t i = kNumBuiltinCategories; i < category_index; i++)
     category_groups->push_back(g_category_groups[i]);
 }
 
-void TraceLog::SetEnabled(const TraceConfig& trace_config, Mode mode) {
+void TraceLog::SetEnabled(const TraceConfig& trace_config, Mode new_mode) {
   std::vector<EnabledStateObserver*> observer_list;
   std::map<AsyncEnabledStateObserver*, RegisteredAsyncObserver> observer_map;
   {
     AutoLock lock(lock_);
 
     // Can't enable tracing when Flush() is in progress.
     DCHECK(!flush_task_runner_);
 
     InternalTraceOptions new_options =
         GetInternalOptionsFromTraceConfig(trace_config);
 
     InternalTraceOptions old_options = trace_options();
 
-    if (IsEnabled()) {
-      if (new_options != old_options) {
-        DLOG(ERROR) << "Attempting to re-enable tracing with a different "
-                    << "set of options.";
-      }
-
-      if (mode != mode_) {
-        DLOG(ERROR) << "Attempting to re-enable tracing with a different mode.";
-      }
-
-      DCHECK(!trace_config.event_filters().size())
-          << "Adding new filters while tracing was already enabled is not "
-             "supported.";
-
-      trace_config_.Merge(trace_config);
-      UpdateCategoryGroupEnabledFlags();
-      return;
-    }
-
     if (dispatching_to_observer_list_) {
-      DLOG(ERROR)
+      NOTREACHED()
           << "Cannot manipulate TraceLog::Enabled state from an observer.";
       return;
     }
 
-    mode_ = mode;
+    // Update event filters:
+    DCHECK(
+        !(new_mode == FILTERING_MODE && trace_config.event_filters().empty()))
+        << "Attempting to enable filtering without any filters";
+    if (!mode_) {
+      // Clear all filters from previous tracing session. These filters are not
+      // cleared at the end of tracing because some threads which hit trace
+      // event when disabling, could try to use the filters.
+      g_category_group_filters.Get().clear();
+    }
+    if (event_filters_enabled_.empty()) {
+      // Use the given event filters only if filtering was not enabled.
+      event_filters_enabled_ = trace_config.event_filters();
+    } else if (new_mode == FILTERING_MODE) {
+      NOTREACHED() << "Attempting to re-enable filtering when filters are "
+                      "already enabled.";
+      return;
+    }
+
+    // Update trace config for recording.
+    bool already_recording = mode_ & RECORDING_MODE;
+    if (new_mode == RECORDING_MODE) {
+      if (already_recording) {
+        DCHECK_EQ(new_options, old_options) << "Attempting to re-enable "
+                                               "tracing with a different set "
+                                               "of options.";
+        trace_config_.Merge(trace_config);
+      } else {
+        trace_config_ = trace_config;
+      }
+    }
+    // Keep the |trace_config_| updated with only enabled filters in case anyone
+    // tries to read it using |GetCurrentTraceConfig|
+    trace_config_.SetEventFilterConfigs(event_filters_enabled_);
+
+    mode_ |= new_mode;
+    UpdateCategoryGroupEnabledFlags();
+
+    // Do not notify observers and create trace buffer if enabled for filtering
+    // or if recording was already enabled.
+    if (new_mode == FILTERING_MODE || already_recording)
+      return;
 
     if (new_options != old_options) {
       subtle::NoBarrier_Store(&trace_options_, new_options);
       UseNextTraceBuffer();
     }
 
     num_traces_recorded_++;
 
-    // Clear all filters from previous tracing session. These filters are not
-    // cleared at the end of tracing because some threads which hit trace event
-    // when disabling, could try to use the filters.
-    g_category_group_filters.Get().clear();
-
-    trace_config_ = TraceConfig(trace_config);
     UpdateCategoryGroupEnabledFlags();
     UpdateSyntheticDelaysFromTraceConfig();
 
     if (new_options & kInternalEnableSampling) {
       sampling_thread_.reset(new TraceSamplingThread);
       sampling_thread_->RegisterSampleBucket(
           &g_trace_state[0], "bucket0",
           Bind(&TraceSamplingThread::DefaultSamplingCallback));
       sampling_thread_->RegisterSampleBucket(
           &g_trace_state[1], "bucket1",
@@ skipping 54 matching lines @@
   return kInternalNone;
 }
 
 TraceConfig TraceLog::GetCurrentTraceConfig() const {
   AutoLock lock(lock_);
   return trace_config_;
 }
 
 void TraceLog::SetDisabled() {
   AutoLock lock(lock_);
-  SetDisabledWhileLocked();
+  SetDisabledWhileLocked(RECORDING_MODE);
 }
 
-void TraceLog::SetDisabledWhileLocked() {
+void TraceLog::SetDisabled(Mode mode) {
+  AutoLock lock(lock_);
+  SetDisabledWhileLocked(mode);
+}
+
+void TraceLog::SetDisabledWhileLocked(Mode mode) {
   lock_.AssertAcquired();
 
-  if (!IsEnabled())
+  if (!(mode_ & mode))
     return;
 
   if (dispatching_to_observer_list_) {
-    DLOG(ERROR)
+    NOTREACHED()
         << "Cannot manipulate TraceLog::Enabled state from an observer.";
     return;
   }
 
-  mode_ = DISABLED;
-
   if (sampling_thread_) {
     // Stop the sampling thread.
     sampling_thread_->Stop();
     lock_.Release();
     PlatformThread::Join(sampling_thread_handle_);
     lock_.Acquire();
     sampling_thread_handle_ = PlatformThreadHandle();
     sampling_thread_.reset();
   }
 
-  trace_config_.Clear();
+  mode_ &= ~mode;
+  if (mode == RECORDING_MODE)
+    trace_config_.Clear();
+  // Clear the filters if tracing is no longer enabled or filtering is disabled.
+  if (!mode || mode == FILTERING_MODE)
+    event_filters_enabled_.clear();
+
   subtle::NoBarrier_Store(&watch_category_, 0);
   watch_event_name_.clear();
   UpdateCategoryGroupEnabledFlags();
+
+  // Skip adding metadata events and notifying observers for filtering mode.
+  if (mode == FILTERING_MODE)
+    return;
+
   AddMetadataEventsWhileLocked();
 
   // Remove metadata events so they will not get added to a subsequent trace.
   metadata_events_.clear();
 
   dispatching_to_observer_list_ = true;
   std::vector<EnabledStateObserver*> observer_list =
       enabled_state_observer_list_;
   std::map<AsyncEnabledStateObserver*, RegisteredAsyncObserver> observer_map =
       async_observers_;
 
   {
     // Dispatch to observers outside the lock in case the observer triggers a
     // trace event.
     AutoUnlock unlock(lock_);
     for (EnabledStateObserver* observer : observer_list)
       observer->OnTraceLogDisabled();
     for (const auto& it : observer_map) {
       it.second.task_runner->PostTask(
           FROM_HERE, Bind(&AsyncEnabledStateObserver::OnTraceLogDisabled,
                           it.second.observer));
     }
   }
   dispatching_to_observer_list_ = false;
 }
 
+bool TraceLog::IsFilteringEnabled() {
+  AutoLock lock(lock_);
+  return !event_filters_enabled_.empty();
+}
+
 int TraceLog::GetNumTracesRecorded() {
   AutoLock lock(lock_);
   if (!IsEnabled())
     return -1;
   return num_traces_recorded_;
 }
 
 void TraceLog::AddEnabledStateObserver(EnabledStateObserver* listener) {
   AutoLock lock(lock_);
   enabled_state_observer_list_.push_back(listener);
@@ skipping 53 matching lines @@
   }
   return trace_event;
 }
 
 void TraceLog::CheckIfBufferIsFullWhileLocked() {
   lock_.AssertAcquired();
   if (logged_events_->IsFull()) {
     if (buffer_limit_reached_timestamp_.is_null()) {
       buffer_limit_reached_timestamp_ = OffsetNow();
     }
-    SetDisabledWhileLocked();
+    SetDisabledWhileLocked(RECORDING_MODE);
   }
 }
 
 void TraceLog::SetEventCallbackEnabled(const TraceConfig& trace_config,
                                        EventCallback cb) {
   AutoLock lock(lock_);
   subtle::NoBarrier_Store(&event_callback_,
                           reinterpret_cast<subtle::AtomicWord>(cb));
   event_callback_trace_config_ = trace_config;
   UpdateCategoryGroupEnabledFlags();
@@ skipping 366 matching lines @@
   if (flags & TRACE_EVENT_FLAG_MANGLE_ID) {
     if ((flags & TRACE_EVENT_FLAG_FLOW_IN) ||
         (flags & TRACE_EVENT_FLAG_FLOW_OUT))
       bind_id = MangleEventId(bind_id);
     id = MangleEventId(id);
   }
 
   TimeTicks offset_event_timestamp = OffsetTimestamp(timestamp);
   ThreadTicks thread_now = ThreadNow();
 
-  // |thread_local_event_buffer_| can be null if the current thread doesn't have
-  // a message loop or the message loop is blocked.
-  InitializeThreadLocalEventBufferIfSupported();
-  auto* thread_local_event_buffer = thread_local_event_buffer_.Get();
-
   // Check and update the current thread name only if the event is for the
   // current thread to avoid locks in most cases.
   if (thread_id == static_cast<int>(PlatformThread::CurrentId())) {
     const char* new_name =
         ThreadIdNameManager::GetInstance()->GetName(thread_id);
     // Check if the thread name has been set or changed since the previous
     // call (if any), but don't bother if the new name is empty. Note this will
     // not detect a thread name change within the same char* buffer address: we
     // favor common case performance over corner case correctness.
     if (new_name != g_current_thread_name.Get().Get() && new_name &&
@@ skipping 51 matching lines @@
             disabled_by_filters = false;
         });
     if (!disabled_by_filters)
       filtered_trace_event = std::move(new_trace_event);
   }
 
   // If enabled for recording, the event should be added only if one of the
   // filters indicates or category is not enabled for filtering.
   if ((*category_group_enabled & ENABLED_FOR_RECORDING) &&
       !disabled_by_filters) {
+    // |thread_local_event_buffer_| can be null if the current thread doesn't
+    // have a message loop or the message loop is blocked.
+    InitializeThreadLocalEventBufferIfSupported();
+    auto* thread_local_event_buffer = thread_local_event_buffer_.Get();
+
     OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = NULL;
     if (thread_local_event_buffer) {
       trace_event = thread_local_event_buffer->AddTraceEvent(&handle);
     } else {
       lock.EnsureAcquired();
       trace_event = AddEventToThreadSharedChunkWhileLocked(&handle, true);
     }
 
@@ skipping 498 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_, name_,
                                                 event_handle_);
   }
 }
 
 }  // namespace trace_event_internal