// 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_serializer.h"
|
|
#include <stdint.h>
|
#include <stdio.h>
|
#include <sys/time.h>
|
|
#include <algorithm> // for std::copy
|
|
#include "base/logging.h"
|
|
#include "binary_data_utils.h"
|
#include "compat/proto.h"
|
#include "compat/string.h"
|
#include "kernel/perf_event.h"
|
#include "perf_data_structures.h"
|
#include "perf_data_utils.h"
|
#include "perf_parser.h"
|
#include "perf_reader.h"
|
|
namespace quipper {
|
|
PerfSerializer::PerfSerializer() {}
|
|
PerfSerializer::~PerfSerializer() {}
|
|
bool PerfSerializer::SerializePerfFileAttr(
|
const PerfFileAttr& perf_file_attr,
|
PerfDataProto_PerfFileAttr* perf_file_attr_proto) const {
|
if (!SerializePerfEventAttr(perf_file_attr.attr,
|
perf_file_attr_proto->mutable_attr())) {
|
return false;
|
}
|
|
for (size_t i = 0; i < perf_file_attr.ids.size(); i++)
|
perf_file_attr_proto->add_ids(perf_file_attr.ids[i]);
|
return true;
|
}
|
|
bool PerfSerializer::DeserializePerfFileAttr(
|
const PerfDataProto_PerfFileAttr& perf_file_attr_proto,
|
PerfFileAttr* perf_file_attr) const {
|
if (!DeserializePerfEventAttr(perf_file_attr_proto.attr(),
|
&perf_file_attr->attr)) {
|
return false;
|
}
|
|
for (int i = 0; i < perf_file_attr_proto.ids_size(); i++)
|
perf_file_attr->ids.push_back(perf_file_attr_proto.ids(i));
|
return true;
|
}
|
|
bool PerfSerializer::SerializePerfEventAttr(
|
const perf_event_attr& perf_event_attr,
|
PerfDataProto_PerfEventAttr* perf_event_attr_proto) const {
|
#define S(x) perf_event_attr_proto->set_##x(perf_event_attr.x)
|
S(type);
|
S(size);
|
S(config);
|
if (perf_event_attr_proto->freq())
|
S(sample_freq);
|
else
|
S(sample_period);
|
S(sample_type);
|
S(read_format);
|
S(disabled);
|
S(inherit);
|
S(pinned);
|
S(exclusive);
|
S(exclude_user);
|
S(exclude_kernel);
|
S(exclude_hv);
|
S(exclude_idle);
|
S(mmap);
|
S(comm);
|
S(freq);
|
S(inherit_stat);
|
S(enable_on_exec);
|
S(task);
|
S(watermark);
|
S(precise_ip);
|
S(mmap_data);
|
S(sample_id_all);
|
S(exclude_host);
|
S(exclude_guest);
|
S(exclude_callchain_kernel);
|
S(exclude_callchain_user);
|
S(mmap2);
|
S(comm_exec);
|
if (perf_event_attr_proto->watermark())
|
S(wakeup_watermark);
|
else
|
S(wakeup_events);
|
S(bp_type);
|
S(bp_addr);
|
S(bp_len);
|
S(branch_sample_type);
|
S(sample_regs_user);
|
S(sample_stack_user);
|
#undef S
|
return true;
|
}
|
|
bool PerfSerializer::DeserializePerfEventAttr(
|
const PerfDataProto_PerfEventAttr& perf_event_attr_proto,
|
perf_event_attr* perf_event_attr) const {
|
memset(perf_event_attr, 0, sizeof(*perf_event_attr));
|
#define S(x) perf_event_attr->x = perf_event_attr_proto.x()
|
S(type);
|
S(size);
|
S(config);
|
if (perf_event_attr->freq)
|
S(sample_freq);
|
else
|
S(sample_period);
|
S(sample_type);
|
S(read_format);
|
S(disabled);
|
S(inherit);
|
S(pinned);
|
S(exclusive);
|
S(exclude_user);
|
S(exclude_kernel);
|
S(exclude_hv);
|
S(exclude_idle);
|
S(mmap);
|
S(comm);
|
S(freq);
|
S(inherit_stat);
|
S(enable_on_exec);
|
S(task);
|
S(watermark);
|
S(precise_ip);
|
S(mmap_data);
|
S(sample_id_all);
|
S(exclude_host);
|
S(exclude_guest);
|
S(exclude_callchain_kernel);
|
S(exclude_callchain_user);
|
S(mmap2);
|
S(comm_exec);
|
if (perf_event_attr->watermark)
|
S(wakeup_watermark);
|
else
|
S(wakeup_events);
|
S(bp_type);
|
S(bp_addr);
|
S(bp_len);
|
S(branch_sample_type);
|
S(sample_regs_user);
|
S(sample_stack_user);
|
#undef S
|
return true;
|
}
|
|
bool PerfSerializer::SerializePerfEventType(
|
const PerfFileAttr& event_attr,
|
quipper::PerfDataProto_PerfEventType* event_type_proto) const {
|
event_type_proto->set_id(event_attr.attr.config);
|
event_type_proto->set_name(event_attr.name);
|
event_type_proto->set_name_md5_prefix(Md5Prefix(event_attr.name));
|
return true;
|
}
|
|
bool PerfSerializer::DeserializePerfEventType(
|
const quipper::PerfDataProto_PerfEventType& event_type_proto,
|
PerfFileAttr* event_attr) const {
|
// Attr should have already been deserialized.
|
if (event_attr->attr.config != event_type_proto.id()) {
|
LOG(ERROR) << "Event type ID " << event_type_proto.id()
|
<< " does not match attr.config " << event_attr->attr.config
|
<< ". Not deserializing the event name!";
|
return false;
|
}
|
event_attr->name = event_type_proto.name();
|
return true;
|
}
|
|
bool PerfSerializer::SerializeEvent(
|
const malloced_unique_ptr<event_t>& event_ptr,
|
PerfDataProto_PerfEvent* event_proto) const {
|
const event_t& event = *event_ptr;
|
|
if (!SerializeEventHeader(event.header, event_proto->mutable_header()))
|
return false;
|
|
if (event.header.type >= PERF_RECORD_USER_TYPE_START) {
|
if (!SerializeUserEvent(event, event_proto)) {
|
return false;
|
}
|
} else if (!SerializeKernelEvent(event, event_proto)) {
|
return false;
|
}
|
|
event_proto->set_timestamp(GetTimeFromPerfEvent(*event_proto));
|
return true;
|
}
|
|
bool PerfSerializer::SerializeKernelEvent(
|
const event_t& event, PerfDataProto_PerfEvent* event_proto) const {
|
switch (event.header.type) {
|
case PERF_RECORD_SAMPLE:
|
return SerializeSampleEvent(event, event_proto->mutable_sample_event());
|
case PERF_RECORD_MMAP:
|
return SerializeMMapEvent(event, event_proto->mutable_mmap_event());
|
case PERF_RECORD_MMAP2:
|
return SerializeMMap2Event(event, event_proto->mutable_mmap_event());
|
case PERF_RECORD_COMM:
|
return SerializeCommEvent(event, event_proto->mutable_comm_event());
|
case PERF_RECORD_EXIT:
|
return SerializeForkExitEvent(event, event_proto->mutable_exit_event());
|
case PERF_RECORD_FORK:
|
return SerializeForkExitEvent(event, event_proto->mutable_fork_event());
|
case PERF_RECORD_LOST:
|
return SerializeLostEvent(event, event_proto->mutable_lost_event());
|
case PERF_RECORD_THROTTLE:
|
case PERF_RECORD_UNTHROTTLE:
|
return SerializeThrottleEvent(event,
|
event_proto->mutable_throttle_event());
|
case PERF_RECORD_READ:
|
return SerializeReadEvent(event, event_proto->mutable_read_event());
|
case PERF_RECORD_AUX:
|
return SerializeAuxEvent(event, event_proto->mutable_aux_event());
|
default:
|
LOG(ERROR) << "Unknown event type: " << event.header.type;
|
}
|
return true;
|
}
|
|
bool PerfSerializer::SerializeUserEvent(
|
const event_t& event, PerfDataProto_PerfEvent* event_proto) const {
|
switch (event.header.type) {
|
case PERF_RECORD_AUXTRACE:
|
return SerializeAuxtraceEvent(event,
|
event_proto->mutable_auxtrace_event());
|
default:
|
if (event.header.type >= PERF_RECORD_HEADER_MAX) {
|
LOG(ERROR) << "Unknown event type: " << event.header.type;
|
}
|
}
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeEvent(
|
const PerfDataProto_PerfEvent& event_proto,
|
malloced_unique_ptr<event_t>* event_ptr) const {
|
event_ptr->reset(CallocMemoryForEvent(event_proto.header().size()));
|
event_t* event = event_ptr->get();
|
|
if (!DeserializeEventHeader(event_proto.header(), &event->header))
|
return false;
|
|
bool event_deserialized = false;
|
if (event_proto.header().type() >= PERF_RECORD_USER_TYPE_START) {
|
event_deserialized = DeserializeUserEvent(event_proto, event);
|
} else {
|
event_deserialized = DeserializeKernelEvent(event_proto, event);
|
}
|
|
if (!event_deserialized) {
|
LOG(ERROR) << "Could not deserialize event of type "
|
<< event_proto.header().type();
|
return false;
|
}
|
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeKernelEvent(
|
const PerfDataProto_PerfEvent& event_proto, event_t* event) const {
|
switch (event_proto.header().type()) {
|
case PERF_RECORD_SAMPLE:
|
return DeserializeSampleEvent(event_proto.sample_event(), event);
|
case PERF_RECORD_MMAP:
|
return DeserializeMMapEvent(event_proto.mmap_event(), event);
|
case PERF_RECORD_MMAP2:
|
return DeserializeMMap2Event(event_proto.mmap_event(), event);
|
case PERF_RECORD_COMM:
|
return DeserializeCommEvent(event_proto.comm_event(), event);
|
case PERF_RECORD_EXIT:
|
return (event_proto.has_exit_event() &&
|
DeserializeForkExitEvent(event_proto.exit_event(), event)) ||
|
(event_proto.has_fork_event() &&
|
DeserializeForkExitEvent(event_proto.fork_event(), event));
|
// Some older protobufs use the |fork_event| field to store exit
|
// events.
|
case PERF_RECORD_FORK:
|
return DeserializeForkExitEvent(event_proto.fork_event(), event);
|
case PERF_RECORD_LOST:
|
return DeserializeLostEvent(event_proto.lost_event(), event);
|
case PERF_RECORD_THROTTLE:
|
case PERF_RECORD_UNTHROTTLE:
|
return DeserializeThrottleEvent(event_proto.throttle_event(), event);
|
case PERF_RECORD_READ:
|
return DeserializeReadEvent(event_proto.read_event(), event);
|
case PERF_RECORD_AUX:
|
return DeserializeAuxEvent(event_proto.aux_event(), event);
|
case PERF_RECORD_ITRACE_START:
|
case PERF_RECORD_LOST_SAMPLES:
|
case PERF_RECORD_SWITCH:
|
case PERF_RECORD_SWITCH_CPU_WIDE:
|
case PERF_RECORD_NAMESPACES:
|
LOG(ERROR) << "Event type: " << event_proto.header().type()
|
<< ". Not yet supported.";
|
return true;
|
break;
|
}
|
return false;
|
}
|
|
bool PerfSerializer::DeserializeUserEvent(
|
const PerfDataProto_PerfEvent& event_proto, event_t* event) const {
|
switch (event_proto.header().type()) {
|
case PERF_RECORD_AUXTRACE:
|
return DeserializeAuxtraceEvent(event_proto.auxtrace_event(), event);
|
default:
|
// User type events are marked as deserialized because they don't
|
// have non-header data in perf.data proto.
|
if (event_proto.header().type() >= PERF_RECORD_HEADER_MAX) {
|
return false;
|
}
|
}
|
return true;
|
}
|
|
bool PerfSerializer::SerializeEventHeader(
|
const perf_event_header& header,
|
PerfDataProto_EventHeader* header_proto) const {
|
header_proto->set_type(header.type);
|
header_proto->set_misc(header.misc);
|
header_proto->set_size(header.size);
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeEventHeader(
|
const PerfDataProto_EventHeader& header_proto,
|
perf_event_header* header) const {
|
header->type = header_proto.type();
|
header->misc = header_proto.misc();
|
header->size = header_proto.size();
|
return true;
|
}
|
|
bool PerfSerializer::SerializeSampleEvent(
|
const event_t& event, PerfDataProto_SampleEvent* sample) const {
|
perf_sample sample_info;
|
uint64_t sample_type = 0;
|
if (!ReadPerfSampleInfoAndType(event, &sample_info, &sample_type))
|
return false;
|
|
if (sample_type & PERF_SAMPLE_IP) sample->set_ip(sample_info.ip);
|
if (sample_type & PERF_SAMPLE_TID) {
|
sample->set_pid(sample_info.pid);
|
sample->set_tid(sample_info.tid);
|
}
|
if (sample_type & PERF_SAMPLE_TIME)
|
sample->set_sample_time_ns(sample_info.time);
|
if (sample_type & PERF_SAMPLE_ADDR) sample->set_addr(sample_info.addr);
|
if ((sample_type & PERF_SAMPLE_ID) || (sample_type & PERF_SAMPLE_IDENTIFIER))
|
sample->set_id(sample_info.id);
|
if (sample_type & PERF_SAMPLE_STREAM_ID)
|
sample->set_stream_id(sample_info.stream_id);
|
if (sample_type & PERF_SAMPLE_CPU) sample->set_cpu(sample_info.cpu);
|
if (sample_type & PERF_SAMPLE_PERIOD) sample->set_period(sample_info.period);
|
if (sample_type & PERF_SAMPLE_RAW) sample->set_raw_size(sample_info.raw_size);
|
if (sample_type & PERF_SAMPLE_READ) {
|
const SampleInfoReader* reader = GetSampleInfoReaderForEvent(event);
|
if (reader) {
|
PerfDataProto_ReadInfo* read_info = sample->mutable_read_info();
|
if (reader->event_attr().read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
|
read_info->set_time_enabled(sample_info.read.time_enabled);
|
if (reader->event_attr().read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
|
read_info->set_time_running(sample_info.read.time_running);
|
if (reader->event_attr().read_format & PERF_FORMAT_GROUP) {
|
for (size_t i = 0; i < sample_info.read.group.nr; i++) {
|
auto read_value = read_info->add_read_value();
|
read_value->set_value(sample_info.read.group.values[i].value);
|
read_value->set_id(sample_info.read.group.values[i].id);
|
}
|
} else {
|
auto read_value = read_info->add_read_value();
|
read_value->set_value(sample_info.read.one.value);
|
read_value->set_id(sample_info.read.one.id);
|
}
|
}
|
}
|
if (sample_type & PERF_SAMPLE_CALLCHAIN) {
|
sample->mutable_callchain()->Reserve(sample_info.callchain->nr);
|
for (size_t i = 0; i < sample_info.callchain->nr; ++i)
|
sample->add_callchain(sample_info.callchain->ips[i]);
|
}
|
if (sample_type & PERF_SAMPLE_BRANCH_STACK) {
|
for (size_t i = 0; i < sample_info.branch_stack->nr; ++i) {
|
sample->add_branch_stack();
|
const struct branch_entry& entry = sample_info.branch_stack->entries[i];
|
sample->mutable_branch_stack(i)->set_from_ip(entry.from);
|
sample->mutable_branch_stack(i)->set_to_ip(entry.to);
|
sample->mutable_branch_stack(i)->set_mispredicted(entry.flags.mispred);
|
}
|
}
|
|
if (sample_type & PERF_SAMPLE_WEIGHT) sample->set_weight(sample_info.weight);
|
if (sample_type & PERF_SAMPLE_DATA_SRC)
|
sample->set_data_src(sample_info.data_src);
|
if (sample_type & PERF_SAMPLE_TRANSACTION)
|
sample->set_transaction(sample_info.transaction);
|
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeSampleEvent(
|
const PerfDataProto_SampleEvent& sample, event_t* event) const {
|
perf_sample sample_info;
|
if (sample.has_ip()) sample_info.ip = sample.ip();
|
if (sample.has_pid()) {
|
CHECK(sample.has_tid()) << "Cannot have PID without TID.";
|
sample_info.pid = sample.pid();
|
sample_info.tid = sample.tid();
|
}
|
if (sample.has_sample_time_ns()) sample_info.time = sample.sample_time_ns();
|
if (sample.has_addr()) sample_info.addr = sample.addr();
|
if (sample.has_id()) sample_info.id = sample.id();
|
if (sample.has_stream_id()) sample_info.stream_id = sample.stream_id();
|
if (sample.has_cpu()) sample_info.cpu = sample.cpu();
|
if (sample.has_period()) sample_info.period = sample.period();
|
if (sample.has_read_info()) {
|
const SampleInfoReader* reader = GetSampleInfoReaderForEvent(*event);
|
if (reader) {
|
const PerfDataProto_ReadInfo& read_info = sample.read_info();
|
if (reader->event_attr().read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
|
sample_info.read.time_enabled = read_info.time_enabled();
|
if (reader->event_attr().read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
|
sample_info.read.time_running = read_info.time_running();
|
if (reader->event_attr().read_format & PERF_FORMAT_GROUP) {
|
sample_info.read.group.nr = read_info.read_value_size();
|
sample_info.read.group.values =
|
new sample_read_value[read_info.read_value_size()];
|
for (size_t i = 0; i < sample_info.read.group.nr; i++) {
|
sample_info.read.group.values[i].value =
|
read_info.read_value(i).value();
|
sample_info.read.group.values[i].id = read_info.read_value(i).id();
|
}
|
} else if (read_info.read_value_size() == 1) {
|
sample_info.read.one.value = read_info.read_value(0).value();
|
sample_info.read.one.id = read_info.read_value(0).id();
|
} else {
|
LOG(ERROR) << "Expected read_value array size of 1 but got "
|
<< read_info.read_value_size();
|
}
|
}
|
}
|
if (sample.callchain_size() > 0) {
|
uint64_t callchain_size = sample.callchain_size();
|
sample_info.callchain = reinterpret_cast<struct ip_callchain*>(
|
new uint64_t[callchain_size + 1]);
|
sample_info.callchain->nr = callchain_size;
|
for (size_t i = 0; i < callchain_size; ++i)
|
sample_info.callchain->ips[i] = sample.callchain(i);
|
}
|
if (sample.raw_size() > 0) {
|
sample_info.raw_size = sample.raw_size();
|
sample_info.raw_data = new uint8_t[sample.raw_size()];
|
memset(sample_info.raw_data, 0, sample.raw_size());
|
}
|
if (sample.branch_stack_size() > 0) {
|
uint64_t branch_stack_size = sample.branch_stack_size();
|
sample_info.branch_stack = reinterpret_cast<struct branch_stack*>(
|
new uint8_t[sizeof(uint64_t) +
|
branch_stack_size * sizeof(struct branch_entry)]);
|
sample_info.branch_stack->nr = branch_stack_size;
|
for (size_t i = 0; i < branch_stack_size; ++i) {
|
struct branch_entry& entry = sample_info.branch_stack->entries[i];
|
memset(&entry, 0, sizeof(entry));
|
entry.from = sample.branch_stack(i).from_ip();
|
entry.to = sample.branch_stack(i).to_ip();
|
entry.flags.mispred = sample.branch_stack(i).mispredicted();
|
entry.flags.predicted = !entry.flags.mispred;
|
}
|
}
|
|
if (sample.has_weight()) sample_info.weight = sample.weight();
|
if (sample.has_data_src()) sample_info.data_src = sample.data_src();
|
if (sample.has_transaction()) sample_info.transaction = sample.transaction();
|
|
const SampleInfoReader* writer = GetSampleInfoReaderForId(sample.id());
|
CHECK(writer);
|
return writer->WritePerfSampleInfo(sample_info, event);
|
}
|
|
bool PerfSerializer::SerializeMMapEvent(const event_t& event,
|
PerfDataProto_MMapEvent* sample) const {
|
const struct mmap_event& mmap = event.mmap;
|
sample->set_pid(mmap.pid);
|
sample->set_tid(mmap.tid);
|
sample->set_start(mmap.start);
|
sample->set_len(mmap.len);
|
sample->set_pgoff(mmap.pgoff);
|
sample->set_filename(mmap.filename);
|
sample->set_filename_md5_prefix(Md5Prefix(mmap.filename));
|
|
return SerializeSampleInfo(event, sample->mutable_sample_info());
|
}
|
|
bool PerfSerializer::DeserializeMMapEvent(const PerfDataProto_MMapEvent& sample,
|
event_t* event) const {
|
struct mmap_event& mmap = event->mmap;
|
mmap.pid = sample.pid();
|
mmap.tid = sample.tid();
|
mmap.start = sample.start();
|
mmap.len = sample.len();
|
mmap.pgoff = sample.pgoff();
|
snprintf(mmap.filename, PATH_MAX, "%s", sample.filename().c_str());
|
|
return DeserializeSampleInfo(sample.sample_info(), event);
|
}
|
|
bool PerfSerializer::SerializeMMap2Event(
|
const event_t& event, PerfDataProto_MMapEvent* sample) const {
|
const struct mmap2_event& mmap = event.mmap2;
|
sample->set_pid(mmap.pid);
|
sample->set_tid(mmap.tid);
|
sample->set_start(mmap.start);
|
sample->set_len(mmap.len);
|
sample->set_pgoff(mmap.pgoff);
|
sample->set_maj(mmap.maj);
|
sample->set_min(mmap.min);
|
sample->set_ino(mmap.ino);
|
sample->set_ino_generation(mmap.ino_generation);
|
sample->set_prot(mmap.prot);
|
sample->set_flags(mmap.flags);
|
sample->set_filename(mmap.filename);
|
sample->set_filename_md5_prefix(Md5Prefix(mmap.filename));
|
|
return SerializeSampleInfo(event, sample->mutable_sample_info());
|
}
|
|
bool PerfSerializer::DeserializeMMap2Event(
|
const PerfDataProto_MMapEvent& sample, event_t* event) const {
|
struct mmap2_event& mmap = event->mmap2;
|
mmap.pid = sample.pid();
|
mmap.tid = sample.tid();
|
mmap.start = sample.start();
|
mmap.len = sample.len();
|
mmap.pgoff = sample.pgoff();
|
mmap.maj = sample.maj();
|
mmap.min = sample.min();
|
mmap.ino = sample.ino();
|
mmap.ino_generation = sample.ino_generation();
|
mmap.prot = sample.prot();
|
mmap.flags = sample.flags();
|
snprintf(mmap.filename, PATH_MAX, "%s", sample.filename().c_str());
|
|
return DeserializeSampleInfo(sample.sample_info(), event);
|
}
|
|
bool PerfSerializer::SerializeCommEvent(const event_t& event,
|
PerfDataProto_CommEvent* sample) const {
|
const struct comm_event& comm = event.comm;
|
sample->set_pid(comm.pid);
|
sample->set_tid(comm.tid);
|
sample->set_comm(comm.comm);
|
sample->set_comm_md5_prefix(Md5Prefix(comm.comm));
|
|
return SerializeSampleInfo(event, sample->mutable_sample_info());
|
}
|
|
bool PerfSerializer::DeserializeCommEvent(const PerfDataProto_CommEvent& sample,
|
event_t* event) const {
|
struct comm_event& comm = event->comm;
|
comm.pid = sample.pid();
|
comm.tid = sample.tid();
|
snprintf(comm.comm, sizeof(comm.comm), "%s", sample.comm().c_str());
|
|
// Sometimes the command string will be modified. e.g. if the original comm
|
// string is not recoverable from the Md5sum prefix, then use the latter as a
|
// replacement comm string. However, if the original was < 8 bytes (fit into
|
// |sizeof(uint64_t)|), then the size is no longer correct. This section
|
// checks for the size difference and updates the size in the header.
|
const SampleInfoReader* reader =
|
GetSampleInfoReaderForId(sample.sample_info().id());
|
CHECK(reader);
|
uint64_t sample_fields = SampleInfoReader::GetSampleFieldsForEventType(
|
comm.header.type, reader->event_attr().sample_type);
|
comm.header.size = SampleInfoReader::GetPerfSampleDataOffset(*event) +
|
GetNumBits(sample_fields) * sizeof(uint64_t);
|
|
return DeserializeSampleInfo(sample.sample_info(), event);
|
}
|
|
bool PerfSerializer::SerializeForkExitEvent(
|
const event_t& event, PerfDataProto_ForkEvent* sample) const {
|
const struct fork_event& fork = event.fork;
|
sample->set_pid(fork.pid);
|
sample->set_ppid(fork.ppid);
|
sample->set_tid(fork.tid);
|
sample->set_ptid(fork.ptid);
|
sample->set_fork_time_ns(fork.time);
|
|
return SerializeSampleInfo(event, sample->mutable_sample_info());
|
}
|
|
bool PerfSerializer::DeserializeForkExitEvent(
|
const PerfDataProto_ForkEvent& sample, event_t* event) const {
|
struct fork_event& fork = event->fork;
|
fork.pid = sample.pid();
|
fork.ppid = sample.ppid();
|
fork.tid = sample.tid();
|
fork.ptid = sample.ptid();
|
fork.time = sample.fork_time_ns();
|
|
return DeserializeSampleInfo(sample.sample_info(), event);
|
}
|
|
bool PerfSerializer::SerializeLostEvent(const event_t& event,
|
PerfDataProto_LostEvent* sample) const {
|
const struct lost_event& lost = event.lost;
|
sample->set_id(lost.id);
|
sample->set_lost(lost.lost);
|
|
return SerializeSampleInfo(event, sample->mutable_sample_info());
|
}
|
|
bool PerfSerializer::DeserializeLostEvent(const PerfDataProto_LostEvent& sample,
|
event_t* event) const {
|
struct lost_event& lost = event->lost;
|
lost.id = sample.id();
|
lost.lost = sample.lost();
|
|
return DeserializeSampleInfo(sample.sample_info(), event);
|
}
|
|
bool PerfSerializer::SerializeThrottleEvent(
|
const event_t& event, PerfDataProto_ThrottleEvent* sample) const {
|
const struct throttle_event& throttle = event.throttle;
|
sample->set_time_ns(throttle.time);
|
sample->set_id(throttle.id);
|
sample->set_stream_id(throttle.stream_id);
|
|
return SerializeSampleInfo(event, sample->mutable_sample_info());
|
}
|
|
bool PerfSerializer::DeserializeThrottleEvent(
|
const PerfDataProto_ThrottleEvent& sample, event_t* event) const {
|
struct throttle_event& throttle = event->throttle;
|
throttle.time = sample.time_ns();
|
throttle.id = sample.id();
|
throttle.stream_id = sample.stream_id();
|
|
return DeserializeSampleInfo(sample.sample_info(), event);
|
}
|
|
bool PerfSerializer::SerializeReadEvent(const event_t& event,
|
PerfDataProto_ReadEvent* sample) const {
|
const struct read_event& read = event.read;
|
sample->set_pid(read.pid);
|
sample->set_tid(read.tid);
|
sample->set_value(read.value);
|
sample->set_time_enabled(read.time_enabled);
|
sample->set_time_running(read.time_running);
|
sample->set_id(read.id);
|
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeReadEvent(const PerfDataProto_ReadEvent& sample,
|
event_t* event) const {
|
struct read_event& read = event->read;
|
read.pid = sample.pid();
|
read.tid = sample.tid();
|
read.value = sample.value();
|
read.time_enabled = sample.time_enabled();
|
read.time_running = sample.time_running();
|
read.id = sample.id();
|
|
return true;
|
}
|
|
bool PerfSerializer::SerializeAuxEvent(const event_t& event,
|
PerfDataProto_AuxEvent* sample) const {
|
const struct aux_event& aux = event.aux;
|
sample->set_aux_offset(aux.aux_offset);
|
sample->set_aux_size(aux.aux_size);
|
sample->set_is_truncated(aux.flags & PERF_AUX_FLAG_TRUNCATED ? true : false);
|
sample->set_is_overwrite(aux.flags & PERF_AUX_FLAG_OVERWRITE ? true : false);
|
sample->set_is_partial(aux.flags & PERF_AUX_FLAG_PARTIAL ? true : false);
|
if (aux.flags & ~(PERF_AUX_FLAG_TRUNCATED | PERF_AUX_FLAG_OVERWRITE |
|
PERF_AUX_FLAG_PARTIAL)) {
|
LOG(WARNING) << "Ignoring unknown PERF_RECORD_AUX flag: " << aux.flags;
|
}
|
|
return SerializeSampleInfo(event, sample->mutable_sample_info());
|
}
|
|
bool PerfSerializer::DeserializeAuxEvent(const PerfDataProto_AuxEvent& sample,
|
event_t* event) const {
|
struct aux_event& aux = event->aux;
|
aux.aux_offset = sample.aux_offset();
|
aux.aux_size = sample.aux_size();
|
aux.flags |= sample.is_truncated() ? PERF_AUX_FLAG_TRUNCATED : 0;
|
aux.flags |= sample.is_overwrite() ? PERF_AUX_FLAG_OVERWRITE : 0;
|
aux.flags |= sample.is_partial() ? PERF_AUX_FLAG_PARTIAL : 0;
|
|
return DeserializeSampleInfo(sample.sample_info(), event);
|
}
|
|
bool PerfSerializer::SerializeSampleInfo(
|
const event_t& event, PerfDataProto_SampleInfo* sample) const {
|
if (!SampleIdAll()) return true;
|
|
perf_sample sample_info;
|
uint64_t sample_type = 0;
|
if (!ReadPerfSampleInfoAndType(event, &sample_info, &sample_type))
|
return false;
|
|
if (sample_type & PERF_SAMPLE_TID) {
|
sample->set_pid(sample_info.pid);
|
sample->set_tid(sample_info.tid);
|
}
|
if (sample_type & PERF_SAMPLE_TIME)
|
sample->set_sample_time_ns(sample_info.time);
|
if ((sample_type & PERF_SAMPLE_ID) || (sample_type & PERF_SAMPLE_IDENTIFIER))
|
sample->set_id(sample_info.id);
|
if (sample_type & PERF_SAMPLE_CPU) sample->set_cpu(sample_info.cpu);
|
if (sample_type & PERF_SAMPLE_STREAM_ID)
|
sample->set_stream_id(sample_info.stream_id);
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeSampleInfo(
|
const PerfDataProto_SampleInfo& sample, event_t* event) const {
|
if (!SampleIdAll()) return true;
|
|
perf_sample sample_info;
|
if (sample.has_tid()) {
|
sample_info.pid = sample.pid();
|
sample_info.tid = sample.tid();
|
}
|
if (sample.has_sample_time_ns()) sample_info.time = sample.sample_time_ns();
|
if (sample.has_id()) sample_info.id = sample.id();
|
if (sample.has_cpu()) sample_info.cpu = sample.cpu();
|
if (sample.has_stream_id()) sample_info.stream_id = sample.stream_id();
|
|
const SampleInfoReader* writer = GetSampleInfoReaderForId(sample.id());
|
CHECK(writer);
|
return writer->WritePerfSampleInfo(sample_info, event);
|
}
|
|
bool PerfSerializer::SerializeTracingMetadata(const std::vector<char>& from,
|
PerfDataProto* to) const {
|
if (from.empty()) {
|
return true;
|
}
|
PerfDataProto_PerfTracingMetadata* data = to->mutable_tracing_data();
|
data->set_tracing_data(from.data(), from.size());
|
data->set_tracing_data_md5_prefix(Md5Prefix(from));
|
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeTracingMetadata(const PerfDataProto& from,
|
std::vector<char>* to) const {
|
if (!from.has_tracing_data()) {
|
to->clear();
|
return true;
|
}
|
|
const PerfDataProto_PerfTracingMetadata& data = from.tracing_data();
|
to->assign(data.tracing_data().begin(), data.tracing_data().end());
|
return true;
|
}
|
|
bool PerfSerializer::SerializeBuildIDEvent(
|
const malloced_unique_ptr<build_id_event>& from,
|
PerfDataProto_PerfBuildID* to) const {
|
to->set_misc(from->header.misc);
|
to->set_pid(from->pid);
|
to->set_filename(from->filename);
|
to->set_filename_md5_prefix(Md5Prefix(from->filename));
|
|
// Trim out trailing zeroes from the build ID.
|
string build_id = RawDataToHexString(from->build_id, kBuildIDArraySize);
|
TrimZeroesFromBuildIDString(&build_id);
|
|
uint8_t build_id_bytes[kBuildIDArraySize];
|
if (!HexStringToRawData(build_id, build_id_bytes, sizeof(build_id_bytes)))
|
return false;
|
|
// Used to convert build IDs (and possibly other hashes) between raw data
|
// format and as string of hex digits.
|
const int kHexCharsPerByte = 2;
|
to->set_build_id_hash(build_id_bytes, build_id.size() / kHexCharsPerByte);
|
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeBuildIDEvent(
|
const PerfDataProto_PerfBuildID& from,
|
malloced_unique_ptr<build_id_event>* to) const {
|
const string& filename = from.filename();
|
size_t size = sizeof(build_id_event) + GetUint64AlignedStringLength(filename);
|
|
malloced_unique_ptr<build_id_event>& event = *to;
|
event.reset(CallocMemoryForBuildID(size));
|
event->header.type = PERF_RECORD_HEADER_BUILD_ID;
|
event->header.size = size;
|
event->header.misc = from.misc();
|
event->pid = from.pid();
|
memcpy(event->build_id, from.build_id_hash().c_str(),
|
from.build_id_hash().size());
|
|
if (from.has_filename() && !filename.empty()) {
|
CHECK_GT(
|
snprintf(event->filename, filename.size() + 1, "%s", filename.c_str()),
|
0);
|
}
|
return true;
|
}
|
|
bool PerfSerializer::SerializeAuxtraceEvent(
|
const event_t& event, PerfDataProto_AuxtraceEvent* sample) const {
|
const struct auxtrace_event& auxtrace = event.auxtrace;
|
sample->set_size(auxtrace.size);
|
sample->set_offset(auxtrace.offset);
|
sample->set_reference(auxtrace.reference);
|
sample->set_idx(auxtrace.idx);
|
sample->set_tid(auxtrace.tid);
|
sample->set_cpu(auxtrace.cpu);
|
|
return true;
|
}
|
|
bool PerfSerializer::SerializeAuxtraceEventTraceData(
|
const std::vector<char>& from, PerfDataProto_AuxtraceEvent* to) const {
|
if (from.empty()) {
|
return true;
|
}
|
to->set_trace_data(from.data(), from.size());
|
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeAuxtraceEvent(
|
const PerfDataProto_AuxtraceEvent& sample, event_t* event) const {
|
struct auxtrace_event& auxtrace = event->auxtrace;
|
auxtrace.size = sample.size();
|
auxtrace.offset = sample.offset();
|
auxtrace.reference = sample.reference();
|
auxtrace.idx = sample.idx();
|
auxtrace.tid = sample.tid();
|
auxtrace.cpu = sample.cpu();
|
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeAuxtraceEventTraceData(
|
const PerfDataProto_AuxtraceEvent& from, std::vector<char>* to) const {
|
to->assign(from.trace_data().begin(), from.trace_data().end());
|
return true;
|
}
|
|
bool PerfSerializer::SerializeSingleUint32Metadata(
|
const PerfUint32Metadata& metadata,
|
PerfDataProto_PerfUint32Metadata* proto_metadata) const {
|
proto_metadata->set_type(metadata.type);
|
for (size_t i = 0; i < metadata.data.size(); ++i)
|
proto_metadata->add_data(metadata.data[i]);
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeSingleUint32Metadata(
|
const PerfDataProto_PerfUint32Metadata& proto_metadata,
|
PerfUint32Metadata* metadata) const {
|
metadata->type = proto_metadata.type();
|
for (int i = 0; i < proto_metadata.data_size(); ++i)
|
metadata->data.push_back(proto_metadata.data(i));
|
return true;
|
}
|
|
bool PerfSerializer::SerializeSingleUint64Metadata(
|
const PerfUint64Metadata& metadata,
|
PerfDataProto_PerfUint64Metadata* proto_metadata) const {
|
proto_metadata->set_type(metadata.type);
|
for (size_t i = 0; i < metadata.data.size(); ++i)
|
proto_metadata->add_data(metadata.data[i]);
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeSingleUint64Metadata(
|
const PerfDataProto_PerfUint64Metadata& proto_metadata,
|
PerfUint64Metadata* metadata) const {
|
metadata->type = proto_metadata.type();
|
for (int i = 0; i < proto_metadata.data_size(); ++i)
|
metadata->data.push_back(proto_metadata.data(i));
|
return true;
|
}
|
|
bool PerfSerializer::SerializeCPUTopologyMetadata(
|
const PerfCPUTopologyMetadata& metadata,
|
PerfDataProto_PerfCPUTopologyMetadata* proto_metadata) const {
|
for (const string& core_name : metadata.core_siblings) {
|
proto_metadata->add_core_siblings(core_name);
|
proto_metadata->add_core_siblings_md5_prefix(Md5Prefix(core_name));
|
}
|
for (const string& thread_name : metadata.thread_siblings) {
|
proto_metadata->add_thread_siblings(thread_name);
|
proto_metadata->add_thread_siblings_md5_prefix(Md5Prefix(thread_name));
|
}
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeCPUTopologyMetadata(
|
const PerfDataProto_PerfCPUTopologyMetadata& proto_metadata,
|
PerfCPUTopologyMetadata* metadata) const {
|
metadata->core_siblings.clear();
|
metadata->core_siblings.reserve(proto_metadata.core_siblings().size());
|
std::copy(proto_metadata.core_siblings().begin(),
|
proto_metadata.core_siblings().end(),
|
std::back_inserter(metadata->core_siblings));
|
|
metadata->thread_siblings.clear();
|
metadata->thread_siblings.reserve(proto_metadata.thread_siblings().size());
|
std::copy(proto_metadata.thread_siblings().begin(),
|
proto_metadata.thread_siblings().end(),
|
std::back_inserter(metadata->thread_siblings));
|
return true;
|
}
|
|
bool PerfSerializer::SerializeNodeTopologyMetadata(
|
const PerfNodeTopologyMetadata& metadata,
|
PerfDataProto_PerfNodeTopologyMetadata* proto_metadata) const {
|
proto_metadata->set_id(metadata.id);
|
proto_metadata->set_total_memory(metadata.total_memory);
|
proto_metadata->set_free_memory(metadata.free_memory);
|
proto_metadata->set_cpu_list(metadata.cpu_list);
|
proto_metadata->set_cpu_list_md5_prefix(Md5Prefix(metadata.cpu_list));
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeNodeTopologyMetadata(
|
const PerfDataProto_PerfNodeTopologyMetadata& proto_metadata,
|
PerfNodeTopologyMetadata* metadata) const {
|
metadata->id = proto_metadata.id();
|
metadata->total_memory = proto_metadata.total_memory();
|
metadata->free_memory = proto_metadata.free_memory();
|
metadata->cpu_list = proto_metadata.cpu_list();
|
return true;
|
}
|
|
bool PerfSerializer::SerializePMUMappingsMetadata(
|
const PerfPMUMappingsMetadata& metadata,
|
PerfDataProto_PerfPMUMappingsMetadata* proto_metadata) const {
|
proto_metadata->set_type(metadata.type);
|
proto_metadata->set_name(metadata.name);
|
proto_metadata->set_name_md5_prefix(Md5Prefix(metadata.name));
|
return true;
|
}
|
|
bool PerfSerializer::DeserializePMUMappingsMetadata(
|
const PerfDataProto_PerfPMUMappingsMetadata& proto_metadata,
|
PerfPMUMappingsMetadata* metadata) const {
|
metadata->type = proto_metadata.type();
|
metadata->name = proto_metadata.name();
|
return true;
|
}
|
|
bool PerfSerializer::SerializeGroupDescMetadata(
|
const PerfGroupDescMetadata& metadata,
|
PerfDataProto_PerfGroupDescMetadata* proto_metadata) const {
|
proto_metadata->set_name(metadata.name);
|
proto_metadata->set_name_md5_prefix(Md5Prefix(metadata.name));
|
proto_metadata->set_leader_idx(metadata.leader_idx);
|
proto_metadata->set_num_members(metadata.num_members);
|
return true;
|
}
|
|
bool PerfSerializer::DeserializeGroupDescMetadata(
|
const PerfDataProto_PerfGroupDescMetadata& proto_metadata,
|
PerfGroupDescMetadata* metadata) const {
|
metadata->name = proto_metadata.name();
|
metadata->leader_idx = proto_metadata.leader_idx();
|
metadata->num_members = proto_metadata.num_members();
|
return true;
|
}
|
|
// static
|
void PerfSerializer::SerializeParserStats(const PerfEventStats& stats,
|
PerfDataProto* perf_data_proto) {
|
PerfDataProto_PerfEventStats* stats_pb = perf_data_proto->mutable_stats();
|
stats_pb->set_num_sample_events(stats.num_sample_events);
|
stats_pb->set_num_mmap_events(stats.num_mmap_events);
|
stats_pb->set_num_fork_events(stats.num_fork_events);
|
stats_pb->set_num_exit_events(stats.num_exit_events);
|
stats_pb->set_did_remap(stats.did_remap);
|
stats_pb->set_num_sample_events_mapped(stats.num_sample_events_mapped);
|
}
|
|
// static
|
void PerfSerializer::DeserializeParserStats(
|
const PerfDataProto& perf_data_proto, PerfEventStats* stats) {
|
const PerfDataProto_PerfEventStats& stats_pb = perf_data_proto.stats();
|
stats->num_sample_events = stats_pb.num_sample_events();
|
stats->num_mmap_events = stats_pb.num_mmap_events();
|
stats->num_fork_events = stats_pb.num_fork_events();
|
stats->num_exit_events = stats_pb.num_exit_events();
|
stats->did_remap = stats_pb.did_remap();
|
stats->num_sample_events_mapped = stats_pb.num_sample_events_mapped();
|
}
|
|
void PerfSerializer::CreateSampleInfoReader(const PerfFileAttr& attr,
|
bool read_cross_endian) {
|
for (const auto& id :
|
(attr.ids.empty() ? std::initializer_list<u64>({0}) : attr.ids)) {
|
sample_info_reader_map_[id].reset(
|
new SampleInfoReader(attr.attr, read_cross_endian));
|
}
|
UpdateEventIdPositions(attr.attr);
|
}
|
|
void PerfSerializer::UpdateEventIdPositions(
|
const struct perf_event_attr& attr) {
|
const u64 sample_type = attr.sample_type;
|
ssize_t new_sample_event_id_pos = EventIdPosition::NotPresent;
|
ssize_t new_other_event_id_pos = EventIdPosition::NotPresent;
|
if (sample_type & PERF_SAMPLE_IDENTIFIER) {
|
new_sample_event_id_pos = 0;
|
new_other_event_id_pos = 1;
|
} else if (sample_type & PERF_SAMPLE_ID) {
|
// Increment for IP, TID, TIME, ADDR
|
new_sample_event_id_pos = 0;
|
if (sample_type & PERF_SAMPLE_IP) new_sample_event_id_pos++;
|
if (sample_type & PERF_SAMPLE_TID) new_sample_event_id_pos++;
|
if (sample_type & PERF_SAMPLE_TIME) new_sample_event_id_pos++;
|
if (sample_type & PERF_SAMPLE_ADDR) new_sample_event_id_pos++;
|
|
// Increment for CPU, STREAM_ID
|
new_other_event_id_pos = 1;
|
if (sample_type & PERF_SAMPLE_CPU) new_other_event_id_pos++;
|
if (sample_type & PERF_SAMPLE_STREAM_ID) new_other_event_id_pos++;
|
}
|
|
if (sample_event_id_pos_ == EventIdPosition::Uninitialized) {
|
sample_event_id_pos_ = new_sample_event_id_pos;
|
} else {
|
CHECK_EQ(new_sample_event_id_pos, sample_event_id_pos_)
|
<< "Event ids must be in a consistent positition";
|
}
|
if (other_event_id_pos_ == EventIdPosition::Uninitialized) {
|
other_event_id_pos_ = new_other_event_id_pos;
|
} else {
|
CHECK_EQ(new_other_event_id_pos, other_event_id_pos_)
|
<< "Event ids must be in a consistent positition";
|
}
|
}
|
|
bool PerfSerializer::SampleIdAll() const {
|
if (sample_info_reader_map_.empty()) {
|
return false;
|
}
|
return sample_info_reader_map_.begin()->second->event_attr().sample_id_all;
|
}
|
|
const SampleInfoReader* PerfSerializer::GetSampleInfoReaderForEvent(
|
const event_t& event) const {
|
// Where is the event id?
|
ssize_t event_id_pos = EventIdPosition::Uninitialized;
|
if (event.header.type == PERF_RECORD_SAMPLE) {
|
event_id_pos = sample_event_id_pos_;
|
} else if (SampleIdAll()) {
|
event_id_pos = other_event_id_pos_;
|
} else {
|
event_id_pos = EventIdPosition::NotPresent;
|
}
|
|
// What is the event id?
|
u64 event_id;
|
switch (event_id_pos) {
|
case EventIdPosition::Uninitialized:
|
LOG(FATAL) << "Position of the event id was not initialized!";
|
return nullptr;
|
case EventIdPosition::NotPresent:
|
event_id = 0;
|
break;
|
default:
|
if (event.header.type == PERF_RECORD_SAMPLE) {
|
event_id = event.sample.array[event_id_pos];
|
} else {
|
// Pretend this is a sample event--ie, an array of u64. Find the length
|
// of the array. The sample id is at the end of the array, and
|
// event_id_pos (aka other_event_id_pos_) counts from the end.
|
size_t event_end_pos =
|
(event.header.size - sizeof(event.header)) / sizeof(u64);
|
event_id = event.sample.array[event_end_pos - event_id_pos];
|
}
|
break;
|
}
|
return GetSampleInfoReaderForId(event_id);
|
}
|
|
const SampleInfoReader* PerfSerializer::GetSampleInfoReaderForId(
|
uint64_t id) const {
|
if (id) {
|
auto iter = sample_info_reader_map_.find(id);
|
if (iter == sample_info_reader_map_.end()) return nullptr;
|
return iter->second.get();
|
}
|
|
if (sample_info_reader_map_.empty()) return nullptr;
|
return sample_info_reader_map_.begin()->second.get();
|
}
|
|
bool PerfSerializer::ReadPerfSampleInfoAndType(const event_t& event,
|
perf_sample* sample_info,
|
uint64_t* sample_type) const {
|
const SampleInfoReader* reader = GetSampleInfoReaderForEvent(event);
|
if (!reader) {
|
LOG(ERROR) << "No SampleInfoReader available";
|
return false;
|
}
|
|
if (!reader->ReadPerfSampleInfo(event, sample_info)) return false;
|
*sample_type = reader->event_attr().sample_type;
|
return true;
|
}
|
|
} // namespace quipper
|
