/*

     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/extable.h>

  #include <linux/moduleloader.h>

  #include <linux/trace_events.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/device.h>

  #include <linux/string.h>

  #include <linux/mutex.h>

  #include <linux/rculist.h>

  #include <linux/uaccess.h>

  #include <asm/cacheflush.h>

  #include <linux/set_memory.h>

  #include <asm/mmu_context.h>

  #include <linux/license.h>

  #include <asm/sections.h>

  #include <linux/tracepoint.h>

  #include <linux/ftrace.h>

  #include <linux/livepatch.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/dynamic_debug.h>

  #include <linux/audit.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_STRICT_MODULE_RWX=y

   */

  #ifdef CONFIG_STRICT_MODULE_RWX

  # define debug_align(X) ALIGN(X, PAGE_SIZE)
  #else
  # define debug_align(X) (X)
  #endif

  /* 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 and add uses RCU list operations). */

  DEFINE_MUTEX(module_mutex);
  EXPORT_SYMBOL_GPL(module_mutex);

  static LIST_HEAD(modules);

  #ifdef CONFIG_MODULES_TREE_LOOKUP

  /*
   * Use a latched RB-tree for __module_address(); this allows us to use
   * RCU-sched lookups of the address from any context.
   *

   * This is conditional on PERF_EVENTS || TRACING because those can really hit
   * __module_address() hard by doing a lot of stack unwinding; potentially from
   * NMI context.

   */
  
  static __always_inline unsigned long __mod_tree_val(struct latch_tree_node *n)

  {

  	struct module_layout *layout = container_of(n, struct module_layout, mtn.node);

  	return (unsigned long)layout->base;

  }
  
  static __always_inline unsigned long __mod_tree_size(struct latch_tree_node *n)
  {

  	struct module_layout *layout = container_of(n, struct module_layout, mtn.node);

  	return (unsigned long)layout->size;

  }
  
  static __always_inline bool
  mod_tree_less(struct latch_tree_node *a, struct latch_tree_node *b)
  {
  	return __mod_tree_val(a) < __mod_tree_val(b);
  }
  
  static __always_inline int
  mod_tree_comp(void *key, struct latch_tree_node *n)
  {
  	unsigned long val = (unsigned long)key;
  	unsigned long start, end;
  
  	start = __mod_tree_val(n);
  	if (val < start)
  		return -1;
  
  	end = start + __mod_tree_size(n);
  	if (val >= end)
  		return 1;

  	return 0;
  }

  static const struct latch_tree_ops mod_tree_ops = {
  	.less = mod_tree_less,
  	.comp = mod_tree_comp,
  };

  static struct mod_tree_root {
  	struct latch_tree_root root;
  	unsigned long addr_min;
  	unsigned long addr_max;
  } mod_tree __cacheline_aligned = {
  	.addr_min = -1UL,

  };

  #define module_addr_min mod_tree.addr_min
  #define module_addr_max mod_tree.addr_max
  
  static noinline void __mod_tree_insert(struct mod_tree_node *node)
  {
  	latch_tree_insert(&node->node, &mod_tree.root, &mod_tree_ops);
  }
  
  static void __mod_tree_remove(struct mod_tree_node *node)
  {
  	latch_tree_erase(&node->node, &mod_tree.root, &mod_tree_ops);
  }

  
  /*
   * These modifications: insert, remove_init and remove; are serialized by the
   * module_mutex.
   */
  static void mod_tree_insert(struct module *mod)
  {

  	mod->core_layout.mtn.mod = mod;
  	mod->init_layout.mtn.mod = mod;

  	__mod_tree_insert(&mod->core_layout.mtn);
  	if (mod->init_layout.size)
  		__mod_tree_insert(&mod->init_layout.mtn);

  }
  
  static void mod_tree_remove_init(struct module *mod)
  {

  	if (mod->init_layout.size)
  		__mod_tree_remove(&mod->init_layout.mtn);

  }
  
  static void mod_tree_remove(struct module *mod)
  {

  	__mod_tree_remove(&mod->core_layout.mtn);

  	mod_tree_remove_init(mod);
  }

  static struct module *mod_find(unsigned long addr)

  {
  	struct latch_tree_node *ltn;

  	ltn = latch_tree_find((void *)addr, &mod_tree.root, &mod_tree_ops);

  	if (!ltn)
  		return NULL;
  
  	return container_of(ltn, struct mod_tree_node, node)->mod;
  }

  #else /* MODULES_TREE_LOOKUP */

  static unsigned long module_addr_min = -1UL, module_addr_max = 0;

  static void mod_tree_insert(struct module *mod) { }
  static void mod_tree_remove_init(struct module *mod) { }
  static void mod_tree_remove(struct module *mod) { }
  
  static struct module *mod_find(unsigned long addr)
  {
  	struct module *mod;
  
  	list_for_each_entry_rcu(mod, &modules, list) {
  		if (within_module(addr, mod))
  			return mod;
  	}
  
  	return NULL;
  }
  
  #endif /* MODULES_TREE_LOOKUP */

  /*
   * Bounds of module text, for speeding up __module_address.
   * Protected by module_mutex.
   */
  static void __mod_update_bounds(void *base, unsigned int size)
  {
  	unsigned long min = (unsigned long)base;
  	unsigned long max = min + size;
  
  	if (min < module_addr_min)
  		module_addr_min = min;
  	if (max > module_addr_max)
  		module_addr_max = max;
  }
  
  static void mod_update_bounds(struct module *mod)
  {

  	__mod_update_bounds(mod->core_layout.base, mod->core_layout.size);
  	if (mod->init_layout.size)
  		__mod_update_bounds(mod->init_layout.base, mod->init_layout.size);

  }

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

  static void module_assert_mutex(void)
  {
  	lockdep_assert_held(&module_mutex);
  }
  
  static void module_assert_mutex_or_preempt(void)
  {
  #ifdef CONFIG_LOCKDEP
  	if (unlikely(!debug_locks))
  		return;

  	WARN_ON_ONCE(!rcu_read_lock_sched_held() &&

  		!lockdep_is_held(&module_mutex));
  #endif
  }

  static bool sig_enforce = IS_ENABLED(CONFIG_MODULE_SIG_FORCE);
  #ifndef CONFIG_MODULE_SIG_FORCE

  module_param(sig_enforce, bool_enable_only, 0644);
  #endif /* !CONFIG_MODULE_SIG_FORCE */

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

  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 {

  	const char *name;

  	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;

  #ifdef CONFIG_KALLSYMS
  	unsigned long mod_kallsyms_init_off;
  #endif

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

  /*
   * We require a truly strong try_module_get(): 0 means success.
   * Otherwise an error is returned 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);

  	set_bit(flag, &mod->taints);

  }

  /*
   * 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 __noreturn __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 s32 __start___kcrctab[];
  extern const s32 __start___kcrctab_gpl[];
  extern const s32 __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 s32 __start___kcrctab_unused[];
  extern const s32 __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

  	};

  	module_assert_mutex_or_preempt();

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

  			pr_warn("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) {

  		pr_warn("Symbol %s is marked as UNUSED, however this module is "
  			"using it.
  ", fsa->name);
  		pr_warn("This symbol will go away in the future.
  ");

  		pr_warn("Please evaluate if this is the right api to use and "
  			"if it really is, submit a report to the linux kernel "
  			"mailing list 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 s32 **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 (or preempt disabled
   * for read-only access).
   */

  static struct module *find_module_all(const char *name, size_t len,

  				      bool even_unformed)

  {
  	struct module *mod;

  	module_assert_mutex_or_preempt();

  	list_for_each_entry_rcu(mod, &modules, list) {

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

  		if (strlen(mod->name) == len && !memcmp(mod->name, name, len))

  			return mod;
  	}
  	return NULL;
  }

  
  struct module *find_module(const char *name)
  {

  	module_assert_mutex();

  	return find_module_all(name, strlen(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, struct load_info *info)

  {

  	Elf_Shdr *pcpusec = &info->sechdrs[info->index.pcpu];
  	unsigned long align = pcpusec->sh_addralign;
  
  	if (!pcpusec->sh_size)
  		return 0;

  	if (align > PAGE_SIZE) {

  		pr_warn("%s: per-cpu alignment %li > %li
  ",
  			mod->name, align, PAGE_SIZE);

  		align = PAGE_SIZE;
  	}

  	mod->percpu = __alloc_reserved_percpu(pcpusec->sh_size, align);

  	if (!mod->percpu) {

  		pr_warn("%s: Could not allocate %lu bytes percpu data
  ",
  			mod->name, (unsigned long)pcpusec->sh_size);

  		return -ENOMEM;
  	}

  	mod->percpu_size = pcpusec->sh_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);

  }

  bool __is_module_percpu_address(unsigned long addr, unsigned long *can_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);

  			void *va = (void *)addr;

  			if (va >= start && va < start + mod->percpu_size) {

  				if (can_addr) {

  					*can_addr = (unsigned long) (va - start);

  					*can_addr += (unsigned long)
  						per_cpu_ptr(mod->percpu,
  							    get_boot_cpu_id());
  				}

  				preempt_enable();
  				return true;
  			}
  		}
  	}
  
  	preempt_enable();
  	return false;

  }

  /**
   * 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)
  {
  	return __is_module_percpu_address(addr, NULL);
  }

  #else /* ... !CONFIG_SMP */

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

  {
  	return NULL;
  }

  static int percpu_modalloc(struct module *mod, struct load_info *info)

  {

  	/* UP modules shouldn't have this section: ENOMEM isn't quite right */
  	if (info->sechdrs[info->index.pcpu].sh_size != 0)
  		return -ENOMEM;
  	return 0;

  }
  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;
  }

  bool __is_module_percpu_address(unsigned long addr, unsigned long *can_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 scnprintf(buffer, PAGE_SIZE, "%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);

  /* MODULE_REF_BASE is the base reference count by kmodule loader. */
  #define MODULE_REF_BASE	1

  /* Init the unload section of the module. */

  static int module_unload_init(struct module *mod)

  {

  	/*
  	 * Initialize reference counter to MODULE_REF_BASE.
  	 * refcnt == 0 means module is going.
  	 */
  	atomic_set(&mod->refcnt, MODULE_REF_BASE);

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

  	/* Hold reference count during initialization. */

  	atomic_inc(&mod->refcnt);

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

  		pr_warn("%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);

  }
  
  #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 */

  /* Try to release refcount of module, 0 means success. */
  static int try_release_module_ref(struct module *mod)

  {

  	int ret;

  	/* Try to decrement refcnt which we set at loading */
  	ret = atomic_sub_return(MODULE_REF_BASE, &mod->refcnt);
  	BUG_ON(ret < 0);
  	if (ret)
  		/* Someone can put this right now, recover with checking */
  		ret = atomic_add_unless(&mod->refcnt, MODULE_REF_BASE, 0);

  	return ret;
  }

  static int try_stop_module(struct module *mod, int flags, int *forced)
  {

  	/* If it's not unused, quit unless we're forcing. */

  	if (try_release_module_ref(mod) != 0) {
  		*forced = try_force_unload(flags);
  		if (!(*forced))

  			return -EWOULDBLOCK;
  	}
  
  	/* Mark it as dying. */

  	mod->state = MODULE_STATE_GOING;

  	return 0;

  }

  /**
   * module_refcount - return the refcount or -1 if unloading
   *
   * @mod:	the module we're checking
   *
   * Returns:
   *	-1 if the module is in the process of unloading
   *	otherwise the number of references in the kernel to the module
   */
  int module_refcount(struct module *mod)

  {

  	return atomic_read(&mod->refcnt) - MODULE_REF_BASE;

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

  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';

  	audit_log_kern_module(name);

  	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 damn the torpedoes */

  		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;
  		}
  	}

  	/* Stop the machine so refcounts can't move and disable module. */
  	ret = try_stop_module(mod, flags, &forced);
  	if (ret != 0)
  		goto out;

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

  	klp_module_going(mod);

  	ftrace_release_mod(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, " %i ", 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_puts(m, "[permanent],");

  	}
  
  	if (!printed_something)

  		seq_puts(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;

  	/*
  	 * Even though we hold a reference on the module; we still need to
  	 * disable preemption in order to safely traverse the data structure.
  	 */
  	preempt_disable();

  	modaddr = __module_text_address(a);

  	BUG_ON(!modaddr);

  	module_put(modaddr);

  	preempt_enable();

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

  			   struct module_kobject *mk, char *buffer)

  {

  	return sprintf(buffer, "%i
  ", 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();

  		atomic_inc(&module->refcnt);

  		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();

  		/* Note: here, we can fail to get a reference */
  		if (likely(module_is_live(module) &&
  			   atomic_inc_not_zero(&module->refcnt) != 0))

  			trace_module_get(module, _RET_IP_);

  		else

  			ret = false;
  
  		preempt_enable();
  	}
  	return ret;
  }
  EXPORT_SYMBOL(try_module_get);

  void module_put(struct module *module)
  {

  	int ret;

  	if (module) {

  		preempt_disable();

  		ret = atomic_dec_if_positive(&module->refcnt);
  		WARN_ON(ret < 0);	/* Failed to put refcount */

  		trace_module_put(module, _RET_IP_);

  		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_puts(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;

  	int i;
  
  	for (i = 0; i < TAINT_FLAGS_COUNT; i++) {
  		if (taint_flags[i].module && test_bit(i, &mod->taints))

  			buf[l++] = taint_flags[i].c_true;

  	}

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

  	kobject_synth_uevent(&mk->kobj, buffer, count);

  	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_layout.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_layout.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))

  		pr_warn("%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

  
  static u32 resolve_rel_crc(const s32 *crc)

  {

  	return *(u32 *)((void *)crc + *crc);

  }

  static int check_version(const struct load_info *info,

  			 const char *symname,

  			 struct module *mod,

  			 const s32 *crc)

  {

  	Elf_Shdr *sechdrs = info->sechdrs;
  	unsigned int versindex = info->index.vers;

  	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++) {

  		u32 crcval;

  		if (strcmp(versions[i].name, symname) != 0)
  			continue;

  		if (IS_ENABLED(CONFIG_MODULE_REL_CRCS))
  			crcval = resolve_rel_crc(crc);
  		else
  			crcval = *crc;
  		if (versions[i].crc == crcval)

  			return 1;

  		pr_debug("Found checksum %X vs module %lX
  ",
  			 crcval, versions[i].crc);

  		goto bad_version;

  	}

  	/* Broken toolchain. Warn once, then let it go.. */

  	pr_warn_once("%s: no symbol version for %s
  ", info->name, symname);

  	return 1;

  
  bad_version:

  	pr_warn("%s: disagrees about version of symbol %s
  ",

  	       info->name, symname);

  	return 0;

  }

  static inline int check_modstruct_version(const struct load_info *info,

  					  struct module *mod)
  {

  	const s32 *crc;

  	/*
  	 * Since this should be found in kernel (which can't be removed), no
  	 * locking is necessary -- use preempt_disable() to placate lockdep.
  	 */
  	preempt_disable();

  	if (!find_symbol(VMLINUX_SYMBOL_STR(module_layout), NULL,

  			 &crc, true, false)) {
  		preempt_enable();

  		BUG();

  	}
  	preempt_enable();

  	return check_version(info, VMLINUX_SYMBOL_STR(module_layout),
  			     mod, crc);

  }

  /* 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(const struct load_info *info,

  				const char *symname,

  				struct module *mod,

  				const s32 *crc)

  {
  	return 1;
  }

  static inline int check_modstruct_version(const struct load_info *info,

  					  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 s32 *crc;

  	int err;

  	/*
  	 * The module_mutex should not be a heavily contended lock;
  	 * if we get the occasional sleep here, we'll go an extra iteration
  	 * in the wait_event_interruptible(), which is harmless.
  	 */
  	sched_annotate_sleep();

  	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, name, mod, crc)) {

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

  		pr_warn("%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;
  }