Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit eac23d1c384b55e4bbb89ea9e5a6bb77fb4d1140

Authored by Ian Munsie 2010-12-09 13:33:53 +0800

Committed by Arnaldo Carvalho de Melo 2010-12-22 06:17:51 +0800

Exists in master and in 7 other branches

perf record,report,annotate,diff: Process events in order

This patch changes perf report to ask for the ID info on all events be
default if recording from multiple CPUs.

Perf report, annotate and diff will now process the events in order if
the kernel is able to provide timestamps on all events. This ensures
that events such as COMM and MMAP which are necessary to correctly
interpret samples are processed prior to those samples so that they are
attributed correctly.

Before:
 # perf record ./cachetest
 # perf report

 # Events: 6K cycles
 #
 # Overhead  Command      Shared Object                           Symbol
 # ........  .......  .................  ...............................
 #
     74.11%    :3259  [unknown]          [k] 0x4a6c
      1.50%  cachetest  ld-2.11.2.so       [.] 0x1777c
      1.46%    :3259  [kernel.kallsyms]  [k] .perf_event_mmap_ctx
      1.25%    :3259  [kernel.kallsyms]  [k] restore
      0.74%    :3259  [kernel.kallsyms]  [k] ._raw_spin_lock
      0.71%    :3259  [kernel.kallsyms]  [k] .filemap_fault
      0.66%    :3259  [kernel.kallsyms]  [k] .memset
      0.54%  cachetest  [kernel.kallsyms]  [k] .sha_transform
      0.54%    :3259  [kernel.kallsyms]  [k] .copy_4K_page
      0.54%    :3259  [kernel.kallsyms]  [k] .find_get_page
      0.52%    :3259  [kernel.kallsyms]  [k] .trace_hardirqs_off
      0.50%    :3259  [kernel.kallsyms]  [k] .__do_fault
<SNIP>

After:
 # perf report

 # Events: 6K cycles
 #
 # Overhead  Command      Shared Object                           Symbol
 # ........  .......  .................  ...............................
 #
     44.28%  cachetest  cachetest          [.] sumArrayNaive
     22.53%  cachetest  cachetest          [.] sumArrayOptimal
      6.59%  cachetest  ld-2.11.2.so       [.] 0x1777c
      2.13%  cachetest  [unknown]          [k] 0x340
      1.46%  cachetest  [kernel.kallsyms]  [k] .perf_event_mmap_ctx
      1.25%  cachetest  [kernel.kallsyms]  [k] restore
      0.74%  cachetest  [kernel.kallsyms]  [k] ._raw_spin_lock
      0.71%  cachetest  [kernel.kallsyms]  [k] .filemap_fault
      0.66%  cachetest  [kernel.kallsyms]  [k] .memset
      0.54%  cachetest  [kernel.kallsyms]  [k] .copy_4K_page
      0.54%  cachetest  [kernel.kallsyms]  [k] .find_get_page
      0.54%  cachetest  [kernel.kallsyms]  [k] .sha_transform
      0.52%  cachetest  [kernel.kallsyms]  [k] .trace_hardirqs_off
      0.50%  cachetest  [kernel.kallsyms]  [k] .__do_fault
<SNIP>

Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
LKML-Reference: <1291872833-839-1-git-send-email-imunsie@au1.ibm.com>
Signed-off-by: Ian Munsie <imunsie@au1.ibm.com>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

Showing 4 changed files with 10 additions and 1 deletions Inline Diff

tools/perf/builtin-annotate.c
tools/perf/builtin-diff.c
tools/perf/builtin-record.c
tools/perf/builtin-report.c

tools/perf/builtin-annotate.c

Diff comments View file @ eac23d1

 /*
  * builtin-annotate.c
  *
  * Builtin annotate command: Analyze the perf.data input file,
  * look up and read DSOs and symbol information and display
  * a histogram of results, along various sorting keys.
  */
 #include "builtin.h"
 #include "util/util.h"
 #include "util/color.h"
 #include <linux/list.h>
 #include "util/cache.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
 #include "perf.h"
 #include "util/debug.h"
 #include "util/event.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/thread.h"
 #include "util/sort.h"
 #include "util/hist.h"
 #include "util/session.h"
 static char		const *input_name = "perf.data";
 static bool		force, use_tui, use_stdio;
 static bool		full_paths;
 static bool		print_line;
 static const char *sym_hist_filter;
 static int hists__add_entry(struct hists *self, struct addr_location *al)
 {
 	struct hist_entry *he;
 	if (sym_hist_filter != NULL &&
 	    (al->sym == NULL || strcmp(sym_hist_filter, al->sym->name) != 0)) {
 		/* We're only interested in a symbol named sym_hist_filter */
 		if (al->sym != NULL) {
 			rb_erase(&al->sym->rb_node,
 				 &al->map->dso->symbols[al->map->type]);
 			symbol__delete(al->sym);
 		}
 		return 0;
 	}
 	he = __hists__add_entry(self, al, NULL, 1);
 	if (he == NULL)
 		return -ENOMEM;
 	return hist_entry__inc_addr_samples(he, al->addr);
 }
 static int process_sample_event(event_t *event, struct sample_data *sample,
 				struct perf_session *session)
 {
 	struct addr_location al;
 	if (event__preprocess_sample(event, session, &al, sample, NULL) < 0) {
 		pr_warning("problem processing %d event, skipping it.\n",
 			   event->header.type);
 		return -1;
 	}
 	if (!al.filtered && hists__add_entry(&session->hists, &al)) {
 		pr_warning("problem incrementing symbol count, "
 			   "skipping event\n");
 		return -1;
 	}
 	return 0;
 }
 static int objdump_line__print(struct objdump_line *self,
 			       struct list_head *head,
 			       struct hist_entry *he, u64 len)
 {
 	struct symbol *sym = he->ms.sym;
 	static const char *prev_line;
 	static const char *prev_color;
 	if (self->offset != -1) {
 		const char *path = NULL;
 		unsigned int hits = 0;
 		double percent = 0.0;
 		const char *color;
 		struct sym_priv *priv = symbol__priv(sym);
 		struct sym_ext *sym_ext = priv->ext;
 		struct sym_hist *h = priv->hist;
 		s64 offset = self->offset;
 		struct objdump_line *next = objdump__get_next_ip_line(head, self);
 		while (offset < (s64)len &&
 		       (next == NULL || offset < next->offset)) {
 			if (sym_ext) {
 				if (path == NULL)
 					path = sym_ext[offset].path;
 				percent += sym_ext[offset].percent;
 			} else
 				hits += h->ip[offset];
 			++offset;
 		}
 		if (sym_ext == NULL && h->sum)
 			percent = 100.0 * hits / h->sum;
 		color = get_percent_color(percent);
 		/*
 		 * Also color the filename and line if needed, with
 		 * the same color than the percentage. Don't print it
 		 * twice for close colored ip with the same filename:line
 		 */
 		if (path) {
 			if (!prev_line || strcmp(prev_line, path)
 				       || color != prev_color) {
 				color_fprintf(stdout, color, " %s", path);
 				prev_line = path;
 				prev_color = color;
 			}
 		}
 		color_fprintf(stdout, color, " %7.2f", percent);
 		printf(" :	");
 		color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", self->line);
 	} else {
 		if (!*self->line)
 			printf("         :\n");
 		else
 			printf("         :	%s\n", self->line);
 	}
 	return 0;
 }
 static struct rb_root root_sym_ext;
 static void insert_source_line(struct sym_ext *sym_ext)
 {
 	struct sym_ext *iter;
 	struct rb_node **p = &root_sym_ext.rb_node;
 	struct rb_node *parent = NULL;
 	while (*p != NULL) {
 		parent = *p;
 		iter = rb_entry(parent, struct sym_ext, node);
 		if (sym_ext->percent > iter->percent)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&sym_ext->node, parent, p);
 	rb_insert_color(&sym_ext->node, &root_sym_ext);
 }
 static void free_source_line(struct hist_entry *he, int len)
 {
 	struct sym_priv *priv = symbol__priv(he->ms.sym);
 	struct sym_ext *sym_ext = priv->ext;
 	int i;
 	if (!sym_ext)
 		return;
 	for (i = 0; i < len; i++)
 		free(sym_ext[i].path);
 	free(sym_ext);
 	priv->ext = NULL;
 	root_sym_ext = RB_ROOT;
 }
 /* Get the filename:line for the colored entries */
 static void
 get_source_line(struct hist_entry *he, int len, const char *filename)
 {
 	struct symbol *sym = he->ms.sym;
 	u64 start;
 	int i;
 	char cmd[PATH_MAX * 2];
 	struct sym_ext *sym_ext;
 	struct sym_priv *priv = symbol__priv(sym);
 	struct sym_hist *h = priv->hist;
 	if (!h->sum)
 		return;
 	sym_ext = priv->ext = calloc(len, sizeof(struct sym_ext));
 	if (!priv->ext)
 		return;
 	start = he->ms.map->unmap_ip(he->ms.map, sym->start);
 	for (i = 0; i < len; i++) {
 		char *path = NULL;
 		size_t line_len;
 		u64 offset;
 		FILE *fp;
 		sym_ext[i].percent = 100.0 * h->ip[i] / h->sum;
 		if (sym_ext[i].percent <= 0.5)
 			continue;
 		offset = start + i;
 		sprintf(cmd, "addr2line -e %s %016llx", filename, offset);
 		fp = popen(cmd, "r");
 		if (!fp)
 			continue;
 		if (getline(&path, &line_len, fp) < 0 || !line_len)
 			goto next;
 		sym_ext[i].path = malloc(sizeof(char) * line_len + 1);
 		if (!sym_ext[i].path)
 			goto next;
 		strcpy(sym_ext[i].path, path);
 		insert_source_line(&sym_ext[i]);
 	next:
 		pclose(fp);
 	}
 }
 static void print_summary(const char *filename)
 {
 	struct sym_ext *sym_ext;
 	struct rb_node *node;
 	printf("\nSorted summary for file %s\n", filename);
 	printf("----------------------------------------------\n\n");
 	if (RB_EMPTY_ROOT(&root_sym_ext)) {
 		printf(" Nothing higher than %1.1f%%\n", MIN_GREEN);
 		return;
 	}
 	node = rb_first(&root_sym_ext);
 	while (node) {
 		double percent;
 		const char *color;
 		char *path;
 		sym_ext = rb_entry(node, struct sym_ext, node);
 		percent = sym_ext->percent;
 		color = get_percent_color(percent);
 		path = sym_ext->path;
 		color_fprintf(stdout, color, " %7.2f %s", percent, path);
 		node = rb_next(node);
 	}
 }
 static void hist_entry__print_hits(struct hist_entry *self)
 {
 	struct symbol *sym = self->ms.sym;
 	struct sym_priv *priv = symbol__priv(sym);
 	struct sym_hist *h = priv->hist;
 	u64 len = sym->end - sym->start, offset;
 	for (offset = 0; offset < len; ++offset)
 		if (h->ip[offset] != 0)
 			printf("%*Lx: %Lu\n", BITS_PER_LONG / 2,
 			       sym->start + offset, h->ip[offset]);
 	printf("%*s: %Lu\n", BITS_PER_LONG / 2, "h->sum", h->sum);
 }
 static int hist_entry__tty_annotate(struct hist_entry *he)
 {
 	struct map *map = he->ms.map;
 	struct dso *dso = map->dso;
 	struct symbol *sym = he->ms.sym;
 	const char *filename = dso->long_name, *d_filename;
 	u64 len;
 	LIST_HEAD(head);
 	struct objdump_line *pos, *n;
 	if (hist_entry__annotate(he, &head, 0) < 0)
 		return -1;
 	if (full_paths)
 		d_filename = filename;
 	else
 		d_filename = basename(filename);
 	len = sym->end - sym->start;
 	if (print_line) {
 		get_source_line(he, len, filename);
 		print_summary(filename);
 	}
 	printf("\n\n------------------------------------------------\n");
 	printf(" Percent |	Source code & Disassembly of %s\n", d_filename);
 	printf("------------------------------------------------\n");
 	if (verbose)
 		hist_entry__print_hits(he);
 	list_for_each_entry_safe(pos, n, &head, node) {
 		objdump_line__print(pos, &head, he, len);
 		list_del(&pos->node);
 		objdump_line__free(pos);
 	}
 	if (print_line)
 		free_source_line(he, len);
 	return 0;
 }
 static void hists__find_annotations(struct hists *self)
 {
 	struct rb_node *nd = rb_first(&self->entries), *next;
 	int key = KEY_RIGHT;
 	while (nd) {
 		struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
 		struct sym_priv *priv;
 		if (he->ms.sym == NULL || he->ms.map->dso->annotate_warned)
 			goto find_next;
 		priv = symbol__priv(he->ms.sym);
 		if (priv->hist == NULL) {
 find_next:
 			if (key == KEY_LEFT)
 				nd = rb_prev(nd);
 			else
 				nd = rb_next(nd);
 			continue;
 		}
 		if (use_browser > 0) {
 			key = hist_entry__tui_annotate(he);
 			switch (key) {
 			case KEY_RIGHT:
 				next = rb_next(nd);
 				break;
 			case KEY_LEFT:
 				next = rb_prev(nd);
 				break;
 			default:
 				return;
 			}
 			if (next != NULL)
 				nd = next;
 		} else {
 			hist_entry__tty_annotate(he);
 			nd = rb_next(nd);
 			/*
 			 * Since we have a hist_entry per IP for the same
 			 * symbol, free he->ms.sym->hist to signal we already
 			 * processed this symbol.
 			 */
 			free(priv->hist);
 			priv->hist = NULL;
 		}
 	}
 }
 static struct perf_event_ops event_ops = {
 	.sample	= process_sample_event,
 	.mmap	= event__process_mmap,
 	.comm	= event__process_comm,
 	.fork	= event__process_task,
+	.ordered_samples = true,
+	.ordering_requires_timestamps = true,
 };
 static int __cmd_annotate(void)
 {
 	int ret;
 	struct perf_session *session;
 	session = perf_session__new(input_name, O_RDONLY, force, false, &event_ops);
 	if (session == NULL)
 		return -ENOMEM;
 	ret = perf_session__process_events(session, &event_ops);
 	if (ret)
 		goto out_delete;
 	if (dump_trace) {
 		perf_session__fprintf_nr_events(session, stdout);
 		goto out_delete;
 	}
 	if (verbose > 3)
 		perf_session__fprintf(session, stdout);
 	if (verbose > 2)
 		perf_session__fprintf_dsos(session, stdout);
 	hists__collapse_resort(&session->hists);
 	hists__output_resort(&session->hists);
 	hists__find_annotations(&session->hists);
 out_delete:
 	perf_session__delete(session);
 	return ret;
 }
 static const char * const annotate_usage[] = {
 	"perf annotate [<options>] <command>",
 	NULL
 };
 static const struct option options[] = {
 	OPT_STRING('i', "input", &input_name, "file",
 		    "input file name"),
 	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
 		   "only consider symbols in these dsos"),
 	OPT_STRING('s', "symbol", &sym_hist_filter, "symbol",
 		    "symbol to annotate"),
 	OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show symbol address, etc)"),
 	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
 		    "dump raw trace in ASCII"),
 	OPT_BOOLEAN(0, "tui", &use_tui, "Use the TUI interface"),
 	OPT_BOOLEAN(0, "stdio", &use_stdio, "Use the stdio interface"),
 	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
 		   "file", "vmlinux pathname"),
 	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
 		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
 	OPT_BOOLEAN('l', "print-line", &print_line,
 		    "print matching source lines (may be slow)"),
 	OPT_BOOLEAN('P', "full-paths", &full_paths,
 		    "Don't shorten the displayed pathnames"),
 	OPT_END()
 };
 int cmd_annotate(int argc, const char **argv, const char *prefix __used)
 {
 	argc = parse_options(argc, argv, options, annotate_usage, 0);
 	if (use_stdio)
 		use_browser = 0;
 	else if (use_tui)
 		use_browser = 1;
 	setup_browser();
 	symbol_conf.priv_size = sizeof(struct sym_priv);
 	symbol_conf.try_vmlinux_path = true;
 	if (symbol__init() < 0)
 		return -1;
 	setup_sorting(annotate_usage, options);
 	if (argc) {
 		/*
 		 * Special case: if there's an argument left then assume tha
 		 * it's a symbol filter:
 		 */
 		if (argc > 1)
 			usage_with_options(annotate_usage, options);
 		sym_hist_filter = argv[0];
 	}
 	if (field_sep && *field_sep == '.') {
 		pr_err("'.' is the only non valid --field-separator argument\n");
 		return -1;
 	}
 	return __cmd_annotate();
 }

tools/perf/builtin-diff.c

Diff comments View file @ eac23d1

 /*
  * builtin-diff.c
  *
  * Builtin diff command: Analyze two perf.data input files, look up and read
  * DSOs and symbol information, sort them and produce a diff.
  */
 #include "builtin.h"
 #include "util/debug.h"
 #include "util/event.h"
 #include "util/hist.h"
 #include "util/session.h"
 #include "util/sort.h"
 #include "util/symbol.h"
 #include "util/util.h"
 #include <stdlib.h>
 static char const *input_old = "perf.data.old",
 		  *input_new = "perf.data";
 static char	  diff__default_sort_order[] = "dso,symbol";
 static bool  force;
 static bool show_displacement;
 static int hists__add_entry(struct hists *self,
 			    struct addr_location *al, u64 period)
 {
 	if (__hists__add_entry(self, al, NULL, period) != NULL)
 		return 0;
 	return -ENOMEM;
 }
 static int diff__process_sample_event(event_t *event,
 				      struct sample_data *sample,
 				      struct perf_session *session)
 {
 	struct addr_location al;
 	if (event__preprocess_sample(event, session, &al, sample, NULL) < 0) {
 		pr_warning("problem processing %d event, skipping it.\n",
 			   event->header.type);
 		return -1;
 	}
 	if (al.filtered || al.sym == NULL)
 		return 0;
 	if (hists__add_entry(&session->hists, &al, sample->period)) {
 		pr_warning("problem incrementing symbol period, skipping event\n");
 		return -1;
 	}
 	session->hists.stats.total_period += sample->period;
 	return 0;
 }
 static struct perf_event_ops event_ops = {
 	.sample	= diff__process_sample_event,
 	.mmap	= event__process_mmap,
 	.comm	= event__process_comm,
 	.exit	= event__process_task,
 	.fork	= event__process_task,
 	.lost	= event__process_lost,
+	.ordered_samples = true,
+	.ordering_requires_timestamps = true,
 };
 static void perf_session__insert_hist_entry_by_name(struct rb_root *root,
 						    struct hist_entry *he)
 {
 	struct rb_node **p = &root->rb_node;
 	struct rb_node *parent = NULL;
 	struct hist_entry *iter;
 	while (*p != NULL) {
 		parent = *p;
 		iter = rb_entry(parent, struct hist_entry, rb_node);
 		if (hist_entry__cmp(he, iter) < 0)
 			p = &(*p)->rb_left;
 		else
 			p = &(*p)->rb_right;
 	}
 	rb_link_node(&he->rb_node, parent, p);
 	rb_insert_color(&he->rb_node, root);
 }
 static void hists__resort_entries(struct hists *self)
 {
 	unsigned long position = 1;
 	struct rb_root tmp = RB_ROOT;
 	struct rb_node *next = rb_first(&self->entries);
 	while (next != NULL) {
 		struct hist_entry *n = rb_entry(next, struct hist_entry, rb_node);
 		next = rb_next(&n->rb_node);
 		rb_erase(&n->rb_node, &self->entries);
 		n->position = position++;
 		perf_session__insert_hist_entry_by_name(&tmp, n);
 	}
 	self->entries = tmp;
 }
 static void hists__set_positions(struct hists *self)
 {
 	hists__output_resort(self);
 	hists__resort_entries(self);
 }
 static struct hist_entry *hists__find_entry(struct hists *self,
 					    struct hist_entry *he)
 {
 	struct rb_node *n = self->entries.rb_node;
 	while (n) {
 		struct hist_entry *iter = rb_entry(n, struct hist_entry, rb_node);
 		int64_t cmp = hist_entry__cmp(he, iter);
 		if (cmp < 0)
 			n = n->rb_left;
 		else if (cmp > 0)
 			n = n->rb_right;
 		else
 			return iter;
 	}
 	return NULL;
 }
 static void hists__match(struct hists *older, struct hists *newer)
 {
 	struct rb_node *nd;
 	for (nd = rb_first(&newer->entries); nd; nd = rb_next(nd)) {
 		struct hist_entry *pos = rb_entry(nd, struct hist_entry, rb_node);
 		pos->pair = hists__find_entry(older, pos);
 	}
 }
 static int __cmd_diff(void)
 {
 	int ret, i;
 	struct perf_session *session[2];
 	session[0] = perf_session__new(input_old, O_RDONLY, force, false, &event_ops);
 	session[1] = perf_session__new(input_new, O_RDONLY, force, false, &event_ops);
 	if (session[0] == NULL || session[1] == NULL)
 		return -ENOMEM;
 	for (i = 0; i < 2; ++i) {
 		ret = perf_session__process_events(session[i], &event_ops);
 		if (ret)
 			goto out_delete;
 	}
 	hists__output_resort(&session[1]->hists);
 	if (show_displacement)
 		hists__set_positions(&session[0]->hists);
 	hists__match(&session[0]->hists, &session[1]->hists);
 	hists__fprintf(&session[1]->hists, &session[0]->hists,
 		       show_displacement, stdout);
 out_delete:
 	for (i = 0; i < 2; ++i)
 		perf_session__delete(session[i]);
 	return ret;
 }
 static const char * const diff_usage[] = {
 	"perf diff [<options>] [old_file] [new_file]",
 	NULL,
 };
 static const struct option options[] = {
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show symbol address, etc)"),
 	OPT_BOOLEAN('M', "displacement", &show_displacement,
 		    "Show position displacement relative to baseline"),
 	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
 		    "dump raw trace in ASCII"),
 	OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
 	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
 		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
 	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
 		   "only consider symbols in these dsos"),
 	OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
 		   "only consider symbols in these comms"),
 	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
 		   "only consider these symbols"),
 	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
 		   "sort by key(s): pid, comm, dso, symbol, parent"),
 	OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
 		   "separator for columns, no spaces will be added between "
 		   "columns '.' is reserved."),
 	OPT_END()
 };
 int cmd_diff(int argc, const char **argv, const char *prefix __used)
 {
 	sort_order = diff__default_sort_order;
 	argc = parse_options(argc, argv, options, diff_usage, 0);
 	if (argc) {
 		if (argc > 2)
 			usage_with_options(diff_usage, options);
 		if (argc == 2) {
 			input_old = argv[0];
 			input_new = argv[1];
 		} else
 			input_new = argv[0];
 	} else if (symbol_conf.default_guest_vmlinux_name ||
 		   symbol_conf.default_guest_kallsyms) {
 		input_old = "perf.data.host";
 		input_new = "perf.data.guest";
 	}
 	symbol_conf.exclude_other = false;
 	if (symbol__init() < 0)
 		return -1;
 	setup_sorting(diff_usage, options);
 	setup_pager();
 	sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", NULL);
 	sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", NULL);
 	sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", NULL);
 	return __cmd_diff();
 }

tools/perf/builtin-record.c

Diff comments View file @ eac23d1

 /*
  * builtin-record.c
  *
  * Builtin record command: Record the profile of a workload
  * (or a CPU, or a PID) into the perf.data output file - for
  * later analysis via perf report.
  */
 #define _FILE_OFFSET_BITS 64
 #include "builtin.h"
 #include "perf.h"
 #include "util/build-id.h"
 #include "util/util.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/header.h"
 #include "util/event.h"
 #include "util/debug.h"
 #include "util/session.h"
 #include "util/symbol.h"
 #include "util/cpumap.h"
 #include <unistd.h>
 #include <sched.h>
 #include <sys/mman.h>
 enum write_mode_t {
 	WRITE_FORCE,
 	WRITE_APPEND
 };
 static int			*fd[MAX_NR_CPUS][MAX_COUNTERS];
 static u64			user_interval			= ULLONG_MAX;
 static u64			default_interval		=      0;
 static u64			sample_type;
 static int			nr_cpus				=      0;
 static unsigned int		page_size;
 static unsigned int		mmap_pages			=    128;
 static unsigned int		user_freq 			= UINT_MAX;
 static int			freq				=   1000;
 static int			output;
 static int			pipe_output			=      0;
 static const char		*output_name			= "perf.data";
 static int			group				=      0;
 static int			realtime_prio			=      0;
 static bool			raw_samples			=  false;
 static bool			sample_id_all_avail		=   true;
 static bool			system_wide			=  false;
 static pid_t			target_pid			=     -1;
 static pid_t			target_tid			=     -1;
 static pid_t			*all_tids			=      NULL;
 static int			thread_num			=      0;
 static pid_t			child_pid			=     -1;
 static bool			no_inherit			=  false;
 static enum write_mode_t	write_mode			= WRITE_FORCE;
 static bool			call_graph			=  false;
 static bool			inherit_stat			=  false;
 static bool			no_samples			=  false;
 static bool			sample_address			=  false;
 static bool			sample_time			=  false;
 static bool			no_buildid			=  false;
 static bool			no_buildid_cache		=  false;
 static long			samples				=      0;
 static u64			bytes_written			=      0;
 static struct pollfd		*event_array;
 static int			nr_poll				=      0;
 static int			nr_cpu				=      0;
 static int			file_new			=      1;
 static off_t			post_processing_offset;
 static struct perf_session	*session;
 static const char		*cpu_list;
 struct mmap_data {
 	int			counter;
 	void			*base;
 	unsigned int		mask;
 	unsigned int		prev;
 };
 static struct mmap_data		mmap_array[MAX_NR_CPUS];
 static unsigned long mmap_read_head(struct mmap_data *md)
 {
 	struct perf_event_mmap_page *pc = md->base;
 	long head;
 	head = pc->data_head;
 	rmb();
 	return head;
 }
 static void mmap_write_tail(struct mmap_data *md, unsigned long tail)
 {
 	struct perf_event_mmap_page *pc = md->base;
 	/*
 	 * ensure all reads are done before we write the tail out.
 	 */
 	/* mb(); */
 	pc->data_tail = tail;
 }
 static void advance_output(size_t size)
 {
 	bytes_written += size;
 }
 static void write_output(void *buf, size_t size)
 {
 	while (size) {
 		int ret = write(output, buf, size);
 		if (ret < 0)
 			die("failed to write");
 		size -= ret;
 		buf += ret;
 		bytes_written += ret;
 	}
 }
 static int process_synthesized_event(event_t *event,
 				     struct sample_data *sample __used,
 				     struct perf_session *self __used)
 {
 	write_output(event, event->header.size);
 	return 0;
 }
 static void mmap_read(struct mmap_data *md)
 {
 	unsigned int head = mmap_read_head(md);
 	unsigned int old = md->prev;
 	unsigned char *data = md->base + page_size;
 	unsigned long size;
 	void *buf;
 	int diff;
 	/*
 	 * If we're further behind than half the buffer, there's a chance
 	 * the writer will bite our tail and mess up the samples under us.
 	 *
 	 * If we somehow ended up ahead of the head, we got messed up.
 	 *
 	 * In either case, truncate and restart at head.
 	 */
 	diff = head - old;
 	if (diff < 0) {
 		fprintf(stderr, "WARNING: failed to keep up with mmap data\n");
 		/*
 		 * head points to a known good entry, start there.
 		 */
 		old = head;
 	}
 	if (old != head)
 		samples++;
 	size = head - old;
 	if ((old & md->mask) + size != (head & md->mask)) {
 		buf = &data[old & md->mask];
 		size = md->mask + 1 - (old & md->mask);
 		old += size;
 		write_output(buf, size);
 	}
 	buf = &data[old & md->mask];
 	size = head - old;
 	old += size;
 	write_output(buf, size);
 	md->prev = old;
 	mmap_write_tail(md, old);
 }
 static volatile int done = 0;
 static volatile int signr = -1;
 static void sig_handler(int sig)
 {
 	done = 1;
 	signr = sig;
 }
 static void sig_atexit(void)
 {
 	if (child_pid > 0)
 		kill(child_pid, SIGTERM);
 	if (signr == -1 || signr == SIGUSR1)
 		return;
 	signal(signr, SIG_DFL);
 	kill(getpid(), signr);
 }
 static int group_fd;
 static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int nr)
 {
 	struct perf_header_attr *h_attr;
 	if (nr < session->header.attrs) {
 		h_attr = session->header.attr[nr];
 	} else {
 		h_attr = perf_header_attr__new(a);
 		if (h_attr != NULL)
 			if (perf_header__add_attr(&session->header, h_attr) < 0) {
 				perf_header_attr__delete(h_attr);
 				h_attr = NULL;
 			}
 	}
 	return h_attr;
 }
 static void create_counter(int counter, int cpu)
 {
 	char *filter = filters[counter];
 	struct perf_event_attr *attr = attrs + counter;
 	struct perf_header_attr *h_attr;
 	int track = !counter; /* only the first counter needs these */
 	int thread_index;
 	int ret;
 	struct {
 		u64 count;
 		u64 time_enabled;
 		u64 time_running;
 		u64 id;
 	} read_data;
 	attr->read_format	= PERF_FORMAT_TOTAL_TIME_ENABLED |
 				  PERF_FORMAT_TOTAL_TIME_RUNNING |
 				  PERF_FORMAT_ID;
 	attr->sample_type	|= PERF_SAMPLE_IP | PERF_SAMPLE_TID;
 	if (nr_counters > 1)
 		attr->sample_type |= PERF_SAMPLE_ID;
 	/*
 	 * We default some events to a 1 default interval. But keep
 	 * it a weak assumption overridable by the user.
 	 */
 	if (!attr->sample_period || (user_freq != UINT_MAX &&
 				     user_interval != ULLONG_MAX)) {
 		if (freq) {
 			attr->sample_type	|= PERF_SAMPLE_PERIOD;
 			attr->freq		= 1;
 			attr->sample_freq	= freq;
 		} else {
 			attr->sample_period = default_interval;
 		}
 	}
 	if (no_samples)
 		attr->sample_freq = 0;
 	if (inherit_stat)
 		attr->inherit_stat = 1;
 	if (sample_address) {
 		attr->sample_type	|= PERF_SAMPLE_ADDR;
 		attr->mmap_data = track;
 	}
 	if (call_graph)
 		attr->sample_type	|= PERF_SAMPLE_CALLCHAIN;
 	if (system_wide)
 		attr->sample_type	|= PERF_SAMPLE_CPU;
-	if (sample_time)
+	if (sample_time || system_wide || !no_inherit || cpu_list)
 		attr->sample_type	|= PERF_SAMPLE_TIME;
 	if (raw_samples) {
 		attr->sample_type	|= PERF_SAMPLE_TIME;
 		attr->sample_type	|= PERF_SAMPLE_RAW;
 		attr->sample_type	|= PERF_SAMPLE_CPU;
 	}
 	if (!sample_type)
 		sample_type = attr->sample_type;
 	attr->mmap		= track;
 	attr->comm		= track;
 	attr->inherit		= !no_inherit;
 	if (target_pid == -1 && target_tid == -1 && !system_wide) {
 		attr->disabled = 1;
 		attr->enable_on_exec = 1;
 	}
 retry_sample_id:
 	attr->sample_id_all = sample_id_all_avail ? 1 : 0;
 	for (thread_index = 0; thread_index < thread_num; thread_index++) {
 try_again:
 		fd[nr_cpu][counter][thread_index] = sys_perf_event_open(attr,
 				all_tids[thread_index], cpu, group_fd, 0);
 		if (fd[nr_cpu][counter][thread_index] < 0) {
 			int err = errno;
 			if (err == EPERM || err == EACCES)
 				die("Permission error - are you root?\n"
 					"\t Consider tweaking"
 					" /proc/sys/kernel/perf_event_paranoid.\n");
 			else if (err ==  ENODEV && cpu_list) {
 				die("No such device - did you specify"
 					" an out-of-range profile CPU?\n");
 			} else if (err == EINVAL && sample_id_all_avail) {
 				/*
 				 * Old kernel, no attr->sample_id_type_all field
 				 */
 				sample_id_all_avail = false;
+				if (!sample_time && !raw_samples)
+					attr->sample_type &= ~PERF_SAMPLE_TIME;
 				goto retry_sample_id;
 			}
 			/*
 			 * If it's cycles then fall back to hrtimer
 			 * based cpu-clock-tick sw counter, which
 			 * is always available even if no PMU support:
 			 */
 			if (attr->type == PERF_TYPE_HARDWARE
 					&& attr->config == PERF_COUNT_HW_CPU_CYCLES) {
 				if (verbose)
 					warning(" ... trying to fall back to cpu-clock-ticks\n");
 				attr->type = PERF_TYPE_SOFTWARE;
 				attr->config = PERF_COUNT_SW_CPU_CLOCK;
 				goto try_again;
 			}
 			printf("\n");
 			error("sys_perf_event_open() syscall returned with %d (%s).  /bin/dmesg may provide additional information.\n",
 					fd[nr_cpu][counter][thread_index], strerror(err));
 #if defined(__i386__) || defined(__x86_64__)
 			if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
 				die("No hardware sampling interrupt available."
 				    " No APIC? If so then you can boot the kernel"
 				    " with the \"lapic\" boot parameter to"
 				    " force-enable it.\n");
 #endif
 			die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
 			exit(-1);
 		}
 		h_attr = get_header_attr(attr, counter);
 		if (h_attr == NULL)
 			die("nomem\n");
 		if (!file_new) {
 			if (memcmp(&h_attr->attr, attr, sizeof(*attr))) {
 				fprintf(stderr, "incompatible append\n");
 				exit(-1);
 			}
 		}
 		if (read(fd[nr_cpu][counter][thread_index], &read_data, sizeof(read_data)) == -1) {
 			perror("Unable to read perf file descriptor");
 			exit(-1);
 		}
 		if (perf_header_attr__add_id(h_attr, read_data.id) < 0) {
 			pr_warning("Not enough memory to add id\n");
 			exit(-1);
 		}
 		assert(fd[nr_cpu][counter][thread_index] >= 0);
 		fcntl(fd[nr_cpu][counter][thread_index], F_SETFL, O_NONBLOCK);
 		/*
 		 * First counter acts as the group leader:
 		 */
 		if (group && group_fd == -1)
 			group_fd = fd[nr_cpu][counter][thread_index];
 		if (counter || thread_index) {
 			ret = ioctl(fd[nr_cpu][counter][thread_index],
 					PERF_EVENT_IOC_SET_OUTPUT,
 					fd[nr_cpu][0][0]);
 			if (ret) {
 				error("failed to set output: %d (%s)\n", errno,
 						strerror(errno));
 				exit(-1);
 			}
 		} else {
 			mmap_array[nr_cpu].counter = counter;
 			mmap_array[nr_cpu].prev = 0;
 			mmap_array[nr_cpu].mask = mmap_pages*page_size - 1;
 			mmap_array[nr_cpu].base = mmap(NULL, (mmap_pages+1)*page_size,
 				PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter][thread_index], 0);
 			if (mmap_array[nr_cpu].base == MAP_FAILED) {
 				error("failed to mmap with %d (%s)\n", errno, strerror(errno));
 				exit(-1);
 			}
 			event_array[nr_poll].fd = fd[nr_cpu][counter][thread_index];
 			event_array[nr_poll].events = POLLIN;
 			nr_poll++;
 		}
 		if (filter != NULL) {
 			ret = ioctl(fd[nr_cpu][counter][thread_index],
 					PERF_EVENT_IOC_SET_FILTER, filter);
 			if (ret) {
 				error("failed to set filter with %d (%s)\n", errno,
 						strerror(errno));
 				exit(-1);
 			}
 		}
 	}
 }
 static void open_counters(int cpu)
 {
 	int counter;
 	group_fd = -1;
 	for (counter = 0; counter < nr_counters; counter++)
 		create_counter(counter, cpu);
 	nr_cpu++;
 }
 static int process_buildids(void)
 {
 	u64 size = lseek(output, 0, SEEK_CUR);
 	if (size == 0)
 		return 0;
 	session->fd = output;
 	return __perf_session__process_events(session, post_processing_offset,
 					      size - post_processing_offset,
 					      size, &build_id__mark_dso_hit_ops);
 }
 static void atexit_header(void)
 {
 	if (!pipe_output) {
 		session->header.data_size += bytes_written;
 		if (!no_buildid)
 			process_buildids();
 		perf_header__write(&session->header, output, true);
 		perf_session__delete(session);
 		symbol__exit();
 	}
 }
 static void event__synthesize_guest_os(struct machine *machine, void *data)
 {
 	int err;
 	struct perf_session *psession = data;
 	if (machine__is_host(machine))
 		return;
 	/*
 	 *As for guest kernel when processing subcommand record&report,
 	 *we arrange module mmap prior to guest kernel mmap and trigger
 	 *a preload dso because default guest module symbols are loaded
 	 *from guest kallsyms instead of /lib/modules/XXX/XXX. This
 	 *method is used to avoid symbol missing when the first addr is
 	 *in module instead of in guest kernel.
 	 */
 	err = event__synthesize_modules(process_synthesized_event,
 					psession, machine);
 	if (err < 0)
 		pr_err("Couldn't record guest kernel [%d]'s reference"
 		       " relocation symbol.\n", machine->pid);
 	/*
 	 * We use _stext for guest kernel because guest kernel's /proc/kallsyms
 	 * have no _text sometimes.
 	 */
 	err = event__synthesize_kernel_mmap(process_synthesized_event,
 					    psession, machine, "_text");
 	if (err < 0)
 		err = event__synthesize_kernel_mmap(process_synthesized_event,
 						    psession, machine, "_stext");
 	if (err < 0)
 		pr_err("Couldn't record guest kernel [%d]'s reference"
 		       " relocation symbol.\n", machine->pid);
 }
 static struct perf_event_header finished_round_event = {
 	.size = sizeof(struct perf_event_header),
 	.type = PERF_RECORD_FINISHED_ROUND,
 };
 static void mmap_read_all(void)
 {
 	int i;
 	for (i = 0; i < nr_cpu; i++) {
 		if (mmap_array[i].base)
 			mmap_read(&mmap_array[i]);
 	}
 	if (perf_header__has_feat(&session->header, HEADER_TRACE_INFO))
 		write_output(&finished_round_event, sizeof(finished_round_event));
 }
 static int __cmd_record(int argc, const char **argv)
 {
 	int i, counter;
 	struct stat st;
 	int flags;
 	int err;
 	unsigned long waking = 0;
 	int child_ready_pipe[2], go_pipe[2];
 	const bool forks = argc > 0;
 	char buf;
 	struct machine *machine;
 	page_size = sysconf(_SC_PAGE_SIZE);
 	atexit(sig_atexit);
 	signal(SIGCHLD, sig_handler);
 	signal(SIGINT, sig_handler);
 	signal(SIGUSR1, sig_handler);
 	if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
 		perror("failed to create pipes");
 		exit(-1);
 	}
 	if (!strcmp(output_name, "-"))
 		pipe_output = 1;
 	else if (!stat(output_name, &st) && st.st_size) {
 		if (write_mode == WRITE_FORCE) {
 			char oldname[PATH_MAX];
 			snprintf(oldname, sizeof(oldname), "%s.old",
 				 output_name);
 			unlink(oldname);
 			rename(output_name, oldname);
 		}
 	} else if (write_mode == WRITE_APPEND) {
 		write_mode = WRITE_FORCE;
 	}
 	flags = O_CREAT|O_RDWR;
 	if (write_mode == WRITE_APPEND)
 		file_new = 0;
 	else
 		flags |= O_TRUNC;
 	if (pipe_output)
 		output = STDOUT_FILENO;
 	else
 		output = open(output_name, flags, S_IRUSR | S_IWUSR);
 	if (output < 0) {
 		perror("failed to create output file");
 		exit(-1);
 	}
 	session = perf_session__new(output_name, O_WRONLY,
 				    write_mode == WRITE_FORCE, false, NULL);
 	if (session == NULL) {
 		pr_err("Not enough memory for reading perf file header\n");
 		return -1;
 	}
 	if (!no_buildid)
 		perf_header__set_feat(&session->header, HEADER_BUILD_ID);
 	if (!file_new) {
 		err = perf_header__read(session, output);
 		if (err < 0)
 			goto out_delete_session;
 	}
 	if (have_tracepoints(attrs, nr_counters))
 		perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
 	/*
  	 * perf_session__delete(session) will be called at atexit_header()
 	 */
 	atexit(atexit_header);
 	if (forks) {
 		child_pid = fork();
 		if (child_pid < 0) {
 			perror("failed to fork");
 			exit(-1);
 		}
 		if (!child_pid) {
 			if (pipe_output)
 				dup2(2, 1);
 			close(child_ready_pipe[0]);
 			close(go_pipe[1]);
 			fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC);
 			/*
 			 * Do a dummy execvp to get the PLT entry resolved,
 			 * so we avoid the resolver overhead on the real
 			 * execvp call.
 			 */
 			execvp("", (char **)argv);
 			/*
 			 * Tell the parent we're ready to go
 			 */
 			close(child_ready_pipe[1]);
 			/*
 			 * Wait until the parent tells us to go.
 			 */
 			if (read(go_pipe[0], &buf, 1) == -1)
 				perror("unable to read pipe");
 			execvp(argv[0], (char **)argv);
 			perror(argv[0]);
 			kill(getppid(), SIGUSR1);
 			exit(-1);
 		}
 		if (!system_wide && target_tid == -1 && target_pid == -1)
 			all_tids[0] = child_pid;
 		close(child_ready_pipe[1]);
 		close(go_pipe[0]);
 		/*
 		 * wait for child to settle
 		 */
 		if (read(child_ready_pipe[0], &buf, 1) == -1) {
 			perror("unable to read pipe");
 			exit(-1);
 		}
 		close(child_ready_pipe[0]);
 	}
 	nr_cpus = read_cpu_map(cpu_list);
 	if (nr_cpus < 1) {
 		perror("failed to collect number of CPUs");
 		return -1;
 	}
 	if (!system_wide && no_inherit && !cpu_list) {
 		open_counters(-1);
 	} else {
 		for (i = 0; i < nr_cpus; i++)
 			open_counters(cpumap[i]);
 	}
 	perf_session__set_sample_type(session, sample_type);
 	if (pipe_output) {
 		err = perf_header__write_pipe(output);
 		if (err < 0)
 			return err;
 	} else if (file_new) {
 		err = perf_header__write(&session->header, output, false);
 		if (err < 0)
 			return err;
 	}
 	post_processing_offset = lseek(output, 0, SEEK_CUR);
 	perf_session__set_sample_id_all(session, sample_id_all_avail);
 	if (pipe_output) {
 		err = event__synthesize_attrs(&session->header,
 					      process_synthesized_event,
 					      session);
 		if (err < 0) {
 			pr_err("Couldn't synthesize attrs.\n");
 			return err;
 		}
 		err = event__synthesize_event_types(process_synthesized_event,
 						    session);
 		if (err < 0) {
 			pr_err("Couldn't synthesize event_types.\n");
 			return err;
 		}
 		if (have_tracepoints(attrs, nr_counters)) {
 			/*
 			 * FIXME err <= 0 here actually means that
 			 * there were no tracepoints so its not really
 			 * an error, just that we don't need to
 			 * synthesize anything.  We really have to
 			 * return this more properly and also
 			 * propagate errors that now are calling die()
 			 */
 			err = event__synthesize_tracing_data(output, attrs,
 							     nr_counters,
 							     process_synthesized_event,
 							     session);
 			if (err <= 0) {
 				pr_err("Couldn't record tracing data.\n");
 				return err;
 			}
 			advance_output(err);
 		}
 	}
 	machine = perf_session__find_host_machine(session);
 	if (!machine) {
 		pr_err("Couldn't find native kernel information.\n");
 		return -1;
 	}
 	err = event__synthesize_kernel_mmap(process_synthesized_event,
 					    session, machine, "_text");
 	if (err < 0)
 		err = event__synthesize_kernel_mmap(process_synthesized_event,
 						    session, machine, "_stext");
 	if (err < 0)
 		pr_err("Couldn't record kernel reference relocation symbol\n"
 		       "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 		       "Check /proc/kallsyms permission or run as root.\n");
 	err = event__synthesize_modules(process_synthesized_event,
 					session, machine);
 	if (err < 0)
 		pr_err("Couldn't record kernel module information.\n"
 		       "Symbol resolution may be skewed if relocation was used (e.g. kexec).\n"
 		       "Check /proc/modules permission or run as root.\n");
 	if (perf_guest)
 		perf_session__process_machines(session, event__synthesize_guest_os);
 	if (!system_wide)
 		event__synthesize_thread(target_tid, process_synthesized_event,
 					 session);
 	else
 		event__synthesize_threads(process_synthesized_event, session);
 	if (realtime_prio) {
 		struct sched_param param;
 		param.sched_priority = realtime_prio;
 		if (sched_setscheduler(0, SCHED_FIFO, &param)) {
 			pr_err("Could not set realtime priority.\n");
 			exit(-1);
 		}
 	}
 	/*
 	 * Let the child rip
 	 */
 	if (forks)
 		close(go_pipe[1]);
 	for (;;) {
 		int hits = samples;
 		int thread;
 		mmap_read_all();
 		if (hits == samples) {
 			if (done)
 				break;
 			err = poll(event_array, nr_poll, -1);
 			waking++;
 		}
 		if (done) {
 			for (i = 0; i < nr_cpu; i++) {
 				for (counter = 0;
 					counter < nr_counters;
 					counter++) {
 					for (thread = 0;
 						thread < thread_num;
 						thread++)
 						ioctl(fd[i][counter][thread],
 							PERF_EVENT_IOC_DISABLE);
 				}
 			}
 		}
 	}
 	if (quiet || signr == SIGUSR1)
 		return 0;
 	fprintf(stderr, "[ perf record: Woken up %ld times to write data ]\n", waking);
 	/*
 	 * Approximate RIP event size: 24 bytes.
 	 */
 	fprintf(stderr,
 		"[ perf record: Captured and wrote %.3f MB %s (~%lld samples) ]\n",
 		(double)bytes_written / 1024.0 / 1024.0,
 		output_name,
 		bytes_written / 24);
 	return 0;
 out_delete_session:
 	perf_session__delete(session);
 	return err;
 }
 static const char * const record_usage[] = {
 	"perf record [<options>] [<command>]",
 	"perf record [<options>] -- <command> [<options>]",
 	NULL
 };
 static bool force, append_file;
 const struct option record_options[] = {
 	OPT_CALLBACK('e', "event", NULL, "event",
 		     "event selector. use 'perf list' to list available events",
 		     parse_events),
 	OPT_CALLBACK(0, "filter", NULL, "filter",
 		     "event filter", parse_filter),
 	OPT_INTEGER('p', "pid", &target_pid,
 		    "record events on existing process id"),
 	OPT_INTEGER('t', "tid", &target_tid,
 		    "record events on existing thread id"),
 	OPT_INTEGER('r', "realtime", &realtime_prio,
 		    "collect data with this RT SCHED_FIFO priority"),
 	OPT_BOOLEAN('R', "raw-samples", &raw_samples,
 		    "collect raw sample records from all opened counters"),
 	OPT_BOOLEAN('a', "all-cpus", &system_wide,
 			    "system-wide collection from all CPUs"),
 	OPT_BOOLEAN('A', "append", &append_file,
 			    "append to the output file to do incremental profiling"),
 	OPT_STRING('C', "cpu", &cpu_list, "cpu",
 		    "list of cpus to monitor"),
 	OPT_BOOLEAN('f', "force", &force,
 			"overwrite existing data file (deprecated)"),
 	OPT_U64('c', "count", &user_interval, "event period to sample"),
 	OPT_STRING('o', "output", &output_name, "file",
 		    "output file name"),
 	OPT_BOOLEAN('i', "no-inherit", &no_inherit,
 		    "child tasks do not inherit counters"),
 	OPT_UINTEGER('F', "freq", &user_freq, "profile at this frequency"),
 	OPT_UINTEGER('m', "mmap-pages", &mmap_pages, "number of mmap data pages"),
 	OPT_BOOLEAN('g', "call-graph", &call_graph,
 		    "do call-graph (stack chain/backtrace) recording"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show counter open errors, etc)"),
 	OPT_BOOLEAN('q', "quiet", &quiet, "don't print any message"),
 	OPT_BOOLEAN('s', "stat", &inherit_stat,
 		    "per thread counts"),
 	OPT_BOOLEAN('d', "data", &sample_address,
 		    "Sample addresses"),
 	OPT_BOOLEAN('T', "timestamp", &sample_time, "Sample timestamps"),
 	OPT_BOOLEAN('n', "no-samples", &no_samples,
 		    "don't sample"),
 	OPT_BOOLEAN('N', "no-buildid-cache", &no_buildid_cache,
 		    "do not update the buildid cache"),
 	OPT_BOOLEAN('B', "no-buildid", &no_buildid,
 		    "do not collect buildids in perf.data"),
 	OPT_END()
 };
 int cmd_record(int argc, const char **argv, const char *prefix __used)
 {
 	int i, j, err = -ENOMEM;
 	argc = parse_options(argc, argv, record_options, record_usage,
 			    PARSE_OPT_STOP_AT_NON_OPTION);
 	if (!argc && target_pid == -1 && target_tid == -1 &&
 		!system_wide && !cpu_list)
 		usage_with_options(record_usage, record_options);
 	if (force && append_file) {
 		fprintf(stderr, "Can't overwrite and append at the same time."
 				" You need to choose between -f and -A");
 		usage_with_options(record_usage, record_options);
 	} else if (append_file) {
 		write_mode = WRITE_APPEND;
 	} else {
 		write_mode = WRITE_FORCE;
 	}
 	symbol__init();
 	if (no_buildid_cache || no_buildid)
 		disable_buildid_cache();
 	if (!nr_counters) {
 		nr_counters	= 1;
 		attrs[0].type	= PERF_TYPE_HARDWARE;
 		attrs[0].config = PERF_COUNT_HW_CPU_CYCLES;
 	}
 	if (target_pid != -1) {
 		target_tid = target_pid;
 		thread_num = find_all_tid(target_pid, &all_tids);
 		if (thread_num <= 0) {
 			fprintf(stderr, "Can't find all threads of pid %d\n",
 					target_pid);
 			usage_with_options(record_usage, record_options);
 		}
 	} else {
 		all_tids=malloc(sizeof(pid_t));
 		if (!all_tids)
 			goto out_symbol_exit;
 		all_tids[0] = target_tid;
 		thread_num = 1;
 	}
 	for (i = 0; i < MAX_NR_CPUS; i++) {
 		for (j = 0; j < MAX_COUNTERS; j++) {
 			fd[i][j] = malloc(sizeof(int)*thread_num);
 			if (!fd[i][j])
 				goto out_free_fd;
 		}
 	}
 	event_array = malloc(
 		sizeof(struct pollfd)*MAX_NR_CPUS*MAX_COUNTERS*thread_num);
 	if (!event_array)
 		goto out_free_fd;
 	if (user_interval != ULLONG_MAX)
 		default_interval = user_interval;
 	if (user_freq != UINT_MAX)
 		freq = user_freq;
 	/*
 	 * User specified count overrides default frequency.
 	 */
 	if (default_interval)
 		freq = 0;
 	else if (freq) {
 		default_interval = freq;
 	} else {
 		fprintf(stderr, "frequency and count are zero, aborting\n");
 		err = -EINVAL;
 		goto out_free_event_array;
 	}
 	err = __cmd_record(argc, argv);
 out_free_event_array:
 	free(event_array);
 out_free_fd:
 	for (i = 0; i < MAX_NR_CPUS; i++) {
 		for (j = 0; j < MAX_COUNTERS; j++)
 			free(fd[i][j]);
 	}
 	free(all_tids);
 	all_tids = NULL;
 out_symbol_exit:
 	symbol__exit();
 	return err;
 }

tools/perf/builtin-report.c

Diff comments View file @ eac23d1

 /*
  * builtin-report.c
  *
  * Builtin report command: Analyze the perf.data input file,
  * look up and read DSOs and symbol information and display
  * a histogram of results, along various sorting keys.
  */
 #include "builtin.h"
 #include "util/util.h"
 #include "util/color.h"
 #include <linux/list.h>
 #include "util/cache.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
 #include "util/callchain.h"
 #include "util/strlist.h"
 #include "util/values.h"
 #include "perf.h"
 #include "util/debug.h"
 #include "util/header.h"
 #include "util/session.h"
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/thread.h"
 #include "util/sort.h"
 #include "util/hist.h"
 static char		const *input_name = "perf.data";
 static bool		force, use_tui, use_stdio;
 static bool		hide_unresolved;
 static bool		dont_use_callchains;
 static bool		show_threads;
 static struct perf_read_values	show_threads_values;
 static const char	default_pretty_printing_style[] = "normal";
 static const char	*pretty_printing_style = default_pretty_printing_style;
 static char		callchain_default_opt[] = "fractal,0.5";
 static struct hists *perf_session__hists_findnew(struct perf_session *self,
 						 u64 event_stream, u32 type,
 						 u64 config)
 {
 	struct rb_node **p = &self->hists_tree.rb_node;
 	struct rb_node *parent = NULL;
 	struct hists *iter, *new;
 	while (*p != NULL) {
 		parent = *p;
 		iter = rb_entry(parent, struct hists, rb_node);
 		if (iter->config == config)
 			return iter;
 		if (config > iter->config)
 			p = &(*p)->rb_right;
 		else
 			p = &(*p)->rb_left;
 	}
 	new = malloc(sizeof(struct hists));
 	if (new == NULL)
 		return NULL;
 	memset(new, 0, sizeof(struct hists));
 	new->event_stream = event_stream;
 	new->config = config;
 	new->type = type;
 	rb_link_node(&new->rb_node, parent, p);
 	rb_insert_color(&new->rb_node, &self->hists_tree);
 	return new;
 }
 static int perf_session__add_hist_entry(struct perf_session *self,
 					struct addr_location *al,
 					struct sample_data *data)
 {
 	struct map_symbol *syms = NULL;
 	struct symbol *parent = NULL;
 	int err = -ENOMEM;
 	struct hist_entry *he;
 	struct hists *hists;
 	struct perf_event_attr *attr;
 	if ((sort__has_parent || symbol_conf.use_callchain) && data->callchain) {
 		syms = perf_session__resolve_callchain(self, al->thread,
 						       data->callchain, &parent);
 		if (syms == NULL)
 			return -ENOMEM;
 	}
 	attr = perf_header__find_attr(data->id, &self->header);
 	if (attr)
 		hists = perf_session__hists_findnew(self, data->id, attr->type, attr->config);
 	else
 		hists = perf_session__hists_findnew(self, data->id, 0, 0);
 	if (hists == NULL)
 		goto out_free_syms;
 	he = __hists__add_entry(hists, al, parent, data->period);
 	if (he == NULL)
 		goto out_free_syms;
 	err = 0;
 	if (symbol_conf.use_callchain) {
 		err = callchain_append(he->callchain, data->callchain, syms,
 				       data->period);
 		if (err)
 			goto out_free_syms;
 	}
 	/*
 	 * Only in the newt browser we are doing integrated annotation,
 	 * so we don't allocated the extra space needed because the stdio
 	 * code will not use it.
 	 */
 	if (use_browser > 0)
 		err = hist_entry__inc_addr_samples(he, al->addr);
 out_free_syms:
 	free(syms);
 	return err;
 }
 static int add_event_total(struct perf_session *session,
 			   struct sample_data *data,
 			   struct perf_event_attr *attr)
 {
 	struct hists *hists;
 	if (attr)
 		hists = perf_session__hists_findnew(session, data->id,
 						    attr->type, attr->config);
 	else
 		hists = perf_session__hists_findnew(session, data->id, 0, 0);
 	if (!hists)
 		return -ENOMEM;
 	hists->stats.total_period += data->period;
 	/*
 	 * FIXME: add_event_total should be moved from here to
 	 * perf_session__process_event so that the proper hist is passed to
 	 * the event_op methods.
 	 */
 	hists__inc_nr_events(hists, PERF_RECORD_SAMPLE);
 	session->hists.stats.total_period += data->period;
 	return 0;
 }
 static int process_sample_event(event_t *event, struct sample_data *sample,
 				struct perf_session *session)
 {
 	struct addr_location al;
 	struct perf_event_attr *attr;
 	if (event__preprocess_sample(event, session, &al, sample, NULL) < 0) {
 		fprintf(stderr, "problem processing %d event, skipping it.\n",
 			event->header.type);
 		return -1;
 	}
 	if (al.filtered || (hide_unresolved && al.sym == NULL))
 		return 0;
 	if (perf_session__add_hist_entry(session, &al, sample)) {
 		pr_debug("problem incrementing symbol period, skipping event\n");
 		return -1;
 	}
 	attr = perf_header__find_attr(sample->id, &session->header);
 	if (add_event_total(session, sample, attr)) {
 		pr_debug("problem adding event period\n");
 		return -1;
 	}
 	return 0;
 }
 static int process_read_event(event_t *event, struct sample_data *sample __used,
 			      struct perf_session *session __used)
 {
 	struct perf_event_attr *attr;
 	attr = perf_header__find_attr(event->read.id, &session->header);
 	if (show_threads) {
 		const char *name = attr ? __event_name(attr->type, attr->config)
 				   : "unknown";
 		perf_read_values_add_value(&show_threads_values,
 					   event->read.pid, event->read.tid,
 					   event->read.id,
 					   name,
 					   event->read.value);
 	}
 	dump_printf(": %d %d %s %Lu\n", event->read.pid, event->read.tid,
 		    attr ? __event_name(attr->type, attr->config) : "FAIL",
 		    event->read.value);
 	return 0;
 }
 static int perf_session__setup_sample_type(struct perf_session *self)
 {
 	if (!(self->sample_type & PERF_SAMPLE_CALLCHAIN)) {
 		if (sort__has_parent) {
 			fprintf(stderr, "selected --sort parent, but no"
 					" callchain data. Did you call"
 					" perf record without -g?\n");
 			return -EINVAL;
 		}
 		if (symbol_conf.use_callchain) {
 			fprintf(stderr, "selected -g but no callchain data."
 					" Did you call perf record without"
 					" -g?\n");
 			return -1;
 		}
 	} else if (!dont_use_callchains && callchain_param.mode != CHAIN_NONE &&
 		   !symbol_conf.use_callchain) {
 			symbol_conf.use_callchain = true;
 			if (register_callchain_param(&callchain_param) < 0) {
 				fprintf(stderr, "Can't register callchain"
 						" params\n");
 				return -EINVAL;
 			}
 	}
 	return 0;
 }
 static struct perf_event_ops event_ops = {
 	.sample	= process_sample_event,
 	.mmap	= event__process_mmap,
 	.comm	= event__process_comm,
 	.exit	= event__process_task,
 	.fork	= event__process_task,
 	.lost	= event__process_lost,
 	.read	= process_read_event,
 	.attr	= event__process_attr,
 	.event_type = event__process_event_type,
 	.tracing_data = event__process_tracing_data,
 	.build_id = event__process_build_id,
+	.ordered_samples = true,
+	.ordering_requires_timestamps = true,
 };
 extern volatile int session_done;
 static void sig_handler(int sig __used)
 {
 	session_done = 1;
 }
 static size_t hists__fprintf_nr_sample_events(struct hists *self,
 					      const char *evname, FILE *fp)
 {
 	size_t ret;
 	char unit;
 	unsigned long nr_events = self->stats.nr_events[PERF_RECORD_SAMPLE];
 	nr_events = convert_unit(nr_events, &unit);
 	ret = fprintf(fp, "# Events: %lu%c", nr_events, unit);
 	if (evname != NULL)
 		ret += fprintf(fp, " %s", evname);
 	return ret + fprintf(fp, "\n#\n");
 }
 static int hists__tty_browse_tree(struct rb_root *tree, const char *help)
 {
 	struct rb_node *next = rb_first(tree);
 	while (next) {
 		struct hists *hists = rb_entry(next, struct hists, rb_node);
 		const char *evname = NULL;
 		if (rb_first(&hists->entries) != rb_last(&hists->entries))
 			evname = __event_name(hists->type, hists->config);
 		hists__fprintf_nr_sample_events(hists, evname, stdout);
 		hists__fprintf(hists, NULL, false, stdout);
 		fprintf(stdout, "\n\n");
 		next = rb_next(&hists->rb_node);
 	}
 	if (sort_order == default_sort_order &&
 	    parent_pattern == default_parent_pattern) {
 		fprintf(stdout, "#\n# (%s)\n#\n", help);
 		if (show_threads) {
 			bool style = !strcmp(pretty_printing_style, "raw");
 			perf_read_values_display(stdout, &show_threads_values,
 						 style);
 			perf_read_values_destroy(&show_threads_values);
 		}
 	}
 	return 0;
 }
 static int __cmd_report(void)
 {
 	int ret = -EINVAL;
 	struct perf_session *session;
 	struct rb_node *next;
 	const char *help = "For a higher level overview, try: perf report --sort comm,dso";
 	signal(SIGINT, sig_handler);
 	session = perf_session__new(input_name, O_RDONLY, force, false, &event_ops);
 	if (session == NULL)
 		return -ENOMEM;
 	if (show_threads)
 		perf_read_values_init(&show_threads_values);
 	ret = perf_session__setup_sample_type(session);
 	if (ret)
 		goto out_delete;
 	ret = perf_session__process_events(session, &event_ops);
 	if (ret)
 		goto out_delete;
 	if (dump_trace) {
 		perf_session__fprintf_nr_events(session, stdout);
 		goto out_delete;
 	}
 	if (verbose > 3)
 		perf_session__fprintf(session, stdout);
 	if (verbose > 2)
 		perf_session__fprintf_dsos(session, stdout);
 	next = rb_first(&session->hists_tree);
 	while (next) {
 		struct hists *hists;
 		hists = rb_entry(next, struct hists, rb_node);
 		hists__collapse_resort(hists);
 		hists__output_resort(hists);
 		next = rb_next(&hists->rb_node);
 	}
 	if (use_browser > 0)
 		hists__tui_browse_tree(&session->hists_tree, help);
 	else
 		hists__tty_browse_tree(&session->hists_tree, help);
 out_delete:
 	/*
 	 * Speed up the exit process, for large files this can
 	 * take quite a while.
 	 *
 	 * XXX Enable this when using valgrind or if we ever
 	 * librarize this command.
 	 *
 	 * Also experiment with obstacks to see how much speed
 	 * up we'll get here.
 	 *
  	 * perf_session__delete(session);
  	 */
 	return ret;
 }
 static int
 parse_callchain_opt(const struct option *opt __used, const char *arg,
 		    int unset)
 {
 	char *tok, *tok2;
 	char *endptr;
 	/*
 	 * --no-call-graph
 	 */
 	if (unset) {
 		dont_use_callchains = true;
 		return 0;
 	}
 	symbol_conf.use_callchain = true;
 	if (!arg)
 		return 0;
 	tok = strtok((char *)arg, ",");
 	if (!tok)
 		return -1;
 	/* get the output mode */
 	if (!strncmp(tok, "graph", strlen(arg)))
 		callchain_param.mode = CHAIN_GRAPH_ABS;
 	else if (!strncmp(tok, "flat", strlen(arg)))
 		callchain_param.mode = CHAIN_FLAT;
 	else if (!strncmp(tok, "fractal", strlen(arg)))
 		callchain_param.mode = CHAIN_GRAPH_REL;
 	else if (!strncmp(tok, "none", strlen(arg))) {
 		callchain_param.mode = CHAIN_NONE;
 		symbol_conf.use_callchain = false;
 		return 0;
 	}
 	else
 		return -1;
 	/* get the min percentage */
 	tok = strtok(NULL, ",");
 	if (!tok)
 		goto setup;
 	tok2 = strtok(NULL, ",");
 	callchain_param.min_percent = strtod(tok, &endptr);
 	if (tok == endptr)
 		return -1;
 	if (tok2)
 		callchain_param.print_limit = strtod(tok2, &endptr);
 setup:
 	if (register_callchain_param(&callchain_param) < 0) {
 		fprintf(stderr, "Can't register callchain params\n");
 		return -1;
 	}
 	return 0;
 }
 static const char * const report_usage[] = {
 	"perf report [<options>] <command>",
 	NULL
 };
 static const struct option options[] = {
 	OPT_STRING('i', "input", &input_name, "file",
 		    "input file name"),
 	OPT_INCR('v', "verbose", &verbose,
 		    "be more verbose (show symbol address, etc)"),
 	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
 		    "dump raw trace in ASCII"),
 	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
 		   "file", "vmlinux pathname"),
 	OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
 		   "file", "kallsyms pathname"),
 	OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
 	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
 		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
 	OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
 		    "Show a column with the number of samples"),
 	OPT_BOOLEAN('T', "threads", &show_threads,
 		    "Show per-thread event counters"),
 	OPT_STRING(0, "pretty", &pretty_printing_style, "key",
 		   "pretty printing style key: normal raw"),
 	OPT_BOOLEAN(0, "tui", &use_tui, "Use the TUI interface"),
 	OPT_BOOLEAN(0, "stdio", &use_stdio, "Use the stdio interface"),
 	OPT_STRING('s', "sort", &sort_order, "key[,key2...]",
 		   "sort by key(s): pid, comm, dso, symbol, parent"),
 	OPT_BOOLEAN(0, "showcpuutilization", &symbol_conf.show_cpu_utilization,
 		    "Show sample percentage for different cpu modes"),
 	OPT_STRING('p', "parent", &parent_pattern, "regex",
 		   "regex filter to identify parent, see: '--sort parent'"),
 	OPT_BOOLEAN('x', "exclude-other", &symbol_conf.exclude_other,
 		    "Only display entries with parent-match"),
 	OPT_CALLBACK_DEFAULT('g', "call-graph", NULL, "output_type,min_percent",
 		     "Display callchains using output_type (graph, flat, fractal, or none) and min percent threshold. "
 		     "Default: fractal,0.5", &parse_callchain_opt, callchain_default_opt),
 	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
 		   "only consider symbols in these dsos"),
 	OPT_STRING('C', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
 		   "only consider symbols in these comms"),
 	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
 		   "only consider these symbols"),
 	OPT_STRING('w', "column-widths", &symbol_conf.col_width_list_str,
 		   "width[,width...]",
 		   "don't try to adjust column width, use these fixed values"),
 	OPT_STRING('t', "field-separator", &symbol_conf.field_sep, "separator",
 		   "separator for columns, no spaces will be added between "
 		   "columns '.' is reserved."),
 	OPT_BOOLEAN('U', "hide-unresolved", &hide_unresolved,
 		    "Only display entries resolved to a symbol"),
 	OPT_END()
 };
 int cmd_report(int argc, const char **argv, const char *prefix __used)
 {
 	argc = parse_options(argc, argv, options, report_usage, 0);
 	if (use_stdio)
 		use_browser = 0;
 	else if (use_tui)
 		use_browser = 1;
 	if (strcmp(input_name, "-") != 0)
 		setup_browser();
 	else
 		use_browser = 0;
 	/*
 	 * Only in the newt browser we are doing integrated annotation,
 	 * so don't allocate extra space that won't be used in the stdio
 	 * implementation.
 	 */
 	if (use_browser > 0) {
 		symbol_conf.priv_size = sizeof(struct sym_priv);
 		/*
  		 * For searching by name on the "Browse map details".
  		 * providing it only in verbose mode not to bloat too
  		 * much struct symbol.
  		 */
 		if (verbose) {
 			/*
 			 * XXX: Need to provide a less kludgy way to ask for
 			 * more space per symbol, the u32 is for the index on
 			 * the ui browser.
 			 * See symbol__browser_index.
 			 */
 			symbol_conf.priv_size += sizeof(u32);
 			symbol_conf.sort_by_name = true;
 		}
 	}
 	if (symbol__init() < 0)
 		return -1;
 	setup_sorting(report_usage, options);
 	if (parent_pattern != default_parent_pattern) {
 		if (sort_dimension__add("parent") < 0)
 			return -1;
 		sort_parent.elide = 1;
 	} else
 		symbol_conf.exclude_other = false;
 	/*
 	 * Any (unrecognized) arguments left?
 	 */
 	if (argc)
 		usage_with_options(report_usage, options);
 	sort_entry__setup_elide(&sort_dso, symbol_conf.dso_list, "dso", stdout);
 	sort_entry__setup_elide(&sort_comm, symbol_conf.comm_list, "comm", stdout);
 	sort_entry__setup_elide(&sort_sym, symbol_conf.sym_list, "symbol", stdout);
 	return __cmd_report();
 }