hc
2024-08-09 d3d58fa5ee2428cd2dde78fd8eeeeabe916b3835
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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
/* SPDX-License-Identifier: GPL-2.0 */
#ifndef __LIBPERF_EVENT_H
#define __LIBPERF_EVENT_H
 
#include <linux/perf_event.h>
#include <linux/types.h>
#include <linux/limits.h>
#include <linux/bpf.h>
#include <sys/types.h> /* pid_t */
 
#define event_contains(obj, mem) ((obj).header.size > offsetof(typeof(obj), mem))
 
struct perf_record_mmap {
   struct perf_event_header header;
   __u32             pid, tid;
   __u64             start;
   __u64             len;
   __u64             pgoff;
   char             filename[PATH_MAX];
};
 
struct perf_record_mmap2 {
   struct perf_event_header header;
   __u32             pid, tid;
   __u64             start;
   __u64             len;
   __u64             pgoff;
   __u32             maj;
   __u32             min;
   __u64             ino;
   __u64             ino_generation;
   __u32             prot;
   __u32             flags;
   char             filename[PATH_MAX];
};
 
struct perf_record_comm {
   struct perf_event_header header;
   __u32             pid, tid;
   char             comm[16];
};
 
struct perf_record_namespaces {
   struct perf_event_header header;
   __u32             pid, tid;
   __u64             nr_namespaces;
   struct perf_ns_link_info link_info[];
};
 
struct perf_record_fork {
   struct perf_event_header header;
   __u32             pid, ppid;
   __u32             tid, ptid;
   __u64             time;
};
 
struct perf_record_lost {
   struct perf_event_header header;
   __u64             id;
   __u64             lost;
};
 
struct perf_record_lost_samples {
   struct perf_event_header header;
   __u64             lost;
};
 
/*
 * PERF_FORMAT_ENABLED | PERF_FORMAT_RUNNING | PERF_FORMAT_ID
 */
struct perf_record_read {
   struct perf_event_header header;
   __u32             pid, tid;
   __u64             value;
   __u64             time_enabled;
   __u64             time_running;
   __u64             id;
};
 
struct perf_record_throttle {
   struct perf_event_header header;
   __u64             time;
   __u64             id;
   __u64             stream_id;
};
 
#ifndef KSYM_NAME_LEN
#define KSYM_NAME_LEN 256
#endif
 
struct perf_record_ksymbol {
   struct perf_event_header header;
   __u64             addr;
   __u32             len;
   __u16             ksym_type;
   __u16             flags;
   char             name[KSYM_NAME_LEN];
};
 
struct perf_record_bpf_event {
   struct perf_event_header header;
   __u16             type;
   __u16             flags;
   __u32             id;
 
   /* for bpf_prog types */
   __u8             tag[BPF_TAG_SIZE];  // prog tag
};
 
struct perf_record_cgroup {
   struct perf_event_header header;
   __u64             id;
   char             path[PATH_MAX];
};
 
struct perf_record_text_poke_event {
   struct perf_event_header header;
   __u64            addr;
   __u16            old_len;
   __u16            new_len;
   __u8            bytes[];
};
 
struct perf_record_sample {
   struct perf_event_header header;
   __u64             array[];
};
 
struct perf_record_switch {
   struct perf_event_header header;
   __u32             next_prev_pid;
   __u32             next_prev_tid;
};
 
struct perf_record_header_attr {
   struct perf_event_header header;
   struct perf_event_attr     attr;
   __u64             id[];
};
 
enum {
   PERF_CPU_MAP__CPUS = 0,
   PERF_CPU_MAP__MASK = 1,
};
 
struct cpu_map_entries {
   __u16             nr;
   __u16             cpu[];
};
 
struct perf_record_record_cpu_map {
   __u16             nr;
   __u16             long_size;
   unsigned long         mask[];
};
 
struct perf_record_cpu_map_data {
   __u16             type;
   char             data[];
};
 
struct perf_record_cpu_map {
   struct perf_event_header     header;
   struct perf_record_cpu_map_data     data;
};
 
enum {
   PERF_EVENT_UPDATE__UNIT  = 0,
   PERF_EVENT_UPDATE__SCALE = 1,
   PERF_EVENT_UPDATE__NAME  = 2,
   PERF_EVENT_UPDATE__CPUS  = 3,
};
 
struct perf_record_event_update_cpus {
   struct perf_record_cpu_map_data     cpus;
};
 
struct perf_record_event_update_scale {
   double             scale;
};
 
struct perf_record_event_update {
   struct perf_event_header header;
   __u64             type;
   __u64             id;
   char             data[];
};
 
#define MAX_EVENT_NAME 64
 
struct perf_trace_event_type {
   __u64             event_id;
   char             name[MAX_EVENT_NAME];
};
 
struct perf_record_header_event_type {
   struct perf_event_header     header;
   struct perf_trace_event_type     event_type;
};
 
struct perf_record_header_tracing_data {
   struct perf_event_header header;
   __u32             size;
};
 
#define PERF_RECORD_MISC_BUILD_ID_SIZE (1 << 15)
 
struct perf_record_header_build_id {
   struct perf_event_header header;
   pid_t             pid;
   union {
       __u8         build_id[24];
       struct {
           __u8     data[20];
           __u8     size;
           __u8     reserved1__;
           __u16     reserved2__;
       };
   };
   char             filename[];
};
 
struct id_index_entry {
   __u64             id;
   __u64             idx;
   __u64             cpu;
   __u64             tid;
};
 
struct perf_record_id_index {
   struct perf_event_header header;
   __u64             nr;
   struct id_index_entry     entries[0];
};
 
struct perf_record_auxtrace_info {
   struct perf_event_header header;
   __u32             type;
   __u32             reserved__; /* For alignment */
   __u64             priv[];
};
 
struct perf_record_auxtrace {
   struct perf_event_header header;
   __u64             size;
   __u64             offset;
   __u64             reference;
   __u32             idx;
   __u32             tid;
   __u32             cpu;
   __u32             reserved__; /* For alignment */
};
 
#define MAX_AUXTRACE_ERROR_MSG 64
 
struct perf_record_auxtrace_error {
   struct perf_event_header header;
   __u32             type;
   __u32             code;
   __u32             cpu;
   __u32             pid;
   __u32             tid;
   __u32             fmt;
   __u64             ip;
   __u64             time;
   char             msg[MAX_AUXTRACE_ERROR_MSG];
};
 
struct perf_record_aux {
   struct perf_event_header header;
   __u64             aux_offset;
   __u64             aux_size;
   __u64             flags;
};
 
struct perf_record_itrace_start {
   struct perf_event_header header;
   __u32             pid;
   __u32             tid;
};
 
struct perf_record_thread_map_entry {
   __u64             pid;
   char             comm[16];
};
 
struct perf_record_thread_map {
   struct perf_event_header         header;
   __u64                     nr;
   struct perf_record_thread_map_entry     entries[];
};
 
enum {
   PERF_STAT_CONFIG_TERM__AGGR_MODE    = 0,
   PERF_STAT_CONFIG_TERM__INTERVAL        = 1,
   PERF_STAT_CONFIG_TERM__SCALE        = 2,
   PERF_STAT_CONFIG_TERM__MAX        = 3,
};
 
struct perf_record_stat_config_entry {
   __u64             tag;
   __u64             val;
};
 
struct perf_record_stat_config {
   struct perf_event_header         header;
   __u64                     nr;
   struct perf_record_stat_config_entry     data[];
};
 
struct perf_record_stat {
   struct perf_event_header header;
 
   __u64             id;
   __u32             cpu;
   __u32             thread;
 
   union {
       struct {
           __u64     val;
           __u64     ena;
           __u64     run;
       };
       __u64         values[3];
   };
};
 
struct perf_record_stat_round {
   struct perf_event_header header;
   __u64             type;
   __u64             time;
};
 
struct perf_record_time_conv {
   struct perf_event_header header;
   __u64             time_shift;
   __u64             time_mult;
   __u64             time_zero;
   __u64             time_cycles;
   __u64             time_mask;
   __u8             cap_user_time_zero;
   __u8             cap_user_time_short;
   __u8             reserved[6];    /* For alignment */
};
 
struct perf_record_header_feature {
   struct perf_event_header header;
   __u64             feat_id;
   char             data[];
};
 
struct perf_record_compressed {
   struct perf_event_header header;
   char             data[];
};
 
enum perf_user_event_type { /* above any possible kernel type */
   PERF_RECORD_USER_TYPE_START        = 64,
   PERF_RECORD_HEADER_ATTR            = 64,
   PERF_RECORD_HEADER_EVENT_TYPE        = 65, /* deprecated */
   PERF_RECORD_HEADER_TRACING_DATA        = 66,
   PERF_RECORD_HEADER_BUILD_ID        = 67,
   PERF_RECORD_FINISHED_ROUND        = 68,
   PERF_RECORD_ID_INDEX            = 69,
   PERF_RECORD_AUXTRACE_INFO        = 70,
   PERF_RECORD_AUXTRACE            = 71,
   PERF_RECORD_AUXTRACE_ERROR        = 72,
   PERF_RECORD_THREAD_MAP            = 73,
   PERF_RECORD_CPU_MAP            = 74,
   PERF_RECORD_STAT_CONFIG            = 75,
   PERF_RECORD_STAT            = 76,
   PERF_RECORD_STAT_ROUND            = 77,
   PERF_RECORD_EVENT_UPDATE        = 78,
   PERF_RECORD_TIME_CONV            = 79,
   PERF_RECORD_HEADER_FEATURE        = 80,
   PERF_RECORD_COMPRESSED            = 81,
   PERF_RECORD_HEADER_MAX
};
 
union perf_event {
   struct perf_event_header        header;
   struct perf_record_mmap            mmap;
   struct perf_record_mmap2        mmap2;
   struct perf_record_comm            comm;
   struct perf_record_namespaces        namespaces;
   struct perf_record_cgroup        cgroup;
   struct perf_record_fork            fork;
   struct perf_record_lost            lost;
   struct perf_record_lost_samples        lost_samples;
   struct perf_record_read            read;
   struct perf_record_throttle        throttle;
   struct perf_record_sample        sample;
   struct perf_record_bpf_event        bpf;
   struct perf_record_ksymbol        ksymbol;
   struct perf_record_text_poke_event    text_poke;
   struct perf_record_header_attr        attr;
   struct perf_record_event_update        event_update;
   struct perf_record_header_event_type    event_type;
   struct perf_record_header_tracing_data    tracing_data;
   struct perf_record_header_build_id    build_id;
   struct perf_record_id_index        id_index;
   struct perf_record_auxtrace_info    auxtrace_info;
   struct perf_record_auxtrace        auxtrace;
   struct perf_record_auxtrace_error    auxtrace_error;
   struct perf_record_aux            aux;
   struct perf_record_itrace_start        itrace_start;
   struct perf_record_switch        context_switch;
   struct perf_record_thread_map        thread_map;
   struct perf_record_cpu_map        cpu_map;
   struct perf_record_stat_config        stat_config;
   struct perf_record_stat            stat;
   struct perf_record_stat_round        stat_round;
   struct perf_record_time_conv        time_conv;
   struct perf_record_header_feature    feat;
   struct perf_record_compressed        pack;
};
 
#endif /* __LIBPERF_EVENT_H */