Linux Audio

Check our new training course

Loading...
v5.14.15
  1/* SPDX-License-Identifier: GPL-2.0-only */
 
  2/*
  3 * Dynamic loading of modules into the kernel.
  4 *
  5 * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
  6 * Rewritten again by Rusty Russell, 2002
  7 */
  8
  9#ifndef _LINUX_MODULE_H
 10#define _LINUX_MODULE_H
 11
 12#include <linux/list.h>
 13#include <linux/stat.h>
 14#include <linux/buildid.h>
 15#include <linux/compiler.h>
 16#include <linux/cache.h>
 17#include <linux/kmod.h>
 18#include <linux/init.h>
 19#include <linux/elf.h>
 20#include <linux/stringify.h>
 21#include <linux/kobject.h>
 22#include <linux/moduleparam.h>
 23#include <linux/jump_label.h>
 24#include <linux/export.h>
 25#include <linux/rbtree_latch.h>
 26#include <linux/error-injection.h>
 27#include <linux/tracepoint-defs.h>
 28#include <linux/srcu.h>
 29#include <linux/static_call_types.h>
 30#include <linux/cfi.h>
 31
 32#include <linux/percpu.h>
 33#include <asm/module.h>
 34
 
 
 
 
 
 
 35#define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
 36
 37struct modversion_info {
 38	unsigned long crc;
 39	char name[MODULE_NAME_LEN];
 40};
 41
 42struct module;
 43struct exception_table_entry;
 44
 45struct module_kobject {
 46	struct kobject kobj;
 47	struct module *mod;
 48	struct kobject *drivers_dir;
 49	struct module_param_attrs *mp;
 50	struct completion *kobj_completion;
 51} __randomize_layout;
 52
 53struct module_attribute {
 54	struct attribute attr;
 55	ssize_t (*show)(struct module_attribute *, struct module_kobject *,
 56			char *);
 57	ssize_t (*store)(struct module_attribute *, struct module_kobject *,
 58			 const char *, size_t count);
 59	void (*setup)(struct module *, const char *);
 60	int (*test)(struct module *);
 61	void (*free)(struct module *);
 62};
 63
 64struct module_version_attribute {
 65	struct module_attribute mattr;
 66	const char *module_name;
 67	const char *version;
 68};
 69
 70extern ssize_t __modver_version_show(struct module_attribute *,
 71				     struct module_kobject *, char *);
 72
 73extern struct module_attribute module_uevent;
 74
 75/* These are either module local, or the kernel's dummy ones. */
 76extern int init_module(void);
 77extern void cleanup_module(void);
 78
 79#ifndef MODULE
 80/**
 81 * module_init() - driver initialization entry point
 82 * @x: function to be run at kernel boot time or module insertion
 83 *
 84 * module_init() will either be called during do_initcalls() (if
 85 * builtin) or at module insertion time (if a module).  There can only
 86 * be one per module.
 87 */
 88#define module_init(x)	__initcall(x);
 89
 90/**
 91 * module_exit() - driver exit entry point
 92 * @x: function to be run when driver is removed
 93 *
 94 * module_exit() will wrap the driver clean-up code
 95 * with cleanup_module() when used with rmmod when
 96 * the driver is a module.  If the driver is statically
 97 * compiled into the kernel, module_exit() has no effect.
 98 * There can only be one per module.
 99 */
100#define module_exit(x)	__exitcall(x);
101
102#else /* MODULE */
103
104/*
105 * In most cases loadable modules do not need custom
106 * initcall levels. There are still some valid cases where
107 * a driver may be needed early if built in, and does not
108 * matter when built as a loadable module. Like bus
109 * snooping debug drivers.
110 */
111#define early_initcall(fn)		module_init(fn)
112#define core_initcall(fn)		module_init(fn)
113#define core_initcall_sync(fn)		module_init(fn)
114#define postcore_initcall(fn)		module_init(fn)
115#define postcore_initcall_sync(fn)	module_init(fn)
116#define arch_initcall(fn)		module_init(fn)
117#define subsys_initcall(fn)		module_init(fn)
118#define subsys_initcall_sync(fn)	module_init(fn)
119#define fs_initcall(fn)			module_init(fn)
120#define fs_initcall_sync(fn)		module_init(fn)
121#define rootfs_initcall(fn)		module_init(fn)
122#define device_initcall(fn)		module_init(fn)
123#define device_initcall_sync(fn)	module_init(fn)
124#define late_initcall(fn)		module_init(fn)
125#define late_initcall_sync(fn)		module_init(fn)
126
127#define console_initcall(fn)		module_init(fn)
 
128
129/* Each module must use one module_init(). */
130#define module_init(initfn)					\
131	static inline initcall_t __maybe_unused __inittest(void)		\
132	{ return initfn; }					\
133	int init_module(void) __copy(initfn)			\
134		__attribute__((alias(#initfn)));		\
135	__CFI_ADDRESSABLE(init_module, __initdata);
136
137/* This is only required if you want to be unloadable. */
138#define module_exit(exitfn)					\
139	static inline exitcall_t __maybe_unused __exittest(void)		\
140	{ return exitfn; }					\
141	void cleanup_module(void) __copy(exitfn)		\
142		__attribute__((alias(#exitfn)));		\
143	__CFI_ADDRESSABLE(cleanup_module, __exitdata);
144
145#endif
146
147/* This means "can be init if no module support, otherwise module load
148   may call it." */
149#ifdef CONFIG_MODULES
150#define __init_or_module
151#define __initdata_or_module
152#define __initconst_or_module
153#define __INIT_OR_MODULE	.text
154#define __INITDATA_OR_MODULE	.data
155#define __INITRODATA_OR_MODULE	.section ".rodata","a",%progbits
156#else
157#define __init_or_module __init
158#define __initdata_or_module __initdata
159#define __initconst_or_module __initconst
160#define __INIT_OR_MODULE __INIT
161#define __INITDATA_OR_MODULE __INITDATA
162#define __INITRODATA_OR_MODULE __INITRODATA
163#endif /*CONFIG_MODULES*/
164
 
 
 
 
 
 
 
 
 
 
 
 
165/* Generic info of form tag = "info" */
166#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
167
168/* For userspace: you can also call me... */
169#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
170
171/* Soft module dependencies. See man modprobe.d for details.
172 * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz")
173 */
174#define MODULE_SOFTDEP(_softdep) MODULE_INFO(softdep, _softdep)
175
176/*
177 * MODULE_FILE is used for generating modules.builtin
178 * So, make it no-op when this is being built as a module
179 */
180#ifdef MODULE
181#define MODULE_FILE
182#else
183#define MODULE_FILE	MODULE_INFO(file, KBUILD_MODFILE);
184#endif
185
186/*
187 * The following license idents are currently accepted as indicating free
188 * software modules
189 *
190 *	"GPL"				[GNU Public License v2]
191 *	"GPL v2"			[GNU Public License v2]
192 *	"GPL and additional rights"	[GNU Public License v2 rights and more]
193 *	"Dual BSD/GPL"			[GNU Public License v2
194 *					 or BSD license choice]
195 *	"Dual MIT/GPL"			[GNU Public License v2
196 *					 or MIT license choice]
197 *	"Dual MPL/GPL"			[GNU Public License v2
198 *					 or Mozilla license choice]
199 *
200 * The following other idents are available
201 *
202 *	"Proprietary"			[Non free products]
203 *
204 * Both "GPL v2" and "GPL" (the latter also in dual licensed strings) are
205 * merely stating that the module is licensed under the GPL v2, but are not
206 * telling whether "GPL v2 only" or "GPL v2 or later". The reason why there
207 * are two variants is a historic and failed attempt to convey more
208 * information in the MODULE_LICENSE string. For module loading the
209 * "only/or later" distinction is completely irrelevant and does neither
210 * replace the proper license identifiers in the corresponding source file
211 * nor amends them in any way. The sole purpose is to make the
212 * 'Proprietary' flagging work and to refuse to bind symbols which are
213 * exported with EXPORT_SYMBOL_GPL when a non free module is loaded.
214 *
215 * In the same way "BSD" is not a clear license information. It merely
216 * states, that the module is licensed under one of the compatible BSD
217 * license variants. The detailed and correct license information is again
218 * to be found in the corresponding source files.
219 *
220 * There are dual licensed components, but when running with Linux it is the
221 * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
222 * is a GPL combined work.
223 *
224 * This exists for several reasons
225 * 1.	So modinfo can show license info for users wanting to vet their setup
226 *	is free
227 * 2.	So the community can ignore bug reports including proprietary modules
228 * 3.	So vendors can do likewise based on their own policies
229 */
230#define MODULE_LICENSE(_license) MODULE_FILE MODULE_INFO(license, _license)
231
232/*
233 * Author(s), use "Name <email>" or just "Name", for multiple
234 * authors use multiple MODULE_AUTHOR() statements/lines.
235 */
236#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
237
238/* What your module does. */
239#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
240
241#ifdef MODULE
242/* Creates an alias so file2alias.c can find device table. */
243#define MODULE_DEVICE_TABLE(type, name)					\
244extern typeof(name) __mod_##type##__##name##_device_table		\
245  __attribute__ ((unused, alias(__stringify(name))))
246#else  /* !MODULE */
247#define MODULE_DEVICE_TABLE(type, name)
248#endif
249
250/* Version of form [<epoch>:]<version>[-<extra-version>].
251 * Or for CVS/RCS ID version, everything but the number is stripped.
252 * <epoch>: A (small) unsigned integer which allows you to start versions
253 * anew. If not mentioned, it's zero.  eg. "2:1.0" is after
254 * "1:2.0".
255
256 * <version>: The <version> may contain only alphanumerics and the
257 * character `.'.  Ordered by numeric sort for numeric parts,
258 * ascii sort for ascii parts (as per RPM or DEB algorithm).
259
260 * <extraversion>: Like <version>, but inserted for local
261 * customizations, eg "rh3" or "rusty1".
262
263 * Using this automatically adds a checksum of the .c files and the
264 * local headers in "srcversion".
265 */
266
267#if defined(MODULE) || !defined(CONFIG_SYSFS)
268#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
269#else
270#define MODULE_VERSION(_version)					\
271	MODULE_INFO(version, _version);					\
272	static struct module_version_attribute __modver_attr		\
273		__used __section("__modver")				\
274		__aligned(__alignof__(struct module_version_attribute)) \
275		= {							\
276			.mattr	= {					\
277				.attr	= {				\
278					.name	= "version",		\
279					.mode	= S_IRUGO,		\
280				},					\
281				.show	= __modver_version_show,	\
282			},						\
283			.module_name	= KBUILD_MODNAME,		\
284			.version	= _version,			\
285		}
 
 
 
 
 
286#endif
287
288/* Optional firmware file (or files) needed by the module
289 * format is simply firmware file name.  Multiple firmware
290 * files require multiple MODULE_FIRMWARE() specifiers */
291#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
292
293#define MODULE_IMPORT_NS(ns) MODULE_INFO(import_ns, #ns)
 
294
295struct notifier_block;
296
297#ifdef CONFIG_MODULES
298
299extern int modules_disabled; /* for sysctl */
300/* Get/put a kernel symbol (calls must be symmetric) */
301void *__symbol_get(const char *symbol);
302void *__symbol_get_gpl(const char *symbol);
303#define symbol_get(x) ((typeof(&x))(__symbol_get(__stringify(x))))
304
305/* modules using other modules: kdb wants to see this. */
306struct module_use {
307	struct list_head source_list;
308	struct list_head target_list;
309	struct module *source, *target;
310};
311
312enum module_state {
313	MODULE_STATE_LIVE,	/* Normal state. */
314	MODULE_STATE_COMING,	/* Full formed, running module_init. */
315	MODULE_STATE_GOING,	/* Going away. */
316	MODULE_STATE_UNFORMED,	/* Still setting it up. */
317};
318
 
 
319struct mod_tree_node {
320	struct module *mod;
321	struct latch_tree_node node;
322};
323
324struct module_layout {
325	/* The actual code + data. */
326	void *base;
327	/* Total size. */
328	unsigned int size;
329	/* The size of the executable code.  */
330	unsigned int text_size;
331	/* Size of RO section of the module (text+rodata) */
332	unsigned int ro_size;
333	/* Size of RO after init section */
334	unsigned int ro_after_init_size;
335
336#ifdef CONFIG_MODULES_TREE_LOOKUP
337	struct mod_tree_node mtn;
338#endif
339};
340
341#ifdef CONFIG_MODULES_TREE_LOOKUP
342/* Only touch one cacheline for common rbtree-for-core-layout case. */
343#define __module_layout_align ____cacheline_aligned
344#else
345#define __module_layout_align
346#endif
347
348struct mod_kallsyms {
349	Elf_Sym *symtab;
350	unsigned int num_symtab;
351	char *strtab;
352	char *typetab;
353};
354
355#ifdef CONFIG_LIVEPATCH
356struct klp_modinfo {
357	Elf_Ehdr hdr;
358	Elf_Shdr *sechdrs;
359	char *secstrings;
360	unsigned int symndx;
361};
362#endif
363
364struct module {
365	enum module_state state;
366
367	/* Member of list of modules */
368	struct list_head list;
369
370	/* Unique handle for this module */
371	char name[MODULE_NAME_LEN];
372
373#ifdef CONFIG_STACKTRACE_BUILD_ID
374	/* Module build ID */
375	unsigned char build_id[BUILD_ID_SIZE_MAX];
376#endif
377
378	/* Sysfs stuff. */
379	struct module_kobject mkobj;
380	struct module_attribute *modinfo_attrs;
381	const char *version;
382	const char *srcversion;
383	struct kobject *holders_dir;
384
385	/* Exported symbols */
386	const struct kernel_symbol *syms;
387	const s32 *crcs;
388	unsigned int num_syms;
389
390#ifdef CONFIG_CFI_CLANG
391	cfi_check_fn cfi_check;
392#endif
393
394	/* Kernel parameters. */
395#ifdef CONFIG_SYSFS
396	struct mutex param_lock;
397#endif
398	struct kernel_param *kp;
399	unsigned int num_kp;
400
401	/* GPL-only exported symbols. */
402	unsigned int num_gpl_syms;
403	const struct kernel_symbol *gpl_syms;
404	const s32 *gpl_crcs;
405	bool using_gplonly_symbols;
 
 
 
 
 
 
 
 
 
 
 
406
407#ifdef CONFIG_MODULE_SIG
408	/* Signature was verified. */
409	bool sig_ok;
410#endif
411
412	bool async_probe_requested;
413
 
 
 
 
 
414	/* Exception table */
415	unsigned int num_exentries;
416	struct exception_table_entry *extable;
417
418	/* Startup function. */
419	int (*init)(void);
420
421	/* Core layout: rbtree is accessed frequently, so keep together. */
422	struct module_layout core_layout __module_layout_align;
423	struct module_layout init_layout;
424
425	/* Arch-specific module values */
426	struct mod_arch_specific arch;
427
428	unsigned long taints;	/* same bits as kernel:taint_flags */
429
430#ifdef CONFIG_GENERIC_BUG
431	/* Support for BUG */
432	unsigned num_bugs;
433	struct list_head bug_list;
434	struct bug_entry *bug_table;
435#endif
436
437#ifdef CONFIG_KALLSYMS
438	/* Protected by RCU and/or module_mutex: use rcu_dereference() */
439	struct mod_kallsyms __rcu *kallsyms;
440	struct mod_kallsyms core_kallsyms;
441
442	/* Section attributes */
443	struct module_sect_attrs *sect_attrs;
444
445	/* Notes attributes */
446	struct module_notes_attrs *notes_attrs;
447#endif
448
449	/* The command line arguments (may be mangled).  People like
450	   keeping pointers to this stuff */
451	char *args;
452
453#ifdef CONFIG_SMP
454	/* Per-cpu data. */
455	void __percpu *percpu;
456	unsigned int percpu_size;
457#endif
458	void *noinstr_text_start;
459	unsigned int noinstr_text_size;
460
461#ifdef CONFIG_TRACEPOINTS
462	unsigned int num_tracepoints;
463	tracepoint_ptr_t *tracepoints_ptrs;
464#endif
465#ifdef CONFIG_TREE_SRCU
466	unsigned int num_srcu_structs;
467	struct srcu_struct **srcu_struct_ptrs;
468#endif
469#ifdef CONFIG_BPF_EVENTS
470	unsigned int num_bpf_raw_events;
471	struct bpf_raw_event_map *bpf_raw_events;
472#endif
473#ifdef CONFIG_DEBUG_INFO_BTF_MODULES
474	unsigned int btf_data_size;
475	void *btf_data;
476#endif
477#ifdef CONFIG_JUMP_LABEL
478	struct jump_entry *jump_entries;
479	unsigned int num_jump_entries;
480#endif
481#ifdef CONFIG_TRACING
482	unsigned int num_trace_bprintk_fmt;
483	const char **trace_bprintk_fmt_start;
484#endif
485#ifdef CONFIG_EVENT_TRACING
486	struct trace_event_call **trace_events;
487	unsigned int num_trace_events;
488	struct trace_eval_map **trace_evals;
489	unsigned int num_trace_evals;
490#endif
491#ifdef CONFIG_FTRACE_MCOUNT_RECORD
492	unsigned int num_ftrace_callsites;
493	unsigned long *ftrace_callsites;
494#endif
495#ifdef CONFIG_KPROBES
496	void *kprobes_text_start;
497	unsigned int kprobes_text_size;
498	unsigned long *kprobe_blacklist;
499	unsigned int num_kprobe_blacklist;
500#endif
501#ifdef CONFIG_HAVE_STATIC_CALL_INLINE
502	int num_static_call_sites;
503	struct static_call_site *static_call_sites;
504#endif
505
506#ifdef CONFIG_LIVEPATCH
507	bool klp; /* Is this a livepatch module? */
508	bool klp_alive;
509
510	/* Elf information */
511	struct klp_modinfo *klp_info;
512#endif
513
514#ifdef CONFIG_MODULE_UNLOAD
515	/* What modules depend on me? */
516	struct list_head source_list;
517	/* What modules do I depend on? */
518	struct list_head target_list;
519
520	/* Destruction function. */
521	void (*exit)(void);
522
523	atomic_t refcnt;
524#endif
525
526#ifdef CONFIG_CONSTRUCTORS
527	/* Constructor functions. */
528	ctor_fn_t *ctors;
529	unsigned int num_ctors;
530#endif
531
532#ifdef CONFIG_FUNCTION_ERROR_INJECTION
533	struct error_injection_entry *ei_funcs;
534	unsigned int num_ei_funcs;
535#endif
536} ____cacheline_aligned __randomize_layout;
537#ifndef MODULE_ARCH_INIT
538#define MODULE_ARCH_INIT {}
539#endif
540
541#ifndef HAVE_ARCH_KALLSYMS_SYMBOL_VALUE
542static inline unsigned long kallsyms_symbol_value(const Elf_Sym *sym)
543{
544	return sym->st_value;
545}
546#endif
547
548/* FIXME: It'd be nice to isolate modules during init, too, so they
549   aren't used before they (may) fail.  But presently too much code
550   (IDE & SCSI) require entry into the module during init.*/
551static inline bool module_is_live(struct module *mod)
552{
553	return mod->state != MODULE_STATE_GOING;
554}
555
556struct module *__module_text_address(unsigned long addr);
557struct module *__module_address(unsigned long addr);
558bool is_module_address(unsigned long addr);
559bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr);
560bool is_module_percpu_address(unsigned long addr);
561bool is_module_text_address(unsigned long addr);
562
563static inline bool within_module_core(unsigned long addr,
564				      const struct module *mod)
565{
566	return (unsigned long)mod->core_layout.base <= addr &&
567	       addr < (unsigned long)mod->core_layout.base + mod->core_layout.size;
568}
569
570static inline bool within_module_init(unsigned long addr,
571				      const struct module *mod)
572{
573	return (unsigned long)mod->init_layout.base <= addr &&
574	       addr < (unsigned long)mod->init_layout.base + mod->init_layout.size;
575}
576
577static inline bool within_module(unsigned long addr, const struct module *mod)
578{
579	return within_module_init(addr, mod) || within_module_core(addr, mod);
580}
581
582/* Search for module by name: must be in a RCU-sched critical section. */
583struct module *find_module(const char *name);
584
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
585/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
586   symnum out of range. */
587int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
588			char *name, char *module_name, int *exported);
589
590/* Look for this name: can be of form module:name. */
591unsigned long module_kallsyms_lookup_name(const char *name);
592
593extern void __noreturn __module_put_and_exit(struct module *mod,
594			long code);
 
 
 
 
595#define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code)
596
597#ifdef CONFIG_MODULE_UNLOAD
598int module_refcount(struct module *mod);
599void __symbol_put(const char *symbol);
600#define symbol_put(x) __symbol_put(__stringify(x))
601void symbol_put_addr(void *addr);
602
603/* Sometimes we know we already have a refcount, and it's easier not
604   to handle the error case (which only happens with rmmod --wait). */
605extern void __module_get(struct module *module);
606
607/* This is the Right Way to get a module: if it fails, it's being removed,
608 * so pretend it's not there. */
609extern bool try_module_get(struct module *module);
610
611extern void module_put(struct module *module);
612
613#else /*!CONFIG_MODULE_UNLOAD*/
614static inline bool try_module_get(struct module *module)
615{
616	return !module || module_is_live(module);
617}
618static inline void module_put(struct module *module)
619{
620}
621static inline void __module_get(struct module *module)
622{
623}
624#define symbol_put(x) do { } while (0)
625#define symbol_put_addr(p) do { } while (0)
626
627#endif /* CONFIG_MODULE_UNLOAD */
 
628
629/* This is a #define so the string doesn't get put in every .o file */
630#define module_name(mod)			\
631({						\
632	struct module *__mod = (mod);		\
633	__mod ? __mod->name : "kernel";		\
634})
635
636/* Dereference module function descriptor */
637void *dereference_module_function_descriptor(struct module *mod, void *ptr);
638
639/* For kallsyms to ask for address resolution.  namebuf should be at
640 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
641 * found, otherwise NULL. */
642const char *module_address_lookup(unsigned long addr,
643			    unsigned long *symbolsize,
644			    unsigned long *offset,
645			    char **modname, const unsigned char **modbuildid,
646			    char *namebuf);
647int lookup_module_symbol_name(unsigned long addr, char *symname);
648int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
649
 
 
 
650int register_module_notifier(struct notifier_block *nb);
651int unregister_module_notifier(struct notifier_block *nb);
652
653extern void print_modules(void);
654
655static inline bool module_requested_async_probing(struct module *module)
656{
657	return module && module->async_probe_requested;
658}
659
660#ifdef CONFIG_LIVEPATCH
661static inline bool is_livepatch_module(struct module *mod)
662{
663	return mod->klp;
664}
665#else /* !CONFIG_LIVEPATCH */
666static inline bool is_livepatch_module(struct module *mod)
667{
668	return false;
669}
670#endif /* CONFIG_LIVEPATCH */
671
672bool is_module_sig_enforced(void);
673void set_module_sig_enforced(void);
674
675#else /* !CONFIG_MODULES... */
676
677static inline struct module *__module_address(unsigned long addr)
678{
679	return NULL;
680}
681
682static inline struct module *__module_text_address(unsigned long addr)
683{
684	return NULL;
685}
686
687static inline bool is_module_address(unsigned long addr)
688{
689	return false;
690}
691
692static inline bool is_module_percpu_address(unsigned long addr)
693{
694	return false;
695}
696
697static inline bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr)
698{
699	return false;
700}
701
702static inline bool is_module_text_address(unsigned long addr)
703{
704	return false;
705}
706
707static inline bool within_module_core(unsigned long addr,
708				      const struct module *mod)
709{
710	return false;
711}
712
713static inline bool within_module_init(unsigned long addr,
714				      const struct module *mod)
715{
716	return false;
717}
718
719static inline bool within_module(unsigned long addr, const struct module *mod)
720{
721	return false;
722}
723
724/* Get/put a kernel symbol (calls should be symmetric) */
725#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak,visibility("hidden"))); &(x); })
726#define symbol_put(x) do { } while (0)
727#define symbol_put_addr(x) do { } while (0)
728
729static inline void __module_get(struct module *module)
730{
731}
732
733static inline bool try_module_get(struct module *module)
734{
735	return true;
736}
737
738static inline void module_put(struct module *module)
739{
740}
741
742#define module_name(mod) "kernel"
743
744/* For kallsyms to ask for address resolution.  NULL means not found. */
745static inline const char *module_address_lookup(unsigned long addr,
746					  unsigned long *symbolsize,
747					  unsigned long *offset,
748					  char **modname,
749					  const unsigned char **modbuildid,
750					  char *namebuf)
751{
752	return NULL;
753}
754
755static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
756{
757	return -ERANGE;
758}
759
760static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
761{
762	return -ERANGE;
763}
764
765static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
766					char *type, char *name,
767					char *module_name, int *exported)
768{
769	return -ERANGE;
770}
771
772static inline unsigned long module_kallsyms_lookup_name(const char *name)
773{
774	return 0;
775}
776
 
 
 
 
 
 
 
 
777static inline int register_module_notifier(struct notifier_block *nb)
778{
779	/* no events will happen anyway, so this can always succeed */
780	return 0;
781}
782
783static inline int unregister_module_notifier(struct notifier_block *nb)
784{
785	return 0;
786}
787
788#define module_put_and_exit(code) do_exit(code)
789
790static inline void print_modules(void)
791{
792}
793
794static inline bool module_requested_async_probing(struct module *module)
795{
796	return false;
797}
798
799static inline bool is_module_sig_enforced(void)
800{
801	return false;
802}
803
804static inline void set_module_sig_enforced(void)
805{
806}
807
808/* Dereference module function descriptor */
809static inline
810void *dereference_module_function_descriptor(struct module *mod, void *ptr)
811{
812	return ptr;
813}
814
815#endif /* CONFIG_MODULES */
816
817#ifdef CONFIG_SYSFS
818extern struct kset *module_kset;
819extern struct kobj_type module_ktype;
820extern int module_sysfs_initialized;
821#endif /* CONFIG_SYSFS */
822
823#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
824
825/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
826
827#define __MODULE_STRING(x) __stringify(x)
828
 
 
 
 
 
 
 
 
 
 
 
 
829#ifdef CONFIG_GENERIC_BUG
830void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
831			 struct module *);
832void module_bug_cleanup(struct module *);
833
834#else	/* !CONFIG_GENERIC_BUG */
835
836static inline void module_bug_finalize(const Elf_Ehdr *hdr,
837					const Elf_Shdr *sechdrs,
838					struct module *mod)
839{
840}
841static inline void module_bug_cleanup(struct module *mod) {}
842#endif	/* CONFIG_GENERIC_BUG */
843
844#ifdef CONFIG_RETPOLINE
845extern bool retpoline_module_ok(bool has_retpoline);
846#else
847static inline bool retpoline_module_ok(bool has_retpoline)
848{
849	return true;
850}
851#endif
852
853#ifdef CONFIG_MODULE_SIG
854static inline bool module_sig_ok(struct module *module)
855{
856	return module->sig_ok;
857}
858#else	/* !CONFIG_MODULE_SIG */
859static inline bool module_sig_ok(struct module *module)
860{
861	return true;
862}
863#endif	/* CONFIG_MODULE_SIG */
864
865int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
866					     struct module *, unsigned long),
867				   void *data);
868
869#endif /* _LINUX_MODULE_H */
v4.6
  1#ifndef _LINUX_MODULE_H
  2#define _LINUX_MODULE_H
  3/*
  4 * Dynamic loading of modules into the kernel.
  5 *
  6 * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
  7 * Rewritten again by Rusty Russell, 2002
  8 */
 
 
 
 
  9#include <linux/list.h>
 10#include <linux/stat.h>
 
 11#include <linux/compiler.h>
 12#include <linux/cache.h>
 13#include <linux/kmod.h>
 14#include <linux/init.h>
 15#include <linux/elf.h>
 16#include <linux/stringify.h>
 17#include <linux/kobject.h>
 18#include <linux/moduleparam.h>
 19#include <linux/jump_label.h>
 20#include <linux/export.h>
 21#include <linux/rbtree_latch.h>
 
 
 
 
 
 22
 23#include <linux/percpu.h>
 24#include <asm/module.h>
 25
 26/* In stripped ARM and x86-64 modules, ~ is surprisingly rare. */
 27#define MODULE_SIG_STRING "~Module signature appended~\n"
 28
 29/* Not Yet Implemented */
 30#define MODULE_SUPPORTED_DEVICE(name)
 31
 32#define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
 33
 34struct modversion_info {
 35	unsigned long crc;
 36	char name[MODULE_NAME_LEN];
 37};
 38
 39struct module;
 
 40
 41struct module_kobject {
 42	struct kobject kobj;
 43	struct module *mod;
 44	struct kobject *drivers_dir;
 45	struct module_param_attrs *mp;
 46	struct completion *kobj_completion;
 47};
 48
 49struct module_attribute {
 50	struct attribute attr;
 51	ssize_t (*show)(struct module_attribute *, struct module_kobject *,
 52			char *);
 53	ssize_t (*store)(struct module_attribute *, struct module_kobject *,
 54			 const char *, size_t count);
 55	void (*setup)(struct module *, const char *);
 56	int (*test)(struct module *);
 57	void (*free)(struct module *);
 58};
 59
 60struct module_version_attribute {
 61	struct module_attribute mattr;
 62	const char *module_name;
 63	const char *version;
 64} __attribute__ ((__aligned__(sizeof(void *))));
 65
 66extern ssize_t __modver_version_show(struct module_attribute *,
 67				     struct module_kobject *, char *);
 68
 69extern struct module_attribute module_uevent;
 70
 71/* These are either module local, or the kernel's dummy ones. */
 72extern int init_module(void);
 73extern void cleanup_module(void);
 74
 75#ifndef MODULE
 76/**
 77 * module_init() - driver initialization entry point
 78 * @x: function to be run at kernel boot time or module insertion
 79 *
 80 * module_init() will either be called during do_initcalls() (if
 81 * builtin) or at module insertion time (if a module).  There can only
 82 * be one per module.
 83 */
 84#define module_init(x)	__initcall(x);
 85
 86/**
 87 * module_exit() - driver exit entry point
 88 * @x: function to be run when driver is removed
 89 *
 90 * module_exit() will wrap the driver clean-up code
 91 * with cleanup_module() when used with rmmod when
 92 * the driver is a module.  If the driver is statically
 93 * compiled into the kernel, module_exit() has no effect.
 94 * There can only be one per module.
 95 */
 96#define module_exit(x)	__exitcall(x);
 97
 98#else /* MODULE */
 99
100/*
101 * In most cases loadable modules do not need custom
102 * initcall levels. There are still some valid cases where
103 * a driver may be needed early if built in, and does not
104 * matter when built as a loadable module. Like bus
105 * snooping debug drivers.
106 */
107#define early_initcall(fn)		module_init(fn)
108#define core_initcall(fn)		module_init(fn)
109#define core_initcall_sync(fn)		module_init(fn)
110#define postcore_initcall(fn)		module_init(fn)
111#define postcore_initcall_sync(fn)	module_init(fn)
112#define arch_initcall(fn)		module_init(fn)
113#define subsys_initcall(fn)		module_init(fn)
114#define subsys_initcall_sync(fn)	module_init(fn)
115#define fs_initcall(fn)			module_init(fn)
116#define fs_initcall_sync(fn)		module_init(fn)
117#define rootfs_initcall(fn)		module_init(fn)
118#define device_initcall(fn)		module_init(fn)
119#define device_initcall_sync(fn)	module_init(fn)
120#define late_initcall(fn)		module_init(fn)
121#define late_initcall_sync(fn)		module_init(fn)
122
123#define console_initcall(fn)		module_init(fn)
124#define security_initcall(fn)		module_init(fn)
125
126/* Each module must use one module_init(). */
127#define module_init(initfn)					\
128	static inline initcall_t __inittest(void)		\
129	{ return initfn; }					\
130	int init_module(void) __attribute__((alias(#initfn)));
 
 
131
132/* This is only required if you want to be unloadable. */
133#define module_exit(exitfn)					\
134	static inline exitcall_t __exittest(void)		\
135	{ return exitfn; }					\
136	void cleanup_module(void) __attribute__((alias(#exitfn)));
 
 
137
138#endif
139
140/* This means "can be init if no module support, otherwise module load
141   may call it." */
142#ifdef CONFIG_MODULES
143#define __init_or_module
144#define __initdata_or_module
145#define __initconst_or_module
146#define __INIT_OR_MODULE	.text
147#define __INITDATA_OR_MODULE	.data
148#define __INITRODATA_OR_MODULE	.section ".rodata","a",%progbits
149#else
150#define __init_or_module __init
151#define __initdata_or_module __initdata
152#define __initconst_or_module __initconst
153#define __INIT_OR_MODULE __INIT
154#define __INITDATA_OR_MODULE __INITDATA
155#define __INITRODATA_OR_MODULE __INITRODATA
156#endif /*CONFIG_MODULES*/
157
158/* Archs provide a method of finding the correct exception table. */
159struct exception_table_entry;
160
161const struct exception_table_entry *
162search_extable(const struct exception_table_entry *first,
163	       const struct exception_table_entry *last,
164	       unsigned long value);
165void sort_extable(struct exception_table_entry *start,
166		  struct exception_table_entry *finish);
167void sort_main_extable(void);
168void trim_init_extable(struct module *m);
169
170/* Generic info of form tag = "info" */
171#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
172
173/* For userspace: you can also call me... */
174#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
175
176/* Soft module dependencies. See man modprobe.d for details.
177 * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz")
178 */
179#define MODULE_SOFTDEP(_softdep) MODULE_INFO(softdep, _softdep)
180
181/*
 
 
 
 
 
 
 
 
 
 
182 * The following license idents are currently accepted as indicating free
183 * software modules
184 *
185 *	"GPL"				[GNU Public License v2 or later]
186 *	"GPL v2"			[GNU Public License v2]
187 *	"GPL and additional rights"	[GNU Public License v2 rights and more]
188 *	"Dual BSD/GPL"			[GNU Public License v2
189 *					 or BSD license choice]
190 *	"Dual MIT/GPL"			[GNU Public License v2
191 *					 or MIT license choice]
192 *	"Dual MPL/GPL"			[GNU Public License v2
193 *					 or Mozilla license choice]
194 *
195 * The following other idents are available
196 *
197 *	"Proprietary"			[Non free products]
198 *
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
199 * There are dual licensed components, but when running with Linux it is the
200 * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
201 * is a GPL combined work.
202 *
203 * This exists for several reasons
204 * 1.	So modinfo can show license info for users wanting to vet their setup
205 *	is free
206 * 2.	So the community can ignore bug reports including proprietary modules
207 * 3.	So vendors can do likewise based on their own policies
208 */
209#define MODULE_LICENSE(_license) MODULE_INFO(license, _license)
210
211/*
212 * Author(s), use "Name <email>" or just "Name", for multiple
213 * authors use multiple MODULE_AUTHOR() statements/lines.
214 */
215#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
216
217/* What your module does. */
218#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
219
220#ifdef MODULE
221/* Creates an alias so file2alias.c can find device table. */
222#define MODULE_DEVICE_TABLE(type, name)					\
223extern const typeof(name) __mod_##type##__##name##_device_table		\
224  __attribute__ ((unused, alias(__stringify(name))))
225#else  /* !MODULE */
226#define MODULE_DEVICE_TABLE(type, name)
227#endif
228
229/* Version of form [<epoch>:]<version>[-<extra-version>].
230 * Or for CVS/RCS ID version, everything but the number is stripped.
231 * <epoch>: A (small) unsigned integer which allows you to start versions
232 * anew. If not mentioned, it's zero.  eg. "2:1.0" is after
233 * "1:2.0".
234
235 * <version>: The <version> may contain only alphanumerics and the
236 * character `.'.  Ordered by numeric sort for numeric parts,
237 * ascii sort for ascii parts (as per RPM or DEB algorithm).
238
239 * <extraversion>: Like <version>, but inserted for local
240 * customizations, eg "rh3" or "rusty1".
241
242 * Using this automatically adds a checksum of the .c files and the
243 * local headers in "srcversion".
244 */
245
246#if defined(MODULE) || !defined(CONFIG_SYSFS)
247#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
248#else
249#define MODULE_VERSION(_version)					\
250	static struct module_version_attribute ___modver_attr = {	\
251		.mattr	= {						\
252			.attr	= {					\
253				.name	= "version",			\
254				.mode	= S_IRUGO,			\
 
 
 
 
 
 
255			},						\
256			.show	= __modver_version_show,		\
257		},							\
258		.module_name	= KBUILD_MODNAME,			\
259		.version	= _version,				\
260	};								\
261	static const struct module_version_attribute			\
262	__used __attribute__ ((__section__ ("__modver")))		\
263	* __moduleparam_const __modver_attr = &___modver_attr
264#endif
265
266/* Optional firmware file (or files) needed by the module
267 * format is simply firmware file name.  Multiple firmware
268 * files require multiple MODULE_FIRMWARE() specifiers */
269#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
270
271/* Given an address, look for it in the exception tables */
272const struct exception_table_entry *search_exception_tables(unsigned long add);
273
274struct notifier_block;
275
276#ifdef CONFIG_MODULES
277
278extern int modules_disabled; /* for sysctl */
279/* Get/put a kernel symbol (calls must be symmetric) */
280void *__symbol_get(const char *symbol);
281void *__symbol_get_gpl(const char *symbol);
282#define symbol_get(x) ((typeof(&x))(__symbol_get(VMLINUX_SYMBOL_STR(x))))
283
284/* modules using other modules: kdb wants to see this. */
285struct module_use {
286	struct list_head source_list;
287	struct list_head target_list;
288	struct module *source, *target;
289};
290
291enum module_state {
292	MODULE_STATE_LIVE,	/* Normal state. */
293	MODULE_STATE_COMING,	/* Full formed, running module_init. */
294	MODULE_STATE_GOING,	/* Going away. */
295	MODULE_STATE_UNFORMED,	/* Still setting it up. */
296};
297
298struct module;
299
300struct mod_tree_node {
301	struct module *mod;
302	struct latch_tree_node node;
303};
304
305struct module_layout {
306	/* The actual code + data. */
307	void *base;
308	/* Total size. */
309	unsigned int size;
310	/* The size of the executable code.  */
311	unsigned int text_size;
312	/* Size of RO section of the module (text+rodata) */
313	unsigned int ro_size;
 
 
314
315#ifdef CONFIG_MODULES_TREE_LOOKUP
316	struct mod_tree_node mtn;
317#endif
318};
319
320#ifdef CONFIG_MODULES_TREE_LOOKUP
321/* Only touch one cacheline for common rbtree-for-core-layout case. */
322#define __module_layout_align ____cacheline_aligned
323#else
324#define __module_layout_align
325#endif
326
327struct mod_kallsyms {
328	Elf_Sym *symtab;
329	unsigned int num_symtab;
330	char *strtab;
 
331};
332
 
 
 
 
 
 
 
 
 
333struct module {
334	enum module_state state;
335
336	/* Member of list of modules */
337	struct list_head list;
338
339	/* Unique handle for this module */
340	char name[MODULE_NAME_LEN];
341
 
 
 
 
 
342	/* Sysfs stuff. */
343	struct module_kobject mkobj;
344	struct module_attribute *modinfo_attrs;
345	const char *version;
346	const char *srcversion;
347	struct kobject *holders_dir;
348
349	/* Exported symbols */
350	const struct kernel_symbol *syms;
351	const unsigned long *crcs;
352	unsigned int num_syms;
353
 
 
 
 
354	/* Kernel parameters. */
355#ifdef CONFIG_SYSFS
356	struct mutex param_lock;
357#endif
358	struct kernel_param *kp;
359	unsigned int num_kp;
360
361	/* GPL-only exported symbols. */
362	unsigned int num_gpl_syms;
363	const struct kernel_symbol *gpl_syms;
364	const unsigned long *gpl_crcs;
365
366#ifdef CONFIG_UNUSED_SYMBOLS
367	/* unused exported symbols. */
368	const struct kernel_symbol *unused_syms;
369	const unsigned long *unused_crcs;
370	unsigned int num_unused_syms;
371
372	/* GPL-only, unused exported symbols. */
373	unsigned int num_unused_gpl_syms;
374	const struct kernel_symbol *unused_gpl_syms;
375	const unsigned long *unused_gpl_crcs;
376#endif
377
378#ifdef CONFIG_MODULE_SIG
379	/* Signature was verified. */
380	bool sig_ok;
381#endif
382
383	bool async_probe_requested;
384
385	/* symbols that will be GPL-only in the near future. */
386	const struct kernel_symbol *gpl_future_syms;
387	const unsigned long *gpl_future_crcs;
388	unsigned int num_gpl_future_syms;
389
390	/* Exception table */
391	unsigned int num_exentries;
392	struct exception_table_entry *extable;
393
394	/* Startup function. */
395	int (*init)(void);
396
397	/* Core layout: rbtree is accessed frequently, so keep together. */
398	struct module_layout core_layout __module_layout_align;
399	struct module_layout init_layout;
400
401	/* Arch-specific module values */
402	struct mod_arch_specific arch;
403
404	unsigned int taints;	/* same bits as kernel:tainted */
405
406#ifdef CONFIG_GENERIC_BUG
407	/* Support for BUG */
408	unsigned num_bugs;
409	struct list_head bug_list;
410	struct bug_entry *bug_table;
411#endif
412
413#ifdef CONFIG_KALLSYMS
414	/* Protected by RCU and/or module_mutex: use rcu_dereference() */
415	struct mod_kallsyms *kallsyms;
416	struct mod_kallsyms core_kallsyms;
417	
418	/* Section attributes */
419	struct module_sect_attrs *sect_attrs;
420
421	/* Notes attributes */
422	struct module_notes_attrs *notes_attrs;
423#endif
424
425	/* The command line arguments (may be mangled).  People like
426	   keeping pointers to this stuff */
427	char *args;
428
429#ifdef CONFIG_SMP
430	/* Per-cpu data. */
431	void __percpu *percpu;
432	unsigned int percpu_size;
433#endif
 
 
434
435#ifdef CONFIG_TRACEPOINTS
436	unsigned int num_tracepoints;
437	struct tracepoint * const *tracepoints_ptrs;
 
 
 
 
 
 
 
 
 
 
 
 
438#endif
439#ifdef HAVE_JUMP_LABEL
440	struct jump_entry *jump_entries;
441	unsigned int num_jump_entries;
442#endif
443#ifdef CONFIG_TRACING
444	unsigned int num_trace_bprintk_fmt;
445	const char **trace_bprintk_fmt_start;
446#endif
447#ifdef CONFIG_EVENT_TRACING
448	struct trace_event_call **trace_events;
449	unsigned int num_trace_events;
450	struct trace_enum_map **trace_enums;
451	unsigned int num_trace_enums;
452#endif
453#ifdef CONFIG_FTRACE_MCOUNT_RECORD
454	unsigned int num_ftrace_callsites;
455	unsigned long *ftrace_callsites;
456#endif
 
 
 
 
 
 
 
 
 
 
457
458#ifdef CONFIG_LIVEPATCH
 
459	bool klp_alive;
 
 
 
460#endif
461
462#ifdef CONFIG_MODULE_UNLOAD
463	/* What modules depend on me? */
464	struct list_head source_list;
465	/* What modules do I depend on? */
466	struct list_head target_list;
467
468	/* Destruction function. */
469	void (*exit)(void);
470
471	atomic_t refcnt;
472#endif
473
474#ifdef CONFIG_CONSTRUCTORS
475	/* Constructor functions. */
476	ctor_fn_t *ctors;
477	unsigned int num_ctors;
478#endif
479} ____cacheline_aligned;
 
 
 
 
 
480#ifndef MODULE_ARCH_INIT
481#define MODULE_ARCH_INIT {}
482#endif
483
484extern struct mutex module_mutex;
 
 
 
 
 
485
486/* FIXME: It'd be nice to isolate modules during init, too, so they
487   aren't used before they (may) fail.  But presently too much code
488   (IDE & SCSI) require entry into the module during init.*/
489static inline int module_is_live(struct module *mod)
490{
491	return mod->state != MODULE_STATE_GOING;
492}
493
494struct module *__module_text_address(unsigned long addr);
495struct module *__module_address(unsigned long addr);
496bool is_module_address(unsigned long addr);
 
497bool is_module_percpu_address(unsigned long addr);
498bool is_module_text_address(unsigned long addr);
499
500static inline bool within_module_core(unsigned long addr,
501				      const struct module *mod)
502{
503	return (unsigned long)mod->core_layout.base <= addr &&
504	       addr < (unsigned long)mod->core_layout.base + mod->core_layout.size;
505}
506
507static inline bool within_module_init(unsigned long addr,
508				      const struct module *mod)
509{
510	return (unsigned long)mod->init_layout.base <= addr &&
511	       addr < (unsigned long)mod->init_layout.base + mod->init_layout.size;
512}
513
514static inline bool within_module(unsigned long addr, const struct module *mod)
515{
516	return within_module_init(addr, mod) || within_module_core(addr, mod);
517}
518
519/* Search for module by name: must hold module_mutex. */
520struct module *find_module(const char *name);
521
522struct symsearch {
523	const struct kernel_symbol *start, *stop;
524	const unsigned long *crcs;
525	enum {
526		NOT_GPL_ONLY,
527		GPL_ONLY,
528		WILL_BE_GPL_ONLY,
529	} licence;
530	bool unused;
531};
532
533/*
534 * Search for an exported symbol by name.
535 *
536 * Must be called with module_mutex held or preemption disabled.
537 */
538const struct kernel_symbol *find_symbol(const char *name,
539					struct module **owner,
540					const unsigned long **crc,
541					bool gplok,
542					bool warn);
543
544/*
545 * Walk the exported symbol table
546 *
547 * Must be called with module_mutex held or preemption disabled.
548 */
549bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
550				    struct module *owner,
551				    void *data), void *data);
552
553/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
554   symnum out of range. */
555int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
556			char *name, char *module_name, int *exported);
557
558/* Look for this name: can be of form module:name. */
559unsigned long module_kallsyms_lookup_name(const char *name);
560
561int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
562					     struct module *, unsigned long),
563				   void *data);
564
565extern void __module_put_and_exit(struct module *mod, long code)
566	__attribute__((noreturn));
567#define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code)
568
569#ifdef CONFIG_MODULE_UNLOAD
570int module_refcount(struct module *mod);
571void __symbol_put(const char *symbol);
572#define symbol_put(x) __symbol_put(VMLINUX_SYMBOL_STR(x))
573void symbol_put_addr(void *addr);
574
575/* Sometimes we know we already have a refcount, and it's easier not
576   to handle the error case (which only happens with rmmod --wait). */
577extern void __module_get(struct module *module);
578
579/* This is the Right Way to get a module: if it fails, it's being removed,
580 * so pretend it's not there. */
581extern bool try_module_get(struct module *module);
582
583extern void module_put(struct module *module);
584
585#else /*!CONFIG_MODULE_UNLOAD*/
586static inline int try_module_get(struct module *module)
587{
588	return !module || module_is_live(module);
589}
590static inline void module_put(struct module *module)
591{
592}
593static inline void __module_get(struct module *module)
594{
595}
596#define symbol_put(x) do { } while (0)
597#define symbol_put_addr(p) do { } while (0)
598
599#endif /* CONFIG_MODULE_UNLOAD */
600int ref_module(struct module *a, struct module *b);
601
602/* This is a #define so the string doesn't get put in every .o file */
603#define module_name(mod)			\
604({						\
605	struct module *__mod = (mod);		\
606	__mod ? __mod->name : "kernel";		\
607})
608
 
 
 
609/* For kallsyms to ask for address resolution.  namebuf should be at
610 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
611 * found, otherwise NULL. */
612const char *module_address_lookup(unsigned long addr,
613			    unsigned long *symbolsize,
614			    unsigned long *offset,
615			    char **modname,
616			    char *namebuf);
617int lookup_module_symbol_name(unsigned long addr, char *symname);
618int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
619
620/* For extable.c to search modules' exception tables. */
621const struct exception_table_entry *search_module_extables(unsigned long addr);
622
623int register_module_notifier(struct notifier_block *nb);
624int unregister_module_notifier(struct notifier_block *nb);
625
626extern void print_modules(void);
627
628static inline bool module_requested_async_probing(struct module *module)
629{
630	return module && module->async_probe_requested;
631}
632
633#else /* !CONFIG_MODULES... */
634
635/* Given an address, look for it in the exception tables. */
636static inline const struct exception_table_entry *
637search_module_extables(unsigned long addr)
 
 
638{
639	return NULL;
640}
 
 
 
 
 
 
641
642static inline struct module *__module_address(unsigned long addr)
643{
644	return NULL;
645}
646
647static inline struct module *__module_text_address(unsigned long addr)
648{
649	return NULL;
650}
651
652static inline bool is_module_address(unsigned long addr)
653{
654	return false;
655}
656
657static inline bool is_module_percpu_address(unsigned long addr)
658{
659	return false;
660}
661
 
 
 
 
 
662static inline bool is_module_text_address(unsigned long addr)
663{
664	return false;
665}
666
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
667/* Get/put a kernel symbol (calls should be symmetric) */
668#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
669#define symbol_put(x) do { } while (0)
670#define symbol_put_addr(x) do { } while (0)
671
672static inline void __module_get(struct module *module)
673{
674}
675
676static inline int try_module_get(struct module *module)
677{
678	return 1;
679}
680
681static inline void module_put(struct module *module)
682{
683}
684
685#define module_name(mod) "kernel"
686
687/* For kallsyms to ask for address resolution.  NULL means not found. */
688static inline const char *module_address_lookup(unsigned long addr,
689					  unsigned long *symbolsize,
690					  unsigned long *offset,
691					  char **modname,
 
692					  char *namebuf)
693{
694	return NULL;
695}
696
697static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
698{
699	return -ERANGE;
700}
701
702static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
703{
704	return -ERANGE;
705}
706
707static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
708					char *type, char *name,
709					char *module_name, int *exported)
710{
711	return -ERANGE;
712}
713
714static inline unsigned long module_kallsyms_lookup_name(const char *name)
715{
716	return 0;
717}
718
719static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
720							   struct module *,
721							   unsigned long),
722						 void *data)
723{
724	return 0;
725}
726
727static inline int register_module_notifier(struct notifier_block *nb)
728{
729	/* no events will happen anyway, so this can always succeed */
730	return 0;
731}
732
733static inline int unregister_module_notifier(struct notifier_block *nb)
734{
735	return 0;
736}
737
738#define module_put_and_exit(code) do_exit(code)
739
740static inline void print_modules(void)
741{
742}
743
744static inline bool module_requested_async_probing(struct module *module)
745{
746	return false;
747}
748
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
749#endif /* CONFIG_MODULES */
750
751#ifdef CONFIG_SYSFS
752extern struct kset *module_kset;
753extern struct kobj_type module_ktype;
754extern int module_sysfs_initialized;
755#endif /* CONFIG_SYSFS */
756
757#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
758
759/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
760
761#define __MODULE_STRING(x) __stringify(x)
762
763#ifdef CONFIG_DEBUG_SET_MODULE_RONX
764extern void set_all_modules_text_rw(void);
765extern void set_all_modules_text_ro(void);
766extern void module_enable_ro(const struct module *mod);
767extern void module_disable_ro(const struct module *mod);
768#else
769static inline void set_all_modules_text_rw(void) { }
770static inline void set_all_modules_text_ro(void) { }
771static inline void module_enable_ro(const struct module *mod) { }
772static inline void module_disable_ro(const struct module *mod) { }
773#endif
774
775#ifdef CONFIG_GENERIC_BUG
776void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
777			 struct module *);
778void module_bug_cleanup(struct module *);
779
780#else	/* !CONFIG_GENERIC_BUG */
781
782static inline void module_bug_finalize(const Elf_Ehdr *hdr,
783					const Elf_Shdr *sechdrs,
784					struct module *mod)
785{
786}
787static inline void module_bug_cleanup(struct module *mod) {}
788#endif	/* CONFIG_GENERIC_BUG */
789
 
 
 
 
 
 
 
 
 
790#ifdef CONFIG_MODULE_SIG
791static inline bool module_sig_ok(struct module *module)
792{
793	return module->sig_ok;
794}
795#else	/* !CONFIG_MODULE_SIG */
796static inline bool module_sig_ok(struct module *module)
797{
798	return true;
799}
800#endif	/* CONFIG_MODULE_SIG */
 
 
 
 
801
802#endif /* _LINUX_MODULE_H */