]> bbs.cooldavid.org Git - net-next-2.6.git/blobdiff - kernel/module.c
module: move find_module check to end
[net-next-2.6.git] / kernel / module.c
index 333fbcc969783a7cca1728f141c870be7b24e918..28450047852a7c3aa0ce73f90810f17ea41904fd 100644 (file)
 /* If this is set, the section belongs in the init part of the module */
 #define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
 
-/* List of modules, protected by module_mutex or preempt_disable
+/*
+ * Mutex protects:
+ * 1) List of modules (also safely readable with preempt_disable),
+ * 2) module_use links,
+ * 3) module_addr_min/module_addr_max.
  * (delete uses stop_machine/add uses RCU list operations). */
 DEFINE_MUTEX(module_mutex);
 EXPORT_SYMBOL_GPL(module_mutex);
@@ -90,7 +94,8 @@ static DECLARE_WAIT_QUEUE_HEAD(module_wq);
 
 static BLOCKING_NOTIFIER_HEAD(module_notify_list);
 
-/* Bounds of module allocation, for speeding __module_address */
+/* Bounds of module allocation, for speeding __module_address.
+ * Protected by module_mutex. */
 static unsigned long module_addr_min = -1UL, module_addr_max = 0;
 
 int register_module_notifier(struct notifier_block * nb)
@@ -329,7 +334,7 @@ static bool find_symbol_in_section(const struct symsearch *syms,
 }
 
 /* Find a symbol and return it, along with, (optional) crc and
- * (optional) module which owns it */
+ * (optional) module which owns it.  Needs preempt disabled or module_mutex. */
 const struct kernel_symbol *find_symbol(const char *name,
                                        struct module **owner,
                                        const unsigned long **crc,
@@ -403,7 +408,7 @@ static unsigned int find_pcpusec(Elf_Ehdr *hdr,
                                 Elf_Shdr *sechdrs,
                                 const char *secstrings)
 {
-       return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
+       return find_sec(hdr, sechdrs, secstrings, ".data..percpu");
 }
 
 static void percpu_modcopy(struct module *mod,
@@ -523,7 +528,8 @@ static void module_unload_init(struct module *mod)
 {
        int cpu;
 
-       INIT_LIST_HEAD(&mod->modules_which_use_me);
+       INIT_LIST_HEAD(&mod->source_list);
+       INIT_LIST_HEAD(&mod->target_list);
        for_each_possible_cpu(cpu) {
                per_cpu_ptr(mod->refptr, cpu)->incs = 0;
                per_cpu_ptr(mod->refptr, cpu)->decs = 0;
@@ -535,20 +541,13 @@ static void module_unload_init(struct module *mod)
        mod->waiter = current;
 }
 
-/* modules using other modules */
-struct module_use
-{
-       struct list_head list;
-       struct module *module_which_uses;
-};
-
 /* Does a already use b? */
 static int already_uses(struct module *a, struct module *b)
 {
        struct module_use *use;
 
-       list_for_each_entry(use, &b->modules_which_use_me, list) {
-               if (use->module_which_uses == a) {
+       list_for_each_entry(use, &b->source_list, source_list) {
+               if (use->source == a) {
                        DEBUGP("%s uses %s!\n", a->name, b->name);
                        return 1;
                }
@@ -557,11 +556,35 @@ static int already_uses(struct module *a, struct module *b)
        return 0;
 }
 
-/* Module a uses b */
-int use_module(struct module *a, struct module *b)
+/*
+ * Module a uses b
+ *  - we add 'a' as a "source", 'b' as a "target" of module use
+ *  - the module_use is added to the list of 'b' sources (so
+ *    'b' can walk the list to see who sourced them), and of 'a'
+ *    targets (so 'a' can see what modules it targets).
+ */
+static int add_module_usage(struct module *a, struct module *b)
 {
        struct module_use *use;
-       int no_warn, err;
+
+       DEBUGP("Allocating new usage for %s.\n", a->name);
+       use = kmalloc(sizeof(*use), GFP_ATOMIC);
+       if (!use) {
+               printk(KERN_WARNING "%s: out of memory loading\n", a->name);
+               return -ENOMEM;
+       }
+
+       use->source = a;
+       use->target = b;
+       list_add(&use->source_list, &b->source_list);
+       list_add(&use->target_list, &a->target_list);
+       return 0;
+}
+
+/* Module a uses b: caller needs module_mutex() */
+int use_module(struct module *a, struct module *b)
+{
+       int err;
 
        if (b == NULL || already_uses(a, b)) return 1;
 
@@ -578,17 +601,11 @@ int use_module(struct module *a, struct module *b)
        if (err)
                return 0;
 
-       DEBUGP("Allocating new usage for %s.\n", a->name);
-       use = kmalloc(sizeof(*use), GFP_ATOMIC);
-       if (!use) {
-               printk("%s: out of memory loading\n", a->name);
+       err = add_module_usage(a, b);
+       if (err) {
                module_put(b);
                return 0;
        }
-
-       use->module_which_uses = a;
-       list_add(&use->list, &b->modules_which_use_me);
-       no_warn = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name);
        return 1;
 }
 EXPORT_SYMBOL_GPL(use_module);
@@ -596,23 +613,18 @@ EXPORT_SYMBOL_GPL(use_module);
 /* Clear the unload stuff of the module. */
 static void module_unload_free(struct module *mod)
 {
-       struct module *i;
-
-       list_for_each_entry(i, &modules, list) {
-               struct module_use *use;
+       struct module_use *use, *tmp;
 
-               list_for_each_entry(use, &i->modules_which_use_me, list) {
-                       if (use->module_which_uses == mod) {
-                               DEBUGP("%s unusing %s\n", mod->name, i->name);
-                               module_put(i);
-                               list_del(&use->list);
-                               kfree(use);
-                               sysfs_remove_link(i->holders_dir, mod->name);
-                               /* There can be at most one match. */
-                               break;
-                       }
-               }
+       mutex_lock(&module_mutex);
+       list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
+               struct module *i = use->target;
+               DEBUGP("%s unusing %s\n", mod->name, i->name);
+               module_put(i);
+               list_del(&use->source_list);
+               list_del(&use->target_list);
+               kfree(use);
        }
+       mutex_unlock(&module_mutex);
 }
 
 #ifdef CONFIG_MODULE_FORCE_UNLOAD
@@ -735,7 +747,7 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
                goto out;
        }
 
-       if (!list_empty(&mod->modules_which_use_me)) {
+       if (!list_empty(&mod->source_list)) {
                /* Other modules depend on us: get rid of them first. */
                ret = -EWOULDBLOCK;
                goto out;
@@ -779,13 +791,14 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
        blocking_notifier_call_chain(&module_notify_list,
                                     MODULE_STATE_GOING, mod);
        async_synchronize_full();
-       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));
        ddebug_remove_module(mod->name);
-       free_module(mod);
 
- out:
+       free_module(mod);
+       return 0;
+out:
        mutex_unlock(&module_mutex);
        return ret;
 }
@@ -799,9 +812,9 @@ static inline void print_unload_info(struct seq_file *m, struct module *mod)
 
        /* Always include a trailing , so userspace can differentiate
            between this and the old multi-field proc format. */
-       list_for_each_entry(use, &mod->modules_which_use_me, list) {
+       list_for_each_entry(use, &mod->source_list, source_list) {
                printed_something = 1;
-               seq_printf(m, "%s,", use->module_which_uses->name);
+               seq_printf(m, "%s,", use->source->name);
        }
 
        if (mod->init != NULL && mod->exit == NULL) {
@@ -1001,6 +1014,8 @@ static inline int check_modstruct_version(Elf_Shdr *sechdrs,
 {
        const unsigned long *crc;
 
+       /* Since this should be found in kernel (which can't be removed),
+        * no locking is necessary. */
        if (!find_symbol(MODULE_SYMBOL_PREFIX "module_layout", NULL,
                         &crc, true, false))
                BUG();
@@ -1043,8 +1058,7 @@ static inline int same_magic(const char *amagic, const char *bmagic,
 }
 #endif /* CONFIG_MODVERSIONS */
 
-/* Resolve a symbol for this module.  I.e. if we find one, record usage.
-   Must be holding module_mutex. */
+/* Resolve a symbol for this module.  I.e. if we find one, record usage. */
 static const struct kernel_symbol *resolve_symbol(Elf_Shdr *sechdrs,
                                                  unsigned int versindex,
                                                  const char *name,
@@ -1054,6 +1068,7 @@ static const struct kernel_symbol *resolve_symbol(Elf_Shdr *sechdrs,
        const struct kernel_symbol *sym;
        const unsigned long *crc;
 
+       mutex_lock(&module_mutex);
        sym = find_symbol(name, &owner, &crc,
                          !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
        /* use_module can fail due to OOM,
@@ -1063,6 +1078,7 @@ static const struct kernel_symbol *resolve_symbol(Elf_Shdr *sechdrs,
                    || !use_module(mod, owner))
                        sym = NULL;
        }
+       mutex_unlock(&module_mutex);
        return sym;
 }
 
@@ -1295,7 +1311,34 @@ static inline void remove_notes_attrs(struct module *mod)
 #endif
 
 #ifdef CONFIG_SYSFS
-int module_add_modinfo_attrs(struct module *mod)
+static void add_usage_links(struct module *mod)
+{
+#ifdef CONFIG_MODULE_UNLOAD
+       struct module_use *use;
+       int nowarn;
+
+       mutex_lock(&module_mutex);
+       list_for_each_entry(use, &mod->target_list, target_list) {
+               nowarn = sysfs_create_link(use->target->holders_dir,
+                                          &mod->mkobj.kobj, mod->name);
+       }
+       mutex_unlock(&module_mutex);
+#endif
+}
+
+static void del_usage_links(struct module *mod)
+{
+#ifdef CONFIG_MODULE_UNLOAD
+       struct module_use *use;
+
+       mutex_lock(&module_mutex);
+       list_for_each_entry(use, &mod->target_list, target_list)
+               sysfs_remove_link(use->target->holders_dir, mod->name);
+       mutex_unlock(&module_mutex);
+#endif
+}
+
+static int module_add_modinfo_attrs(struct module *mod)
 {
        struct module_attribute *attr;
        struct module_attribute *temp_attr;
@@ -1321,7 +1364,7 @@ int module_add_modinfo_attrs(struct module *mod)
        return error;
 }
 
-void module_remove_modinfo_attrs(struct module *mod)
+static void module_remove_modinfo_attrs(struct module *mod)
 {
        struct module_attribute *attr;
        int i;
@@ -1337,7 +1380,7 @@ void module_remove_modinfo_attrs(struct module *mod)
        kfree(mod->modinfo_attrs);
 }
 
-int mod_sysfs_init(struct module *mod)
+static int mod_sysfs_init(struct module *mod)
 {
        int err;
        struct kobject *kobj;
@@ -1371,12 +1414,16 @@ out:
        return err;
 }
 
-int mod_sysfs_setup(struct module *mod,
+static int mod_sysfs_setup(struct module *mod,
                           struct kernel_param *kparam,
                           unsigned int num_params)
 {
        int err;
 
+       err = mod_sysfs_init(mod);
+       if (err)
+               goto out;
+
        mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);
        if (!mod->holders_dir) {
                err = -ENOMEM;
@@ -1391,6 +1438,8 @@ int mod_sysfs_setup(struct module *mod,
        if (err)
                goto out_unreg_param;
 
+       add_usage_links(mod);
+
        kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
        return 0;
 
@@ -1400,6 +1449,7 @@ out_unreg_holders:
        kobject_put(mod->holders_dir);
 out_unreg:
        kobject_put(&mod->mkobj.kobj);
+out:
        return err;
 }
 
@@ -1410,14 +1460,40 @@ static void mod_sysfs_fini(struct module *mod)
 
 #else /* CONFIG_SYSFS */
 
+static inline int mod_sysfs_init(struct module *mod)
+{
+       return 0;
+}
+
+static inline int mod_sysfs_setup(struct module *mod,
+                          struct kernel_param *kparam,
+                          unsigned int num_params)
+{
+       return 0;
+}
+
+static inline int module_add_modinfo_attrs(struct module *mod)
+{
+       return 0;
+}
+
+static inline void module_remove_modinfo_attrs(struct module *mod)
+{
+}
+
 static void mod_sysfs_fini(struct module *mod)
 {
 }
 
+static void del_usage_links(struct module *mod)
+{
+}
+
 #endif /* CONFIG_SYSFS */
 
 static void mod_kobject_remove(struct module *mod)
 {
+       del_usage_links(mod);
        module_remove_modinfo_attrs(mod);
        module_param_sysfs_remove(mod);
        kobject_put(mod->mkobj.drivers_dir);
@@ -1436,13 +1512,15 @@ static int __unlink_module(void *_mod)
        return 0;
 }
 
-/* Free a module, remove from lists, etc (must hold module_mutex). */
+/* Free a module, remove from lists, etc. */
 static void free_module(struct module *mod)
 {
        trace_module_free(mod);
 
        /* Delete from various lists */
+       mutex_lock(&module_mutex);
        stop_machine(__unlink_module, mod, NULL);
+       mutex_unlock(&module_mutex);
        remove_notes_attrs(mod);
        remove_sect_attrs(mod);
        mod_kobject_remove(mod);
@@ -1514,7 +1592,14 @@ 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 (find_symbol(s->name, &owner, NULL, true, false)) {
+                       const struct kernel_symbol *sym;
+
+                       /* Stopping preemption makes find_symbol safe. */
+                       preempt_disable();
+                       sym = find_symbol(s->name, &owner, NULL, true, false);
+                       preempt_enable();
+
+                       if (sym) {
                                printk(KERN_ERR
                                       "%s: exports duplicate symbol %s"
                                       " (owned by %s)\n",
@@ -1960,11 +2045,13 @@ static void *module_alloc_update_bounds(unsigned long size)
        void *ret = module_alloc(size);
 
        if (ret) {
+               mutex_lock(&module_mutex);
                /* Update module bounds. */
                if ((unsigned long)ret < module_addr_min)
                        module_addr_min = (unsigned long)ret;
                if ((unsigned long)ret + size > module_addr_max)
                        module_addr_max = (unsigned long)ret + size;
+               mutex_unlock(&module_mutex);
        }
        return ret;
 }
@@ -2014,6 +2101,7 @@ static noinline struct module *load_module(void __user *umod,
        long err = 0;
        void *ptr = NULL; /* Stops spurious gcc warning */
        unsigned long symoffs, stroffs, *strmap;
+       void __percpu *percpu;
 
        mm_segment_t old_fs;
 
@@ -2138,11 +2226,6 @@ static noinline struct module *load_module(void __user *umod,
                goto free_mod;
        }
 
-       if (find_module(mod->name)) {
-               err = -EEXIST;
-               goto free_mod;
-       }
-
        mod->state = MODULE_STATE_COMING;
 
        /* Allow arches to frob section contents and sizes.  */
@@ -2158,6 +2241,8 @@ static noinline struct module *load_module(void __user *umod,
                        goto free_mod;
                sechdrs[pcpuindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
        }
+       /* Keep this around for failure path. */
+       percpu = mod_percpu(mod);
 
        /* Determine total sizes, and put offsets in sh_entsize.  For now
           this is done generically; there doesn't appear to be any
@@ -2231,11 +2316,6 @@ static noinline struct module *load_module(void __user *umod,
        /* Now we've moved module, initialize linked lists, etc. */
        module_unload_init(mod);
 
-       /* add kobject, so we can reference it. */
-       err = mod_sysfs_init(mod);
-       if (err)
-               goto free_unload;
-
        /* Set up license info based on the info section */
        set_license(mod, get_modinfo(sechdrs, infoindex, "license"));
 
@@ -2423,7 +2503,15 @@ static noinline struct module *load_module(void __user *umod,
         * function to insert in a way safe to concurrent readers.
         * The mutex protects against concurrent writers.
         */
+       mutex_lock(&module_mutex);
+       if (find_module(mod->name)) {
+               err = -EEXIST;
+               /* This will also unlock the mutex */
+               goto already_exists;
+       }
+
        list_add_rcu(&mod->list, &modules);
+       mutex_unlock(&module_mutex);
 
        err = parse_args(mod->name, mod->args, mod->kp, mod->num_kp, NULL);
        if (err < 0)
@@ -2432,6 +2520,7 @@ static noinline struct module *load_module(void __user *umod,
        err = mod_sysfs_setup(mod, mod->kp, mod->num_kp);
        if (err < 0)
                goto unlink;
+
        add_sect_attrs(mod, hdr->e_shnum, secstrings, sechdrs);
        add_notes_attrs(mod, hdr->e_shnum, secstrings, sechdrs);
 
@@ -2444,15 +2533,15 @@ static noinline struct module *load_module(void __user *umod,
        return mod;
 
  unlink:
+       mutex_lock(&module_mutex);
        /* Unlink carefully: kallsyms could be walking list. */
        list_del_rcu(&mod->list);
+ already_exists:
+       mutex_unlock(&module_mutex);
        synchronize_sched();
        module_arch_cleanup(mod);
  cleanup:
        free_modinfo(mod);
-       kobject_del(&mod->mkobj.kobj);
-       kobject_put(&mod->mkobj.kobj);
- free_unload:
        module_unload_free(mod);
 #if defined(CONFIG_MODULE_UNLOAD)
        free_percpu(mod->refptr);
@@ -2463,7 +2552,7 @@ static noinline struct module *load_module(void __user *umod,
        module_free(mod, mod->module_core);
        /* mod will be freed with core. Don't access it beyond this line! */
  free_percpu:
-       percpu_modfree(mod);
+       free_percpu(percpu);
  free_mod:
        kfree(args);
        kfree(strmap);
@@ -2499,19 +2588,10 @@ SYSCALL_DEFINE3(init_module, void __user *, umod,
        if (!capable(CAP_SYS_MODULE) || modules_disabled)
                return -EPERM;
 
-       /* Only one module load at a time, please */
-       if (mutex_lock_interruptible(&module_mutex) != 0)
-               return -EINTR;
-
        /* Do all the hard work */
        mod = load_module(umod, len, uargs);
-       if (IS_ERR(mod)) {
-               mutex_unlock(&module_mutex);
+       if (IS_ERR(mod))
                return PTR_ERR(mod);
-       }
-
-       /* Drop lock so they can recurse */
-       mutex_unlock(&module_mutex);
 
        blocking_notifier_call_chain(&module_notify_list,
                        MODULE_STATE_COMING, mod);
@@ -2528,9 +2608,7 @@ SYSCALL_DEFINE3(init_module, void __user *, umod,
                module_put(mod);
                blocking_notifier_call_chain(&module_notify_list,
                                             MODULE_STATE_GOING, mod);
-               mutex_lock(&module_mutex);
                free_module(mod);
-               mutex_unlock(&module_mutex);
                wake_up(&module_wq);
                return ret;
        }