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 (at) 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 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 */ 160 const struct exception_table_entry *search_exception_tables(unsigned long add); 161 162 struct notifier_block; 163 164 #ifdef CONFIG_MODULES 165 166 /* Get/put a kernel symbol (calls must be symmetric) */ 167 void *__symbol_get(const char *symbol); 168 void *__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 217 struct module_ref 218 { 219 local_t count; 220 } ____cacheline_aligned; 221 222 enum 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 231 struct module_sect_attr 232 { 233 struct module_attribute mattr; 234 char name[MODULE_SECT_NAME_LEN]; 235 unsigned long address; 236 }; 237 238 struct module_sect_attrs 239 { 240 struct attribute_group grp; 241 struct module_sect_attr attrs[0]; 242 }; 243 244 struct module_param_attrs; 245 246 struct 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.*/ 353 static 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) */ 359 struct module *module_text_address(unsigned long addr); 360 struct module *__module_text_address(unsigned long addr); 361 int 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. */ 365 struct 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. */ 369 unsigned long module_kallsyms_lookup_name(const char *name); 370 371 int is_exported(const char *name, const struct module *mod); 372 373 extern 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 378 unsigned int module_refcount(struct module *mod); 379 void __symbol_put(const char *symbol); 380 #define symbol_put(x) __symbol_put(MODULE_SYMBOL_PREFIX #x) 381 void 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). */ 385 static 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 394 static 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 409 static 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*/ 422 static inline int try_module_get(struct module *module) 423 { 424 return !module || module_is_live(module); 425 } 426 static inline void module_put(struct module *module) 427 { 428 } 429 static 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) \ 445 do { \ 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. */ 455 const 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. */ 461 const struct exception_table_entry *search_module_extables(unsigned long addr); 462 463 int register_module_notifier(struct notifier_block * nb); 464 int unregister_module_notifier(struct notifier_block * nb); 465 466 extern void print_modules(void); 467 468 struct device_driver; 469 void module_add_driver(struct module *, struct device_driver *); 470 void 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. */ 480 static inline const struct exception_table_entry * 481 search_module_extables(unsigned long addr) 482 { 483 return NULL; 484 } 485 486 /* Is this address in a module? */ 487 static 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) */ 493 static inline struct module *__module_text_address(unsigned long addr) 494 { 495 return NULL; 496 } 497 498 static 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 508 static inline void __module_get(struct module *module) 509 { 510 } 511 512 static inline int try_module_get(struct module *module) 513 { 514 return 1; 515 } 516 517 static 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. */ 526 static 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 534 static 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 542 static inline unsigned long module_kallsyms_lookup_name(const char *name) 543 { 544 return 0; 545 } 546 547 static inline int is_exported(const char *name, const struct module *mod) 548 { 549 return 0; 550 } 551 552 static 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 558 static 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 565 static inline void print_modules(void) 566 { 567 } 568 569 struct device_driver; 570 struct module; 571 572 static inline void module_add_driver(struct module *module, struct device_driver *driver) 573 { 574 } 575 576 static 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
