include/linux/module.h

   1 /*
   2  * Dynamic loading of modules into the kernel.
   3  *
   4  * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
   5  */
   6
   7 #ifndef _LINUX_MODULE_H
   8 #define _LINUX_MODULE_H
   9
  10 #include <linux/config.h>
  11 #include <linux/spinlock.h>
  12 #include <linux/list.h>
  13
  14 #ifdef __GENKSYMS__
  15 #  define _set_ver(sym) sym
  16 #  undef  MODVERSIONS
  17 #  define MODVERSIONS
  18 #else /* ! __GENKSYMS__ */
  19 # if !defined(MODVERSIONS) && defined(EXPORT_SYMTAB)
  20 #   define _set_ver(sym) sym
  21 #   include <linux/modversions.h>
  22 # endif
  23 #endif /* __GENKSYMS__ */
  24
  25 #include <asm/atomic.h>
  26
  27 /* Don't need to bring in all of uaccess.h just for this decl.  */
  28 struct exception_table_entry;
  29
  30 /* Used by get_kernel_syms, which is obsolete.  */
  31 struct kernel_sym
  32 {
  33         unsigned long value;
  34         char name[60];          /* should have been 64-sizeof(long); oh well */
  35 };
  36
  37 struct module_symbol
  38 {
  39         unsigned long value;
  40         const char *name;
  41 };
  42
  43 struct module_ref
  44 {
  45         struct module *dep;     /* "parent" pointer */
  46         struct module *ref;     /* "child" pointer */
  47         struct module_ref *next_ref;
  48 };
  49
  50 /* TBD */
  51 struct module_persist;
  52
  53 struct module
  54 {
  55         unsigned long size_of_struct;   /* == sizeof(module) */
  56         struct module *next;
  57         const char *name;
  58         unsigned long size;
  59
  60         union
  61         {
  62                 atomic_t usecount;
  63                 long pad;
  64         } uc;                           /* Needs to keep its size - so says rth */
  65
  66         unsigned long flags;            /* AUTOCLEAN et al */
  67
  68         unsigned nsyms;
  69         unsigned ndeps;
  70
  71         struct module_symbol *syms;
  72         struct module_ref *deps;
  73         struct module_ref *refs;
  74         int (*init)(void);
  75         void (*cleanup)(void);
  76         const struct exception_table_entry *ex_table_start;
  77         const struct exception_table_entry *ex_table_end;
  78 #ifdef __alpha__
  79         unsigned long gp;
  80 #endif
  81         /* Members past this point are extensions to the basic
  82            module support and are optional.  Use mod_member_present()
  83            to examine them.  */
  84         const struct module_persist *persist_start;
  85         const struct module_persist *persist_end;
  86         int (*can_unload)(void);
  87         int runsize;                    /* In modutils, not currently used */
  88         const char *kallsyms_start;     /* All symbols for kernel debugging */
  89         const char *kallsyms_end;
  90         const char *archdata_start;     /* arch specific data for module */
  91         const char *archdata_end;
  92         const char *kernel_data;        /* Reserved for kernel internal use */
  93 };
  94
  95 struct module_info
  96 {
  97         unsigned long addr;
  98         unsigned long size;
  99         unsigned long flags;
 100         long usecount;
 101 };
 102
 103 /* Bits of module.flags.  */
 104
 105 #define MOD_UNINITIALIZED       0
 106 #define MOD_RUNNING             1
 107 #define MOD_DELETED             2
 108 #define MOD_AUTOCLEAN           4
 109 #define MOD_VISITED             8
 110 #define MOD_USED_ONCE           16
 111 #define MOD_JUST_FREED          32
 112 #define MOD_INITIALIZING        64
 113
 114 /* Values for query_module's which.  */
 115
 116 #define QM_MODULES      1
 117 #define QM_DEPS         2
 118 #define QM_REFS         3
 119 #define QM_SYMBOLS      4
 120 #define QM_INFO         5
 121
 122 /* Can the module be queried? */
 123 #define MOD_CAN_QUERY(mod) (((mod)->flags & (MOD_RUNNING | MOD_INITIALIZING)) && !((mod)->flags & MOD_DELETED))
 124
 125 /* When struct module is extended, we must test whether the new member
 126    is present in the header received from insmod before we can use it.
 127    This function returns true if the member is present.  */
 128
 129 #define mod_member_present(mod,member)                                  \
 130         ((unsigned long)(&((struct module *)0L)->member + 1)            \
 131          <= (mod)->size_of_struct)
 132
 133 /* Check if an address p with number of entries n is within the body of module m */
 134 #define mod_bound(p, n, m) ((unsigned long)(p) >= ((unsigned long)(m) + ((m)->size_of_struct)) && \
 135                  (unsigned long)((p)+(n)) <= (unsigned long)(m) + (m)->size)
 136
 137 /* Backwards compatibility definition.  */
 138
 139 #define GET_USE_COUNT(module)   (atomic_read(&(module)->uc.usecount))
 140
 141 /* Poke the use count of a module.  */
 142
 143 #define __MOD_INC_USE_COUNT(mod)                                        \
 144         (atomic_inc(&(mod)->uc.usecount), (mod)->flags |= MOD_VISITED|MOD_USED_ONCE)
 145 #define __MOD_DEC_USE_COUNT(mod)                                        \
 146         (atomic_dec(&(mod)->uc.usecount), (mod)->flags |= MOD_VISITED)
 147 #define __MOD_IN_USE(mod)                                               \
 148         (mod_member_present((mod), can_unload) && (mod)->can_unload     \
 149          ? (mod)->can_unload() : atomic_read(&(mod)->uc.usecount))
 150
 151 /* Indirect stringification.  */
 152
 153 #define __MODULE_STRING_1(x)    #x
 154 #define __MODULE_STRING(x)      __MODULE_STRING_1(x)
 155
 156 /* Generic inter module communication.
 157  *
 158  * NOTE: This interface is intended for small amounts of data that are
 159  *       passed between two objects and either or both of the objects
 160  *       might be compiled as modules.  Do not over use this interface.
 161  *
 162  *       If more than two objects need to communicate then you probably
 163  *       need a specific interface instead of abusing this generic
 164  *       interface.  If both objects are *always* built into the kernel
 165  *       then a global extern variable is good enough, you do not need
 166  *       this interface.
 167  *
 168  * Keith Owens <kaos@ocs.com.au> 28 Oct 2000.
 169  */
 170
 171 #define HAVE_INTER_MODULE
 172 extern void inter_module_register(const char *, struct module *, const void *);
 173 extern void inter_module_unregister(const char *);
 174 extern const void *inter_module_get(const char *);
 175 extern const void *inter_module_get_request(const char *, const char *);
 176 extern void inter_module_put(const char *);
 177
 178 struct inter_module_entry {
 179         struct list_head list;
 180         const char *im_name;
 181         struct module *owner;
 182         const void *userdata;
 183 };
 184
 185 extern int try_inc_mod_count(struct module *mod);
 186
 187 #if defined(MODULE) && !defined(__GENKSYMS__)
 188
 189 /* Embedded module documentation macros.  */
 190
 191 /* For documentation purposes only.  */
 192
 193 #define MODULE_AUTHOR(name)                                                \
 194 const char __module_author[] __attribute__((section(".modinfo"))) =        \
 195 "author=" name
 196
 197 #define MODULE_DESCRIPTION(desc)                                           \
 198 const char __module_description[] __attribute__((section(".modinfo"))) =   \
 199 "description=" desc
 200
 201 /* Could potentially be used by kmod...  */
 202
 203 #define MODULE_SUPPORTED_DEVICE(dev)                                       \
 204 const char __module_device[] __attribute__((section(".modinfo"))) =        \
 205 "device=" dev
 206
 207 /* Used to verify parameters given to the module.  The TYPE arg should
 208    be a string in the following format:
 209         [min[-max]]{b,h,i,l,s}
 210    The MIN and MAX specifiers delimit the length of the array.  If MAX
 211    is omitted, it defaults to MIN; if both are omitted, the default is 1.
 212    The final character is a type specifier:
 213         b       byte
 214         h       short
 215         i       int
 216         l       long
 217         s       string
 218 */
 219
 220 #define MODULE_PARM(var,type)                   \
 221 const char __module_parm_##var[]                \
 222 __attribute__((section(".modinfo"))) =          \
 223 "parm_" __MODULE_STRING(var) "=" type
 224
 225 #define MODULE_PARM_DESC(var,desc)              \
 226 const char __module_parm_desc_##var[]           \
 227 __attribute__((section(".modinfo"))) =          \
 228 "parm_desc_" __MODULE_STRING(var) "=" desc
 229
 230 /*
 231  * MODULE_DEVICE_TABLE exports information about devices
 232  * currently supported by this module.  A device type, such as PCI,
 233  * is a C-like identifier passed as the first arg to this macro.
 234  * The second macro arg is the variable containing the device
 235  * information being made public.
 236  *
 237  * The following is a list of known device types (arg 1),
 238  * and the C types which are to be passed as arg 2.
 239  * pci - struct pci_device_id - List of PCI ids supported by this module
 240  * isapnp - struct isapnp_device_id - List of ISA PnP ids supported by this module
 241  * usb - struct usb_device_id - List of USB ids supported by this module
 242  */
 243 #define MODULE_GENERIC_TABLE(gtype,name)        \
 244 static const unsigned long __module_##gtype##_size \
 245   __attribute__ ((unused)) = sizeof(struct gtype##_id); \
 246 static const struct gtype##_id * __module_##gtype##_table \
 247   __attribute__ ((unused)) = name
 248 #define MODULE_DEVICE_TABLE(type,name)          \
 249   MODULE_GENERIC_TABLE(type##_device,name)
 250 /* not put to .modinfo section to avoid section type conflicts */
 251
 252 /* The attributes of a section are set the first time the section is
 253    seen; we want .modinfo to not be allocated.  */
 254
 255 __asm__(".section .modinfo\n\t.previous");
 256
 257 /* Define the module variable, and usage macros.  */
 258 extern struct module __this_module;
 259
 260 #define THIS_MODULE             (&__this_module)
 261 #define MOD_INC_USE_COUNT       __MOD_INC_USE_COUNT(THIS_MODULE)
 262 #define MOD_DEC_USE_COUNT       __MOD_DEC_USE_COUNT(THIS_MODULE)
 263 #define MOD_IN_USE              __MOD_IN_USE(THIS_MODULE)
 264
 265 #include <linux/version.h>
 266 static const char __module_kernel_version[] __attribute__((section(".modinfo"))) =
 267 "kernel_version=" UTS_RELEASE;
 268 #ifdef MODVERSIONS
 269 static const char __module_using_checksums[] __attribute__((section(".modinfo"))) =
 270 "using_checksums=1";
 271 #endif
 272
 273 #else /* MODULE */
 274
 275 #define MODULE_AUTHOR(name)
 276 #define MODULE_DESCRIPTION(desc)
 277 #define MODULE_SUPPORTED_DEVICE(name)
 278 #define MODULE_PARM(var,type)
 279 #define MODULE_PARM_DESC(var,desc)
 280 #define MODULE_GENERIC_TABLE(gtype,name)
 281 #define MODULE_DEVICE_TABLE(type,name)
 282
 283 #ifndef __GENKSYMS__
 284
 285 #define THIS_MODULE             NULL
 286 #define MOD_INC_USE_COUNT       do { } while (0)
 287 #define MOD_DEC_USE_COUNT       do { } while (0)
 288 #define MOD_IN_USE              1
 289
 290 extern struct module *module_list;
 291
 292 #endif /* !__GENKSYMS__ */
 293
 294 #endif /* MODULE */
 295
 296 /* Export a symbol either from the kernel or a module.
 297
 298    In the kernel, the symbol is added to the kernel's global symbol table.
 299
 300    In a module, it controls which variables are exported.  If no
 301    variables are explicitly exported, the action is controled by the
 302    insmod -[xX] flags.  Otherwise, only the variables listed are exported.
 303    This obviates the need for the old register_symtab() function.  */
 304
 305 #if defined(__GENKSYMS__)
 306
 307 /* We want the EXPORT_SYMBOL tag left intact for recognition.  */
 308
 309 #elif !defined(AUTOCONF_INCLUDED)
 310
 311 #define __EXPORT_SYMBOL(sym,str)   error config_must_be_included_before_module
 312 #define EXPORT_SYMBOL(var)         error config_must_be_included_before_module
 313 #define EXPORT_SYMBOL_NOVERS(var)  error config_must_be_included_before_module
 314
 315 #elif !defined(CONFIG_MODULES)
 316
 317 #define __EXPORT_SYMBOL(sym,str)
 318 #define EXPORT_SYMBOL(var)
 319 #define EXPORT_SYMBOL_NOVERS(var)
 320
 321 #else
 322
 323 #define __EXPORT_SYMBOL(sym, str)                       \
 324 const char __kstrtab_##sym[]                            \
 325 __attribute__((section(".kstrtab"))) = str;             \
 326 const struct module_symbol __ksymtab_##sym              \
 327 __attribute__((section("__ksymtab"))) =                 \
 328 { (unsigned long)&sym, __kstrtab_##sym }
 329
 330 #if defined(MODVERSIONS) || !defined(CONFIG_MODVERSIONS)
 331 #define EXPORT_SYMBOL(var)  __EXPORT_SYMBOL(var, __MODULE_STRING(var))
 332 #else
 333 #define EXPORT_SYMBOL(var)  __EXPORT_SYMBOL(var, __MODULE_STRING(__VERSIONED_SYMBOL(var)))
 334 #endif
 335
 336 #define EXPORT_SYMBOL_NOVERS(var)  __EXPORT_SYMBOL(var, __MODULE_STRING(var))
 337
 338 #endif /* __GENKSYMS__ */
 339
 340 #ifdef MODULE
 341 /* Force a module to export no symbols.  */
 342 #define EXPORT_NO_SYMBOLS  __asm__(".section __ksymtab\n.previous")
 343 #else
 344 #define EXPORT_NO_SYMBOLS
 345 #endif /* MODULE */
 346
 347 #ifdef CONFIG_MODULES
 348 #define SET_MODULE_OWNER(some_struct) do { (some_struct)->owner = THIS_MODULE; } while (0)
 349 #else
 350 #define SET_MODULE_OWNER(some_struct) do { } while (0)
 351 #endif
 352
 353 #endif /* _LINUX_MODULE_H */