/*

     Copyright (C) 2002 Richard Henderson

     Copyright (C) 2001 Rusty Russell, 2002, 2010 Rusty Russell IBM.

  
      This program is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation; either version 2 of the License, or
      (at your option) any later version.
  
      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU General Public License for more details.
  
      You should have received a copy of the GNU General Public License
      along with this program; if not, write to the Free Software
      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */

  #include <linux/export.h>

  #include <linux/moduleloader.h>

  #include <linux/ftrace_event.h>

  #include <linux/init.h>

  #include <linux/kallsyms.h>

  #include <linux/file.h>

  #include <linux/fs.h>

  #include <linux/sysfs.h>

  #include <linux/kernel.h>

  #include <linux/slab.h>
  #include <linux/vmalloc.h>
  #include <linux/elf.h>

  #include <linux/proc_fs.h>

  #include <linux/security.h>

  #include <linux/seq_file.h>
  #include <linux/syscalls.h>
  #include <linux/fcntl.h>
  #include <linux/rcupdate.h>

  #include <linux/capability.h>

  #include <linux/cpu.h>
  #include <linux/moduleparam.h>
  #include <linux/errno.h>
  #include <linux/err.h>
  #include <linux/vermagic.h>
  #include <linux/notifier.h>

  #include <linux/sched.h>

  #include <linux/stop_machine.h>
  #include <linux/device.h>

  #include <linux/string.h>

  #include <linux/mutex.h>

  #include <linux/rculist.h>

  #include <asm/uaccess.h>

  #include <asm/cacheflush.h>

  #include <asm/mmu_context.h>

  #include <linux/license.h>

  #include <asm/sections.h>

  #include <linux/tracepoint.h>

  #include <linux/ftrace.h>

  #include <linux/async.h>

  #include <linux/percpu.h>

  #include <linux/kmemleak.h>

  #include <linux/jump_label.h>

  #include <linux/pfn.h>

  #include <linux/bsearch.h>

  #include <linux/fips.h>

  #include <uapi/linux/module.h>

  #include "module-internal.h"

  #define CREATE_TRACE_POINTS
  #include <trace/events/module.h>

  #ifndef ARCH_SHF_SMALL
  #define ARCH_SHF_SMALL 0
  #endif

  /*
   * Modules' sections will be aligned on page boundaries
   * to ensure complete separation of code and data, but
   * only when CONFIG_DEBUG_SET_MODULE_RONX=y
   */
  #ifdef CONFIG_DEBUG_SET_MODULE_RONX
  # define debug_align(X) ALIGN(X, PAGE_SIZE)
  #else
  # define debug_align(X) (X)
  #endif
  
  /*
   * Given BASE and SIZE this macro calculates the number of pages the
   * memory regions occupies
   */
  #define MOD_NUMBER_OF_PAGES(BASE, SIZE) (((SIZE) > 0) ?		\
  		(PFN_DOWN((unsigned long)(BASE) + (SIZE) - 1) -	\
  			 PFN_DOWN((unsigned long)BASE) + 1)	\
  		: (0UL))

  /* If this is set, the section belongs in the init part of the module */
  #define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))

  /*
   * 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);

  static LIST_HEAD(modules);

  #ifdef CONFIG_KGDB_KDB
  struct list_head *kdb_modules = &modules; /* kdb needs the list of modules */
  #endif /* CONFIG_KGDB_KDB */

  #ifdef CONFIG_MODULE_SIG
  #ifdef CONFIG_MODULE_SIG_FORCE
  static bool sig_enforce = true;
  #else
  static bool sig_enforce = false;
  
  static int param_set_bool_enable_only(const char *val,
  				      const struct kernel_param *kp)
  {
  	int err;
  	bool test;
  	struct kernel_param dummy_kp = *kp;
  
  	dummy_kp.arg = &test;
  
  	err = param_set_bool(val, &dummy_kp);
  	if (err)
  		return err;
  
  	/* Don't let them unset it once it's set! */
  	if (!test && sig_enforce)
  		return -EROFS;
  
  	if (test)
  		sig_enforce = true;
  	return 0;
  }
  
  static const struct kernel_param_ops param_ops_bool_enable_only = {
  	.set = param_set_bool_enable_only,
  	.get = param_get_bool,
  };
  #define param_check_bool_enable_only param_check_bool
  
  module_param(sig_enforce, bool_enable_only, 0644);
  #endif /* !CONFIG_MODULE_SIG_FORCE */
  #endif /* CONFIG_MODULE_SIG */

  /* Block module loading/unloading? */
  int modules_disabled = 0;

  core_param(nomodule, modules_disabled, bint, 0);

  /* Waiting for a module to finish initializing? */
  static DECLARE_WAIT_QUEUE_HEAD(module_wq);

  static BLOCKING_NOTIFIER_HEAD(module_notify_list);

  /* 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)
  {

  	return blocking_notifier_chain_register(&module_notify_list, nb);

  }
  EXPORT_SYMBOL(register_module_notifier);
  
  int unregister_module_notifier(struct notifier_block * nb)
  {

  	return blocking_notifier_chain_unregister(&module_notify_list, nb);

  }
  EXPORT_SYMBOL(unregister_module_notifier);

  struct load_info {
  	Elf_Ehdr *hdr;
  	unsigned long len;
  	Elf_Shdr *sechdrs;

  	char *secstrings, *strtab;

  	unsigned long symoffs, stroffs;

  	struct _ddebug *debug;
  	unsigned int num_debug;

  	bool sig_ok;

  	struct {
  		unsigned int sym, str, mod, vers, info, pcpu;
  	} index;
  };

  /* We require a truly strong try_module_get(): 0 means failure due to
     ongoing or failed initialization etc. */

  static inline int strong_try_module_get(struct module *mod)
  {

  	BUG_ON(mod && mod->state == MODULE_STATE_UNFORMED);

  	if (mod && mod->state == MODULE_STATE_COMING)

  		return -EBUSY;
  	if (try_module_get(mod))

  		return 0;

  	else
  		return -ENOENT;

  }

  static inline void add_taint_module(struct module *mod, unsigned flag,
  				    enum lockdep_ok lockdep_ok)

  {

  	add_taint(flag, lockdep_ok);

  	mod->taints |= (1U << flag);

  }

  /*
   * A thread that wants to hold a reference to a module only while it
   * is running can call this to safely exit.  nfsd and lockd use this.

   */
  void __module_put_and_exit(struct module *mod, long code)
  {
  	module_put(mod);
  	do_exit(code);
  }
  EXPORT_SYMBOL(__module_put_and_exit);

  /* Find a module section: 0 means not found. */

  static unsigned int find_sec(const struct load_info *info, const char *name)

  {
  	unsigned int i;

  	for (i = 1; i < info->hdr->e_shnum; i++) {
  		Elf_Shdr *shdr = &info->sechdrs[i];

  		/* Alloc bit cleared means "ignore it." */

  		if ((shdr->sh_flags & SHF_ALLOC)
  		    && strcmp(info->secstrings + shdr->sh_name, name) == 0)

  			return i;

  	}

  	return 0;
  }

  /* Find a module section, or NULL. */

  static void *section_addr(const struct load_info *info, const char *name)

  {
  	/* Section 0 has sh_addr 0. */

  	return (void *)info->sechdrs[find_sec(info, name)].sh_addr;

  }
  
  /* Find a module section, or NULL.  Fill in number of "objects" in section. */

  static void *section_objs(const struct load_info *info,

  			  const char *name,
  			  size_t object_size,
  			  unsigned int *num)
  {

  	unsigned int sec = find_sec(info, name);

  
  	/* Section 0 has sh_addr 0 and sh_size 0. */

  	*num = info->sechdrs[sec].sh_size / object_size;
  	return (void *)info->sechdrs[sec].sh_addr;

  }

  /* Provided by the linker */
  extern const struct kernel_symbol __start___ksymtab[];
  extern const struct kernel_symbol __stop___ksymtab[];
  extern const struct kernel_symbol __start___ksymtab_gpl[];
  extern const struct kernel_symbol __stop___ksymtab_gpl[];

  extern const struct kernel_symbol __start___ksymtab_gpl_future[];
  extern const struct kernel_symbol __stop___ksymtab_gpl_future[];

  extern const unsigned long __start___kcrctab[];
  extern const unsigned long __start___kcrctab_gpl[];

  extern const unsigned long __start___kcrctab_gpl_future[];

  #ifdef CONFIG_UNUSED_SYMBOLS
  extern const struct kernel_symbol __start___ksymtab_unused[];
  extern const struct kernel_symbol __stop___ksymtab_unused[];
  extern const struct kernel_symbol __start___ksymtab_unused_gpl[];
  extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];

  extern const unsigned long __start___kcrctab_unused[];
  extern const unsigned long __start___kcrctab_unused_gpl[];

  #endif

  
  #ifndef CONFIG_MODVERSIONS
  #define symversion(base, idx) NULL
  #else

  #define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)

  #endif

  static bool each_symbol_in_section(const struct symsearch *arr,
  				   unsigned int arrsize,
  				   struct module *owner,
  				   bool (*fn)(const struct symsearch *syms,
  					      struct module *owner,

  					      void *data),

  				   void *data)

  {

  	unsigned int j;

  	for (j = 0; j < arrsize; j++) {

  		if (fn(&arr[j], owner, data))
  			return true;

  	}

  
  	return false;

  }

  /* Returns true as soon as fn returns true, otherwise false. */

  bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
  				    struct module *owner,
  				    void *data),
  			 void *data)

  {
  	struct module *mod;

  	static const struct symsearch arr[] = {

  		{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,

  		  NOT_GPL_ONLY, false },

  		{ __start___ksymtab_gpl, __stop___ksymtab_gpl,

  		  __start___kcrctab_gpl,
  		  GPL_ONLY, false },

  		{ __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,

  		  __start___kcrctab_gpl_future,
  		  WILL_BE_GPL_ONLY, false },

  #ifdef CONFIG_UNUSED_SYMBOLS

  		{ __start___ksymtab_unused, __stop___ksymtab_unused,

  		  __start___kcrctab_unused,
  		  NOT_GPL_ONLY, true },

  		{ __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,

  		  __start___kcrctab_unused_gpl,
  		  GPL_ONLY, true },

  #endif

  	};

  	if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
  		return true;

  	list_for_each_entry_rcu(mod, &modules, list) {

  		struct symsearch arr[] = {
  			{ mod->syms, mod->syms + mod->num_syms, mod->crcs,

  			  NOT_GPL_ONLY, false },

  			{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,

  			  mod->gpl_crcs,
  			  GPL_ONLY, false },

  			{ mod->gpl_future_syms,
  			  mod->gpl_future_syms + mod->num_gpl_future_syms,

  			  mod->gpl_future_crcs,
  			  WILL_BE_GPL_ONLY, false },

  #ifdef CONFIG_UNUSED_SYMBOLS

  			{ mod->unused_syms,
  			  mod->unused_syms + mod->num_unused_syms,

  			  mod->unused_crcs,
  			  NOT_GPL_ONLY, true },

  			{ mod->unused_gpl_syms,
  			  mod->unused_gpl_syms + mod->num_unused_gpl_syms,

  			  mod->unused_gpl_crcs,
  			  GPL_ONLY, true },

  #endif

  		};

  		if (mod->state == MODULE_STATE_UNFORMED)
  			continue;

  		if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
  			return true;
  	}
  	return false;
  }

  EXPORT_SYMBOL_GPL(each_symbol_section);

  
  struct find_symbol_arg {
  	/* Input */
  	const char *name;
  	bool gplok;
  	bool warn;
  
  	/* Output */
  	struct module *owner;
  	const unsigned long *crc;

  	const struct kernel_symbol *sym;

  };

  static bool check_symbol(const struct symsearch *syms,
  				 struct module *owner,
  				 unsigned int symnum, void *data)

  {
  	struct find_symbol_arg *fsa = data;

  	if (!fsa->gplok) {
  		if (syms->licence == GPL_ONLY)
  			return false;
  		if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) {
  			printk(KERN_WARNING "Symbol %s is being used "
  			       "by a non-GPL module, which will not "
  			       "be allowed in the future
  ", fsa->name);

  		}

  	}

  #ifdef CONFIG_UNUSED_SYMBOLS

  	if (syms->unused && fsa->warn) {
  		printk(KERN_WARNING "Symbol %s is marked as UNUSED, "
  		       "however this module is using it.
  ", fsa->name);
  		printk(KERN_WARNING
  		       "This symbol will go away in the future.
  ");
  		printk(KERN_WARNING
  		       "Please evalute if this is the right api to use and if "
  		       "it really is, submit a report the linux kernel "
  		       "mailinglist together with submitting your code for "
  		       "inclusion.
  ");
  	}

  #endif

  
  	fsa->owner = owner;
  	fsa->crc = symversion(syms->crcs, symnum);

  	fsa->sym = &syms->start[symnum];

  	return true;
  }

  static int cmp_name(const void *va, const void *vb)
  {
  	const char *a;
  	const struct kernel_symbol *b;
  	a = va; b = vb;
  	return strcmp(a, b->name);
  }

  static bool find_symbol_in_section(const struct symsearch *syms,
  				   struct module *owner,
  				   void *data)
  {
  	struct find_symbol_arg *fsa = data;

  	struct kernel_symbol *sym;
  
  	sym = bsearch(fsa->name, syms->start, syms->stop - syms->start,
  			sizeof(struct kernel_symbol), cmp_name);
  
  	if (sym != NULL && check_symbol(syms, owner, sym - syms->start, data))
  		return true;

  	return false;
  }

  /* Find a symbol and return it, along with, (optional) crc and

   * (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,
  					bool gplok,
  					bool warn)

  {
  	struct find_symbol_arg fsa;
  
  	fsa.name = name;
  	fsa.gplok = gplok;
  	fsa.warn = warn;

  	if (each_symbol_section(find_symbol_in_section, &fsa)) {

  		if (owner)
  			*owner = fsa.owner;
  		if (crc)
  			*crc = fsa.crc;

  		return fsa.sym;

  	}

  	pr_debug("Failed to find symbol %s
  ", name);

  	return NULL;

  }

  EXPORT_SYMBOL_GPL(find_symbol);

  /* Search for module by name: must hold module_mutex. */

  static struct module *find_module_all(const char *name,
  				      bool even_unformed)

  {
  	struct module *mod;
  
  	list_for_each_entry(mod, &modules, list) {

  		if (!even_unformed && mod->state == MODULE_STATE_UNFORMED)
  			continue;

  		if (strcmp(mod->name, name) == 0)
  			return mod;
  	}
  	return NULL;
  }

  
  struct module *find_module(const char *name)
  {
  	return find_module_all(name, false);
  }

  EXPORT_SYMBOL_GPL(find_module);

  
  #ifdef CONFIG_SMP

  static inline void __percpu *mod_percpu(struct module *mod)

  {

  	return mod->percpu;
  }

  static int percpu_modalloc(struct module *mod,
  			   unsigned long size, unsigned long align)
  {

  	if (align > PAGE_SIZE) {
  		printk(KERN_WARNING "%s: per-cpu alignment %li > %li
  ",

  		       mod->name, align, PAGE_SIZE);

  		align = PAGE_SIZE;
  	}

  	mod->percpu = __alloc_reserved_percpu(size, align);
  	if (!mod->percpu) {

  		printk(KERN_WARNING

  		       "%s: Could not allocate %lu bytes percpu data
  ",
  		       mod->name, size);

  		return -ENOMEM;
  	}
  	mod->percpu_size = size;
  	return 0;

  }

  static void percpu_modfree(struct module *mod)

  {

  	free_percpu(mod->percpu);

  }

  static unsigned int find_pcpusec(struct load_info *info)

  {

  	return find_sec(info, ".data..percpu");

  }

  static void percpu_modcopy(struct module *mod,
  			   const void *from, unsigned long size)

  {
  	int cpu;
  
  	for_each_possible_cpu(cpu)

  		memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);

  }

  /**
   * is_module_percpu_address - test whether address is from module static percpu
   * @addr: address to test
   *
   * Test whether @addr belongs to module static percpu area.
   *
   * RETURNS:
   * %true if @addr is from module static percpu area
   */
  bool is_module_percpu_address(unsigned long addr)
  {
  	struct module *mod;
  	unsigned int cpu;
  
  	preempt_disable();
  
  	list_for_each_entry_rcu(mod, &modules, list) {

  		if (mod->state == MODULE_STATE_UNFORMED)
  			continue;

  		if (!mod->percpu_size)
  			continue;
  		for_each_possible_cpu(cpu) {
  			void *start = per_cpu_ptr(mod->percpu, cpu);
  
  			if ((void *)addr >= start &&
  			    (void *)addr < start + mod->percpu_size) {
  				preempt_enable();
  				return true;
  			}
  		}
  	}
  
  	preempt_enable();
  	return false;

  }

  #else /* ... !CONFIG_SMP */

  static inline void __percpu *mod_percpu(struct module *mod)

  {
  	return NULL;
  }

  static inline int percpu_modalloc(struct module *mod,
  				  unsigned long size, unsigned long align)
  {
  	return -ENOMEM;
  }
  static inline void percpu_modfree(struct module *mod)

  {

  }

  static unsigned int find_pcpusec(struct load_info *info)

  {
  	return 0;
  }

  static inline void percpu_modcopy(struct module *mod,
  				  const void *from, unsigned long size)

  {
  	/* pcpusec should be 0, and size of that section should be 0. */
  	BUG_ON(size != 0);
  }

  bool is_module_percpu_address(unsigned long addr)
  {
  	return false;
  }

  #endif /* CONFIG_SMP */

  #define MODINFO_ATTR(field)	\
  static void setup_modinfo_##field(struct module *mod, const char *s)  \
  {                                                                     \
  	mod->field = kstrdup(s, GFP_KERNEL);                          \
  }                                                                     \
  static ssize_t show_modinfo_##field(struct module_attribute *mattr,   \

  			struct module_kobject *mk, char *buffer)      \

  {                                                                     \

  	return sprintf(buffer, "%s
  ", mk->mod->field);               \

  }                                                                     \
  static int modinfo_##field##_exists(struct module *mod)               \
  {                                                                     \
  	return mod->field != NULL;                                    \
  }                                                                     \
  static void free_modinfo_##field(struct module *mod)                  \
  {                                                                     \

  	kfree(mod->field);                                            \
  	mod->field = NULL;                                            \

  }                                                                     \
  static struct module_attribute modinfo_##field = {                    \

  	.attr = { .name = __stringify(field), .mode = 0444 },         \

  	.show = show_modinfo_##field,                                 \
  	.setup = setup_modinfo_##field,                               \
  	.test = modinfo_##field##_exists,                             \
  	.free = free_modinfo_##field,                                 \
  };
  
  MODINFO_ATTR(version);
  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 int module_unload_init(struct module *mod)

  {

  	mod->refptr = alloc_percpu(struct module_ref);
  	if (!mod->refptr)
  		return -ENOMEM;

  	INIT_LIST_HEAD(&mod->source_list);
  	INIT_LIST_HEAD(&mod->target_list);

  	/* Hold reference count during initialization. */

  	__this_cpu_write(mod->refptr->incs, 1);

  	/* Backwards compatibility macros put refcount during init. */
  	mod->waiter = current;

  
  	return 0;

  }

  /* 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->source_list, source_list) {
  		if (use->source == a) {

  			pr_debug("%s uses %s!
  ", a->name, b->name);

  			return 1;
  		}
  	}

  	pr_debug("%s does not use %s!
  ", a->name, b->name);

  	return 0;
  }

  /*
   * 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;

  	pr_debug("Allocating new usage for %s.
  ", a->name);

  	use = kmalloc(sizeof(*use), GFP_ATOMIC);
  	if (!use) {
  		printk(KERN_WARNING "%s: out of memory loading
  ", 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 ref_module(struct module *a, struct module *b)

  {

  	int err;

  	if (b == NULL || already_uses(a, b))

  		return 0;

  	/* If module isn't available, we fail. */
  	err = strong_try_module_get(b);

  	if (err)

  		return err;

  	err = add_module_usage(a, b);
  	if (err) {

  		module_put(b);

  		return err;

  	}

  	return 0;

  }

  EXPORT_SYMBOL_GPL(ref_module);

  
  /* Clear the unload stuff of the module. */
  static void module_unload_free(struct module *mod)
  {

  	struct module_use *use, *tmp;

  	mutex_lock(&module_mutex);

  	list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
  		struct module *i = use->target;

  		pr_debug("%s unusing %s
  ", mod->name, i->name);

  		module_put(i);
  		list_del(&use->source_list);
  		list_del(&use->target_list);
  		kfree(use);

  	}

  	mutex_unlock(&module_mutex);

  
  	free_percpu(mod->refptr);

  }
  
  #ifdef CONFIG_MODULE_FORCE_UNLOAD

  static inline int try_force_unload(unsigned int flags)

  {
  	int ret = (flags & O_TRUNC);
  	if (ret)

  		add_taint(TAINT_FORCED_RMMOD, LOCKDEP_NOW_UNRELIABLE);

  	return ret;
  }
  #else

  static inline int try_force_unload(unsigned int flags)

  {
  	return 0;
  }
  #endif /* CONFIG_MODULE_FORCE_UNLOAD */
  
  struct stopref
  {
  	struct module *mod;
  	int flags;
  	int *forced;
  };
  
  /* Whole machine is stopped with interrupts off when this runs. */
  static int __try_stop_module(void *_sref)
  {
  	struct stopref *sref = _sref;

  	/* If it's not unused, quit unless we're forcing. */
  	if (module_refcount(sref->mod) != 0) {

  		if (!(*sref->forced = try_force_unload(sref->flags)))

  			return -EWOULDBLOCK;
  	}
  
  	/* Mark it as dying. */
  	sref->mod->state = MODULE_STATE_GOING;
  	return 0;
  }
  
  static int try_stop_module(struct module *mod, int flags, int *forced)
  {

  	if (flags & O_NONBLOCK) {
  		struct stopref sref = { mod, flags, forced };

  		return stop_machine(__try_stop_module, &sref, NULL);

  	} else {
  		/* We don't need to stop the machine for this. */
  		mod->state = MODULE_STATE_GOING;
  		synchronize_sched();
  		return 0;
  	}

  }

  unsigned long module_refcount(struct module *mod)

  {

  	unsigned long incs = 0, decs = 0;

  	int cpu;

  	for_each_possible_cpu(cpu)

  		decs += per_cpu_ptr(mod->refptr, cpu)->decs;
  	/*
  	 * ensure the incs are added up after the decs.
  	 * module_put ensures incs are visible before decs with smp_wmb.
  	 *
  	 * This 2-count scheme avoids the situation where the refcount
  	 * for CPU0 is read, then CPU0 increments the module refcount,
  	 * then CPU1 drops that refcount, then the refcount for CPU1 is
  	 * read. We would record a decrement but not its corresponding
  	 * increment so we would see a low count (disaster).
  	 *
  	 * Rare situation? But module_refcount can be preempted, and we
  	 * might be tallying up 4096+ CPUs. So it is not impossible.
  	 */
  	smp_rmb();
  	for_each_possible_cpu(cpu)
  		incs += per_cpu_ptr(mod->refptr, cpu)->incs;
  	return incs - decs;

  }
  EXPORT_SYMBOL(module_refcount);
  
  /* This exists whether we can unload or not */
  static void free_module(struct module *mod);
  
  static void wait_for_zero_refcount(struct module *mod)
  {

  	/* Since we might sleep for some time, release the mutex first */

  	mutex_unlock(&module_mutex);

  	for (;;) {

  		pr_debug("Looking at refcount...
  ");

  		set_current_state(TASK_UNINTERRUPTIBLE);
  		if (module_refcount(mod) == 0)
  			break;
  		schedule();
  	}
  	current->state = TASK_RUNNING;

  	mutex_lock(&module_mutex);

  }

  SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
  		unsigned int, flags)

  {
  	struct module *mod;

  	char name[MODULE_NAME_LEN];

  	int ret, forced = 0;

  	if (!capable(CAP_SYS_MODULE) || modules_disabled)

  		return -EPERM;
  
  	if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
  		return -EFAULT;
  	name[MODULE_NAME_LEN-1] = '\0';

  	if (mutex_lock_interruptible(&module_mutex) != 0)
  		return -EINTR;

  
  	mod = find_module(name);
  	if (!mod) {
  		ret = -ENOENT;
  		goto out;
  	}

  	if (!list_empty(&mod->source_list)) {

  		/* Other modules depend on us: get rid of them first. */
  		ret = -EWOULDBLOCK;
  		goto out;
  	}
  
  	/* Doing init or already dying? */
  	if (mod->state != MODULE_STATE_LIVE) {
  		/* FIXME: if (force), slam module count and wake up
                     waiter --RR */

  		pr_debug("%s already dying
  ", mod->name);

  		ret = -EBUSY;
  		goto out;
  	}
  
  	/* If it has an init func, it must have an exit func to unload */

  	if (mod->init && !mod->exit) {

  		forced = try_force_unload(flags);

  		if (!forced) {
  			/* This module can't be removed */
  			ret = -EBUSY;
  			goto out;
  		}
  	}
  
  	/* Set this up before setting mod->state */
  	mod->waiter = current;
  
  	/* Stop the machine so refcounts can't move and disable module. */
  	ret = try_stop_module(mod, flags, &forced);
  	if (ret != 0)
  		goto out;
  
  	/* Never wait if forced. */
  	if (!forced && module_refcount(mod) != 0)
  		wait_for_zero_refcount(mod);

  	mutex_unlock(&module_mutex);

  	/* Final destruction now no one is using it. */

  	if (mod->exit != NULL)

  		mod->exit();

  	blocking_notifier_call_chain(&module_notify_list,
  				     MODULE_STATE_GOING, mod);

  	async_synchronize_full();

  	/* Store the name of the last unloaded module for diagnostic purposes */

  	strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));

  	free_module(mod);
  	return 0;
  out:

  	mutex_unlock(&module_mutex);

  	return ret;
  }

  static inline void print_unload_info(struct seq_file *m, struct module *mod)

  {
  	struct module_use *use;
  	int printed_something = 0;

  	seq_printf(m, " %lu ", module_refcount(mod));

  
  	/* Always include a trailing , so userspace can differentiate
             between this and the old multi-field proc format. */

  	list_for_each_entry(use, &mod->source_list, source_list) {

  		printed_something = 1;

  		seq_printf(m, "%s,", use->source->name);

  	}

  	if (mod->init != NULL && mod->exit == NULL) {
  		printed_something = 1;
  		seq_printf(m, "[permanent],");
  	}
  
  	if (!printed_something)
  		seq_printf(m, "-");
  }
  
  void __symbol_put(const char *symbol)
  {
  	struct module *owner;

  	preempt_disable();

  	if (!find_symbol(symbol, &owner, NULL, true, false))

  		BUG();
  	module_put(owner);

  	preempt_enable();

  }
  EXPORT_SYMBOL(__symbol_put);

  /* Note this assumes addr is a function, which it currently always is. */

  void symbol_put_addr(void *addr)
  {

  	struct module *modaddr;

  	unsigned long a = (unsigned long)dereference_function_descriptor(addr);

  	if (core_kernel_text(a))

  		return;

  	/* 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(a);

  	BUG_ON(!modaddr);

  	module_put(modaddr);

  }
  EXPORT_SYMBOL_GPL(symbol_put_addr);
  
  static ssize_t show_refcnt(struct module_attribute *mattr,

  			   struct module_kobject *mk, char *buffer)

  {

  	return sprintf(buffer, "%lu
  ", module_refcount(mk->mod));

  }

  static struct module_attribute modinfo_refcnt =
  	__ATTR(refcnt, 0444, show_refcnt, NULL);

  void __module_get(struct module *module)
  {
  	if (module) {
  		preempt_disable();
  		__this_cpu_inc(module->refptr->incs);
  		trace_module_get(module, _RET_IP_);
  		preempt_enable();
  	}
  }
  EXPORT_SYMBOL(__module_get);
  
  bool try_module_get(struct module *module)
  {
  	bool ret = true;
  
  	if (module) {
  		preempt_disable();
  
  		if (likely(module_is_live(module))) {
  			__this_cpu_inc(module->refptr->incs);
  			trace_module_get(module, _RET_IP_);
  		} else
  			ret = false;
  
  		preempt_enable();
  	}
  	return ret;
  }
  EXPORT_SYMBOL(try_module_get);

  void module_put(struct module *module)
  {
  	if (module) {

  		preempt_disable();

  		smp_wmb(); /* see comment in module_refcount */
  		__this_cpu_inc(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);

  		preempt_enable();

  	}
  }
  EXPORT_SYMBOL(module_put);

  #else /* !CONFIG_MODULE_UNLOAD */

  static inline void print_unload_info(struct seq_file *m, struct module *mod)

  {
  	/* We don't know the usage count, or what modules are using. */
  	seq_printf(m, " - -");
  }
  
  static inline void module_unload_free(struct module *mod)
  {
  }

  int ref_module(struct module *a, struct module *b)

  {

  	return strong_try_module_get(b);

  }

  EXPORT_SYMBOL_GPL(ref_module);

  static inline int module_unload_init(struct module *mod)

  {

  	return 0;

  }
  #endif /* CONFIG_MODULE_UNLOAD */

  static size_t module_flags_taint(struct module *mod, char *buf)
  {
  	size_t l = 0;
  
  	if (mod->taints & (1 << TAINT_PROPRIETARY_MODULE))
  		buf[l++] = 'P';
  	if (mod->taints & (1 << TAINT_OOT_MODULE))
  		buf[l++] = 'O';
  	if (mod->taints & (1 << TAINT_FORCED_MODULE))
  		buf[l++] = 'F';
  	if (mod->taints & (1 << TAINT_CRAP))
  		buf[l++] = 'C';
  	/*
  	 * TAINT_FORCED_RMMOD: could be added.
  	 * TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
  	 * apply to modules.
  	 */
  	return l;
  }

  static ssize_t show_initstate(struct module_attribute *mattr,

  			      struct module_kobject *mk, char *buffer)

  {
  	const char *state = "unknown";

  	switch (mk->mod->state) {

  	case MODULE_STATE_LIVE:
  		state = "live";
  		break;
  	case MODULE_STATE_COMING:
  		state = "coming";
  		break;
  	case MODULE_STATE_GOING:
  		state = "going";
  		break;

  	default:
  		BUG();

  	}
  	return sprintf(buffer, "%s
  ", state);
  }

  static struct module_attribute modinfo_initstate =
  	__ATTR(initstate, 0444, show_initstate, NULL);

  static ssize_t store_uevent(struct module_attribute *mattr,
  			    struct module_kobject *mk,
  			    const char *buffer, size_t count)
  {
  	enum kobject_action action;
  
  	if (kobject_action_type(buffer, count, &action) == 0)
  		kobject_uevent(&mk->kobj, action);
  	return count;
  }

  struct module_attribute module_uevent =
  	__ATTR(uevent, 0200, NULL, store_uevent);
  
  static ssize_t show_coresize(struct module_attribute *mattr,
  			     struct module_kobject *mk, char *buffer)
  {
  	return sprintf(buffer, "%u
  ", mk->mod->core_size);
  }
  
  static struct module_attribute modinfo_coresize =
  	__ATTR(coresize, 0444, show_coresize, NULL);
  
  static ssize_t show_initsize(struct module_attribute *mattr,
  			     struct module_kobject *mk, char *buffer)
  {
  	return sprintf(buffer, "%u
  ", mk->mod->init_size);
  }
  
  static struct module_attribute modinfo_initsize =
  	__ATTR(initsize, 0444, show_initsize, NULL);
  
  static ssize_t show_taint(struct module_attribute *mattr,
  			  struct module_kobject *mk, char *buffer)
  {
  	size_t l;
  
  	l = module_flags_taint(mk->mod, buffer);
  	buffer[l++] = '
  ';
  	return l;
  }
  
  static struct module_attribute modinfo_taint =
  	__ATTR(taint, 0444, show_taint, NULL);

  static struct module_attribute *modinfo_attrs[] = {

  	&module_uevent,

  	&modinfo_version,
  	&modinfo_srcversion,

  	&modinfo_initstate,
  	&modinfo_coresize,
  	&modinfo_initsize,
  	&modinfo_taint,

  #ifdef CONFIG_MODULE_UNLOAD

  	&modinfo_refcnt,

  #endif
  	NULL,
  };

  static const char vermagic[] = VERMAGIC_STRING;

  static int try_to_force_load(struct module *mod, const char *reason)

  {
  #ifdef CONFIG_MODULE_FORCE_LOAD

  	if (!test_taint(TAINT_FORCED_MODULE))

  		printk(KERN_WARNING "%s: %s: kernel tainted.
  ",
  		       mod->name, reason);

  	add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_NOW_UNRELIABLE);

  	return 0;
  #else
  	return -ENOEXEC;
  #endif
  }

  #ifdef CONFIG_MODVERSIONS

  /* If the arch applies (non-zero) relocations to kernel kcrctab, unapply it. */
  static unsigned long maybe_relocated(unsigned long crc,
  				     const struct module *crc_owner)
  {
  #ifdef ARCH_RELOCATES_KCRCTAB
  	if (crc_owner == NULL)
  		return crc - (unsigned long)reloc_start;
  #endif
  	return crc;
  }

  static int check_version(Elf_Shdr *sechdrs,
  			 unsigned int versindex,
  			 const char *symname,
  			 struct module *mod, 

  			 const unsigned long *crc,
  			 const struct module *crc_owner)

  {
  	unsigned int i, num_versions;
  	struct modversion_info *versions;
  
  	/* Exporting module didn't supply crcs?  OK, we're already tainted. */
  	if (!crc)
  		return 1;

  	/* No versions at all?  modprobe --force does this. */
  	if (versindex == 0)
  		return try_to_force_load(mod, symname) == 0;

  	versions = (void *) sechdrs[versindex].sh_addr;
  	num_versions = sechdrs[versindex].sh_size
  		/ sizeof(struct modversion_info);
  
  	for (i = 0; i < num_versions; i++) {
  		if (strcmp(versions[i].name, symname) != 0)
  			continue;

  		if (versions[i].crc == maybe_relocated(*crc, crc_owner))

  			return 1;

  		pr_debug("Found checksum %lX vs module %lX
  ",

  		       maybe_relocated(*crc, crc_owner), versions[i].crc);

  		goto bad_version;

  	}

  	printk(KERN_WARNING "%s: no symbol version for %s
  ",
  	       mod->name, symname);
  	return 0;

  
  bad_version:
  	printk("%s: disagrees about version of symbol %s
  ",
  	       mod->name, symname);
  	return 0;

  }
  
  static inline int check_modstruct_version(Elf_Shdr *sechdrs,
  					  unsigned int versindex,
  					  struct module *mod)
  {
  	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();

  	return check_version(sechdrs, versindex, "module_layout", mod, crc,
  			     NULL);

  }

  /* First part is kernel version, which we ignore if module has crcs. */
  static inline int same_magic(const char *amagic, const char *bmagic,
  			     bool has_crcs)

  {

  	if (has_crcs) {
  		amagic += strcspn(amagic, " ");
  		bmagic += strcspn(bmagic, " ");
  	}

  	return strcmp(amagic, bmagic) == 0;
  }
  #else
  static inline int check_version(Elf_Shdr *sechdrs,
  				unsigned int versindex,
  				const char *symname,
  				struct module *mod, 

  				const unsigned long *crc,
  				const struct module *crc_owner)

  {
  	return 1;
  }
  
  static inline int check_modstruct_version(Elf_Shdr *sechdrs,
  					  unsigned int versindex,
  					  struct module *mod)
  {
  	return 1;
  }

  static inline int same_magic(const char *amagic, const char *bmagic,
  			     bool has_crcs)

  {
  	return strcmp(amagic, bmagic) == 0;
  }
  #endif /* CONFIG_MODVERSIONS */

  /* Resolve a symbol for this module.  I.e. if we find one, record usage. */

  static const struct kernel_symbol *resolve_symbol(struct module *mod,
  						  const struct load_info *info,

  						  const char *name,

  						  char ownername[])

  {
  	struct module *owner;

  	const struct kernel_symbol *sym;

  	const unsigned long *crc;

  	int err;

  	mutex_lock(&module_mutex);

  	sym = find_symbol(name, &owner, &crc,

  			  !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);

  	if (!sym)
  		goto unlock;

  	if (!check_version(info->sechdrs, info->index.vers, name, mod, crc,
  			   owner)) {

  		sym = ERR_PTR(-EINVAL);
  		goto getname;

  	}

  
  	err = ref_module(mod, owner);
  	if (err) {
  		sym = ERR_PTR(err);
  		goto getname;
  	}
  
  getname:
  	/* We must make copy under the lock if we failed to get ref. */
  	strncpy(ownername, module_name(owner), MODULE_NAME_LEN);
  unlock:

  	mutex_unlock(&module_mutex);

  	return sym;

  }

  static const struct kernel_symbol *
  resolve_symbol_wait(struct module *mod,
  		    const struct load_info *info,
  		    const char *name)

  {
  	const struct kernel_symbol *ksym;

  	char owner[MODULE_NAME_LEN];

  
  	if (wait_event_interruptible_timeout(module_wq,

  			!IS_ERR(ksym = resolve_symbol(mod, info, name, owner))
  			|| PTR_ERR(ksym) != -EBUSY,

  					     30 * HZ) <= 0) {
  		printk(KERN_WARNING "%s: gave up waiting for init of module %s.
  ",

  		       mod->name, owner);

  	}
  	return ksym;
  }

  /*
   * /sys/module/foo/sections stuff
   * J. Corbet <corbet@lwn.net>
   */

  #ifdef CONFIG_SYSFS

  #ifdef CONFIG_KALLSYMS

  static inline bool sect_empty(const Elf_Shdr *sect)
  {
  	return !(sect->sh_flags & SHF_ALLOC) || sect->sh_size == 0;
  }

  struct module_sect_attr
  {
  	struct module_attribute mattr;
  	char *name;
  	unsigned long address;
  };
  
  struct module_sect_attrs
  {
  	struct attribute_group grp;
  	unsigned int nsections;
  	struct module_sect_attr attrs[0];
  };

  static ssize_t module_sect_show(struct module_attribute *mattr,

  				struct module_kobject *mk, char *buf)

  {
  	struct module_sect_attr *sattr =
  		container_of(mattr, struct module_sect_attr, mattr);

  	return sprintf(buf, "0x%pK
  ", (void *)sattr->address);

  }

  static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
  {

  	unsigned int section;

  
  	for (section = 0; section < sect_attrs->nsections; section++)
  		kfree(sect_attrs->attrs[section].name);
  	kfree(sect_attrs);
  }

  static void add_sect_attrs(struct module *mod, const struct load_info *info)

  {
  	unsigned int nloaded = 0, i, size[2];
  	struct module_sect_attrs *sect_attrs;
  	struct module_sect_attr *sattr;
  	struct attribute **gattr;

  	/* Count loaded sections and allocate structures */

  	for (i = 0; i < info->hdr->e_shnum; i++)
  		if (!sect_empty(&info->sechdrs[i]))

  			nloaded++;
  	size[0] = ALIGN(sizeof(*sect_attrs)
  			+ nloaded * sizeof(sect_attrs->attrs[0]),
  			sizeof(sect_attrs->grp.attrs[0]));
  	size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]);

  	sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);
  	if (sect_attrs == NULL)

  		return;
  
  	/* Setup section attributes. */
  	sect_attrs->grp.name = "sections";
  	sect_attrs->grp.attrs = (void *)sect_attrs + size[0];

  	sect_attrs->nsections = 0;

  	sattr = &sect_attrs->attrs[0];
  	gattr = &sect_attrs->grp.attrs[0];

  	for (i = 0; i < info->hdr->e_shnum; i++) {
  		Elf_Shdr *sec = &info->sechdrs[i];
  		if (sect_empty(sec))

  			continue;

  		sattr->address = sec->sh_addr;
  		sattr->name = kstrdup(info->secstrings + sec->sh_name,

  					GFP_KERNEL);
  		if (sattr->name == NULL)
  			goto out;
  		sect_attrs->nsections++;

  		sysfs_attr_init(&sattr->mattr.attr);

  		sattr->mattr.show = module_sect_show;
  		sattr->mattr.store = NULL;
  		sattr->mattr.attr.name = sattr->name;

  		sattr->mattr.attr.mode = S_IRUGO;
  		*(gattr++) = &(sattr++)->mattr.attr;
  	}
  	*gattr = NULL;
  
  	if (sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp))
  		goto out;
  
  	mod->sect_attrs = sect_attrs;
  	return;
    out:

  	free_sect_attrs(sect_attrs);

  }
  
  static void remove_sect_attrs(struct module *mod)
  {
  	if (mod->sect_attrs) {
  		sysfs_remove_group(&mod->mkobj.kobj,
  				   &mod->sect_attrs->grp);
  		/* We are positive that no one is using any sect attrs
  		 * at this point.  Deallocate immediately. */

  		free_sect_attrs(mod->sect_attrs);

  		mod->sect_attrs = NULL;
  	}
  }

  /*
   * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
   */
  
  struct module_notes_attrs {
  	struct kobject *dir;
  	unsigned int notes;
  	struct bin_attribute attrs[0];
  };

  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)
  {
  	/*
  	 * The caller checked the pos and count against our size.
  	 */
  	memcpy(buf, bin_attr->private + pos, count);
  	return count;
  }
  
  static void free_notes_attrs(struct module_notes_attrs *notes_attrs,
  			     unsigned int i)
  {
  	if (notes_attrs->dir) {
  		while (i-- > 0)
  			sysfs_remove_bin_file(notes_attrs->dir,
  					      &notes_attrs->attrs[i]);

  		kobject_put(notes_attrs->dir);

  	}
  	kfree(notes_attrs);
  }

  static void add_notes_attrs(struct module *mod, const struct load_info *info)

  {
  	unsigned int notes, loaded, i;
  	struct module_notes_attrs *notes_attrs;
  	struct bin_attribute *nattr;

  	/* failed to create section attributes, so can't create notes */
  	if (!mod->sect_attrs)
  		return;

  	/* Count notes sections and allocate structures.  */
  	notes = 0;

  	for (i = 0; i < info->hdr->e_shnum; i++)
  		if (!sect_empty(&info->sechdrs[i]) &&
  		    (info->sechdrs[i].sh_type == SHT_NOTE))

  			++notes;
  
  	if (notes == 0)
  		return;
  
  	notes_attrs = kzalloc(sizeof(*notes_attrs)
  			      + notes * sizeof(notes_attrs->attrs[0]),
  			      GFP_KERNEL);
  	if (notes_attrs == NULL)
  		return;
  
  	notes_attrs->notes = notes;
  	nattr = &notes_attrs->attrs[0];

  	for (loaded = i = 0; i < info->hdr->e_shnum; ++i) {
  		if (sect_empty(&info->sechdrs[i]))

  			continue;

  		if (info->sechdrs[i].sh_type == SHT_NOTE) {

  			sysfs_bin_attr_init(nattr);

  			nattr->attr.name = mod->sect_attrs->attrs[loaded].name;
  			nattr->attr.mode = S_IRUGO;

  			nattr->size = info->sechdrs[i].sh_size;
  			nattr->private = (void *) info->sechdrs[i].sh_addr;

  			nattr->read = module_notes_read;
  			++nattr;
  		}
  		++loaded;
  	}

  	notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);

  	if (!notes_attrs->dir)
  		goto out;
  
  	for (i = 0; i < notes; ++i)
  		if (sysfs_create_bin_file(notes_attrs->dir,
  					  &notes_attrs->attrs[i]))
  			goto out;
  
  	mod->notes_attrs = notes_attrs;
  	return;
  
    out:
  	free_notes_attrs(notes_attrs, i);
  }
  
  static void remove_notes_attrs(struct module *mod)
  {
  	if (mod->notes_attrs)
  		free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);
  }

  #else

  static inline void add_sect_attrs(struct module *mod,
  				  const struct load_info *info)

  {
  }
  
  static inline void remove_sect_attrs(struct module *mod)
  {
  }

  static inline void add_notes_attrs(struct module *mod,
  				   const struct load_info *info)

  {
  }
  
  static inline void remove_notes_attrs(struct module *mod)
  {
  }

  #endif /* CONFIG_KALLSYMS */

  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;

  	int error = 0;
  	int i;

  	mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *
  					(ARRAY_SIZE(modinfo_attrs) + 1)),
  					GFP_KERNEL);
  	if (!mod->modinfo_attrs)
  		return -ENOMEM;
  
  	temp_attr = mod->modinfo_attrs;

  	for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) {
  		if (!attr->test ||

  		    (attr->test && attr->test(mod))) {
  			memcpy(temp_attr, attr, sizeof(*temp_attr));

  			sysfs_attr_init(&temp_attr->attr);

  			error = sysfs_create_file(&mod->mkobj.kobj,&temp_attr->attr);
  			++temp_attr;
  		}

  	}
  	return error;
  }

  static void module_remove_modinfo_attrs(struct module *mod)

  {
  	struct module_attribute *attr;
  	int i;

  	for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {
  		/* pick a field to test for end of list */
  		if (!attr->attr.name)
  			break;

  		sysfs_remove_file(&mod->mkobj.kobj,&attr->attr);

  		if (attr->free)
  			attr->free(mod);

  	}

  	kfree(mod->modinfo_attrs);

  }

  static int mod_sysfs_init(struct module *mod)

  {
  	int err;

  	struct kobject *kobj;

  	if (!module_sysfs_initialized) {
  		printk(KERN_ERR "%s: module sysfs not initialized
  ",

  		       mod->name);
  		err = -EINVAL;
  		goto out;
  	}

  
  	kobj = kset_find_obj(module_kset, mod->name);
  	if (kobj) {
  		printk(KERN_ERR "%s: module is already loaded
  ", mod->name);
  		kobject_put(kobj);
  		err = -EINVAL;
  		goto out;
  	}

  	mod->mkobj.mod = mod;

  	memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
  	mod->mkobj.kobj.kset = module_kset;
  	err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
  				   "%s", mod->name);
  	if (err)
  		kobject_put(&mod->mkobj.kobj);

  	/* delay uevent until full sysfs population */

  out:
  	return err;
  }

  static int mod_sysfs_setup(struct module *mod,

  			   const struct load_info *info,

  			   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;

  		goto out_unreg;

  	}

  	err = module_param_sysfs_setup(mod, kparam, num_params);
  	if (err)

  		goto out_unreg_holders;

  	err = module_add_modinfo_attrs(mod);
  	if (err)

  		goto out_unreg_param;

  	add_usage_links(mod);

  	add_sect_attrs(mod, info);
  	add_notes_attrs(mod, info);

  	kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);

  	return 0;

  out_unreg_param:
  	module_param_sysfs_remove(mod);

  out_unreg_holders:

  	kobject_put(mod->holders_dir);

  out_unreg:

  	kobject_put(&mod->mkobj.kobj);

  out:

  	return err;
  }

  
  static void mod_sysfs_fini(struct module *mod)
  {

  	remove_notes_attrs(mod);
  	remove_sect_attrs(mod);

  	kobject_put(&mod->mkobj.kobj);
  }

  #else /* !CONFIG_SYSFS */

  static int mod_sysfs_setup(struct module *mod,
  			   const struct load_info *info,

  			   struct kernel_param *kparam,
  			   unsigned int num_params)
  {
  	return 0;
  }

  static void mod_sysfs_fini(struct module *mod)
  {
  }

  static void module_remove_modinfo_attrs(struct module *mod)
  {
  }

  static void del_usage_links(struct module *mod)
  {
  }

  #endif /* CONFIG_SYSFS */

  static void mod_sysfs_teardown(struct module *mod)

  {

  	del_usage_links(mod);

  	module_remove_modinfo_attrs(mod);

  	module_param_sysfs_remove(mod);

  	kobject_put(mod->mkobj.drivers_dir);
  	kobject_put(mod->holders_dir);