/*   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/module.h>#include <linux/moduleloader.h>#include <linux/ftrace_event.h>#include <linux/init.h>#include <linux/kallsyms.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/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> #define CREATE_TRACE_POINTS#include <trace/events/module.h> #if 0#define DEBUGP printk#else#define DEBUGP(fmt , a...)#endif #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_KDBstruct list_head *kdb_modules = &modules; /* kdb needs the list of modules */#endif /* CONFIG_KGDB_KDB */  /* Block module loading/unloading? */int modules_disabled = 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 *strmap;	unsigned long symoffs, stroffs;	struct _ddebug *debug;	unsigned int num_debug;	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){	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){	add_taint(flag);	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_SYMBOLSextern 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 (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\n", fsa->name);			printk(KERN_WARNING "Please see the file "			       "Documentation/feature-removal-schedule.txt "			       "in the kernel source tree for more details.\n");		}	} #ifdef CONFIG_UNUSED_SYMBOLS	if (syms->unused && fsa->warn) {		printk(KERN_WARNING "Symbol %s is marked as UNUSED, "		       "however this module is using it.\n", fsa->name);		printk(KERN_WARNING		       "This symbol will go away in the future.\n");		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.\n");	}#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;	} 	DEBUGP("Failed to find symbol %s\n", name);	return NULL;}EXPORT_SYMBOL_GPL(find_symbol); /* Search for module by name: must hold module_mutex. */struct module *find_module(const char *name){	struct module *mod; 	list_for_each_entry(mod, &modules, list) {		if (strcmp(mod->name, name) == 0)			return mod;	}	return NULL;}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\n",		       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\n",		       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->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) {

Lines 1–500 of 3536. Load more