projects/linux·blob v4.19-rc4 · refs

841 lines · 22.6 KiB

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