tools/perf/util/sample.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __PERF_SAMPLE_H
   3 #define __PERF_SAMPLE_H
   4
   5 #include <linux/perf_event.h>
   6 #include <linux/types.h>
   7
   8 /* number of register is bound by the number of bits in regs_dump::mask (64) */
   9 #define PERF_SAMPLE_REGS_CACHE_SIZE (8 * sizeof(u64))
  10
  11 struct regs_dump {
  12         u64 abi;
  13         u64 mask;
  14         u64 *regs;
  15
  16         /* Cached values/mask filled by first register access. */
  17         u64 cache_regs[PERF_SAMPLE_REGS_CACHE_SIZE];
  18         u64 cache_mask;
  19 };
  20
  21 struct stack_dump {
  22         u16 offset;
  23         u64 size;
  24         char *data;
  25 };
  26
  27 struct sample_read_value {
  28         u64 value;
  29         u64 id;   /* only if PERF_FORMAT_ID */
  30         u64 lost; /* only if PERF_FORMAT_LOST */
  31 };
  32
  33 struct sample_read {
  34         u64 time_enabled;
  35         u64 time_running;
  36         union {
  37                 struct {
  38                         u64 nr;
  39                         struct sample_read_value *values;
  40                 } group;
  41                 struct sample_read_value one;
  42         };
  43 };
  44
  45 static inline size_t sample_read_value_size(u64 read_format)
  46 {
  47         /* PERF_FORMAT_ID is forced for PERF_SAMPLE_READ */
  48         if (read_format & PERF_FORMAT_LOST)
  49                 return sizeof(struct sample_read_value);
  50         else
  51                 return offsetof(struct sample_read_value, lost);
  52 }
  53
  54 static inline struct sample_read_value *next_sample_read_value(struct sample_read_value *v, u64 read_format)
  55 {
  56         return (void *)v + sample_read_value_size(read_format);
  57 }
  58
  59 #define sample_read_group__for_each(v, nr, rf) \
  60         for (int __i = 0; __i < (int)nr; v = next_sample_read_value(v, rf), __i++)
  61
  62 #define MAX_INSN 16
  63
  64 struct aux_sample {
  65         u64 size;
  66         void *data;
  67 };
  68
  69 struct perf_sample {
  70         u64 ip;
  71         u32 pid, tid;
  72         u64 time;
  73         u64 addr;
  74         u64 id;
  75         u64 stream_id;
  76         u64 period;
  77         u64 weight;
  78         u64 transaction;
  79         u64 insn_cnt;
  80         u64 cyc_cnt;
  81         u32 cpu;
  82         u32 raw_size;
  83         u64 data_src;
  84         u64 phys_addr;
  85         u64 data_page_size;
  86         u64 code_page_size;
  87         u64 cgroup;
  88         u32 flags;
  89         u32 machine_pid;
  90         u32 vcpu;
  91         u16 insn_len;
  92         u8  cpumode;
  93         u16 misc;
  94         u16 ins_lat;
  95         u16 p_stage_cyc;
  96         bool no_hw_idx;         /* No hw_idx collected in branch_stack */
  97         char insn[MAX_INSN];
  98         void *raw_data;
  99         struct ip_callchain *callchain;
 100         struct branch_stack *branch_stack;
 101         struct regs_dump  user_regs;
 102         struct regs_dump  intr_regs;
 103         struct stack_dump user_stack;
 104         struct sample_read read;
 105         struct aux_sample aux_sample;
 106 };
 107
 108 /*
 109  * raw_data is always 4 bytes from an 8-byte boundary, so subtract 4 to get
 110  * 8-byte alignment.
 111  */
 112 static inline void *perf_sample__synth_ptr(struct perf_sample *sample)
 113 {
 114         return sample->raw_data - 4;
 115 }
 116
 117 #endif /* __PERF_SAMPLE_H */