1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * builtin-annotate.c 4 * 5 * Builtin annotate command: Analyze the perf.data input file, 6 * look up and read DSOs and symbol information and display 7 * a histogram of results, along various sorting keys. 8 */ 9 #include "builtin.h" 10 11 #include "util/util.h" 12 #include "util/color.h" 13 #include <linux/list.h> 14 #include "util/cache.h" 15 #include <linux/rbtree.h> 16 #include "util/symbol.h" 17 18 #include "perf.h" 19 #include "util/debug.h" 20 21 #include "util/evlist.h" 22 #include "util/evsel.h" 23 #include "util/annotate.h" 24 #include "util/event.h" 25 #include <subcmd/parse-options.h> 26 #include "util/parse-events.h" 27 #include "util/thread.h" 28 #include "util/sort.h" 29 #include "util/hist.h" 30 #include "util/session.h" 31 #include "util/tool.h" 32 #include "util/data.h" 33 #include "arch/common.h" 34 #include "util/block-range.h" 35 36 #include <dlfcn.h> 37 #include <errno.h> 38 #include <linux/bitmap.h> 39 40 struct perf_annotate { 41 struct perf_tool tool; 42 struct perf_session *session; 43 bool use_tui, use_stdio, use_gtk; 44 bool full_paths; 45 bool print_line; 46 bool skip_missing; 47 const char *sym_hist_filter; 48 const char *cpu_list; 49 DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS); 50 }; 51 52 /* 53 * Given one basic block: 54 * 55 * from to branch_i 56 * * ----> * 57 * | 58 * | block 59 * v 60 * * ----> * 61 * from to branch_i+1 62 * 63 * where the horizontal are the branches and the vertical is the executed 64 * block of instructions. 65 * 66 * We count, for each 'instruction', the number of blocks that covered it as 67 * well as count the ratio each branch is taken. 68 * 69 * We can do this without knowing the actual instruction stream by keeping 70 * track of the address ranges. We break down ranges such that there is no 71 * overlap and iterate from the start until the end. 72 * 73 * @acme: once we parse the objdump output _before_ processing the samples, 74 * we can easily fold the branch.cycles IPC bits in. 75 */ 76 static void process_basic_block(struct addr_map_symbol *start, 77 struct addr_map_symbol *end, 78 struct branch_flags *flags) 79 { 80 struct symbol *sym = start->sym; 81 struct annotation *notes = sym ? symbol__annotation(sym) : NULL; 82 struct block_range_iter iter; 83 struct block_range *entry; 84 85 /* 86 * Sanity; NULL isn't executable and the CPU cannot execute backwards 87 */ 88 if (!start->addr || start->addr > end->addr) 89 return; 90 91 iter = block_range__create(start->addr, end->addr); 92 if (!block_range_iter__valid(&iter)) 93 return; 94 95 /* 96 * First block in range is a branch target. 97 */ 98 entry = block_range_iter(&iter); 99 assert(entry->is_target); 100 entry->entry++; 101 102 do { 103 entry = block_range_iter(&iter); 104 105 entry->coverage++; 106 entry->sym = sym; 107 108 if (notes) 109 notes->max_coverage = max(notes->max_coverage, entry->coverage); 110 111 } while (block_range_iter__next(&iter)); 112 113 /* 114 * Last block in rage is a branch. 115 */ 116 entry = block_range_iter(&iter); 117 assert(entry->is_branch); 118 entry->taken++; 119 if (flags->predicted) 120 entry->pred++; 121 } 122 123 static void process_branch_stack(struct branch_stack *bs, struct addr_location *al, 124 struct perf_sample *sample) 125 { 126 struct addr_map_symbol *prev = NULL; 127 struct branch_info *bi; 128 int i; 129 130 if (!bs || !bs->nr) 131 return; 132 133 bi = sample__resolve_bstack(sample, al); 134 if (!bi) 135 return; 136 137 for (i = bs->nr - 1; i >= 0; i--) { 138 /* 139 * XXX filter against symbol 140 */ 141 if (prev) 142 process_basic_block(prev, &bi[i].from, &bi[i].flags); 143 prev = &bi[i].to; 144 } 145 146 free(bi); 147 } 148 149 static int perf_evsel__add_sample(struct perf_evsel *evsel, 150 struct perf_sample *sample, 151 struct addr_location *al, 152 struct perf_annotate *ann) 153 { 154 struct hists *hists = evsel__hists(evsel); 155 struct hist_entry *he; 156 int ret; 157 158 if (ann->sym_hist_filter != NULL && 159 (al->sym == NULL || 160 strcmp(ann->sym_hist_filter, al->sym->name) != 0)) { 161 /* We're only interested in a symbol named sym_hist_filter */ 162 /* 163 * FIXME: why isn't this done in the symbol_filter when loading 164 * the DSO? 165 */ 166 if (al->sym != NULL) { 167 rb_erase(&al->sym->rb_node, 168 &al->map->dso->symbols[al->map->type]); 169 symbol__delete(al->sym); 170 dso__reset_find_symbol_cache(al->map->dso); 171 } 172 return 0; 173 } 174 175 /* 176 * XXX filtered samples can still have branch entires pointing into our 177 * symbol and are missed. 178 */ 179 process_branch_stack(sample->branch_stack, al, sample); 180 181 he = hists__add_entry(hists, al, NULL, NULL, NULL, sample, true); 182 if (he == NULL) 183 return -ENOMEM; 184 185 ret = hist_entry__inc_addr_samples(he, sample, evsel->idx, al->addr); 186 hists__inc_nr_samples(hists, true); 187 return ret; 188 } 189 190 static int process_sample_event(struct perf_tool *tool, 191 union perf_event *event, 192 struct perf_sample *sample, 193 struct perf_evsel *evsel, 194 struct machine *machine) 195 { 196 struct perf_annotate *ann = container_of(tool, struct perf_annotate, tool); 197 struct addr_location al; 198 int ret = 0; 199 200 if (machine__resolve(machine, &al, sample) < 0) { 201 pr_warning("problem processing %d event, skipping it.\n", 202 event->header.type); 203 return -1; 204 } 205 206 if (ann->cpu_list && !test_bit(sample->cpu, ann->cpu_bitmap)) 207 goto out_put; 208 209 if (!al.filtered && perf_evsel__add_sample(evsel, sample, &al, ann)) { 210 pr_warning("problem incrementing symbol count, " 211 "skipping event\n"); 212 ret = -1; 213 } 214 out_put: 215 addr_location__put(&al); 216 return ret; 217 } 218 219 static int hist_entry__tty_annotate(struct hist_entry *he, 220 struct perf_evsel *evsel, 221 struct perf_annotate *ann) 222 { 223 return symbol__tty_annotate(he->ms.sym, he->ms.map, evsel, 224 ann->print_line, ann->full_paths, 0, 0); 225 } 226 227 static void hists__find_annotations(struct hists *hists, 228 struct perf_evsel *evsel, 229 struct perf_annotate *ann) 230 { 231 struct rb_node *nd = rb_first(&hists->entries), *next; 232 int key = K_RIGHT; 233 234 while (nd) { 235 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node); 236 struct annotation *notes; 237 238 if (he->ms.sym == NULL || he->ms.map->dso->annotate_warned) 239 goto find_next; 240 241 notes = symbol__annotation(he->ms.sym); 242 if (notes->src == NULL) { 243 find_next: 244 if (key == K_LEFT) 245 nd = rb_prev(nd); 246 else 247 nd = rb_next(nd); 248 continue; 249 } 250 251 if (use_browser == 2) { 252 int ret; 253 int (*annotate)(struct hist_entry *he, 254 struct perf_evsel *evsel, 255 struct hist_browser_timer *hbt); 256 257 annotate = dlsym(perf_gtk_handle, 258 "hist_entry__gtk_annotate"); 259 if (annotate == NULL) { 260 ui__error("GTK browser not found!\n"); 261 return; 262 } 263 264 ret = annotate(he, evsel, NULL); 265 if (!ret || !ann->skip_missing) 266 return; 267 268 /* skip missing symbols */ 269 nd = rb_next(nd); 270 } else if (use_browser == 1) { 271 key = hist_entry__tui_annotate(he, evsel, NULL); 272 switch (key) { 273 case -1: 274 if (!ann->skip_missing) 275 return; 276 /* fall through */ 277 case K_RIGHT: 278 next = rb_next(nd); 279 break; 280 case K_LEFT: 281 next = rb_prev(nd); 282 break; 283 default: 284 return; 285 } 286 287 if (next != NULL) 288 nd = next; 289 } else { 290 hist_entry__tty_annotate(he, evsel, ann); 291 nd = rb_next(nd); 292 /* 293 * Since we have a hist_entry per IP for the same 294 * symbol, free he->ms.sym->src to signal we already 295 * processed this symbol. 296 */ 297 zfree(¬es->src->cycles_hist); 298 zfree(¬es->src); 299 } 300 } 301 } 302 303 static int __cmd_annotate(struct perf_annotate *ann) 304 { 305 int ret; 306 struct perf_session *session = ann->session; 307 struct perf_evsel *pos; 308 u64 total_nr_samples; 309 310 if (ann->cpu_list) { 311 ret = perf_session__cpu_bitmap(session, ann->cpu_list, 312 ann->cpu_bitmap); 313 if (ret) 314 goto out; 315 } 316 317 if (!objdump_path) { 318 ret = perf_env__lookup_objdump(&session->header.env); 319 if (ret) 320 goto out; 321 } 322 323 ret = perf_session__process_events(session); 324 if (ret) 325 goto out; 326 327 if (dump_trace) { 328 perf_session__fprintf_nr_events(session, stdout); 329 perf_evlist__fprintf_nr_events(session->evlist, stdout); 330 goto out; 331 } 332 333 if (verbose > 3) 334 perf_session__fprintf(session, stdout); 335 336 if (verbose > 2) 337 perf_session__fprintf_dsos(session, stdout); 338 339 total_nr_samples = 0; 340 evlist__for_each_entry(session->evlist, pos) { 341 struct hists *hists = evsel__hists(pos); 342 u32 nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE]; 343 344 if (nr_samples > 0) { 345 total_nr_samples += nr_samples; 346 hists__collapse_resort(hists, NULL); 347 /* Don't sort callchain */ 348 perf_evsel__reset_sample_bit(pos, CALLCHAIN); 349 perf_evsel__output_resort(pos, NULL); 350 351 if (symbol_conf.event_group && 352 !perf_evsel__is_group_leader(pos)) 353 continue; 354 355 hists__find_annotations(hists, pos, ann); 356 } 357 } 358 359 if (total_nr_samples == 0) { 360 ui__error("The %s file has no samples!\n", session->data->file.path); 361 goto out; 362 } 363 364 if (use_browser == 2) { 365 void (*show_annotations)(void); 366 367 show_annotations = dlsym(perf_gtk_handle, 368 "perf_gtk__show_annotations"); 369 if (show_annotations == NULL) { 370 ui__error("GTK browser not found!\n"); 371 goto out; 372 } 373 show_annotations(); 374 } 375 376 out: 377 return ret; 378 } 379 380 static const char * const annotate_usage[] = { 381 "perf annotate [<options>]", 382 NULL 383 }; 384 385 int cmd_annotate(int argc, const char **argv) 386 { 387 struct perf_annotate annotate = { 388 .tool = { 389 .sample = process_sample_event, 390 .mmap = perf_event__process_mmap, 391 .mmap2 = perf_event__process_mmap2, 392 .comm = perf_event__process_comm, 393 .exit = perf_event__process_exit, 394 .fork = perf_event__process_fork, 395 .namespaces = perf_event__process_namespaces, 396 .attr = perf_event__process_attr, 397 .build_id = perf_event__process_build_id, 398 .tracing_data = perf_event__process_tracing_data, 399 .feature = perf_event__process_feature, 400 .ordered_events = true, 401 .ordering_requires_timestamps = true, 402 }, 403 }; 404 struct perf_data data = { 405 .mode = PERF_DATA_MODE_READ, 406 }; 407 struct option options[] = { 408 OPT_STRING('i', "input", &input_name, "file", 409 "input file name"), 410 OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]", 411 "only consider symbols in these dsos"), 412 OPT_STRING('s', "symbol", &annotate.sym_hist_filter, "symbol", 413 "symbol to annotate"), 414 OPT_BOOLEAN('f', "force", &data.force, "don't complain, do it"), 415 OPT_INCR('v', "verbose", &verbose, 416 "be more verbose (show symbol address, etc)"), 417 OPT_BOOLEAN('q', "quiet", &quiet, "do now show any message"), 418 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, 419 "dump raw trace in ASCII"), 420 OPT_BOOLEAN(0, "gtk", &annotate.use_gtk, "Use the GTK interface"), 421 OPT_BOOLEAN(0, "tui", &annotate.use_tui, "Use the TUI interface"), 422 OPT_BOOLEAN(0, "stdio", &annotate.use_stdio, "Use the stdio interface"), 423 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 424 "file", "vmlinux pathname"), 425 OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules, 426 "load module symbols - WARNING: use only with -k and LIVE kernel"), 427 OPT_BOOLEAN('l', "print-line", &annotate.print_line, 428 "print matching source lines (may be slow)"), 429 OPT_BOOLEAN('P', "full-paths", &annotate.full_paths, 430 "Don't shorten the displayed pathnames"), 431 OPT_BOOLEAN(0, "skip-missing", &annotate.skip_missing, 432 "Skip symbols that cannot be annotated"), 433 OPT_STRING('C', "cpu", &annotate.cpu_list, "cpu", "list of cpus to profile"), 434 OPT_CALLBACK(0, "symfs", NULL, "directory", 435 "Look for files with symbols relative to this directory", 436 symbol__config_symfs), 437 OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src, 438 "Interleave source code with assembly code (default)"), 439 OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw, 440 "Display raw encoding of assembly instructions (default)"), 441 OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style", 442 "Specify disassembler style (e.g. -M intel for intel syntax)"), 443 OPT_STRING(0, "objdump", &objdump_path, "path", 444 "objdump binary to use for disassembly and annotations"), 445 OPT_BOOLEAN(0, "group", &symbol_conf.event_group, 446 "Show event group information together"), 447 OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period, 448 "Show a column with the sum of periods"), 449 OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples, 450 "Show a column with the number of samples"), 451 OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode", 452 "'always' (default), 'never' or 'auto' only applicable to --stdio mode", 453 stdio__config_color, "always"), 454 OPT_END() 455 }; 456 int ret; 457 458 set_option_flag(options, 0, "show-total-period", PARSE_OPT_EXCLUSIVE); 459 set_option_flag(options, 0, "show-nr-samples", PARSE_OPT_EXCLUSIVE); 460 461 462 ret = hists__init(); 463 if (ret < 0) 464 return ret; 465 466 argc = parse_options(argc, argv, options, annotate_usage, 0); 467 if (argc) { 468 /* 469 * Special case: if there's an argument left then assume that 470 * it's a symbol filter: 471 */ 472 if (argc > 1) 473 usage_with_options(annotate_usage, options); 474 475 annotate.sym_hist_filter = argv[0]; 476 } 477 478 if (symbol_conf.show_nr_samples && annotate.use_gtk) { 479 pr_err("--show-nr-samples is not available in --gtk mode at this time\n"); 480 return ret; 481 } 482 483 if (quiet) 484 perf_quiet_option(); 485 486 data.file.path = input_name; 487 488 annotate.session = perf_session__new(&data, false, &annotate.tool); 489 if (annotate.session == NULL) 490 return -1; 491 492 ret = symbol__annotation_init(); 493 if (ret < 0) 494 goto out_delete; 495 496 symbol_conf.try_vmlinux_path = true; 497 498 ret = symbol__init(&annotate.session->header.env); 499 if (ret < 0) 500 goto out_delete; 501 502 if (setup_sorting(NULL) < 0) 503 usage_with_options(annotate_usage, options); 504 505 if (annotate.use_stdio) 506 use_browser = 0; 507 else if (annotate.use_tui) 508 use_browser = 1; 509 else if (annotate.use_gtk) 510 use_browser = 2; 511 512 setup_browser(true); 513 514 ret = __cmd_annotate(&annotate); 515 516 out_delete: 517 /* 518 * Speed up the exit process, for large files this can 519 * take quite a while. 520 * 521 * XXX Enable this when using valgrind or if we ever 522 * librarize this command. 523 * 524 * Also experiment with obstacks to see how much speed 525 * up we'll get here. 526 * 527 * perf_session__delete(session); 528 */ 529 return ret; 530 } 531