/*
|
**
|
** Copyright 2015, 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 "perfprofd_perf.h"
|
|
|
#include <inttypes.h>
|
#include <signal.h>
|
#include <sys/wait.h>
|
#include <unistd.h>
|
|
#include <algorithm>
|
#include <cerrno>
|
#include <cstdio>
|
#include <cstring>
|
#include <memory>
|
#include <vector>
|
|
#include <android-base/file.h>
|
#include <android-base/logging.h>
|
#include <android-base/stringprintf.h>
|
#include <android-base/strings.h>
|
#include <android-base/unique_fd.h>
|
|
#include "config.h"
|
|
namespace android {
|
namespace perfprofd {
|
|
namespace {
|
|
std::unordered_set<std::string>& GetSupportedPerfCountersInternal() {
|
static std::unordered_set<std::string>& vec = *new std::unordered_set<std::string>();
|
return vec;
|
}
|
|
} // namespace
|
|
//
|
// Invoke "perf record". Return value is OK_PROFILE_COLLECTION for
|
// success, or some other error code if something went wrong.
|
//
|
PerfResult InvokePerf(Config& config,
|
const std::string &perf_path,
|
const char *stack_profile_opt,
|
unsigned duration,
|
const std::string &data_file_path,
|
const std::string &perf_stderr_path)
|
{
|
std::vector<std::string> argv_backing;
|
std::vector<const char*> argv_vector;
|
char paranoid_env[] = "PERFPROFD_DISABLE_PERF_EVENT_PARANOID_CHANGE=1";
|
char* envp[2] = {paranoid_env, nullptr};
|
|
{
|
auto add = [&argv_backing](auto arg) {
|
argv_backing.push_back(arg);
|
};
|
|
add(perf_path);
|
add("record");
|
|
// -o perf.data
|
add("-o");
|
add(data_file_path);
|
|
// -c/f N
|
std::string p_str;
|
if (config.sampling_frequency > 0) {
|
add("-f");
|
add(android::base::StringPrintf("%u", config.sampling_frequency));
|
} else if (config.sampling_period > 0) {
|
add("-c");
|
add(android::base::StringPrintf("%u", config.sampling_period));
|
}
|
|
if (!config.event_config.empty()) {
|
const std::unordered_set<std::string>& supported = GetSupportedPerfCountersInternal();
|
for (const auto& event_set : config.event_config) {
|
if (event_set.events.empty()) {
|
LOG(WARNING) << "Unexpected empty event set";
|
continue;
|
}
|
|
std::ostringstream event_str;
|
bool added = false;
|
for (const std::string& event : event_set.events) {
|
if (supported.find(event) == supported.end()) {
|
LOG(WARNING) << "Event " << event << " is unsupported.";
|
if (config.fail_on_unsupported_events) {
|
return PerfResult::kUnsupportedEvent;
|
}
|
continue;
|
}
|
if (added) {
|
event_str << ',';
|
}
|
event_str << event;
|
added = true;
|
}
|
|
if (!added) {
|
continue;
|
}
|
|
if (event_set.sampling_period > 0) {
|
add("-c");
|
add(std::to_string(event_set.sampling_period));
|
}
|
add(event_set.group ? "--group" : "-e");
|
add(event_str.str());
|
}
|
}
|
|
// -g if desired
|
if (stack_profile_opt != nullptr) {
|
add(stack_profile_opt);
|
add("-m");
|
add("8192");
|
}
|
|
if (config.process < 0) {
|
// system wide profiling
|
add("-a");
|
} else {
|
add("-p");
|
add(std::to_string(config.process));
|
}
|
|
// no need for kernel or other symbols
|
add("--no-dump-kernel-symbols");
|
add("--no-dump-symbols");
|
|
// sleep <duration>
|
add("--duration");
|
add(android::base::StringPrintf("%u", duration));
|
|
|
// Now create the char* buffer.
|
argv_vector.resize(argv_backing.size() + 1, nullptr);
|
std::transform(argv_backing.begin(),
|
argv_backing.end(),
|
argv_vector.begin(),
|
[](const std::string& in) { return in.c_str(); });
|
}
|
|
pid_t pid = fork();
|
|
if (pid == -1) {
|
PLOG(ERROR) << "Fork failed";
|
return PerfResult::kForkFailed;
|
}
|
|
if (pid == 0) {
|
// child
|
|
// Open file to receive stderr/stdout from perf
|
FILE *efp = fopen(perf_stderr_path.c_str(), "w");
|
if (efp) {
|
dup2(fileno(efp), STDERR_FILENO);
|
dup2(fileno(efp), STDOUT_FILENO);
|
} else {
|
PLOG(WARNING) << "unable to open " << perf_stderr_path << " for writing";
|
}
|
|
// record the final command line in the error output file for
|
// posterity/debugging purposes
|
fprintf(stderr, "perf invocation (pid=%d):\n", getpid());
|
for (unsigned i = 0; argv_vector[i] != nullptr; ++i) {
|
fprintf(stderr, "%s%s", i ? " " : "", argv_vector[i]);
|
}
|
fprintf(stderr, "\n");
|
|
// exec
|
execvpe(argv_vector[0], const_cast<char* const*>(argv_vector.data()), envp);
|
fprintf(stderr, "exec failed: %s\n", strerror(errno));
|
exit(1);
|
|
} else {
|
// parent
|
|
// Try to sleep.
|
config.Sleep(duration);
|
|
// We may have been woken up to stop profiling.
|
if (config.ShouldStopProfiling()) {
|
// Send SIGHUP to simpleperf to make it stop.
|
kill(pid, SIGHUP);
|
}
|
|
// Wait for the child, so it's reaped correctly.
|
int st = 0;
|
pid_t reaped = TEMP_FAILURE_RETRY(waitpid(pid, &st, 0));
|
|
auto print_perferr = [&perf_stderr_path]() {
|
std::string tmp;
|
if (android::base::ReadFileToString(perf_stderr_path, &tmp)) {
|
LOG(WARNING) << tmp;
|
} else {
|
PLOG(WARNING) << "Could not read " << perf_stderr_path;
|
}
|
};
|
|
if (reaped == -1) {
|
PLOG(WARNING) << "waitpid failed";
|
} else if (WIFSIGNALED(st)) {
|
if (WTERMSIG(st) == SIGHUP && config.ShouldStopProfiling()) {
|
// That was us...
|
return PerfResult::kOK;
|
}
|
LOG(WARNING) << "perf killed by signal " << WTERMSIG(st);
|
print_perferr();
|
} else if (WEXITSTATUS(st) != 0) {
|
LOG(WARNING) << "perf bad exit status " << WEXITSTATUS(st);
|
print_perferr();
|
} else {
|
return PerfResult::kOK;
|
}
|
}
|
|
return PerfResult::kRecordFailed;
|
}
|
|
bool FindSupportedPerfCounters(const std::string& perf_path) {
|
const char* argv[] = { perf_path.c_str(), "list", nullptr };
|
char paranoid_env[] = "PERFPROFD_DISABLE_PERF_EVENT_PARANOID_CHANGE=1";
|
char* envp[2] = {paranoid_env, nullptr};
|
|
base::unique_fd link[2];
|
{
|
int link_fd[2];
|
|
if (pipe(link_fd) == -1) {
|
PLOG(ERROR) << "Pipe failed";
|
return false;
|
}
|
link[0].reset(link_fd[0]);
|
link[1].reset(link_fd[1]);
|
}
|
|
pid_t pid = fork();
|
|
if (pid == -1) {
|
PLOG(ERROR) << "Fork failed";
|
return PerfResult::kForkFailed;
|
}
|
|
if (pid == 0) {
|
// Child
|
|
// Redirect stdout and stderr.
|
dup2(link[1].get(), STDOUT_FILENO);
|
dup2(link[1].get(), STDERR_FILENO);
|
|
link[0].reset();
|
link[1].reset();
|
|
// exec
|
execvpe(argv[0], const_cast<char* const*>(argv), envp);
|
PLOG(WARNING) << "exec failed";
|
exit(1);
|
__builtin_unreachable();
|
}
|
|
link[1].reset();
|
|
std::string result;
|
if (!android::base::ReadFdToString(link[0].get(), &result)) {
|
PLOG(WARNING) << perf_path << " list reading failed.";
|
}
|
|
link[0].reset();
|
|
int status_code;
|
if (waitpid(pid, &status_code, 0) == -1) {
|
LOG(WARNING) << "Failed to wait for " << perf_path << " list";
|
return false;
|
}
|
|
if (!WIFEXITED(status_code) || WEXITSTATUS(status_code) != 0) {
|
LOG(WARNING) << perf_path << " list did not exit normally.";
|
return false;
|
}
|
|
std::unordered_set<std::string>& supported = GetSupportedPerfCountersInternal();
|
supported.clear();
|
|
// Could implement something with less memory requirements. But for now this is good
|
// enough.
|
std::vector<std::string> lines = base::Split(result, "\n");
|
for (const std::string& line : lines) {
|
if (line.length() < 2 || line.compare(0, 2, " ") != 0) {
|
continue;
|
}
|
const size_t comment = line.find('#');
|
const size_t space = line.find(' ', 2);
|
size_t end = std::min(space, comment);
|
if (end != std::string::npos) {
|
// Scan backwards.
|
--end;
|
while (end > 2 && isspace(line[end])) {
|
end--;
|
}
|
}
|
if (end > 2) {
|
supported.insert(line.substr(2, end - 2));
|
}
|
}
|
|
return true;
|
}
|
|
const std::unordered_set<std::string>& GetSupportedPerfCounters() {
|
return GetSupportedPerfCountersInternal();
|
}
|
|
} // namespace perfprofd
|
} // namespace android
|
