add latency format option to all output

All traces have info about interrupts disabled, preempt count
and needing rescheduling. Add an option to expose these.

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

4 files changed, 122 insertions, 20 deletions

diff --git a/parse-events.c b/parse-events.c
index 3581214..50ed6d9 100644
--- a/parse-events.c
+++ b/parse-events.c
@@ -36,6 +36,8 @@ int header_page_size_size;
 int header_page_data_offset;
 int header_page_data_size;
 
+int latency_format;
+
 static char *input_buf;
 static unsigned long long input_buf_ptr;
 static unsigned long long input_buf_siz;
@@ -1866,37 +1868,67 @@ static int get_common_info(const char *type, int *offset, int *size)
         return 0;
 }
 
-static int parse_common_type(void *data)
+static int __parse_common(void *data, int *size, int *offset,
+                          char *name)
 {
-        static int type_offset;
-        static int type_size;
         int ret;
 
-        if (!type_size) {
-                ret = get_common_info("common_type",
-                                      &type_offset,
-                                      &type_size);
+        if (!*size) {
+                ret = get_common_info(name, offset, size);
                 if (ret < 0)
                         return ret;
         }
-        return read_size(data + type_offset, type_size);
+        return read_size(data + *offset, *size);
+}
+
+static int parse_common_type(void *data)
+{
+        static int type_offset;
+        static int type_size;
+
+        return __parse_common(data, &type_size, &type_offset,
+                              "common_type");
 }
 
 static int parse_common_pid(void *data)
 {
         static int pid_offset;
         static int pid_size;
+
+        return __parse_common(data, &pid_size, &pid_offset,
+                              "common_pid");
+}
+
+static int parse_common_pc(void *data)
+{
+        static int pc_offset;
+        static int pc_size;
+
+        return __parse_common(data, &pc_size, &pc_offset,
+                              "common_preempt_count");
+}
+
+static int parse_common_flags(void *data)
+{
+        static int flags_offset;
+        static int flags_size;
+
+        return __parse_common(data, &flags_size, &flags_offset,
+                              "common_flags");
+}
+
+static int parse_common_lock_depth(void *data)
+{
+        static int ld_offset;
+        static int ld_size;
         int ret;
 
-        if (!pid_size) {
-                ret = get_common_info("common_pid",
-                                      &pid_offset,
-                                      &pid_size);
-                if (ret < 0)
-                        return ret;
-        }
+        ret = __parse_common(data, &ld_size, &ld_offset,
+                             "common_lock_depth");
+        if (ret < 0)
+                return -1;
 
-        return read_size(data + pid_offset, pid_size);
+        return ret;
 }
 
 static struct event *find_event(int id)
@@ -2438,6 +2470,41 @@ static inline int log10_cpu(int nb)
         return 1;
 }
 
+static void print_lat_fmt(void *data, int size)
+{
+        unsigned int flags;
+        unsigned int pc;
+        int lock_depth;
+        int hardirq;
+        int softirq;
+
+        flags = parse_common_flags(data);
+        pc = parse_common_pc(data);
+        lock_depth = parse_common_lock_depth(data);
+
+        hardirq = flags & TRACE_FLAG_HARDIRQ;
+        softirq = flags & TRACE_FLAG_SOFTIRQ;
+
+        printf("%c%c%c",
+               (flags & TRACE_FLAG_IRQS_OFF) ? 'd' :
+               (flags & TRACE_FLAG_IRQS_NOSUPPORT) ?
+               'X' : '.',
+               (flags & TRACE_FLAG_NEED_RESCHED) ?
+               'N' : '.',
+               (hardirq && softirq) ? 'H' :
+               hardirq ? 'h' : softirq ? 's' : '.');
+
+        if (pc)
+                printf("%x", pc);
+        else
+                printf(".");
+
+        if (lock_depth < 0)
+                printf(".");
+        else
+                printf("%d", lock_depth);
+}
+
 /* taken from Linux, written by Frederic Weisbecker */
 static void print_graph_cpu(int cpu)
 {
@@ -2681,6 +2748,11 @@ pretty_print_func_ent(void *data, int size, struct event *event,
 
         printf(" | ");
 
+        if (latency_format) {
+                print_lat_fmt(data, size);
+                printf(" | ");
+        }
+
         field = find_field(event, "func");
         if (!field)
                 die("function entry does not have func field");
@@ -2724,6 +2796,11 @@ pretty_print_func_ret(void *data, int size, struct event *event,
 
         printf(" | ");
 
+        if (latency_format) {
+                print_lat_fmt(data, size);
+                printf(" | ");
+        }
+
         field = find_field(event, "rettime");
         if (!field)
                 die("can't find rettime in return graph");
@@ -2794,9 +2871,15 @@ void print_event(int cpu, void *data, int size, unsigned long long nsecs)
                 return pretty_print_func_graph(data, size, event, cpu,
                                                pid, comm, secs, usecs);
 
-        printf("%16s-%-5d [%03d] %5lu.%06lu: %s: ",
-               comm, pid,  cpu,
-               secs, usecs, event->name);
+        if (latency_format) {
+                printf("%8.8s-%-5d %3d",
+                       comm, pid, cpu);
+                print_lat_fmt(data, size);
+        } else
+                printf("%16s-%-5d [%03d] %5lu.%06lu: %s: ",
+                       comm, pid,  cpu,
+                       secs, usecs, event->name);
+
 
         if (event->flags & EVENT_FL_FAILED) {
                 printf("EVENT '%s' FAILED TO PARSE\n",
diff --git a/parse-events.h b/parse-events.h
index d517ba2..d9e8f4f 100644
--- a/parse-events.h
+++ b/parse-events.h
@@ -234,6 +234,17 @@ extern int header_page_size_size;
 extern int header_page_data_offset;
 extern int header_page_data_size;
 
+extern int latency_format;
+
 int parse_header_page(char *buf, unsigned long size);
 
+/* taken from kernel/trace/trace.h */
+enum trace_flag_type {
+        TRACE_FLAG_IRQS_OFF             = 0x01,
+        TRACE_FLAG_IRQS_NOSUPPORT       = 0x02,
+        TRACE_FLAG_NEED_RESCHED         = 0x04,
+        TRACE_FLAG_HARDIRQ              = 0x08,
+        TRACE_FLAG_SOFTIRQ              = 0x10,
+};
+
 #endif /* _PARSE_EVENTS_H */
diff --git a/trace-cmd.c b/trace-cmd.c
index 3657dd3..25e9692 100644
--- a/trace-cmd.c
+++ b/trace-cmd.c
@@ -153,6 +153,8 @@ void warn(char *fmt, ...)
 
         if (errno)
                 perror("trace-cmd");
+        breakpoint();
+        errno = 0;
 
         va_start(ap, fmt);
         fprintf(stderr, "  ");
@@ -1039,6 +1041,7 @@ void usage(char **argv)
                "          -e show file endianess\n"
                "          -f show function list\n"
                "          -P show printk list\n"
+               "          -l show latency format (default with latency tracers)\n"
                "\n"
                " %s list [-e][-p]\n"
                "          -e list available events\n"
@@ -1058,6 +1061,8 @@ int main (int argc, char **argv)
 
         int c;
 
+        errno = 0;
+
         if (argc < 2)
                 usage(argv);
 
diff --git a/trace-read.c b/trace-read.c
index d3faede..b3cb20a 100644
--- a/trace-read.c
+++ b/trace-read.c
@@ -613,7 +613,7 @@ void trace_report (int argc, char **argv)
                         {NULL, 0, NULL, 0}
                 };
 
-                c = getopt_long (argc-1, argv+1, "+hi:fepP",
+                c = getopt_long (argc-1, argv+1, "+hi:fepPl",
                         long_options, &option_index);
                 if (c == -1)
                         break;
@@ -636,6 +636,9 @@ void trace_report (int argc, char **argv)
                 case 'p':
                         show_page_size = 1;
                         break;
+                case 'l':
+                        latency_format = 1;
+                        break;
                 case 0:
                         switch(option_index) {
                         case 0: