Merge branch 'modules' of git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux...

[pandora-kernel.git] / kernel / module.c

diff --git a/kernel/module.c b/kernel/module.c
index 1016b75..a8014bf 100644 (file)
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -59,8 +59,6 @@
 #define CREATE_TRACE_POINTS
 #include <trace/events/module.h>
 
-EXPORT_TRACEPOINT_SYMBOL(module_get);
-
 #if 0
 #define DEBUGP printk
 #else
@@ -79,6 +77,10 @@ EXPORT_TRACEPOINT_SYMBOL(module_get);
 DEFINE_MUTEX(module_mutex);
 EXPORT_SYMBOL_GPL(module_mutex);
 static LIST_HEAD(modules);
+#ifdef CONFIG_KGDB_KDB
+struct list_head *kdb_modules = &modules; /* kdb needs the list of modules */
+#endif /* CONFIG_KGDB_KDB */
+
 
 /* Block module loading/unloading? */
 int modules_disabled = 0;
@@ -515,6 +517,9 @@ MODINFO_ATTR(srcversion);
 static char last_unloaded_module[MODULE_NAME_LEN+1];
 
 #ifdef CONFIG_MODULE_UNLOAD
+
+EXPORT_TRACEPOINT_SYMBOL(module_get);
+
 /* Init the unload section of the module. */
 static void module_unload_init(struct module *mod)
 {
@@ -560,33 +565,26 @@ int use_module(struct module *a, struct module *b)
        struct module_use *use;
        int no_warn, err;
 
-       if (b == NULL || already_uses(a, b)) return 1;
-
-       /* If we're interrupted or time out, we fail. */
-       if (wait_event_interruptible_timeout(
-                   module_wq, (err = strong_try_module_get(b)) != -EBUSY,
-                   30 * HZ) <= 0) {
-               printk("%s: gave up waiting for init of module %s.\n",
-                      a->name, b->name);
+       if (b == NULL || already_uses(a, b))
                return 0;
-       }
 
-       /* If strong_try_module_get() returned a different error, we fail. */
+       /* If we're interrupted or time out, we fail. */
+       err = strong_try_module_get(b);
        if (err)
-               return 0;
+               return err;
 
        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);
                module_put(b);
-               return 0;
+               return -ENOMEM;
        }
 
        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;
+       return 0;
 }
 EXPORT_SYMBOL_GPL(use_module);
 
@@ -723,16 +721,8 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
                return -EFAULT;
        name[MODULE_NAME_LEN-1] = '\0';
 
-       /* Create stop_machine threads since free_module relies on
-        * a non-failing stop_machine call. */
-       ret = stop_machine_create();
-       if (ret)
-               return ret;
-
-       if (mutex_lock_interruptible(&module_mutex) != 0) {
-               ret = -EINTR;
-               goto out_stop;
-       }
+       if (mutex_lock_interruptible(&module_mutex) != 0)
+               return -EINTR;
 
        mod = find_module(name);
        if (!mod) {
@@ -792,8 +782,6 @@ SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
 
  out:
        mutex_unlock(&module_mutex);
-out_stop:
-       stop_machine_destroy();
        return ret;
 }
 
@@ -867,8 +855,7 @@ void module_put(struct module *module)
                smp_wmb(); /* see comment in module_refcount */
                __this_cpu_inc(module->refptr->decs);
 
-               trace_module_put(module, _RET_IP_,
-                                __this_cpu_read(module->refptr->decs));
+               trace_module_put(module, _RET_IP_);
                /* Maybe they're waiting for us to drop reference? */
                if (unlikely(!module_is_live(module)))
                        wake_up_process(module->waiter);
@@ -890,7 +877,7 @@ static inline void module_unload_free(struct module *mod)
 
 int use_module(struct module *a, struct module *b)
 {
-       return strong_try_module_get(b) == 0;
+       return strong_try_module_get(b);
 }
 EXPORT_SYMBOL_GPL(use_module);
 
@@ -1061,17 +1048,39 @@ static const struct kernel_symbol *resolve_symbol(Elf_Shdr *sechdrs,
        struct module *owner;
        const struct kernel_symbol *sym;
        const unsigned long *crc;
+       DEFINE_WAIT(wait);
+       int err;
+       long timeleft = 30 * HZ;
 
+again:
        sym = find_symbol(name, &owner, &crc,
                          !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
-       /* use_module can fail due to OOM,
-          or module initialization or unloading */
-       if (sym) {
-               if (!check_version(sechdrs, versindex, name, mod, crc, owner)
-                   || !use_module(mod, owner))
-                       sym = NULL;
+       if (!sym)
+               return NULL;
+
+       if (!check_version(sechdrs, versindex, name, mod, crc, owner))
+               return NULL;
+
+       prepare_to_wait(&module_wq, &wait, TASK_INTERRUPTIBLE);
+       err = use_module(mod, owner);
+       if (likely(!err) || err != -EBUSY || signal_pending(current)) {
+               finish_wait(&module_wq, &wait);
+               return err ? NULL : sym;
        }
-       return sym;
+
+       /* Module is still loading.  Drop lock and wait. */
+       mutex_unlock(&module_mutex);
+       timeleft = schedule_timeout(timeleft);
+       mutex_lock(&module_mutex);
+       finish_wait(&module_wq, &wait);
+
+       /* Module might be gone entirely, or replaced.  Re-lookup. */
+       if (timeleft)
+               goto again;
+
+       printk(KERN_WARNING "%s: gave up waiting for init of module %s.\n",
+              mod->name, owner->name);
+       return NULL;
 }
 
 /*
@@ -1192,7 +1201,7 @@ struct module_notes_attrs {
        struct bin_attribute attrs[0];
 };
 
-static ssize_t module_notes_read(struct kobject *kobj,
+static ssize_t module_notes_read(struct file *filp, struct kobject *kobj,
                                 struct bin_attribute *bin_attr,
                                 char *buf, loff_t pos, size_t count)
 {