tools/perf/util/evsel.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __PERF_EVSEL_H
   3 #define __PERF_EVSEL_H 1
   4
   5 #include <linux/list.h>
   6 #include <stdbool.h>
   7 #include <sys/types.h>
   8 #include <linux/perf_event.h>
   9 #include <linux/types.h>
  10 #include <internal/evsel.h>
  11 #include <perf/evsel.h>
  12 #include "symbol_conf.h"
  13 #include "pmus.h"
  14 #include "pmu.h"
  15
  16 struct bpf_object;
  17 struct cgroup;
  18 struct perf_counts;
  19 struct perf_stat_config;
  20 struct perf_stat_evsel;
  21 union perf_event;
  22 struct bpf_counter_ops;
  23 struct target;
  24 struct hashmap;
  25 struct bperf_leader_bpf;
  26 struct bperf_follower_bpf;
  27
  28 typedef int (evsel__sb_cb_t)(union perf_event *event, void *data);
  29
  30 /** struct evsel - event selector
  31  *
  32  * @evlist - evlist this evsel is in, if it is in one.
  33  * @core - libperf evsel object
  34  * @name - Can be set to retain the original event name passed by the user,
  35  *         so that when showing results in tools such as 'perf stat', we
  36  *         show the name used, not some alias.
  37  * @id_pos: the position of the event id (PERF_SAMPLE_ID or
  38  *          PERF_SAMPLE_IDENTIFIER) in a sample event i.e. in the array of
  39  *          struct perf_record_sample
  40  * @is_pos: the position (counting backwards) of the event id (PERF_SAMPLE_ID or
  41  *          PERF_SAMPLE_IDENTIFIER) in a non-sample event i.e. if sample_id_all
  42  *          is used there is an id sample appended to non-sample events
  43  * @priv:   And what is in its containing unnamed union are tool specific
  44  */
  45 struct evsel {
  46         struct perf_evsel       core;
  47         struct evlist           *evlist;
  48         off_t                   id_offset;
  49         int                     id_pos;
  50         int                     is_pos;
  51         unsigned int            sample_size;
  52
  53         /*
  54          * These fields can be set in the parse-events code or similar.
  55          * Please check evsel__clone() to copy them properly so that
  56          * they can be released properly.
  57          */
  58         struct {
  59                 char                    *name;
  60                 char                    *group_name;
  61                 const char              *group_pmu_name;
  62 #ifdef HAVE_LIBTRACEEVENT
  63                 char                    *tp_sys;
  64                 char                    *tp_name;
  65                 struct tep_event        *tp_format;
  66 #endif
  67                 char                    *filter;
  68                 unsigned long           max_events;
  69                 double                  scale;
  70                 const char              *unit;
  71                 struct cgroup           *cgrp;
  72                 const char              *metric_id;
  73                 /*
  74                  * This point to the first evsel with the same name, intended to store the
  75                  * aggregated counts in aggregation mode.
  76                  */
  77                 struct evsel            *first_wildcard_match;
  78                 /* parse modifier helper */
  79                 int                     exclude_GH;
  80                 int                     sample_read;
  81                 bool                    snapshot;
  82                 bool                    per_pkg;
  83                 bool                    percore;
  84                 bool                    precise_max;
  85                 bool                    is_libpfm_event;
  86                 bool                    collect_stat;
  87                 bool                    weak_group;
  88                 bool                    bpf_counter;
  89                 bool                    use_config_name;
  90                 bool                    skippable;
  91                 bool                    retire_lat;
  92                 int                     bpf_fd;
  93                 struct bpf_object       *bpf_obj;
  94                 struct list_head        config_terms;
  95                 u64                     alternate_hw_config;
  96         };
  97
  98         /*
  99          * metric fields are similar, but needs more care as they can have
 100          * references to other metric (evsel).
 101          */
 102         struct evsel            **metric_events;
 103         struct evsel            *metric_leader;
 104
 105         void                    *handler;
 106         struct perf_counts      *counts;
 107         struct perf_counts      *prev_raw_counts;
 108         unsigned long           nr_events_printed;
 109         struct perf_stat_evsel  *stats;
 110         void                    *priv;
 111         u64                     db_id;
 112         bool                    uniquified_name;
 113         bool                    supported;
 114         bool                    needs_swap;
 115         bool                    disabled;
 116         bool                    no_aux_samples;
 117         bool                    immediate;
 118         bool                    tracking;
 119         bool                    ignore_missing_thread;
 120         bool                    forced_leader;
 121         bool                    cmdline_group_boundary;
 122         bool                    reset_group;
 123         bool                    errored;
 124         bool                    needs_auxtrace_mmap;
 125         bool                    default_metricgroup; /* A member of the Default metricgroup */
 126         bool                    needs_uniquify;
 127         struct hashmap          *per_pkg_mask;
 128         int                     err;
 129         int                     script_output_type;
 130         struct {
 131                 evsel__sb_cb_t  *cb;
 132                 void            *data;
 133         } side_band;
 134         /*
 135          * For reporting purposes, an evsel sample can have a callchain
 136          * synthesized from AUX area data. Keep track of synthesized sample
 137          * types here. Note, the recorded sample_type cannot be changed because
 138          * it is needed to continue to parse events.
 139          * See also evsel__has_callchain().
 140          */
 141         __u64                   synth_sample_type;
 142
 143         /*
 144          * Store the branch counter related information.
 145          * br_cntr_idx: The idx of the branch counter event in the evlist
 146          * br_cntr_nr:  The number of the branch counter event in the group
 147          *              (Only available for the leader event)
 148          * abbr_name:   The abbreviation name assigned to an event which is
 149          *              logged by the branch counter.
 150          *              The abbr name is from A to Z9. NA is applied if out
 151          *              of the range.
 152          */
 153         int                     br_cntr_idx;
 154         int                     br_cntr_nr;
 155         char                    abbr_name[3];
 156
 157         /*
 158          * bpf_counter_ops serves two use cases:
 159          *   1. perf-stat -b          counting events used byBPF programs
 160          *   2. perf-stat --use-bpf   use BPF programs to aggregate counts
 161          */
 162         struct bpf_counter_ops  *bpf_counter_ops;
 163
 164         struct list_head        bpf_counter_list; /* for perf-stat -b */
 165         struct list_head        bpf_filters; /* for perf-record --filter */
 166
 167         /* for perf-stat --use-bpf */
 168         int                     bperf_leader_prog_fd;
 169         int                     bperf_leader_link_fd;
 170         union {
 171                 struct bperf_leader_bpf *leader_skel;
 172                 struct bperf_follower_bpf *follower_skel;
 173                 void *bpf_skel;
 174         };
 175         unsigned long           open_flags;
 176         int                     precise_ip_original;
 177
 178         /* The PMU the event is from. Used for missing_features, PMU name, etc. */
 179         struct perf_pmu         *pmu;
 180
 181         /* For tool events */
 182         /* Beginning time subtracted when the counter is read. */
 183         union {
 184                 /* Defaults for retirement latency events. */
 185                 struct _retirement_latency {
 186                         double mean;
 187                         double min;
 188                         double max;
 189                 } retirement_latency;
 190                 /* duration_time is a single global time. */
 191                 __u64 start_time;
 192                 /*
 193                  * user_time and system_time read an initial value potentially
 194                  * per-CPU or per-pid.
 195                  */
 196                 struct xyarray *start_times;
 197         };
 198         /* Is the tool's fd for /proc/pid/stat or /proc/stat. */
 199         bool pid_stat;
 200 };
 201
 202 struct perf_missing_features {
 203         bool sample_id_all;
 204         bool exclude_guest;
 205         bool mmap2;
 206         bool cloexec;
 207         bool clockid;
 208         bool clockid_wrong;
 209         bool lbr_flags;
 210         bool write_backward;
 211         bool group_read;
 212         bool ksymbol;
 213         bool bpf;
 214         bool aux_output;
 215         bool branch_hw_idx;
 216         bool cgroup;
 217         bool data_page_size;
 218         bool code_page_size;
 219         bool weight_struct;
 220         bool read_lost;
 221         bool branch_counters;
 222         bool aux_action;
 223         bool inherit_sample_read;
 224 };
 225
 226 extern struct perf_missing_features perf_missing_features;
 227
 228 struct perf_cpu_map;
 229 struct thread_map;
 230 struct record_opts;
 231
 232 static inline struct perf_cpu_map *evsel__cpus(struct evsel *evsel)
 233 {
 234         return perf_evsel__cpus(&evsel->core);
 235 }
 236
 237 static inline int evsel__nr_cpus(struct evsel *evsel)
 238 {
 239         return perf_cpu_map__nr(evsel__cpus(evsel));
 240 }
 241
 242 void evsel__compute_deltas(struct evsel *evsel, int cpu, int thread,
 243                            struct perf_counts_values *count);
 244
 245 int evsel__object_config(size_t object_size,
 246                          int (*init)(struct evsel *evsel),
 247                          void (*fini)(struct evsel *evsel));
 248
 249 struct perf_pmu *evsel__find_pmu(const struct evsel *evsel);
 250 const char *evsel__pmu_name(const struct evsel *evsel);
 251 bool evsel__is_aux_event(const struct evsel *evsel);
 252
 253 struct evsel *evsel__new_idx(struct perf_event_attr *attr, int idx);
 254
 255 static inline struct evsel *evsel__new(struct perf_event_attr *attr)
 256 {
 257         return evsel__new_idx(attr, 0);
 258 }
 259
 260 struct evsel *evsel__clone(struct evsel *dest, struct evsel *orig);
 261
 262 int copy_config_terms(struct list_head *dst, struct list_head *src);
 263 void free_config_terms(struct list_head *config_terms);
 264
 265
 266 /*
 267  * Returns pointer with encoded error via <linux/err.h> interface.
 268  */
 269 struct evsel *evsel__newtp_idx(const char *sys, const char *name, int idx, bool format);
 270 static inline struct evsel *evsel__newtp(const char *sys, const char *name)
 271 {
 272         return evsel__newtp_idx(sys, name, 0, true);
 273 }
 274
 275 #ifdef HAVE_LIBTRACEEVENT
 276 struct tep_event *evsel__tp_format(struct evsel *evsel);
 277 #endif
 278
 279 void evsel__init(struct evsel *evsel, struct perf_event_attr *attr, int idx);
 280 void evsel__exit(struct evsel *evsel);
 281 void evsel__delete(struct evsel *evsel);
 282
 283 struct callchain_param;
 284
 285 void evsel__config(struct evsel *evsel, struct record_opts *opts,
 286                    struct callchain_param *callchain);
 287 void evsel__config_callchain(struct evsel *evsel, struct record_opts *opts,
 288                              struct callchain_param *callchain);
 289
 290 int __evsel__sample_size(u64 sample_type);
 291 void evsel__calc_id_pos(struct evsel *evsel);
 292
 293 bool evsel__is_cache_op_valid(u8 type, u8 op);
 294
 295 static inline bool evsel__is_bpf(struct evsel *evsel)
 296 {
 297         return evsel->bpf_counter_ops != NULL;
 298 }
 299
 300 static inline bool evsel__is_bperf(struct evsel *evsel)
 301 {
 302         return evsel->bpf_counter_ops != NULL && list_empty(&evsel->bpf_counter_list);
 303 }
 304
 305 #define EVSEL__MAX_ALIASES 8
 306
 307 extern const char *const evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX][EVSEL__MAX_ALIASES];
 308 extern const char *const evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX][EVSEL__MAX_ALIASES];
 309 extern const char *const evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX][EVSEL__MAX_ALIASES];
 310 extern const char *const evsel__hw_names[PERF_COUNT_HW_MAX];
 311 extern const char *const evsel__sw_names[PERF_COUNT_SW_MAX];
 312 extern char *evsel__bpf_counter_events;
 313 bool evsel__match_bpf_counter_events(const char *name);
 314 int arch_evsel__hw_name(struct evsel *evsel, char *bf, size_t size);
 315
 316 int __evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result, char *bf, size_t size);
 317 const char *evsel__name(struct evsel *evsel);
 318 bool evsel__name_is(struct evsel *evsel, const char *name);
 319 const char *evsel__metric_id(const struct evsel *evsel);
 320
 321 static inline bool evsel__is_retire_lat(const struct evsel *evsel)
 322 {
 323         return evsel->retire_lat;
 324 }
 325
 326 const char *evsel__group_name(struct evsel *evsel);
 327 int evsel__group_desc(struct evsel *evsel, char *buf, size_t size);
 328
 329 void __evsel__set_sample_bit(struct evsel *evsel, enum perf_event_sample_format bit);
 330 void __evsel__reset_sample_bit(struct evsel *evsel, enum perf_event_sample_format bit);
 331
 332 #define evsel__set_sample_bit(evsel, bit) \
 333         __evsel__set_sample_bit(evsel, PERF_SAMPLE_##bit)
 334
 335 #define evsel__reset_sample_bit(evsel, bit) \
 336         __evsel__reset_sample_bit(evsel, PERF_SAMPLE_##bit)
 337
 338 void evsel__set_sample_id(struct evsel *evsel, bool use_sample_identifier);
 339
 340 void arch_evsel__set_sample_weight(struct evsel *evsel);
 341 void arch__post_evsel_config(struct evsel *evsel, struct perf_event_attr *attr);
 342 int arch_evsel__open_strerror(struct evsel *evsel, char *msg, size_t size);
 343
 344 int evsel__set_filter(struct evsel *evsel, const char *filter);
 345 int evsel__append_tp_filter(struct evsel *evsel, const char *filter);
 346 int evsel__append_addr_filter(struct evsel *evsel, const char *filter);
 347 int evsel__enable_cpu(struct evsel *evsel, int cpu_map_idx);
 348 int evsel__enable(struct evsel *evsel);
 349 int evsel__disable(struct evsel *evsel);
 350 int evsel__disable_cpu(struct evsel *evsel, int cpu_map_idx);
 351
 352 int evsel__open_per_cpu(struct evsel *evsel, struct perf_cpu_map *cpus, int cpu_map_idx);
 353 int evsel__open_per_thread(struct evsel *evsel, struct perf_thread_map *threads);
 354 int evsel__open(struct evsel *evsel, struct perf_cpu_map *cpus,
 355                 struct perf_thread_map *threads);
 356 void evsel__close(struct evsel *evsel);
 357 int evsel__prepare_open(struct evsel *evsel, struct perf_cpu_map *cpus,
 358                 struct perf_thread_map *threads);
 359
 360 bool evsel__precise_ip_fallback(struct evsel *evsel);
 361
 362 struct perf_sample;
 363
 364 #ifdef HAVE_LIBTRACEEVENT
 365 void *evsel__rawptr(struct evsel *evsel, struct perf_sample *sample, const char *name);
 366 u64 evsel__intval(struct evsel *evsel, struct perf_sample *sample, const char *name);
 367 u64 evsel__intval_common(struct evsel *evsel, struct perf_sample *sample, const char *name);
 368 char evsel__taskstate(struct evsel *evsel, struct perf_sample *sample, const char *name);
 369
 370 static inline char *evsel__strval(struct evsel *evsel, struct perf_sample *sample, const char *name)
 371 {
 372         return evsel__rawptr(evsel, sample, name);
 373 }
 374 #endif
 375
 376 struct tep_format_field;
 377
 378 u64 format_field__intval(struct tep_format_field *field, struct perf_sample *sample, bool needs_swap);
 379
 380 struct tep_format_field *evsel__field(struct evsel *evsel, const char *name);
 381 struct tep_format_field *evsel__common_field(struct evsel *evsel, const char *name);
 382
 383 bool __evsel__match(const struct evsel *evsel, u32 type, u64 config);
 384
 385 #define evsel__match(evsel, t, c) __evsel__match(evsel, PERF_TYPE_##t, PERF_COUNT_##c)
 386
 387 int evsel__read_counter(struct evsel *evsel, int cpu_map_idx, int thread);
 388
 389 int __evsel__read_on_cpu(struct evsel *evsel, int cpu_map_idx, int thread, bool scale);
 390
 391 /**
 392  * evsel__read_on_cpu - Read out the results on a CPU and thread
 393  *
 394  * @evsel - event selector to read value
 395  * @cpu_map_idx - CPU of interest
 396  * @thread - thread of interest
 397  */
 398 static inline int evsel__read_on_cpu(struct evsel *evsel, int cpu_map_idx, int thread)
 399 {
 400         return __evsel__read_on_cpu(evsel, cpu_map_idx, thread, false);
 401 }
 402
 403 /**
 404  * evsel__read_on_cpu_scaled - Read out the results on a CPU and thread, scaled
 405  *
 406  * @evsel - event selector to read value
 407  * @cpu_map_idx - CPU of interest
 408  * @thread - thread of interest
 409  */
 410 static inline int evsel__read_on_cpu_scaled(struct evsel *evsel, int cpu_map_idx, int thread)
 411 {
 412         return __evsel__read_on_cpu(evsel, cpu_map_idx, thread, true);
 413 }
 414
 415 int evsel__parse_sample(struct evsel *evsel, union perf_event *event,
 416                         struct perf_sample *sample);
 417
 418 int evsel__parse_sample_timestamp(struct evsel *evsel, union perf_event *event,
 419                                   u64 *timestamp);
 420
 421 u16 evsel__id_hdr_size(const struct evsel *evsel);
 422
 423 static inline struct evsel *evsel__next(struct evsel *evsel)
 424 {
 425         return list_entry(evsel->core.node.next, struct evsel, core.node);
 426 }
 427
 428 static inline struct evsel *evsel__prev(struct evsel *evsel)
 429 {
 430         return list_entry(evsel->core.node.prev, struct evsel, core.node);
 431 }
 432
 433 /**
 434  * evsel__is_group_leader - Return whether given evsel is a leader event
 435  *
 436  * @evsel - evsel selector to be tested
 437  *
 438  * Return %true if @evsel is a group leader or a stand-alone event
 439  */
 440 static inline bool evsel__is_group_leader(const struct evsel *evsel)
 441 {
 442         return evsel->core.leader == &evsel->core;
 443 }
 444
 445 /**
 446  * evsel__is_group_event - Return whether given evsel is a group event
 447  *
 448  * @evsel - evsel selector to be tested
 449  *
 450  * Return %true iff event group view is enabled and @evsel is a actual group
 451  * leader which has other members in the group
 452  */
 453 static inline bool evsel__is_group_event(struct evsel *evsel)
 454 {
 455         if (!symbol_conf.event_group)
 456                 return false;
 457
 458         return evsel__is_group_leader(evsel) && evsel->core.nr_members > 1;
 459 }
 460
 461 bool evsel__is_function_event(struct evsel *evsel);
 462
 463 static inline bool evsel__is_bpf_output(struct evsel *evsel)
 464 {
 465         return evsel__match(evsel, SOFTWARE, SW_BPF_OUTPUT);
 466 }
 467
 468 static inline bool evsel__is_clock(const struct evsel *evsel)
 469 {
 470         return evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
 471                evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK);
 472 }
 473
 474 bool evsel__fallback(struct evsel *evsel, struct target *target, int err,
 475                      char *msg, size_t msgsize);
 476 int evsel__open_strerror(struct evsel *evsel, struct target *target,
 477                          int err, char *msg, size_t size);
 478
 479 static inline int evsel__group_idx(struct evsel *evsel)
 480 {
 481         return evsel->core.idx - evsel->core.leader->idx;
 482 }
 483
 484 /* Iterates group WITHOUT the leader. */
 485 #define for_each_group_member_head(_evsel, _leader, _head)                              \
 486 for ((_evsel) = list_entry((_leader)->core.node.next, struct evsel, core.node);         \
 487         (_evsel) && &(_evsel)->core.node != (_head) &&                                  \
 488         (_evsel)->core.leader == &(_leader)->core;                                      \
 489         (_evsel) = list_entry((_evsel)->core.node.next, struct evsel, core.node))
 490
 491 #define for_each_group_member(_evsel, _leader)                          \
 492         for_each_group_member_head(_evsel, _leader, &(_leader)->evlist->core.entries)
 493
 494 /* Iterates group WITH the leader. */
 495 #define for_each_group_evsel_head(_evsel, _leader, _head)                               \
 496 for ((_evsel) = _leader;                                                                \
 497         (_evsel) && &(_evsel)->core.node != (_head) &&                                  \
 498         (_evsel)->core.leader == &(_leader)->core;                                      \
 499         (_evsel) = list_entry((_evsel)->core.node.next, struct evsel, core.node))
 500
 501 #define for_each_group_evsel(_evsel, _leader)                           \
 502         for_each_group_evsel_head(_evsel, _leader, &(_leader)->evlist->core.entries)
 503
 504 static inline bool evsel__has_branch_callstack(const struct evsel *evsel)
 505 {
 506         return evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_CALL_STACK;
 507 }
 508
 509 static inline bool evsel__has_branch_hw_idx(const struct evsel *evsel)
 510 {
 511         return evsel->core.attr.branch_sample_type & PERF_SAMPLE_BRANCH_HW_INDEX;
 512 }
 513
 514 static inline bool evsel__has_callchain(const struct evsel *evsel)
 515 {
 516         /*
 517          * For reporting purposes, an evsel sample can have a recorded callchain
 518          * or a callchain synthesized from AUX area data.
 519          */
 520         return evsel->core.attr.sample_type & PERF_SAMPLE_CALLCHAIN ||
 521                evsel->synth_sample_type & PERF_SAMPLE_CALLCHAIN;
 522 }
 523
 524 static inline bool evsel__has_br_stack(const struct evsel *evsel)
 525 {
 526         /*
 527          * For reporting purposes, an evsel sample can have a recorded branch
 528          * stack or a branch stack synthesized from AUX area data.
 529          */
 530         return evsel->core.attr.sample_type & PERF_SAMPLE_BRANCH_STACK ||
 531                evsel->synth_sample_type & PERF_SAMPLE_BRANCH_STACK;
 532 }
 533
 534 static inline bool evsel__is_dummy_event(struct evsel *evsel)
 535 {
 536         return (evsel->core.attr.type == PERF_TYPE_SOFTWARE) &&
 537                (evsel->core.attr.config == PERF_COUNT_SW_DUMMY);
 538 }
 539
 540 struct perf_env *evsel__env(struct evsel *evsel);
 541
 542 int evsel__store_ids(struct evsel *evsel, struct evlist *evlist);
 543
 544 void evsel__zero_per_pkg(struct evsel *evsel);
 545 bool evsel__is_hybrid(const struct evsel *evsel);
 546 struct evsel *evsel__leader(const struct evsel *evsel);
 547 bool evsel__has_leader(struct evsel *evsel, struct evsel *leader);
 548 bool evsel__is_leader(struct evsel *evsel);
 549 void evsel__set_leader(struct evsel *evsel, struct evsel *leader);
 550 int evsel__source_count(const struct evsel *evsel);
 551 void evsel__remove_from_group(struct evsel *evsel, struct evsel *leader);
 552
 553 bool arch_evsel__must_be_in_group(const struct evsel *evsel);
 554
 555 bool evsel__set_needs_uniquify(struct evsel *counter, const struct perf_stat_config *config);
 556 void evsel__uniquify_counter(struct evsel *counter);
 557
 558 /*
 559  * Macro to swap the bit-field postition and size.
 560  * Used when,
 561  * - dont need to swap the entire u64 &&
 562  * - when u64 has variable bit-field sizes &&
 563  * - when presented in a host endian which is different
 564  *   than the source endian of the perf.data file
 565  */
 566 #define bitfield_swap(src, pos, size)   \
 567         ((((src) >> (pos)) & ((1ull << (size)) - 1)) << (63 - ((pos) + (size) - 1)))
 568
 569 u64 evsel__bitfield_swap_branch_flags(u64 value);
 570 void evsel__set_config_if_unset(struct perf_pmu *pmu, struct evsel *evsel,
 571                                 const char *config_name, u64 val);
 572
 573 bool evsel__is_offcpu_event(struct evsel *evsel);
 574
 575 #endif /* __PERF_EVSEL_H */