1 files changed, 249 insertions, 157 deletions

diff --git a/kernel/module.c b/kernel/module.c
index c9332c90d5a0..e797812a4d95 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -51,6 +51,7 @@
 #include <linux/tracepoint.h>
 #include <linux/ftrace.h>
 #include <linux/async.h>
+#include <linux/percpu.h>
 
 #if 0
 #define DEBUGP printk
@@ -67,7 +68,8 @@
 
 /* List of modules, protected by module_mutex or preempt_disable
  * (delete uses stop_machine/add uses RCU list operations). */
-static DEFINE_MUTEX(module_mutex);
+DEFINE_MUTEX(module_mutex);
+EXPORT_SYMBOL_GPL(module_mutex);
 static LIST_HEAD(modules);
 
 /* Waiting for a module to finish initializing? */
@@ -75,7 +77,7 @@ static DECLARE_WAIT_QUEUE_HEAD(module_wq);
 
 static BLOCKING_NOTIFIER_HEAD(module_notify_list);
 
-/* Bounds of module allocation, for speeding __module_text_address */
+/* Bounds of module allocation, for speeding __module_address */
 static unsigned long module_addr_min = -1UL, module_addr_max = 0;
 
 int register_module_notifier(struct notifier_block * nb)
@@ -185,17 +187,6 @@ extern const unsigned long __start___kcrctab_unused_gpl[];
 #define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
 #endif
 
-struct symsearch {
-        const struct kernel_symbol *start, *stop;
-        const unsigned long *crcs;
-        enum {
-                NOT_GPL_ONLY,
-                GPL_ONLY,
-                WILL_BE_GPL_ONLY,
-        } licence;
-        bool unused;
-};
-
 static bool each_symbol_in_section(const struct symsearch *arr,
                                    unsigned int arrsize,
                                    struct module *owner,
@@ -216,10 +207,8 @@ static bool each_symbol_in_section(const struct symsearch *arr,
 }
 
 /* Returns true as soon as fn returns true, otherwise false. */
-static bool each_symbol(bool (*fn)(const struct symsearch *arr,
-                                   struct module *owner,
-                                   unsigned int symnum, void *data),
-                        void *data)
+bool each_symbol(bool (*fn)(const struct symsearch *arr, struct module *owner,
+                            unsigned int symnum, void *data), void *data)
 {
         struct module *mod;
         const struct symsearch arr[] = {
@@ -272,6 +261,7 @@ static bool each_symbol(bool (*fn)(const struct symsearch *arr,
         }
         return false;
 }
+EXPORT_SYMBOL_GPL(each_symbol);
 
 struct find_symbol_arg {
         /* Input */
@@ -282,7 +272,7 @@ struct find_symbol_arg {
         /* Output */
         struct module *owner;
         const unsigned long *crc;
-        unsigned long value;
+        const struct kernel_symbol *sym;
 };
 
 static bool find_symbol_in_section(const struct symsearch *syms,
@@ -323,17 +313,17 @@ static bool find_symbol_in_section(const struct symsearch *syms,
 
         fsa->owner = owner;
         fsa->crc = symversion(syms->crcs, symnum);
-        fsa->value = syms->start[symnum].value;
+        fsa->sym = &syms->start[symnum];
         return true;
 }
 
-/* Find a symbol, return value, (optional) crc and (optional) module
- * which owns it */
-static unsigned long find_symbol(const char *name,
-                                 struct module **owner,
-                                 const unsigned long **crc,
-                                 bool gplok,
-                                 bool warn)
+/* Find a symbol and return it, along with, (optional) crc and
+ * (optional) module which owns it */
+const struct kernel_symbol *find_symbol(const char *name,
+                                        struct module **owner,
+                                        const unsigned long **crc,
+                                        bool gplok,
+                                        bool warn)
 {
         struct find_symbol_arg fsa;
 
@@ -346,15 +336,16 @@ static unsigned long find_symbol(const char *name,
                         *owner = fsa.owner;
                 if (crc)
                         *crc = fsa.crc;
-                return fsa.value;
+                return fsa.sym;
         }
 
         DEBUGP("Failed to find symbol %s\n", name);
-        return -ENOENT;
+        return NULL;
 }
+EXPORT_SYMBOL_GPL(find_symbol);
 
 /* Search for module by name: must hold module_mutex. */
-static struct module *find_module(const char *name)
+struct module *find_module(const char *name)
 {
         struct module *mod;
 
@@ -364,8 +355,37 @@ static struct module *find_module(const char *name)
         }
         return NULL;
 }
+EXPORT_SYMBOL_GPL(find_module);
 
 #ifdef CONFIG_SMP
+
+#ifdef CONFIG_HAVE_DYNAMIC_PER_CPU_AREA
+
+static void *percpu_modalloc(unsigned long size, unsigned long align,
+                             const char *name)
+{
+        void *ptr;
+
+        if (align > PAGE_SIZE) {
+                printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
+                       name, align, PAGE_SIZE);
+                align = PAGE_SIZE;
+        }
+
+        ptr = __alloc_reserved_percpu(size, align);
+        if (!ptr)
+                printk(KERN_WARNING
+                       "Could not allocate %lu bytes percpu data\n", size);
+        return ptr;
+}
+
+static void percpu_modfree(void *freeme)
+{
+        free_percpu(freeme);
+}
+
+#else /* ... !CONFIG_HAVE_DYNAMIC_PER_CPU_AREA */
+
 /* Number of blocks used and allocated. */
 static unsigned int pcpu_num_used, pcpu_num_allocated;
 /* Size of each block.  -ve means used. */
@@ -480,21 +500,6 @@ static void percpu_modfree(void *freeme)
         }
 }
 
-static unsigned int find_pcpusec(Elf_Ehdr *hdr,
-                                 Elf_Shdr *sechdrs,
-                                 const char *secstrings)
-{
-        return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
-}
-
-static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)
-{
-        int cpu;
-
-        for_each_possible_cpu(cpu)
-                memcpy(pcpudest + per_cpu_offset(cpu), from, size);
-}
-
 static int percpu_modinit(void)
 {
         pcpu_num_used = 2;
@@ -513,7 +518,26 @@ static int percpu_modinit(void)
         return 0;
 }
 __initcall(percpu_modinit);
+
+#endif /* CONFIG_HAVE_DYNAMIC_PER_CPU_AREA */
+
+static unsigned int find_pcpusec(Elf_Ehdr *hdr,
+                                 Elf_Shdr *sechdrs,
+                                 const char *secstrings)
+{
+        return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
+}
+
+static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)
+{
+        int cpu;
+
+        for_each_possible_cpu(cpu)
+                memcpy(pcpudest + per_cpu_offset(cpu), from, size);
+}
+
 #else /* ... !CONFIG_SMP */
+
 static inline void *percpu_modalloc(unsigned long size, unsigned long align,
                                     const char *name)
 {
@@ -535,6 +559,7 @@ static inline void percpu_modcopy(void *pcpudst, const void *src,
         /* pcpusec should be 0, and size of that section should be 0. */
         BUG_ON(size != 0);
 }
+
 #endif /* CONFIG_SMP */
 
 #define MODINFO_ATTR(field)     \
@@ -573,13 +598,13 @@ static char last_unloaded_module[MODULE_NAME_LEN+1];
 /* Init the unload section of the module. */
 static void module_unload_init(struct module *mod)
 {
-        unsigned int i;
+        int cpu;
 
         INIT_LIST_HEAD(&mod->modules_which_use_me);
-        for (i = 0; i < NR_CPUS; i++)
-                local_set(&mod->ref[i].count, 0);
+        for_each_possible_cpu(cpu)
+                local_set(__module_ref_addr(mod, cpu), 0);
         /* Hold reference count during initialization. */
-        local_set(&mod->ref[raw_smp_processor_id()].count, 1);
+        local_set(__module_ref_addr(mod, raw_smp_processor_id()), 1);
         /* Backwards compatibility macros put refcount during init. */
         mod->waiter = current;
 }
@@ -607,7 +632,7 @@ static int already_uses(struct module *a, struct module *b)
 }
 
 /* Module a uses b */
-static int use_module(struct module *a, struct module *b)
+int use_module(struct module *a, struct module *b)
 {
         struct module_use *use;
         int no_warn, err;
@@ -640,6 +665,7 @@ static int use_module(struct module *a, struct module *b)
         no_warn = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name);
         return 1;
 }
+EXPORT_SYMBOL_GPL(use_module);
 
 /* Clear the unload stuff of the module. */
 static void module_unload_free(struct module *mod)
@@ -717,10 +743,11 @@ static int try_stop_module(struct module *mod, int flags, int *forced)
 
 unsigned int module_refcount(struct module *mod)
 {
-        unsigned int i, total = 0;
+        unsigned int total = 0;
+        int cpu;
 
-        for (i = 0; i < NR_CPUS; i++)
-                total += local_read(&mod->ref[i].count);
+        for_each_possible_cpu(cpu)
+                total += local_read(__module_ref_addr(mod, cpu));
         return total;
 }
 EXPORT_SYMBOL(module_refcount);
@@ -743,8 +770,8 @@ static void wait_for_zero_refcount(struct module *mod)
         mutex_lock(&module_mutex);
 }
 
-asmlinkage long
-sys_delete_module(const char __user *name_user, unsigned int flags)
+SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
+                unsigned int, flags)
 {
         struct module *mod;
         char name[MODULE_NAME_LEN];
@@ -821,7 +848,7 @@ sys_delete_module(const char __user *name_user, unsigned int flags)
         mutex_lock(&module_mutex);
         /* Store the name of the last unloaded module for diagnostic purposes */
         strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
-        unregister_dynamic_debug_module(mod->name);
+        ddebug_remove_module(mod->name);
         free_module(mod);
 
  out:
@@ -859,7 +886,7 @@ void __symbol_put(const char *symbol)
         struct module *owner;
 
         preempt_disable();
-        if (IS_ERR_VALUE(find_symbol(symbol, &owner, NULL, true, false)))
+        if (!find_symbol(symbol, &owner, NULL, true, false))
                 BUG();
         module_put(owner);
         preempt_enable();
@@ -873,8 +900,10 @@ void symbol_put_addr(void *addr)
         if (core_kernel_text((unsigned long)addr))
                 return;
 
-        if (!(modaddr = module_text_address((unsigned long)addr)))
-                BUG();
+        /* module_text_address is safe here: we're supposed to have reference
+         * to module from symbol_get, so it can't go away. */
+        modaddr = __module_text_address((unsigned long)addr);
+        BUG_ON(!modaddr);
         module_put(modaddr);
 }
 EXPORT_SYMBOL_GPL(symbol_put_addr);
@@ -894,7 +923,7 @@ void module_put(struct module *module)
 {
         if (module) {
                 unsigned int cpu = get_cpu();
-                local_dec(&module->ref[cpu].count);
+                local_dec(__module_ref_addr(module, cpu));
                 /* Maybe they're waiting for us to drop reference? */
                 if (unlikely(!module_is_live(module)))
                         wake_up_process(module->waiter);
@@ -914,10 +943,11 @@ static inline void module_unload_free(struct module *mod)
 {
 }
 
-static inline int use_module(struct module *a, struct module *b)
+int use_module(struct module *a, struct module *b)
 {
         return strong_try_module_get(b) == 0;
 }
+EXPORT_SYMBOL_GPL(use_module);
 
 static inline void module_unload_init(struct module *mod)
 {
@@ -960,12 +990,12 @@ static struct module_attribute *modinfo_attrs[] = {
 
 static const char vermagic[] = VERMAGIC_STRING;
 
-static int try_to_force_load(struct module *mod, const char *symname)
+static int try_to_force_load(struct module *mod, const char *reason)
 {
 #ifdef CONFIG_MODULE_FORCE_LOAD
         if (!test_taint(TAINT_FORCED_MODULE))
-                printk("%s: no version for \"%s\" found: kernel tainted.\n",
-                       mod->name, symname);
+                printk(KERN_WARNING "%s: %s: kernel tainted.\n",
+                       mod->name, reason);
         add_taint_module(mod, TAINT_FORCED_MODULE);
         return 0;
 #else
@@ -1022,9 +1052,9 @@ static inline int check_modstruct_version(Elf_Shdr *sechdrs,
 {
         const unsigned long *crc;
 
-        if (IS_ERR_VALUE(find_symbol("struct_module", NULL, &crc, true, false)))
+        if (!find_symbol("module_layout", NULL, &crc, true, false))
                 BUG();
-        return check_version(sechdrs, versindex, "struct_module", mod, crc);
+        return check_version(sechdrs, versindex, "module_layout", mod, crc);
 }
 
 /* First part is kernel version, which we ignore if module has crcs. */
@@ -1063,25 +1093,25 @@ static inline int same_magic(const char *amagic, const char *bmagic,
 
 /* Resolve a symbol for this module.  I.e. if we find one, record usage.
    Must be holding module_mutex. */
-static unsigned long resolve_symbol(Elf_Shdr *sechdrs,
-                                    unsigned int versindex,
-                                    const char *name,
-                                    struct module *mod)
+static const struct kernel_symbol *resolve_symbol(Elf_Shdr *sechdrs,
+                                                  unsigned int versindex,
+                                                  const char *name,
+                                                  struct module *mod)
 {
         struct module *owner;
-        unsigned long ret;
+        const struct kernel_symbol *sym;
         const unsigned long *crc;
 
-        ret = find_symbol(name, &owner, &crc,
+        sym = find_symbol(name, &owner, &crc,
                           !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
-        if (!IS_ERR_VALUE(ret)) {
-                /* use_module can fail due to OOM,
-                   or module initialization or unloading */
+        /* use_module can fail due to OOM,
+           or module initialization or unloading */
+        if (sym) {
                 if (!check_version(sechdrs, versindex, name, mod, crc) ||
                     !use_module(mod, owner))
-                        ret = -EINVAL;
+                        sym = NULL;
         }
-        return ret;
+        return sym;
 }
 
 /*
@@ -1456,6 +1486,9 @@ static void free_module(struct module *mod)
         /* Module unload stuff */
         module_unload_free(mod);
 
+        /* Free any allocated parameters. */
+        destroy_params(mod->kp, mod->num_kp);
+
         /* release any pointers to mcount in this module */
         ftrace_release(mod->module_core, mod->core_size);
 
@@ -1464,7 +1497,10 @@ static void free_module(struct module *mod)
         kfree(mod->args);
         if (mod->percpu)
                 percpu_modfree(mod->percpu);
-
+#if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
+        if (mod->refptr)
+                percpu_modfree(mod->refptr);
+#endif
         /* Free lock-classes: */
         lockdep_free_key_range(mod->module_core, mod->core_size);
 
@@ -1475,17 +1511,15 @@ static void free_module(struct module *mod)
 void *__symbol_get(const char *symbol)
 {
         struct module *owner;
-        unsigned long value;
+        const struct kernel_symbol *sym;
 
         preempt_disable();
-        value = find_symbol(symbol, &owner, NULL, true, true);
-        if (IS_ERR_VALUE(value))
-                value = 0;
-        else if (strong_try_module_get(owner))
-                value = 0;
+        sym = find_symbol(symbol, &owner, NULL, true, true);
+        if (sym && strong_try_module_get(owner))
+                sym = NULL;
         preempt_enable();
 
-        return (void *)value;
+        return sym ? (void *)sym->value : NULL;
 }
 EXPORT_SYMBOL_GPL(__symbol_get);
 
@@ -1513,8 +1547,7 @@ static int verify_export_symbols(struct module *mod)
 
         for (i = 0; i < ARRAY_SIZE(arr); i++) {
                 for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) {
-                        if (!IS_ERR_VALUE(find_symbol(s->name, &owner,
-                                                      NULL, true, false))) {
+                        if (find_symbol(s->name, &owner, NULL, true, false)) {
                                 printk(KERN_ERR
                                        "%s: exports duplicate symbol %s"
                                        " (owned by %s)\n",
@@ -1538,6 +1571,7 @@ static int simplify_symbols(Elf_Shdr *sechdrs,
         unsigned long secbase;
         unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
         int ret = 0;
+        const struct kernel_symbol *ksym;
 
         for (i = 1; i < n; i++) {
                 switch (sym[i].st_shndx) {
@@ -1557,13 +1591,14 @@ static int simplify_symbols(Elf_Shdr *sechdrs,
                         break;
 
                 case SHN_UNDEF:
-                        sym[i].st_value
-                          = resolve_symbol(sechdrs, versindex,
-                                           strtab + sym[i].st_name, mod);
-
+                        ksym = resolve_symbol(sechdrs, versindex,
+                                              strtab + sym[i].st_name, mod);
                         /* Ok if resolved.  */
-                        if (!IS_ERR_VALUE(sym[i].st_value))
+                        if (ksym) {
+                                sym[i].st_value = ksym->value;
                                 break;
+                        }
+
                         /* Ok if weak.  */
                         if (ELF_ST_BIND(sym[i].st_info) == STB_WEAK)
                                 break;
@@ -1638,8 +1673,7 @@ static void layout_sections(struct module *mod,
                         if ((s->sh_flags & masks[m][0]) != masks[m][0]
                             || (s->sh_flags & masks[m][1])
                             || s->sh_entsize != ~0UL
-                            || strncmp(secstrings + s->sh_name,
-                                       ".init", 5) == 0)
+                            || strstarts(secstrings + s->sh_name, ".init"))
                                 continue;
                         s->sh_entsize = get_offset(mod, &mod->core_size, s, i);
                         DEBUGP("\t%s\n", secstrings + s->sh_name);
@@ -1656,8 +1690,7 @@ static void layout_sections(struct module *mod,
                         if ((s->sh_flags & masks[m][0]) != masks[m][0]
                             || (s->sh_flags & masks[m][1])
                             || s->sh_entsize != ~0UL
-                            || strncmp(secstrings + s->sh_name,
-                                       ".init", 5) != 0)
+                            || !strstarts(secstrings + s->sh_name, ".init"))
                                 continue;
                         s->sh_entsize = (get_offset(mod, &mod->init_size, s, i)
                                          | INIT_OFFSET_MASK);
@@ -1790,8 +1823,7 @@ static char elf_type(const Elf_Sym *sym,
                 else
                         return 'b';
         }
-        if (strncmp(secstrings + sechdrs[sym->st_shndx].sh_name,
-                    ".debug", strlen(".debug")) == 0)
+        if (strstarts(secstrings + sechdrs[sym->st_shndx].sh_name, ".debug"))
                 return 'n';
         return '?';
 }
@@ -1823,19 +1855,13 @@ static inline void add_kallsyms(struct module *mod,
 }
 #endif /* CONFIG_KALLSYMS */
 
-static void dynamic_printk_setup(struct mod_debug *debug, unsigned int num)
+static void dynamic_debug_setup(struct _ddebug *debug, unsigned int num)
 {
-#ifdef CONFIG_DYNAMIC_PRINTK_DEBUG
-        unsigned int i;
-
-        for (i = 0; i < num; i++) {
-                register_dynamic_debug_module(debug[i].modname,
-                                              debug[i].type,
-                                              debug[i].logical_modname,
-                                              debug[i].flag_names,
-                                              debug[i].hash, debug[i].hash2);
-        }
-#endif /* CONFIG_DYNAMIC_PRINTK_DEBUG */
+#ifdef CONFIG_DYNAMIC_DEBUG
+        if (ddebug_add_module(debug, num, debug->modname))
+                printk(KERN_ERR "dynamic debug error adding module: %s\n",
+                                        debug->modname);
+#endif
 }
 
 static void *module_alloc_update_bounds(unsigned long size)
@@ -1866,8 +1892,7 @@ static noinline struct module *load_module(void __user *umod,
         unsigned int symindex = 0;
         unsigned int strindex = 0;
         unsigned int modindex, versindex, infoindex, pcpuindex;
-        unsigned int num_kp, num_mcount;
-        struct kernel_param *kp;
+        unsigned int num_mcount;
         struct module *mod;
         long err = 0;
         void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */
@@ -1884,12 +1909,6 @@ static noinline struct module *load_module(void __user *umod,
         if (len > 64 * 1024 * 1024 || (hdr = vmalloc(len)) == NULL)
                 return ERR_PTR(-ENOMEM);
 
-        /* Create stop_machine threads since the error path relies on
-         * a non-failing stop_machine call. */
-        err = stop_machine_create();
-        if (err)
-                goto free_hdr;
-
         if (copy_from_user(hdr, umod, len) != 0) {
                 err = -EFAULT;
                 goto free_hdr;
@@ -1930,7 +1949,7 @@ static noinline struct module *load_module(void __user *umod,
                 }
 #ifndef CONFIG_MODULE_UNLOAD
                 /* Don't load .exit sections */
-                if (strncmp(secstrings+sechdrs[i].sh_name, ".exit", 5) == 0)
+                if (strstarts(secstrings+sechdrs[i].sh_name, ".exit"))
                         sechdrs[i].sh_flags &= ~(unsigned long)SHF_ALLOC;
 #endif
         }
@@ -1974,7 +1993,7 @@ static noinline struct module *load_module(void __user *umod,
         modmagic = get_modinfo(sechdrs, infoindex, "vermagic");
         /* This is allowed: modprobe --force will invalidate it. */
         if (!modmagic) {
-                err = try_to_force_load(mod, "magic");
+                err = try_to_force_load(mod, "bad vermagic");
                 if (err)
                         goto free_hdr;
         } else if (!same_magic(modmagic, vermagic, versindex)) {
@@ -2070,6 +2089,14 @@ static noinline struct module *load_module(void __user *umod,
         /* Module has been moved. */
         mod = (void *)sechdrs[modindex].sh_addr;
 
+#if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
+        mod->refptr = percpu_modalloc(sizeof(local_t), __alignof__(local_t),
+                                      mod->name);
+        if (!mod->refptr) {
+                err = -ENOMEM;
+                goto free_init;
+        }
+#endif
         /* Now we've moved module, initialize linked lists, etc. */
         module_unload_init(mod);
 
@@ -2104,8 +2131,8 @@ static noinline struct module *load_module(void __user *umod,
 
         /* Now we've got everything in the final locations, we can
          * find optional sections. */
-        kp = section_objs(hdr, sechdrs, secstrings, "__param", sizeof(*kp),
-                          &num_kp);
+        mod->kp = section_objs(hdr, sechdrs, secstrings, "__param",
+                               sizeof(*mod->kp), &mod->num_kp);
         mod->syms = section_objs(hdr, sechdrs, secstrings, "__ksymtab",
                                  sizeof(*mod->syms), &mod->num_syms);
         mod->crcs = section_addr(hdr, sechdrs, secstrings, "__kcrctab");
@@ -2155,8 +2182,8 @@ static noinline struct module *load_module(void __user *umod,
             || (mod->num_unused_gpl_syms && !mod->unused_gpl_crcs)
 #endif
                 ) {
-                printk(KERN_WARNING "%s: No versions for exported symbols.\n", mod->name);
-                err = try_to_force_load(mod, "nocrc");
+                err = try_to_force_load(mod,
+                                        "no versions for exported symbols");
                 if (err)
                         goto cleanup;
         }
@@ -2201,12 +2228,13 @@ static noinline struct module *load_module(void __user *umod,
         add_kallsyms(mod, sechdrs, symindex, strindex, secstrings);
 
         if (!mod->taints) {
-                struct mod_debug *debug;
+                struct _ddebug *debug;
                 unsigned int num_debug;
 
                 debug = section_objs(hdr, sechdrs, secstrings, "__verbose",
                                      sizeof(*debug), &num_debug);
-                dynamic_printk_setup(debug, num_debug);
+                if (debug)
+                        dynamic_debug_setup(debug, num_debug);
         }
 
         /* sechdrs[0].sh_size is always zero */
@@ -2250,11 +2278,11 @@ static noinline struct module *load_module(void __user *umod,
          */
         list_add_rcu(&mod->list, &modules);
 
-        err = parse_args(mod->name, mod->args, kp, num_kp, NULL);
+        err = parse_args(mod->name, mod->args, mod->kp, mod->num_kp, NULL);
         if (err < 0)
                 goto unlink;
 
-        err = mod_sysfs_setup(mod, kp, num_kp);
+        err = mod_sysfs_setup(mod, mod->kp, mod->num_kp);
         if (err < 0)
                 goto unlink;
         add_sect_attrs(mod, hdr->e_shnum, secstrings, sechdrs);
@@ -2263,12 +2291,13 @@ static noinline struct module *load_module(void __user *umod,
         /* Get rid of temporary copy */
         vfree(hdr);
 
-        stop_machine_destroy();
         /* Done! */
         return mod;
 
  unlink:
-        stop_machine(__unlink_module, mod, NULL);
+        /* Unlink carefully: kallsyms could be walking list. */
+        list_del_rcu(&mod->list);
+        synchronize_sched();
         module_arch_cleanup(mod);
  cleanup:
         kobject_del(&mod->mkobj.kobj);
@@ -2276,9 +2305,14 @@ static noinline struct module *load_module(void __user *umod,
         ftrace_release(mod->module_core, mod->core_size);
  free_unload:
         module_unload_free(mod);
+#if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
+ free_init:
+        percpu_modfree(mod->refptr);
+#endif
         module_free(mod, mod->module_init);
  free_core:
         module_free(mod, mod->module_core);
+        /* mod will be freed with core. Don't access it beyond this line! */
  free_percpu:
         if (percpu)
                 percpu_modfree(percpu);
@@ -2286,7 +2320,6 @@ static noinline struct module *load_module(void __user *umod,
         kfree(args);
  free_hdr:
         vfree(hdr);
-        stop_machine_destroy();
         return ERR_PTR(err);
 
  truncated:
@@ -2296,10 +2329,8 @@ static noinline struct module *load_module(void __user *umod,
 }
 
 /* This is where the real work happens */
-asmlinkage long
-sys_init_module(void __user *umod,
-                unsigned long len,
-                const char __user *uargs)
+SYSCALL_DEFINE3(init_module, void __user *, umod,
+                unsigned long, len, const char __user *, uargs)
 {
         struct module *mod;
         int ret = 0;
@@ -2357,6 +2388,9 @@ sys_init_module(void __user *umod,
         blocking_notifier_call_chain(&module_notify_list,
                                      MODULE_STATE_LIVE, mod);
 
+        /* We need to finish all async code before the module init sequence is done */
+        async_synchronize_full();
+
         mutex_lock(&module_mutex);
         /* Drop initial reference. */
         module_put(mod);
@@ -2565,6 +2599,25 @@ unsigned long module_kallsyms_lookup_name(const char *name)
         preempt_enable();
         return ret;
 }
+
+int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
+                                             struct module *, unsigned long),
+                                   void *data)
+{
+        struct module *mod;
+        unsigned int i;
+        int ret;
+
+        list_for_each_entry(mod, &modules, list) {
+                for (i = 0; i < mod->num_symtab; i++) {
+                        ret = fn(data, mod->strtab + mod->symtab[i].st_name,
+                                 mod, mod->symtab[i].st_value);
+                        if (ret != 0)
+                                return ret;
+                }
+        }
+        return 0;
+}
 #endif /* CONFIG_KALLSYMS */
 
 static char *module_flags(struct module *mod, char *buf)
@@ -2700,29 +2753,31 @@ const struct exception_table_entry *search_module_extables(unsigned long addr)
 }
 
 /*
- * Is this a valid module address?
+ * is_module_address - is this address inside a module?
+ * @addr: the address to check.
+ *
+ * See is_module_text_address() if you simply want to see if the address
+ * is code (not data).
  */
-int is_module_address(unsigned long addr)
+bool is_module_address(unsigned long addr)
 {
-        struct module *mod;
+        bool ret;
 
         preempt_disable();
-
-        list_for_each_entry_rcu(mod, &modules, list) {
-                if (within_module_core(addr, mod)) {
-                        preempt_enable();
-                        return 1;
-                }
-        }
-
+        ret = __module_address(addr) != NULL;
         preempt_enable();
 
-        return 0;
+        return ret;
 }
 
-
-/* Is this a valid kernel address? */
-__notrace_funcgraph struct module *__module_text_address(unsigned long addr)
+/*
+ * __module_address - get the module which contains an address.
+ * @addr: the address.
+ *
+ * Must be called with preempt disabled or module mutex held so that
+ * module doesn't get freed during this.
+ */
+struct module *__module_address(unsigned long addr)
 {
         struct module *mod;
 
@@ -2730,22 +2785,51 @@ __notrace_funcgraph struct module *__module_text_address(unsigned long addr)
                 return NULL;
 
         list_for_each_entry_rcu(mod, &modules, list)
-                if (within(addr, mod->module_init, mod->init_text_size)
-                    || within(addr, mod->module_core, mod->core_text_size))
+                if (within_module_core(addr, mod)
+                    || within_module_init(addr, mod))
                         return mod;
         return NULL;
 }
+EXPORT_SYMBOL_GPL(__module_address);
 
-struct module *module_text_address(unsigned long addr)
+/*
+ * is_module_text_address - is this address inside module code?
+ * @addr: the address to check.
+ *
+ * See is_module_address() if you simply want to see if the address is
+ * anywhere in a module.  See kernel_text_address() for testing if an
+ * address corresponds to kernel or module code.
+ */
+bool is_module_text_address(unsigned long addr)
 {
-        struct module *mod;
+        bool ret;
 
         preempt_disable();
-        mod = __module_text_address(addr);
+        ret = __module_text_address(addr) != NULL;
         preempt_enable();
 
+        return ret;
+}
+
+/*
+ * __module_text_address - get the module whose code contains an address.
+ * @addr: the address.
+ *
+ * Must be called with preempt disabled or module mutex held so that
+ * module doesn't get freed during this.
+ */
+struct module *__module_text_address(unsigned long addr)
+{
+        struct module *mod = __module_address(addr);
+        if (mod) {
+                /* Make sure it's within the text section. */
+                if (!within(addr, mod->module_init, mod->init_text_size)
+                    && !within(addr, mod->module_core, mod->core_text_size))
+                        mod = NULL;
+        }
         return mod;
 }
+EXPORT_SYMBOL_GPL(__module_text_address);
 
 /* Don't grab lock, we're oopsing. */
 void print_modules(void)
@@ -2765,9 +2849,17 @@ void print_modules(void)
 }
 
 #ifdef CONFIG_MODVERSIONS
-/* Generate the signature for struct module here, too, for modversions. */
-void struct_module(struct module *mod) { return; }
-EXPORT_SYMBOL(struct_module);
+/* Generate the signature for all relevant module structures here.
+ * If these change, we don't want to try to parse the module. */
+void module_layout(struct module *mod,
+                   struct modversion_info *ver,
+                   struct kernel_param *kp,
+                   struct kernel_symbol *ks,
+                   struct marker *marker,
+                   struct tracepoint *tp)
+{
+}
+EXPORT_SYMBOL(module_layout);
 #endif
 
 #ifdef CONFIG_MARKERS