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 <[email protected]> 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/tracepoint.h> 19 #include <linux/export.h> 20 21 #include <linux/percpu.h> 22 #include <asm/module.h> 23 24 /* In stripped ARM and x86-64 modules, ~ is surprisingly rare. */ 25 #define MODULE_SIG_STRING "~Module signature appended~\n" 26 27 /* Not Yet Implemented */ 28 #define MODULE_SUPPORTED_DEVICE(name) 29 30 #define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN 31 32 struct modversion_info { 33 unsigned long crc; 34 char name[MODULE_NAME_LEN]; 35 }; 36 37 struct module; 38 39 struct module_kobject { 40 struct kobject kobj; 41 struct module *mod; 42 struct kobject *drivers_dir; 43 struct module_param_attrs *mp; 44 struct completion *kobj_completion; 45 }; 46 47 struct module_attribute { 48 struct attribute attr; 49 ssize_t (*show)(struct module_attribute *, struct module_kobject *, 50 char *); 51 ssize_t (*store)(struct module_attribute *, struct module_kobject *, 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_version_attribute { 59 struct module_attribute mattr; 60 const char *module_name; 61 const char *version; 62 } __attribute__ ((__aligned__(sizeof(void *)))); 63 64 extern ssize_t __modver_version_show(struct module_attribute *, 65 struct module_kobject *, char *); 66 67 extern struct module_attribute module_uevent; 68 69 /* These are either module local, or the kernel's dummy ones. */ 70 extern int init_module(void); 71 extern void cleanup_module(void); 72 73 /* Archs provide a method of finding the correct exception table. */ 74 struct exception_table_entry; 75 76 const struct exception_table_entry * 77 search_extable(const struct exception_table_entry *first, 78 const struct exception_table_entry *last, 79 unsigned long value); 80 void sort_extable(struct exception_table_entry *start, 81 struct exception_table_entry *finish); 82 void sort_main_extable(void); 83 void trim_init_extable(struct module *m); 84 85 #ifdef MODULE 86 #define MODULE_GENERIC_TABLE(gtype, name) \ 87 extern const struct gtype##_id __mod_##gtype##_table \ 88 __attribute__ ((unused, alias(__stringify(name)))) 89 90 #else /* !MODULE */ 91 #define MODULE_GENERIC_TABLE(gtype, name) 92 #endif 93 94 /* Generic info of form tag = "info" */ 95 #define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info) 96 97 /* For userspace: you can also call me... */ 98 #define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias) 99 100 /* Soft module dependencies. See man modprobe.d for details. 101 * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz") 102 */ 103 #define MODULE_SOFTDEP(_softdep) MODULE_INFO(softdep, _softdep) 104 105 /* 106 * The following license idents are currently accepted as indicating free 107 * software modules 108 * 109 * "GPL" [GNU Public License v2 or later] 110 * "GPL v2" [GNU Public License v2] 111 * "GPL and additional rights" [GNU Public License v2 rights and more] 112 * "Dual BSD/GPL" [GNU Public License v2 113 * or BSD license choice] 114 * "Dual MIT/GPL" [GNU Public License v2 115 * or MIT license choice] 116 * "Dual MPL/GPL" [GNU Public License v2 117 * or Mozilla license choice] 118 * 119 * The following other idents are available 120 * 121 * "Proprietary" [Non free products] 122 * 123 * There are dual licensed components, but when running with Linux it is the 124 * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL 125 * is a GPL combined work. 126 * 127 * This exists for several reasons 128 * 1. So modinfo can show license info for users wanting to vet their setup 129 * is free 130 * 2. So the community can ignore bug reports including proprietary modules 131 * 3. So vendors can do likewise based on their own policies 132 */ 133 #define MODULE_LICENSE(_license) MODULE_INFO(license, _license) 134 135 /* 136 * Author(s), use "Name <email>" or just "Name", for multiple 137 * authors use multiple MODULE_AUTHOR() statements/lines. 138 */ 139 #define MODULE_AUTHOR(_author) MODULE_INFO(author, _author) 140 141 /* What your module does. */ 142 #define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description) 143 144 #define MODULE_DEVICE_TABLE(type, name) \ 145 MODULE_GENERIC_TABLE(type##_device, name) 146 147 /* Version of form [<epoch>:]<version>[-<extra-version>]. 148 * Or for CVS/RCS ID version, everything but the number is stripped. 149 * <epoch>: A (small) unsigned integer which allows you to start versions 150 * anew. If not mentioned, it's zero. eg. "2:1.0" is after 151 * "1:2.0". 152 153 * <version>: The <version> may contain only alphanumerics and the 154 * character `.'. Ordered by numeric sort for numeric parts, 155 * ascii sort for ascii parts (as per RPM or DEB algorithm). 156 157 * <extraversion>: Like <version>, but inserted for local 158 * customizations, eg "rh3" or "rusty1". 159 160 * Using this automatically adds a checksum of the .c files and the 161 * local headers in "srcversion". 162 */ 163 164 #if defined(MODULE) || !defined(CONFIG_SYSFS) 165 #define MODULE_VERSION(_version) MODULE_INFO(version, _version) 166 #else 167 #define MODULE_VERSION(_version) \ 168 static struct module_version_attribute ___modver_attr = { \ 169 .mattr = { \ 170 .attr = { \ 171 .name = "version", \ 172 .mode = S_IRUGO, \ 173 }, \ 174 .show = __modver_version_show, \ 175 }, \ 176 .module_name = KBUILD_MODNAME, \ 177 .version = _version, \ 178 }; \ 179 static const struct module_version_attribute \ 180 __used __attribute__ ((__section__ ("__modver"))) \ 181 * __moduleparam_const __modver_attr = &___modver_attr 182 #endif 183 184 /* Optional firmware file (or files) needed by the module 185 * format is simply firmware file name. Multiple firmware 186 * files require multiple MODULE_FIRMWARE() specifiers */ 187 #define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware) 188 189 /* Given an address, look for it in the exception tables */ 190 const struct exception_table_entry *search_exception_tables(unsigned long add); 191 192 struct notifier_block; 193 194 #ifdef CONFIG_MODULES 195 196 extern int modules_disabled; /* for sysctl */ 197 /* Get/put a kernel symbol (calls must be symmetric) */ 198 void *__symbol_get(const char *symbol); 199 void *__symbol_get_gpl(const char *symbol); 200 #define symbol_get(x) ((typeof(&x))(__symbol_get(VMLINUX_SYMBOL_STR(x)))) 201 202 /* modules using other modules: kdb wants to see this. */ 203 struct module_use { 204 struct list_head source_list; 205 struct list_head target_list; 206 struct module *source, *target; 207 }; 208 209 enum module_state { 210 MODULE_STATE_LIVE, /* Normal state. */ 211 MODULE_STATE_COMING, /* Full formed, running module_init. */ 212 MODULE_STATE_GOING, /* Going away. */ 213 MODULE_STATE_UNFORMED, /* Still setting it up. */ 214 }; 215 216 /** 217 * struct module_ref - per cpu module reference counts 218 * @incs: number of module get on this cpu 219 * @decs: number of module put on this cpu 220 * 221 * We force an alignment on 8 or 16 bytes, so that alloc_percpu() 222 * put @incs/@decs in same cache line, with no extra memory cost, 223 * since alloc_percpu() is fine grained. 224 */ 225 struct module_ref { 226 unsigned long incs; 227 unsigned long decs; 228 } __attribute((aligned(2 * sizeof(unsigned long)))); 229 230 struct module { 231 enum module_state state; 232 233 /* Member of list of modules */ 234 struct list_head list; 235 236 /* Unique handle for this module */ 237 char name[MODULE_NAME_LEN]; 238 239 /* Sysfs stuff. */ 240 struct module_kobject mkobj; 241 struct module_attribute *modinfo_attrs; 242 const char *version; 243 const char *srcversion; 244 struct kobject *holders_dir; 245 246 /* Exported symbols */ 247 const struct kernel_symbol *syms; 248 const unsigned long *crcs; 249 unsigned int num_syms; 250 251 /* Kernel parameters. */ 252 struct kernel_param *kp; 253 unsigned int num_kp; 254 255 /* GPL-only exported symbols. */ 256 unsigned int num_gpl_syms; 257 const struct kernel_symbol *gpl_syms; 258 const unsigned long *gpl_crcs; 259 260 #ifdef CONFIG_UNUSED_SYMBOLS 261 /* unused exported symbols. */ 262 const struct kernel_symbol *unused_syms; 263 const unsigned long *unused_crcs; 264 unsigned int num_unused_syms; 265 266 /* GPL-only, unused exported symbols. */ 267 unsigned int num_unused_gpl_syms; 268 const struct kernel_symbol *unused_gpl_syms; 269 const unsigned long *unused_gpl_crcs; 270 #endif 271 272 #ifdef CONFIG_MODULE_SIG 273 /* Signature was verified. */ 274 bool sig_ok; 275 #endif 276 277 /* symbols that will be GPL-only in the near future. */ 278 const struct kernel_symbol *gpl_future_syms; 279 const unsigned long *gpl_future_crcs; 280 unsigned int num_gpl_future_syms; 281 282 /* Exception table */ 283 unsigned int num_exentries; 284 struct exception_table_entry *extable; 285 286 /* Startup function. */ 287 int (*init)(void); 288 289 /* If this is non-NULL, vfree after init() returns */ 290 void *module_init; 291 292 /* Here is the actual code + data, vfree'd on unload. */ 293 void *module_core; 294 295 /* Here are the sizes of the init and core sections */ 296 unsigned int init_size, core_size; 297 298 /* The size of the executable code in each section. */ 299 unsigned int init_text_size, core_text_size; 300 301 /* Size of RO sections of the module (text+rodata) */ 302 unsigned int init_ro_size, core_ro_size; 303 304 /* Arch-specific module values */ 305 struct mod_arch_specific arch; 306 307 unsigned int taints; /* same bits as kernel:tainted */ 308 309 #ifdef CONFIG_GENERIC_BUG 310 /* Support for BUG */ 311 unsigned num_bugs; 312 struct list_head bug_list; 313 struct bug_entry *bug_table; 314 #endif 315 316 #ifdef CONFIG_KALLSYMS 317 /* 318 * We keep the symbol and string tables for kallsyms. 319 * The core_* fields below are temporary, loader-only (they 320 * could really be discarded after module init). 321 */ 322 Elf_Sym *symtab, *core_symtab; 323 unsigned int num_symtab, core_num_syms; 324 char *strtab, *core_strtab; 325 326 /* Section attributes */ 327 struct module_sect_attrs *sect_attrs; 328 329 /* Notes attributes */ 330 struct module_notes_attrs *notes_attrs; 331 #endif 332 333 /* The command line arguments (may be mangled). People like 334 keeping pointers to this stuff */ 335 char *args; 336 337 #ifdef CONFIG_SMP 338 /* Per-cpu data. */ 339 void __percpu *percpu; 340 unsigned int percpu_size; 341 #endif 342 343 #ifdef CONFIG_TRACEPOINTS 344 unsigned int num_tracepoints; 345 struct tracepoint * const *tracepoints_ptrs; 346 #endif 347 #ifdef HAVE_JUMP_LABEL 348 struct jump_entry *jump_entries; 349 unsigned int num_jump_entries; 350 #endif 351 #ifdef CONFIG_TRACING 352 unsigned int num_trace_bprintk_fmt; 353 const char **trace_bprintk_fmt_start; 354 #endif 355 #ifdef CONFIG_EVENT_TRACING 356 struct ftrace_event_call **trace_events; 357 unsigned int num_trace_events; 358 #endif 359 #ifdef CONFIG_FTRACE_MCOUNT_RECORD 360 unsigned int num_ftrace_callsites; 361 unsigned long *ftrace_callsites; 362 #endif 363 364 #ifdef CONFIG_MODULE_UNLOAD 365 /* What modules depend on me? */ 366 struct list_head source_list; 367 /* What modules do I depend on? */ 368 struct list_head target_list; 369 370 /* Destruction function. */ 371 void (*exit)(void); 372 373 struct module_ref __percpu *refptr; 374 #endif 375 376 #ifdef CONFIG_CONSTRUCTORS 377 /* Constructor functions. */ 378 ctor_fn_t *ctors; 379 unsigned int num_ctors; 380 #endif 381 }; 382 #ifndef MODULE_ARCH_INIT 383 #define MODULE_ARCH_INIT {} 384 #endif 385 386 extern struct mutex module_mutex; 387 388 /* FIXME: It'd be nice to isolate modules during init, too, so they 389 aren't used before they (may) fail. But presently too much code 390 (IDE & SCSI) require entry into the module during init.*/ 391 static inline int module_is_live(struct module *mod) 392 { 393 return mod->state != MODULE_STATE_GOING; 394 } 395 396 struct module *__module_text_address(unsigned long addr); 397 struct module *__module_address(unsigned long addr); 398 bool is_module_address(unsigned long addr); 399 bool is_module_percpu_address(unsigned long addr); 400 bool is_module_text_address(unsigned long addr); 401 402 static inline int within_module_core(unsigned long addr, const struct module *mod) 403 { 404 return (unsigned long)mod->module_core <= addr && 405 addr < (unsigned long)mod->module_core + mod->core_size; 406 } 407 408 static inline int within_module_init(unsigned long addr, const struct module *mod) 409 { 410 return (unsigned long)mod->module_init <= addr && 411 addr < (unsigned long)mod->module_init + mod->init_size; 412 } 413 414 /* Search for module by name: must hold module_mutex. */ 415 struct module *find_module(const char *name); 416 417 struct symsearch { 418 const struct kernel_symbol *start, *stop; 419 const unsigned long *crcs; 420 enum { 421 NOT_GPL_ONLY, 422 GPL_ONLY, 423 WILL_BE_GPL_ONLY, 424 } licence; 425 bool unused; 426 }; 427 428 /* Search for an exported symbol by name. */ 429 const struct kernel_symbol *find_symbol(const char *name, 430 struct module **owner, 431 const unsigned long **crc, 432 bool gplok, 433 bool warn); 434 435 /* Walk the exported symbol table */ 436 bool each_symbol_section(bool (*fn)(const struct symsearch *arr, 437 struct module *owner, 438 void *data), void *data); 439 440 /* Returns 0 and fills in value, defined and namebuf, or -ERANGE if 441 symnum out of range. */ 442 int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type, 443 char *name, char *module_name, int *exported); 444 445 /* Look for this name: can be of form module:name. */ 446 unsigned long module_kallsyms_lookup_name(const char *name); 447 448 int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *, 449 struct module *, unsigned long), 450 void *data); 451 452 extern void __module_put_and_exit(struct module *mod, long code) 453 __attribute__((noreturn)); 454 #define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code) 455 456 #ifdef CONFIG_MODULE_UNLOAD 457 unsigned long module_refcount(struct module *mod); 458 void __symbol_put(const char *symbol); 459 #define symbol_put(x) __symbol_put(VMLINUX_SYMBOL_STR(x)) 460 void symbol_put_addr(void *addr); 461 462 /* Sometimes we know we already have a refcount, and it's easier not 463 to handle the error case (which only happens with rmmod --wait). */ 464 extern void __module_get(struct module *module); 465 466 /* This is the Right Way to get a module: if it fails, it's being removed, 467 * so pretend it's not there. */ 468 extern bool try_module_get(struct module *module); 469 470 extern void module_put(struct module *module); 471 472 #else /*!CONFIG_MODULE_UNLOAD*/ 473 static inline int try_module_get(struct module *module) 474 { 475 return !module || module_is_live(module); 476 } 477 static inline void module_put(struct module *module) 478 { 479 } 480 static inline void __module_get(struct module *module) 481 { 482 } 483 #define symbol_put(x) do { } while (0) 484 #define symbol_put_addr(p) do { } while (0) 485 486 #endif /* CONFIG_MODULE_UNLOAD */ 487 int ref_module(struct module *a, struct module *b); 488 489 /* This is a #define so the string doesn't get put in every .o file */ 490 #define module_name(mod) \ 491 ({ \ 492 struct module *__mod = (mod); \ 493 __mod ? __mod->name : "kernel"; \ 494 }) 495 496 /* For kallsyms to ask for address resolution. namebuf should be at 497 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if 498 * found, otherwise NULL. */ 499 const char *module_address_lookup(unsigned long addr, 500 unsigned long *symbolsize, 501 unsigned long *offset, 502 char **modname, 503 char *namebuf); 504 int lookup_module_symbol_name(unsigned long addr, char *symname); 505 int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name); 506 507 /* For extable.c to search modules' exception tables. */ 508 const struct exception_table_entry *search_module_extables(unsigned long addr); 509 510 int register_module_notifier(struct notifier_block *nb); 511 int unregister_module_notifier(struct notifier_block *nb); 512 513 extern void print_modules(void); 514 515 #else /* !CONFIG_MODULES... */ 516 517 /* Given an address, look for it in the exception tables. */ 518 static inline const struct exception_table_entry * 519 search_module_extables(unsigned long addr) 520 { 521 return NULL; 522 } 523 524 static inline struct module *__module_address(unsigned long addr) 525 { 526 return NULL; 527 } 528 529 static inline struct module *__module_text_address(unsigned long addr) 530 { 531 return NULL; 532 } 533 534 static inline bool is_module_address(unsigned long addr) 535 { 536 return false; 537 } 538 539 static inline bool is_module_percpu_address(unsigned long addr) 540 { 541 return false; 542 } 543 544 static inline bool is_module_text_address(unsigned long addr) 545 { 546 return false; 547 } 548 549 /* Get/put a kernel symbol (calls should be symmetric) */ 550 #define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); }) 551 #define symbol_put(x) do { } while (0) 552 #define symbol_put_addr(x) do { } while (0) 553 554 static inline void __module_get(struct module *module) 555 { 556 } 557 558 static inline int try_module_get(struct module *module) 559 { 560 return 1; 561 } 562 563 static inline void module_put(struct module *module) 564 { 565 } 566 567 #define module_name(mod) "kernel" 568 569 /* For kallsyms to ask for address resolution. NULL means not found. */ 570 static inline const char *module_address_lookup(unsigned long addr, 571 unsigned long *symbolsize, 572 unsigned long *offset, 573 char **modname, 574 char *namebuf) 575 { 576 return NULL; 577 } 578 579 static inline int lookup_module_symbol_name(unsigned long addr, char *symname) 580 { 581 return -ERANGE; 582 } 583 584 static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name) 585 { 586 return -ERANGE; 587 } 588 589 static inline int module_get_kallsym(unsigned int symnum, unsigned long *value, 590 char *type, char *name, 591 char *module_name, int *exported) 592 { 593 return -ERANGE; 594 } 595 596 static inline unsigned long module_kallsyms_lookup_name(const char *name) 597 { 598 return 0; 599 } 600 601 static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *, 602 struct module *, 603 unsigned long), 604 void *data) 605 { 606 return 0; 607 } 608 609 static inline int register_module_notifier(struct notifier_block *nb) 610 { 611 /* no events will happen anyway, so this can always succeed */ 612 return 0; 613 } 614 615 static inline int unregister_module_notifier(struct notifier_block *nb) 616 { 617 return 0; 618 } 619 620 #define module_put_and_exit(code) do_exit(code) 621 622 static inline void print_modules(void) 623 { 624 } 625 #endif /* CONFIG_MODULES */ 626 627 #ifdef CONFIG_SYSFS 628 extern struct kset *module_kset; 629 extern struct kobj_type module_ktype; 630 extern int module_sysfs_initialized; 631 #endif /* CONFIG_SYSFS */ 632 633 #define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x) 634 635 /* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */ 636 637 #define __MODULE_STRING(x) __stringify(x) 638 639 #ifdef CONFIG_DEBUG_SET_MODULE_RONX 640 extern void set_all_modules_text_rw(void); 641 extern void set_all_modules_text_ro(void); 642 #else 643 static inline void set_all_modules_text_rw(void) { } 644 static inline void set_all_modules_text_ro(void) { } 645 #endif 646 647 #ifdef CONFIG_GENERIC_BUG 648 void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *, 649 struct module *); 650 void module_bug_cleanup(struct module *); 651 652 #else /* !CONFIG_GENERIC_BUG */ 653 654 static inline void module_bug_finalize(const Elf_Ehdr *hdr, 655 const Elf_Shdr *sechdrs, 656 struct module *mod) 657 { 658 } 659 static inline void module_bug_cleanup(struct module *mod) {} 660 #endif /* CONFIG_GENERIC_BUG */ 661 662 #endif /* _LINUX_MODULE_H */ 663