// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
|
// Use of this source code is governed by a BSD-style license that can be
|
// found in the LICENSE file.
|
|
#include "perf_reader.h"
|
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <sys/time.h>
|
|
#include <algorithm>
|
#include <vector>
|
|
#include "base/logging.h"
|
#include "base/macros.h"
|
|
#include "binary_data_utils.h"
|
#include "buffer_reader.h"
|
#include "buffer_writer.h"
|
#include "compat/string.h"
|
#include "file_reader.h"
|
#include "file_utils.h"
|
#include "perf_data_structures.h"
|
#include "perf_data_utils.h"
|
#include "sample_info_reader.h"
|
|
namespace quipper {
|
|
using PerfEvent = PerfDataProto_PerfEvent;
|
using SampleInfo = PerfDataProto_SampleInfo;
|
using StringAndMd5sumPrefix =
|
PerfDataProto_StringMetadata_StringAndMd5sumPrefix;
|
|
namespace {
|
|
// The type of the storage size of a string, prefixed before each string field
|
// in raw data.
|
typedef u32 string_size_type;
|
|
// The type of the number of string data, found in the command line metadata in
|
// the perf data file.
|
typedef u32 num_string_data_type;
|
|
// Types of the event desc fields that are not found in other structs.
|
typedef u32 event_desc_num_events;
|
typedef u32 event_desc_attr_size;
|
typedef u32 event_desc_num_unique_ids;
|
|
// The type of the number of nodes field in NUMA topology.
|
typedef u32 numa_topology_num_nodes_type;
|
|
// The type of the number of mappings in pmu mappings.
|
typedef u32 pmu_mappings_num_mappings_type;
|
|
// The type of the number of groups in group desc.
|
typedef u32 group_desc_num_groups_type;
|
|
// A mask that is applied to |metadata_mask()| in order to get a mask for
|
// only the metadata supported by quipper.
|
const uint32_t kSupportedMetadataMask =
|
1 << HEADER_TRACING_DATA | 1 << HEADER_BUILD_ID | 1 << HEADER_HOSTNAME |
|
1 << HEADER_OSRELEASE | 1 << HEADER_VERSION | 1 << HEADER_ARCH |
|
1 << HEADER_NRCPUS | 1 << HEADER_CPUDESC | 1 << HEADER_CPUID |
|
1 << HEADER_TOTAL_MEM | 1 << HEADER_CMDLINE | 1 << HEADER_EVENT_DESC |
|
1 << HEADER_CPU_TOPOLOGY | 1 << HEADER_NUMA_TOPOLOGY |
|
1 << HEADER_BRANCH_STACK | 1 << HEADER_PMU_MAPPINGS |
|
1 << HEADER_GROUP_DESC;
|
|
// By default, the build ID event has PID = -1.
|
const uint32_t kDefaultBuildIDEventPid = static_cast<uint32_t>(-1);
|
|
// Eight bits in a byte.
|
size_t BytesToBits(size_t num_bytes) { return num_bytes * 8; }
|
|
u8 ReverseByte(u8 x) {
|
x = (x & 0xf0) >> 4 | (x & 0x0f) << 4; // exchange nibbles
|
x = (x & 0xcc) >> 2 | (x & 0x33) << 2; // exchange pairs
|
x = (x & 0xaa) >> 1 | (x & 0x55) << 1; // exchange neighbors
|
return x;
|
}
|
|
// If field points to the start of a bitfield padded to len bytes, this
|
// performs an endian swap of the bitfield, assuming the compiler that produced
|
// it conforms to the same ABI (bitfield layout is not completely specified by
|
// the language).
|
void SwapBitfieldOfBits(u8* field, size_t len) {
|
for (size_t i = 0; i < len; i++) {
|
field[i] = ReverseByte(field[i]);
|
}
|
}
|
|
// The code currently assumes that the compiler will not add any padding to the
|
// various structs. These CHECKs make sure that this is true.
|
void CheckNoEventHeaderPadding() {
|
perf_event_header header;
|
CHECK_EQ(sizeof(header),
|
sizeof(header.type) + sizeof(header.misc) + sizeof(header.size));
|
}
|
|
void CheckNoPerfEventAttrPadding() {
|
perf_event_attr attr;
|
CHECK_EQ(sizeof(attr), (reinterpret_cast<u64>(&attr.__reserved_2) -
|
reinterpret_cast<u64>(&attr)) +
|
sizeof(attr.__reserved_2));
|
}
|
|
void CheckNoEventTypePadding() {
|
perf_trace_event_type event_type;
|
CHECK_EQ(sizeof(event_type),
|
sizeof(event_type.event_id) + sizeof(event_type.name));
|
}
|
|
void CheckNoBuildIDEventPadding() {
|
build_id_event event;
|
CHECK_EQ(sizeof(event), sizeof(event.header.type) +
|
sizeof(event.header.misc) +
|
sizeof(event.header.size) + sizeof(event.pid) +
|
sizeof(event.build_id));
|
}
|
|
// Creates a new build ID event with the given build ID string, filename, and
|
// misc value.
|
malloced_unique_ptr<build_id_event> CreateBuildIDEvent(const string& build_id,
|
const string& filename,
|
uint16_t misc) {
|
size_t filename_len = GetUint64AlignedStringLength(filename);
|
size_t size = sizeof(struct build_id_event) + filename_len;
|
malloced_unique_ptr<build_id_event> event(CallocMemoryForBuildID(size));
|
event->header.type = HEADER_BUILD_ID;
|
event->header.misc = misc;
|
event->header.size = size;
|
|
event->pid = kDefaultBuildIDEventPid;
|
snprintf(event->filename, filename_len, "%s", filename.c_str());
|
memset(event->filename + filename.size(), 0, filename_len - filename.size());
|
|
HexStringToRawData(build_id, event->build_id, sizeof(event->build_id));
|
return event;
|
}
|
|
// Given a string, returns the total size required to store the string in perf
|
// data, including a preceding length field and extra padding to align the
|
// string + null terminator to a multiple of uint64s.
|
size_t ExpectedStorageSizeOf(const string& str) {
|
return sizeof(string_size_type) + GetUint64AlignedStringLength(str);
|
}
|
|
// Reads a perf_event_header from |data| and performs byte swapping if
|
// necessary. Returns true on success, or false if there was an error.
|
bool ReadPerfEventHeader(DataReader* data, struct perf_event_header* header) {
|
if (!data->ReadData(sizeof(struct perf_event_header), header)) {
|
LOG(ERROR) << "Error reading perf event header.";
|
return false;
|
}
|
if (data->is_cross_endian()) {
|
ByteSwap(&header->type);
|
ByteSwap(&header->size);
|
ByteSwap(&header->misc);
|
}
|
return true;
|
}
|
|
// Reads a perf_file_section from |data| and performs byte swapping if
|
// necessary. Returns true on success, or false if there was an error.
|
bool ReadPerfFileSection(DataReader* data, struct perf_file_section* section) {
|
if (!data->ReadData(sizeof(*section), section)) {
|
LOG(ERROR) << "Error reading perf file section info.";
|
return false;
|
}
|
if (data->is_cross_endian()) {
|
ByteSwap(§ion->offset);
|
ByteSwap(§ion->size);
|
}
|
return true;
|
}
|
|
// Returns true if |e1| has an earlier timestamp than |e2|. Used to sort an
|
// array of events.
|
static bool CompareEventTimes(const PerfEvent* e1, const PerfEvent* e2) {
|
return e1->timestamp() < e2->timestamp();
|
}
|
|
} // namespace
|
|
PerfReader::PerfReader()
|
: proto_(Arena::CreateMessage<PerfDataProto>(&arena_)),
|
is_cross_endian_(false) {
|
// The metadata mask is stored in |proto_|. It should be initialized to 0
|
// since it is used heavily.
|
proto_->add_metadata_mask(0);
|
}
|
|
PerfReader::~PerfReader() {}
|
|
bool PerfReader::Serialize(PerfDataProto* perf_data_proto) const {
|
perf_data_proto->CopyFrom(*proto_);
|
|
// Add a timestamp_sec to the protobuf.
|
struct timeval timestamp_sec;
|
if (!gettimeofday(×tamp_sec, NULL))
|
perf_data_proto->set_timestamp_sec(timestamp_sec.tv_sec);
|
return true;
|
}
|
|
bool PerfReader::Deserialize(const PerfDataProto& perf_data_proto) {
|
proto_->CopyFrom(perf_data_proto);
|
|
// Iterate through all attrs and create a SampleInfoReader for each of them.
|
// This is necessary for writing the proto representation of perf data to raw
|
// data.
|
for (const auto& stored_attr : proto_->file_attrs()) {
|
PerfFileAttr attr;
|
serializer_.DeserializePerfFileAttr(stored_attr, &attr);
|
serializer_.CreateSampleInfoReader(attr, false /* read_cross_endian */);
|
}
|
return true;
|
}
|
|
bool PerfReader::ReadFile(const string& filename) {
|
FileReader reader(filename);
|
if (!reader.IsOpen()) {
|
LOG(ERROR) << "Unable to open file " << filename;
|
return false;
|
}
|
return ReadFromData(&reader);
|
}
|
|
bool PerfReader::ReadFromVector(const std::vector<char>& data) {
|
return ReadFromPointer(data.data(), data.size());
|
}
|
|
bool PerfReader::ReadFromString(const string& str) {
|
return ReadFromPointer(str.data(), str.size());
|
}
|
|
bool PerfReader::ReadFromPointer(const char* data, size_t size) {
|
BufferReader buffer(data, size);
|
return ReadFromData(&buffer);
|
}
|
|
bool PerfReader::ReadFromData(DataReader* data) {
|
if (data->size() == 0) {
|
LOG(ERROR) << "Input data is empty";
|
return false;
|
}
|
if (!ReadHeader(data)) return false;
|
|
// Check if it is normal perf data.
|
if (header_.size == sizeof(header_)) {
|
DVLOG(1) << "Perf data is in normal format.";
|
return ReadFileData(data);
|
}
|
|
// Otherwise it is piped data.
|
if (piped_header_.size != sizeof(piped_header_)) {
|
LOG(ERROR) << "Expecting piped data format, but header size "
|
<< piped_header_.size << " does not match expected size "
|
<< sizeof(piped_header_);
|
return false;
|
}
|
|
return ReadPipedData(data);
|
}
|
|
bool PerfReader::WriteFile(const string& filename) {
|
std::vector<char> data;
|
return WriteToVector(&data) && BufferToFile(filename, data);
|
}
|
|
bool PerfReader::WriteToVector(std::vector<char>* data) {
|
data->resize(GetSize());
|
return WriteToPointerWithoutCheckingSize(&data->at(0), data->size());
|
}
|
|
bool PerfReader::WriteToString(string* str) {
|
str->resize(GetSize());
|
return WriteToPointerWithoutCheckingSize(&str->at(0), str->size());
|
}
|
|
bool PerfReader::WriteToPointer(char* buffer, size_t size) {
|
size_t required_size = GetSize();
|
if (size < required_size) {
|
LOG(ERROR) << "Buffer is too small - buffer size is " << size
|
<< " and required size is " << required_size;
|
return false;
|
}
|
return WriteToPointerWithoutCheckingSize(buffer, size);
|
}
|
|
bool PerfReader::WriteToPointerWithoutCheckingSize(char* buffer, size_t size) {
|
BufferWriter data(buffer, size);
|
struct perf_file_header header;
|
GenerateHeader(&header);
|
|
return WriteHeader(header, &data) && WriteAttrs(header, &data) &&
|
WriteData(header, &data) && WriteMetadata(header, &data);
|
}
|
|
size_t PerfReader::GetSize() const {
|
struct perf_file_header header;
|
GenerateHeader(&header);
|
|
size_t total_size = 0;
|
total_size += header.size;
|
total_size += header.attrs.size;
|
total_size += header.event_types.size;
|
total_size += header.data.size;
|
// Add the ID info, whose size is not explicitly included in the header.
|
for (const auto& attr : proto_->file_attrs()) {
|
total_size +=
|
attr.ids_size() * sizeof(decltype(PerfFileAttr::ids)::value_type);
|
}
|
|
// Additional info about metadata. See WriteMetadata for explanation.
|
total_size += GetNumSupportedMetadata() * sizeof(struct perf_file_section);
|
|
// Add the sizes of the various metadata.
|
total_size += tracing_data().size();
|
total_size += GetBuildIDMetadataSize();
|
total_size += GetStringMetadataSize();
|
total_size += GetUint32MetadataSize();
|
total_size += GetUint64MetadataSize();
|
total_size += GetEventDescMetadataSize();
|
total_size += GetCPUTopologyMetadataSize();
|
total_size += GetNUMATopologyMetadataSize();
|
total_size += GetPMUMappingsMetadataSize();
|
total_size += GetGroupDescMetadataSize();
|
return total_size;
|
}
|
|
void PerfReader::GenerateHeader(struct perf_file_header* header) const {
|
// This is the order of the input perf file contents in normal mode:
|
// 1. Header
|
// 2. Attribute IDs (pointed to by attr.ids.offset)
|
// 3. Attributes
|
// 4. Event types
|
// 5. Data
|
// 6. Metadata
|
|
// Compute offsets in the above order.
|
CheckNoEventHeaderPadding();
|
memset(header, 0, sizeof(*header));
|
header->magic = kPerfMagic;
|
header->size = sizeof(*header);
|
header->attr_size = sizeof(perf_file_attr);
|
header->attrs.size = header->attr_size * attrs().size();
|
for (const PerfEvent& event : proto_->events()) {
|
header->data.size += event.header().size();
|
// Auxtrace event contain trace data at the end of the event. Add the size
|
// of this trace data to the header.data size.
|
if (event.header().type() == PERF_RECORD_AUXTRACE) {
|
header->data.size += event.auxtrace_event().size();
|
}
|
}
|
// Do not use the event_types section. Use EVENT_DESC metadata instead.
|
header->event_types.size = 0;
|
|
u64 current_offset = 0;
|
current_offset += header->size;
|
for (const auto& attr : proto_->file_attrs()) {
|
current_offset +=
|
sizeof(decltype(PerfFileAttr::ids)::value_type) * attr.ids_size();
|
}
|
header->attrs.offset = current_offset;
|
current_offset += header->attrs.size;
|
header->event_types.offset = current_offset;
|
current_offset += header->event_types.size;
|
|
header->data.offset = current_offset;
|
|
// Construct the header feature bits.
|
memset(&header->adds_features, 0, sizeof(header->adds_features));
|
// The following code makes the assumption that all feature bits are in the
|
// first word of |adds_features|. If the perf data format changes and the
|
// assumption is no longer valid, this CHECK will fail, at which point the
|
// below code needs to be updated. For now, sticking to that assumption keeps
|
// the code simple.
|
// This assumption is also used when reading metadata, so that code
|
// will also have to be updated if this CHECK starts to fail.
|
CHECK_LE(static_cast<size_t>(HEADER_LAST_FEATURE),
|
BytesToBits(sizeof(header->adds_features[0])));
|
header->adds_features[0] |= metadata_mask() & kSupportedMetadataMask;
|
}
|
|
bool PerfReader::InjectBuildIDs(
|
const std::map<string, string>& filenames_to_build_ids) {
|
set_metadata_mask_bit(HEADER_BUILD_ID);
|
std::set<string> updated_filenames;
|
// Inject new build ID's for existing build ID events.
|
for (auto& build_id : *proto_->mutable_build_ids()) {
|
auto find_result = filenames_to_build_ids.find(build_id.filename());
|
if (find_result == filenames_to_build_ids.end()) continue;
|
const string& build_id_string = find_result->second;
|
const int kHexCharsPerByte = 2;
|
std::vector<uint8_t> build_id_data(build_id_string.size() /
|
kHexCharsPerByte);
|
if (!HexStringToRawData(build_id_string, build_id_data.data(),
|
build_id_data.size())) {
|
LOG(ERROR) << "Could not convert hex string to raw data: "
|
<< build_id_string;
|
return false;
|
}
|
build_id.set_build_id_hash(build_id_data.data(), build_id_data.size());
|
|
updated_filenames.insert(build_id.filename());
|
}
|
|
// For files with no existing build ID events, create new build ID events.
|
// This requires a lookup of all MMAP's to determine the |misc| field of each
|
// build ID event.
|
std::map<string, uint16_t> filename_to_misc;
|
for (const PerfEvent& event : proto_->events()) {
|
if (event.header().type() == PERF_RECORD_MMAP ||
|
event.header().type() == PERF_RECORD_MMAP2) {
|
filename_to_misc[event.mmap_event().filename()] = event.header().misc();
|
}
|
}
|
|
std::map<string, string>::const_iterator it;
|
for (it = filenames_to_build_ids.begin(); it != filenames_to_build_ids.end();
|
++it) {
|
const string& filename = it->first;
|
if (updated_filenames.find(filename) != updated_filenames.end()) continue;
|
|
// Determine the misc field.
|
uint16_t new_misc = PERF_RECORD_MISC_KERNEL;
|
std::map<string, uint16_t>::const_iterator misc_iter =
|
filename_to_misc.find(filename);
|
if (misc_iter != filename_to_misc.end()) new_misc = misc_iter->second;
|
|
string build_id = it->second;
|
malloced_unique_ptr<build_id_event> event =
|
CreateBuildIDEvent(build_id, filename, new_misc);
|
if (!serializer_.SerializeBuildIDEvent(event, proto_->add_build_ids())) {
|
LOG(ERROR) << "Could not serialize build ID event with ID " << build_id;
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PerfReader::Localize(
|
const std::map<string, string>& build_ids_to_filenames) {
|
std::map<string, string> filename_map;
|
for (auto& build_id : *proto_->mutable_build_ids()) {
|
string build_id_string = RawDataToHexString(build_id.build_id_hash());
|
auto find_result = build_ids_to_filenames.find(build_id_string);
|
if (find_result == build_ids_to_filenames.end()) continue;
|
const string& new_filename = find_result->second;
|
filename_map[build_id.filename()] = new_filename;
|
}
|
|
return LocalizeUsingFilenames(filename_map);
|
}
|
|
bool PerfReader::LocalizeUsingFilenames(
|
const std::map<string, string>& filename_map) {
|
LocalizeMMapFilenames(filename_map);
|
for (auto& build_id : *proto_->mutable_build_ids()) {
|
auto find_result = filename_map.find(build_id.filename());
|
if (find_result != filename_map.end())
|
build_id.set_filename(find_result->second);
|
}
|
return true;
|
}
|
|
void PerfReader::GetFilenames(std::vector<string>* filenames) const {
|
std::set<string> filename_set;
|
GetFilenamesAsSet(&filename_set);
|
filenames->clear();
|
filenames->insert(filenames->begin(), filename_set.begin(),
|
filename_set.end());
|
}
|
|
void PerfReader::GetFilenamesAsSet(std::set<string>* filenames) const {
|
filenames->clear();
|
for (const PerfEvent& event : proto_->events()) {
|
if (event.header().type() == PERF_RECORD_MMAP ||
|
event.header().type() == PERF_RECORD_MMAP2) {
|
filenames->insert(event.mmap_event().filename());
|
}
|
}
|
}
|
|
void PerfReader::GetFilenamesToBuildIDs(
|
std::map<string, string>* filenames_to_build_ids) const {
|
filenames_to_build_ids->clear();
|
for (const auto& build_id : proto_->build_ids()) {
|
string build_id_string = RawDataToHexString(build_id.build_id_hash());
|
PerfizeBuildIDString(&build_id_string);
|
(*filenames_to_build_ids)[build_id.filename()] = build_id_string;
|
}
|
}
|
|
void PerfReader::MaybeSortEventsByTime() {
|
// Events can not be sorted by time if PERF_SAMPLE_TIME is not set in
|
// attr.sample_type for all attrs.
|
for (const auto& attr : attrs()) {
|
if (!(attr.attr().sample_type() & PERF_SAMPLE_TIME)) {
|
return;
|
}
|
}
|
|
// Sort the events based on timestamp.
|
|
// This sorts the pointers in the proto-internal vector, which
|
// requires no copying and less external space.
|
std::stable_sort(proto_->mutable_events()->pointer_begin(),
|
proto_->mutable_events()->pointer_end(), CompareEventTimes);
|
}
|
|
bool PerfReader::ReadHeader(DataReader* data) {
|
CheckNoEventHeaderPadding();
|
// The header is the first thing to be read. Don't use SeekSet(0) because it
|
// doesn't make sense for piped files. Instead, verify that the reader points
|
// to the start of the data.
|
CHECK_EQ(0U, data->Tell());
|
if (!data->ReadUint64(&piped_header_.magic)) {
|
LOG(ERROR) << "Error reading header magic number.";
|
return false;
|
}
|
|
if (piped_header_.magic != kPerfMagic &&
|
piped_header_.magic != bswap_64(kPerfMagic)) {
|
// clang-format off
|
LOG(ERROR) << "Read wrong magic. Expected: 0x" << std::hex << kPerfMagic
|
<< " or 0x" << std::hex << bswap_64(kPerfMagic)
|
<< " Got: 0x" << std::hex << piped_header_.magic;
|
// clang-format on
|
return false;
|
}
|
is_cross_endian_ = (piped_header_.magic != kPerfMagic);
|
data->set_is_cross_endian(is_cross_endian_);
|
|
if (!data->ReadUint64(&piped_header_.size)) {
|
LOG(ERROR) << "Error reading header size.";
|
return false;
|
}
|
|
CHECK_EQ(data->Tell(), sizeof(piped_header_));
|
|
// Header can be a piped header.
|
if (piped_header_.size == sizeof(piped_header_)) return true;
|
|
// Read as a non-piped header.
|
if (!data->ReadUint64(&header_.attr_size)) {
|
LOG(ERROR) << "Error reading header::attr_size.";
|
return false;
|
}
|
if (!ReadPerfFileSection(data, &header_.attrs) ||
|
!ReadPerfFileSection(data, &header_.data) ||
|
!ReadPerfFileSection(data, &header_.event_types)) {
|
LOG(ERROR) << "Error reading header file section info.";
|
return false;
|
}
|
|
const size_t features_size = sizeof(header_.adds_features);
|
CHECK_EQ(data->Tell(), sizeof(header_) - features_size);
|
|
if (!data->ReadData(features_size, header_.adds_features)) {
|
LOG(ERROR) << "Error reading header::adds_features.";
|
return false;
|
}
|
proto_->set_metadata_mask(0, header_.adds_features[0]);
|
|
// Byte-swapping |adds_features| is tricky. It is defined as an array of
|
// unsigned longs, which can vary between architectures. However, the overall
|
// size of the array in bytes is fixed.
|
//
|
// According to perf's perf_file_header__read() function, the hostname feature
|
// should always be set. Try byte-swapping as uint64s first and check the
|
// hostname bit. If it's not set, then try swapping as uint32s. This is
|
// similar to the algorithm used in perf.
|
if (data->is_cross_endian()) {
|
static_assert(sizeof(header_.adds_features[0]) == sizeof(uint32_t) ||
|
sizeof(header_.adds_features[0]) == sizeof(uint64_t),
|
"|header_.adds_features| must be defined as an array of "
|
"either 32-bit or 64-bit words.");
|
|
uint64_t features64 = 0;
|
// Some compilers will complain if we directly cast |header_.adds_features|
|
// to a uint64_t*. Instead, determine the first uint64_t without using
|
// pointer aliasing.
|
if (sizeof(header_.adds_features[0]) == sizeof(uint64_t)) {
|
features64 = bswap_64(header_.adds_features[0]);
|
} else {
|
// If the native |adds_features| is composed of 32-bit words, swap the
|
// byte order of each word and then swap their positions to create a
|
// 64-bit word.
|
features64 = static_cast<uint64_t>(bswap_32(header_.adds_features[0]))
|
<< 32;
|
features64 |= bswap_32(header_.adds_features[1]);
|
}
|
if (features64 & (1 << HEADER_HOSTNAME)) {
|
for (size_t i = 0; i < features_size / sizeof(uint64_t); ++i)
|
ByteSwap(reinterpret_cast<uint64_t*>(header_.adds_features) + i);
|
} else {
|
for (size_t i = 0; i < features_size / sizeof(uint32_t); ++i)
|
ByteSwap(reinterpret_cast<uint32_t*>(header_.adds_features) + i);
|
}
|
}
|
|
return true;
|
}
|
|
bool PerfReader::ReadAttrsSection(DataReader* data) {
|
size_t num_attrs = header_.attrs.size / header_.attr_size;
|
if (header_.attrs.size % header_.attr_size != 0) {
|
LOG(ERROR) << "Total size of attrs " << header_.attrs.size
|
<< " is not a multiple of attr size " << header_.attr_size;
|
}
|
data->SeekSet(header_.attrs.offset);
|
for (size_t i = 0; i < num_attrs; i++) {
|
if (!ReadAttr(data)) return false;
|
}
|
return true;
|
}
|
|
bool PerfReader::ReadAttr(DataReader* data) {
|
PerfFileAttr attr;
|
if (!ReadEventAttr(data, &attr.attr)) return false;
|
|
perf_file_section ids;
|
if (!ReadPerfFileSection(data, &ids)) return false;
|
|
// The ID may be stored at a different location in the file than where we're
|
// currently reading.
|
size_t saved_offset = data->Tell();
|
data->SeekSet(ids.offset);
|
|
size_t num_ids = ids.size / sizeof(decltype(attr.ids)::value_type);
|
if (!ReadUniqueIDs(data, num_ids, &attr.ids)) return false;
|
data->SeekSet(saved_offset);
|
AddPerfFileAttr(attr);
|
|
return true;
|
}
|
|
bool PerfReader::ReadEventAttr(DataReader* data, perf_event_attr* attr) {
|
CheckNoPerfEventAttrPadding();
|
*attr = {0};
|
|
static_assert(
|
offsetof(struct perf_event_attr, size) == sizeof(perf_event_attr::type),
|
"type and size should be the first to fields of perf_event_attr");
|
|
if (!data->ReadUint32(&attr->type) || !data->ReadUint32(&attr->size)) {
|
LOG(ERROR) << "Error reading event attr type and size.";
|
return false;
|
}
|
|
// Now read the rest of the attr struct.
|
const size_t attr_offset = sizeof(attr->type) + sizeof(attr->size);
|
const size_t attr_readable_size =
|
std::min(static_cast<size_t>(attr->size), sizeof(*attr));
|
if (!data->ReadDataValue(attr_readable_size - attr_offset, "attribute",
|
reinterpret_cast<char*>(attr) + attr_offset)) {
|
return false;
|
}
|
data->SeekSet(data->Tell() + attr->size - attr_readable_size);
|
|
if (data->is_cross_endian()) {
|
// Depending on attr->size, some of these might not have actually been
|
// read. This is okay: they are zero.
|
ByteSwap(&attr->type);
|
ByteSwap(&attr->size);
|
ByteSwap(&attr->config);
|
ByteSwap(&attr->sample_period);
|
ByteSwap(&attr->sample_type);
|
ByteSwap(&attr->read_format);
|
|
// NB: This will also reverse precise_ip : 2 as if it was two fields:
|
auto* const bitfield_start = &attr->read_format + 1;
|
SwapBitfieldOfBits(reinterpret_cast<u8*>(bitfield_start), sizeof(u64));
|
// ... So swap it back:
|
const auto tmp = attr->precise_ip;
|
attr->precise_ip = (tmp & 0x2) >> 1 | (tmp & 0x1) << 1;
|
|
ByteSwap(&attr->wakeup_events); // union with wakeup_watermark
|
ByteSwap(&attr->bp_type);
|
ByteSwap(&attr->bp_addr); // union with config1
|
ByteSwap(&attr->bp_len); // union with config2
|
ByteSwap(&attr->branch_sample_type);
|
ByteSwap(&attr->sample_regs_user);
|
ByteSwap(&attr->sample_stack_user);
|
}
|
|
// The actual perf_event_attr data size might be different from the size of
|
// the struct definition. Check against perf_event_attr's |size| field.
|
attr->size = sizeof(*attr);
|
|
return true;
|
}
|
|
bool PerfReader::ReadUniqueIDs(DataReader* data, size_t num_ids,
|
std::vector<u64>* ids) {
|
ids->resize(num_ids);
|
for (u64& id : *ids) {
|
if (!data->ReadUint64(&id)) {
|
LOG(ERROR) << "Error reading unique ID.";
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PerfReader::ReadEventTypesSection(DataReader* data) {
|
int num_event_types =
|
header_.event_types.size / sizeof(struct perf_trace_event_type);
|
if (num_event_types == 0) {
|
// Not available.
|
return true;
|
}
|
CHECK_EQ(proto_->file_attrs().size(), num_event_types);
|
CHECK_EQ(sizeof(perf_trace_event_type) * num_event_types,
|
header_.event_types.size);
|
data->SeekSet(header_.event_types.offset);
|
for (int i = 0; i < num_event_types; ++i) {
|
if (!ReadEventType(data, i, 0)) return false;
|
}
|
return true;
|
}
|
|
bool PerfReader::ReadEventType(DataReader* data, int attr_idx,
|
size_t event_size) {
|
CheckNoEventTypePadding();
|
decltype(perf_trace_event_type::event_id) event_id;
|
|
if (!data->ReadUint64(&event_id)) {
|
LOG(ERROR) << "Error reading event ID.";
|
return false;
|
}
|
|
size_t event_name_len;
|
if (event_size == 0) { // Not in an event.
|
event_name_len = sizeof(perf_trace_event_type::name);
|
} else {
|
event_name_len = event_size - sizeof(perf_event_header) - sizeof(event_id);
|
}
|
|
PerfFileAttr attr;
|
if (!data->ReadString(event_name_len, &attr.name)) {
|
LOG(ERROR) << "Not enough data left in data to read event name.";
|
return false;
|
}
|
|
if (attr_idx >= proto_->file_attrs().size()) {
|
LOG(ERROR) << "Too many event types, or attrs not read yet!";
|
return false;
|
}
|
if (event_id != proto_->file_attrs(attr_idx).attr().config()) {
|
LOG(ERROR) << "event_id for perf_trace_event_type (" << event_id << ") "
|
<< "does not match attr.config ("
|
<< proto_->file_attrs(attr_idx).attr().config() << ")";
|
return false;
|
}
|
attr.attr.config = proto_->file_attrs(attr_idx).attr().config();
|
|
serializer_.SerializePerfEventType(attr, proto_->add_event_types());
|
return true;
|
}
|
|
bool PerfReader::ReadDataSection(DataReader* data) {
|
u64 data_remaining_bytes = header_.data.size;
|
data->SeekSet(header_.data.offset);
|
while (data_remaining_bytes != 0) {
|
// Read the header to determine the size of the event.
|
perf_event_header header;
|
if (!ReadPerfEventHeader(data, &header)) {
|
LOG(ERROR) << "Error reading event header from data section.";
|
return false;
|
}
|
|
// Read the rest of the event data.
|
malloced_unique_ptr<event_t> event(CallocMemoryForEvent(header.size));
|
event->header = header;
|
if (!data->ReadDataValue(event->header.size - sizeof(event->header),
|
"rest of event", &event->header + 1)) {
|
return false;
|
}
|
MaybeSwapEventFields(event.get(), data->is_cross_endian());
|
|
// We must have a valid way to read sample info before reading perf events.
|
CHECK(serializer_.SampleInfoReaderAvailable());
|
|
// Serialize the event to protobuf form.
|
PerfEvent* proto_event = proto_->add_events();
|
if (!serializer_.SerializeEvent(event, proto_event)) return false;
|
|
if (proto_event->header().type() == PERF_RECORD_AUXTRACE) {
|
if (!ReadAuxtraceTraceData(data, proto_event)) return false;
|
data_remaining_bytes -= proto_event->auxtrace_event().size();
|
}
|
data_remaining_bytes -= event->header.size;
|
}
|
|
DLOG(INFO) << "Number of events stored: " << proto_->events_size();
|
return true;
|
}
|
|
bool PerfReader::ReadMetadata(DataReader* data) {
|
// Metadata comes after the event data.
|
data->SeekSet(header_.data.offset + header_.data.size);
|
|
// Read the (offset, size) pairs of all the metadata elements. Note that this
|
// takes into account all present metadata types, not just the ones included
|
// in |kSupportedMetadataMask|. If a metadata type is not supported, it is
|
// skipped over.
|
std::vector<struct perf_file_section> sections(GetNumBits(metadata_mask()));
|
for (struct perf_file_section& section : sections) {
|
if (!ReadPerfFileSection(data, §ion)) {
|
LOG(ERROR) << "Error reading metadata entry info.";
|
return false;
|
}
|
}
|
|
auto section_iter = sections.begin();
|
for (u32 type = HEADER_FIRST_FEATURE; type != HEADER_LAST_FEATURE; ++type) {
|
if (!get_metadata_mask_bit(type)) continue;
|
data->SeekSet(section_iter->offset);
|
u64 size = section_iter->size;
|
|
switch (type) {
|
case HEADER_TRACING_DATA:
|
if (!ReadTracingMetadata(data, size)) return false;
|
break;
|
case HEADER_BUILD_ID:
|
if (!ReadBuildIDMetadata(data, size)) return false;
|
break;
|
case HEADER_HOSTNAME:
|
if (!ReadSingleStringMetadata(
|
data, size,
|
proto_->mutable_string_metadata()->mutable_hostname())) {
|
return false;
|
}
|
break;
|
case HEADER_OSRELEASE:
|
if (!ReadSingleStringMetadata(
|
data, size,
|
proto_->mutable_string_metadata()->mutable_kernel_version())) {
|
return false;
|
}
|
break;
|
case HEADER_VERSION:
|
if (!ReadSingleStringMetadata(
|
data, size,
|
proto_->mutable_string_metadata()->mutable_perf_version())) {
|
return false;
|
}
|
break;
|
case HEADER_ARCH:
|
if (!ReadSingleStringMetadata(
|
data, size,
|
proto_->mutable_string_metadata()->mutable_architecture())) {
|
return false;
|
}
|
break;
|
case HEADER_CPUDESC:
|
if (!ReadSingleStringMetadata(
|
data, size,
|
proto_->mutable_string_metadata()->mutable_cpu_description())) {
|
return false;
|
}
|
break;
|
case HEADER_CPUID:
|
if (!ReadSingleStringMetadata(
|
data, size,
|
proto_->mutable_string_metadata()->mutable_cpu_id())) {
|
return false;
|
}
|
break;
|
case HEADER_CMDLINE: {
|
auto* string_metadata = proto_->mutable_string_metadata();
|
if (!ReadRepeatedStringMetadata(
|
data, size, string_metadata->mutable_perf_command_line_token(),
|
string_metadata->mutable_perf_command_line_whole())) {
|
return false;
|
}
|
break;
|
}
|
case HEADER_NRCPUS:
|
if (!ReadUint32Metadata(data, type, size)) return false;
|
break;
|
case HEADER_TOTAL_MEM:
|
if (!ReadUint64Metadata(data, type, size)) return false;
|
break;
|
case HEADER_EVENT_DESC:
|
if (!ReadEventDescMetadata(data)) return false;
|
break;
|
case HEADER_CPU_TOPOLOGY:
|
if (!ReadCPUTopologyMetadata(data)) return false;
|
break;
|
case HEADER_NUMA_TOPOLOGY:
|
if (!ReadNUMATopologyMetadata(data)) return false;
|
break;
|
case HEADER_BRANCH_STACK:
|
break;
|
case HEADER_PMU_MAPPINGS:
|
if (!ReadPMUMappingsMetadata(data, size)) return false;
|
break;
|
case HEADER_GROUP_DESC:
|
if (!ReadGroupDescMetadata(data)) return false;
|
break;
|
default:
|
LOG(INFO) << "Unsupported metadata type, skipping: " << type;
|
break;
|
}
|
++section_iter;
|
}
|
|
return true;
|
}
|
|
bool PerfReader::ReadBuildIDMetadata(DataReader* data, size_t size) {
|
CheckNoBuildIDEventPadding();
|
while (size > 0) {
|
// Make sure there is enough data for everything but the filename.
|
perf_event_header build_id_header;
|
if (!ReadPerfEventHeader(data, &build_id_header)) {
|
LOG(ERROR) << "Error reading build ID header.";
|
return false;
|
}
|
|
if (!ReadBuildIDMetadataWithoutHeader(data, build_id_header)) return false;
|
size -= build_id_header.size;
|
}
|
|
return true;
|
}
|
|
bool PerfReader::ReadBuildIDMetadataWithoutHeader(
|
DataReader* data, const perf_event_header& header) {
|
// Allocate memory for the event.
|
malloced_unique_ptr<build_id_event> event(
|
CallocMemoryForBuildID(header.size));
|
event->header = header;
|
|
// Make sure there is enough data for the rest of the event.
|
if (!data->ReadDataValue(header.size - sizeof(header),
|
"rest of build ID event", &event->header + 1)) {
|
LOG(ERROR) << "Not enough bytes to read build id event";
|
return false;
|
}
|
if (data->is_cross_endian()) ByteSwap(&event->pid);
|
|
// Perf tends to use more space than necessary, so fix the size.
|
event->header.size =
|
sizeof(*event) + GetUint64AlignedStringLength(event->filename);
|
|
if (!serializer_.SerializeBuildIDEvent(event, proto_->add_build_ids())) {
|
LOG(ERROR) << "Could not serialize build ID event with ID "
|
<< RawDataToHexString(event->build_id, sizeof(event->build_id));
|
return false;
|
}
|
return true;
|
}
|
|
bool PerfReader::ReadSingleStringMetadata(DataReader* data,
|
size_t max_readable_size,
|
StringAndMd5sumPrefix* dest) const {
|
// If a string metadata field is present but empty, it can have a size of 0,
|
// in which case there is nothing to be read.
|
string single_string;
|
if (max_readable_size && !data->ReadStringWithSizeFromData(&single_string))
|
return false;
|
dest->set_value(single_string);
|
dest->set_value_md5_prefix(Md5Prefix(single_string));
|
return true;
|
}
|
|
bool PerfReader::ReadRepeatedStringMetadata(
|
DataReader* data, size_t max_readable_size,
|
RepeatedPtrField<StringAndMd5sumPrefix>* dest_array,
|
StringAndMd5sumPrefix* dest_single) const {
|
num_string_data_type count = 1;
|
if (!data->ReadUint32(&count)) {
|
LOG(ERROR) << "Error reading string count.";
|
return false;
|
}
|
size_t size_read = sizeof(count);
|
|
string full_string;
|
while (count-- > 0 && size_read < max_readable_size) {
|
StringAndMd5sumPrefix* new_entry = dest_array->Add();
|
size_t offset = data->Tell();
|
if (!ReadSingleStringMetadata(data, max_readable_size - size_read,
|
new_entry)) {
|
return false;
|
}
|
|
if (!full_string.empty()) full_string += " ";
|
full_string += new_entry->value();
|
|
size_read += data->Tell() - offset;
|
}
|
|
dest_single->set_value(full_string);
|
dest_single->set_value_md5_prefix(Md5Prefix(full_string));
|
return true;
|
}
|
|
bool PerfReader::ReadUint32Metadata(DataReader* data, u32 type, size_t size) {
|
PerfUint32Metadata uint32_data;
|
uint32_data.type = type;
|
|
while (size > 0) {
|
uint32_t item;
|
if (!data->ReadUint32(&item)) {
|
LOG(ERROR) << "Error reading uint32 metadata";
|
return false;
|
}
|
|
uint32_data.data.push_back(item);
|
size -= sizeof(item);
|
}
|
|
serializer_.SerializeSingleUint32Metadata(uint32_data,
|
proto_->add_uint32_metadata());
|
return true;
|
}
|
|
bool PerfReader::ReadUint64Metadata(DataReader* data, u32 type, size_t size) {
|
PerfUint64Metadata uint64_data;
|
uint64_data.type = type;
|
|
while (size > 0) {
|
uint64_t item;
|
if (!data->ReadUint64(&item)) {
|
LOG(ERROR) << "Error reading uint64 metadata";
|
return false;
|
}
|
|
uint64_data.data.push_back(item);
|
size -= sizeof(item);
|
}
|
|
serializer_.SerializeSingleUint64Metadata(uint64_data,
|
proto_->add_uint64_metadata());
|
return true;
|
}
|
bool PerfReader::ReadEventDescMetadata(DataReader* data) {
|
// Structure:
|
// u32 nr_events
|
// u32 sizeof(perf_event_attr)
|
// foreach event (nr_events):
|
// struct perf_event_attr
|
// u32 nr_ids
|
// event name (len & string, 64-bit padded)
|
// u64 ids[nr_ids]
|
|
u32 nr_events;
|
if (!data->ReadUint32(&nr_events)) {
|
LOG(ERROR) << "Error reading event_desc nr_events.";
|
return false;
|
}
|
|
u32 attr_size;
|
if (!data->ReadUint32(&attr_size)) {
|
LOG(ERROR) << "Error reading event_desc attr_size.";
|
return false;
|
}
|
|
file_attrs_seen_.clear();
|
proto_->clear_file_attrs();
|
proto_->mutable_file_attrs()->Reserve(nr_events);
|
|
for (u32 i = 0; i < nr_events; i++) {
|
PerfFileAttr attr;
|
if (!ReadEventAttr(data, &attr.attr)) return false;
|
|
u32 nr_ids;
|
if (!data->ReadUint32(&nr_ids)) {
|
LOG(ERROR) << "Error reading event_desc nr_ids.";
|
return false;
|
}
|
|
if (!data->ReadStringWithSizeFromData(&attr.name)) return false;
|
std::vector<u64>& ids = attr.ids;
|
ids.resize(nr_ids);
|
for (u64& id : ids) {
|
if (!data->ReadUint64(&id)) {
|
LOG(ERROR) << "Error reading ID value for attr #" << i;
|
return false;
|
}
|
}
|
AddPerfFileAttr(attr);
|
// The EVENT_DESC metadata is the newer replacement for the older event type
|
// fields. In the protobuf, both types of data are stored in the
|
// |event_types| field.
|
serializer_.SerializePerfEventType(attr, proto_->add_event_types());
|
}
|
return true;
|
}
|
|
bool PerfReader::ReadCPUTopologyMetadata(DataReader* data) {
|
num_siblings_type num_core_siblings;
|
if (!data->ReadUint32(&num_core_siblings)) {
|
LOG(ERROR) << "Error reading num core siblings.";
|
return false;
|
}
|
|
PerfCPUTopologyMetadata cpu_topology;
|
cpu_topology.core_siblings.resize(num_core_siblings);
|
for (size_t i = 0; i < num_core_siblings; ++i) {
|
if (!data->ReadStringWithSizeFromData(&cpu_topology.core_siblings[i]))
|
return false;
|
}
|
|
num_siblings_type num_thread_siblings;
|
if (!data->ReadUint32(&num_thread_siblings)) {
|
LOG(ERROR) << "Error reading num core siblings.";
|
return false;
|
}
|
|
cpu_topology.thread_siblings.resize(num_thread_siblings);
|
for (size_t i = 0; i < num_thread_siblings; ++i) {
|
if (!data->ReadStringWithSizeFromData(&cpu_topology.thread_siblings[i]))
|
return false;
|
}
|
|
serializer_.SerializeCPUTopologyMetadata(cpu_topology,
|
proto_->mutable_cpu_topology());
|
return true;
|
}
|
|
bool PerfReader::ReadNUMATopologyMetadata(DataReader* data) {
|
numa_topology_num_nodes_type num_nodes;
|
if (!data->ReadUint32(&num_nodes)) {
|
LOG(ERROR) << "Error reading NUMA topology num nodes.";
|
return false;
|
}
|
|
for (size_t i = 0; i < num_nodes; ++i) {
|
PerfNodeTopologyMetadata node;
|
if (!data->ReadUint32(&node.id) || !data->ReadUint64(&node.total_memory) ||
|
!data->ReadUint64(&node.free_memory) ||
|
!data->ReadStringWithSizeFromData(&node.cpu_list)) {
|
LOG(ERROR) << "Error reading NUMA topology info for node #" << i;
|
return false;
|
}
|
serializer_.SerializeNodeTopologyMetadata(node,
|
proto_->add_numa_topology());
|
}
|
return true;
|
}
|
|
bool PerfReader::ReadPMUMappingsMetadata(DataReader* data, size_t size) {
|
pmu_mappings_num_mappings_type num_mappings;
|
auto begin_offset = data->Tell();
|
if (!data->ReadUint32(&num_mappings)) {
|
LOG(ERROR) << "Error reading the number of PMU mappings.";
|
return false;
|
}
|
|
// Check size of the data read in addition to the iteration based on the
|
// number of PMU mappings because the number of pmu mappings is always zero
|
// in piped perf.data file.
|
//
|
// The number of PMU mappings is initialized to zero and after all the
|
// mappings are wirtten to the perf.data files, this value is set to the
|
// number of PMU mappings written. This logic doesn't work in pipe mode. So,
|
// the number of PMU mappings is always zero.
|
// Fix to write the number of PMU mappings before writing the actual PMU
|
// mappings landed upstream in 4.14. But the check for size is required as
|
// long as there are machines with older version of perf.
|
for (u32 i = 0; i < num_mappings || data->Tell() - begin_offset < size; ++i) {
|
PerfPMUMappingsMetadata mapping;
|
if (!data->ReadUint32(&mapping.type) ||
|
!data->ReadStringWithSizeFromData(&mapping.name)) {
|
LOG(ERROR) << "Error reading PMU mapping info for mapping #" << i;
|
return false;
|
}
|
serializer_.SerializePMUMappingsMetadata(mapping,
|
proto_->add_pmu_mappings());
|
}
|
if (data->Tell() - begin_offset != size) {
|
LOG(ERROR) << "Size from the header doesn't match the read size";
|
return false;
|
}
|
return true;
|
}
|
|
bool PerfReader::ReadGroupDescMetadata(DataReader* data) {
|
group_desc_num_groups_type num_groups;
|
if (!data->ReadUint32(&num_groups)) {
|
LOG(ERROR) << "Error reading group desc num groups.";
|
return false;
|
}
|
|
for (u32 i = 0; i < num_groups; ++i) {
|
PerfGroupDescMetadata group;
|
if (!data->ReadStringWithSizeFromData(&group.name) ||
|
!data->ReadUint32(&group.leader_idx) ||
|
!data->ReadUint32(&group.num_members)) {
|
LOG(ERROR) << "Error reading group desc info for group #" << i;
|
return false;
|
}
|
serializer_.SerializeGroupDescMetadata(group, proto_->add_group_desc());
|
}
|
return true;
|
}
|
bool PerfReader::ReadTracingMetadata(DataReader* data, size_t size) {
|
std::vector<char> tracing_data(size);
|
if (!data->ReadDataValue(tracing_data.size(), "tracing_data",
|
tracing_data.data())) {
|
return false;
|
}
|
serializer_.SerializeTracingMetadata(tracing_data, proto_);
|
return true;
|
}
|
|
bool PerfReader::ReadFileData(DataReader* data) {
|
// Make sure sections are within the size of the file. This check prevents
|
// more obscure messages later when attempting to read from one of these
|
// sections.
|
if (header_.attrs.offset + header_.attrs.size > data->size()) {
|
LOG(ERROR) << "Header says attrs section ends at "
|
<< header_.attrs.offset + header_.attrs.size
|
<< " bytes, which is larger than perf data size of "
|
<< data->size() << " bytes.";
|
return false;
|
}
|
if (header_.data.offset + header_.data.size > data->size()) {
|
LOG(ERROR) << "Header says data section ends at "
|
<< header_.data.offset + header_.data.size
|
<< " bytes, which is larger than perf data size of "
|
<< data->size() << " bytes.";
|
return false;
|
}
|
if (header_.event_types.offset + header_.event_types.size > data->size()) {
|
LOG(ERROR) << "Header says event_types section ends at "
|
<< header_.event_types.offset + header_.event_types.size
|
<< " bytes, which is larger than perf data size of "
|
<< data->size() << " bytes.";
|
return false;
|
}
|
|
if (!get_metadata_mask_bit(HEADER_EVENT_DESC)) {
|
// Prefer to read attrs and event names from HEADER_EVENT_DESC metadata if
|
// available. event_types section of perf.data is obsolete, but use it as
|
// a fallback:
|
if (!(ReadAttrsSection(data) && ReadEventTypesSection(data))) return false;
|
}
|
|
if (!(ReadMetadata(data) && ReadDataSection(data))) return false;
|
|
// We can construct HEADER_EVENT_DESC from attrs and event types.
|
// NB: Can't set this before ReadMetadata(), or it may misread the metadata.
|
if (!event_types().empty()) set_metadata_mask_bit(HEADER_EVENT_DESC);
|
|
return true;
|
}
|
|
bool PerfReader::ReadPipedData(DataReader* data) {
|
// The piped data comes right after the file header.
|
CHECK_EQ(piped_header_.size, data->Tell());
|
bool result = true;
|
int num_event_types = 0;
|
|
CheckNoEventHeaderPadding();
|
|
while (result && data->Tell() < data->size()) {
|
perf_event_header header;
|
if (!ReadPerfEventHeader(data, &header)) {
|
LOG(ERROR) << "Error reading event header.";
|
break;
|
}
|
|
if (header.size == 0) {
|
// Avoid an infinite loop.
|
LOG(ERROR) << "Event size is zero. Type: " << header.type;
|
return false;
|
}
|
|
// Compute the size of the post-header part of the event data.
|
size_t size_without_header = header.size - sizeof(header);
|
|
bool isHeaderEventType = [&] {
|
switch (header.type) {
|
case PERF_RECORD_HEADER_ATTR:
|
case PERF_RECORD_HEADER_EVENT_TYPE:
|
case PERF_RECORD_HEADER_TRACING_DATA:
|
case PERF_RECORD_HEADER_BUILD_ID:
|
return true;
|
default:
|
return false;
|
}
|
}();
|
|
if (!isHeaderEventType) {
|
// Allocate space for an event struct based on the size in the header.
|
// Don't blindly allocate the entire event_t because it is a
|
// variable-sized type that may include data beyond what's nominally
|
// declared in its definition.
|
malloced_unique_ptr<event_t> event(CallocMemoryForEvent(header.size));
|
event->header = header;
|
|
// Read the rest of the event data.
|
if (!data->ReadDataValue(size_without_header, "rest of piped event",
|
&event->header + 1)) {
|
break;
|
}
|
MaybeSwapEventFields(event.get(), data->is_cross_endian());
|
|
// Serialize the event to protobuf form.
|
PerfEvent* proto_event = proto_->add_events();
|
if (!serializer_.SerializeEvent(event, proto_event)) return false;
|
|
if (proto_event->header().type() == PERF_RECORD_AUXTRACE) {
|
if (!ReadAuxtraceTraceData(data, proto_event)) return false;
|
}
|
continue;
|
}
|
|
result = [&] {
|
switch (header.type) {
|
case PERF_RECORD_HEADER_ATTR:
|
return ReadAttrEventBlock(data, size_without_header);
|
case PERF_RECORD_HEADER_EVENT_TYPE:
|
return ReadEventType(data, num_event_types++, header.size);
|
case PERF_RECORD_HEADER_TRACING_DATA:
|
set_metadata_mask_bit(HEADER_TRACING_DATA);
|
{
|
// TRACING_DATA's header.size is a lie. It is the size of only the
|
// event struct. The size of the data is in the event struct, and
|
// followed immediately by the tracing header data.
|
decltype(tracing_data_event::size) size = 0;
|
if (!data->ReadUint32(&size)) {
|
LOG(ERROR) << "Error reading tracing data size.";
|
return false;
|
}
|
return ReadTracingMetadata(data, size);
|
}
|
case PERF_RECORD_HEADER_BUILD_ID:
|
set_metadata_mask_bit(HEADER_BUILD_ID);
|
return ReadBuildIDMetadataWithoutHeader(data, header);
|
default:
|
// For unsupported event types, log a warning only if the type is an
|
// unknown type.
|
if (header.type < PERF_RECORD_USER_TYPE_START ||
|
header.type >= PERF_RECORD_HEADER_MAX) {
|
LOG(WARNING) << "Unknown event type: " << header.type;
|
}
|
// Skip over the data in this event.
|
data->SeekSet(data->Tell() + size_without_header);
|
return true;
|
}
|
}();
|
}
|
|
if (!result) return false;
|
|
// The PERF_RECORD_HEADER_EVENT_TYPE events are obsolete, but if present
|
// and PERF_RECORD_HEADER_EVENT_DESC metadata events are not, we should use
|
// them. Otherwise, we should use prefer the _EVENT_DESC data.
|
if (!get_metadata_mask_bit(HEADER_EVENT_DESC) &&
|
num_event_types == proto_->file_attrs().size()) {
|
// We can construct HEADER_EVENT_DESC:
|
set_metadata_mask_bit(HEADER_EVENT_DESC);
|
}
|
|
return result;
|
}
|
|
bool PerfReader::ReadAuxtraceTraceData(DataReader* data,
|
PerfEvent* proto_event) {
|
std::vector<char> trace_data(proto_event->auxtrace_event().size());
|
if (!data->ReadDataValue(trace_data.size(),
|
"trace date from PERF_RECORD_AUXTRACE event",
|
trace_data.data())) {
|
return false;
|
}
|
if (data->is_cross_endian()) {
|
LOG(ERROR) << "Cannot byteswap trace data from PERF_RECORD_AUXTRACE";
|
}
|
if (!serializer_.SerializeAuxtraceEventTraceData(
|
trace_data, proto_event->mutable_auxtrace_event())) {
|
return false;
|
}
|
return true;
|
}
|
|
bool PerfReader::WriteHeader(const struct perf_file_header& header,
|
DataWriter* data) const {
|
CheckNoEventHeaderPadding();
|
size_t size = sizeof(header);
|
return data->WriteDataValue(&header, size, "file header");
|
}
|
|
bool PerfReader::WriteAttrs(const struct perf_file_header& header,
|
DataWriter* data) const {
|
CheckNoPerfEventAttrPadding();
|
const size_t id_offset = header.size;
|
CHECK_EQ(id_offset, data->Tell());
|
|
std::vector<struct perf_file_section> id_sections;
|
id_sections.reserve(attrs().size());
|
for (const auto& attr : proto_->file_attrs()) {
|
size_t section_size =
|
attr.ids_size() * sizeof(decltype(PerfFileAttr::ids)::value_type);
|
id_sections.push_back(perf_file_section{data->Tell(), section_size});
|
for (const uint64_t& id : attr.ids()) {
|
if (!data->WriteDataValue(&id, sizeof(id), "ID info")) return false;
|
}
|
}
|
|
CHECK_EQ(header.attrs.offset, data->Tell());
|
for (int i = 0; i < attrs().size(); i++) {
|
const struct perf_file_section& id_section = id_sections[i];
|
PerfFileAttr attr;
|
serializer_.DeserializePerfFileAttr(proto_->file_attrs(i), &attr);
|
if (!data->WriteDataValue(&attr.attr, sizeof(attr.attr), "attribute") ||
|
!data->WriteDataValue(&id_section, sizeof(id_section), "ID section")) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PerfReader::WriteData(const struct perf_file_header& header,
|
DataWriter* data) const {
|
// No need to CHECK anything if no event data is being written.
|
if (proto_->events().empty()) return true;
|
|
CHECK(serializer_.SampleInfoReaderAvailable());
|
CHECK_EQ(header.data.offset, data->Tell());
|
for (const PerfEvent& proto_event : proto_->events()) {
|
malloced_unique_ptr<event_t> event;
|
// The nominal size given by |proto_event| may not be correct, as the
|
// contents may have changed since the PerfEvent was created. Use the size
|
// in the event_t returned by PerfSerializer::DeserializeEvent().
|
if (!serializer_.DeserializeEvent(proto_event, &event) ||
|
!data->WriteDataValue(event.get(), event->header.size, "event data")) {
|
return false;
|
}
|
// PERF_RECORD_AUXTRACE contains trace data that is written after writing
|
// the actual event data.
|
if (proto_event.header().type() == PERF_RECORD_AUXTRACE &&
|
proto_event.auxtrace_event().size() > 0) {
|
std::vector<char> trace_data;
|
if (!serializer_.DeserializeAuxtraceEventTraceData(
|
proto_event.auxtrace_event(), &trace_data) ||
|
!data->WriteDataValue(reinterpret_cast<void*>(trace_data.data()),
|
trace_data.size(),
|
"trace data from PERF_RECORD_AUXTRACE event")) {
|
return false;
|
}
|
}
|
}
|
return true;
|
}
|
|
bool PerfReader::WriteMetadata(const struct perf_file_header& header,
|
DataWriter* data) const {
|
const size_t header_offset = header.data.offset + header.data.size;
|
CHECK_EQ(header_offset, data->Tell());
|
|
// There is one header for each feature pointing to the metadata for that
|
// feature. If a feature has no metadata, the size field is zero.
|
const size_t headers_size =
|
GetNumSupportedMetadata() * sizeof(perf_file_section);
|
const size_t metadata_offset = header_offset + headers_size;
|
data->SeekSet(metadata_offset);
|
|
// Record the new metadata offsets and sizes in this vector of info entries.
|
std::vector<struct perf_file_section> metadata_sections;
|
metadata_sections.reserve(GetNumSupportedMetadata());
|
|
// For less verbose access to string metadata fields.
|
const auto& string_metadata = proto_->string_metadata();
|
|
for (u32 type = HEADER_FIRST_FEATURE; type != HEADER_LAST_FEATURE; ++type) {
|
if ((header.adds_features[0] & (1 << type)) == 0) continue;
|
|
struct perf_file_section header_entry;
|
header_entry.offset = data->Tell();
|
// Write actual metadata to address metadata_offset
|
switch (type) {
|
case HEADER_TRACING_DATA:
|
if (!data->WriteDataValue(tracing_data().data(), tracing_data().size(),
|
"tracing data")) {
|
return false;
|
}
|
break;
|
case HEADER_BUILD_ID:
|
if (!WriteBuildIDMetadata(type, data)) return false;
|
break;
|
case HEADER_HOSTNAME:
|
if (!WriteSingleStringMetadata(string_metadata.hostname(), data))
|
return false;
|
break;
|
case HEADER_OSRELEASE:
|
if (!WriteSingleStringMetadata(string_metadata.kernel_version(), data))
|
return false;
|
break;
|
case HEADER_VERSION:
|
if (!WriteSingleStringMetadata(string_metadata.perf_version(), data))
|
return false;
|
break;
|
case HEADER_ARCH:
|
if (!WriteSingleStringMetadata(string_metadata.architecture(), data))
|
return false;
|
break;
|
case HEADER_CPUDESC:
|
if (!WriteSingleStringMetadata(string_metadata.cpu_description(), data))
|
return false;
|
break;
|
case HEADER_CPUID:
|
if (!WriteSingleStringMetadata(string_metadata.cpu_id(), data))
|
return false;
|
break;
|
case HEADER_CMDLINE:
|
if (!WriteRepeatedStringMetadata(
|
string_metadata.perf_command_line_token(), data)) {
|
return false;
|
}
|
break;
|
case HEADER_NRCPUS:
|
if (!WriteUint32Metadata(type, data)) return false;
|
break;
|
case HEADER_TOTAL_MEM:
|
if (!WriteUint64Metadata(type, data)) return false;
|
break;
|
case HEADER_EVENT_DESC:
|
if (!WriteEventDescMetadata(data)) return false;
|
break;
|
case HEADER_CPU_TOPOLOGY:
|
if (!WriteCPUTopologyMetadata(data)) return false;
|
break;
|
case HEADER_NUMA_TOPOLOGY:
|
if (!WriteNUMATopologyMetadata(data)) return false;
|
break;
|
case HEADER_BRANCH_STACK:
|
break;
|
case HEADER_PMU_MAPPINGS:
|
if (!WritePMUMappingsMetadata(data)) return false;
|
break;
|
case HEADER_GROUP_DESC:
|
if (!WriteGroupDescMetadata(data)) return false;
|
break;
|
default:
|
LOG(ERROR) << "Unsupported metadata type: " << type;
|
return false;
|
}
|
|
// Compute the size of the metadata that was just written. This is reflected
|
// in how much the data write pointer has moved.
|
header_entry.size = data->Tell() - header_entry.offset;
|
metadata_sections.push_back(header_entry);
|
}
|
// Make sure we have recorded the right number of entries.
|
CHECK_EQ(GetNumSupportedMetadata(), metadata_sections.size());
|
|
// Now write the metadata offset and size info back to the metadata headers.
|
size_t old_offset = data->Tell();
|
data->SeekSet(header_offset);
|
if (!data->WriteDataValue(metadata_sections.data(), headers_size,
|
"metadata section info")) {
|
return false;
|
}
|
// Make sure the write pointer now points to the end of the metadata headers
|
// and hence the beginning of the actual metadata.
|
CHECK_EQ(metadata_offset, data->Tell());
|
data->SeekSet(old_offset);
|
|
return true;
|
}
|
|
bool PerfReader::WriteBuildIDMetadata(u32 type, DataWriter* data) const {
|
CheckNoBuildIDEventPadding();
|
for (const auto& build_id : proto_->build_ids()) {
|
malloced_unique_ptr<build_id_event> event;
|
if (!serializer_.DeserializeBuildIDEvent(build_id, &event)) {
|
LOG(ERROR) << "Could not deserialize build ID event with build ID "
|
<< RawDataToHexString(build_id.build_id_hash());
|
return false;
|
}
|
if (!data->WriteDataValue(event.get(), event->header.size,
|
"Build ID metadata")) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PerfReader::WriteSingleStringMetadata(const StringAndMd5sumPrefix& src,
|
DataWriter* data) const {
|
return data->WriteStringWithSizeToData(src.value());
|
}
|
|
bool PerfReader::WriteRepeatedStringMetadata(
|
const RepeatedPtrField<StringAndMd5sumPrefix>& src_array,
|
DataWriter* data) const {
|
num_string_data_type num_strings = src_array.size();
|
if (!data->WriteDataValue(&num_strings, sizeof(num_strings),
|
"number of string metadata")) {
|
return false;
|
}
|
for (const auto& src_entry : src_array) {
|
if (!data->WriteStringWithSizeToData(src_entry.value())) return false;
|
}
|
return true;
|
}
|
|
bool PerfReader::WriteUint32Metadata(u32 type, DataWriter* data) const {
|
for (const auto& metadata : proto_->uint32_metadata()) {
|
if (metadata.type() != type) continue;
|
PerfUint32Metadata local_metadata;
|
serializer_.DeserializeSingleUint32Metadata(metadata, &local_metadata);
|
const std::vector<uint32_t>& raw_data = local_metadata.data;
|
return data->WriteDataValue(raw_data.data(),
|
raw_data.size() * sizeof(uint32_t),
|
"uint32_t metadata");
|
}
|
LOG(ERROR) << "Uint32 metadata of type " << type << " not present";
|
return false;
|
}
|
|
bool PerfReader::WriteUint64Metadata(u32 type, DataWriter* data) const {
|
for (const auto& metadata : proto_->uint64_metadata()) {
|
if (metadata.type() != type) continue;
|
PerfUint64Metadata local_metadata;
|
serializer_.DeserializeSingleUint64Metadata(metadata, &local_metadata);
|
const std::vector<uint64_t>& raw_data = local_metadata.data;
|
return data->WriteDataValue(raw_data.data(),
|
raw_data.size() * sizeof(uint64_t),
|
"uint32_t metadata");
|
}
|
LOG(ERROR) << "Uint64 metadata of type " << type << " not present";
|
return false;
|
}
|
|
bool PerfReader::WriteEventDescMetadata(DataWriter* data) const {
|
CheckNoPerfEventAttrPadding();
|
|
if (attrs().size() > event_types().size()) {
|
LOG(ERROR) << "Number of attrs (" << attrs().size() << ") cannot exceed "
|
<< "number of event types (" << event_types().size() << ")";
|
return false;
|
}
|
|
event_desc_num_events num_events = proto_->file_attrs().size();
|
if (!data->WriteDataValue(&num_events, sizeof(num_events),
|
"event_desc num_events")) {
|
return false;
|
}
|
event_desc_attr_size attr_size = sizeof(perf_event_attr);
|
if (!data->WriteDataValue(&attr_size, sizeof(attr_size),
|
"event_desc attr_size")) {
|
return false;
|
}
|
|
for (int i = 0; i < attrs().size(); ++i) {
|
const auto& stored_attr = attrs().Get(i);
|
PerfFileAttr attr;
|
serializer_.DeserializePerfFileAttr(stored_attr, &attr);
|
if (!serializer_.DeserializePerfEventType(proto_->event_types(i), &attr))
|
return false;
|
|
if (!data->WriteDataValue(&attr.attr, sizeof(attr.attr),
|
"event_desc attribute")) {
|
return false;
|
}
|
|
event_desc_num_unique_ids num_ids = attr.ids.size();
|
if (!data->WriteDataValue(&num_ids, sizeof(num_ids),
|
"event_desc num_unique_ids")) {
|
return false;
|
}
|
|
if (!data->WriteStringWithSizeToData(attr.name)) return false;
|
|
if (!data->WriteDataValue(attr.ids.data(), num_ids * sizeof(attr.ids[0]),
|
"event_desc unique_ids")) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PerfReader::WriteCPUTopologyMetadata(DataWriter* data) const {
|
PerfCPUTopologyMetadata cpu_topology;
|
serializer_.DeserializeCPUTopologyMetadata(proto_->cpu_topology(),
|
&cpu_topology);
|
|
std::vector<string>& cores = cpu_topology.core_siblings;
|
num_siblings_type num_cores = cores.size();
|
if (!data->WriteDataValue(&num_cores, sizeof(num_cores), "num cores"))
|
return false;
|
for (string& core_name : cores) {
|
if (!data->WriteStringWithSizeToData(core_name)) return false;
|
}
|
|
std::vector<string>& threads = cpu_topology.thread_siblings;
|
num_siblings_type num_threads = threads.size();
|
if (!data->WriteDataValue(&num_threads, sizeof(num_threads), "num threads"))
|
return false;
|
for (string& thread_name : threads) {
|
if (!data->WriteStringWithSizeToData(thread_name)) return false;
|
}
|
|
return true;
|
}
|
|
bool PerfReader::WriteNUMATopologyMetadata(DataWriter* data) const {
|
numa_topology_num_nodes_type num_nodes = proto_->numa_topology().size();
|
if (!data->WriteDataValue(&num_nodes, sizeof(num_nodes), "num nodes"))
|
return false;
|
|
for (const auto& node_proto : proto_->numa_topology()) {
|
PerfNodeTopologyMetadata node;
|
serializer_.DeserializeNodeTopologyMetadata(node_proto, &node);
|
|
if (!data->WriteDataValue(&node.id, sizeof(node.id), "node id") ||
|
!data->WriteDataValue(&node.total_memory, sizeof(node.total_memory),
|
"node total memory") ||
|
!data->WriteDataValue(&node.free_memory, sizeof(node.free_memory),
|
"node free memory") ||
|
!data->WriteStringWithSizeToData(node.cpu_list)) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PerfReader::WritePMUMappingsMetadata(DataWriter* data) const {
|
pmu_mappings_num_mappings_type num_mappings = proto_->pmu_mappings().size();
|
if (!data->WriteDataValue(&num_mappings, sizeof(num_mappings),
|
"num mappings"))
|
return false;
|
|
for (const auto& mapping_proto : proto_->pmu_mappings()) {
|
PerfPMUMappingsMetadata mapping;
|
serializer_.DeserializePMUMappingsMetadata(mapping_proto, &mapping);
|
|
if (!data->WriteDataValue(&mapping.type, sizeof(mapping.type),
|
"mapping type") ||
|
!data->WriteStringWithSizeToData(mapping.name)) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PerfReader::WriteGroupDescMetadata(DataWriter* data) const {
|
group_desc_num_groups_type num_groups = proto_->group_desc().size();
|
if (!data->WriteDataValue(&num_groups, sizeof(num_groups), "num groups"))
|
return false;
|
|
for (const auto& group_proto : proto_->group_desc()) {
|
PerfGroupDescMetadata group;
|
serializer_.DeserializeGroupDescMetadata(group_proto, &group);
|
|
if (!data->WriteStringWithSizeToData(group.name) ||
|
!data->WriteDataValue(&group.leader_idx, sizeof(group.leader_idx),
|
"group leader index") ||
|
!data->WriteDataValue(&group.num_members, sizeof(group.num_members),
|
"group num members")) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PerfReader::ReadAttrEventBlock(DataReader* data, size_t size) {
|
const size_t initial_offset = data->Tell();
|
PerfFileAttr attr;
|
if (!ReadEventAttr(data, &attr.attr)) return false;
|
|
// attr.attr.size has been upgraded to the current size of perf_event_attr.
|
const size_t actual_attr_size = data->Tell() - initial_offset;
|
|
const size_t num_ids =
|
(size - actual_attr_size) / sizeof(decltype(attr.ids)::value_type);
|
if (!ReadUniqueIDs(data, num_ids, &attr.ids)) return false;
|
|
// Event types are found many times in the perf data file.
|
// Only add this event type if it is not already present.
|
if (!attr.ids.empty() &&
|
file_attrs_seen_.find(attr.ids[0]) != file_attrs_seen_.end()) {
|
return true;
|
}
|
|
AddPerfFileAttr(attr);
|
return true;
|
}
|
|
void PerfReader::MaybeSwapEventFields(event_t* event, bool is_cross_endian) {
|
if (!is_cross_endian) return;
|
uint32_t type = event->header.type;
|
switch (type) {
|
case PERF_RECORD_SAMPLE:
|
break;
|
case PERF_RECORD_MMAP:
|
ByteSwap(&event->mmap.pid);
|
ByteSwap(&event->mmap.tid);
|
ByteSwap(&event->mmap.start);
|
ByteSwap(&event->mmap.len);
|
ByteSwap(&event->mmap.pgoff);
|
break;
|
case PERF_RECORD_MMAP2:
|
ByteSwap(&event->mmap2.pid);
|
ByteSwap(&event->mmap2.tid);
|
ByteSwap(&event->mmap2.start);
|
ByteSwap(&event->mmap2.len);
|
ByteSwap(&event->mmap2.pgoff);
|
ByteSwap(&event->mmap2.maj);
|
ByteSwap(&event->mmap2.min);
|
ByteSwap(&event->mmap2.ino);
|
ByteSwap(&event->mmap2.ino_generation);
|
ByteSwap(&event->mmap2.prot);
|
ByteSwap(&event->mmap2.flags);
|
break;
|
case PERF_RECORD_FORK:
|
case PERF_RECORD_EXIT:
|
ByteSwap(&event->fork.pid);
|
ByteSwap(&event->fork.tid);
|
ByteSwap(&event->fork.ppid);
|
ByteSwap(&event->fork.ptid);
|
ByteSwap(&event->fork.time);
|
break;
|
case PERF_RECORD_COMM:
|
ByteSwap(&event->comm.pid);
|
ByteSwap(&event->comm.tid);
|
break;
|
case PERF_RECORD_LOST:
|
ByteSwap(&event->lost.id);
|
ByteSwap(&event->lost.lost);
|
break;
|
case PERF_RECORD_THROTTLE:
|
case PERF_RECORD_UNTHROTTLE:
|
ByteSwap(&event->throttle.time);
|
ByteSwap(&event->throttle.id);
|
ByteSwap(&event->throttle.stream_id);
|
break;
|
case PERF_RECORD_READ:
|
ByteSwap(&event->read.pid);
|
ByteSwap(&event->read.tid);
|
ByteSwap(&event->read.value);
|
ByteSwap(&event->read.time_enabled);
|
ByteSwap(&event->read.time_running);
|
ByteSwap(&event->read.id);
|
break;
|
case PERF_RECORD_AUX:
|
ByteSwap(&event->aux.aux_offset);
|
ByteSwap(&event->aux.aux_size);
|
ByteSwap(&event->aux.flags);
|
break;
|
case PERF_RECORD_AUXTRACE:
|
ByteSwap(&event->auxtrace.size);
|
ByteSwap(&event->auxtrace.offset);
|
ByteSwap(&event->auxtrace.reference);
|
ByteSwap(&event->auxtrace.idx);
|
ByteSwap(&event->auxtrace.tid);
|
ByteSwap(&event->auxtrace.cpu);
|
break;
|
default:
|
LOG(FATAL) << "Unknown event type: " << type;
|
}
|
|
// Do not swap the sample info fields that are not explicitly listed in the
|
// struct definition of each event type. Leave that up to SampleInfoReader
|
// within |serializer_|.
|
}
|
|
size_t PerfReader::GetNumSupportedMetadata() const {
|
return GetNumBits(metadata_mask() & kSupportedMetadataMask);
|
}
|
|
size_t PerfReader::GetEventDescMetadataSize() const {
|
if (attrs().size() > event_types().size()) {
|
LOG(ERROR) << "Number of attrs (" << attrs().size() << ") cannot exceed "
|
<< "number of event types (" << event_types().size() << ")";
|
return 0;
|
}
|
|
size_t size = 0;
|
if (get_metadata_mask_bit(HEADER_EVENT_DESC)) {
|
size += sizeof(event_desc_num_events) + sizeof(event_desc_attr_size);
|
for (int i = 0; i < attrs().size(); ++i) {
|
size += sizeof(perf_event_attr);
|
size += sizeof(event_desc_num_unique_ids);
|
size += ExpectedStorageSizeOf(event_types().Get(i).name());
|
size += attrs().Get(i).ids_size() *
|
sizeof(decltype(PerfFileAttr::ids)::value_type);
|
}
|
}
|
return size;
|
}
|
|
size_t PerfReader::GetBuildIDMetadataSize() const {
|
size_t size = 0;
|
for (const auto& build_id : proto_->build_ids()) {
|
size += sizeof(build_id_event) +
|
GetUint64AlignedStringLength(build_id.filename());
|
}
|
return size;
|
}
|
|
size_t PerfReader::GetStringMetadataSize() const {
|
size_t size = 0;
|
if (string_metadata().has_hostname())
|
size += ExpectedStorageSizeOf(string_metadata().hostname().value());
|
if (string_metadata().has_kernel_version())
|
size += ExpectedStorageSizeOf(string_metadata().kernel_version().value());
|
if (string_metadata().has_perf_version())
|
size += ExpectedStorageSizeOf(string_metadata().perf_version().value());
|
if (string_metadata().has_architecture())
|
size += ExpectedStorageSizeOf(string_metadata().architecture().value());
|
if (string_metadata().has_cpu_description())
|
size += ExpectedStorageSizeOf(string_metadata().cpu_description().value());
|
if (string_metadata().has_cpu_id())
|
size += ExpectedStorageSizeOf(string_metadata().cpu_id().value());
|
|
if (!string_metadata().perf_command_line_token().empty()) {
|
size += sizeof(num_string_data_type);
|
for (const auto& token : string_metadata().perf_command_line_token())
|
size += ExpectedStorageSizeOf(token.value());
|
}
|
return size;
|
}
|
|
size_t PerfReader::GetUint32MetadataSize() const {
|
size_t size = 0;
|
for (const auto& metadata : proto_->uint32_metadata())
|
size += metadata.data().size() * sizeof(uint32_t);
|
return size;
|
}
|
|
size_t PerfReader::GetUint64MetadataSize() const {
|
size_t size = 0;
|
for (const auto& metadata : proto_->uint64_metadata())
|
size += metadata.data().size() * sizeof(uint64_t);
|
return size;
|
}
|
|
size_t PerfReader::GetCPUTopologyMetadataSize() const {
|
// Core siblings.
|
size_t size = sizeof(num_siblings_type);
|
for (const string& core_sibling : proto_->cpu_topology().core_siblings())
|
size += ExpectedStorageSizeOf(core_sibling);
|
|
// Thread siblings.
|
size += sizeof(num_siblings_type);
|
for (const string& thread_sibling : proto_->cpu_topology().thread_siblings())
|
size += ExpectedStorageSizeOf(thread_sibling);
|
|
return size;
|
}
|
|
size_t PerfReader::GetNUMATopologyMetadataSize() const {
|
size_t size = sizeof(numa_topology_num_nodes_type);
|
for (const auto& node : proto_->numa_topology()) {
|
size += sizeof(node.id());
|
size += sizeof(node.total_memory()) + sizeof(node.free_memory());
|
size += ExpectedStorageSizeOf(node.cpu_list());
|
}
|
return size;
|
}
|
|
size_t PerfReader::GetPMUMappingsMetadataSize() const {
|
size_t size = sizeof(pmu_mappings_num_mappings_type);
|
for (const auto& node : proto_->pmu_mappings()) {
|
size += sizeof(node.type());
|
size += ExpectedStorageSizeOf(node.name());
|
}
|
return size;
|
}
|
|
size_t PerfReader::GetGroupDescMetadataSize() const {
|
size_t size = sizeof(group_desc_num_groups_type);
|
for (const auto& group : proto_->group_desc()) {
|
size += ExpectedStorageSizeOf(group.name());
|
size += sizeof(group.leader_idx());
|
size += sizeof(group.num_members());
|
}
|
return size;
|
}
|
|
bool PerfReader::NeedsNumberOfStringData(u32 type) const {
|
return type == HEADER_CMDLINE;
|
}
|
|
bool PerfReader::LocalizeMMapFilenames(
|
const std::map<string, string>& filename_map) {
|
CHECK(serializer_.SampleInfoReaderAvailable());
|
|
// Search for mmap/mmap2 events for which the filename needs to be updated.
|
for (PerfEvent& event : *proto_->mutable_events()) {
|
if (event.header().type() != PERF_RECORD_MMAP &&
|
event.header().type() != PERF_RECORD_MMAP2) {
|
continue;
|
}
|
const string& filename = event.mmap_event().filename();
|
const auto it = filename_map.find(filename);
|
if (it == filename_map.end()) // not found
|
continue;
|
|
const string& new_filename = it->second;
|
size_t old_len = GetUint64AlignedStringLength(filename);
|
size_t new_len = GetUint64AlignedStringLength(new_filename);
|
size_t new_size = event.header().size() - old_len + new_len;
|
|
event.mutable_mmap_event()->set_filename(new_filename);
|
event.mutable_header()->set_size(new_size);
|
}
|
|
return true;
|
}
|
|
void PerfReader::AddPerfFileAttr(const PerfFileAttr& attr) {
|
serializer_.SerializePerfFileAttr(attr, proto_->add_file_attrs());
|
|
// Generate a new SampleInfoReader with the new attr.
|
serializer_.CreateSampleInfoReader(attr, is_cross_endian_);
|
if (!attr.ids.empty()) {
|
file_attrs_seen_.insert(attr.ids[0]);
|
}
|
}
|
|
} // namespace quipper
|
