| /* |
| * 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 <condition_variable> |
| #include <functional> |
| #include <initializer_list> |
| #include <random> |
| #include <thread> |
| |
| #include <gmock/gmock.h> |
| #include <gtest/gtest.h> |
| #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_config.h" |
| #include "perfetto/ext/tracing/core/trace_packet.h" |
| #include "perfetto/protozero/scattered_heap_buffer.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 "src/tracing/ipc/default_socket.h" |
| #include "test/task_runner_thread.h" |
| #include "test/task_runner_thread_delegates.h" |
| #include "test/test_helper.h" |
| |
| #include "perfetto/config/power/android_power_config.pbzero.h" |
| #include "perfetto/trace/trace.pb.h" |
| #include "perfetto/trace/trace_packet.pb.h" |
| #include "perfetto/trace/trace_packet.pbzero.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; |
| } |
| |
| 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 { test_helper_.StartServiceIfRequired(); } |
| |
| void TearDown() override {} |
| |
| int ExecPerfetto(std::initializer_list<std::string> args, |
| std::string input = "") { |
| return Exec("perfetto", args, input); |
| } |
| |
| int ExecTrigger(std::initializer_list<std::string> args, |
| std::string input = "") { |
| return Exec("trigger_perfetto", args, input); |
| } |
| |
| // Fork() + executes the perfetto cmdline client with the given args and |
| // returns the exit code. |
| int Exec(const std::string& argv0, |
| std::initializer_list<std::string> args, |
| std::string input = "") { |
| 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); |
| |
| // Create the pipe for the child process to return stderr. |
| base::Pipe err_pipe = base::Pipe::Create(); |
| base::Pipe in_pipe = base::Pipe::Create(); |
| |
| pid_t pid = fork(); |
| PERFETTO_CHECK(pid >= 0); |
| if (pid == 0) { |
| // Child process. |
| err_pipe.rd.reset(); |
| in_pipe.wr.reset(); |
| |
| 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") { |
| _exit(PerfettoCmdMain(static_cast<int>(argv.size() - 1), argv.data())); |
| } else if (argv0 == "trigger_perfetto") { |
| _exit(TriggerPerfettoMain(static_cast<int>(argv.size() - 1), |
| argv.data())); |
| } else { |
| ADD_FAILURE() << "Unknown binary: " << argv0.c_str(); |
| } |
| #else |
| execv((std::string("/system/bin/") + argv0).c_str(), &argv[0]); |
| _exit(3); |
| #endif |
| } |
| |
| // Parent. |
| err_pipe.wr.reset(); |
| stderr_ = std::string(1024 * 1024, '\0'); |
| |
| // 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. |
| 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(); |
| |
| ssize_t rsize = 0; |
| size_t stderr_pos = 0; |
| while (stderr_pos < stderr_.size()) { |
| rsize = PERFETTO_EINTR(read(*err_pipe.rd, &stderr_[stderr_pos], |
| stderr_.size() - stderr_pos - 1)); |
| if (rsize <= 0) |
| break; |
| stderr_pos += static_cast<size_t>(rsize); |
| } |
| stderr_.resize(stderr_pos); |
| 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; |
| } |
| |
| std::string stderr_; |
| base::TestTaskRunner task_runner_; |
| 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"); |
| |
| EXPECT_EQ(1, ExecPerfetto({"--invalid-arg"})); |
| |
| EXPECT_EQ(1, ExecPerfetto({"-c", "-", "-o", "-"}, "")); |
| 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, ExecPerfetto({"-c", "-", "--txt", "-o", "-", "--dropbox=foo"}, cfg)); |
| |
| EXPECT_EQ(1, ExecPerfetto({"-c", "-", "--txt"}, cfg)); |
| EXPECT_THAT(stderr_, HasSubstr("Either --out or --dropbox")); |
| |
| // Disallow mixing simple and file config. |
| EXPECT_EQ(1, ExecPerfetto({"-o", "-", "-c", "-", "-t", "2s"}, cfg)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify both -c")); |
| |
| EXPECT_EQ(1, ExecPerfetto({"-o", "-", "-c", "-", "-b", "2m"}, cfg)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify both -c")); |
| |
| EXPECT_EQ(1, ExecPerfetto({"-o", "-", "-c", "-", "-s", "2m"}, cfg)); |
| EXPECT_THAT(stderr_, HasSubstr("Cannot specify both -c")); |
| |
| // Invalid --attach / --detach cases. |
| EXPECT_EQ(1, ExecPerfetto({"-c", "-", "--txt", "-o", "-", "--stop"}, cfg)); |
| EXPECT_THAT(stderr_, HasSubstr("--stop is supported only in combination")); |
| |
| EXPECT_EQ(1, |
| ExecPerfetto({"-c", "-", "--txt", "-o", "-", "--attach=foo"}, cfg)); |
| EXPECT_THAT(stderr_, HasSubstr("trace config with --attach")); |
| |
| EXPECT_EQ(1, ExecPerfetto({"-t", "2s", "-o", "-", "--attach=foo"}, cfg)); |
| EXPECT_THAT(stderr_, HasSubstr("trace config with --attach")); |
| |
| EXPECT_EQ(1, ExecPerfetto({"--attach"}, cfg)); |
| EXPECT_THAT(stderr_, ContainsRegex("option.*--attach.*requires an argument")); |
| |
| EXPECT_EQ(1, ExecPerfetto({"-t", "2s", "-o", "-", "--detach"}, cfg)); |
| EXPECT_THAT(stderr_, ContainsRegex("option.*--detach.*requires an argument")); |
| |
| EXPECT_EQ(1, ExecPerfetto({"-t", "2s", "--detach=foo"}, cfg)); |
| EXPECT_THAT(stderr_, HasSubstr("--out or --dropbox is required")); |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(TxtConfig)) { |
| std::string cfg("duration_ms: 100"); |
| EXPECT_EQ(0, ExecPerfetto({"-c", "-", "--txt", "-o", "-"}, cfg)) << stderr_; |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(SimpleConfig)) { |
| EXPECT_EQ(0, ExecPerfetto({"-o", "-", "-c", "-", "-t", "100ms"})); |
| } |
| |
| TEST_F(PerfettoCmdlineTest, NoSanitizers(DetachAndAttach)) { |
| EXPECT_NE(0, ExecPerfetto({"--attach=not_existent"})); |
| EXPECT_THAT(stderr_, HasSubstr("Session re-attach failed")); |
| |
| std::string cfg("duration_ms: 10000; write_into_file: true"); |
| EXPECT_EQ(0, ExecPerfetto( |
| {"-o", "-", "-c", "-", "--txt", "--detach=valid_stop"}, cfg)) |
| << stderr_; |
| EXPECT_EQ(0, ExecPerfetto({"--attach=valid_stop", "--stop"})); |
| } |
| |
| 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; |
| |
| base::TestTaskRunner task_runner; |
| |
| // Enable tracing and detach as soon as it gets started. |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| auto* fake_producer = helper.ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| const std::string path = RandomTraceFileName(); |
| std::thread background_trace([&path, &trace_config, this]() { |
| EXPECT_EQ(0, ExecPerfetto( |
| { |
| "-o", path, "-c", "-", |
| }, |
| trace_config.SerializeAsString())); |
| }); |
| |
| helper.WaitForProducerSetup(); |
| EXPECT_EQ(0, ExecTrigger({"trigger_name"})) << "stderr: " << stderr_; |
| |
| // Wait for the producer to start, and then write out 11 packets. |
| helper.WaitForProducerEnabled(); |
| auto on_data_written = task_runner.CreateCheckpoint("data_written"); |
| fake_producer->ProduceEventBatch(helper.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(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; |
| |
| base::TestTaskRunner task_runner; |
| |
| // Enable tracing and detach as soon as it gets started. |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| auto* fake_producer = helper.ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| |
| const std::string path = RandomTraceFileName(); |
| std::thread background_trace([&path, &trace_config, this]() { |
| EXPECT_EQ(0, ExecPerfetto( |
| { |
| "-o", path, "-c", "-", |
| }, |
| trace_config.SerializeAsString())); |
| }); |
| |
| helper.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(helper.WrapTask(on_data_written)); |
| task_runner.RunUntilCheckpoint("data_written_1"); |
| |
| EXPECT_EQ(0, |
| ExecTrigger({"trigger_name_2", "trigger_name", "trigger_name_3"})) |
| << "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(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(); |
| |
| // Enable tracing and detach as soon as it gets started. |
| base::TestTaskRunner task_runner; |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| auto* fake_producer = helper.ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| |
| std::thread background_trace([&trace_config, this]() { |
| EXPECT_EQ(0, ExecPerfetto( |
| { |
| "--dropbox", "TAG", "--no-guardrails", "-c", "-", |
| }, |
| trace_config.SerializeAsString())); |
| }); |
| background_trace.join(); |
| |
| EXPECT_THAT(stderr_, |
| ::testing::HasSubstr("Skipping upload 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 5 normal preample packets (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. |
| base::TestTaskRunner task_runner; |
| |
| // Enable tracing and detach as soon as it gets started. |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| auto* fake_producer = helper.ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| |
| const std::string path = RandomTraceFileName(); |
| std::thread background_trace([&path, &trace_config, this]() { |
| EXPECT_EQ(0, ExecPerfetto( |
| { |
| "-o", path, "-c", "-", |
| }, |
| trace_config.SerializeAsString())); |
| }); |
| |
| helper.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(helper.WrapTask(on_data_written)); |
| task_runner.RunUntilCheckpoint("data_written_1"); |
| |
| std::string triggers = R"( |
| activate_triggers: "trigger_name_2" |
| activate_triggers: "trigger_name" |
| activate_triggers: "trigger_name_3" |
| )"; |
| |
| EXPECT_EQ(0, ExecPerfetto( |
| { |
| "-o", path, "-c", "-", "--txt", |
| }, |
| triggers)) |
| << "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(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 5 normal preample packets (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. |
| base::TestTaskRunner task_runner; |
| |
| // Enable tracing and detach as soon as it gets started. |
| TestHelper helper(&task_runner); |
| helper.StartServiceIfRequired(); |
| auto* fake_producer = helper.ConnectFakeProducer(); |
| EXPECT_TRUE(fake_producer); |
| |
| const std::string path = RandomTraceFileName(); |
| |
| std::string trace_str; |
| EXPECT_FALSE(base::ReadFile(path, &trace_str)); |
| |
| std::string triggers = R"( |
| activate_triggers: "trigger_name_2" |
| activate_triggers: "trigger_name" |
| activate_triggers: "trigger_name_3" |
| )"; |
| |
| EXPECT_EQ(0, ExecPerfetto( |
| { |
| "-o", path, "-c", "-", "--txt", |
| }, |
| triggers)) |
| << "stderr: " << stderr_; |
| |
| EXPECT_FALSE(base::ReadFile(path, &trace_str)); |
| } |
| |
| } // namespace perfetto |