home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / linux / module.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  15.0 KB  |  569 lines
  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/sched.h>
  10. #include <linux/spinlock.h>
  11. #include <linux/list.h>
  12. #include <linux/stat.h>
  13. #include <linux/compiler.h>
  14. #include <linux/cache.h>
  15. #include <linux/kmod.h>
  16. #include <linux/elf.h>
  17. #include <linux/stringify.h>
  18. #include <linux/kobject.h>
  19. #include <linux/moduleparam.h>
  20. #include <asm/local.h>
  21.  
  22. #include <asm/module.h>
  23.  
  24. /* Not Yet Implemented */
  25. #define MODULE_SUPPORTED_DEVICE(name)
  26.  
  27. /* v850 toolchain uses a `_' prefix for all user symbols */
  28. #ifndef MODULE_SYMBOL_PREFIX
  29. #define MODULE_SYMBOL_PREFIX ""
  30. #endif
  31.  
  32. #define MODULE_NAME_LEN (64 - sizeof(unsigned long))
  33.  
  34. struct kernel_symbol
  35. {
  36.     unsigned long value;
  37.     const char *name;
  38. };
  39.  
  40. struct modversion_info
  41. {
  42.     unsigned long crc;
  43.     char name[MODULE_NAME_LEN];
  44. };
  45.  
  46. struct module;
  47.  
  48. struct module_attribute {
  49.         struct attribute attr;
  50.         ssize_t (*show)(struct module_attribute *, struct module *, char *);
  51.         ssize_t (*store)(struct module_attribute *, struct module *,
  52.              const char *, size_t count);
  53.     void (*setup)(struct module *, const char *);
  54.     int (*test)(struct module *);
  55.     void (*free)(struct module *);
  56. };
  57.  
  58. struct module_kobject
  59. {
  60.     struct kobject kobj;
  61.     struct module *mod;
  62. };
  63.  
  64. /* These are either module local, or the kernel's dummy ones. */
  65. extern int init_module(void);
  66. extern void cleanup_module(void);
  67.  
  68. /* Archs provide a method of finding the correct exception table. */
  69. struct exception_table_entry;
  70.  
  71. const struct exception_table_entry *
  72. search_extable(const struct exception_table_entry *first,
  73.            const struct exception_table_entry *last,
  74.            unsigned long value);
  75. void sort_extable(struct exception_table_entry *start,
  76.           struct exception_table_entry *finish);
  77. void sort_main_extable(void);
  78.  
  79. extern struct subsystem module_subsys;
  80.  
  81. #ifdef MODULE
  82. #define MODULE_GENERIC_TABLE(gtype,name)            \
  83. extern const struct gtype##_id __mod_##gtype##_table        \
  84.   __attribute__ ((unused, alias(__stringify(name))))
  85.  
  86. extern struct module __this_module;
  87. #define THIS_MODULE (&__this_module)
  88. #else  /* !MODULE */
  89. #define MODULE_GENERIC_TABLE(gtype,name)
  90. #define THIS_MODULE ((struct module *)0)
  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 MPL/GPL"            [GNU Public License v2
  109.  *                     or Mozilla license choice]
  110.  *
  111.  * The following other idents are available
  112.  *
  113.  *    "Proprietary"            [Non free products]
  114.  *
  115.  * There are dual licensed components, but when running with Linux it is the
  116.  * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
  117.  * is a GPL combined work.
  118.  *
  119.  * This exists for several reasons
  120.  * 1.    So modinfo can show license info for users wanting to vet their setup 
  121.  *    is free
  122.  * 2.    So the community can ignore bug reports including proprietary modules
  123.  * 3.    So vendors can do likewise based on their own policies
  124.  */
  125. #define MODULE_LICENSE(_license) MODULE_INFO(license, _license)
  126.  
  127. /* Author, ideally of form NAME <EMAIL>[, NAME <EMAIL>]*[ and NAME <EMAIL>] */
  128. #define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
  129.   
  130. /* What your module does. */
  131. #define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
  132.  
  133. /* One for each parameter, describing how to use it.  Some files do
  134.    multiple of these per line, so can't just use MODULE_INFO. */
  135. #define MODULE_PARM_DESC(_parm, desc) \
  136.     __MODULE_INFO(parm, _parm, #_parm ":" desc)
  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. #define MODULE_VERSION(_version) MODULE_INFO(version, _version)
  156.  
  157. /* Given an address, look for it in the exception tables */
  158. const struct exception_table_entry *search_exception_tables(unsigned long add);
  159.  
  160. struct notifier_block;
  161.  
  162. #ifdef CONFIG_MODULES
  163.  
  164. /* Get/put a kernel symbol (calls must be symmetric) */
  165. void *__symbol_get(const char *symbol);
  166. void *__symbol_get_gpl(const char *symbol);
  167. #define symbol_get(x) ((typeof(&x))(__symbol_get(MODULE_SYMBOL_PREFIX #x)))
  168.  
  169. #ifndef __GENKSYMS__
  170. #ifdef CONFIG_MODVERSIONS
  171. /* Mark the CRC weak since genksyms apparently decides not to
  172.  * generate a checksums for some symbols */
  173. #define __CRC_SYMBOL(sym, sec)                    \
  174.     extern void *__crc_##sym __attribute__((weak));        \
  175.     static const unsigned long __kcrctab_##sym        \
  176.     __attribute_used__                    \
  177.     __attribute__((section("__kcrctab" sec), unused))    \
  178.     = (unsigned long) &__crc_##sym;
  179. #else
  180. #define __CRC_SYMBOL(sym, sec)
  181. #endif
  182.  
  183. /* For every exported symbol, place a struct in the __ksymtab section */
  184. #define __EXPORT_SYMBOL(sym, sec)                \
  185.     extern typeof(sym) sym;                    \
  186.     __CRC_SYMBOL(sym, sec)                    \
  187.     static const char __kstrtab_##sym[]            \
  188.     __attribute__((section("__ksymtab_strings")))        \
  189.     = MODULE_SYMBOL_PREFIX #sym;                        \
  190.     static const struct kernel_symbol __ksymtab_##sym    \
  191.     __attribute_used__                    \
  192.     __attribute__((section("__ksymtab" sec), unused))    \
  193.     = { (unsigned long)&sym, __kstrtab_##sym }
  194.  
  195. #define EXPORT_SYMBOL(sym)                    \
  196.     __EXPORT_SYMBOL(sym, "")
  197.  
  198. #define EXPORT_SYMBOL_GPL(sym)                    \
  199.     __EXPORT_SYMBOL(sym, "_gpl")
  200.  
  201. #define EXPORT_SYMBOL_GPL_FUTURE(sym)                \
  202.     __EXPORT_SYMBOL(sym, "_gpl_future")
  203.  
  204. #endif
  205.  
  206. struct module_ref
  207. {
  208.     local_t count;
  209. } ____cacheline_aligned;
  210.  
  211. enum module_state
  212. {
  213.     MODULE_STATE_LIVE,
  214.     MODULE_STATE_COMING,
  215.     MODULE_STATE_GOING,
  216. };
  217.  
  218. /* Similar stuff for section attributes. */
  219. #define MODULE_SECT_NAME_LEN 32
  220. struct module_sect_attr
  221. {
  222.     struct module_attribute mattr;
  223.     char name[MODULE_SECT_NAME_LEN];
  224.     unsigned long address;
  225. };
  226.  
  227. struct module_sect_attrs
  228. {
  229.     struct attribute_group grp;
  230.     struct module_sect_attr attrs[0];
  231. };
  232.  
  233. struct module_param_attrs;
  234.  
  235. struct module
  236. {
  237.     enum module_state state;
  238.  
  239.     /* Member of list of modules */
  240.     struct list_head list;
  241.  
  242.     /* Unique handle for this module */
  243.     char name[MODULE_NAME_LEN];
  244.  
  245.     /* Sysfs stuff. */
  246.     struct module_kobject mkobj;
  247.     struct module_param_attrs *param_attrs;
  248.     struct module_attribute *modinfo_attrs;
  249.     const char *version;
  250.     const char *srcversion;
  251.  
  252.     /* Exported symbols */
  253.     const struct kernel_symbol *syms;
  254.     unsigned int num_syms;
  255.     const unsigned long *crcs;
  256.  
  257.     /* GPL-only exported symbols. */
  258.     const struct kernel_symbol *gpl_syms;
  259.     unsigned int num_gpl_syms;
  260.     const unsigned long *gpl_crcs;
  261.  
  262.     /* symbols that will be GPL-only in the near future. */
  263.     const struct kernel_symbol *gpl_future_syms;
  264.     unsigned int num_gpl_future_syms;
  265.     const unsigned long *gpl_future_crcs;
  266.  
  267.     /* Exception table */
  268.     unsigned int num_exentries;
  269.     const struct exception_table_entry *extable;
  270.  
  271.     /* Startup function. */
  272.     int (*init)(void);
  273.  
  274.     /* If this is non-NULL, vfree after init() returns */
  275.     void *module_init;
  276.  
  277.     /* Here is the actual code + data, vfree'd on unload. */
  278.     void *module_core;
  279.  
  280.     /* Here are the sizes of the init and core sections */
  281.     unsigned long init_size, core_size;
  282.  
  283.     /* The size of the executable code in each section.  */
  284.     unsigned long init_text_size, core_text_size;
  285.  
  286.     /* Arch-specific module values */
  287.     struct mod_arch_specific arch;
  288.  
  289.     /* Am I unsafe to unload? */
  290.     int unsafe;
  291.  
  292.     /* Am I GPL-compatible */
  293.     int license_gplok;
  294.  
  295. #ifdef CONFIG_MODULE_UNLOAD
  296.     /* Reference counts */
  297.     struct module_ref ref[NR_CPUS];
  298.  
  299.     /* What modules depend on me? */
  300.     struct list_head modules_which_use_me;
  301.  
  302.     /* Who is waiting for us to be unloaded */
  303.     struct task_struct *waiter;
  304.  
  305.     /* Destruction function. */
  306.     void (*exit)(void);
  307. #endif
  308.  
  309. #ifdef CONFIG_KALLSYMS
  310.     /* We keep the symbol and string tables for kallsyms. */
  311.     Elf_Sym *symtab;
  312.     unsigned long num_symtab;
  313.     char *strtab;
  314.  
  315.     /* Section attributes */
  316.     struct module_sect_attrs *sect_attrs;
  317. #endif
  318.  
  319.     /* Per-cpu data. */
  320.     void *percpu;
  321.  
  322.     /* The command line arguments (may be mangled).  People like
  323.        keeping pointers to this stuff */
  324.     char *args;
  325. };
  326.  
  327. /* FIXME: It'd be nice to isolate modules during init, too, so they
  328.    aren't used before they (may) fail.  But presently too much code
  329.    (IDE & SCSI) require entry into the module during init.*/
  330. static inline int module_is_live(struct module *mod)
  331. {
  332.     return mod->state != MODULE_STATE_GOING;
  333. }
  334.  
  335. /* Is this address in a module? (second is with no locks, for oops) */
  336. struct module *module_text_address(unsigned long addr);
  337. struct module *__module_text_address(unsigned long addr);
  338.  
  339. /* Returns module and fills in value, defined and namebuf, or NULL if
  340.    symnum out of range. */
  341. struct module *module_get_kallsym(unsigned int symnum,
  342.                   unsigned long *value,
  343.                   char *type,
  344.                   char namebuf[128]);
  345.  
  346. /* Look for this name: can be of form module:name. */
  347. unsigned long module_kallsyms_lookup_name(const char *name);
  348.  
  349. int is_exported(const char *name, const struct module *mod);
  350.  
  351. extern void __module_put_and_exit(struct module *mod, long code)
  352.     __attribute__((noreturn));
  353. #define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code);
  354.  
  355. #ifdef CONFIG_MODULE_UNLOAD
  356. unsigned int module_refcount(struct module *mod);
  357. void __symbol_put(const char *symbol);
  358. #define symbol_put(x) __symbol_put(MODULE_SYMBOL_PREFIX #x)
  359. void symbol_put_addr(void *addr);
  360.  
  361. /* Sometimes we know we already have a refcount, and it's easier not
  362.    to handle the error case (which only happens with rmmod --wait). */
  363. static inline void __module_get(struct module *module)
  364. {
  365.     if (module) {
  366.         BUG_ON(module_refcount(module) == 0);
  367.         local_inc(&module->ref[get_cpu()].count);
  368.         put_cpu();
  369.     }
  370. }
  371.  
  372. static inline int try_module_get(struct module *module)
  373. {
  374.     int ret = 1;
  375.  
  376.     if (module) {
  377.         unsigned int cpu = get_cpu();
  378.         if (likely(module_is_live(module)))
  379.             local_inc(&module->ref[cpu].count);
  380.         else
  381.             ret = 0;
  382.         put_cpu();
  383.     }
  384.     return ret;
  385. }
  386.  
  387. static inline void module_put(struct module *module)
  388. {
  389.     if (module) {
  390.         unsigned int cpu = get_cpu();
  391.         local_dec(&module->ref[cpu].count);
  392.         /* Maybe they're waiting for us to drop reference? */
  393.         if (unlikely(!module_is_live(module)))
  394.             wake_up_process(module->waiter);
  395.         put_cpu();
  396.     }
  397. }
  398.  
  399. #else /*!CONFIG_MODULE_UNLOAD*/
  400. static inline int try_module_get(struct module *module)
  401. {
  402.     return !module || module_is_live(module);
  403. }
  404. static inline void module_put(struct module *module)
  405. {
  406. }
  407. static inline void __module_get(struct module *module)
  408. {
  409. }
  410. #define symbol_put(x) do { } while(0)
  411. #define symbol_put_addr(p) do { } while(0)
  412.  
  413. #endif /* CONFIG_MODULE_UNLOAD */
  414.  
  415. /* This is a #define so the string doesn't get put in every .o file */
  416. #define module_name(mod)            \
  417. ({                        \
  418.     struct module *__mod = (mod);        \
  419.     __mod ? __mod->name : "kernel";        \
  420. })
  421.  
  422. #define __unsafe(mod)                                 \
  423. do {                                         \
  424.     if (mod && !(mod)->unsafe) {                         \
  425.         printk(KERN_WARNING                         \
  426.                "Module %s cannot be unloaded due to unsafe usage in" \
  427.                " %s:%u\n", (mod)->name, __FILE__, __LINE__);         \
  428.         (mod)->unsafe = 1;                         \
  429.     }                                     \
  430. } while(0)
  431.  
  432. /* For kallsyms to ask for address resolution.  NULL means not found. */
  433. const char *module_address_lookup(unsigned long addr,
  434.                   unsigned long *symbolsize,
  435.                   unsigned long *offset,
  436.                   char **modname);
  437.  
  438. /* For extable.c to search modules' exception tables. */
  439. const struct exception_table_entry *search_module_extables(unsigned long addr);
  440.  
  441. int register_module_notifier(struct notifier_block * nb);
  442. int unregister_module_notifier(struct notifier_block * nb);
  443.  
  444. extern void print_modules(void);
  445.  
  446. struct device_driver;
  447. void module_add_driver(struct module *, struct device_driver *);
  448. void module_remove_driver(struct device_driver *);
  449.  
  450. #else /* !CONFIG_MODULES... */
  451. #define EXPORT_SYMBOL(sym)
  452. #define EXPORT_SYMBOL_GPL(sym)
  453. #define EXPORT_SYMBOL_GPL_FUTURE(sym)
  454.  
  455. /* Given an address, look for it in the exception tables. */
  456. static inline const struct exception_table_entry *
  457. search_module_extables(unsigned long addr)
  458. {
  459.     return NULL;
  460. }
  461.  
  462. /* Is this address in a module? */
  463. static inline struct module *module_text_address(unsigned long addr)
  464. {
  465.     return NULL;
  466. }
  467.  
  468. /* Is this address in a module? (don't take a lock, we're oopsing) */
  469. static inline struct module *__module_text_address(unsigned long addr)
  470. {
  471.     return NULL;
  472. }
  473.  
  474. /* Get/put a kernel symbol (calls should be symmetric) */
  475. #define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
  476. #define symbol_put(x) do { } while(0)
  477. #define symbol_put_addr(x) do { } while(0)
  478.  
  479. static inline void __module_get(struct module *module)
  480. {
  481. }
  482.  
  483. static inline int try_module_get(struct module *module)
  484. {
  485.     return 1;
  486. }
  487.  
  488. static inline void module_put(struct module *module)
  489. {
  490. }
  491.  
  492. #define module_name(mod) "kernel"
  493.  
  494. #define __unsafe(mod)
  495.  
  496. /* For kallsyms to ask for address resolution.  NULL means not found. */
  497. static inline const char *module_address_lookup(unsigned long addr,
  498.                         unsigned long *symbolsize,
  499.                         unsigned long *offset,
  500.                         char **modname)
  501. {
  502.     return NULL;
  503. }
  504.  
  505. static inline struct module *module_get_kallsym(unsigned int symnum,
  506.                         unsigned long *value,
  507.                         char *type,
  508.                         char namebuf[128])
  509. {
  510.     return NULL;
  511. }
  512.  
  513. static inline unsigned long module_kallsyms_lookup_name(const char *name)
  514. {
  515.     return 0;
  516. }
  517.  
  518. static inline int is_exported(const char *name, const struct module *mod)
  519. {
  520.     return 0;
  521. }
  522.  
  523. static inline int register_module_notifier(struct notifier_block * nb)
  524. {
  525.     /* no events will happen anyway, so this can always succeed */
  526.     return 0;
  527. }
  528.  
  529. static inline int unregister_module_notifier(struct notifier_block * nb)
  530. {
  531.     return 0;
  532. }
  533.  
  534. #define module_put_and_exit(code) do_exit(code)
  535.  
  536. static inline void print_modules(void)
  537. {
  538. }
  539.  
  540. struct device_driver;
  541. struct module;
  542.  
  543. static inline void module_add_driver(struct module *module, struct device_driver *driver)
  544. {
  545. }
  546.  
  547. static inline void module_remove_driver(struct device_driver *driver)
  548. {
  549. }
  550.  
  551. #endif /* CONFIG_MODULES */
  552.  
  553. #define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
  554.  
  555. /* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
  556.  
  557. #define __MODULE_STRING(x) __stringify(x)
  558.  
  559. /* Use symbol_get and symbol_put instead.  You'll thank me. */
  560. #define HAVE_INTER_MODULE
  561. extern void __deprecated inter_module_register(const char *,
  562.         struct module *, const void *);
  563. extern void __deprecated inter_module_unregister(const char *);
  564. extern const void * __deprecated inter_module_get_request(const char *,
  565.         const char *);
  566. extern void __deprecated inter_module_put(const char *);
  567.  
  568. #endif /* _LINUX_MODULE_H */
  569.