// Copyright 2015 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 "sample_info_reader.h"
|
|
#include <string.h>
|
|
#include "base/logging.h"
|
#include "buffer_reader.h"
|
#include "buffer_writer.h"
|
#include "kernel/perf_internals.h"
|
#include "perf_data_utils.h"
|
|
namespace quipper {
|
|
namespace {
|
|
bool IsSupportedEventType(uint32_t type) {
|
switch (type) {
|
case PERF_RECORD_SAMPLE:
|
case PERF_RECORD_MMAP:
|
case PERF_RECORD_MMAP2:
|
case PERF_RECORD_FORK:
|
case PERF_RECORD_EXIT:
|
case PERF_RECORD_COMM:
|
case PERF_RECORD_LOST:
|
case PERF_RECORD_THROTTLE:
|
case PERF_RECORD_UNTHROTTLE:
|
case PERF_RECORD_AUX:
|
return true;
|
case PERF_RECORD_READ:
|
case PERF_RECORD_MAX:
|
return false;
|
default:
|
LOG(FATAL) << "Unknown event type " << type;
|
return false;
|
}
|
}
|
|
// Read read info from perf data. Corresponds to sample format type
|
// PERF_SAMPLE_READ in the !PERF_FORMAT_GROUP case.
|
void ReadReadInfo(DataReader* reader, uint64_t read_format,
|
struct perf_sample* sample) {
|
reader->ReadUint64(&sample->read.one.value);
|
if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
|
reader->ReadUint64(&sample->read.time_enabled);
|
if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
|
reader->ReadUint64(&sample->read.time_running);
|
if (read_format & PERF_FORMAT_ID) reader->ReadUint64(&sample->read.one.id);
|
}
|
|
// Read read info from perf data. Corresponds to sample format type
|
// PERF_SAMPLE_READ in the PERF_FORMAT_GROUP case.
|
void ReadGroupReadInfo(DataReader* reader, uint64_t read_format,
|
struct perf_sample* sample) {
|
uint64_t num = 0;
|
reader->ReadUint64(&num);
|
if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
|
reader->ReadUint64(&sample->read.time_enabled);
|
if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
|
reader->ReadUint64(&sample->read.time_running);
|
|
// Make sure there is no existing allocated memory in
|
// |sample->read.group.values|.
|
CHECK_EQ(static_cast<void*>(NULL), sample->read.group.values);
|
sample_read_value* values = new sample_read_value[num];
|
for (uint64_t i = 0; i < num; i++) {
|
reader->ReadUint64(&values[i].value);
|
if (read_format & PERF_FORMAT_ID) reader->ReadUint64(&values[i].id);
|
}
|
sample->read.group.nr = num;
|
sample->read.group.values = values;
|
}
|
|
// Read call chain info from perf data. Corresponds to sample format type
|
// PERF_SAMPLE_CALLCHAIN.
|
void ReadCallchain(DataReader* reader, struct perf_sample* sample) {
|
// Make sure there is no existing allocated memory in |sample->callchain|.
|
CHECK_EQ(static_cast<void*>(NULL), sample->callchain);
|
|
// The callgraph data consists of a uint64_t value |nr| followed by |nr|
|
// addresses.
|
uint64_t callchain_size = 0;
|
reader->ReadUint64(&callchain_size);
|
|
struct ip_callchain* callchain =
|
reinterpret_cast<struct ip_callchain*>(new uint64_t[callchain_size + 1]);
|
callchain->nr = callchain_size;
|
|
for (size_t i = 0; i < callchain_size; ++i)
|
reader->ReadUint64(&callchain->ips[i]);
|
|
sample->callchain = callchain;
|
}
|
|
// Read raw info from perf data. Corresponds to sample format type
|
// PERF_SAMPLE_RAW.
|
void ReadRawData(DataReader* reader, struct perf_sample* sample) {
|
// Save the original read offset.
|
size_t reader_offset = reader->Tell();
|
|
reader->ReadUint32(&sample->raw_size);
|
|
// Allocate space for and read the raw data bytes.
|
sample->raw_data = new uint8_t[sample->raw_size];
|
reader->ReadData(sample->raw_size, sample->raw_data);
|
|
// Determine the bytes that were read, and align to the next 64 bits.
|
reader_offset += Align<uint64_t>(sizeof(sample->raw_size) + sample->raw_size);
|
reader->SeekSet(reader_offset);
|
}
|
|
// Read call chain info from perf data. Corresponds to sample format type
|
// PERF_SAMPLE_CALLCHAIN.
|
void ReadBranchStack(DataReader* reader, struct perf_sample* sample) {
|
// Make sure there is no existing allocated memory in
|
// |sample->branch_stack|.
|
CHECK_EQ(static_cast<void*>(NULL), sample->branch_stack);
|
|
// The branch stack data consists of a uint64_t value |nr| followed by |nr|
|
// branch_entry structs.
|
uint64_t branch_stack_size = 0;
|
reader->ReadUint64(&branch_stack_size);
|
|
struct branch_stack* branch_stack = reinterpret_cast<struct branch_stack*>(
|
new uint8_t[sizeof(uint64_t) +
|
branch_stack_size * sizeof(struct branch_entry)]);
|
branch_stack->nr = branch_stack_size;
|
for (size_t i = 0; i < branch_stack_size; ++i) {
|
reader->ReadUint64(&branch_stack->entries[i].from);
|
reader->ReadUint64(&branch_stack->entries[i].to);
|
reader->ReadData(sizeof(branch_stack->entries[i].flags),
|
&branch_stack->entries[i].flags);
|
if (reader->is_cross_endian()) {
|
LOG(ERROR) << "Byte swapping of branch stack flags is not yet supported.";
|
}
|
}
|
sample->branch_stack = branch_stack;
|
}
|
|
// Reads perf sample info data from |event| into |sample|.
|
// |attr| is the event attribute struct, which contains info such as which
|
// sample info fields are present.
|
// |is_cross_endian| indicates that the data is cross-endian and that the byte
|
// order should be reversed for each field according to its size.
|
// Returns number of bytes of data read or skipped.
|
size_t ReadPerfSampleFromData(const event_t& event,
|
const struct perf_event_attr& attr,
|
bool is_cross_endian,
|
struct perf_sample* sample) {
|
BufferReader reader(&event, event.header.size);
|
reader.set_is_cross_endian(is_cross_endian);
|
reader.SeekSet(SampleInfoReader::GetPerfSampleDataOffset(event));
|
|
if (!(event.header.type == PERF_RECORD_SAMPLE || attr.sample_id_all)) {
|
return reader.Tell();
|
}
|
|
uint64_t sample_fields = SampleInfoReader::GetSampleFieldsForEventType(
|
event.header.type, attr.sample_type);
|
|
// See structure for PERF_RECORD_SAMPLE in kernel/perf_event.h
|
// and compare sample_id when sample_id_all is set.
|
|
// NB: For sample_id, sample_fields has already been masked to the set
|
// of fields in that struct by GetSampleFieldsForEventType. That set
|
// of fields is mostly in the same order as PERF_RECORD_SAMPLE, with
|
// the exception of PERF_SAMPLE_IDENTIFIER.
|
|
// PERF_SAMPLE_IDENTIFIER is in a different location depending on
|
// if this is a SAMPLE event or the sample_id of another event.
|
if (event.header.type == PERF_RECORD_SAMPLE) {
|
// { u64 id; } && PERF_SAMPLE_IDENTIFIER
|
if (sample_fields & PERF_SAMPLE_IDENTIFIER) {
|
reader.ReadUint64(&sample->id);
|
}
|
}
|
|
// { u64 ip; } && PERF_SAMPLE_IP
|
if (sample_fields & PERF_SAMPLE_IP) {
|
reader.ReadUint64(&sample->ip);
|
}
|
|
// { u32 pid, tid; } && PERF_SAMPLE_TID
|
if (sample_fields & PERF_SAMPLE_TID) {
|
reader.ReadUint32(&sample->pid);
|
reader.ReadUint32(&sample->tid);
|
}
|
|
// { u64 time; } && PERF_SAMPLE_TIME
|
if (sample_fields & PERF_SAMPLE_TIME) {
|
reader.ReadUint64(&sample->time);
|
}
|
|
// { u64 addr; } && PERF_SAMPLE_ADDR
|
if (sample_fields & PERF_SAMPLE_ADDR) {
|
reader.ReadUint64(&sample->addr);
|
}
|
|
// { u64 id; } && PERF_SAMPLE_ID
|
if (sample_fields & PERF_SAMPLE_ID) {
|
reader.ReadUint64(&sample->id);
|
}
|
|
// { u64 stream_id;} && PERF_SAMPLE_STREAM_ID
|
if (sample_fields & PERF_SAMPLE_STREAM_ID) {
|
reader.ReadUint64(&sample->stream_id);
|
}
|
|
// { u32 cpu, res; } && PERF_SAMPLE_CPU
|
if (sample_fields & PERF_SAMPLE_CPU) {
|
reader.ReadUint32(&sample->cpu);
|
|
// The PERF_SAMPLE_CPU format bit specifies 64-bits of data, but the actual
|
// CPU number is really only 32 bits. There is an extra 32-bit word of
|
// reserved padding, as the whole field is aligned to 64 bits.
|
|
// reader.ReadUint32(&sample->res); // reserved
|
u32 reserved;
|
reader.ReadUint32(&reserved);
|
}
|
|
// This is the location of PERF_SAMPLE_IDENTIFIER in struct sample_id.
|
if (event.header.type != PERF_RECORD_SAMPLE) {
|
// { u64 id; } && PERF_SAMPLE_IDENTIFIER
|
if (sample_fields & PERF_SAMPLE_IDENTIFIER) {
|
reader.ReadUint64(&sample->id);
|
}
|
}
|
|
//
|
// The remaining fields are only in PERF_RECORD_SAMPLE
|
//
|
|
// { u64 period; } && PERF_SAMPLE_PERIOD
|
if (sample_fields & PERF_SAMPLE_PERIOD) {
|
reader.ReadUint64(&sample->period);
|
}
|
|
// { struct read_format values; } && PERF_SAMPLE_READ
|
if (sample_fields & PERF_SAMPLE_READ) {
|
if (attr.read_format & PERF_FORMAT_GROUP)
|
ReadGroupReadInfo(&reader, attr.read_format, sample);
|
else
|
ReadReadInfo(&reader, attr.read_format, sample);
|
}
|
|
// { u64 nr,
|
// u64 ips[nr]; } && PERF_SAMPLE_CALLCHAIN
|
if (sample_fields & PERF_SAMPLE_CALLCHAIN) {
|
ReadCallchain(&reader, sample);
|
}
|
|
// { u32 size;
|
// char data[size];}&& PERF_SAMPLE_RAW
|
if (sample_fields & PERF_SAMPLE_RAW) {
|
ReadRawData(&reader, sample);
|
}
|
|
// { u64 nr;
|
// { u64 from, to, flags } lbr[nr];} && PERF_SAMPLE_BRANCH_STACK
|
if (sample_fields & PERF_SAMPLE_BRANCH_STACK) {
|
ReadBranchStack(&reader, sample);
|
}
|
|
// { u64 abi; # enum perf_sample_regs_abi
|
// u64 regs[weight(mask)]; } && PERF_SAMPLE_REGS_USER
|
if (sample_fields & PERF_SAMPLE_REGS_USER) {
|
VLOG(1) << "Skipping PERF_SAMPLE_REGS_USER data.";
|
u64 abi;
|
if (!reader.ReadUint64(&abi)) {
|
return false;
|
}
|
size_t weight = abi == 0 ? 0 : __builtin_popcountll(attr.sample_regs_user);
|
u64 regs[64];
|
if (weight > 0 && !reader.ReadData(weight * sizeof(u64), regs)) {
|
return false;
|
}
|
}
|
|
// { u64 size;
|
// char data[size];
|
// u64 dyn_size; } && PERF_SAMPLE_STACK_USER
|
if (sample_fields & PERF_SAMPLE_STACK_USER) {
|
VLOG(1) << "Skipping PERF_SAMPLE_STACK_USER data.";
|
u64 size;
|
if (!reader.ReadUint64(&size)) {
|
return false;
|
}
|
if (size != 0) {
|
std::unique_ptr<char[]> data(new char[size]);
|
if (!reader.ReadData(size, data.get())) {
|
return false;
|
}
|
u64 dyn_size;
|
reader.ReadUint64(&dyn_size);
|
}
|
}
|
|
// { u64 weight; } && PERF_SAMPLE_WEIGHT
|
if (sample_fields & PERF_SAMPLE_WEIGHT) {
|
reader.ReadUint64(&sample->weight);
|
}
|
|
// { u64 data_src; } && PERF_SAMPLE_DATA_SRC
|
if (sample_fields & PERF_SAMPLE_DATA_SRC) {
|
reader.ReadUint64(&sample->data_src);
|
}
|
|
// { u64 transaction; } && PERF_SAMPLE_TRANSACTION
|
if (sample_fields & PERF_SAMPLE_TRANSACTION) {
|
reader.ReadUint64(&sample->transaction);
|
}
|
|
if (sample_fields & ~(PERF_SAMPLE_MAX - 1)) {
|
LOG(WARNING) << "Unrecognized sample fields 0x" << std::hex
|
<< (sample_fields & ~(PERF_SAMPLE_MAX - 1));
|
}
|
|
return reader.Tell();
|
}
|
|
// Writes sample info data data from |sample| into |event|.
|
// |attr| is the event attribute struct, which contains info such as which
|
// sample info fields are present.
|
// |event| is the destination event. Its header should already be filled out.
|
// Returns the number of bytes written or skipped.
|
size_t WritePerfSampleToData(const struct perf_sample& sample,
|
const struct perf_event_attr& attr,
|
event_t* event) {
|
const uint64_t* initial_array_ptr = reinterpret_cast<const uint64_t*>(event);
|
|
uint64_t offset = SampleInfoReader::GetPerfSampleDataOffset(*event);
|
uint64_t* array =
|
reinterpret_cast<uint64_t*>(event) + offset / sizeof(uint64_t);
|
|
if (!(event->header.type == PERF_RECORD_SAMPLE || attr.sample_id_all)) {
|
return offset;
|
}
|
|
uint64_t sample_fields = SampleInfoReader::GetSampleFieldsForEventType(
|
event->header.type, attr.sample_type);
|
|
union {
|
uint32_t val32[sizeof(uint64_t) / sizeof(uint32_t)];
|
uint64_t val64;
|
};
|
|
// See notes at the top of ReadPerfSampleFromData regarding the structure
|
// of PERF_RECORD_SAMPLE, sample_id, and PERF_SAMPLE_IDENTIFIER, as they
|
// all apply here as well.
|
|
// PERF_SAMPLE_IDENTIFIER is in a different location depending on
|
// if this is a SAMPLE event or the sample_id of another event.
|
if (event->header.type == PERF_RECORD_SAMPLE) {
|
// { u64 id; } && PERF_SAMPLE_IDENTIFIER
|
if (sample_fields & PERF_SAMPLE_IDENTIFIER) {
|
*array++ = sample.id;
|
}
|
}
|
|
// { u64 ip; } && PERF_SAMPLE_IP
|
if (sample_fields & PERF_SAMPLE_IP) {
|
*array++ = sample.ip;
|
}
|
|
// { u32 pid, tid; } && PERF_SAMPLE_TID
|
if (sample_fields & PERF_SAMPLE_TID) {
|
val32[0] = sample.pid;
|
val32[1] = sample.tid;
|
*array++ = val64;
|
}
|
|
// { u64 time; } && PERF_SAMPLE_TIME
|
if (sample_fields & PERF_SAMPLE_TIME) {
|
*array++ = sample.time;
|
}
|
|
// { u64 addr; } && PERF_SAMPLE_ADDR
|
if (sample_fields & PERF_SAMPLE_ADDR) {
|
*array++ = sample.addr;
|
}
|
|
// { u64 id; } && PERF_SAMPLE_ID
|
if (sample_fields & PERF_SAMPLE_ID) {
|
*array++ = sample.id;
|
}
|
|
// { u64 stream_id;} && PERF_SAMPLE_STREAM_ID
|
if (sample_fields & PERF_SAMPLE_STREAM_ID) {
|
*array++ = sample.stream_id;
|
}
|
|
// { u32 cpu, res; } && PERF_SAMPLE_CPU
|
if (sample_fields & PERF_SAMPLE_CPU) {
|
val32[0] = sample.cpu;
|
// val32[1] = sample.res; // reserved
|
val32[1] = 0;
|
*array++ = val64;
|
}
|
|
// This is the location of PERF_SAMPLE_IDENTIFIER in struct sample_id.
|
if (event->header.type != PERF_RECORD_SAMPLE) {
|
// { u64 id; } && PERF_SAMPLE_IDENTIFIER
|
if (sample_fields & PERF_SAMPLE_IDENTIFIER) {
|
*array++ = sample.id;
|
}
|
}
|
|
//
|
// The remaining fields are only in PERF_RECORD_SAMPLE
|
//
|
|
// { u64 period; } && PERF_SAMPLE_PERIOD
|
if (sample_fields & PERF_SAMPLE_PERIOD) {
|
*array++ = sample.period;
|
}
|
|
// { struct read_format values; } && PERF_SAMPLE_READ
|
if (sample_fields & PERF_SAMPLE_READ) {
|
if (attr.read_format & PERF_FORMAT_GROUP) {
|
*array++ = sample.read.group.nr;
|
if (attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
|
*array++ = sample.read.time_enabled;
|
if (attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
|
*array++ = sample.read.time_running;
|
for (size_t i = 0; i < sample.read.group.nr; i++) {
|
*array++ = sample.read.group.values[i].value;
|
if (attr.read_format & PERF_FORMAT_ID) *array++ = sample.read.one.id;
|
}
|
} else {
|
*array++ = sample.read.one.value;
|
if (attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
|
*array++ = sample.read.time_enabled;
|
if (attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
|
*array++ = sample.read.time_running;
|
if (attr.read_format & PERF_FORMAT_ID) *array++ = sample.read.one.id;
|
}
|
}
|
|
// { u64 nr,
|
// u64 ips[nr]; } && PERF_SAMPLE_CALLCHAIN
|
if (sample_fields & PERF_SAMPLE_CALLCHAIN) {
|
if (!sample.callchain) {
|
LOG(ERROR) << "Expecting callchain data, but none was found.";
|
} else {
|
*array++ = sample.callchain->nr;
|
for (size_t i = 0; i < sample.callchain->nr; ++i)
|
*array++ = sample.callchain->ips[i];
|
}
|
}
|
|
// { u32 size;
|
// char data[size];}&& PERF_SAMPLE_RAW
|
if (sample_fields & PERF_SAMPLE_RAW) {
|
uint32_t* ptr = reinterpret_cast<uint32_t*>(array);
|
*ptr++ = sample.raw_size;
|
memcpy(ptr, sample.raw_data, sample.raw_size);
|
|
// Update the data read pointer after aligning to the next 64 bytes.
|
int num_bytes = Align<uint64_t>(sizeof(sample.raw_size) + sample.raw_size);
|
array += num_bytes / sizeof(uint64_t);
|
}
|
|
// { u64 nr;
|
// { u64 from, to, flags } lbr[nr];} && PERF_SAMPLE_BRANCH_STACK
|
if (sample_fields & PERF_SAMPLE_BRANCH_STACK) {
|
if (!sample.branch_stack) {
|
LOG(ERROR) << "Expecting branch stack data, but none was found.";
|
} else {
|
*array++ = sample.branch_stack->nr;
|
for (size_t i = 0; i < sample.branch_stack->nr; ++i) {
|
*array++ = sample.branch_stack->entries[i].from;
|
*array++ = sample.branch_stack->entries[i].to;
|
memcpy(array++, &sample.branch_stack->entries[i].flags,
|
sizeof(uint64_t));
|
}
|
}
|
}
|
|
// { u64 abi; # enum perf_sample_regs_abi
|
// u64 regs[weight(mask)]; } && PERF_SAMPLE_REGS_USER
|
if (sample_fields & PERF_SAMPLE_REGS_USER) {
|
LOG(ERROR) << "PERF_SAMPLE_REGS_USER is not yet supported.";
|
return (array - initial_array_ptr) * sizeof(uint64_t);
|
}
|
|
// { u64 size;
|
// char data[size];
|
// u64 dyn_size; } && PERF_SAMPLE_STACK_USER
|
if (sample_fields & PERF_SAMPLE_STACK_USER) {
|
LOG(ERROR) << "PERF_SAMPLE_STACK_USER is not yet supported.";
|
return (array - initial_array_ptr) * sizeof(uint64_t);
|
}
|
|
// { u64 weight; } && PERF_SAMPLE_WEIGHT
|
if (sample_fields & PERF_SAMPLE_WEIGHT) {
|
*array++ = sample.weight;
|
}
|
|
// { u64 data_src; } && PERF_SAMPLE_DATA_SRC
|
if (sample_fields & PERF_SAMPLE_DATA_SRC) {
|
*array++ = sample.data_src;
|
}
|
|
// { u64 transaction; } && PERF_SAMPLE_TRANSACTION
|
if (sample_fields & PERF_SAMPLE_TRANSACTION) {
|
*array++ = sample.transaction;
|
}
|
|
return (array - initial_array_ptr) * sizeof(uint64_t);
|
}
|
|
} // namespace
|
|
bool SampleInfoReader::ReadPerfSampleInfo(const event_t& event,
|
struct perf_sample* sample) const {
|
CHECK(sample);
|
|
if (!IsSupportedEventType(event.header.type)) {
|
LOG(ERROR) << "Unsupported event type " << event.header.type;
|
return false;
|
}
|
|
size_t size_read_or_skipped =
|
ReadPerfSampleFromData(event, event_attr_, read_cross_endian_, sample);
|
|
if (size_read_or_skipped != event.header.size) {
|
LOG(ERROR) << "Read/skipped " << size_read_or_skipped << " bytes, expected "
|
<< event.header.size << " bytes.";
|
}
|
|
return (size_read_or_skipped == event.header.size);
|
}
|
|
bool SampleInfoReader::WritePerfSampleInfo(const perf_sample& sample,
|
event_t* event) const {
|
CHECK(event);
|
|
if (!IsSupportedEventType(event->header.type)) {
|
LOG(ERROR) << "Unsupported event type " << event->header.type;
|
return false;
|
}
|
|
size_t size_written_or_skipped =
|
WritePerfSampleToData(sample, event_attr_, event);
|
if (size_written_or_skipped != event->header.size) {
|
LOG(ERROR) << "Wrote/skipped " << size_written_or_skipped
|
<< " bytes, expected " << event->header.size << " bytes.";
|
}
|
|
return (size_written_or_skipped == event->header.size);
|
}
|
|
// static
|
uint64_t SampleInfoReader::GetSampleFieldsForEventType(uint32_t event_type,
|
uint64_t sample_type) {
|
uint64_t mask = UINT64_MAX;
|
switch (event_type) {
|
case PERF_RECORD_MMAP:
|
case PERF_RECORD_LOST:
|
case PERF_RECORD_COMM:
|
case PERF_RECORD_EXIT:
|
case PERF_RECORD_THROTTLE:
|
case PERF_RECORD_UNTHROTTLE:
|
case PERF_RECORD_FORK:
|
case PERF_RECORD_READ:
|
case PERF_RECORD_MMAP2:
|
case PERF_RECORD_AUX:
|
// See perf_event.h "struct" sample_id and sample_id_all.
|
mask = PERF_SAMPLE_TID | PERF_SAMPLE_TIME | PERF_SAMPLE_ID |
|
PERF_SAMPLE_STREAM_ID | PERF_SAMPLE_CPU | PERF_SAMPLE_IDENTIFIER;
|
break;
|
case PERF_RECORD_SAMPLE:
|
break;
|
default:
|
LOG(FATAL) << "Unknown event type " << event_type;
|
}
|
return sample_type & mask;
|
}
|
|
// static
|
uint64_t SampleInfoReader::GetPerfSampleDataOffset(const event_t& event) {
|
uint64_t offset = UINT64_MAX;
|
switch (event.header.type) {
|
case PERF_RECORD_SAMPLE:
|
offset = offsetof(event_t, sample.array);
|
break;
|
case PERF_RECORD_MMAP:
|
offset = sizeof(event.mmap) - sizeof(event.mmap.filename) +
|
GetUint64AlignedStringLength(event.mmap.filename);
|
break;
|
case PERF_RECORD_FORK:
|
case PERF_RECORD_EXIT:
|
offset = sizeof(event.fork);
|
break;
|
case PERF_RECORD_COMM:
|
offset = sizeof(event.comm) - sizeof(event.comm.comm) +
|
GetUint64AlignedStringLength(event.comm.comm);
|
break;
|
case PERF_RECORD_LOST:
|
offset = sizeof(event.lost);
|
break;
|
case PERF_RECORD_THROTTLE:
|
case PERF_RECORD_UNTHROTTLE:
|
offset = sizeof(event.throttle);
|
break;
|
case PERF_RECORD_READ:
|
offset = sizeof(event.read);
|
break;
|
case PERF_RECORD_MMAP2:
|
offset = sizeof(event.mmap2) - sizeof(event.mmap2.filename) +
|
GetUint64AlignedStringLength(event.mmap2.filename);
|
break;
|
case PERF_RECORD_AUX:
|
offset = sizeof(event.aux);
|
break;
|
default:
|
LOG(FATAL) << "Unknown event type " << event.header.type;
|
break;
|
}
|
// Make sure the offset was valid
|
CHECK_NE(offset, UINT64_MAX);
|
CHECK_EQ(offset % sizeof(uint64_t), 0U);
|
return offset;
|
}
|
|
} // namespace quipper
|
