tracing: Add interface to allow multiple trace buffers
Add the interface ("instances" directory) to add multiple buffers
to ftrace. To create a new instance, simply do a mkdir in the
instances directory:
This will create a directory with the following:
# cd instances
# mkdir foo
# ls foo
buffer_size_kb free_buffer trace_clock trace_pipe
buffer_total_size_kb set_event trace_marker tracing_enabled
events/ trace trace_options tracing_on
Currently only events are able to be set, and there isn't a way
to delete a buffer when one is created (yet).
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 74bc123..dbd2412 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -5016,6 +5016,202 @@
.llseek = default_llseek,
};
+struct dentry *trace_instance_dir;
+
+static void
+init_tracer_debugfs(struct trace_array *tr, struct dentry *d_tracer);
+
+static ssize_t
+trace_new_instance_read(struct file *filp, char __user *ubuf,
+ size_t cnt, loff_t *ppos)
+{
+ static char text[] =
+ "\nWrite into this file to create a new instance\n\n";
+
+ return simple_read_from_buffer(ubuf, cnt, ppos, text, sizeof(text));
+}
+
+static int new_instance_create(const char *name)
+{
+ enum ring_buffer_flags rb_flags;
+ struct trace_array *tr;
+ int ret;
+ int i;
+
+ mutex_lock(&trace_types_lock);
+
+ ret = -EEXIST;
+ list_for_each_entry(tr, &ftrace_trace_arrays, list) {
+ if (tr->name && strcmp(tr->name, name) == 0)
+ goto out_unlock;
+ }
+
+ ret = -ENOMEM;
+ tr = kzalloc(sizeof(*tr), GFP_KERNEL);
+ if (!tr)
+ goto out_unlock;
+
+ tr->name = kstrdup(name, GFP_KERNEL);
+ if (!tr->name)
+ goto out_free_tr;
+
+ raw_spin_lock_init(&tr->start_lock);
+
+ tr->current_trace = &nop_trace;
+
+ INIT_LIST_HEAD(&tr->systems);
+ INIT_LIST_HEAD(&tr->events);
+
+ rb_flags = trace_flags & TRACE_ITER_OVERWRITE ? RB_FL_OVERWRITE : 0;
+
+ tr->buffer = ring_buffer_alloc(trace_buf_size, rb_flags);
+ if (!tr->buffer)
+ goto out_free_tr;
+
+ tr->data = alloc_percpu(struct trace_array_cpu);
+ if (!tr->data)
+ goto out_free_tr;
+
+ for_each_tracing_cpu(i) {
+ memset(per_cpu_ptr(tr->data, i), 0, sizeof(struct trace_array_cpu));
+ per_cpu_ptr(tr->data, i)->trace_cpu.cpu = i;
+ per_cpu_ptr(tr->data, i)->trace_cpu.tr = tr;
+ }
+
+ /* Holder for file callbacks */
+ tr->trace_cpu.cpu = RING_BUFFER_ALL_CPUS;
+ tr->trace_cpu.tr = tr;
+
+ tr->dir = debugfs_create_dir(name, trace_instance_dir);
+ if (!tr->dir)
+ goto out_free_tr;
+
+ ret = event_trace_add_tracer(tr->dir, tr);
+ if (ret)
+ goto out_free_tr;
+
+ init_tracer_debugfs(tr, tr->dir);
+
+ list_add(&tr->list, &ftrace_trace_arrays);
+
+ mutex_unlock(&trace_types_lock);
+
+ return 0;
+
+ out_free_tr:
+ if (tr->buffer)
+ ring_buffer_free(tr->buffer);
+ kfree(tr->name);
+ kfree(tr);
+
+ out_unlock:
+ mutex_unlock(&trace_types_lock);
+
+ return ret;
+
+}
+
+static ssize_t
+trace_new_instance_write(struct file *filp, const char __user *ubuf,
+ size_t cnt, loff_t *ppos)
+{
+ char *buf;
+ char *name;
+ int ret;
+
+ /* Don't let names be bigger than 1024 */
+ if (cnt > 1024)
+ return -EINVAL;
+
+ ret = -ENOMEM;
+ name = kmalloc(cnt+1, GFP_KERNEL);
+ if (!name)
+ return -ENOMEM;
+
+ ret = -EFAULT;
+ if (strncpy_from_user(name, ubuf, cnt) < 0)
+ goto out_free_name;
+
+ name[cnt] = '\0';
+
+ /* remove leading and trailing whitespace */
+ ret = -ENOMEM;
+ buf = strstrip(name);
+ buf = kstrdup(buf, GFP_KERNEL);
+ if (!buf)
+ goto out_free_name;
+ kfree(name);
+ name = buf;
+
+ ret = new_instance_create(name);
+
+ kfree(name);
+
+ if (ret)
+ return ret;
+
+ (*ppos) += cnt;
+
+ return cnt;
+
+ out_free_name:
+ kfree(name);
+ return ret;
+}
+
+static const struct file_operations trace_new_instance_fops = {
+ .open = tracing_open_generic,
+ .read = trace_new_instance_read,
+ .write = trace_new_instance_write,
+ .llseek = default_llseek,
+};
+
+static int instance_mkdir (struct inode *inode, struct dentry *dentry, umode_t mode)
+{
+ struct dentry *parent;
+ int ret;
+
+ /* Paranoid: Make sure the parent is the "instances" directory */
+ parent = hlist_entry(inode->i_dentry.first, struct dentry, d_alias);
+ if (WARN_ON_ONCE(parent != trace_instance_dir))
+ return -ENOENT;
+
+ /*
+ * The inode mutex is locked, but debugfs_create_dir() will also
+ * take the mutex. As the instances directory can not be destroyed
+ * or changed in any other way, it is safe to unlock it, and
+ * let the dentry try. If two users try to make the same dir at
+ * the same time, then the new_instance_create() determine the
+ * winner.
+ */
+ mutex_unlock(&inode->i_mutex);
+
+ ret = new_instance_create(dentry->d_iname);
+
+ mutex_lock(&inode->i_mutex);
+
+ return ret;
+}
+
+static const struct inode_operations instance_dir_inode_operations = {
+ .lookup = simple_lookup,
+ .mkdir = instance_mkdir,
+};
+
+static __init void create_trace_instances(struct dentry *d_tracer)
+{
+ trace_instance_dir = debugfs_create_dir("instances", d_tracer);
+ if (WARN_ON(!trace_instance_dir))
+ return;
+
+ /* Hijack the dir inode operations, to allow mkdir */
+ trace_instance_dir->d_inode->i_op = &instance_dir_inode_operations;
+
+ return;
+ trace_create_file("new", 0644, trace_instance_dir, NULL,
+ &trace_new_instance_fops);
+}
+
static void
init_tracer_debugfs(struct trace_array *tr, struct dentry *d_tracer)
{
@@ -5092,6 +5288,8 @@
(void *) RING_BUFFER_ALL_CPUS, &snapshot_fops);
#endif
+ create_trace_instances(d_tracer);
+
create_trace_options_dir(&global_trace);
for_each_tracing_cpu(cpu)
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 5b45688..8aeac9b 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -175,6 +175,7 @@
struct trace_array {
struct ring_buffer *buffer;
struct list_head list;
+ char *name;
int cpu;
int buffer_disabled;
struct trace_cpu trace_cpu; /* place holder */
@@ -995,6 +996,7 @@
}
extern void trace_event_enable_cmd_record(bool enable);
+extern int event_trace_add_tracer(struct dentry *parent, struct trace_array *tr);
extern struct mutex event_mutex;
extern struct list_head ftrace_events;
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 4399552..58a6130 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -1754,16 +1754,22 @@
struct dentry *d_events;
struct dentry *entry;
+ mutex_lock(&event_mutex);
+
entry = debugfs_create_file("set_event", 0644, parent,
tr, &ftrace_set_event_fops);
if (!entry) {
pr_warning("Could not create debugfs 'set_event' entry\n");
+ mutex_unlock(&event_mutex);
return -ENOMEM;
}
d_events = debugfs_create_dir("events", parent);
- if (!d_events)
+ if (!d_events) {
pr_warning("Could not create debugfs 'events' directory\n");
+ mutex_unlock(&event_mutex);
+ return -ENOMEM;
+ }
/* ring buffer internal formats */
trace_create_file("header_page", 0444, d_events,
@@ -1778,7 +1784,11 @@
tr, &ftrace_tr_enable_fops);
tr->event_dir = d_events;
+ down_write(&trace_event_mutex);
__trace_add_event_dirs(tr);
+ up_write(&trace_event_mutex);
+
+ mutex_unlock(&event_mutex);
return 0;
}
