1 /*
2 * Copyright (C) 2018 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 #include "test/test_helper.h"
18
19 #include "perfetto/base/compiler.h"
20 #include "perfetto/ext/tracing/core/trace_packet.h"
21 #include "perfetto/ext/tracing/ipc/default_socket.h"
22 #include "perfetto/tracing/core/tracing_service_state.h"
23
24 #include "protos/perfetto/trace/trace_packet.pbzero.h"
25
26 namespace perfetto {
27
28 namespace {
ProducerSocketForMode(TestHelper::Mode mode)29 const char* ProducerSocketForMode(TestHelper::Mode mode) {
30 #if !PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
31 base::ignore_result(mode);
32 return ::perfetto::GetProducerSocket();
33 #else
34 switch (mode) {
35 case TestHelper::Mode::kStartDaemons:
36 return "/data/local/tmp/traced_producer";
37 case TestHelper::Mode::kUseSystemService:
38 return ::perfetto::GetProducerSocket();
39 }
40 #endif
41 }
42
ConsumerSocketForMode(TestHelper::Mode mode)43 const char* ConsumerSocketForMode(TestHelper::Mode mode) {
44 #if !PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
45 base::ignore_result(mode);
46 return ::perfetto::GetConsumerSocket();
47 #else
48 switch (mode) {
49 case TestHelper::Mode::kStartDaemons:
50 return "/data/local/tmp/traced_consumer";
51 case TestHelper::Mode::kUseSystemService:
52 return ::perfetto::GetConsumerSocket();
53 }
54 #endif
55 }
56 } // namespace
57
58 uint64_t TestHelper::next_instance_num_ = 0;
59 #if PERFETTO_BUILDFLAG(PERFETTO_START_DAEMONS)
60 TestHelper::Mode TestHelper::kDefaultMode = Mode::kStartDaemons;
61 #else
62 TestHelper::Mode TestHelper::kDefaultMode = Mode::kUseSystemService;
63 #endif
64
TestHelper(base::TestTaskRunner * task_runner,Mode mode)65 TestHelper::TestHelper(base::TestTaskRunner* task_runner, Mode mode)
66 : instance_num_(next_instance_num_++),
67 task_runner_(task_runner),
68 mode_(mode),
69 producer_socket_(ProducerSocketForMode(mode)),
70 consumer_socket_(ConsumerSocketForMode(mode)),
71 service_thread_(producer_socket_, consumer_socket_),
72 fake_producer_thread_(producer_socket_,
73 WrapTask(CreateCheckpoint("producer.connect")),
74 WrapTask(CreateCheckpoint("producer.setup")),
75 WrapTask(CreateCheckpoint("producer.enabled"))) {}
76
OnConnect()77 void TestHelper::OnConnect() {
78 std::move(on_connect_callback_)();
79 }
80
OnDisconnect()81 void TestHelper::OnDisconnect() {
82 PERFETTO_FATAL("Consumer unexpectedly disconnected from the service");
83 }
84
OnTracingDisabled(const std::string &)85 void TestHelper::OnTracingDisabled(const std::string& /*error*/) {
86 std::move(on_stop_tracing_callback_)();
87 on_stop_tracing_callback_ = nullptr;
88 }
89
ReadTraceData(std::vector<TracePacket> packets)90 void TestHelper::ReadTraceData(std::vector<TracePacket> packets) {
91 for (auto& encoded_packet : packets) {
92 protos::gen::TracePacket packet;
93 PERFETTO_CHECK(
94 packet.ParseFromString(encoded_packet.GetRawBytesForTesting()));
95 full_trace_.push_back(packet);
96 if (packet.has_clock_snapshot() || packet.has_trace_uuid() ||
97 packet.has_trace_config() || packet.has_trace_stats() ||
98 !packet.synchronization_marker().empty() || packet.has_system_info() ||
99 packet.has_service_event()) {
100 continue;
101 }
102 PERFETTO_CHECK(packet.has_trusted_uid());
103 trace_.push_back(std::move(packet));
104 }
105 }
106
OnTraceData(std::vector<TracePacket> packets,bool has_more)107 void TestHelper::OnTraceData(std::vector<TracePacket> packets, bool has_more) {
108 ReadTraceData(std::move(packets));
109 if (!has_more) {
110 std::move(on_packets_finished_callback_)();
111 }
112 }
113
StartServiceIfRequired()114 void TestHelper::StartServiceIfRequired() {
115 if (mode_ == Mode::kStartDaemons)
116 env_cleaner_ = service_thread_.Start();
117 }
118
RestartService()119 void TestHelper::RestartService() {
120 PERFETTO_CHECK(mode_ == Mode::kStartDaemons);
121 service_thread_.Stop();
122 service_thread_.Start();
123 }
124
ConnectFakeProducer()125 FakeProducer* TestHelper::ConnectFakeProducer() {
126 fake_producer_thread_.Connect();
127 // This will wait until the service has seen the RegisterDataSource() call
128 // (because of the Sync() in FakeProducer::OnConnect()).
129 RunUntilCheckpoint("producer.connect");
130 return fake_producer_thread_.producer();
131 }
132
ConnectConsumer()133 void TestHelper::ConnectConsumer() {
134 cur_consumer_num_++;
135 on_connect_callback_ = CreateCheckpoint("consumer.connected." +
136 std::to_string(cur_consumer_num_));
137 endpoint_ = ConsumerIPCClient::Connect(consumer_socket_, this, task_runner_);
138 }
139
DetachConsumer(const std::string & key)140 void TestHelper::DetachConsumer(const std::string& key) {
141 on_detach_callback_ = CreateCheckpoint("detach." + key);
142 endpoint_->Detach(key);
143 RunUntilCheckpoint("detach." + key);
144 endpoint_.reset();
145 }
146
AttachConsumer(const std::string & key)147 bool TestHelper::AttachConsumer(const std::string& key) {
148 bool success = false;
149 auto checkpoint = CreateCheckpoint("attach." + key);
150 on_attach_callback_ = [&success, checkpoint](bool s) {
151 success = s;
152 checkpoint();
153 };
154 endpoint_->Attach(key);
155 RunUntilCheckpoint("attach." + key);
156 return success;
157 }
158
CreateProducerProvidedSmb()159 void TestHelper::CreateProducerProvidedSmb() {
160 fake_producer_thread_.CreateProducerProvidedSmb();
161 }
162
IsShmemProvidedByProducer()163 bool TestHelper::IsShmemProvidedByProducer() {
164 return fake_producer_thread_.producer()->IsShmemProvidedByProducer();
165 }
166
ProduceStartupEventBatch(const protos::gen::TestConfig & config)167 void TestHelper::ProduceStartupEventBatch(
168 const protos::gen::TestConfig& config) {
169 auto on_data_written = CreateCheckpoint("startup_data_written");
170 fake_producer_thread_.ProduceStartupEventBatch(config,
171 WrapTask(on_data_written));
172 RunUntilCheckpoint("startup_data_written");
173 }
174
StartTracing(const TraceConfig & config,base::ScopedFile file)175 void TestHelper::StartTracing(const TraceConfig& config,
176 base::ScopedFile file) {
177 PERFETTO_CHECK(!on_stop_tracing_callback_);
178 trace_.clear();
179 on_stop_tracing_callback_ =
180 CreateCheckpoint("stop.tracing" + std::to_string(++trace_count_));
181 endpoint_->EnableTracing(config, std::move(file));
182 }
183
DisableTracing()184 void TestHelper::DisableTracing() {
185 endpoint_->DisableTracing();
186 }
187
FlushAndWait(uint32_t timeout_ms)188 void TestHelper::FlushAndWait(uint32_t timeout_ms) {
189 static int flush_num = 0;
190 std::string checkpoint_name = "flush." + std::to_string(flush_num++);
191 auto checkpoint = CreateCheckpoint(checkpoint_name);
192 endpoint_->Flush(timeout_ms, [checkpoint](bool) { checkpoint(); });
193 RunUntilCheckpoint(checkpoint_name, timeout_ms + 1000);
194 }
195
ReadData(uint32_t read_count)196 void TestHelper::ReadData(uint32_t read_count) {
197 on_packets_finished_callback_ =
198 CreateCheckpoint("readback.complete." + std::to_string(read_count));
199 endpoint_->ReadBuffers();
200 }
201
FreeBuffers()202 void TestHelper::FreeBuffers() {
203 endpoint_->FreeBuffers();
204 }
205
WaitForConsumerConnect()206 void TestHelper::WaitForConsumerConnect() {
207 RunUntilCheckpoint("consumer.connected." + std::to_string(cur_consumer_num_));
208 }
209
WaitForProducerSetup()210 void TestHelper::WaitForProducerSetup() {
211 RunUntilCheckpoint("producer.setup");
212 }
213
WaitForProducerEnabled()214 void TestHelper::WaitForProducerEnabled() {
215 RunUntilCheckpoint("producer.enabled");
216 }
217
WaitForTracingDisabled(uint32_t timeout_ms)218 void TestHelper::WaitForTracingDisabled(uint32_t timeout_ms) {
219 RunUntilCheckpoint(std::string("stop.tracing") + std::to_string(trace_count_),
220 timeout_ms);
221 }
222
WaitForReadData(uint32_t read_count,uint32_t timeout_ms)223 void TestHelper::WaitForReadData(uint32_t read_count, uint32_t timeout_ms) {
224 RunUntilCheckpoint("readback.complete." + std::to_string(read_count),
225 timeout_ms);
226 }
227
WaitFor(std::function<bool ()> predicate,const std::string & error_msg,uint32_t timeout_ms)228 void TestHelper::WaitFor(std::function<bool()> predicate,
229 const std::string& error_msg,
230 uint32_t timeout_ms) {
231 int64_t deadline_ms = base::GetWallTimeMs().count() + timeout_ms;
232 while (base::GetWallTimeMs().count() < deadline_ms) {
233 if (predicate())
234 return;
235 base::SleepMicroseconds(500 * 1000); // 0.5 s.
236 }
237 PERFETTO_FATAL("Test timed out waiting for: %s", error_msg.c_str());
238 }
239
WaitForDataSourceConnected(const std::string & ds_name)240 void TestHelper::WaitForDataSourceConnected(const std::string& ds_name) {
241 auto predicate = [&] {
242 auto dss = QueryServiceStateAndWait().data_sources();
243 return std::any_of(dss.begin(), dss.end(),
244 [&](const TracingServiceState::DataSource& ds) {
245 return ds.ds_descriptor().name() == ds_name;
246 });
247 };
248 WaitFor(predicate, "connection of data source " + ds_name);
249 }
250
SyncAndWaitProducer()251 void TestHelper::SyncAndWaitProducer() {
252 static int sync_id = 0;
253 std::string checkpoint_name = "producer_sync_" + std::to_string(++sync_id);
254 auto checkpoint = CreateCheckpoint(checkpoint_name);
255 fake_producer_thread_.producer()->Sync(
256 [this, &checkpoint] { task_runner_->PostTask(checkpoint); });
257 RunUntilCheckpoint(checkpoint_name);
258 }
259
QueryServiceStateAndWait()260 TracingServiceState TestHelper::QueryServiceStateAndWait() {
261 TracingServiceState res;
262 static int n = 0;
263 std::string checkpoint_name = "query_svc_state_" + std::to_string(n++);
264 auto checkpoint = CreateCheckpoint(checkpoint_name);
265 auto callback = [&checkpoint, &res](bool, const TracingServiceState& tss) {
266 res = tss;
267 checkpoint();
268 };
269 endpoint_->QueryServiceState(callback);
270 RunUntilCheckpoint(checkpoint_name);
271 return res;
272 }
273
WrapTask(const std::function<void ()> & function)274 std::function<void()> TestHelper::WrapTask(
275 const std::function<void()>& function) {
276 return [this, function] { task_runner_->PostTask(function); };
277 }
278
OnDetach(bool)279 void TestHelper::OnDetach(bool) {
280 if (on_detach_callback_)
281 std::move(on_detach_callback_)();
282 }
283
OnAttach(bool success,const TraceConfig &)284 void TestHelper::OnAttach(bool success, const TraceConfig&) {
285 if (on_attach_callback_)
286 std::move(on_attach_callback_)(success);
287 }
288
OnTraceStats(bool,const TraceStats &)289 void TestHelper::OnTraceStats(bool, const TraceStats&) {}
290
OnObservableEvents(const ObservableEvents &)291 void TestHelper::OnObservableEvents(const ObservableEvents&) {}
292
OnSessionCloned(const OnSessionClonedArgs &)293 void TestHelper::OnSessionCloned(const OnSessionClonedArgs&) {}
294
295 // static
GetDefaultModeConsumerSocketName()296 const char* TestHelper::GetDefaultModeConsumerSocketName() {
297 return ConsumerSocketForMode(TestHelper::kDefaultMode);
298 }
299
300 // static
GetDefaultModeProducerSocketName()301 const char* TestHelper::GetDefaultModeProducerSocketName() {
302 return ProducerSocketForMode(TestHelper::kDefaultMode);
303 }
304
305 } // namespace perfetto
306