blob: f8a0eff5ae51b4dcaee02b535a825b604c4769bb [file] [log] [blame]
/*
* 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 "src/traced/probes/ftrace/ftrace_config_muxer.h"
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <cstdint>
#include <algorithm>
#include <iterator>
#include <limits>
#include "perfetto/base/compiler.h"
#include "perfetto/ext/base/utils.h"
#include "src/traced/probes/ftrace/atrace_wrapper.h"
#include "src/traced/probes/ftrace/compact_sched.h"
#include "src/traced/probes/ftrace/ftrace_config_utils.h"
#include "src/traced/probes/ftrace/ftrace_stats.h"
#include "protos/perfetto/trace/ftrace/ftrace_event.pbzero.h"
namespace perfetto {
namespace {
constexpr uint64_t kDefaultLowRamPerCpuBufferSizeKb = 2 * (1ULL << 10); // 2mb
constexpr uint64_t kDefaultHighRamPerCpuBufferSizeKb = 8 * (1ULL << 10); // 8mb
constexpr uint64_t kMaxPerCpuBufferSizeKb = 64 * (1ULL << 10); // 64mb
// Threshold for physical ram size used when deciding on default kernel buffer
// sizes. We want to detect 8 GB, but the size reported through sysconf is
// usually lower.
constexpr uint64_t kHighMemBytes = 7 * (1ULL << 30); // 7gb
// A fake "syscall id" that indicates all syscalls should be recorded. This
// allows us to distinguish between the case where `syscall_events` is empty
// because raw_syscalls aren't enabled, or the case where it is and we want to
// record all events.
constexpr size_t kAllSyscallsId = kMaxSyscalls + 1;
// trace_clocks in preference order.
// If this list is changed, the FtraceClocks enum in ftrace_event_bundle.proto
// and FtraceConfigMuxer::SetupClock() should be also changed accordingly.
constexpr const char* kClocks[] = {"boot", "global", "local"};
// optional monotonic raw clock.
// Enabled by the "use_monotonic_raw_clock" option in the ftrace config.
constexpr const char* kClockMonoRaw = "mono_raw";
void AddEventGroup(const ProtoTranslationTable* table,
const std::string& group,
std::set<GroupAndName>* to) {
const std::vector<const Event*>* events = table->GetEventsByGroup(group);
if (!events)
return;
for (const Event* event : *events)
to->insert(GroupAndName(group, event->name));
}
std::set<GroupAndName> ReadEventsInGroupFromFs(
const FtraceProcfs& ftrace_procfs,
const std::string& group) {
std::set<std::string> names =
ftrace_procfs.GetEventNamesForGroup("events/" + group);
std::set<GroupAndName> events;
for (const auto& name : names)
events.insert(GroupAndName(group, name));
return events;
}
std::pair<std::string, std::string> EventToStringGroupAndName(
const std::string& event) {
auto slash_pos = event.find('/');
if (slash_pos == std::string::npos)
return std::make_pair("", event);
return std::make_pair(event.substr(0, slash_pos),
event.substr(slash_pos + 1));
}
void UnionInPlace(const std::vector<std::string>& unsorted_a,
std::vector<std::string>* out) {
std::vector<std::string> a = unsorted_a;
std::sort(a.begin(), a.end());
std::sort(out->begin(), out->end());
std::vector<std::string> v;
std::set_union(a.begin(), a.end(), out->begin(), out->end(),
std::back_inserter(v));
*out = std::move(v);
}
void IntersectInPlace(const std::vector<std::string>& unsorted_a,
std::vector<std::string>* out) {
std::vector<std::string> a = unsorted_a;
std::sort(a.begin(), a.end());
std::sort(out->begin(), out->end());
std::vector<std::string> v;
std::set_intersection(a.begin(), a.end(), out->begin(), out->end(),
std::back_inserter(v));
*out = std::move(v);
}
// This is just to reduce binary size and stack frame size of the insertions.
// It effectively undoes STL's set::insert inlining.
void PERFETTO_NO_INLINE InsertEvent(const char* group,
const char* name,
std::set<GroupAndName>* dst) {
dst->insert(GroupAndName(group, name));
}
} // namespace
std::set<GroupAndName> FtraceConfigMuxer::GetFtraceEvents(
const FtraceConfig& request,
const ProtoTranslationTable* table) {
std::set<GroupAndName> events;
for (const auto& config_value : request.ftrace_events()) {
std::string group;
std::string name;
std::tie(group, name) = EventToStringGroupAndName(config_value);
if (name == "*") {
for (const auto& event : ReadEventsInGroupFromFs(*ftrace_, group))
events.insert(event);
} else if (group.empty()) {
// If there is no group specified, find an event with that name and
// use it's group.
const Event* e = table->GetEventByName(name);
if (!e) {
PERFETTO_DLOG(
"Event doesn't exist: %s. Include the group in the config to allow "
"the event to be output as a generic event.",
name.c_str());
continue;
}
events.insert(GroupAndName(e->group, e->name));
} else {
events.insert(GroupAndName(group, name));
}
}
if (RequiresAtrace(request)) {
InsertEvent("ftrace", "print", &events);
// Ideally we should keep this code in sync with:
// platform/frameworks/native/cmds/atrace/atrace.cpp
// It's not a disaster if they go out of sync, we can always add the ftrace
// categories manually server side but this is user friendly and reduces the
// size of the configs.
for (const std::string& category : request.atrace_categories()) {
if (category == "gfx") {
AddEventGroup(table, "mdss", &events);
InsertEvent("mdss", "rotator_bw_ao_as_context", &events);
InsertEvent("mdss", "mdp_trace_counter", &events);
InsertEvent("mdss", "tracing_mark_write", &events);
InsertEvent("mdss", "mdp_cmd_wait_pingpong", &events);
InsertEvent("mdss", "mdp_cmd_kickoff", &events);
InsertEvent("mdss", "mdp_cmd_release_bw", &events);
InsertEvent("mdss", "mdp_cmd_readptr_done", &events);
InsertEvent("mdss", "mdp_cmd_pingpong_done", &events);
InsertEvent("mdss", "mdp_misr_crc", &events);
InsertEvent("mdss", "mdp_compare_bw", &events);
InsertEvent("mdss", "mdp_perf_update_bus", &events);
InsertEvent("mdss", "mdp_video_underrun_done", &events);
InsertEvent("mdss", "mdp_commit", &events);
InsertEvent("mdss", "mdp_mixer_update", &events);
InsertEvent("mdss", "mdp_perf_prefill_calc", &events);
InsertEvent("mdss", "mdp_perf_set_ot", &events);
InsertEvent("mdss", "mdp_perf_set_wm_levels", &events);
InsertEvent("mdss", "mdp_perf_set_panic_luts", &events);
InsertEvent("mdss", "mdp_perf_set_qos_luts", &events);
InsertEvent("mdss", "mdp_sspp_change", &events);
InsertEvent("mdss", "mdp_sspp_set", &events);
AddEventGroup(table, "mali", &events);
InsertEvent("mali", "tracing_mark_write", &events);
AddEventGroup(table, "sde", &events);
InsertEvent("sde", "tracing_mark_write", &events);
InsertEvent("sde", "sde_perf_update_bus", &events);
InsertEvent("sde", "sde_perf_set_qos_luts", &events);
InsertEvent("sde", "sde_perf_set_ot", &events);
InsertEvent("sde", "sde_perf_set_danger_luts", &events);
InsertEvent("sde", "sde_perf_crtc_update", &events);
InsertEvent("sde", "sde_perf_calc_crtc", &events);
InsertEvent("sde", "sde_evtlog", &events);
InsertEvent("sde", "sde_encoder_underrun", &events);
InsertEvent("sde", "sde_cmd_release_bw", &events);
AddEventGroup(table, "dpu", &events);
InsertEvent("dpu", "tracing_mark_write", &events);
AddEventGroup(table, "g2d", &events);
InsertEvent("g2d", "tracing_mark_write", &events);
InsertEvent("g2d", "g2d_perf_update_qos", &events);
AddEventGroup(table, "panel", &events);
InsertEvent("panel", "panel_write_generic", &events);
continue;
}
if (category == "ion") {
InsertEvent("kmem", "ion_alloc_buffer_start", &events);
continue;
}
// Note: sched_wakeup intentionally removed (diverging from atrace), as it
// is high-volume, but mostly redundant when sched_waking is also enabled.
// The event can still be enabled explicitly when necessary.
if (category == "sched") {
InsertEvent("sched", "sched_switch", &events);
InsertEvent("sched", "sched_waking", &events);
InsertEvent("sched", "sched_blocked_reason", &events);
InsertEvent("sched", "sched_cpu_hotplug", &events);
InsertEvent("sched", "sched_pi_setprio", &events);
InsertEvent("sched", "sched_process_exit", &events);
AddEventGroup(table, "cgroup", &events);
InsertEvent("cgroup", "cgroup_transfer_tasks", &events);
InsertEvent("cgroup", "cgroup_setup_root", &events);
InsertEvent("cgroup", "cgroup_rmdir", &events);
InsertEvent("cgroup", "cgroup_rename", &events);
InsertEvent("cgroup", "cgroup_remount", &events);
InsertEvent("cgroup", "cgroup_release", &events);
InsertEvent("cgroup", "cgroup_mkdir", &events);
InsertEvent("cgroup", "cgroup_destroy_root", &events);
InsertEvent("cgroup", "cgroup_attach_task", &events);
InsertEvent("oom", "oom_score_adj_update", &events);
InsertEvent("task", "task_rename", &events);
InsertEvent("task", "task_newtask", &events);
AddEventGroup(table, "systrace", &events);
InsertEvent("systrace", "0", &events);
AddEventGroup(table, "scm", &events);
InsertEvent("scm", "scm_call_start", &events);
InsertEvent("scm", "scm_call_end", &events);
continue;
}
if (category == "irq") {
AddEventGroup(table, "irq", &events);
InsertEvent("irq", "tasklet_hi_exit", &events);
InsertEvent("irq", "tasklet_hi_entry", &events);
InsertEvent("irq", "tasklet_exit", &events);
InsertEvent("irq", "tasklet_entry", &events);
InsertEvent("irq", "softirq_raise", &events);
InsertEvent("irq", "softirq_exit", &events);
InsertEvent("irq", "softirq_entry", &events);
InsertEvent("irq", "irq_handler_exit", &events);
InsertEvent("irq", "irq_handler_entry", &events);
AddEventGroup(table, "ipi", &events);
InsertEvent("ipi", "ipi_raise", &events);
InsertEvent("ipi", "ipi_exit", &events);
InsertEvent("ipi", "ipi_entry", &events);
continue;
}
if (category == "irqoff") {
InsertEvent("preemptirq", "irq_enable", &events);
InsertEvent("preemptirq", "irq_disable", &events);
continue;
}
if (category == "preemptoff") {
InsertEvent("preemptirq", "preempt_enable", &events);
InsertEvent("preemptirq", "preempt_disable", &events);
continue;
}
if (category == "i2c") {
AddEventGroup(table, "i2c", &events);
InsertEvent("i2c", "i2c_read", &events);
InsertEvent("i2c", "i2c_write", &events);
InsertEvent("i2c", "i2c_result", &events);
InsertEvent("i2c", "i2c_reply", &events);
InsertEvent("i2c", "smbus_read", &events);
InsertEvent("i2c", "smbus_write", &events);
InsertEvent("i2c", "smbus_result", &events);
InsertEvent("i2c", "smbus_reply", &events);
continue;
}
if (category == "freq") {
InsertEvent("power", "cpu_frequency", &events);
InsertEvent("power", "gpu_frequency", &events);
InsertEvent("power", "clock_set_rate", &events);
InsertEvent("power", "clock_disable", &events);
InsertEvent("power", "clock_enable", &events);
InsertEvent("clk", "clk_set_rate", &events);
InsertEvent("clk", "clk_disable", &events);
InsertEvent("clk", "clk_enable", &events);
InsertEvent("power", "cpu_frequency_limits", &events);
InsertEvent("power", "suspend_resume", &events);
InsertEvent("cpuhp", "cpuhp_enter", &events);
InsertEvent("cpuhp", "cpuhp_exit", &events);
InsertEvent("cpuhp", "cpuhp_pause", &events);
AddEventGroup(table, "msm_bus", &events);
InsertEvent("msm_bus", "bus_update_request_end", &events);
InsertEvent("msm_bus", "bus_update_request", &events);
InsertEvent("msm_bus", "bus_rules_matches", &events);
InsertEvent("msm_bus", "bus_max_votes", &events);
InsertEvent("msm_bus", "bus_client_status", &events);
InsertEvent("msm_bus", "bus_bke_params", &events);
InsertEvent("msm_bus", "bus_bimc_config_limiter", &events);
InsertEvent("msm_bus", "bus_avail_bw", &events);
InsertEvent("msm_bus", "bus_agg_bw", &events);
continue;
}
if (category == "membus") {
AddEventGroup(table, "memory_bus", &events);
continue;
}
if (category == "idle") {
InsertEvent("power", "cpu_idle", &events);
continue;
}
if (category == "disk") {
InsertEvent("f2fs", "f2fs_sync_file_enter", &events);
InsertEvent("f2fs", "f2fs_sync_file_exit", &events);
InsertEvent("f2fs", "f2fs_write_begin", &events);
InsertEvent("f2fs", "f2fs_write_end", &events);
InsertEvent("f2fs", "f2fs_iostat", &events);
InsertEvent("f2fs", "f2fs_iostat_latency", &events);
InsertEvent("ext4", "ext4_da_write_begin", &events);
InsertEvent("ext4", "ext4_da_write_end", &events);
InsertEvent("ext4", "ext4_sync_file_enter", &events);
InsertEvent("ext4", "ext4_sync_file_exit", &events);
InsertEvent("block", "block_bio_queue", &events);
InsertEvent("block", "block_bio_complete", &events);
InsertEvent("ufs", "ufshcd_command", &events);
continue;
}
if (category == "mmc") {
AddEventGroup(table, "mmc", &events);
continue;
}
if (category == "load") {
AddEventGroup(table, "cpufreq_interactive", &events);
continue;
}
if (category == "sync") {
// linux kernel < 4.9
AddEventGroup(table, "sync", &events);
InsertEvent("sync", "sync_pt", &events);
InsertEvent("sync", "sync_timeline", &events);
InsertEvent("sync", "sync_wait", &events);
// linux kernel == 4.9.x
AddEventGroup(table, "fence", &events);
InsertEvent("fence", "fence_annotate_wait_on", &events);
InsertEvent("fence", "fence_destroy", &events);
InsertEvent("fence", "fence_emit", &events);
InsertEvent("fence", "fence_enable_signal", &events);
InsertEvent("fence", "fence_init", &events);
InsertEvent("fence", "fence_signaled", &events);
InsertEvent("fence", "fence_wait_end", &events);
InsertEvent("fence", "fence_wait_start", &events);
// linux kernel > 4.9
AddEventGroup(table, "dma_fence", &events);
continue;
}
if (category == "workq") {
AddEventGroup(table, "workqueue", &events);
InsertEvent("workqueue", "workqueue_queue_work", &events);
InsertEvent("workqueue", "workqueue_execute_start", &events);
InsertEvent("workqueue", "workqueue_execute_end", &events);
InsertEvent("workqueue", "workqueue_activate_work", &events);
continue;
}
if (category == "memreclaim") {
InsertEvent("vmscan", "mm_vmscan_direct_reclaim_begin", &events);
InsertEvent("vmscan", "mm_vmscan_direct_reclaim_end", &events);
InsertEvent("vmscan", "mm_vmscan_kswapd_wake", &events);
InsertEvent("vmscan", "mm_vmscan_kswapd_sleep", &events);
AddEventGroup(table, "lowmemorykiller", &events);
InsertEvent("lowmemorykiller", "lowmemory_kill", &events);
continue;
}
if (category == "regulators") {
AddEventGroup(table, "regulator", &events);
events.insert(
GroupAndName("regulator", "regulator_set_voltage_complete"));
InsertEvent("regulator", "regulator_set_voltage", &events);
InsertEvent("regulator", "regulator_enable_delay", &events);
InsertEvent("regulator", "regulator_enable_complete", &events);
InsertEvent("regulator", "regulator_enable", &events);
InsertEvent("regulator", "regulator_disable_complete", &events);
InsertEvent("regulator", "regulator_disable", &events);
continue;
}
if (category == "binder_driver") {
InsertEvent("binder", "binder_transaction", &events);
InsertEvent("binder", "binder_transaction_received", &events);
InsertEvent("binder", "binder_transaction_alloc_buf", &events);
InsertEvent("binder", "binder_set_priority", &events);
continue;
}
if (category == "binder_lock") {
InsertEvent("binder", "binder_lock", &events);
InsertEvent("binder", "binder_locked", &events);
InsertEvent("binder", "binder_unlock", &events);
continue;
}
if (category == "pagecache") {
AddEventGroup(table, "filemap", &events);
events.insert(
GroupAndName("filemap", "mm_filemap_delete_from_page_cache"));
InsertEvent("filemap", "mm_filemap_add_to_page_cache", &events);
InsertEvent("filemap", "filemap_set_wb_err", &events);
InsertEvent("filemap", "file_check_and_advance_wb_err", &events);
continue;
}
if (category == "memory") {
// Use rss_stat_throttled if supported
if (ftrace_->SupportsRssStatThrottled()) {
InsertEvent("synthetic", "rss_stat_throttled", &events);
} else {
InsertEvent("kmem", "rss_stat", &events);
}
InsertEvent("kmem", "ion_heap_grow", &events);
InsertEvent("kmem", "ion_heap_shrink", &events);
// ion_stat supersedes ion_heap_grow / shrink for kernel 4.19+
InsertEvent("ion", "ion_stat", &events);
InsertEvent("mm_event", "mm_event_record", &events);
InsertEvent("dmabuf_heap", "dma_heap_stat", &events);
InsertEvent("gpu_mem", "gpu_mem_total", &events);
continue;
}
if (category == "thermal") {
InsertEvent("thermal", "thermal_temperature", &events);
InsertEvent("thermal", "cdev_update", &events);
continue;
}
if (category == "camera") {
AddEventGroup(table, "lwis", &events);
InsertEvent("lwis", "tracing_mark_write", &events);
continue;
}
}
}
// recording a subset of syscalls -> enable the backing events
if (request.syscall_events_size() > 0) {
InsertEvent("raw_syscalls", "sys_enter", &events);
InsertEvent("raw_syscalls", "sys_exit", &events);
}
// function_graph tracer emits two builtin ftrace events
if (request.enable_function_graph()) {
InsertEvent("ftrace", "funcgraph_entry", &events);
InsertEvent("ftrace", "funcgraph_exit", &events);
}
// If throttle_rss_stat: true, use the rss_stat_throttled event if supported
if (request.throttle_rss_stat() && ftrace_->SupportsRssStatThrottled()) {
auto it = std::find_if(
events.begin(), events.end(), [](const GroupAndName& event) {
return event.group() == "kmem" && event.name() == "rss_stat";
});
if (it != events.end()) {
events.erase(it);
InsertEvent("synthetic", "rss_stat_throttled", &events);
}
}
return events;
}
base::FlatSet<int64_t> FtraceConfigMuxer::GetSyscallsReturningFds(
const SyscallTable& syscalls) {
auto insertSyscallId = [&syscalls](base::FlatSet<int64_t>& set,
const char* syscall) {
auto syscall_id = syscalls.GetByName(syscall);
if (syscall_id)
set.insert(static_cast<int64_t>(*syscall_id));
};
base::FlatSet<int64_t> call_ids;
insertSyscallId(call_ids, "sys_open");
insertSyscallId(call_ids, "sys_openat");
insertSyscallId(call_ids, "sys_socket");
insertSyscallId(call_ids, "sys_dup");
insertSyscallId(call_ids, "sys_dup2");
insertSyscallId(call_ids, "sys_dup3");
return call_ids;
}
bool FtraceConfigMuxer::FilterHasGroup(const EventFilter& filter,
const std::string& group) {
const std::vector<const Event*>* events = table_->GetEventsByGroup(group);
if (!events) {
return false;
}
for (const Event* event : *events) {
if (filter.IsEventEnabled(event->ftrace_event_id)) {
return true;
}
}
return false;
}
EventFilter FtraceConfigMuxer::BuildSyscallFilter(
const EventFilter& ftrace_filter,
const FtraceConfig& request) {
EventFilter output;
if (!FilterHasGroup(ftrace_filter, "raw_syscalls")) {
return output;
}
if (request.syscall_events().empty()) {
output.AddEnabledEvent(kAllSyscallsId);
return output;
}
for (const std::string& syscall : request.syscall_events()) {
std::optional<size_t> id = syscalls_.GetByName(syscall);
if (!id.has_value()) {
PERFETTO_ELOG("Can't enable %s, syscall not known", syscall.c_str());
continue;
}
output.AddEnabledEvent(*id);
}
return output;
}
bool FtraceConfigMuxer::SetSyscallEventFilter(
const EventFilter& extra_syscalls) {
EventFilter syscall_filter;
syscall_filter.EnableEventsFrom(extra_syscalls);
for (const auto& id_config : ds_configs_) {
const perfetto::FtraceDataSourceConfig& config = id_config.second;
syscall_filter.EnableEventsFrom(config.syscall_filter);
}
std::set<size_t> filter_set = syscall_filter.GetEnabledEvents();
if (syscall_filter.IsEventEnabled(kAllSyscallsId)) {
filter_set.clear();
}
if (current_state_.syscall_filter != filter_set) {
if (!ftrace_->SetSyscallFilter(filter_set)) {
return false;
}
current_state_.syscall_filter = filter_set;
}
return true;
}
FtraceConfigMuxer::FtraceConfigMuxer(
FtraceProcfs* ftrace,
AtraceWrapper* atrace_wrapper,
ProtoTranslationTable* table,
SyscallTable syscalls,
std::map<std::string, std::vector<GroupAndName>> vendor_events,
bool secondary_instance)
: ftrace_(ftrace),
atrace_wrapper_(atrace_wrapper),
table_(table),
syscalls_(std::move(syscalls)),
current_state_(),
ds_configs_(),
vendor_events_(std::move(vendor_events)),
secondary_instance_(secondary_instance) {}
FtraceConfigMuxer::~FtraceConfigMuxer() = default;
bool FtraceConfigMuxer::SetupConfig(FtraceConfigId id,
const FtraceConfig& request,
FtraceSetupErrors* errors) {
EventFilter filter;
if (ds_configs_.empty()) {
PERFETTO_DCHECK(active_configs_.empty());
// If someone outside of perfetto is using a non-nop tracer, yield. We can't
// realistically figure out all notions of "in use" even if we look at
// set_event or events/enable, so this is all we check for.
if (!request.preserve_ftrace_buffer() && !ftrace_->IsTracingAvailable()) {
PERFETTO_ELOG(
"ftrace in use by non-Perfetto. Check that %s current_tracer is nop.",
ftrace_->GetRootPath().c_str());
return false;
}
// Clear tracefs state, remembering which value of "tracing_on" to restore
// to after we're done, though we won't restore the rest of the tracefs
// state.
current_state_.saved_tracing_on = ftrace_->GetTracingOn();
if (!request.preserve_ftrace_buffer()) {
ftrace_->SetTracingOn(false);
// This will fail on release ("user") builds due to ACLs, but that's
// acceptable since the per-event enabling/disabling should still be
// balanced.
ftrace_->DisableAllEvents();
ftrace_->ClearTrace();
}
// Set up the rest of the tracefs state, without starting it.
// Notes:
// * resizing buffers can be quite slow (up to hundreds of ms).
// * resizing buffers may truncate existing contents if the new size is
// smaller, which matters to the preserve_ftrace_buffer option.
if (!request.preserve_ftrace_buffer()) {
SetupClock(request);
SetupBufferSize(request);
}
}
std::set<GroupAndName> events = GetFtraceEvents(request, table_);
// Vendors can provide a set of extra ftrace categories to be enabled when a
// specific atrace category is used (e.g. "gfx" -> ["my_hw/my_custom_event",
// "my_hw/my_special_gpu"]). Merge them with the hard coded events for each
// categories.
for (const std::string& category : request.atrace_categories()) {
if (vendor_events_.count(category)) {
for (const GroupAndName& event : vendor_events_[category]) {
events.insert(event);
}
}
}
if (RequiresAtrace(request)) {
if (secondary_instance_) {
PERFETTO_ELOG(
"Secondary ftrace instances do not support atrace_categories and "
"atrace_apps options as they affect global state");
return false;
}
if (!atrace_wrapper_->SupportsUserspaceOnly() && !ds_configs_.empty()) {
PERFETTO_ELOG(
"Concurrent atrace sessions are not supported before Android P, "
"bailing out.");
return false;
}
UpdateAtrace(request, errors ? &errors->atrace_errors : nullptr);
}
for (const auto& group_and_name : events) {
const Event* event = table_->GetOrCreateEvent(group_and_name);
if (!event) {
PERFETTO_DLOG("Can't enable %s, event not known",
group_and_name.ToString().c_str());
if (errors)
errors->unknown_ftrace_events.push_back(group_and_name.ToString());
continue;
}
// Niche option to skip events that are in the config, but don't have a
// dedicated proto for the event in perfetto. Otherwise such events will be
// encoded as GenericFtraceEvent.
if (request.disable_generic_events() &&
event->proto_field_id ==
protos::pbzero::FtraceEvent::kGenericFieldNumber) {
if (errors)
errors->failed_ftrace_events.push_back(group_and_name.ToString());
continue;
}
// Note: ftrace events are always implicitly enabled (and don't have an
// "enable" file). So they aren't tracked by the central event filter (but
// still need to be added to the per data source event filter to retain
// the events during parsing).
if (current_state_.ftrace_events.IsEventEnabled(event->ftrace_event_id) ||
std::string("ftrace") == event->group) {
filter.AddEnabledEvent(event->ftrace_event_id);
continue;
}
if (ftrace_->EnableEvent(event->group, event->name)) {
current_state_.ftrace_events.AddEnabledEvent(event->ftrace_event_id);
filter.AddEnabledEvent(event->ftrace_event_id);
} else {
PERFETTO_DPLOG("Failed to enable %s.", group_and_name.ToString().c_str());
if (errors)
errors->failed_ftrace_events.push_back(group_and_name.ToString());
}
}
EventFilter syscall_filter = BuildSyscallFilter(filter, request);
if (!SetSyscallEventFilter(syscall_filter)) {
PERFETTO_ELOG("Failed to set raw_syscall ftrace filter in SetupConfig");
return false;
}
// Kernel function tracing (function_graph).
// Note 1: there is no cleanup in |RemoveConfig| because tracers cannot be
// changed while tracing pipes are opened. So we'll keep the current_tracer
// until all data sources are gone, at which point ftrace_controller will
// make an explicit call to |ResetCurrentTracer|.
// Note 2: we don't track the set of filters ourselves and instead let the
// kernel statefully collate them, hence the use of |AppendFunctionFilters|.
// This is because each concurrent data source that wants funcgraph will get
// all of the enabled functions (we don't go as far as doing per-DS event
// steering in the parser), and we don't want to remove functions midway
// through a trace (but some might get added).
if (request.enable_function_graph()) {
if (!current_state_.funcgraph_on && !ftrace_->ClearFunctionFilters())
return false;
if (!current_state_.funcgraph_on && !ftrace_->ClearFunctionGraphFilters())
return false;
if (!ftrace_->AppendFunctionFilters(request.function_filters()))
return false;
if (!ftrace_->AppendFunctionGraphFilters(request.function_graph_roots()))
return false;
if (!current_state_.funcgraph_on &&
!ftrace_->SetCurrentTracer("function_graph")) {
PERFETTO_LOG(
"Unable to enable function_graph tracing since a concurrent ftrace "
"data source is using a different tracer");
return false;
}
current_state_.funcgraph_on = true;
}
const auto& compact_format = table_->compact_sched_format();
auto compact_sched = CreateCompactSchedConfig(
request, filter.IsEventEnabled(compact_format.sched_switch.event_id),
compact_format);
if (errors && !compact_format.format_valid) {
errors->failed_ftrace_events.emplace_back(
"perfetto/compact_sched (unexpected sched event format)");
}
std::optional<FtracePrintFilterConfig> ftrace_print_filter;
if (request.has_print_filter()) {
ftrace_print_filter =
FtracePrintFilterConfig::Create(request.print_filter(), table_);
if (!ftrace_print_filter.has_value()) {
if (errors) {
errors->failed_ftrace_events.emplace_back(
"ftrace/print (unexpected format for filtering)");
}
}
}
std::vector<std::string> apps(request.atrace_apps());
std::vector<std::string> categories(request.atrace_categories());
ds_configs_.emplace(
std::piecewise_construct, std::forward_as_tuple(id),
std::forward_as_tuple(
std::move(filter), std::move(syscall_filter), compact_sched,
std::move(ftrace_print_filter), std::move(apps),
std::move(categories), request.symbolize_ksyms(),
request.drain_buffer_percent(), GetSyscallsReturningFds(syscalls_)));
return true;
}
bool FtraceConfigMuxer::ActivateConfig(FtraceConfigId id) {
if (!id || ds_configs_.count(id) == 0) {
PERFETTO_DFATAL("Config not found");
return false;
}
bool first_config = active_configs_.empty();
active_configs_.insert(id);
// Pick the lowest buffer_percent across the new set of active configs.
if (!UpdateBufferPercent()) {
PERFETTO_ELOG(
"Invalid FtraceConfig.drain_buffer_percent or "
"/sys/kernel/tracing/buffer_percent file permissions.");
// carry on, non-critical error
}
// Enable kernel event writer.
if (first_config) {
if (!ftrace_->SetTracingOn(true)) {
PERFETTO_ELOG("Failed to enable ftrace.");
active_configs_.erase(id);
return false;
}
}
return true;
}
bool FtraceConfigMuxer::RemoveConfig(FtraceConfigId config_id) {
if (!config_id || !ds_configs_.erase(config_id))
return false;
EventFilter expected_ftrace_events;
std::vector<std::string> expected_apps;
std::vector<std::string> expected_categories;
for (const auto& id_config : ds_configs_) {
const perfetto::FtraceDataSourceConfig& config = id_config.second;
expected_ftrace_events.EnableEventsFrom(config.event_filter);
UnionInPlace(config.atrace_apps, &expected_apps);
UnionInPlace(config.atrace_categories, &expected_categories);
}
// At this point expected_{apps,categories} contains the union of the
// leftover configs (if any) that should be still on. However we did not
// necessarily succeed in turning on atrace for each of those configs
// previously so we now intersect the {apps,categories} that we *did* manage
// to turn on with those we want on to determine the new state we should aim
// for:
IntersectInPlace(current_state_.atrace_apps, &expected_apps);
IntersectInPlace(current_state_.atrace_categories, &expected_categories);
// Work out if there is any difference between the current state and the
// desired state: It's sufficient to compare sizes here (since we know from
// above that expected_{apps,categories} is now a subset of
// atrace_{apps,categories}:
bool atrace_changed =
(current_state_.atrace_apps.size() != expected_apps.size()) ||
(current_state_.atrace_categories.size() != expected_categories.size());
if (!SetSyscallEventFilter(/*extra_syscalls=*/{})) {
PERFETTO_ELOG("Failed to set raw_syscall ftrace filter in RemoveConfig");
}
// Disable any events that are currently enabled, but are not in any configs
// anymore.
std::set<size_t> event_ids = current_state_.ftrace_events.GetEnabledEvents();
for (size_t id : event_ids) {
if (expected_ftrace_events.IsEventEnabled(id))
continue;
const Event* event = table_->GetEventById(id);
// Any event that was enabled must exist.
PERFETTO_DCHECK(event);
if (ftrace_->DisableEvent(event->group, event->name))
current_state_.ftrace_events.DisableEvent(event->ftrace_event_id);
}
auto active_it = active_configs_.find(config_id);
if (active_it != active_configs_.end()) {
active_configs_.erase(active_it);
if (active_configs_.empty()) {
// This was the last active config for now, but potentially more dormant
// configs need to be activated. We are not interested in reading while no
// active configs so diasble tracing_on here.
ftrace_->SetTracingOn(false);
}
}
// Update buffer_percent to the minimum of the remaining configs.
UpdateBufferPercent();
// Even if we don't have any other active configs, we might still have idle
// configs around. Tear down the rest of the ftrace config only if all
// configs are removed.
if (ds_configs_.empty()) {
if (ftrace_->SetCpuBufferSizeInPages(1))
current_state_.cpu_buffer_size_pages = 1;
ftrace_->SetBufferPercent(50);
ftrace_->DisableAllEvents();
ftrace_->ClearTrace();
ftrace_->SetTracingOn(current_state_.saved_tracing_on);
}
if (current_state_.atrace_on) {
if (expected_apps.empty() && expected_categories.empty()) {
DisableAtrace();
} else if (atrace_changed) {
// Update atrace to remove the no longer wanted categories/apps. For
// some categories this won't disable them (e.g. categories that just
// enable ftrace events) for those there is nothing we can do till the
// last ftrace config is removed.
if (StartAtrace(expected_apps, expected_categories,
/*atrace_errors=*/nullptr)) {
// Update current_state_ to reflect this change.
current_state_.atrace_apps = expected_apps;
current_state_.atrace_categories = expected_categories;
}
}
}
return true;
}
bool FtraceConfigMuxer::ResetCurrentTracer() {
if (!current_state_.funcgraph_on)
return true;
if (!ftrace_->ResetCurrentTracer()) {
PERFETTO_PLOG("Failed to reset current_tracer to nop");
return false;
}
current_state_.funcgraph_on = false;
if (!ftrace_->ClearFunctionFilters()) {
PERFETTO_PLOG("Failed to reset set_ftrace_filter.");
return false;
}
if (!ftrace_->ClearFunctionGraphFilters()) {
PERFETTO_PLOG("Failed to reset set_function_graph.");
return false;
}
return true;
}
const FtraceDataSourceConfig* FtraceConfigMuxer::GetDataSourceConfig(
FtraceConfigId id) {
if (!ds_configs_.count(id))
return nullptr;
return &ds_configs_.at(id);
}
void FtraceConfigMuxer::SetupClock(const FtraceConfig& config) {
std::string current_clock = ftrace_->GetClock();
std::set<std::string> clocks = ftrace_->AvailableClocks();
if (config.has_use_monotonic_raw_clock() &&
config.use_monotonic_raw_clock() && clocks.count(kClockMonoRaw)) {
ftrace_->SetClock(kClockMonoRaw);
current_clock = kClockMonoRaw;
} else {
for (size_t i = 0; i < base::ArraySize(kClocks); i++) {
std::string clock = std::string(kClocks[i]);
if (!clocks.count(clock))
continue;
if (current_clock == clock)
break;
ftrace_->SetClock(clock);
current_clock = clock;
break;
}
}
namespace pb0 = protos::pbzero;
if (current_clock == "boot") {
// "boot" is the default expectation on modern kernels, which is why we
// don't have an explicit FTRACE_CLOCK_BOOT enum and leave it unset.
// See comments in ftrace_event_bundle.proto.
current_state_.ftrace_clock = pb0::FTRACE_CLOCK_UNSPECIFIED;
} else if (current_clock == "global") {
current_state_.ftrace_clock = pb0::FTRACE_CLOCK_GLOBAL;
} else if (current_clock == "local") {
current_state_.ftrace_clock = pb0::FTRACE_CLOCK_LOCAL;
} else if (current_clock == kClockMonoRaw) {
current_state_.ftrace_clock = pb0::FTRACE_CLOCK_MONO_RAW;
} else {
current_state_.ftrace_clock = pb0::FTRACE_CLOCK_UNKNOWN;
}
}
void FtraceConfigMuxer::SetupBufferSize(const FtraceConfig& request) {
int64_t phys_ram_pages = sysconf(_SC_PHYS_PAGES);
size_t pages = ComputeCpuBufferSizeInPages(request.buffer_size_kb(),
request.buffer_size_lower_bound(),
phys_ram_pages);
ftrace_->SetCpuBufferSizeInPages(pages);
current_state_.cpu_buffer_size_pages = pages;
}
// Post-conditions:
// 1. result >= 1 (should have at least one page per CPU)
// 2. result < kMaxTotalBufferSizeKb / (page_size / 1024)
// 3. If input is 0 output is a good default number
size_t ComputeCpuBufferSizeInPages(size_t requested_buffer_size_kb,
bool buffer_size_lower_bound,
int64_t sysconf_phys_pages) {
uint32_t page_sz = base::GetSysPageSize();
uint64_t default_size_kb =
(sysconf_phys_pages > 0 &&
(static_cast<uint64_t>(sysconf_phys_pages) >= (kHighMemBytes / page_sz)))
? kDefaultHighRamPerCpuBufferSizeKb
: kDefaultLowRamPerCpuBufferSizeKb;
size_t actual_size_kb = requested_buffer_size_kb;
if ((requested_buffer_size_kb == 0) ||
(buffer_size_lower_bound && default_size_kb > requested_buffer_size_kb)) {
actual_size_kb = default_size_kb;
}
if (actual_size_kb > kMaxPerCpuBufferSizeKb) {
PERFETTO_ELOG(
"The requested ftrace buf size (%zu KB) is too big, capping to %" PRIu64
" KB",
actual_size_kb, kMaxPerCpuBufferSizeKb);
actual_size_kb = kMaxPerCpuBufferSizeKb;
}
size_t pages = actual_size_kb / (page_sz / 1024);
return pages ? pages : 1;
}
size_t FtraceConfigMuxer::GetPerCpuBufferSizePages() {
return current_state_.cpu_buffer_size_pages;
}
// If new_cfg_id is set, consider it in addition to already active configs
// as we're trying to activate it.
bool FtraceConfigMuxer::UpdateBufferPercent() {
uint32_t kUnsetPercent = std::numeric_limits<uint32_t>::max();
uint32_t min_percent = kUnsetPercent;
for (auto cfg_id : active_configs_) {
auto ds_it = ds_configs_.find(cfg_id);
if (ds_it != ds_configs_.end() && ds_it->second.buffer_percent > 0) {
min_percent = std::min(min_percent, ds_it->second.buffer_percent);
}
}
if (min_percent == kUnsetPercent)
return true;
// Let the kernel ignore values >100.
return ftrace_->SetBufferPercent(min_percent);
}
void FtraceConfigMuxer::UpdateAtrace(const FtraceConfig& request,
std::string* atrace_errors) {
// We want to avoid poisoning current_state_.atrace_{categories, apps}
// if for some reason these args make atrace unhappy so we stash the
// union into temps and only update current_state_ if we successfully
// run atrace.
std::vector<std::string> combined_categories = request.atrace_categories();
UnionInPlace(current_state_.atrace_categories, &combined_categories);
std::vector<std::string> combined_apps = request.atrace_apps();
UnionInPlace(current_state_.atrace_apps, &combined_apps);
if (current_state_.atrace_on &&
combined_apps.size() == current_state_.atrace_apps.size() &&
combined_categories.size() == current_state_.atrace_categories.size()) {
return;
}
if (StartAtrace(combined_apps, combined_categories, atrace_errors)) {
current_state_.atrace_categories = combined_categories;
current_state_.atrace_apps = combined_apps;
current_state_.atrace_on = true;
}
}
bool FtraceConfigMuxer::StartAtrace(const std::vector<std::string>& apps,
const std::vector<std::string>& categories,
std::string* atrace_errors) {
PERFETTO_DLOG("Update atrace config...");
std::vector<std::string> args;
args.push_back("atrace"); // argv0 for exec()
args.push_back("--async_start");
if (atrace_wrapper_->SupportsUserspaceOnly())
args.push_back("--only_userspace");
for (const auto& category : categories)
args.push_back(category);
if (!apps.empty()) {
args.push_back("-a");
std::string arg = "";
for (const auto& app : apps) {
arg += app;
arg += ",";
}
arg.resize(arg.size() - 1);
args.push_back(arg);
}
bool result = atrace_wrapper_->RunAtrace(args, atrace_errors);
PERFETTO_DLOG("...done (%s)", result ? "success" : "fail");
return result;
}
void FtraceConfigMuxer::DisableAtrace() {
PERFETTO_DCHECK(current_state_.atrace_on);
PERFETTO_DLOG("Stop atrace...");
std::vector<std::string> args{"atrace", "--async_stop"};
if (atrace_wrapper_->SupportsUserspaceOnly())
args.push_back("--only_userspace");
if (atrace_wrapper_->RunAtrace(args, /*atrace_errors=*/nullptr)) {
current_state_.atrace_categories.clear();
current_state_.atrace_apps.clear();
current_state_.atrace_on = false;
}
PERFETTO_DLOG("...done");
}
} // namespace perfetto