| /* |
| * 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 <stdint.h> |
| #include <string.h> |
| #include <sys/types.h> |
| #include <unistd.h> |
| |
| #include <algorithm> |
| #include <iterator> |
| |
| #include "perfetto/ext/base/utils.h" |
| #include "protos/perfetto/trace/ftrace/sched.pbzero.h" |
| #include "src/traced/probes/ftrace/atrace_wrapper.h" |
| #include "src/traced/probes/ftrace/compact_sched.h" |
| |
| namespace perfetto { |
| namespace { |
| |
| constexpr int kDefaultPerCpuBufferSizeKb = 2 * 1024; // 2mb |
| constexpr int kMaxPerCpuBufferSizeKb = 64 * 1024; // 64mb |
| |
| // trace_clocks in preference order. |
| constexpr const char* kClocks[] = {"boot", "global", "local"}; |
| |
| 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); |
| } |
| |
| } // 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)) { |
| events.insert(GroupAndName("ftrace", "print")); |
| |
| // 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); |
| events.insert(GroupAndName("mdss", "rotator_bw_ao_as_context")); |
| events.insert(GroupAndName("mdss", "mdp_trace_counter")); |
| events.insert(GroupAndName("mdss", "tracing_mark_write")); |
| events.insert(GroupAndName("mdss", "mdp_cmd_wait_pingpong")); |
| events.insert(GroupAndName("mdss", "mdp_cmd_kickoff")); |
| events.insert(GroupAndName("mdss", "mdp_cmd_release_bw")); |
| events.insert(GroupAndName("mdss", "mdp_cmd_readptr_done")); |
| events.insert(GroupAndName("mdss", "mdp_cmd_pingpong_done")); |
| events.insert(GroupAndName("mdss", "mdp_misr_crc")); |
| events.insert(GroupAndName("mdss", "mdp_compare_bw")); |
| events.insert(GroupAndName("mdss", "mdp_perf_update_bus")); |
| events.insert(GroupAndName("mdss", "mdp_video_underrun_done")); |
| events.insert(GroupAndName("mdss", "mdp_commit")); |
| events.insert(GroupAndName("mdss", "mdp_mixer_update")); |
| events.insert(GroupAndName("mdss", "mdp_perf_prefill_calc")); |
| events.insert(GroupAndName("mdss", "mdp_perf_set_ot")); |
| events.insert(GroupAndName("mdss", "mdp_perf_set_wm_levels")); |
| events.insert(GroupAndName("mdss", "mdp_perf_set_panic_luts")); |
| events.insert(GroupAndName("mdss", "mdp_perf_set_qos_luts")); |
| events.insert(GroupAndName("mdss", "mdp_sspp_change")); |
| events.insert(GroupAndName("mdss", "mdp_sspp_set")); |
| AddEventGroup(table, "mali", &events); |
| events.insert(GroupAndName("mali", "tracing_mark_write")); |
| |
| AddEventGroup(table, "sde", &events); |
| events.insert(GroupAndName("sde", "tracing_mark_write")); |
| events.insert(GroupAndName("sde", "sde_perf_update_bus")); |
| events.insert(GroupAndName("sde", "sde_perf_set_qos_luts")); |
| events.insert(GroupAndName("sde", "sde_perf_set_ot")); |
| events.insert(GroupAndName("sde", "sde_perf_set_danger_luts")); |
| events.insert(GroupAndName("sde", "sde_perf_crtc_update")); |
| events.insert(GroupAndName("sde", "sde_perf_calc_crtc")); |
| events.insert(GroupAndName("sde", "sde_evtlog")); |
| events.insert(GroupAndName("sde", "sde_encoder_underrun")); |
| events.insert(GroupAndName("sde", "sde_cmd_release_bw")); |
| |
| AddEventGroup(table, "dpu", &events); |
| events.insert(GroupAndName("dpu", "tracing_mark_write")); |
| |
| AddEventGroup(table, "g2d", &events); |
| events.insert(GroupAndName("g2d", "tracing_mark_write")); |
| events.insert(GroupAndName("g2d", "g2d_perf_update_qos")); |
| continue; |
| } |
| |
| if (category == "ion") { |
| events.insert(GroupAndName("kmem", "ion_alloc_buffer_start")); |
| 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") { |
| events.insert(GroupAndName("sched", "sched_switch")); |
| events.insert(GroupAndName("sched", "sched_waking")); |
| events.insert(GroupAndName("sched", "sched_blocked_reason")); |
| events.insert(GroupAndName("sched", "sched_cpu_hotplug")); |
| events.insert(GroupAndName("sched", "sched_pi_setprio")); |
| events.insert(GroupAndName("sched", "sched_process_exit")); |
| AddEventGroup(table, "cgroup", &events); |
| events.insert(GroupAndName("cgroup", "cgroup_transfer_tasks")); |
| events.insert(GroupAndName("cgroup", "cgroup_setup_root")); |
| events.insert(GroupAndName("cgroup", "cgroup_rmdir")); |
| events.insert(GroupAndName("cgroup", "cgroup_rename")); |
| events.insert(GroupAndName("cgroup", "cgroup_remount")); |
| events.insert(GroupAndName("cgroup", "cgroup_release")); |
| events.insert(GroupAndName("cgroup", "cgroup_mkdir")); |
| events.insert(GroupAndName("cgroup", "cgroup_destroy_root")); |
| events.insert(GroupAndName("cgroup", "cgroup_attach_task")); |
| events.insert(GroupAndName("oom", "oom_score_adj_update")); |
| events.insert(GroupAndName("task", "task_rename")); |
| events.insert(GroupAndName("task", "task_newtask")); |
| |
| AddEventGroup(table, "systrace", &events); |
| events.insert(GroupAndName("systrace", "0")); |
| |
| AddEventGroup(table, "scm", &events); |
| events.insert(GroupAndName("scm", "scm_call_start")); |
| events.insert(GroupAndName("scm", "scm_call_end")); |
| continue; |
| } |
| |
| if (category == "irq") { |
| AddEventGroup(table, "irq", &events); |
| events.insert(GroupAndName("irq", "tasklet_hi_exit")); |
| events.insert(GroupAndName("irq", "tasklet_hi_entry")); |
| events.insert(GroupAndName("irq", "tasklet_exit")); |
| events.insert(GroupAndName("irq", "tasklet_entry")); |
| events.insert(GroupAndName("irq", "softirq_raise")); |
| events.insert(GroupAndName("irq", "softirq_exit")); |
| events.insert(GroupAndName("irq", "softirq_entry")); |
| events.insert(GroupAndName("irq", "irq_handler_exit")); |
| events.insert(GroupAndName("irq", "irq_handler_entry")); |
| AddEventGroup(table, "ipi", &events); |
| events.insert(GroupAndName("ipi", "ipi_raise")); |
| events.insert(GroupAndName("ipi", "ipi_exit")); |
| events.insert(GroupAndName("ipi", "ipi_entry")); |
| continue; |
| } |
| |
| if (category == "irqoff") { |
| events.insert(GroupAndName("preemptirq", "irq_enable")); |
| events.insert(GroupAndName("preemptirq", "irq_disable")); |
| continue; |
| } |
| |
| if (category == "preemptoff") { |
| events.insert(GroupAndName("preemptirq", "preempt_enable")); |
| events.insert(GroupAndName("preemptirq", "preempt_disable")); |
| continue; |
| } |
| |
| if (category == "i2c") { |
| AddEventGroup(table, "i2c", &events); |
| events.insert(GroupAndName("i2c", "i2c_read")); |
| events.insert(GroupAndName("i2c", "i2c_write")); |
| events.insert(GroupAndName("i2c", "i2c_result")); |
| events.insert(GroupAndName("i2c", "i2c_reply")); |
| events.insert(GroupAndName("i2c", "smbus_read")); |
| events.insert(GroupAndName("i2c", "smbus_write")); |
| events.insert(GroupAndName("i2c", "smbus_result")); |
| events.insert(GroupAndName("i2c", "smbus_reply")); |
| continue; |
| } |
| |
| if (category == "freq") { |
| events.insert(GroupAndName("power", "cpu_frequency")); |
| events.insert(GroupAndName("power", "gpu_frequency")); |
| events.insert(GroupAndName("power", "clock_set_rate")); |
| events.insert(GroupAndName("power", "clock_disable")); |
| events.insert(GroupAndName("power", "clock_enable")); |
| events.insert(GroupAndName("clk", "clk_set_rate")); |
| events.insert(GroupAndName("clk", "clk_disable")); |
| events.insert(GroupAndName("clk", "clk_enable")); |
| events.insert(GroupAndName("power", "cpu_frequency_limits")); |
| events.insert(GroupAndName("power", "suspend_resume")); |
| events.insert(GroupAndName("cpuhp", "cpuhp_enter")); |
| events.insert(GroupAndName("cpuhp", "cpuhp_exit")); |
| events.insert(GroupAndName("cpuhp", "cpuhp_pause")); |
| AddEventGroup(table, "msm_bus", &events); |
| events.insert(GroupAndName("msm_bus", "bus_update_request_end")); |
| events.insert(GroupAndName("msm_bus", "bus_update_request")); |
| events.insert(GroupAndName("msm_bus", "bus_rules_matches")); |
| events.insert(GroupAndName("msm_bus", "bus_max_votes")); |
| events.insert(GroupAndName("msm_bus", "bus_client_status")); |
| events.insert(GroupAndName("msm_bus", "bus_bke_params")); |
| events.insert(GroupAndName("msm_bus", "bus_bimc_config_limiter")); |
| events.insert(GroupAndName("msm_bus", "bus_avail_bw")); |
| events.insert(GroupAndName("msm_bus", "bus_agg_bw")); |
| continue; |
| } |
| |
| if (category == "membus") { |
| AddEventGroup(table, "memory_bus", &events); |
| continue; |
| } |
| |
| if (category == "idle") { |
| events.insert(GroupAndName("power", "cpu_idle")); |
| continue; |
| } |
| |
| if (category == "disk") { |
| events.insert(GroupAndName("f2fs", "f2fs_sync_file_enter")); |
| events.insert(GroupAndName("f2fs", "f2fs_sync_file_exit")); |
| events.insert(GroupAndName("f2fs", "f2fs_write_begin")); |
| events.insert(GroupAndName("f2fs", "f2fs_write_end")); |
| events.insert(GroupAndName("ext4", "ext4_da_write_begin")); |
| events.insert(GroupAndName("ext4", "ext4_da_write_end")); |
| events.insert(GroupAndName("ext4", "ext4_sync_file_enter")); |
| events.insert(GroupAndName("ext4", "ext4_sync_file_exit")); |
| events.insert(GroupAndName("block", "block_rq_issue")); |
| events.insert(GroupAndName("block", "block_rq_complete")); |
| 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); |
| events.insert(GroupAndName("sync", "sync_pt")); |
| events.insert(GroupAndName("sync", "sync_timeline")); |
| events.insert(GroupAndName("sync", "sync_wait")); |
| // linux kernel == 4.9.x |
| AddEventGroup(table, "fence", &events); |
| events.insert(GroupAndName("fence", "fence_annotate_wait_on")); |
| events.insert(GroupAndName("fence", "fence_destroy")); |
| events.insert(GroupAndName("fence", "fence_emit")); |
| events.insert(GroupAndName("fence", "fence_enable_signal")); |
| events.insert(GroupAndName("fence", "fence_init")); |
| events.insert(GroupAndName("fence", "fence_signaled")); |
| events.insert(GroupAndName("fence", "fence_wait_end")); |
| events.insert(GroupAndName("fence", "fence_wait_start")); |
| // linux kernel > 4.9 |
| AddEventGroup(table, "dma_fence", &events); |
| continue; |
| } |
| |
| if (category == "workq") { |
| AddEventGroup(table, "workqueue", &events); |
| events.insert(GroupAndName("workqueue", "workqueue_queue_work")); |
| events.insert(GroupAndName("workqueue", "workqueue_execute_start")); |
| events.insert(GroupAndName("workqueue", "workqueue_execute_end")); |
| events.insert(GroupAndName("workqueue", "workqueue_activate_work")); |
| continue; |
| } |
| |
| if (category == "memreclaim") { |
| events.insert(GroupAndName("vmscan", "mm_vmscan_direct_reclaim_begin")); |
| events.insert(GroupAndName("vmscan", "mm_vmscan_direct_reclaim_end")); |
| events.insert(GroupAndName("vmscan", "mm_vmscan_kswapd_wake")); |
| events.insert(GroupAndName("vmscan", "mm_vmscan_kswapd_sleep")); |
| AddEventGroup(table, "lowmemorykiller", &events); |
| events.insert(GroupAndName("lowmemorykiller", "lowmemory_kill")); |
| continue; |
| } |
| |
| if (category == "regulators") { |
| AddEventGroup(table, "regulator", &events); |
| events.insert( |
| GroupAndName("regulator", "regulator_set_voltage_complete")); |
| events.insert(GroupAndName("regulator", "regulator_set_voltage")); |
| events.insert(GroupAndName("regulator", "regulator_enable_delay")); |
| events.insert(GroupAndName("regulator", "regulator_enable_complete")); |
| events.insert(GroupAndName("regulator", "regulator_enable")); |
| events.insert(GroupAndName("regulator", "regulator_disable_complete")); |
| events.insert(GroupAndName("regulator", "regulator_disable")); |
| continue; |
| } |
| |
| if (category == "binder_driver") { |
| events.insert(GroupAndName("binder", "binder_transaction")); |
| events.insert(GroupAndName("binder", "binder_transaction_received")); |
| events.insert(GroupAndName("binder", "binder_transaction_alloc_buf")); |
| events.insert(GroupAndName("binder", "binder_set_priority")); |
| continue; |
| } |
| |
| if (category == "binder_lock") { |
| events.insert(GroupAndName("binder", "binder_lock")); |
| events.insert(GroupAndName("binder", "binder_locked")); |
| events.insert(GroupAndName("binder", "binder_unlock")); |
| continue; |
| } |
| |
| if (category == "pagecache") { |
| AddEventGroup(table, "filemap", &events); |
| events.insert( |
| GroupAndName("filemap", "mm_filemap_delete_from_page_cache")); |
| events.insert(GroupAndName("filemap", "mm_filemap_add_to_page_cache")); |
| events.insert(GroupAndName("filemap", "filemap_set_wb_err")); |
| events.insert(GroupAndName("filemap", "file_check_and_advance_wb_err")); |
| continue; |
| } |
| |
| if (category == "memory") { |
| events.insert(GroupAndName("kmem", "rss_stat")); |
| events.insert(GroupAndName("kmem", "ion_heap_grow")); |
| events.insert(GroupAndName("kmem", "ion_heap_shrink")); |
| // ion_stat supersedes ion_heap_grow / shrink for kernel 4.19+ |
| events.insert(GroupAndName("ion", "ion_stat")); |
| events.insert(GroupAndName("mm_event", "mm_event_record")); |
| events.insert(GroupAndName("dmabuf_heap", "dma_heap_stat")); |
| continue; |
| } |
| |
| if (category == "thermal") { |
| events.insert(GroupAndName("thermal", "thermal_temperature")); |
| events.insert(GroupAndName("thermal", "cdev_update")); |
| continue; |
| } |
| } |
| } |
| return events; |
| } |
| |
| // Post-conditions: |
| // 1. result >= 1 (should have at least one page per CPU) |
| // 2. result * 4 < kMaxTotalBufferSizeKb |
| // 3. If input is 0 output is a good default number. |
| size_t ComputeCpuBufferSizeInPages(size_t requested_buffer_size_kb) { |
| if (requested_buffer_size_kb == 0) |
| requested_buffer_size_kb = kDefaultPerCpuBufferSizeKb; |
| if (requested_buffer_size_kb > kMaxPerCpuBufferSizeKb) { |
| PERFETTO_ELOG( |
| "The requested ftrace buf size (%zu KB) is too big, capping to %d KB", |
| requested_buffer_size_kb, kMaxPerCpuBufferSizeKb); |
| requested_buffer_size_kb = kMaxPerCpuBufferSizeKb; |
| } |
| |
| size_t pages = requested_buffer_size_kb / (base::kPageSize / 1024); |
| if (pages == 0) |
| return 1; |
| |
| return pages; |
| } |
| |
| FtraceConfigMuxer::FtraceConfigMuxer( |
| FtraceProcfs* ftrace, |
| ProtoTranslationTable* table, |
| std::map<std::string, std::vector<GroupAndName>> vendor_events) |
| : ftrace_(ftrace), |
| table_(table), |
| current_state_(), |
| ds_configs_(), |
| vendor_events_(vendor_events) {} |
| FtraceConfigMuxer::~FtraceConfigMuxer() = default; |
| |
| FtraceConfigId FtraceConfigMuxer::SetupConfig(const FtraceConfig& request) { |
| EventFilter filter; |
| bool is_ftrace_enabled = ftrace_->IsTracingEnabled(); |
| if (ds_configs_.empty()) { |
| PERFETTO_DCHECK(active_configs_.empty()); |
| |
| // If someone outside of perfetto is using ftrace give up now. |
| if (is_ftrace_enabled) { |
| PERFETTO_ELOG("ftrace in use by non-Perfetto."); |
| return 0; |
| } |
| |
| // Setup ftrace, without starting it. Setting buffers can be quite slow |
| // (up to hundreds of ms). |
| SetupClock(request); |
| SetupBufferSize(request); |
| } else { |
| // Did someone turn ftrace off behind our back? If so give up. |
| if (!active_configs_.empty() && !is_ftrace_enabled) { |
| PERFETTO_ELOG("ftrace disabled by non-Perfetto."); |
| return 0; |
| } |
| } |
| |
| 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)) |
| UpdateAtrace(request); |
| |
| 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()); |
| 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()); |
| } |
| } |
| |
| auto compact_sched = |
| CreateCompactSchedConfig(request, table_->compact_sched_format()); |
| |
| std::vector<std::string> apps(request.atrace_apps()); |
| std::vector<std::string> categories(request.atrace_categories()); |
| FtraceConfigId id = ++last_id_; |
| ds_configs_.emplace( |
| std::piecewise_construct, std::forward_as_tuple(id), |
| std::forward_as_tuple(std::move(filter), compact_sched, std::move(apps), |
| std::move(categories), request.symbolize_ksyms())); |
| return id; |
| } |
| |
| bool FtraceConfigMuxer::ActivateConfig(FtraceConfigId id) { |
| if (!id || ds_configs_.count(id) == 0) { |
| PERFETTO_DFATAL("Config not found"); |
| return false; |
| } |
| |
| if (active_configs_.empty()) { |
| if (ftrace_->IsTracingEnabled()) { |
| // If someone outside of perfetto is using ftrace give up now. |
| PERFETTO_ELOG("ftrace in use by non-Perfetto."); |
| return false; |
| } |
| if (!ftrace_->EnableTracing()) { |
| PERFETTO_ELOG("Failed to enable ftrace."); |
| return false; |
| } |
| } |
| |
| active_configs_.insert(id); |
| 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()); |
| |
| // 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); |
| } |
| |
| // If there aren't any more active configs, disable ftrace. |
| 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, disable ftrace. |
| if (!ftrace_->DisableTracing()) |
| PERFETTO_ELOG("Failed to disable ftrace."); |
| } |
| } |
| |
| // 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_->DisableAllEvents(); |
| ftrace_->ClearTrace(); |
| } |
| |
| 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)) { |
| // Update current_state_ to reflect this change. |
| current_state_.atrace_apps = expected_apps; |
| current_state_.atrace_categories = expected_categories; |
| } |
| } |
| } |
| |
| 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&) { |
| std::string current_clock = ftrace_->GetClock(); |
| std::set<std::string> clocks = ftrace_->AvailableClocks(); |
| |
| 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); |
| break; |
| } |
| } |
| |
| void FtraceConfigMuxer::SetupBufferSize(const FtraceConfig& request) { |
| size_t pages = ComputeCpuBufferSizeInPages(request.buffer_size_kb()); |
| ftrace_->SetCpuBufferSizeInPages(pages); |
| current_state_.cpu_buffer_size_pages = pages; |
| } |
| |
| size_t FtraceConfigMuxer::GetPerCpuBufferSizePages() { |
| return current_state_.cpu_buffer_size_pages; |
| } |
| |
| void FtraceConfigMuxer::UpdateAtrace(const FtraceConfig& request) { |
| // 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)) { |
| current_state_.atrace_categories = combined_categories; |
| current_state_.atrace_apps = combined_apps; |
| current_state_.atrace_on = true; |
| } |
| } |
| |
| // static |
| bool FtraceConfigMuxer::StartAtrace( |
| const std::vector<std::string>& apps, |
| const std::vector<std::string>& categories) { |
| PERFETTO_DLOG("Update atrace config..."); |
| |
| std::vector<std::string> args; |
| args.push_back("atrace"); // argv0 for exec() |
| args.push_back("--async_start"); |
| 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 = RunAtrace(args); |
| PERFETTO_DLOG("...done (%s)", result ? "success" : "fail"); |
| return result; |
| } |
| |
| void FtraceConfigMuxer::DisableAtrace() { |
| PERFETTO_DCHECK(current_state_.atrace_on); |
| |
| PERFETTO_DLOG("Stop atrace..."); |
| |
| if (RunAtrace({"atrace", "--async_stop", "--only_userspace"})) { |
| current_state_.atrace_categories.clear(); |
| current_state_.atrace_apps.clear(); |
| current_state_.atrace_on = false; |
| } |
| |
| PERFETTO_DLOG("...done"); |
| } |
| |
| } // namespace perfetto |
