1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189

use byteorder::{BigEndian, ByteOrder, LittleEndian};

use crate::{Endianness, RawData, SampleFormat};

use super::RecordParseInfo;

#[derive(Clone, Debug, Default)]
pub struct CommonData {
    pub pid: Option<i32>,
    pub tid: Option<i32>,
    pub timestamp: Option<u64>,
    pub id: Option<u64>,
    pub stream_id: Option<u64>,
    pub cpu: Option<u32>,
}

impl CommonData {
    pub fn parse_sample(
        data: RawData,
        parse_info: &RecordParseInfo,
    ) -> Result<Self, std::io::Error> {
        match parse_info.endian {
            Endianness::LittleEndian => Self::parse_sample_impl::<LittleEndian>(data, parse_info),
            Endianness::BigEndian => Self::parse_sample_impl::<BigEndian>(data, parse_info),
        }
    }

    pub fn parse_sample_impl<T: ByteOrder>(
        data: RawData,
        parse_info: &RecordParseInfo,
    ) -> Result<Self, std::io::Error> {
        let sample_format = parse_info.sample_format;

        // { u64 id;       } && PERF_SAMPLE_IDENTIFIER
        // { u64 ip;       } && PERF_SAMPLE_IP
        // { u32 pid, tid; } && PERF_SAMPLE_TID
        // { u64 time;     } && PERF_SAMPLE_TIME
        // { u64 addr;     } && PERF_SAMPLE_ADDR
        // { u64 id;       } && PERF_SAMPLE_ID
        // { u64 stream_id;} && PERF_SAMPLE_STREAM_ID
        // { u32 cpu, res; } && PERF_SAMPLE_CPU
        let mut cur = data;
        let identifier = if sample_format.contains(SampleFormat::IDENTIFIER) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        if sample_format.contains(SampleFormat::IP) {
            let _ip = cur.read_u64::<T>()?;
        }

        let (pid, tid) = if sample_format.contains(SampleFormat::TID) {
            let pid = cur.read_i32::<T>()?;
            let tid = cur.read_i32::<T>()?;
            (Some(pid), Some(tid))
        } else {
            (None, None)
        };

        let timestamp = if sample_format.contains(SampleFormat::TIME) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        if sample_format.contains(SampleFormat::ADDR) {
            let _addr = cur.read_u64::<T>()?;
        }

        let id = if sample_format.contains(SampleFormat::ID) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };
        let id = identifier.or(id);

        let stream_id = if sample_format.contains(SampleFormat::STREAM_ID) {
            Some(cur.read_u64::<T>()?)
        } else {
            None
        };

        let cpu = if sample_format.contains(SampleFormat::CPU) {
            let cpu = cur.read_u32::<T>()?;
            let _ = cur.read_u32::<T>()?; // Reserved field; is always zero.
            Some(cpu)
        } else {
            None
        };

        Ok(CommonData {
            pid,
            tid,
            timestamp,
            id,
            stream_id,
            cpu,
        })
    }

    pub fn parse_nonsample(
        data: RawData,
        parse_info: &RecordParseInfo,
    ) -> Result<Self, std::io::Error> {
        match parse_info.endian {
            Endianness::LittleEndian => {
                Self::parse_nonsample_impl::<LittleEndian>(data, parse_info)
            }
            Endianness::BigEndian => Self::parse_nonsample_impl::<BigEndian>(data, parse_info),
        }
    }

    pub fn parse_nonsample_impl<T: ByteOrder>(
        data: RawData,
        parse_info: &RecordParseInfo,
    ) -> Result<Self, std::io::Error> {
        if let Some(common_data_offset_from_end) = parse_info.common_data_offset_from_end {
            let sample_format = parse_info.sample_format;

            let mut cur = data;
            let common_data_offset_from_start = cur
                .len()
                .checked_sub(common_data_offset_from_end)
                .ok_or(std::io::ErrorKind::UnexpectedEof)?;
            cur.skip(common_data_offset_from_start)?;

            // struct sample_id {
            //     { u32 pid, tid;  }   /* if PERF_SAMPLE_TID set */
            //     { u64 timestamp; }   /* if PERF_SAMPLE_TIME set */
            //     { u64 id;        }   /* if PERF_SAMPLE_ID set */
            //     { u64 stream_id; }   /* if PERF_SAMPLE_STREAM_ID set  */
            //     { u32 cpu, res;  }   /* if PERF_SAMPLE_CPU set */
            //     { u64 identifier;}   /* if PERF_SAMPLE_IDENTIFIER set */
            // };
            let (pid, tid) = if sample_format.contains(SampleFormat::TID) {
                let pid = cur.read_i32::<T>()?;
                let tid = cur.read_i32::<T>()?;
                (Some(pid), Some(tid))
            } else {
                (None, None)
            };

            let timestamp = if sample_format.contains(SampleFormat::TIME) {
                Some(cur.read_u64::<T>()?)
            } else {
                None
            };

            let id = if sample_format.contains(SampleFormat::ID) {
                Some(cur.read_u64::<T>()?)
            } else {
                None
            };

            let stream_id = if sample_format.contains(SampleFormat::STREAM_ID) {
                Some(cur.read_u64::<T>()?)
            } else {
                None
            };

            let cpu = if sample_format.contains(SampleFormat::CPU) {
                let cpu = cur.read_u32::<T>()?;
                let _ = cur.read_u32::<T>()?; // Reserved field; is always zero.
                Some(cpu)
            } else {
                None
            };

            let identifier = if sample_format.contains(SampleFormat::IDENTIFIER) {
                Some(cur.read_u64::<T>()?)
            } else {
                None
            };
            let id = identifier.or(id);

            Ok(CommonData {
                pid,
                tid,
                timestamp,
                id,
                stream_id,
                cpu,
            })
        } else {
            Ok(Default::default())
        }
    }
}