Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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/cleanup.h>
18#include <linux/kmod.h>
19#include <linux/init.h>
20#include <linux/elf.h>
21#include <linux/stringify.h>
22#include <linux/kobject.h>
23#include <linux/moduleparam.h>
24#include <linux/jump_label.h>
25#include <linux/export.h>
26#include <linux/rbtree_latch.h>
27#include <linux/error-injection.h>
28#include <linux/tracepoint-defs.h>
29#include <linux/srcu.h>
30#include <linux/static_call_types.h>
31#include <linux/dynamic_debug.h>
32
33#include <linux/percpu.h>
34#include <asm/module.h>
35
36#define MODULE_NAME_LEN __MODULE_NAME_LEN
37
38struct modversion_info {
39 unsigned long crc;
40 char name[MODULE_NAME_LEN];
41};
42
43struct module;
44struct exception_table_entry;
45
46struct module_kobject {
47 struct kobject kobj;
48 struct module *mod;
49 struct kobject *drivers_dir;
50 struct module_param_attrs *mp;
51 struct completion *kobj_completion;
52} __randomize_layout;
53
54struct module_attribute {
55 struct attribute attr;
56 ssize_t (*show)(const struct module_attribute *, struct module_kobject *,
57 char *);
58 ssize_t (*store)(const struct module_attribute *, struct module_kobject *,
59 const char *, size_t count);
60 void (*setup)(struct module *, const char *);
61 int (*test)(struct module *);
62 void (*free)(struct module *);
63};
64
65struct module_version_attribute {
66 struct module_attribute mattr;
67 const char *module_name;
68 const char *version;
69};
70
71extern ssize_t __modver_version_show(const struct module_attribute *,
72 struct module_kobject *, char *);
73
74extern const struct module_attribute module_uevent;
75
76/* These are either module local, or the kernel's dummy ones. */
77extern int init_module(void);
78extern void cleanup_module(void);
79
80#ifndef MODULE
81/**
82 * module_init() - driver initialization entry point
83 * @x: function to be run at kernel boot time or module insertion
84 *
85 * module_init() will either be called during do_initcalls() (if
86 * builtin) or at module insertion time (if a module). There can only
87 * be one per module.
88 */
89#define module_init(x) __initcall(x);
90
91/**
92 * module_exit() - driver exit entry point
93 * @x: function to be run when driver is removed
94 *
95 * module_exit() will wrap the driver clean-up code
96 * with cleanup_module() when used with rmmod when
97 * the driver is a module. If the driver is statically
98 * compiled into the kernel, module_exit() has no effect.
99 * There can only be one per module.
100 */
101#define module_exit(x) __exitcall(x);
102
103#else /* MODULE */
104
105/*
106 * In most cases loadable modules do not need custom
107 * initcall levels. There are still some valid cases where
108 * a driver may be needed early if built in, and does not
109 * matter when built as a loadable module. Like bus
110 * snooping debug drivers.
111 */
112#define early_initcall(fn) module_init(fn)
113#define core_initcall(fn) module_init(fn)
114#define core_initcall_sync(fn) module_init(fn)
115#define postcore_initcall(fn) module_init(fn)
116#define postcore_initcall_sync(fn) module_init(fn)
117#define arch_initcall(fn) module_init(fn)
118#define subsys_initcall(fn) module_init(fn)
119#define subsys_initcall_sync(fn) module_init(fn)
120#define fs_initcall(fn) module_init(fn)
121#define fs_initcall_sync(fn) module_init(fn)
122#define rootfs_initcall(fn) module_init(fn)
123#define device_initcall(fn) module_init(fn)
124#define device_initcall_sync(fn) module_init(fn)
125#define late_initcall(fn) module_init(fn)
126#define late_initcall_sync(fn) module_init(fn)
127
128#define console_initcall(fn) module_init(fn)
129
130/* Each module must use one module_init(). */
131#define module_init(initfn) \
132 static inline initcall_t __maybe_unused __inittest(void) \
133 { return initfn; } \
134 int init_module(void) __copy(initfn) \
135 __attribute__((alias(#initfn))); \
136 ___ADDRESSABLE(init_module, __initdata);
137
138/* This is only required if you want to be unloadable. */
139#define module_exit(exitfn) \
140 static inline exitcall_t __maybe_unused __exittest(void) \
141 { return exitfn; } \
142 void cleanup_module(void) __copy(exitfn) \
143 __attribute__((alias(#exitfn))); \
144 ___ADDRESSABLE(cleanup_module, __exitdata);
145
146#endif
147
148/* This means "can be init if no module support, otherwise module load
149 may call it." */
150#ifdef CONFIG_MODULES
151#define __init_or_module
152#define __initdata_or_module
153#define __initconst_or_module
154#else
155#define __init_or_module __init
156#define __initdata_or_module __initdata
157#define __initconst_or_module __initconst
158#endif /*CONFIG_MODULES*/
159
160struct module_kobject *lookup_or_create_module_kobject(const char *name);
161
162/* For userspace: you can also call me... */
163#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
164
165/* Soft module dependencies. See man modprobe.d for details.
166 * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz")
167 */
168#define MODULE_SOFTDEP(_softdep) MODULE_INFO(softdep, _softdep)
169
170/*
171 * Weak module dependencies. See man modprobe.d for details.
172 * Example: MODULE_WEAKDEP("module-foo")
173 */
174#define MODULE_WEAKDEP(_weakdep) MODULE_INFO(weakdep, _weakdep)
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/*
242 * Format: __mod_device_table__kmod_<modname>__<type>__<name>
243 * Parts of the string `__kmod_` and `__` are used as delimiters when parsing
244 * a symbol in file2alias.c
245 */
246#define __mod_device_table(type, name) \
247 __PASTE(__mod_device_table__, \
248 __PASTE(kmod_, \
249 __PASTE(__KBUILD_MODNAME, \
250 __PASTE(__, \
251 __PASTE(type, \
252 __PASTE(__, name))))))
253
254/* Creates an alias so file2alias.c can find device table. */
255#define MODULE_DEVICE_TABLE(type, name) \
256static typeof(name) __mod_device_table(type, name) \
257 __attribute__ ((used, alias(__stringify(name))))
258
259/* Version of form [<epoch>:]<version>[-<extra-version>].
260 * Or for CVS/RCS ID version, everything but the number is stripped.
261 * <epoch>: A (small) unsigned integer which allows you to start versions
262 * anew. If not mentioned, it's zero. eg. "2:1.0" is after
263 * "1:2.0".
264
265 * <version>: The <version> may contain only alphanumerics and the
266 * character `.'. Ordered by numeric sort for numeric parts,
267 * ascii sort for ascii parts (as per RPM or DEB algorithm).
268
269 * <extraversion>: Like <version>, but inserted for local
270 * customizations, eg "rh3" or "rusty1".
271
272 * Using this automatically adds a checksum of the .c files and the
273 * local headers in "srcversion".
274 */
275
276#if defined(MODULE) || !defined(CONFIG_SYSFS)
277#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
278#else
279#define MODULE_VERSION(_version) \
280 MODULE_INFO(version, _version); \
281 static const struct module_version_attribute __modver_attr \
282 __used __section("__modver") \
283 __aligned(__alignof__(struct module_version_attribute)) \
284 = { \
285 .mattr = { \
286 .attr = { \
287 .name = "version", \
288 .mode = S_IRUGO, \
289 }, \
290 .show = __modver_version_show, \
291 }, \
292 .module_name = KBUILD_MODNAME, \
293 .version = _version, \
294 }
295#endif
296
297/* Optional firmware file (or files) needed by the module
298 * format is simply firmware file name. Multiple firmware
299 * files require multiple MODULE_FIRMWARE() specifiers */
300#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
301
302#define MODULE_IMPORT_NS(ns) MODULE_INFO(import_ns, ns)
303
304struct notifier_block;
305
306enum module_state {
307 MODULE_STATE_LIVE, /* Normal state. */
308 MODULE_STATE_COMING, /* Full formed, running module_init. */
309 MODULE_STATE_GOING, /* Going away. */
310 MODULE_STATE_UNFORMED, /* Still setting it up. */
311};
312
313struct mod_tree_node {
314 struct module *mod;
315 struct latch_tree_node node;
316};
317
318enum mod_mem_type {
319 MOD_TEXT = 0,
320 MOD_DATA,
321 MOD_RODATA,
322 MOD_RO_AFTER_INIT,
323 MOD_INIT_TEXT,
324 MOD_INIT_DATA,
325 MOD_INIT_RODATA,
326
327 MOD_MEM_NUM_TYPES,
328 MOD_INVALID = -1,
329};
330
331#define mod_mem_type_is_init(type) \
332 ((type) == MOD_INIT_TEXT || \
333 (type) == MOD_INIT_DATA || \
334 (type) == MOD_INIT_RODATA)
335
336#define mod_mem_type_is_core(type) (!mod_mem_type_is_init(type))
337
338#define mod_mem_type_is_text(type) \
339 ((type) == MOD_TEXT || \
340 (type) == MOD_INIT_TEXT)
341
342#define mod_mem_type_is_data(type) (!mod_mem_type_is_text(type))
343
344#define mod_mem_type_is_core_data(type) \
345 (mod_mem_type_is_core(type) && \
346 mod_mem_type_is_data(type))
347
348#define for_each_mod_mem_type(type) \
349 for (enum mod_mem_type (type) = 0; \
350 (type) < MOD_MEM_NUM_TYPES; (type)++)
351
352#define for_class_mod_mem_type(type, class) \
353 for_each_mod_mem_type(type) \
354 if (mod_mem_type_is_##class(type))
355
356struct module_memory {
357 void *base;
358 bool is_rox;
359 unsigned int size;
360
361#ifdef CONFIG_MODULES_TREE_LOOKUP
362 struct mod_tree_node mtn;
363#endif
364};
365
366#ifdef CONFIG_MODULES_TREE_LOOKUP
367/* Only touch one cacheline for common rbtree-for-core-layout case. */
368#define __module_memory_align ____cacheline_aligned
369#else
370#define __module_memory_align
371#endif
372
373struct mod_kallsyms {
374 Elf_Sym *symtab;
375 unsigned int num_symtab;
376 char *strtab;
377 char *typetab;
378};
379
380#ifdef CONFIG_LIVEPATCH
381/**
382 * struct klp_modinfo - ELF information preserved from the livepatch module
383 *
384 * @hdr: ELF header
385 * @sechdrs: Section header table
386 * @secstrings: String table for the section headers
387 * @symndx: The symbol table section index
388 */
389struct klp_modinfo {
390 Elf_Ehdr hdr;
391 Elf_Shdr *sechdrs;
392 char *secstrings;
393 unsigned int symndx;
394};
395#endif
396
397struct module {
398 enum module_state state;
399
400 /* Member of list of modules */
401 struct list_head list;
402
403 /* Unique handle for this module */
404 char name[MODULE_NAME_LEN];
405
406#ifdef CONFIG_STACKTRACE_BUILD_ID
407 /* Module build ID */
408 unsigned char build_id[BUILD_ID_SIZE_MAX];
409#endif
410
411 /* Sysfs stuff. */
412 struct module_kobject mkobj;
413 struct module_attribute *modinfo_attrs;
414 const char *version;
415 const char *srcversion;
416 struct kobject *holders_dir;
417
418 /* Exported symbols */
419 const struct kernel_symbol *syms;
420 const u32 *crcs;
421 unsigned int num_syms;
422
423#ifdef CONFIG_ARCH_USES_CFI_TRAPS
424 s32 *kcfi_traps;
425 s32 *kcfi_traps_end;
426#endif
427
428 /* Kernel parameters. */
429#ifdef CONFIG_SYSFS
430 struct mutex param_lock;
431#endif
432 struct kernel_param *kp;
433 unsigned int num_kp;
434
435 /* GPL-only exported symbols. */
436 unsigned int num_gpl_syms;
437 const struct kernel_symbol *gpl_syms;
438 const u32 *gpl_crcs;
439 bool using_gplonly_symbols;
440
441#ifdef CONFIG_MODULE_SIG
442 /* Signature was verified. */
443 bool sig_ok;
444#endif
445
446 bool async_probe_requested;
447
448 /* Exception table */
449 unsigned int num_exentries;
450 struct exception_table_entry *extable;
451
452 /* Startup function. */
453 int (*init)(void);
454
455 struct module_memory mem[MOD_MEM_NUM_TYPES] __module_memory_align;
456
457 /* Arch-specific module values */
458 struct mod_arch_specific arch;
459
460 unsigned long taints; /* same bits as kernel:taint_flags */
461
462#ifdef CONFIG_GENERIC_BUG
463 /* Support for BUG */
464 unsigned num_bugs;
465 struct list_head bug_list;
466 struct bug_entry *bug_table;
467#endif
468
469#ifdef CONFIG_KALLSYMS
470 /* Protected by RCU and/or module_mutex: use rcu_dereference() */
471 struct mod_kallsyms __rcu *kallsyms;
472 struct mod_kallsyms core_kallsyms;
473
474 /* Section attributes */
475 struct module_sect_attrs *sect_attrs;
476
477 /* Notes attributes */
478 struct module_notes_attrs *notes_attrs;
479#endif
480
481 /* The command line arguments (may be mangled). People like
482 keeping pointers to this stuff */
483 char *args;
484
485#ifdef CONFIG_SMP
486 /* Per-cpu data. */
487 void __percpu *percpu;
488 unsigned int percpu_size;
489#endif
490 void *noinstr_text_start;
491 unsigned int noinstr_text_size;
492
493#ifdef CONFIG_TRACEPOINTS
494 unsigned int num_tracepoints;
495 tracepoint_ptr_t *tracepoints_ptrs;
496#endif
497#ifdef CONFIG_TREE_SRCU
498 unsigned int num_srcu_structs;
499 struct srcu_struct **srcu_struct_ptrs;
500#endif
501#ifdef CONFIG_BPF_EVENTS
502 unsigned int num_bpf_raw_events;
503 struct bpf_raw_event_map *bpf_raw_events;
504#endif
505#ifdef CONFIG_DEBUG_INFO_BTF_MODULES
506 unsigned int btf_data_size;
507 unsigned int btf_base_data_size;
508 void *btf_data;
509 void *btf_base_data;
510#endif
511#ifdef CONFIG_JUMP_LABEL
512 struct jump_entry *jump_entries;
513 unsigned int num_jump_entries;
514#endif
515#ifdef CONFIG_TRACING
516 unsigned int num_trace_bprintk_fmt;
517 const char **trace_bprintk_fmt_start;
518#endif
519#ifdef CONFIG_EVENT_TRACING
520 struct trace_event_call **trace_events;
521 unsigned int num_trace_events;
522 struct trace_eval_map **trace_evals;
523 unsigned int num_trace_evals;
524#endif
525#ifdef CONFIG_DYNAMIC_FTRACE
526 unsigned int num_ftrace_callsites;
527 unsigned long *ftrace_callsites;
528#endif
529#ifdef CONFIG_KPROBES
530 void *kprobes_text_start;
531 unsigned int kprobes_text_size;
532 unsigned long *kprobe_blacklist;
533 unsigned int num_kprobe_blacklist;
534#endif
535#ifdef CONFIG_HAVE_STATIC_CALL_INLINE
536 int num_static_call_sites;
537 struct static_call_site *static_call_sites;
538#endif
539#if IS_ENABLED(CONFIG_KUNIT)
540 int num_kunit_init_suites;
541 struct kunit_suite **kunit_init_suites;
542 int num_kunit_suites;
543 struct kunit_suite **kunit_suites;
544#endif
545
546
547#ifdef CONFIG_LIVEPATCH
548 bool klp; /* Is this a livepatch module? */
549 bool klp_alive;
550
551 /* ELF information */
552 struct klp_modinfo *klp_info;
553#endif
554
555#ifdef CONFIG_PRINTK_INDEX
556 unsigned int printk_index_size;
557 struct pi_entry **printk_index_start;
558#endif
559
560#ifdef CONFIG_MODULE_UNLOAD
561 /* What modules depend on me? */
562 struct list_head source_list;
563 /* What modules do I depend on? */
564 struct list_head target_list;
565
566 /* Destruction function. */
567 void (*exit)(void);
568
569 atomic_t refcnt;
570#endif
571
572#ifdef CONFIG_CONSTRUCTORS
573 /* Constructor functions. */
574 ctor_fn_t *ctors;
575 unsigned int num_ctors;
576#endif
577
578#ifdef CONFIG_FUNCTION_ERROR_INJECTION
579 struct error_injection_entry *ei_funcs;
580 unsigned int num_ei_funcs;
581#endif
582#ifdef CONFIG_DYNAMIC_DEBUG_CORE
583 struct _ddebug_info dyndbg_info;
584#endif
585} ____cacheline_aligned __randomize_layout;
586#ifndef MODULE_ARCH_INIT
587#define MODULE_ARCH_INIT {}
588#endif
589
590#ifdef CONFIG_MODULES
591
592/* Get/put a kernel symbol (calls must be symmetric) */
593void *__symbol_get(const char *symbol);
594void *__symbol_get_gpl(const char *symbol);
595#define symbol_get(x) ({ \
596 static const char __notrim[] \
597 __used __section(".no_trim_symbol") = __stringify(x); \
598 (typeof(&x))(__symbol_get(__stringify(x))); })
599
600#ifndef HAVE_ARCH_KALLSYMS_SYMBOL_VALUE
601static inline unsigned long kallsyms_symbol_value(const Elf_Sym *sym)
602{
603 return sym->st_value;
604}
605#endif
606
607/* FIXME: It'd be nice to isolate modules during init, too, so they
608 aren't used before they (may) fail. But presently too much code
609 (IDE & SCSI) require entry into the module during init.*/
610static inline bool module_is_live(struct module *mod)
611{
612 return mod->state != MODULE_STATE_GOING;
613}
614
615static inline bool module_is_coming(struct module *mod)
616{
617 return mod->state == MODULE_STATE_COMING;
618}
619
620struct module *__module_text_address(unsigned long addr);
621struct module *__module_address(unsigned long addr);
622bool is_module_address(unsigned long addr);
623bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr);
624bool is_module_percpu_address(unsigned long addr);
625bool is_module_text_address(unsigned long addr);
626
627static inline bool within_module_mem_type(unsigned long addr,
628 const struct module *mod,
629 enum mod_mem_type type)
630{
631 unsigned long base, size;
632
633 base = (unsigned long)mod->mem[type].base;
634 size = mod->mem[type].size;
635 return addr - base < size;
636}
637
638static inline bool within_module_core(unsigned long addr,
639 const struct module *mod)
640{
641 for_class_mod_mem_type(type, core) {
642 if (within_module_mem_type(addr, mod, type))
643 return true;
644 }
645 return false;
646}
647
648static inline bool within_module_init(unsigned long addr,
649 const struct module *mod)
650{
651 for_class_mod_mem_type(type, init) {
652 if (within_module_mem_type(addr, mod, type))
653 return true;
654 }
655 return false;
656}
657
658static inline bool within_module(unsigned long addr, const struct module *mod)
659{
660 return within_module_init(addr, mod) || within_module_core(addr, mod);
661}
662
663/* Search for module by name: must be in a RCU critical section. */
664struct module *find_module(const char *name);
665
666extern void __noreturn __module_put_and_kthread_exit(struct module *mod,
667 long code);
668#define module_put_and_kthread_exit(code) __module_put_and_kthread_exit(THIS_MODULE, code)
669
670#ifdef CONFIG_MODULE_UNLOAD
671int module_refcount(struct module *mod);
672void __symbol_put(const char *symbol);
673#define symbol_put(x) __symbol_put(__stringify(x))
674void symbol_put_addr(void *addr);
675
676/* Sometimes we know we already have a refcount, and it's easier not
677 to handle the error case (which only happens with rmmod --wait). */
678extern void __module_get(struct module *module);
679
680/**
681 * try_module_get() - take module refcount unless module is being removed
682 * @module: the module we should check for
683 *
684 * Only try to get a module reference count if the module is not being removed.
685 * This call will fail if the module is in the process of being removed.
686 *
687 * Care must also be taken to ensure the module exists and is alive prior to
688 * usage of this call. This can be gauranteed through two means:
689 *
690 * 1) Direct protection: you know an earlier caller must have increased the
691 * module reference through __module_get(). This can typically be achieved
692 * by having another entity other than the module itself increment the
693 * module reference count.
694 *
695 * 2) Implied protection: there is an implied protection against module
696 * removal. An example of this is the implied protection used by kernfs /
697 * sysfs. The sysfs store / read file operations are guaranteed to exist
698 * through the use of kernfs's active reference (see kernfs_active()) and a
699 * sysfs / kernfs file removal cannot happen unless the same file is not
700 * active. Therefore, if a sysfs file is being read or written to the module
701 * which created it must still exist. It is therefore safe to use
702 * try_module_get() on module sysfs store / read ops.
703 *
704 * One of the real values to try_module_get() is the module_is_live() check
705 * which ensures that the caller of try_module_get() can yield to userspace
706 * module removal requests and gracefully fail if the module is on its way out.
707 *
708 * Returns true if the reference count was successfully incremented.
709 */
710extern bool try_module_get(struct module *module);
711
712/**
713 * module_put() - release a reference count to a module
714 * @module: the module we should release a reference count for
715 *
716 * If you successfully bump a reference count to a module with try_module_get(),
717 * when you are finished you must call module_put() to release that reference
718 * count.
719 */
720extern void module_put(struct module *module);
721
722#else /*!CONFIG_MODULE_UNLOAD*/
723static inline bool try_module_get(struct module *module)
724{
725 return !module || module_is_live(module);
726}
727static inline void module_put(struct module *module)
728{
729}
730static inline void __module_get(struct module *module)
731{
732}
733#define symbol_put(x) do { } while (0)
734#define symbol_put_addr(p) do { } while (0)
735
736#endif /* CONFIG_MODULE_UNLOAD */
737
738/* This is a #define so the string doesn't get put in every .o file */
739#define module_name(mod) \
740({ \
741 struct module *__mod = (mod); \
742 __mod ? __mod->name : "kernel"; \
743})
744
745static inline const unsigned char *module_buildid(struct module *mod)
746{
747#ifdef CONFIG_STACKTRACE_BUILD_ID
748 return mod->build_id;
749#else
750 return NULL;
751#endif
752}
753
754/* Dereference module function descriptor */
755void *dereference_module_function_descriptor(struct module *mod, void *ptr);
756
757int register_module_notifier(struct notifier_block *nb);
758int unregister_module_notifier(struct notifier_block *nb);
759
760extern void print_modules(void);
761
762static inline bool module_requested_async_probing(struct module *module)
763{
764 return module && module->async_probe_requested;
765}
766
767static inline bool is_livepatch_module(struct module *mod)
768{
769#ifdef CONFIG_LIVEPATCH
770 return mod->klp;
771#else
772 return false;
773#endif
774}
775
776void module_for_each_mod(int(*func)(struct module *mod, void *data), void *data);
777
778#else /* !CONFIG_MODULES... */
779
780static inline struct module *__module_address(unsigned long addr)
781{
782 return NULL;
783}
784
785static inline struct module *__module_text_address(unsigned long addr)
786{
787 return NULL;
788}
789
790static inline bool is_module_address(unsigned long addr)
791{
792 return false;
793}
794
795static inline bool is_module_percpu_address(unsigned long addr)
796{
797 return false;
798}
799
800static inline bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr)
801{
802 return false;
803}
804
805static inline bool is_module_text_address(unsigned long addr)
806{
807 return false;
808}
809
810static inline bool within_module_core(unsigned long addr,
811 const struct module *mod)
812{
813 return false;
814}
815
816static inline bool within_module_init(unsigned long addr,
817 const struct module *mod)
818{
819 return false;
820}
821
822static inline bool within_module(unsigned long addr, const struct module *mod)
823{
824 return false;
825}
826
827/* Get/put a kernel symbol (calls should be symmetric) */
828#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak,visibility("hidden"))); &(x); })
829#define symbol_put(x) do { } while (0)
830#define symbol_put_addr(x) do { } while (0)
831
832static inline void __module_get(struct module *module)
833{
834}
835
836static inline bool try_module_get(struct module *module)
837{
838 return true;
839}
840
841static inline void module_put(struct module *module)
842{
843}
844
845#define module_name(mod) "kernel"
846
847static inline int register_module_notifier(struct notifier_block *nb)
848{
849 /* no events will happen anyway, so this can always succeed */
850 return 0;
851}
852
853static inline int unregister_module_notifier(struct notifier_block *nb)
854{
855 return 0;
856}
857
858#define module_put_and_kthread_exit(code) kthread_exit(code)
859
860static inline void print_modules(void)
861{
862}
863
864static inline bool module_requested_async_probing(struct module *module)
865{
866 return false;
867}
868
869
870/* Dereference module function descriptor */
871static inline
872void *dereference_module_function_descriptor(struct module *mod, void *ptr)
873{
874 return ptr;
875}
876
877static inline bool module_is_coming(struct module *mod)
878{
879 return false;
880}
881
882static inline void module_for_each_mod(int(*func)(struct module *mod, void *data), void *data)
883{
884}
885#endif /* CONFIG_MODULES */
886
887#ifdef CONFIG_SYSFS
888extern struct kset *module_kset;
889extern const struct kobj_type module_ktype;
890#endif /* CONFIG_SYSFS */
891
892#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
893
894/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
895
896#define __MODULE_STRING(x) __stringify(x)
897
898#ifdef CONFIG_GENERIC_BUG
899void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
900 struct module *);
901void module_bug_cleanup(struct module *);
902
903#else /* !CONFIG_GENERIC_BUG */
904
905static inline void module_bug_finalize(const Elf_Ehdr *hdr,
906 const Elf_Shdr *sechdrs,
907 struct module *mod)
908{
909}
910static inline void module_bug_cleanup(struct module *mod) {}
911#endif /* CONFIG_GENERIC_BUG */
912
913#ifdef CONFIG_MITIGATION_RETPOLINE
914extern bool retpoline_module_ok(bool has_retpoline);
915#else
916static inline bool retpoline_module_ok(bool has_retpoline)
917{
918 return true;
919}
920#endif
921
922#ifdef CONFIG_MODULE_SIG
923bool is_module_sig_enforced(void);
924
925void set_module_sig_enforced(void);
926
927static inline bool module_sig_ok(struct module *module)
928{
929 return module->sig_ok;
930}
931#else /* !CONFIG_MODULE_SIG */
932static inline bool is_module_sig_enforced(void)
933{
934 return false;
935}
936
937static inline void set_module_sig_enforced(void)
938{
939}
940
941static inline bool module_sig_ok(struct module *module)
942{
943 return true;
944}
945#endif /* CONFIG_MODULE_SIG */
946
947#if defined(CONFIG_MODULES) && defined(CONFIG_KALLSYMS)
948int module_kallsyms_on_each_symbol(const char *modname,
949 int (*fn)(void *, const char *, unsigned long),
950 void *data);
951
952/* For kallsyms to ask for address resolution. namebuf should be at
953 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
954 * found, otherwise NULL.
955 */
956int module_address_lookup(unsigned long addr,
957 unsigned long *symbolsize,
958 unsigned long *offset,
959 char **modname, const unsigned char **modbuildid,
960 char *namebuf);
961int lookup_module_symbol_name(unsigned long addr, char *symname);
962int lookup_module_symbol_attrs(unsigned long addr,
963 unsigned long *size,
964 unsigned long *offset,
965 char *modname,
966 char *name);
967
968/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
969 * symnum out of range.
970 */
971int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
972 char *name, char *module_name, int *exported);
973
974/* Look for this name: can be of form module:name. */
975unsigned long module_kallsyms_lookup_name(const char *name);
976
977unsigned long find_kallsyms_symbol_value(struct module *mod, const char *name);
978
979#else /* CONFIG_MODULES && CONFIG_KALLSYMS */
980
981static inline int module_kallsyms_on_each_symbol(const char *modname,
982 int (*fn)(void *, const char *, unsigned long),
983 void *data)
984{
985 return -EOPNOTSUPP;
986}
987
988/* For kallsyms to ask for address resolution. NULL means not found. */
989static inline int module_address_lookup(unsigned long addr,
990 unsigned long *symbolsize,
991 unsigned long *offset,
992 char **modname,
993 const unsigned char **modbuildid,
994 char *namebuf)
995{
996 return 0;
997}
998
999static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
1000{
1001 return -ERANGE;
1002}
1003
1004static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
1005 char *type, char *name,
1006 char *module_name, int *exported)
1007{
1008 return -ERANGE;
1009}
1010
1011static inline unsigned long module_kallsyms_lookup_name(const char *name)
1012{
1013 return 0;
1014}
1015
1016static inline unsigned long find_kallsyms_symbol_value(struct module *mod,
1017 const char *name)
1018{
1019 return 0;
1020}
1021
1022#endif /* CONFIG_MODULES && CONFIG_KALLSYMS */
1023
1024/* Define __free(module_put) macro for struct module *. */
1025DEFINE_FREE(module_put, struct module *, if (_T) module_put(_T))
1026
1027#endif /* _LINUX_MODULE_H */