ftrace: add function tracing to single thread

Impact: feature to function trace a single thread

This patch adds the ability to function trace a single thread.
The file:

  /debugfs/tracing/set_ftrace_pid

contains the pid to trace. Valid pids are any positive integer.
Writing any negative number to this file will disable the pid
tracing and the function tracer will go back to tracing all of
threads.

This feature works with both static and dynamic function tracing.

Signed-off-by: Steven Rostedt <srostedt@redhat.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 183 insertions, 26 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 7e2d3b91692d..00d98c65fad0 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -47,6 +47,9 @@
 int ftrace_enabled __read_mostly;
 static int last_ftrace_enabled;
 
+/* ftrace_pid_trace >= 0 will only trace threads with this pid */
+static int ftrace_pid_trace = -1;
+
 /* Quick disabling of function tracer. */
 int function_trace_stop;
 
@@ -61,6 +64,7 @@ static int ftrace_disabled __read_mostly;
 
 static DEFINE_SPINLOCK(ftrace_lock);
 static DEFINE_MUTEX(ftrace_sysctl_lock);
+static DEFINE_MUTEX(ftrace_start_lock);
 
 static struct ftrace_ops ftrace_list_end __read_mostly =
 {
@@ -70,6 +74,7 @@ static struct ftrace_ops ftrace_list_end __read_mostly =
 static struct ftrace_ops *ftrace_list __read_mostly = &ftrace_list_end;
 ftrace_func_t ftrace_trace_function __read_mostly = ftrace_stub;
 ftrace_func_t __ftrace_trace_function __read_mostly = ftrace_stub;
+ftrace_func_t ftrace_pid_function __read_mostly = ftrace_stub;
 
 static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
 {
@@ -86,6 +91,21 @@ static void ftrace_list_func(unsigned long ip, unsigned long parent_ip)
         };
 }
 
+static void ftrace_pid_func(unsigned long ip, unsigned long parent_ip)
+{
+        if (current->pid != ftrace_pid_trace)
+                return;
+
+        ftrace_pid_function(ip, parent_ip);
+}
+
+static void set_ftrace_pid_function(ftrace_func_t func)
+{
+        /* do not set ftrace_pid_function to itself! */
+        if (func != ftrace_pid_func)
+                ftrace_pid_function = func;
+}
+
 /**
  * clear_ftrace_function - reset the ftrace function
  *
@@ -96,6 +116,7 @@ void clear_ftrace_function(void)
 {
         ftrace_trace_function = ftrace_stub;
         __ftrace_trace_function = ftrace_stub;
+        ftrace_pid_function = ftrace_stub;
 }
 
 #ifndef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
@@ -128,20 +149,26 @@ static int __register_ftrace_function(struct ftrace_ops *ops)
         ftrace_list = ops;
 
         if (ftrace_enabled) {
+                ftrace_func_t func;
+
+                if (ops->next == &ftrace_list_end)
+                        func = ops->func;
+                else
+                        func = ftrace_list_func;
+
+                if (ftrace_pid_trace >= 0) {
+                        set_ftrace_pid_function(func);
+                        func = ftrace_pid_func;
+                }
+
                 /*
                  * For one func, simply call it directly.
                  * For more than one func, call the chain.
                  */
 #ifdef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
-                if (ops->next == &ftrace_list_end)
-                        ftrace_trace_function = ops->func;
-                else
-                        ftrace_trace_function = ftrace_list_func;
+                ftrace_trace_function = func;
 #else
-                if (ops->next == &ftrace_list_end)
-                        __ftrace_trace_function = ops->func;
-                else
-                        __ftrace_trace_function = ftrace_list_func;
+                __ftrace_trace_function = func;
                 ftrace_trace_function = ftrace_test_stop_func;
 #endif
         }
@@ -182,8 +209,19 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
 
         if (ftrace_enabled) {
                 /* If we only have one func left, then call that directly */
-                if (ftrace_list->next == &ftrace_list_end)
-                        ftrace_trace_function = ftrace_list->func;
+                if (ftrace_list->next == &ftrace_list_end) {
+                        ftrace_func_t func = ftrace_list->func;
+
+                        if (ftrace_pid_trace >= 0) {
+                                set_ftrace_pid_function(func);
+                                func = ftrace_pid_func;
+                        }
+#ifdef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
+                        ftrace_trace_function = func;
+#else
+                        __ftrace_trace_function = func;
+#endif
+                }
         }
 
  out:
@@ -192,6 +230,38 @@ static int __unregister_ftrace_function(struct ftrace_ops *ops)
         return ret;
 }
 
+static void ftrace_update_pid_func(void)
+{
+        ftrace_func_t func;
+
+        /* should not be called from interrupt context */
+        spin_lock(&ftrace_lock);
+
+        if (ftrace_trace_function == ftrace_stub)
+                goto out;
+
+        func = ftrace_trace_function;
+
+        if (ftrace_pid_trace >= 0) {
+                set_ftrace_pid_function(func);
+                func = ftrace_pid_func;
+        } else {
+                if (func != ftrace_pid_func)
+                        goto out;
+
+                set_ftrace_pid_function(func);
+        }
+
+#ifdef CONFIG_HAVE_FUNCTION_TRACE_MCOUNT_TEST
+        ftrace_trace_function = func;
+#else
+        __ftrace_trace_function = func;
+#endif
+
+ out:
+        spin_unlock(&ftrace_lock);
+}
+
 #ifdef CONFIG_DYNAMIC_FTRACE
 #ifndef CONFIG_FTRACE_MCOUNT_RECORD
 # error Dynamic ftrace depends on MCOUNT_RECORD
@@ -545,7 +615,19 @@ static void ftrace_run_update_code(int command)
 
 static ftrace_func_t saved_ftrace_func;
 static int ftrace_start_up;
-static DEFINE_MUTEX(ftrace_start_lock);
+
+static void ftrace_startup_enable(int command)
+{
+        if (saved_ftrace_func != ftrace_trace_function) {
+                saved_ftrace_func = ftrace_trace_function;
+                command |= FTRACE_UPDATE_TRACE_FUNC;
+        }
+
+        if (!command || !ftrace_enabled)
+                return;
+
+        ftrace_run_update_code(command);
+}
 
 static void ftrace_startup(void)
 {
@@ -558,16 +640,8 @@ static void ftrace_startup(void)
         ftrace_start_up++;
         command |= FTRACE_ENABLE_CALLS;
 
-        if (saved_ftrace_func != ftrace_trace_function) {
-                saved_ftrace_func = ftrace_trace_function;
-                command |= FTRACE_UPDATE_TRACE_FUNC;
-        }
-
-        if (!command || !ftrace_enabled)
-                goto out;
+        ftrace_startup_enable(command);
 
-        ftrace_run_update_code(command);
- out:
         mutex_unlock(&ftrace_start_lock);
 }
 
@@ -1262,13 +1336,10 @@ static struct file_operations ftrace_notrace_fops = {
         .release = ftrace_notrace_release,
 };
 
-static __init int ftrace_init_debugfs(void)
+static __init int ftrace_init_dyn_debugfs(struct dentry *d_tracer)
 {
-        struct dentry *d_tracer;
         struct dentry *entry;
 
-        d_tracer = tracing_init_dentry();
-
         entry = debugfs_create_file("available_filter_functions", 0444,
                                     d_tracer, NULL, &ftrace_avail_fops);
         if (!entry)
@@ -1295,8 +1366,6 @@ static __init int ftrace_init_debugfs(void)
         return 0;
 }
 
-fs_initcall(ftrace_init_debugfs);
-
 static int ftrace_convert_nops(struct module *mod,
                                unsigned long *start,
                                unsigned long *end)
@@ -1382,12 +1451,100 @@ static int __init ftrace_nodyn_init(void)
 }
 device_initcall(ftrace_nodyn_init);
 
+static inline int ftrace_init_dyn_debugfs(struct dentry *d_tracer) { return 0; }
+static inline void ftrace_startup_enable(int command) { }
 # define ftrace_startup()               do { } while (0)
 # define ftrace_shutdown()              do { } while (0)
 # define ftrace_startup_sysctl()        do { } while (0)
 # define ftrace_shutdown_sysctl()       do { } while (0)
 #endif /* CONFIG_DYNAMIC_FTRACE */
 
+static ssize_t
+ftrace_pid_read(struct file *file, char __user *ubuf,
+                       size_t cnt, loff_t *ppos)
+{
+        char buf[64];
+        int r;
+
+        if (ftrace_pid_trace >= 0)
+                r = sprintf(buf, "%u\n", ftrace_pid_trace);
+        else
+                r = sprintf(buf, "no pid\n");
+
+        return simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
+}
+
+static ssize_t
+ftrace_pid_write(struct file *filp, const char __user *ubuf,
+                   size_t cnt, loff_t *ppos)
+{
+        char buf[64];
+        long val;
+        int ret;
+
+        if (cnt >= sizeof(buf))
+                return -EINVAL;
+
+        if (copy_from_user(&buf, ubuf, cnt))
+                return -EFAULT;
+
+        buf[cnt] = 0;
+
+        ret = strict_strtol(buf, 10, &val);
+        if (ret < 0)
+                return ret;
+
+        mutex_lock(&ftrace_start_lock);
+        if (ret < 0) {
+                /* disable pid tracing */
+                if (ftrace_pid_trace < 0)
+                        goto out;
+                ftrace_pid_trace = -1;
+
+        } else {
+
+                if (ftrace_pid_trace == val)
+                        goto out;
+
+                ftrace_pid_trace = val;
+        }
+
+        /* update the function call */
+        ftrace_update_pid_func();
+        ftrace_startup_enable(0);
+
+ out:
+        mutex_unlock(&ftrace_start_lock);
+
+        return cnt;
+}
+
+static struct file_operations ftrace_pid_fops = {
+        .read = ftrace_pid_read,
+        .write = ftrace_pid_write,
+};
+
+static __init int ftrace_init_debugfs(void)
+{
+        struct dentry *d_tracer;
+        struct dentry *entry;
+
+        d_tracer = tracing_init_dentry();
+        if (!d_tracer)
+                return 0;
+
+        ftrace_init_dyn_debugfs(d_tracer);
+
+        entry = debugfs_create_file("set_ftrace_pid", 0644, d_tracer,
+                                    NULL, &ftrace_pid_fops);
+        if (!entry)
+                pr_warning("Could not create debugfs "
+                           "'set_ftrace_pid' entry\n");
+        return 0;
+}
+
+fs_initcall(ftrace_init_debugfs);
+
 /**
  * ftrace_kill - kill ftrace
  *