home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / module.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  16.5 KB  |  624 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/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/marker.h>
  19. #include <linux/tracepoint.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. /* some toolchains 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 MAX_PARAM_PREFIX_LEN
  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.     struct kobject *drivers_dir;
  63.     struct module_param_attrs *mp;
  64. };
  65.  
  66. /* These are either module local, or the kernel's dummy ones. */
  67. extern int init_module(void);
  68. extern void cleanup_module(void);
  69.  
  70. /* Archs provide a method of finding the correct exception table. */
  71. struct exception_table_entry;
  72.  
  73. const struct exception_table_entry *
  74. search_extable(const struct exception_table_entry *first,
  75.            const struct exception_table_entry *last,
  76.            unsigned long value);
  77. void sort_extable(struct exception_table_entry *start,
  78.           struct exception_table_entry *finish);
  79. void sort_main_extable(void);
  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 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. /* Author, ideally of form NAME[, NAME]*[ and NAME] */
  130. #define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
  131.   
  132. /* What your module does. */
  133. #define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
  134.  
  135. /* One for each parameter, describing how to use it.  Some files do
  136.    multiple of these per line, so can't just use MODULE_INFO. */
  137. #define MODULE_PARM_DESC(_parm, desc) \
  138.     __MODULE_INFO(parm, _parm, #_parm ":" desc)
  139.  
  140. #define MODULE_DEVICE_TABLE(type,name)        \
  141.   MODULE_GENERIC_TABLE(type##_device,name)
  142.  
  143. /* Version of form [<epoch>:]<version>[-<extra-version>].
  144.    Or for CVS/RCS ID version, everything but the number is stripped.
  145.   <epoch>: A (small) unsigned integer which allows you to start versions
  146.            anew. If not mentioned, it's zero.  eg. "2:1.0" is after
  147.        "1:2.0".
  148.   <version>: The <version> may contain only alphanumerics and the
  149.            character `.'.  Ordered by numeric sort for numeric parts,
  150.        ascii sort for ascii parts (as per RPM or DEB algorithm).
  151.   <extraversion>: Like <version>, but inserted for local
  152.            customizations, eg "rh3" or "rusty1".
  153.  
  154.   Using this automatically adds a checksum of the .c files and the
  155.   local headers in "srcversion".
  156. */
  157. #define MODULE_VERSION(_version) MODULE_INFO(version, _version)
  158.  
  159. /* Optional firmware file (or files) needed by the module
  160.  * format is simply firmware file name.  Multiple firmware
  161.  * files require multiple MODULE_FIRMWARE() specifiers */
  162. #define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
  163.  
  164. /* Given an address, look for it in the exception tables */
  165. const struct exception_table_entry *search_exception_tables(unsigned long add);
  166.  
  167. struct notifier_block;
  168.  
  169. #ifdef CONFIG_MODULES
  170.  
  171. /* Get/put a kernel symbol (calls must be symmetric) */
  172. void *__symbol_get(const char *symbol);
  173. void *__symbol_get_gpl(const char *symbol);
  174. #define symbol_get(x) ((typeof(&x))(__symbol_get(MODULE_SYMBOL_PREFIX #x)))
  175.  
  176. #ifndef __GENKSYMS__
  177. #ifdef CONFIG_MODVERSIONS
  178. /* Mark the CRC weak since genksyms apparently decides not to
  179.  * generate a checksums for some symbols */
  180. #define __CRC_SYMBOL(sym, sec)                    \
  181.     extern void *__crc_##sym __attribute__((weak));        \
  182.     static const unsigned long __kcrctab_##sym        \
  183.     __used                            \
  184.     __attribute__((section("__kcrctab" sec), unused))    \
  185.     = (unsigned long) &__crc_##sym;
  186. #else
  187. #define __CRC_SYMBOL(sym, sec)
  188. #endif
  189.  
  190. /* For every exported symbol, place a struct in the __ksymtab section */
  191. #define __EXPORT_SYMBOL(sym, sec)                \
  192.     extern typeof(sym) sym;                    \
  193.     __CRC_SYMBOL(sym, sec)                    \
  194.     static const char __kstrtab_##sym[]            \
  195.     __attribute__((section("__ksymtab_strings"), aligned(1))) \
  196.     = MODULE_SYMBOL_PREFIX #sym;                        \
  197.     static const struct kernel_symbol __ksymtab_##sym    \
  198.     __used                            \
  199.     __attribute__((section("__ksymtab" sec), unused))    \
  200.     = { (unsigned long)&sym, __kstrtab_##sym }
  201.  
  202. #define EXPORT_SYMBOL(sym)                    \
  203.     __EXPORT_SYMBOL(sym, "")
  204.  
  205. #define EXPORT_SYMBOL_GPL(sym)                    \
  206.     __EXPORT_SYMBOL(sym, "_gpl")
  207.  
  208. #define EXPORT_SYMBOL_GPL_FUTURE(sym)                \
  209.     __EXPORT_SYMBOL(sym, "_gpl_future")
  210.  
  211.  
  212. #ifdef CONFIG_UNUSED_SYMBOLS
  213. #define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused")
  214. #define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl")
  215. #else
  216. #define EXPORT_UNUSED_SYMBOL(sym)
  217. #define EXPORT_UNUSED_SYMBOL_GPL(sym)
  218. #endif
  219.  
  220. #endif
  221.  
  222. struct module_ref
  223. {
  224.     local_t count;
  225. } ____cacheline_aligned;
  226.  
  227. enum module_state
  228. {
  229.     MODULE_STATE_LIVE,
  230.     MODULE_STATE_COMING,
  231.     MODULE_STATE_GOING,
  232. };
  233.  
  234. struct module
  235. {
  236.     enum module_state state;
  237.  
  238.     /* Member of list of modules */
  239.     struct list_head list;
  240.  
  241.     /* Unique handle for this module */
  242.     char name[MODULE_NAME_LEN];
  243.  
  244.     /* Sysfs stuff. */
  245.     struct module_kobject mkobj;
  246.     struct module_attribute *modinfo_attrs;
  247.     const char *version;
  248.     const char *srcversion;
  249.     struct kobject *holders_dir;
  250.  
  251.     /* Exported symbols */
  252.     const struct kernel_symbol *syms;
  253.     const unsigned long *crcs;
  254.     unsigned int num_syms;
  255.  
  256.     /* GPL-only exported symbols. */
  257.     unsigned int num_gpl_syms;
  258.     const struct kernel_symbol *gpl_syms;
  259.     const unsigned long *gpl_crcs;
  260.  
  261. #ifdef CONFIG_UNUSED_SYMBOLS
  262.     /* unused exported symbols. */
  263.     const struct kernel_symbol *unused_syms;
  264.     const unsigned long *unused_crcs;
  265.     unsigned int num_unused_syms;
  266.  
  267.     /* GPL-only, unused exported symbols. */
  268.     unsigned int num_unused_gpl_syms;
  269.     const struct kernel_symbol *unused_gpl_syms;
  270.     const unsigned long *unused_gpl_crcs;
  271. #endif
  272.  
  273.     /* symbols that will be GPL-only in the near future. */
  274.     const struct kernel_symbol *gpl_future_syms;
  275.     const unsigned long *gpl_future_crcs;
  276.     unsigned int num_gpl_future_syms;
  277.  
  278.     /* Exception table */
  279.     unsigned int num_exentries;
  280.     struct exception_table_entry *extable;
  281.  
  282.     /* Startup function. */
  283.     int (*init)(void);
  284.  
  285.     /* If this is non-NULL, vfree after init() returns */
  286.     void *module_init;
  287.  
  288.     /* Here is the actual code + data, vfree'd on unload. */
  289.     void *module_core;
  290.  
  291.     /* Here are the sizes of the init and core sections */
  292.     unsigned int init_size, core_size;
  293.  
  294.     /* The size of the executable code in each section.  */
  295.     unsigned int init_text_size, core_text_size;
  296.  
  297.     /* The handle returned from unwind_add_table. */
  298.     void *unwind_info;
  299.  
  300.     /* Arch-specific module values */
  301.     struct mod_arch_specific arch;
  302.  
  303.     unsigned int taints;    /* same bits as kernel:tainted */
  304.  
  305. #ifdef CONFIG_GENERIC_BUG
  306.     /* Support for BUG */
  307.     unsigned num_bugs;
  308.     struct list_head bug_list;
  309.     struct bug_entry *bug_table;
  310. #endif
  311.  
  312. #ifdef CONFIG_KALLSYMS
  313.     /* We keep the symbol and string tables for kallsyms. */
  314.     Elf_Sym *symtab;
  315.     unsigned int num_symtab;
  316.     char *strtab;
  317.  
  318.     /* Section attributes */
  319.     struct module_sect_attrs *sect_attrs;
  320.  
  321.     /* Notes attributes */
  322.     struct module_notes_attrs *notes_attrs;
  323. #endif
  324.  
  325.     /* Per-cpu data. */
  326.     void *percpu;
  327.  
  328.     /* The command line arguments (may be mangled).  People like
  329.        keeping pointers to this stuff */
  330.     char *args;
  331. #ifdef CONFIG_MARKERS
  332.     struct marker *markers;
  333.     unsigned int num_markers;
  334. #endif
  335. #ifdef CONFIG_TRACEPOINTS
  336.     struct tracepoint *tracepoints;
  337.     unsigned int num_tracepoints;
  338. #endif
  339.  
  340. #ifdef CONFIG_MODULE_UNLOAD
  341.     /* What modules depend on me? */
  342.     struct list_head modules_which_use_me;
  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.     /* Reference counts */
  351.     struct module_ref ref[NR_CPUS];
  352. #endif
  353. };
  354. #ifndef MODULE_ARCH_INIT
  355. #define MODULE_ARCH_INIT {}
  356. #endif
  357.  
  358. /* FIXME: It'd be nice to isolate modules during init, too, so they
  359.    aren't used before they (may) fail.  But presently too much code
  360.    (IDE & SCSI) require entry into the module during init.*/
  361. static inline int module_is_live(struct module *mod)
  362. {
  363.     return mod->state != MODULE_STATE_GOING;
  364. }
  365.  
  366. /* Is this address in a module? (second is with no locks, for oops) */
  367. struct module *module_text_address(unsigned long addr);
  368. struct module *__module_text_address(unsigned long addr);
  369. int is_module_address(unsigned long addr);
  370.  
  371. /* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
  372.    symnum out of range. */
  373. int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
  374.             char *name, char *module_name, int *exported);
  375.  
  376. /* Look for this name: can be of form module:name. */
  377. unsigned long module_kallsyms_lookup_name(const char *name);
  378.  
  379. extern void __module_put_and_exit(struct module *mod, long code)
  380.     __attribute__((noreturn));
  381. #define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code);
  382.  
  383. #ifdef CONFIG_MODULE_UNLOAD
  384. unsigned int module_refcount(struct module *mod);
  385. void __symbol_put(const char *symbol);
  386. #define symbol_put(x) __symbol_put(MODULE_SYMBOL_PREFIX #x)
  387. void symbol_put_addr(void *addr);
  388.  
  389. /* Sometimes we know we already have a refcount, and it's easier not
  390.    to handle the error case (which only happens with rmmod --wait). */
  391. static inline void __module_get(struct module *module)
  392. {
  393.     if (module) {
  394.         local_inc(&module->ref[get_cpu()].count);
  395.         put_cpu();
  396.     }
  397. }
  398.  
  399. static inline int try_module_get(struct module *module)
  400. {
  401.     int ret = 1;
  402.  
  403.     if (module) {
  404.         unsigned int cpu = get_cpu();
  405.         if (likely(module_is_live(module)))
  406.             local_inc(&module->ref[cpu].count);
  407.         else
  408.             ret = 0;
  409.         put_cpu();
  410.     }
  411.     return ret;
  412. }
  413.  
  414. extern void module_put(struct module *module);
  415.  
  416. #else /*!CONFIG_MODULE_UNLOAD*/
  417. static inline int try_module_get(struct module *module)
  418. {
  419.     return !module || module_is_live(module);
  420. }
  421. static inline void module_put(struct module *module)
  422. {
  423. }
  424. static inline void __module_get(struct module *module)
  425. {
  426. }
  427. #define symbol_put(x) do { } while(0)
  428. #define symbol_put_addr(p) do { } while(0)
  429.  
  430. #endif /* CONFIG_MODULE_UNLOAD */
  431.  
  432. /* This is a #define so the string doesn't get put in every .o file */
  433. #define module_name(mod)            \
  434. ({                        \
  435.     struct module *__mod = (mod);        \
  436.     __mod ? __mod->name : "kernel";        \
  437. })
  438.  
  439. /* For kallsyms to ask for address resolution.  namebuf should be at
  440.  * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
  441.  * found, otherwise NULL. */
  442. const char *module_address_lookup(unsigned long addr,
  443.                 unsigned long *symbolsize,
  444.                 unsigned long *offset,
  445.                 char **modname,
  446.                 char *namebuf);
  447. int lookup_module_symbol_name(unsigned long addr, char *symname);
  448. int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
  449.  
  450. /* For extable.c to search modules' exception tables. */
  451. const struct exception_table_entry *search_module_extables(unsigned long addr);
  452.  
  453. int register_module_notifier(struct notifier_block * nb);
  454. int unregister_module_notifier(struct notifier_block * nb);
  455.  
  456. extern void print_modules(void);
  457.  
  458. extern void module_update_markers(void);
  459.  
  460. extern void module_update_tracepoints(void);
  461. extern int module_get_iter_tracepoints(struct tracepoint_iter *iter);
  462.  
  463. #else /* !CONFIG_MODULES... */
  464. #define EXPORT_SYMBOL(sym)
  465. #define EXPORT_SYMBOL_GPL(sym)
  466. #define EXPORT_SYMBOL_GPL_FUTURE(sym)
  467. #define EXPORT_UNUSED_SYMBOL(sym)
  468. #define EXPORT_UNUSED_SYMBOL_GPL(sym)
  469.  
  470. /* Given an address, look for it in the exception tables. */
  471. static inline const struct exception_table_entry *
  472. search_module_extables(unsigned long addr)
  473. {
  474.     return NULL;
  475. }
  476.  
  477. /* Is this address in a module? */
  478. static inline struct module *module_text_address(unsigned long addr)
  479. {
  480.     return NULL;
  481. }
  482.  
  483. /* Is this address in a module? (don't take a lock, we're oopsing) */
  484. static inline struct module *__module_text_address(unsigned long addr)
  485. {
  486.     return NULL;
  487. }
  488.  
  489. static inline int is_module_address(unsigned long addr)
  490. {
  491.     return 0;
  492. }
  493.  
  494. /* Get/put a kernel symbol (calls should be symmetric) */
  495. #define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
  496. #define symbol_put(x) do { } while(0)
  497. #define symbol_put_addr(x) do { } while(0)
  498.  
  499. static inline void __module_get(struct module *module)
  500. {
  501. }
  502.  
  503. static inline int try_module_get(struct module *module)
  504. {
  505.     return 1;
  506. }
  507.  
  508. static inline void module_put(struct module *module)
  509. {
  510. }
  511.  
  512. #define module_name(mod) "kernel"
  513.  
  514. /* For kallsyms to ask for address resolution.  NULL means not found. */
  515. static inline const char *module_address_lookup(unsigned long addr,
  516.                       unsigned long *symbolsize,
  517.                       unsigned long *offset,
  518.                       char **modname,
  519.                       char *namebuf)
  520. {
  521.     return NULL;
  522. }
  523.  
  524. static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
  525. {
  526.     return -ERANGE;
  527. }
  528.  
  529. static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
  530. {
  531.     return -ERANGE;
  532. }
  533.  
  534. static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
  535.                     char *type, char *name,
  536.                     char *module_name, int *exported)
  537. {
  538.     return -ERANGE;
  539. }
  540.  
  541. static inline unsigned long module_kallsyms_lookup_name(const char *name)
  542. {
  543.     return 0;
  544. }
  545.  
  546. static inline int register_module_notifier(struct notifier_block * nb)
  547. {
  548.     /* no events will happen anyway, so this can always succeed */
  549.     return 0;
  550. }
  551.  
  552. static inline int unregister_module_notifier(struct notifier_block * nb)
  553. {
  554.     return 0;
  555. }
  556.  
  557. #define module_put_and_exit(code) do_exit(code)
  558.  
  559. static inline void print_modules(void)
  560. {
  561. }
  562.  
  563. static inline void module_update_markers(void)
  564. {
  565. }
  566.  
  567. static inline void module_update_tracepoints(void)
  568. {
  569. }
  570.  
  571. static inline int module_get_iter_tracepoints(struct tracepoint_iter *iter)
  572. {
  573.     return 0;
  574. }
  575.  
  576. #endif /* CONFIG_MODULES */
  577.  
  578. struct device_driver;
  579. #ifdef CONFIG_SYSFS
  580. struct module;
  581.  
  582. extern struct kset *module_kset;
  583. extern struct kobj_type module_ktype;
  584. extern int module_sysfs_initialized;
  585.  
  586. int mod_sysfs_init(struct module *mod);
  587. int mod_sysfs_setup(struct module *mod,
  588.                struct kernel_param *kparam,
  589.                unsigned int num_params);
  590. int module_add_modinfo_attrs(struct module *mod);
  591. void module_remove_modinfo_attrs(struct module *mod);
  592.  
  593. #else /* !CONFIG_SYSFS */
  594.  
  595. static inline int mod_sysfs_init(struct module *mod)
  596. {
  597.     return 0;
  598. }
  599.  
  600. static inline int mod_sysfs_setup(struct module *mod,
  601.                struct kernel_param *kparam,
  602.                unsigned int num_params)
  603. {
  604.     return 0;
  605. }
  606.  
  607. static inline int module_add_modinfo_attrs(struct module *mod)
  608. {
  609.     return 0;
  610. }
  611.  
  612. static inline void module_remove_modinfo_attrs(struct module *mod)
  613. { }
  614.  
  615. #endif /* CONFIG_SYSFS */
  616.  
  617. #define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
  618.  
  619. /* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
  620.  
  621. #define __MODULE_STRING(x) __stringify(x)
  622.  
  623. #endif /* _LINUX_MODULE_H */
  624.