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