tracing: add format file to describe event struct fields
Steven Rostedt [Mon, 2 Mar 2009 18:53:59 +0000 (13:53 -0500)]
This patch adds the "format" file to the trace point event directory.
This is based off of work by Tom Zanussi, in which a file is exported
to be tread from user land such that a user space app may read the
binary record stored in the ring buffer.

 # cat /debug/tracing/events/sched/sched_switch/format
        field:pid_t prev_pid;   offset:12;      size:4;
        field:int prev_prio;    offset:16;      size:4;
        field special:char next_comm[TASK_COMM_LEN];    offset:20;      size:16;
        field:pid_t next_pid;   offset:36;      size:4;
        field:int next_prio;    offset:40;      size:4;

Idea-from: Tom Zanussi <tzanussi@gmail.com>
Signed-off-by: Steven Rostedt <srostedt@redhat.com>

kernel/trace/trace.h
kernel/trace/trace_events.c
kernel/trace/trace_events_stage_2.h
kernel/trace/trace_events_stage_3.h

index cf6ba41..e606633 100644 (file)
@@ -754,6 +754,7 @@ struct ftrace_event_call {
        int             (*raw_init)(void);
        int             (*raw_reg)(void);
        void            (*raw_unreg)(void);
+       int             (*show_format)(struct trace_seq *s);
 };
 
 void event_trace_printk(unsigned long ip, const char *fmt, ...);
index 26069fa..d57a772 100644 (file)
@@ -3,6 +3,9 @@
  *
  * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
  *
+ *  - Added format output of fields of the trace point.
+ *    This was based off of work by Tom Zanussi <tzanussi@gmail.com>.
+ *
  */
 
 #include <linux/debugfs.h>
@@ -444,6 +447,42 @@ event_available_types_read(struct file *filp, char __user *ubuf, size_t cnt,
        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
 }
 
+static ssize_t
+event_format_read(struct file *filp, char __user *ubuf, size_t cnt,
+                 loff_t *ppos)
+{
+       struct ftrace_event_call *call = filp->private_data;
+       struct trace_seq *s;
+       char *buf;
+       int r;
+
+       s = kmalloc(sizeof(*s), GFP_KERNEL);
+       if (!s)
+               return -ENOMEM;
+
+       trace_seq_init(s);
+
+       if (*ppos)
+               return 0;
+
+       r = call->show_format(s);
+       if (!r) {
+               /*
+                * ug!  The format output is bigger than a PAGE!!
+                */
+               buf = "FORMAT TOO BIG\n";
+               r = simple_read_from_buffer(ubuf, cnt, ppos,
+                                             buf, strlen(buf));
+               goto out;
+       }
+
+       r = simple_read_from_buffer(ubuf, cnt, ppos,
+                                   s->buffer, s->len);
+ out:
+       kfree(s);
+       return r;
+}
+
 static const struct seq_operations show_event_seq_ops = {
        .start = t_start,
        .next = t_next,
@@ -490,6 +529,11 @@ static const struct file_operations ftrace_available_types_fops = {
        .read = event_available_types_read,
 };
 
+static const struct file_operations ftrace_event_format_fops = {
+       .open = tracing_open_generic,
+       .read = event_format_read,
+};
+
 static struct dentry *event_trace_events_dir(void)
 {
        static struct dentry *d_tracer;
@@ -602,7 +646,17 @@ event_create_dir(struct ftrace_event_call *call, struct dentry *d_events)
                                    &ftrace_available_types_fops);
        if (!entry)
                pr_warning("Could not create debugfs "
-                          "'%s/type' available_types\n", call->name);
+                          "'%s/available_types' entry\n", call->name);
+
+       /* A trace may not want to export its format */
+       if (!call->show_format)
+               return 0;
+
+       entry = debugfs_create_file("format", 0444, call->dir, call,
+                                   &ftrace_event_format_fops);
+       if (!entry)
+               pr_warning("Could not create debugfs "
+                          "'%s/format' entry\n", call->name);
 
        return 0;
 }
index dc79fe3..3a80ea4 100644 (file)
@@ -74,3 +74,55 @@ ftrace_raw_output_##call(struct trace_iterator *iter, int flags)     \
 }
 
 #include <trace/trace_event_types.h>
+
+/*
+ * Setup the showing format of trace point.
+ *
+ * int
+ * ftrace_format_##call(struct trace_seq *s)
+ * {
+ *     struct ftrace_raw_##call field;
+ *     int ret;
+ *
+ *     ret = trace_seq_printf(s, #type " " #item ";"
+ *                            " size:%d; offset:%d;\n",
+ *                            sizeof(field.type),
+ *                            offsetof(struct ftrace_raw_##call,
+ *                                     item));
+ *
+ * }
+ */
+
+#undef TRACE_FIELD
+#define TRACE_FIELD(type, item, assign)                                        \
+       ret = trace_seq_printf(s, "\tfield:" #type " " #item ";\t"      \
+                              "offset:%lu;\tsize:%lu;\n",              \
+                              offsetof(typeof(field), item),           \
+                              sizeof(field.item));                     \
+       if (!ret)                                                       \
+               return 0;
+
+
+#undef TRACE_FIELD_SPECIAL
+#define TRACE_FIELD_SPECIAL(type_item, item, cmd)                      \
+       ret = trace_seq_printf(s, "\tfield special:" #type_item ";\t"   \
+                              "offset:%lu;\tsize:%lu;\n",              \
+                              offsetof(typeof(field), item),           \
+                              sizeof(field.item));                     \
+       if (!ret)                                                       \
+               return 0;
+
+#undef TRACE_EVENT_FORMAT
+#define TRACE_EVENT_FORMAT(call, proto, args, fmt, tstruct, tpfmt)     \
+int                                                                    \
+ftrace_format_##call(struct trace_seq *s)                              \
+{                                                                      \
+       struct ftrace_raw_##call field;                                 \
+       int ret;                                                        \
+                                                                       \
+       tstruct;                                                        \
+                                                                       \
+       return ret;                                                     \
+}
+
+#include <trace/trace_event_types.h>
index 2ab65e9..c62a4d2 100644 (file)
  *     .raw_init               = ftrace_raw_init_event_<call>,
  *     .raw_reg                = ftrace_raw_reg_event_<call>,
  *     .raw_unreg              = ftrace_raw_unreg_event_<call>,
+ *     .show_format            = ftrace_format_<call>,
  * }
  *
  */
@@ -230,4 +231,5 @@ __attribute__((section("_ftrace_events"))) event_##call = {         \
        .raw_init               = ftrace_raw_init_event_##call,         \
        .raw_reg                = ftrace_raw_reg_event_##call,          \
        .raw_unreg              = ftrace_raw_unreg_event_##call,        \
+       .show_format            = ftrace_format_##call,                 \
 }