blob: fcaa8e63f285262489b0c1f2b6111b0b54faee55 [file] [log] [blame]
/*
* Copyright (C) 2019 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.
*/
#define LOG_TAG "perfetto_hprof"
#include "perfetto_hprof.h"
#include <android-base/logging.h>
#include <fcntl.h>
#include <inttypes.h>
#include <sched.h>
#include <signal.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/un.h>
#include <sys/wait.h>
#include <thread>
#include <time.h>
#include <type_traits>
#include "gc/heap-visit-objects-inl.h"
#include "gc/heap.h"
#include "gc/scoped_gc_critical_section.h"
#include "mirror/object-refvisitor-inl.h"
#include "nativehelper/scoped_local_ref.h"
#include "perfetto/profiling/normalize.h"
#include "perfetto/profiling/parse_smaps.h"
#include "perfetto/trace/interned_data/interned_data.pbzero.h"
#include "perfetto/trace/profiling/heap_graph.pbzero.h"
#include "perfetto/trace/profiling/profile_common.pbzero.h"
#include "perfetto/trace/profiling/smaps.pbzero.h"
#include "perfetto/config/profiling/java_hprof_config.pbzero.h"
#include "perfetto/protozero/packed_repeated_fields.h"
#include "perfetto/tracing.h"
#include "runtime-inl.h"
#include "runtime_callbacks.h"
#include "scoped_thread_state_change-inl.h"
#include "thread_list.h"
#include "well_known_classes.h"
#include "dex/descriptors_names.h"
// There are three threads involved in this:
// * listener thread: this is idle in the background when this plugin gets loaded, and waits
// for data on on g_signal_pipe_fds.
// * signal thread: an arbitrary thread that handles the signal and writes data to
// g_signal_pipe_fds.
// * perfetto producer thread: once the signal is received, the app forks. In the newly forked
// child, the Perfetto Client API spawns a thread to communicate with traced.
namespace perfetto_hprof {
constexpr int kJavaHeapprofdSignal = __SIGRTMIN + 6;
constexpr time_t kWatchdogTimeoutSec = 120;
// This needs to be lower than the maximum acceptable chunk size, because this
// is checked *before* writing another submessage. We conservatively assume
// submessages can be up to 100k here for a 500k chunk size.
// DropBox has a 500k chunk limit, and each chunk needs to parse as a proto.
constexpr uint32_t kPacketSizeThreshold = 400000;
constexpr char kByte[1] = {'x'};
static art::Mutex& GetStateMutex() {
static art::Mutex state_mutex("perfetto_hprof_state_mutex", art::LockLevel::kGenericBottomLock);
return state_mutex;
}
static art::ConditionVariable& GetStateCV() {
static art::ConditionVariable state_cv("perfetto_hprof_state_cv", GetStateMutex());
return state_cv;
}
static State g_state = State::kUninitialized;
// Pipe to signal from the signal handler into a worker thread that handles the
// dump requests.
int g_signal_pipe_fds[2];
static struct sigaction g_orig_act = {};
template <typename T>
uint64_t FindOrAppend(std::map<T, uint64_t>* m, const T& s) {
auto it = m->find(s);
if (it == m->end()) {
std::tie(it, std::ignore) = m->emplace(s, m->size());
}
return it->second;
}
void ArmWatchdogOrDie() {
timer_t timerid{};
struct sigevent sev {};
sev.sigev_notify = SIGEV_SIGNAL;
sev.sigev_signo = SIGKILL;
if (timer_create(CLOCK_MONOTONIC, &sev, &timerid) == -1) {
// This only gets called in the child, so we can fatal without impacting
// the app.
PLOG(FATAL) << "failed to create watchdog timer";
}
struct itimerspec its {};
its.it_value.tv_sec = kWatchdogTimeoutSec;
if (timer_settime(timerid, 0, &its, nullptr) == -1) {
// This only gets called in the child, so we can fatal without impacting
// the app.
PLOG(FATAL) << "failed to arm watchdog timer";
}
}
bool StartsWith(const std::string& str, const std::string& prefix) {
return str.compare(0, prefix.length(), prefix) == 0;
}
// Sample entries that match one of the following
// start with /system/
// start with /vendor/
// start with /data/app/
// contains "extracted in memory from Y", where Y matches any of the above
bool ShouldSampleSmapsEntry(const perfetto::profiling::SmapsEntry& e) {
if (StartsWith(e.pathname, "/system/") || StartsWith(e.pathname, "/vendor/") ||
StartsWith(e.pathname, "/data/app/")) {
return true;
}
if (StartsWith(e.pathname, "[anon:")) {
if (e.pathname.find("extracted in memory from /system/") != std::string::npos) {
return true;
}
if (e.pathname.find("extracted in memory from /vendor/") != std::string::npos) {
return true;
}
if (e.pathname.find("extracted in memory from /data/app/") != std::string::npos) {
return true;
}
}
return false;
}
bool CanConnectToSocket(const char* name) {
struct sockaddr_un addr = {};
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, name, sizeof(addr.sun_path) - 1);
int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
if (fd == -1) {
PLOG(ERROR) << "failed to create socket";
return false;
}
bool connected = connect(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) == 0;
close(fd);
return connected;
}
constexpr size_t kMaxCmdlineSize = 512;
class JavaHprofDataSource : public perfetto::DataSource<JavaHprofDataSource> {
public:
constexpr static perfetto::BufferExhaustedPolicy kBufferExhaustedPolicy =
perfetto::BufferExhaustedPolicy::kStall;
void OnSetup(const SetupArgs& args) override {
// This is on the heap as it triggers -Wframe-larger-than.
std::unique_ptr<perfetto::protos::pbzero::JavaHprofConfig::Decoder> cfg(
new perfetto::protos::pbzero::JavaHprofConfig::Decoder(
args.config->java_hprof_config_raw()));
if (args.config->enable_extra_guardrails() && !CanConnectToSocket("/dev/socket/heapprofd")) {
LOG(ERROR) << "rejecting extra guardrails";
enabled_ = false;
return;
}
dump_smaps_ = cfg->dump_smaps();
for (auto it = cfg->ignored_types(); it; ++it) {
std::string name = (*it).ToStdString();
ignored_types_.emplace_back(std::move(name));
}
uint64_t self_pid = static_cast<uint64_t>(getpid());
for (auto pid_it = cfg->pid(); pid_it; ++pid_it) {
if (*pid_it == self_pid) {
enabled_ = true;
return;
}
}
if (cfg->has_process_cmdline()) {
int fd = open("/proc/self/cmdline", O_RDONLY | O_CLOEXEC);
if (fd == -1) {
PLOG(ERROR) << "failed to open /proc/self/cmdline";
return;
}
char cmdline[kMaxCmdlineSize];
ssize_t rd = read(fd, cmdline, sizeof(cmdline) - 1);
if (rd == -1) {
PLOG(ERROR) << "failed to read /proc/self/cmdline";
}
close(fd);
if (rd == -1) {
return;
}
cmdline[rd] = '\0';
char* cmdline_ptr = cmdline;
ssize_t sz = perfetto::profiling::NormalizeCmdLine(&cmdline_ptr, static_cast<size_t>(rd + 1));
if (sz == -1) {
PLOG(ERROR) << "failed to normalize cmdline";
}
for (auto it = cfg->process_cmdline(); it; ++it) {
std::string other = (*it).ToStdString();
// Append \0 to make this a C string.
other.resize(other.size() + 1);
char* other_ptr = &(other[0]);
ssize_t other_sz = perfetto::profiling::NormalizeCmdLine(&other_ptr, other.size());
if (other_sz == -1) {
PLOG(ERROR) << "failed to normalize other cmdline";
continue;
}
if (sz == other_sz && strncmp(cmdline_ptr, other_ptr, static_cast<size_t>(sz)) == 0) {
enabled_ = true;
return;
}
}
}
}
bool dump_smaps() { return dump_smaps_; }
bool enabled() { return enabled_; }
void OnStart(const StartArgs&) override {
if (!enabled()) {
return;
}
art::MutexLock lk(art_thread(), GetStateMutex());
if (g_state == State::kWaitForStart) {
g_state = State::kStart;
GetStateCV().Broadcast(art_thread());
}
}
// This datasource can be used with a trace config with a short duration_ms
// but a long datasource_stop_timeout_ms. In that case, OnStop is called (in
// general) before the dump is done. In that case, we handle the stop
// asynchronously, and notify the tracing service once we are done.
// In case OnStop is called after the dump is done (but before the process)
// has exited, we just acknowledge the request.
void OnStop(const StopArgs& a) override {
art::MutexLock lk(art_thread(), finish_mutex_);
if (is_finished_) {
return;
}
is_stopped_ = true;
async_stop_ = std::move(a.HandleStopAsynchronously());
}
static art::Thread* art_thread() {
// TODO(fmayer): Attach the Perfetto producer thread to ART and give it a name. This is
// not trivial, we cannot just attach the first time this method is called, because
// AttachCurrentThread deadlocks with the ConditionVariable::Wait in WaitForDataSource.
//
// We should attach the thread as soon as the Client API spawns it, but that needs more
// complicated plumbing.
return nullptr;
}
std::vector<std::string> ignored_types() { return ignored_types_; }
void Finish() {
art::MutexLock lk(art_thread(), finish_mutex_);
if (is_stopped_) {
async_stop_();
} else {
is_finished_ = true;
}
}
private:
bool enabled_ = false;
bool dump_smaps_ = false;
std::vector<std::string> ignored_types_;
static art::Thread* self_;
art::Mutex finish_mutex_{"perfetto_hprof_ds_mutex", art::LockLevel::kGenericBottomLock};
bool is_finished_ = false;
bool is_stopped_ = false;
std::function<void()> async_stop_;
};
art::Thread* JavaHprofDataSource::self_ = nullptr;
void WaitForDataSource(art::Thread* self) {
perfetto::TracingInitArgs args;
args.backends = perfetto::BackendType::kSystemBackend;
perfetto::Tracing::Initialize(args);
perfetto::DataSourceDescriptor dsd;
dsd.set_name("android.java_hprof");
dsd.set_will_notify_on_stop(true);
JavaHprofDataSource::Register(dsd);
LOG(INFO) << "waiting for data source";
art::MutexLock lk(self, GetStateMutex());
while (g_state != State::kStart) {
GetStateCV().Wait(self);
}
}
class Writer {
public:
Writer(pid_t parent_pid, JavaHprofDataSource::TraceContext* ctx, uint64_t timestamp)
: parent_pid_(parent_pid), ctx_(ctx), timestamp_(timestamp),
last_written_(ctx_->written()) {}
// Return whether the next call to GetHeapGraph will create a new TracePacket.
bool will_create_new_packet() {
return !heap_graph_ || ctx_->written() - last_written_ > kPacketSizeThreshold;
}
perfetto::protos::pbzero::HeapGraph* GetHeapGraph() {
if (will_create_new_packet()) {
CreateNewHeapGraph();
}
return heap_graph_;
}
void CreateNewHeapGraph() {
if (heap_graph_) {
heap_graph_->set_continued(true);
}
Finalize();
uint64_t written = ctx_->written();
trace_packet_ = ctx_->NewTracePacket();
trace_packet_->set_timestamp(timestamp_);
heap_graph_ = trace_packet_->set_heap_graph();
heap_graph_->set_pid(parent_pid_);
heap_graph_->set_index(index_++);
last_written_ = written;
}
void Finalize() {
if (trace_packet_) {
trace_packet_->Finalize();
}
heap_graph_ = nullptr;
}
~Writer() { Finalize(); }
private:
const pid_t parent_pid_;
JavaHprofDataSource::TraceContext* const ctx_;
const uint64_t timestamp_;
uint64_t last_written_ = 0;
perfetto::DataSource<JavaHprofDataSource>::TraceContext::TracePacketHandle
trace_packet_;
perfetto::protos::pbzero::HeapGraph* heap_graph_ = nullptr;
uint64_t index_ = 0;
};
class ReferredObjectsFinder {
public:
explicit ReferredObjectsFinder(
std::vector<std::pair<std::string, art::mirror::Object*>>* referred_objects,
art::mirror::Object** min_nonnull_ptr)
: referred_objects_(referred_objects), min_nonnull_ptr_(min_nonnull_ptr) {}
// For art::mirror::Object::VisitReferences.
void operator()(art::ObjPtr<art::mirror::Object> obj, art::MemberOffset offset,
bool is_static) const
REQUIRES_SHARED(art::Locks::mutator_lock_) {
if (offset.Uint32Value() == art::mirror::Object::ClassOffset().Uint32Value()) {
// Skip shadow$klass pointer.
return;
}
art::mirror::Object* ref = obj->GetFieldObject<art::mirror::Object>(offset);
art::ArtField* field;
if (is_static) {
field = art::ArtField::FindStaticFieldWithOffset(obj->AsClass(), offset.Uint32Value());
} else {
field = art::ArtField::FindInstanceFieldWithOffset(obj->GetClass(), offset.Uint32Value());
}
std::string field_name = "";
if (field != nullptr) {
field_name = field->PrettyField(/*with_type=*/true);
}
referred_objects_->emplace_back(std::move(field_name), ref);
if (!*min_nonnull_ptr_ || (ref && *min_nonnull_ptr_ > ref)) {
*min_nonnull_ptr_ = ref;
}
}
void VisitRootIfNonNull(art::mirror::CompressedReference<art::mirror::Object>* root
ATTRIBUTE_UNUSED) const {}
void VisitRoot(art::mirror::CompressedReference<art::mirror::Object>* root
ATTRIBUTE_UNUSED) const {}
private:
// We can use a raw Object* pointer here, because there are no concurrent GC threads after the
// fork.
std::vector<std::pair<std::string, art::mirror::Object*>>* referred_objects_;
art::mirror::Object** min_nonnull_ptr_;
};
class RootFinder : public art::SingleRootVisitor {
public:
explicit RootFinder(
std::map<art::RootType, std::vector<art::mirror::Object*>>* root_objects)
: root_objects_(root_objects) {}
void VisitRoot(art::mirror::Object* root, const art::RootInfo& info) override {
(*root_objects_)[info.GetType()].emplace_back(root);
}
private:
// We can use a raw Object* pointer here, because there are no concurrent GC threads after the
// fork.
std::map<art::RootType, std::vector<art::mirror::Object*>>* root_objects_;
};
perfetto::protos::pbzero::HeapGraphRoot::Type ToProtoType(art::RootType art_type) {
using perfetto::protos::pbzero::HeapGraphRoot;
switch (art_type) {
case art::kRootUnknown:
return HeapGraphRoot::ROOT_UNKNOWN;
case art::kRootJNIGlobal:
return HeapGraphRoot::ROOT_JNI_GLOBAL;
case art::kRootJNILocal:
return HeapGraphRoot::ROOT_JNI_LOCAL;
case art::kRootJavaFrame:
return HeapGraphRoot::ROOT_JAVA_FRAME;
case art::kRootNativeStack:
return HeapGraphRoot::ROOT_NATIVE_STACK;
case art::kRootStickyClass:
return HeapGraphRoot::ROOT_STICKY_CLASS;
case art::kRootThreadBlock:
return HeapGraphRoot::ROOT_THREAD_BLOCK;
case art::kRootMonitorUsed:
return HeapGraphRoot::ROOT_MONITOR_USED;
case art::kRootThreadObject:
return HeapGraphRoot::ROOT_THREAD_OBJECT;
case art::kRootInternedString:
return HeapGraphRoot::ROOT_INTERNED_STRING;
case art::kRootFinalizing:
return HeapGraphRoot::ROOT_FINALIZING;
case art::kRootDebugger:
return HeapGraphRoot::ROOT_DEBUGGER;
case art::kRootReferenceCleanup:
return HeapGraphRoot::ROOT_REFERENCE_CLEANUP;
case art::kRootVMInternal:
return HeapGraphRoot::ROOT_VM_INTERNAL;
case art::kRootJNIMonitor:
return HeapGraphRoot::ROOT_JNI_MONITOR;
}
}
perfetto::protos::pbzero::HeapGraphType::Kind ProtoClassKind(uint32_t class_flags) {
using perfetto::protos::pbzero::HeapGraphType;
switch (class_flags) {
case art::mirror::kClassFlagNormal:
return HeapGraphType::KIND_NORMAL;
case art::mirror::kClassFlagNoReferenceFields:
return HeapGraphType::KIND_NOREFERENCES;
case art::mirror::kClassFlagString | art::mirror::kClassFlagNoReferenceFields:
return HeapGraphType::KIND_STRING;
case art::mirror::kClassFlagObjectArray:
return HeapGraphType::KIND_ARRAY;
case art::mirror::kClassFlagClass:
return HeapGraphType::KIND_CLASS;
case art::mirror::kClassFlagClassLoader:
return HeapGraphType::KIND_CLASSLOADER;
case art::mirror::kClassFlagDexCache:
return HeapGraphType::KIND_DEXCACHE;
case art::mirror::kClassFlagSoftReference:
return HeapGraphType::KIND_SOFT_REFERENCE;
case art::mirror::kClassFlagWeakReference:
return HeapGraphType::KIND_WEAK_REFERENCE;
case art::mirror::kClassFlagFinalizerReference:
return HeapGraphType::KIND_FINALIZER_REFERENCE;
case art::mirror::kClassFlagPhantomReference:
return HeapGraphType::KIND_PHANTOM_REFERENCE;
default:
return HeapGraphType::KIND_UNKNOWN;
}
}
std::string PrettyType(art::mirror::Class* klass) NO_THREAD_SAFETY_ANALYSIS {
if (klass == nullptr) {
return "(raw)";
}
std::string temp;
std::string result(art::PrettyDescriptor(klass->GetDescriptor(&temp)));
return result;
}
void DumpSmaps(JavaHprofDataSource::TraceContext* ctx) {
FILE* smaps = fopen("/proc/self/smaps", "r");
if (smaps != nullptr) {
auto trace_packet = ctx->NewTracePacket();
auto* smaps_packet = trace_packet->set_smaps_packet();
smaps_packet->set_pid(getpid());
perfetto::profiling::ParseSmaps(smaps,
[&smaps_packet](const perfetto::profiling::SmapsEntry& e) {
if (ShouldSampleSmapsEntry(e)) {
auto* smaps_entry = smaps_packet->add_entries();
smaps_entry->set_path(e.pathname);
smaps_entry->set_size_kb(e.size_kb);
smaps_entry->set_private_dirty_kb(e.private_dirty_kb);
smaps_entry->set_swap_kb(e.swap_kb);
}
});
fclose(smaps);
} else {
PLOG(ERROR) << "failed to open smaps";
}
}
uint64_t GetObjectId(const art::mirror::Object* obj) {
return reinterpret_cast<uint64_t>(obj) / std::alignment_of<art::mirror::Object>::value;
}
template <typename F>
void ForInstanceReferenceField(art::mirror::Class* klass, F fn) NO_THREAD_SAFETY_ANALYSIS {
for (art::ArtField& af : klass->GetIFields()) {
if (af.IsPrimitiveType() ||
af.GetOffset().Uint32Value() == art::mirror::Object::ClassOffset().Uint32Value()) {
continue;
}
fn(af.GetOffset());
}
}
bool IsIgnored(const std::vector<std::string>& ignored_types,
art::mirror::Object* obj) NO_THREAD_SAFETY_ANALYSIS {
if (obj->IsClass()) {
return false;
}
art::mirror::Class* klass = obj->GetClass();
return std::find(ignored_types.begin(), ignored_types.end(), PrettyType(klass)) !=
ignored_types.end();
}
size_t EncodedSize(uint64_t n) {
if (n == 0) return 1;
return 1 + static_cast<size_t>(art::MostSignificantBit(n)) / 7;
}
void DumpPerfetto(art::Thread* self) {
pid_t parent_pid = getpid();
LOG(INFO) << "preparing to dump heap for " << parent_pid;
// Need to take a heap dump while GC isn't running. See the comment in
// Heap::VisitObjects(). Also we need the critical section to avoid visiting
// the same object twice. See b/34967844.
//
// We need to do this before the fork, because otherwise it can deadlock
// waiting for the GC, as all other threads get terminated by the clone, but
// their locks are not released.
art::gc::ScopedGCCriticalSection gcs(self, art::gc::kGcCauseHprof,
art::gc::kCollectorTypeHprof);
art::ScopedSuspendAll ssa(__FUNCTION__, /* long_suspend=*/ true);
pid_t pid = fork();
if (pid == -1) {
// Fork error.
PLOG(ERROR) << "fork";
return;
}
if (pid != 0) {
// Parent
int stat_loc;
for (;;) {
if (waitpid(pid, &stat_loc, 0) != -1 || errno != EINTR) {
break;
}
}
return;
}
// The following code is only executed by the child of the original process.
//
// Daemon creates a new process that is the grand-child of the original process, and exits.
if (daemon(0, 0) == -1) {
PLOG(FATAL) << "daemon";
}
// The following code is only executed by the grand-child of the original process.
// Make sure that this is the first thing we do after forking, so if anything
// below hangs, the fork will go away from the watchdog.
ArmWatchdogOrDie();
struct timespec ts = {};
if (clock_gettime(CLOCK_BOOTTIME, &ts) != 0) {
LOG(FATAL) << "Failed to get boottime.";
}
uint64_t timestamp = ts.tv_sec * 1000000000LL + ts.tv_nsec;
WaitForDataSource(self);
JavaHprofDataSource::Trace(
[parent_pid, timestamp](JavaHprofDataSource::TraceContext ctx)
NO_THREAD_SAFETY_ANALYSIS {
bool dump_smaps;
std::vector<std::string> ignored_types;
{
auto ds = ctx.GetDataSourceLocked();
if (!ds || !ds->enabled()) {
if (ds) ds->Finish();
LOG(INFO) << "skipping irrelevant data source.";
return;
}
dump_smaps = ds->dump_smaps();
ignored_types = ds->ignored_types();
}
LOG(INFO) << "dumping heap for " << parent_pid;
if (dump_smaps) {
DumpSmaps(&ctx);
}
Writer writer(parent_pid, &ctx, timestamp);
// Make sure that intern ID 0 (default proto value for a uint64_t) always maps to ""
// (default proto value for a string).
std::map<std::string, uint64_t> interned_fields{{"", 0}};
std::map<std::string, uint64_t> interned_locations{{"", 0}};
std::map<uintptr_t, uint64_t> interned_classes{{0, 0}};
std::map<art::RootType, std::vector<art::mirror::Object*>> root_objects;
RootFinder rcf(&root_objects);
art::Runtime::Current()->VisitRoots(&rcf);
std::unique_ptr<protozero::PackedVarInt> object_ids(
new protozero::PackedVarInt);
for (const auto& p : root_objects) {
const art::RootType root_type = p.first;
const std::vector<art::mirror::Object*>& children = p.second;
perfetto::protos::pbzero::HeapGraphRoot* root_proto =
writer.GetHeapGraph()->add_roots();
root_proto->set_root_type(ToProtoType(root_type));
for (art::mirror::Object* obj : children) {
if (writer.will_create_new_packet()) {
root_proto->set_object_ids(*object_ids);
object_ids->Reset();
root_proto = writer.GetHeapGraph()->add_roots();
root_proto->set_root_type(ToProtoType(root_type));
}
object_ids->Append(GetObjectId(obj));
}
root_proto->set_object_ids(*object_ids);
object_ids->Reset();
}
std::unique_ptr<protozero::PackedVarInt> reference_field_ids(
new protozero::PackedVarInt);
std::unique_ptr<protozero::PackedVarInt> reference_object_ids(
new protozero::PackedVarInt);
art::Runtime::Current()->GetHeap()->VisitObjectsPaused(
[&writer, &interned_fields, &interned_locations, &reference_field_ids,
&reference_object_ids, &interned_classes, &ignored_types](
art::mirror::Object* obj) REQUIRES_SHARED(art::Locks::mutator_lock_) {
if (obj->IsClass()) {
art::mirror::Class* klass = obj->AsClass().Ptr();
perfetto::protos::pbzero::HeapGraphType* type_proto =
writer.GetHeapGraph()->add_types();
type_proto->set_id(FindOrAppend(&interned_classes,
reinterpret_cast<uintptr_t>(klass)));
type_proto->set_class_name(PrettyType(klass));
type_proto->set_location_id(FindOrAppend(&interned_locations,
klass->GetLocation()));
type_proto->set_object_size(klass->GetObjectSize());
type_proto->set_kind(ProtoClassKind(klass->GetClassFlags()));
type_proto->set_classloader_id(GetObjectId(klass->GetClassLoader().Ptr()));
if (klass->GetSuperClass().Ptr()) {
type_proto->set_superclass_id(
FindOrAppend(&interned_classes,
reinterpret_cast<uintptr_t>(klass->GetSuperClass().Ptr())));
}
ForInstanceReferenceField(
klass, [klass, &reference_field_ids, &interned_fields](
art::MemberOffset offset) NO_THREAD_SAFETY_ANALYSIS {
auto art_field = art::ArtField::FindInstanceFieldWithOffset(
klass, offset.Uint32Value());
reference_field_ids->Append(
FindOrAppend(&interned_fields, art_field->PrettyField(true)));
});
type_proto->set_reference_field_id(*reference_field_ids);
reference_field_ids->Reset();
}
art::mirror::Class* klass = obj->GetClass();
uintptr_t class_ptr = reinterpret_cast<uintptr_t>(klass);
// We need to synethesize a new type for Class<Foo>, which does not exist
// in the runtime. Otherwise, all the static members of all classes would be
// attributed to java.lang.Class.
if (klass->IsClassClass()) {
CHECK(obj->IsClass());
perfetto::protos::pbzero::HeapGraphType* type_proto =
writer.GetHeapGraph()->add_types();
// All pointers are at least multiples of two, so this way we can make sure
// we are not colliding with a real class.
class_ptr = reinterpret_cast<uintptr_t>(obj) | 1;
auto class_id = FindOrAppend(&interned_classes, class_ptr);
type_proto->set_id(class_id);
type_proto->set_class_name(obj->PrettyTypeOf());
type_proto->set_location_id(FindOrAppend(&interned_locations,
obj->AsClass()->GetLocation()));
}
if (IsIgnored(ignored_types, obj)) {
return;
}
auto class_id = FindOrAppend(&interned_classes, class_ptr);
perfetto::protos::pbzero::HeapGraphObject* object_proto =
writer.GetHeapGraph()->add_objects();
object_proto->set_id(GetObjectId(obj));
object_proto->set_type_id(class_id);
// Arrays / strings are magic and have an instance dependent size.
if (obj->SizeOf() != klass->GetObjectSize())
object_proto->set_self_size(obj->SizeOf());
std::vector<std::pair<std::string, art::mirror::Object*>>
referred_objects;
art::mirror::Object* min_nonnull_ptr = nullptr;
ReferredObjectsFinder objf(&referred_objects, &min_nonnull_ptr);
const bool emit_field_ids =
klass->GetClassFlags() != art::mirror::kClassFlagObjectArray &&
klass->GetClassFlags() != art::mirror::kClassFlagNormal;
if (klass->GetClassFlags() != art::mirror::kClassFlagNormal) {
obj->VisitReferences(objf, art::VoidFunctor());
} else {
for (art::mirror::Class* cls = klass; cls != nullptr;
cls = cls->GetSuperClass().Ptr()) {
ForInstanceReferenceField(
cls, [obj, objf](art::MemberOffset offset) NO_THREAD_SAFETY_ANALYSIS {
objf(art::ObjPtr<art::mirror::Object>(obj), offset,
/*is_static=*/false);
});
}
}
uint64_t bytes_saved = 0;
uint64_t base_obj_id = GetObjectId(min_nonnull_ptr);
if (base_obj_id) {
// We need to decrement the base for object ids so that we can tell apart
// null references.
base_obj_id--;
}
if (base_obj_id) {
for (auto& p : referred_objects) {
art::mirror::Object*& referred_obj = p.second;
if (!referred_obj || IsIgnored(ignored_types, referred_obj)) {
referred_obj = nullptr;
continue;
}
uint64_t referred_obj_id = GetObjectId(referred_obj);
bytes_saved +=
EncodedSize(referred_obj_id) - EncodedSize(referred_obj_id - base_obj_id);
}
}
// +1 for storing the field id.
if (bytes_saved <= EncodedSize(base_obj_id) + 1) {
// Subtracting the base ptr gains fewer bytes than it takes to store it.
base_obj_id = 0;
}
for (auto& p : referred_objects) {
const std::string& field_name = p.first;
art::mirror::Object* referred_obj = p.second;
if (emit_field_ids) {
reference_field_ids->Append(FindOrAppend(&interned_fields, field_name));
}
uint64_t referred_obj_id = GetObjectId(referred_obj);
if (referred_obj_id) {
referred_obj_id -= base_obj_id;
}
reference_object_ids->Append(referred_obj_id);
}
if (emit_field_ids) {
object_proto->set_reference_field_id(*reference_field_ids);
reference_field_ids->Reset();
}
if (base_obj_id) {
object_proto->set_reference_field_id_base(base_obj_id);
}
object_proto->set_reference_object_id(*reference_object_ids);
reference_object_ids->Reset();
});
for (const auto& p : interned_fields) {
const std::string& str = p.first;
uint64_t id = p.second;
perfetto::protos::pbzero::InternedString* field_proto =
writer.GetHeapGraph()->add_field_names();
field_proto->set_iid(id);
field_proto->set_str(
reinterpret_cast<const uint8_t*>(str.c_str()), str.size());
}
for (const auto& p : interned_locations) {
const std::string& str = p.first;
uint64_t id = p.second;
perfetto::protos::pbzero::InternedString* location_proto =
writer.GetHeapGraph()->add_location_names();
location_proto->set_iid(id);
location_proto->set_str(reinterpret_cast<const uint8_t*>(str.c_str()),
str.size());
}
writer.Finalize();
ctx.Flush([] {
{
art::MutexLock lk(JavaHprofDataSource::art_thread(), GetStateMutex());
g_state = State::kEnd;
GetStateCV().Broadcast(JavaHprofDataSource::art_thread());
}
});
// Wait for the Flush that will happen on the Perfetto thread.
{
art::MutexLock lk(JavaHprofDataSource::art_thread(), GetStateMutex());
while (g_state != State::kEnd) {
GetStateCV().Wait(JavaHprofDataSource::art_thread());
}
}
{
auto ds = ctx.GetDataSourceLocked();
if (ds) {
ds->Finish();
} else {
LOG(ERROR) << "datasource timed out (duration_ms + datasource_stop_timeout_ms) "
"before dump finished";
}
}
});
LOG(INFO) << "finished dumping heap for " << parent_pid;
// Prevent the atexit handlers to run. We do not want to call cleanup
// functions the parent process has registered.
_exit(0);
}
// The plugin initialization function.
extern "C" bool ArtPlugin_Initialize() {
if (art::Runtime::Current() == nullptr) {
return false;
}
art::Thread* self = art::Thread::Current();
{
art::MutexLock lk(self, GetStateMutex());
if (g_state != State::kUninitialized) {
LOG(ERROR) << "perfetto_hprof already initialized. state: " << g_state;
return false;
}
g_state = State::kWaitForListener;
}
if (pipe2(g_signal_pipe_fds, O_CLOEXEC) == -1) {
PLOG(ERROR) << "Failed to pipe";
return false;
}
struct sigaction act = {};
act.sa_flags = SA_SIGINFO | SA_RESTART;
act.sa_sigaction = [](int, siginfo_t*, void*) {
if (write(g_signal_pipe_fds[1], kByte, sizeof(kByte)) == -1) {
PLOG(ERROR) << "Failed to trigger heap dump";
}
};
// TODO(fmayer): We can probably use the SignalCatcher thread here to not
// have an idle thread.
if (sigaction(kJavaHeapprofdSignal, &act, &g_orig_act) != 0) {
close(g_signal_pipe_fds[0]);
close(g_signal_pipe_fds[1]);
PLOG(ERROR) << "Failed to sigaction";
return false;
}
std::thread th([] {
art::Runtime* runtime = art::Runtime::Current();
if (!runtime) {
LOG(FATAL_WITHOUT_ABORT) << "no runtime in perfetto_hprof_listener";
return;
}
if (!runtime->AttachCurrentThread("perfetto_hprof_listener", /*as_daemon=*/ true,
runtime->GetSystemThreadGroup(), /*create_peer=*/ false)) {
LOG(ERROR) << "failed to attach thread.";
{
art::MutexLock lk(nullptr, GetStateMutex());
g_state = State::kUninitialized;
GetStateCV().Broadcast(nullptr);
}
return;
}
art::Thread* self = art::Thread::Current();
if (!self) {
LOG(FATAL_WITHOUT_ABORT) << "no thread in perfetto_hprof_listener";
return;
}
{
art::MutexLock lk(self, GetStateMutex());
if (g_state == State::kWaitForListener) {
g_state = State::kWaitForStart;
GetStateCV().Broadcast(self);
}
}
char buf[1];
for (;;) {
int res;
do {
res = read(g_signal_pipe_fds[0], buf, sizeof(buf));
} while (res == -1 && errno == EINTR);
if (res <= 0) {
if (res == -1) {
PLOG(ERROR) << "failed to read";
}
close(g_signal_pipe_fds[0]);
return;
}
perfetto_hprof::DumpPerfetto(self);
}
});
th.detach();
return true;
}
extern "C" bool ArtPlugin_Deinitialize() {
if (sigaction(kJavaHeapprofdSignal, &g_orig_act, nullptr) != 0) {
PLOG(ERROR) << "failed to reset signal handler";
// We cannot close the pipe if the signal handler wasn't unregistered,
// to avoid receiving SIGPIPE.
return false;
}
close(g_signal_pipe_fds[1]);
art::Thread* self = art::Thread::Current();
art::MutexLock lk(self, GetStateMutex());
// Wait until after the thread was registered to the runtime. This is so
// we do not attempt to register it with the runtime after it had been torn
// down (ArtPlugin_Deinitialize gets called in the Runtime dtor).
while (g_state == State::kWaitForListener) {
GetStateCV().Wait(art::Thread::Current());
}
g_state = State::kUninitialized;
GetStateCV().Broadcast(self);
return true;
}
} // namespace perfetto_hprof
namespace perfetto {
PERFETTO_DEFINE_DATA_SOURCE_STATIC_MEMBERS(perfetto_hprof::JavaHprofDataSource);
}