1 /* 2 * builtin-annotate.c 3 * 4 * Builtin annotate command: Analyze the perf.data input file, 5 * look up and read DSOs and symbol information and display 6 * a histogram of results, along various sorting keys. 7 */ 8 #include "builtin.h" 9 10 #include "util/util.h" 11 #include "util/color.h" 12 #include <linux/list.h> 13 #include "util/cache.h" 14 #include <linux/rbtree.h> 15 #include "util/symbol.h" 16 17 #include "perf.h" 18 #include "util/debug.h" 19 20 #include "util/evlist.h" 21 #include "util/evsel.h" 22 #include "util/annotate.h" 23 #include "util/event.h" 24 #include "util/parse-options.h" 25 #include "util/parse-events.h" 26 #include "util/thread.h" 27 #include "util/sort.h" 28 #include "util/hist.h" 29 #include "util/session.h" 30 #include "util/tool.h" 31 #include "util/data.h" 32 #include "arch/common.h" 33 34 #include <dlfcn.h> 35 #include <linux/bitmap.h> 36 37 struct perf_annotate { 38 struct perf_tool tool; 39 struct perf_session *session; 40 bool use_tui, use_stdio, use_gtk; 41 bool full_paths; 42 bool print_line; 43 bool skip_missing; 44 const char *sym_hist_filter; 45 const char *cpu_list; 46 DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS); 47 }; 48 49 static int perf_evsel__add_sample(struct perf_evsel *evsel, 50 struct perf_sample *sample __maybe_unused, 51 struct addr_location *al, 52 struct perf_annotate *ann) 53 { 54 struct hists *hists = evsel__hists(evsel); 55 struct hist_entry *he; 56 int ret; 57 58 if (ann->sym_hist_filter != NULL && 59 (al->sym == NULL || 60 strcmp(ann->sym_hist_filter, al->sym->name) != 0)) { 61 /* We're only interested in a symbol named sym_hist_filter */ 62 /* 63 * FIXME: why isn't this done in the symbol_filter when loading 64 * the DSO? 65 */ 66 if (al->sym != NULL) { 67 rb_erase(&al->sym->rb_node, 68 &al->map->dso->symbols[al->map->type]); 69 symbol__delete(al->sym); 70 } 71 return 0; 72 } 73 74 he = __hists__add_entry(hists, al, NULL, NULL, NULL, 1, 1, 0, true); 75 if (he == NULL) 76 return -ENOMEM; 77 78 ret = hist_entry__inc_addr_samples(he, evsel->idx, al->addr); 79 hists__inc_nr_samples(hists, true); 80 return ret; 81 } 82 83 static int process_sample_event(struct perf_tool *tool, 84 union perf_event *event, 85 struct perf_sample *sample, 86 struct perf_evsel *evsel, 87 struct machine *machine) 88 { 89 struct perf_annotate *ann = container_of(tool, struct perf_annotate, tool); 90 struct addr_location al; 91 int ret = 0; 92 93 if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) { 94 pr_warning("problem processing %d event, skipping it.\n", 95 event->header.type); 96 return -1; 97 } 98 99 if (ann->cpu_list && !test_bit(sample->cpu, ann->cpu_bitmap)) 100 goto out_put; 101 102 if (!al.filtered && perf_evsel__add_sample(evsel, sample, &al, ann)) { 103 pr_warning("problem incrementing symbol count, " 104 "skipping event\n"); 105 ret = -1; 106 } 107 out_put: 108 addr_location__put(&al); 109 return ret; 110 } 111 112 static int hist_entry__tty_annotate(struct hist_entry *he, 113 struct perf_evsel *evsel, 114 struct perf_annotate *ann) 115 { 116 return symbol__tty_annotate(he->ms.sym, he->ms.map, evsel, 117 ann->print_line, ann->full_paths, 0, 0); 118 } 119 120 static void hists__find_annotations(struct hists *hists, 121 struct perf_evsel *evsel, 122 struct perf_annotate *ann) 123 { 124 struct rb_node *nd = rb_first(&hists->entries), *next; 125 int key = K_RIGHT; 126 127 while (nd) { 128 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node); 129 struct annotation *notes; 130 131 if (he->ms.sym == NULL || he->ms.map->dso->annotate_warned) 132 goto find_next; 133 134 notes = symbol__annotation(he->ms.sym); 135 if (notes->src == NULL) { 136 find_next: 137 if (key == K_LEFT) 138 nd = rb_prev(nd); 139 else 140 nd = rb_next(nd); 141 continue; 142 } 143 144 if (use_browser == 2) { 145 int ret; 146 int (*annotate)(struct hist_entry *he, 147 struct perf_evsel *evsel, 148 struct hist_browser_timer *hbt); 149 150 annotate = dlsym(perf_gtk_handle, 151 "hist_entry__gtk_annotate"); 152 if (annotate == NULL) { 153 ui__error("GTK browser not found!\n"); 154 return; 155 } 156 157 ret = annotate(he, evsel, NULL); 158 if (!ret || !ann->skip_missing) 159 return; 160 161 /* skip missing symbols */ 162 nd = rb_next(nd); 163 } else if (use_browser == 1) { 164 key = hist_entry__tui_annotate(he, evsel, NULL); 165 switch (key) { 166 case -1: 167 if (!ann->skip_missing) 168 return; 169 /* fall through */ 170 case K_RIGHT: 171 next = rb_next(nd); 172 break; 173 case K_LEFT: 174 next = rb_prev(nd); 175 break; 176 default: 177 return; 178 } 179 180 if (next != NULL) 181 nd = next; 182 } else { 183 hist_entry__tty_annotate(he, evsel, ann); 184 nd = rb_next(nd); 185 /* 186 * Since we have a hist_entry per IP for the same 187 * symbol, free he->ms.sym->src to signal we already 188 * processed this symbol. 189 */ 190 zfree(¬es->src); 191 } 192 } 193 } 194 195 static int __cmd_annotate(struct perf_annotate *ann) 196 { 197 int ret; 198 struct perf_session *session = ann->session; 199 struct perf_evsel *pos; 200 u64 total_nr_samples; 201 202 machines__set_symbol_filter(&session->machines, symbol__annotate_init); 203 204 if (ann->cpu_list) { 205 ret = perf_session__cpu_bitmap(session, ann->cpu_list, 206 ann->cpu_bitmap); 207 if (ret) 208 goto out; 209 } 210 211 if (!objdump_path) { 212 ret = perf_session_env__lookup_objdump(&session->header.env); 213 if (ret) 214 goto out; 215 } 216 217 ret = perf_session__process_events(session); 218 if (ret) 219 goto out; 220 221 if (dump_trace) { 222 perf_session__fprintf_nr_events(session, stdout); 223 perf_evlist__fprintf_nr_events(session->evlist, stdout); 224 goto out; 225 } 226 227 if (verbose > 3) 228 perf_session__fprintf(session, stdout); 229 230 if (verbose > 2) 231 perf_session__fprintf_dsos(session, stdout); 232 233 total_nr_samples = 0; 234 evlist__for_each(session->evlist, pos) { 235 struct hists *hists = evsel__hists(pos); 236 u32 nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE]; 237 238 if (nr_samples > 0) { 239 total_nr_samples += nr_samples; 240 hists__collapse_resort(hists, NULL); 241 hists__output_resort(hists, NULL); 242 243 if (symbol_conf.event_group && 244 !perf_evsel__is_group_leader(pos)) 245 continue; 246 247 hists__find_annotations(hists, pos, ann); 248 } 249 } 250 251 if (total_nr_samples == 0) { 252 ui__error("The %s file has no samples!\n", session->file->path); 253 goto out; 254 } 255 256 if (use_browser == 2) { 257 void (*show_annotations)(void); 258 259 show_annotations = dlsym(perf_gtk_handle, 260 "perf_gtk__show_annotations"); 261 if (show_annotations == NULL) { 262 ui__error("GTK browser not found!\n"); 263 goto out; 264 } 265 show_annotations(); 266 } 267 268 out: 269 return ret; 270 } 271 272 static const char * const annotate_usage[] = { 273 "perf annotate [<options>]", 274 NULL 275 }; 276 277 int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused) 278 { 279 struct perf_annotate annotate = { 280 .tool = { 281 .sample = process_sample_event, 282 .mmap = perf_event__process_mmap, 283 .mmap2 = perf_event__process_mmap2, 284 .comm = perf_event__process_comm, 285 .exit = perf_event__process_exit, 286 .fork = perf_event__process_fork, 287 .ordered_events = true, 288 .ordering_requires_timestamps = true, 289 }, 290 }; 291 struct perf_data_file file = { 292 .mode = PERF_DATA_MODE_READ, 293 }; 294 const struct option options[] = { 295 OPT_STRING('i', "input", &input_name, "file", 296 "input file name"), 297 OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]", 298 "only consider symbols in these dsos"), 299 OPT_STRING('s', "symbol", &annotate.sym_hist_filter, "symbol", 300 "symbol to annotate"), 301 OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"), 302 OPT_INCR('v', "verbose", &verbose, 303 "be more verbose (show symbol address, etc)"), 304 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace, 305 "dump raw trace in ASCII"), 306 OPT_BOOLEAN(0, "gtk", &annotate.use_gtk, "Use the GTK interface"), 307 OPT_BOOLEAN(0, "tui", &annotate.use_tui, "Use the TUI interface"), 308 OPT_BOOLEAN(0, "stdio", &annotate.use_stdio, "Use the stdio interface"), 309 OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name, 310 "file", "vmlinux pathname"), 311 OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules, 312 "load module symbols - WARNING: use only with -k and LIVE kernel"), 313 OPT_BOOLEAN('l', "print-line", &annotate.print_line, 314 "print matching source lines (may be slow)"), 315 OPT_BOOLEAN('P', "full-paths", &annotate.full_paths, 316 "Don't shorten the displayed pathnames"), 317 OPT_BOOLEAN(0, "skip-missing", &annotate.skip_missing, 318 "Skip symbols that cannot be annotated"), 319 OPT_STRING('C', "cpu", &annotate.cpu_list, "cpu", "list of cpus to profile"), 320 OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory", 321 "Look for files with symbols relative to this directory"), 322 OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src, 323 "Interleave source code with assembly code (default)"), 324 OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw, 325 "Display raw encoding of assembly instructions (default)"), 326 OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style", 327 "Specify disassembler style (e.g. -M intel for intel syntax)"), 328 OPT_STRING(0, "objdump", &objdump_path, "path", 329 "objdump binary to use for disassembly and annotations"), 330 OPT_BOOLEAN(0, "group", &symbol_conf.event_group, 331 "Show event group information together"), 332 OPT_END() 333 }; 334 int ret = hists__init(); 335 336 if (ret < 0) 337 return ret; 338 339 argc = parse_options(argc, argv, options, annotate_usage, 0); 340 341 if (annotate.use_stdio) 342 use_browser = 0; 343 else if (annotate.use_tui) 344 use_browser = 1; 345 else if (annotate.use_gtk) 346 use_browser = 2; 347 348 file.path = input_name; 349 350 setup_browser(true); 351 352 annotate.session = perf_session__new(&file, false, &annotate.tool); 353 if (annotate.session == NULL) 354 return -1; 355 356 symbol_conf.priv_size = sizeof(struct annotation); 357 symbol_conf.try_vmlinux_path = true; 358 359 ret = symbol__init(&annotate.session->header.env); 360 if (ret < 0) 361 goto out_delete; 362 363 if (setup_sorting() < 0) 364 usage_with_options(annotate_usage, options); 365 366 if (argc) { 367 /* 368 * Special case: if there's an argument left then assume that 369 * it's a symbol filter: 370 */ 371 if (argc > 1) 372 usage_with_options(annotate_usage, options); 373 374 annotate.sym_hist_filter = argv[0]; 375 } 376 377 ret = __cmd_annotate(&annotate); 378 379 out_delete: 380 /* 381 * Speed up the exit process, for large files this can 382 * take quite a while. 383 * 384 * XXX Enable this when using valgrind or if we ever 385 * librarize this command. 386 * 387 * Also experiment with obstacks to see how much speed 388 * up we'll get here. 389 * 390 * perf_session__delete(session); 391 */ 392 return ret; 393 } 394