| // 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 |
