1 files changed, 90 insertions, 72 deletions

diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index cd7f76d1eb86..1fd4b9479210 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -237,14 +237,13 @@ static int control_ops_alloc(struct ftrace_ops *ops)
         return 0;
 }
 
-static void control_ops_free(struct ftrace_ops *ops)
-{
-        free_percpu(ops->disabled);
-}
-
 static void update_global_ops(void)
 {
-        ftrace_func_t func;
+        ftrace_func_t func = ftrace_global_list_func;
+        void *private = NULL;
+
+        /* The list has its own recursion protection. */
+        global_ops.flags |= FTRACE_OPS_FL_RECURSION_SAFE;
 
         /*
          * If there's only one function registered, then call that
@@ -254,23 +253,17 @@ static void update_global_ops(void)
         if (ftrace_global_list == &ftrace_list_end ||
             ftrace_global_list->next == &ftrace_list_end) {
                 func = ftrace_global_list->func;
+                private = ftrace_global_list->private;
                 /*
                  * As we are calling the function directly.
                  * If it does not have recursion protection,
                  * the function_trace_op needs to be updated
                  * accordingly.
                  */
-                if (ftrace_global_list->flags & FTRACE_OPS_FL_RECURSION_SAFE)
-                        global_ops.flags |= FTRACE_OPS_FL_RECURSION_SAFE;
-                else
+                if (!(ftrace_global_list->flags & FTRACE_OPS_FL_RECURSION_SAFE))
                         global_ops.flags &= ~FTRACE_OPS_FL_RECURSION_SAFE;
-        } else {
-                func = ftrace_global_list_func;
-                /* The list has its own recursion protection. */
-                global_ops.flags |= FTRACE_OPS_FL_RECURSION_SAFE;
         }
 
-
         /* If we filter on pids, update to use the pid function */
         if (!list_empty(&ftrace_pids)) {
                 set_ftrace_pid_function(func);
@@ -278,6 +271,7 @@ static void update_global_ops(void)
         }
 
         global_ops.func = func;
+        global_ops.private = private;
 }
 
 static void ftrace_sync(struct work_struct *work)
@@ -437,6 +431,9 @@ static int remove_ftrace_list_ops(struct ftrace_ops **list,
 
 static int __register_ftrace_function(struct ftrace_ops *ops)
 {
+        if (ops->flags & FTRACE_OPS_FL_DELETED)
+                return -EINVAL;
+
         if (FTRACE_WARN_ON(ops == &global_ops))
                 return -EINVAL;
 
@@ -1172,8 +1169,6 @@ struct ftrace_page {
         int                     size;
 };
 
-static struct ftrace_page *ftrace_new_pgs;
-
 #define ENTRY_SIZE sizeof(struct dyn_ftrace)
 #define ENTRIES_PER_PAGE (PAGE_SIZE / ENTRY_SIZE)
 
@@ -1560,7 +1555,7 @@ unsigned long ftrace_location(unsigned long ip)
  * the function tracer. It checks the ftrace internal tables to
  * determine if the address belongs or not.
  */
-int ftrace_text_reserved(void *start, void *end)
+int ftrace_text_reserved(const void *start, const void *end)
 {
         unsigned long ret;
 
@@ -1994,6 +1989,7 @@ int __weak ftrace_arch_code_modify_post_process(void)
 void ftrace_modify_all_code(int command)
 {
         int update = command & FTRACE_UPDATE_TRACE_FUNC;
+        int err = 0;
 
         /*
          * If the ftrace_caller calls a ftrace_ops func directly,
@@ -2005,8 +2001,11 @@ void ftrace_modify_all_code(int command)
          * to make sure the ops are having the right functions
          * traced.
          */
-        if (update)
-                ftrace_update_ftrace_func(ftrace_ops_list_func);
+        if (update) {
+                err = ftrace_update_ftrace_func(ftrace_ops_list_func);
+                if (FTRACE_WARN_ON(err))
+                        return;
+        }
 
         if (command & FTRACE_UPDATE_CALLS)
                 ftrace_replace_code(1);
@@ -2019,13 +2018,16 @@ void ftrace_modify_all_code(int command)
                 /* If irqs are disabled, we are in stop machine */
                 if (!irqs_disabled())
                         smp_call_function(ftrace_sync_ipi, NULL, 1);
-                ftrace_update_ftrace_func(ftrace_trace_function);
+                err = ftrace_update_ftrace_func(ftrace_trace_function);
+                if (FTRACE_WARN_ON(err))
+                        return;
         }
 
         if (command & FTRACE_START_FUNC_RET)
-                ftrace_enable_ftrace_graph_caller();
+                err = ftrace_enable_ftrace_graph_caller();
         else if (command & FTRACE_STOP_FUNC_RET)
-                ftrace_disable_ftrace_graph_caller();
+                err = ftrace_disable_ftrace_graph_caller();
+        FTRACE_WARN_ON(err);
 }
 
 static int __ftrace_modify_code(void *data)
@@ -2093,6 +2095,11 @@ static ftrace_func_t saved_ftrace_func;
 static int ftrace_start_up;
 static int global_start_up;
 
+static void control_ops_free(struct ftrace_ops *ops)
+{
+        free_percpu(ops->disabled);
+}
+
 static void ftrace_startup_enable(int command)
 {
         if (saved_ftrace_func != ftrace_trace_function) {
@@ -2244,7 +2251,6 @@ static void ftrace_shutdown_sysctl(void)
 }
 
 static cycle_t          ftrace_update_time;
-static unsigned long    ftrace_update_cnt;
 unsigned long           ftrace_update_tot_cnt;
 
 static inline int ops_traces_mod(struct ftrace_ops *ops)
@@ -2300,11 +2306,12 @@ static int referenced_filters(struct dyn_ftrace *rec)
         return cnt;
 }
 
-static int ftrace_update_code(struct module *mod)
+static int ftrace_update_code(struct module *mod, struct ftrace_page *new_pgs)
 {
         struct ftrace_page *pg;
         struct dyn_ftrace *p;
         cycle_t start, stop;
+        unsigned long update_cnt = 0;
         unsigned long ref = 0;
         bool test = false;
         int i;
@@ -2330,9 +2337,8 @@ static int ftrace_update_code(struct module *mod)
         }
 
         start = ftrace_now(raw_smp_processor_id());
-        ftrace_update_cnt = 0;
 
-        for (pg = ftrace_new_pgs; pg; pg = pg->next) {
+        for (pg = new_pgs; pg; pg = pg->next) {
 
                 for (i = 0; i < pg->index; i++) {
                         int cnt = ref;
@@ -2353,7 +2359,7 @@ static int ftrace_update_code(struct module *mod)
                         if (!ftrace_code_disable(mod, p))
                                 break;
 
-                        ftrace_update_cnt++;
+                        update_cnt++;
 
                         /*
                          * If the tracing is enabled, go ahead and enable the record.
@@ -2372,11 +2378,9 @@ static int ftrace_update_code(struct module *mod)
                 }
         }
 
-        ftrace_new_pgs = NULL;
-
         stop = ftrace_now(raw_smp_processor_id());
         ftrace_update_time = stop - start;
-        ftrace_update_tot_cnt += ftrace_update_cnt;
+        ftrace_update_tot_cnt += update_cnt;
 
         return 0;
 }
@@ -2468,22 +2472,6 @@ ftrace_allocate_pages(unsigned long num_to_init)
         return NULL;
 }
 
-static int __init ftrace_dyn_table_alloc(unsigned long num_to_init)
-{
-        int cnt;
-
-        if (!num_to_init) {
-                pr_info("ftrace: No functions to be traced?\n");
-                return -1;
-        }
-
-        cnt = num_to_init / ENTRIES_PER_PAGE;
-        pr_info("ftrace: allocating %ld entries in %d pages\n",
-                num_to_init, cnt + 1);
-
-        return 0;
-}
-
 #define FTRACE_BUFF_MAX (KSYM_SYMBOL_LEN+4) /* room for wildcards */
 
 struct ftrace_iterator {
@@ -2871,7 +2859,9 @@ ftrace_regex_open(struct ftrace_ops *ops, int flag,
 static int
 ftrace_filter_open(struct inode *inode, struct file *file)
 {
-        return ftrace_regex_open(&global_ops,
+        struct ftrace_ops *ops = inode->i_private;
+
+        return ftrace_regex_open(ops,
                         FTRACE_ITER_FILTER | FTRACE_ITER_DO_HASH,
                         inode, file);
 }
@@ -2879,7 +2869,9 @@ ftrace_filter_open(struct inode *inode, struct file *file)
 static int
 ftrace_notrace_open(struct inode *inode, struct file *file)
 {
-        return ftrace_regex_open(&global_ops, FTRACE_ITER_NOTRACE,
+        struct ftrace_ops *ops = inode->i_private;
+
+        return ftrace_regex_open(ops, FTRACE_ITER_NOTRACE,
                                  inode, file);
 }
 
@@ -4109,6 +4101,36 @@ static const struct file_operations ftrace_graph_notrace_fops = {
 };
 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */
 
+void ftrace_create_filter_files(struct ftrace_ops *ops,
+                                struct dentry *parent)
+{
+
+        trace_create_file("set_ftrace_filter", 0644, parent,
+                          ops, &ftrace_filter_fops);
+
+        trace_create_file("set_ftrace_notrace", 0644, parent,
+                          ops, &ftrace_notrace_fops);
+}
+
+/*
+ * The name "destroy_filter_files" is really a misnomer. Although
+ * in the future, it may actualy delete the files, but this is
+ * really intended to make sure the ops passed in are disabled
+ * and that when this function returns, the caller is free to
+ * free the ops.
+ *
+ * The "destroy" name is only to match the "create" name that this
+ * should be paired with.
+ */
+void ftrace_destroy_filter_files(struct ftrace_ops *ops)
+{
+        mutex_lock(&ftrace_lock);
+        if (ops->flags & FTRACE_OPS_FL_ENABLED)
+                ftrace_shutdown(ops, 0);
+        ops->flags |= FTRACE_OPS_FL_DELETED;
+        mutex_unlock(&ftrace_lock);
+}
+
 static __init int ftrace_init_dyn_debugfs(struct dentry *d_tracer)
 {
 
@@ -4118,11 +4140,7 @@ static __init int ftrace_init_dyn_debugfs(struct dentry *d_tracer)
         trace_create_file("enabled_functions", 0444,
                         d_tracer, NULL, &ftrace_enabled_fops);
 
-        trace_create_file("set_ftrace_filter", 0644, d_tracer,
-                        NULL, &ftrace_filter_fops);
-
-        trace_create_file("set_ftrace_notrace", 0644, d_tracer,
-                                    NULL, &ftrace_notrace_fops);
+        ftrace_create_filter_files(&global_ops, d_tracer);
 
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
         trace_create_file("set_graph_function", 0444, d_tracer,
@@ -4238,9 +4256,6 @@ static int ftrace_process_locs(struct module *mod,
         /* Assign the last page to ftrace_pages */
         ftrace_pages = pg;
 
-        /* These new locations need to be initialized */
-        ftrace_new_pgs = start_pg;
-
         /*
          * We only need to disable interrupts on start up
          * because we are modifying code that an interrupt
@@ -4251,7 +4266,7 @@ static int ftrace_process_locs(struct module *mod,
          */
         if (!mod)
                 local_irq_save(flags);
-        ftrace_update_code(mod);
+        ftrace_update_code(mod, start_pg);
         if (!mod)
                 local_irq_restore(flags);
         ret = 0;
@@ -4360,30 +4375,27 @@ struct notifier_block ftrace_module_exit_nb = {
         .priority = INT_MIN,    /* Run after anything that can remove kprobes */
 };
 
-extern unsigned long __start_mcount_loc[];
-extern unsigned long __stop_mcount_loc[];
-
 void __init ftrace_init(void)
 {
-        unsigned long count, addr, flags;
+        extern unsigned long __start_mcount_loc[];
+        extern unsigned long __stop_mcount_loc[];
+        unsigned long count, flags;
         int ret;
 
-        /* Keep the ftrace pointer to the stub */
-        addr = (unsigned long)ftrace_stub;
-
         local_irq_save(flags);
-        ftrace_dyn_arch_init(&addr);
+        ret = ftrace_dyn_arch_init();
         local_irq_restore(flags);
-
-        /* ftrace_dyn_arch_init places the return code in addr */
-        if (addr)
+        if (ret)
                 goto failed;
 
         count = __stop_mcount_loc - __start_mcount_loc;
-
-        ret = ftrace_dyn_table_alloc(count);
-        if (ret)
+        if (!count) {
+                pr_info("ftrace: No functions to be traced?\n");
                 goto failed;
+        }
+
+        pr_info("ftrace: allocating %ld entries in %ld pages\n",
+                count, count / ENTRIES_PER_PAGE + 1);
 
         last_ftrace_enabled = ftrace_enabled = 1;
 
@@ -4431,7 +4443,13 @@ static inline void ftrace_startup_enable(int command) { }
                         (ops)->flags |= FTRACE_OPS_FL_ENABLED;          \
                 ___ret;                                                 \
         })
-# define ftrace_shutdown(ops, command) __unregister_ftrace_function(ops)
+# define ftrace_shutdown(ops, command)                                  \
+        ({                                                              \
+                int ___ret = __unregister_ftrace_function(ops);         \
+                if (!___ret)                                            \
+                        (ops)->flags &= ~FTRACE_OPS_FL_ENABLED;         \
+                ___ret;                                                 \
+        })
 
 # define ftrace_startup_sysctl()        do { } while (0)
 # define ftrace_shutdown_sysctl()       do { } while (0)