← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to include/linux/module.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/linux/module.h
 
1
#ifndef _LINUX_MODULE_H
 
2
#define _LINUX_MODULE_H
 
3
/*
 
4
 * Dynamic loading of modules into the kernel.
 
5
 *
 
6
 * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
 
7
 * Rewritten again by Rusty Russell, 2002
 
8
 */
 
9
#include <linux/list.h>
 
10
#include <linux/stat.h>
 
11
#include <linux/compiler.h>
 
12
#include <linux/cache.h>
 
13
#include <linux/kmod.h>
 
14
#include <linux/elf.h>
 
15
#include <linux/stringify.h>
 
16
#include <linux/kobject.h>
 
17
#include <linux/moduleparam.h>
 
18
#include <linux/tracepoint.h>
 
19
#include <linux/export.h>
 
20
 
 
21
#include <linux/percpu.h>
 
22
#include <asm/module.h>
 
23
 
 
24
#include <trace/events/module.h>
 
25
 
 
26
/* Not Yet Implemented */
 
27
#define MODULE_SUPPORTED_DEVICE(name)
 
28
 
 
29
#define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
 
30
 
 
31
struct modversion_info
 
32
{
 
33
        unsigned long crc;
 
34
        char name[MODULE_NAME_LEN];
 
35
};
 
36
 
 
37
struct module;
 
38
 
 
39
struct module_kobject {
 
40
        struct kobject kobj;
 
41
        struct module *mod;
 
42
        struct kobject *drivers_dir;
 
43
        struct module_param_attrs *mp;
 
44
};
 
45
 
 
46
struct module_attribute {
 
47
        struct attribute attr;
 
48
        ssize_t (*show)(struct module_attribute *, struct module_kobject *,
 
49
                        char *);
 
50
        ssize_t (*store)(struct module_attribute *, struct module_kobject *,
 
51
                         const char *, size_t count);
 
52
        void (*setup)(struct module *, const char *);
 
53
        int (*test)(struct module *);
 
54
        void (*free)(struct module *);
 
55
};
 
56
 
 
57
struct module_version_attribute {
 
58
        struct module_attribute mattr;
 
59
        const char *module_name;
 
60
        const char *version;
 
61
} __attribute__ ((__aligned__(sizeof(void *))));
 
62
 
 
63
extern ssize_t __modver_version_show(struct module_attribute *,
 
64
                                     struct module_kobject *, char *);
 
65
 
 
66
extern struct module_attribute module_uevent;
 
67
 
 
68
/* These are either module local, or the kernel's dummy ones. */
 
69
extern int init_module(void);
 
70
extern void cleanup_module(void);
 
71
 
 
72
/* Archs provide a method of finding the correct exception table. */
 
73
struct exception_table_entry;
 
74
 
 
75
const struct exception_table_entry *
 
76
search_extable(const struct exception_table_entry *first,
 
77
               const struct exception_table_entry *last,
 
78
               unsigned long value);
 
79
void sort_extable(struct exception_table_entry *start,
 
80
                  struct exception_table_entry *finish);
 
81
void sort_main_extable(void);
 
82
void trim_init_extable(struct module *m);
 
83
 
 
84
#ifdef MODULE
 
85
#define MODULE_GENERIC_TABLE(gtype,name)                        \
 
86
extern const struct gtype##_id __mod_##gtype##_table            \
 
87
  __attribute__ ((unused, alias(__stringify(name))))
 
88
 
 
89
#else  /* !MODULE */
 
90
#define MODULE_GENERIC_TABLE(gtype,name)
 
91
#endif
 
92
 
 
93
/* Generic info of form tag = "info" */
 
94
#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
 
95
 
 
96
/* For userspace: you can also call me... */
 
97
#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
 
98
 
 
99
/*
 
100
 * The following license idents are currently accepted as indicating free
 
101
 * software modules
 
102
 *
 
103
 *      "GPL"                           [GNU Public License v2 or later]
 
104
 *      "GPL v2"                        [GNU Public License v2]
 
105
 *      "GPL and additional rights"     [GNU Public License v2 rights and more]
 
106
 *      "Dual BSD/GPL"                  [GNU Public License v2
 
107
 *                                       or BSD license choice]
 
108
 *      "Dual MIT/GPL"                  [GNU Public License v2
 
109
 *                                       or MIT license choice]
 
110
 *      "Dual MPL/GPL"                  [GNU Public License v2
 
111
 *                                       or Mozilla license choice]
 
112
 *
 
113
 * The following other idents are available
 
114
 *
 
115
 *      "Proprietary"                   [Non free products]
 
116
 *
 
117
 * There are dual licensed components, but when running with Linux it is the
 
118
 * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
 
119
 * is a GPL combined work.
 
120
 *
 
121
 * This exists for several reasons
 
122
 * 1.   So modinfo can show license info for users wanting to vet their setup 
 
123
 *      is free
 
124
 * 2.   So the community can ignore bug reports including proprietary modules
 
125
 * 3.   So vendors can do likewise based on their own policies
 
126
 */
 
127
#define MODULE_LICENSE(_license) MODULE_INFO(license, _license)
 
128
 
 
129
/*
 
130
 * Author(s), use "Name <email>" or just "Name", for multiple
 
131
 * authors use multiple MODULE_AUTHOR() statements/lines.
 
132
 */
 
133
#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
 
134
  
 
135
/* What your module does. */
 
136
#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
 
137
 
 
138
#define MODULE_DEVICE_TABLE(type,name)          \
 
139
  MODULE_GENERIC_TABLE(type##_device,name)
 
140
 
 
141
/* Version of form [<epoch>:]<version>[-<extra-version>].
 
142
   Or for CVS/RCS ID version, everything but the number is stripped.
 
143
  <epoch>: A (small) unsigned integer which allows you to start versions
 
144
           anew. If not mentioned, it's zero.  eg. "2:1.0" is after
 
145
           "1:2.0".
 
146
  <version>: The <version> may contain only alphanumerics and the
 
147
           character `.'.  Ordered by numeric sort for numeric parts,
 
148
           ascii sort for ascii parts (as per RPM or DEB algorithm).
 
149
  <extraversion>: Like <version>, but inserted for local
 
150
           customizations, eg "rh3" or "rusty1".
 
151
 
 
152
  Using this automatically adds a checksum of the .c files and the
 
153
  local headers in "srcversion".
 
154
*/
 
155
 
 
156
#if defined(MODULE) || !defined(CONFIG_SYSFS)
 
157
#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
 
158
#else
 
159
#define MODULE_VERSION(_version)                                        \
 
160
        static struct module_version_attribute ___modver_attr = {       \
 
161
                .mattr  = {                                             \
 
162
                        .attr   = {                                     \
 
163
                                .name   = "version",                    \
 
164
                                .mode   = S_IRUGO,                      \
 
165
                        },                                              \
 
166
                        .show   = __modver_version_show,                \
 
167
                },                                                      \
 
168
                .module_name    = KBUILD_MODNAME,                       \
 
169
                .version        = _version,                             \
 
170
        };                                                              \
 
171
        static const struct module_version_attribute                    \
 
172
        __used __attribute__ ((__section__ ("__modver")))               \
 
173
        * __moduleparam_const __modver_attr = &___modver_attr
 
174
#endif
 
175
 
 
176
/* Optional firmware file (or files) needed by the module
 
177
 * format is simply firmware file name.  Multiple firmware
 
178
 * files require multiple MODULE_FIRMWARE() specifiers */
 
179
#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
 
180
 
 
181
/* Given an address, look for it in the exception tables */
 
182
const struct exception_table_entry *search_exception_tables(unsigned long add);
 
183
 
 
184
struct notifier_block;
 
185
 
 
186
#ifdef CONFIG_MODULES
 
187
 
 
188
extern int modules_disabled; /* for sysctl */
 
189
/* Get/put a kernel symbol (calls must be symmetric) */
 
190
void *__symbol_get(const char *symbol);
 
191
void *__symbol_get_gpl(const char *symbol);
 
192
#define symbol_get(x) ((typeof(&x))(__symbol_get(MODULE_SYMBOL_PREFIX #x)))
 
193
 
 
194
/* modules using other modules: kdb wants to see this. */
 
195
struct module_use {
 
196
        struct list_head source_list;
 
197
        struct list_head target_list;
 
198
        struct module *source, *target;
 
199
};
 
200
 
 
201
enum module_state
 
202
{
 
203
        MODULE_STATE_LIVE,
 
204
        MODULE_STATE_COMING,
 
205
        MODULE_STATE_GOING,
 
206
};
 
207
 
 
208
struct module
 
209
{
 
210
        enum module_state state;
 
211
 
 
212
        /* Member of list of modules */
 
213
        struct list_head list;
 
214
 
 
215
        /* Unique handle for this module */
 
216
        char name[MODULE_NAME_LEN];
 
217
 
 
218
        /* Sysfs stuff. */
 
219
        struct module_kobject mkobj;
 
220
        struct module_attribute *modinfo_attrs;
 
221
        const char *version;
 
222
        const char *srcversion;
 
223
        struct kobject *holders_dir;
 
224
 
 
225
        /* Exported symbols */
 
226
        const struct kernel_symbol *syms;
 
227
        const unsigned long *crcs;
 
228
        unsigned int num_syms;
 
229
 
 
230
        /* Kernel parameters. */
 
231
        struct kernel_param *kp;
 
232
        unsigned int num_kp;
 
233
 
 
234
        /* GPL-only exported symbols. */
 
235
        unsigned int num_gpl_syms;
 
236
        const struct kernel_symbol *gpl_syms;
 
237
        const unsigned long *gpl_crcs;
 
238
 
 
239
#ifdef CONFIG_UNUSED_SYMBOLS
 
240
        /* unused exported symbols. */
 
241
        const struct kernel_symbol *unused_syms;
 
242
        const unsigned long *unused_crcs;
 
243
        unsigned int num_unused_syms;
 
244
 
 
245
        /* GPL-only, unused exported symbols. */
 
246
        unsigned int num_unused_gpl_syms;
 
247
        const struct kernel_symbol *unused_gpl_syms;
 
248
        const unsigned long *unused_gpl_crcs;
 
249
#endif
 
250
 
 
251
        /* symbols that will be GPL-only in the near future. */
 
252
        const struct kernel_symbol *gpl_future_syms;
 
253
        const unsigned long *gpl_future_crcs;
 
254
        unsigned int num_gpl_future_syms;
 
255
 
 
256
        /* Exception table */
 
257
        unsigned int num_exentries;
 
258
        struct exception_table_entry *extable;
 
259
 
 
260
        /* Startup function. */
 
261
        int (*init)(void);
 
262
 
 
263
        /* If this is non-NULL, vfree after init() returns */
 
264
        void *module_init;
 
265
 
 
266
        /* Here is the actual code + data, vfree'd on unload. */
 
267
        void *module_core;
 
268
 
 
269
        /* Here are the sizes of the init and core sections */
 
270
        unsigned int init_size, core_size;
 
271
 
 
272
        /* The size of the executable code in each section.  */
 
273
        unsigned int init_text_size, core_text_size;
 
274
 
 
275
        /* Size of RO sections of the module (text+rodata) */
 
276
        unsigned int init_ro_size, core_ro_size;
 
277
 
 
278
        /* Arch-specific module values */
 
279
        struct mod_arch_specific arch;
 
280
 
 
281
        unsigned int taints;    /* same bits as kernel:tainted */
 
282
 
 
283
#ifdef CONFIG_GENERIC_BUG
 
284
        /* Support for BUG */
 
285
        unsigned num_bugs;
 
286
        struct list_head bug_list;
 
287
        struct bug_entry *bug_table;
 
288
#endif
 
289
 
 
290
#ifdef CONFIG_KALLSYMS
 
291
        /*
 
292
         * We keep the symbol and string tables for kallsyms.
 
293
         * The core_* fields below are temporary, loader-only (they
 
294
         * could really be discarded after module init).
 
295
         */
 
296
        Elf_Sym *symtab, *core_symtab;
 
297
        unsigned int num_symtab, core_num_syms;
 
298
        char *strtab, *core_strtab;
 
299
 
 
300
        /* Section attributes */
 
301
        struct module_sect_attrs *sect_attrs;
 
302
 
 
303
        /* Notes attributes */
 
304
        struct module_notes_attrs *notes_attrs;
 
305
#endif
 
306
 
 
307
        /* The command line arguments (may be mangled).  People like
 
308
           keeping pointers to this stuff */
 
309
        char *args;
 
310
 
 
311
#ifdef CONFIG_SMP
 
312
        /* Per-cpu data. */
 
313
        void __percpu *percpu;
 
314
        unsigned int percpu_size;
 
315
#endif
 
316
 
 
317
#ifdef CONFIG_TRACEPOINTS
 
318
        unsigned int num_tracepoints;
 
319
        struct tracepoint * const *tracepoints_ptrs;
 
320
#endif
 
321
#ifdef HAVE_JUMP_LABEL
 
322
        struct jump_entry *jump_entries;
 
323
        unsigned int num_jump_entries;
 
324
#endif
 
325
#ifdef CONFIG_TRACING
 
326
        unsigned int num_trace_bprintk_fmt;
 
327
        const char **trace_bprintk_fmt_start;
 
328
#endif
 
329
#ifdef CONFIG_EVENT_TRACING
 
330
        struct ftrace_event_call **trace_events;
 
331
        unsigned int num_trace_events;
 
332
#endif
 
333
#ifdef CONFIG_FTRACE_MCOUNT_RECORD
 
334
        unsigned int num_ftrace_callsites;
 
335
        unsigned long *ftrace_callsites;
 
336
#endif
 
337
 
 
338
#ifdef CONFIG_MODULE_UNLOAD
 
339
        /* What modules depend on me? */
 
340
        struct list_head source_list;
 
341
        /* What modules do I depend on? */
 
342
        struct list_head target_list;
 
343
 
 
344
        /* Who is waiting for us to be unloaded */
 
345
        struct task_struct *waiter;
 
346
 
 
347
        /* Destruction function. */
 
348
        void (*exit)(void);
 
349
 
 
350
        struct module_ref {
 
351
                unsigned int incs;
 
352
                unsigned int decs;
 
353
        } __percpu *refptr;
 
354
#endif
 
355
 
 
356
#ifdef CONFIG_CONSTRUCTORS
 
357
        /* Constructor functions. */
 
358
        ctor_fn_t *ctors;
 
359
        unsigned int num_ctors;
 
360
#endif
 
361
};
 
362
#ifndef MODULE_ARCH_INIT
 
363
#define MODULE_ARCH_INIT {}
 
364
#endif
 
365
 
 
366
extern struct mutex module_mutex;
 
367
 
 
368
/* FIXME: It'd be nice to isolate modules during init, too, so they
 
369
   aren't used before they (may) fail.  But presently too much code
 
370
   (IDE & SCSI) require entry into the module during init.*/
 
371
static inline int module_is_live(struct module *mod)
 
372
{
 
373
        return mod->state != MODULE_STATE_GOING;
 
374
}
 
375
 
 
376
struct module *__module_text_address(unsigned long addr);
 
377
struct module *__module_address(unsigned long addr);
 
378
bool is_module_address(unsigned long addr);
 
379
bool is_module_percpu_address(unsigned long addr);
 
380
bool is_module_text_address(unsigned long addr);
 
381
 
 
382
static inline int within_module_core(unsigned long addr, struct module *mod)
 
383
{
 
384
        return (unsigned long)mod->module_core <= addr &&
 
385
               addr < (unsigned long)mod->module_core + mod->core_size;
 
386
}
 
387
 
 
388
static inline int within_module_init(unsigned long addr, struct module *mod)
 
389
{
 
390
        return (unsigned long)mod->module_init <= addr &&
 
391
               addr < (unsigned long)mod->module_init + mod->init_size;
 
392
}
 
393
 
 
394
/* Search for module by name: must hold module_mutex. */
 
395
struct module *find_module(const char *name);
 
396
 
 
397
struct symsearch {
 
398
        const struct kernel_symbol *start, *stop;
 
399
        const unsigned long *crcs;
 
400
        enum {
 
401
                NOT_GPL_ONLY,
 
402
                GPL_ONLY,
 
403
                WILL_BE_GPL_ONLY,
 
404
        } licence;
 
405
        bool unused;
 
406
};
 
407
 
 
408
/* Search for an exported symbol by name. */
 
409
const struct kernel_symbol *find_symbol(const char *name,
 
410
                                        struct module **owner,
 
411
                                        const unsigned long **crc,
 
412
                                        bool gplok,
 
413
                                        bool warn);
 
414
 
 
415
/* Walk the exported symbol table */
 
416
bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
 
417
                                    struct module *owner,
 
418
                                    void *data), void *data);
 
419
 
 
420
/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
 
421
   symnum out of range. */
 
422
int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
 
423
                        char *name, char *module_name, int *exported);
 
424
 
 
425
/* Look for this name: can be of form module:name. */
 
426
unsigned long module_kallsyms_lookup_name(const char *name);
 
427
 
 
428
int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
 
429
                                             struct module *, unsigned long),
 
430
                                   void *data);
 
431
 
 
432
extern void __module_put_and_exit(struct module *mod, long code)
 
433
        __attribute__((noreturn));
 
434
#define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code);
 
435
 
 
436
#ifdef CONFIG_MODULE_UNLOAD
 
437
unsigned int module_refcount(struct module *mod);
 
438
void __symbol_put(const char *symbol);
 
439
#define symbol_put(x) __symbol_put(MODULE_SYMBOL_PREFIX #x)
 
440
void symbol_put_addr(void *addr);
 
441
 
 
442
/* Sometimes we know we already have a refcount, and it's easier not
 
443
   to handle the error case (which only happens with rmmod --wait). */
 
444
static inline void __module_get(struct module *module)
 
445
{
 
446
        if (module) {
 
447
                preempt_disable();
 
448
                __this_cpu_inc(module->refptr->incs);
 
449
                trace_module_get(module, _THIS_IP_);
 
450
                preempt_enable();
 
451
        }
 
452
}
 
453
 
 
454
static inline int try_module_get(struct module *module)
 
455
{
 
456
        int ret = 1;
 
457
 
 
458
        if (module) {
 
459
                preempt_disable();
 
460
 
 
461
                if (likely(module_is_live(module))) {
 
462
                        __this_cpu_inc(module->refptr->incs);
 
463
                        trace_module_get(module, _THIS_IP_);
 
464
                } else
 
465
                        ret = 0;
 
466
 
 
467
                preempt_enable();
 
468
        }
 
469
        return ret;
 
470
}
 
471
 
 
472
extern void module_put(struct module *module);
 
473
 
 
474
#else /*!CONFIG_MODULE_UNLOAD*/
 
475
static inline int try_module_get(struct module *module)
 
476
{
 
477
        return !module || module_is_live(module);
 
478
}
 
479
static inline void module_put(struct module *module)
 
480
{
 
481
}
 
482
static inline void __module_get(struct module *module)
 
483
{
 
484
}
 
485
#define symbol_put(x) do { } while(0)
 
486
#define symbol_put_addr(p) do { } while(0)
 
487
 
 
488
#endif /* CONFIG_MODULE_UNLOAD */
 
489
int ref_module(struct module *a, struct module *b);
 
490
 
 
491
/* This is a #define so the string doesn't get put in every .o file */
 
492
#define module_name(mod)                        \
 
493
({                                              \
 
494
        struct module *__mod = (mod);           \
 
495
        __mod ? __mod->name : "kernel";         \
 
496
})
 
497
 
 
498
/* For kallsyms to ask for address resolution.  namebuf should be at
 
499
 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
 
500
 * found, otherwise NULL. */
 
501
const char *module_address_lookup(unsigned long addr,
 
502
                            unsigned long *symbolsize,
 
503
                            unsigned long *offset,
 
504
                            char **modname,
 
505
                            char *namebuf);
 
506
int lookup_module_symbol_name(unsigned long addr, char *symname);
 
507
int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
 
508
 
 
509
/* For extable.c to search modules' exception tables. */
 
510
const struct exception_table_entry *search_module_extables(unsigned long addr);
 
511
 
 
512
int register_module_notifier(struct notifier_block * nb);
 
513
int unregister_module_notifier(struct notifier_block * nb);
 
514
 
 
515
extern void print_modules(void);
 
516
 
 
517
#else /* !CONFIG_MODULES... */
 
518
 
 
519
/* Given an address, look for it in the exception tables. */
 
520
static inline const struct exception_table_entry *
 
521
search_module_extables(unsigned long addr)
 
522
{
 
523
        return NULL;
 
524
}
 
525
 
 
526
static inline struct module *__module_address(unsigned long addr)
 
527
{
 
528
        return NULL;
 
529
}
 
530
 
 
531
static inline struct module *__module_text_address(unsigned long addr)
 
532
{
 
533
        return NULL;
 
534
}
 
535
 
 
536
static inline bool is_module_address(unsigned long addr)
 
537
{
 
538
        return false;
 
539
}
 
540
 
 
541
static inline bool is_module_percpu_address(unsigned long addr)
 
542
{
 
543
        return false;
 
544
}
 
545
 
 
546
static inline bool is_module_text_address(unsigned long addr)
 
547
{
 
548
        return false;
 
549
}
 
550
 
 
551
/* Get/put a kernel symbol (calls should be symmetric) */
 
552
#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
 
553
#define symbol_put(x) do { } while(0)
 
554
#define symbol_put_addr(x) do { } while(0)
 
555
 
 
556
static inline void __module_get(struct module *module)
 
557
{
 
558
}
 
559
 
 
560
static inline int try_module_get(struct module *module)
 
561
{
 
562
        return 1;
 
563
}
 
564
 
 
565
static inline void module_put(struct module *module)
 
566
{
 
567
}
 
568
 
 
569
#define module_name(mod) "kernel"
 
570
 
 
571
/* For kallsyms to ask for address resolution.  NULL means not found. */
 
572
static inline const char *module_address_lookup(unsigned long addr,
 
573
                                          unsigned long *symbolsize,
 
574
                                          unsigned long *offset,
 
575
                                          char **modname,
 
576
                                          char *namebuf)
 
577
{
 
578
        return NULL;
 
579
}
 
580
 
 
581
static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
 
582
{
 
583
        return -ERANGE;
 
584
}
 
585
 
 
586
static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
 
587
{
 
588
        return -ERANGE;
 
589
}
 
590
 
 
591
static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
 
592
                                        char *type, char *name,
 
593
                                        char *module_name, int *exported)
 
594
{
 
595
        return -ERANGE;
 
596
}
 
597
 
 
598
static inline unsigned long module_kallsyms_lookup_name(const char *name)
 
599
{
 
600
        return 0;
 
601
}
 
602
 
 
603
static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
 
604
                                                           struct module *,
 
605
                                                           unsigned long),
 
606
                                                 void *data)
 
607
{
 
608
        return 0;
 
609
}
 
610
 
 
611
static inline int register_module_notifier(struct notifier_block * nb)
 
612
{
 
613
        /* no events will happen anyway, so this can always succeed */
 
614
        return 0;
 
615
}
 
616
 
 
617
static inline int unregister_module_notifier(struct notifier_block * nb)
 
618
{
 
619
        return 0;
 
620
}
 
621
 
 
622
#define module_put_and_exit(code) do_exit(code)
 
623
 
 
624
static inline void print_modules(void)
 
625
{
 
626
}
 
627
#endif /* CONFIG_MODULES */
 
628
 
 
629
#ifdef CONFIG_SYSFS
 
630
extern struct kset *module_kset;
 
631
extern struct kobj_type module_ktype;
 
632
extern int module_sysfs_initialized;
 
633
#endif /* CONFIG_SYSFS */
 
634
 
 
635
#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
 
636
 
 
637
/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
 
638
 
 
639
#define __MODULE_STRING(x) __stringify(x)
 
640
 
 
641
#ifdef CONFIG_DEBUG_SET_MODULE_RONX
 
642
extern void set_all_modules_text_rw(void);
 
643
extern void set_all_modules_text_ro(void);
 
644
#else
 
645
static inline void set_all_modules_text_rw(void) { }
 
646
static inline void set_all_modules_text_ro(void) { }
 
647
#endif
 
648
 
 
649
#ifdef CONFIG_GENERIC_BUG
 
650
void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
 
651
                         struct module *);
 
652
void module_bug_cleanup(struct module *);
 
653
 
 
654
#else   /* !CONFIG_GENERIC_BUG */
 
655
 
 
656
static inline void module_bug_finalize(const Elf_Ehdr *hdr,
 
657
                                        const Elf_Shdr *sechdrs,
 
658
                                        struct module *mod)
 
659
{
 
660
}
 
661
static inline void module_bug_cleanup(struct module *mod) {}
 
662
#endif  /* CONFIG_GENERIC_BUG */
 
663
 
 
664
#endif /* _LINUX_MODULE_H */