1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef SRC_TRACED_PROBES_FTRACE_FTRACE_CONTROLLER_H_ 18 #define SRC_TRACED_PROBES_FTRACE_FTRACE_CONTROLLER_H_ 19 20 #include <stdint.h> 21 #include <unistd.h> 22 23 #include <bitset> 24 #include <functional> 25 #include <map> 26 #include <memory> 27 #include <set> 28 #include <string> 29 30 #include "perfetto/base/gtest_prod_util.h" 31 #include "perfetto/base/task_runner.h" 32 #include "perfetto/base/utils.h" 33 #include "perfetto/base/weak_ptr.h" 34 #include "perfetto/tracing/core/basic_types.h" 35 #include "src/traced/probes/ftrace/ftrace_config.h" 36 #include "src/traced/probes/ftrace/ftrace_thread_sync.h" 37 38 namespace perfetto { 39 40 class CpuReader; 41 class FtraceConfigMuxer; 42 class FtraceDataSource; 43 class FtraceProcfs; 44 class ProtoTranslationTable; 45 struct FtraceStats; 46 47 // Method of last resort to reset ftrace state. 48 void HardResetFtraceState(); 49 50 // Utility class for controlling ftrace. 51 class FtraceController { 52 public: 53 static const char* const kTracingPaths[]; 54 55 class Observer { 56 public: 57 virtual ~Observer(); 58 virtual void OnFtraceDataWrittenIntoDataSourceBuffers() = 0; 59 }; 60 61 // The passed Observer must outlive the returned FtraceController instance. 62 static std::unique_ptr<FtraceController> Create(base::TaskRunner*, Observer*); 63 virtual ~FtraceController(); 64 65 // These two methods are called by CpuReader(s) from their worker threads. 66 static void OnCpuReaderRead(size_t cpu, int generation, FtraceThreadSync*); 67 static void OnCpuReaderFlush(size_t cpu, int generation, FtraceThreadSync*); 68 69 void DisableAllEvents(); 70 void WriteTraceMarker(const std::string& s); 71 void ClearTrace(); 72 73 bool AddDataSource(FtraceDataSource*) PERFETTO_WARN_UNUSED_RESULT; 74 bool StartDataSource(FtraceDataSource*); 75 void RemoveDataSource(FtraceDataSource*); 76 77 // Force a read of the ftrace buffers, including kernel buffer pages that 78 // are not full. Will call OnFtraceFlushComplete() on all 79 // |started_data_sources_| once all workers have flushed (or timed out). 80 void Flush(FlushRequestID); 81 82 void DumpFtraceStats(FtraceStats*); 83 GetWeakPtr()84 base::WeakPtr<FtraceController> GetWeakPtr() { 85 return weak_factory_.GetWeakPtr(); 86 } 87 88 protected: 89 // Protected for testing. 90 FtraceController(std::unique_ptr<FtraceProcfs>, 91 std::unique_ptr<ProtoTranslationTable>, 92 std::unique_ptr<FtraceConfigMuxer>, 93 base::TaskRunner*, 94 Observer*); 95 OnDrainCpuForTesting(size_t)96 virtual void OnDrainCpuForTesting(size_t /*cpu*/) {} 97 98 // Protected and virtual for testing. 99 virtual uint64_t NowMs() const; 100 101 private: 102 friend class TestFtraceController; 103 FRIEND_TEST(FtraceControllerIntegrationTest, EnableDisableEvent); 104 105 FtraceController(const FtraceController&) = delete; 106 FtraceController& operator=(const FtraceController&) = delete; 107 108 void OnFlushTimeout(FlushRequestID); 109 void DrainCPUs(int generation); 110 void UnblockReaders(); 111 void NotifyFlushCompleteToStartedDataSources(FlushRequestID); 112 void IssueThreadSyncCmd(FtraceThreadSync::Cmd, 113 std::unique_lock<std::mutex> = {}); 114 115 uint32_t GetDrainPeriodMs(); 116 117 void StartIfNeeded(); 118 void StopIfNeeded(); 119 120 base::TaskRunner* const task_runner_; 121 Observer* const observer_; 122 FtraceThreadSync thread_sync_; 123 std::unique_ptr<FtraceProcfs> ftrace_procfs_; 124 std::unique_ptr<ProtoTranslationTable> table_; 125 std::unique_ptr<FtraceConfigMuxer> ftrace_config_muxer_; 126 int generation_ = 0; 127 FlushRequestID cur_flush_request_id_ = 0; 128 bool atrace_running_ = false; 129 std::vector<std::unique_ptr<CpuReader>> cpu_readers_; 130 std::set<FtraceDataSource*> data_sources_; 131 std::set<FtraceDataSource*> started_data_sources_; 132 PERFETTO_THREAD_CHECKER(thread_checker_) 133 base::WeakPtrFactory<FtraceController> weak_factory_; // Keep last. 134 }; 135 136 } // namespace perfetto 137 138 #endif // SRC_TRACED_PROBES_FTRACE_FTRACE_CONTROLLER_H_ 139