blob: 8a6b9fdc7ffae0c20335b8a2c73726396a934ee2 [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>
14#include <linux/elf.h>
15#include <linux/stringify.h>
16#include <linux/kobject.h>
17#include <linux/moduleparam.h>
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -040018#include <linux/tracepoint.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
Christoph Lametere1783a22010-01-05 15:34:50 +090020#include <linux/percpu.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <asm/module.h>
22
Li Zefan7ead8b82009-08-17 16:56:28 +080023#include <trace/events/module.h>
24
Linus Torvalds1da177e2005-04-16 15:20:36 -070025/* Not Yet Implemented */
26#define MODULE_SUPPORTED_DEVICE(name)
27
Alan Jenkins9e1b9b82009-11-07 21:03:54 +000028/* Some toolchains use a `_' prefix for all user symbols. */
29#ifdef CONFIG_SYMBOL_PREFIX
30#define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX
31#else
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#define MODULE_SYMBOL_PREFIX ""
33#endif
34
Rusty Russell730b69d2008-10-22 10:00:22 -050035#define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
37struct kernel_symbol
38{
39 unsigned long value;
40 const char *name;
41};
42
43struct modversion_info
44{
45 unsigned long crc;
46 char name[MODULE_NAME_LEN];
47};
48
49struct module;
50
51struct module_attribute {
52 struct attribute attr;
53 ssize_t (*show)(struct module_attribute *, struct module *, char *);
54 ssize_t (*store)(struct module_attribute *, struct module *,
55 const char *, size_t count);
Matt Domschc988d2b2005-06-23 22:05:15 -070056 void (*setup)(struct module *, const char *);
57 int (*test)(struct module *);
58 void (*free)(struct module *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059};
60
61struct module_kobject
62{
63 struct kobject kobj;
64 struct module *mod;
Kay Sieversf30c53a2007-01-15 20:22:02 +010065 struct kobject *drivers_dir;
Rusty Russell9b473de2008-10-22 10:00:22 -050066 struct module_param_attrs *mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067};
68
69/* These are either module local, or the kernel's dummy ones. */
70extern int init_module(void);
71extern void cleanup_module(void);
72
73/* Archs provide a method of finding the correct exception table. */
74struct exception_table_entry;
75
76const struct exception_table_entry *
77search_extable(const struct exception_table_entry *first,
78 const struct exception_table_entry *last,
79 unsigned long value);
80void sort_extable(struct exception_table_entry *start,
81 struct exception_table_entry *finish);
82void sort_main_extable(void);
Rusty Russellad6561d2009-06-12 21:47:03 -060083void trim_init_extable(struct module *m);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Linus Torvalds1da177e2005-04-16 15:20:36 -070085#ifdef MODULE
86#define MODULE_GENERIC_TABLE(gtype,name) \
87extern const struct gtype##_id __mod_##gtype##_table \
88 __attribute__ ((unused, alias(__stringify(name))))
89
90extern struct module __this_module;
91#define THIS_MODULE (&__this_module)
92#else /* !MODULE */
93#define MODULE_GENERIC_TABLE(gtype,name)
94#define THIS_MODULE ((struct module *)0)
95#endif
96
97/* Generic info of form tag = "info" */
98#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
99
100/* For userspace: you can also call me... */
101#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
102
103/*
104 * The following license idents are currently accepted as indicating free
105 * software modules
106 *
107 * "GPL" [GNU Public License v2 or later]
108 * "GPL v2" [GNU Public License v2]
109 * "GPL and additional rights" [GNU Public License v2 rights and more]
110 * "Dual BSD/GPL" [GNU Public License v2
111 * or BSD license choice]
Xose Vazquez Perez8d27e902006-06-23 02:05:13 -0700112 * "Dual MIT/GPL" [GNU Public License v2
113 * or MIT license choice]
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 * "Dual MPL/GPL" [GNU Public License v2
115 * or Mozilla license choice]
116 *
117 * The following other idents are available
118 *
119 * "Proprietary" [Non free products]
120 *
121 * There are dual licensed components, but when running with Linux it is the
122 * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
123 * is a GPL combined work.
124 *
125 * This exists for several reasons
126 * 1. So modinfo can show license info for users wanting to vet their setup
127 * is free
128 * 2. So the community can ignore bug reports including proprietary modules
129 * 3. So vendors can do likewise based on their own policies
130 */
131#define MODULE_LICENSE(_license) MODULE_INFO(license, _license)
132
Johannes Berg1d7015c2009-09-25 00:32:58 -0600133/*
134 * Author(s), use "Name <email>" or just "Name", for multiple
135 * authors use multiple MODULE_AUTHOR() statements/lines.
136 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
138
139/* What your module does. */
140#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
141
142/* One for each parameter, describing how to use it. Some files do
143 multiple of these per line, so can't just use MODULE_INFO. */
144#define MODULE_PARM_DESC(_parm, desc) \
145 __MODULE_INFO(parm, _parm, #_parm ":" desc)
146
147#define MODULE_DEVICE_TABLE(type,name) \
148 MODULE_GENERIC_TABLE(type##_device,name)
149
150/* Version of form [<epoch>:]<version>[-<extra-version>].
151 Or for CVS/RCS ID version, everything but the number is stripped.
152 <epoch>: A (small) unsigned integer which allows you to start versions
153 anew. If not mentioned, it's zero. eg. "2:1.0" is after
154 "1:2.0".
155 <version>: The <version> may contain only alphanumerics and the
156 character `.'. Ordered by numeric sort for numeric parts,
157 ascii sort for ascii parts (as per RPM or DEB algorithm).
158 <extraversion>: Like <version>, but inserted for local
159 customizations, eg "rh3" or "rusty1".
160
161 Using this automatically adds a checksum of the .c files and the
162 local headers in "srcversion".
163*/
164#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
165
Jon Masters187afbe2006-08-28 17:08:21 -0500166/* Optional firmware file (or files) needed by the module
167 * format is simply firmware file name. Multiple firmware
168 * files require multiple MODULE_FIRMWARE() specifiers */
169#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171/* Given an address, look for it in the exception tables */
172const struct exception_table_entry *search_exception_tables(unsigned long add);
173
174struct notifier_block;
175
176#ifdef CONFIG_MODULES
177
Dave Young5ed10912010-03-10 15:24:06 -0800178extern int modules_disabled; /* for sysctl */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179/* Get/put a kernel symbol (calls must be symmetric) */
180void *__symbol_get(const char *symbol);
181void *__symbol_get_gpl(const char *symbol);
182#define symbol_get(x) ((typeof(&x))(__symbol_get(MODULE_SYMBOL_PREFIX #x)))
183
Rusty Russellc8e21ce2010-06-05 11:17:35 -0600184/* modules using other modules: kdb wants to see this. */
185struct module_use {
186 struct list_head source_list;
187 struct list_head target_list;
188 struct module *source, *target;
189};
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191#ifndef __GENKSYMS__
192#ifdef CONFIG_MODVERSIONS
193/* Mark the CRC weak since genksyms apparently decides not to
194 * generate a checksums for some symbols */
195#define __CRC_SYMBOL(sym, sec) \
196 extern void *__crc_##sym __attribute__((weak)); \
197 static const unsigned long __kcrctab_##sym \
Adrian Bunk3ff6eec2008-01-24 22:16:20 +0100198 __used \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 __attribute__((section("__kcrctab" sec), unused)) \
200 = (unsigned long) &__crc_##sym;
201#else
202#define __CRC_SYMBOL(sym, sec)
203#endif
204
205/* For every exported symbol, place a struct in the __ksymtab section */
206#define __EXPORT_SYMBOL(sym, sec) \
Patrick McHardya1a8fee2006-03-23 22:07:34 -0800207 extern typeof(sym) sym; \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 __CRC_SYMBOL(sym, sec) \
209 static const char __kstrtab_##sym[] \
Rusty Russellea01e792008-03-13 09:02:17 +0000210 __attribute__((section("__ksymtab_strings"), aligned(1))) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 = MODULE_SYMBOL_PREFIX #sym; \
212 static const struct kernel_symbol __ksymtab_##sym \
Adrian Bunk3ff6eec2008-01-24 22:16:20 +0100213 __used \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 __attribute__((section("__ksymtab" sec), unused)) \
215 = { (unsigned long)&sym, __kstrtab_##sym }
216
217#define EXPORT_SYMBOL(sym) \
218 __EXPORT_SYMBOL(sym, "")
219
220#define EXPORT_SYMBOL_GPL(sym) \
221 __EXPORT_SYMBOL(sym, "_gpl")
222
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800223#define EXPORT_SYMBOL_GPL_FUTURE(sym) \
224 __EXPORT_SYMBOL(sym, "_gpl_future")
225
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700226
227#ifdef CONFIG_UNUSED_SYMBOLS
228#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused")
229#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl")
230#else
231#define EXPORT_UNUSED_SYMBOL(sym)
232#define EXPORT_UNUSED_SYMBOL_GPL(sym)
233#endif
234
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235#endif
236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237enum module_state
238{
239 MODULE_STATE_LIVE,
240 MODULE_STATE_COMING,
241 MODULE_STATE_GOING,
242};
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244struct module
245{
246 enum module_state state;
247
248 /* Member of list of modules */
249 struct list_head list;
250
251 /* Unique handle for this module */
252 char name[MODULE_NAME_LEN];
253
254 /* Sysfs stuff. */
255 struct module_kobject mkobj;
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -0800256 struct module_attribute *modinfo_attrs;
Matt Domschc988d2b2005-06-23 22:05:15 -0700257 const char *version;
258 const char *srcversion;
Kay Sievers270a6c42007-01-18 13:26:15 +0100259 struct kobject *holders_dir;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
261 /* Exported symbols */
262 const struct kernel_symbol *syms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 const unsigned long *crcs;
Richard Kennedyaf540682008-07-22 19:24:26 -0500264 unsigned int num_syms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
Rusty Russelle180a6b2009-03-31 13:05:29 -0600266 /* Kernel parameters. */
267 struct kernel_param *kp;
268 unsigned int num_kp;
269
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 /* GPL-only exported symbols. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 unsigned int num_gpl_syms;
Richard Kennedyaf540682008-07-22 19:24:26 -0500272 const struct kernel_symbol *gpl_syms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 const unsigned long *gpl_crcs;
274
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500275#ifdef CONFIG_UNUSED_SYMBOLS
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700276 /* unused exported symbols. */
277 const struct kernel_symbol *unused_syms;
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700278 const unsigned long *unused_crcs;
Richard Kennedyaf540682008-07-22 19:24:26 -0500279 unsigned int num_unused_syms;
280
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700281 /* GPL-only, unused exported symbols. */
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700282 unsigned int num_unused_gpl_syms;
Richard Kennedyaf540682008-07-22 19:24:26 -0500283 const struct kernel_symbol *unused_gpl_syms;
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700284 const unsigned long *unused_gpl_crcs;
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500285#endif
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700286
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800287 /* symbols that will be GPL-only in the near future. */
288 const struct kernel_symbol *gpl_future_syms;
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800289 const unsigned long *gpl_future_crcs;
Richard Kennedyaf540682008-07-22 19:24:26 -0500290 unsigned int num_gpl_future_syms;
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 /* Exception table */
293 unsigned int num_exentries;
Rusty Russell5e458cc2008-10-22 10:00:13 -0500294 struct exception_table_entry *extable;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
296 /* Startup function. */
297 int (*init)(void);
298
299 /* If this is non-NULL, vfree after init() returns */
300 void *module_init;
301
302 /* Here is the actual code + data, vfree'd on unload. */
303 void *module_core;
304
305 /* Here are the sizes of the init and core sections */
Denys Vlasenko2f0f2a32008-07-22 19:24:27 -0500306 unsigned int init_size, core_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
308 /* The size of the executable code in each section. */
Denys Vlasenko2f0f2a32008-07-22 19:24:27 -0500309 unsigned int init_text_size, core_text_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
311 /* Arch-specific module values */
312 struct mod_arch_specific arch;
313
Randy Dunlap2bc2d612006-10-02 02:17:02 -0700314 unsigned int taints; /* same bits as kernel:tainted */
315
Jeremy Fitzhardinge7664c5a2006-12-08 02:36:19 -0800316#ifdef CONFIG_GENERIC_BUG
317 /* Support for BUG */
Richard Kennedyaf540682008-07-22 19:24:26 -0500318 unsigned num_bugs;
Jeremy Fitzhardinge7664c5a2006-12-08 02:36:19 -0800319 struct list_head bug_list;
320 struct bug_entry *bug_table;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321#endif
322
323#ifdef CONFIG_KALLSYMS
Jan Beulich4a496222009-07-06 14:50:42 +0100324 /*
325 * We keep the symbol and string tables for kallsyms.
326 * The core_* fields below are temporary, loader-only (they
327 * could really be discarded after module init).
328 */
329 Elf_Sym *symtab, *core_symtab;
330 unsigned int num_symtab, core_num_syms;
Jan Beulich554bdfe2009-07-06 14:51:44 +0100331 char *strtab, *core_strtab;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332
333 /* Section attributes */
334 struct module_sect_attrs *sect_attrs;
Roland McGrath6d760132007-10-16 23:26:40 -0700335
336 /* Notes attributes */
337 struct module_notes_attrs *notes_attrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338#endif
339
Tejun Heo259354d2010-03-10 18:56:10 +0900340#ifdef CONFIG_SMP
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 /* Per-cpu data. */
Tejun Heo259354d2010-03-10 18:56:10 +0900342 void __percpu *percpu;
343 unsigned int percpu_size;
344#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345
346 /* The command line arguments (may be mangled). People like
347 keeping pointers to this stuff */
348 char *args;
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400349#ifdef CONFIG_TRACEPOINTS
350 struct tracepoint *tracepoints;
351 unsigned int num_tracepoints;
352#endif
Richard Kennedyaf540682008-07-22 19:24:26 -0500353
Frederic Weisbecker769b0442009-03-06 17:21:49 +0100354#ifdef CONFIG_TRACING
Lai Jiangshan1ba28e02009-03-06 17:21:48 +0100355 const char **trace_bprintk_fmt_start;
356 unsigned int num_trace_bprintk_fmt;
357#endif
Steven Rostedt6d723732009-04-10 14:53:50 -0400358#ifdef CONFIG_EVENT_TRACING
359 struct ftrace_event_call *trace_events;
360 unsigned int num_trace_events;
361#endif
Steven Rostedt93eb6772009-04-15 13:24:06 -0400362#ifdef CONFIG_FTRACE_MCOUNT_RECORD
363 unsigned long *ftrace_callsites;
364 unsigned int num_ftrace_callsites;
365#endif
Lai Jiangshan1ba28e02009-03-06 17:21:48 +0100366
Richard Kennedyaf540682008-07-22 19:24:26 -0500367#ifdef CONFIG_MODULE_UNLOAD
368 /* What modules depend on me? */
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700369 struct list_head source_list;
370 /* What modules do I depend on? */
371 struct list_head target_list;
Richard Kennedyaf540682008-07-22 19:24:26 -0500372
373 /* Who is waiting for us to be unloaded */
374 struct task_struct *waiter;
375
376 /* Destruction function. */
377 void (*exit)(void);
378
Christoph Lametere1783a22010-01-05 15:34:50 +0900379 struct module_ref {
Nick Piggin5fbfb182010-04-01 19:09:40 +1100380 unsigned int incs;
381 unsigned int decs;
Tejun Heo43cf38e2010-02-02 14:38:57 +0900382 } __percpu *refptr;
Richard Kennedyaf540682008-07-22 19:24:26 -0500383#endif
Peter Oberparleiterb99b87f2009-06-17 16:28:03 -0700384
385#ifdef CONFIG_CONSTRUCTORS
386 /* Constructor functions. */
387 ctor_fn_t *ctors;
388 unsigned int num_ctors;
389#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390};
Roman Zippele61a1c12007-05-09 02:35:15 -0700391#ifndef MODULE_ARCH_INIT
392#define MODULE_ARCH_INIT {}
393#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
Tim Abbottc6b37802008-12-05 19:03:59 -0500395extern struct mutex module_mutex;
396
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397/* FIXME: It'd be nice to isolate modules during init, too, so they
398 aren't used before they (may) fail. But presently too much code
399 (IDE & SCSI) require entry into the module during init.*/
400static inline int module_is_live(struct module *mod)
401{
402 return mod->state != MODULE_STATE_GOING;
403}
404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405struct module *__module_text_address(unsigned long addr);
Rusty Russelle6104992009-03-31 13:05:31 -0600406struct module *__module_address(unsigned long addr);
407bool is_module_address(unsigned long addr);
Tejun Heo10fad5e2010-03-10 18:57:54 +0900408bool is_module_percpu_address(unsigned long addr);
Rusty Russelle6104992009-03-31 13:05:31 -0600409bool is_module_text_address(unsigned long addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
Masami Hiramatsua06f6212009-01-06 14:41:49 -0800411static inline int within_module_core(unsigned long addr, struct module *mod)
412{
413 return (unsigned long)mod->module_core <= addr &&
414 addr < (unsigned long)mod->module_core + mod->core_size;
415}
416
417static inline int within_module_init(unsigned long addr, struct module *mod)
418{
419 return (unsigned long)mod->module_init <= addr &&
420 addr < (unsigned long)mod->module_init + mod->init_size;
421}
422
Tim Abbottc6b37802008-12-05 19:03:59 -0500423/* Search for module by name: must hold module_mutex. */
424struct module *find_module(const char *name);
425
426struct symsearch {
427 const struct kernel_symbol *start, *stop;
428 const unsigned long *crcs;
429 enum {
430 NOT_GPL_ONLY,
431 GPL_ONLY,
432 WILL_BE_GPL_ONLY,
433 } licence;
434 bool unused;
435};
436
437/* Search for an exported symbol by name. */
438const struct kernel_symbol *find_symbol(const char *name,
439 struct module **owner,
440 const unsigned long **crc,
441 bool gplok,
442 bool warn);
443
444/* Walk the exported symbol table */
445bool each_symbol(bool (*fn)(const struct symsearch *arr, struct module *owner,
446 unsigned int symnum, void *data), void *data);
447
Alexey Dobriyanea078902007-05-08 00:28:39 -0700448/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 symnum out of range. */
Alexey Dobriyanea078902007-05-08 00:28:39 -0700450int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
451 char *name, char *module_name, int *exported);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453/* Look for this name: can be of form module:name. */
454unsigned long module_kallsyms_lookup_name(const char *name);
455
Anders Kaseorg75a66612008-12-05 19:03:58 -0500456int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
457 struct module *, unsigned long),
458 void *data);
459
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460extern void __module_put_and_exit(struct module *mod, long code)
461 __attribute__((noreturn));
462#define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code);
463
464#ifdef CONFIG_MODULE_UNLOAD
465unsigned int module_refcount(struct module *mod);
466void __symbol_put(const char *symbol);
467#define symbol_put(x) __symbol_put(MODULE_SYMBOL_PREFIX #x)
468void symbol_put_addr(void *addr);
469
470/* Sometimes we know we already have a refcount, and it's easier not
471 to handle the error case (which only happens with rmmod --wait). */
472static inline void __module_get(struct module *module)
473{
474 if (module) {
Christoph Lametere1783a22010-01-05 15:34:50 +0900475 preempt_disable();
Nick Piggin5fbfb182010-04-01 19:09:40 +1100476 __this_cpu_inc(module->refptr->incs);
Li Zefanae832d12010-03-24 10:57:43 +0800477 trace_module_get(module, _THIS_IP_);
Christoph Lametere1783a22010-01-05 15:34:50 +0900478 preempt_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 }
480}
481
482static inline int try_module_get(struct module *module)
483{
484 int ret = 1;
485
486 if (module) {
Christoph Lametere1783a22010-01-05 15:34:50 +0900487 preempt_disable();
488
Li Zefan7ead8b82009-08-17 16:56:28 +0800489 if (likely(module_is_live(module))) {
Nick Piggin5fbfb182010-04-01 19:09:40 +1100490 __this_cpu_inc(module->refptr->incs);
Li Zefanae832d12010-03-24 10:57:43 +0800491 trace_module_get(module, _THIS_IP_);
Nick Piggin5fbfb182010-04-01 19:09:40 +1100492 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 ret = 0;
Christoph Lametere1783a22010-01-05 15:34:50 +0900494
495 preempt_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 }
497 return ret;
498}
499
Al Virof6a57032006-10-18 01:47:25 -0400500extern void module_put(struct module *module);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
502#else /*!CONFIG_MODULE_UNLOAD*/
503static inline int try_module_get(struct module *module)
504{
505 return !module || module_is_live(module);
506}
507static inline void module_put(struct module *module)
508{
509}
510static inline void __module_get(struct module *module)
511{
512}
513#define symbol_put(x) do { } while(0)
514#define symbol_put_addr(p) do { } while(0)
515
516#endif /* CONFIG_MODULE_UNLOAD */
Tim Abbottc6b37802008-12-05 19:03:59 -0500517int use_module(struct module *a, struct module *b);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
519/* This is a #define so the string doesn't get put in every .o file */
520#define module_name(mod) \
521({ \
522 struct module *__mod = (mod); \
523 __mod ? __mod->name : "kernel"; \
524})
525
Rusty Russell6dd06c92008-01-29 17:13:22 -0500526/* For kallsyms to ask for address resolution. namebuf should be at
527 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
528 * found, otherwise NULL. */
Andrew Morton92dfc9d2008-02-08 04:18:43 -0800529const char *module_address_lookup(unsigned long addr,
Rusty Russell6dd06c92008-01-29 17:13:22 -0500530 unsigned long *symbolsize,
531 unsigned long *offset,
532 char **modname,
533 char *namebuf);
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -0700534int lookup_module_symbol_name(unsigned long addr, char *symname);
Alexey Dobriyana5c43da2007-05-08 00:28:47 -0700535int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
537/* For extable.c to search modules' exception tables. */
538const struct exception_table_entry *search_module_extables(unsigned long addr);
539
540int register_module_notifier(struct notifier_block * nb);
541int unregister_module_notifier(struct notifier_block * nb);
542
543extern void print_modules(void);
544
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400545extern void module_update_tracepoints(void);
546extern int module_get_iter_tracepoints(struct tracepoint_iter *iter);
547
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548#else /* !CONFIG_MODULES... */
549#define EXPORT_SYMBOL(sym)
550#define EXPORT_SYMBOL_GPL(sym)
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800551#define EXPORT_SYMBOL_GPL_FUTURE(sym)
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700552#define EXPORT_UNUSED_SYMBOL(sym)
553#define EXPORT_UNUSED_SYMBOL_GPL(sym)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555/* Given an address, look for it in the exception tables. */
556static inline const struct exception_table_entry *
557search_module_extables(unsigned long addr)
558{
559 return NULL;
560}
561
Rusty Russelle6104992009-03-31 13:05:31 -0600562static inline struct module *__module_address(unsigned long addr)
563{
564 return NULL;
565}
566
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567static inline struct module *__module_text_address(unsigned long addr)
568{
569 return NULL;
570}
571
Rusty Russelle6104992009-03-31 13:05:31 -0600572static inline bool is_module_address(unsigned long addr)
Ingo Molnar4d435f92006-07-03 00:24:24 -0700573{
Rusty Russelle6104992009-03-31 13:05:31 -0600574 return false;
575}
576
Randy Dunlapd5e50da2010-03-31 11:33:42 +0900577static inline bool is_module_percpu_address(unsigned long addr)
578{
579 return false;
580}
581
Rusty Russelle6104992009-03-31 13:05:31 -0600582static inline bool is_module_text_address(unsigned long addr)
583{
584 return false;
Ingo Molnar4d435f92006-07-03 00:24:24 -0700585}
586
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587/* Get/put a kernel symbol (calls should be symmetric) */
588#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
589#define symbol_put(x) do { } while(0)
590#define symbol_put_addr(x) do { } while(0)
591
592static inline void __module_get(struct module *module)
593{
594}
595
596static inline int try_module_get(struct module *module)
597{
598 return 1;
599}
600
601static inline void module_put(struct module *module)
602{
603}
604
605#define module_name(mod) "kernel"
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607/* For kallsyms to ask for address resolution. NULL means not found. */
Andrew Morton92dfc9d2008-02-08 04:18:43 -0800608static inline const char *module_address_lookup(unsigned long addr,
Rusty Russell6dd06c92008-01-29 17:13:22 -0500609 unsigned long *symbolsize,
610 unsigned long *offset,
611 char **modname,
612 char *namebuf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613{
614 return NULL;
615}
616
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -0700617static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
618{
619 return -ERANGE;
620}
621
Alexey Dobriyana5c43da2007-05-08 00:28:47 -0700622static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
623{
624 return -ERANGE;
625}
626
Alexey Dobriyanea078902007-05-08 00:28:39 -0700627static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
628 char *type, char *name,
629 char *module_name, int *exported)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630{
Alexey Dobriyanea078902007-05-08 00:28:39 -0700631 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632}
633
634static inline unsigned long module_kallsyms_lookup_name(const char *name)
635{
636 return 0;
637}
638
Anders Kaseorg75a66612008-12-05 19:03:58 -0500639static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
640 struct module *,
641 unsigned long),
642 void *data)
643{
644 return 0;
645}
646
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647static inline int register_module_notifier(struct notifier_block * nb)
648{
649 /* no events will happen anyway, so this can always succeed */
650 return 0;
651}
652
653static inline int unregister_module_notifier(struct notifier_block * nb)
654{
655 return 0;
656}
657
658#define module_put_and_exit(code) do_exit(code)
659
660static inline void print_modules(void)
661{
662}
663
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -0400664static inline void module_update_tracepoints(void)
665{
666}
667
668static inline int module_get_iter_tracepoints(struct tracepoint_iter *iter)
669{
670 return 0;
671}
672
Randy Dunlapef665c12007-02-13 15:19:06 -0800673#endif /* CONFIG_MODULES */
674
Randy Dunlapef665c12007-02-13 15:19:06 -0800675#ifdef CONFIG_SYSFS
Greg Kroah-Hartman7405c1e2007-11-01 10:39:50 -0700676extern struct kset *module_kset;
677extern struct kobj_type module_ktype;
678extern int module_sysfs_initialized;
Randy Dunlapef665c12007-02-13 15:19:06 -0800679#endif /* CONFIG_SYSFS */
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
682
683/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685#define __MODULE_STRING(x) __stringify(x)
686
Andrew Morton0d9c25d2009-06-16 15:33:37 -0700687
688#ifdef CONFIG_GENERIC_BUG
689int module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
690 struct module *);
691void module_bug_cleanup(struct module *);
692
693#else /* !CONFIG_GENERIC_BUG */
694
695static inline int module_bug_finalize(const Elf_Ehdr *hdr,
696 const Elf_Shdr *sechdrs,
697 struct module *mod)
698{
699 return 0;
700}
701static inline void module_bug_cleanup(struct module *mod) {}
702#endif /* CONFIG_GENERIC_BUG */
703
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704#endif /* _LINUX_MODULE_H */