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