tools/perf/util/trace-event.h

   1 #ifndef __PERF_TRACE_EVENTS_H
   2 #define __PERF_TRACE_EVENTS_H
   3
   4 #include <stdbool.h>
   5 #include "parse-events.h"
   6 #include "session.h"
   7
   8 #define __unused __attribute__((unused))
   9
  10
  11 #ifndef PAGE_MASK
  12 #define PAGE_MASK (page_size - 1)
  13 #endif
  14
  15 enum {
  16         RINGBUF_TYPE_PADDING            = 29,
  17         RINGBUF_TYPE_TIME_EXTEND        = 30,
  18         RINGBUF_TYPE_TIME_STAMP         = 31,
  19 };
  20
  21 #ifndef TS_SHIFT
  22 #define TS_SHIFT                27
  23 #endif
  24
  25 #define NSECS_PER_SEC           1000000000ULL
  26 #define NSECS_PER_USEC          1000ULL
  27
  28 enum format_flags {
  29         FIELD_IS_ARRAY          = 1,
  30         FIELD_IS_POINTER        = 2,
  31         FIELD_IS_SIGNED         = 4,
  32         FIELD_IS_STRING         = 8,
  33         FIELD_IS_DYNAMIC        = 16,
  34         FIELD_IS_FLAG           = 32,
  35         FIELD_IS_SYMBOLIC       = 64,
  36 };
  37
  38 struct format_field {
  39         struct format_field     *next;
  40         char                    *type;
  41         char                    *name;
  42         int                     offset;
  43         int                     size;
  44         unsigned long           flags;
  45 };
  46
  47 struct format {
  48         int                     nr_common;
  49         int                     nr_fields;
  50         struct format_field     *common_fields;
  51         struct format_field     *fields;
  52 };
  53
  54 struct print_arg_atom {
  55         char                    *atom;
  56 };
  57
  58 struct print_arg_string {
  59         char                    *string;
  60         int                     offset;
  61 };
  62
  63 struct print_arg_field {
  64         char                    *name;
  65         struct format_field     *field;
  66 };
  67
  68 struct print_flag_sym {
  69         struct print_flag_sym   *next;
  70         char                    *value;
  71         char                    *str;
  72 };
  73
  74 struct print_arg_typecast {
  75         char                    *type;
  76         struct print_arg        *item;
  77 };
  78
  79 struct print_arg_flags {
  80         struct print_arg        *field;
  81         char                    *delim;
  82         struct print_flag_sym   *flags;
  83 };
  84
  85 struct print_arg_symbol {
  86         struct print_arg        *field;
  87         struct print_flag_sym   *symbols;
  88 };
  89
  90 struct print_arg;
  91
  92 struct print_arg_op {
  93         char                    *op;
  94         int                     prio;
  95         struct print_arg        *left;
  96         struct print_arg        *right;
  97 };
  98
  99 struct print_arg_func {
 100         char                    *name;
 101         struct print_arg        *args;
 102 };
 103
 104 enum print_arg_type {
 105         PRINT_NULL,
 106         PRINT_ATOM,
 107         PRINT_FIELD,
 108         PRINT_FLAGS,
 109         PRINT_SYMBOL,
 110         PRINT_TYPE,
 111         PRINT_STRING,
 112         PRINT_OP,
 113 };
 114
 115 struct print_arg {
 116         struct print_arg                *next;
 117         enum print_arg_type             type;
 118         union {
 119                 struct print_arg_atom           atom;
 120                 struct print_arg_field          field;
 121                 struct print_arg_typecast       typecast;
 122                 struct print_arg_flags          flags;
 123                 struct print_arg_symbol         symbol;
 124                 struct print_arg_func           func;
 125                 struct print_arg_string         string;
 126                 struct print_arg_op             op;
 127         };
 128 };
 129
 130 struct print_fmt {
 131         char                    *format;
 132         struct print_arg        *args;
 133 };
 134
 135 struct event {
 136         struct event            *next;
 137         char                    *name;
 138         int                     id;
 139         int                     flags;
 140         struct format           format;
 141         struct print_fmt        print_fmt;
 142         char                    *system;
 143 };
 144
 145 enum {
 146         EVENT_FL_ISFTRACE       = 0x01,
 147         EVENT_FL_ISPRINT        = 0x02,
 148         EVENT_FL_ISBPRINT       = 0x04,
 149         EVENT_FL_ISFUNC         = 0x08,
 150         EVENT_FL_ISFUNCENT      = 0x10,
 151         EVENT_FL_ISFUNCRET      = 0x20,
 152
 153         EVENT_FL_FAILED         = 0x80000000
 154 };
 155
 156 struct record {
 157         unsigned long long ts;
 158         int size;
 159         void *data;
 160 };
 161
 162 struct record *trace_peek_data(int cpu);
 163 struct record *trace_read_data(int cpu);
 164
 165 void parse_set_info(int nr_cpus, int long_sz);
 166
 167 ssize_t trace_report(int fd, bool repipe);
 168
 169 void *malloc_or_die(unsigned int size);
 170
 171 void parse_cmdlines(char *file, int size);
 172 void parse_proc_kallsyms(char *file, unsigned int size);
 173 void parse_ftrace_printk(char *file, unsigned int size);
 174
 175 void print_funcs(void);
 176 void print_printk(void);
 177
 178 int parse_ftrace_file(char *buf, unsigned long size);
 179 int parse_event_file(char *buf, unsigned long size, char *sys);
 180 void print_trace_event(int cpu, void *data, int size);
 181
 182 extern int file_bigendian;
 183 extern int host_bigendian;
 184
 185 int bigendian(void);
 186
 187 static inline unsigned short __data2host2(unsigned short data)
 188 {
 189         unsigned short swap;
 190
 191         if (host_bigendian == file_bigendian)
 192                 return data;
 193
 194         swap = ((data & 0xffULL) << 8) |
 195                 ((data & (0xffULL << 8)) >> 8);
 196
 197         return swap;
 198 }
 199
 200 static inline unsigned int __data2host4(unsigned int data)
 201 {
 202         unsigned int swap;
 203
 204         if (host_bigendian == file_bigendian)
 205                 return data;
 206
 207         swap = ((data & 0xffULL) << 24) |
 208                 ((data & (0xffULL << 8)) << 8) |
 209                 ((data & (0xffULL << 16)) >> 8) |
 210                 ((data & (0xffULL << 24)) >> 24);
 211
 212         return swap;
 213 }
 214
 215 static inline unsigned long long __data2host8(unsigned long long data)
 216 {
 217         unsigned long long swap;
 218
 219         if (host_bigendian == file_bigendian)
 220                 return data;
 221
 222         swap = ((data & 0xffULL) << 56) |
 223                 ((data & (0xffULL << 8)) << 40) |
 224                 ((data & (0xffULL << 16)) << 24) |
 225                 ((data & (0xffULL << 24)) << 8) |
 226                 ((data & (0xffULL << 32)) >> 8) |
 227                 ((data & (0xffULL << 40)) >> 24) |
 228                 ((data & (0xffULL << 48)) >> 40) |
 229                 ((data & (0xffULL << 56)) >> 56);
 230
 231         return swap;
 232 }
 233
 234 #define data2host2(ptr)         __data2host2(*(unsigned short *)ptr)
 235 #define data2host4(ptr)         __data2host4(*(unsigned int *)ptr)
 236 #define data2host8(ptr)         ({                              \
 237         unsigned long long __val;                               \
 238                                                                 \
 239         memcpy(&__val, (ptr), sizeof(unsigned long long));      \
 240         __data2host8(__val);                                    \
 241 })
 242
 243 extern int header_page_ts_offset;
 244 extern int header_page_ts_size;
 245 extern int header_page_size_offset;
 246 extern int header_page_size_size;
 247 extern int header_page_data_offset;
 248 extern int header_page_data_size;
 249
 250 extern bool latency_format;
 251
 252 int trace_parse_common_type(void *data);
 253 int trace_parse_common_pid(void *data);
 254 int parse_common_pc(void *data);
 255 int parse_common_flags(void *data);
 256 int parse_common_lock_depth(void *data);
 257 struct event *trace_find_event(int id);
 258 struct event *trace_find_next_event(struct event *event);
 259 unsigned long long read_size(void *ptr, int size);
 260 unsigned long long
 261 raw_field_value(struct event *event, const char *name, void *data);
 262 void *raw_field_ptr(struct event *event, const char *name, void *data);
 263 unsigned long long eval_flag(const char *flag);
 264
 265 int read_tracing_data(int fd, struct list_head *pattrs);
 266 ssize_t read_tracing_data_size(int fd, struct list_head *pattrs);
 267
 268 /* taken from kernel/trace/trace.h */
 269 enum trace_flag_type {
 270         TRACE_FLAG_IRQS_OFF             = 0x01,
 271         TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
 272         TRACE_FLAG_NEED_RESCHED         = 0x04,
 273         TRACE_FLAG_HARDIRQ              = 0x08,
 274         TRACE_FLAG_SOFTIRQ              = 0x10,
 275 };
 276
 277 struct scripting_ops {
 278         const char *name;
 279         int (*start_script) (const char *script, int argc, const char **argv);
 280         int (*stop_script) (void);
 281         void (*process_event) (union perf_event *event,
 282                                struct perf_sample *sample,
 283                                struct perf_evsel *evsel,
 284                                struct perf_session *session,
 285                                struct thread *thread);
 286         int (*generate_script) (const char *outfile);
 287 };
 288
 289 int script_spec_register(const char *spec, struct scripting_ops *ops);
 290
 291 void setup_perl_scripting(void);
 292 void setup_python_scripting(void);
 293
 294 struct scripting_context {
 295         void *event_data;
 296 };
 297
 298 int common_pc(struct scripting_context *context);
 299 int common_flags(struct scripting_context *context);
 300 int common_lock_depth(struct scripting_context *context);
 301
 302 #endif /* __PERF_TRACE_EVENTS_H */