Struct linux_perf_data::jitdump::JitDumpRawRecord

pub struct JitDumpRawRecord<'a> {
    pub endian: Endianness,
    pub record_type: JitDumpRecordType,
    pub timestamp: u64,
    pub start_offset: u64,
    pub record_size: u32,
    pub body: RawData<'a>,
}

A raw jitdump record whose body hasn’t been parsed yet.

Fields

endian: Endianness

The file endian (needs to be known during parsing).

record_type: JitDumpRecordType

The record type.

timestamp: u64

The timestamp.

start_offset: u64

The offset in the jitdump file at which this record is stored. This points to the start of the record header.

record_size: u32

The size of this record in bytes, including the record header.

body: RawData<'a>

The raw data for the body of this record.

Implementations

impl<'a> JitDumpRawRecord<'a>

pub fn parse(&self) -> Result<JitDumpRecord<'_>, Error>

Examples found in repository

examples/jitdumpdump.rs (line 15)

fn main() {
    let file = std::fs::File::open(
        std::env::args()
            .nth(1)
            .unwrap_or("/Users/mstange/Downloads/jit-34147.dump".into()),
    )
    .unwrap();

    let mut reader = JitDumpReader::new(file).unwrap();

    while let Ok(Some(record)) = reader.next_record() {
        let timestamp = record.timestamp;
        match record.parse().unwrap() {
            JitDumpRecord::CodeLoad(record) => {
                println!(
                    "{timestamp:016} LOAD {} (pid: {}, tid: {})",
                    record.code_index, record.pid, record.tid
                );
                println!(
                    "  address: {:#x}, size: {:#x}, name: {}",
                    record.code_addr,
                    record.code_bytes.len(),
                    std::str::from_utf8(&record.function_name.as_slice()).unwrap()
                );
                println!();
            }
            JitDumpRecord::CodeMove(record) => {
                println!(
                    "{timestamp:016} MOVE {} (pid: {}, tid: {})",
                    record.code_index, record.pid, record.tid
                );
                println!(
                    "  address: {:#x} -> {:#x}, size: {:#x}",
                    record.old_code_addr, record.new_code_addr, record.code_size
                );
                println!();
            }
            JitDumpRecord::CodeDebugInfo(record) => {
                println!("{timestamp:016} DEBUG INFO");
                println!("  address: {:#x}", record.code_addr);
                for entry in &record.entries {
                    println!(
                        "  {:#8x} {}:{}:{}",
                        entry.code_addr,
                        std::str::from_utf8(&entry.file_path.as_slice()).unwrap(),
                        entry.line,
                        entry.column
                    );
                }
                println!();
            }
            JitDumpRecord::CodeClose => {
                println!("{timestamp:016} CLOSE");
                println!();
            }
            JitDumpRecord::CodeUnwindingInfo(_record) => {
                println!("{timestamp:016} UNWINDING INFO");
                println!();
            }
            JitDumpRecord::Other(record) => {
                println!("{timestamp:016} <unknown type {}>", record.record_type.0);
                println!();
            }
        }
    }
}

Trait Implementations

impl<'a> Clone for JitDumpRawRecord<'a>

fn clone(&self) -> JitDumpRawRecord<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for JitDumpRawRecord<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.