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