module.h

   1/* SPDX-License-Identifier: GPL-2.0-only */
   2/*
   3 * Dynamic loading of modules into the kernel.
   4 *
   5 * Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
   6 * Rewritten again by Rusty Russell, 2002
   7 */
   8
   9#ifndef _LINUX_MODULE_H
  10#define _LINUX_MODULE_H
  11
  12#include <linux/list.h>
  13#include <linux/stat.h>
  14#include <linux/buildid.h>
  15#include <linux/compiler.h>
  16#include <linux/cache.h>
  17#include <linux/cleanup.h>
  18#include <linux/kmod.h>
  19#include <linux/init.h>
  20#include <linux/elf.h>
  21#include <linux/stringify.h>
  22#include <linux/kobject.h>
  23#include <linux/moduleparam.h>
  24#include <linux/jump_label.h>
  25#include <linux/export.h>
  26#include <linux/rbtree_latch.h>
  27#include <linux/error-injection.h>
  28#include <linux/tracepoint-defs.h>
  29#include <linux/srcu.h>
  30#include <linux/static_call_types.h>
  31#include <linux/dynamic_debug.h>
  32
  33#include <linux/percpu.h>
  34#include <asm/module.h>
  35
  36#define MODULE_NAME_LEN __MODULE_NAME_LEN
  37
  38struct modversion_info {
  39	unsigned long crc;
  40	char name[MODULE_NAME_LEN];
  41};
  42
  43struct module;
  44struct exception_table_entry;
  45
  46struct module_kobject {
  47	struct kobject kobj;
  48	struct module *mod;
  49	struct kobject *drivers_dir;
  50	struct module_param_attrs *mp;
  51	struct completion *kobj_completion;
  52} __randomize_layout;
  53
  54struct module_attribute {
  55	struct attribute attr;
  56	ssize_t (*show)(const struct module_attribute *, struct module_kobject *,
  57			char *);
  58	ssize_t (*store)(const struct module_attribute *, struct module_kobject *,
  59			 const char *, size_t count);
  60	void (*setup)(struct module *, const char *);
  61	int (*test)(struct module *);
  62	void (*free)(struct module *);
  63};
  64
  65struct module_version_attribute {
  66	struct module_attribute mattr;
  67	const char *module_name;
  68	const char *version;
  69};
  70
  71extern ssize_t __modver_version_show(const struct module_attribute *,
  72				     struct module_kobject *, char *);
  73
  74extern const struct module_attribute module_uevent;
  75
  76/* These are either module local, or the kernel's dummy ones. */
  77extern int init_module(void);
  78extern void cleanup_module(void);
  79
  80#ifndef MODULE
  81/**
  82 * module_init() - driver initialization entry point
  83 * @x: function to be run at kernel boot time or module insertion
  84 *
  85 * module_init() will either be called during do_initcalls() (if
  86 * builtin) or at module insertion time (if a module).  There can only
  87 * be one per module.
  88 */
  89#define module_init(x)	__initcall(x);
  90
  91/**
  92 * module_exit() - driver exit entry point
  93 * @x: function to be run when driver is removed
  94 *
  95 * module_exit() will wrap the driver clean-up code
  96 * with cleanup_module() when used with rmmod when
  97 * the driver is a module.  If the driver is statically
  98 * compiled into the kernel, module_exit() has no effect.
  99 * There can only be one per module.
 100 */
 101#define module_exit(x)	__exitcall(x);
 102
 103#else /* MODULE */
 104
 105/*
 106 * In most cases loadable modules do not need custom
 107 * initcall levels. There are still some valid cases where
 108 * a driver may be needed early if built in, and does not
 109 * matter when built as a loadable module. Like bus
 110 * snooping debug drivers.
 111 */
 112#define early_initcall(fn)		module_init(fn)
 113#define core_initcall(fn)		module_init(fn)
 114#define core_initcall_sync(fn)		module_init(fn)
 115#define postcore_initcall(fn)		module_init(fn)
 116#define postcore_initcall_sync(fn)	module_init(fn)
 117#define arch_initcall(fn)		module_init(fn)
 118#define subsys_initcall(fn)		module_init(fn)
 119#define subsys_initcall_sync(fn)	module_init(fn)
 120#define fs_initcall(fn)			module_init(fn)
 121#define fs_initcall_sync(fn)		module_init(fn)
 122#define rootfs_initcall(fn)		module_init(fn)
 123#define device_initcall(fn)		module_init(fn)
 124#define device_initcall_sync(fn)	module_init(fn)
 125#define late_initcall(fn)		module_init(fn)
 126#define late_initcall_sync(fn)		module_init(fn)
 127
 128#define console_initcall(fn)		module_init(fn)
 129
 130/* Each module must use one module_init(). */
 131#define module_init(initfn)					\
 132	static inline initcall_t __maybe_unused __inittest(void)		\
 133	{ return initfn; }					\
 134	int init_module(void) __copy(initfn)			\
 135		__attribute__((alias(#initfn)));		\
 136	___ADDRESSABLE(init_module, __initdata);
 137
 138/* This is only required if you want to be unloadable. */
 139#define module_exit(exitfn)					\
 140	static inline exitcall_t __maybe_unused __exittest(void)		\
 141	{ return exitfn; }					\
 142	void cleanup_module(void) __copy(exitfn)		\
 143		__attribute__((alias(#exitfn)));		\
 144	___ADDRESSABLE(cleanup_module, __exitdata);
 145
 146#endif
 147
 148/* This means "can be init if no module support, otherwise module load
 149   may call it." */
 150#ifdef CONFIG_MODULES
 151#define __init_or_module
 152#define __initdata_or_module
 153#define __initconst_or_module
 154#define __INIT_OR_MODULE	.text
 155#define __INITDATA_OR_MODULE	.data
 156#define __INITRODATA_OR_MODULE	.section ".rodata","a",%progbits
 157#else
 158#define __init_or_module __init
 159#define __initdata_or_module __initdata
 160#define __initconst_or_module __initconst
 161#define __INIT_OR_MODULE __INIT
 162#define __INITDATA_OR_MODULE __INITDATA
 163#define __INITRODATA_OR_MODULE __INITRODATA
 164#endif /*CONFIG_MODULES*/
 165
 166struct module_kobject *lookup_or_create_module_kobject(const char *name);
 167
 168/* For userspace: you can also call me... */
 169#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
 170
 171/* Soft module dependencies. See man modprobe.d for details.
 172 * Example: MODULE_SOFTDEP("pre: module-foo module-bar post: module-baz")
 173 */
 174#define MODULE_SOFTDEP(_softdep) MODULE_INFO(softdep, _softdep)
 175
 176/*
 177 * Weak module dependencies. See man modprobe.d for details.
 178 * Example: MODULE_WEAKDEP("module-foo")
 179 */
 180#define MODULE_WEAKDEP(_weakdep) MODULE_INFO(weakdep, _weakdep)
 181
 182/*
 183 * MODULE_FILE is used for generating modules.builtin
 184 * So, make it no-op when this is being built as a module
 185 */
 186#ifdef MODULE
 187#define MODULE_FILE
 188#else
 189#define MODULE_FILE	MODULE_INFO(file, KBUILD_MODFILE);
 190#endif
 191
 192/*
 193 * The following license idents are currently accepted as indicating free
 194 * software modules
 195 *
 196 *	"GPL"				[GNU Public License v2]
 197 *	"GPL v2"			[GNU Public License v2]
 198 *	"GPL and additional rights"	[GNU Public License v2 rights and more]
 199 *	"Dual BSD/GPL"			[GNU Public License v2
 200 *					 or BSD license choice]
 201 *	"Dual MIT/GPL"			[GNU Public License v2
 202 *					 or MIT license choice]
 203 *	"Dual MPL/GPL"			[GNU Public License v2
 204 *					 or Mozilla license choice]
 205 *
 206 * The following other idents are available
 207 *
 208 *	"Proprietary"			[Non free products]
 209 *
 210 * Both "GPL v2" and "GPL" (the latter also in dual licensed strings) are
 211 * merely stating that the module is licensed under the GPL v2, but are not
 212 * telling whether "GPL v2 only" or "GPL v2 or later". The reason why there
 213 * are two variants is a historic and failed attempt to convey more
 214 * information in the MODULE_LICENSE string. For module loading the
 215 * "only/or later" distinction is completely irrelevant and does neither
 216 * replace the proper license identifiers in the corresponding source file
 217 * nor amends them in any way. The sole purpose is to make the
 218 * 'Proprietary' flagging work and to refuse to bind symbols which are
 219 * exported with EXPORT_SYMBOL_GPL when a non free module is loaded.
 220 *
 221 * In the same way "BSD" is not a clear license information. It merely
 222 * states, that the module is licensed under one of the compatible BSD
 223 * license variants. The detailed and correct license information is again
 224 * to be found in the corresponding source files.
 225 *
 226 * There are dual licensed components, but when running with Linux it is the
 227 * GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
 228 * is a GPL combined work.
 229 *
 230 * This exists for several reasons
 231 * 1.	So modinfo can show license info for users wanting to vet their setup
 232 *	is free
 233 * 2.	So the community can ignore bug reports including proprietary modules
 234 * 3.	So vendors can do likewise based on their own policies
 235 */
 236#define MODULE_LICENSE(_license) MODULE_FILE MODULE_INFO(license, _license)
 237
 238/*
 239 * Author(s), use "Name <email>" or just "Name", for multiple
 240 * authors use multiple MODULE_AUTHOR() statements/lines.
 241 */
 242#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
 243
 244/* What your module does. */
 245#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
 246
 247/*
 248 * Format: __mod_device_table__kmod_<modname>__<type>__<name>
 249 * Parts of the string `__kmod_` and `__` are used as delimiters when parsing
 250 * a symbol in file2alias.c
 251 */
 252#define __mod_device_table(type, name)	\
 253	__PASTE(__mod_device_table__,	\
 254	__PASTE(kmod_,			\
 255	__PASTE(__KBUILD_MODNAME,	\
 256	__PASTE(__,			\
 257	__PASTE(type,			\
 258	__PASTE(__, name))))))
 259
 260/* Creates an alias so file2alias.c can find device table. */
 261#define MODULE_DEVICE_TABLE(type, name)					\
 262static typeof(name) __mod_device_table(type, name)			\
 263  __attribute__ ((used, alias(__stringify(name))))
 264
 265/* Version of form [<epoch>:]<version>[-<extra-version>].
 266 * Or for CVS/RCS ID version, everything but the number is stripped.
 267 * <epoch>: A (small) unsigned integer which allows you to start versions
 268 * anew. If not mentioned, it's zero.  eg. "2:1.0" is after
 269 * "1:2.0".
 270
 271 * <version>: The <version> may contain only alphanumerics and the
 272 * character `.'.  Ordered by numeric sort for numeric parts,
 273 * ascii sort for ascii parts (as per RPM or DEB algorithm).
 274
 275 * <extraversion>: Like <version>, but inserted for local
 276 * customizations, eg "rh3" or "rusty1".
 277
 278 * Using this automatically adds a checksum of the .c files and the
 279 * local headers in "srcversion".
 280 */
 281
 282#if defined(MODULE) || !defined(CONFIG_SYSFS)
 283#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
 284#else
 285#define MODULE_VERSION(_version)					\
 286	MODULE_INFO(version, _version);					\
 287	static const struct module_version_attribute __modver_attr	\
 288		__used __section("__modver")				\
 289		__aligned(__alignof__(struct module_version_attribute)) \
 290		= {							\
 291			.mattr	= {					\
 292				.attr	= {				\
 293					.name	= "version",		\
 294					.mode	= S_IRUGO,		\
 295				},					\
 296				.show	= __modver_version_show,	\
 297			},						\
 298			.module_name	= KBUILD_MODNAME,		\
 299			.version	= _version,			\
 300		}
 301#endif
 302
 303/* Optional firmware file (or files) needed by the module
 304 * format is simply firmware file name.  Multiple firmware
 305 * files require multiple MODULE_FIRMWARE() specifiers */
 306#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
 307
 308#define MODULE_IMPORT_NS(ns)	MODULE_INFO(import_ns, ns)
 309
 310struct notifier_block;
 311
 312enum module_state {
 313	MODULE_STATE_LIVE,	/* Normal state. */
 314	MODULE_STATE_COMING,	/* Full formed, running module_init. */
 315	MODULE_STATE_GOING,	/* Going away. */
 316	MODULE_STATE_UNFORMED,	/* Still setting it up. */
 317};
 318
 319struct mod_tree_node {
 320	struct module *mod;
 321	struct latch_tree_node node;
 322};
 323
 324enum mod_mem_type {
 325	MOD_TEXT = 0,
 326	MOD_DATA,
 327	MOD_RODATA,
 328	MOD_RO_AFTER_INIT,
 329	MOD_INIT_TEXT,
 330	MOD_INIT_DATA,
 331	MOD_INIT_RODATA,
 332
 333	MOD_MEM_NUM_TYPES,
 334	MOD_INVALID = -1,
 335};
 336
 337#define mod_mem_type_is_init(type)	\
 338	((type) == MOD_INIT_TEXT ||	\
 339	 (type) == MOD_INIT_DATA ||	\
 340	 (type) == MOD_INIT_RODATA)
 341
 342#define mod_mem_type_is_core(type) (!mod_mem_type_is_init(type))
 343
 344#define mod_mem_type_is_text(type)	\
 345	 ((type) == MOD_TEXT ||		\
 346	  (type) == MOD_INIT_TEXT)
 347
 348#define mod_mem_type_is_data(type) (!mod_mem_type_is_text(type))
 349
 350#define mod_mem_type_is_core_data(type)	\
 351	(mod_mem_type_is_core(type) &&	\
 352	 mod_mem_type_is_data(type))
 353
 354#define for_each_mod_mem_type(type)			\
 355	for (enum mod_mem_type (type) = 0;		\
 356	     (type) < MOD_MEM_NUM_TYPES; (type)++)
 357
 358#define for_class_mod_mem_type(type, class)		\
 359	for_each_mod_mem_type(type)			\
 360		if (mod_mem_type_is_##class(type))
 361
 362struct module_memory {
 363	void *base;
 364	bool is_rox;
 365	unsigned int size;
 366
 367#ifdef CONFIG_MODULES_TREE_LOOKUP
 368	struct mod_tree_node mtn;
 369#endif
 370};
 371
 372#ifdef CONFIG_MODULES_TREE_LOOKUP
 373/* Only touch one cacheline for common rbtree-for-core-layout case. */
 374#define __module_memory_align ____cacheline_aligned
 375#else
 376#define __module_memory_align
 377#endif
 378
 379struct mod_kallsyms {
 380	Elf_Sym *symtab;
 381	unsigned int num_symtab;
 382	char *strtab;
 383	char *typetab;
 384};
 385
 386#ifdef CONFIG_LIVEPATCH
 387/**
 388 * struct klp_modinfo - ELF information preserved from the livepatch module
 389 *
 390 * @hdr: ELF header
 391 * @sechdrs: Section header table
 392 * @secstrings: String table for the section headers
 393 * @symndx: The symbol table section index
 394 */
 395struct klp_modinfo {
 396	Elf_Ehdr hdr;
 397	Elf_Shdr *sechdrs;
 398	char *secstrings;
 399	unsigned int symndx;
 400};
 401#endif
 402
 403struct module {
 404	enum module_state state;
 405
 406	/* Member of list of modules */
 407	struct list_head list;
 408
 409	/* Unique handle for this module */
 410	char name[MODULE_NAME_LEN];
 411
 412#ifdef CONFIG_STACKTRACE_BUILD_ID
 413	/* Module build ID */
 414	unsigned char build_id[BUILD_ID_SIZE_MAX];
 415#endif
 416
 417	/* Sysfs stuff. */
 418	struct module_kobject mkobj;
 419	struct module_attribute *modinfo_attrs;
 420	const char *version;
 421	const char *srcversion;
 422	struct kobject *holders_dir;
 423
 424	/* Exported symbols */
 425	const struct kernel_symbol *syms;
 426	const u32 *crcs;
 427	unsigned int num_syms;
 428
 429#ifdef CONFIG_ARCH_USES_CFI_TRAPS
 430	s32 *kcfi_traps;
 431	s32 *kcfi_traps_end;
 432#endif
 433
 434	/* Kernel parameters. */
 435#ifdef CONFIG_SYSFS
 436	struct mutex param_lock;
 437#endif
 438	struct kernel_param *kp;
 439	unsigned int num_kp;
 440
 441	/* GPL-only exported symbols. */
 442	unsigned int num_gpl_syms;
 443	const struct kernel_symbol *gpl_syms;
 444	const u32 *gpl_crcs;
 445	bool using_gplonly_symbols;
 446
 447#ifdef CONFIG_MODULE_SIG
 448	/* Signature was verified. */
 449	bool sig_ok;
 450#endif
 451
 452	bool async_probe_requested;
 453
 454	/* Exception table */
 455	unsigned int num_exentries;
 456	struct exception_table_entry *extable;
 457
 458	/* Startup function. */
 459	int (*init)(void);
 460
 461	struct module_memory mem[MOD_MEM_NUM_TYPES] __module_memory_align;
 462
 463	/* Arch-specific module values */
 464	struct mod_arch_specific arch;
 465
 466	unsigned long taints;	/* same bits as kernel:taint_flags */
 467
 468#ifdef CONFIG_GENERIC_BUG
 469	/* Support for BUG */
 470	unsigned num_bugs;
 471	struct list_head bug_list;
 472	struct bug_entry *bug_table;
 473#endif
 474
 475#ifdef CONFIG_KALLSYMS
 476	/* Protected by RCU and/or module_mutex: use rcu_dereference() */
 477	struct mod_kallsyms __rcu *kallsyms;
 478	struct mod_kallsyms core_kallsyms;
 479
 480	/* Section attributes */
 481	struct module_sect_attrs *sect_attrs;
 482
 483	/* Notes attributes */
 484	struct module_notes_attrs *notes_attrs;
 485#endif
 486
 487	/* The command line arguments (may be mangled).  People like
 488	   keeping pointers to this stuff */
 489	char *args;
 490
 491#ifdef CONFIG_SMP
 492	/* Per-cpu data. */
 493	void __percpu *percpu;
 494	unsigned int percpu_size;
 495#endif
 496	void *noinstr_text_start;
 497	unsigned int noinstr_text_size;
 498
 499#ifdef CONFIG_TRACEPOINTS
 500	unsigned int num_tracepoints;
 501	tracepoint_ptr_t *tracepoints_ptrs;
 502#endif
 503#ifdef CONFIG_TREE_SRCU
 504	unsigned int num_srcu_structs;
 505	struct srcu_struct **srcu_struct_ptrs;
 506#endif
 507#ifdef CONFIG_BPF_EVENTS
 508	unsigned int num_bpf_raw_events;
 509	struct bpf_raw_event_map *bpf_raw_events;
 510#endif
 511#ifdef CONFIG_DEBUG_INFO_BTF_MODULES
 512	unsigned int btf_data_size;
 513	unsigned int btf_base_data_size;
 514	void *btf_data;
 515	void *btf_base_data;
 516#endif
 517#ifdef CONFIG_JUMP_LABEL
 518	struct jump_entry *jump_entries;
 519	unsigned int num_jump_entries;
 520#endif
 521#ifdef CONFIG_TRACING
 522	unsigned int num_trace_bprintk_fmt;
 523	const char **trace_bprintk_fmt_start;
 524#endif
 525#ifdef CONFIG_EVENT_TRACING
 526	struct trace_event_call **trace_events;
 527	unsigned int num_trace_events;
 528	struct trace_eval_map **trace_evals;
 529	unsigned int num_trace_evals;
 530#endif
 531#ifdef CONFIG_DYNAMIC_FTRACE
 532	unsigned int num_ftrace_callsites;
 533	unsigned long *ftrace_callsites;
 534#endif
 535#ifdef CONFIG_KPROBES
 536	void *kprobes_text_start;
 537	unsigned int kprobes_text_size;
 538	unsigned long *kprobe_blacklist;
 539	unsigned int num_kprobe_blacklist;
 540#endif
 541#ifdef CONFIG_HAVE_STATIC_CALL_INLINE
 542	int num_static_call_sites;
 543	struct static_call_site *static_call_sites;
 544#endif
 545#if IS_ENABLED(CONFIG_KUNIT)
 546	int num_kunit_init_suites;
 547	struct kunit_suite **kunit_init_suites;
 548	int num_kunit_suites;
 549	struct kunit_suite **kunit_suites;
 550#endif
 551
 552
 553#ifdef CONFIG_LIVEPATCH
 554	bool klp; /* Is this a livepatch module? */
 555	bool klp_alive;
 556
 557	/* ELF information */
 558	struct klp_modinfo *klp_info;
 559#endif
 560
 561#ifdef CONFIG_PRINTK_INDEX
 562	unsigned int printk_index_size;
 563	struct pi_entry **printk_index_start;
 564#endif
 565
 566#ifdef CONFIG_MODULE_UNLOAD
 567	/* What modules depend on me? */
 568	struct list_head source_list;
 569	/* What modules do I depend on? */
 570	struct list_head target_list;
 571
 572	/* Destruction function. */
 573	void (*exit)(void);
 574
 575	atomic_t refcnt;
 576#endif
 577
 578#ifdef CONFIG_CONSTRUCTORS
 579	/* Constructor functions. */
 580	ctor_fn_t *ctors;
 581	unsigned int num_ctors;
 582#endif
 583
 584#ifdef CONFIG_FUNCTION_ERROR_INJECTION
 585	struct error_injection_entry *ei_funcs;
 586	unsigned int num_ei_funcs;
 587#endif
 588#ifdef CONFIG_DYNAMIC_DEBUG_CORE
 589	struct _ddebug_info dyndbg_info;
 590#endif
 591} ____cacheline_aligned __randomize_layout;
 592#ifndef MODULE_ARCH_INIT
 593#define MODULE_ARCH_INIT {}
 594#endif
 595
 596#ifdef CONFIG_MODULES
 597
 598/* Get/put a kernel symbol (calls must be symmetric) */
 599void *__symbol_get(const char *symbol);
 600void *__symbol_get_gpl(const char *symbol);
 601#define symbol_get(x)	({ \
 602	static const char __notrim[] \
 603		__used __section(".no_trim_symbol") = __stringify(x); \
 604	(typeof(&x))(__symbol_get(__stringify(x))); })
 605
 606#ifndef HAVE_ARCH_KALLSYMS_SYMBOL_VALUE
 607static inline unsigned long kallsyms_symbol_value(const Elf_Sym *sym)
 608{
 609	return sym->st_value;
 610}
 611#endif
 612
 613/* FIXME: It'd be nice to isolate modules during init, too, so they
 614   aren't used before they (may) fail.  But presently too much code
 615   (IDE & SCSI) require entry into the module during init.*/
 616static inline bool module_is_live(struct module *mod)
 617{
 618	return mod->state != MODULE_STATE_GOING;
 619}
 620
 621static inline bool module_is_coming(struct module *mod)
 622{
 623        return mod->state == MODULE_STATE_COMING;
 624}
 625
 626struct module *__module_text_address(unsigned long addr);
 627struct module *__module_address(unsigned long addr);
 628bool is_module_address(unsigned long addr);
 629bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr);
 630bool is_module_percpu_address(unsigned long addr);
 631bool is_module_text_address(unsigned long addr);
 632
 633static inline bool within_module_mem_type(unsigned long addr,
 634					  const struct module *mod,
 635					  enum mod_mem_type type)
 636{
 637	unsigned long base, size;
 638
 639	base = (unsigned long)mod->mem[type].base;
 640	size = mod->mem[type].size;
 641	return addr - base < size;
 642}
 643
 644static inline bool within_module_core(unsigned long addr,
 645				      const struct module *mod)
 646{
 647	for_class_mod_mem_type(type, core) {
 648		if (within_module_mem_type(addr, mod, type))
 649			return true;
 650	}
 651	return false;
 652}
 653
 654static inline bool within_module_init(unsigned long addr,
 655				      const struct module *mod)
 656{
 657	for_class_mod_mem_type(type, init) {
 658		if (within_module_mem_type(addr, mod, type))
 659			return true;
 660	}
 661	return false;
 662}
 663
 664static inline bool within_module(unsigned long addr, const struct module *mod)
 665{
 666	return within_module_init(addr, mod) || within_module_core(addr, mod);
 667}
 668
 669/* Search for module by name: must be in a RCU critical section. */
 670struct module *find_module(const char *name);
 671
 672extern void __noreturn __module_put_and_kthread_exit(struct module *mod,
 673			long code);
 674#define module_put_and_kthread_exit(code) __module_put_and_kthread_exit(THIS_MODULE, code)
 675
 676#ifdef CONFIG_MODULE_UNLOAD
 677int module_refcount(struct module *mod);
 678void __symbol_put(const char *symbol);
 679#define symbol_put(x) __symbol_put(__stringify(x))
 680void symbol_put_addr(void *addr);
 681
 682/* Sometimes we know we already have a refcount, and it's easier not
 683   to handle the error case (which only happens with rmmod --wait). */
 684extern void __module_get(struct module *module);
 685
 686/**
 687 * try_module_get() - take module refcount unless module is being removed
 688 * @module: the module we should check for
 689 *
 690 * Only try to get a module reference count if the module is not being removed.
 691 * This call will fail if the module is in the process of being removed.
 692 *
 693 * Care must also be taken to ensure the module exists and is alive prior to
 694 * usage of this call. This can be gauranteed through two means:
 695 *
 696 * 1) Direct protection: you know an earlier caller must have increased the
 697 *    module reference through __module_get(). This can typically be achieved
 698 *    by having another entity other than the module itself increment the
 699 *    module reference count.
 700 *
 701 * 2) Implied protection: there is an implied protection against module
 702 *    removal. An example of this is the implied protection used by kernfs /
 703 *    sysfs. The sysfs store / read file operations are guaranteed to exist
 704 *    through the use of kernfs's active reference (see kernfs_active()) and a
 705 *    sysfs / kernfs file removal cannot happen unless the same file is not
 706 *    active. Therefore, if a sysfs file is being read or written to the module
 707 *    which created it must still exist. It is therefore safe to use
 708 *    try_module_get() on module sysfs store / read ops.
 709 *
 710 * One of the real values to try_module_get() is the module_is_live() check
 711 * which ensures that the caller of try_module_get() can yield to userspace
 712 * module removal requests and gracefully fail if the module is on its way out.
 713 *
 714 * Returns true if the reference count was successfully incremented.
 715 */
 716extern bool try_module_get(struct module *module);
 717
 718/**
 719 * module_put() - release a reference count to a module
 720 * @module: the module we should release a reference count for
 721 *
 722 * If you successfully bump a reference count to a module with try_module_get(),
 723 * when you are finished you must call module_put() to release that reference
 724 * count.
 725 */
 726extern void module_put(struct module *module);
 727
 728#else /*!CONFIG_MODULE_UNLOAD*/
 729static inline bool try_module_get(struct module *module)
 730{
 731	return !module || module_is_live(module);
 732}
 733static inline void module_put(struct module *module)
 734{
 735}
 736static inline void __module_get(struct module *module)
 737{
 738}
 739#define symbol_put(x) do { } while (0)
 740#define symbol_put_addr(p) do { } while (0)
 741
 742#endif /* CONFIG_MODULE_UNLOAD */
 743
 744/* This is a #define so the string doesn't get put in every .o file */
 745#define module_name(mod)			\
 746({						\
 747	struct module *__mod = (mod);		\
 748	__mod ? __mod->name : "kernel";		\
 749})
 750
 751static inline const unsigned char *module_buildid(struct module *mod)
 752{
 753#ifdef CONFIG_STACKTRACE_BUILD_ID
 754	return mod->build_id;
 755#else
 756	return NULL;
 757#endif
 758}
 759
 760/* Dereference module function descriptor */
 761void *dereference_module_function_descriptor(struct module *mod, void *ptr);
 762
 763int register_module_notifier(struct notifier_block *nb);
 764int unregister_module_notifier(struct notifier_block *nb);
 765
 766extern void print_modules(void);
 767
 768static inline bool module_requested_async_probing(struct module *module)
 769{
 770	return module && module->async_probe_requested;
 771}
 772
 773static inline bool is_livepatch_module(struct module *mod)
 774{
 775#ifdef CONFIG_LIVEPATCH
 776	return mod->klp;
 777#else
 778	return false;
 779#endif
 780}
 781
 782void set_module_sig_enforced(void);
 783
 784void module_for_each_mod(int(*func)(struct module *mod, void *data), void *data);
 785
 786#else /* !CONFIG_MODULES... */
 787
 788static inline struct module *__module_address(unsigned long addr)
 789{
 790	return NULL;
 791}
 792
 793static inline struct module *__module_text_address(unsigned long addr)
 794{
 795	return NULL;
 796}
 797
 798static inline bool is_module_address(unsigned long addr)
 799{
 800	return false;
 801}
 802
 803static inline bool is_module_percpu_address(unsigned long addr)
 804{
 805	return false;
 806}
 807
 808static inline bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr)
 809{
 810	return false;
 811}
 812
 813static inline bool is_module_text_address(unsigned long addr)
 814{
 815	return false;
 816}
 817
 818static inline bool within_module_core(unsigned long addr,
 819				      const struct module *mod)
 820{
 821	return false;
 822}
 823
 824static inline bool within_module_init(unsigned long addr,
 825				      const struct module *mod)
 826{
 827	return false;
 828}
 829
 830static inline bool within_module(unsigned long addr, const struct module *mod)
 831{
 832	return false;
 833}
 834
 835/* Get/put a kernel symbol (calls should be symmetric) */
 836#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak,visibility("hidden"))); &(x); })
 837#define symbol_put(x) do { } while (0)
 838#define symbol_put_addr(x) do { } while (0)
 839
 840static inline void __module_get(struct module *module)
 841{
 842}
 843
 844static inline bool try_module_get(struct module *module)
 845{
 846	return true;
 847}
 848
 849static inline void module_put(struct module *module)
 850{
 851}
 852
 853#define module_name(mod) "kernel"
 854
 855static inline int register_module_notifier(struct notifier_block *nb)
 856{
 857	/* no events will happen anyway, so this can always succeed */
 858	return 0;
 859}
 860
 861static inline int unregister_module_notifier(struct notifier_block *nb)
 862{
 863	return 0;
 864}
 865
 866#define module_put_and_kthread_exit(code) kthread_exit(code)
 867
 868static inline void print_modules(void)
 869{
 870}
 871
 872static inline bool module_requested_async_probing(struct module *module)
 873{
 874	return false;
 875}
 876
 877
 878static inline void set_module_sig_enforced(void)
 879{
 880}
 881
 882/* Dereference module function descriptor */
 883static inline
 884void *dereference_module_function_descriptor(struct module *mod, void *ptr)
 885{
 886	return ptr;
 887}
 888
 889static inline bool module_is_coming(struct module *mod)
 890{
 891	return false;
 892}
 893
 894static inline void module_for_each_mod(int(*func)(struct module *mod, void *data), void *data)
 895{
 896}
 897#endif /* CONFIG_MODULES */
 898
 899#ifdef CONFIG_SYSFS
 900extern struct kset *module_kset;
 901extern const struct kobj_type module_ktype;
 902#endif /* CONFIG_SYSFS */
 903
 904#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
 905
 906/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
 907
 908#define __MODULE_STRING(x) __stringify(x)
 909
 910#ifdef CONFIG_GENERIC_BUG
 911void module_bug_finalize(const Elf_Ehdr *, const Elf_Shdr *,
 912			 struct module *);
 913void module_bug_cleanup(struct module *);
 914
 915#else	/* !CONFIG_GENERIC_BUG */
 916
 917static inline void module_bug_finalize(const Elf_Ehdr *hdr,
 918					const Elf_Shdr *sechdrs,
 919					struct module *mod)
 920{
 921}
 922static inline void module_bug_cleanup(struct module *mod) {}
 923#endif	/* CONFIG_GENERIC_BUG */
 924
 925#ifdef CONFIG_MITIGATION_RETPOLINE
 926extern bool retpoline_module_ok(bool has_retpoline);
 927#else
 928static inline bool retpoline_module_ok(bool has_retpoline)
 929{
 930	return true;
 931}
 932#endif
 933
 934#ifdef CONFIG_MODULE_SIG
 935bool is_module_sig_enforced(void);
 936
 937static inline bool module_sig_ok(struct module *module)
 938{
 939	return module->sig_ok;
 940}
 941#else	/* !CONFIG_MODULE_SIG */
 942static inline bool is_module_sig_enforced(void)
 943{
 944	return false;
 945}
 946
 947static inline bool module_sig_ok(struct module *module)
 948{
 949	return true;
 950}
 951#endif	/* CONFIG_MODULE_SIG */
 952
 953#if defined(CONFIG_MODULES) && defined(CONFIG_KALLSYMS)
 954int module_kallsyms_on_each_symbol(const char *modname,
 955				   int (*fn)(void *, const char *, unsigned long),
 956				   void *data);
 957
 958/* For kallsyms to ask for address resolution.  namebuf should be at
 959 * least KSYM_NAME_LEN long: a pointer to namebuf is returned if
 960 * found, otherwise NULL.
 961 */
 962int module_address_lookup(unsigned long addr,
 963			  unsigned long *symbolsize,
 964			  unsigned long *offset,
 965			  char **modname, const unsigned char **modbuildid,
 966			  char *namebuf);
 967int lookup_module_symbol_name(unsigned long addr, char *symname);
 968int lookup_module_symbol_attrs(unsigned long addr,
 969			       unsigned long *size,
 970			       unsigned long *offset,
 971			       char *modname,
 972			       char *name);
 973
 974/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
 975 * symnum out of range.
 976 */
 977int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
 978		       char *name, char *module_name, int *exported);
 979
 980/* Look for this name: can be of form module:name. */
 981unsigned long module_kallsyms_lookup_name(const char *name);
 982
 983unsigned long find_kallsyms_symbol_value(struct module *mod, const char *name);
 984
 985#else	/* CONFIG_MODULES && CONFIG_KALLSYMS */
 986
 987static inline int module_kallsyms_on_each_symbol(const char *modname,
 988						 int (*fn)(void *, const char *, unsigned long),
 989						 void *data)
 990{
 991	return -EOPNOTSUPP;
 992}
 993
 994/* For kallsyms to ask for address resolution.  NULL means not found. */
 995static inline int module_address_lookup(unsigned long addr,
 996						unsigned long *symbolsize,
 997						unsigned long *offset,
 998						char **modname,
 999						const unsigned char **modbuildid,
1000						char *namebuf)
1001{
1002	return 0;
1003}
1004
1005static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
1006{
1007	return -ERANGE;
1008}
1009
1010static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
1011				     char *type, char *name,
1012				     char *module_name, int *exported)
1013{
1014	return -ERANGE;
1015}
1016
1017static inline unsigned long module_kallsyms_lookup_name(const char *name)
1018{
1019	return 0;
1020}
1021
1022static inline unsigned long find_kallsyms_symbol_value(struct module *mod,
1023						       const char *name)
1024{
1025	return 0;
1026}
1027
1028#endif  /* CONFIG_MODULES && CONFIG_KALLSYMS */
1029
1030/* Define __free(module_put) macro for struct module *. */
1031DEFINE_FREE(module_put, struct module *, if (_T) module_put(_T))
1032
1033#endif /* _LINUX_MODULE_H */