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.c (6458B)


      1// SPDX-License-Identifier: GPL-2.0
      2#include "gtk.h"
      3#include "util/sort.h"
      4#include "util/debug.h"
      5#include "util/annotate.h"
      6#include "util/evsel.h"
      7#include "util/map.h"
      8#include "util/dso.h"
      9#include "util/symbol.h"
     10#include "ui/helpline.h"
     11#include <inttypes.h>
     12#include <signal.h>
     13
     14enum {
     15	ANN_COL__PERCENT,
     16	ANN_COL__OFFSET,
     17	ANN_COL__LINE,
     18
     19	MAX_ANN_COLS
     20};
     21
     22static const char *const col_names[] = {
     23	"Overhead",
     24	"Offset",
     25	"Line"
     26};
     27
     28static int perf_gtk__get_percent(char *buf, size_t size, struct symbol *sym,
     29				 struct disasm_line *dl, int evidx)
     30{
     31	struct sym_hist *symhist;
     32	double percent = 0.0;
     33	const char *markup;
     34	int ret = 0;
     35
     36	strcpy(buf, "");
     37
     38	if (dl->al.offset == (s64) -1)
     39		return 0;
     40
     41	symhist = annotation__histogram(symbol__annotation(sym), evidx);
     42	if (!symbol_conf.event_group && !symhist->addr[dl->al.offset].nr_samples)
     43		return 0;
     44
     45	percent = 100.0 * symhist->addr[dl->al.offset].nr_samples / symhist->nr_samples;
     46
     47	markup = perf_gtk__get_percent_color(percent);
     48	if (markup)
     49		ret += scnprintf(buf, size, "%s", markup);
     50	ret += scnprintf(buf + ret, size - ret, "%6.2f%%", percent);
     51	if (markup)
     52		ret += scnprintf(buf + ret, size - ret, "</span>");
     53
     54	return ret;
     55}
     56
     57static int perf_gtk__get_offset(char *buf, size_t size, struct map_symbol *ms,
     58				struct disasm_line *dl)
     59{
     60	u64 start = map__rip_2objdump(ms->map, ms->sym->start);
     61
     62	strcpy(buf, "");
     63
     64	if (dl->al.offset == (s64) -1)
     65		return 0;
     66
     67	return scnprintf(buf, size, "%"PRIx64, start + dl->al.offset);
     68}
     69
     70static int perf_gtk__get_line(char *buf, size_t size, struct disasm_line *dl)
     71{
     72	int ret = 0;
     73	char *line = g_markup_escape_text(dl->al.line, -1);
     74	const char *markup = "<span fgcolor='gray'>";
     75
     76	strcpy(buf, "");
     77
     78	if (!line)
     79		return 0;
     80
     81	if (dl->al.offset != (s64) -1)
     82		markup = NULL;
     83
     84	if (markup)
     85		ret += scnprintf(buf, size, "%s", markup);
     86	ret += scnprintf(buf + ret, size - ret, "%s", line);
     87	if (markup)
     88		ret += scnprintf(buf + ret, size - ret, "</span>");
     89
     90	g_free(line);
     91	return ret;
     92}
     93
     94static int perf_gtk__annotate_symbol(GtkWidget *window, struct map_symbol *ms,
     95				struct evsel *evsel,
     96				struct hist_browser_timer *hbt __maybe_unused)
     97{
     98	struct symbol *sym = ms->sym;
     99	struct disasm_line *pos, *n;
    100	struct annotation *notes;
    101	GType col_types[MAX_ANN_COLS];
    102	GtkCellRenderer *renderer;
    103	GtkListStore *store;
    104	GtkWidget *view;
    105	int i;
    106	char s[512];
    107
    108	notes = symbol__annotation(sym);
    109
    110	for (i = 0; i < MAX_ANN_COLS; i++) {
    111		col_types[i] = G_TYPE_STRING;
    112	}
    113	store = gtk_list_store_newv(MAX_ANN_COLS, col_types);
    114
    115	view = gtk_tree_view_new();
    116	renderer = gtk_cell_renderer_text_new();
    117
    118	for (i = 0; i < MAX_ANN_COLS; i++) {
    119		gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
    120					-1, col_names[i], renderer, "markup",
    121					i, NULL);
    122	}
    123
    124	gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
    125	g_object_unref(GTK_TREE_MODEL(store));
    126
    127	list_for_each_entry(pos, &notes->src->source, al.node) {
    128		GtkTreeIter iter;
    129		int ret = 0;
    130
    131		gtk_list_store_append(store, &iter);
    132
    133		if (evsel__is_group_event(evsel)) {
    134			for (i = 0; i < evsel->core.nr_members; i++) {
    135				ret += perf_gtk__get_percent(s + ret,
    136							     sizeof(s) - ret,
    137							     sym, pos,
    138							     evsel->core.idx + i);
    139				ret += scnprintf(s + ret, sizeof(s) - ret, " ");
    140			}
    141		} else {
    142			ret = perf_gtk__get_percent(s, sizeof(s), sym, pos,
    143						    evsel->core.idx);
    144		}
    145
    146		if (ret)
    147			gtk_list_store_set(store, &iter, ANN_COL__PERCENT, s, -1);
    148		if (perf_gtk__get_offset(s, sizeof(s), ms, pos))
    149			gtk_list_store_set(store, &iter, ANN_COL__OFFSET, s, -1);
    150		if (perf_gtk__get_line(s, sizeof(s), pos))
    151			gtk_list_store_set(store, &iter, ANN_COL__LINE, s, -1);
    152	}
    153
    154	gtk_container_add(GTK_CONTAINER(window), view);
    155
    156	list_for_each_entry_safe(pos, n, &notes->src->source, al.node) {
    157		list_del_init(&pos->al.node);
    158		disasm_line__free(pos);
    159	}
    160
    161	return 0;
    162}
    163
    164static int symbol__gtk_annotate(struct map_symbol *ms, struct evsel *evsel,
    165				struct hist_browser_timer *hbt)
    166{
    167	struct symbol *sym = ms->sym;
    168	GtkWidget *window;
    169	GtkWidget *notebook;
    170	GtkWidget *scrolled_window;
    171	GtkWidget *tab_label;
    172	int err;
    173
    174	if (ms->map->dso->annotate_warned)
    175		return -1;
    176
    177	err = symbol__annotate(ms, evsel, &annotation__default_options, NULL);
    178	if (err) {
    179		char msg[BUFSIZ];
    180		ms->map->dso->annotate_warned = true;
    181		symbol__strerror_disassemble(ms, err, msg, sizeof(msg));
    182		ui__error("Couldn't annotate %s: %s\n", sym->name, msg);
    183		return -1;
    184	}
    185
    186	symbol__calc_percent(sym, evsel);
    187
    188	if (perf_gtk__is_active_context(pgctx)) {
    189		window = pgctx->main_window;
    190		notebook = pgctx->notebook;
    191	} else {
    192		GtkWidget *vbox;
    193		GtkWidget *infobar;
    194		GtkWidget *statbar;
    195
    196		signal(SIGSEGV, perf_gtk__signal);
    197		signal(SIGFPE,  perf_gtk__signal);
    198		signal(SIGINT,  perf_gtk__signal);
    199		signal(SIGQUIT, perf_gtk__signal);
    200		signal(SIGTERM, perf_gtk__signal);
    201
    202		window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    203		gtk_window_set_title(GTK_WINDOW(window), "perf annotate");
    204
    205		g_signal_connect(window, "delete_event", gtk_main_quit, NULL);
    206
    207		pgctx = perf_gtk__activate_context(window);
    208		if (!pgctx)
    209			return -1;
    210
    211		vbox = gtk_vbox_new(FALSE, 0);
    212		notebook = gtk_notebook_new();
    213		pgctx->notebook = notebook;
    214
    215		gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
    216
    217		infobar = perf_gtk__setup_info_bar();
    218		if (infobar) {
    219			gtk_box_pack_start(GTK_BOX(vbox), infobar,
    220					   FALSE, FALSE, 0);
    221		}
    222
    223		statbar = perf_gtk__setup_statusbar();
    224		gtk_box_pack_start(GTK_BOX(vbox), statbar, FALSE, FALSE, 0);
    225
    226		gtk_container_add(GTK_CONTAINER(window), vbox);
    227	}
    228
    229	scrolled_window = gtk_scrolled_window_new(NULL, NULL);
    230	tab_label = gtk_label_new(sym->name);
    231
    232	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
    233				       GTK_POLICY_AUTOMATIC,
    234				       GTK_POLICY_AUTOMATIC);
    235
    236	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), scrolled_window,
    237				 tab_label);
    238
    239	perf_gtk__annotate_symbol(scrolled_window, ms, evsel, hbt);
    240	return 0;
    241}
    242
    243int hist_entry__gtk_annotate(struct hist_entry *he,
    244			     struct evsel *evsel,
    245			     struct hist_browser_timer *hbt)
    246{
    247	return symbol__gtk_annotate(&he->ms, evsel, hbt);
    248}
    249
    250void perf_gtk__show_annotations(void)
    251{
    252	GtkWidget *window;
    253
    254	if (!perf_gtk__is_active_context(pgctx))
    255		return;
    256
    257	window = pgctx->main_window;
    258	gtk_widget_show_all(window);
    259
    260	perf_gtk__resize_window(window);
    261	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    262
    263	gtk_main();
    264
    265	perf_gtk__deactivate_context(&pgctx);
    266}