perf tools: Reorganize event processing routines, lotsa dups killed

While implementing event__preprocess_sample, that will do all of
the symbol lookup in one convenient function, I noticed that
util/process_event.[ch] were not being used at all, then started
looking if there were other functions that could be shared
and...

All those functions really don't need to receive offset + head,
the only thing they did was common to all of them, so do it at
one place instead.

Stats about number of each type of event processed now is done
in a central place.

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: John Kacur <jkacur@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1259346563-12568-11-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

9 files changed, 135 insertions, 202 deletions

diff --git a/tools/perf/util/data_map.c b/tools/perf/util/data_map.c
index b238462b8983..ca0bedf637c2 100644
--- a/tools/perf/util/data_map.c
+++ b/tools/perf/util/data_map.c
@@ -8,11 +8,9 @@ static struct perf_file_handler *curr_handler;
 static unsigned long    mmap_window = 32;
 static char             __cwd[PATH_MAX];
 
-static int
-process_event_stub(event_t *event __used,
-                   unsigned long offset __used,
-                   unsigned long head __used)
+static int process_event_stub(event_t *event __used)
 {
+        dump_printf(": unhandled!\n");
         return 0;
 }
 
@@ -40,30 +38,62 @@ void register_perf_file_handler(struct perf_file_handler *handler)
         curr_handler = handler;
 }
 
+static const char *event__name[] = {
+        [0]                      = "TOTAL",
+        [PERF_RECORD_MMAP]       = "MMAP",
+        [PERF_RECORD_LOST]       = "LOST",
+        [PERF_RECORD_COMM]       = "COMM",
+        [PERF_RECORD_EXIT]       = "EXIT",
+        [PERF_RECORD_THROTTLE]   = "THROTTLE",
+        [PERF_RECORD_UNTHROTTLE] = "UNTHROTTLE",
+        [PERF_RECORD_FORK]       = "FORK",
+        [PERF_RECORD_READ]       = "READ",
+        [PERF_RECORD_SAMPLE]     = "SAMPLE",
+};
+
+unsigned long event__total[PERF_RECORD_MAX];
+
+void event__print_totals(void)
+{
+        int i;
+        for (i = 0; i < PERF_RECORD_MAX; ++i)
+                pr_info("%10s events: %10ld\n",
+                        event__name[i], event__total[i]);
+}
+
 static int
 process_event(event_t *event, unsigned long offset, unsigned long head)
 {
         trace_event(event);
 
+        if (event->header.type < PERF_RECORD_MAX) {
+                dump_printf("%p [%p]: PERF_RECORD_%s",
+                            (void *)(offset + head),
+                            (void *)(long)(event->header.size),
+                            event__name[event->header.type]);
+                ++event__total[0];
+                ++event__total[event->header.type];
+        }
+
         switch (event->header.type) {
         case PERF_RECORD_SAMPLE:
-                return curr_handler->process_sample_event(event, offset, head);
+                return curr_handler->process_sample_event(event);
         case PERF_RECORD_MMAP:
-                return curr_handler->process_mmap_event(event, offset, head);
+                return curr_handler->process_mmap_event(event);
         case PERF_RECORD_COMM:
-                return curr_handler->process_comm_event(event, offset, head);
+                return curr_handler->process_comm_event(event);
         case PERF_RECORD_FORK:
-                return curr_handler->process_fork_event(event, offset, head);
+                return curr_handler->process_fork_event(event);
         case PERF_RECORD_EXIT:
-                return curr_handler->process_exit_event(event, offset, head);
+                return curr_handler->process_exit_event(event);
         case PERF_RECORD_LOST:
-                return curr_handler->process_lost_event(event, offset, head);
+                return curr_handler->process_lost_event(event);
         case PERF_RECORD_READ:
-                return curr_handler->process_read_event(event, offset, head);
+                return curr_handler->process_read_event(event);
         case PERF_RECORD_THROTTLE:
-                return curr_handler->process_throttle_event(event, offset, head);
+                return curr_handler->process_throttle_event(event);
         case PERF_RECORD_UNTHROTTLE:
-                return curr_handler->process_unthrottle_event(event, offset, head);
+                return curr_handler->process_unthrottle_event(event);
         default:
                 curr_handler->total_unknown++;
                 return -1;
diff --git a/tools/perf/util/data_map.h b/tools/perf/util/data_map.h
index ae036ecd7625..3180ff7e3633 100644
--- a/tools/perf/util/data_map.h
+++ b/tools/perf/util/data_map.h
@@ -4,7 +4,7 @@
 #include "event.h"
 #include "header.h"
 
-typedef int (*event_type_handler_t)(event_t *, unsigned long, unsigned long);
+typedef int (*event_type_handler_t)(event_t *);
 
 struct perf_file_handler {
         event_type_handler_t    process_sample_event;
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 1dae7e3b400d..70b4aa03b472 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -2,6 +2,7 @@
 #include "event.h"
 #include "debug.h"
 #include "string.h"
+#include "thread.h"
 
 static pid_t event__synthesize_comm(pid_t pid, int full,
                                     int (*process)(event_t *event))
@@ -175,3 +176,76 @@ void event__synthesize_threads(int (*process)(event_t *event))
 
         closedir(proc);
 }
+
+char *event__cwd;
+int  event__cwdlen;
+
+struct events_stats event__stats;
+
+int event__process_comm(event_t *self)
+{
+        struct thread *thread = threads__findnew(self->comm.pid);
+
+        dump_printf("PERF_RECORD_COMM: %s:%d\n",
+                    self->comm.comm, self->comm.pid);
+
+        if (thread == NULL || thread__set_comm(thread, self->comm.comm)) {
+                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
+                return -1;
+        }
+
+        return 0;
+}
+
+int event__process_lost(event_t *self)
+{
+        dump_printf(": id:%Ld: lost:%Ld\n", self->lost.id, self->lost.lost);
+        event__stats.lost += self->lost.lost;
+        return 0;
+}
+
+int event__process_mmap(event_t *self)
+{
+        struct thread *thread = threads__findnew(self->mmap.pid);
+        struct map *map = map__new(&self->mmap, MAP__FUNCTION,
+                                   event__cwd, event__cwdlen);
+
+        dump_printf(" %d/%d: [%p(%p) @ %p]: %s\n",
+                    self->mmap.pid, self->mmap.tid,
+                    (void *)(long)self->mmap.start,
+                    (void *)(long)self->mmap.len,
+                    (void *)(long)self->mmap.pgoff,
+                    self->mmap.filename);
+
+        if (thread == NULL || map == NULL)
+                dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
+        else
+                thread__insert_map(thread, map);
+
+        return 0;
+}
+
+int event__process_task(event_t *self)
+{
+        struct thread *thread = threads__findnew(self->fork.pid);
+        struct thread *parent = threads__findnew(self->fork.ppid);
+
+        dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
+                    self->fork.ppid, self->fork.ptid);
+        /*
+         * A thread clone will have the same PID for both parent and child.
+         */
+        if (thread == parent)
+                return 0;
+
+        if (self->header.type == PERF_RECORD_EXIT)
+                return 0;
+
+        if (thread == NULL || parent == NULL ||
+            thread__fork(thread, parent) < 0) {
+                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
+                return -1;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 3ae3c964c901..13c12c75f970 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -80,6 +80,13 @@ typedef union event_union {
         struct sample_event             sample;
 } event_t;
 
+struct events_stats {
+        unsigned long total;
+        unsigned long lost;
+};
+
+void event__print_totals(void);
+
 enum map_type {
         MAP__FUNCTION = 0,
 
@@ -135,4 +142,14 @@ void map__fixup_end(struct map *self);
 int event__synthesize_thread(pid_t pid, int (*process)(event_t *event));
 void event__synthesize_threads(int (*process)(event_t *event));
 
+extern char *event__cwd;
+extern int  event__cwdlen;
+extern struct events_stats event__stats;
+extern unsigned long event__total[PERF_RECORD_MAX];
+
+int event__process_comm(event_t *self);
+int event__process_lost(event_t *self);
+int event__process_mmap(event_t *self);
+int event__process_task(event_t *self);
+
 #endif /* __PERF_RECORD_H */
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 7393a02fd8d4..f26cd9ba00fd 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -10,13 +10,6 @@ struct callchain_param	callchain_param = {
         .min_percent = 0.5
 };
 
-unsigned long total;
-unsigned long total_mmap;
-unsigned long total_comm;
-unsigned long total_fork;
-unsigned long total_unknown;
-unsigned long total_lost;
-
 /*
  * histogram, sorted on item, collects counts
  */
diff --git a/tools/perf/util/process_event.c b/tools/perf/util/process_event.c
deleted file mode 100644
index a970789581a2..000000000000
--- a/tools/perf/util/process_event.c
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "process_event.h"
-
-char    *cwd;
-int     cwdlen;
-
-int
-process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct map *map = map__new(&event->mmap, cwd, cwdlen);
-        struct thread *thread = threads__findnew(event->mmap.pid);
-
-        dump_printf("%p [%p]: PERF_RECORD_MMAP %d/%d: [%p(%p) @ %p]: %s\n",
-                        (void *)(offset + head),
-                        (void *)(long)(event->header.size),
-                        event->mmap.pid,
-                        event->mmap.tid,
-                        (void *)(long)event->mmap.start,
-                        (void *)(long)event->mmap.len,
-                        (void *)(long)event->mmap.pgoff,
-                        event->mmap.filename);
-
-        if (thread == NULL || map == NULL) {
-                dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
-                return 0;
-        }
-
-        thread__insert_map(thread, map);
-        total_mmap++;
-
-        return 0;
-
-}
-
-int
-process_comm_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct thread *thread = threads__findnew(event->comm.pid);
-
-        dump_printf("%p [%p]: PERF_RECORD_COMM: %s:%d\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->comm.comm, event->comm.pid);
-
-        if (thread == NULL ||
-            thread__set_comm_adjust(thread, event->comm.comm)) {
-                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
-                return -1;
-        }
-        total_comm++;
-
-        return 0;
-}
-
diff --git a/tools/perf/util/process_event.h b/tools/perf/util/process_event.h
deleted file mode 100644
index 6f68c69736cd..000000000000
--- a/tools/perf/util/process_event.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef __PROCESS_EVENT_H
-#define __PROCESS_EVENT_H
-
-#include "../builtin.h"
-#include "util.h"
-
-#include "color.h"
-#include <linux/list.h>
-#include "cache.h"
-#include <linux/rbtree.h>
-#include "symbol.h"
-#include "string.h"
-
-#include "../perf.h"
-#include "debug.h"
-
-#include "parse-options.h"
-#include "parse-events.h"
-
-#include "thread.h"
-#include "sort.h"
-#include "hist.h"
-
-extern char     *cwd;
-extern int      cwdlen;
-extern int process_mmap_event(event_t *, unsigned long, unsigned long);
-extern int process_comm_event(event_t *, unsigned long , unsigned long);
-
-#endif  /* __PROCESS_H */
diff --git a/tools/perf/util/process_events.c b/tools/perf/util/process_events.c
deleted file mode 100644
index 53778684641c..000000000000
--- a/tools/perf/util/process_events.c
+++ /dev/null
@@ -1,64 +0,0 @@
-#include "process_events.h"
-
-char    *cwd;
-int     cwdlen;
-
-int
-process_mmap_event(event_t *event, unsigned long offset, unsigned long head)
-{
-        struct map *map = map__new(&event->mmap, MAP__FUNCTION, cwd, cwdlen);
-        struct thread *thread = threads__findnew(event->mmap.pid);
-
-        dump_printf("%p [%p]: PERF_RECORD_MMAP %d/%d: [%p(%p) @ %p]: %s\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->mmap.pid,
-                event->mmap.tid,
-                (void *)(long)event->mmap.start,
-                (void *)(long)event->mmap.len,
-                (void *)(long)event->mmap.pgoff,
-                event->mmap.filename);
-
-        if (thread == NULL || map == NULL) {
-                dump_printf("problem processing PERF_RECORD_MMAP, skipping event.\n");
-                return 0;
-        }
-
-        thread__insert_map(thread, map);
-        total_mmap++;
-
-        return 0;
-}
-
-int
-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);
-
-        dump_printf("%p [%p]: PERF_RECORD_%s: (%d:%d):(%d:%d)\n",
-                (void *)(offset + head),
-                (void *)(long)(event->header.size),
-                event->header.type == PERF_RECORD_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_RECORD_EXIT)
-                return 0;
-
-        if (!thread || !parent || thread__fork(thread, parent)) {
-                dump_printf("problem processing PERF_RECORD_FORK, skipping event.\n");
-                return -1;
-        }
-        total_fork++;
-
-        return 0;
-}
-
diff --git a/tools/perf/util/process_events.h b/tools/perf/util/process_events.h
deleted file mode 100644
index 73d092f83283..000000000000
--- a/tools/perf/util/process_events.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#ifndef __PROCESS_EVENTS_H
-#define __PROCESS_EVENTS_H
-
-#include "../builtin.h"
-
-#include "util.h"
-#include "color.h"
-#include <linux/list.h>
-#include "cache.h"
-#include <linux/rbtree.h>
-#include "symbol.h"
-#include "string.h"
-#include "callchain.h"
-#include "strlist.h"
-#include "values.h"
-
-#include "../perf.h"
-#include "debug.h"
-#include "header.h"
-
-#include "parse-options.h"
-#include "parse-events.h"
-
-#include "data_map.h"
-#include "thread.h"
-#include "sort.h"
-#include "hist.h"
-
-extern char     *cwd;
-extern int      cwdlen;
-
-extern int process_mmap_event(event_t *, unsigned long , unsigned long);
-extern int process_task_event(event_t *, unsigned long, unsigned long);
-
-#endif  /* __PROCESS_EVENTS_H */