blob: ee7064a23024a86996b74a15aea0864f8a2148ad [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 <fcntl.h>
#include <getopt.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fstream>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include "perfetto/base/logging.h"
#include "perfetto/base/scoped_file.h"
#include "perfetto/base/unix_task_runner.h"
#include "perfetto/base/utils.h"
#include "perfetto/protozero/proto_utils.h"
#include "perfetto/traced/traced.h"
#include "perfetto/tracing/core/consumer.h"
#include "perfetto/tracing/core/data_source_config.h"
#include "perfetto/tracing/core/data_source_descriptor.h"
#include "perfetto/tracing/core/trace_config.h"
#include "perfetto/tracing/core/trace_packet.h"
#include "perfetto/tracing/ipc/consumer_ipc_client.h"
#include "perfetto/config/trace_config.pb.h"
#include "perfetto/trace/trace.pb.h"
#if defined(PERFETTO_OS_ANDROID)
#include "perfetto/base/android_task_runner.h"
#endif // defined(PERFETTO_OS_ANDROID)
#if defined(PERFETTO_BUILD_WITH_ANDROID)
#include <android/os/DropBoxManager.h>
#include <utils/Looper.h>
#include <utils/StrongPointer.h>
#endif // defined(PERFETTO_BUILD_WITH_ANDROID)
// TODO(primiano): add the ability to pass the file descriptor directly to the
// traced service instead of receiving a copy of the slices and writing them
// from this process.
namespace perfetto {
namespace {
// Temporary directory for DropBox traces. Note that this is automatically
// created by the system by setting setprop persist.traced.enable=1.
const char kTempDropBoxTraceDir[] = "/data/misc/perfetto-traces";
const char kDefaultDropBoxTag[] = "perfetto";
std::string GetDirName(const std::string& path) {
size_t sep = path.find_last_of('/');
if (sep == std::string::npos)
return ".";
return path.substr(0, sep);
}
} // namespace
using protozero::proto_utils::WriteVarInt;
using protozero::proto_utils::MakeTagLengthDelimited;
#if defined(PERFETTO_OS_ANDROID)
using PlatformTaskRunner = base::AndroidTaskRunner;
#else
using PlatformTaskRunner = base::UnixTaskRunner;
#endif
class PerfettoCmd : public Consumer {
public:
int Main(int argc, char** argv);
int PrintUsage(const char* argv0);
void OnStopTraceTimer();
void OnTimeout();
// perfetto::Consumer implementation.
void OnConnect() override;
void OnDisconnect() override;
void OnTraceData(std::vector<TracePacket>, bool has_more) override;
private:
bool OpenOutputFile();
PlatformTaskRunner task_runner_;
std::unique_ptr<perfetto::Service::ConsumerEndpoint> consumer_endpoint_;
std::unique_ptr<TraceConfig> trace_config_;
base::ScopedFstream trace_out_stream_;
std::string trace_out_path_;
// Only used if linkat(AT_FDCWD) isn't available.
std::string tmp_trace_out_path_;
std::string dropbox_tag_;
bool did_process_full_trace_ = false;
};
int PerfettoCmd::PrintUsage(const char* argv0) {
PERFETTO_ELOG(R"(
Usage: %s
--background -b : Exits immediately and continues tracing in background
--config -c : /path/to/trace/config/file or - for stdin
--out -o : /path/to/out/trace/file
--dropbox -d TAG : Upload trace into DropBox using tag TAG (default: %s)
--help -h
)",
argv0, kDefaultDropBoxTag);
return 1;
}
int PerfettoCmd::Main(int argc, char** argv) {
static const struct option long_options[] = {
// |option_index| relies on the order of options, don't reshuffle them.
{"help", required_argument, 0, 'h'},
{"config", required_argument, 0, 'c'},
{"out", required_argument, 0, 'o'},
{"background", no_argument, 0, 'b'},
{"dropbox", optional_argument, 0, 'd'},
{nullptr, 0, nullptr, 0}};
int option_index = 0;
std::string trace_config_raw;
bool background = false;
for (;;) {
int option =
getopt_long(argc, argv, "c:o:bd::", long_options, &option_index);
if (option == -1)
break; // EOF.
if (option == 'c') {
if (strcmp(optarg, "-") == 0) {
std::istreambuf_iterator<char> begin(std::cin), end;
trace_config_raw.assign(begin, end);
} else if (strcmp(optarg, ":test") == 0) {
// TODO(primiano): temporary for testing only.
perfetto::protos::TraceConfig test_config;
test_config.add_buffers()->set_size_kb(4096);
test_config.set_duration_ms(10000);
auto* ds_config = test_config.add_data_sources()->mutable_config();
ds_config->set_name("com.google.perfetto.ftrace");
ds_config->mutable_ftrace_config()->add_ftrace_events("sched_switch");
ds_config->mutable_ftrace_config()->add_ftrace_events("cpu_idle");
ds_config->mutable_ftrace_config()->add_ftrace_events("cpu_frequency");
ds_config->set_target_buffer(0);
test_config.SerializeToString(&trace_config_raw);
} else {
std::ifstream file_stream;
file_stream.open(optarg, std::ios_base::in | std::ios_base::binary);
if (!file_stream.is_open()) {
PERFETTO_ELOG("Could not open %s", optarg);
return 1;
}
std::istreambuf_iterator<char> begin(file_stream), end;
trace_config_raw.assign(begin, end);
}
continue;
}
if (option == 'o') {
trace_out_path_ = optarg;
continue;
}
if (option == 'd') {
#if defined(PERFETTO_BUILD_WITH_ANDROID)
dropbox_tag_ = optarg ? optarg : kDefaultDropBoxTag;
continue;
#else
PERFETTO_ELOG("DropBox is only supported with Android tree builds");
return 1;
#endif
}
if (option == 'b') {
background = true;
continue;
}
return PrintUsage(argv[0]);
}
if (!trace_out_path_.empty() && !dropbox_tag_.empty()) {
PERFETTO_ELOG(
"Can't log to a file (--out) and DropBox (--dropbox) at the same "
"time");
return 1;
}
if (trace_out_path_.empty() && dropbox_tag_.empty()) {
return PrintUsage(argv[0]);
}
if (trace_config_raw.empty()) {
PERFETTO_ELOG("The TraceConfig is empty");
return 1;
}
perfetto::protos::TraceConfig trace_config_proto;
PERFETTO_DLOG("Parsing TraceConfig, %zu bytes", trace_config_raw.size());
bool parsed = trace_config_proto.ParseFromString(trace_config_raw);
if (!parsed) {
PERFETTO_ELOG("Could not parse TraceConfig proto from stdin");
return 1;
}
trace_config_.reset(new TraceConfig());
trace_config_->FromProto(trace_config_proto);
trace_config_raw.clear();
if (!OpenOutputFile())
return 1;
if (background) {
PERFETTO_CHECK(daemon(0 /*nochdir*/, 0 /*noclose*/) == 0);
PERFETTO_DLOG("Continuing in background");
}
consumer_endpoint_ = ConsumerIPCClient::Connect(PERFETTO_CONSUMER_SOCK_NAME,
this, &task_runner_);
task_runner_.Run();
return did_process_full_trace_ ? 0 : 1;
} // namespace perfetto
void PerfettoCmd::OnConnect() {
PERFETTO_LOG(
"Connected to the Perfetto traced service, starting tracing for %d ms",
trace_config_->duration_ms());
PERFETTO_DCHECK(trace_config_);
trace_config_->set_enable_extra_guardrails(!dropbox_tag_.empty());
consumer_endpoint_->EnableTracing(*trace_config_);
task_runner_.PostDelayedTask(std::bind(&PerfettoCmd::OnStopTraceTimer, this),
trace_config_->duration_ms());
// Failsafe mechanism to avoid waiting indefinitely if the service hangs.
task_runner_.PostDelayedTask(std::bind(&PerfettoCmd::OnTimeout, this),
trace_config_->duration_ms() * 2);
}
void PerfettoCmd::OnDisconnect() {
PERFETTO_LOG("Disconnected from the Perfetto traced service");
task_runner_.Quit();
}
void PerfettoCmd::OnStopTraceTimer() {
PERFETTO_LOG("Timer expired, disabling tracing and collecting results");
consumer_endpoint_->DisableTracing();
consumer_endpoint_->ReadBuffers();
}
void PerfettoCmd::OnTimeout() {
PERFETTO_ELOG("Timed out while waiting for trace from the service, aborting");
task_runner_.Quit();
}
void PerfettoCmd::OnTraceData(std::vector<TracePacket> packets, bool has_more) {
PERFETTO_DLOG("Received trace packet, has_more=%d", has_more);
for (TracePacket& packet : packets) {
for (const Slice& slice : packet.slices()) {
uint8_t preamble[16];
uint8_t* pos = preamble;
pos = WriteVarInt(
MakeTagLengthDelimited(protos::Trace::kPacketFieldNumber), pos);
pos = WriteVarInt(static_cast<uint32_t>(slice.size), pos);
fwrite(reinterpret_cast<const char*>(preamble), pos - preamble, 1,
trace_out_stream_.get());
fwrite(reinterpret_cast<const char*>(slice.start), slice.size, 1,
trace_out_stream_.get());
}
}
if (has_more)
return;
// Reached end of trace.
task_runner_.Quit();
fflush(*trace_out_stream_);
long bytes_written = ftell(*trace_out_stream_);
if (!dropbox_tag_.empty()) {
#if defined(PERFETTO_BUILD_WITH_ANDROID)
android::sp<android::os::DropBoxManager> dropbox =
new android::os::DropBoxManager();
fseek(*trace_out_stream_, 0, SEEK_SET);
// DropBox takes ownership of the file descriptor, so give it a duplicate.
// Also we need to give it a read-only copy of the fd or will hit a SELinux
// violation (about system_server ending up with a writable FD to our dir).
char fdpath[64];
sprintf(fdpath, "/proc/self/fd/%d", fileno(*trace_out_stream_));
base::ScopedFile read_only_fd(open(fdpath, O_RDONLY));
PERFETTO_CHECK(read_only_fd);
trace_out_stream_.reset();
android::binder::Status status =
dropbox->addFile(android::String16(dropbox_tag_.c_str()),
read_only_fd.release(), 0 /* flags */);
if (!status.isOk()) {
PERFETTO_ELOG("DropBox upload failed: %s", status.toString8().c_str());
return;
}
PERFETTO_ILOG("Uploaded %ld bytes into DropBox with tag %s", bytes_written,
dropbox_tag_.c_str());
#endif // defined(PERFETTO_BUILD_WITH_ANDROID)
} else {
trace_out_stream_.reset();
PERFETTO_CHECK(
rename(tmp_trace_out_path_.c_str(), trace_out_path_.c_str()) == 0);
PERFETTO_ILOG("Wrote %ld bytes into %s", bytes_written,
trace_out_path_.c_str());
}
did_process_full_trace_ = true;
}
bool PerfettoCmd::OpenOutputFile() {
base::ScopedFile fd;
if (!dropbox_tag_.empty()) {
// If we are tracing to DropBox, there's no need to make a
// filesystem-visible temporary file.
// TODO(skyostil): Fall back to mkstemp() + open() + unlink() for older
// devices.
fd.reset(open(kTempDropBoxTraceDir, O_TMPFILE | O_RDWR, 0600));
if (!fd) {
PERFETTO_ELOG("Could not create a temporary trace file in %s",
kTempDropBoxTraceDir);
return false;
}
} else {
// Otherwise create a temporary file in the directory where the final trace
// is going to be.
tmp_trace_out_path_ = GetDirName(trace_out_path_) + "/perfetto-traceXXXXXX";
fd.reset(mkstemp(&tmp_trace_out_path_[0]));
}
trace_out_stream_.reset(fdopen(fd.release(), "wb"));
PERFETTO_CHECK(trace_out_stream_);
return true;
}
int __attribute__((visibility("default")))
PerfettoCmdMain(int argc, char** argv) {
perfetto::PerfettoCmd consumer_cmd;
return consumer_cmd.Main(argc, argv);
}
} // namespace perfetto