1 files changed, 137 insertions, 91 deletions

diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index f815de25d0f..1d3c1003b43 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -14,7 +14,6 @@
 #include "util/cache.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
-#include "util/string.h"
 #include "util/callchain.h"
 #include "util/strlist.h"
 #include "util/values.h"
@@ -33,28 +32,29 @@
 
 static char             const *input_name = "perf.data";
 
-static int              force;
+static bool             force;
 static bool             hide_unresolved;
 static bool             dont_use_callchains;
 
-static int              show_threads;
+static bool             show_threads;
 static struct perf_read_values  show_threads_values;
 
-static char             default_pretty_printing_style[] = "normal";
-static char             *pretty_printing_style = default_pretty_printing_style;
+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 event_stat_id *get_stats(struct perf_session *self,
-                                       u64 event_stream, u32 type, u64 config)
+static struct hists *perf_session__hists_findnew(struct perf_session *self,
+                                                 u64 event_stream, u32 type,
+                                                 u64 config)
 {
-        struct rb_node **p = &self->stats_by_id.rb_node;
+        struct rb_node **p = &self->hists_tree.rb_node;
         struct rb_node *parent = NULL;
-        struct event_stat_id *iter, *new;
+        struct hists *iter, *new;
 
         while (*p != NULL) {
                 parent = *p;
-                iter = rb_entry(parent, struct event_stat_id, rb_node);
+                iter = rb_entry(parent, struct hists, rb_node);
                 if (iter->config == config)
                         return iter;
 
@@ -65,15 +65,15 @@ static struct event_stat_id *get_stats(struct perf_session *self,
                         p = &(*p)->rb_left;
         }
 
-        new = malloc(sizeof(struct event_stat_id));
+        new = malloc(sizeof(struct hists));
         if (new == NULL)
                 return NULL;
-        memset(new, 0, sizeof(struct event_stat_id));
+        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->stats_by_id);
+        rb_insert_color(&new->rb_node, &self->hists_tree);
         return new;
 }
 
@@ -81,70 +81,71 @@ static int perf_session__add_hist_entry(struct perf_session *self,
                                         struct addr_location *al,
                                         struct sample_data *data)
 {
-        struct symbol **syms = NULL, *parent = NULL;
-        bool hit;
+        struct map_symbol *syms = NULL;
+        struct symbol *parent = NULL;
+        int err = -ENOMEM;
         struct hist_entry *he;
-        struct event_stat_id *stats;
+        struct hists *hists;
         struct perf_event_attr *attr;
 
-        if ((sort__has_parent || symbol_conf.use_callchain) && data->callchain)
+        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)
-                stats = get_stats(self, data->id, attr->type, attr->config);
+                hists = perf_session__hists_findnew(self, data->id, attr->type, attr->config);
         else
-                stats = get_stats(self, data->id, 0, 0);
-        if (stats == NULL)
-                return -ENOMEM;
-        he = __perf_session__add_hist_entry(&stats->hists, al, parent,
-                                            data->period, &hit);
+                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)
-                return -ENOMEM;
-
-        if (hit)
-                he->count += data->period;
-
+                goto out_free_syms;
+        err = 0;
         if (symbol_conf.use_callchain) {
-                if (!hit)
-                        callchain_init(&he->callchain);
-                append_chain(&he->callchain, data->callchain, syms);
-                free(syms);
+                err = append_chain(he->callchain, data->callchain, syms);
+                if (err)
+                        goto out_free_syms;
         }
-
-        return 0;
-}
-
-static int validate_chain(struct ip_callchain *chain, event_t *event)
-{
-        unsigned int chain_size;
-
-        chain_size = event->header.size;
-        chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
-
-        if (chain->nr*sizeof(u64) > chain_size)
-                return -1;
-
-        return 0;
+        /*
+         * 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)
+                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 event_stat_id *stats;
+        struct hists *hists;
 
         if (attr)
-                stats = get_stats(session, data->id, attr->type, attr->config);
+                hists = perf_session__hists_findnew(session, data->id,
+                                                    attr->type, attr->config);
         else
-                stats = get_stats(session, data->id, 0, 0);
+                hists = perf_session__hists_findnew(session, data->id, 0, 0);
 
-        if (!stats)
+        if (!hists)
                 return -ENOMEM;
 
-        stats->stats.total += data->period;
-        session->events_stats.total += data->period;
+        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;
 }
 
@@ -164,7 +165,7 @@ static int process_sample_event(event_t *event, struct perf_session *session)
 
                 dump_printf("... chain: nr:%Lu\n", data.callchain->nr);
 
-                if (validate_chain(data.callchain, event) < 0) {
+                if (!ip_callchain__valid(data.callchain, event)) {
                         pr_debug("call-chain problem with event, "
                                  "skipping it.\n");
                         return 0;
@@ -187,14 +188,14 @@ static int process_sample_event(event_t *event, struct perf_session *session)
                 return 0;
 
         if (perf_session__add_hist_entry(session, &al, &data)) {
-                pr_debug("problem incrementing symbol count, skipping event\n");
+                pr_debug("problem incrementing symbol period, skipping event\n");
                 return -1;
         }
 
         attr = perf_header__find_attr(data.id, &session->header);
 
         if (add_event_total(session, &data, attr)) {
-                pr_debug("problem adding event count\n");
+                pr_debug("problem adding event period\n");
                 return -1;
         }
 
@@ -260,15 +261,43 @@ static struct perf_event_ops event_ops = {
         .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,
 };
 
+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 __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);
+        session = perf_session__new(input_name, O_RDONLY, force, false);
         if (session == NULL)
                 return -ENOMEM;
 
@@ -284,7 +313,7 @@ static int __cmd_report(void)
                 goto out_delete;
 
         if (dump_trace) {
-                event__print_totals();
+                perf_session__fprintf_nr_events(session, stdout);
                 goto out_delete;
         }
 
@@ -292,39 +321,42 @@ static int __cmd_report(void)
                 perf_session__fprintf(session, stdout);
 
         if (verbose > 2)
-                dsos__fprintf(stdout);
+                perf_session__fprintf_dsos(session, stdout);
 
-        next = rb_first(&session->stats_by_id);
+        next = rb_first(&session->hists_tree);
         while (next) {
-                struct event_stat_id *stats;
-
-                stats = rb_entry(next, struct event_stat_id, rb_node);
-                perf_session__collapse_resort(&stats->hists);
-                perf_session__output_resort(&stats->hists, stats->stats.total);
-                if (rb_first(&session->stats_by_id) ==
-                    rb_last(&session->stats_by_id))
-                        fprintf(stdout, "# Samples: %Ld\n#\n",
-                                stats->stats.total);
-                else
-                        fprintf(stdout, "# Samples: %Ld %s\n#\n",
-                                stats->stats.total,
-                                __event_name(stats->type, stats->config));
-
-                perf_session__fprintf_hists(&stats->hists, NULL, false, stdout,
-                                            stats->stats.total);
-                fprintf(stdout, "\n\n");
-                next = rb_next(&stats->rb_node);
+                struct hists *hists;
+
+                hists = rb_entry(next, struct hists, rb_node);
+                hists__collapse_resort(hists);
+                hists__output_resort(hists);
+                if (use_browser)
+                        hists__browse(hists, help, input_name);
+                else {
+                        const char *evname = NULL;
+                        if (rb_first(&session->hists.entries) !=
+                            rb_last(&session->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# (For a higher level overview, try: perf report --sort comm,dso)\n#\n");
+        if (!use_browser && sort_order == default_sort_order &&
+            parent_pattern == default_parent_pattern) {
+                fprintf(stdout, "#\n# (%s)\n#\n", help);
 
-        if (show_threads) {
-                bool raw_printing_style = !strcmp(pretty_printing_style, "raw");
-                perf_read_values_display(stdout, &show_threads_values,
-                                         raw_printing_style);
-                perf_read_values_destroy(&show_threads_values);
+                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);
+                }
         }
 out_delete:
         perf_session__delete(session);
@@ -335,7 +367,7 @@ static int
 parse_callchain_opt(const struct option *opt __used, const char *arg,
                     int unset)
 {
-        char *tok;
+        char *tok, *tok2;
         char *endptr;
 
         /*
@@ -380,10 +412,13 @@ parse_callchain_opt(const struct option *opt __used, const char *arg,
         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");
@@ -400,7 +435,7 @@ static const char * const report_usage[] = {
 static const struct option options[] = {
         OPT_STRING('i', "input", &input_name, "file",
                     "input file name"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        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"),
@@ -419,12 +454,14 @@ static const struct option options[] = {
                    "sort by key(s): pid, comm, dso, symbol, parent"),
         OPT_BOOLEAN('P', "full-paths", &symbol_conf.full_paths,
                     "Don't shorten the pathnames taking into account the cwd"),
+        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 and min percent threshold. "
+                     "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"),
@@ -447,7 +484,15 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
 {
         argc = parse_options(argc, argv, options, report_usage, 0);
 
-        setup_pager();
+        if (strcmp(input_name, "-") != 0)
+                setup_browser();
+        /*
+         * 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)
+                symbol_conf.priv_size = sizeof(struct sym_priv);
 
         if (symbol__init() < 0)
                 return -1;
@@ -455,7 +500,8 @@ int cmd_report(int argc, const char **argv, const char *prefix __used)
         setup_sorting(report_usage, options);
 
         if (parent_pattern != default_parent_pattern) {
-                sort_dimension__add("parent");
+                if (sort_dimension__add("parent") < 0)
+                        return -1;
                 sort_parent.elide = 1;
         } else
                 symbol_conf.exclude_other = false;