/*
|
* Copyright (C) 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 "debugger_interface.h"
|
|
#include <android-base/logging.h>
|
|
#include "base/array_ref.h"
|
#include "base/logging.h"
|
#include "base/mutex.h"
|
#include "base/time_utils.h"
|
#include "base/utils.h"
|
#include "dex/dex_file.h"
|
#include "thread-current-inl.h"
|
#include "thread.h"
|
|
#include <atomic>
|
#include <cstddef>
|
#include <deque>
|
#include <map>
|
|
//
|
// Debug interface for native tools (gdb, lldb, libunwind, simpleperf).
|
//
|
// See http://sourceware.org/gdb/onlinedocs/gdb/Declarations.html
|
//
|
// There are two ways for native tools to access the debug data safely:
|
//
|
// 1) Synchronously, by setting a breakpoint in the __*_debug_register_code
|
// method, which is called after every modification of the linked list.
|
// GDB does this, but it is complex to set up and it stops the process.
|
//
|
// 2) Asynchronously, by monitoring the action_seqlock_.
|
// * The seqlock is a monotonically increasing counter which is incremented
|
// before and after every modification of the linked list. Odd value of
|
// the counter means the linked list is being modified (it is locked).
|
// * The tool should read the value of the seqlock both before and after
|
// copying the linked list. If the seqlock values match and are even,
|
// the copy is consistent. Otherwise, the reader should try again.
|
// * Note that using the data directly while is it being modified
|
// might crash the tool. Therefore, the only safe way is to make
|
// a copy and use the copy only after the seqlock has been checked.
|
// * Note that the process might even free and munmap the data while
|
// it is being copied, therefore the reader should either handle
|
// SEGV or use OS calls to read the memory (e.g. process_vm_readv).
|
// * The seqlock can be used to determine the number of modifications of
|
// the linked list, which can be used to intelligently cache the data.
|
// Note the possible overflow of the seqlock. It is intentionally
|
// 32-bit, since 64-bit atomics can be tricky on some architectures.
|
// * The timestamps on the entry record the time when the entry was
|
// created which is relevant if the unwinding is not live and is
|
// postponed until much later. All timestamps must be unique.
|
// * Memory barriers are used to make it possible to reason about
|
// the data even when it is being modified (e.g. the process crashed
|
// while that data was locked, and thus it will be never unlocked).
|
// * In particular, it should be possible to:
|
// 1) read the seqlock and then the linked list head pointer.
|
// 2) copy the entry and check that seqlock has not changed.
|
// 3) copy the symfile and check that seqlock has not changed.
|
// 4) go back to step 2 using the next pointer (if non-null).
|
// This safely creates copy of all symfiles, although other data
|
// might be inconsistent/unusable (e.g. prev_, action_timestamp_).
|
// * For full conformance with the C++ memory model, all seqlock
|
// protected accesses should be atomic. We currently do this in the
|
// more critical cases. The rest will have to be fixed before
|
// attempting to run TSAN on this code.
|
//
|
|
namespace art {
|
|
static Mutex g_jit_debug_lock("JIT native debug entries", kNativeDebugInterfaceLock);
|
static Mutex g_dex_debug_lock("DEX native debug entries", kNativeDebugInterfaceLock);
|
|
extern "C" {
|
enum JITAction {
|
JIT_NOACTION = 0,
|
JIT_REGISTER_FN,
|
JIT_UNREGISTER_FN
|
};
|
|
struct JITCodeEntry {
|
// Atomic to ensure the reader can always iterate over the linked list
|
// (e.g. the process could crash in the middle of writing this field).
|
std::atomic<JITCodeEntry*> next_;
|
// Non-atomic. The reader should not use it. It is only used for deletion.
|
JITCodeEntry* prev_;
|
const uint8_t* symfile_addr_;
|
uint64_t symfile_size_; // Beware of the offset (12 on x86; but 16 on ARM32).
|
|
// Android-specific fields:
|
uint64_t register_timestamp_; // CLOCK_MONOTONIC time of entry registration.
|
};
|
|
struct JITDescriptor {
|
uint32_t version_ = 1; // NB: GDB supports only version 1.
|
uint32_t action_flag_ = JIT_NOACTION; // One of the JITAction enum values.
|
JITCodeEntry* relevant_entry_ = nullptr; // The entry affected by the action.
|
std::atomic<JITCodeEntry*> head_{nullptr}; // Head of link list of all entries.
|
|
// Android-specific fields:
|
uint8_t magic_[8] = {'A', 'n', 'd', 'r', 'o', 'i', 'd', '1'};
|
uint32_t flags_ = 0; // Reserved for future use. Must be 0.
|
uint32_t sizeof_descriptor = sizeof(JITDescriptor);
|
uint32_t sizeof_entry = sizeof(JITCodeEntry);
|
std::atomic_uint32_t action_seqlock_{0}; // Incremented before and after any modification.
|
uint64_t action_timestamp_ = 1; // CLOCK_MONOTONIC time of last action.
|
};
|
|
// Check that std::atomic has the expected layout.
|
static_assert(alignof(std::atomic_uint32_t) == alignof(uint32_t), "Weird alignment");
|
static_assert(sizeof(std::atomic_uint32_t) == sizeof(uint32_t), "Weird size");
|
static_assert(alignof(std::atomic<void*>) == alignof(void*), "Weird alignment");
|
static_assert(sizeof(std::atomic<void*>) == sizeof(void*), "Weird size");
|
|
// GDB may set breakpoint here. We must ensure it is not removed or deduplicated.
|
void __attribute__((noinline)) __jit_debug_register_code() {
|
__asm__("");
|
}
|
|
// Alternatively, native tools may overwrite this field to execute custom handler.
|
void (*__jit_debug_register_code_ptr)() = __jit_debug_register_code;
|
|
// The root data structure describing of all JITed methods.
|
JITDescriptor __jit_debug_descriptor GUARDED_BY(g_jit_debug_lock) {};
|
|
// The following globals mirror the ones above, but are used to register dex files.
|
void __attribute__((noinline)) __dex_debug_register_code() {
|
__asm__("");
|
}
|
void (*__dex_debug_register_code_ptr)() = __dex_debug_register_code;
|
JITDescriptor __dex_debug_descriptor GUARDED_BY(g_dex_debug_lock) {};
|
}
|
|
// Mark the descriptor as "locked", so native tools know the data is being modified.
|
static void ActionSeqlock(JITDescriptor& descriptor) {
|
DCHECK_EQ(descriptor.action_seqlock_.load() & 1, 0u) << "Already locked";
|
descriptor.action_seqlock_.fetch_add(1, std::memory_order_relaxed);
|
// Ensure that any writes within the locked section cannot be reordered before the increment.
|
std::atomic_thread_fence(std::memory_order_release);
|
}
|
|
// Mark the descriptor as "unlocked", so native tools know the data is safe to read.
|
static void ActionSequnlock(JITDescriptor& descriptor) {
|
DCHECK_EQ(descriptor.action_seqlock_.load() & 1, 1u) << "Already unlocked";
|
// Ensure that any writes within the locked section cannot be reordered after the increment.
|
std::atomic_thread_fence(std::memory_order_release);
|
descriptor.action_seqlock_.fetch_add(1, std::memory_order_relaxed);
|
}
|
|
static JITCodeEntry* CreateJITCodeEntryInternal(
|
JITDescriptor& descriptor,
|
void (*register_code_ptr)(),
|
ArrayRef<const uint8_t> symfile,
|
bool copy_symfile) {
|
// Make a copy of the buffer to shrink it and to pass ownership to JITCodeEntry.
|
if (copy_symfile) {
|
uint8_t* copy = new uint8_t[symfile.size()];
|
CHECK(copy != nullptr);
|
memcpy(copy, symfile.data(), symfile.size());
|
symfile = ArrayRef<const uint8_t>(copy, symfile.size());
|
}
|
|
// Ensure the timestamp is monotonically increasing even in presence of low
|
// granularity system timer. This ensures each entry has unique timestamp.
|
uint64_t timestamp = std::max(descriptor.action_timestamp_ + 1, NanoTime());
|
|
JITCodeEntry* head = descriptor.head_.load(std::memory_order_relaxed);
|
JITCodeEntry* entry = new JITCodeEntry;
|
CHECK(entry != nullptr);
|
entry->symfile_addr_ = symfile.data();
|
entry->symfile_size_ = symfile.size();
|
entry->prev_ = nullptr;
|
entry->next_.store(head, std::memory_order_relaxed);
|
entry->register_timestamp_ = timestamp;
|
|
// We are going to modify the linked list, so take the seqlock.
|
ActionSeqlock(descriptor);
|
if (head != nullptr) {
|
head->prev_ = entry;
|
}
|
descriptor.head_.store(entry, std::memory_order_relaxed);
|
descriptor.relevant_entry_ = entry;
|
descriptor.action_flag_ = JIT_REGISTER_FN;
|
descriptor.action_timestamp_ = timestamp;
|
ActionSequnlock(descriptor);
|
|
(*register_code_ptr)();
|
return entry;
|
}
|
|
static void DeleteJITCodeEntryInternal(
|
JITDescriptor& descriptor,
|
void (*register_code_ptr)(),
|
JITCodeEntry* entry,
|
bool free_symfile) {
|
CHECK(entry != nullptr);
|
const uint8_t* symfile = entry->symfile_addr_;
|
|
// Ensure the timestamp is monotonically increasing even in presence of low
|
// granularity system timer. This ensures each entry has unique timestamp.
|
uint64_t timestamp = std::max(descriptor.action_timestamp_ + 1, NanoTime());
|
|
// We are going to modify the linked list, so take the seqlock.
|
ActionSeqlock(descriptor);
|
JITCodeEntry* next = entry->next_.load(std::memory_order_relaxed);
|
if (entry->prev_ != nullptr) {
|
entry->prev_->next_.store(next, std::memory_order_relaxed);
|
} else {
|
descriptor.head_.store(next, std::memory_order_relaxed);
|
}
|
if (next != nullptr) {
|
next->prev_ = entry->prev_;
|
}
|
descriptor.relevant_entry_ = entry;
|
descriptor.action_flag_ = JIT_UNREGISTER_FN;
|
descriptor.action_timestamp_ = timestamp;
|
ActionSequnlock(descriptor);
|
|
(*register_code_ptr)();
|
|
// Ensure that clear below can not be reordered above the unlock above.
|
std::atomic_thread_fence(std::memory_order_release);
|
|
// Aggressively clear the entry as an extra check of the synchronisation.
|
memset(entry, 0, sizeof(*entry));
|
|
delete entry;
|
if (free_symfile) {
|
delete[] symfile;
|
}
|
}
|
|
static std::map<const DexFile*, JITCodeEntry*> g_dex_debug_entries GUARDED_BY(g_dex_debug_lock);
|
|
void AddNativeDebugInfoForDex(Thread* self, const DexFile* dexfile) {
|
MutexLock mu(self, g_dex_debug_lock);
|
DCHECK(dexfile != nullptr);
|
// This is just defensive check. The class linker should not register the dex file twice.
|
if (g_dex_debug_entries.count(dexfile) == 0) {
|
const ArrayRef<const uint8_t> symfile(dexfile->Begin(), dexfile->Size());
|
JITCodeEntry* entry = CreateJITCodeEntryInternal(__dex_debug_descriptor,
|
__dex_debug_register_code_ptr,
|
symfile,
|
/*copy_symfile=*/ false);
|
g_dex_debug_entries.emplace(dexfile, entry);
|
}
|
}
|
|
void RemoveNativeDebugInfoForDex(Thread* self, const DexFile* dexfile) {
|
MutexLock mu(self, g_dex_debug_lock);
|
auto it = g_dex_debug_entries.find(dexfile);
|
// We register dex files in the class linker and free them in DexFile_closeDexFile, but
|
// there might be cases where we load the dex file without using it in the class linker.
|
if (it != g_dex_debug_entries.end()) {
|
DeleteJITCodeEntryInternal(__dex_debug_descriptor,
|
__dex_debug_register_code_ptr,
|
/*entry=*/ it->second,
|
/*free_symfile=*/ false);
|
g_dex_debug_entries.erase(it);
|
}
|
}
|
|
// Mapping from handle to entry. Used to manage life-time of the entries.
|
static std::multimap<const void*, JITCodeEntry*> g_jit_debug_entries GUARDED_BY(g_jit_debug_lock);
|
|
// Number of entries added since last packing. Used to pack entries in bulk.
|
static size_t g_jit_num_unpacked_entries GUARDED_BY(g_jit_debug_lock) = 0;
|
|
// We postpone removal so that it is done in bulk.
|
static std::deque<const void*> g_jit_removed_entries GUARDED_BY(g_jit_debug_lock);
|
|
// Split the JIT code cache into groups of fixed size and create singe JITCodeEntry for each group.
|
// The start address of method's code determines which group it belongs to. The end is irrelevant.
|
// As a consequnce, newly added mini debug infos will be merged and old ones (GCed) will be pruned.
|
static void MaybePackJitMiniDebugInfo(PackElfFileForJITFunction pack,
|
InstructionSet isa,
|
const InstructionSetFeatures* features)
|
REQUIRES(g_jit_debug_lock) {
|
// Size of memory range covered by each JITCodeEntry.
|
// The number of methods per entry is variable (depending on how many fit in that range).
|
constexpr uint32_t kGroupSize = 64 * KB;
|
// Even if there are no removed entries, we want to pack new entries on regular basis.
|
constexpr uint32_t kPackFrequency = 64;
|
|
std::deque<const void*>& removed_entries = g_jit_removed_entries;
|
std::sort(removed_entries.begin(), removed_entries.end());
|
if (removed_entries.empty() && g_jit_num_unpacked_entries < kPackFrequency) {
|
return; // Nothing to do.
|
}
|
|
std::vector<ArrayRef<const uint8_t>> added_elf_files;
|
std::vector<const void*> removed_symbols;
|
auto added_it = g_jit_debug_entries.begin();
|
auto removed_it = removed_entries.begin();
|
while (added_it != g_jit_debug_entries.end()) {
|
// Collect all entries that have been added or removed within our memory range.
|
const void* group_ptr = AlignDown(added_it->first, kGroupSize);
|
added_elf_files.clear();
|
auto added_begin = added_it;
|
while (added_it != g_jit_debug_entries.end() &&
|
AlignDown(added_it->first, kGroupSize) == group_ptr) {
|
JITCodeEntry* entry = (added_it++)->second;
|
added_elf_files.emplace_back(entry->symfile_addr_, entry->symfile_size_);
|
}
|
removed_symbols.clear();
|
while (removed_it != removed_entries.end() &&
|
AlignDown(*removed_it, kGroupSize) == group_ptr) {
|
removed_symbols.push_back(*(removed_it++));
|
}
|
|
// Create new singe JITCodeEntry that covers this memory range.
|
if (added_elf_files.size() == 1 && removed_symbols.size() == 0) {
|
continue; // Nothing changed in this memory range.
|
}
|
uint64_t start_time = MilliTime();
|
size_t symbols;
|
std::vector<uint8_t> packed = pack(isa, features, added_elf_files, removed_symbols, &symbols);
|
VLOG(jit)
|
<< "JIT mini-debug-info packed"
|
<< " for " << group_ptr
|
<< " in " << MilliTime() - start_time << "ms"
|
<< " files=" << added_elf_files.size()
|
<< " removed=" << removed_symbols.size()
|
<< " symbols=" << symbols
|
<< " size=" << PrettySize(packed.size());
|
|
// Replace the old entries with the new one (with their lifetime temporally overlapping).
|
JITCodeEntry* packed_entry = CreateJITCodeEntryInternal(
|
__jit_debug_descriptor,
|
__jit_debug_register_code_ptr,
|
ArrayRef<const uint8_t>(packed),
|
/*copy_symfile=*/ true);
|
for (auto it = added_begin; it != added_it; ++it) {
|
DeleteJITCodeEntryInternal(__jit_debug_descriptor,
|
__jit_debug_register_code_ptr,
|
/*entry=*/ it->second,
|
/*free_symfile=*/ true);
|
}
|
g_jit_debug_entries.erase(added_begin, added_it);
|
g_jit_debug_entries.emplace(group_ptr, packed_entry);
|
}
|
CHECK(added_it == g_jit_debug_entries.end());
|
CHECK(removed_it == removed_entries.end());
|
removed_entries.clear();
|
g_jit_num_unpacked_entries = 0;
|
}
|
|
void AddNativeDebugInfoForJit(Thread* self,
|
const void* code_ptr,
|
const std::vector<uint8_t>& symfile,
|
PackElfFileForJITFunction pack,
|
InstructionSet isa,
|
const InstructionSetFeatures* features) {
|
MutexLock mu(self, g_jit_debug_lock);
|
DCHECK_NE(symfile.size(), 0u);
|
|
MaybePackJitMiniDebugInfo(pack, isa, features);
|
|
JITCodeEntry* entry = CreateJITCodeEntryInternal(
|
__jit_debug_descriptor,
|
__jit_debug_register_code_ptr,
|
ArrayRef<const uint8_t>(symfile),
|
/*copy_symfile=*/ true);
|
|
VLOG(jit)
|
<< "JIT mini-debug-info added"
|
<< " for " << code_ptr
|
<< " size=" << PrettySize(symfile.size());
|
|
// We don't provide code_ptr for type debug info, which means we cannot free it later.
|
// (this only happens when --generate-debug-info flag is enabled for the purpose
|
// of being debugged with gdb; it does not happen for debuggable apps by default).
|
if (code_ptr != nullptr) {
|
g_jit_debug_entries.emplace(code_ptr, entry);
|
// Count how many entries we have added since the last mini-debug-info packing.
|
// We avoid g_jit_debug_entries.size() here because it can shrink during packing.
|
g_jit_num_unpacked_entries++;
|
}
|
}
|
|
void RemoveNativeDebugInfoForJit(Thread* self, const void* code_ptr) {
|
MutexLock mu(self, g_jit_debug_lock);
|
// We generate JIT native debug info only if the right runtime flags are enabled,
|
// but we try to remove it unconditionally whenever code is freed from JIT cache.
|
if (!g_jit_debug_entries.empty()) {
|
g_jit_removed_entries.push_back(code_ptr);
|
}
|
}
|
|
size_t GetJitMiniDebugInfoMemUsage() {
|
MutexLock mu(Thread::Current(), g_jit_debug_lock);
|
size_t size = 0;
|
for (auto entry : g_jit_debug_entries) {
|
size += sizeof(JITCodeEntry) + entry.second->symfile_size_ + /*map entry*/ 4 * sizeof(void*);
|
}
|
return size;
|
}
|
|
} // namespace art
|
