cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

annotate.h (11683B)


      1/* SPDX-License-Identifier: GPL-2.0 */
      2#ifndef __PERF_ANNOTATE_H
      3#define __PERF_ANNOTATE_H
      4
      5#include <stdbool.h>
      6#include <stdint.h>
      7#include <stdio.h>
      8#include <linux/types.h>
      9#include <linux/list.h>
     10#include <linux/rbtree.h>
     11#include <pthread.h>
     12#include <asm/bug.h>
     13#include "symbol_conf.h"
     14#include "spark.h"
     15
     16struct hist_browser_timer;
     17struct hist_entry;
     18struct ins_ops;
     19struct map;
     20struct map_symbol;
     21struct addr_map_symbol;
     22struct option;
     23struct perf_sample;
     24struct evsel;
     25struct symbol;
     26
     27struct ins {
     28	const char     *name;
     29	struct ins_ops *ops;
     30};
     31
     32struct ins_operands {
     33	char	*raw;
     34	char	*raw_comment;
     35	char	*raw_func_start;
     36	struct {
     37		char	*raw;
     38		char	*name;
     39		struct symbol *sym;
     40		u64	addr;
     41		s64	offset;
     42		bool	offset_avail;
     43		bool	outside;
     44	} target;
     45	union {
     46		struct {
     47			char	*raw;
     48			char	*name;
     49			u64	addr;
     50		} source;
     51		struct {
     52			struct ins	    ins;
     53			struct ins_operands *ops;
     54		} locked;
     55	};
     56};
     57
     58struct arch;
     59
     60struct ins_ops {
     61	void (*free)(struct ins_operands *ops);
     62	int (*parse)(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms);
     63	int (*scnprintf)(struct ins *ins, char *bf, size_t size,
     64			 struct ins_operands *ops, int max_ins_name);
     65};
     66
     67bool ins__is_jump(const struct ins *ins);
     68bool ins__is_call(const struct ins *ins);
     69bool ins__is_ret(const struct ins *ins);
     70bool ins__is_lock(const struct ins *ins);
     71int ins__scnprintf(struct ins *ins, char *bf, size_t size, struct ins_operands *ops, int max_ins_name);
     72bool ins__is_fused(struct arch *arch, const char *ins1, const char *ins2);
     73
     74#define ANNOTATION__IPC_WIDTH 6
     75#define ANNOTATION__CYCLES_WIDTH 6
     76#define ANNOTATION__MINMAX_CYCLES_WIDTH 19
     77#define ANNOTATION__AVG_IPC_WIDTH 36
     78#define ANNOTATION_DUMMY_LEN	256
     79
     80struct annotation_options {
     81	bool hide_src_code,
     82	     use_offset,
     83	     jump_arrows,
     84	     print_lines,
     85	     full_path,
     86	     show_linenr,
     87	     show_fileloc,
     88	     show_nr_jumps,
     89	     show_minmax_cycle,
     90	     show_asm_raw,
     91	     annotate_src;
     92	u8   offset_level;
     93	int  min_pcnt;
     94	int  max_lines;
     95	int  context;
     96	const char *objdump_path;
     97	const char *disassembler_style;
     98	const char *prefix;
     99	const char *prefix_strip;
    100	unsigned int percent_type;
    101};
    102
    103enum {
    104	ANNOTATION__OFFSET_JUMP_TARGETS = 1,
    105	ANNOTATION__OFFSET_CALL,
    106	ANNOTATION__MAX_OFFSET_LEVEL,
    107};
    108
    109#define ANNOTATION__MIN_OFFSET_LEVEL ANNOTATION__OFFSET_JUMP_TARGETS
    110
    111extern struct annotation_options annotation__default_options;
    112
    113struct annotation;
    114
    115struct sym_hist_entry {
    116	u64		nr_samples;
    117	u64		period;
    118};
    119
    120enum {
    121	PERCENT_HITS_LOCAL,
    122	PERCENT_HITS_GLOBAL,
    123	PERCENT_PERIOD_LOCAL,
    124	PERCENT_PERIOD_GLOBAL,
    125	PERCENT_MAX,
    126};
    127
    128struct annotation_data {
    129	double			 percent[PERCENT_MAX];
    130	double			 percent_sum;
    131	struct sym_hist_entry	 he;
    132};
    133
    134struct annotation_line {
    135	struct list_head	 node;
    136	struct rb_node		 rb_node;
    137	s64			 offset;
    138	char			*line;
    139	int			 line_nr;
    140	char			*fileloc;
    141	int			 jump_sources;
    142	float			 ipc;
    143	u64			 cycles;
    144	u64			 cycles_max;
    145	u64			 cycles_min;
    146	char			*path;
    147	u32			 idx;
    148	int			 idx_asm;
    149	int			 data_nr;
    150	struct annotation_data	 data[];
    151};
    152
    153struct disasm_line {
    154	struct ins		 ins;
    155	struct ins_operands	 ops;
    156
    157	/* This needs to be at the end. */
    158	struct annotation_line	 al;
    159};
    160
    161static inline double annotation_data__percent(struct annotation_data *data,
    162					      unsigned int which)
    163{
    164	return which < PERCENT_MAX ? data->percent[which] : -1;
    165}
    166
    167static inline const char *percent_type_str(unsigned int type)
    168{
    169	static const char *str[PERCENT_MAX] = {
    170		"local hits",
    171		"global hits",
    172		"local period",
    173		"global period",
    174	};
    175
    176	if (WARN_ON(type >= PERCENT_MAX))
    177		return "N/A";
    178
    179	return str[type];
    180}
    181
    182static inline struct disasm_line *disasm_line(struct annotation_line *al)
    183{
    184	return al ? container_of(al, struct disasm_line, al) : NULL;
    185}
    186
    187/*
    188 * Is this offset in the same function as the line it is used?
    189 * asm functions jump to other functions, for instance.
    190 */
    191static inline bool disasm_line__has_local_offset(const struct disasm_line *dl)
    192{
    193	return dl->ops.target.offset_avail && !dl->ops.target.outside;
    194}
    195
    196/*
    197 * Can we draw an arrow from the jump to its target, for instance? I.e.
    198 * is the jump and its target in the same function?
    199 */
    200bool disasm_line__is_valid_local_jump(struct disasm_line *dl, struct symbol *sym);
    201
    202void disasm_line__free(struct disasm_line *dl);
    203struct annotation_line *
    204annotation_line__next(struct annotation_line *pos, struct list_head *head);
    205
    206struct annotation_write_ops {
    207	bool first_line, current_entry, change_color;
    208	int  width;
    209	void *obj;
    210	int  (*set_color)(void *obj, int color);
    211	void (*set_percent_color)(void *obj, double percent, bool current);
    212	int  (*set_jumps_percent_color)(void *obj, int nr, bool current);
    213	void (*printf)(void *obj, const char *fmt, ...);
    214	void (*write_graph)(void *obj, int graph);
    215};
    216
    217void annotation_line__write(struct annotation_line *al, struct annotation *notes,
    218			    struct annotation_write_ops *ops,
    219			    struct annotation_options *opts);
    220
    221int __annotation__scnprintf_samples_period(struct annotation *notes,
    222					   char *bf, size_t size,
    223					   struct evsel *evsel,
    224					   bool show_freq);
    225
    226int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw, int max_ins_name);
    227size_t disasm__fprintf(struct list_head *head, FILE *fp);
    228void symbol__calc_percent(struct symbol *sym, struct evsel *evsel);
    229
    230struct sym_hist {
    231	u64		      nr_samples;
    232	u64		      period;
    233	struct sym_hist_entry addr[];
    234};
    235
    236struct cyc_hist {
    237	u64	start;
    238	u64	cycles;
    239	u64	cycles_aggr;
    240	u64	cycles_max;
    241	u64	cycles_min;
    242	s64	cycles_spark[NUM_SPARKS];
    243	u32	num;
    244	u32	num_aggr;
    245	u8	have_start;
    246	/* 1 byte padding */
    247	u16	reset;
    248};
    249
    250/** struct annotated_source - symbols with hits have this attached as in sannotation
    251 *
    252 * @histograms: Array of addr hit histograms per event being monitored
    253 * nr_histograms: This may not be the same as evsel->evlist->core.nr_entries if
    254 * 		  we have more than a group in a evlist, where we will want
    255 * 		  to see each group separately, that is why symbol__annotate2()
    256 * 		  sets src->nr_histograms to evsel->nr_members.
    257 * @lines: If 'print_lines' is specified, per source code line percentages
    258 * @source: source parsed from a disassembler like objdump -dS
    259 * @cyc_hist: Average cycles per basic block
    260 *
    261 * lines is allocated, percentages calculated and all sorted by percentage
    262 * when the annotation is about to be presented, so the percentages are for
    263 * one of the entries in the histogram array, i.e. for the event/counter being
    264 * presented. It is deallocated right after symbol__{tui,tty,etc}_annotate
    265 * returns.
    266 */
    267struct annotated_source {
    268	struct list_head   source;
    269	int    		   nr_histograms;
    270	size_t		   sizeof_sym_hist;
    271	struct cyc_hist	   *cycles_hist;
    272	struct sym_hist	   *histograms;
    273};
    274
    275struct annotation {
    276	pthread_mutex_t		lock;
    277	u64			max_coverage;
    278	u64			start;
    279	u64			hit_cycles;
    280	u64			hit_insn;
    281	unsigned int		total_insn;
    282	unsigned int		cover_insn;
    283	struct annotation_options *options;
    284	struct annotation_line	**offsets;
    285	int			nr_events;
    286	int			max_jump_sources;
    287	int			nr_entries;
    288	int			nr_asm_entries;
    289	u16			max_line_len;
    290	struct {
    291		u8		addr;
    292		u8		jumps;
    293		u8		target;
    294		u8		min_addr;
    295		u8		max_addr;
    296		u8		max_ins_name;
    297	} widths;
    298	bool			have_cycles;
    299	struct annotated_source *src;
    300};
    301
    302void annotation__init(struct annotation *notes);
    303void annotation__exit(struct annotation *notes);
    304
    305static inline int annotation__cycles_width(struct annotation *notes)
    306{
    307	if (notes->have_cycles && notes->options->show_minmax_cycle)
    308		return ANNOTATION__IPC_WIDTH + ANNOTATION__MINMAX_CYCLES_WIDTH;
    309
    310	return notes->have_cycles ? ANNOTATION__IPC_WIDTH + ANNOTATION__CYCLES_WIDTH : 0;
    311}
    312
    313static inline int annotation__pcnt_width(struct annotation *notes)
    314{
    315	return (symbol_conf.show_total_period ? 12 : 7) * notes->nr_events;
    316}
    317
    318static inline bool annotation_line__filter(struct annotation_line *al, struct annotation *notes)
    319{
    320	return notes->options->hide_src_code && al->offset == -1;
    321}
    322
    323void annotation__set_offsets(struct annotation *notes, s64 size);
    324void annotation__compute_ipc(struct annotation *notes, size_t size);
    325void annotation__mark_jump_targets(struct annotation *notes, struct symbol *sym);
    326void annotation__update_column_widths(struct annotation *notes);
    327void annotation__init_column_widths(struct annotation *notes, struct symbol *sym);
    328
    329static inline struct sym_hist *annotated_source__histogram(struct annotated_source *src, int idx)
    330{
    331	return ((void *)src->histograms) + (src->sizeof_sym_hist * idx);
    332}
    333
    334static inline struct sym_hist *annotation__histogram(struct annotation *notes, int idx)
    335{
    336	return annotated_source__histogram(notes->src, idx);
    337}
    338
    339static inline struct annotation *symbol__annotation(struct symbol *sym)
    340{
    341	return (void *)sym - symbol_conf.priv_size;
    342}
    343
    344int addr_map_symbol__inc_samples(struct addr_map_symbol *ams, struct perf_sample *sample,
    345				 struct evsel *evsel);
    346
    347int addr_map_symbol__account_cycles(struct addr_map_symbol *ams,
    348				    struct addr_map_symbol *start,
    349				    unsigned cycles);
    350
    351int hist_entry__inc_addr_samples(struct hist_entry *he, struct perf_sample *sample,
    352				 struct evsel *evsel, u64 addr);
    353
    354struct annotated_source *symbol__hists(struct symbol *sym, int nr_hists);
    355void symbol__annotate_zero_histograms(struct symbol *sym);
    356
    357int symbol__annotate(struct map_symbol *ms,
    358		     struct evsel *evsel,
    359		     struct annotation_options *options,
    360		     struct arch **parch);
    361int symbol__annotate2(struct map_symbol *ms,
    362		      struct evsel *evsel,
    363		      struct annotation_options *options,
    364		      struct arch **parch);
    365
    366enum symbol_disassemble_errno {
    367	SYMBOL_ANNOTATE_ERRNO__SUCCESS		= 0,
    368
    369	/*
    370	 * Choose an arbitrary negative big number not to clash with standard
    371	 * errno since SUS requires the errno has distinct positive values.
    372	 * See 'Issue 6' in the link below.
    373	 *
    374	 * http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html
    375	 */
    376	__SYMBOL_ANNOTATE_ERRNO__START		= -10000,
    377
    378	SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX	= __SYMBOL_ANNOTATE_ERRNO__START,
    379	SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF,
    380	SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_CPUID_PARSING,
    381	SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_REGEXP,
    382	SYMBOL_ANNOTATE_ERRNO__BPF_INVALID_FILE,
    383	SYMBOL_ANNOTATE_ERRNO__BPF_MISSING_BTF,
    384
    385	__SYMBOL_ANNOTATE_ERRNO__END,
    386};
    387
    388int symbol__strerror_disassemble(struct map_symbol *ms, int errnum, char *buf, size_t buflen);
    389
    390int symbol__annotate_printf(struct map_symbol *ms, struct evsel *evsel,
    391			    struct annotation_options *options);
    392void symbol__annotate_zero_histogram(struct symbol *sym, int evidx);
    393void symbol__annotate_decay_histogram(struct symbol *sym, int evidx);
    394void annotated_source__purge(struct annotated_source *as);
    395
    396int map_symbol__annotation_dump(struct map_symbol *ms, struct evsel *evsel,
    397				struct annotation_options *opts);
    398
    399bool ui__has_annotation(void);
    400
    401int symbol__tty_annotate(struct map_symbol *ms, struct evsel *evsel, struct annotation_options *opts);
    402
    403int symbol__tty_annotate2(struct map_symbol *ms, struct evsel *evsel, struct annotation_options *opts);
    404
    405#ifdef HAVE_SLANG_SUPPORT
    406int symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,
    407			 struct hist_browser_timer *hbt,
    408			 struct annotation_options *opts);
    409#else
    410static inline int symbol__tui_annotate(struct map_symbol *ms __maybe_unused,
    411				struct evsel *evsel  __maybe_unused,
    412				struct hist_browser_timer *hbt __maybe_unused,
    413				struct annotation_options *opts __maybe_unused)
    414{
    415	return 0;
    416}
    417#endif
    418
    419void annotation_config__init(struct annotation_options *opt);
    420
    421int annotate_parse_percent_type(const struct option *opt, const char *_str,
    422				int unset);
    423
    424int annotate_check_args(struct annotation_options *args);
    425
    426#endif	/* __PERF_ANNOTATE_H */