| /* |
| * Copyright (C) 2018 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include <unistd.h> |
| |
| #include <chrono> |
| #include <functional> |
| #include <initializer_list> |
| #include <random> |
| #include <thread> |
| |
| #include "perfetto/base/build_config.h" |
| #include "perfetto/base/logging.h" |
| #include "perfetto/ext/base/file_utils.h" |
| #include "perfetto/ext/base/pipe.h" |
| #include "perfetto/ext/base/temp_file.h" |
| #include "perfetto/ext/traced/traced.h" |
| #include "perfetto/ext/tracing/core/trace_packet.h" |
| #include "perfetto/ext/tracing/ipc/default_socket.h" |
| #include "perfetto/protozero/scattered_heap_buffer.h" |
| #include "protos/perfetto/config/power/android_power_config.pbzero.h" |
| #include "protos/perfetto/config/test_config.gen.h" |
| #include "protos/perfetto/config/trace_config.gen.h" |
| #include "protos/perfetto/trace/trace.pb.h" |
| #include "protos/perfetto/trace/trace_packet.pb.h" |
| #include "protos/perfetto/trace/trace_packet.pbzero.h" |
| #include "src/base/test/test_task_runner.h" |
| #include "src/traced/probes/ftrace/ftrace_controller.h" |
| #include "src/traced/probes/ftrace/ftrace_procfs.h" |
| #include "test/gtest_and_gmock.h" |
| #include "test/task_runner_thread.h" |
| #include "test/task_runner_thread_delegates.h" |
| #include "test/test_helper.h" |
| |
| namespace perfetto { |
| |
| namespace { |
| |
| using ::testing::ContainsRegex; |
| using ::testing::HasSubstr; |
| |
| std::string RandomTraceFileName() { |
| #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) |
| constexpr char kSysTmpPath[] = "/data/misc/perfetto-traces"; |
| #else |
| constexpr char kSysTmpPath[] = "/tmp"; |
| #endif |
| static int suffix = 0; |
| |
| std::string path; |
| path.assign(kSysTmpPath); |
| path.append("/trace-"); |
| path.append(std::to_string(base::GetBootTimeNs().count())); |
| path.append("-"); |
| path.append(std::to_string(suffix++)); |
| return path; |
| } |
| |
| // This class is a reference to a child process that has in essence been execv |
| // to the requested binary. The process will start and then wait for Run() |
| // before proceeding. We use this to fork new processes before starting any |
| // additional threads in the parent process (otherwise you would risk |
| // deadlocks), but pause the forked processes until remaining setup (including |
| // any necessary threads) in the parent process is complete. |
| class Exec { |
| public: |
| // Starts the forked process that was created. If not null then |stderr_out |
| // will contain the std::cerr output of the process. |
| int Run(std::string* stderr_out = nullptr) { |
| // We can't be the child process. |
| PERFETTO_CHECK(pid_ != 0); |
| |
| // Send some random bytes so the child process knows the service is up and |
| // it can connect and execute. |
| PERFETTO_CHECK(PERFETTO_EINTR(write(*start_pipe_.wr, "42", 2)) == |
| static_cast<ssize_t>(2)); |
| start_pipe_.wr.reset(); |
| |
| // Setup a large enough buffer and read all of stderr (until the process |
| // closes the err_pipe on process exit). |
| std::string stderr_str = std::string(1024 * 1024, '\0'); |
| ssize_t rsize = 0; |
| size_t stderr_pos = 0; |
| while (stderr_pos < stderr_str.size()) { |
| rsize = PERFETTO_EINTR(read(*err_pipe_.rd, &stderr_str[stderr_pos], |
| stderr_str.size() - stderr_pos - 1)); |
| if (rsize <= 0) |
| break; |
| stderr_pos += static_cast<size_t>(rsize); |
| } |
| stderr_str.resize(stderr_pos); |
| |
| // Either output the stderr_out to the provided variable or for the record |
| // it into the info logs. |
| if (stderr_out) { |
| *stderr_out = stderr_str; |
| } else { |
| PERFETTO_LOG("Child proc %d exited with stderr: \"%s\"", pid_, |
| stderr_str.c_str()); |
| } |
| |
| int status = 1; |
| PERFETTO_CHECK(PERFETTO_EINTR(waitpid(pid_, &status, 0)) == pid_); |
| int exit_code; |
| if (WIFEXITED(status)) { |
| exit_code = WEXITSTATUS(status); |
| } else if (WIFSIGNALED(status)) { |
| exit_code = -(WTERMSIG(status)); |
| PERFETTO_CHECK(exit_code < 0); |
| } else { |
| PERFETTO_FATAL("Unexpected exit status: %d", status); |
| } |
| return exit_code; |
| } |
| |
| private: |
| Exec(pid_t pid, base::Pipe err, base::Pipe start) |
| : pid_(pid), err_pipe_(std::move(err)), start_pipe_(std::move(start)) {} |
| |
| static Exec Create(const std::string& argv0, |
| std::initializer_list<std::string> args, |
| std::string input = "") { |
| if (argv0 != "perfetto" && argv0 != "trigger_perfetto") { |
| PERFETTO_FATAL( |
| "Received argv0: \"%s\" which isn't supported. Supported binaries " |
| "are \"perfetto\" or \"trigger_perfetto\".", |
| argv0.c_str()); |
| } |
| |
| // |in_pipe| == std::cin, |err_pipe| == std::cerr for the process we're |
| // about to fork. |start_pipe| is used to block the process so we can hold |
| // it until we're ready (the service has started up). |
| base::Pipe in_pipe = base::Pipe::Create(); |
| base::Pipe err_pipe = base::Pipe::Create(); |
| base::Pipe start_pipe = base::Pipe::Create(); |
| |
| pid_t pid = fork(); |
| PERFETTO_CHECK(pid >= 0); |
| if (pid == 0) { |
| // Child process, we need to block the child process until we've been |
| // signaled on the |start_pipe|. |
| std::string junk = std::string(4, '\0'); |
| start_pipe.wr.reset(); |
| ssize_t rsize = 0; |
| rsize = PERFETTO_EINTR(read(*start_pipe.rd, &junk[0], junk.size() - 1)); |
| PERFETTO_CHECK(rsize >= 0); |
| start_pipe.rd.reset(); |
| |
| // We've been signalled to start so execute in a sub function. |
| _exit(RunChild(argv0, std::move(args), std::move(in_pipe), |
| std::move(err_pipe))); |
| } else { |
| // Parent, we don't need to write to the childs std::cerr nor do we need |
| // to read the start_pipe. |
| err_pipe.wr.reset(); |
| start_pipe.rd.reset(); |
| |
| // This is generally an unsafe pattern because the child process might |
| // be blocked on stdout and stall the stdin reads. It's pragmatically |
| // okay for our test cases because stdin is not expected to exceed the |
| // pipe buffer. |
| // |
| // We need to write this now up front (rather than in Run(), because in |
| // some tests we create multiple Exec classes, and if we don't close the |
| // input pipe up front then future Exec's will have a reference and the |
| // pipe won't close properly. |
| PERFETTO_CHECK(input.size() <= base::kPageSize); |
| PERFETTO_CHECK( |
| PERFETTO_EINTR(write(*in_pipe.wr, input.data(), input.size())) == |
| static_cast<ssize_t>(input.size())); |
| in_pipe.wr.reset(); |
| // Close the input pipe only after the write so we don't get an EPIPE |
| // signal in the cases when the child process earlies out without |
| // reading stdin. |
| in_pipe.rd.reset(); |
| |
| return Exec(pid, std::move(err_pipe), std::move(start_pipe)); |
| } |
| } |
| |
| // Wrapper to contain all the work the child process needs to do. |
| static int RunChild(const std::string& argv0, |
| std::initializer_list<std::string> args, |
| base::Pipe in_pipe, |
| base::Pipe err_pipe) { |
| // This sets up the char** argv buffer we're going to provide to the main |
| // function for |argv0| binary. |
| std::vector<char> argv_buffer; |
| std::vector<size_t> argv_offsets; |
| std::vector<char*> argv; |
| argv_offsets.push_back(0); |
| |
| argv_buffer.insert(argv_buffer.end(), argv0.begin(), argv0.end()); |
| argv_buffer.push_back('\0'); |
| |
| for (const std::string& arg : args) { |
| argv_offsets.push_back(argv_buffer.size()); |
| argv_buffer.insert(argv_buffer.end(), arg.begin(), arg.end()); |
| argv_buffer.push_back('\0'); |
| } |
| |
| for (size_t off : argv_offsets) |
| argv.push_back(&argv_buffer[off]); |
| argv.push_back(nullptr); |
| |
| // We aren't reading std::cerr nor writing to std::cin. |
| err_pipe.rd.reset(); |
| in_pipe.wr.reset(); |
| |
| // This makes it so the binaries below will correctly write their std::cin |
| // and std::cerr to the right pipes. |
| int devnull = open("/dev/null", O_RDWR); |
| PERFETTO_CHECK(devnull >= 0); |
| PERFETTO_CHECK(dup2(*in_pipe.rd, STDIN_FILENO) != -1); |
| PERFETTO_CHECK(dup2(devnull, STDOUT_FILENO) != -1); |
| PERFETTO_CHECK(dup2(*err_pipe.wr, STDERR_FILENO) != -1); |
| #if PERFETTO_BUILDFLAG(PERFETTO_START_DAEMONS) |
| setenv("PERFETTO_CONSUMER_SOCK_NAME", TestHelper::GetConsumerSocketName(), |
| 1); |
| setenv("PERFETTO_PRODUCER_SOCK_NAME", TestHelper::GetProducerSocketName(), |
| 1); |
| if (argv0 == "perfetto") { |
| return PerfettoCmdMain(static_cast<int>(argv.size() - 1), argv.data()); |
| } else if (argv0 == "trigger_perfetto") { |
| return TriggerPerfettoMain(static_cast<int>(argv.size() - 1), |
| argv.data()); |
| } else { |
| PERFETTO_FATAL("Unknown binary: %s", argv0.c_str()); |
| return 4; |
| } |
| #else |
| execv((std::string("/system/bin/") + argv0).c_str(), &argv[0]); |
| return 3; |
| #endif |
| } |
| |
| friend class PerfettoCmdlineTest; |
| |
| pid_t pid_; |
| base::Pipe err_pipe_; |
| base::Pipe start_pipe_; |
| }; |
| |
| class PerfettoTest : public ::testing::Test { |
| public: |
| void SetUp() override { |
| // TODO(primiano): refactor this, it's copy/pasted in three places now. |
| size_t index = 0; |
| constexpr auto kTracingPaths = FtraceController::kTracingPaths; |
| while (!ftrace_procfs_ && kTracingPaths[index]) { |
| ftrace_procfs_ = FtraceProcfs::Create(kTracingPaths[index++]); |
| } |
| if (!ftrace_procfs_) |
| return; |
| ftrace_procfs_->SetTracingOn(false); |
| } |
| |
| void TearDown() override { |
| if (ftrace_procfs_) |
| ftrace_procfs_->SetTracingOn(false); |
| } |
| |
| std::unique_ptr<FtraceProcfs> ftrace_procfs_; |
| }; |
| |
| class PerfettoCmdlineTest : public ::testing::Test { |
| public: |
| void SetUp() override { exec_allowed_ = true; } |
| |
| void TearDown() override {} |
| |
| void StartServiceIfRequiredNoNewExecsAfterThis() { |
| exec_allowed_ = false; |
| test_helper_.StartServiceIfRequired(); |
| } |
| |
| FakeProducer* ConnectFakeProducer() { |
| return test_helper_.ConnectFakeProducer(); |
| } |
| |
| std::function<void()> WrapTask(const std::function<void()>& function) { |
| return test_helper_.WrapTask(function); |
| } |
| |
| void WaitForProducerSetup() { test_helper_.WaitForProducerSetup(); } |
| |
| void WaitForProducerEnabled() { test_helper_.WaitForProducerEnabled(); } |
| |
| // Creates a process that represents the perfetto binary that will |
| // start when Run() is called. |args| will be passed as part of |
| // the command line and |std_in| will be piped into std::cin. |
| Exec ExecPerfetto(std::initializer_list<std::string> args, |
| std::string std_in = "") { |
| // You can not fork after you've started the service due to risk of |
| // deadlocks. |
| PERFETTO_CHECK(exec_allowed_); |
| return Exec::Create("perfetto", std::move(args), std::move(std_in)); |
| } |
| |
| // Creates a process that represents the trigger_perfetto binary that will |
| // start when Run() is called. |args| will be passed as part of |
| // the command line and |std_in| will be piped into std::cin. |
| Exec ExecTrigger(std::initializer_list<std::string> args, |
| std::string std_in = "") { |
| // You can not fork after you've started the service due to risk of |
| // deadlocks. |
| PERFETTO_CHECK(exec_allowed_); |
| return Exec::Create("trigger_perfetto", std::move(args), std::move(std_in)); |
| } |
| |
| // Tests are allowed to freely use these variables. |
| std::string stderr_; |
| base::TestTaskRunner task_runner_; |
| |
| private: |
| bool exec_allowed_; |
| TestHelper test_helper_{&task_runner_}; |
| }; |
| |
| } // namespace |
| |
| // If we're building on Android and starting the daemons ourselves, |
| // create the sockets in a world-writable location. |
| #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \ |
| PERFETTO_BUILDFLAG(PERFETTO_START_DAEMONS) |
| #define TEST_PRODUCER_SOCK_NAME "/data/local/tmp/traced_producer" |
| #else |
| #define TEST_PRODUCER_SOCK_NAME ::perfetto::GetProducerSocket() |
| #endif |
| |
| // TODO(b/73453011): reenable on more platforms (including standalone Android). |
| #if PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) |
| #define TreeHuggerOnly(x) x |
| #else |
| #define TreeHuggerOnly(x) DISABLED_##x |
| #endif |
| |
| TEST_F(PerfettoTest, TreeHuggerOnly(TestFtraceProducer)) { |
| base::TestTaskRunner task_runner; |
| |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| |
| #if PERFETTO_BUILDFLAG(PERFETTO_START_DAEMONS) |
| TaskRunnerThread producer_thread("perfetto.prd"); |
| producer_thread.Start(std::unique_ptr<ProbesProducerDelegate>( |
| new ProbesProducerDelegate(TEST_PRODUCER_SOCK_NAME))); |
| #endif |
| |
| helper.ConnectConsumer(); |
| helper.WaitForConsumerConnect(); |
| |
| TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(1024); |
| trace_config.set_duration_ms(3000); |
| |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("linux.ftrace"); |
| ds_config->set_target_buffer(0); |
| |
| protos::FtraceConfig ftrace_config; |
| ftrace_config.add_ftrace_events("sched_switch"); |
| ftrace_config.add_ftrace_events("bar"); |
| ds_config->set_ftrace_config_raw(ftrace_config.SerializeAsString()); |
| |
| helper.StartTracing(trace_config); |
| helper.WaitForTracingDisabled(); |
| |
| helper.ReadData(); |
| helper.WaitForReadData(); |
| |
| const auto& packets = helper.trace(); |
| ASSERT_GT(packets.size(), 0u); |
| |
| for (const auto& packet : packets) { |
| for (int ev = 0; ev < packet.ftrace_events().event_size(); ev++) { |
| ASSERT_TRUE(packet.ftrace_events().event(ev).has_sched_switch()); |
| } |
| } |
| } |
| |
| TEST_F(PerfettoTest, TreeHuggerOnly(TestFtraceFlush)) { |
| base::TestTaskRunner task_runner; |
| |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| |
| #if PERFETTO_BUILDFLAG(PERFETTO_START_DAEMONS) |
| TaskRunnerThread producer_thread("perfetto.prd"); |
| producer_thread.Start(std::unique_ptr<ProbesProducerDelegate>( |
| new ProbesProducerDelegate(TEST_PRODUCER_SOCK_NAME))); |
| #endif |
| |
| helper.ConnectConsumer(); |
| helper.WaitForConsumerConnect(); |
| |
| const uint32_t kTestTimeoutMs = 30000; |
| TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(16); |
| trace_config.set_duration_ms(kTestTimeoutMs); |
| |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("linux.ftrace"); |
| |
| protos::FtraceConfig ftrace_config; |
| ftrace_config.add_ftrace_events("print"); |
| ds_config->set_ftrace_config_raw(ftrace_config.SerializeAsString()); |
| |
| helper.StartTracing(trace_config); |
| |
| // Do a first flush just to synchronize with the producer. The problem here |
| // is that, on a Linux workstation, the producer can take several seconds just |
| // to get to the point where ftrace is ready. We use the flush ack as a |
| // synchronization point. |
| helper.FlushAndWait(kTestTimeoutMs); |
| |
| EXPECT_TRUE(ftrace_procfs_->IsTracingEnabled()); |
| const char kMarker[] = "just_one_event"; |
| EXPECT_TRUE(ftrace_procfs_->WriteTraceMarker(kMarker)); |
| |
| // This is the real flush we are testing. |
| helper.FlushAndWait(kTestTimeoutMs); |
| |
| helper.DisableTracing(); |
| helper.WaitForTracingDisabled(kTestTimeoutMs); |
| |
| helper.ReadData(); |
| helper.WaitForReadData(); |
| |
| int marker_found = 0; |
| for (const auto& packet : helper.trace()) { |
| for (int i = 0; i < packet.ftrace_events().event_size(); i++) { |
| const auto& ev = packet.ftrace_events().event(i); |
| if (ev.has_print() && ev.print().buf().find(kMarker) != std::string::npos) |
| marker_found++; |
| } |
| } |
| ASSERT_EQ(marker_found, 1); |
| } |
| |
| TEST_F(PerfettoTest, TreeHuggerOnly(TestBatteryTracing)) { |
| base::TestTaskRunner task_runner; |
| |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| |
| #if PERFETTO_BUILDFLAG(PERFETTO_START_DAEMONS) |
| TaskRunnerThread producer_thread("perfetto.prd"); |
| producer_thread.Start(std::unique_ptr<ProbesProducerDelegate>( |
| new ProbesProducerDelegate(TEST_PRODUCER_SOCK_NAME))); |
| #else |
| base::ignore_result(TEST_PRODUCER_SOCK_NAME); |
| #endif |
| |
| helper.ConnectConsumer(); |
| helper.WaitForConsumerConnect(); |
| |
| TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(128); |
| trace_config.set_duration_ms(3000); |
| |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.power"); |
| ds_config->set_target_buffer(0); |
| |
| using protos::pbzero::AndroidPowerConfig; |
| protozero::HeapBuffered<AndroidPowerConfig> power_config; |
| power_config->set_battery_poll_ms(250); |
| power_config->add_battery_counters( |
| AndroidPowerConfig::BATTERY_COUNTER_CHARGE); |
| power_config->add_battery_counters( |
| AndroidPowerConfig::BATTERY_COUNTER_CAPACITY_PERCENT); |
| ds_config->set_android_power_config_raw(power_config.SerializeAsString()); |
| |
| helper.StartTracing(trace_config); |
| helper.WaitForTracingDisabled(); |
| |
| helper.ReadData(); |
| helper.WaitForReadData(); |
| |
| const auto& packets = helper.trace(); |
| ASSERT_GT(packets.size(), 0u); |
| |
| bool has_battery_packet = false; |
| for (const auto& packet : packets) { |
| if (!packet.has_battery()) |
| continue; |
| has_battery_packet = true; |
| // Unfortunately we cannot make any assertions on the charge counter. |
| // On some devices it can reach negative values (b/64685329). |
| EXPECT_GE(packet.battery().capacity_percent(), 0); |
| EXPECT_LE(packet.battery().capacity_percent(), 100); |
| } |
| |
| ASSERT_TRUE(has_battery_packet); |
| } |
| |
| TEST_F(PerfettoTest, TestFakeProducer) { |
| base::TestTaskRunner task_runner; |
| |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| helper.ConnectFakeProducer(); |
| helper.ConnectConsumer(); |
| helper.WaitForConsumerConnect(); |
| |
| TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(1024); |
| trace_config.set_duration_ms(200); |
| |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.perfetto.FakeProducer"); |
| ds_config->set_target_buffer(0); |
| |
| static constexpr size_t kNumPackets = 11; |
| static constexpr uint32_t kRandomSeed = 42; |
| static constexpr uint32_t kMsgSize = 1024; |
| ds_config->mutable_for_testing()->set_seed(kRandomSeed); |
| ds_config->mutable_for_testing()->set_message_count(kNumPackets); |
| ds_config->mutable_for_testing()->set_message_size(kMsgSize); |
| ds_config->mutable_for_testing()->set_send_batch_on_register(true); |
| |
| helper.StartTracing(trace_config); |
| helper.WaitForTracingDisabled(); |
| |
| helper.ReadData(); |
| helper.WaitForReadData(); |
| |
| const auto& packets = helper.trace(); |
| ASSERT_EQ(packets.size(), kNumPackets); |
| |
| std::minstd_rand0 rnd_engine(kRandomSeed); |
| for (const auto& packet : packets) { |
| ASSERT_TRUE(packet.has_for_testing()); |
| ASSERT_EQ(packet.for_testing().seq_value(), rnd_engine()); |
| } |
| } |
| |
| TEST_F(PerfettoTest, VeryLargePackets) { |
| base::TestTaskRunner task_runner; |
| |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| helper.ConnectFakeProducer(); |
| helper.ConnectConsumer(); |
| helper.WaitForConsumerConnect(); |
| |
| TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(4096 * 10); |
| trace_config.set_duration_ms(500); |
| |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.perfetto.FakeProducer"); |
| ds_config->set_target_buffer(0); |
| |
| static constexpr size_t kNumPackets = 7; |
| static constexpr uint32_t kRandomSeed = 42; |
| static constexpr uint32_t kMsgSize = 1024 * 1024 - 42; |
| ds_config->mutable_for_testing()->set_seed(kRandomSeed); |
| ds_config->mutable_for_testing()->set_message_count(kNumPackets); |
| ds_config->mutable_for_testing()->set_message_size(kMsgSize); |
| ds_config->mutable_for_testing()->set_send_batch_on_register(true); |
| |
| helper.StartTracing(trace_config); |
| helper.WaitForTracingDisabled(); |
| |
| helper.ReadData(); |
| helper.WaitForReadData(); |
| |
| const auto& packets = helper.trace(); |
| ASSERT_EQ(packets.size(), kNumPackets); |
| |
| std::minstd_rand0 rnd_engine(kRandomSeed); |
| for (const auto& packet : packets) { |
| ASSERT_TRUE(packet.has_for_testing()); |
| ASSERT_EQ(packet.for_testing().seq_value(), rnd_engine()); |
| size_t msg_size = packet.for_testing().str().size(); |
| ASSERT_EQ(kMsgSize, msg_size); |
| for (size_t i = 0; i < msg_size; i++) |
| ASSERT_EQ(i < msg_size - 1 ? '.' : 0, packet.for_testing().str()[i]); |
| } |
| } |
| |
| TEST_F(PerfettoTest, DetachAndReattach) { |
| base::TestTaskRunner task_runner; |
| |
| TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(1024); |
| trace_config.set_duration_ms(10000); // Max timeout, session is ended before. |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.perfetto.FakeProducer"); |
| static constexpr size_t kNumPackets = 11; |
| ds_config->mutable_for_testing()->set_message_count(kNumPackets); |
| ds_config->mutable_for_testing()->set_message_size(32); |
| |
| // Enable tracing and detach as soon as it gets started. |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| auto* fake_producer = helper.ConnectFakeProducer(); |
| helper.ConnectConsumer(); |
| helper.WaitForConsumerConnect(); |
| helper.StartTracing(trace_config); |
| |
| // Detach. |
| helper.DetachConsumer("key"); |
| |
| // Write data while detached. |
| helper.WaitForProducerEnabled(); |
| auto on_data_written = task_runner.CreateCheckpoint("data_written"); |
| fake_producer->ProduceEventBatch(helper.WrapTask(on_data_written)); |
| task_runner.RunUntilCheckpoint("data_written"); |
| |
| // Then reattach the consumer. |
| helper.ConnectConsumer(); |
| helper.WaitForConsumerConnect(); |
| helper.AttachConsumer("key"); |
| |
| helper.DisableTracing(); |
| helper.WaitForTracingDisabled(); |
| |
| helper.ReadData(); |
| helper.WaitForReadData(); |
| const auto& packets = helper.trace(); |
| ASSERT_EQ(packets.size(), kNumPackets); |
| } |
| |
| // Tests that a detached trace session is automatically cleaned up if the |
| // consumer doesn't re-attach before its expiration time. |
| TEST_F(PerfettoTest, ReattachFailsAfterTimeout) { |
| base::TestTaskRunner task_runner; |
| |
| TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(1024); |
| trace_config.set_duration_ms(250); |
| trace_config.set_write_into_file(true); |
| trace_config.set_file_write_period_ms(100000); |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.perfetto.FakeProducer"); |
| ds_config->mutable_for_testing()->set_message_count(1); |
| ds_config->mutable_for_testing()->set_message_size(32); |
| ds_config->mutable_for_testing()->set_send_batch_on_register(true); |
| |
| // Enable tracing and detach as soon as it gets started. |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| helper.ConnectFakeProducer(); |
| helper.ConnectConsumer(); |
| helper.WaitForConsumerConnect(); |
| |
| auto pipe_pair = base::Pipe::Create(); |
| helper.StartTracing(trace_config, std::move(pipe_pair.wr)); |
| |
| // Detach. |
| helper.DetachConsumer("key"); |
| |
| // Use the file EOF (write end closed) as a way to detect when the trace |
| // session is ended. |
| char buf[1024]; |
| while (PERFETTO_EINTR(read(*pipe_pair.rd, buf, sizeof(buf))) > 0) { |
| } |
| |
| // Give some margin for the tracing service to destroy the session. |
| usleep(250000); |
| |
| // Reconnect and find out that it's too late and the session is gone. |
| helper.ConnectConsumer(); |
| helper.WaitForConsumerConnect(); |
| EXPECT_FALSE(helper.AttachConsumer("key")); |
| } |
| |
| // Disable cmdline tests on sanitizets because they use fork() and that messes |
| // up leak / races detections, which has been fixed only recently (see |
| // https://github.com/google/sanitizers/issues/836 ). |
| #if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) || \ |
| defined(MEMORY_SANITIZER) || defined(LEAK_SANITIZER) |
| #define NoSanitizers(X) DISABLED_##X |
| #else |
| #define NoSanitizers(X) X |
| #endif |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(InvalidCases)) { |
| std::string cfg("duration_ms: 100"); |
| |
| auto invalid_arg = ExecPerfetto({"--invalid-arg"}); |
| auto empty_config = ExecPerfetto({"-c", "-", "-o", "-"}, ""); |
| |
| // Cannot make assertions on --dropbox because on standalone builds it fails |
| // prematurely due to lack of dropbox. |
| auto missing_dropbox = |
| ExecPerfetto({"-c", "-", "--txt", "-o", "-", "--dropbox=foo"}, cfg); |
| auto either_out_or_dropbox = ExecPerfetto({"-c", "-", "--txt"}, cfg); |
| |
| // Disallow mixing simple and file config. |
| auto simple_and_file_1 = |
| ExecPerfetto({"-o", "-", "-c", "-", "-t", "2s"}, cfg); |
| auto simple_and_file_2 = |
| ExecPerfetto({"-o", "-", "-c", "-", "-b", "2m"}, cfg); |
| auto simple_and_file_3 = |
| ExecPerfetto({"-o", "-", "-c", "-", "-s", "2m"}, cfg); |
| |
| // Invalid --attach / --detach cases. |
| auto invalid_stop = |
| ExecPerfetto({"-c", "-", "--txt", "-o", "-", "--stop"}, cfg); |
| auto attach_and_config_1 = |
| ExecPerfetto({"-c", "-", "--txt", "-o", "-", "--attach=foo"}, cfg); |
| auto attach_and_config_2 = |
| ExecPerfetto({"-t", "2s", "-o", "-", "--attach=foo"}, cfg); |
| auto attach_needs_argument = ExecPerfetto({"--attach"}, cfg); |
| auto detach_needs_argument = |
| ExecPerfetto({"-t", "2s", "-o", "-", "--detach"}, cfg); |
| auto detach_without_out_or_dropbox = |
| ExecPerfetto({"-t", "2s", "--detach=foo"}, cfg); |
| |
| // Cannot trace and use --query. |
| auto trace_and_query_1 = ExecPerfetto({"-t", "2s", "--query"}, cfg); |
| auto trace_and_query_2 = ExecPerfetto({"-c", "-", "--query"}, cfg); |
| |
| // Ensure all Exec:: calls have been saved to prevent deadlocks. |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| |
| EXPECT_EQ(1, invalid_arg.Run(&stderr_)); |
| |
| EXPECT_EQ(1, empty_config.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("TraceConfig is empty")); |
| |
| // Cannot make assertions on --dropbox because on standalone builds it fails |
| // prematurely due to lack of dropbox. |
| EXPECT_EQ(1, missing_dropbox.Run(&stderr_)); |
| |
| EXPECT_EQ(1, either_out_or_dropbox.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("Either --out or --dropbox")); |
| |
| // Disallow mixing simple and file config. |
| EXPECT_EQ(1, simple_and_file_1.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify both -c")); |
| |
| EXPECT_EQ(1, simple_and_file_2.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify both -c")); |
| |
| EXPECT_EQ(1, simple_and_file_3.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify both -c")); |
| |
| // Invalid --attach / --detach cases. |
| EXPECT_EQ(1, invalid_stop.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("--stop is supported only in combination")); |
| |
| EXPECT_EQ(1, attach_and_config_1.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify a trace config")); |
| |
| EXPECT_EQ(1, attach_and_config_2.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify a trace config")); |
| |
| EXPECT_EQ(1, attach_needs_argument.Run(&stderr_)); |
| EXPECT_THAT(stderr_, ContainsRegex("option.*--attach.*requires an argument")); |
| |
| EXPECT_EQ(1, detach_needs_argument.Run(&stderr_)); |
| EXPECT_THAT(stderr_, ContainsRegex("option.*--detach.*requires an argument")); |
| |
| EXPECT_EQ(1, detach_without_out_or_dropbox.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("--out or --dropbox is required")); |
| |
| // Cannot trace and use --query. |
| EXPECT_EQ(1, trace_and_query_1.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify a trace config")); |
| |
| EXPECT_EQ(1, trace_and_query_2.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify a trace config")); |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(TxtConfig)) { |
| std::string cfg("duration_ms: 100"); |
| auto perfetto = ExecPerfetto({"-c", "-", "--txt", "-o", "-"}, cfg); |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| EXPECT_EQ(0, perfetto.Run(&stderr_)) << stderr_; |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(SimpleConfig)) { |
| auto perfetto = ExecPerfetto({"-o", "-", "-c", "-", "-t", "100ms"}); |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| EXPECT_EQ(0, perfetto.Run(&stderr_)) << stderr_; |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(DetachAndAttach)) { |
| auto attach_to_not_existing = ExecPerfetto({"--attach=not_existent"}); |
| |
| std::string cfg("duration_ms: 10000; write_into_file: true"); |
| auto detach_valid_stop = |
| ExecPerfetto({"-o", "-", "-c", "-", "--txt", "--detach=valid_stop"}, cfg); |
| auto stop_valid_stop = ExecPerfetto({"--attach=valid_stop", "--stop"}); |
| |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| |
| EXPECT_NE(0, attach_to_not_existing.Run(&stderr_)); |
| EXPECT_THAT(stderr_, HasSubstr("Session re-attach failed")); |
| |
| EXPECT_EQ(0, detach_valid_stop.Run(&stderr_)) << stderr_; |
| EXPECT_EQ(0, stop_valid_stop.Run(&stderr_)); |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(StartTracingTrigger)) { |
| // See |message_count| and |message_size| in the TraceConfig above. |
| constexpr size_t kMessageCount = 11; |
| constexpr size_t kMessageSize = 32; |
| protos::TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(1024); |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.perfetto.FakeProducer"); |
| ds_config->mutable_for_testing()->set_message_count(kMessageCount); |
| ds_config->mutable_for_testing()->set_message_size(kMessageSize); |
| auto* trigger_cfg = trace_config.mutable_trigger_config(); |
| trigger_cfg->set_trigger_mode( |
| protos::TraceConfig::TriggerConfig::START_TRACING); |
| trigger_cfg->set_trigger_timeout_ms(15000); |
| auto* trigger = trigger_cfg->add_triggers(); |
| trigger->set_name("trigger_name"); |
| // |stop_delay_ms| must be long enough that we can write the packets in |
| // before the trace finishes. This has to be long enough for the slowest |
| // emulator. But as short as possible to prevent the test running a long |
| // time. |
| trigger->set_stop_delay_ms(500); |
| |
| // We have 6 normal preamble packets (start clock, trace config, clock, |
| // system info, sync marker, stats) and then since this is a trace with a |
| // trigger config we have an additional ReceivedTriggers packet. |
| constexpr size_t kPreamblePackets = 7; |
| |
| // We have to construct all the processes we want to fork before we start the |
| // service with |StartServiceIfRequired()|. this is because it is unsafe |
| // (could deadlock) to fork after we've spawned some threads which might |
| // printf (and thus hold locks). |
| const std::string path = RandomTraceFileName(); |
| auto perfetto_proc = ExecPerfetto( |
| { |
| "-o", |
| path, |
| "-c", |
| "-", |
| }, |
| trace_config.SerializeAsString()); |
| |
| auto trigger_proc = ExecTrigger({"trigger_name"}); |
| |
| // Start the service and connect a simple fake producer. |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| |
| auto* fake_producer = ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| |
| // Start a background thread that will deliver the config now that we've |
| // started the service. See |perfetto_proc| above for the args passed. |
| std::thread background_trace([&perfetto_proc]() { |
| std::string stderr_str; |
| EXPECT_EQ(0, perfetto_proc.Run(&stderr_str)) << stderr_str; |
| }); |
| |
| WaitForProducerSetup(); |
| EXPECT_EQ(0, trigger_proc.Run(&stderr_)); |
| |
| // Wait for the producer to start, and then write out 11 packets. |
| WaitForProducerEnabled(); |
| auto on_data_written = task_runner_.CreateCheckpoint("data_written"); |
| fake_producer->ProduceEventBatch(WrapTask(on_data_written)); |
| task_runner_.RunUntilCheckpoint("data_written"); |
| background_trace.join(); |
| |
| std::string trace_str; |
| base::ReadFile(path, &trace_str); |
| protos::Trace trace; |
| ASSERT_TRUE(trace.ParseFromString(trace_str)); |
| EXPECT_EQ(static_cast<int>(kPreamblePackets + kMessageCount), |
| trace.packet_size()); |
| for (const auto& packet : trace.packet()) { |
| if (packet.data_case() == protos::TracePacket::kTraceConfig) { |
| // Ensure the trace config properly includes the trigger mode we set. |
| EXPECT_EQ(protos::TraceConfig::TriggerConfig::START_TRACING, |
| packet.trace_config().trigger_config().trigger_mode()); |
| } else if (packet.data_case() == protos::TracePacket::kTrigger) { |
| // validate that the triggers are properly added to the trace. |
| EXPECT_EQ("trigger_name", packet.trigger().trigger_name()); |
| } else if (packet.data_case() == protos::TracePacket::kForTesting) { |
| // Make sure that the data size is correctly set based on what we |
| // requested. |
| EXPECT_EQ(kMessageSize, packet.for_testing().str().size()); |
| } |
| } |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(StopTracingTrigger)) { |
| // See |message_count| and |message_size| in the TraceConfig above. |
| constexpr size_t kMessageCount = 11; |
| constexpr size_t kMessageSize = 32; |
| protos::TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(1024); |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.perfetto.FakeProducer"); |
| ds_config->mutable_for_testing()->set_message_count(kMessageCount); |
| ds_config->mutable_for_testing()->set_message_size(kMessageSize); |
| auto* trigger_cfg = trace_config.mutable_trigger_config(); |
| trigger_cfg->set_trigger_mode( |
| protos::TraceConfig::TriggerConfig::STOP_TRACING); |
| trigger_cfg->set_trigger_timeout_ms(15000); |
| auto* trigger = trigger_cfg->add_triggers(); |
| trigger->set_name("trigger_name"); |
| // |stop_delay_ms| must be long enough that we can write the packets in |
| // before the trace finishes. This has to be long enough for the slowest |
| // emulator. But as short as possible to prevent the test running a long |
| // time. |
| trigger->set_stop_delay_ms(500); |
| trigger = trigger_cfg->add_triggers(); |
| trigger->set_name("trigger_name_3"); |
| trigger->set_stop_delay_ms(60000); |
| |
| // We have 6 normal preamble packets (start clock, trace config, clock, |
| // system info, sync marker, stats) and then since this is a trace with a |
| // trigger config we have an additional ReceivedTriggers packet. |
| constexpr size_t kPreamblePackets = 8; |
| |
| // We have to construct all the processes we want to fork before we start the |
| // service with |StartServiceIfRequired()|. this is because it is unsafe |
| // (could deadlock) to fork after we've spawned some threads which might |
| // printf (and thus hold locks). |
| const std::string path = RandomTraceFileName(); |
| auto perfetto_proc = ExecPerfetto( |
| { |
| "-o", |
| path, |
| "-c", |
| "-", |
| }, |
| trace_config.SerializeAsString()); |
| |
| auto trigger_proc = |
| ExecTrigger({"trigger_name_2", "trigger_name", "trigger_name_3"}); |
| |
| // Start the service and connect a simple fake producer. |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| auto* fake_producer = ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| |
| // Start a background thread that will deliver the config now that we've |
| // started the service. See |perfetto_proc| above for the args passed. |
| std::thread background_trace([&perfetto_proc]() { |
| std::string stderr_str; |
| EXPECT_EQ(0, perfetto_proc.Run(&stderr_str)) << stderr_str; |
| }); |
| |
| WaitForProducerEnabled(); |
| // Wait for the producer to start, and then write out 11 packets, before the |
| // trace actually starts (the trigger is seen). |
| auto on_data_written = task_runner_.CreateCheckpoint("data_written_1"); |
| fake_producer->ProduceEventBatch(WrapTask(on_data_written)); |
| task_runner_.RunUntilCheckpoint("data_written_1"); |
| |
| EXPECT_EQ(0, trigger_proc.Run(&stderr_)) << "stderr: " << stderr_; |
| |
| background_trace.join(); |
| |
| std::string trace_str; |
| base::ReadFile(path, &trace_str); |
| protos::Trace trace; |
| ASSERT_TRUE(trace.ParseFromString(trace_str)); |
| EXPECT_EQ(static_cast<int>(kPreamblePackets + kMessageCount), |
| trace.packet_size()); |
| bool seen_first_trigger = false; |
| for (const auto& packet : trace.packet()) { |
| if (packet.data_case() == protos::TracePacket::kTraceConfig) { |
| // Ensure the trace config properly includes the trigger mode we set. |
| EXPECT_EQ(protos::TraceConfig::TriggerConfig::STOP_TRACING, |
| packet.trace_config().trigger_config().trigger_mode()); |
| } else if (packet.data_case() == protos::TracePacket::kTrigger) { |
| // validate that the triggers are properly added to the trace. |
| if (!seen_first_trigger) { |
| EXPECT_EQ("trigger_name", packet.trigger().trigger_name()); |
| seen_first_trigger = true; |
| } else { |
| EXPECT_EQ("trigger_name_3", packet.trigger().trigger_name()); |
| } |
| } else if (packet.data_case() == protos::TracePacket::kForTesting) { |
| // Make sure that the data size is correctly set based on what we |
| // requested. |
| EXPECT_EQ(kMessageSize, packet.for_testing().str().size()); |
| } |
| } |
| } |
| |
| // Dropbox on the commandline client only works on android builds. So disable |
| // this test on all other builds. |
| #if PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(NoDataNoFileWithoutTrigger)) { |
| #else |
| TEST_F(PerfettoCmdlineTest, DISABLED_NoDataNoFileWithoutTrigger) { |
| #endif |
| // See |message_count| and |message_size| in the TraceConfig above. |
| constexpr size_t kMessageCount = 11; |
| constexpr size_t kMessageSize = 32; |
| protos::TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(1024); |
| trace_config.set_allow_user_build_tracing(true); |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.perfetto.FakeProducer"); |
| ds_config->mutable_for_testing()->set_message_count(kMessageCount); |
| ds_config->mutable_for_testing()->set_message_size(kMessageSize); |
| auto* trigger_cfg = trace_config.mutable_trigger_config(); |
| trigger_cfg->set_trigger_mode( |
| protos::TraceConfig::TriggerConfig::STOP_TRACING); |
| trigger_cfg->set_trigger_timeout_ms(1000); |
| auto* trigger = trigger_cfg->add_triggers(); |
| trigger->set_name("trigger_name"); |
| // |stop_delay_ms| must be long enough that we can write the packets in |
| // before the trace finishes. This has to be long enough for the slowest |
| // emulator. But as short as possible to prevent the test running a long |
| // time. |
| trigger->set_stop_delay_ms(500); |
| trigger = trigger_cfg->add_triggers(); |
| |
| // We have to construct all the processes we want to fork before we start the |
| // service with |StartServiceIfRequired()|. this is because it is unsafe |
| // (could deadlock) to fork after we've spawned some threads which might |
| // printf (and thus hold locks). |
| const std::string path = RandomTraceFileName(); |
| auto perfetto_proc = ExecPerfetto( |
| { |
| "--dropbox", |
| "TAG", |
| "--no-guardrails", |
| "-c", |
| "-", |
| }, |
| trace_config.SerializeAsString()); |
| |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| auto* fake_producer = ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| |
| std::string stderr_str; |
| std::thread background_trace([&perfetto_proc, &stderr_str]() { |
| EXPECT_EQ(0, perfetto_proc.Run(&stderr_str)); |
| }); |
| background_trace.join(); |
| |
| EXPECT_THAT(stderr_str, |
| ::testing::HasSubstr("Skipping write to dropbox. Empty trace.")); |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(StopTracingTriggerFromConfig)) { |
| // See |message_count| and |message_size| in the TraceConfig above. |
| constexpr size_t kMessageCount = 11; |
| constexpr size_t kMessageSize = 32; |
| protos::TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(1024); |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.perfetto.FakeProducer"); |
| ds_config->mutable_for_testing()->set_message_count(kMessageCount); |
| ds_config->mutable_for_testing()->set_message_size(kMessageSize); |
| auto* trigger_cfg = trace_config.mutable_trigger_config(); |
| trigger_cfg->set_trigger_mode( |
| protos::TraceConfig::TriggerConfig::STOP_TRACING); |
| trigger_cfg->set_trigger_timeout_ms(15000); |
| auto* trigger = trigger_cfg->add_triggers(); |
| trigger->set_name("trigger_name"); |
| // |stop_delay_ms| must be long enough that we can write the packets in |
| // before the trace finishes. This has to be long enough for the slowest |
| // emulator. But as short as possible to prevent the test running a long |
| // time. |
| trigger->set_stop_delay_ms(500); |
| trigger = trigger_cfg->add_triggers(); |
| trigger->set_name("trigger_name_3"); |
| trigger->set_stop_delay_ms(60000); |
| |
| // We have to construct all the processes we want to fork before we start the |
| // service with |StartServiceIfRequired()|. this is because it is unsafe |
| // (could deadlock) to fork after we've spawned some threads which might |
| // printf (and thus hold locks). |
| const std::string path = RandomTraceFileName(); |
| auto perfetto_proc = ExecPerfetto( |
| { |
| "-o", |
| path, |
| "-c", |
| "-", |
| }, |
| trace_config.SerializeAsString()); |
| |
| std::string triggers = R"( |
| activate_triggers: "trigger_name_2" |
| activate_triggers: "trigger_name" |
| activate_triggers: "trigger_name_3" |
| )"; |
| auto perfetto_proc_2 = ExecPerfetto( |
| { |
| "-o", |
| path, |
| "-c", |
| "-", |
| "--txt", |
| }, |
| triggers); |
| |
| // Start the service and connect a simple fake producer. |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| auto* fake_producer = ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| |
| std::thread background_trace([&perfetto_proc]() { |
| std::string stderr_str; |
| EXPECT_EQ(0, perfetto_proc.Run(&stderr_str)) << stderr_str; |
| }); |
| |
| WaitForProducerEnabled(); |
| // Wait for the producer to start, and then write out 11 packets, before the |
| // trace actually starts (the trigger is seen). |
| auto on_data_written = task_runner_.CreateCheckpoint("data_written_1"); |
| fake_producer->ProduceEventBatch(WrapTask(on_data_written)); |
| task_runner_.RunUntilCheckpoint("data_written_1"); |
| |
| EXPECT_EQ(0, perfetto_proc_2.Run(&stderr_)) << "stderr: " << stderr_; |
| |
| background_trace.join(); |
| |
| std::string trace_str; |
| base::ReadFile(path, &trace_str); |
| protos::Trace trace; |
| ASSERT_TRUE(trace.ParseFromString(trace_str)); |
| EXPECT_LT(static_cast<int>(kMessageCount), trace.packet_size()); |
| bool seen_first_trigger = false; |
| for (const auto& packet : trace.packet()) { |
| if (packet.data_case() == protos::TracePacket::kTraceConfig) { |
| // Ensure the trace config properly includes the trigger mode we set. |
| EXPECT_EQ(protos::TraceConfig::TriggerConfig::STOP_TRACING, |
| packet.trace_config().trigger_config().trigger_mode()); |
| } else if (packet.data_case() == protos::TracePacket::kTrigger) { |
| // validate that the triggers are properly added to the trace. |
| if (!seen_first_trigger) { |
| EXPECT_EQ("trigger_name", packet.trigger().trigger_name()); |
| seen_first_trigger = true; |
| } else { |
| EXPECT_EQ("trigger_name_3", packet.trigger().trigger_name()); |
| } |
| } else if (packet.data_case() == protos::TracePacket::kForTesting) { |
| // Make sure that the data size is correctly set based on what we |
| // requested. |
| EXPECT_EQ(kMessageSize, packet.for_testing().str().size()); |
| } |
| } |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(TriggerFromConfigStopsFileOpening)) { |
| // See |message_count| and |message_size| in the TraceConfig above. |
| constexpr size_t kMessageCount = 11; |
| constexpr size_t kMessageSize = 32; |
| protos::TraceConfig trace_config; |
| trace_config.add_buffers()->set_size_kb(1024); |
| auto* ds_config = trace_config.add_data_sources()->mutable_config(); |
| ds_config->set_name("android.perfetto.FakeProducer"); |
| ds_config->mutable_for_testing()->set_message_count(kMessageCount); |
| ds_config->mutable_for_testing()->set_message_size(kMessageSize); |
| auto* trigger_cfg = trace_config.mutable_trigger_config(); |
| trigger_cfg->set_trigger_mode( |
| protos::TraceConfig::TriggerConfig::STOP_TRACING); |
| trigger_cfg->set_trigger_timeout_ms(15000); |
| auto* trigger = trigger_cfg->add_triggers(); |
| trigger->set_name("trigger_name"); |
| // |stop_delay_ms| must be long enough that we can write the packets in |
| // before the trace finishes. This has to be long enough for the slowest |
| // emulator. But as short as possible to prevent the test running a long |
| // time. |
| trigger->set_stop_delay_ms(500); |
| trigger = trigger_cfg->add_triggers(); |
| trigger->set_name("trigger_name_3"); |
| trigger->set_stop_delay_ms(60000); |
| |
| // We have to construct all the processes we want to fork before we start the |
| // service with |StartServiceIfRequired()|. this is because it is unsafe |
| // (could deadlock) to fork after we've spawned some threads which might |
| // printf (and thus hold locks). |
| const std::string path = RandomTraceFileName(); |
| std::string triggers = R"( |
| activate_triggers: "trigger_name_2" |
| activate_triggers: "trigger_name" |
| activate_triggers: "trigger_name_3" |
| )"; |
| auto perfetto_proc = ExecPerfetto( |
| { |
| "-o", |
| path, |
| "-c", |
| "-", |
| "--txt", |
| }, |
| triggers); |
| |
| // Start the service and connect a simple fake producer. |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| auto* fake_producer = ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| |
| std::string trace_str; |
| EXPECT_FALSE(base::ReadFile(path, &trace_str)); |
| |
| EXPECT_EQ(0, perfetto_proc.Run(&stderr_)) << "stderr: " << stderr_; |
| |
| EXPECT_FALSE(base::ReadFile(path, &trace_str)); |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(Query)) { |
| auto query = ExecPerfetto({"--query"}); |
| auto query_raw = ExecPerfetto({"--query-raw"}); |
| StartServiceIfRequiredNoNewExecsAfterThis(); |
| EXPECT_EQ(0, query.Run(&stderr_)) << stderr_; |
| EXPECT_EQ(0, query_raw.Run(&stderr_)) << stderr_; |
| } |
| |
| } // namespace perfetto |