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

Pull more tracing updates from Steven Rostedt:
 "This includes the final patch to clean up and fix the issue with the
  design of tracepoints and how a user could register a tracepoint and
  have that tracepoint not be activated but no error was shown.

  The design was for an out of tree module but broke in tree users.  The
  clean up was to remove the saving of the hash table of tracepoint
  names such that they can be enabled before they exist (enabling a
  module tracepoint before that module is loaded).  This added more
  complexity than needed.  The clean up was to remove that code and just
  enable tracepoints that exist or fail if they do not.

  This removed a lot of code as well as the complexity that it brought.
  As a side effect, instead of registering a tracepoint by its name, the
  tracepoint needs to be registered with the tracepoint descriptor.
  This removes having to duplicate the tracepoint names that are
  enabled.

  The second patch was added that simplified the way modules were
  searched for.

  This cleanup required changes that were in the 3.15 queue as well as
  some changes that were added late in the 3.14-rc cycle.  This final
  change waited till the two were merged in upstream and then the change
  was added and full tests were run.  Unfortunately, the test found some
  errors, but after it was already submitted to the for-next branch and
  not to be rebased.  Sparse errors were detected by Fengguang Wu's bot
  tests, and my internal tests discovered that the anonymous union
  initialization triggered a bug in older gcc compilers.  Luckily, there
  was a bugzilla for the gcc bug which gave a work around to the
  problem.  The third and fourth patch handled the sparse error and the
  gcc bug respectively.

  A final patch was tagged along to fix a missing documentation for the
  README file"

* tag 'trace-3.15-v2' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace:
  tracing: Add missing function triggers dump and cpudump to README
  tracing: Fix anonymous unions in struct ftrace_event_call
  tracepoint: Fix sparse warnings in tracepoint.c
  tracepoint: Simplify tracepoint module search
  tracepoint: Use struct pointer instead of name hash for reg/unreg tracepoints

diff --cc include/linux/syscalls.h
Simple merge

diff --cc kernel/tracepoint.c
index fb0a38a265555c6c846254859c83468d0aba0f35,ca2cfe21bb8e22ab02b3cb7a5c3536dcc8309a6f..ac5b23cf7212c6ebb0045bedce2f13ee8d0a19b3
--- 1/kernel/tracepoint.c
--- 2/kernel/tracepoint.c
+++ b/kernel/tracepoint.c
@@@ -459,11 -284,77 +284,78 @@@ EXPORT_SYMBOL_GPL(tracepoint_probe_unre
  #ifdef CONFIG_MODULES
  bool trace_module_has_bad_taint(struct module *mod)
  {
 -      return mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP));
 +      return mod->taints & ~((1 << TAINT_OOT_MODULE) | (1 << TAINT_CRAP) |
 +                             (1 << TAINT_UNSIGNED_MODULE));
  }
  
+ static BLOCKING_NOTIFIER_HEAD(tracepoint_notify_list);
+ 
+ /**
+  * register_tracepoint_notifier - register tracepoint coming/going notifier
+  * @nb: notifier block
+  *
+  * Notifiers registered with this function are called on module
+  * coming/going with the tracepoint_module_list_mutex held.
+  * The notifier block callback should expect a "struct tp_module" data
+  * pointer.
+  */
+ int register_tracepoint_module_notifier(struct notifier_block *nb)
+ {
+       struct tp_module *tp_mod;
+       int ret;
+ 
+       mutex_lock(&tracepoint_module_list_mutex);
+       ret = blocking_notifier_chain_register(&tracepoint_notify_list, nb);
+       if (ret)
+               goto end;
+       list_for_each_entry(tp_mod, &tracepoint_module_list, list)
+               (void) nb->notifier_call(nb, MODULE_STATE_COMING, tp_mod);
+ end:
+       mutex_unlock(&tracepoint_module_list_mutex);
+       return ret;
+ }
+ EXPORT_SYMBOL_GPL(register_tracepoint_module_notifier);
+ 
+ /**
+  * unregister_tracepoint_notifier - unregister tracepoint coming/going notifier
+  * @nb: notifier block
+  *
+  * The notifier block callback should expect a "struct tp_module" data
+  * pointer.
+  */
+ int unregister_tracepoint_module_notifier(struct notifier_block *nb)
+ {
+       struct tp_module *tp_mod;
+       int ret;
+ 
+       mutex_lock(&tracepoint_module_list_mutex);
+       ret = blocking_notifier_chain_unregister(&tracepoint_notify_list, nb);
+       if (ret)
+               goto end;
+       list_for_each_entry(tp_mod, &tracepoint_module_list, list)
+               (void) nb->notifier_call(nb, MODULE_STATE_GOING, tp_mod);
+ end:
+       mutex_unlock(&tracepoint_module_list_mutex);
+       return ret;
+ 
+ }
+ EXPORT_SYMBOL_GPL(unregister_tracepoint_module_notifier);
+ 
+ /*
+  * Ensure the tracer unregistered the module's probes before the module
+  * teardown is performed. Prevents leaks of probe and data pointers.
+  */
+ static void tp_module_going_check_quiescent(struct tracepoint * const *begin,
+               struct tracepoint * const *end)
+ {
+       struct tracepoint * const *iter;
+ 
+       if (!begin)
+               return;
+       for (iter = begin; iter < end; iter++)
+               WARN_ON_ONCE((*iter)->funcs);
+ }
+ 
  static int tracepoint_module_coming(struct module *mod)
  {
        struct tp_module *tp_mod;