/*
|
* 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.
|
*/
|
|
#ifndef SIMPLE_PERF_JIT_DEBUG_READER_H_
|
#define SIMPLE_PERF_JIT_DEBUG_READER_H_
|
|
#include <unistd.h>
|
|
#include <functional>
|
#include <memory>
|
#include <queue>
|
#include <stack>
|
#include <unordered_map>
|
#include <unordered_set>
|
#include <vector>
|
|
#include <android-base/file.h>
|
#include <android-base/logging.h>
|
|
#include "IOEventLoop.h"
|
#include "record.h"
|
|
namespace simpleperf {
|
|
// JITDebugInfo represents the debug info of a JITed Java method or a dex file.
|
struct JITDebugInfo {
|
enum {
|
JIT_DEBUG_JIT_CODE,
|
JIT_DEBUG_DEX_FILE,
|
} type;
|
pid_t pid; // Process of the debug info
|
uint64_t timestamp; // Monotonic timestamp for the creation of the debug info
|
union {
|
struct {
|
uint64_t jit_code_addr; // The start addr of the JITed code
|
uint64_t jit_code_len; // The end addr of the JITed code
|
};
|
uint64_t dex_file_offset; // The offset of the dex file in the file containing it
|
};
|
// For JITed code, it is the path of a temporary ELF file storing its debug info.
|
// For dex file, it is the path of the file containing the dex file.
|
std::string file_path;
|
|
JITDebugInfo(pid_t pid, uint64_t timestamp, uint64_t jit_code_addr, uint64_t jit_code_len,
|
const std::string& file_path)
|
: type(JIT_DEBUG_JIT_CODE), pid(pid), timestamp(timestamp), jit_code_addr(jit_code_addr),
|
jit_code_len(jit_code_len), file_path(file_path) {}
|
|
JITDebugInfo(pid_t pid, uint64_t timestamp, uint64_t dex_file_offset,
|
const std::string& file_path)
|
: type(JIT_DEBUG_DEX_FILE), pid(pid), timestamp(timestamp), dex_file_offset(dex_file_offset),
|
file_path(file_path) {}
|
|
bool operator>(const JITDebugInfo& other) const {
|
return timestamp > other.timestamp;
|
}
|
};
|
|
// JITDebugReader reads debug info of JIT code and dex files of processes using ART. The
|
// corresponding debug interface in ART is at art/runtime/jit/debugger_interface.cc.
|
class JITDebugReader {
|
public:
|
// keep_symfiles: whether to keep dumped JIT debug info files after recording. Usually they
|
// are only kept for debug unwinding.
|
// sync_with_records: If true, sync debug info with records based on monotonic timestamp.
|
// Otherwise, save debug info whenever they are added.
|
JITDebugReader(bool keep_symfiles, bool sync_with_records)
|
: keep_symfiles_(keep_symfiles), sync_with_records_(sync_with_records) {}
|
|
bool SyncWithRecords() const {
|
return sync_with_records_;
|
}
|
|
typedef std::function<bool(const std::vector<JITDebugInfo>&, bool)> debug_info_callback_t;
|
bool RegisterDebugInfoCallback(IOEventLoop* loop, const debug_info_callback_t& callback);
|
|
// There are two ways to select which processes to monitor. One is using MonitorProcess(), the
|
// other is finding all processes having libart.so using records.
|
bool MonitorProcess(pid_t pid);
|
bool UpdateRecord(const Record* record);
|
|
// Read new debug info from all monitored processes.
|
bool ReadAllProcesses();
|
// Read new debug info from one process.
|
bool ReadProcess(pid_t pid);
|
|
// Flush all debug info registered before timestamp.
|
bool FlushDebugInfo(uint64_t timestamp);
|
|
private:
|
|
// An arch-independent representation of JIT/dex debug descriptor.
|
struct Descriptor {
|
uint32_t action_seqlock = 0; // incremented before and after any modification
|
uint64_t action_timestamp = 0; // CLOCK_MONOTONIC time of last action
|
uint64_t first_entry_addr = 0;
|
};
|
|
// An arch-independent representation of JIT/dex code entry.
|
struct CodeEntry {
|
uint64_t addr;
|
uint64_t symfile_addr;
|
uint64_t symfile_size;
|
uint64_t timestamp; // CLOCK_MONOTONIC time of last action
|
};
|
|
struct Process {
|
pid_t pid = -1;
|
bool initialized = false;
|
bool died = false;
|
bool is_64bit = false;
|
// The jit descriptor and dex descriptor can be read in one process_vm_readv() call.
|
uint64_t descriptors_addr = 0;
|
uint64_t descriptors_size = 0;
|
// offset relative to descriptors_addr
|
uint64_t jit_descriptor_offset = 0;
|
// offset relative to descriptors_addr
|
uint64_t dex_descriptor_offset = 0;
|
|
// The state we know about the remote jit debug descriptor.
|
Descriptor last_jit_descriptor;
|
// The state we know about the remote dex debug descriptor.
|
Descriptor last_dex_descriptor;
|
};
|
|
// The location of descriptors in libart.so.
|
struct DescriptorsLocation {
|
uint64_t relative_addr = 0;
|
uint64_t size = 0;
|
uint64_t jit_descriptor_offset = 0;
|
uint64_t dex_descriptor_offset = 0;
|
};
|
|
void ReadProcess(Process& process, std::vector<JITDebugInfo>* debug_info);
|
bool InitializeProcess(Process& process);
|
const DescriptorsLocation* GetDescriptorsLocation(const std::string& art_lib_path,
|
bool is_64bit);
|
bool ReadRemoteMem(Process& process, uint64_t remote_addr, uint64_t size, void* data);
|
bool ReadDescriptors(Process& process, Descriptor* jit_descriptor, Descriptor* dex_descriptor);
|
bool LoadDescriptor(bool is_64bit, const char* data, Descriptor* descriptor);
|
template <typename DescriptorT, typename CodeEntryT>
|
bool LoadDescriptorImpl(const char* data, Descriptor* descriptor);
|
|
bool ReadNewCodeEntries(Process& process, const Descriptor& descriptor,
|
uint64_t last_action_timestamp, uint32_t read_entry_limit,
|
std::vector<CodeEntry>* new_code_entries);
|
template <typename DescriptorT, typename CodeEntryT>
|
bool ReadNewCodeEntriesImpl(Process& process, const Descriptor& descriptor,
|
uint64_t last_action_timestamp, uint32_t read_entry_limit,
|
std::vector<CodeEntry>* new_code_entries);
|
|
void ReadJITCodeDebugInfo(Process& process, const std::vector<CodeEntry>& jit_entries,
|
std::vector<JITDebugInfo>* debug_info);
|
void ReadDexFileDebugInfo(Process& process, const std::vector<CodeEntry>& dex_entries,
|
std::vector<JITDebugInfo>* debug_info);
|
bool AddDebugInfo(const std::vector<JITDebugInfo>& jit_symfiles, bool sync_kernel_records);
|
|
bool keep_symfiles_ = false;
|
bool sync_with_records_ = false;
|
IOEventRef read_event_ = nullptr;
|
debug_info_callback_t debug_info_callback_;
|
|
// Keys are pids of processes having libart.so, values show whether a process has been monitored.
|
std::unordered_map<pid_t, bool> pids_with_art_lib_;
|
|
// All monitored processes
|
std::unordered_map<pid_t, Process> processes_;
|
std::unordered_map<std::string, DescriptorsLocation> descriptors_location_cache_;
|
std::vector<char> descriptors_buf_;
|
|
std::priority_queue<JITDebugInfo, std::vector<JITDebugInfo>, std::greater<JITDebugInfo>>
|
debug_info_q_;
|
};
|
|
} //namespace simpleperf
|
|
#endif // SIMPLE_PERF_JIT_DEBUG_READER_H_
|
