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