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/init.h> 15 #include <linux/elf.h> 16 #include <linux/stringify.h> 17 #include <linux/kobject.h> 18 #include <linux/moduleparam.h> 19 #include <linux/jump_label.h> 20 #include <linux/export.h> 21 #include <linux/rbtree_latch.h> 22 #include <linux/error-injection.h> 23 #include <linux/tracepoint-defs.h> 24 #include <linux/srcu.h> 25 26 #include <linux/percpu.h> 27 #include <asm/module.h> 28 29 /* Not Yet Implemented */ 30 #define MODULE_SUPPORTED_DEVICE(name) 31 32 #define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN 33 34 struct modversion_info { 35 unsigned long crc; 36 char name[MODULE_NAME_LEN]; 37 }; 38 39 struct module; 40 struct exception_table_entry; 41 42 struct module_kobject { 43 struct kobject kobj; 44 struct module *mod; 45 struct kobject *drivers_dir; 46 struct module_param_attrs *mp; 47 struct completion *kobj_completion; 48 } __randomize_layout; 49 50 struct module_attribute { 51 struct attribute attr; 52 ssize_t (*show)(struct module_attribute *, struct module_kobject *, 53 char *); 54 ssize_t (*store)(struct module_attribute *, struct module_kobject *, 55 const char *, size_t count); 56 void (*setup)(struct module *, const char *); 57 int (*test)(struct module *); 58 void (*free)(struct module *); 59 }; 60 61 struct module_version_attribute { 62 struct module_attribute mattr; 63 const char *module_name; 64 const char *version; 65 } __attribute__ ((__aligned__(sizeof(void *)))); 66 67 extern ssize_t __modver_version_show(struct module_attribute *, 68 struct module_kobject *, char *); 69 70 extern struct module_attribute module_uevent; 71 72 /* These are either module local, or the kernel's dummy ones. */ 73 extern int init_module(void); 74 extern void cleanup_module(void); 75 76 #ifndef MODULE 77 /** 78 * module_init() - driver initialization entry point 79 * @x: function to be run at kernel boot time or module insertion 80 * 81 * module_init() will either be called during do_initcalls() (if 82 * builtin) or at module insertion time (if a module). There can only 83 * be one per module. 84 */ 85 #define module_init(x) __initcall(x); 86 87 /** 88 * module_exit() - driver exit entry point 89 * @x: function to be run when driver is removed 90 * 91 * module_exit() will wrap the driver clean-up code 92 * with cleanup_module() when used with rmmod when 93 * the driver is a module. If the driver is statically 94 * compiled into the kernel, module_exit() has no effect. 95 * There can only be one per module. 96 */ 97 #define module_exit(x) __exitcall(x); 98 99 #else /* MODULE */ 100 101 /* 102 * In most cases loadable modules do not need custom 103 * initcall levels. There are still some valid cases where 104 * a driver may be needed early if built in, and does not 105 * matter when built as a loadable module. Like bus 106 * snooping debug drivers. 107 */ 108 #define early_initcall(fn) module_init(fn) 109 #define core_initcall(fn) module_init(fn) 110 #define core_initcall_sync(fn) module_init(fn) 111 #define postcore_initcall(fn) module_init(fn) 112 #define postcore_initcall_sync(fn) module_init(fn) 113 #define arch_initcall(fn) module_init(fn) 114 #define subsys_initcall(fn) module_init(fn) 115 #define subsys_initcall_sync(fn) module_init(fn) 116 #define fs_initcall(fn) module_init(fn) 117 #define fs_initcall_sync(fn) module_init(fn) 118 #define rootfs_initcall(fn) module_init(fn) 119 #define device_initcall(fn) module_init(fn) 120 #define device_initcall_sync(fn) module_init(fn) 121 #define late_initcall(fn) module_init(fn) 122 #define late_initcall_sync(fn) module_init(fn) 123 124 #define console_initcall(fn) module_init(fn) 125 126 /* Each module must use one module_init(). */ 127 #define module_init(initfn) \ 128 static inline initcall_t __maybe_unused __inittest(void) \ 129 { return initfn; } \ 130 int init_module(void) __copy(initfn) __attribute__((alias(#initfn))); 131 132 /* This is only required if you want to be unloadable. */ 133 #define module_exit(exitfn) \ 134 static inline exitcall_t __maybe_unused __exittest(void) \ 135 { return exitfn; } \ 136 void cleanup_module(void) __copy(exitfn) __attribute__((alias(#exitfn))); 137 138 #endif 139 140 /* This means "can be init if no module support, otherwise module load 141 may call it." */ 142 #ifdef CONFIG_MODULES 143 #define __init_or_module 144 #define __initdata_or_module 145 #define __initconst_or_module 146 #define __INIT_OR_MODULE .text 147 #define __INITDATA_OR_MODULE .data 148 #define __INITRODATA_OR_MODULE .section ".rodata","a",%progbits 149 #else 150 #define __init_or_module __init 151 #define __initdata_or_module __initdata 152 #define __initconst_or_module __initconst 153 #define __INIT_OR_MODULE __INIT 154 #define __INITDATA_OR_MODULE __INITDATA 155 #define __INITRODATA_OR_MODULE __INITRODATA 156 #endif /*CONFIG_MODULES*/ 157 158 /* Generic info of form tag = "info" */ 159 #define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info) 160 161 /* For userspace: you can also call me... */ 162 #define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias) 163 164 /* Soft module dependencies. See man modprobe.d for details. 165 * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz") 166 */ 167 #define MODULE_SOFTDEP(_softdep) MODULE_INFO(softdep, _softdep) 168 169 /* 170 * The following license idents are currently accepted as indicating free 171 * software modules 172 * 173 * "GPL" [GNU Public License v2] 174 * "GPL v2" [GNU Public License v2] 175 * "GPL and additional rights" [GNU Public License v2 rights and more] 176 * "Dual BSD/GPL" [GNU Public License v2 177 * or BSD license choice] 178 * "Dual MIT/GPL" [GNU Public License v2 179 * or MIT license choice] 180 * "Dual MPL/GPL" [GNU Public License v2 181 * or Mozilla license choice] 182 * 183 * The following other idents are available 184 * 185 * "Proprietary" [Non free products] 186 * 187 * Both "GPL v2" and "GPL" (the latter also in dual licensed strings) are 188 * merely stating that the module is licensed under the GPL v2, but are not 189 * telling whether "GPL v2 only" or "GPL v2 or later". The reason why there 190 * are two variants is a historic and failed attempt to convey more 191 * information in the MODULE_LICENSE string. For module loading the 192 * "only/or later" distinction is completely irrelevant and does neither 193 * replace the proper license identifiers in the corresponding source file 194 * nor amends them in any way. The sole purpose is to make the 195 * 'Proprietary' flagging work and to refuse to bind symbols which are 196 * exported with EXPORT_SYMBOL_GPL when a non free module is loaded. 197 * 198 * In the same way "BSD" is not a clear license information. It merely 199 * states, that the module is licensed under one of the compatible BSD 200 * license variants. The detailed and correct license information is again 201 * to be found in the corresponding source files. 202 * 203 * There are dual licensed components, but when running with Linux it is the 204 * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL 205 * is a GPL combined work. 206 * 207 * This exists for several reasons 208 * 1. So modinfo can show license info for users wanting to vet their setup 209 * is free 210 * 2. So the community can ignore bug reports including proprietary modules 211 * 3. So vendors can do likewise based on their own policies 212 */ 213 #define MODULE_LICENSE(_license) MODULE_INFO(license, _license) 214 215 /* 216 * Author(s), use "Name <email>" or just "Name", for multiple 217 * authors use multiple MODULE_AUTHOR() statements/lines. 218 */ 219 #define MODULE_AUTHOR(_author) MODULE_INFO(author, _author) 220 221 /* What your module does. */ 222 #define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description) 223 224 #ifdef MODULE 225 /* Creates an alias so file2alias.c can find device table. */ 226 #define MODULE_DEVICE_TABLE(type, name) \ 227 extern typeof(name) __mod_##type##__##name##_device_table \ 228 __attribute__ ((unused, alias(__stringify(name)))) 229 #else /* !MODULE */ 230 #define MODULE_DEVICE_TABLE(type, name) 231 #endif 232 233 /* Version of form [<epoch>:]<version>[-<extra-version>]. 234 * Or for CVS/RCS ID version, everything but the number is stripped. 235 * <epoch>: A (small) unsigned integer which allows you to start versions 236 * anew. If not mentioned, it's zero. eg. "2:1.0" is after 237 * "1:2.0". 238 239 * <version>: The <version> may contain only alphanumerics and the 240 * character `.'. Ordered by numeric sort for numeric parts, 241 * ascii sort for ascii parts (as per RPM or DEB algorithm). 242 243 * <extraversion>: Like <version>, but inserted for local 244 * customizations, eg "rh3" or "rusty1". 245 246 * Using this automatically adds a checksum of the .c files and the 247 * local headers in "srcversion". 248 */ 249 250 #if defined(MODULE) || !defined(CONFIG_SYSFS) 251 #define MODULE_VERSION(_version) MODULE_INFO(version, _version) 252 #else 253 #define MODULE_VERSION(_version) \ 254 MODULE_INFO(version, _version); \ 255 static struct module_version_attribute ___modver_attr = { \ 256 .mattr = { \ 257 .attr = { \ 258 .name = "version", \ 259 .mode = S_IRUGO, \ 260 }, \ 261 .show = __modver_version_show, \ 262 }, \ 263 .module_name = KBUILD_MODNAME, \ 264 .version = _version, \ 265 }; \ 266 static const struct module_version_attribute \ 267 __used __attribute__ ((__section__ ("__modver"))) \ 268 * __moduleparam_const __modver_attr = &___modver_attr 269 #endif 270 271 /* Optional firmware file (or files) needed by the module 272 * format is simply firmware file name. Multiple firmware 273 * files require multiple MODULE_FIRMWARE() specifiers */ 274 #define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware) 275 276 #define MODULE_IMPORT_NS(ns) MODULE_INFO(import_ns, #ns) 277 278 struct notifier_block; 279 280 #ifdef CONFIG_MODULES 281 282 extern int modules_disabled; /* for sysctl */ 283 /* Get/put a kernel symbol (calls must be symmetric) */ 284 void *__symbol_get(const char *symbol); 285 void *__symbol_get_gpl(const char *symbol); 286 #define symbol_get(x) ((typeof(&x))(__symbol_get(__stringify(x)))) 287 288 /* modules using other modules: kdb wants to see this. */ 289 struct module_use { 290 struct list_head source_list; 291 struct list_head target_list; 292 struct module *source, *target; 293 }; 294 295 enum module_state { 296 MODULE_STATE_LIVE, /* Normal state. */ 297 MODULE_STATE_COMING, /* Full formed, running module_init. */ 298 MODULE_STATE_GOING, /* Going away. */ 299 MODULE_STATE_UNFORMED, /* Still setting it up. */ 300 }; 301 302 struct mod_tree_node { 303 struct module *mod; 304 struct latch_tree_node node; 305 }; 306 307 struct module_layout { 308 /* The actual code + data. */ 309 void *base; 310 /* Total size. */ 311 unsigned int size; 312 /* The size of the executable code. */ 313 unsigned int text_size; 314 /* Size of RO section of the module (text+rodata) */ 315 unsigned int ro_size; 316 /* Size of RO after init section */ 317 unsigned int ro_after_init_size; 318 319 #ifdef CONFIG_MODULES_TREE_LOOKUP 320 struct mod_tree_node mtn; 321 #endif 322 }; 323 324 #ifdef CONFIG_MODULES_TREE_LOOKUP 325 /* Only touch one cacheline for common rbtree-for-core-layout case. */ 326 #define __module_layout_align ____cacheline_aligned 327 #else 328 #define __module_layout_align 329 #endif 330 331 struct mod_kallsyms { 332 Elf_Sym *symtab; 333 unsigned int num_symtab; 334 char *strtab; 335 char *typetab; 336 }; 337 338 #ifdef CONFIG_LIVEPATCH 339 struct klp_modinfo { 340 Elf_Ehdr hdr; 341 Elf_Shdr *sechdrs; 342 char *secstrings; 343 unsigned int symndx; 344 }; 345 #endif 346 347 struct module { 348 enum module_state state; 349 350 /* Member of list of modules */ 351 struct list_head list; 352 353 /* Unique handle for this module */ 354 char name[MODULE_NAME_LEN]; 355 356 /* Sysfs stuff. */ 357 struct module_kobject mkobj; 358 struct module_attribute *modinfo_attrs; 359 const char *version; 360 const char *srcversion; 361 struct kobject *holders_dir; 362 363 /* Exported symbols */ 364 const struct kernel_symbol *syms; 365 const s32 *crcs; 366 unsigned int num_syms; 367 368 /* Kernel parameters. */ 369 #ifdef CONFIG_SYSFS 370 struct mutex param_lock; 371 #endif 372 struct kernel_param *kp; 373 unsigned int num_kp; 374 375 /* GPL-only exported symbols. */ 376 unsigned int num_gpl_syms; 377 const struct kernel_symbol *gpl_syms; 378 const s32 *gpl_crcs; 379 380 #ifdef CONFIG_UNUSED_SYMBOLS 381 /* unused exported symbols. */ 382 const struct kernel_symbol *unused_syms; 383 const s32 *unused_crcs; 384 unsigned int num_unused_syms; 385 386 /* GPL-only, unused exported symbols. */ 387 unsigned int num_unused_gpl_syms; 388 const struct kernel_symbol *unused_gpl_syms; 389 const s32 *unused_gpl_crcs; 390 #endif 391 392 #ifdef CONFIG_MODULE_SIG 393 /* Signature was verified. */ 394 bool sig_ok; 395 #endif 396 397 bool async_probe_requested; 398 399 /* symbols that will be GPL-only in the near future. */ 400 const struct kernel_symbol *gpl_future_syms; 401 const s32 *gpl_future_crcs; 402 unsigned int num_gpl_future_syms; 403 404 /* Exception table */ 405 unsigned int num_exentries; 406 struct exception_table_entry *extable; 407 408 /* Startup function. */ 409 int (*init)(void); 410 411 /* Core layout: rbtree is accessed frequently, so keep together. */ 412 struct module_layout core_layout __module_layout_align; 413 struct module_layout init_layout; 414 415 /* Arch-specific module values */ 416 struct mod_arch_specific arch; 417 418 unsigned long taints; /* same bits as kernel:taint_flags */ 419 420 #ifdef CONFIG_GENERIC_BUG 421 /* Support for BUG */ 422 unsigned num_bugs; 423 struct list_head bug_list; 424 struct bug_entry *bug_table; 425 #endif 426 427 #ifdef CONFIG_KALLSYMS 428 /* Protected by RCU and/or module_mutex: use rcu_dereference() */ 429 struct mod_kallsyms *kallsyms; 430 struct mod_kallsyms core_kallsyms; 431 432 /* Section attributes */ 433 struct module_sect_attrs *sect_attrs; 434 435 /* Notes attributes */ 436 struct module_notes_attrs *notes_attrs; 437 #endif 438 439 /* The command line arguments (may be mangled). People like 440 keeping pointers to this stuff */ 441 char *args; 442 443 #ifdef CONFIG_SMP 444 /* Per-cpu data. */ 445 void __percpu *percpu; 446 unsigned int percpu_size; 447 #endif 448 449 #ifdef CONFIG_TRACEPOINTS 450 unsigned int num_tracepoints; 451 tracepoint_ptr_t *tracepoints_ptrs; 452 #endif 453 #ifdef CONFIG_TREE_SRCU 454 unsigned int num_srcu_structs; 455 struct srcu_struct **srcu_struct_ptrs; 456 #endif 457 #ifdef CONFIG_BPF_EVENTS 458 unsigned int num_bpf_raw_events; 459 struct bpf_raw_event_map *bpf_raw_events; 460 #endif 461 #ifdef CONFIG_JUMP_LABEL 462 struct jump_entry *jump_entries; 463 unsigned int num_jump_entries; 464 #endif 465 #ifdef CONFIG_TRACING 466 unsigned int num_trace_bprintk_fmt; 467 const char **trace_bprintk_fmt_start; 468 #endif 469 #ifdef CONFIG_EVENT_TRACING 470 struct trace_event_call **trace_events; 471 unsigned int num_trace_events; 472 struct trace_eval_map **trace_evals; 473 unsigned int num_trace_evals; 474 #endif 475 #ifdef CONFIG_FTRACE_MCOUNT_RECORD 476 unsigned int num_ftrace_callsites; 477 unsigned long *ftrace_callsites; 478 #endif 479 480 #ifdef CONFIG_LIVEPATCH 481 bool klp; /* Is this a livepatch module? */ 482 bool klp_alive; 483 484 /* Elf information */ 485 struct klp_modinfo *klp_info; 486 #endif 487 488 #ifdef CONFIG_MODULE_UNLOAD 489 /* What modules depend on me? */ 490 struct list_head source_list; 491 /* What modules do I depend on? */ 492 struct list_head target_list; 493 494 /* Destruction function. */ 495 void (*exit)(void); 496 497 atomic_t refcnt; 498 #endif 499 500 #ifdef CONFIG_CONSTRUCTORS 501 /* Constructor functions. */ 502 ctor_fn_t *ctors; 503 unsigned int num_ctors; 504 #endif 505 506 #ifdef CONFIG_FUNCTION_ERROR_INJECTION 507 struct error_injection_entry *ei_funcs; 508 unsigned int num_ei_funcs; 509 #endif 510 } ____cacheline_aligned __randomize_layout; 511 #ifndef MODULE_ARCH_INIT 512 #define MODULE_ARCH_INIT {} 513 #endif 514 515 #ifndef HAVE_ARCH_KALLSYMS_SYMBOL_VALUE 516 static inline unsigned long kallsyms_symbol_value(const Elf_Sym *sym) 517 { 518 return sym->st_value; 519 } 520 #endif 521 522 extern struct mutex module_mutex; 523 524 /* FIXME: It'd be nice to isolate modules during init, too, so they 525 aren't used before they (may) fail. But presently too much code 526 (IDE & SCSI) require entry into the module during init.*/ 527 static inline bool module_is_live(struct module *mod) 528 { 529 return mod->state != MODULE_STATE_GOING; 530 } 531 532 struct module *__module_text_address(unsigned long addr); 533 struct module *__module_address(unsigned long addr); 534 bool is_module_address(unsigned long addr); 535 bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr); 536 bool is_module_percpu_address(unsigned long addr); 537 bool is_module_text_address(unsigned long addr); 538 539 static inline bool within_module_core(unsigned long addr, 540 const struct module *mod) 541 { 542 return (unsigned long)mod->core_layout.base <= addr && 543 addr < (unsigned long)mod->core_layout.base + mod->core_layout.size; 544 } 545 546 static inline bool within_module_init(unsigned long addr, 547 const struct module *mod) 548 { 549 return (unsigned long)mod->init_layout.base <= addr && 550 addr < (unsigned long)mod->init_layout.base + mod->init_layout.size; 551 } 552 553 static inline bool within_module(unsigned long addr, const struct module *mod) 554 { 555 return within_module_init(addr, mod) || within_module_core(addr, mod); 556 } 557 558 /* Search for module by name: must hold module_mutex. */ 559 struct module *find_module(const char *name); 560 561 struct symsearch { 562 const struct kernel_symbol *start, *stop; 563 const s32 *crcs; 564 enum { 565 NOT_GPL_ONLY, 566 GPL_ONLY, 567 WILL_BE_GPL_ONLY, 568 } licence; 569 bool unused; 570 }; 571 572 /* 573 * Search for an exported symbol by name. 574 * 575 * Must be called with module_mutex held or preemption disabled. 576 */ 577 const struct kernel_symbol *find_symbol(const char *name, 578 struct module **owner, 579 const s32 **crc, 580 bool gplok, 581 bool warn); 582 583 /* 584 * Walk the exported symbol table 585 * 586 * Must be called with module_mutex held or preemption disabled. 587 */ 588 bool each_symbol_section(bool (*fn)(const struct symsearch *arr, 589 struct module *owner, 590 void *data), void *data); 591 592 /* Returns 0 and fills in value, defined and namebuf, or -ERANGE if 593 symnum out of range. */ 594 int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type, 595 char *name, char *module_name, int *exported); 596 597 /* Look for this name: can be of form module:name. */ 598 unsigned long module_kallsyms_lookup_name(const char *name); 599 600 int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *, 601 struct module *, unsigned long), 602 void *data); 603 604 extern void __noreturn __module_put_and_exit(struct module *mod, 605 long code); 606 #define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code) 607 608 #ifdef CONFIG_MODULE_UNLOAD 609 int module_refcount(struct module *mod); 610 void __symbol_put(const char *symbol); 611 #define symbol_put(x) __symbol_put(__stringify(x)) 612 void symbol_put_addr(void *addr); 613 614 /* Sometimes we know we already have a refcount, and it's easier not 615 to handle the error case (which only happens with rmmod --wait). */ 616 extern void __module_get(struct module *module); 617 618 /* This is the Right Way to get a module: if it fails, it's being removed, 619 * so pretend it's not there. */ 620 extern bool try_module_get(struct module *module); 621 622 extern void module_put(struct module *module); 623 624 #else /*!CONFIG_MODULE_UNLOAD*/ 625 static inline bool try_module_get(struct module *module) 626 { 627 return !module || module_is_live(module); 628 } 629 static inline void module_put(struct module *module) 630 { 631 } 632 static inline void __module_get(struct module *module) 633 { 634 } 635 #define symbol_put(x) do { } while (0) 636 #define symbol_put_addr(p) do { } while (0) 637 638 #endif /* CONFIG_MODULE_UNLOAD */ 639 int ref_module(struct module *a, struct module *b); 640 641 /* This is a #define so the string doesn't get put in every .o file */ 642 #define module_name(mod) \ 643 ({ \ 644 struct module *__mod = (mod); \ 645 __mod ? __mod->name : "kernel"; \ 646 }) 647 648 /* Dereference module function descriptor */ 649 void *dereference_module_function_descriptor(struct module *mod, void *ptr); 650 651 /* For kallsyms to ask for address resolution. namebuf should be at 652 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if 653 * found, otherwise NULL. */ 654 const char *module_address_lookup(unsigned long addr, 655 unsigned long *symbolsize, 656 unsigned long *offset, 657 char **modname, 658 char *namebuf); 659 int lookup_module_symbol_name(unsigned long addr, char *symname); 660 int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name); 661 662 int register_module_notifier(struct notifier_block *nb); 663 int unregister_module_notifier(struct notifier_block *nb); 664 665 extern void print_modules(void); 666 667 static inline bool module_requested_async_probing(struct module *module) 668 { 669 return module && module->async_probe_requested; 670 } 671 672 #ifdef CONFIG_LIVEPATCH 673 static inline bool is_livepatch_module(struct module *mod) 674 { 675 return mod->klp; 676 } 677 #else /* !CONFIG_LIVEPATCH */ 678 static inline bool is_livepatch_module(struct module *mod) 679 { 680 return false; 681 } 682 #endif /* CONFIG_LIVEPATCH */ 683 684 bool is_module_sig_enforced(void); 685 void set_module_sig_enforced(void); 686 687 #else /* !CONFIG_MODULES... */ 688 689 static inline struct module *__module_address(unsigned long addr) 690 { 691 return NULL; 692 } 693 694 static inline struct module *__module_text_address(unsigned long addr) 695 { 696 return NULL; 697 } 698 699 static inline bool is_module_address(unsigned long addr) 700 { 701 return false; 702 } 703 704 static inline bool is_module_percpu_address(unsigned long addr) 705 { 706 return false; 707 } 708 709 static inline bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr) 710 { 711 return false; 712 } 713 714 static inline bool is_module_text_address(unsigned long addr) 715 { 716 return false; 717 } 718 719 static inline bool within_module_core(unsigned long addr, 720 const struct module *mod) 721 { 722 return false; 723 } 724 725 static inline bool within_module_init(unsigned long addr, 726 const struct module *mod) 727 { 728 return false; 729 } 730 731 static inline bool within_module(unsigned long addr, const struct module *mod) 732 { 733 return false; 734 } 735 736 /* Get/put a kernel symbol (calls should be symmetric) */ 737 #define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); }) 738 #define symbol_put(x) do { } while (0) 739 #define symbol_put_addr(x) do { } while (0) 740 741 static inline void __module_get(struct module *module) 742 { 743 } 744 745 static inline bool try_module_get(struct module *module) 746 { 747 return true; 748 } 749 750 static inline void module_put(struct module *module) 751 { 752 } 753 754 #define module_name(mod) "kernel" 755 756 /* For kallsyms to ask for address resolution. NULL means not found. */ 757 static inline const char *module_address_lookup(unsigned long addr, 758 unsigned long *symbolsize, 759 unsigned long *offset, 760 char **modname, 761 char *namebuf) 762 { 763 return NULL; 764 } 765 766 static inline int lookup_module_symbol_name(unsigned long addr, char *symname) 767 { 768 return -ERANGE; 769 } 770 771 static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name) 772 { 773 return -ERANGE; 774 } 775 776 static inline int module_get_kallsym(unsigned int symnum, unsigned long *value, 777 char *type, char *name, 778 char *module_name, int *exported) 779 { 780 return -ERANGE; 781 } 782 783 static inline unsigned long module_kallsyms_lookup_name(const char *name) 784 { 785 return 0; 786 } 787 788 static inline int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *, 789 struct module *, 790 unsigned long), 791 void *data) 792 { 793 return 0; 794 } 795 796 static inline int register_module_notifier(struct notifier_block *nb) 797 { 798 /* no events will happen anyway, so this can always succeed */ 799 return 0; 800 } 801 802 static inline int unregister_module_notifier(struct notifier_block *nb) 803 { 804 return 0; 805 } 806 807 #define module_put_and_exit(code) do_exit(code) 808 809 static inline void print_modules(void) 810 { 811 } 812 813 static inline bool module_requested_async_probing(struct module *module) 814 { 815 return false; 816 } 817 818 static inline bool is_module_sig_enforced(void) 819 { 820 return false; 821 } 822 823 static inline void set_module_sig_enforced(void) 824 { 825 } 826 827 /* Dereference module function descriptor */ 828 static inline 829 void *dereference_module_function_descriptor(struct module *mod, void *ptr) 830 { 831 return ptr; 832 } 833 834 #endif /* CONFIG_MODULES */ 835 836 #ifdef CONFIG_SYSFS 837 extern struct kset *module_kset; 838 extern struct kobj_type module_ktype; 839 extern int module_sysfs_initialized; 840 #endif /* CONFIG_SYSFS */ 841 842 #define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x) 843 844 /* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */ 845 846 #define __MODULE_STRING(x) __stringify(x) 847 848 #ifdef CONFIG_STRICT_MODULE_RWX 849 extern void set_all_modules_text_rw(void); 850 extern void set_all_modules_text_ro(void); 851 extern void module_enable_ro(const struct module *mod, bool after_init); 852 extern void module_disable_ro(const struct module *mod); 853 #else 854 static inline void set_all_modules_text_rw(void) { } 855 static inline void set_all_modules_text_ro(void) { } 856 static inline void module_enable_ro(const struct module *mod, bool after_init) { } 857 static inline void module_disable_ro(const struct module *mod) { } 858 #endif 859 860 #ifdef CONFIG_GENERIC_BUG 861 void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *, 862 struct module *); 863 void module_bug_cleanup(struct module *); 864 865 #else /* !CONFIG_GENERIC_BUG */ 866 867 static inline void module_bug_finalize(const Elf_Ehdr *hdr, 868 const Elf_Shdr *sechdrs, 869 struct module *mod) 870 { 871 } 872 static inline void module_bug_cleanup(struct module *mod) {} 873 #endif /* CONFIG_GENERIC_BUG */ 874 875 #ifdef CONFIG_RETPOLINE 876 extern bool retpoline_module_ok(bool has_retpoline); 877 #else 878 static inline bool retpoline_module_ok(bool has_retpoline) 879 { 880 return true; 881 } 882 #endif 883 884 #ifdef CONFIG_MODULE_SIG 885 static inline bool module_sig_ok(struct module *module) 886 { 887 return module->sig_ok; 888 } 889 #else /* !CONFIG_MODULE_SIG */ 890 static inline bool module_sig_ok(struct module *module) 891 { 892 return true; 893 } 894 #endif /* CONFIG_MODULE_SIG */ 895 896 #endif /* _LINUX_MODULE_H */ 897