Merge tag 'trace-v4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace

Pull tracing updates from Steven Rostedt:
 "Some clean ups and small fixes, but the biggest change is the addition
  of the TRACE_DEFINE_ENUM() macro that can be used by tracepoints.

  Tracepoints have helper functions for the TP_printk() called
  __print_symbolic() and __print_flags() that lets a numeric number be
  displayed as a a human comprehensible text.  What is placed in the
  TP_printk() is also shown in the tracepoint format file such that user
  space tools like perf and trace-cmd can parse the binary data and
  express the values too.  Unfortunately, the way the TRACE_EVENT()
  macro works, anything placed in the TP_printk() will be shown pretty
  much exactly as is.  The problem arises when enums are used.  That's
  because unlike macros, enums will not be changed into their values by
  the C pre-processor.  Thus, the enum string is exported to the format
  file, and this makes it useless for user space tools.

  The TRACE_DEFINE_ENUM() solves this by converting the enum strings in
  the TP_printk() format into their number, and that is what is shown to
  user space.  For example, the tracepoint tlb_flush currently has this
  in its format file:

     __print_symbolic(REC->reason,
        { TLB_FLUSH_ON_TASK_SWITCH, "flush on task switch" },
        { TLB_REMOTE_SHOOTDOWN, "remote shootdown" },
        { TLB_LOCAL_SHOOTDOWN, "local shootdown" },
        { TLB_LOCAL_MM_SHOOTDOWN, "local mm shootdown" })

  After adding:

     TRACE_DEFINE_ENUM(TLB_FLUSH_ON_TASK_SWITCH);
     TRACE_DEFINE_ENUM(TLB_REMOTE_SHOOTDOWN);
     TRACE_DEFINE_ENUM(TLB_LOCAL_SHOOTDOWN);
     TRACE_DEFINE_ENUM(TLB_LOCAL_MM_SHOOTDOWN);

  Its format file will contain this:

     __print_symbolic(REC->reason,
        { 0, "flush on task switch" },
        { 1, "remote shootdown" },
        { 2, "local shootdown" },
        { 3, "local mm shootdown" })"

* tag 'trace-v4.1' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace: (27 commits)
  tracing: Add enum_map file to show enums that have been mapped
  writeback: Export enums used by tracepoint to user space
  v4l: Export enums used by tracepoints to user space
  SUNRPC: Export enums in tracepoints to user space
  mm: tracing: Export enums in tracepoints to user space
  irq/tracing: Export enums in tracepoints to user space
  f2fs: Export the enums in the tracepoints to userspace
  net/9p/tracing: Export enums in tracepoints to userspace
  x86/tlb/trace: Export enums in used by tlb_flush tracepoint
  tracing/samples: Update the trace-event-sample.h with TRACE_DEFINE_ENUM()
  tracing: Allow for modules to convert their enums to values
  tracing: Add TRACE_DEFINE_ENUM() macro to map enums to their values
  tracing: Update trace-event-sample with TRACE_SYSTEM_VAR documentation
  tracing: Give system name a pointer
  brcmsmac: Move each system tracepoints to their own header
  iwlwifi: Move each system tracepoints to their own header
  mac80211: Move message tracepoints to their own header
  tracing: Add TRACE_SYSTEM_VAR to xhci-hcd
  tracing: Add TRACE_SYSTEM_VAR to kvm-s390
  tracing: Add TRACE_SYSTEM_VAR to intel-sst
  ...

13 files changed, 492 insertions, 45 deletions

diff --git a/kernel/module.c b/kernel/module.c
index ec53f594e9c9..650b038ae520 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -2770,6 +2770,9 @@ static int find_module_sections(struct module *mod, struct load_info *info)
         mod->trace_events = section_objs(info, "_ftrace_events",
                                          sizeof(*mod->trace_events),
                                          &mod->num_trace_events);
+        mod->trace_enums = section_objs(info, "_ftrace_enum_map",
+                                        sizeof(*mod->trace_enums),
+                                        &mod->num_trace_enums);
 #endif
 #ifdef CONFIG_TRACING
         mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index a5da09c899dd..fedbdd7d5d1e 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -599,6 +599,34 @@ config RING_BUFFER_STARTUP_TEST
 
          If unsure, say N
 
+config TRACE_ENUM_MAP_FILE
+       bool "Show enum mappings for trace events"
+       depends on TRACING
+       help
+        The "print fmt" of the trace events will show the enum names instead
+        of their values. This can cause problems for user space tools that
+        use this string to parse the raw data as user space does not know
+        how to convert the string to its value.
+
+        To fix this, there's a special macro in the kernel that can be used
+        to convert the enum into its value. If this macro is used, then the
+        print fmt strings will have the enums converted to their values.
+
+        If something does not get converted properly, this option can be
+        used to show what enums the kernel tried to convert.
+
+        This option is for debugging the enum conversions. A file is created
+        in the tracing directory called "enum_map" that will show the enum
+        names matched with their values and what trace event system they
+        belong too.
+
+        Normally, the mapping of the strings to values will be freed after
+        boot up or module load. With this option, they will not be freed, as
+        they are needed for the "enum_map" file. Enabling this option will
+        increase the memory footprint of the running kernel.
+
+        If unsure, say N
+
 endif # FTRACE
 
 endif # TRACING_SUPPORT
diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
index 5a2e0b53af30..02bece4a99ea 100644
--- a/kernel/trace/ftrace.c
+++ b/kernel/trace/ftrace.c
@@ -249,6 +249,19 @@ static void update_function_graph_func(void);
 static inline void update_function_graph_func(void) { }
 #endif
 
+
+static ftrace_func_t ftrace_ops_get_list_func(struct ftrace_ops *ops)
+{
+        /*
+         * If this is a dynamic ops or we force list func,
+         * then it needs to call the list anyway.
+         */
+        if (ops->flags & FTRACE_OPS_FL_DYNAMIC || FTRACE_FORCE_LIST_FUNC)
+                return ftrace_ops_list_func;
+
+        return ftrace_ops_get_func(ops);
+}
+
 static void update_ftrace_function(void)
 {
         ftrace_func_t func;
@@ -270,7 +283,7 @@ static void update_ftrace_function(void)
          * then have the mcount trampoline call the function directly.
          */
         } else if (ftrace_ops_list->next == &ftrace_list_end) {
-                func = ftrace_ops_get_func(ftrace_ops_list);
+                func = ftrace_ops_get_list_func(ftrace_ops_list);
 
         } else {
                 /* Just use the default ftrace_ops */
@@ -5209,13 +5222,6 @@ static void ftrace_ops_recurs_func(unsigned long ip, unsigned long parent_ip,
 ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops)
 {
         /*
-         * If this is a dynamic ops or we force list func,
-         * then it needs to call the list anyway.
-         */
-        if (ops->flags & FTRACE_OPS_FL_DYNAMIC || FTRACE_FORCE_LIST_FUNC)
-                return ftrace_ops_list_func;
-
-        /*
          * If the func handles its own recursion, call it directly.
          * Otherwise call the recursion protected function that
          * will call the ftrace ops function.
diff --git a/kernel/trace/ring_buffer.c b/kernel/trace/ring_buffer.c
index 5040d44fe5a3..0315d43176d8 100644
--- a/kernel/trace/ring_buffer.c
+++ b/kernel/trace/ring_buffer.c
@@ -2679,7 +2679,7 @@ static DEFINE_PER_CPU(unsigned int, current_context);
 
 static __always_inline int trace_recursive_lock(void)
 {
-        unsigned int val = this_cpu_read(current_context);
+        unsigned int val = __this_cpu_read(current_context);
         int bit;
 
         if (in_interrupt()) {
@@ -2696,18 +2696,14 @@ static __always_inline int trace_recursive_lock(void)
                 return 1;
 
         val |= (1 << bit);
-        this_cpu_write(current_context, val);
+        __this_cpu_write(current_context, val);
 
         return 0;
 }
 
 static __always_inline void trace_recursive_unlock(void)
 {
-        unsigned int val = this_cpu_read(current_context);
-
-        val--;
-        val &= this_cpu_read(current_context);
-        this_cpu_write(current_context, val);
+        __this_cpu_and(current_context, __this_cpu_read(current_context) - 1);
 }
 
 #else
diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index bcfa2add6dda..91eecaaa43e0 100644
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -125,6 +125,42 @@ enum ftrace_dump_mode ftrace_dump_on_oops;
 /* When set, tracing will stop when a WARN*() is hit */
 int __disable_trace_on_warning;
 
+#ifdef CONFIG_TRACE_ENUM_MAP_FILE
+/* Map of enums to their values, for "enum_map" file */
+struct trace_enum_map_head {
+        struct module                   *mod;
+        unsigned long                   length;
+};
+
+union trace_enum_map_item;
+
+struct trace_enum_map_tail {
+        /*
+         * "end" is first and points to NULL as it must be different
+         * than "mod" or "enum_string"
+         */
+        union trace_enum_map_item       *next;
+        const char                      *end;   /* points to NULL */
+};
+
+static DEFINE_MUTEX(trace_enum_mutex);
+
+/*
+ * The trace_enum_maps are saved in an array with two extra elements,
+ * one at the beginning, and one at the end. The beginning item contains
+ * the count of the saved maps (head.length), and the module they
+ * belong to if not built in (head.mod). The ending item contains a
+ * pointer to the next array of saved enum_map items.
+ */
+union trace_enum_map_item {
+        struct trace_enum_map           map;
+        struct trace_enum_map_head      head;
+        struct trace_enum_map_tail      tail;
+};
+
+static union trace_enum_map_item *trace_enum_maps;
+#endif /* CONFIG_TRACE_ENUM_MAP_FILE */
+
 static int tracing_set_tracer(struct trace_array *tr, const char *buf);
 
 #define MAX_TRACER_SIZE         100
@@ -3910,6 +3946,182 @@ static const struct file_operations tracing_saved_cmdlines_size_fops = {
         .write          = tracing_saved_cmdlines_size_write,
 };
 
+#ifdef CONFIG_TRACE_ENUM_MAP_FILE
+static union trace_enum_map_item *
+update_enum_map(union trace_enum_map_item *ptr)
+{
+        if (!ptr->map.enum_string) {
+                if (ptr->tail.next) {
+                        ptr = ptr->tail.next;
+                        /* Set ptr to the next real item (skip head) */
+                        ptr++;
+                } else
+                        return NULL;
+        }
+        return ptr;
+}
+
+static void *enum_map_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        union trace_enum_map_item *ptr = v;
+
+        /*
+         * Paranoid! If ptr points to end, we don't want to increment past it.
+         * This really should never happen.
+         */
+        ptr = update_enum_map(ptr);
+        if (WARN_ON_ONCE(!ptr))
+                return NULL;
+
+        ptr++;
+
+        (*pos)++;
+
+        ptr = update_enum_map(ptr);
+
+        return ptr;
+}
+
+static void *enum_map_start(struct seq_file *m, loff_t *pos)
+{
+        union trace_enum_map_item *v;
+        loff_t l = 0;
+
+        mutex_lock(&trace_enum_mutex);
+
+        v = trace_enum_maps;
+        if (v)
+                v++;
+
+        while (v && l < *pos) {
+                v = enum_map_next(m, v, &l);
+        }
+
+        return v;
+}
+
+static void enum_map_stop(struct seq_file *m, void *v)
+{
+        mutex_unlock(&trace_enum_mutex);
+}
+
+static int enum_map_show(struct seq_file *m, void *v)
+{
+        union trace_enum_map_item *ptr = v;
+
+        seq_printf(m, "%s %ld (%s)\n",
+                   ptr->map.enum_string, ptr->map.enum_value,
+                   ptr->map.system);
+
+        return 0;
+}
+
+static const struct seq_operations tracing_enum_map_seq_ops = {
+        .start          = enum_map_start,
+        .next           = enum_map_next,
+        .stop           = enum_map_stop,
+        .show           = enum_map_show,
+};
+
+static int tracing_enum_map_open(struct inode *inode, struct file *filp)
+{
+        if (tracing_disabled)
+                return -ENODEV;
+
+        return seq_open(filp, &tracing_enum_map_seq_ops);
+}
+
+static const struct file_operations tracing_enum_map_fops = {
+        .open           = tracing_enum_map_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = seq_release,
+};
+
+static inline union trace_enum_map_item *
+trace_enum_jmp_to_tail(union trace_enum_map_item *ptr)
+{
+        /* Return tail of array given the head */
+        return ptr + ptr->head.length + 1;
+}
+
+static void
+trace_insert_enum_map_file(struct module *mod, struct trace_enum_map **start,
+                           int len)
+{
+        struct trace_enum_map **stop;
+        struct trace_enum_map **map;
+        union trace_enum_map_item *map_array;
+        union trace_enum_map_item *ptr;
+
+        stop = start + len;
+
+        /*
+         * The trace_enum_maps contains the map plus a head and tail item,
+         * where the head holds the module and length of array, and the
+         * tail holds a pointer to the next list.
+         */
+        map_array = kmalloc(sizeof(*map_array) * (len + 2), GFP_KERNEL);
+        if (!map_array) {
+                pr_warning("Unable to allocate trace enum mapping\n");
+                return;
+        }
+
+        mutex_lock(&trace_enum_mutex);
+
+        if (!trace_enum_maps)
+                trace_enum_maps = map_array;
+        else {
+                ptr = trace_enum_maps;
+                for (;;) {
+                        ptr = trace_enum_jmp_to_tail(ptr);
+                        if (!ptr->tail.next)
+                                break;
+                        ptr = ptr->tail.next;
+
+                }
+                ptr->tail.next = map_array;
+        }
+        map_array->head.mod = mod;
+        map_array->head.length = len;
+        map_array++;
+
+        for (map = start; (unsigned long)map < (unsigned long)stop; map++) {
+                map_array->map = **map;
+                map_array++;
+        }
+        memset(map_array, 0, sizeof(*map_array));
+
+        mutex_unlock(&trace_enum_mutex);
+}
+
+static void trace_create_enum_file(struct dentry *d_tracer)
+{
+        trace_create_file("enum_map", 0444, d_tracer,
+                          NULL, &tracing_enum_map_fops);
+}
+
+#else /* CONFIG_TRACE_ENUM_MAP_FILE */
+static inline void trace_create_enum_file(struct dentry *d_tracer) { }
+static inline void trace_insert_enum_map_file(struct module *mod,
+                              struct trace_enum_map **start, int len) { }
+#endif /* !CONFIG_TRACE_ENUM_MAP_FILE */
+
+static void trace_insert_enum_map(struct module *mod,
+                                  struct trace_enum_map **start, int len)
+{
+        struct trace_enum_map **map;
+
+        if (len <= 0)
+                return;
+
+        map = start;
+
+        trace_event_enum_update(map, len);
+
+        trace_insert_enum_map_file(mod, start, len);
+}
+
 static ssize_t
 tracing_set_trace_read(struct file *filp, char __user *ubuf,
                        size_t cnt, loff_t *ppos)
@@ -6527,6 +6739,88 @@ struct dentry *tracing_init_dentry(void)
         return NULL;
 }
 
+extern struct trace_enum_map *__start_ftrace_enum_maps[];
+extern struct trace_enum_map *__stop_ftrace_enum_maps[];
+
+static void __init trace_enum_init(void)
+{
+        int len;
+
+        len = __stop_ftrace_enum_maps - __start_ftrace_enum_maps;
+        trace_insert_enum_map(NULL, __start_ftrace_enum_maps, len);
+}
+
+#ifdef CONFIG_MODULES
+static void trace_module_add_enums(struct module *mod)
+{
+        if (!mod->num_trace_enums)
+                return;
+
+        /*
+         * Modules with bad taint do not have events created, do
+         * not bother with enums either.
+         */
+        if (trace_module_has_bad_taint(mod))
+                return;
+
+        trace_insert_enum_map(mod, mod->trace_enums, mod->num_trace_enums);
+}
+
+#ifdef CONFIG_TRACE_ENUM_MAP_FILE
+static void trace_module_remove_enums(struct module *mod)
+{
+        union trace_enum_map_item *map;
+        union trace_enum_map_item **last = &trace_enum_maps;
+
+        if (!mod->num_trace_enums)
+                return;
+
+        mutex_lock(&trace_enum_mutex);
+
+        map = trace_enum_maps;
+
+        while (map) {
+                if (map->head.mod == mod)
+                        break;
+                map = trace_enum_jmp_to_tail(map);
+                last = &map->tail.next;
+                map = map->tail.next;
+        }
+        if (!map)
+                goto out;
+
+        *last = trace_enum_jmp_to_tail(map)->tail.next;
+        kfree(map);
+ out:
+        mutex_unlock(&trace_enum_mutex);
+}
+#else
+static inline void trace_module_remove_enums(struct module *mod) { }
+#endif /* CONFIG_TRACE_ENUM_MAP_FILE */
+
+static int trace_module_notify(struct notifier_block *self,
+                               unsigned long val, void *data)
+{
+        struct module *mod = data;
+
+        switch (val) {
+        case MODULE_STATE_COMING:
+                trace_module_add_enums(mod);
+                break;
+        case MODULE_STATE_GOING:
+                trace_module_remove_enums(mod);
+                break;
+        }
+
+        return 0;
+}
+
+static struct notifier_block trace_module_nb = {
+        .notifier_call = trace_module_notify,
+        .priority = 0,
+};
+#endif /* CONFIG_MODULES */
+
 static __init int tracer_init_tracefs(void)
 {
         struct dentry *d_tracer;
@@ -6551,6 +6845,14 @@ static __init int tracer_init_tracefs(void)
         trace_create_file("saved_cmdlines_size", 0644, d_tracer,
                           NULL, &tracing_saved_cmdlines_size_fops);
 
+        trace_enum_init();
+
+        trace_create_enum_file(d_tracer);
+
+#ifdef CONFIG_MODULES
+        register_module_notifier(&trace_module_nb);
+#endif
+
 #ifdef CONFIG_DYNAMIC_FTRACE
         trace_create_file("dyn_ftrace_total_info", 0444, d_tracer,
                         &ftrace_update_tot_cnt, &tracing_dyn_info_fops);
@@ -6877,7 +7179,7 @@ void __init trace_init(void)
                         tracepoint_printk = 0;
         }
         tracer_alloc_buffers();
-        trace_event_init();     
+        trace_event_init();
 }
 
 __init static int clear_boot_tracer(void)
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index d951deddec89..d2612016de94 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -1309,8 +1309,10 @@ static inline void init_ftrace_syscalls(void) { }
 
 #ifdef CONFIG_EVENT_TRACING
 void trace_event_init(void);
+void trace_event_enum_update(struct trace_enum_map **map, int len);
 #else
 static inline void __init trace_event_init(void) { }
+static inlin void trace_event_enum_update(struct trace_enum_map **map, int len) { }
 #endif
 
 extern struct trace_iterator *tracepoint_print_iter;
diff --git a/kernel/trace/trace_entries.h b/kernel/trace/trace_entries.h
index e2d027ac66a2..ee7b94a4810a 100644
--- a/kernel/trace/trace_entries.h
+++ b/kernel/trace/trace_entries.h
@@ -223,7 +223,7 @@ FTRACE_ENTRY(bprint, bprint_entry,
                 __dynamic_array(        u32,    buf     )
         ),
 
-        F_printk("%pf: %s",
+        F_printk("%ps: %s",
                  (void *)__entry->ip, __entry->fmt),
 
         FILTER_OTHER
@@ -238,7 +238,7 @@ FTRACE_ENTRY(print, print_entry,
                 __dynamic_array(        char,   buf     )
         ),
 
-        F_printk("%pf: %s",
+        F_printk("%ps: %s",
                  (void *)__entry->ip, __entry->buf),
 
         FILTER_OTHER
@@ -253,7 +253,7 @@ FTRACE_ENTRY(bputs, bputs_entry,
                 __field(        const char *,   str     )
         ),
 
-        F_printk("%pf: %s",
+        F_printk("%ps: %s",
                  (void *)__entry->ip, __entry->str),
 
         FILTER_OTHER
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index 0d2e47370ee7..7da1dfeb322e 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -1704,6 +1704,125 @@ __register_event(struct ftrace_event_call *call, struct module *mod)
         return 0;
 }
 
+static char *enum_replace(char *ptr, struct trace_enum_map *map, int len)
+{
+        int rlen;
+        int elen;
+
+        /* Find the length of the enum value as a string */
+        elen = snprintf(ptr, 0, "%ld", map->enum_value);
+        /* Make sure there's enough room to replace the string with the value */
+        if (len < elen)
+                return NULL;
+
+        snprintf(ptr, elen + 1, "%ld", map->enum_value);
+
+        /* Get the rest of the string of ptr */
+        rlen = strlen(ptr + len);
+        memmove(ptr + elen, ptr + len, rlen);
+        /* Make sure we end the new string */
+        ptr[elen + rlen] = 0;
+
+        return ptr + elen;
+}
+
+static void update_event_printk(struct ftrace_event_call *call,
+                                struct trace_enum_map *map)
+{
+        char *ptr;
+        int quote = 0;
+        int len = strlen(map->enum_string);
+
+        for (ptr = call->print_fmt; *ptr; ptr++) {
+                if (*ptr == '\\') {
+                        ptr++;
+                        /* paranoid */
+                        if (!*ptr)
+                                break;
+                        continue;
+                }
+                if (*ptr == '"') {
+                        quote ^= 1;
+                        continue;
+                }
+                if (quote)
+                        continue;
+                if (isdigit(*ptr)) {
+                        /* skip numbers */
+                        do {
+                                ptr++;
+                                /* Check for alpha chars like ULL */
+                        } while (isalnum(*ptr));
+                        /*
+                         * A number must have some kind of delimiter after
+                         * it, and we can ignore that too.
+                         */
+                        continue;
+                }
+                if (isalpha(*ptr) || *ptr == '_') {
+                        if (strncmp(map->enum_string, ptr, len) == 0 &&
+                            !isalnum(ptr[len]) && ptr[len] != '_') {
+                                ptr = enum_replace(ptr, map, len);
+                                /* Hmm, enum string smaller than value */
+                                if (WARN_ON_ONCE(!ptr))
+                                        return;
+                                /*
+                                 * No need to decrement here, as enum_replace()
+                                 * returns the pointer to the character passed
+                                 * the enum, and two enums can not be placed
+                                 * back to back without something in between.
+                                 * We can skip that something in between.
+                                 */
+                                continue;
+                        }
+                skip_more:
+                        do {
+                                ptr++;
+                        } while (isalnum(*ptr) || *ptr == '_');
+                        /*
+                         * If what comes after this variable is a '.' or
+                         * '->' then we can continue to ignore that string.
+                         */
+                        if (*ptr == '.' || (ptr[0] == '-' && ptr[1] == '>')) {
+                                ptr += *ptr == '.' ? 1 : 2;
+                                goto skip_more;
+                        }
+                        /*
+                         * Once again, we can skip the delimiter that came
+                         * after the string.
+                         */
+                        continue;
+                }
+        }
+}
+
+void trace_event_enum_update(struct trace_enum_map **map, int len)
+{
+        struct ftrace_event_call *call, *p;
+        const char *last_system = NULL;
+        int last_i;
+        int i;
+
+        down_write(&trace_event_sem);
+        list_for_each_entry_safe(call, p, &ftrace_events, list) {
+                /* events are usually grouped together with systems */
+                if (!last_system || call->class->system != last_system) {
+                        last_i = 0;
+                        last_system = call->class->system;
+                }
+
+                for (i = last_i; i < len; i++) {
+                        if (call->class->system == map[i]->system) {
+                                /* Save the first system if need be */
+                                if (!last_i)
+                                        last_i = i;
+                                update_event_printk(call, map[i]);
+                        }
+                }
+        }
+        up_write(&trace_event_sem);
+}
+
 static struct ftrace_event_file *
 trace_create_new_event(struct ftrace_event_call *call,
                        struct trace_array *tr)
@@ -1915,7 +2034,7 @@ static int trace_module_notify(struct notifier_block *self,
 
 static struct notifier_block trace_module_nb = {
         .notifier_call = trace_module_notify,
-        .priority = 0,
+        .priority = 1, /* higher than trace.c module notify */
 };
 #endif /* CONFIG_MODULES */
 
diff --git a/kernel/trace/trace_export.c b/kernel/trace/trace_export.c
index 12e2b99be862..174a6a71146c 100644
--- a/kernel/trace/trace_export.c
+++ b/kernel/trace/trace_export.c
@@ -177,7 +177,7 @@ struct ftrace_event_call __used event_##call = {			\
         },                                                              \
         .event.type             = etype,                                \
         .print_fmt              = print,                                \
-        .flags                  = TRACE_EVENT_FL_IGNORE_ENABLE | TRACE_EVENT_FL_USE_CALL_FILTER, \
+        .flags                  = TRACE_EVENT_FL_IGNORE_ENABLE,         \
 };                                                                      \
 struct ftrace_event_call __used                                         \
 __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call;
diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c
index ed998fbf09ce..9ba3f43f580e 100644
--- a/kernel/trace/trace_kprobe.c
+++ b/kernel/trace/trace_kprobe.c
@@ -250,7 +250,7 @@ DEFINE_FETCH_symbol(string_size)
 #define fetch_file_offset_string_size   NULL
 
 /* Fetch type information table */
-const struct fetch_type kprobes_fetch_type_table[] = {
+static const struct fetch_type kprobes_fetch_type_table[] = {
         /* Special types */
         [FETCH_TYPE_STRING] = __ASSIGN_FETCH_TYPE("string", string, string,
                                         sizeof(u32), 1, "__data_loc char[]"),
@@ -760,7 +760,8 @@ static int create_trace_kprobe(int argc, char **argv)
 
                 /* Parse fetch argument */
                 ret = traceprobe_parse_probe_arg(arg, &tk->tp.size, parg,
-                                                is_return, true);
+                                                is_return, true,
+                                                kprobes_fetch_type_table);
                 if (ret) {
                         pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
                         goto error;
diff --git a/kernel/trace/trace_probe.c b/kernel/trace/trace_probe.c
index b983b2fd2ca1..1769a81da8a7 100644
--- a/kernel/trace/trace_probe.c
+++ b/kernel/trace/trace_probe.c
@@ -356,17 +356,14 @@ static int parse_probe_vars(char *arg, const struct fetch_type *t,
 
 /* Recursive argument parser */
 static int parse_probe_arg(char *arg, const struct fetch_type *t,
-                     struct fetch_param *f, bool is_return, bool is_kprobe)
+                     struct fetch_param *f, bool is_return, bool is_kprobe,
+                     const struct fetch_type *ftbl)
 {
-        const struct fetch_type *ftbl;
         unsigned long param;
         long offset;
         char *tmp;
         int ret = 0;
 
-        ftbl = is_kprobe ? kprobes_fetch_type_table : uprobes_fetch_type_table;
-        BUG_ON(ftbl == NULL);
-
         switch (arg[0]) {
         case '$':
                 ret = parse_probe_vars(arg + 1, t, f, is_return, is_kprobe);
@@ -447,7 +444,7 @@ static int parse_probe_arg(char *arg, const struct fetch_type *t,
                         dprm->fetch_size = get_fetch_size_function(t,
                                                         dprm->fetch, ftbl);
                         ret = parse_probe_arg(arg, t2, &dprm->orig, is_return,
-                                                        is_kprobe);
+                                                        is_kprobe, ftbl);
                         if (ret)
                                 kfree(dprm);
                         else {
@@ -505,15 +502,12 @@ static int __parse_bitfield_probe_arg(const char *bf,
 
 /* String length checking wrapper */
 int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
-                struct probe_arg *parg, bool is_return, bool is_kprobe)
+                struct probe_arg *parg, bool is_return, bool is_kprobe,
+                const struct fetch_type *ftbl)
 {
-        const struct fetch_type *ftbl;
         const char *t;
         int ret;
 
-        ftbl = is_kprobe ? kprobes_fetch_type_table : uprobes_fetch_type_table;
-        BUG_ON(ftbl == NULL);
-
         if (strlen(arg) > MAX_ARGSTR_LEN) {
                 pr_info("Argument is too long.: %s\n",  arg);
                 return -ENOSPC;
@@ -535,7 +529,8 @@ int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
         }
         parg->offset = *size;
         *size += parg->type->size;
-        ret = parse_probe_arg(arg, parg->type, &parg->fetch, is_return, is_kprobe);
+        ret = parse_probe_arg(arg, parg->type, &parg->fetch, is_return,
+                              is_kprobe, ftbl);
 
         if (ret >= 0 && t != NULL)
                 ret = __parse_bitfield_probe_arg(t, parg->type, &parg->fetch);
diff --git a/kernel/trace/trace_probe.h b/kernel/trace/trace_probe.h
index 19aff635841a..ab283e146b70 100644
--- a/kernel/trace/trace_probe.h
+++ b/kernel/trace/trace_probe.h
@@ -229,13 +229,6 @@ ASSIGN_FETCH_FUNC(file_offset, ftype),			\
 #define FETCH_TYPE_STRING       0
 #define FETCH_TYPE_STRSIZE      1
 
-/*
- * Fetch type information table.
- * It's declared as a weak symbol due to conditional compilation.
- */
-extern __weak const struct fetch_type kprobes_fetch_type_table[];
-extern __weak const struct fetch_type uprobes_fetch_type_table[];
-
 #ifdef CONFIG_KPROBE_EVENT
 struct symbol_cache;
 unsigned long update_symbol_cache(struct symbol_cache *sc);
@@ -333,7 +326,8 @@ find_event_file_link(struct trace_probe *tp, struct ftrace_event_file *file)
 }
 
 extern int traceprobe_parse_probe_arg(char *arg, ssize_t *size,
-                   struct probe_arg *parg, bool is_return, bool is_kprobe);
+                   struct probe_arg *parg, bool is_return, bool is_kprobe,
+                   const struct fetch_type *ftbl);
 
 extern int traceprobe_conflict_field_name(const char *name,
                                struct probe_arg *args, int narg);
diff --git a/kernel/trace/trace_uprobe.c b/kernel/trace/trace_uprobe.c
index 7dc1c8abecd6..74865465e0b7 100644
--- a/kernel/trace/trace_uprobe.c
+++ b/kernel/trace/trace_uprobe.c
@@ -196,7 +196,7 @@ DEFINE_FETCH_file_offset(string)
 DEFINE_FETCH_file_offset(string_size)
 
 /* Fetch type information table */
-const struct fetch_type uprobes_fetch_type_table[] = {
+static const struct fetch_type uprobes_fetch_type_table[] = {
         /* Special types */
         [FETCH_TYPE_STRING] = __ASSIGN_FETCH_TYPE("string", string, string,
                                         sizeof(u32), 1, "__data_loc char[]"),
@@ -535,7 +535,8 @@ static int create_trace_uprobe(int argc, char **argv)
 
                 /* Parse fetch argument */
                 ret = traceprobe_parse_probe_arg(arg, &tu->tp.size, parg,
-                                                 is_return, false);
+                                                 is_return, false,
+                                                 uprobes_fetch_type_table);
                 if (ret) {
                         pr_info("Parse error at argument[%d]. (%d)\n", i, ret);
                         goto error;