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