LCOV - code coverage report
Current view: top level - lkbce/include/linux - module.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 4 4 100.0 %
Date: 2017-01-25 Functions: 2 2 100.0 %

          Line data    Source code
       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             : 
      20             : #include <asm/local.h>
      21             : #include <asm/module.h>
      22             : 
      23             : #include <trace/events/module.h>
      24             : 
      25             : /* Not Yet Implemented */
      26             : #define MODULE_SUPPORTED_DEVICE(name)
      27             : 
      28             : /* Some toolchains use a `_' prefix for all user symbols. */
      29             : #ifdef CONFIG_SYMBOL_PREFIX
      30             : #define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX
      31             : #else
      32             : #define MODULE_SYMBOL_PREFIX ""
      33             : #endif
      34             : 
      35             : #define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
      36             : 
      37             : struct kernel_symbol
      38             : {
      39             :         unsigned long value;
      40             :         const char *name;
      41             : };
      42             : 
      43             : struct modversion_info
      44             : {
      45             :         unsigned long crc;
      46             :         char name[MODULE_NAME_LEN];
      47             : };
      48             : 
      49             : struct module;
      50             : 
      51             : struct 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);
      56             :         void (*setup)(struct module *, const char *);
      57             :         int (*test)(struct module *);
      58             :         void (*free)(struct module *);
      59             : };
      60             : 
      61             : struct module_kobject
      62             : {
      63             :         struct kobject kobj;
      64             :         struct module *mod;
      65             :         struct kobject *drivers_dir;
      66             :         struct module_param_attrs *mp;
      67             : };
      68             : 
      69             : /* These are either module local, or the kernel's dummy ones. */
      70             : extern int init_module(void);
      71             : extern void cleanup_module(void);
      72             : 
      73             : /* Archs provide a method of finding the correct exception table. */
      74             : struct exception_table_entry;
      75             : 
      76             : const struct exception_table_entry *
      77             : search_extable(const struct exception_table_entry *first,
      78             :                const struct exception_table_entry *last,
      79             :                unsigned long value);
      80             : void sort_extable(struct exception_table_entry *start,
      81             :                   struct exception_table_entry *finish);
      82             : void sort_main_extable(void);
      83             : void trim_init_extable(struct module *m);
      84             : 
      85             : #ifdef MODULE
      86             : #define MODULE_GENERIC_TABLE(gtype,name)                        \
      87             : extern const struct gtype##_id __mod_##gtype##_table            \
      88             :   __attribute__ ((unused, alias(__stringify(name))))
      89             : 
      90             : extern 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]
     112             :  *      "Dual MIT/GPL"                        [GNU Public License v2
     113             :  *                                       or MIT license choice]
     114             :  *      "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             : 
     133             : /*
     134             :  * Author(s), use "Name <email>" or just "Name", for multiple
     135             :  * authors use multiple MODULE_AUTHOR() statements/lines.
     136             :  */
     137             : #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             : 
     166             : /* 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             : 
     171             : /* Given an address, look for it in the exception tables */
     172             : const struct exception_table_entry *search_exception_tables(unsigned long add);
     173             : 
     174             : struct notifier_block;
     175             : 
     176             : #ifdef CONFIG_MODULES
     177             : 
     178             : /* Get/put a kernel symbol (calls must be symmetric) */
     179             : void *__symbol_get(const char *symbol);
     180             : void *__symbol_get_gpl(const char *symbol);
     181             : #define symbol_get(x) ((typeof(&x))(__symbol_get(MODULE_SYMBOL_PREFIX #x)))
     182             : 
     183             : #ifndef __GENKSYMS__
     184             : #ifdef CONFIG_MODVERSIONS
     185             : /* Mark the CRC weak since genksyms apparently decides not to
     186             :  * generate a checksums for some symbols */
     187             : #define __CRC_SYMBOL(sym, sec)                                  \
     188             :         extern void *__crc_##sym __attribute__((weak));         \
     189             :         static const unsigned long __kcrctab_##sym              \
     190             :         __used                                                  \
     191             :         __attribute__((section("__kcrctab" sec), unused))     \
     192             :         = (unsigned long) &__crc_##sym;
     193             : #else
     194             : #define __CRC_SYMBOL(sym, sec)
     195             : #endif
     196             : 
     197             : /* For every exported symbol, place a struct in the __ksymtab section */
     198             : #define __EXPORT_SYMBOL(sym, sec)                               \
     199             :         extern typeof(sym) sym;                                 \
     200             :         __CRC_SYMBOL(sym, sec)                                  \
     201             :         static const char __kstrtab_##sym[]                     \
     202             :         __attribute__((section("__ksymtab_strings"), aligned(1))) \
     203             :         = MODULE_SYMBOL_PREFIX #sym;                            \
     204             :         static const struct kernel_symbol __ksymtab_##sym       \
     205             :         __used                                                  \
     206             :         __attribute__((section("__ksymtab" sec), unused))     \
     207             :         = { (unsigned long)&sym, __kstrtab_##sym }
     208             : 
     209             : #define EXPORT_SYMBOL(sym)                                      \
     210             :         __EXPORT_SYMBOL(sym, "")
     211             : 
     212             : #define EXPORT_SYMBOL_GPL(sym)                                  \
     213             :         __EXPORT_SYMBOL(sym, "_gpl")
     214             : 
     215             : #define EXPORT_SYMBOL_GPL_FUTURE(sym)                           \
     216             :         __EXPORT_SYMBOL(sym, "_gpl_future")
     217             : 
     218             : 
     219             : #ifdef CONFIG_UNUSED_SYMBOLS
     220             : #define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused")
     221             : #define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl")
     222             : #else
     223             : #define EXPORT_UNUSED_SYMBOL(sym)
     224             : #define EXPORT_UNUSED_SYMBOL_GPL(sym)
     225             : #endif
     226             : 
     227             : #endif
     228             : 
     229             : enum module_state
     230             : {
     231             :         MODULE_STATE_LIVE,
     232             :         MODULE_STATE_COMING,
     233             :         MODULE_STATE_GOING,
     234             : };
     235             : 
     236             : struct module
     237             : {
     238             :         enum module_state state;
     239             : 
     240             :         /* Member of list of modules */
     241             :         struct list_head list;
     242             : 
     243             :         /* Unique handle for this module */
     244             :         char name[MODULE_NAME_LEN];
     245             : 
     246             :         /* Sysfs stuff. */
     247             :         struct module_kobject mkobj;
     248             :         struct module_attribute *modinfo_attrs;
     249             :         const char *version;
     250             :         const char *srcversion;
     251             :         struct kobject *holders_dir;
     252             : 
     253             :         /* Exported symbols */
     254             :         const struct kernel_symbol *syms;
     255             :         const unsigned long *crcs;
     256             :         unsigned int num_syms;
     257             : 
     258             :         /* Kernel parameters. */
     259             :         struct kernel_param *kp;
     260             :         unsigned int num_kp;
     261             : 
     262             :         /* GPL-only exported symbols. */
     263             :         unsigned int num_gpl_syms;
     264             :         const struct kernel_symbol *gpl_syms;
     265             :         const unsigned long *gpl_crcs;
     266             : 
     267             : #ifdef CONFIG_UNUSED_SYMBOLS
     268             :         /* unused exported symbols. */
     269             :         const struct kernel_symbol *unused_syms;
     270             :         const unsigned long *unused_crcs;
     271             :         unsigned int num_unused_syms;
     272             : 
     273             :         /* GPL-only, unused exported symbols. */
     274             :         unsigned int num_unused_gpl_syms;
     275             :         const struct kernel_symbol *unused_gpl_syms;
     276             :         const unsigned long *unused_gpl_crcs;
     277             : #endif
     278             : 
     279             :         /* symbols that will be GPL-only in the near future. */
     280             :         const struct kernel_symbol *gpl_future_syms;
     281             :         const unsigned long *gpl_future_crcs;
     282             :         unsigned int num_gpl_future_syms;
     283             : 
     284             :         /* Exception table */
     285             :         unsigned int num_exentries;
     286             :         struct exception_table_entry *extable;
     287             : 
     288             :         /* Startup function. */
     289             :         int (*init)(void);
     290             : 
     291             :         /* If this is non-NULL, vfree after init() returns */
     292             :         void *module_init;
     293             : 
     294             :         /* Here is the actual code + data, vfree'd on unload. */
     295             :         void *module_core;
     296             : 
     297             :         /* Here are the sizes of the init and core sections */
     298             :         unsigned int init_size, core_size;
     299             : 
     300             :         /* The size of the executable code in each section.  */
     301             :         unsigned int init_text_size, core_text_size;
     302             : 
     303             :         /* Arch-specific module values */
     304             :         struct mod_arch_specific arch;
     305             : 
     306             :         unsigned int taints;    /* same bits as kernel:tainted */
     307             : 
     308             : #ifdef CONFIG_GENERIC_BUG
     309             :         /* Support for BUG */
     310             :         unsigned num_bugs;
     311             :         struct list_head bug_list;
     312             :         struct bug_entry *bug_table;
     313             : #endif
     314             : 
     315             : #ifdef CONFIG_KALLSYMS
     316             :         /*
     317             :          * We keep the symbol and string tables for kallsyms.
     318             :          * The core_* fields below are temporary, loader-only (they
     319             :          * could really be discarded after module init).
     320             :          */
     321             :         Elf_Sym *symtab, *core_symtab;
     322             :         unsigned int num_symtab, core_num_syms;
     323             :         char *strtab, *core_strtab;
     324             : 
     325             :         /* Section attributes */
     326             :         struct module_sect_attrs *sect_attrs;
     327             : 
     328             :         /* Notes attributes */
     329             :         struct module_notes_attrs *notes_attrs;
     330             : #endif
     331             : 
     332             :         /* Per-cpu data. */
     333             :         void *percpu;
     334             : 
     335             :         /* The command line arguments (may be mangled).  People like
     336             :            keeping pointers to this stuff */
     337             :         char *args;
     338             : #ifdef CONFIG_TRACEPOINTS
     339             :         struct tracepoint *tracepoints;
     340             :         unsigned int num_tracepoints;
     341             : #endif
     342             : 
     343             : #ifdef CONFIG_TRACING
     344             :         const char **trace_bprintk_fmt_start;
     345             :         unsigned int num_trace_bprintk_fmt;
     346             : #endif
     347             : #ifdef CONFIG_EVENT_TRACING
     348             :         struct ftrace_event_call *trace_events;
     349             :         unsigned int num_trace_events;
     350             : #endif
     351             : #ifdef CONFIG_FTRACE_MCOUNT_RECORD
     352             :         unsigned long *ftrace_callsites;
     353             :         unsigned int num_ftrace_callsites;
     354             : #endif
     355             : 
     356             : #ifdef CONFIG_MODULE_UNLOAD
     357             :         /* What modules depend on me? */
     358             :         struct list_head modules_which_use_me;
     359             : 
     360             :         /* Who is waiting for us to be unloaded */
     361             :         struct task_struct *waiter;
     362             : 
     363             :         /* Destruction function. */
     364             :         void (*exit)(void);
     365             : 
     366             : #ifdef CONFIG_SMP
     367             :         char *refptr;
     368             : #else
     369             :         local_t ref;
     370             : #endif
     371             : #endif
     372             : 
     373             : #ifdef CONFIG_CONSTRUCTORS
     374             :         /* Constructor functions. */
     375             :         ctor_fn_t *ctors;
     376             :         unsigned int num_ctors;
     377             : #endif
     378             : };
     379             : #ifndef MODULE_ARCH_INIT
     380             : #define MODULE_ARCH_INIT {}
     381             : #endif
     382             : 
     383             : extern struct mutex module_mutex;
     384             : 
     385             : /* FIXME: It'd be nice to isolate modules during init, too, so they
     386             :    aren't used before they (may) fail.  But presently too much code
     387             :    (IDE & SCSI) require entry into the module during init.*/
     388             : static inline int module_is_live(struct module *mod)
     389             : {
     390             :         return mod->state != MODULE_STATE_GOING;
     391             : }
     392             : 
     393             : struct module *__module_text_address(unsigned long addr);
     394             : struct module *__module_address(unsigned long addr);
     395             : bool is_module_address(unsigned long addr);
     396             : bool is_module_text_address(unsigned long addr);
     397             : 
     398             : static inline int within_module_core(unsigned long addr, struct module *mod)
     399             : {
     400             :         return (unsigned long)mod->module_core <= addr &&
     401             :                addr < (unsigned long)mod->module_core + mod->core_size;
     402             : }
     403             : 
     404             : static inline int within_module_init(unsigned long addr, struct module *mod)
     405             : {
     406             :         return (unsigned long)mod->module_init <= addr &&
     407             :                addr < (unsigned long)mod->module_init + mod->init_size;
     408             : }
     409             : 
     410             : /* Search for module by name: must hold module_mutex. */
     411             : struct module *find_module(const char *name);
     412             : 
     413             : struct symsearch {
     414             :         const struct kernel_symbol *start, *stop;
     415             :         const unsigned long *crcs;
     416             :         enum {
     417             :                 NOT_GPL_ONLY,
     418             :                 GPL_ONLY,
     419             :                 WILL_BE_GPL_ONLY,
     420             :         } licence;
     421             :         bool unused;
     422             : };
     423             : 
     424             : /* Search for an exported symbol by name. */
     425             : const struct kernel_symbol *find_symbol(const char *name,
     426             :                                         struct module **owner,
     427             :                                         const unsigned long **crc,
     428             :                                         bool gplok,
     429             :                                         bool warn);
     430             : 
     431             : /* Walk the exported symbol table */
     432             : bool each_symbol(bool (*fn)(const struct symsearch *arr, struct module *owner,
     433             :                             unsigned int symnum, void *data), void *data);
     434             : 
     435             : /* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
     436             :    symnum out of range. */
     437             : int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
     438             :                         char *name, char *module_name, int *exported);
     439             : 
     440             : /* Look for this name: can be of form module:name. */
     441             : unsigned long module_kallsyms_lookup_name(const char *name);
     442             : 
     443             : int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
     444             :                                              struct module *, unsigned long),
     445             :                                    void *data);
     446             : 
     447             : extern void __module_put_and_exit(struct module *mod, long code)
     448             :         __attribute__((noreturn));
     449             : #define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code);
     450             : 
     451             : #ifdef CONFIG_MODULE_UNLOAD
     452             : unsigned int module_refcount(struct module *mod);
     453             : void __symbol_put(const char *symbol);
     454             : #define symbol_put(x) __symbol_put(MODULE_SYMBOL_PREFIX #x)
     455             : void symbol_put_addr(void *addr);
     456             : 
     457             : static inline local_t *__module_ref_addr(struct module *mod, int cpu)
     458             : {
     459             : #ifdef CONFIG_SMP
     460             :         return (local_t *) per_cpu_ptr(mod->refptr, cpu);
     461             : #else
     462             :         return &mod->ref;
     463             : #endif
     464             : }
     465             : 
     466             : /* Sometimes we know we already have a refcount, and it's easier not
     467             :    to handle the error case (which only happens with rmmod --wait). */
     468             : static inline void __module_get(struct module *module)
     469             : {
     470             :         if (module) {
     471             :                 unsigned int cpu = get_cpu();
     472             :                 local_inc(__module_ref_addr(module, cpu));
     473             :                 trace_module_get(module, _THIS_IP_,
     474             :                                  local_read(__module_ref_addr(module, cpu)));
     475             :                 put_cpu();
     476             :         }
     477             : }
     478             : 
     479             : static inline int try_module_get(struct module *module)
     480             : {
     481             :         int ret = 1;
     482             : 
     483             :         if (module) {
     484             :                 unsigned int cpu = get_cpu();
     485             :                 if (likely(module_is_live(module))) {
     486             :                         local_inc(__module_ref_addr(module, cpu));
     487             :                         trace_module_get(module, _THIS_IP_,
     488             :                                 local_read(__module_ref_addr(module, cpu)));
     489             :                 }
     490             :                 else
     491             :                         ret = 0;
     492             :                 put_cpu();
     493             :         }
     494             :         return ret;
     495             : }
     496             : 
     497             : extern void module_put(struct module *module);
     498             : 
     499             : #else /*!CONFIG_MODULE_UNLOAD*/
     500             : static inline int try_module_get(struct module *module)
     501             : {
     502             :         return !module || module_is_live(module);
     503             : }
     504             : static inline void module_put(struct module *module)
     505             : {
     506             : }
     507             : static inline void __module_get(struct module *module)
     508             : {
     509             : }
     510             : #define symbol_put(x) do { } while(0)
     511             : #define symbol_put_addr(p) do { } while(0)
     512             : 
     513             : #endif /* CONFIG_MODULE_UNLOAD */
     514             : int use_module(struct module *a, struct module *b);
     515             : 
     516             : /* This is a #define so the string doesn't get put in every .o file */
     517             : #define module_name(mod)                        \
     518             : ({                                              \
     519             :         struct module *__mod = (mod);           \
     520             :         __mod ? __mod->name : "kernel";            \
     521             : })
     522             : 
     523             : /* For kallsyms to ask for address resolution.  namebuf should be at
     524             :  * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
     525             :  * found, otherwise NULL. */
     526             : const char *module_address_lookup(unsigned long addr,
     527             :                             unsigned long *symbolsize,
     528             :                             unsigned long *offset,
     529             :                             char **modname,
     530             :                             char *namebuf);
     531             : int lookup_module_symbol_name(unsigned long addr, char *symname);
     532             : int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
     533             : 
     534             : /* For extable.c to search modules' exception tables. */
     535             : const struct exception_table_entry *search_module_extables(unsigned long addr);
     536             : 
     537             : int register_module_notifier(struct notifier_block * nb);
     538             : int unregister_module_notifier(struct notifier_block * nb);
     539             : 
     540             : extern void print_modules(void);
     541             : 
     542             : extern void module_update_tracepoints(void);
     543             : extern int module_get_iter_tracepoints(struct tracepoint_iter *iter);
     544             : 
     545             : #else /* !CONFIG_MODULES... */
     546             : #define EXPORT_SYMBOL(sym)
     547             : #define EXPORT_SYMBOL_GPL(sym)
     548             : #define EXPORT_SYMBOL_GPL_FUTURE(sym)
     549             : #define EXPORT_UNUSED_SYMBOL(sym)
     550             : #define EXPORT_UNUSED_SYMBOL_GPL(sym)
     551             : 
     552             : /* Given an address, look for it in the exception tables. */
     553             : static inline const struct exception_table_entry *
     554             : search_module_extables(unsigned long addr)
     555             : {
     556             :         return NULL;
     557             : }
     558             : 
     559             : static inline struct module *__module_address(unsigned long addr)
     560             : {
     561             :         return NULL;
     562             : }
     563             : 
     564             : static inline struct module *__module_text_address(unsigned long addr)
     565             : {
     566             :         return NULL;
     567             : }
     568             : 
     569             : static inline bool is_module_address(unsigned long addr)
     570             : {
     571             :         return false;
     572             : }
     573             : 
     574             : static inline bool is_module_text_address(unsigned long addr)
     575             : {
     576             :         return false;
     577             : }
     578             : 
     579             : /* Get/put a kernel symbol (calls should be symmetric) */
     580             : #define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
     581             : #define symbol_put(x) do { } while(0)
     582             : #define symbol_put_addr(x) do { } while(0)
     583             : 
     584             : static inline void __module_get(struct module *module)
     585             : {
     586             : }
     587             : 
     588             : static inline int try_module_get(struct module *module)
     589             : {
     590         213 :         return 1;
     591             : }
     592             : 
     593             : static inline void module_put(struct module *module)
     594             : {
     595           1 : }
     596             : 
     597             : #define module_name(mod) "kernel"
     598             : 
     599             : /* For kallsyms to ask for address resolution.  NULL means not found. */
     600             : static inline const char *module_address_lookup(unsigned long addr,
     601             :                                           unsigned long *symbolsize,
     602             :                                           unsigned long *offset,
     603             :                                           char **modname,
     604             :                                           char *namebuf)
     605             : {
     606             :         return NULL;
     607             : }
     608             : 
     609             : static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
     610             : {
     611             :         return -ERANGE;
     612             : }
     613             : 
     614             : static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
     615             : {
     616             :         return -ERANGE;
     617             : }
     618             : 
     619             : static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
     620             :                                         char *type, char *name,
     621             :                                         char *module_name, int *exported)
     622             : {
     623             :         return -ERANGE;
     624             : }
     625             : 
     626             : static inline unsigned long module_kallsyms_lookup_name(const char *name)
     627             : {
     628             :         return 0;
     629             : }
     630             : 
     631             : static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
     632             :                                                            struct module *,
     633             :                                                            unsigned long),
     634             :                                                  void *data)
     635             : {
     636             :         return 0;
     637             : }
     638             : 
     639             : static inline int register_module_notifier(struct notifier_block * nb)
     640             : {
     641             :         /* no events will happen anyway, so this can always succeed */
     642             :         return 0;
     643             : }
     644             : 
     645             : static inline int unregister_module_notifier(struct notifier_block * nb)
     646             : {
     647             :         return 0;
     648             : }
     649             : 
     650             : #define module_put_and_exit(code) do_exit(code)
     651             : 
     652             : static inline void print_modules(void)
     653             : {
     654             : }
     655             : 
     656             : static inline void module_update_tracepoints(void)
     657             : {
     658             : }
     659             : 
     660             : static inline int module_get_iter_tracepoints(struct tracepoint_iter *iter)
     661             : {
     662             :         return 0;
     663             : }
     664           1 : 
     665             : #endif /* CONFIG_MODULES */
     666             : 
     667             : struct device_driver;
     668             : #ifdef CONFIG_SYSFS
     669             : struct module;
     670             : 
     671             : extern struct kset *module_kset;
     672             : extern struct kobj_type module_ktype;
     673             : extern int module_sysfs_initialized;
     674             : 
     675             : int mod_sysfs_init(struct module *mod);
     676             : int mod_sysfs_setup(struct module *mod,
     677             :                            struct kernel_param *kparam,
     678             :                            unsigned int num_params);
     679             : int module_add_modinfo_attrs(struct module *mod);
     680             : void module_remove_modinfo_attrs(struct module *mod);
     681             : 
     682             : #else /* !CONFIG_SYSFS */
     683             : 
     684             : static inline int mod_sysfs_init(struct module *mod)
     685             : {
     686             :         return 0;
     687             : }
     688             : 
     689             : static inline int mod_sysfs_setup(struct module *mod,
     690             :                            struct kernel_param *kparam,
     691             :                            unsigned int num_params)
     692             : {
     693             :         return 0;
     694             : }
     695             : 
     696             : static inline int module_add_modinfo_attrs(struct module *mod)
     697             : {
     698             :         return 0;
     699             : }
     700             : 
     701             : static inline void module_remove_modinfo_attrs(struct module *mod)
     702             : { }
     703             : 
     704             : #endif /* CONFIG_SYSFS */
     705             : 
     706             : #define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
     707             : 
     708             : /* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
     709             : 
     710             : #define __MODULE_STRING(x) __stringify(x)
     711             : 
     712             : 
     713             : #ifdef CONFIG_GENERIC_BUG
     714             : int  module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
     715             :                          struct module *);
     716             : void module_bug_cleanup(struct module *);
     717           1 : 
     718             : #else   /* !CONFIG_GENERIC_BUG */
     719             : 
     720             : static inline int  module_bug_finalize(const Elf_Ehdr *hdr,
     721             :                                         const Elf_Shdr *sechdrs,
     722             :                                         struct module *mod)
     723             : {
     724             :         return 0;
     725             : }
     726             : static inline void module_bug_cleanup(struct module *mod) {}
     727             : #endif  /* CONFIG_GENERIC_BUG */
     728             : 
     729             : #endif /* _LINUX_MODULE_H */

Generated by: LCOV version 1.10