libata: struct device - replace bus_id with dev_name(), dev_set_name()

[pandora-kernel.git] / kernel / trace / trace_functions_graph.c

diff --git a/kernel/trace/trace_functions_graph.c b/kernel/trace/trace_functions_graph.c
index c66578f..930c08e 100644 (file)
--- a/kernel/trace/trace_functions_graph.c
+++ b/kernel/trace/trace_functions_graph.c
@@ -79,7 +79,7 @@ print_graph_cpu(struct trace_seq *s, int cpu)
        int i;
        int ret;
        int log10_this = log10_cpu(cpu);
-       int log10_all = log10_cpu(cpus_weight_nr(cpu_online_map));
+       int log10_all = log10_cpu(cpumask_weight(cpu_online_mask));
 
 
        /*
@@ -173,7 +173,7 @@ verif_pid(struct trace_seq *s, pid_t pid, int cpu)
 
  */
        ret = trace_seq_printf(s,
-               "\n ------------------------------------------\n |");
+               " ------------------------------------------\n");
        if (!ret)
                TRACE_TYPE_PARTIAL_LINE;
 
@@ -231,6 +231,49 @@ trace_branch_is_leaf(struct trace_iterator *iter,
        return true;
 }
 
+static enum print_line_t
+print_graph_irq(struct trace_seq *s, unsigned long addr,
+                               enum trace_type type, int cpu, pid_t pid)
+{
+       int ret;
+
+       if (addr < (unsigned long)__irqentry_text_start ||
+               addr >= (unsigned long)__irqentry_text_end)
+               return TRACE_TYPE_UNHANDLED;
+
+       if (type == TRACE_GRAPH_ENT) {
+               ret = trace_seq_printf(s, "==========> |  ");
+       } else {
+               /* Cpu */
+               if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
+                       ret = print_graph_cpu(s, cpu);
+                       if (ret == TRACE_TYPE_PARTIAL_LINE)
+                               return TRACE_TYPE_PARTIAL_LINE;
+               }
+               /* Proc */
+               if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
+                       ret = print_graph_proc(s, pid);
+                       if (ret == TRACE_TYPE_PARTIAL_LINE)
+                               return TRACE_TYPE_PARTIAL_LINE;
+
+                       ret = trace_seq_printf(s, " | ");
+                       if (!ret)
+                               return TRACE_TYPE_PARTIAL_LINE;
+               }
+
+               /* No overhead */
+               if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+                       ret = trace_seq_printf(s, "  ");
+                       if (!ret)
+                               return TRACE_TYPE_PARTIAL_LINE;
+               }
+
+               ret = trace_seq_printf(s, "<========== |\n");
+       }
+       if (!ret)
+               return TRACE_TYPE_PARTIAL_LINE;
+       return TRACE_TYPE_HANDLED;
+}
 
 static enum print_line_t
 print_graph_duration(unsigned long long duration, struct trace_seq *s)
@@ -344,7 +387,7 @@ print_graph_entry_leaf(struct trace_iterator *iter,
 
 static enum print_line_t
 print_graph_entry_nested(struct ftrace_graph_ent_entry *entry,
-                       struct trace_seq *s)
+                       struct trace_seq *s, pid_t pid, int cpu)
 {
        int i;
        int ret;
@@ -357,8 +400,18 @@ print_graph_entry_nested(struct ftrace_graph_ent_entry *entry,
                        return TRACE_TYPE_PARTIAL_LINE;
        }
 
-       /* No time */
-       ret = trace_seq_printf(s, "            |  ");
+       /* Interrupt */
+       ret = print_graph_irq(s, call->func, TRACE_GRAPH_ENT, cpu, pid);
+       if (ret == TRACE_TYPE_UNHANDLED) {
+               /* No time */
+               ret = trace_seq_printf(s, "            |  ");
+               if (!ret)
+                       return TRACE_TYPE_PARTIAL_LINE;
+       } else {
+               if (ret == TRACE_TYPE_PARTIAL_LINE)
+                       return TRACE_TYPE_PARTIAL_LINE;
+       }
+
 
        /* Function */
        for (i = 0; i < call->depth * TRACE_GRAPH_INDENT; i++) {
@@ -410,7 +463,7 @@ print_graph_entry(struct ftrace_graph_ent_entry *field, struct trace_seq *s,
        if (trace_branch_is_leaf(iter, field))
                return print_graph_entry_leaf(iter, field, s);
        else
-               return print_graph_entry_nested(field, s);
+               return print_graph_entry_nested(field, s, iter->ent->pid, cpu);
 
 }
 
@@ -474,9 +527,79 @@ print_graph_return(struct ftrace_graph_ret *trace, struct trace_seq *s,
                if (!ret)
                        return TRACE_TYPE_PARTIAL_LINE;
        }
+
+       ret = print_graph_irq(s, trace->func, TRACE_GRAPH_RET, cpu, ent->pid);
+       if (ret == TRACE_TYPE_PARTIAL_LINE)
+               return TRACE_TYPE_PARTIAL_LINE;
+
        return TRACE_TYPE_HANDLED;
 }
 
+static enum print_line_t
+print_graph_comment(struct print_entry *trace, struct trace_seq *s,
+                  struct trace_entry *ent, struct trace_iterator *iter)
+{
+       int i;
+       int ret;
+
+       /* Pid */
+       if (verif_pid(s, ent->pid, iter->cpu) == TRACE_TYPE_PARTIAL_LINE)
+               return TRACE_TYPE_PARTIAL_LINE;
+
+       /* Cpu */
+       if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU) {
+               ret = print_graph_cpu(s, iter->cpu);
+               if (ret == TRACE_TYPE_PARTIAL_LINE)
+                       return TRACE_TYPE_PARTIAL_LINE;
+       }
+
+       /* Proc */
+       if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC) {
+               ret = print_graph_proc(s, ent->pid);
+               if (ret == TRACE_TYPE_PARTIAL_LINE)
+                       return TRACE_TYPE_PARTIAL_LINE;
+
+               ret = trace_seq_printf(s, " | ");
+               if (!ret)
+                       return TRACE_TYPE_PARTIAL_LINE;
+       }
+
+       /* No overhead */
+       if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+               ret = trace_seq_printf(s, "  ");
+               if (!ret)
+                       return TRACE_TYPE_PARTIAL_LINE;
+       }
+
+       /* No time */
+       ret = trace_seq_printf(s, "            |  ");
+       if (!ret)
+               return TRACE_TYPE_PARTIAL_LINE;
+
+       /* Indentation */
+       if (trace->depth > 0)
+               for (i = 0; i < (trace->depth + 1) * TRACE_GRAPH_INDENT; i++) {
+                       ret = trace_seq_printf(s, " ");
+                       if (!ret)
+                               return TRACE_TYPE_PARTIAL_LINE;
+               }
+
+       /* The comment */
+       ret = trace_seq_printf(s, "/* %s", trace->buf);
+       if (!ret)
+               return TRACE_TYPE_PARTIAL_LINE;
+
+       if (ent->flags & TRACE_FLAG_CONT)
+               trace_seq_print_cont(s, iter);
+
+       ret = trace_seq_printf(s, " */\n");
+       if (!ret)
+               return TRACE_TYPE_PARTIAL_LINE;
+
+       return TRACE_TYPE_HANDLED;
+}
+
+
 enum print_line_t
 print_graph_function(struct trace_iterator *iter)
 {
@@ -495,16 +618,46 @@ print_graph_function(struct trace_iterator *iter)
                trace_assign_type(field, entry);
                return print_graph_return(&field->ret, s, entry, iter->cpu);
        }
+       case TRACE_PRINT: {
+               struct print_entry *field;
+               trace_assign_type(field, entry);
+               return print_graph_comment(field, s, entry, iter);
+       }
        default:
                return TRACE_TYPE_UNHANDLED;
        }
 }
 
+static void print_graph_headers(struct seq_file *s)
+{
+       /* 1st line */
+       seq_printf(s, "# ");
+       if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
+               seq_printf(s, "CPU ");
+       if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
+               seq_printf(s, "TASK/PID     ");
+       if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD)
+               seq_printf(s, "OVERHEAD/");
+       seq_printf(s, "DURATION            FUNCTION CALLS\n");
+
+       /* 2nd line */
+       seq_printf(s, "# ");
+       if (tracer_flags.val & TRACE_GRAPH_PRINT_CPU)
+               seq_printf(s, "|   ");
+       if (tracer_flags.val & TRACE_GRAPH_PRINT_PROC)
+               seq_printf(s, "|      |     ");
+       if (tracer_flags.val & TRACE_GRAPH_PRINT_OVERHEAD) {
+               seq_printf(s, "|        ");
+               seq_printf(s, "|                   |   |   |   |\n");
+       } else
+               seq_printf(s, "    |               |   |   |   |\n");
+}
 static struct tracer graph_trace __read_mostly = {
-       .name        = "function_graph",
-       .init        = graph_trace_init,
-       .reset       = graph_trace_reset,
-       .print_line = print_graph_function,
+       .name           = "function_graph",
+       .init           = graph_trace_init,
+       .reset          = graph_trace_reset,
+       .print_line     = print_graph_function,
+       .print_header   = print_graph_headers,
        .flags          = &tracer_flags,
 };