Merge branch 'perfcounters-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'perfcounters-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip: (58 commits)
  perf_counter: Fix perf_copy_attr() pointer arithmetic
  perf utils: Use a define for the maximum length of a trace event
  perf: Add timechart help text and add timechart to "perf help"
  tracing, x86, cpuidle: Move the end point of a C state in the power tracer
  perf utils: Be consistent about minimum text size in the svghelper
  perf timechart: Add "perf timechart record"
  perf: Add the timechart tool
  perf: Add a SVG helper library file
  tracing, perf: Convert the power tracer into an event tracer
  perf: Add a sample_event type to the event_union
  perf: Allow perf utilities to have "callback" options without arguments
  perf: Store trace event name/id pairs in perf.data
  perf: Add a timestamp to fork events
  sched_clock: Make it NMI safe
  perf_counter: Fix up swcounter throttling
  x86, perf_counter, bts: Optimize BTS overflow handling
  perf sched: Add --input=file option to builtin-sched.c
  perf trace: Sample timestamp and cpu when using record flag
  perf tools: Increase MAX_EVENT_LENGTH
  perf tools: Fix memory leak in read_ftrace_printk()
  ...

13 files changed, 729 insertions, 78 deletions

diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index fa2d4e91d329..018d414a09d1 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -39,6 +39,7 @@ struct fork_event {
         struct perf_event_header header;
         u32 pid, ppid;
         u32 tid, ptid;
+        u64 time;
 };
 
 struct lost_event {
@@ -52,13 +53,19 @@ struct lost_event {
  */
 struct read_event {
         struct perf_event_header header;
-        u32 pid,tid;
+        u32 pid, tid;
         u64 value;
         u64 time_enabled;
         u64 time_running;
         u64 id;
 };
 
+struct sample_event{
+        struct perf_event_header        header;
+        u64 array[];
+};
+
+
 typedef union event_union {
         struct perf_event_header        header;
         struct ip_event                 ip;
@@ -67,6 +74,7 @@ typedef union event_union {
         struct fork_event               fork;
         struct lost_event               lost;
         struct read_event               read;
+        struct sample_event             sample;
 } event_t;
 
 struct map {
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index ec4d4c2f9522..bb4fca3efcc3 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -7,9 +7,8 @@
 #include "header.h"
 
 /*
- *
+ * Create new perf.data header attribute:
  */
-
 struct perf_header_attr *perf_header_attr__new(struct perf_counter_attr *attr)
 {
         struct perf_header_attr *self = malloc(sizeof(*self));
@@ -43,9 +42,8 @@ void perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
 }
 
 /*
- *
+ * Create new perf.data header:
  */
-
 struct perf_header *perf_header__new(void)
 {
         struct perf_header *self = malloc(sizeof(*self));
@@ -86,6 +84,46 @@ void perf_header__add_attr(struct perf_header *self,
         self->attr[pos] = attr;
 }
 
+#define MAX_EVENT_NAME 64
+
+struct perf_trace_event_type {
+        u64     event_id;
+        char    name[MAX_EVENT_NAME];
+};
+
+static int event_count;
+static struct perf_trace_event_type *events;
+
+void perf_header__push_event(u64 id, const char *name)
+{
+        if (strlen(name) > MAX_EVENT_NAME)
+                printf("Event %s will be truncated\n", name);
+
+        if (!events) {
+                events = malloc(sizeof(struct perf_trace_event_type));
+                if (!events)
+                        die("nomem");
+        } else {
+                events = realloc(events, (event_count + 1) * sizeof(struct perf_trace_event_type));
+                if (!events)
+                        die("nomem");
+        }
+        memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
+        events[event_count].event_id = id;
+        strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
+        event_count++;
+}
+
+char *perf_header__find_event(u64 id)
+{
+        int i;
+        for (i = 0 ; i < event_count; i++) {
+                if (events[i].event_id == id)
+                        return events[i].name;
+        }
+        return NULL;
+}
+
 static const char *__perf_magic = "PERFFILE";
 
 #define PERF_MAGIC      (*(u64 *)__perf_magic)
@@ -106,6 +144,7 @@ struct perf_file_header {
         u64                             attr_size;
         struct perf_file_section        attrs;
         struct perf_file_section        data;
+        struct perf_file_section        event_types;
 };
 
 static void do_write(int fd, void *buf, size_t size)
@@ -154,6 +193,11 @@ void perf_header__write(struct perf_header *self, int fd)
                 do_write(fd, &f_attr, sizeof(f_attr));
         }
 
+        self->event_offset = lseek(fd, 0, SEEK_CUR);
+        self->event_size = event_count * sizeof(struct perf_trace_event_type);
+        if (events)
+                do_write(fd, events, self->event_size);
+
 
         self->data_offset = lseek(fd, 0, SEEK_CUR);
 
@@ -169,6 +213,10 @@ void perf_header__write(struct perf_header *self, int fd)
                         .offset = self->data_offset,
                         .size   = self->data_size,
                 },
+                .event_types = {
+                        .offset = self->event_offset,
+                        .size   = self->event_size,
+                },
         };
 
         lseek(fd, 0, SEEK_SET);
@@ -234,6 +282,17 @@ struct perf_header *perf_header__read(int fd)
                 lseek(fd, tmp, SEEK_SET);
         }
 
+        if (f_header.event_types.size) {
+                lseek(fd, f_header.event_types.offset, SEEK_SET);
+                events = malloc(f_header.event_types.size);
+                if (!events)
+                        die("nomem");
+                do_read(fd, events, f_header.event_types.size);
+                event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
+        }
+        self->event_offset = f_header.event_types.offset;
+        self->event_size   = f_header.event_types.size;
+
         self->data_offset = f_header.data.offset;
         self->data_size   = f_header.data.size;
 
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 5d0a72ecc919..7b0e84a87179 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -19,6 +19,8 @@ struct perf_header {
         s64 attr_offset;
         u64 data_offset;
         u64 data_size;
+        u64 event_offset;
+        u64 event_size;
 };
 
 struct perf_header *perf_header__read(int fd);
@@ -27,6 +29,10 @@ void perf_header__write(struct perf_header *self, int fd);
 void perf_header__add_attr(struct perf_header *self,
                            struct perf_header_attr *attr);
 
+void perf_header__push_event(u64 id, const char *name);
+char *perf_header__find_event(u64 id);
+
+
 struct perf_header_attr *
 perf_header_attr__new(struct perf_counter_attr *attr);
 void perf_header_attr__add_id(struct perf_header_attr *self, u64 id);
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index a587d41ae3c9..89172fd0038b 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -6,6 +6,7 @@
 #include "exec_cmd.h"
 #include "string.h"
 #include "cache.h"
+#include "header.h"
 
 int                                     nr_counters;
 
@@ -18,6 +19,12 @@ struct event_symbol {
         const char      *alias;
 };
 
+enum event_result {
+        EVT_FAILED,
+        EVT_HANDLED,
+        EVT_HANDLED_ALL
+};
+
 char debugfs_path[MAXPATHLEN];
 
 #define CHW(x) .type = PERF_TYPE_HARDWARE, .config = PERF_COUNT_HW_##x
@@ -139,7 +146,7 @@ static int tp_event_has_id(struct dirent *sys_dir, struct dirent *evt_dir)
            (strcmp(evt_dirent.d_name, "..")) &&                                \
            (!tp_event_has_id(&sys_dirent, &evt_dirent)))
 
-#define MAX_EVENT_LENGTH 30
+#define MAX_EVENT_LENGTH 512
 
 int valid_debugfs_mount(const char *debugfs)
 {
@@ -344,7 +351,7 @@ static int parse_aliases(const char **str, const char *names[][MAX_ALIASES], int
         return -1;
 }
 
-static int
+static enum event_result
 parse_generic_hw_event(const char **str, struct perf_counter_attr *attr)
 {
         const char *s = *str;
@@ -356,7 +363,7 @@ parse_generic_hw_event(const char **str, struct perf_counter_attr *attr)
          * then bail out:
          */
         if (cache_type == -1)
-                return 0;
+                return EVT_FAILED;
 
         while ((cache_op == -1 || cache_result == -1) && *s == '-') {
                 ++s;
@@ -402,27 +409,115 @@ parse_generic_hw_event(const char **str, struct perf_counter_attr *attr)
         attr->type = PERF_TYPE_HW_CACHE;
 
         *str = s;
-        return 1;
+        return EVT_HANDLED;
+}
+
+static enum event_result
+parse_single_tracepoint_event(char *sys_name,
+                              const char *evt_name,
+                              unsigned int evt_length,
+                              char *flags,
+                              struct perf_counter_attr *attr,
+                              const char **strp)
+{
+        char evt_path[MAXPATHLEN];
+        char id_buf[4];
+        u64 id;
+        int fd;
+
+        if (flags) {
+                if (!strncmp(flags, "record", strlen(flags))) {
+                        attr->sample_type |= PERF_SAMPLE_RAW;
+                        attr->sample_type |= PERF_SAMPLE_TIME;
+                        attr->sample_type |= PERF_SAMPLE_CPU;
+                }
+        }
+
+        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
+                 sys_name, evt_name);
+
+        fd = open(evt_path, O_RDONLY);
+        if (fd < 0)
+                return EVT_FAILED;
+
+        if (read(fd, id_buf, sizeof(id_buf)) < 0) {
+                close(fd);
+                return EVT_FAILED;
+        }
+
+        close(fd);
+        id = atoll(id_buf);
+        attr->config = id;
+        attr->type = PERF_TYPE_TRACEPOINT;
+        *strp = evt_name + evt_length;
+
+        return EVT_HANDLED;
+}
+
+/* sys + ':' + event + ':' + flags*/
+#define MAX_EVOPT_LEN   (MAX_EVENT_LENGTH * 2 + 2 + 128)
+static enum event_result
+parse_subsystem_tracepoint_event(char *sys_name, char *flags)
+{
+        char evt_path[MAXPATHLEN];
+        struct dirent *evt_ent;
+        DIR *evt_dir;
+
+        snprintf(evt_path, MAXPATHLEN, "%s/%s", debugfs_path, sys_name);
+        evt_dir = opendir(evt_path);
+
+        if (!evt_dir) {
+                perror("Can't open event dir");
+                return EVT_FAILED;
+        }
+
+        while ((evt_ent = readdir(evt_dir))) {
+                char event_opt[MAX_EVOPT_LEN + 1];
+                int len;
+                unsigned int rem = MAX_EVOPT_LEN;
+
+                if (!strcmp(evt_ent->d_name, ".")
+                    || !strcmp(evt_ent->d_name, "..")
+                    || !strcmp(evt_ent->d_name, "enable")
+                    || !strcmp(evt_ent->d_name, "filter"))
+                        continue;
+
+                len = snprintf(event_opt, MAX_EVOPT_LEN, "%s:%s", sys_name,
+                               evt_ent->d_name);
+                if (len < 0)
+                        return EVT_FAILED;
+
+                rem -= len;
+                if (flags) {
+                        if (rem < strlen(flags) + 1)
+                                return EVT_FAILED;
+
+                        strcat(event_opt, ":");
+                        strcat(event_opt, flags);
+                }
+
+                if (parse_events(NULL, event_opt, 0))
+                        return EVT_FAILED;
+        }
+
+        return EVT_HANDLED_ALL;
 }
 
-static int parse_tracepoint_event(const char **strp,
+
+static enum event_result parse_tracepoint_event(const char **strp,
                                     struct perf_counter_attr *attr)
 {
         const char *evt_name;
         char *flags;
         char sys_name[MAX_EVENT_LENGTH];
-        char id_buf[4];
-        int fd;
         unsigned int sys_length, evt_length;
-        u64 id;
-        char evt_path[MAXPATHLEN];
 
         if (valid_debugfs_mount(debugfs_path))
                 return 0;
 
         evt_name = strchr(*strp, ':');
         if (!evt_name)
-                return 0;
+                return EVT_FAILED;
 
         sys_length = evt_name - *strp;
         if (sys_length >= MAX_EVENT_LENGTH)
@@ -434,32 +529,22 @@ static int parse_tracepoint_event(const char **strp,
 
         flags = strchr(evt_name, ':');
         if (flags) {
-                *flags = '\0';
+                /* split it out: */
+                evt_name = strndup(evt_name, flags - evt_name);
                 flags++;
-                if (!strncmp(flags, "record", strlen(flags)))
-                        attr->sample_type |= PERF_SAMPLE_RAW;
         }
 
         evt_length = strlen(evt_name);
         if (evt_length >= MAX_EVENT_LENGTH)
-                return 0;
-
-        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", debugfs_path,
-                 sys_name, evt_name);
-        fd = open(evt_path, O_RDONLY);
-        if (fd < 0)
-                return 0;
+                return EVT_FAILED;
 
-        if (read(fd, id_buf, sizeof(id_buf)) < 0) {
-                close(fd);
-                return 0;
-        }
-        close(fd);
-        id = atoll(id_buf);
-        attr->config = id;
-        attr->type = PERF_TYPE_TRACEPOINT;
-        *strp = evt_name + evt_length;
-        return 1;
+        if (!strcmp(evt_name, "*")) {
+                *strp = evt_name + evt_length;
+                return parse_subsystem_tracepoint_event(sys_name, flags);
+        } else
+                return parse_single_tracepoint_event(sys_name, evt_name,
+                                                     evt_length, flags,
+                                                     attr, strp);
 }
 
 static int check_events(const char *str, unsigned int i)
@@ -477,7 +562,7 @@ static int check_events(const char *str, unsigned int i)
         return 0;
 }
 
-static int
+static enum event_result
 parse_symbolic_event(const char **strp, struct perf_counter_attr *attr)
 {
         const char *str = *strp;
@@ -490,31 +575,32 @@ parse_symbolic_event(const char **strp, struct perf_counter_attr *attr)
                         attr->type = event_symbols[i].type;
                         attr->config = event_symbols[i].config;
                         *strp = str + n;
-                        return 1;
+                        return EVT_HANDLED;
                 }
         }
-        return 0;
+        return EVT_FAILED;
 }
 
-static int parse_raw_event(const char **strp, struct perf_counter_attr *attr)
+static enum event_result
+parse_raw_event(const char **strp, struct perf_counter_attr *attr)
 {
         const char *str = *strp;
         u64 config;
         int n;
 
         if (*str != 'r')
-                return 0;
+                return EVT_FAILED;
         n = hex2u64(str + 1, &config);
         if (n > 0) {
                 *strp = str + n + 1;
                 attr->type = PERF_TYPE_RAW;
                 attr->config = config;
-                return 1;
+                return EVT_HANDLED;
         }
-        return 0;
+        return EVT_FAILED;
 }
 
-static int
+static enum event_result
 parse_numeric_event(const char **strp, struct perf_counter_attr *attr)
 {
         const char *str = *strp;
@@ -530,13 +616,13 @@ parse_numeric_event(const char **strp, struct perf_counter_attr *attr)
                         attr->type = type;
                         attr->config = config;
                         *strp = endp;
-                        return 1;
+                        return EVT_HANDLED;
                 }
         }
-        return 0;
+        return EVT_FAILED;
 }
 
-static int
+static enum event_result
 parse_event_modifier(const char **strp, struct perf_counter_attr *attr)
 {
         const char *str = *strp;
@@ -569,37 +655,84 @@ parse_event_modifier(const char **strp, struct perf_counter_attr *attr)
  * Each event can have multiple symbolic names.
  * Symbolic names are (almost) exactly matched.
  */
-static int parse_event_symbols(const char **str, struct perf_counter_attr *attr)
+static enum event_result
+parse_event_symbols(const char **str, struct perf_counter_attr *attr)
 {
-        if (!(parse_tracepoint_event(str, attr) ||
-              parse_raw_event(str, attr) ||
-              parse_numeric_event(str, attr) ||
-              parse_symbolic_event(str, attr) ||
-              parse_generic_hw_event(str, attr)))
-                return 0;
+        enum event_result ret;
+
+        ret = parse_tracepoint_event(str, attr);
+        if (ret != EVT_FAILED)
+                goto modifier;
+
+        ret = parse_raw_event(str, attr);
+        if (ret != EVT_FAILED)
+                goto modifier;
+
+        ret = parse_numeric_event(str, attr);
+        if (ret != EVT_FAILED)
+                goto modifier;
+
+        ret = parse_symbolic_event(str, attr);
+        if (ret != EVT_FAILED)
+                goto modifier;
 
+        ret = parse_generic_hw_event(str, attr);
+        if (ret != EVT_FAILED)
+                goto modifier;
+
+        return EVT_FAILED;
+
+modifier:
         parse_event_modifier(str, attr);
 
-        return 1;
+        return ret;
 }
 
+static void store_event_type(const char *orgname)
+{
+        char filename[PATH_MAX], *c;
+        FILE *file;
+        int id;
+
+        sprintf(filename, "/sys/kernel/debug/tracing/events/%s/id", orgname);
+        c = strchr(filename, ':');
+        if (c)
+                *c = '/';
+
+        file = fopen(filename, "r");
+        if (!file)
+                return;
+        if (fscanf(file, "%i", &id) < 1)
+                die("cannot store event ID");
+        fclose(file);
+        perf_header__push_event(id, orgname);
+}
+
+
 int parse_events(const struct option *opt __used, const char *str, int unset __used)
 {
         struct perf_counter_attr attr;
+        enum event_result ret;
+
+        if (strchr(str, ':'))
+                store_event_type(str);
 
         for (;;) {
                 if (nr_counters == MAX_COUNTERS)
                         return -1;
 
                 memset(&attr, 0, sizeof(attr));
-                if (!parse_event_symbols(&str, &attr))
+                ret = parse_event_symbols(&str, &attr);
+                if (ret == EVT_FAILED)
                         return -1;
 
                 if (!(*str == 0 || *str == ',' || isspace(*str)))
                         return -1;
 
-                attrs[nr_counters] = attr;
-                nr_counters++;
+                if (ret != EVT_HANDLED_ALL) {
+                        attrs[nr_counters] = attr;
+                        nr_counters++;
+                }
 
                 if (*str == 0)
                         break;
diff --git a/tools/perf/util/parse-options.h b/tools/perf/util/parse-options.h
index 8aa3464c7090..2ee248ff27e5 100644
--- a/tools/perf/util/parse-options.h
+++ b/tools/perf/util/parse-options.h
@@ -104,6 +104,8 @@ struct option {
         { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), .argh = "time", .help = (h), .callback = parse_opt_approxidate_cb }
 #define OPT_CALLBACK(s, l, v, a, h, f) \
         { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h), .callback = (f) }
+#define OPT_CALLBACK_NOOPT(s, l, v, a, h, f) \
+        { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h), .callback = (f), .flags = PARSE_OPT_NOARG }
 #define OPT_CALLBACK_DEFAULT(s, l, v, a, h, f, d) \
         { .type = OPTION_CALLBACK, .short_name = (s), .long_name = (l), .value = (v), (a), .help = (h), .callback = (f), .defval = (intptr_t)d, .flags = PARSE_OPT_LASTARG_DEFAULT }
 
diff --git a/tools/perf/util/svghelper.c b/tools/perf/util/svghelper.c
new file mode 100644
index 000000000000..b0fcecdf378d
--- /dev/null
+++ b/tools/perf/util/svghelper.c
@@ -0,0 +1,384 @@
+/*
+ * svghelper.c - helper functions for outputting svg
+ *
+ * (C) Copyright 2009 Intel Corporation
+ *
+ * Authors:
+ *     Arjan van de Ven <arjan@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; version 2
+ * of the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "svghelper.h"
+
+static u64 first_time, last_time;
+static u64 turbo_frequency, max_freq;
+
+
+#define SLOT_MULT 30.0
+#define SLOT_HEIGHT 25.0
+#define WIDTH 1000.0
+
+#define MIN_TEXT_SIZE 0.001
+
+static u64 total_height;
+static FILE *svgfile;
+
+static double cpu2slot(int cpu)
+{
+        return 2 * cpu + 1;
+}
+
+static double cpu2y(int cpu)
+{
+        return cpu2slot(cpu) * SLOT_MULT;
+}
+
+static double time2pixels(u64 time)
+{
+        double X;
+
+        X = WIDTH * (time - first_time) / (last_time - first_time);
+        return X;
+}
+
+void open_svg(const char *filename, int cpus, int rows)
+{
+
+        svgfile = fopen(filename, "w");
+        if (!svgfile) {
+                fprintf(stderr, "Cannot open %s for output\n", filename);
+                return;
+        }
+        total_height = (1 + rows + cpu2slot(cpus)) * SLOT_MULT;
+        fprintf(svgfile, "<?xml version=\"1.0\" standalone=\"no\"?> \n");
+        fprintf(svgfile, "<svg width=\"%4.1f\" height=\"%llu\" version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">\n", WIDTH, total_height);
+
+        fprintf(svgfile, "<defs>\n  <style type=\"text/css\">\n    <![CDATA[\n");
+
+        fprintf(svgfile, "      rect          { stroke-width: 1; }\n");
+        fprintf(svgfile, "      rect.process  { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:1;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.process2 { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.sample   { fill:rgb(  0,  0,255); fill-opacity:0.8; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.blocked  { fill:rgb(255,  0,  0); fill-opacity:0.5; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.waiting  { fill:rgb(255,255,  0); fill-opacity:0.3; stroke-width:0;   stroke:rgb(  0,  0,  0); } \n");
+        fprintf(svgfile, "      rect.cpu      { fill:rgb(192,192,192); fill-opacity:0.2; stroke-width:0.5; stroke:rgb(128,128,128); } \n");
+        fprintf(svgfile, "      rect.pstate   { fill:rgb(128,128,128); fill-opacity:0.8; stroke-width:0; } \n");
+        fprintf(svgfile, "      rect.c1       { fill:rgb(255,214,214); fill-opacity:0.5; stroke-width:0; } \n");
+        fprintf(svgfile, "      rect.c2       { fill:rgb(255,172,172); fill-opacity:0.5; stroke-width:0; } \n");
+        fprintf(svgfile, "      rect.c3       { fill:rgb(255,130,130); fill-opacity:0.5; stroke-width:0; } \n");
+        fprintf(svgfile, "      rect.c4       { fill:rgb(255, 88, 88); fill-opacity:0.5; stroke-width:0; } \n");
+        fprintf(svgfile, "      rect.c5       { fill:rgb(255, 44, 44); fill-opacity:0.5; stroke-width:0; } \n");
+        fprintf(svgfile, "      rect.c6       { fill:rgb(255,  0,  0); fill-opacity:0.5; stroke-width:0; } \n");
+        fprintf(svgfile, "      line.pstate   { stroke:rgb(255,255,  0); stroke-opacity:0.8; stroke-width:2; } \n");
+
+        fprintf(svgfile, "    ]]>\n   </style>\n</defs>\n");
+}
+
+void svg_box(int Yslot, u64 start, u64 end, const char *type)
+{
+        if (!svgfile)
+                return;
+
+        fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
+                time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT, type);
+}
+
+void svg_sample(int Yslot, int cpu, u64 start, u64 end, const char *type)
+{
+        double text_size;
+        if (!svgfile)
+                return;
+
+        fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
+                time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT, type);
+
+        text_size = (time2pixels(end)-time2pixels(start));
+        if (cpu > 9)
+                text_size = text_size/2;
+        if (text_size > 1.25)
+                text_size = 1.25;
+        if (text_size > MIN_TEXT_SIZE)
+                fprintf(svgfile, "<text transform=\"translate(%1.8f,%1.8f)\" font-size=\"%1.6fpt\">%i</text>\n",
+                        time2pixels(start), Yslot *  SLOT_MULT + SLOT_HEIGHT - 1, text_size,  cpu + 1);
+
+}
+
+static char *cpu_model(void)
+{
+        static char cpu_m[255];
+        char buf[256];
+        FILE *file;
+
+        cpu_m[0] = 0;
+        /* CPU type */
+        file = fopen("/proc/cpuinfo", "r");
+        if (file) {
+                while (fgets(buf, 255, file)) {
+                        if (strstr(buf, "model name")) {
+                                strncpy(cpu_m, &buf[13], 255);
+                                break;
+                        }
+                }
+                fclose(file);
+        }
+        return cpu_m;
+}
+
+void svg_cpu_box(int cpu, u64 __max_freq, u64 __turbo_freq)
+{
+        char cpu_string[80];
+        if (!svgfile)
+                return;
+
+        max_freq = __max_freq;
+        turbo_frequency = __turbo_freq;
+
+        fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"cpu\"/>\n",
+                time2pixels(first_time),
+                time2pixels(last_time)-time2pixels(first_time),
+                cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
+
+        sprintf(cpu_string, "CPU %i", (int)cpu+1);
+        fprintf(svgfile, "<text transform=\"translate(%4.8f,%4.8f)\">%s</text>\n",
+                10+time2pixels(first_time), cpu2y(cpu) + SLOT_HEIGHT/2, cpu_string);
+
+        fprintf(svgfile, "<text transform=\"translate(%4.8f,%4.8f)\" font-size=\"1.25pt\">%s</text>\n",
+                10+time2pixels(first_time), cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - 4, cpu_model());
+}
+
+void svg_process(int cpu, u64 start, u64 end, const char *type, const char *name)
+{
+        double width;
+
+        if (!svgfile)
+                return;
+
+        fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
+                time2pixels(start), time2pixels(end)-time2pixels(start), cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT, type);
+        width = time2pixels(end)-time2pixels(start);
+        if (width > 6)
+                width = 6;
+
+        if (width > MIN_TEXT_SIZE)
+                fprintf(svgfile, "<text  transform=\"translate(%4.8f,%4.8f) rotate(90)\" font-size=\"%3.4fpt\">%s</text>\n",
+                        time2pixels(start), cpu2y(cpu), width, name);
+}
+
+void svg_cstate(int cpu, u64 start, u64 end, int type)
+{
+        double width;
+        char style[128];
+
+        if (!svgfile)
+                return;
+
+
+        if (type > 6)
+                type = 6;
+        sprintf(style, "c%i", type);
+
+        fprintf(svgfile, "<rect class=\"%s\" x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\"/>\n",
+                style,
+                time2pixels(start), time2pixels(end)-time2pixels(start),
+                cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
+
+        width = time2pixels(end)-time2pixels(start);
+        if (width > 6)
+                width = 6;
+
+        if (width > MIN_TEXT_SIZE)
+                fprintf(svgfile, "<text  transform=\"translate(%4.8f,%4.8f) rotate(90)\" font-size=\"%3.4fpt\">C%i</text>\n",
+                        time2pixels(start), cpu2y(cpu), width, type);
+}
+
+static char *HzToHuman(unsigned long hz)
+{
+        static char buffer[1024];
+        unsigned long long Hz;
+
+        memset(buffer, 0, 1024);
+
+        Hz = hz;
+
+        /* default: just put the Number in */
+        sprintf(buffer, "%9lli", Hz);
+
+        if (Hz > 1000)
+                sprintf(buffer, " %6lli Mhz", (Hz+500)/1000);
+
+        if (Hz > 1500000)
+                sprintf(buffer, " %6.2f Ghz", (Hz+5000.0)/1000000);
+
+        if (Hz == turbo_frequency)
+                sprintf(buffer, "Turbo");
+
+        return buffer;
+}
+
+void svg_pstate(int cpu, u64 start, u64 end, u64 freq)
+{
+        double height = 0;
+
+        if (!svgfile)
+                return;
+
+        if (max_freq)
+                height = freq * 1.0 / max_freq * (SLOT_HEIGHT + SLOT_MULT);
+        height = 1 + cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - height;
+        fprintf(svgfile, "<line x1=\"%4.8f\" x2=\"%4.8f\" y1=\"%4.1f\" y2=\"%4.1f\" class=\"pstate\"/>\n",
+                time2pixels(start), time2pixels(end), height, height);
+        fprintf(svgfile, "<text transform=\"translate(%4.8f,%4.8f)\" font-size=\"0.25pt\">%s</text>\n",
+                time2pixels(start), height+0.9, HzToHuman(freq));
+
+}
+
+
+void svg_partial_wakeline(u64 start, int row1, int row2)
+{
+        double height;
+
+        if (!svgfile)
+                return;
+
+
+        if (row1 < row2) {
+                if (row1)
+                        fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                                time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT,  time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
+
+                if (row2)
+                        fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                                time2pixels(start), row2 * SLOT_MULT - SLOT_MULT/32,  time2pixels(start), row2 * SLOT_MULT);
+        } else {
+                if (row2)
+                        fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                                time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT,  time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
+
+                if (row1)
+                        fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                                time2pixels(start), row1 * SLOT_MULT - SLOT_MULT/32,  time2pixels(start), row1 * SLOT_MULT);
+        }
+        height = row1 * SLOT_MULT;
+        if (row2 > row1)
+                height += SLOT_HEIGHT;
+        if (row1)
+                fprintf(svgfile, "<circle  cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\"  style=\"fill:rgb(32,255,32)\"/>\n",
+                        time2pixels(start), height);
+}
+
+void svg_wakeline(u64 start, int row1, int row2)
+{
+        double height;
+
+        if (!svgfile)
+                return;
+
+
+        if (row1 < row2)
+                fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                        time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT,  time2pixels(start), row2 * SLOT_MULT);
+        else
+                fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
+                        time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT,  time2pixels(start), row1 * SLOT_MULT);
+
+        height = row1 * SLOT_MULT;
+        if (row2 > row1)
+                height += SLOT_HEIGHT;
+        fprintf(svgfile, "<circle  cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\"  style=\"fill:rgb(32,255,32)\"/>\n",
+                        time2pixels(start), height);
+}
+
+void svg_interrupt(u64 start, int row)
+{
+        if (!svgfile)
+                return;
+
+        fprintf(svgfile, "<circle  cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\"  style=\"fill:rgb(255,128,128)\"/>\n",
+                        time2pixels(start), row * SLOT_MULT);
+        fprintf(svgfile, "<circle  cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\"  style=\"fill:rgb(255,128,128)\"/>\n",
+                        time2pixels(start), row * SLOT_MULT + SLOT_HEIGHT);
+}
+
+void svg_text(int Yslot, u64 start, const char *text)
+{
+        if (!svgfile)
+                return;
+
+        fprintf(svgfile, "<text transform=\"translate(%4.8f,%4.8f)\">%s</text>\n",
+                time2pixels(start), Yslot * SLOT_MULT+SLOT_HEIGHT/2, text);
+}
+
+static void svg_legenda_box(int X, const char *text, const char *style)
+{
+        double boxsize;
+        boxsize = SLOT_HEIGHT / 2;
+
+        fprintf(svgfile, "<rect x=\"%i\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
+                X, boxsize, boxsize, style);
+        fprintf(svgfile, "<text transform=\"translate(%4.8f, %4.8f)\" font-size=\"%4.4fpt\">%s</text>\n",
+                X + boxsize + 5, boxsize, 0.8 * boxsize, text);
+}
+
+void svg_legenda(void)
+{
+        if (!svgfile)
+                return;
+
+        svg_legenda_box(0,      "Running", "sample");
+        svg_legenda_box(100,    "Idle","rect.c1");
+        svg_legenda_box(200,    "Deeper Idle", "rect.c3");
+        svg_legenda_box(350,    "Deepest Idle", "rect.c6");
+        svg_legenda_box(550,    "Sleeping", "process2");
+        svg_legenda_box(650,    "Waiting for cpu", "waiting");
+        svg_legenda_box(800,    "Blocked on IO", "blocked");
+}
+
+void svg_time_grid(u64 start, u64 end)
+{
+        u64 i;
+
+        first_time = start;
+        last_time = end;
+
+        first_time = first_time / 100000000 * 100000000;
+
+        if (!svgfile)
+                return;
+
+        i = first_time;
+        while (i < last_time) {
+                int color = 220;
+                double thickness = 0.075;
+                if ((i % 100000000) == 0) {
+                        thickness = 0.5;
+                        color = 192;
+                }
+                if ((i % 1000000000) == 0) {
+                        thickness = 2.0;
+                        color = 128;
+                }
+
+                fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%llu\" style=\"stroke:rgb(%i,%i,%i);stroke-width:%1.3f\"/>\n",
+                        time2pixels(i), SLOT_MULT/2, time2pixels(i), total_height, color, color, color, thickness);
+
+                i += 10000000;
+        }
+}
+
+void svg_close(void)
+{
+        if (svgfile) {
+                fprintf(svgfile, "</svg>\n");
+                fclose(svgfile);
+                svgfile = NULL;
+        }
+}
diff --git a/tools/perf/util/svghelper.h b/tools/perf/util/svghelper.h
new file mode 100644
index 000000000000..ad79b5dc53de
--- /dev/null
+++ b/tools/perf/util/svghelper.h
@@ -0,0 +1,25 @@
+#ifndef _INCLUDE_GUARD_SVG_HELPER_
+#define _INCLUDE_GUARD_SVG_HELPER_
+
+#include "types.h"
+
+extern void open_svg(const char *filename, int cpus, int rows);
+extern void svg_box(int Yslot, u64 start, u64 end, const char *type);
+extern void svg_sample(int Yslot, int cpu, u64 start, u64 end, const char *type);
+extern void svg_cpu_box(int cpu, u64 max_frequency, u64 turbo_frequency);
+
+
+extern void svg_process(int cpu, u64 start, u64 end, const char *type, const char *name);
+extern void svg_cstate(int cpu, u64 start, u64 end, int type);
+extern void svg_pstate(int cpu, u64 start, u64 end, u64 freq);
+
+
+extern void svg_time_grid(u64 start, u64 end);
+extern void svg_legenda(void);
+extern void svg_wakeline(u64 start, int row1, int row2);
+extern void svg_partial_wakeline(u64 start, int row1, int row2);
+extern void svg_interrupt(u64 start, int row);
+extern void svg_text(int Yslot, u64 start, const char *text);
+extern void svg_close(void);
+
+#endif
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 7635928ca278..45efb5db0d19 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -8,7 +8,7 @@
 
 static struct thread *thread__new(pid_t pid)
 {
-        struct thread *self = malloc(sizeof(*self));
+        struct thread *self = calloc(1, sizeof(*self));
 
         if (self != NULL) {
                 self->pid = pid;
@@ -85,7 +85,7 @@ register_idle_thread(struct rb_root *threads, struct thread **last_match)
 {
         struct thread *thread = threads__findnew(0, threads, last_match);
 
-        if (!thread || thread__set_comm(thread, "[init]")) {
+        if (!thread || thread__set_comm(thread, "swapper")) {
                 fprintf(stderr, "problem inserting idle task.\n");
                 exit(-1);
         }
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 634f2809a342..32aea3c1c2ad 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -4,10 +4,11 @@
 #include "symbol.h"
 
 struct thread {
-        struct rb_node   rb_node;
-        struct list_head maps;
-        pid_t            pid;
-        char             *comm;
+        struct rb_node          rb_node;
+        struct list_head        maps;
+        pid_t                   pid;
+        char                    shortname[3];
+        char                    *comm;
 };
 
 int thread__set_comm(struct thread *self, const char *comm);
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 6c9302a7274c..1fd824c1f1c4 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -458,7 +458,7 @@ static void read_proc_kallsyms(void)
 static void read_ftrace_printk(void)
 {
         unsigned int size, check_size;
-        const char *path;
+        char *path;
         struct stat st;
         int ret;
 
@@ -468,14 +468,15 @@ static void read_ftrace_printk(void)
                 /* not found */
                 size = 0;
                 write_or_die(&size, 4);
-                return;
+                goto out;
         }
         size = get_size(path);
         write_or_die(&size, 4);
         check_size = copy_file(path);
         if (size != check_size)
                 die("error in size of file '%s'", path);
-
+out:
+        put_tracing_file(path);
 }
 
 static struct tracepoint_path *
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 629e602d9405..f6a8437141c8 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -1776,6 +1776,29 @@ static unsigned long long read_size(void *ptr, int size)
         }
 }
 
+unsigned long long
+raw_field_value(struct event *event, const char *name, void *data)
+{
+        struct format_field *field;
+
+        field = find_any_field(event, name);
+        if (!field)
+                return 0ULL;
+
+        return read_size(data + field->offset, field->size);
+}
+
+void *raw_field_ptr(struct event *event, const char *name, void *data)
+{
+        struct format_field *field;
+
+        field = find_any_field(event, name);
+        if (!field)
+                return NULL;
+
+        return data + field->offset;
+}
+
 static int get_common_info(const char *type, int *offset, int *size)
 {
         struct event *event;
@@ -1799,7 +1822,7 @@ static int get_common_info(const char *type, int *offset, int *size)
         return 0;
 }
 
-static int parse_common_type(void *data)
+int trace_parse_common_type(void *data)
 {
         static int type_offset;
         static int type_size;
@@ -1832,7 +1855,7 @@ static int parse_common_pid(void *data)
         return read_size(data + pid_offset, pid_size);
 }
 
-static struct event *find_event(int id)
+struct event *trace_find_event(int id)
 {
         struct event *event;
 
@@ -2420,8 +2443,8 @@ get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func,
         int type;
         int pid;
 
-        type = parse_common_type(next->data);
-        event = find_event(type);
+        type = trace_parse_common_type(next->data);
+        event = trace_find_event(type);
         if (!event)
                 return NULL;
 
@@ -2502,8 +2525,8 @@ print_graph_entry_leaf(struct event *event, void *data, struct record *ret_rec)
         int type;
         int i;
 
-        type = parse_common_type(ret_rec->data);
-        ret_event = find_event(type);
+        type = trace_parse_common_type(ret_rec->data);
+        ret_event = trace_find_event(type);
 
         field = find_field(ret_event, "rettime");
         if (!field)
@@ -2696,11 +2719,13 @@ void print_event(int cpu, void *data, int size, unsigned long long nsecs,
         nsecs -= secs * NSECS_PER_SEC;
         usecs = nsecs / NSECS_PER_USEC;
 
-        type = parse_common_type(data);
+        type = trace_parse_common_type(data);
 
-        event = find_event(type);
-        if (!event)
-                die("ug! no event found for type %d", type);
+        event = trace_find_event(type);
+        if (!event) {
+                printf("ug! no event found for type %d\n", type);
+                return;
+        }
 
         pid = parse_common_pid(data);
 
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index a1217a10632f..1b5c847d2c22 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -458,12 +458,13 @@ struct record *trace_read_data(int cpu)
         return data;
 }
 
-void trace_report (void)
+void trace_report(void)
 {
         const char *input_file = "trace.info";
         char buf[BUFSIZ];
         char test[] = { 23, 8, 68 };
         char *version;
+        int show_version = 0;
         int show_funcs = 0;
         int show_printk = 0;
 
@@ -480,7 +481,8 @@ void trace_report (void)
                 die("not a trace file (missing tracing)");
 
         version = read_string();
-        printf("version = %s\n", version);
+        if (show_version)
+                printf("version = %s\n", version);
         free(version);
 
         read_or_die(buf, 1);
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 420294a5773e..d35ebf1e29ff 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -234,6 +234,11 @@ extern int header_page_data_offset;
 extern int header_page_data_size;
 
 int parse_header_page(char *buf, unsigned long size);
+int trace_parse_common_type(void *data);
+struct event *trace_find_event(int id);
+unsigned long long
+raw_field_value(struct event *event, const char *name, void *data);
+void *raw_field_ptr(struct event *event, const char *name, void *data);
 
 void read_tracing_data(struct perf_counter_attr *pattrs, int nb_counters);