blob: 99f330ae13da557123020cc3aeba40f35f4de598 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/list.h>
10#include <linux/stat.h>
11#include <linux/compiler.h>
12#include <linux/cache.h>
13#include <linux/kmod.h>
Paul Gortmaker0fd972a2015-05-01 20:13:42 -040014#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/elf.h>
16#include <linux/stringify.h>
17#include <linux/kobject.h>
18#include <linux/moduleparam.h>
Steven Rostedt (Red Hat)b2e285f2014-02-26 13:12:06 -050019#include <linux/jump_label.h>
Paul Gortmakerf5016932011-05-23 14:11:39 -040020#include <linux/export.h>
Paul Gortmaker0ef76532016-07-27 12:06:34 +093021#include <linux/extable.h> /* only as arch move module.h -> extable.h */
Peter Zijlstra93c2e102015-05-27 11:09:37 +093022#include <linux/rbtree_latch.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
Christoph Lametere1783a22010-01-05 15:34:50 +090024#include <linux/percpu.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <asm/module.h>
26
Rusty Russell106a4ee2012-09-26 10:09:40 +010027/* In stripped ARM and x86-64 modules, ~ is surprisingly rare. */
28#define MODULE_SIG_STRING "~Module signature appended~\n"
29
Linus Torvalds1da177e2005-04-16 15:20:36 -070030/* Not Yet Implemented */
31#define MODULE_SUPPORTED_DEVICE(name)
32
Rusty Russell730b69d2008-10-22 10:00:22 -050033#define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Seunghun Leee865d062014-01-16 10:18:49 +103035struct modversion_info {
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 unsigned long crc;
37 char name[MODULE_NAME_LEN];
38};
39
40struct module;
Paul Gortmaker0ef76532016-07-27 12:06:34 +093041struct exception_table_entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042
Kay Sievers4befb022011-07-24 22:06:04 +093043struct module_kobject {
44 struct kobject kobj;
45 struct module *mod;
46 struct kobject *drivers_dir;
47 struct module_param_attrs *mp;
Li Zhong942e4432013-09-03 16:33:57 +093048 struct completion *kobj_completion;
Kay Sievers4befb022011-07-24 22:06:04 +093049};
50
Linus Torvalds1da177e2005-04-16 15:20:36 -070051struct module_attribute {
Kay Sievers4befb022011-07-24 22:06:04 +093052 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 *,
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 const char *, size_t count);
Matt Domschc988d2b2005-06-23 22:05:15 -070057 void (*setup)(struct module *, const char *);
58 int (*test)(struct module *);
59 void (*free)(struct module *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060};
61
Dmitry Torokhove94965e2010-12-15 14:00:19 -080062struct module_version_attribute {
63 struct module_attribute mattr;
64 const char *module_name;
65 const char *version;
Dmitry Torokhov98562ad2011-02-04 13:30:10 -080066} __attribute__ ((__aligned__(sizeof(void *))));
Dmitry Torokhove94965e2010-12-15 14:00:19 -080067
Dmitry Torokhov9b73a582011-02-07 16:02:27 -080068extern ssize_t __modver_version_show(struct module_attribute *,
Kay Sievers4befb022011-07-24 22:06:04 +093069 struct module_kobject *, char *);
Dmitry Torokhov9b73a582011-02-07 16:02:27 -080070
Kay Sievers88bfa322011-07-24 22:06:04 +093071extern struct module_attribute module_uevent;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
73/* These are either module local, or the kernel's dummy ones. */
74extern int init_module(void);
75extern void cleanup_module(void);
76
Paul Gortmaker0fd972a2015-05-01 20:13:42 -040077#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) \
Arnd Bergmanne2153882017-02-01 18:00:14 +0100130 static inline initcall_t __maybe_unused __inittest(void) \
Paul Gortmaker0fd972a2015-05-01 20:13:42 -0400131 { return initfn; } \
Miguel Ojeda2c34c212019-08-02 12:37:57 +0200132 int init_module(void) __copy(initfn) __attribute__((alias(#initfn)));
Paul Gortmaker0fd972a2015-05-01 20:13:42 -0400133
134/* This is only required if you want to be unloadable. */
135#define module_exit(exitfn) \
Arnd Bergmanne2153882017-02-01 18:00:14 +0100136 static inline exitcall_t __maybe_unused __exittest(void) \
Paul Gortmaker0fd972a2015-05-01 20:13:42 -0400137 { return exitfn; } \
Miguel Ojeda2c34c212019-08-02 12:37:57 +0200138 void cleanup_module(void) __copy(exitfn) __attribute__((alias(#exitfn)));
Paul Gortmaker0fd972a2015-05-01 20:13:42 -0400139
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160/* 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
Andreas Robinson7cb14ba2013-08-20 15:33:19 +0930166/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171/*
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]
Xose Vazquez Perez8d27e902006-06-23 02:05:13 -0700180 * "Dual MIT/GPL" [GNU Public License v2
181 * or MIT license choice]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 * "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
Seunghun Leee865d062014-01-16 10:18:49 +1030194 * 1. So modinfo can show license info for users wanting to vet their setup
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 * 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
Johannes Berg1d7015c2009-09-25 00:32:58 -0600201/*
202 * Author(s), use "Name <email>" or just "Name", for multiple
203 * authors use multiple MODULE_AUTHOR() statements/lines.
204 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
Seunghun Leee865d062014-01-16 10:18:49 +1030206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207/* What your module does. */
208#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
209
Rusty Russellcff26a52014-02-03 11:15:13 +1030210#ifdef MODULE
211/* Creates an alias so file2alias.c can find device table. */
212#define MODULE_DEVICE_TABLE(type, name) \
Andrey Ryabinin63019392015-02-13 14:40:13 -0800213extern const typeof(name) __mod_##type##__##name##_device_table \
Rusty Russellcff26a52014-02-03 11:15:13 +1030214 __attribute__ ((unused, alias(__stringify(name))))
215#else /* !MODULE */
216#define MODULE_DEVICE_TABLE(type, name)
217#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
219/* Version of form [<epoch>:]<version>[-<extra-version>].
Seunghun Leee865d062014-01-16 10:18:49 +1030220 * 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".
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
Seunghun Leee865d062014-01-16 10:18:49 +1030225 * <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 */
Dmitry Torokhove94965e2010-12-15 14:00:19 -0800235
Rusty Russell3b90a5b2011-01-24 14:32:51 -0600236#if defined(MODULE) || !defined(CONFIG_SYSFS)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
Dmitry Torokhove94965e2010-12-15 14:00:19 -0800238#else
239#define MODULE_VERSION(_version) \
Dmitry Torokhovb4bc84282011-02-07 16:02:25 -0800240 static struct module_version_attribute ___modver_attr = { \
Dmitry Torokhove94965e2010-12-15 14:00:19 -0800241 .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, \
Dmitry Torokhovb4bc84282011-02-07 16:02:25 -0800250 }; \
251 static const struct module_version_attribute \
252 __used __attribute__ ((__section__ ("__modver"))) \
253 * __moduleparam_const __modver_attr = &___modver_attr
Dmitry Torokhove94965e2010-12-15 14:00:19 -0800254#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
Jon Masters187afbe2006-08-28 17:08:21 -0500256/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261struct notifier_block;
262
263#ifdef CONFIG_MODULES
264
Dave Young5ed10912010-03-10 15:24:06 -0800265extern int modules_disabled; /* for sysctl */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266/* Get/put a kernel symbol (calls must be symmetric) */
267void *__symbol_get(const char *symbol);
268void *__symbol_get_gpl(const char *symbol);
Rusty Russellb92021b2013-03-15 15:04:17 +1030269#define symbol_get(x) ((typeof(&x))(__symbol_get(VMLINUX_SYMBOL_STR(x))))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Rusty Russellc8e21ce2010-06-05 11:17:35 -0600271/* 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
Rusty Russell0d21b0e2013-01-12 11:38:44 +1030278enum 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. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283};
284
Peter Zijlstra93c2e102015-05-27 11:09:37 +0930285struct module;
286
287struct mod_tree_node {
288 struct module *mod;
289 struct latch_tree_node node;
290};
291
Rusty Russell7523e4d2015-11-26 09:44:08 +1030292struct module_layout {
293 /* The actual code + data. */
294 void *base;
295 /* Total size. */
296 unsigned int size;
297 /* The size of the executable code. */
298 unsigned int text_size;
299 /* Size of RO section of the module (text+rodata) */
300 unsigned int ro_size;
Jessica Yu444d13f2016-07-27 12:06:21 +0930301 /* Size of RO after init section */
302 unsigned int ro_after_init_size;
Rusty Russell7523e4d2015-11-26 09:44:08 +1030303
304#ifdef CONFIG_MODULES_TREE_LOOKUP
305 struct mod_tree_node mtn;
306#endif
307};
308
309#ifdef CONFIG_MODULES_TREE_LOOKUP
310/* Only touch one cacheline for common rbtree-for-core-layout case. */
311#define __module_layout_align ____cacheline_aligned
312#else
313#define __module_layout_align
314#endif
315
Rusty Russell82440622016-02-03 16:55:26 +1030316struct mod_kallsyms {
317 Elf_Sym *symtab;
318 unsigned int num_symtab;
319 char *strtab;
320};
321
Jessica Yu1ce15ef2016-03-22 20:03:16 -0400322#ifdef CONFIG_LIVEPATCH
323struct klp_modinfo {
324 Elf_Ehdr hdr;
325 Elf_Shdr *sechdrs;
326 char *secstrings;
327 unsigned int symndx;
328};
329#endif
330
Seunghun Leee865d062014-01-16 10:18:49 +1030331struct module {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 enum module_state state;
333
334 /* Member of list of modules */
335 struct list_head list;
336
337 /* Unique handle for this module */
338 char name[MODULE_NAME_LEN];
339
340 /* Sysfs stuff. */
341 struct module_kobject mkobj;
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -0800342 struct module_attribute *modinfo_attrs;
Matt Domschc988d2b2005-06-23 22:05:15 -0700343 const char *version;
344 const char *srcversion;
Kay Sievers270a6c42007-01-18 13:26:15 +0100345 struct kobject *holders_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347 /* Exported symbols */
348 const struct kernel_symbol *syms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 const unsigned long *crcs;
Richard Kennedyaf540682008-07-22 19:24:26 -0500350 unsigned int num_syms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
Rusty Russelle180a6b2009-03-31 13:05:29 -0600352 /* Kernel parameters. */
Rusty Russellcf2fde72015-06-26 06:44:38 +0930353#ifdef CONFIG_SYSFS
Dan Streetmanb51d23e2015-06-17 06:18:52 +0930354 struct mutex param_lock;
Rusty Russellcf2fde72015-06-26 06:44:38 +0930355#endif
Rusty Russelle180a6b2009-03-31 13:05:29 -0600356 struct kernel_param *kp;
357 unsigned int num_kp;
358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 /* GPL-only exported symbols. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 unsigned int num_gpl_syms;
Richard Kennedyaf540682008-07-22 19:24:26 -0500361 const struct kernel_symbol *gpl_syms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 const unsigned long *gpl_crcs;
363
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500364#ifdef CONFIG_UNUSED_SYMBOLS
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700365 /* unused exported symbols. */
366 const struct kernel_symbol *unused_syms;
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700367 const unsigned long *unused_crcs;
Richard Kennedyaf540682008-07-22 19:24:26 -0500368 unsigned int num_unused_syms;
369
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700370 /* GPL-only, unused exported symbols. */
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700371 unsigned int num_unused_gpl_syms;
Richard Kennedyaf540682008-07-22 19:24:26 -0500372 const struct kernel_symbol *unused_gpl_syms;
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700373 const unsigned long *unused_gpl_crcs;
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500374#endif
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700375
Rusty Russell106a4ee2012-09-26 10:09:40 +0100376#ifdef CONFIG_MODULE_SIG
377 /* Signature was verified. */
378 bool sig_ok;
379#endif
380
Luis R. Rodriguezf2411da2015-03-30 16:20:05 -0700381 bool async_probe_requested;
382
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800383 /* symbols that will be GPL-only in the near future. */
384 const struct kernel_symbol *gpl_future_syms;
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800385 const unsigned long *gpl_future_crcs;
Richard Kennedyaf540682008-07-22 19:24:26 -0500386 unsigned int num_gpl_future_syms;
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 /* Exception table */
389 unsigned int num_exentries;
Rusty Russell5e458cc2008-10-22 10:00:13 -0500390 struct exception_table_entry *extable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
392 /* Startup function. */
393 int (*init)(void);
394
Rusty Russell7523e4d2015-11-26 09:44:08 +1030395 /* Core layout: rbtree is accessed frequently, so keep together. */
396 struct module_layout core_layout __module_layout_align;
397 struct module_layout init_layout;
matthieu castet84e1c6b2010-11-16 22:35:16 +0100398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 /* Arch-specific module values */
400 struct mod_arch_specific arch;
401
Randy Dunlap2bc2d612006-10-02 02:17:02 -0700402 unsigned int taints; /* same bits as kernel:tainted */
403
Jeremy Fitzhardinge7664c5a2006-12-08 02:36:19 -0800404#ifdef CONFIG_GENERIC_BUG
405 /* Support for BUG */
Richard Kennedyaf540682008-07-22 19:24:26 -0500406 unsigned num_bugs;
Jeremy Fitzhardinge7664c5a2006-12-08 02:36:19 -0800407 struct list_head bug_list;
408 struct bug_entry *bug_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409#endif
410
411#ifdef CONFIG_KALLSYMS
Rusty Russell82440622016-02-03 16:55:26 +1030412 /* Protected by RCU and/or module_mutex: use rcu_dereference() */
413 struct mod_kallsyms *kallsyms;
414 struct mod_kallsyms core_kallsyms;
415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 /* Section attributes */
417 struct module_sect_attrs *sect_attrs;
Roland McGrath6d760132007-10-16 23:26:40 -0700418
419 /* Notes attributes */
420 struct module_notes_attrs *notes_attrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421#endif
422
Richard Kennedya288bd62011-05-19 16:55:25 -0600423 /* The command line arguments (may be mangled). People like
424 keeping pointers to this stuff */
425 char *args;
426
Tejun Heo259354d2010-03-10 18:56:10 +0900427#ifdef CONFIG_SMP
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 /* Per-cpu data. */
Tejun Heo259354d2010-03-10 18:56:10 +0900429 void __percpu *percpu;
430 unsigned int percpu_size;
431#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400433#ifdef CONFIG_TRACEPOINTS
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400434 unsigned int num_tracepoints;
Richard Kennedya288bd62011-05-19 16:55:25 -0600435 struct tracepoint * const *tracepoints_ptrs;
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400436#endif
Jason Baronbf5438fc2010-09-17 11:09:00 -0400437#ifdef HAVE_JUMP_LABEL
438 struct jump_entry *jump_entries;
439 unsigned int num_jump_entries;
440#endif
Frederic Weisbecker769b0442009-03-06 17:21:49 +0100441#ifdef CONFIG_TRACING
Lai Jiangshan1ba28e02009-03-06 17:21:48 +0100442 unsigned int num_trace_bprintk_fmt;
Richard Kennedya288bd62011-05-19 16:55:25 -0600443 const char **trace_bprintk_fmt_start;
Lai Jiangshan1ba28e02009-03-06 17:21:48 +0100444#endif
Steven Rostedt6d723732009-04-10 14:53:50 -0400445#ifdef CONFIG_EVENT_TRACING
Steven Rostedt (Red Hat)2425bcb2015-05-05 11:45:27 -0400446 struct trace_event_call **trace_events;
Steven Rostedt6d723732009-04-10 14:53:50 -0400447 unsigned int num_trace_events;
Steven Rostedt (Red Hat)3673b8e2015-03-25 15:44:21 -0400448 struct trace_enum_map **trace_enums;
449 unsigned int num_trace_enums;
Steven Rostedt6d723732009-04-10 14:53:50 -0400450#endif
Steven Rostedt93eb6772009-04-15 13:24:06 -0400451#ifdef CONFIG_FTRACE_MCOUNT_RECORD
Steven Rostedt93eb6772009-04-15 13:24:06 -0400452 unsigned int num_ftrace_callsites;
Richard Kennedya288bd62011-05-19 16:55:25 -0600453 unsigned long *ftrace_callsites;
Steven Rostedt93eb6772009-04-15 13:24:06 -0400454#endif
Lai Jiangshan1ba28e02009-03-06 17:21:48 +0100455
Petr Mladek8cb2c2d2015-03-12 12:55:13 +0100456#ifdef CONFIG_LIVEPATCH
Jessica Yu1ce15ef2016-03-22 20:03:16 -0400457 bool klp; /* Is this a livepatch module? */
Petr Mladek8cb2c2d2015-03-12 12:55:13 +0100458 bool klp_alive;
Jessica Yu1ce15ef2016-03-22 20:03:16 -0400459
460 /* Elf information */
461 struct klp_modinfo *klp_info;
Petr Mladek8cb2c2d2015-03-12 12:55:13 +0100462#endif
463
Richard Kennedyaf540682008-07-22 19:24:26 -0500464#ifdef CONFIG_MODULE_UNLOAD
465 /* What modules depend on me? */
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700466 struct list_head source_list;
467 /* What modules do I depend on? */
468 struct list_head target_list;
Richard Kennedyaf540682008-07-22 19:24:26 -0500469
Richard Kennedyaf540682008-07-22 19:24:26 -0500470 /* Destruction function. */
471 void (*exit)(void);
472
Masami Hiramatsu2f35c412014-11-10 09:29:29 +1030473 atomic_t refcnt;
Richard Kennedyaf540682008-07-22 19:24:26 -0500474#endif
Peter Oberparleiterb99b87f2009-06-17 16:28:03 -0700475
476#ifdef CONFIG_CONSTRUCTORS
477 /* Constructor functions. */
478 ctor_fn_t *ctors;
479 unsigned int num_ctors;
480#endif
Peter Zijlstra93c2e102015-05-27 11:09:37 +0930481} ____cacheline_aligned;
Roman Zippele61a1c12007-05-09 02:35:15 -0700482#ifndef MODULE_ARCH_INIT
483#define MODULE_ARCH_INIT {}
484#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Tim Abbottc6b37802008-12-05 19:03:59 -0500486extern struct mutex module_mutex;
487
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488/* FIXME: It'd be nice to isolate modules during init, too, so they
489 aren't used before they (may) fail. But presently too much code
490 (IDE & SCSI) require entry into the module during init.*/
491static inline int module_is_live(struct module *mod)
492{
493 return mod->state != MODULE_STATE_GOING;
494}
495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496struct module *__module_text_address(unsigned long addr);
Rusty Russelle6104992009-03-31 13:05:31 -0600497struct module *__module_address(unsigned long addr);
498bool is_module_address(unsigned long addr);
Tejun Heo10fad5e2010-03-10 18:57:54 +0900499bool is_module_percpu_address(unsigned long addr);
Rusty Russelle6104992009-03-31 13:05:31 -0600500bool is_module_text_address(unsigned long addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Petr Mladek76681c82014-07-27 07:25:01 +0930502static inline bool within_module_core(unsigned long addr,
503 const struct module *mod)
Masami Hiramatsua06f6212009-01-06 14:41:49 -0800504{
Rusty Russell7523e4d2015-11-26 09:44:08 +1030505 return (unsigned long)mod->core_layout.base <= addr &&
506 addr < (unsigned long)mod->core_layout.base + mod->core_layout.size;
Masami Hiramatsua06f6212009-01-06 14:41:49 -0800507}
508
Petr Mladek76681c82014-07-27 07:25:01 +0930509static inline bool within_module_init(unsigned long addr,
510 const struct module *mod)
Masami Hiramatsua06f6212009-01-06 14:41:49 -0800511{
Rusty Russell7523e4d2015-11-26 09:44:08 +1030512 return (unsigned long)mod->init_layout.base <= addr &&
513 addr < (unsigned long)mod->init_layout.base + mod->init_layout.size;
Masami Hiramatsua06f6212009-01-06 14:41:49 -0800514}
515
Petr Mladek76681c82014-07-27 07:25:01 +0930516static inline bool within_module(unsigned long addr, const struct module *mod)
Petr Mladek9b20a352014-07-27 07:24:01 +0930517{
518 return within_module_init(addr, mod) || within_module_core(addr, mod);
519}
520
Tim Abbottc6b37802008-12-05 19:03:59 -0500521/* Search for module by name: must hold module_mutex. */
522struct module *find_module(const char *name);
523
524struct symsearch {
525 const struct kernel_symbol *start, *stop;
526 const unsigned long *crcs;
527 enum {
528 NOT_GPL_ONLY,
529 GPL_ONLY,
530 WILL_BE_GPL_ONLY,
531 } licence;
532 bool unused;
533};
534
Peter Zijlstra0be964b2015-05-27 11:09:35 +0930535/*
536 * Search for an exported symbol by name.
537 *
538 * Must be called with module_mutex held or preemption disabled.
539 */
Tim Abbottc6b37802008-12-05 19:03:59 -0500540const struct kernel_symbol *find_symbol(const char *name,
541 struct module **owner,
542 const unsigned long **crc,
543 bool gplok,
544 bool warn);
545
Peter Zijlstra0be964b2015-05-27 11:09:35 +0930546/*
547 * Walk the exported symbol table
548 *
549 * Must be called with module_mutex held or preemption disabled.
550 */
Rusty Russellde4d8d52011-04-19 21:49:58 +0200551bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
552 struct module *owner,
553 void *data), void *data);
Tim Abbottc6b37802008-12-05 19:03:59 -0500554
Alexey Dobriyanea078902007-05-08 00:28:39 -0700555/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 symnum out of range. */
Alexey Dobriyanea078902007-05-08 00:28:39 -0700557int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
558 char *name, char *module_name, int *exported);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559
560/* Look for this name: can be of form module:name. */
561unsigned long module_kallsyms_lookup_name(const char *name);
562
Anders Kaseorg75a66612008-12-05 19:03:58 -0500563int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
564 struct module *, unsigned long),
565 void *data);
566
Jiri Kosinabf262dc2016-04-12 05:02:09 +0930567extern void __noreturn __module_put_and_exit(struct module *mod,
568 long code);
Joe Perches74e22fa2013-12-04 14:09:38 +1030569#define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571#ifdef CONFIG_MODULE_UNLOAD
Rusty Russelld5db1392015-01-22 11:13:14 +1030572int module_refcount(struct module *mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573void __symbol_put(const char *symbol);
Rusty Russellb92021b2013-03-15 15:04:17 +1030574#define symbol_put(x) __symbol_put(VMLINUX_SYMBOL_STR(x))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575void symbol_put_addr(void *addr);
576
577/* Sometimes we know we already have a refcount, and it's easier not
578 to handle the error case (which only happens with rmmod --wait). */
Steven Rostedtd53799b2012-03-26 12:50:52 +1030579extern void __module_get(struct module *module);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
Steven Rostedtd53799b2012-03-26 12:50:52 +1030581/* This is the Right Way to get a module: if it fails, it's being removed,
582 * so pretend it's not there. */
583extern bool try_module_get(struct module *module);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Al Virof6a57032006-10-18 01:47:25 -0400585extern void module_put(struct module *module);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
587#else /*!CONFIG_MODULE_UNLOAD*/
588static inline int try_module_get(struct module *module)
589{
590 return !module || module_is_live(module);
591}
592static inline void module_put(struct module *module)
593{
594}
595static inline void __module_get(struct module *module)
596{
597}
Seunghun Leee865d062014-01-16 10:18:49 +1030598#define symbol_put(x) do { } while (0)
599#define symbol_put_addr(p) do { } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600
601#endif /* CONFIG_MODULE_UNLOAD */
Anders Kaseorgdfd62d12010-11-24 15:21:10 -0600602int ref_module(struct module *a, struct module *b);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
604/* This is a #define so the string doesn't get put in every .o file */
605#define module_name(mod) \
606({ \
607 struct module *__mod = (mod); \
608 __mod ? __mod->name : "kernel"; \
609})
610
Rusty Russell6dd06c92008-01-29 17:13:22 -0500611/* For kallsyms to ask for address resolution. namebuf should be at
612 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
613 * found, otherwise NULL. */
Andrew Morton92dfc9d2008-02-08 04:18:43 -0800614const char *module_address_lookup(unsigned long addr,
Rusty Russell6dd06c92008-01-29 17:13:22 -0500615 unsigned long *symbolsize,
616 unsigned long *offset,
617 char **modname,
618 char *namebuf);
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -0700619int lookup_module_symbol_name(unsigned long addr, char *symname);
Alexey Dobriyana5c43da2007-05-08 00:28:47 -0700620int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621
Seunghun Leee865d062014-01-16 10:18:49 +1030622int register_module_notifier(struct notifier_block *nb);
623int unregister_module_notifier(struct notifier_block *nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625extern void print_modules(void);
626
Dmitry Torokhov80c6e142015-05-21 15:49:37 -0700627static inline bool module_requested_async_probing(struct module *module)
628{
629 return module && module->async_probe_requested;
630}
631
Jessica Yu1ce15ef2016-03-22 20:03:16 -0400632#ifdef CONFIG_LIVEPATCH
633static inline bool is_livepatch_module(struct module *mod)
634{
635 return mod->klp;
636}
637#else /* !CONFIG_LIVEPATCH */
638static inline bool is_livepatch_module(struct module *mod)
639{
640 return false;
641}
642#endif /* CONFIG_LIVEPATCH */
643
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644#else /* !CONFIG_MODULES... */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
Rusty Russelle6104992009-03-31 13:05:31 -0600646static inline struct module *__module_address(unsigned long addr)
647{
648 return NULL;
649}
650
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651static inline struct module *__module_text_address(unsigned long addr)
652{
653 return NULL;
654}
655
Rusty Russelle6104992009-03-31 13:05:31 -0600656static inline bool is_module_address(unsigned long addr)
Ingo Molnar4d435f92006-07-03 00:24:24 -0700657{
Rusty Russelle6104992009-03-31 13:05:31 -0600658 return false;
659}
660
Randy Dunlapd5e50da2010-03-31 11:33:42 +0900661static inline bool is_module_percpu_address(unsigned long addr)
662{
663 return false;
664}
665
Rusty Russelle6104992009-03-31 13:05:31 -0600666static inline bool is_module_text_address(unsigned long addr)
667{
668 return false;
Ingo Molnar4d435f92006-07-03 00:24:24 -0700669}
670
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671/* Get/put a kernel symbol (calls should be symmetric) */
672#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
Seunghun Leee865d062014-01-16 10:18:49 +1030673#define symbol_put(x) do { } while (0)
674#define symbol_put_addr(x) do { } while (0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
676static inline void __module_get(struct module *module)
677{
678}
679
680static inline int try_module_get(struct module *module)
681{
682 return 1;
683}
684
685static inline void module_put(struct module *module)
686{
687}
688
689#define module_name(mod) "kernel"
690
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691/* For kallsyms to ask for address resolution. NULL means not found. */
Andrew Morton92dfc9d2008-02-08 04:18:43 -0800692static inline const char *module_address_lookup(unsigned long addr,
Rusty Russell6dd06c92008-01-29 17:13:22 -0500693 unsigned long *symbolsize,
694 unsigned long *offset,
695 char **modname,
696 char *namebuf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697{
698 return NULL;
699}
700
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -0700701static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
702{
703 return -ERANGE;
704}
705
Alexey Dobriyana5c43da2007-05-08 00:28:47 -0700706static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
707{
708 return -ERANGE;
709}
710
Alexey Dobriyanea078902007-05-08 00:28:39 -0700711static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
712 char *type, char *name,
713 char *module_name, int *exported)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
Alexey Dobriyanea078902007-05-08 00:28:39 -0700715 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716}
717
718static inline unsigned long module_kallsyms_lookup_name(const char *name)
719{
720 return 0;
721}
722
Anders Kaseorg75a66612008-12-05 19:03:58 -0500723static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
724 struct module *,
725 unsigned long),
726 void *data)
727{
728 return 0;
729}
730
Seunghun Leee865d062014-01-16 10:18:49 +1030731static inline int register_module_notifier(struct notifier_block *nb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732{
733 /* no events will happen anyway, so this can always succeed */
734 return 0;
735}
736
Seunghun Leee865d062014-01-16 10:18:49 +1030737static inline int unregister_module_notifier(struct notifier_block *nb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738{
739 return 0;
740}
741
742#define module_put_and_exit(code) do_exit(code)
743
744static inline void print_modules(void)
745{
746}
Dmitry Torokhov80c6e142015-05-21 15:49:37 -0700747
748static inline bool module_requested_async_probing(struct module *module)
749{
750 return false;
751}
752
Randy Dunlapef665c12007-02-13 15:19:06 -0800753#endif /* CONFIG_MODULES */
754
Randy Dunlapef665c12007-02-13 15:19:06 -0800755#ifdef CONFIG_SYSFS
Greg Kroah-Hartman7405c1e2007-11-01 10:39:50 -0700756extern struct kset *module_kset;
757extern struct kobj_type module_ktype;
758extern int module_sysfs_initialized;
Randy Dunlapef665c12007-02-13 15:19:06 -0800759#endif /* CONFIG_SYSFS */
760
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
762
763/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
764
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765#define __MODULE_STRING(x) __stringify(x)
766
matthieu castet84e1c6b2010-11-16 22:35:16 +0100767#ifdef CONFIG_DEBUG_SET_MODULE_RONX
768extern void set_all_modules_text_rw(void);
769extern void set_all_modules_text_ro(void);
Jessica Yu444d13f2016-07-27 12:06:21 +0930770extern void module_enable_ro(const struct module *mod, bool after_init);
Rusty Russell85c898d2015-11-26 09:45:08 +1030771extern void module_disable_ro(const struct module *mod);
matthieu castet84e1c6b2010-11-16 22:35:16 +0100772#else
773static inline void set_all_modules_text_rw(void) { }
774static inline void set_all_modules_text_ro(void) { }
Jessica Yu444d13f2016-07-27 12:06:21 +0930775static inline void module_enable_ro(const struct module *mod, bool after_init) { }
Rusty Russell85c898d2015-11-26 09:45:08 +1030776static inline void module_disable_ro(const struct module *mod) { }
matthieu castet84e1c6b2010-11-16 22:35:16 +0100777#endif
Andrew Morton0d9c25d2009-06-16 15:33:37 -0700778
779#ifdef CONFIG_GENERIC_BUG
Linus Torvalds53363772010-10-05 11:29:27 -0700780void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
Andrew Morton0d9c25d2009-06-16 15:33:37 -0700781 struct module *);
782void module_bug_cleanup(struct module *);
783
784#else /* !CONFIG_GENERIC_BUG */
785
Linus Torvalds53363772010-10-05 11:29:27 -0700786static inline void module_bug_finalize(const Elf_Ehdr *hdr,
Andrew Morton0d9c25d2009-06-16 15:33:37 -0700787 const Elf_Shdr *sechdrs,
788 struct module *mod)
789{
Andrew Morton0d9c25d2009-06-16 15:33:37 -0700790}
791static inline void module_bug_cleanup(struct module *mod) {}
792#endif /* CONFIG_GENERIC_BUG */
793
Andi Kleena1745ad2018-01-25 15:50:28 -0800794#ifdef RETPOLINE
795extern bool retpoline_module_ok(bool has_retpoline);
796#else
797static inline bool retpoline_module_ok(bool has_retpoline)
798{
799 return true;
800}
801#endif
802
Herbert Xu59afdc72015-04-22 11:28:46 +0800803#ifdef CONFIG_MODULE_SIG
804static inline bool module_sig_ok(struct module *module)
805{
806 return module->sig_ok;
807}
808#else /* !CONFIG_MODULE_SIG */
809static inline bool module_sig_ok(struct module *module)
810{
811 return true;
812}
813#endif /* CONFIG_MODULE_SIG */
814
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815#endif /* _LINUX_MODULE_H */