Handle old format

Update to read the old file format for 2.6.30. It is very limited,
but can process a little.

Unfortunately, the printk_formats file is broken for 2.6.30.

Signed-off-by: Steven Rostedt <rostedt@goodmis.org>

4 files changed, 169 insertions, 5 deletions

diff --git a/parse-events.c b/parse-events.c
index cbd9773..4e48faa 100644
--- a/parse-events.c
+++ b/parse-events.c
@@ -40,6 +40,8 @@ int header_page_data_size;
 
 int latency_format;
 
+int old_format;
+
 static char *input_buf;
 static unsigned long long input_buf_ptr;
 static unsigned long long input_buf_siz;
@@ -3140,6 +3142,17 @@ static void parse_header_field(const char *field,
 
 int parse_header_page(char *buf, unsigned long size)
 {
+        if (!size) {
+                /*
+                 * Old kernels did not have header page info.
+                 * Sorry but we just use what we find here in user space.
+                 */
+                header_page_ts_size = sizeof(long long);
+                header_page_size_size = sizeof(long);
+                header_page_data_offset = sizeof(long long) + sizeof(long);
+                old_format = 1;
+                return 0;
+        }
         init_input_buf(buf, size);
 
         parse_header_field("timestamp", &header_page_ts_offset,
diff --git a/parse-events.h b/parse-events.h
index 740da6c..4858a52 100644
--- a/parse-events.h
+++ b/parse-events.h
@@ -163,6 +163,8 @@ struct record {
 struct record *trace_peek_data(int cpu);
 struct record *trace_read_data(int cpu);
 
+extern int old_format;
+
 void parse_set_info(int nr_cpus, int long_sz);
 
 void trace_report(int argc, char **argv);
diff --git a/trace-cmd.c b/trace-cmd.c
index 9e69aee..2a531bb 100644
--- a/trace-cmd.c
+++ b/trace-cmd.c
@@ -421,6 +421,7 @@ static void set_option(const char *option)
 
 static void enable_event(const char *name)
 {
+        struct stat st;
         FILE *fp;
         char *path;
         int ret;
@@ -428,6 +429,21 @@ static void enable_event(const char *name)
         fprintf(stderr, "enable %s\n", name);
         if (strcmp(name, "all") == 0) {
                 path = get_tracing_file("events/enable");
+
+                ret = stat(path, &st);
+                if (ret < 0) {
+                        put_tracing_file(path);
+                        /* need to use old way */
+                        path = get_tracing_file("set_event");
+                        fp = fopen(path, "w");
+                        if (!fp)
+                                die("writing to '%s'", path);
+                        put_tracing_file(path);
+                        fwrite("*:*\n", 4, 1, fp);
+                        fclose(fp);
+                        return;
+                }
+
                 fp = fopen(path, "w");
                 if (!fp)
                         die("writing to '%s'", path);
@@ -455,11 +471,28 @@ static void enable_event(const char *name)
 
 static void disable_event(const char *name)
 {
+        struct stat st;
         FILE *fp;
         char *path;
+        int ret;
 
         if (strcmp(name, "all") == 0) {
                 path = get_tracing_file("events/enable");
+
+                ret = stat(path, &st);
+                if (ret < 0) {
+                        put_tracing_file(path);
+                        /* need to use old way */
+                        path = get_tracing_file("set_event");
+                        fp = fopen(path, "w");
+                        if (!fp)
+                                die("writing to '%s'", path);
+                        put_tracing_file(path);
+                        fwrite("\n", 1, 1, fp);
+                        fclose(fp);
+                        return;
+                }
+
                 fp = fopen(path, "w");
                 if (!fp)
                         die("writing to '%s'", path);
@@ -750,10 +783,25 @@ static unsigned long get_size(const char *file)
 static void read_header_files(void)
 {
         unsigned long long size, check_size;
+        struct stat st;
         char *path;
         int fd;
+        int ret;
 
         path = get_tracing_file("events/header_page");
+
+        ret = stat(path, &st);
+        if (ret < 0) {
+                /* old style did not show this info, just add zero */
+                put_tracing_file(path);
+                write_or_die("header_page", 12);
+                size = 0;
+                write_or_die(&size, 8);
+                write_or_die("header_event", 13);
+                write_or_die(&size, 8);
+                return;
+        }
+
         fd = open(path, O_RDONLY);
         if (fd < 0)
                 die("can't read '%s'", path);
@@ -1029,11 +1077,17 @@ static void read_thread_data(void)
          * Save the command lines;
          */
         file = get_tracing_file("saved_cmdlines");
-        size = get_size(file);
-        write_or_die(&size, 8);
-        check_size = copy_file(file);
-        if (size != check_size)
-                die("error in size of file '%s'", file);
+        ret = stat(file, &st);
+        if (ret >= 0) {
+                size = get_size(file);
+                write_or_die(&size, 8);
+                check_size = copy_file(file);
+                if (size != check_size)
+                        die("error in size of file '%s'", file);
+        } else {
+                size = 0;
+                write_or_die(&size, 8);
+        }
         put_tracing_file(file);
 
         write_or_die(&cpu_count, 4);
diff --git a/trace-read.c b/trace-read.c
index 79530bc..4b6d522 100644
--- a/trace-read.c
+++ b/trace-read.c
@@ -369,6 +369,22 @@ static void get_next_page(int cpu)
                     cpu, cpu_data[cpu].offset);
 }
 
+static unsigned int type4host(unsigned int type_len_ts)
+{
+        if (file_bigendian)
+                return (type_len_ts >> 29) & 3;
+        else
+                return type_len_ts & 3;
+}
+
+static unsigned int len4host(unsigned int type_len_ts)
+{
+        if (file_bigendian)
+                return (type_len_ts >> 27) & 7;
+        else
+                return (type_len_ts >> 2) & 7;
+}
+
 static unsigned int type_len4host(unsigned int type_len_ts)
 {
         if (file_bigendian)
@@ -389,6 +405,74 @@ static int calc_index(void *ptr, int cpu)
 {
         return (unsigned long)ptr - (unsigned long)cpu_data[cpu].page;
 }
+enum old_ring_buffer_type {
+        OLD_RINGBUF_TYPE_PADDING,
+        OLD_RINGBUF_TYPE_TIME_EXTEND,
+        OLD_RINGBUF_TYPE_TIME_STAMP,
+        OLD_RINGBUF_TYPE_DATA,
+};
+
+static struct record *read_old_format(void **ptr, int cpu)
+{
+        struct record *data;
+        unsigned long long extend;
+        unsigned int type_len_ts;
+        unsigned int type;
+        unsigned int len;
+        unsigned int delta;
+        unsigned int length;
+
+        type_len_ts = data2host4(*ptr);
+        *ptr += 4;
+
+        type = type4host(type_len_ts);
+        len = len4host(type_len_ts);
+        delta = ts4host(type_len_ts);
+
+        switch (type) {
+        case OLD_RINGBUF_TYPE_PADDING:
+                *ptr = (void *)(((unsigned long)*ptr + (page_size - 1)) &
+                                ~(page_size - 1));
+                return NULL;
+
+        case OLD_RINGBUF_TYPE_TIME_EXTEND:
+                extend = data2host4(ptr);
+                extend <<= TS_SHIFT;
+                extend += delta;
+                cpu_data[cpu].timestamp += extend;
+                *ptr += 4;
+                return NULL;
+
+        case OLD_RINGBUF_TYPE_TIME_STAMP:
+                die("should not be here");
+                break;
+        default:
+                if (len)
+                        length = len * 4;
+                else {
+                        length = data2host4(*ptr);
+                        length -= 4;
+                        *ptr += 4;
+                }
+                break;
+        }
+
+        cpu_data[cpu].timestamp += delta;
+
+        data = malloc_or_die(sizeof(*data));
+        memset(data, 0, sizeof(*data));
+
+        data->ts = cpu_data[cpu].timestamp;
+        data->size = length;
+        data->data = *ptr;
+
+        *ptr += ((length+3)/4) * 4;
+
+        cpu_data[cpu].index = calc_index(*ptr, cpu);
+        cpu_data[cpu].next = data;
+
+        return data;
+}
 
 struct record *trace_peek_data(int cpu)
 {
@@ -437,6 +521,17 @@ read_again:
                 return trace_peek_data(cpu);
         }
 
+        if (old_format) {
+                data = read_old_format(&ptr, cpu);
+                if (!data) {
+                        if (!ptr)
+                                return NULL;
+                        goto read_again;
+                }
+                        
+                return data;
+        }
+
         type_len_ts = data2host4(ptr);
         ptr += 4;