tracing: Print trace_bprintk() formats for modules too
Steven Rostedt [Tue, 22 Mar 2011 03:36:31 +0000 (23:36 -0400)]
The file debugfs/tracing/printk_formats maps the addresses
to the formats that are used by trace_bprintk() so that userspace
tools can read the buffer and be able to decode trace_bprintk events
to get the format saved when reading the ring buffer directly.

This is because trace_bprintk() does not store the format into the
buffer, but just the address of the format, which is hidden in
the kernel memory.

But currently it only exports trace_bprintk()s from the kernel core
and not for modules. The modules need their formats exported
as well.

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

kernel/trace/trace_printk.c

index b8b2681..dff763b 100644 (file)
@@ -89,6 +89,76 @@ static int module_trace_bprintk_format_notify(struct notifier_block *self,
        return 0;
 }
 
+/*
+ * The debugfs/tracing/printk_formats file maps the addresses with
+ * the ASCII formats that are used in the bprintk events in the
+ * buffer. For userspace tools to be able to decode the events from
+ * the buffer, they need to be able to map the address with the format.
+ *
+ * The addresses of the bprintk formats are in their own section
+ * __trace_printk_fmt. But for modules we copy them into a link list.
+ * The code to print the formats and their addresses passes around the
+ * address of the fmt string. If the fmt address passed into the seq
+ * functions is within the kernel core __trace_printk_fmt section, then
+ * it simply uses the next pointer in the list.
+ *
+ * When the fmt pointer is outside the kernel core __trace_printk_fmt
+ * section, then we need to read the link list pointers. The trick is
+ * we pass the address of the string to the seq function just like
+ * we do for the kernel core formats. To get back the structure that
+ * holds the format, we simply use containerof() and then go to the
+ * next format in the list.
+ */
+static const char **
+find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
+{
+       struct trace_bprintk_fmt *mod_fmt;
+
+       if (list_empty(&trace_bprintk_fmt_list))
+               return NULL;
+
+       /*
+        * v will point to the address of the fmt record from t_next
+        * v will be NULL from t_start.
+        * If this is the first pointer or called from start
+        * then we need to walk the list.
+        */
+       if (!v || start_index == *pos) {
+               struct trace_bprintk_fmt *p;
+
+               /* search the module list */
+               list_for_each_entry(p, &trace_bprintk_fmt_list, list) {
+                       if (start_index == *pos)
+                               return &p->fmt;
+                       start_index++;
+               }
+               /* pos > index */
+               return NULL;
+       }
+
+       /*
+        * v points to the address of the fmt field in the mod list
+        * structure that holds the module print format.
+        */
+       mod_fmt = container_of(v, typeof(*mod_fmt), fmt);
+       if (mod_fmt->list.next == &trace_bprintk_fmt_list)
+               return NULL;
+
+       mod_fmt = container_of(mod_fmt->list.next, typeof(*mod_fmt), list);
+
+       return &mod_fmt->fmt;
+}
+
+static void format_mod_start(void)
+{
+       mutex_lock(&btrace_mutex);
+}
+
+static void format_mod_stop(void)
+{
+       mutex_unlock(&btrace_mutex);
+}
+
 #else /* !CONFIG_MODULES */
 __init static int
 module_trace_bprintk_format_notify(struct notifier_block *self,
@@ -96,6 +166,13 @@ module_trace_bprintk_format_notify(struct notifier_block *self,
 {
        return 0;
 }
+static inline const char **
+find_next_mod_format(int start_index, void *v, const char **fmt, loff_t *pos)
+{
+       return NULL;
+}
+static inline void format_mod_start(void) { }
+static inline void format_mod_stop(void) { }
 #endif /* CONFIG_MODULES */
 
 
@@ -158,20 +235,33 @@ int __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap)
 }
 EXPORT_SYMBOL_GPL(__ftrace_vprintk);
 
+static const char **find_next(void *v, loff_t *pos)
+{
+       const char **fmt = v;
+       int start_index;
+
+       if (!fmt)
+               fmt = __start___trace_bprintk_fmt + *pos;
+
+       start_index = __stop___trace_bprintk_fmt - __start___trace_bprintk_fmt;
+
+       if (*pos < start_index)
+               return fmt;
+
+       return find_next_mod_format(start_index, v, fmt, pos);
+}
+
 static void *
 t_start(struct seq_file *m, loff_t *pos)
 {
-       const char **fmt = __start___trace_bprintk_fmt + *pos;
-
-       if ((unsigned long)fmt >= (unsigned long)__stop___trace_bprintk_fmt)
-               return NULL;
-       return fmt;
+       format_mod_start();
+       return find_next(NULL, pos);
 }
 
 static void *t_next(struct seq_file *m, void * v, loff_t *pos)
 {
        (*pos)++;
-       return t_start(m, pos);
+       return find_next(v, pos);
 }
 
 static int t_show(struct seq_file *m, void *v)
@@ -210,6 +300,7 @@ static int t_show(struct seq_file *m, void *v)
 
 static void t_stop(struct seq_file *m, void *p)
 {
+       format_mod_stop();
 }
 
 static const struct seq_operations show_format_seq_ops = {