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 34struct kernel_symbol 35{ 36 unsigned long value; 37 const char *name; 38}; 39 40struct modversion_info 41{ 42 unsigned long crc; 43 char name[MODULE_NAME_LEN]; 44}; 45 46struct module; 47 48struct 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 58struct 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. */ 65extern int init_module(void); 66extern void cleanup_module(void); 67 68/* Archs provide a method of finding the correct exception table. */ 69struct exception_table_entry; 70 71const struct exception_table_entry * 72search_extable(const struct exception_table_entry *first, 73 const struct exception_table_entry *last, 74 unsigned long value); 75void sort_extable(struct exception_table_entry *start, 76 struct exception_table_entry *finish); 77void sort_main_extable(void); 78 79extern struct subsystem module_subsys; 80 81#ifdef MODULE 82#define MODULE_GENERIC_TABLE(gtype,name) \ 83extern const struct gtype##_id __mod_##gtype##_table \ 84 __attribute__ ((unused, alias(__stringify(name)))) 85 86extern 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 <EMAIL>[, NAME <EMAIL>]*[ and NAME <EMAIL>] */ 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/* Given an address, look for it in the exception tables */ 160const struct exception_table_entry *search_exception_tables(unsigned long add); 161 162struct notifier_block; 163 164#ifdef CONFIG_MODULES 165 166/* Get/put a kernel symbol (calls must be symmetric) */ 167void *__symbol_get(const char *symbol); 168void *__symbol_get_gpl(const char *symbol); 169#define symbol_get(x) ((typeof(&x))(__symbol_get(MODULE_SYMBOL_PREFIX #x))) 170 171#ifndef __GENKSYMS__ 172#ifdef CONFIG_MODVERSIONS 173/* Mark the CRC weak since genksyms apparently decides not to 174 * generate a checksums for some symbols */ 175#define __CRC_SYMBOL(sym, sec) \ 176 extern void *__crc_##sym __attribute__((weak)); \ 177 static const unsigned long __kcrctab_##sym \ 178 __attribute_used__ \ 179 __attribute__((section("__kcrctab" sec), unused)) \ 180 = (unsigned long) &__crc_##sym; 181#else 182#define __CRC_SYMBOL(sym, sec) 183#endif 184 185/* For every exported symbol, place a struct in the __ksymtab section */ 186#define __EXPORT_SYMBOL(sym, sec) \ 187 extern typeof(sym) sym; \ 188 __CRC_SYMBOL(sym, sec) \ 189 static const char __kstrtab_##sym[] \ 190 __attribute__((section("__ksymtab_strings"))) \ 191 = MODULE_SYMBOL_PREFIX #sym; \ 192 static const struct kernel_symbol __ksymtab_##sym \ 193 __attribute_used__ \ 194 __attribute__((section("__ksymtab" sec), unused)) \ 195 = { (unsigned long)&sym, __kstrtab_##sym } 196 197#define EXPORT_SYMBOL(sym) \ 198 __EXPORT_SYMBOL(sym, "") 199 200#define EXPORT_SYMBOL_GPL(sym) \ 201 __EXPORT_SYMBOL(sym, "_gpl") 202 203#define EXPORT_SYMBOL_GPL_FUTURE(sym) \ 204 __EXPORT_SYMBOL(sym, "_gpl_future") 205 206 207#ifdef CONFIG_UNUSED_SYMBOLS 208#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused") 209#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl") 210#else 211#define EXPORT_UNUSED_SYMBOL(sym) 212#define EXPORT_UNUSED_SYMBOL_GPL(sym) 213#endif 214 215#endif 216 217struct module_ref 218{ 219 local_t count; 220} ____cacheline_aligned; 221 222enum module_state 223{ 224 MODULE_STATE_LIVE, 225 MODULE_STATE_COMING, 226 MODULE_STATE_GOING, 227}; 228 229/* Similar stuff for section attributes. */ 230#define MODULE_SECT_NAME_LEN 32 231struct module_sect_attr 232{ 233 struct module_attribute mattr; 234 char name[MODULE_SECT_NAME_LEN]; 235 unsigned long address; 236}; 237 238struct module_sect_attrs 239{ 240 struct attribute_group grp; 241 struct module_sect_attr attrs[0]; 242}; 243 244struct module_param_attrs; 245 246struct module 247{ 248 enum module_state state; 249 250 /* Member of list of modules */ 251 struct list_head list; 252 253 /* Unique handle for this module */ 254 char name[MODULE_NAME_LEN]; 255 256 /* Sysfs stuff. */ 257 struct module_kobject mkobj; 258 struct module_param_attrs *param_attrs; 259 struct module_attribute *modinfo_attrs; 260 const char *version; 261 const char *srcversion; 262 263 /* Exported symbols */ 264 const struct kernel_symbol *syms; 265 unsigned int num_syms; 266 const unsigned long *crcs; 267 268 /* GPL-only exported symbols. */ 269 const struct kernel_symbol *gpl_syms; 270 unsigned int num_gpl_syms; 271 const unsigned long *gpl_crcs; 272 273 /* unused exported symbols. */ 274 const struct kernel_symbol *unused_syms; 275 unsigned int num_unused_syms; 276 const unsigned long *unused_crcs; 277 /* GPL-only, unused exported symbols. */ 278 const struct kernel_symbol *unused_gpl_syms; 279 unsigned int num_unused_gpl_syms; 280 const unsigned long *unused_gpl_crcs; 281 282 /* symbols that will be GPL-only in the near future. */ 283 const struct kernel_symbol *gpl_future_syms; 284 unsigned int num_gpl_future_syms; 285 const unsigned long *gpl_future_crcs; 286 287 /* Exception table */ 288 unsigned int num_exentries; 289 const struct exception_table_entry *extable; 290 291 /* Startup function. */ 292 int (*init)(void); 293 294 /* If this is non-NULL, vfree after init() returns */ 295 void *module_init; 296 297 /* Here is the actual code + data, vfree'd on unload. */ 298 void *module_core; 299 300 /* Here are the sizes of the init and core sections */ 301 unsigned long init_size, core_size; 302 303 /* The size of the executable code in each section. */ 304 unsigned long init_text_size, core_text_size; 305 306 /* The handle returned from unwind_add_table. */ 307 void *unwind_info; 308 309 /* Arch-specific module values */ 310 struct mod_arch_specific arch; 311 312 /* Am I unsafe to unload? */ 313 int unsafe; 314 315 /* Am I GPL-compatible */ 316 int license_gplok; 317 318#ifdef CONFIG_MODULE_UNLOAD 319 /* Reference counts */ 320 struct module_ref ref[NR_CPUS]; 321 322 /* What modules depend on me? */ 323 struct list_head modules_which_use_me; 324 325 /* Who is waiting for us to be unloaded */ 326 struct task_struct *waiter; 327 328 /* Destruction function. */ 329 void (*exit)(void); 330#endif 331 332#ifdef CONFIG_KALLSYMS 333 /* We keep the symbol and string tables for kallsyms. */ 334 Elf_Sym *symtab; 335 unsigned long num_symtab; 336 char *strtab; 337 338 /* Section attributes */ 339 struct module_sect_attrs *sect_attrs; 340#endif 341 342 /* Per-cpu data. */ 343 void *percpu; 344 345 /* The command line arguments (may be mangled). People like 346 keeping pointers to this stuff */ 347 char *args; 348}; 349 350/* FIXME: It'd be nice to isolate modules during init, too, so they 351 aren't used before they (may) fail. But presently too much code 352 (IDE & SCSI) require entry into the module during init.*/ 353static inline int module_is_live(struct module *mod) 354{ 355 return mod->state != MODULE_STATE_GOING; 356} 357 358/* Is this address in a module? (second is with no locks, for oops) */ 359struct module *module_text_address(unsigned long addr); 360struct module *__module_text_address(unsigned long addr); 361int is_module_address(unsigned long addr); 362 363/* Returns module and fills in value, defined and namebuf, or NULL if 364 symnum out of range. */ 365struct module *module_get_kallsym(unsigned int symnum, unsigned long *value, 366 char *type, char *name, size_t namelen); 367 368/* Look for this name: can be of form module:name. */ 369unsigned long module_kallsyms_lookup_name(const char *name); 370 371int is_exported(const char *name, const struct module *mod); 372 373extern void __module_put_and_exit(struct module *mod, long code) 374 __attribute__((noreturn)); 375#define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code); 376 377#ifdef CONFIG_MODULE_UNLOAD 378unsigned int module_refcount(struct module *mod); 379void __symbol_put(const char *symbol); 380#define symbol_put(x) __symbol_put(MODULE_SYMBOL_PREFIX #x) 381void symbol_put_addr(void *addr); 382 383/* Sometimes we know we already have a refcount, and it's easier not 384 to handle the error case (which only happens with rmmod --wait). */ 385static inline void __module_get(struct module *module) 386{ 387 if (module) { 388 BUG_ON(module_refcount(module) == 0); 389 local_inc(&module->ref[get_cpu()].count); 390 put_cpu(); 391 } 392} 393 394static inline int try_module_get(struct module *module) 395{ 396 int ret = 1; 397 398 if (module) { 399 unsigned int cpu = get_cpu(); 400 if (likely(module_is_live(module))) 401 local_inc(&module->ref[cpu].count); 402 else 403 ret = 0; 404 put_cpu(); 405 } 406 return ret; 407} 408 409static inline void module_put(struct module *module) 410{ 411 if (module) { 412 unsigned int cpu = get_cpu(); 413 local_dec(&module->ref[cpu].count); 414 /* Maybe they're waiting for us to drop reference? */ 415 if (unlikely(!module_is_live(module))) 416 wake_up_process(module->waiter); 417 put_cpu(); 418 } 419} 420 421#else /*!CONFIG_MODULE_UNLOAD*/ 422static inline int try_module_get(struct module *module) 423{ 424 return !module || module_is_live(module); 425} 426static inline void module_put(struct module *module) 427{ 428} 429static inline void __module_get(struct module *module) 430{ 431} 432#define symbol_put(x) do { } while(0) 433#define symbol_put_addr(p) do { } while(0) 434 435#endif /* CONFIG_MODULE_UNLOAD */ 436 437/* This is a #define so the string doesn't get put in every .o file */ 438#define module_name(mod) \ 439({ \ 440 struct module *__mod = (mod); \ 441 __mod ? __mod->name : "kernel"; \ 442}) 443 444#define __unsafe(mod) \ 445do { \ 446 if (mod && !(mod)->unsafe) { \ 447 printk(KERN_WARNING \ 448 "Module %s cannot be unloaded due to unsafe usage in" \ 449 " %s:%u\n", (mod)->name, __FILE__, __LINE__); \ 450 (mod)->unsafe = 1; \ 451 } \ 452} while(0) 453 454/* For kallsyms to ask for address resolution. NULL means not found. */ 455const char *module_address_lookup(unsigned long addr, 456 unsigned long *symbolsize, 457 unsigned long *offset, 458 char **modname); 459 460/* For extable.c to search modules' exception tables. */ 461const struct exception_table_entry *search_module_extables(unsigned long addr); 462 463int register_module_notifier(struct notifier_block * nb); 464int unregister_module_notifier(struct notifier_block * nb); 465 466extern void print_modules(void); 467 468struct device_driver; 469void module_add_driver(struct module *, struct device_driver *); 470void module_remove_driver(struct device_driver *); 471 472#else /* !CONFIG_MODULES... */ 473#define EXPORT_SYMBOL(sym) 474#define EXPORT_SYMBOL_GPL(sym) 475#define EXPORT_SYMBOL_GPL_FUTURE(sym) 476#define EXPORT_UNUSED_SYMBOL(sym) 477#define EXPORT_UNUSED_SYMBOL_GPL(sym) 478 479/* Given an address, look for it in the exception tables. */ 480static inline const struct exception_table_entry * 481search_module_extables(unsigned long addr) 482{ 483 return NULL; 484} 485 486/* Is this address in a module? */ 487static inline struct module *module_text_address(unsigned long addr) 488{ 489 return NULL; 490} 491 492/* Is this address in a module? (don't take a lock, we're oopsing) */ 493static inline struct module *__module_text_address(unsigned long addr) 494{ 495 return NULL; 496} 497 498static inline int is_module_address(unsigned long addr) 499{ 500 return 0; 501} 502 503/* Get/put a kernel symbol (calls should be symmetric) */ 504#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); }) 505#define symbol_put(x) do { } while(0) 506#define symbol_put_addr(x) do { } while(0) 507 508static inline void __module_get(struct module *module) 509{ 510} 511 512static inline int try_module_get(struct module *module) 513{ 514 return 1; 515} 516 517static inline void module_put(struct module *module) 518{ 519} 520 521#define module_name(mod) "kernel" 522 523#define __unsafe(mod) 524 525/* For kallsyms to ask for address resolution. NULL means not found. */ 526static inline const char *module_address_lookup(unsigned long addr, 527 unsigned long *symbolsize, 528 unsigned long *offset, 529 char **modname) 530{ 531 return NULL; 532} 533 534static inline struct module *module_get_kallsym(unsigned int symnum, 535 unsigned long *value, 536 char *type, char *name, 537 size_t namelen) 538{ 539 return NULL; 540} 541 542static inline unsigned long module_kallsyms_lookup_name(const char *name) 543{ 544 return 0; 545} 546 547static inline int is_exported(const char *name, const struct module *mod) 548{ 549 return 0; 550} 551 552static inline int register_module_notifier(struct notifier_block * nb) 553{ 554 /* no events will happen anyway, so this can always succeed */ 555 return 0; 556} 557 558static inline int unregister_module_notifier(struct notifier_block * nb) 559{ 560 return 0; 561} 562 563#define module_put_and_exit(code) do_exit(code) 564 565static inline void print_modules(void) 566{ 567} 568 569struct device_driver; 570struct module; 571 572static inline void module_add_driver(struct module *module, struct device_driver *driver) 573{ 574} 575 576static inline void module_remove_driver(struct device_driver *driver) 577{ 578} 579 580#endif /* CONFIG_MODULES */ 581 582#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x) 583 584/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */ 585 586#define __MODULE_STRING(x) __stringify(x) 587 588#endif /* _LINUX_MODULE_H */ 589