module.h 22.8 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
13
#ifndef _LINUX_MODULE_H
#define _LINUX_MODULE_H
/*
 * Dynamic loading of modules into the kernel.
 *
 * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
 * Rewritten again by Rusty Russell, 2002
 */
#include <linux/list.h>
#include <linux/stat.h>
#include <linux/compiler.h>
#include <linux/cache.h>
#include <linux/kmod.h>
14
#include <linux/init.h>
Linus Torvalds's avatar
Linus Torvalds committed
15
16
17
18
#include <linux/elf.h>
#include <linux/stringify.h>
#include <linux/kobject.h>
#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>
Linus Torvalds's avatar
Linus Torvalds committed
24

25
#include <linux/percpu.h>
Linus Torvalds's avatar
Linus Torvalds committed
26
27
#include <asm/module.h>

28
29
30
/* In stripped ARM and x86-64 modules, ~ is surprisingly rare. */
#define MODULE_SIG_STRING "~Module signature appended~\n"

Linus Torvalds's avatar
Linus Torvalds committed
31
32
33
/* Not Yet Implemented */
#define MODULE_SUPPORTED_DEVICE(name)

34
#define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
Linus Torvalds's avatar
Linus Torvalds committed
35

Seunghun Lee's avatar
Seunghun Lee committed
36
struct modversion_info {
Linus Torvalds's avatar
Linus Torvalds committed
37
38
39
40
41
	unsigned long crc;
	char name[MODULE_NAME_LEN];
};

struct module;
42
struct exception_table_entry;
Linus Torvalds's avatar
Linus Torvalds committed
43

44
45
46
47
48
struct module_kobject {
	struct kobject kobj;
	struct module *mod;
	struct kobject *drivers_dir;
	struct module_param_attrs *mp;
49
	struct completion *kobj_completion;
50
} __randomize_layout;
51

Linus Torvalds's avatar
Linus Torvalds committed
52
struct module_attribute {
53
54
55
56
	struct attribute attr;
	ssize_t (*show)(struct module_attribute *, struct module_kobject *,
			char *);
	ssize_t (*store)(struct module_attribute *, struct module_kobject *,
Linus Torvalds's avatar
Linus Torvalds committed
57
			 const char *, size_t count);
58
59
60
	void (*setup)(struct module *, const char *);
	int (*test)(struct module *);
	void (*free)(struct module *);
Linus Torvalds's avatar
Linus Torvalds committed
61
62
};

63
64
65
66
struct module_version_attribute {
	struct module_attribute mattr;
	const char *module_name;
	const char *version;
67
} __attribute__ ((__aligned__(sizeof(void *))));
68

69
extern ssize_t __modver_version_show(struct module_attribute *,
70
				     struct module_kobject *, char *);
71

72
extern struct module_attribute module_uevent;
Linus Torvalds's avatar
Linus Torvalds committed
73
74
75
76
77

/* These are either module local, or the kernel's dummy ones. */
extern int init_module(void);
extern void cleanup_module(void);

78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#ifndef MODULE
/**
 * module_init() - driver initialization entry point
 * @x: function to be run at kernel boot time or module insertion
 *
 * module_init() will either be called during do_initcalls() (if
 * builtin) or at module insertion time (if a module).  There can only
 * be one per module.
 */
#define module_init(x)	__initcall(x);

/**
 * module_exit() - driver exit entry point
 * @x: function to be run when driver is removed
 *
 * module_exit() will wrap the driver clean-up code
 * with cleanup_module() when used with rmmod when
 * the driver is a module.  If the driver is statically
 * compiled into the kernel, module_exit() has no effect.
 * There can only be one per module.
 */
#define module_exit(x)	__exitcall(x);

#else /* MODULE */

/*
 * In most cases loadable modules do not need custom
 * initcall levels. There are still some valid cases where
 * a driver may be needed early if built in, and does not
 * matter when built as a loadable module. Like bus
 * snooping debug drivers.
 */
#define early_initcall(fn)		module_init(fn)
#define core_initcall(fn)		module_init(fn)
#define core_initcall_sync(fn)		module_init(fn)
#define postcore_initcall(fn)		module_init(fn)
#define postcore_initcall_sync(fn)	module_init(fn)
#define arch_initcall(fn)		module_init(fn)
#define subsys_initcall(fn)		module_init(fn)
#define subsys_initcall_sync(fn)	module_init(fn)
#define fs_initcall(fn)			module_init(fn)
#define fs_initcall_sync(fn)		module_init(fn)
#define rootfs_initcall(fn)		module_init(fn)
#define device_initcall(fn)		module_init(fn)
#define device_initcall_sync(fn)	module_init(fn)
#define late_initcall(fn)		module_init(fn)
#define late_initcall_sync(fn)		module_init(fn)

#define console_initcall(fn)		module_init(fn)

/* Each module must use one module_init(). */
#define module_init(initfn)					\
130
	static inline initcall_t __maybe_unused __inittest(void)		\
131
132
133
134
135
	{ return initfn; }					\
	int init_module(void) __attribute__((alias(#initfn)));

/* This is only required if you want to be unloadable. */
#define module_exit(exitfn)					\
136
	static inline exitcall_t __maybe_unused __exittest(void)		\
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
	{ return exitfn; }					\
	void cleanup_module(void) __attribute__((alias(#exitfn)));

#endif

/* This means "can be init if no module support, otherwise module load
   may call it." */
#ifdef CONFIG_MODULES
#define __init_or_module
#define __initdata_or_module
#define __initconst_or_module
#define __INIT_OR_MODULE	.text
#define __INITDATA_OR_MODULE	.data
#define __INITRODATA_OR_MODULE	.section ".rodata","a",%progbits
#else
#define __init_or_module __init
#define __initdata_or_module __initdata
#define __initconst_or_module __initconst
#define __INIT_OR_MODULE __INIT
#define __INITDATA_OR_MODULE __INITDATA
#define __INITRODATA_OR_MODULE __INITRODATA
#endif /*CONFIG_MODULES*/

Linus Torvalds's avatar
Linus Torvalds committed
160
161
162
163
164
165
/* Generic info of form tag = "info" */
#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)

/* For userspace: you can also call me... */
#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)

166
167
168
169
170
/* Soft module dependencies. See man modprobe.d for details.
 * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz")
 */
#define MODULE_SOFTDEP(_softdep) MODULE_INFO(softdep, _softdep)

Linus Torvalds's avatar
Linus Torvalds committed
171
172
173
174
175
176
177
178
179
/*
 * The following license idents are currently accepted as indicating free
 * software modules
 *
 *	"GPL"				[GNU Public License v2 or later]
 *	"GPL v2"			[GNU Public License v2]
 *	"GPL and additional rights"	[GNU Public License v2 rights and more]
 *	"Dual BSD/GPL"			[GNU Public License v2
 *					 or BSD license choice]
180
181
 *	"Dual MIT/GPL"			[GNU Public License v2
 *					 or MIT license choice]
Linus Torvalds's avatar
Linus Torvalds committed
182
183
184
185
186
187
188
189
190
191
192
193
 *	"Dual MPL/GPL"			[GNU Public License v2
 *					 or Mozilla license choice]
 *
 * The following other idents are available
 *
 *	"Proprietary"			[Non free products]
 *
 * There are dual licensed components, but when running with Linux it is the
 * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
 * is a GPL combined work.
 *
 * This exists for several reasons
Seunghun Lee's avatar
Seunghun Lee committed
194
 * 1.	So modinfo can show license info for users wanting to vet their setup
Linus Torvalds's avatar
Linus Torvalds committed
195
196
197
198
199
200
 *	is free
 * 2.	So the community can ignore bug reports including proprietary modules
 * 3.	So vendors can do likewise based on their own policies
 */
#define MODULE_LICENSE(_license) MODULE_INFO(license, _license)

201
202
203
204
/*
 * Author(s), use "Name <email>" or just "Name", for multiple
 * authors use multiple MODULE_AUTHOR() statements/lines.
 */
Linus Torvalds's avatar
Linus Torvalds committed
205
#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
Seunghun Lee's avatar
Seunghun Lee committed
206

Linus Torvalds's avatar
Linus Torvalds committed
207
208
209
/* What your module does. */
#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)

210
211
212
#ifdef MODULE
/* Creates an alias so file2alias.c can find device table. */
#define MODULE_DEVICE_TABLE(type, name)					\
213
extern typeof(name) __mod_##type##__##name##_device_table		\
214
215
216
217
  __attribute__ ((unused, alias(__stringify(name))))
#else  /* !MODULE */
#define MODULE_DEVICE_TABLE(type, name)
#endif
Linus Torvalds's avatar
Linus Torvalds committed
218
219

/* Version of form [<epoch>:]<version>[-<extra-version>].
Seunghun Lee's avatar
Seunghun Lee committed
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 * Or for CVS/RCS ID version, everything but the number is stripped.
 * <epoch>: A (small) unsigned integer which allows you to start versions
 * anew. If not mentioned, it's zero.  eg. "2:1.0" is after
 * "1:2.0".

 * <version>: The <version> may contain only alphanumerics and the
 * character `.'.  Ordered by numeric sort for numeric parts,
 * ascii sort for ascii parts (as per RPM or DEB algorithm).

 * <extraversion>: Like <version>, but inserted for local
 * customizations, eg "rh3" or "rusty1".

 * Using this automatically adds a checksum of the .c files and the
 * local headers in "srcversion".
 */
235

236
#if defined(MODULE) || !defined(CONFIG_SYSFS)
Linus Torvalds's avatar
Linus Torvalds committed
237
#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
238
239
#else
#define MODULE_VERSION(_version)					\
240
	static struct module_version_attribute ___modver_attr = {	\
241
242
243
244
245
246
247
248
249
		.mattr	= {						\
			.attr	= {					\
				.name	= "version",			\
				.mode	= S_IRUGO,			\
			},						\
			.show	= __modver_version_show,		\
		},							\
		.module_name	= KBUILD_MODNAME,			\
		.version	= _version,				\
250
251
252
253
	};								\
	static const struct module_version_attribute			\
	__used __attribute__ ((__section__ ("__modver")))		\
	* __moduleparam_const __modver_attr = &___modver_attr
254
#endif
Linus Torvalds's avatar
Linus Torvalds committed
255

256
257
258
259
260
/* Optional firmware file (or files) needed by the module
 * format is simply firmware file name.  Multiple firmware
 * files require multiple MODULE_FIRMWARE() specifiers */
#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)

Linus Torvalds's avatar
Linus Torvalds committed
261
262
263
264
struct notifier_block;

#ifdef CONFIG_MODULES

Dave Young's avatar
Dave Young committed
265
extern int modules_disabled; /* for sysctl */
Linus Torvalds's avatar
Linus Torvalds committed
266
267
268
/* Get/put a kernel symbol (calls must be symmetric) */
void *__symbol_get(const char *symbol);
void *__symbol_get_gpl(const char *symbol);
269
#define symbol_get(x) ((typeof(&x))(__symbol_get(__stringify(x))))
Linus Torvalds's avatar
Linus Torvalds committed
270

271
272
273
274
275
276
277
/* modules using other modules: kdb wants to see this. */
struct module_use {
	struct list_head source_list;
	struct list_head target_list;
	struct module *source, *target;
};

278
279
280
281
282
enum module_state {
	MODULE_STATE_LIVE,	/* Normal state. */
	MODULE_STATE_COMING,	/* Full formed, running module_init. */
	MODULE_STATE_GOING,	/* Going away. */
	MODULE_STATE_UNFORMED,	/* Still setting it up. */
Linus Torvalds's avatar
Linus Torvalds committed
283
284
};

285
286
287
288
289
struct mod_tree_node {
	struct module *mod;
	struct latch_tree_node node;
};

290
291
292
293
294
295
296
297
298
struct module_layout {
	/* The actual code + data. */
	void *base;
	/* Total size. */
	unsigned int size;
	/* The size of the executable code.  */
	unsigned int text_size;
	/* Size of RO section of the module (text+rodata) */
	unsigned int ro_size;
299
300
	/* Size of RO after init section */
	unsigned int ro_after_init_size;
301
302
303
304
305
306
307
308
309
310
311
312
313

#ifdef CONFIG_MODULES_TREE_LOOKUP
	struct mod_tree_node mtn;
#endif
};

#ifdef CONFIG_MODULES_TREE_LOOKUP
/* Only touch one cacheline for common rbtree-for-core-layout case. */
#define __module_layout_align ____cacheline_aligned
#else
#define __module_layout_align
#endif

314
315
316
317
318
319
struct mod_kallsyms {
	Elf_Sym *symtab;
	unsigned int num_symtab;
	char *strtab;
};

320
321
322
323
324
325
326
327
328
#ifdef CONFIG_LIVEPATCH
struct klp_modinfo {
	Elf_Ehdr hdr;
	Elf_Shdr *sechdrs;
	char *secstrings;
	unsigned int symndx;
};
#endif

Seunghun Lee's avatar
Seunghun Lee committed
329
struct module {
Linus Torvalds's avatar
Linus Torvalds committed
330
331
332
333
334
335
336
337
338
339
	enum module_state state;

	/* Member of list of modules */
	struct list_head list;

	/* Unique handle for this module */
	char name[MODULE_NAME_LEN];

	/* Sysfs stuff. */
	struct module_kobject mkobj;
340
	struct module_attribute *modinfo_attrs;
341
342
	const char *version;
	const char *srcversion;
Kay Sievers's avatar
Kay Sievers committed
343
	struct kobject *holders_dir;
Linus Torvalds's avatar
Linus Torvalds committed
344
345
346

	/* Exported symbols */
	const struct kernel_symbol *syms;
347
	const s32 *crcs;
348
	unsigned int num_syms;
Linus Torvalds's avatar
Linus Torvalds committed
349

350
	/* Kernel parameters. */
351
#ifdef CONFIG_SYSFS
352
	struct mutex param_lock;
353
#endif
354
355
356
	struct kernel_param *kp;
	unsigned int num_kp;

Linus Torvalds's avatar
Linus Torvalds committed
357
358
	/* GPL-only exported symbols. */
	unsigned int num_gpl_syms;
359
	const struct kernel_symbol *gpl_syms;
360
	const s32 *gpl_crcs;
Linus Torvalds's avatar
Linus Torvalds committed
361

362
#ifdef CONFIG_UNUSED_SYMBOLS
363
364
	/* unused exported symbols. */
	const struct kernel_symbol *unused_syms;
365
	const s32 *unused_crcs;
366
367
	unsigned int num_unused_syms;

368
369
	/* GPL-only, unused exported symbols. */
	unsigned int num_unused_gpl_syms;
370
	const struct kernel_symbol *unused_gpl_syms;
371
	const s32 *unused_gpl_crcs;
372
#endif
373

374
375
376
377
378
#ifdef CONFIG_MODULE_SIG
	/* Signature was verified. */
	bool sig_ok;
#endif

379
380
	bool async_probe_requested;

381
382
	/* symbols that will be GPL-only in the near future. */
	const struct kernel_symbol *gpl_future_syms;
383
	const s32 *gpl_future_crcs;
384
	unsigned int num_gpl_future_syms;
385

Linus Torvalds's avatar
Linus Torvalds committed
386
387
	/* Exception table */
	unsigned int num_exentries;
Rusty Russell's avatar
Rusty Russell committed
388
	struct exception_table_entry *extable;
Linus Torvalds's avatar
Linus Torvalds committed
389
390
391
392

	/* Startup function. */
	int (*init)(void);

393
394
395
	/* Core layout: rbtree is accessed frequently, so keep together. */
	struct module_layout core_layout __module_layout_align;
	struct module_layout init_layout;
396

Linus Torvalds's avatar
Linus Torvalds committed
397
398
399
	/* Arch-specific module values */
	struct mod_arch_specific arch;

400
	unsigned long taints;	/* same bits as kernel:taint_flags */
401

402
403
#ifdef CONFIG_GENERIC_BUG
	/* Support for BUG */
404
	unsigned num_bugs;
405
406
	struct list_head bug_list;
	struct bug_entry *bug_table;
Linus Torvalds's avatar
Linus Torvalds committed
407
408
409
#endif

#ifdef CONFIG_KALLSYMS
410
411
412
	/* Protected by RCU and/or module_mutex: use rcu_dereference() */
	struct mod_kallsyms *kallsyms;
	struct mod_kallsyms core_kallsyms;
413

Linus Torvalds's avatar
Linus Torvalds committed
414
415
	/* Section attributes */
	struct module_sect_attrs *sect_attrs;
Roland McGrath's avatar
Roland McGrath committed
416
417
418

	/* Notes attributes */
	struct module_notes_attrs *notes_attrs;
Linus Torvalds's avatar
Linus Torvalds committed
419
420
#endif

421
422
423
424
	/* The command line arguments (may be mangled).  People like
	   keeping pointers to this stuff */
	char *args;

425
#ifdef CONFIG_SMP
Linus Torvalds's avatar
Linus Torvalds committed
426
	/* Per-cpu data. */
427
428
429
	void __percpu *percpu;
	unsigned int percpu_size;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
430

431
432
#ifdef CONFIG_TRACEPOINTS
	unsigned int num_tracepoints;
433
	tracepoint_ptr_t *tracepoints_ptrs;
434
#endif
435
436
437
438
#ifdef CONFIG_BPF_EVENTS
	unsigned int num_bpf_raw_events;
	struct bpf_raw_event_map *bpf_raw_events;
#endif
439
#ifdef CONFIG_JUMP_LABEL
440
441
442
	struct jump_entry *jump_entries;
	unsigned int num_jump_entries;
#endif
443
#ifdef CONFIG_TRACING
Lai Jiangshan's avatar
Lai Jiangshan committed
444
	unsigned int num_trace_bprintk_fmt;
445
	const char **trace_bprintk_fmt_start;
Lai Jiangshan's avatar
Lai Jiangshan committed
446
#endif
447
#ifdef CONFIG_EVENT_TRACING
448
	struct trace_event_call **trace_events;
449
	unsigned int num_trace_events;
450
451
	struct trace_eval_map **trace_evals;
	unsigned int num_trace_evals;
452
#endif
453
454
#ifdef CONFIG_FTRACE_MCOUNT_RECORD
	unsigned int num_ftrace_callsites;
455
	unsigned long *ftrace_callsites;
456
#endif
Lai Jiangshan's avatar
Lai Jiangshan committed
457

458
#ifdef CONFIG_LIVEPATCH
459
	bool klp; /* Is this a livepatch module? */
460
	bool klp_alive;
461
462
463

	/* Elf information */
	struct klp_modinfo *klp_info;
464
465
#endif

466
467
#ifdef CONFIG_MODULE_UNLOAD
	/* What modules depend on me? */
468
469
470
	struct list_head source_list;
	/* What modules do I depend on? */
	struct list_head target_list;
471
472
473
474

	/* Destruction function. */
	void (*exit)(void);

475
	atomic_t refcnt;
476
#endif
477
478
479
480
481
482

#ifdef CONFIG_CONSTRUCTORS
	/* Constructor functions. */
	ctor_fn_t *ctors;
	unsigned int num_ctors;
#endif
483

484
#ifdef CONFIG_FUNCTION_ERROR_INJECTION
485
	struct error_injection_entry *ei_funcs;
486
	unsigned int num_ei_funcs;
487
#endif
488
} ____cacheline_aligned __randomize_layout;
489
490
491
#ifndef MODULE_ARCH_INIT
#define MODULE_ARCH_INIT {}
#endif
Linus Torvalds's avatar
Linus Torvalds committed
492

493
494
495
496
497
498
499
#ifndef HAVE_ARCH_KALLSYMS_SYMBOL_VALUE
static inline unsigned long kallsyms_symbol_value(const Elf_Sym *sym)
{
	return sym->st_value;
}
#endif

500
501
extern struct mutex module_mutex;

Linus Torvalds's avatar
Linus Torvalds committed
502
503
504
/* FIXME: It'd be nice to isolate modules during init, too, so they
   aren't used before they (may) fail.  But presently too much code
   (IDE & SCSI) require entry into the module during init.*/
505
static inline bool module_is_live(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
506
507
508
509
510
{
	return mod->state != MODULE_STATE_GOING;
}

struct module *__module_text_address(unsigned long addr);
Rusty Russell's avatar
Rusty Russell committed
511
512
struct module *__module_address(unsigned long addr);
bool is_module_address(unsigned long addr);
513
bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr);
514
bool is_module_percpu_address(unsigned long addr);
Rusty Russell's avatar
Rusty Russell committed
515
bool is_module_text_address(unsigned long addr);
Linus Torvalds's avatar
Linus Torvalds committed
516

517
518
static inline bool within_module_core(unsigned long addr,
				      const struct module *mod)
519
{
520
521
	return (unsigned long)mod->core_layout.base <= addr &&
	       addr < (unsigned long)mod->core_layout.base + mod->core_layout.size;
522
523
}

524
525
static inline bool within_module_init(unsigned long addr,
				      const struct module *mod)
526
{
527
528
	return (unsigned long)mod->init_layout.base <= addr &&
	       addr < (unsigned long)mod->init_layout.base + mod->init_layout.size;
529
530
}

531
static inline bool within_module(unsigned long addr, const struct module *mod)
532
533
534
535
{
	return within_module_init(addr, mod) || within_module_core(addr, mod);
}

536
537
538
539
540
/* Search for module by name: must hold module_mutex. */
struct module *find_module(const char *name);

struct symsearch {
	const struct kernel_symbol *start, *stop;
541
	const s32 *crcs;
542
543
544
545
546
547
548
549
	enum {
		NOT_GPL_ONLY,
		GPL_ONLY,
		WILL_BE_GPL_ONLY,
	} licence;
	bool unused;
};

550
551
552
553
554
/*
 * Search for an exported symbol by name.
 *
 * Must be called with module_mutex held or preemption disabled.
 */
555
556
const struct kernel_symbol *find_symbol(const char *name,
					struct module **owner,
557
					const s32 **crc,
558
559
560
					bool gplok,
					bool warn);

561
562
563
564
565
/*
 * Walk the exported symbol table
 *
 * Must be called with module_mutex held or preemption disabled.
 */
566
567
568
bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
				    struct module *owner,
				    void *data), void *data);
569

570
/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
Linus Torvalds's avatar
Linus Torvalds committed
571
   symnum out of range. */
572
573
int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
			char *name, char *module_name, int *exported);
Linus Torvalds's avatar
Linus Torvalds committed
574
575
576
577

/* Look for this name: can be of form module:name. */
unsigned long module_kallsyms_lookup_name(const char *name);

578
579
580
581
int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
					     struct module *, unsigned long),
				   void *data);

582
583
extern void __noreturn __module_put_and_exit(struct module *mod,
			long code);
584
#define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code)
Linus Torvalds's avatar
Linus Torvalds committed
585
586

#ifdef CONFIG_MODULE_UNLOAD
587
int module_refcount(struct module *mod);
Linus Torvalds's avatar
Linus Torvalds committed
588
void __symbol_put(const char *symbol);
589
#define symbol_put(x) __symbol_put(__stringify(x))
Linus Torvalds's avatar
Linus Torvalds committed
590
591
592
593
void symbol_put_addr(void *addr);

/* Sometimes we know we already have a refcount, and it's easier not
   to handle the error case (which only happens with rmmod --wait). */
594
extern void __module_get(struct module *module);
595

596
597
598
/* This is the Right Way to get a module: if it fails, it's being removed,
 * so pretend it's not there. */
extern bool try_module_get(struct module *module);
Linus Torvalds's avatar
Linus Torvalds committed
599

Al Viro's avatar
Al Viro committed
600
extern void module_put(struct module *module);
Linus Torvalds's avatar
Linus Torvalds committed
601
602

#else /*!CONFIG_MODULE_UNLOAD*/
603
static inline bool try_module_get(struct module *module)
Linus Torvalds's avatar
Linus Torvalds committed
604
605
606
607
608
609
610
611
612
{
	return !module || module_is_live(module);
}
static inline void module_put(struct module *module)
{
}
static inline void __module_get(struct module *module)
{
}
Seunghun Lee's avatar
Seunghun Lee committed
613
614
#define symbol_put(x) do { } while (0)
#define symbol_put_addr(p) do { } while (0)
Linus Torvalds's avatar
Linus Torvalds committed
615
616

#endif /* CONFIG_MODULE_UNLOAD */
617
int ref_module(struct module *a, struct module *b);
Linus Torvalds's avatar
Linus Torvalds committed
618
619
620
621
622
623
624
625

/* This is a #define so the string doesn't get put in every .o file */
#define module_name(mod)			\
({						\
	struct module *__mod = (mod);		\
	__mod ? __mod->name : "kernel";		\
})

626
627
628
/* Dereference module function descriptor */
void *dereference_module_function_descriptor(struct module *mod, void *ptr);

629
630
631
/* For kallsyms to ask for address resolution.  namebuf should be at
 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
 * found, otherwise NULL. */
632
const char *module_address_lookup(unsigned long addr,
633
634
635
636
			    unsigned long *symbolsize,
			    unsigned long *offset,
			    char **modname,
			    char *namebuf);
637
int lookup_module_symbol_name(unsigned long addr, char *symname);
638
int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
Linus Torvalds's avatar
Linus Torvalds committed
639

Seunghun Lee's avatar
Seunghun Lee committed
640
641
int register_module_notifier(struct notifier_block *nb);
int unregister_module_notifier(struct notifier_block *nb);
Linus Torvalds's avatar
Linus Torvalds committed
642
643
644

extern void print_modules(void);

645
646
647
648
649
static inline bool module_requested_async_probing(struct module *module)
{
	return module && module->async_probe_requested;
}

650
651
652
653
654
655
656
657
658
659
660
661
#ifdef CONFIG_LIVEPATCH
static inline bool is_livepatch_module(struct module *mod)
{
	return mod->klp;
}
#else /* !CONFIG_LIVEPATCH */
static inline bool is_livepatch_module(struct module *mod)
{
	return false;
}
#endif /* CONFIG_LIVEPATCH */

662
663
bool is_module_sig_enforced(void);

Linus Torvalds's avatar
Linus Torvalds committed
664
665
#else /* !CONFIG_MODULES... */

Rusty Russell's avatar
Rusty Russell committed
666
667
668
669
670
static inline struct module *__module_address(unsigned long addr)
{
	return NULL;
}

Linus Torvalds's avatar
Linus Torvalds committed
671
672
673
674
675
static inline struct module *__module_text_address(unsigned long addr)
{
	return NULL;
}

Rusty Russell's avatar
Rusty Russell committed
676
677
678
679
680
static inline bool is_module_address(unsigned long addr)
{
	return false;
}

681
682
683
684
685
static inline bool is_module_percpu_address(unsigned long addr)
{
	return false;
}

686
687
688
689
690
static inline bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr)
{
	return false;
}

Rusty Russell's avatar
Rusty Russell committed
691
static inline bool is_module_text_address(unsigned long addr)
692
{
Rusty Russell's avatar
Rusty Russell committed
693
	return false;
694
695
}

Linus Torvalds's avatar
Linus Torvalds committed
696
697
/* Get/put a kernel symbol (calls should be symmetric) */
#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
Seunghun Lee's avatar
Seunghun Lee committed
698
699
#define symbol_put(x) do { } while (0)
#define symbol_put_addr(x) do { } while (0)
Linus Torvalds's avatar
Linus Torvalds committed
700
701
702
703
704

static inline void __module_get(struct module *module)
{
}

705
static inline bool try_module_get(struct module *module)
Linus Torvalds's avatar
Linus Torvalds committed
706
{
707
	return true;
Linus Torvalds's avatar
Linus Torvalds committed
708
709
710
711
712
713
714
715
716
}

static inline void module_put(struct module *module)
{
}

#define module_name(mod) "kernel"

/* For kallsyms to ask for address resolution.  NULL means not found. */
717
static inline const char *module_address_lookup(unsigned long addr,
718
719
720
721
					  unsigned long *symbolsize,
					  unsigned long *offset,
					  char **modname,
					  char *namebuf)
Linus Torvalds's avatar
Linus Torvalds committed
722
723
724
725
{
	return NULL;
}

726
727
728
729
730
static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
{
	return -ERANGE;
}

731
732
733
734
735
static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
{
	return -ERANGE;
}

736
737
738
static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
					char *type, char *name,
					char *module_name, int *exported)
Linus Torvalds's avatar
Linus Torvalds committed
739
{
740
	return -ERANGE;
Linus Torvalds's avatar
Linus Torvalds committed
741
742
743
744
745
746
747
}

static inline unsigned long module_kallsyms_lookup_name(const char *name)
{
	return 0;
}

748
749
750
751
752
753
754
755
static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
							   struct module *,
							   unsigned long),
						 void *data)
{
	return 0;
}

Seunghun Lee's avatar
Seunghun Lee committed
756
static inline int register_module_notifier(struct notifier_block *nb)
Linus Torvalds's avatar
Linus Torvalds committed
757
758
759
760
761
{
	/* no events will happen anyway, so this can always succeed */
	return 0;
}

Seunghun Lee's avatar
Seunghun Lee committed
762
static inline int unregister_module_notifier(struct notifier_block *nb)
Linus Torvalds's avatar
Linus Torvalds committed
763
764
765
766
767
768
769
770
771
{
	return 0;
}

#define module_put_and_exit(code) do_exit(code)

static inline void print_modules(void)
{
}
772
773
774
775
776
777

static inline bool module_requested_async_probing(struct module *module)
{
	return false;
}

778
779
780
781
782
static inline bool is_module_sig_enforced(void)
{
	return false;
}

783
784
785
786
787
788
789
/* Dereference module function descriptor */
static inline
void *dereference_module_function_descriptor(struct module *mod, void *ptr)
{
	return ptr;
}

790
791
792
#endif /* CONFIG_MODULES */

#ifdef CONFIG_SYSFS
793
794
795
extern struct kset *module_kset;
extern struct kobj_type module_ktype;
extern int module_sysfs_initialized;
796
797
#endif /* CONFIG_SYSFS */

Linus Torvalds's avatar
Linus Torvalds committed
798
799
800
801
802
803
#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)

/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */

#define __MODULE_STRING(x) __stringify(x)

804
#ifdef CONFIG_STRICT_MODULE_RWX
805
806
extern void set_all_modules_text_rw(void);
extern void set_all_modules_text_ro(void);
807
extern void module_enable_ro(const struct module *mod, bool after_init);
808
extern void module_disable_ro(const struct module *mod);
809
810
811
#else
static inline void set_all_modules_text_rw(void) { }
static inline void set_all_modules_text_ro(void) { }
812
static inline void module_enable_ro(const struct module *mod, bool after_init) { }
813
static inline void module_disable_ro(const struct module *mod) { }
814
#endif
815
816

#ifdef CONFIG_GENERIC_BUG
817
void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
818
819
820
821
822
			 struct module *);
void module_bug_cleanup(struct module *);

#else	/* !CONFIG_GENERIC_BUG */

823
static inline void module_bug_finalize(const Elf_Ehdr *hdr,
824
825
826
827
828
829
830
					const Elf_Shdr *sechdrs,
					struct module *mod)
{
}
static inline void module_bug_cleanup(struct module *mod) {}
#endif	/* CONFIG_GENERIC_BUG */

831
#ifdef CONFIG_RETPOLINE
832
833
834
835
836
837
838
839
extern bool retpoline_module_ok(bool has_retpoline);
#else
static inline bool retpoline_module_ok(bool has_retpoline)
{
	return true;
}
#endif

840
841
842
843
844
845
846
847
848
849
850
851
#ifdef CONFIG_MODULE_SIG
static inline bool module_sig_ok(struct module *module)
{
	return module->sig_ok;
}
#else	/* !CONFIG_MODULE_SIG */
static inline bool module_sig_ok(struct module *module)
{
	return true;
}
#endif	/* CONFIG_MODULE_SIG */

Linus Torvalds's avatar
Linus Torvalds committed
852
#endif /* _LINUX_MODULE_H */