blob: 1efefcc2ffdfa7e3c0caaa718f6daad7ea0b7308 [file] [log] [blame]
Ingo Molnarbf9e1872009-06-02 23:37:05 +02001/*
2 * builtin-report.c
3 *
4 * Builtin report 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 */
Ingo Molnar16f762a2009-05-27 09:10:38 +02008#include "builtin.h"
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02009
Ingo Molnarbf9e1872009-06-02 23:37:05 +020010#include "util/util.h"
11
Ingo Molnar8fc03212009-06-04 15:19:47 +020012#include "util/color.h"
Arnaldo Carvalho de Melo5da50252009-07-01 14:46:08 -030013#include <linux/list.h>
Ingo Molnara930d2c2009-05-27 09:50:13 +020014#include "util/cache.h"
Arnaldo Carvalho de Melo43cbcd82009-07-01 12:28:37 -030015#include <linux/rbtree.h>
Arnaldo Carvalho de Meloa2928c42009-05-28 14:55:04 -030016#include "util/symbol.h"
Arnaldo Carvalho de Meloa0055ae2009-06-01 17:50:19 -030017#include "util/string.h"
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +020018#include "util/callchain.h"
Arnaldo Carvalho de Melo25903402009-06-30 19:01:20 -030019#include "util/strlist.h"
Brice Goglin8d513272009-08-07 13:55:24 +020020#include "util/values.h"
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -030021
Ingo Molnar53cb8bc2009-05-26 09:17:18 +020022#include "perf.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020023#include "util/header.h"
Ingo Molnar53cb8bc2009-05-26 09:17:18 +020024
25#include "util/parse-options.h"
26#include "util/parse-events.h"
27
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -030028#define SHOW_KERNEL 1
29#define SHOW_USER 2
30#define SHOW_HV 4
31
Ingo Molnar23ac9cb2009-05-27 09:33:18 +020032static char const *input_name = "perf.data";
Ingo Molnarbd741372009-06-04 14:13:04 +020033
Pekka Enberg114cfab2009-08-05 13:25:21 +030034static char default_sort_order[] = "comm,dso,symbol";
Ingo Molnarbd741372009-06-04 14:13:04 +020035static char *sort_order = default_sort_order;
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -030036static char *dso_list_str, *comm_list_str, *sym_list_str,
37 *col_width_list_str;
Arnaldo Carvalho de Melo7bec7a92009-06-30 19:01:22 -030038static struct strlist *dso_list, *comm_list, *sym_list;
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -030039static char *field_sep;
Ingo Molnarbd741372009-06-04 14:13:04 +020040
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -030041static int input;
42static int show_mask = SHOW_KERNEL | SHOW_USER | SHOW_HV;
43
Ingo Molnar97b07b62009-05-26 18:48:58 +020044static int dump_trace = 0;
Ingo Molnar35029732009-06-03 09:38:58 +020045#define dprintf(x...) do { if (dump_trace) printf(x); } while (0)
Ingo Molnar3efa1cc92009-06-14 15:04:15 +020046#define cdprintf(x...) do { if (dump_trace) color_fprintf(stdout, color, x); } while (0)
Ingo Molnar35029732009-06-03 09:38:58 +020047
Arnaldo Carvalho de Melob78c07d2009-05-29 13:48:59 -030048static int full_paths;
Arnaldo Carvalho de Meloe3d7e182009-07-11 12:18:37 -030049static int show_nr_samples;
Ingo Molnar97b07b62009-05-26 18:48:58 +020050
Brice Goglin8d513272009-08-07 13:55:24 +020051static int show_threads;
52static struct perf_read_values show_threads_values;
53
Brice Goglin9f866692009-08-10 15:26:32 +020054static char default_pretty_printing_style[] = "normal";
55static char *pretty_printing_style = default_pretty_printing_style;
56
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -030057static unsigned long page_size;
58static unsigned long mmap_window = 32;
59
Ingo Molnarb8e6d822009-06-18 14:32:19 +020060static char default_parent_pattern[] = "^sys_|^do_page_fault";
61static char *parent_pattern = default_parent_pattern;
Ingo Molnarb25bcf22009-06-18 07:01:03 +020062static regex_t parent_regex;
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +020063
Ingo Molnarb8e6d822009-06-18 14:32:19 +020064static int exclude_other = 1;
Frederic Weisbeckerbe903882009-07-05 07:39:18 +020065
Frederic Weisbecker805d1272009-07-05 07:39:21 +020066static char callchain_default_opt[] = "fractal,0.5";
67
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +020068static int callchain;
Frederic Weisbecker805d1272009-07-05 07:39:21 +020069
70static
71struct callchain_param callchain_param = {
Frederic Weisbeckerb1a88342009-08-08 02:16:24 +020072 .mode = CHAIN_GRAPH_REL,
Frederic Weisbecker805d1272009-07-05 07:39:21 +020073 .min_percent = 0.5
74};
Ingo Molnarb8e6d822009-06-18 14:32:19 +020075
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +020076static u64 sample_type;
77
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -030078static int repsep_fprintf(FILE *fp, const char *fmt, ...)
79{
80 int n;
81 va_list ap;
82
83 va_start(ap, fmt);
84 if (!field_sep)
85 n = vfprintf(fp, fmt, ap);
86 else {
87 char *bf = NULL;
88 n = vasprintf(&bf, fmt, ap);
89 if (n > 0) {
90 char *sep = bf;
91 while (1) {
92 sep = strchr(sep, *field_sep);
93 if (sep == NULL)
94 break;
95 *sep = '.';
96 }
97 }
98 fputs(bf, fp);
99 free(bf);
100 }
101 va_end(ap);
102 return n;
103}
104
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300105
Peter Zijlstra450aaa22009-05-27 20:20:23 +0200106
Ingo Molnard80d3382009-06-03 23:14:49 +0200107static char __cwd[PATH_MAX];
108static char *cwd = __cwd;
109static int cwdlen;
110
111static int strcommon(const char *pathname)
Arnaldo Carvalho de Melob78c07d2009-05-29 13:48:59 -0300112{
113 int n = 0;
114
Roel Kluin7e030652009-08-02 13:43:11 +0200115 while (n < cwdlen && pathname[n] == cwd[n])
Arnaldo Carvalho de Melob78c07d2009-05-29 13:48:59 -0300116 ++n;
117
118 return n;
119}
120
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300121struct map {
122 struct list_head node;
Paul Mackerras9cffa8d2009-06-19 22:21:42 +1000123 u64 start;
124 u64 end;
125 u64 pgoff;
126 u64 (*map_ip)(struct map *, u64);
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300127 struct dso *dso;
128};
129
Paul Mackerras9cffa8d2009-06-19 22:21:42 +1000130static u64 map__map_ip(struct map *map, u64 ip)
Peter Zijlstrafc54db52009-06-05 14:04:59 +0200131{
132 return ip - map->start + map->pgoff;
133}
134
Ingo Molnarf37a2912009-07-01 12:37:06 +0200135static u64 vdso__map_ip(struct map *map __used, u64 ip)
Peter Zijlstrafc54db52009-06-05 14:04:59 +0200136{
137 return ip;
138}
139
Pekka Enberg80d496b2009-06-08 21:12:48 +0300140static inline int is_anon_memory(const char *filename)
141{
Arnaldo Carvalho de Melocc8b88b2009-06-30 19:01:21 -0300142 return strcmp(filename, "//anon") == 0;
Pekka Enberg80d496b2009-06-08 21:12:48 +0300143}
144
Ingo Molnard80d3382009-06-03 23:14:49 +0200145static struct map *map__new(struct mmap_event *event)
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300146{
147 struct map *self = malloc(sizeof(*self));
148
149 if (self != NULL) {
Arnaldo Carvalho de Melob78c07d2009-05-29 13:48:59 -0300150 const char *filename = event->filename;
151 char newfilename[PATH_MAX];
Pekka Enberg80d496b2009-06-08 21:12:48 +0300152 int anon;
Arnaldo Carvalho de Melob78c07d2009-05-29 13:48:59 -0300153
154 if (cwd) {
Ingo Molnard80d3382009-06-03 23:14:49 +0200155 int n = strcommon(filename);
156
Arnaldo Carvalho de Melob78c07d2009-05-29 13:48:59 -0300157 if (n == cwdlen) {
158 snprintf(newfilename, sizeof(newfilename),
159 ".%s", filename + n);
160 filename = newfilename;
161 }
162 }
163
Pekka Enberg80d496b2009-06-08 21:12:48 +0300164 anon = is_anon_memory(filename);
165
166 if (anon) {
167 snprintf(newfilename, sizeof(newfilename), "/tmp/perf-%d.map", event->pid);
168 filename = newfilename;
169 }
170
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300171 self->start = event->start;
172 self->end = event->start + event->len;
173 self->pgoff = event->pgoff;
174
Arnaldo Carvalho de Melob78c07d2009-05-29 13:48:59 -0300175 self->dso = dsos__findnew(filename);
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300176 if (self->dso == NULL)
177 goto out_delete;
Peter Zijlstrafc54db52009-06-05 14:04:59 +0200178
Pekka Enberg80d496b2009-06-08 21:12:48 +0300179 if (self->dso == vdso || anon)
Peter Zijlstrafc54db52009-06-05 14:04:59 +0200180 self->map_ip = vdso__map_ip;
181 else
182 self->map_ip = map__map_ip;
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300183 }
184 return self;
185out_delete:
186 free(self);
187 return NULL;
188}
189
Peter Zijlstra62fc4452009-06-04 16:53:49 +0200190static struct map *map__clone(struct map *self)
191{
192 struct map *map = malloc(sizeof(*self));
193
194 if (!map)
195 return NULL;
196
197 memcpy(map, self, sizeof(*self));
198
199 return map;
200}
201
202static int map__overlap(struct map *l, struct map *r)
203{
204 if (l->start > r->start) {
205 struct map *t = l;
206 l = r;
207 r = t;
208 }
209
210 if (l->end > r->start)
211 return 1;
212
213 return 0;
214}
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -0300215
Arnaldo Carvalho de Melo9ac99542009-06-04 13:54:00 -0300216static size_t map__fprintf(struct map *self, FILE *fp)
217{
Ingo Molnar729ff5e22009-06-11 14:16:15 +0200218 return fprintf(fp, " %Lx-%Lx %Lx %s\n",
Arnaldo Carvalho de Melo9ac99542009-06-04 13:54:00 -0300219 self->start, self->end, self->pgoff, self->dso->name);
220}
221
222
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300223struct thread {
Arnaldo Carvalho de Meloce7e4362009-05-19 09:30:23 -0300224 struct rb_node rb_node;
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300225 struct list_head maps;
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300226 pid_t pid;
227 char *comm;
228};
229
230static struct thread *thread__new(pid_t pid)
231{
232 struct thread *self = malloc(sizeof(*self));
233
234 if (self != NULL) {
235 self->pid = pid;
Peter Zijlstra82292892009-06-03 12:37:36 +0200236 self->comm = malloc(32);
Ingo Molnar0a520c62009-06-02 23:24:45 +0200237 if (self->comm)
Peter Zijlstra82292892009-06-03 12:37:36 +0200238 snprintf(self->comm, 32, ":%d", self->pid);
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300239 INIT_LIST_HEAD(&self->maps);
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300240 }
241
242 return self;
243}
244
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300245static unsigned int dsos__col_width,
246 comms__col_width,
247 threads__col_width;
248
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300249static int thread__set_comm(struct thread *self, const char *comm)
250{
Peter Zijlstra82292892009-06-03 12:37:36 +0200251 if (self->comm)
252 free(self->comm);
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300253 self->comm = strdup(comm);
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300254 if (!self->comm)
255 return -ENOMEM;
256
257 if (!col_width_list_str && !field_sep &&
258 (!comm_list || strlist__has_entry(comm_list, comm))) {
259 unsigned int slen = strlen(comm);
260 if (slen > comms__col_width) {
261 comms__col_width = slen;
262 threads__col_width = slen + 6;
263 }
264 }
265
266 return 0;
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300267}
268
Arnaldo Carvalho de Melo9ac99542009-06-04 13:54:00 -0300269static size_t thread__fprintf(struct thread *self, FILE *fp)
270{
271 struct map *pos;
272 size_t ret = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
273
274 list_for_each_entry(pos, &self->maps, node)
275 ret += map__fprintf(pos, fp);
276
277 return ret;
278}
279
280
Ingo Molnar16f762a2009-05-27 09:10:38 +0200281static struct rb_root threads;
Ingo Molnareed4dcd2009-06-03 19:59:24 +0200282static struct thread *last_match;
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300283
284static struct thread *threads__findnew(pid_t pid)
285{
Arnaldo Carvalho de Meloce7e4362009-05-19 09:30:23 -0300286 struct rb_node **p = &threads.rb_node;
287 struct rb_node *parent = NULL;
288 struct thread *th;
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300289
Ingo Molnareed4dcd2009-06-03 19:59:24 +0200290 /*
291 * Font-end cache - PID lookups come in blocks,
292 * so most of the time we dont have to look up
293 * the full rbtree:
294 */
295 if (last_match && last_match->pid == pid)
296 return last_match;
297
Arnaldo Carvalho de Meloce7e4362009-05-19 09:30:23 -0300298 while (*p != NULL) {
299 parent = *p;
300 th = rb_entry(parent, struct thread, rb_node);
301
Ingo Molnareed4dcd2009-06-03 19:59:24 +0200302 if (th->pid == pid) {
303 last_match = th;
Arnaldo Carvalho de Meloce7e4362009-05-19 09:30:23 -0300304 return th;
Ingo Molnareed4dcd2009-06-03 19:59:24 +0200305 }
Arnaldo Carvalho de Meloce7e4362009-05-19 09:30:23 -0300306
307 if (pid < th->pid)
308 p = &(*p)->rb_left;
309 else
310 p = &(*p)->rb_right;
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300311 }
312
Arnaldo Carvalho de Meloce7e4362009-05-19 09:30:23 -0300313 th = thread__new(pid);
314 if (th != NULL) {
315 rb_link_node(&th->rb_node, parent, p);
316 rb_insert_color(&th->rb_node, &threads);
Ingo Molnareed4dcd2009-06-03 19:59:24 +0200317 last_match = th;
Arnaldo Carvalho de Meloce7e4362009-05-19 09:30:23 -0300318 }
Ingo Molnareed4dcd2009-06-03 19:59:24 +0200319
Arnaldo Carvalho de Meloce7e4362009-05-19 09:30:23 -0300320 return th;
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300321}
322
323static void thread__insert_map(struct thread *self, struct map *map)
324{
Peter Zijlstra62fc4452009-06-04 16:53:49 +0200325 struct map *pos, *tmp;
326
327 list_for_each_entry_safe(pos, tmp, &self->maps, node) {
328 if (map__overlap(pos, map)) {
Peter Zijlstra3d906ef2009-06-23 11:23:07 +0200329 if (verbose >= 2) {
330 printf("overlapping maps:\n");
331 map__fprintf(map, stdout);
332 map__fprintf(pos, stdout);
333 }
334
335 if (map->start <= pos->start && map->end > pos->start)
336 pos->start = map->end;
337
338 if (map->end >= pos->end && map->start < pos->end)
339 pos->end = map->start;
340
341 if (verbose >= 2) {
342 printf("after collision:\n");
343 map__fprintf(pos, stdout);
344 }
345
346 if (pos->start >= pos->end) {
347 list_del_init(&pos->node);
348 free(pos);
349 }
Peter Zijlstra62fc4452009-06-04 16:53:49 +0200350 }
351 }
352
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300353 list_add_tail(&map->node, &self->maps);
354}
355
Peter Zijlstra62fc4452009-06-04 16:53:49 +0200356static int thread__fork(struct thread *self, struct thread *parent)
357{
358 struct map *map;
359
360 if (self->comm)
361 free(self->comm);
362 self->comm = strdup(parent->comm);
363 if (!self->comm)
364 return -ENOMEM;
365
366 list_for_each_entry(map, &parent->maps, node) {
367 struct map *new = map__clone(map);
368 if (!new)
369 return -ENOMEM;
370 thread__insert_map(self, new);
371 }
372
373 return 0;
374}
375
Paul Mackerras9cffa8d2009-06-19 22:21:42 +1000376static struct map *thread__find_map(struct thread *self, u64 ip)
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300377{
Ingo Molnar16f762a2009-05-27 09:10:38 +0200378 struct map *pos;
379
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300380 if (self == NULL)
381 return NULL;
382
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300383 list_for_each_entry(pos, &self->maps, node)
384 if (ip >= pos->start && ip <= pos->end)
385 return pos;
386
387 return NULL;
388}
389
Arnaldo Carvalho de Melo9ac99542009-06-04 13:54:00 -0300390static size_t threads__fprintf(FILE *fp)
391{
392 size_t ret = 0;
393 struct rb_node *nd;
394
395 for (nd = rb_first(&threads); nd; nd = rb_next(nd)) {
396 struct thread *pos = rb_entry(nd, struct thread, rb_node);
397
398 ret += thread__fprintf(pos, fp);
399 }
400
401 return ret;
402}
403
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +0200404/*
405 * histogram, sorted on item, collects counts
406 */
407
408static struct rb_root hist;
409
410struct hist_entry {
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +0200411 struct rb_node rb_node;
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +0200412
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +0200413 struct thread *thread;
414 struct map *map;
415 struct dso *dso;
416 struct symbol *sym;
417 struct symbol *parent;
418 u64 ip;
419 char level;
420 struct callchain_node callchain;
421 struct rb_root sorted_chain;
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +0200422
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +0200423 u64 count;
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +0200424};
425
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200426/*
427 * configurable sorting bits
428 */
429
430struct sort_entry {
431 struct list_head list;
432
Peter Zijlstraca8cdee2009-05-28 11:08:33 +0200433 char *header;
434
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200435 int64_t (*cmp)(struct hist_entry *, struct hist_entry *);
Peter Zijlstra82292892009-06-03 12:37:36 +0200436 int64_t (*collapse)(struct hist_entry *, struct hist_entry *);
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300437 size_t (*print)(FILE *fp, struct hist_entry *, unsigned int width);
438 unsigned int *width;
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -0300439 bool elide;
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200440};
441
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200442static int64_t cmp_null(void *l, void *r)
443{
444 if (!l && !r)
445 return 0;
446 else if (!l)
447 return -1;
448 else
449 return 1;
450}
451
Peter Zijlstra82292892009-06-03 12:37:36 +0200452/* --sort pid */
453
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +0200454static int64_t
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200455sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
456{
457 return right->thread->pid - left->thread->pid;
458}
459
460static size_t
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300461sort__thread_print(FILE *fp, struct hist_entry *self, unsigned int width)
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200462{
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300463 return repsep_fprintf(fp, "%*s:%5d", width - 6,
464 self->thread->comm ?: "", self->thread->pid);
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200465}
466
467static struct sort_entry sort_thread = {
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300468 .header = "Command: Pid",
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200469 .cmp = sort__thread_cmp,
470 .print = sort__thread_print,
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300471 .width = &threads__col_width,
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200472};
473
Peter Zijlstra82292892009-06-03 12:37:36 +0200474/* --sort comm */
475
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200476static int64_t
Peter Zijlstra992444b2009-05-27 20:20:27 +0200477sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
478{
Peter Zijlstra82292892009-06-03 12:37:36 +0200479 return right->thread->pid - left->thread->pid;
480}
481
482static int64_t
483sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
484{
Peter Zijlstra992444b2009-05-27 20:20:27 +0200485 char *comm_l = left->thread->comm;
486 char *comm_r = right->thread->comm;
487
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200488 if (!comm_l || !comm_r)
489 return cmp_null(comm_l, comm_r);
Peter Zijlstra992444b2009-05-27 20:20:27 +0200490
491 return strcmp(comm_l, comm_r);
492}
493
494static size_t
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300495sort__comm_print(FILE *fp, struct hist_entry *self, unsigned int width)
Peter Zijlstra992444b2009-05-27 20:20:27 +0200496{
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300497 return repsep_fprintf(fp, "%*s", width, self->thread->comm);
Peter Zijlstra992444b2009-05-27 20:20:27 +0200498}
499
500static struct sort_entry sort_comm = {
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300501 .header = "Command",
Peter Zijlstra82292892009-06-03 12:37:36 +0200502 .cmp = sort__comm_cmp,
503 .collapse = sort__comm_collapse,
504 .print = sort__comm_print,
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300505 .width = &comms__col_width,
Peter Zijlstra992444b2009-05-27 20:20:27 +0200506};
507
Peter Zijlstra82292892009-06-03 12:37:36 +0200508/* --sort dso */
509
Peter Zijlstra992444b2009-05-27 20:20:27 +0200510static int64_t
Peter Zijlstra55e5ec42009-05-27 20:20:28 +0200511sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
512{
513 struct dso *dso_l = left->dso;
514 struct dso *dso_r = right->dso;
515
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200516 if (!dso_l || !dso_r)
517 return cmp_null(dso_l, dso_r);
Peter Zijlstra55e5ec42009-05-27 20:20:28 +0200518
519 return strcmp(dso_l->name, dso_r->name);
520}
521
522static size_t
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300523sort__dso_print(FILE *fp, struct hist_entry *self, unsigned int width)
Peter Zijlstra55e5ec42009-05-27 20:20:28 +0200524{
Ingo Molnar0a520c62009-06-02 23:24:45 +0200525 if (self->dso)
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300526 return repsep_fprintf(fp, "%-*s", width, self->dso->name);
Ingo Molnar0a520c62009-06-02 23:24:45 +0200527
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300528 return repsep_fprintf(fp, "%*llx", width, (u64)self->ip);
Peter Zijlstra55e5ec42009-05-27 20:20:28 +0200529}
530
531static struct sort_entry sort_dso = {
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300532 .header = "Shared Object",
Peter Zijlstra55e5ec42009-05-27 20:20:28 +0200533 .cmp = sort__dso_cmp,
534 .print = sort__dso_print,
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300535 .width = &dsos__col_width,
Peter Zijlstra55e5ec42009-05-27 20:20:28 +0200536};
537
Peter Zijlstra82292892009-06-03 12:37:36 +0200538/* --sort symbol */
539
Peter Zijlstra55e5ec42009-05-27 20:20:28 +0200540static int64_t
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200541sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300542{
Paul Mackerras9cffa8d2009-06-19 22:21:42 +1000543 u64 ip_l, ip_r;
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +0200544
545 if (left->sym == right->sym)
546 return 0;
547
548 ip_l = left->sym ? left->sym->start : left->ip;
549 ip_r = right->sym ? right->sym->start : right->ip;
550
551 return (int64_t)(ip_r - ip_l);
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -0300552}
553
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200554static size_t
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300555sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200556{
557 size_t ret = 0;
558
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200559 if (verbose)
Arnaldo Carvalho de Melo94cb9e32009-08-06 14:43:17 -0300560 ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip,
561 dso__symtab_origin(self->dso));
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200562
Arnaldo Carvalho de Melo60c1baf2009-07-11 12:18:33 -0300563 ret += repsep_fprintf(fp, "[%c] ", self->level);
Ingo Molnar8edd4282009-06-05 14:13:18 +0200564 if (self->sym) {
Arnaldo Carvalho de Melo60c1baf2009-07-11 12:18:33 -0300565 ret += repsep_fprintf(fp, "%s", self->sym->name);
Mike Galbraith42976482009-07-02 08:09:46 +0200566
567 if (self->sym->module)
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300568 ret += repsep_fprintf(fp, "\t[%s]",
569 self->sym->module->name);
Ingo Molnar8edd4282009-06-05 14:13:18 +0200570 } else {
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300571 ret += repsep_fprintf(fp, "%#016llx", (u64)self->ip);
Ingo Molnar8edd4282009-06-05 14:13:18 +0200572 }
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200573
574 return ret;
575}
576
577static struct sort_entry sort_sym = {
Peter Zijlstra71dd8942009-06-04 15:16:56 +0200578 .header = "Symbol",
Peter Zijlstraca8cdee2009-05-28 11:08:33 +0200579 .cmp = sort__sym_cmp,
580 .print = sort__sym_print,
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200581};
582
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200583/* --sort parent */
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200584
585static int64_t
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200586sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200587{
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200588 struct symbol *sym_l = left->parent;
589 struct symbol *sym_r = right->parent;
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200590
591 if (!sym_l || !sym_r)
592 return cmp_null(sym_l, sym_r);
593
594 return strcmp(sym_l->name, sym_r->name);
595}
596
597static size_t
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300598sort__parent_print(FILE *fp, struct hist_entry *self, unsigned int width)
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200599{
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300600 return repsep_fprintf(fp, "%-*s", width,
601 self->parent ? self->parent->name : "[other]");
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200602}
603
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300604static unsigned int parent_symbol__col_width;
605
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200606static struct sort_entry sort_parent = {
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300607 .header = "Parent symbol",
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200608 .cmp = sort__parent_cmp,
609 .print = sort__parent_print,
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300610 .width = &parent_symbol__col_width,
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200611};
612
Peter Zijlstra82292892009-06-03 12:37:36 +0200613static int sort__need_collapse = 0;
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200614static int sort__has_parent = 0;
Peter Zijlstra82292892009-06-03 12:37:36 +0200615
Peter Zijlstra37f440c2009-05-27 20:20:26 +0200616struct sort_dimension {
Ingo Molnar8edd4282009-06-05 14:13:18 +0200617 char *name;
618 struct sort_entry *entry;
619 int taken;
Peter Zijlstra37f440c2009-05-27 20:20:26 +0200620};
621
622static struct sort_dimension sort_dimensions[] = {
623 { .name = "pid", .entry = &sort_thread, },
Peter Zijlstra992444b2009-05-27 20:20:27 +0200624 { .name = "comm", .entry = &sort_comm, },
Peter Zijlstra55e5ec42009-05-27 20:20:28 +0200625 { .name = "dso", .entry = &sort_dso, },
Peter Zijlstra37f440c2009-05-27 20:20:26 +0200626 { .name = "symbol", .entry = &sort_sym, },
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200627 { .name = "parent", .entry = &sort_parent, },
Peter Zijlstra37f440c2009-05-27 20:20:26 +0200628};
629
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200630static LIST_HEAD(hist_entry__sort_list);
631
Peter Zijlstra37f440c2009-05-27 20:20:26 +0200632static int sort_dimension__add(char *tok)
633{
Ingo Molnarf37a2912009-07-01 12:37:06 +0200634 unsigned int i;
Peter Zijlstra37f440c2009-05-27 20:20:26 +0200635
636 for (i = 0; i < ARRAY_SIZE(sort_dimensions); i++) {
637 struct sort_dimension *sd = &sort_dimensions[i];
638
639 if (sd->taken)
640 continue;
641
Ingo Molnar5352f352009-06-03 10:07:39 +0200642 if (strncasecmp(tok, sd->name, strlen(tok)))
Peter Zijlstra37f440c2009-05-27 20:20:26 +0200643 continue;
644
Peter Zijlstra82292892009-06-03 12:37:36 +0200645 if (sd->entry->collapse)
646 sort__need_collapse = 1;
647
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200648 if (sd->entry == &sort_parent) {
649 int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200650 if (ret) {
651 char err[BUFSIZ];
652
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200653 regerror(ret, &parent_regex, err, sizeof(err));
654 fprintf(stderr, "Invalid regex: %s\n%s",
655 parent_pattern, err);
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200656 exit(-1);
657 }
Ingo Molnarb25bcf22009-06-18 07:01:03 +0200658 sort__has_parent = 1;
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200659 }
660
Peter Zijlstra37f440c2009-05-27 20:20:26 +0200661 list_add_tail(&sd->entry->list, &hist_entry__sort_list);
662 sd->taken = 1;
Ingo Molnar5352f352009-06-03 10:07:39 +0200663
Peter Zijlstra37f440c2009-05-27 20:20:26 +0200664 return 0;
665 }
666
667 return -ESRCH;
668}
669
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200670static int64_t
671hist_entry__cmp(struct hist_entry *left, struct hist_entry *right)
672{
673 struct sort_entry *se;
674 int64_t cmp = 0;
675
676 list_for_each_entry(se, &hist_entry__sort_list, list) {
677 cmp = se->cmp(left, right);
678 if (cmp)
679 break;
680 }
681
682 return cmp;
683}
684
Peter Zijlstra82292892009-06-03 12:37:36 +0200685static int64_t
686hist_entry__collapse(struct hist_entry *left, struct hist_entry *right)
687{
688 struct sort_entry *se;
689 int64_t cmp = 0;
690
691 list_for_each_entry(se, &hist_entry__sort_list, list) {
692 int64_t (*f)(struct hist_entry *, struct hist_entry *);
693
694 f = se->collapse ?: se->cmp;
695
696 cmp = f(left, right);
697 if (cmp)
698 break;
699 }
700
701 return cmp;
702}
703
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200704static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask)
705{
706 int i;
707 size_t ret = 0;
708
709 ret += fprintf(fp, "%s", " ");
710
711 for (i = 0; i < depth; i++)
712 if (depth_mask & (1 << i))
713 ret += fprintf(fp, "| ");
714 else
715 ret += fprintf(fp, " ");
716
717 ret += fprintf(fp, "\n");
718
719 return ret;
720}
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200721static size_t
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200722ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain, int depth,
723 int depth_mask, int count, u64 total_samples,
724 int hits)
725{
726 int i;
727 size_t ret = 0;
728
729 ret += fprintf(fp, "%s", " ");
730 for (i = 0; i < depth; i++) {
731 if (depth_mask & (1 << i))
732 ret += fprintf(fp, "|");
733 else
734 ret += fprintf(fp, " ");
735 if (!count && i == depth - 1) {
736 double percent;
737
738 percent = hits * 100.0 / total_samples;
Frederic Weisbecker24b57c62009-07-02 20:14:35 +0200739 ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200740 } else
741 ret += fprintf(fp, "%s", " ");
742 }
743 if (chain->sym)
744 ret += fprintf(fp, "%s\n", chain->sym->name);
745 else
746 ret += fprintf(fp, "%p\n", (void *)(long)chain->ip);
747
748 return ret;
749}
750
Frederic Weisbecker25446032009-08-08 02:16:25 +0200751static struct symbol *rem_sq_bracket;
752static struct callchain_list rem_hits;
753
754static void init_rem_hits(void)
755{
756 rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
757 if (!rem_sq_bracket) {
758 fprintf(stderr, "Not enough memory to display remaining hits\n");
759 return;
760 }
761
762 strcpy(rem_sq_bracket->name, "[...]");
763 rem_hits.sym = rem_sq_bracket;
764}
765
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200766static size_t
767callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
768 u64 total_samples, int depth, int depth_mask)
769{
770 struct rb_node *node, *next;
771 struct callchain_node *child;
772 struct callchain_list *chain;
773 int new_depth_mask = depth_mask;
Frederic Weisbecker805d1272009-07-05 07:39:21 +0200774 u64 new_total;
Frederic Weisbecker25446032009-08-08 02:16:25 +0200775 u64 remaining;
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200776 size_t ret = 0;
777 int i;
778
Frederic Weisbecker805d1272009-07-05 07:39:21 +0200779 if (callchain_param.mode == CHAIN_GRAPH_REL)
Frederic Weisbecker19532872009-08-07 07:11:05 +0200780 new_total = self->children_hit;
Frederic Weisbecker805d1272009-07-05 07:39:21 +0200781 else
782 new_total = total_samples;
783
Frederic Weisbecker25446032009-08-08 02:16:25 +0200784 remaining = new_total;
785
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200786 node = rb_first(&self->rb_root);
787 while (node) {
Frederic Weisbecker25446032009-08-08 02:16:25 +0200788 u64 cumul;
789
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200790 child = rb_entry(node, struct callchain_node, rb_node);
Frederic Weisbecker25446032009-08-08 02:16:25 +0200791 cumul = cumul_hits(child);
792 remaining -= cumul;
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200793
794 /*
795 * The depth mask manages the output of pipes that show
796 * the depth. We don't want to keep the pipes of the current
Frederic Weisbecker25446032009-08-08 02:16:25 +0200797 * level for the last child of this depth.
798 * Except if we have remaining filtered hits. They will
799 * supersede the last child
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200800 */
801 next = rb_next(node);
Frederic Weisbecker25446032009-08-08 02:16:25 +0200802 if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200803 new_depth_mask &= ~(1 << (depth - 1));
804
805 /*
806 * But we keep the older depth mask for the line seperator
807 * to keep the level link until we reach the last child
808 */
809 ret += ipchain__fprintf_graph_line(fp, depth, depth_mask);
810 i = 0;
811 list_for_each_entry(chain, &child->val, list) {
812 if (chain->ip >= PERF_CONTEXT_MAX)
813 continue;
814 ret += ipchain__fprintf_graph(fp, chain, depth,
815 new_depth_mask, i++,
Frederic Weisbecker805d1272009-07-05 07:39:21 +0200816 new_total,
Frederic Weisbecker25446032009-08-08 02:16:25 +0200817 cumul);
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200818 }
Frederic Weisbecker805d1272009-07-05 07:39:21 +0200819 ret += callchain__fprintf_graph(fp, child, new_total,
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200820 depth + 1,
821 new_depth_mask | (1 << depth));
822 node = next;
823 }
824
Frederic Weisbecker25446032009-08-08 02:16:25 +0200825 if (callchain_param.mode == CHAIN_GRAPH_REL &&
826 remaining && remaining != new_total) {
827
828 if (!rem_sq_bracket)
829 return ret;
830
831 new_depth_mask &= ~(1 << (depth - 1));
832
833 ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
834 new_depth_mask, 0, new_total,
835 remaining);
836 }
837
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200838 return ret;
839}
840
841static size_t
842callchain__fprintf_flat(FILE *fp, struct callchain_node *self,
843 u64 total_samples)
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +0200844{
845 struct callchain_list *chain;
846 size_t ret = 0;
847
848 if (!self)
849 return 0;
850
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200851 ret += callchain__fprintf_flat(fp, self->parent, total_samples);
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +0200852
853
Frederic Weisbecker44249612009-07-01 05:35:14 +0200854 list_for_each_entry(chain, &self->val, list) {
855 if (chain->ip >= PERF_CONTEXT_MAX)
856 continue;
857 if (chain->sym)
858 ret += fprintf(fp, " %s\n", chain->sym->name);
859 else
860 ret += fprintf(fp, " %p\n",
Ingo Molnarf37a2912009-07-01 12:37:06 +0200861 (void *)(long)chain->ip);
Frederic Weisbecker44249612009-07-01 05:35:14 +0200862 }
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +0200863
864 return ret;
865}
866
867static size_t
868hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
869 u64 total_samples)
870{
871 struct rb_node *rb_node;
872 struct callchain_node *chain;
873 size_t ret = 0;
874
875 rb_node = rb_first(&self->sorted_chain);
876 while (rb_node) {
877 double percent;
878
879 chain = rb_entry(rb_node, struct callchain_node, rb_node);
880 percent = chain->hit * 100.0 / total_samples;
Frederic Weisbecker805d1272009-07-05 07:39:21 +0200881 switch (callchain_param.mode) {
882 case CHAIN_FLAT:
Frederic Weisbecker24b57c62009-07-02 20:14:35 +0200883 ret += percent_color_fprintf(fp, " %6.2f%%\n",
884 percent);
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200885 ret += callchain__fprintf_flat(fp, chain, total_samples);
Frederic Weisbecker805d1272009-07-05 07:39:21 +0200886 break;
887 case CHAIN_GRAPH_ABS: /* Falldown */
888 case CHAIN_GRAPH_REL:
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200889 ret += callchain__fprintf_graph(fp, chain,
890 total_samples, 1, 1);
Frederic Weisbecker805d1272009-07-05 07:39:21 +0200891 default:
892 break;
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +0200893 }
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +0200894 ret += fprintf(fp, "\n");
895 rb_node = rb_next(rb_node);
896 }
897
898 return ret;
899}
900
901
902static size_t
Paul Mackerras9cffa8d2009-06-19 22:21:42 +1000903hist_entry__fprintf(FILE *fp, struct hist_entry *self, u64 total_samples)
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200904{
905 struct sort_entry *se;
906 size_t ret;
907
Ingo Molnarb8e6d822009-06-18 14:32:19 +0200908 if (exclude_other && !self->parent)
909 return 0;
910
Frederic Weisbecker1e11fd82009-07-02 20:14:34 +0200911 if (total_samples)
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300912 ret = percent_color_fprintf(fp,
913 field_sep ? "%.2f" : " %6.2f%%",
914 (self->count * 100.0) / total_samples);
Frederic Weisbecker1e11fd82009-07-02 20:14:34 +0200915 else
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300916 ret = fprintf(fp, field_sep ? "%lld" : "%12lld ", self->count);
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200917
Arnaldo Carvalho de Meloe3d7e182009-07-11 12:18:37 -0300918 if (show_nr_samples) {
919 if (field_sep)
920 fprintf(fp, "%c%lld", *field_sep, self->count);
921 else
922 fprintf(fp, "%11lld", self->count);
923 }
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200924
Peter Zijlstra71dd8942009-06-04 15:16:56 +0200925 list_for_each_entry(se, &hist_entry__sort_list, list) {
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -0300926 if (se->elide)
Ingo Molnarb8e6d822009-06-18 14:32:19 +0200927 continue;
928
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300929 fprintf(fp, "%s", field_sep ?: " ");
930 ret += se->print(fp, self, se->width ? *se->width : 0);
Peter Zijlstra71dd8942009-06-04 15:16:56 +0200931 }
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200932
933 ret += fprintf(fp, "\n");
934
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +0200935 if (callchain)
936 hist_entry_callchain__fprintf(fp, self, total_samples);
937
Peter Zijlstra1aa16732009-05-27 20:20:25 +0200938 return ret;
939}
940
941/*
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200942 *
943 */
944
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300945static void dso__calc_col_width(struct dso *self)
946{
947 if (!col_width_list_str && !field_sep &&
948 (!dso_list || strlist__has_entry(dso_list, self->name))) {
949 unsigned int slen = strlen(self->name);
950 if (slen > dsos__col_width)
951 dsos__col_width = slen;
952 }
953
954 self->slen_calculated = 1;
955}
956
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200957static struct symbol *
958resolve_symbol(struct thread *thread, struct map **mapp,
Paul Mackerras9cffa8d2009-06-19 22:21:42 +1000959 struct dso **dsop, u64 *ipp)
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200960{
961 struct dso *dso = dsop ? *dsop : NULL;
962 struct map *map = mapp ? *mapp : NULL;
Peter Zijlstra520f2c32009-06-22 16:52:51 +0200963 u64 ip = *ipp;
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200964
965 if (!thread)
966 return NULL;
967
968 if (dso)
969 goto got_dso;
970
971 if (map)
972 goto got_map;
973
974 map = thread__find_map(thread, ip);
975 if (map != NULL) {
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300976 /*
977 * We have to do this here as we may have a dso
978 * with no symbol hit that has a name longer than
979 * the ones with symbols sampled.
980 */
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -0300981 if (!sort_dso.elide && !map->dso->slen_calculated)
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -0300982 dso__calc_col_width(map->dso);
983
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200984 if (mapp)
985 *mapp = map;
986got_map:
987 ip = map->map_ip(map, ip);
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +0200988
989 dso = map->dso;
990 } else {
991 /*
992 * If this is outside of all known maps,
993 * and is a negative address, try to look it
994 * up in the kernel dso, as it might be a
995 * vsyscall (which executes in user-mode):
996 */
997 if ((long long)ip < 0)
998 dso = kernel_dso;
999 }
1000 dprintf(" ...... dso: %s\n", dso ? dso->name : "<not found>");
Peter Zijlstra520f2c32009-06-22 16:52:51 +02001001 dprintf(" ...... map: %Lx -> %Lx\n", *ipp, ip);
1002 *ipp = ip;
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +02001003
1004 if (dsop)
1005 *dsop = dso;
1006
1007 if (!dso)
1008 return NULL;
1009got_dso:
1010 return dso->find_symbol(dso, ip);
1011}
1012
Peter Zijlstra2a0a50f2009-06-18 22:20:45 +02001013static int call__match(struct symbol *sym)
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +02001014{
Ingo Molnarb25bcf22009-06-18 07:01:03 +02001015 if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
Peter Zijlstra2a0a50f2009-06-18 22:20:45 +02001016 return 1;
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +02001017
Peter Zijlstra2a0a50f2009-06-18 22:20:45 +02001018 return 0;
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +02001019}
1020
Frederic Weisbecker44249612009-07-01 05:35:14 +02001021static struct symbol **
Ingo Molnarf37a2912009-07-01 12:37:06 +02001022resolve_callchain(struct thread *thread, struct map *map __used,
Frederic Weisbecker44249612009-07-01 05:35:14 +02001023 struct ip_callchain *chain, struct hist_entry *entry)
1024{
Frederic Weisbecker44249612009-07-01 05:35:14 +02001025 u64 context = PERF_CONTEXT_MAX;
Ingo Molnar029e5b12009-07-03 13:17:28 +02001026 struct symbol **syms = NULL;
Ingo Molnarf37a2912009-07-01 12:37:06 +02001027 unsigned int i;
Frederic Weisbecker44249612009-07-01 05:35:14 +02001028
1029 if (callchain) {
1030 syms = calloc(chain->nr, sizeof(*syms));
1031 if (!syms) {
1032 fprintf(stderr, "Can't allocate memory for symbols\n");
1033 exit(-1);
1034 }
1035 }
1036
1037 for (i = 0; i < chain->nr; i++) {
1038 u64 ip = chain->ips[i];
1039 struct dso *dso = NULL;
1040 struct symbol *sym;
1041
1042 if (ip >= PERF_CONTEXT_MAX) {
1043 context = ip;
1044 continue;
1045 }
1046
1047 switch (context) {
Ingo Molnar88a69df2009-07-01 11:17:20 +02001048 case PERF_CONTEXT_HV:
1049 dso = hypervisor_dso;
1050 break;
Frederic Weisbecker44249612009-07-01 05:35:14 +02001051 case PERF_CONTEXT_KERNEL:
1052 dso = kernel_dso;
1053 break;
1054 default:
1055 break;
1056 }
1057
1058 sym = resolve_symbol(thread, NULL, &dso, &ip);
1059
1060 if (sym) {
1061 if (sort__has_parent && call__match(sym) &&
1062 !entry->parent)
1063 entry->parent = sym;
1064 if (!callchain)
1065 break;
1066 syms[i] = sym;
1067 }
1068 }
1069
1070 return syms;
1071}
1072
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +02001073/*
Peter Zijlstra1aa16732009-05-27 20:20:25 +02001074 * collect histogram counts
1075 */
1076
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001077static int
1078hist_entry__add(struct thread *thread, struct map *map, struct dso *dso,
Paul Mackerras9cffa8d2009-06-19 22:21:42 +10001079 struct symbol *sym, u64 ip, struct ip_callchain *chain,
1080 char level, u64 count)
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001081{
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001082 struct rb_node **p = &hist.rb_node;
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001083 struct rb_node *parent = NULL;
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001084 struct hist_entry *he;
Frederic Weisbecker44249612009-07-01 05:35:14 +02001085 struct symbol **syms = NULL;
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001086 struct hist_entry entry = {
1087 .thread = thread,
1088 .map = map,
1089 .dso = dso,
1090 .sym = sym,
1091 .ip = ip,
1092 .level = level,
Peter Zijlstraea1900e2009-06-10 21:45:22 +02001093 .count = count,
Ingo Molnarb8e6d822009-06-18 14:32:19 +02001094 .parent = NULL,
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +02001095 .sorted_chain = RB_ROOT
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001096 };
1097 int cmp;
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001098
Frederic Weisbecker44249612009-07-01 05:35:14 +02001099 if ((sort__has_parent || callchain) && chain)
1100 syms = resolve_callchain(thread, map, chain, &entry);
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +02001101
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001102 while (*p != NULL) {
1103 parent = *p;
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001104 he = rb_entry(parent, struct hist_entry, rb_node);
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001105
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001106 cmp = hist_entry__cmp(&entry, he);
1107
1108 if (!cmp) {
Peter Zijlstraea1900e2009-06-10 21:45:22 +02001109 he->count += count;
Frederic Weisbecker44249612009-07-01 05:35:14 +02001110 if (callchain) {
1111 append_chain(&he->callchain, chain, syms);
1112 free(syms);
1113 }
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001114 return 0;
1115 }
1116
1117 if (cmp < 0)
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001118 p = &(*p)->rb_left;
1119 else
1120 p = &(*p)->rb_right;
1121 }
1122
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001123 he = malloc(sizeof(*he));
1124 if (!he)
1125 return -ENOMEM;
1126 *he = entry;
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +02001127 if (callchain) {
1128 callchain_init(&he->callchain);
Frederic Weisbecker44249612009-07-01 05:35:14 +02001129 append_chain(&he->callchain, chain, syms);
1130 free(syms);
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +02001131 }
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001132 rb_link_node(&he->rb_node, parent, p);
1133 rb_insert_color(&he->rb_node, &hist);
1134
1135 return 0;
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001136}
1137
Peter Zijlstra82292892009-06-03 12:37:36 +02001138static void hist_entry__free(struct hist_entry *he)
1139{
1140 free(he);
1141}
1142
1143/*
1144 * collapse the histogram
1145 */
1146
1147static struct rb_root collapse_hists;
1148
1149static void collapse__insert_entry(struct hist_entry *he)
1150{
1151 struct rb_node **p = &collapse_hists.rb_node;
1152 struct rb_node *parent = NULL;
1153 struct hist_entry *iter;
1154 int64_t cmp;
1155
1156 while (*p != NULL) {
1157 parent = *p;
1158 iter = rb_entry(parent, struct hist_entry, rb_node);
1159
1160 cmp = hist_entry__collapse(iter, he);
1161
1162 if (!cmp) {
1163 iter->count += he->count;
1164 hist_entry__free(he);
1165 return;
1166 }
1167
1168 if (cmp < 0)
1169 p = &(*p)->rb_left;
1170 else
1171 p = &(*p)->rb_right;
1172 }
1173
1174 rb_link_node(&he->rb_node, parent, p);
1175 rb_insert_color(&he->rb_node, &collapse_hists);
1176}
1177
1178static void collapse__resort(void)
1179{
1180 struct rb_node *next;
1181 struct hist_entry *n;
1182
1183 if (!sort__need_collapse)
1184 return;
1185
1186 next = rb_first(&hist);
1187 while (next) {
1188 n = rb_entry(next, struct hist_entry, rb_node);
1189 next = rb_next(&n->rb_node);
1190
1191 rb_erase(&n->rb_node, &hist);
1192 collapse__insert_entry(n);
1193 }
1194}
1195
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001196/*
1197 * reverse the map, sort on count.
1198 */
1199
1200static struct rb_root output_hists;
1201
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001202static void output__insert_entry(struct hist_entry *he, u64 min_callchain_hits)
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001203{
1204 struct rb_node **p = &output_hists.rb_node;
1205 struct rb_node *parent = NULL;
1206 struct hist_entry *iter;
1207
Frederic Weisbecker805d1272009-07-05 07:39:21 +02001208 if (callchain)
1209 callchain_param.sort(&he->sorted_chain, &he->callchain,
1210 min_callchain_hits, &callchain_param);
Frederic Weisbeckerf55c5552009-06-26 16:28:01 +02001211
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001212 while (*p != NULL) {
1213 parent = *p;
1214 iter = rb_entry(parent, struct hist_entry, rb_node);
1215
1216 if (he->count > iter->count)
1217 p = &(*p)->rb_left;
1218 else
1219 p = &(*p)->rb_right;
1220 }
1221
1222 rb_link_node(&he->rb_node, parent, p);
1223 rb_insert_color(&he->rb_node, &output_hists);
1224}
1225
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001226static void output__resort(u64 total_samples)
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001227{
Peter Zijlstra82292892009-06-03 12:37:36 +02001228 struct rb_node *next;
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001229 struct hist_entry *n;
Arnaldo Carvalho de Meloa4c43be2009-06-03 23:02:33 -03001230 struct rb_root *tree = &hist;
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001231 u64 min_callchain_hits;
1232
Frederic Weisbecker805d1272009-07-05 07:39:21 +02001233 min_callchain_hits = total_samples * (callchain_param.min_percent / 100);
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001234
Peter Zijlstra82292892009-06-03 12:37:36 +02001235 if (sort__need_collapse)
Arnaldo Carvalho de Meloa4c43be2009-06-03 23:02:33 -03001236 tree = &collapse_hists;
1237
1238 next = rb_first(tree);
Peter Zijlstra82292892009-06-03 12:37:36 +02001239
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001240 while (next) {
1241 n = rb_entry(next, struct hist_entry, rb_node);
1242 next = rb_next(&n->rb_node);
1243
Arnaldo Carvalho de Meloa4c43be2009-06-03 23:02:33 -03001244 rb_erase(&n->rb_node, tree);
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001245 output__insert_entry(n, min_callchain_hits);
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001246 }
1247}
1248
Paul Mackerras9cffa8d2009-06-19 22:21:42 +10001249static size_t output__fprintf(FILE *fp, u64 total_samples)
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001250{
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001251 struct hist_entry *pos;
Ingo Molnar2d655372009-05-27 21:36:22 +02001252 struct sort_entry *se;
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001253 struct rb_node *nd;
1254 size_t ret = 0;
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -03001255 unsigned int width;
1256 char *col_width = col_width_list_str;
Brice Goglin9f866692009-08-10 15:26:32 +02001257 int raw_printing_style;
1258
1259 raw_printing_style = !strcmp(pretty_printing_style, "raw");
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001260
Frederic Weisbecker25446032009-08-08 02:16:25 +02001261 init_rem_hits();
1262
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -03001263 fprintf(fp, "# Samples: %Ld\n", (u64)total_samples);
Ingo Molnar05ca0612009-06-04 14:21:16 +02001264 fprintf(fp, "#\n");
Peter Zijlstraca8cdee2009-05-28 11:08:33 +02001265
1266 fprintf(fp, "# Overhead");
Arnaldo Carvalho de Meloe3d7e182009-07-11 12:18:37 -03001267 if (show_nr_samples) {
1268 if (field_sep)
1269 fprintf(fp, "%cSamples", *field_sep);
1270 else
1271 fputs(" Samples ", fp);
1272 }
Ingo Molnarb8e6d822009-06-18 14:32:19 +02001273 list_for_each_entry(se, &hist_entry__sort_list, list) {
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -03001274 if (se->elide)
Ingo Molnarb8e6d822009-06-18 14:32:19 +02001275 continue;
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -03001276 if (field_sep) {
1277 fprintf(fp, "%c%s", *field_sep, se->header);
1278 continue;
1279 }
1280 width = strlen(se->header);
1281 if (se->width) {
1282 if (col_width_list_str) {
1283 if (col_width) {
1284 *se->width = atoi(col_width);
1285 col_width = strchr(col_width, ',');
1286 if (col_width)
1287 ++col_width;
1288 }
1289 }
1290 width = *se->width = max(*se->width, width);
1291 }
1292 fprintf(fp, " %*s", width, se->header);
Ingo Molnarb8e6d822009-06-18 14:32:19 +02001293 }
Peter Zijlstraca8cdee2009-05-28 11:08:33 +02001294 fprintf(fp, "\n");
1295
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -03001296 if (field_sep)
1297 goto print_entries;
1298
Peter Zijlstraca8cdee2009-05-28 11:08:33 +02001299 fprintf(fp, "# ........");
Arnaldo Carvalho de Meloe3d7e182009-07-11 12:18:37 -03001300 if (show_nr_samples)
1301 fprintf(fp, " ..........");
Ingo Molnar2d655372009-05-27 21:36:22 +02001302 list_for_each_entry(se, &hist_entry__sort_list, list) {
Ingo Molnarf37a2912009-07-01 12:37:06 +02001303 unsigned int i;
Peter Zijlstraca8cdee2009-05-28 11:08:33 +02001304
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -03001305 if (se->elide)
Ingo Molnarb8e6d822009-06-18 14:32:19 +02001306 continue;
1307
Ingo Molnar4593bba2009-06-02 15:34:25 +02001308 fprintf(fp, " ");
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -03001309 if (se->width)
1310 width = *se->width;
1311 else
1312 width = strlen(se->header);
1313 for (i = 0; i < width; i++)
Peter Zijlstraca8cdee2009-05-28 11:08:33 +02001314 fprintf(fp, ".");
Ingo Molnar2d655372009-05-27 21:36:22 +02001315 }
Peter Zijlstraca8cdee2009-05-28 11:08:33 +02001316 fprintf(fp, "\n");
1317
1318 fprintf(fp, "#\n");
Ingo Molnar2d655372009-05-27 21:36:22 +02001319
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -03001320print_entries:
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001321 for (nd = rb_first(&output_hists); nd; nd = rb_next(nd)) {
1322 pos = rb_entry(nd, struct hist_entry, rb_node);
1323 ret += hist_entry__fprintf(fp, pos, total_samples);
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001324 }
1325
Ingo Molnarb8e6d822009-06-18 14:32:19 +02001326 if (sort_order == default_sort_order &&
1327 parent_pattern == default_parent_pattern) {
Ingo Molnarbd741372009-06-04 14:13:04 +02001328 fprintf(fp, "#\n");
Pekka Enberg114cfab2009-08-05 13:25:21 +03001329 fprintf(fp, "# (For a higher level overview, try: perf report --sort comm,dso)\n");
Ingo Molnarbd741372009-06-04 14:13:04 +02001330 fprintf(fp, "#\n");
1331 }
Peter Zijlstra71dd8942009-06-04 15:16:56 +02001332 fprintf(fp, "\n");
Ingo Molnarbd741372009-06-04 14:13:04 +02001333
Frederic Weisbecker25446032009-08-08 02:16:25 +02001334 free(rem_sq_bracket);
1335
Brice Goglin8d513272009-08-07 13:55:24 +02001336 if (show_threads)
Brice Goglin9f866692009-08-10 15:26:32 +02001337 perf_read_values_display(fp, &show_threads_values,
1338 raw_printing_style);
Brice Goglin8d513272009-08-07 13:55:24 +02001339
Arnaldo Carvalho de Melo3a4b8cc2009-05-26 16:19:04 -03001340 return ret;
1341}
1342
Peter Zijlstra436224a2009-06-02 21:02:36 +02001343static void register_idle_thread(void)
1344{
1345 struct thread *thread = threads__findnew(0);
1346
1347 if (thread == NULL ||
1348 thread__set_comm(thread, "[idle]")) {
1349 fprintf(stderr, "problem inserting idle task.\n");
1350 exit(-1);
1351 }
1352}
1353
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001354static unsigned long total = 0,
1355 total_mmap = 0,
1356 total_comm = 0,
1357 total_fork = 0,
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +02001358 total_unknown = 0,
1359 total_lost = 0;
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001360
Peter Zijlstra2a0a50f2009-06-18 22:20:45 +02001361static int validate_chain(struct ip_callchain *chain, event_t *event)
Ingo Molnar75220602009-06-18 08:00:17 +02001362{
1363 unsigned int chain_size;
1364
Ingo Molnar75220602009-06-18 08:00:17 +02001365 chain_size = event->header.size;
1366 chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
1367
Paul Mackerras9cffa8d2009-06-19 22:21:42 +10001368 if (chain->nr*sizeof(u64) > chain_size)
Ingo Molnar75220602009-06-18 08:00:17 +02001369 return -1;
1370
1371 return 0;
1372}
1373
Ingo Molnard80d3382009-06-03 23:14:49 +02001374static int
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001375process_sample_event(event_t *event, unsigned long offset, unsigned long head)
Ingo Molnar75051722009-06-03 23:14:49 +02001376{
1377 char level;
1378 int show = 0;
1379 struct dso *dso = NULL;
1380 struct thread *thread = threads__findnew(event->ip.pid);
Paul Mackerras9cffa8d2009-06-19 22:21:42 +10001381 u64 ip = event->ip.ip;
1382 u64 period = 1;
Ingo Molnar75051722009-06-03 23:14:49 +02001383 struct map *map = NULL;
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001384 void *more_data = event->ip.__more_data;
Peter Zijlstra2a0a50f2009-06-18 22:20:45 +02001385 struct ip_callchain *chain = NULL;
Anton Blanchardd8db1b52009-07-01 09:00:48 +10001386 int cpumode;
Ingo Molnar75051722009-06-03 23:14:49 +02001387
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001388 if (sample_type & PERF_SAMPLE_PERIOD) {
Paul Mackerras9cffa8d2009-06-19 22:21:42 +10001389 period = *(u64 *)more_data;
1390 more_data += sizeof(u64);
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001391 }
Peter Zijlstraea1900e2009-06-10 21:45:22 +02001392
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001393 dprintf("%p [%p]: PERF_EVENT_SAMPLE (IP, %d): %d: %p period: %Ld\n",
Ingo Molnar75051722009-06-03 23:14:49 +02001394 (void *)(offset + head),
1395 (void *)(long)(event->header.size),
1396 event->header.misc,
1397 event->ip.pid,
Peter Zijlstra4502d772009-06-10 15:03:06 +02001398 (void *)(long)ip,
Peter Zijlstraea1900e2009-06-10 21:45:22 +02001399 (long long)period);
Ingo Molnar75051722009-06-03 23:14:49 +02001400
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001401 if (sample_type & PERF_SAMPLE_CALLCHAIN) {
Ingo Molnarf37a2912009-07-01 12:37:06 +02001402 unsigned int i;
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001403
1404 chain = (void *)more_data;
1405
Peter Zijlstra2a0a50f2009-06-18 22:20:45 +02001406 dprintf("... chain: nr:%Lu\n", chain->nr);
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001407
Ingo Molnar75220602009-06-18 08:00:17 +02001408 if (validate_chain(chain, event) < 0) {
1409 eprintf("call-chain problem with event, skipping it.\n");
1410 return 0;
1411 }
1412
1413 if (dump_trace) {
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001414 for (i = 0; i < chain->nr; i++)
Peter Zijlstra2a0a50f2009-06-18 22:20:45 +02001415 dprintf("..... %2d: %016Lx\n", i, chain->ips[i]);
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001416 }
1417 }
1418
Ingo Molnar75051722009-06-03 23:14:49 +02001419 dprintf(" ... thread: %s:%d\n", thread->comm, thread->pid);
1420
1421 if (thread == NULL) {
Ingo Molnar75220602009-06-18 08:00:17 +02001422 eprintf("problem processing %d event, skipping it.\n",
Ingo Molnar75051722009-06-03 23:14:49 +02001423 event->header.type);
1424 return -1;
1425 }
1426
Arnaldo Carvalho de Melocc8b88b2009-06-30 19:01:21 -03001427 if (comm_list && !strlist__has_entry(comm_list, thread->comm))
1428 return 0;
1429
Anton Blanchardd8db1b52009-07-01 09:00:48 +10001430 cpumode = event->header.misc & PERF_EVENT_MISC_CPUMODE_MASK;
1431
1432 if (cpumode == PERF_EVENT_MISC_KERNEL) {
Ingo Molnar75051722009-06-03 23:14:49 +02001433 show = SHOW_KERNEL;
1434 level = 'k';
1435
1436 dso = kernel_dso;
1437
1438 dprintf(" ...... dso: %s\n", dso->name);
1439
Anton Blanchardd8db1b52009-07-01 09:00:48 +10001440 } else if (cpumode == PERF_EVENT_MISC_USER) {
Ingo Molnar75051722009-06-03 23:14:49 +02001441
1442 show = SHOW_USER;
1443 level = '.';
1444
Ingo Molnar75051722009-06-03 23:14:49 +02001445 } else {
1446 show = SHOW_HV;
1447 level = 'H';
Anton Blanchardfb9c8182009-07-01 09:00:49 +10001448
1449 dso = hypervisor_dso;
1450
Ingo Molnar75051722009-06-03 23:14:49 +02001451 dprintf(" ...... dso: [hypervisor]\n");
1452 }
1453
1454 if (show & show_mask) {
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +02001455 struct symbol *sym = resolve_symbol(thread, &map, &dso, &ip);
Peter Zijlstrafc54db52009-06-05 14:04:59 +02001456
Arnaldo Carvalho de Melo25903402009-06-30 19:01:20 -03001457 if (dso_list && dso && dso->name && !strlist__has_entry(dso_list, dso->name))
1458 return 0;
1459
Arnaldo Carvalho de Melo7bec7a92009-06-30 19:01:22 -03001460 if (sym_list && sym && !strlist__has_entry(sym_list, sym->name))
1461 return 0;
1462
Peter Zijlstra6e7d6fd2009-06-17 15:51:44 +02001463 if (hist_entry__add(thread, map, dso, sym, ip, chain, level, period)) {
Ingo Molnar75220602009-06-18 08:00:17 +02001464 eprintf("problem incrementing symbol count, skipping event\n");
Ingo Molnar75051722009-06-03 23:14:49 +02001465 return -1;
1466 }
1467 }
Peter Zijlstraea1900e2009-06-10 21:45:22 +02001468 total += period;
Ingo Molnar75051722009-06-03 23:14:49 +02001469
1470 return 0;
1471}
1472
1473static int
1474process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
1475{
1476 struct thread *thread = threads__findnew(event->mmap.pid);
1477 struct map *map = map__new(&event->mmap);
1478
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001479 dprintf("%p [%p]: PERF_EVENT_MMAP %d: [%p(%p) @ %p]: %s\n",
Ingo Molnar75051722009-06-03 23:14:49 +02001480 (void *)(offset + head),
1481 (void *)(long)(event->header.size),
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001482 event->mmap.pid,
Ingo Molnar75051722009-06-03 23:14:49 +02001483 (void *)(long)event->mmap.start,
1484 (void *)(long)event->mmap.len,
1485 (void *)(long)event->mmap.pgoff,
1486 event->mmap.filename);
1487
1488 if (thread == NULL || map == NULL) {
1489 dprintf("problem processing PERF_EVENT_MMAP, skipping event.\n");
Ingo Molnardf979922009-06-04 13:41:22 +02001490 return 0;
Ingo Molnar75051722009-06-03 23:14:49 +02001491 }
1492
1493 thread__insert_map(thread, map);
1494 total_mmap++;
1495
1496 return 0;
1497}
1498
1499static int
1500process_comm_event(event_t *event, unsigned long offset, unsigned long head)
1501{
1502 struct thread *thread = threads__findnew(event->comm.pid);
1503
1504 dprintf("%p [%p]: PERF_EVENT_COMM: %s:%d\n",
1505 (void *)(offset + head),
1506 (void *)(long)(event->header.size),
1507 event->comm.comm, event->comm.pid);
1508
1509 if (thread == NULL ||
1510 thread__set_comm(thread, event->comm.comm)) {
1511 dprintf("problem processing PERF_EVENT_COMM, skipping event.\n");
1512 return -1;
1513 }
1514 total_comm++;
1515
1516 return 0;
1517}
1518
1519static int
Peter Zijlstra27d028d2009-07-23 16:52:41 +02001520process_task_event(event_t *event, unsigned long offset, unsigned long head)
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001521{
1522 struct thread *thread = threads__findnew(event->fork.pid);
1523 struct thread *parent = threads__findnew(event->fork.ppid);
1524
Peter Zijlstra27d028d2009-07-23 16:52:41 +02001525 dprintf("%p [%p]: PERF_EVENT_%s: (%d:%d):(%d:%d)\n",
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001526 (void *)(offset + head),
1527 (void *)(long)(event->header.size),
Peter Zijlstra27d028d2009-07-23 16:52:41 +02001528 event->header.type == PERF_EVENT_FORK ? "FORK" : "EXIT",
1529 event->fork.pid, event->fork.tid,
1530 event->fork.ppid, event->fork.ptid);
1531
1532 /*
1533 * A thread clone will have the same PID for both
1534 * parent and child.
1535 */
1536 if (thread == parent)
1537 return 0;
1538
1539 if (event->header.type == PERF_EVENT_EXIT)
1540 return 0;
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001541
1542 if (!thread || !parent || thread__fork(thread, parent)) {
1543 dprintf("problem processing PERF_EVENT_FORK, skipping event.\n");
1544 return -1;
1545 }
1546 total_fork++;
1547
1548 return 0;
1549}
1550
1551static int
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +02001552process_lost_event(event_t *event, unsigned long offset, unsigned long head)
1553{
1554 dprintf("%p [%p]: PERF_EVENT_LOST: id:%Ld: lost:%Ld\n",
1555 (void *)(offset + head),
1556 (void *)(long)(event->header.size),
1557 event->lost.id,
1558 event->lost.lost);
1559
1560 total_lost += event->lost.lost;
1561
1562 return 0;
1563}
1564
Ingo Molnar8465b052009-06-14 14:44:07 +02001565static void trace_event(event_t *event)
1566{
1567 unsigned char *raw_event = (void *)event;
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001568 char *color = PERF_COLOR_BLUE;
Ingo Molnar8465b052009-06-14 14:44:07 +02001569 int i, j;
1570
1571 if (!dump_trace)
1572 return;
1573
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001574 dprintf(".");
1575 cdprintf("\n. ... raw event: size %d bytes\n", event->header.size);
Ingo Molnar8465b052009-06-14 14:44:07 +02001576
1577 for (i = 0; i < event->header.size; i++) {
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001578 if ((i & 15) == 0) {
1579 dprintf(".");
1580 cdprintf(" %04x: ", i);
1581 }
Ingo Molnar8465b052009-06-14 14:44:07 +02001582
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001583 cdprintf(" %02x", raw_event[i]);
Ingo Molnar8465b052009-06-14 14:44:07 +02001584
1585 if (((i & 15) == 15) || i == event->header.size-1) {
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001586 cdprintf(" ");
Ingo Molnar8465b052009-06-14 14:44:07 +02001587 for (j = 0; j < 15-(i & 15); j++)
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001588 cdprintf(" ");
Ingo Molnar8465b052009-06-14 14:44:07 +02001589 for (j = 0; j < (i & 15); j++) {
Peter Zijlstraa73c7d82009-06-18 09:44:20 +02001590 if (isprint(raw_event[i-15+j]))
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001591 cdprintf("%c", raw_event[i-15+j]);
Ingo Molnar8465b052009-06-14 14:44:07 +02001592 else
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001593 cdprintf(".");
Ingo Molnar8465b052009-06-14 14:44:07 +02001594 }
Ingo Molnar3efa1cc92009-06-14 15:04:15 +02001595 cdprintf("\n");
Ingo Molnar8465b052009-06-14 14:44:07 +02001596 }
1597 }
1598 dprintf(".\n");
1599}
1600
Peter Zijlstra8f18aec2009-08-06 19:40:28 +02001601static struct perf_header *header;
1602
1603static struct perf_counter_attr *perf_header__find_attr(u64 id)
1604{
1605 int i;
1606
1607 for (i = 0; i < header->attrs; i++) {
1608 struct perf_header_attr *attr = header->attr[i];
1609 int j;
1610
1611 for (j = 0; j < attr->ids; j++) {
1612 if (attr->id[j] == id)
1613 return &attr->attr;
1614 }
1615 }
1616
1617 return NULL;
1618}
1619
Ingo Molnarb2fef072009-06-05 18:07:51 +02001620static int
Peter Zijlstrae9ea2fd2009-06-24 22:46:04 +02001621process_read_event(event_t *event, unsigned long offset, unsigned long head)
1622{
Peter Zijlstra8f18aec2009-08-06 19:40:28 +02001623 struct perf_counter_attr *attr = perf_header__find_attr(event->read.id);
1624
Brice Goglin8d513272009-08-07 13:55:24 +02001625 if (show_threads) {
1626 char *name = attr ? __event_name(attr->type, attr->config)
1627 : "unknown";
1628 perf_read_values_add_value(&show_threads_values,
1629 event->read.pid, event->read.tid,
1630 event->read.id,
1631 name,
1632 event->read.value);
1633 }
1634
Peter Zijlstra8f18aec2009-08-06 19:40:28 +02001635 dprintf("%p [%p]: PERF_EVENT_READ: %d %d %s %Lu\n",
Peter Zijlstrae9ea2fd2009-06-24 22:46:04 +02001636 (void *)(offset + head),
1637 (void *)(long)(event->header.size),
1638 event->read.pid,
1639 event->read.tid,
Peter Zijlstra8f18aec2009-08-06 19:40:28 +02001640 attr ? __event_name(attr->type, attr->config)
1641 : "FAIL",
Peter Zijlstrae9ea2fd2009-06-24 22:46:04 +02001642 event->read.value);
1643
1644 return 0;
1645}
1646
1647static int
Ingo Molnard80d3382009-06-03 23:14:49 +02001648process_event(event_t *event, unsigned long offset, unsigned long head)
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -03001649{
Ingo Molnar8465b052009-06-14 14:44:07 +02001650 trace_event(event);
1651
Ingo Molnar75051722009-06-03 23:14:49 +02001652 switch (event->header.type) {
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001653 case PERF_EVENT_SAMPLE:
1654 return process_sample_event(event, offset, head);
1655
Ingo Molnar75051722009-06-03 23:14:49 +02001656 case PERF_EVENT_MMAP:
1657 return process_mmap_event(event, offset, head);
Ingo Molnar97b07b62009-05-26 18:48:58 +02001658
Ingo Molnar75051722009-06-03 23:14:49 +02001659 case PERF_EVENT_COMM:
1660 return process_comm_event(event, offset, head);
Ingo Molnared966aa2009-06-03 10:39:26 +02001661
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001662 case PERF_EVENT_FORK:
Peter Zijlstra27d028d2009-07-23 16:52:41 +02001663 case PERF_EVENT_EXIT:
1664 return process_task_event(event, offset, head);
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001665
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +02001666 case PERF_EVENT_LOST:
1667 return process_lost_event(event, offset, head);
1668
Peter Zijlstrae9ea2fd2009-06-24 22:46:04 +02001669 case PERF_EVENT_READ:
1670 return process_read_event(event, offset, head);
1671
Ingo Molnard11444d2009-06-03 23:29:14 +02001672 /*
1673 * We dont process them right now but they are fine:
1674 */
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001675
Ingo Molnard11444d2009-06-03 23:29:14 +02001676 case PERF_EVENT_THROTTLE:
1677 case PERF_EVENT_UNTHROTTLE:
1678 return 0;
1679
Ingo Molnard80d3382009-06-03 23:14:49 +02001680 default:
1681 return -1;
1682 }
1683
1684 return 0;
1685}
1686
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001687static u64 perf_header__sample_type(void)
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001688{
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001689 u64 sample_type = 0;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001690 int i;
1691
1692 for (i = 0; i < header->attrs; i++) {
1693 struct perf_header_attr *attr = header->attr[i];
1694
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001695 if (!sample_type)
1696 sample_type = attr->attr.sample_type;
1697 else if (sample_type != attr->attr.sample_type)
1698 die("non matching sample_type");
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001699 }
1700
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001701 return sample_type;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001702}
Peter Zijlstraf5970552009-06-18 23:22:55 +02001703
Ingo Molnard80d3382009-06-03 23:14:49 +02001704static int __cmd_report(void)
1705{
Ingo Molnar75051722009-06-03 23:14:49 +02001706 int ret, rc = EXIT_FAILURE;
Ingo Molnard80d3382009-06-03 23:14:49 +02001707 unsigned long offset = 0;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001708 unsigned long head, shift;
Ingo Molnard80d3382009-06-03 23:14:49 +02001709 struct stat stat;
Ingo Molnard80d3382009-06-03 23:14:49 +02001710 event_t *event;
Ingo Molnard80d3382009-06-03 23:14:49 +02001711 uint32_t size;
Ingo Molnar75051722009-06-03 23:14:49 +02001712 char *buf;
Ingo Molnard80d3382009-06-03 23:14:49 +02001713
1714 register_idle_thread();
1715
Brice Goglin8d513272009-08-07 13:55:24 +02001716 if (show_threads)
1717 perf_read_values_init(&show_threads_values);
1718
Ingo Molnard80d3382009-06-03 23:14:49 +02001719 input = open(input_name, O_RDONLY);
1720 if (input < 0) {
Ingo Molnara14832f2009-06-07 17:58:23 +02001721 fprintf(stderr, " failed to open file: %s", input_name);
1722 if (!strcmp(input_name, "perf.data"))
1723 fprintf(stderr, " (try 'perf record' first)");
1724 fprintf(stderr, "\n");
Ingo Molnard80d3382009-06-03 23:14:49 +02001725 exit(-1);
1726 }
1727
1728 ret = fstat(input, &stat);
1729 if (ret < 0) {
1730 perror("failed to stat file");
1731 exit(-1);
1732 }
1733
1734 if (!stat.st_size) {
1735 fprintf(stderr, "zero-sized file, nothing to do!\n");
1736 exit(0);
1737 }
1738
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001739 header = perf_header__read(input);
1740 head = header->data_offset;
Peter Zijlstraf5970552009-06-18 23:22:55 +02001741
Peter Zijlstrae6e18ec2009-06-25 11:27:12 +02001742 sample_type = perf_header__sample_type();
1743
Frederic Weisbecker91b4eae2009-07-05 07:39:17 +02001744 if (!(sample_type & PERF_SAMPLE_CALLCHAIN)) {
1745 if (sort__has_parent) {
1746 fprintf(stderr, "selected --sort parent, but no"
1747 " callchain data. Did you call"
1748 " perf record without -g?\n");
1749 exit(-1);
1750 }
1751 if (callchain) {
1752 fprintf(stderr, "selected -c but no callchain data."
1753 " Did you call perf record without"
1754 " -g?\n");
1755 exit(-1);
1756 }
Frederic Weisbeckerb1a88342009-08-08 02:16:24 +02001757 } else if (callchain_param.mode != CHAIN_NONE && !callchain) {
1758 callchain = 1;
1759 if (register_callchain_param(&callchain_param) < 0) {
1760 fprintf(stderr, "Can't register callchain"
1761 " params\n");
1762 exit(-1);
1763 }
Peter Zijlstraf5970552009-06-18 23:22:55 +02001764 }
1765
Ingo Molnard80d3382009-06-03 23:14:49 +02001766 if (load_kernel() < 0) {
1767 perror("failed to load kernel symbols");
1768 return EXIT_FAILURE;
1769 }
1770
1771 if (!full_paths) {
1772 if (getcwd(__cwd, sizeof(__cwd)) == NULL) {
1773 perror("failed to get the current directory");
1774 return EXIT_FAILURE;
1775 }
1776 cwdlen = strlen(cwd);
1777 } else {
1778 cwd = NULL;
1779 cwdlen = 0;
1780 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001781
1782 shift = page_size * (head / page_size);
1783 offset += shift;
1784 head -= shift;
1785
Ingo Molnard80d3382009-06-03 23:14:49 +02001786remap:
1787 buf = (char *)mmap(NULL, page_size * mmap_window, PROT_READ,
1788 MAP_SHARED, input, offset);
1789 if (buf == MAP_FAILED) {
1790 perror("failed to mmap file");
1791 exit(-1);
1792 }
1793
1794more:
1795 event = (event_t *)(buf + head);
1796
1797 size = event->header.size;
1798 if (!size)
1799 size = 8;
1800
1801 if (head + event->header.size >= page_size * mmap_window) {
Ingo Molnard80d3382009-06-03 23:14:49 +02001802 int ret;
1803
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001804 shift = page_size * (head / page_size);
1805
Ingo Molnard80d3382009-06-03 23:14:49 +02001806 ret = munmap(buf, page_size * mmap_window);
1807 assert(ret == 0);
1808
1809 offset += shift;
1810 head -= shift;
1811 goto remap;
1812 }
1813
1814 size = event->header.size;
1815
Ingo Molnar8465b052009-06-14 14:44:07 +02001816 dprintf("\n%p [%p]: event: %d\n",
Ingo Molnarb2fef072009-06-05 18:07:51 +02001817 (void *)(offset + head),
1818 (void *)(long)event->header.size,
1819 event->header.type);
1820
Ingo Molnard80d3382009-06-03 23:14:49 +02001821 if (!size || process_event(event, offset, head) < 0) {
1822
Ingo Molnar35029732009-06-03 09:38:58 +02001823 dprintf("%p [%p]: skipping unknown header type: %d\n",
1824 (void *)(offset + head),
1825 (void *)(long)(event->header.size),
1826 event->header.type);
Peter Zijlstrab7a16ea2009-05-27 13:35:35 +02001827
Ingo Molnar3e706112009-05-26 18:53:17 +02001828 total_unknown++;
Peter Zijlstra6142f9e2009-05-26 20:51:47 +02001829
1830 /*
1831 * assume we lost track of the stream, check alignment, and
1832 * increment a single u64 in the hope to catch on again 'soon'.
1833 */
1834
1835 if (unlikely(head & 7))
1836 head &= ~7ULL;
1837
1838 size = 8;
Ingo Molnar97b07b62009-05-26 18:48:58 +02001839 }
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -03001840
Peter Zijlstra6142f9e2009-05-26 20:51:47 +02001841 head += size;
Ingo Molnarf49515b2009-05-26 19:03:36 +02001842
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02001843 if (offset + head >= header->data_offset + header->data_size)
Peter Zijlstraf5970552009-06-18 23:22:55 +02001844 goto done;
1845
Ingo Molnarf37a2912009-07-01 12:37:06 +02001846 if (offset + head < (unsigned long)stat.st_size)
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -03001847 goto more;
1848
Peter Zijlstraf5970552009-06-18 23:22:55 +02001849done:
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -03001850 rc = EXIT_SUCCESS;
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -03001851 close(input);
Ingo Molnar97b07b62009-05-26 18:48:58 +02001852
Ingo Molnar35029732009-06-03 09:38:58 +02001853 dprintf(" IP events: %10ld\n", total);
1854 dprintf(" mmap events: %10ld\n", total_mmap);
1855 dprintf(" comm events: %10ld\n", total_comm);
Peter Zijlstra62fc4452009-06-04 16:53:49 +02001856 dprintf(" fork events: %10ld\n", total_fork);
Peter Zijlstra9d91a6f2009-06-18 11:40:28 +02001857 dprintf(" lost events: %10ld\n", total_lost);
Ingo Molnar35029732009-06-03 09:38:58 +02001858 dprintf(" unknown events: %10ld\n", total_unknown);
Ingo Molnar97b07b62009-05-26 18:48:58 +02001859
Ingo Molnar35029732009-06-03 09:38:58 +02001860 if (dump_trace)
Ingo Molnar97b07b62009-05-26 18:48:58 +02001861 return 0;
Ingo Molnar97b07b62009-05-26 18:48:58 +02001862
Arnaldo Carvalho de Melo9ac99542009-06-04 13:54:00 -03001863 if (verbose >= 3)
1864 threads__fprintf(stdout);
1865
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001866 if (verbose >= 2)
Ingo Molnar16f762a2009-05-27 09:10:38 +02001867 dsos__fprintf(stdout);
Ingo Molnar16f762a2009-05-27 09:10:38 +02001868
Peter Zijlstra82292892009-06-03 12:37:36 +02001869 collapse__resort();
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001870 output__resort(total);
Peter Zijlstrae7fb08b2009-05-27 20:20:24 +02001871 output__fprintf(stdout, total);
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -03001872
Brice Goglin8d513272009-08-07 13:55:24 +02001873 if (show_threads)
1874 perf_read_values_destroy(&show_threads_values);
1875
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -03001876 return rc;
1877}
1878
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +02001879static int
1880parse_callchain_opt(const struct option *opt __used, const char *arg,
1881 int unset __used)
1882{
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001883 char *tok;
1884 char *endptr;
1885
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +02001886 callchain = 1;
1887
1888 if (!arg)
1889 return 0;
1890
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001891 tok = strtok((char *)arg, ",");
1892 if (!tok)
1893 return -1;
1894
1895 /* get the output mode */
1896 if (!strncmp(tok, "graph", strlen(arg)))
Frederic Weisbecker805d1272009-07-05 07:39:21 +02001897 callchain_param.mode = CHAIN_GRAPH_ABS;
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +02001898
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001899 else if (!strncmp(tok, "flat", strlen(arg)))
Frederic Weisbecker805d1272009-07-05 07:39:21 +02001900 callchain_param.mode = CHAIN_FLAT;
1901
1902 else if (!strncmp(tok, "fractal", strlen(arg)))
1903 callchain_param.mode = CHAIN_GRAPH_REL;
1904
Frederic Weisbeckerb1a88342009-08-08 02:16:24 +02001905 else if (!strncmp(tok, "none", strlen(arg))) {
1906 callchain_param.mode = CHAIN_NONE;
1907 callchain = 0;
1908
1909 return 0;
1910 }
1911
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +02001912 else
1913 return -1;
1914
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001915 /* get the min percentage */
1916 tok = strtok(NULL, ",");
1917 if (!tok)
Frederic Weisbecker805d1272009-07-05 07:39:21 +02001918 goto setup;
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001919
Frederic Weisbecker805d1272009-07-05 07:39:21 +02001920 callchain_param.min_percent = strtod(tok, &endptr);
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001921 if (tok == endptr)
1922 return -1;
1923
Frederic Weisbecker805d1272009-07-05 07:39:21 +02001924setup:
1925 if (register_callchain_param(&callchain_param) < 0) {
1926 fprintf(stderr, "Can't register callchain params\n");
1927 return -1;
1928 }
Frederic Weisbecker4eb3e472009-07-02 17:58:21 +02001929 return 0;
1930}
1931
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02001932static const char * const report_usage[] = {
1933 "perf report [<options>] <command>",
1934 NULL
1935};
1936
1937static const struct option options[] = {
1938 OPT_STRING('i', "input", &input_name, "file",
1939 "input file name"),
Arnaldo Carvalho de Melo815e7772009-05-26 19:46:14 -03001940 OPT_BOOLEAN('v', "verbose", &verbose,
1941 "be more verbose (show symbol address, etc)"),
Ingo Molnar97b07b62009-05-26 18:48:58 +02001942 OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1943 "dump raw trace in ASCII"),
Peter Zijlstra450aaa22009-05-27 20:20:23 +02001944 OPT_STRING('k', "vmlinux", &vmlinux, "file", "vmlinux pathname"),
Mike Galbraith42976482009-07-02 08:09:46 +02001945 OPT_BOOLEAN('m', "modules", &modules,
1946 "load module symbols - WARNING: use only with -k and LIVE kernel"),
Arnaldo Carvalho de Meloe3d7e182009-07-11 12:18:37 -03001947 OPT_BOOLEAN('n', "show-nr-samples", &show_nr_samples,
1948 "Show a column with the number of samples"),
Brice Goglin8d513272009-08-07 13:55:24 +02001949 OPT_BOOLEAN('T', "threads", &show_threads,
1950 "Show per-thread event counters"),
Brice Goglin9f866692009-08-10 15:26:32 +02001951 OPT_STRING(0, "pretty", &pretty_printing_style, "key",
1952 "pretty printing style key: normal raw"),
Ingo Molnar63299f02009-05-28 10:52:00 +02001953 OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
Ingo Molnarb25bcf22009-06-18 07:01:03 +02001954 "sort by key(s): pid, comm, dso, symbol, parent"),
Arnaldo Carvalho de Melob78c07d2009-05-29 13:48:59 -03001955 OPT_BOOLEAN('P', "full-paths", &full_paths,
1956 "Don't shorten the pathnames taking into account the cwd"),
Ingo Molnarb25bcf22009-06-18 07:01:03 +02001957 OPT_STRING('p', "parent", &parent_pattern, "regex",
1958 "regex filter to identify parent, see: '--sort parent'"),
Ingo Molnarb8e6d822009-06-18 14:32:19 +02001959 OPT_BOOLEAN('x', "exclude-other", &exclude_other,
1960 "Only display entries with parent-match"),
Anton Blanchard1483b19f2009-07-16 15:44:29 +02001961 OPT_CALLBACK_DEFAULT('g', "call-graph", NULL, "output_type,min_percent",
Frederic Weisbeckerc20ab372009-07-02 20:14:33 +02001962 "Display callchains using output_type and min percent threshold. "
Anton Blanchard1483b19f2009-07-16 15:44:29 +02001963 "Default: fractal,0.5", &parse_callchain_opt, callchain_default_opt),
Arnaldo Carvalho de Melo25903402009-06-30 19:01:20 -03001964 OPT_STRING('d', "dsos", &dso_list_str, "dso[,dso...]",
1965 "only consider symbols in these dsos"),
Arnaldo Carvalho de Melocc8b88b2009-06-30 19:01:21 -03001966 OPT_STRING('C', "comms", &comm_list_str, "comm[,comm...]",
1967 "only consider symbols in these comms"),
Arnaldo Carvalho de Melo7bec7a92009-06-30 19:01:22 -03001968 OPT_STRING('S', "symbols", &sym_list_str, "symbol[,symbol...]",
1969 "only consider these symbols"),
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -03001970 OPT_STRING('w', "column-widths", &col_width_list_str,
1971 "width[,width...]",
1972 "don't try to adjust column width, use these fixed values"),
1973 OPT_STRING('t', "field-separator", &field_sep, "separator",
1974 "separator for columns, no spaces will be added between "
1975 "columns '.' is reserved."),
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02001976 OPT_END()
1977};
1978
Ingo Molnar5352f352009-06-03 10:07:39 +02001979static void setup_sorting(void)
1980{
1981 char *tmp, *tok, *str = strdup(sort_order);
1982
1983 for (tok = strtok_r(str, ", ", &tmp);
1984 tok; tok = strtok_r(NULL, ", ", &tmp)) {
1985 if (sort_dimension__add(tok) < 0) {
1986 error("Unknown --sort key: `%s'", tok);
1987 usage_with_options(report_usage, options);
1988 }
1989 }
1990
1991 free(str);
1992}
1993
Arnaldo Carvalho de Melocc8b88b2009-06-30 19:01:21 -03001994static void setup_list(struct strlist **list, const char *list_str,
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -03001995 struct sort_entry *se, const char *list_name,
1996 FILE *fp)
Arnaldo Carvalho de Melocc8b88b2009-06-30 19:01:21 -03001997{
1998 if (list_str) {
1999 *list = strlist__new(true, list_str);
2000 if (!*list) {
2001 fprintf(stderr, "problems parsing %s list\n",
2002 list_name);
2003 exit(129);
2004 }
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -03002005 if (strlist__nr_entries(*list) == 1) {
2006 fprintf(fp, "# %s: %s\n", list_name,
2007 strlist__entry(*list, 0)->s);
2008 se->elide = true;
2009 }
Arnaldo Carvalho de Melocc8b88b2009-06-30 19:01:21 -03002010 }
2011}
2012
Ingo Molnarf37a2912009-07-01 12:37:06 +02002013int cmd_report(int argc, const char **argv, const char *prefix __used)
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02002014{
Arnaldo Carvalho de Meloa2928c42009-05-28 14:55:04 -03002015 symbol__init();
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02002016
2017 page_size = getpagesize();
2018
Ingo Molnaredc52de2009-06-04 16:24:37 +02002019 argc = parse_options(argc, argv, options, report_usage, 0);
Ingo Molnar53cb8bc2009-05-26 09:17:18 +02002020
Peter Zijlstra1aa16732009-05-27 20:20:25 +02002021 setup_sorting();
2022
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -03002023 if (parent_pattern != default_parent_pattern) {
Ingo Molnarb8e6d822009-06-18 14:32:19 +02002024 sort_dimension__add("parent");
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -03002025 sort_parent.elide = 1;
2026 } else
Ingo Molnarb8e6d822009-06-18 14:32:19 +02002027 exclude_other = 0;
2028
Ingo Molnaredc52de2009-06-04 16:24:37 +02002029 /*
2030 * Any (unrecognized) arguments left?
2031 */
2032 if (argc)
2033 usage_with_options(report_usage, options);
2034
Ingo Molnara930d2c2009-05-27 09:50:13 +02002035 setup_pager();
2036
Arnaldo Carvalho de Melo021191b2009-07-11 12:18:35 -03002037 setup_list(&dso_list, dso_list_str, &sort_dso, "dso", stdout);
2038 setup_list(&comm_list, comm_list_str, &sort_comm, "comm", stdout);
2039 setup_list(&sym_list, sym_list_str, &sort_sym, "symbol", stdout);
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -03002040
Arnaldo Carvalho de Melo52d422d2009-07-10 22:47:28 -03002041 if (field_sep && *field_sep == '.') {
2042 fputs("'.' is the only non valid --field-separator argument\n",
2043 stderr);
2044 exit(129);
2045 }
2046
Arnaldo Carvalho de Melo8fa66bd2009-05-18 12:45:42 -03002047 return __cmd_report();
2048}