#if 0
// Below options are only used internally and shouldn't be visible to the public.
"--in-app We are already running in the app's context.\n"
+"--tracepoint-events file_name Read tracepoint events from [file_name] instead of tracefs.\n"
#endif
// clang-format on
),
};
bool RecordCommand::Run(const std::vector<std::string>& args) {
- // 0. Do some environment preparation.
if (!CheckPerfEventLimit()) {
return false;
}
- if (!InitPerfClock()) {
- return false;
- }
- PrepareVdsoFile();
// 1. Parse options, and use default measured event type if not given.
std::vector<std::string> workload_args;
// root.
if (!IsRoot()) {
return RunInAppContext(app_package_name_, "record", args, workload_args.size(),
- record_filename_);
+ record_filename_, !event_selection_set_.GetTracepointEvents().empty());
}
}
if (event_selection_set_.empty()) {
if (!SetEventSelectionFlags()) {
return false;
}
+
+ // 2. Do some environment preparation.
ScopedCurrentArch scoped_arch(GetMachineArch());
+ if (!InitPerfClock()) {
+ return false;
+ }
+ PrepareVdsoFile();
- // 2. Create workload.
+ // 3. Create workload.
std::unique_ptr<Workload> workload;
if (!workload_args.empty()) {
workload = Workload::CreateWorkload(workload_args);
need_to_check_targets = true;
}
- // 3. Open perf_event_files, create mapped buffers for perf_event_files.
+ // 4. Open perf_event_files, create mapped buffers for perf_event_files.
if (!event_selection_set_.OpenEventFiles(cpus_)) {
return false;
}
return false;
}
- // 4. Create perf.data.
+ // 5. Create perf.data.
if (!CreateAndInitRecordFile()) {
return false;
}
- // 5. Add read/signal/periodic Events.
+ // 6. Add read/signal/periodic Events.
auto callback =
std::bind(&RecordCommand::ProcessRecord, this, std::placeholders::_1);
if (!event_selection_set_.PrepareToReadMmapEventData(callback)) {
}
}
- // 6. Write records in mapped buffers of perf_event_files to output file while
+ // 7. Write records in mapped buffers of perf_event_files to output file while
// workload is running.
start_sampling_time_in_ns_ = GetPerfClock();
LOG(VERBOSE) << "start_sampling_time is " << start_sampling_time_in_ns_
return false;
}
- // 7. Dump additional features, and close record file.
+ // 8. Dump additional features, and close record file.
if (!DumpAdditionalFeatures(args)) {
return false;
}
return false;
}
- // 8. Unwind dwarf callchain.
+ // 9. Unwind dwarf callchain.
if (post_unwind_) {
if (!PostUnwind(args)) {
return false;
}
}
- // 9. Show brief record result.
+ // 10. Show brief record result.
LOG(INFO) << "Samples recorded: " << sample_record_count_
<< ". Samples lost: " << lost_record_count_ << ".";
if (sample_record_count_ + lost_record_count_ != 0) {
return false;
}
event_selection_set_.AddMonitoredThreads(tids);
+ } else if (args[i] == "--tracepoint-events") {
+ if (!NextArgumentOrError(args, &i)) {
+ return false;
+ }
+ if (!SetTracepointEventsFilePath(args[i])) {
+ return false;
+ }
} else {
ReportUnknownOption(args, i);
return false;
bool RecordCommand::DumpTracingData() {
std::vector<const EventType*> tracepoint_event_types =
event_selection_set_.GetTracepointEvents();
- if (tracepoint_event_types.empty()) {
- return true; // No need to dump tracing data.
+ if (tracepoint_event_types.empty() || !CanRecordRawData()) {
+ return true; // No need to dump tracing data, or can't do it.
}
std::vector<char> tracing_data;
if (!GetTracingData(tracepoint_event_types, &tracing_data)) {
ASSERT_TRUE(RecordCmd()->Run(
{"-e", "cpu-clock", "-o", tmpfile.path, "-p", pid, "--duration", "3"}));
}
+
+TEST(record_cmd, dump_regs_for_tracepoint_events) {
+ // Check if the kernel can dump registers for tracepoint events.
+ // If not, probably a kernel patch below is missing:
+ // "5b09a094f2 arm64: perf: Fix callchain parse error with kernel tracepoint events"
+ std::vector<std::unique_ptr<Workload>> workloads;
+ CreateProcesses(1, &workloads);
+ std::string pid = std::to_string(workloads[0]->GetPid());
+ TemporaryFile tmpfile;
+ ASSERT_TRUE(RecordCmd()->Run({"-o", tmpfile.path, "-p", pid, "-e", "sched:sched_switch",
+ "-g", "--no-unwind", "--duration", "1"}));
+
+ // If the kernel patch is missing, all regs dumped in sample records are zero.
+ std::unique_ptr<RecordFileReader> reader = RecordFileReader::CreateInstance(tmpfile.path);
+ CHECK(reader != nullptr);
+ std::unique_ptr<Record> r;
+ bool regs_all_zero = true;
+ while (reader->ReadRecord(r) && r && regs_all_zero) {
+ if (r->type() != PERF_RECORD_SAMPLE) {
+ continue;
+ }
+ SampleRecord* s = static_cast<SampleRecord*>(r.get());
+ for (size_t i = 0; i < s->regs_user_data.reg_nr; ++i) {
+ if (s->regs_user_data.regs[i] != 0u) {
+ regs_all_zero = false;
+ break;
+ }
+ }
+ }
+ ASSERT_FALSE(regs_all_zero);
+}
#if 0
// Below options are only used internally and shouldn't be visible to the public.
"--in-app We are already running in the app's context.\n"
+"--tracepoint-events file_name Read tracepoint events from [file_name] instead of tracefs.\n"
#endif
// clang-format on
),
if (!app_package_name_.empty() && !in_app_context_) {
if (!IsRoot()) {
return RunInAppContext(app_package_name_, "stat", args, workload_args.size(),
- output_filename_);
+ output_filename_, !event_selection_set_.GetTracepointEvents().empty());
}
}
if (event_selection_set_.empty()) {
return false;
}
event_selection_set_.AddMonitoredThreads(tids);
+ } else if (args[i] == "--tracepoint-events") {
+ if (!NextArgumentOrError(args, &i)) {
+ return false;
+ }
+ if (!SetTracepointEventsFilePath(args[i])) {
+ return false;
+ }
} else if (args[i] == "--verbose") {
verbose_mode_ = true;
} else {
#include <sys/system_properties.h>
#endif
+#include "event_type.h"
#include "IOEventLoop.h"
#include "read_elf.h"
#include "thread_tree.h"
return true;
}
+bool CanRecordRawData() {
+ int value;
+ return IsRoot() || (ReadPerfEventParanoid(&value) && value == -1);
+}
+
static const char* GetLimitLevelDescription(int limit_level) {
switch (limit_level) {
case -1: return "unlimited";
}
}
+class ScopedFile {
+ public:
+ ScopedFile(const std::string& filepath, std::string app_package_name = "")
+ : filepath_(filepath), app_package_name_(app_package_name) {}
+
+ ~ScopedFile() {
+ if (app_package_name_.empty()) {
+ unlink(filepath_.c_str());
+ } else {
+ Workload::RunCmd({"run-as", app_package_name_, "rm", "-rf", filepath_});
+ }
+ }
+
+ private:
+ std::string filepath_;
+ std::string app_package_name_;
+};
+
bool RunInAppContext(const std::string& app_package_name, const std::string& cmd,
const std::vector<std::string>& args, size_t workload_args_size,
- const std::string& output_filepath) {
+ const std::string& output_filepath, bool need_tracepoint_events) {
// 1. Test if the package exists.
if (!Workload::RunCmd({"run-as", app_package_name, "echo", ">/dev/null"}, false)) {
LOG(ERROR) << "Package " << app_package_name << "doesn't exist or isn't debuggable.";
return false;
}
- // 2. Copy simpleperf binary to the package.
+ // 2. Copy simpleperf binary to the package. Create tracepoint_file if needed.
std::string simpleperf_path;
if (!android::base::Readlink("/proc/self/exe", &simpleperf_path)) {
PLOG(ERROR) << "ReadLink failed";
if (!Workload::RunCmd({"run-as", app_package_name, "cp", simpleperf_path, "simpleperf"})) {
return false;
}
+ ScopedFile scoped_simpleperf("simpleperf", app_package_name);
+ std::unique_ptr<ScopedFile> scoped_tracepoint_file;
+ const std::string tracepoint_file = "/data/local/tmp/tracepoint_events";
+ if (need_tracepoint_events) {
+ // Since we can't read tracepoint events from tracefs in app's context, we need to prepare
+ // them in tracepoint_file in shell's context, and pass the path of tracepoint_file to the
+ // child process using --tracepoint-events option.
+ if (!android::base::WriteStringToFile(GetTracepointEvents(), tracepoint_file)) {
+ PLOG(ERROR) << "Failed to store tracepoint events";
+ return false;
+ }
+ scoped_tracepoint_file.reset(new ScopedFile(tracepoint_file));
+ }
// 3. Prepare to start child process to profile.
std::string output_basename = output_filepath.empty() ? "" :
android::base::Basename(output_filepath);
std::vector<std::string> new_args =
{"run-as", app_package_name, "./simpleperf", cmd, "--in-app"};
+ if (need_tracepoint_events) {
+ new_args.push_back("--tracepoint-events");
+ new_args.push_back(tracepoint_file);
+ }
for (size_t i = 0; i < args.size(); ++i) {
if (i >= args.size() - workload_args_size || args[i] != "-o") {
new_args.push_back(args[i]);
bool GetMaxSampleFrequency(uint64_t* max_sample_freq);
bool CheckSampleFrequency(uint64_t sample_freq);
bool CheckKernelSymbolAddresses();
+bool CanRecordRawData();
#if defined(__linux__)
static inline uint64_t GetSystemClock() {
int WaitForAppProcess(const std::string& package_name);
bool RunInAppContext(const std::string& app_package_name, const std::string& cmd,
const std::vector<std::string>& args, size_t workload_args_size,
- const std::string& output_filepath);
+ const std::string& output_filepath, bool need_tracepoint_events);
// Below two functions are only used in cts tests, to force stat/record cmd to run in app's context.
void SetDefaultAppPackageName(const std::string& package_name);
#include <android-base/logging.h>
+#include "environment.h"
#include "event_type.h"
#include "utils.h"
if (attr.type == PERF_TYPE_TRACEPOINT) {
// Tracepoint information are stored in raw data in sample records.
- attr.sample_type |= PERF_SAMPLE_RAW;
+ if (CanRecordRawData()) {
+ attr.sample_type |= PERF_SAMPLE_RAW;
+ }
}
return attr;
}
#include "event_type.h"
+#include <inttypes.h>
#include <unistd.h>
#include <algorithm>
#include <string>
#include <android-base/file.h>
#include <android-base/logging.h>
+#include <android-base/parseint.h>
+#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include "event_attr.h"
#include "event_type_table.h"
};
-static const std::vector<EventType> GetTracepointEventTypes() {
+static std::string tracepoint_events;
+
+bool SetTracepointEventsFilePath(const std::string& filepath) {
+ if (!android::base::ReadFileToString(filepath, &tracepoint_events)) {
+ PLOG(ERROR) << "Failed to read " << filepath;
+ return false;
+ }
+ return true;
+}
+
+std::string GetTracepointEvents() {
+ std::string result;
+ for (const EventType& event : GetAllEventTypes()) {
+ if (!result.empty()) {
+ result.push_back('\n');
+ }
+ result += android::base::StringPrintf("%s %" PRIu64, event.name.c_str(), event.config);
+ }
+ return result;
+}
+
+static std::vector<EventType> GetTracepointEventTypesFromString(const std::string& s) {
std::vector<EventType> result;
- if (!IsRoot()) {
- // Not having permission to profile tracing events.
- return result;
+ for (auto& line : android::base::Split(s, "\n")) {
+ std::vector<std::string> items = android::base::Split(line, " ");
+ CHECK_EQ(items.size(), 2u);
+ std::string event_name = items[0];
+ uint64_t id;
+ CHECK(android::base::ParseUint(items[1].c_str(), &id));
+ result.push_back(EventType(event_name, PERF_TYPE_TRACEPOINT, id, "", ""));
}
+ return result;
+}
+
+static std::vector<EventType> GetTracepointEventTypesFromTraceFs() {
+ std::vector<EventType> result;
const std::string tracepoint_dirname = "/sys/kernel/debug/tracing/events";
for (const auto& system_name : GetSubDirs(tracepoint_dirname)) {
std::string system_path = tracepoint_dirname + "/" + system_name;
result.push_back(EventType(system_name + ":" + event_name, PERF_TYPE_TRACEPOINT, id, "", ""));
}
}
+ return result;
+}
+
+static std::vector<EventType> GetTracepointEventTypes() {
+ std::vector<EventType> result;
+ if (!tracepoint_events.empty()) {
+ result = GetTracepointEventTypesFromString(tracepoint_events);
+ } else {
+ result = GetTracepointEventTypesFromTraceFs();
+ }
std::sort(result.begin(), result.end(),
[](const EventType& type1, const EventType& type2) { return type1.name < type2.name; });
return result;
if (event_type_array.empty()) {
event_type_array.insert(event_type_array.end(), static_event_type_array.begin(),
static_event_type_array.end());
- const std::vector<EventType> tracepoint_array = GetTracepointEventTypes();
+ std::vector<EventType> tracepoint_array = GetTracepointEventTypes();
event_type_array.insert(event_type_array.end(), tracepoint_array.begin(),
tracepoint_array.end());
}
std::string limited_arch;
};
+bool SetTracepointEventsFilePath(const std::string& filepath);
+std::string GetTracepointEvents();
const std::vector<EventType>& GetAllEventTypes();
const EventType* FindEventTypeByName(const std::string& name);
bool GetKernelBuildId(BuildId*) {
return false;
}
+
+bool CanRecordRawData() {
+ return false;
+}
std::string arg_str = android::base::Join(args, ' ');
int ret = system(arg_str.c_str());
if (ret != 0 && report_error) {
- PLOG(ERROR) << "Failed to run cmd " << arg_str;
+ LOG(ERROR) << "Failed to run cmd " << arg_str << ", exitcode " << ret;
return false;
}
return ret == 0;
OSDN Git Service
