Merge tag 'modules-next-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux

Pull module updates from Rusty Russell:
 "The exciting thing here is the getting rid of stop_machine on module
  removal.  This is possible by using a simple atomic_t for the counter,
  rather than our fancy per-cpu counter: it turns out that no one is
  doing a module increment per net packet, so the slowdown should be in
  the noise"

* tag 'modules-next-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux:
  param: do not set store func without write perm
  params: cleanup sysfs allocation
  kernel:module Fix coding style errors and warnings.
  module: Remove stop_machine from module unloading
  module: Replace module_ref with atomic_t refcnt
  lib/bug: Use RCU list ops for module_bug_list
  module: Unlink module with RCU synchronizing instead of stop_machine
  module: Wait for RCU synchronizing before releasing a module

1 files changed, 14 insertions, 6 deletions

diff --git a/lib/bug.c b/lib/bug.c
index d1d7c7878900..0c3bd9552b6f 100644
--- a/lib/bug.c
+++ b/lib/bug.c
@@ -64,16 +64,22 @@ static LIST_HEAD(module_bug_list);
 static const struct bug_entry *module_find_bug(unsigned long bugaddr)
 {
         struct module *mod;
+        const struct bug_entry *bug = NULL;
 
-        list_for_each_entry(mod, &module_bug_list, bug_list) {
-                const struct bug_entry *bug = mod->bug_table;
+        rcu_read_lock();
+        list_for_each_entry_rcu(mod, &module_bug_list, bug_list) {
                 unsigned i;
 
+                bug = mod->bug_table;
                 for (i = 0; i < mod->num_bugs; ++i, ++bug)
                         if (bugaddr == bug_addr(bug))
-                                return bug;
+                                goto out;
         }
-        return NULL;
+        bug = NULL;
+out:
+        rcu_read_unlock();
+
+        return bug;
 }
 
 void module_bug_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
@@ -99,13 +105,15 @@ void module_bug_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
          * Strictly speaking this should have a spinlock to protect against
          * traversals, but since we only traverse on BUG()s, a spinlock
          * could potentially lead to deadlock and thus be counter-productive.
+         * Thus, this uses RCU to safely manipulate the bug list, since BUG
+         * must run in non-interruptive state.
          */
-        list_add(&mod->bug_list, &module_bug_list);
+        list_add_rcu(&mod->bug_list, &module_bug_list);
 }
 
 void module_bug_cleanup(struct module *mod)
 {
-        list_del(&mod->bug_list);
+        list_del_rcu(&mod->bug_list);
 }
 
 #else