blob: c9a5ca1cea5222e67c4b77100ff2da58a420a3d4 [file] [log] [blame]
/*
* Copyright (C) 2017 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 "src/traced/probes/ftrace/ftrace_controller.h"
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "perfetto/ext/base/file_utils.h"
#include "src/traced/probes/ftrace/compact_sched.h"
#include "src/traced/probes/ftrace/cpu_reader.h"
#include "src/traced/probes/ftrace/ftrace_config_muxer.h"
#include "src/traced/probes/ftrace/ftrace_config_utils.h"
#include "src/traced/probes/ftrace/ftrace_data_source.h"
#include "src/traced/probes/ftrace/ftrace_procfs.h"
#include "src/traced/probes/ftrace/proto_translation_table.h"
#include "src/tracing/core/trace_writer_for_testing.h"
#include "test/gtest_and_gmock.h"
#include "protos/perfetto/trace/ftrace/ftrace_stats.gen.h"
#include "protos/perfetto/trace/ftrace/ftrace_stats.pbzero.h"
#include "protos/perfetto/trace/trace_packet.gen.h"
#include "protos/perfetto/trace/trace_packet.pbzero.h"
using testing::_;
using testing::AnyNumber;
using testing::ByMove;
using testing::ElementsAre;
using testing::Invoke;
using testing::IsEmpty;
using testing::MatchesRegex;
using testing::Mock;
using testing::NiceMock;
using testing::Pair;
using testing::Return;
using testing::UnorderedElementsAre;
using Table = perfetto::ProtoTranslationTable;
namespace perfetto {
namespace {
constexpr char kFooEnablePath[] = "/root/events/group/foo/enable";
constexpr char kBarEnablePath[] = "/root/events/group/bar/enable";
std::string PageSizeKb() {
return std::to_string(base::GetSysPageSize() / 1024);
}
class MockTaskRunner : public base::TaskRunner {
public:
MOCK_METHOD(void, PostTask, (std::function<void()>), (override));
MOCK_METHOD(void,
PostDelayedTask,
(std::function<void()>, uint32_t delay_ms),
(override));
MOCK_METHOD(void,
AddFileDescriptorWatch,
(int fd, std::function<void()>),
(override));
MOCK_METHOD(void, RemoveFileDescriptorWatch, (int fd), (override));
MOCK_METHOD(bool, RunsTasksOnCurrentThread, (), (const, override));
};
std::unique_ptr<Table> FakeTable(FtraceProcfs* ftrace) {
std::vector<Field> common_fields;
std::vector<Event> events;
{
events.push_back(Event{});
auto& event = events.back();
event.name = "foo";
event.group = "group";
event.ftrace_event_id = 1;
}
{
events.push_back(Event{});
auto& event = events.back();
event.name = "bar";
event.group = "group";
event.ftrace_event_id = 10;
}
return std::unique_ptr<Table>(
new Table(ftrace, events, std::move(common_fields),
ProtoTranslationTable::DefaultPageHeaderSpecForTesting(),
InvalidCompactSchedEventFormatForTesting(), PrintkMap()));
}
std::unique_ptr<FtraceConfigMuxer> FakeMuxer(FtraceProcfs* ftrace,
ProtoTranslationTable* table) {
return std::unique_ptr<FtraceConfigMuxer>(
new FtraceConfigMuxer(ftrace, table, SyscallTable(kUnknown), {}));
}
class MockFtraceProcfs : public FtraceProcfs {
public:
explicit MockFtraceProcfs(const std::string& root, size_t cpu_count = 1)
: FtraceProcfs(root) {
ON_CALL(*this, NumberOfCpus()).WillByDefault(Return(cpu_count));
EXPECT_CALL(*this, NumberOfCpus()).Times(AnyNumber());
ON_CALL(*this, ReadFileIntoString(root + "trace_clock"))
.WillByDefault(Return("local global [boot]"));
EXPECT_CALL(*this, ReadFileIntoString(root + "trace_clock"))
.Times(AnyNumber());
ON_CALL(*this, ReadFileIntoString(root + "per_cpu/cpu0/stats"))
.WillByDefault(Return(""));
EXPECT_CALL(*this, ReadFileIntoString(root + "per_cpu/cpu0/stats"))
.Times(AnyNumber());
ON_CALL(*this, ReadFileIntoString(root + "events//not_an_event/format"))
.WillByDefault(Return(""));
EXPECT_CALL(*this, ReadFileIntoString(root + "events//not_an_event/format"))
.Times(AnyNumber());
ON_CALL(*this, ReadFileIntoString(root + "events/group/bar/format"))
.WillByDefault(Return(""));
EXPECT_CALL(*this, ReadFileIntoString(root + "events/group/bar/format"))
.Times(AnyNumber());
ON_CALL(*this, WriteToFile(_, _)).WillByDefault(Return(true));
ON_CALL(*this, ClearFile(_)).WillByDefault(Return(true));
ON_CALL(*this, WriteToFile(root + "tracing_on", _))
.WillByDefault(Invoke(this, &MockFtraceProcfs::WriteTracingOn));
ON_CALL(*this, ReadOneCharFromFile(root + "tracing_on"))
.WillByDefault(Invoke(this, &MockFtraceProcfs::ReadTracingOn));
EXPECT_CALL(*this, ReadOneCharFromFile(root + "tracing_on"))
.Times(AnyNumber());
ON_CALL(*this, WriteToFile(root + "current_tracer", _))
.WillByDefault(Invoke(this, &MockFtraceProcfs::WriteCurrentTracer));
ON_CALL(*this, ReadFileIntoString(root + "current_tracer"))
.WillByDefault(Invoke(this, &MockFtraceProcfs::ReadCurrentTracer));
EXPECT_CALL(*this, ReadFileIntoString(root + "current_tracer"))
.Times(AnyNumber());
}
bool WriteTracingOn(const std::string& /*path*/, const std::string& value) {
PERFETTO_CHECK(value == "1" || value == "0");
tracing_on_ = value == "1";
return true;
}
char ReadTracingOn(const std::string& /*path*/) {
return tracing_on_ ? '1' : '0';
}
bool WriteCurrentTracer(const std::string& /*path*/,
const std::string& value) {
current_tracer_ = value;
return true;
}
std::string ReadCurrentTracer(const std::string& /*path*/) {
return current_tracer_;
}
base::ScopedFile OpenPipeForCpu(size_t /*cpu*/) override {
return base::ScopedFile(base::OpenFile("/dev/null", O_RDONLY));
}
MOCK_METHOD(bool,
WriteToFile,
(const std::string& path, const std::string& str),
(override));
MOCK_METHOD(size_t, NumberOfCpus, (), (const, override));
MOCK_METHOD(char, ReadOneCharFromFile, (const std::string& path), (override));
MOCK_METHOD(bool, ClearFile, (const std::string& path), (override));
MOCK_METHOD(bool, IsFileWriteable, (const std::string& path), (override));
MOCK_METHOD(std::string,
ReadFileIntoString,
(const std::string& path),
(const, override));
bool is_tracing_on() { return tracing_on_; }
private:
bool tracing_on_ = true;
std::string current_tracer_ = "nop";
};
} // namespace
class TestFtraceController : public FtraceController,
public FtraceController::Observer {
public:
TestFtraceController(std::unique_ptr<MockFtraceProcfs> ftrace_procfs,
std::unique_ptr<Table> table,
std::unique_ptr<FtraceConfigMuxer> muxer,
std::unique_ptr<MockTaskRunner> runner,
MockFtraceProcfs* raw_procfs)
: FtraceController(std::move(ftrace_procfs),
std::move(table),
std::move(muxer),
runner.get(),
/*observer=*/this),
runner_(std::move(runner)),
primary_procfs_(raw_procfs) {}
MockTaskRunner* runner() { return runner_.get(); }
MockFtraceProcfs* procfs() { return primary_procfs_; }
uint32_t drain_period_ms() { return GetDrainPeriodMs(); }
std::unique_ptr<FtraceDataSource> AddFakeDataSource(const FtraceConfig& cfg) {
std::unique_ptr<FtraceDataSource> data_source(new FtraceDataSource(
GetWeakPtr(), 0 /* session id */, cfg, nullptr /* trace_writer */));
if (!AddDataSource(data_source.get()))
return nullptr;
return data_source;
}
uint64_t NowMs() const override { return 0; }
void OnFtraceDataWrittenIntoDataSourceBuffers() override {}
bool InstanceExists(const std::string& instance_name) {
auto* instance = GetInstance(instance_name);
return instance != nullptr;
}
void PrepareMockProcfsForInstance(const std::string& name,
std::unique_ptr<MockFtraceProcfs> fs) {
pending_instance_procfs_[name] = std::move(fs);
}
MockFtraceProcfs* GetInstanceMockProcfs(const std::string& instance_name) {
auto* instance = GetInstance(instance_name);
PERFETTO_CHECK(instance);
return reinterpret_cast<MockFtraceProcfs*>(instance->ftrace_procfs.get());
}
std::unique_ptr<FtraceInstanceState> CreateSecondaryInstance(
const std::string& instance_name) override {
auto ftrace_procfs = std::move(pending_instance_procfs_[instance_name]);
PERFETTO_CHECK(ftrace_procfs);
auto table = FakeTable(ftrace_procfs.get());
auto muxer = FakeMuxer(ftrace_procfs.get(), table.get());
return std::unique_ptr<FtraceController::FtraceInstanceState>(
new FtraceController::FtraceInstanceState(
std::move(ftrace_procfs), std::move(table), std::move(muxer)));
}
private:
TestFtraceController(const TestFtraceController&) = delete;
TestFtraceController& operator=(const TestFtraceController&) = delete;
std::unique_ptr<MockTaskRunner> runner_;
MockFtraceProcfs* primary_procfs_;
std::map<std::string, std::unique_ptr<MockFtraceProcfs>>
pending_instance_procfs_;
};
namespace {
std::unique_ptr<TestFtraceController> CreateTestController(
bool procfs_is_nice_mock,
size_t cpu_count = 1) {
std::unique_ptr<MockTaskRunner> runner =
std::unique_ptr<MockTaskRunner>(new NiceMock<MockTaskRunner>());
std::unique_ptr<MockFtraceProcfs> ftrace_procfs;
if (procfs_is_nice_mock) {
ftrace_procfs = std::unique_ptr<MockFtraceProcfs>(
new NiceMock<MockFtraceProcfs>("/root/", cpu_count));
} else {
ftrace_procfs = std::unique_ptr<MockFtraceProcfs>(
new MockFtraceProcfs("/root/", cpu_count));
}
auto table = FakeTable(ftrace_procfs.get());
auto muxer = FakeMuxer(ftrace_procfs.get(), table.get());
MockFtraceProcfs* raw_procfs = ftrace_procfs.get();
return std::unique_ptr<TestFtraceController>(new TestFtraceController(
std::move(ftrace_procfs), std::move(table), std::move(muxer),
std::move(runner), raw_procfs));
}
} // namespace
TEST(FtraceControllerTest, NonExistentEventsDontCrash) {
auto controller = CreateTestController(true /* nice procfs */);
FtraceConfig config = CreateFtraceConfig({"not_an_event"});
EXPECT_TRUE(controller->AddFakeDataSource(config));
}
TEST(FtraceControllerTest, RejectsBadEventNames) {
auto controller = CreateTestController(true /* nice procfs */);
FtraceConfig config = CreateFtraceConfig({"../try/to/escape"});
EXPECT_FALSE(controller->AddFakeDataSource(config));
config = CreateFtraceConfig({"/event"});
EXPECT_FALSE(controller->AddFakeDataSource(config));
config = CreateFtraceConfig({"event/"});
EXPECT_FALSE(controller->AddFakeDataSource(config));
}
TEST(FtraceControllerTest, OneSink) {
auto controller = CreateTestController(false /* nice procfs */);
// No read tasks posted as part of adding the data source.
EXPECT_CALL(*controller->runner(), PostDelayedTask(_, _)).Times(0);
FtraceConfig config = CreateFtraceConfig({"group/foo"});
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "0"));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/events/enable", "0"));
EXPECT_CALL(*controller->procfs(), ClearFile("/root/trace"))
.WillOnce(Return(true));
EXPECT_CALL(*controller->procfs(),
ClearFile(MatchesRegex("/root/per_cpu/cpu[0-9]/trace")))
.WillRepeatedly(Return(true));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/buffer_size_kb", _));
EXPECT_CALL(*controller->procfs(), WriteToFile(kFooEnablePath, "1"));
auto data_source = controller->AddFakeDataSource(config);
ASSERT_TRUE(data_source);
// Verify that no read tasks have been posted. And set up expectation that
// a single recurring read task will be posted as part of starting the data
// source.
Mock::VerifyAndClearExpectations(controller->runner());
EXPECT_CALL(*controller->runner(), PostDelayedTask(_, _)).Times(1);
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "1"));
ASSERT_TRUE(controller->StartDataSource(data_source.get()));
// Verify single posted read task.
Mock::VerifyAndClearExpectations(controller->runner());
// State clearing on tracing teardown.
EXPECT_CALL(*controller->procfs(), WriteToFile(kFooEnablePath, "0"));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "0"));
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/buffer_size_kb", PageSizeKb()));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/events/enable", "0"));
EXPECT_CALL(*controller->procfs(), ClearFile("/root/trace"))
.WillOnce(Return(true));
EXPECT_CALL(*controller->procfs(),
ClearFile(MatchesRegex("/root/per_cpu/cpu[0-9]/trace")))
.WillRepeatedly(Return(true));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "1"));
data_source.reset();
EXPECT_TRUE(controller->procfs()->is_tracing_on());
}
TEST(FtraceControllerTest, MultipleSinks) {
auto controller = CreateTestController(false /* nice procfs */);
FtraceConfig configA = CreateFtraceConfig({"group/foo"});
FtraceConfig configB = CreateFtraceConfig({"group/foo", "group/bar"});
// No read tasks posted as part of adding the data sources.
EXPECT_CALL(*controller->runner(), PostDelayedTask(_, _)).Times(0);
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "0"));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/events/enable", "0"));
EXPECT_CALL(*controller->procfs(), ClearFile("/root/trace"))
.WillOnce(Return(true));
EXPECT_CALL(*controller->procfs(),
ClearFile(MatchesRegex("/root/per_cpu/cpu[0-9]/trace")))
.WillRepeatedly(Return(true));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/buffer_size_kb", _));
EXPECT_CALL(*controller->procfs(), WriteToFile(kFooEnablePath, "1"));
auto data_sourceA = controller->AddFakeDataSource(configA);
EXPECT_CALL(*controller->procfs(), WriteToFile(kBarEnablePath, "1"));
auto data_sourceB = controller->AddFakeDataSource(configB);
// Verify that no read tasks have been posted. And set up expectation that
// a single recurring read task will be posted as part of starting the data
// sources.
Mock::VerifyAndClearExpectations(controller->runner());
EXPECT_CALL(*controller->runner(), PostDelayedTask(_, _)).Times(1);
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "1"));
ASSERT_TRUE(controller->StartDataSource(data_sourceA.get()));
ASSERT_TRUE(controller->StartDataSource(data_sourceB.get()));
// Verify single posted read task.
Mock::VerifyAndClearExpectations(controller->runner());
data_sourceA.reset();
EXPECT_TRUE(controller->procfs()->is_tracing_on());
// State clearing on tracing teardown.
EXPECT_CALL(*controller->procfs(), WriteToFile(kFooEnablePath, "0"));
EXPECT_CALL(*controller->procfs(), WriteToFile(kBarEnablePath, "0"));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "0"));
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/buffer_size_kb", PageSizeKb()));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/events/enable", "0"));
EXPECT_CALL(*controller->procfs(), ClearFile("/root/trace"))
.WillOnce(Return(true));
EXPECT_CALL(*controller->procfs(),
ClearFile(MatchesRegex("/root/per_cpu/cpu[0-9]/trace")))
.WillRepeatedly(Return(true));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "1"));
data_sourceB.reset();
EXPECT_TRUE(controller->procfs()->is_tracing_on());
}
TEST(FtraceControllerTest, ControllerMayDieFirst) {
auto controller = CreateTestController(false /* nice procfs */);
FtraceConfig config = CreateFtraceConfig({"group/foo"});
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "0"));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/events/enable", "0"));
EXPECT_CALL(*controller->procfs(), ClearFile("/root/trace"))
.WillOnce(Return(true));
EXPECT_CALL(*controller->procfs(),
ClearFile(MatchesRegex("/root/per_cpu/cpu[0-9]/trace")))
.WillRepeatedly(Return(true));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/buffer_size_kb", _));
EXPECT_CALL(*controller->procfs(), WriteToFile(kFooEnablePath, "1"));
auto data_source = controller->AddFakeDataSource(config);
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "1"));
ASSERT_TRUE(controller->StartDataSource(data_source.get()));
// State clearing on tracing teardown.
EXPECT_CALL(*controller->procfs(), WriteToFile(kFooEnablePath, "0"));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "0"));
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/buffer_size_kb", PageSizeKb()));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/events/enable", "0"));
EXPECT_CALL(*controller->procfs(), ClearFile("/root/trace"))
.WillOnce(Return(true));
EXPECT_CALL(*controller->procfs(),
ClearFile(MatchesRegex("/root/per_cpu/cpu[0-9]/trace")))
.WillRepeatedly(Return(true));
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "1"));
controller.reset();
data_source.reset();
}
TEST(FtraceControllerTest, BufferSize) {
auto controller = CreateTestController(false /* nice procfs */);
// For this test we don't care about most calls to WriteToFile/ClearFile.
EXPECT_CALL(*controller->procfs(), WriteToFile(_, _)).Times(AnyNumber());
EXPECT_CALL(*controller->procfs(), ClearFile(_)).Times(AnyNumber());
// Every time a fake data source is destroyed, the controller will reset the
// buffer size to a single page.
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/buffer_size_kb", PageSizeKb()))
.Times(AnyNumber());
{
// No buffer size -> good default.
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/buffer_size_kb", "2048"));
FtraceConfig config = CreateFtraceConfig({"group/foo"});
auto data_source = controller->AddFakeDataSource(config);
ASSERT_TRUE(controller->StartDataSource(data_source.get()));
}
{
// Way too big buffer size -> max size.
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/buffer_size_kb", "65536"));
FtraceConfig config = CreateFtraceConfig({"group/foo"});
config.set_buffer_size_kb(10 * 1024 * 1024);
auto data_source = controller->AddFakeDataSource(config);
ASSERT_TRUE(controller->StartDataSource(data_source.get()));
}
{
// The limit is 64mb, 65mb is too much.
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/buffer_size_kb", "65536"));
FtraceConfig config = CreateFtraceConfig({"group/foo"});
ON_CALL(*controller->procfs(), NumberOfCpus()).WillByDefault(Return(2));
config.set_buffer_size_kb(65 * 1024);
auto data_source = controller->AddFakeDataSource(config);
ASSERT_TRUE(controller->StartDataSource(data_source.get()));
}
{
// Your size ends up with less than 1 page per cpu -> 1 page (gmock already
// covered by the cleanup expectation above).
FtraceConfig config = CreateFtraceConfig({"group/foo"});
config.set_buffer_size_kb(1);
auto data_source = controller->AddFakeDataSource(config);
ASSERT_TRUE(controller->StartDataSource(data_source.get()));
}
{
// You picked a good size -> your size rounded to nearest page.
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/buffer_size_kb", "64"));
FtraceConfig config = CreateFtraceConfig({"group/foo"});
config.set_buffer_size_kb(65);
auto data_source = controller->AddFakeDataSource(config);
ASSERT_TRUE(controller->StartDataSource(data_source.get()));
}
{
// You picked a good size -> your size rounded to nearest page.
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/buffer_size_kb", "64"));
FtraceConfig config = CreateFtraceConfig({"group/foo"});
ON_CALL(*controller->procfs(), NumberOfCpus()).WillByDefault(Return(2));
config.set_buffer_size_kb(65);
auto data_source = controller->AddFakeDataSource(config);
ASSERT_TRUE(controller->StartDataSource(data_source.get()));
}
}
TEST(FtraceControllerTest, PeriodicDrainConfig) {
auto controller = CreateTestController(false /* nice procfs */);
// For this test we don't care about calls to WriteToFile/ClearFile.
EXPECT_CALL(*controller->procfs(), WriteToFile(_, _)).Times(AnyNumber());
EXPECT_CALL(*controller->procfs(), ClearFile(_)).Times(AnyNumber());
{
// No period -> good default.
FtraceConfig config = CreateFtraceConfig({"group/foo"});
auto data_source = controller->AddFakeDataSource(config);
EXPECT_EQ(100u, controller->drain_period_ms());
}
{
// Pick a tiny value -> good default.
FtraceConfig config = CreateFtraceConfig({"group/foo"});
config.set_drain_period_ms(0);
auto data_source = controller->AddFakeDataSource(config);
EXPECT_EQ(100u, controller->drain_period_ms());
}
{
// Pick a huge value -> good default.
FtraceConfig config = CreateFtraceConfig({"group/foo"});
config.set_drain_period_ms(1000 * 60 * 60);
auto data_source = controller->AddFakeDataSource(config);
EXPECT_EQ(100u, controller->drain_period_ms());
}
{
// Pick a resonable value -> get that value.
FtraceConfig config = CreateFtraceConfig({"group/foo"});
config.set_drain_period_ms(200);
auto data_source = controller->AddFakeDataSource(config);
EXPECT_EQ(200u, controller->drain_period_ms());
}
}
TEST(FtraceMetadataTest, Clear) {
FtraceMetadata metadata;
metadata.inode_and_device.insert(std::make_pair(1, 1));
metadata.pids.insert(2);
metadata.last_seen_device_id = 100;
metadata.Clear();
EXPECT_THAT(metadata.inode_and_device, IsEmpty());
EXPECT_THAT(metadata.pids, IsEmpty());
EXPECT_EQ(BlockDeviceID(0), metadata.last_seen_device_id);
}
TEST(FtraceMetadataTest, AddDevice) {
FtraceMetadata metadata;
metadata.AddDevice(1);
EXPECT_EQ(BlockDeviceID(1), metadata.last_seen_device_id);
metadata.AddDevice(3);
EXPECT_EQ(BlockDeviceID(3), metadata.last_seen_device_id);
}
TEST(FtraceMetadataTest, AddInode) {
FtraceMetadata metadata;
metadata.AddCommonPid(getpid() + 1);
metadata.AddDevice(3);
metadata.AddInode(2);
metadata.AddInode(1);
metadata.AddCommonPid(getpid() + 1);
metadata.AddDevice(4);
metadata.AddInode(3);
// Check activity from ourselves is excluded.
metadata.AddCommonPid(getpid());
metadata.AddDevice(5);
metadata.AddInode(5);
EXPECT_THAT(metadata.inode_and_device,
UnorderedElementsAre(Pair(2, 3), Pair(1, 3), Pair(3, 4)));
}
TEST(FtraceMetadataTest, AddPid) {
FtraceMetadata metadata;
metadata.AddPid(1);
metadata.AddPid(2);
metadata.AddPid(2);
metadata.AddPid(3);
EXPECT_THAT(metadata.pids, ElementsAre(1, 2, 3));
}
TEST(FtraceStatsTest, Write) {
FtraceStats stats{};
FtraceCpuStats cpu_stats{};
cpu_stats.cpu = 0;
cpu_stats.entries = 1;
cpu_stats.overrun = 2;
stats.cpu_stats.push_back(cpu_stats);
std::unique_ptr<TraceWriterForTesting> writer =
std::unique_ptr<TraceWriterForTesting>(new TraceWriterForTesting());
{
auto packet = writer->NewTracePacket();
auto* out = packet->set_ftrace_stats();
stats.Write(out);
}
protos::gen::TracePacket result_packet = writer->GetOnlyTracePacket();
auto result = result_packet.ftrace_stats().cpu_stats()[0];
EXPECT_EQ(result.cpu(), 0u);
EXPECT_EQ(result.entries(), 1u);
EXPECT_EQ(result.overrun(), 2u);
}
TEST(FtraceControllerTest, OnlySecondaryInstance) {
auto controller = CreateTestController(true /* nice procfs */);
FtraceConfig config = CreateFtraceConfig({"group/foo"});
config.set_instance_name("secondary");
// Primary instance won't be touched throughout the entire test.
EXPECT_CALL(*controller->procfs(), WriteToFile(_, _)).Times(0);
EXPECT_CALL(*controller->procfs(), ClearFile(_)).Times(0);
// AddDataSource will initialise the tracefs instance, enable the event
// through the muxer, but not yet enable tracing_on.
auto secondary_procfs = std::unique_ptr<MockFtraceProcfs>(
new NiceMock<MockFtraceProcfs>("/root/instances/secondary/", 1));
EXPECT_CALL(*secondary_procfs, WriteToFile(_, _)).Times(AnyNumber());
EXPECT_CALL(*secondary_procfs,
WriteToFile("/root/instances/secondary/tracing_on", "0"));
EXPECT_CALL(
*secondary_procfs,
WriteToFile("/root/instances/secondary/events/group/foo/enable", "1"));
controller->PrepareMockProcfsForInstance("secondary",
std::move(secondary_procfs));
// No read tasks posted as part of adding the data source.
EXPECT_CALL(*controller->runner(), PostDelayedTask(_, _)).Times(0);
std::unique_ptr<FtraceDataSource> data_source =
controller->AddFakeDataSource(config);
ASSERT_NE(nullptr, data_source);
Mock::VerifyAndClearExpectations(
controller->GetInstanceMockProcfs("secondary"));
Mock::VerifyAndClearExpectations(controller->runner());
// StartDataSource will simply enable the event and post a ReadTick.
EXPECT_CALL(*controller->GetInstanceMockProcfs("secondary"),
WriteToFile("/root/instances/secondary/tracing_on", "1"));
EXPECT_CALL(*controller->runner(), PostDelayedTask(_, _)).Times(1);
ASSERT_TRUE(controller->StartDataSource(data_source.get()));
Mock::VerifyAndClearExpectations(
controller->GetInstanceMockProcfs("secondary"));
Mock::VerifyAndClearExpectations(controller->runner());
// RemoveDataSource will reset the tracefs instance.
EXPECT_CALL(*controller->GetInstanceMockProcfs("secondary"),
WriteToFile(_, _))
.Times(AnyNumber());
EXPECT_CALL(
*controller->GetInstanceMockProcfs("secondary"),
WriteToFile("/root/instances/secondary/events/group/foo/enable", "0"));
EXPECT_CALL(
*controller->GetInstanceMockProcfs("secondary"),
WriteToFile("/root/instances/secondary/buffer_size_kb", PageSizeKb()));
controller->RemoveDataSource(data_source.get());
// Controller forgot about the instance.
EXPECT_FALSE(controller->InstanceExists("secondary"));
}
TEST(FtraceControllerTest, DefaultAndSecondaryInstance) {
auto controller = CreateTestController(true /* nice procfs */);
FtraceConfig primary_cfg = CreateFtraceConfig({"group/foo"});
FtraceConfig secondary_cfg = CreateFtraceConfig({"group/bar"});
secondary_cfg.set_instance_name("secondary");
// AddDataSource will initialise the tracefs instances, enable the events
// through the muxers, but not yet enable tracing_on.
EXPECT_CALL(*controller->procfs(), WriteToFile(_, _)).Times(AnyNumber());
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "0"));
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/events/group/foo/enable", "1"));
auto secondary_procfs = std::unique_ptr<MockFtraceProcfs>(
new NiceMock<MockFtraceProcfs>("/root/instances/secondary/", 1));
EXPECT_CALL(*secondary_procfs, WriteToFile(_, _)).Times(AnyNumber());
EXPECT_CALL(*secondary_procfs,
WriteToFile("/root/instances/secondary/tracing_on", "0"));
EXPECT_CALL(
*secondary_procfs,
WriteToFile("/root/instances/secondary/events/group/bar/enable", "1"));
controller->PrepareMockProcfsForInstance("secondary",
std::move(secondary_procfs));
// No read tasks posted as part of adding the data sources.
EXPECT_CALL(*controller->runner(), PostDelayedTask(_, _)).Times(0);
std::unique_ptr<FtraceDataSource> primary_ds =
controller->AddFakeDataSource(primary_cfg);
std::unique_ptr<FtraceDataSource> secondary_ds =
controller->AddFakeDataSource(secondary_cfg);
ASSERT_NE(nullptr, primary_ds);
ASSERT_NE(nullptr, secondary_ds);
ASSERT_NE(primary_ds->config_id(), secondary_ds->config_id());
Mock::VerifyAndClearExpectations(controller->procfs());
Mock::VerifyAndClearExpectations(
controller->GetInstanceMockProcfs("secondary"));
Mock::VerifyAndClearExpectations(controller->runner());
// StartDataSource will simply enable the events and post two ReadTicks (one
// per instance having the first data source activated), with the first tick
// becoming obsolete.
EXPECT_CALL(*controller->procfs(), WriteToFile("/root/tracing_on", "1"));
EXPECT_CALL(*controller->GetInstanceMockProcfs("secondary"),
WriteToFile("/root/instances/secondary/tracing_on", "1"));
EXPECT_CALL(*controller->runner(), PostDelayedTask(_, _)).Times(2);
ASSERT_TRUE(controller->StartDataSource(primary_ds.get()));
ASSERT_TRUE(controller->StartDataSource(secondary_ds.get()));
Mock::VerifyAndClearExpectations(controller->procfs());
Mock::VerifyAndClearExpectations(
controller->GetInstanceMockProcfs("secondary"));
Mock::VerifyAndClearExpectations(controller->runner());
// RemoveDataSource will reset the tracefs instances.
EXPECT_CALL(*controller->procfs(), WriteToFile(_, _)).Times(AnyNumber());
EXPECT_CALL(*controller->procfs(),
WriteToFile("/root/events/group/foo/enable", "0"));
EXPECT_CALL(*controller->GetInstanceMockProcfs("secondary"),
WriteToFile(_, _))
.Times(AnyNumber());
EXPECT_CALL(
*controller->GetInstanceMockProcfs("secondary"),
WriteToFile("/root/instances/secondary/events/group/bar/enable", "0"));
controller->RemoveDataSource(primary_ds.get());
controller->RemoveDataSource(secondary_ds.get());
// Controller forgot about the secondary instance.
EXPECT_FALSE(controller->InstanceExists("secondary"));
}
TEST(FtraceControllerTest, TracefsInstanceFilepaths) {
std::optional<std::string> path;
path = FtraceController::AbsolutePathForInstance("/root/", "test");
EXPECT_EQ(*path, "/root/instances/test/");
// named directory should stay under instances/
path = FtraceController::AbsolutePathForInstance("/root/", "test/test");
EXPECT_FALSE(path.has_value());
path = FtraceController::AbsolutePathForInstance("/root/", "..");
EXPECT_FALSE(path.has_value());
// special-cased pkvm path
path = FtraceController::AbsolutePathForInstance("/root/", "hyp");
EXPECT_EQ(*path, "/root/hyp/");
}
} // namespace perfetto