1 files changed, 110 insertions, 17 deletions

diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index b20a4b6e31b7..99274cec0adb 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -31,7 +31,7 @@
 static char             const *input_name = "perf.data";
 static char             *vmlinux = NULL;
 
-static char             default_sort_order[] = "comm,dso";
+static char             default_sort_order[] = "comm,dso,symbol";
 static char             *sort_order = default_sort_order;
 static char             *dso_list_str, *comm_list_str, *sym_list_str,
                         *col_width_list_str;
@@ -68,7 +68,7 @@ static int		callchain;
 
 static
 struct callchain_param  callchain_param = {
-        .mode   = CHAIN_GRAPH_ABS,
+        .mode   = CHAIN_GRAPH_REL,
         .min_percent = 0.5
 };
 
@@ -99,6 +99,7 @@ struct comm_event {
 struct fork_event {
         struct perf_event_header header;
         u32 pid, ppid;
+        u32 tid, ptid;
 };
 
 struct lost_event {
@@ -111,7 +112,9 @@ struct read_event {
         struct perf_event_header header;
         u32 pid,tid;
         u64 value;
-        u64 format[3];
+        u64 time_enabled;
+        u64 time_running;
+        u64 id;
 };
 
 typedef union event_union {
@@ -252,7 +255,7 @@ static int strcommon(const char *pathname)
 {
         int n = 0;
 
-        while (pathname[n] == cwd[n] && n < cwdlen)
+        while (n < cwdlen && pathname[n] == cwd[n])
                 ++n;
 
         return n;
@@ -697,7 +700,8 @@ sort__sym_print(FILE *fp, struct hist_entry *self, unsigned int width __used)
         size_t ret = 0;
 
         if (verbose)
-                ret += repsep_fprintf(fp, "%#018llx  ", (u64)self->ip);
+                ret += repsep_fprintf(fp, "%#018llx %c ", (u64)self->ip,
+                                      dso__symtab_origin(self->dso));
 
         ret += repsep_fprintf(fp, "[%c] ", self->level);
         if (self->sym) {
@@ -887,6 +891,21 @@ ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain, int depth,
         return ret;
 }
 
+static struct symbol *rem_sq_bracket;
+static struct callchain_list rem_hits;
+
+static void init_rem_hits(void)
+{
+        rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
+        if (!rem_sq_bracket) {
+                fprintf(stderr, "Not enough memory to display remaining hits\n");
+                return;
+        }
+
+        strcpy(rem_sq_bracket->name, "[...]");
+        rem_hits.sym = rem_sq_bracket;
+}
+
 static size_t
 callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                         u64 total_samples, int depth, int depth_mask)
@@ -896,25 +915,34 @@ callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
         struct callchain_list *chain;
         int new_depth_mask = depth_mask;
         u64 new_total;
+        u64 remaining;
         size_t ret = 0;
         int i;
 
         if (callchain_param.mode == CHAIN_GRAPH_REL)
-                new_total = self->cumul_hit;
+                new_total = self->children_hit;
         else
                 new_total = total_samples;
 
+        remaining = new_total;
+
         node = rb_first(&self->rb_root);
         while (node) {
+                u64 cumul;
+
                 child = rb_entry(node, struct callchain_node, rb_node);
+                cumul = cumul_hits(child);
+                remaining -= cumul;
 
                 /*
                  * The depth mask manages the output of pipes that show
                  * the depth. We don't want to keep the pipes of the current
-                 * level for the last child of this depth
+                 * level for the last child of this depth.
+                 * Except if we have remaining filtered hits. They will
+                 * supersede the last child
                  */
                 next = rb_next(node);
-                if (!next)
+                if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
                         new_depth_mask &= ~(1 << (depth - 1));
 
                 /*
@@ -929,7 +957,7 @@ callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                         ret += ipchain__fprintf_graph(fp, chain, depth,
                                                       new_depth_mask, i++,
                                                       new_total,
-                                                      child->cumul_hit);
+                                                      cumul);
                 }
                 ret += callchain__fprintf_graph(fp, child, new_total,
                                                 depth + 1,
@@ -937,6 +965,19 @@ callchain__fprintf_graph(FILE *fp, struct callchain_node *self,
                 node = next;
         }
 
+        if (callchain_param.mode == CHAIN_GRAPH_REL &&
+                remaining && remaining != new_total) {
+
+                if (!rem_sq_bracket)
+                        return ret;
+
+                new_depth_mask &= ~(1 << (depth - 1));
+
+                ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
+                                              new_depth_mask, 0, new_total,
+                                              remaining);
+        }
+
         return ret;
 }
 
@@ -1357,6 +1398,8 @@ static size_t output__fprintf(FILE *fp, u64 total_samples)
         unsigned int width;
         char *col_width = col_width_list_str;
 
+        init_rem_hits();
+
         fprintf(fp, "# Samples: %Ld\n", (u64)total_samples);
         fprintf(fp, "#\n");
 
@@ -1423,11 +1466,13 @@ print_entries:
         if (sort_order == default_sort_order &&
                         parent_pattern == default_parent_pattern) {
                 fprintf(fp, "#\n");
-                fprintf(fp, "# (For more details, try: perf report --sort comm,dso,symbol)\n");
+                fprintf(fp, "# (For a higher level overview, try: perf report --sort comm,dso)\n");
                 fprintf(fp, "#\n");
         }
         fprintf(fp, "\n");
 
+        free(rem_sq_bracket);
+
         return ret;
 }
 
@@ -1608,15 +1653,27 @@ process_comm_event(event_t *event, unsigned long offset, unsigned long head)
 }
 
 static int
-process_fork_event(event_t *event, unsigned long offset, unsigned long head)
+process_task_event(event_t *event, unsigned long offset, unsigned long head)
 {
         struct thread *thread = threads__findnew(event->fork.pid);
         struct thread *parent = threads__findnew(event->fork.ppid);
 
-        dprintf("%p [%p]: PERF_EVENT_FORK: %d:%d\n",
+        dprintf("%p [%p]: PERF_EVENT_%s: (%d:%d):(%d:%d)\n",
                 (void *)(offset + head),
                 (void *)(long)(event->header.size),
-                event->fork.pid, event->fork.ppid);
+                event->header.type == PERF_EVENT_FORK ? "FORK" : "EXIT",
+                event->fork.pid, event->fork.tid,
+                event->fork.ppid, event->fork.ptid);
+
+        /*
+         * A thread clone will have the same PID for both
+         * parent and child.
+         */
+        if (thread == parent)
+                return 0;
+
+        if (event->header.type == PERF_EVENT_EXIT)
+                return 0;
 
         if (!thread || !parent || thread__fork(thread, parent)) {
                 dprintf("problem processing PERF_EVENT_FORK, skipping event.\n");
@@ -1677,14 +1734,37 @@ static void trace_event(event_t *event)
         dprintf(".\n");
 }
 
+static struct perf_header       *header;
+
+static struct perf_counter_attr *perf_header__find_attr(u64 id)
+{
+        int i;
+
+        for (i = 0; i < header->attrs; i++) {
+                struct perf_header_attr *attr = header->attr[i];
+                int j;
+
+                for (j = 0; j < attr->ids; j++) {
+                        if (attr->id[j] == id)
+                                return &attr->attr;
+                }
+        }
+
+        return NULL;
+}
+
 static int
 process_read_event(event_t *event, unsigned long offset, unsigned long head)
 {
-        dprintf("%p [%p]: PERF_EVENT_READ: %d %d %Lu\n",
+        struct perf_counter_attr *attr = perf_header__find_attr(event->read.id);
+
+        dprintf("%p [%p]: PERF_EVENT_READ: %d %d %s %Lu\n",
                         (void *)(offset + head),
                         (void *)(long)(event->header.size),
                         event->read.pid,
                         event->read.tid,
+                        attr ? __event_name(attr->type, attr->config)
+                             : "FAIL",
                         event->read.value);
 
         return 0;
@@ -1706,7 +1786,8 @@ process_event(event_t *event, unsigned long offset, unsigned long head)
                 return process_comm_event(event, offset, head);
 
         case PERF_EVENT_FORK:
-                return process_fork_event(event, offset, head);
+        case PERF_EVENT_EXIT:
+                return process_task_event(event, offset, head);
 
         case PERF_EVENT_LOST:
                 return process_lost_event(event, offset, head);
@@ -1729,8 +1810,6 @@ process_event(event_t *event, unsigned long offset, unsigned long head)
         return 0;
 }
 
-static struct perf_header       *header;
-
 static u64 perf_header__sample_type(void)
 {
         u64 sample_type = 0;
@@ -1798,6 +1877,13 @@ static int __cmd_report(void)
                                         " -g?\n");
                         exit(-1);
                 }
+        } else if (callchain_param.mode != CHAIN_NONE && !callchain) {
+                        callchain = 1;
+                        if (register_callchain_param(&callchain_param) < 0) {
+                                fprintf(stderr, "Can't register callchain"
+                                                " params\n");
+                                exit(-1);
+                        }
         }
 
         if (load_kernel() < 0) {
@@ -1936,6 +2022,13 @@ parse_callchain_opt(const struct option *opt __used, const char *arg,
         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;
+                callchain = 0;
+
+                return 0;
+        }
+
         else
                 return -1;