| 1 | |
| 2 | * builtin-diff.c
|
| 3 | *
|
| 4 | * Builtin diff command: Analyze two perf.data input files, look up and read
|
| 5 | * DSOs and symbol information, sort them and produce a diff.
|
| 6 |
|
| 7 | #include "builtin.h"
|
| 8 |
|
| 9 | #include "util/debug.h"
|
| 10 | #include "util/event.h"
|
| 11 | #include "util/hist.h"
|
| 12 | #include "util/session.h"
|
| 13 | #include "util/sort.h"
|
| 14 | #include "util/symbol.h"
|
| 15 | #include "util/util.h"
|
| 16 |
|
| 17 | #include <stdlib.h>
|
| 18 |
|
| 19 | static char const *input_old = "perf.data.old",
|
| 20 | *input_new = "perf.data";
|
| 21 | static char diff__default_sort_order[] = "dso,symbol";
|
| 22 | static bool force;
|
| 23 | static bool show_displacement;
|
| 24 |
|
| 25 | static int hists__add_entry(struct hists *self,
|
| 26 | struct addr_location *al, u64 period)
|
| 27 | {
|
| 28 | if (__hists__add_entry(self, al, NULL, period) != NULL)
|
| 29 | return 0;
|
| 30 | return -ENOMEM;
|
| 31 | }
|
| 32 |
|
| 33 | static int diff__process_sample_event(union perf_event *event,
|
| 34 | struct perf_sample *sample,
|
| 35 | struct perf_evsel *evsel __used,
|
| 36 | struct perf_session *session)
|
| 37 | {
|
| 38 | struct addr_location al;
|
| 39 |
|
| 40 | if (perf_event__preprocess_sample(event, session, &al, sample, NULL) < 0) {
|
| 41 | pr_warning("problem processing %d event, skipping it.\n",
|
| 42 | event->header.type);
|
| 43 | return -1;
|
| 44 | }
|
| 45 |
|
| 46 | if (al.filtered || al.sym == NULL)
|
| 47 | return 0;
|
| 48 |
|
| 49 | if (hists__add_entry(&session->hists, &al, sample->period)) {
|
| 50 | pr_warning("problem incrementing symbol period, skipping event\n");
|
| 51 | return -1;
|
| 52 | }
|
| 53 |
|
| 54 | session->hists.stats.total_period += sample->period;
|
| 55 | return 0;
|
| 56 | }
|
| 57 |
|
| 58 | static struct perf_event_ops event_ops = {
|
| 59 | .sample = diff__process_sample_event,
|
| 60 | .mmap = perf_event__process_mmap,
|
| 61 | .comm = perf_event__process_comm,
|
| 62 | .exit = perf_event__process_task,
|
| 63 | .fork = perf_event__process_task,
|
| 64 | .lost = perf_event__process_lost,
|
| 65 | .ordered_samples = true,
|
| 66 | .ordering_requires_timestamps = true,
|
| 67 | };
|
| 68 |
|
| 69 | static void perf_session__insert_hist_entry_by_name(struct rb_root *root,
|
| 70 | struct hist_entry *he)
|
| 71 | {
|
| 72 | struct rb_node **p = &root->rb_node;
|
| 73 | struct rb_node *parent = NULL;
|
| 74 | struct hist_entry *iter;
|
| 75 |
|
| 76 | while (*p != NULL) {
|
| 77 | parent = *p;
|
| 78 | iter = rb_entry(parent, struct hist_entry, rb_node);
|
| 79 | if (hist_entry__cmp(he, iter) < 0)
|
| 80 | p = &(*p)->rb_left;
|
| 81 | else
|
| 82 | p = &(*p)->rb_right;
|
| 83 | }
|
| 84 |
|
| 85 | rb_link_node(&he->rb_node, parent, p);
|
| 86 | rb_insert_color(&he->rb_node, root);
|
| 87 | }
|
| 88 |
|
| 89 | static void hists__resort_entries(struct hists *self)
|
| 90 | {
|
| 91 | unsigned long position = 1;
|
| 92 | struct rb_root tmp = RB_ROOT;
|
| 93 | struct rb_node *next = rb_first(&self->entries);
|
| 94 |
|
| 95 | while (next != NULL) {
|
| 96 | struct hist_entry *n = rb_entry(next, struct hist_entry, rb_node);
|
| 97 |
|
| 98 | next = rb_next(&n->rb_node);
|
| 99 | rb_erase(&n->rb_node, &self->entries);
|
| 100 | n->position = position++;
|
| 101 | perf_session__insert_hist_entry_by_name(&tmp, n);
|
| 102 | }
|
| 103 |
|
| 104 | self->entries = tmp;
|
| 105 | }
|
| 106 |
|
| 107 | static void hists__set_positions(struct hists *self)
|
| 108 | {
|
| 109 | hists__output_resort(self);
|
| 110 | hists__resort_entries(self);
|
| 111 | }
|
| 112 |
|
| 113 | static struct hist_entry *hists__find_entry(struct hists *self,
|
| 114 | struct hist_entry *he)
|
| 115 | {
|
| 116 | struct rb_node *n = self->entries.rb_node;
|
| 117 |
|
| 118 | while (n) {
|
| 119 | struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node);
|
| 120 | int64_t cmp = hist_entry__cmp(he, iter);
|
| 121 |
|
| 122 | if (cmp < 0)
|
| 123 | n = n->rb_left;
|
| 124 | else if (cmp > 0)
|
| 125 | n = n->rb_right;
|
| 126 | else
|
| 127 | return iter;
|
| 128 | }
|
| 129 |
|
| 130 | return NULL;
|
| 131 | }
|
| 132 |
|
| 133 | static void hists__match(struct hists *older, struct hists *newer)
|
| 134 | {
|
| 135 | struct rb_node *nd;
|
| 136 |
|
| 137 | for (nd = rb_first(&newer->entries); nd; nd = rb_next(nd)) {
|
| 138 | struct hist_entry *pos = rb_entry(nd, struct hist_entry, rb_node);
|
| 139 | pos->pair = hists__find_entry(older, pos);
|
| 140 | }
|
| 141 | }
|
| 142 |
|
| 143 | static int __cmd_diff(void)
|
| 144 | {
|
| 145 | int ret, i;
|
| 146 | struct perf_session *session[2];
|
| 147 |
|
| 148 | session[0] = perf_session__new(input_old, O_RDONLY, force, false, &event_ops);
|
| 149 | session[1] = perf_session__new(input_new, O_RDONLY, force, false, &event_ops);
|
| 150 | if (session[0] == NULL || session[1] == NULL)
|
| 151 | return -ENOMEM;
|
| 152 |
|
| 153 | for (i = 0; i < 2; ++i) {
|
| 154 | ret = perf_session__process_events(session[i], &event_ops);
|
| 155 | if (ret)
|
| 156 | goto out_delete;
|
| 157 | }
|
| 158 |
|
| 159 | hists__output_resort(&session[1]->hists);
|
| 160 | if (show_displacement)
|
| 161 | hists__set_positions(&session[0]->hists);
|
| 162 |
|
| 163 | hists__match(&session[0]->hists, &session[1]->hists);
|
| 164 | hists__fprintf(&session[1]->hists, &session[0]->hists,
|
| 165 | show_displacement, true, 0, 0, stdout);
|
| 166 | out_delete:
|
| 167 | for (i = 0; i < 2; ++i)
|
| 168 | perf_session__delete(session[i]);
|
| 169 | return ret;
|
| 170 | }
|
| 171 |
|
| 172 | static const char * const diff_usage[] = {
|
| 173 | "perf diff [<options>] [old_file] [new_file]",
|
| 174 | NULL,
|
| 175 | };
|
| 176 |
|
| 177 | static const struct option options[] = {
|
| 178 | OPT_INCR('v', "verbose", &verbose,
|
| 179 | "be more verbose (show symbol address, etc)"),
|
| 180 | OPT_BOOLEAN('M', "displacement", &show_displacement,
|
| 181 | "Show position displacement relative to baseline"),
|
| 182 | OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
|
| 183 | "dump raw trace in ASCII"),
|
| 184 | OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
|
| 185 | OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
|
| 186 | "load module symbols - WARNING: use only with -k and LIVE kernel"),
|
| 187 | OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
|
| 188 | "only consider symbols in these dsos"),
|
| 189 | OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
|
| 190 | "only consider symbols in these comms"),
|
| 191 | OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
|
| 192 | "only consider these symbols"),
|
| 193 | OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
|
| 194 | "sort by key(s): pid, comm, dso, symbol, parent"),
|
| 195 | OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
|
| 196 | "separator for columns, no spaces will be added between "
|
| 197 | "columns '.' is reserved."),
|
| 198 | OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
|
| 199 | "Look for files with symbols relative to this directory"),
|
| 200 | OPT_END()
|
| 201 | };
|
| 202 |
|
| 203 | int cmd_diff(int argc, const char **argv, const char *prefix __used)
|
| 204 | {
|
| 205 | sort_order = diff__default_sort_order;
|
| 206 | argc = parse_options(argc, argv, options, diff_usage, 0);
|
| 207 | if (argc) {
|
| 208 | if (argc > 2)
|
| 209 | usage_with_options(diff_usage, options);
|
| 210 | if (argc == 2) {
|
| 211 | input_old = argv[0];
|
| 212 | input_new = argv[1];
|
| 213 | } else
|
| 214 | input_new = argv[0];
|
| 215 | } else if (symbol_conf.default_guest_vmlinux_name ||
|
| 216 | symbol_conf.default_guest_kallsyms) {
|
| 217 | input_old = "perf.data.host";
|
| 218 | input_new = "perf.data.guest";
|
| 219 | }
|
| 220 |
|
| 221 | symbol_conf.exclude_other = false;
|
| 222 | if (symbol__init() < 0)
|
| 223 | return -1;
|
| 224 |
|
| 225 | setup_sorting(diff_usage, options);
|
| 226 | setup_pager();
|
| 227 |
|
| 228 | sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", NULL);
|
| 229 | sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", NULL);
|
| 230 | sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", NULL);
|
| 231 |
|
| 232 | return __cmd_diff();
|
| 233 | }
|