1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Copyright (C) 2002 Richard Henderson
4 * Copyright (C) 2001 Rusty Russell, 2002, 2010 Rusty Russell IBM.
5 */
6
7#define INCLUDE_VERMAGIC
8
9#include <linux/export.h>
10#include <linux/extable.h>
11#include <linux/moduleloader.h>
12#include <linux/module_signature.h>
13#include <linux/trace_events.h>
14#include <linux/init.h>
15#include <linux/kallsyms.h>
16#include <linux/buildid.h>
17#include <linux/fs.h>
18#include <linux/kernel.h>
19#include <linux/kernel_read_file.h>
20#include <linux/slab.h>
21#include <linux/vmalloc.h>
22#include <linux/elf.h>
23#include <linux/seq_file.h>
24#include <linux/syscalls.h>
25#include <linux/fcntl.h>
26#include <linux/rcupdate.h>
27#include <linux/capability.h>
28#include <linux/cpu.h>
29#include <linux/moduleparam.h>
30#include <linux/errno.h>
31#include <linux/err.h>
32#include <linux/vermagic.h>
33#include <linux/notifier.h>
34#include <linux/sched.h>
35#include <linux/device.h>
36#include <linux/string.h>
37#include <linux/mutex.h>
38#include <linux/rculist.h>
39#include <linux/uaccess.h>
40#include <asm/cacheflush.h>
41#include <linux/set_memory.h>
42#include <asm/mmu_context.h>
43#include <linux/license.h>
44#include <asm/sections.h>
45#include <linux/tracepoint.h>
46#include <linux/ftrace.h>
47#include <linux/livepatch.h>
48#include <linux/async.h>
49#include <linux/percpu.h>
50#include <linux/kmemleak.h>
51#include <linux/jump_label.h>
52#include <linux/pfn.h>
53#include <linux/bsearch.h>
54#include <linux/dynamic_debug.h>
55#include <linux/audit.h>
56#include <uapi/linux/module.h>
57#include "internal.h"
58
59#define CREATE_TRACE_POINTS
60#include <trace/events/module.h>
61
62/*
63 * Mutex protects:
64 * 1) List of modules (also safely readable with preempt_disable),
65 * 2) module_use links,
66 * 3) mod_tree.addr_min/mod_tree.addr_max.
67 * (delete and add uses RCU list operations).
68 */
69DEFINE_MUTEX(module_mutex);
70LIST_HEAD(modules);
71
72/* Work queue for freeing init sections in success case */
73static void do_free_init(struct work_struct *w);
74static DECLARE_WORK(init_free_wq, do_free_init);
75static LLIST_HEAD(init_free_list);
76
77struct mod_tree_root mod_tree __cacheline_aligned = {
78	.addr_min = -1UL,
79};
80
81#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
82struct mod_tree_root mod_data_tree __cacheline_aligned = {
83	.addr_min = -1UL,
84};
85#endif
86
87#define module_addr_min mod_tree.addr_min
88#define module_addr_max mod_tree.addr_max
89
90struct symsearch {
91	const struct kernel_symbol *start, *stop;
92	const s32 *crcs;
93	enum mod_license license;
94};
95
96/*
97 * Bounds of module text, for speeding up __module_address.
98 * Protected by module_mutex.
99 */
100static void __mod_update_bounds(void *base, unsigned int size, struct mod_tree_root *tree)
101{
102	unsigned long min = (unsigned long)base;
103	unsigned long max = min + size;
104
105	if (min < tree->addr_min)
106		tree->addr_min = min;
107	if (max > tree->addr_max)
108		tree->addr_max = max;
109}
110
111static void mod_update_bounds(struct module *mod)
112{
113	__mod_update_bounds(mod->core_layout.base, mod->core_layout.size, &mod_tree);
114	if (mod->init_layout.size)
115		__mod_update_bounds(mod->init_layout.base, mod->init_layout.size, &mod_tree);
116#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
117	__mod_update_bounds(mod->data_layout.base, mod->data_layout.size, &mod_data_tree);
118#endif
119}
120
121/* Block module loading/unloading? */
122int modules_disabled;
123core_param(nomodule, modules_disabled, bint, 0);
124
125/* Waiting for a module to finish initializing? */
126static DECLARE_WAIT_QUEUE_HEAD(module_wq);
127
128static BLOCKING_NOTIFIER_HEAD(module_notify_list);
129
130int register_module_notifier(struct notifier_block *nb)
131{
132	return blocking_notifier_chain_register(&module_notify_list, nb);
133}
134EXPORT_SYMBOL(register_module_notifier);
135
136int unregister_module_notifier(struct notifier_block *nb)
137{
138	return blocking_notifier_chain_unregister(&module_notify_list, nb);
139}
140EXPORT_SYMBOL(unregister_module_notifier);
141
142/*
143 * We require a truly strong try_module_get(): 0 means success.
144 * Otherwise an error is returned due to ongoing or failed
145 * initialization etc.
146 */
147static inline int strong_try_module_get(struct module *mod)
148{
149	BUG_ON(mod && mod->state == MODULE_STATE_UNFORMED);
150	if (mod && mod->state == MODULE_STATE_COMING)
151		return -EBUSY;
152	if (try_module_get(mod))
153		return 0;
154	else
155		return -ENOENT;
156}
157
158static inline void add_taint_module(struct module *mod, unsigned flag,
159				    enum lockdep_ok lockdep_ok)
160{
161	add_taint(flag, lockdep_ok);
162	set_bit(flag, &mod->taints);
163}
164
165/*
166 * A thread that wants to hold a reference to a module only while it
167 * is running can call this to safely exit.
168 */
169void __noreturn __module_put_and_kthread_exit(struct module *mod, long code)
170{
171	module_put(mod);
172	kthread_exit(code);
173}
174EXPORT_SYMBOL(__module_put_and_kthread_exit);
175
176/* Find a module section: 0 means not found. */
177static unsigned int find_sec(const struct load_info *info, const char *name)
178{
179	unsigned int i;
180
181	for (i = 1; i < info->hdr->e_shnum; i++) {
182		Elf_Shdr *shdr = &info->sechdrs[i];
183		/* Alloc bit cleared means "ignore it." */
184		if ((shdr->sh_flags & SHF_ALLOC)
185		    && strcmp(info->secstrings + shdr->sh_name, name) == 0)
186			return i;
187	}
188	return 0;
189}
190
191/* Find a module section, or NULL. */
192static void *section_addr(const struct load_info *info, const char *name)
193{
194	/* Section 0 has sh_addr 0. */
195	return (void *)info->sechdrs[find_sec(info, name)].sh_addr;
196}
197
198/* Find a module section, or NULL.  Fill in number of "objects" in section. */
199static void *section_objs(const struct load_info *info,
200			  const char *name,
201			  size_t object_size,
202			  unsigned int *num)
203{
204	unsigned int sec = find_sec(info, name);
205
206	/* Section 0 has sh_addr 0 and sh_size 0. */
207	*num = info->sechdrs[sec].sh_size / object_size;
208	return (void *)info->sechdrs[sec].sh_addr;
209}
210
211/* Find a module section: 0 means not found. Ignores SHF_ALLOC flag. */
212static unsigned int find_any_sec(const struct load_info *info, const char *name)
213{
214	unsigned int i;
215
216	for (i = 1; i < info->hdr->e_shnum; i++) {
217		Elf_Shdr *shdr = &info->sechdrs[i];
218		if (strcmp(info->secstrings + shdr->sh_name, name) == 0)
219			return i;
220	}
221	return 0;
222}
223
224/*
225 * Find a module section, or NULL. Fill in number of "objects" in section.
226 * Ignores SHF_ALLOC flag.
227 */
228static __maybe_unused void *any_section_objs(const struct load_info *info,
229					     const char *name,
230					     size_t object_size,
231					     unsigned int *num)
232{
233	unsigned int sec = find_any_sec(info, name);
234
235	/* Section 0 has sh_addr 0 and sh_size 0. */
236	*num = info->sechdrs[sec].sh_size / object_size;
237	return (void *)info->sechdrs[sec].sh_addr;
238}
239
240#ifndef CONFIG_MODVERSIONS
241#define symversion(base, idx) NULL
242#else
243#define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
244#endif
245
246static const char *kernel_symbol_name(const struct kernel_symbol *sym)
247{
248#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
249	return offset_to_ptr(&sym->name_offset);
250#else
251	return sym->name;
252#endif
253}
254
255static const char *kernel_symbol_namespace(const struct kernel_symbol *sym)
256{
257#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
258	if (!sym->namespace_offset)
259		return NULL;
260	return offset_to_ptr(&sym->namespace_offset);
261#else
262	return sym->namespace;
263#endif
264}
265
266int cmp_name(const void *name, const void *sym)
267{
268	return strcmp(name, kernel_symbol_name(sym));
269}
270
271static bool find_exported_symbol_in_section(const struct symsearch *syms,
272					    struct module *owner,
273					    struct find_symbol_arg *fsa)
274{
275	struct kernel_symbol *sym;
276
277	if (!fsa->gplok && syms->license == GPL_ONLY)
278		return false;
279
280	sym = bsearch(fsa->name, syms->start, syms->stop - syms->start,
281			sizeof(struct kernel_symbol), cmp_name);
282	if (!sym)
283		return false;
284
285	fsa->owner = owner;
286	fsa->crc = symversion(syms->crcs, sym - syms->start);
287	fsa->sym = sym;
288	fsa->license = syms->license;
289
290	return true;
291}
292
293/*
294 * Find an exported symbol and return it, along with, (optional) crc and
295 * (optional) module which owns it.  Needs preempt disabled or module_mutex.
296 */
297bool find_symbol(struct find_symbol_arg *fsa)
298{
299	static const struct symsearch arr[] = {
300		{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,
301		  NOT_GPL_ONLY },
302		{ __start___ksymtab_gpl, __stop___ksymtab_gpl,
303		  __start___kcrctab_gpl,
304		  GPL_ONLY },
305	};
306	struct module *mod;
307	unsigned int i;
308
309	module_assert_mutex_or_preempt();
310
311	for (i = 0; i < ARRAY_SIZE(arr); i++)
312		if (find_exported_symbol_in_section(&arr[i], NULL, fsa))
313			return true;
314
315	list_for_each_entry_rcu(mod, &modules, list,
316				lockdep_is_held(&module_mutex)) {
317		struct symsearch arr[] = {
318			{ mod->syms, mod->syms + mod->num_syms, mod->crcs,
319			  NOT_GPL_ONLY },
320			{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
321			  mod->gpl_crcs,
322			  GPL_ONLY },
323		};
324
325		if (mod->state == MODULE_STATE_UNFORMED)
326			continue;
327
328		for (i = 0; i < ARRAY_SIZE(arr); i++)
329			if (find_exported_symbol_in_section(&arr[i], mod, fsa))
330				return true;
331	}
332
333	pr_debug("Failed to find symbol %s\n", fsa->name);
334	return false;
335}
336
337/*
338 * Search for module by name: must hold module_mutex (or preempt disabled
339 * for read-only access).
340 */
341struct module *find_module_all(const char *name, size_t len,
342			       bool even_unformed)
343{
344	struct module *mod;
345
346	module_assert_mutex_or_preempt();
347
348	list_for_each_entry_rcu(mod, &modules, list,
349				lockdep_is_held(&module_mutex)) {
350		if (!even_unformed && mod->state == MODULE_STATE_UNFORMED)
351			continue;
352		if (strlen(mod->name) == len && !memcmp(mod->name, name, len))
353			return mod;
354	}
355	return NULL;
356}
357
358struct module *find_module(const char *name)
359{
360	return find_module_all(name, strlen(name), false);
361}
362
363#ifdef CONFIG_SMP
364
365static inline void __percpu *mod_percpu(struct module *mod)
366{
367	return mod->percpu;
368}
369
370static int percpu_modalloc(struct module *mod, struct load_info *info)
371{
372	Elf_Shdr *pcpusec = &info->sechdrs[info->index.pcpu];
373	unsigned long align = pcpusec->sh_addralign;
374
375	if (!pcpusec->sh_size)
376		return 0;
377
378	if (align > PAGE_SIZE) {
379		pr_warn("%s: per-cpu alignment %li > %li\n",
380			mod->name, align, PAGE_SIZE);
381		align = PAGE_SIZE;
382	}
383
384	mod->percpu = __alloc_reserved_percpu(pcpusec->sh_size, align);
385	if (!mod->percpu) {
386		pr_warn("%s: Could not allocate %lu bytes percpu data\n",
387			mod->name, (unsigned long)pcpusec->sh_size);
388		return -ENOMEM;
389	}
390	mod->percpu_size = pcpusec->sh_size;
391	return 0;
392}
393
394static void percpu_modfree(struct module *mod)
395{
396	free_percpu(mod->percpu);
397}
398
399static unsigned int find_pcpusec(struct load_info *info)
400{
401	return find_sec(info, ".data..percpu");
402}
403
404static void percpu_modcopy(struct module *mod,
405			   const void *from, unsigned long size)
406{
407	int cpu;
408
409	for_each_possible_cpu(cpu)
410		memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);
411}
412
413bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr)
414{
415	struct module *mod;
416	unsigned int cpu;
417
418	preempt_disable();
419
420	list_for_each_entry_rcu(mod, &modules, list) {
421		if (mod->state == MODULE_STATE_UNFORMED)
422			continue;
423		if (!mod->percpu_size)
424			continue;
425		for_each_possible_cpu(cpu) {
426			void *start = per_cpu_ptr(mod->percpu, cpu);
427			void *va = (void *)addr;
428
429			if (va >= start && va < start + mod->percpu_size) {
430				if (can_addr) {
431					*can_addr = (unsigned long) (va - start);
432					*can_addr += (unsigned long)
433						per_cpu_ptr(mod->percpu,
434							    get_boot_cpu_id());
435				}
436				preempt_enable();
437				return true;
438			}
439		}
440	}
441
442	preempt_enable();
443	return false;
444}
445
446/**
447 * is_module_percpu_address() - test whether address is from module static percpu
448 * @addr: address to test
449 *
450 * Test whether @addr belongs to module static percpu area.
451 *
452 * Return: %true if @addr is from module static percpu area
453 */
454bool is_module_percpu_address(unsigned long addr)
455{
456	return __is_module_percpu_address(addr, NULL);
457}
458
459#else /* ... !CONFIG_SMP */
460
461static inline void __percpu *mod_percpu(struct module *mod)
462{
463	return NULL;
464}
465static int percpu_modalloc(struct module *mod, struct load_info *info)
466{
467	/* UP modules shouldn't have this section: ENOMEM isn't quite right */
468	if (info->sechdrs[info->index.pcpu].sh_size != 0)
469		return -ENOMEM;
470	return 0;
471}
472static inline void percpu_modfree(struct module *mod)
473{
474}
475static unsigned int find_pcpusec(struct load_info *info)
476{
477	return 0;
478}
479static inline void percpu_modcopy(struct module *mod,
480				  const void *from, unsigned long size)
481{
482	/* pcpusec should be 0, and size of that section should be 0. */
483	BUG_ON(size != 0);
484}
485bool is_module_percpu_address(unsigned long addr)
486{
487	return false;
488}
489
490bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr)
491{
492	return false;
493}
494
495#endif /* CONFIG_SMP */
496
497#define MODINFO_ATTR(field)	\
498static void setup_modinfo_##field(struct module *mod, const char *s)  \
499{                                                                     \
500	mod->field = kstrdup(s, GFP_KERNEL);                          \
501}                                                                     \
502static ssize_t show_modinfo_##field(struct module_attribute *mattr,   \
503			struct module_kobject *mk, char *buffer)      \
504{                                                                     \
505	return scnprintf(buffer, PAGE_SIZE, "%s\n", mk->mod->field);  \
506}                                                                     \
507static int modinfo_##field##_exists(struct module *mod)               \
508{                                                                     \
509	return mod->field != NULL;                                    \
510}                                                                     \
511static void free_modinfo_##field(struct module *mod)                  \
512{                                                                     \
513	kfree(mod->field);                                            \
514	mod->field = NULL;                                            \
515}                                                                     \
516static struct module_attribute modinfo_##field = {                    \
517	.attr = { .name = __stringify(field), .mode = 0444 },         \
518	.show = show_modinfo_##field,                                 \
519	.setup = setup_modinfo_##field,                               \
520	.test = modinfo_##field##_exists,                             \
521	.free = free_modinfo_##field,                                 \
522};
523
524MODINFO_ATTR(version);
525MODINFO_ATTR(srcversion);
526
527static struct {
528	char name[MODULE_NAME_LEN + 1];
529	char taints[MODULE_FLAGS_BUF_SIZE];
530} last_unloaded_module;
531
532#ifdef CONFIG_MODULE_UNLOAD
533
534EXPORT_TRACEPOINT_SYMBOL(module_get);
535
536/* MODULE_REF_BASE is the base reference count by kmodule loader. */
537#define MODULE_REF_BASE	1
538
539/* Init the unload section of the module. */
540static int module_unload_init(struct module *mod)
541{
542	/*
543	 * Initialize reference counter to MODULE_REF_BASE.
544	 * refcnt == 0 means module is going.
545	 */
546	atomic_set(&mod->refcnt, MODULE_REF_BASE);
547
548	INIT_LIST_HEAD(&mod->source_list);
549	INIT_LIST_HEAD(&mod->target_list);
550
551	/* Hold reference count during initialization. */
552	atomic_inc(&mod->refcnt);
553
554	return 0;
555}
556
557/* Does a already use b? */
558static int already_uses(struct module *a, struct module *b)
559{
560	struct module_use *use;
561
562	list_for_each_entry(use, &b->source_list, source_list) {
563		if (use->source == a) {
564			pr_debug("%s uses %s!\n", a->name, b->name);
565			return 1;
566		}
567	}
568	pr_debug("%s does not use %s!\n", a->name, b->name);
569	return 0;
570}
571
572/*
573 * Module a uses b
574 *  - we add 'a' as a "source", 'b' as a "target" of module use
575 *  - the module_use is added to the list of 'b' sources (so
576 *    'b' can walk the list to see who sourced them), and of 'a'
577 *    targets (so 'a' can see what modules it targets).
578 */
579static int add_module_usage(struct module *a, struct module *b)
580{
581	struct module_use *use;
582
583	pr_debug("Allocating new usage for %s.\n", a->name);
584	use = kmalloc(sizeof(*use), GFP_ATOMIC);
585	if (!use)
586		return -ENOMEM;
587
588	use->source = a;
589	use->target = b;
590	list_add(&use->source_list, &b->source_list);
591	list_add(&use->target_list, &a->target_list);
592	return 0;
593}
594
595/* Module a uses b: caller needs module_mutex() */
596static int ref_module(struct module *a, struct module *b)
597{
598	int err;
599
600	if (b == NULL || already_uses(a, b))
601		return 0;
602
603	/* If module isn't available, we fail. */
604	err = strong_try_module_get(b);
605	if (err)
606		return err;
607
608	err = add_module_usage(a, b);
609	if (err) {
610		module_put(b);
611		return err;
612	}
613	return 0;
614}
615
616/* Clear the unload stuff of the module. */
617static void module_unload_free(struct module *mod)
618{
619	struct module_use *use, *tmp;
620
621	mutex_lock(&module_mutex);
622	list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
623		struct module *i = use->target;
624		pr_debug("%s unusing %s\n", mod->name, i->name);
625		module_put(i);
626		list_del(&use->source_list);
627		list_del(&use->target_list);
628		kfree(use);
629	}
630	mutex_unlock(&module_mutex);
631}
632
633#ifdef CONFIG_MODULE_FORCE_UNLOAD
634static inline int try_force_unload(unsigned int flags)
635{
636	int ret = (flags & O_TRUNC);
637	if (ret)
638		add_taint(TAINT_FORCED_RMMOD, LOCKDEP_NOW_UNRELIABLE);
639	return ret;
640}
641#else
642static inline int try_force_unload(unsigned int flags)
643{
644	return 0;
645}
646#endif /* CONFIG_MODULE_FORCE_UNLOAD */
647
648/* Try to release refcount of module, 0 means success. */
649static int try_release_module_ref(struct module *mod)
650{
651	int ret;
652
653	/* Try to decrement refcnt which we set at loading */
654	ret = atomic_sub_return(MODULE_REF_BASE, &mod->refcnt);
655	BUG_ON(ret < 0);
656	if (ret)
657		/* Someone can put this right now, recover with checking */
658		ret = atomic_add_unless(&mod->refcnt, MODULE_REF_BASE, 0);
659
660	return ret;
661}
662
663static int try_stop_module(struct module *mod, int flags, int *forced)
664{
665	/* If it's not unused, quit unless we're forcing. */
666	if (try_release_module_ref(mod) != 0) {
667		*forced = try_force_unload(flags);
668		if (!(*forced))
669			return -EWOULDBLOCK;
670	}
671
672	/* Mark it as dying. */
673	mod->state = MODULE_STATE_GOING;
674
675	return 0;
676}
677
678/**
679 * module_refcount() - return the refcount or -1 if unloading
680 * @mod:	the module we're checking
681 *
682 * Return:
683 *	-1 if the module is in the process of unloading
684 *	otherwise the number of references in the kernel to the module
685 */
686int module_refcount(struct module *mod)
687{
688	return atomic_read(&mod->refcnt) - MODULE_REF_BASE;
689}
690EXPORT_SYMBOL(module_refcount);
691
692/* This exists whether we can unload or not */
693static void free_module(struct module *mod);
694
695SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
696		unsigned int, flags)
697{
698	struct module *mod;
699	char name[MODULE_NAME_LEN];
700	char buf[MODULE_FLAGS_BUF_SIZE];
701	int ret, forced = 0;
702
703	if (!capable(CAP_SYS_MODULE) || modules_disabled)
704		return -EPERM;
705
706	if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
707		return -EFAULT;
708	name[MODULE_NAME_LEN-1] = '\0';
709
710	audit_log_kern_module(name);
711
712	if (mutex_lock_interruptible(&module_mutex) != 0)
713		return -EINTR;
714
715	mod = find_module(name);
716	if (!mod) {
717		ret = -ENOENT;
718		goto out;
719	}
720
721	if (!list_empty(&mod->source_list)) {
722		/* Other modules depend on us: get rid of them first. */
723		ret = -EWOULDBLOCK;
724		goto out;
725	}
726
727	/* Doing init or already dying? */
728	if (mod->state != MODULE_STATE_LIVE) {
729		/* FIXME: if (force), slam module count damn the torpedoes */
730		pr_debug("%s already dying\n", mod->name);
731		ret = -EBUSY;
732		goto out;
733	}
734
735	/* If it has an init func, it must have an exit func to unload */
736	if (mod->init && !mod->exit) {
737		forced = try_force_unload(flags);
738		if (!forced) {
739			/* This module can't be removed */
740			ret = -EBUSY;
741			goto out;
742		}
743	}
744
745	ret = try_stop_module(mod, flags, &forced);
746	if (ret != 0)
747		goto out;
748
749	mutex_unlock(&module_mutex);
750	/* Final destruction now no one is using it. */
751	if (mod->exit != NULL)
752		mod->exit();
753	blocking_notifier_call_chain(&module_notify_list,
754				     MODULE_STATE_GOING, mod);
755	klp_module_going(mod);
756	ftrace_release_mod(mod);
757
758	async_synchronize_full();
759
760	/* Store the name and taints of the last unloaded module for diagnostic purposes */
761	strscpy(last_unloaded_module.name, mod->name, sizeof(last_unloaded_module.name));
762	strscpy(last_unloaded_module.taints, module_flags(mod, buf, false), sizeof(last_unloaded_module.taints));
763
764	free_module(mod);
765	/* someone could wait for the module in add_unformed_module() */
766	wake_up_all(&module_wq);
767	return 0;
768out:
769	mutex_unlock(&module_mutex);
770	return ret;
771}
772
773void __symbol_put(const char *symbol)
774{
775	struct find_symbol_arg fsa = {
776		.name	= symbol,
777		.gplok	= true,
778	};
779
780	preempt_disable();
781	BUG_ON(!find_symbol(&fsa));
782	module_put(fsa.owner);
783	preempt_enable();
784}
785EXPORT_SYMBOL(__symbol_put);
786
787/* Note this assumes addr is a function, which it currently always is. */
788void symbol_put_addr(void *addr)
789{
790	struct module *modaddr;
791	unsigned long a = (unsigned long)dereference_function_descriptor(addr);
792
793	if (core_kernel_text(a))
794		return;
795
796	/*
797	 * Even though we hold a reference on the module; we still need to
798	 * disable preemption in order to safely traverse the data structure.
799	 */
800	preempt_disable();
801	modaddr = __module_text_address(a);
802	BUG_ON(!modaddr);
803	module_put(modaddr);
804	preempt_enable();
805}
806EXPORT_SYMBOL_GPL(symbol_put_addr);
807
808static ssize_t show_refcnt(struct module_attribute *mattr,
809			   struct module_kobject *mk, char *buffer)
810{
811	return sprintf(buffer, "%i\n", module_refcount(mk->mod));
812}
813
814static struct module_attribute modinfo_refcnt =
815	__ATTR(refcnt, 0444, show_refcnt, NULL);
816
817void __module_get(struct module *module)
818{
819	if (module) {
820		preempt_disable();
821		atomic_inc(&module->refcnt);
822		trace_module_get(module, _RET_IP_);
823		preempt_enable();
824	}
825}
826EXPORT_SYMBOL(__module_get);
827
828bool try_module_get(struct module *module)
829{
830	bool ret = true;
831
832	if (module) {
833		preempt_disable();
834		/* Note: here, we can fail to get a reference */
835		if (likely(module_is_live(module) &&
836			   atomic_inc_not_zero(&module->refcnt) != 0))
837			trace_module_get(module, _RET_IP_);
838		else
839			ret = false;
840
841		preempt_enable();
842	}
843	return ret;
844}
845EXPORT_SYMBOL(try_module_get);
846
847void module_put(struct module *module)
848{
849	int ret;
850
851	if (module) {
852		preempt_disable();
853		ret = atomic_dec_if_positive(&module->refcnt);
854		WARN_ON(ret < 0);	/* Failed to put refcount */
855		trace_module_put(module, _RET_IP_);
856		preempt_enable();
857	}
858}
859EXPORT_SYMBOL(module_put);
860
861#else /* !CONFIG_MODULE_UNLOAD */
862static inline void module_unload_free(struct module *mod)
863{
864}
865
866static int ref_module(struct module *a, struct module *b)
867{
868	return strong_try_module_get(b);
869}
870
871static inline int module_unload_init(struct module *mod)
872{
873	return 0;
874}
875#endif /* CONFIG_MODULE_UNLOAD */
876
877size_t module_flags_taint(unsigned long taints, char *buf)
878{
879	size_t l = 0;
880	int i;
881
882	for (i = 0; i < TAINT_FLAGS_COUNT; i++) {
883		if (taint_flags[i].module && test_bit(i, &taints))
884			buf[l++] = taint_flags[i].c_true;
885	}
886
887	return l;
888}
889
890static ssize_t show_initstate(struct module_attribute *mattr,
891			      struct module_kobject *mk, char *buffer)
892{
893	const char *state = "unknown";
894
895	switch (mk->mod->state) {
896	case MODULE_STATE_LIVE:
897		state = "live";
898		break;
899	case MODULE_STATE_COMING:
900		state = "coming";
901		break;
902	case MODULE_STATE_GOING:
903		state = "going";
904		break;
905	default:
906		BUG();
907	}
908	return sprintf(buffer, "%s\n", state);
909}
910
911static struct module_attribute modinfo_initstate =
912	__ATTR(initstate, 0444, show_initstate, NULL);
913
914static ssize_t store_uevent(struct module_attribute *mattr,
915			    struct module_kobject *mk,
916			    const char *buffer, size_t count)
917{
918	int rc;
919
920	rc = kobject_synth_uevent(&mk->kobj, buffer, count);
921	return rc ? rc : count;
922}
923
924struct module_attribute module_uevent =
925	__ATTR(uevent, 0200, NULL, store_uevent);
926
927static ssize_t show_coresize(struct module_attribute *mattr,
928			     struct module_kobject *mk, char *buffer)
929{
930	return sprintf(buffer, "%u\n", mk->mod->core_layout.size);
931}
932
933static struct module_attribute modinfo_coresize =
934	__ATTR(coresize, 0444, show_coresize, NULL);
935
936#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
937static ssize_t show_datasize(struct module_attribute *mattr,
938			     struct module_kobject *mk, char *buffer)
939{
940	return sprintf(buffer, "%u\n", mk->mod->data_layout.size);
941}
942
943static struct module_attribute modinfo_datasize =
944	__ATTR(datasize, 0444, show_datasize, NULL);
945#endif
946
947static ssize_t show_initsize(struct module_attribute *mattr,
948			     struct module_kobject *mk, char *buffer)
949{
950	return sprintf(buffer, "%u\n", mk->mod->init_layout.size);
951}
952
953static struct module_attribute modinfo_initsize =
954	__ATTR(initsize, 0444, show_initsize, NULL);
955
956static ssize_t show_taint(struct module_attribute *mattr,
957			  struct module_kobject *mk, char *buffer)
958{
959	size_t l;
960
961	l = module_flags_taint(mk->mod->taints, buffer);
962	buffer[l++] = '\n';
963	return l;
964}
965
966static struct module_attribute modinfo_taint =
967	__ATTR(taint, 0444, show_taint, NULL);
968
969struct module_attribute *modinfo_attrs[] = {
970	&module_uevent,
971	&modinfo_version,
972	&modinfo_srcversion,
973	&modinfo_initstate,
974	&modinfo_coresize,
975#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
976	&modinfo_datasize,
977#endif
978	&modinfo_initsize,
979	&modinfo_taint,
980#ifdef CONFIG_MODULE_UNLOAD
981	&modinfo_refcnt,
982#endif
983	NULL,
984};
985
986size_t modinfo_attrs_count = ARRAY_SIZE(modinfo_attrs);
987
988static const char vermagic[] = VERMAGIC_STRING;
989
990int try_to_force_load(struct module *mod, const char *reason)
991{
992#ifdef CONFIG_MODULE_FORCE_LOAD
993	if (!test_taint(TAINT_FORCED_MODULE))
994		pr_warn("%s: %s: kernel tainted.\n", mod->name, reason);
995	add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_NOW_UNRELIABLE);
996	return 0;
997#else
998	return -ENOEXEC;
999#endif
1000}
1001
1002static char *get_modinfo(const struct load_info *info, const char *tag);
1003static char *get_next_modinfo(const struct load_info *info, const char *tag,
1004			      char *prev);
1005
1006static int verify_namespace_is_imported(const struct load_info *info,
1007					const struct kernel_symbol *sym,
1008					struct module *mod)
1009{
1010	const char *namespace;
1011	char *imported_namespace;
1012
1013	namespace = kernel_symbol_namespace(sym);
1014	if (namespace && namespace[0]) {
1015		imported_namespace = get_modinfo(info, "import_ns");
1016		while (imported_namespace) {
1017			if (strcmp(namespace, imported_namespace) == 0)
1018				return 0;
1019			imported_namespace = get_next_modinfo(
1020				info, "import_ns", imported_namespace);
1021		}
1022#ifdef CONFIG_MODULE_ALLOW_MISSING_NAMESPACE_IMPORTS
1023		pr_warn(
1024#else
1025		pr_err(
1026#endif
1027			"%s: module uses symbol (%s) from namespace %s, but does not import it.\n",
1028			mod->name, kernel_symbol_name(sym), namespace);
1029#ifndef CONFIG_MODULE_ALLOW_MISSING_NAMESPACE_IMPORTS
1030		return -EINVAL;
1031#endif
1032	}
1033	return 0;
1034}
1035
1036static bool inherit_taint(struct module *mod, struct module *owner, const char *name)
1037{
1038	if (!owner || !test_bit(TAINT_PROPRIETARY_MODULE, &owner->taints))
1039		return true;
1040
1041	if (mod->using_gplonly_symbols) {
1042		pr_err("%s: module using GPL-only symbols uses symbols %s from proprietary module %s.\n",
1043			mod->name, name, owner->name);
1044		return false;
1045	}
1046
1047	if (!test_bit(TAINT_PROPRIETARY_MODULE, &mod->taints)) {
1048		pr_warn("%s: module uses symbols %s from proprietary module %s, inheriting taint.\n",
1049			mod->name, name, owner->name);
1050		set_bit(TAINT_PROPRIETARY_MODULE, &mod->taints);
1051	}
1052	return true;
1053}
1054
1055/* Resolve a symbol for this module.  I.e. if we find one, record usage. */
1056static const struct kernel_symbol *resolve_symbol(struct module *mod,
1057						  const struct load_info *info,
1058						  const char *name,
1059						  char ownername[])
1060{
1061	struct find_symbol_arg fsa = {
1062		.name	= name,
1063		.gplok	= !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)),
1064		.warn	= true,
1065	};
1066	int err;
1067
1068	/*
1069	 * The module_mutex should not be a heavily contended lock;
1070	 * if we get the occasional sleep here, we'll go an extra iteration
1071	 * in the wait_event_interruptible(), which is harmless.
1072	 */
1073	sched_annotate_sleep();
1074	mutex_lock(&module_mutex);
1075	if (!find_symbol(&fsa))
1076		goto unlock;
1077
1078	if (fsa.license == GPL_ONLY)
1079		mod->using_gplonly_symbols = true;
1080
1081	if (!inherit_taint(mod, fsa.owner, name)) {
1082		fsa.sym = NULL;
1083		goto getname;
1084	}
1085
1086	if (!check_version(info, name, mod, fsa.crc)) {
1087		fsa.sym = ERR_PTR(-EINVAL);
1088		goto getname;
1089	}
1090
1091	err = verify_namespace_is_imported(info, fsa.sym, mod);
1092	if (err) {
1093		fsa.sym = ERR_PTR(err);
1094		goto getname;
1095	}
1096
1097	err = ref_module(mod, fsa.owner);
1098	if (err) {
1099		fsa.sym = ERR_PTR(err);
1100		goto getname;
1101	}
1102
1103getname:
1104	/* We must make copy under the lock if we failed to get ref. */
1105	strncpy(ownername, module_name(fsa.owner), MODULE_NAME_LEN);
1106unlock:
1107	mutex_unlock(&module_mutex);
1108	return fsa.sym;
1109}
1110
1111static const struct kernel_symbol *
1112resolve_symbol_wait(struct module *mod,
1113		    const struct load_info *info,
1114		    const char *name)
1115{
1116	const struct kernel_symbol *ksym;
1117	char owner[MODULE_NAME_LEN];
1118
1119	if (wait_event_interruptible_timeout(module_wq,
1120			!IS_ERR(ksym = resolve_symbol(mod, info, name, owner))
1121			|| PTR_ERR(ksym) != -EBUSY,
1122					     30 * HZ) <= 0) {
1123		pr_warn("%s: gave up waiting for init of module %s.\n",
1124			mod->name, owner);
1125	}
1126	return ksym;
1127}
1128
1129void __weak module_memfree(void *module_region)
1130{
1131	/*
1132	 * This memory may be RO, and freeing RO memory in an interrupt is not
1133	 * supported by vmalloc.
1134	 */
1135	WARN_ON(in_interrupt());
1136	vfree(module_region);
1137}
1138
1139void __weak module_arch_cleanup(struct module *mod)
1140{
1141}
1142
1143void __weak module_arch_freeing_init(struct module *mod)
1144{
1145}
1146
1147static void cfi_cleanup(struct module *mod);
1148
1149/* Free a module, remove from lists, etc. */
1150static void free_module(struct module *mod)
1151{
1152	trace_module_free(mod);
1153
1154	mod_sysfs_teardown(mod);
1155
1156	/*
1157	 * We leave it in list to prevent duplicate loads, but make sure
1158	 * that noone uses it while it's being deconstructed.
1159	 */
1160	mutex_lock(&module_mutex);
1161	mod->state = MODULE_STATE_UNFORMED;
1162	mutex_unlock(&module_mutex);
1163
1164	/* Remove dynamic debug info */
1165	ddebug_remove_module(mod->name);
1166
1167	/* Arch-specific cleanup. */
1168	module_arch_cleanup(mod);
1169
1170	/* Module unload stuff */
1171	module_unload_free(mod);
1172
1173	/* Free any allocated parameters. */
1174	destroy_params(mod->kp, mod->num_kp);
1175
1176	if (is_livepatch_module(mod))
1177		free_module_elf(mod);
1178
1179	/* Now we can delete it from the lists */
1180	mutex_lock(&module_mutex);
1181	/* Unlink carefully: kallsyms could be walking list. */
1182	list_del_rcu(&mod->list);
1183	mod_tree_remove(mod);
1184	/* Remove this module from bug list, this uses list_del_rcu */
1185	module_bug_cleanup(mod);
1186	/* Wait for RCU-sched synchronizing before releasing mod->list and buglist. */
1187	synchronize_rcu();
1188	if (try_add_tainted_module(mod))
1189		pr_err("%s: adding tainted module to the unloaded tainted modules list failed.\n",
1190		       mod->name);
1191	mutex_unlock(&module_mutex);
1192
1193	/* Clean up CFI for the module. */
1194	cfi_cleanup(mod);
1195
1196	/* This may be empty, but that's OK */
1197	module_arch_freeing_init(mod);
1198	module_memfree(mod->init_layout.base);
1199	kfree(mod->args);
1200	percpu_modfree(mod);
1201
1202	/* Free lock-classes; relies on the preceding sync_rcu(). */
1203	lockdep_free_key_range(mod->data_layout.base, mod->data_layout.size);
1204
1205	/* Finally, free the core (containing the module structure) */
1206	module_memfree(mod->core_layout.base);
1207#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
1208	vfree(mod->data_layout.base);
1209#endif
1210}
1211
1212void *__symbol_get(const char *symbol)
1213{
1214	struct find_symbol_arg fsa = {
1215		.name	= symbol,
1216		.gplok	= true,
1217		.warn	= true,
1218	};
1219
1220	preempt_disable();
1221	if (!find_symbol(&fsa) || strong_try_module_get(fsa.owner)) {
1222		preempt_enable();
1223		return NULL;
1224	}
1225	preempt_enable();
1226	return (void *)kernel_symbol_value(fsa.sym);
1227}
1228EXPORT_SYMBOL_GPL(__symbol_get);
1229
1230/*
1231 * Ensure that an exported symbol [global namespace] does not already exist
1232 * in the kernel or in some other module's exported symbol table.
1233 *
1234 * You must hold the module_mutex.
1235 */
1236static int verify_exported_symbols(struct module *mod)
1237{
1238	unsigned int i;
1239	const struct kernel_symbol *s;
1240	struct {
1241		const struct kernel_symbol *sym;
1242		unsigned int num;
1243	} arr[] = {
1244		{ mod->syms, mod->num_syms },
1245		{ mod->gpl_syms, mod->num_gpl_syms },
1246	};
1247
1248	for (i = 0; i < ARRAY_SIZE(arr); i++) {
1249		for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) {
1250			struct find_symbol_arg fsa = {
1251				.name	= kernel_symbol_name(s),
1252				.gplok	= true,
1253			};
1254			if (find_symbol(&fsa)) {
1255				pr_err("%s: exports duplicate symbol %s"
1256				       " (owned by %s)\n",
1257				       mod->name, kernel_symbol_name(s),
1258				       module_name(fsa.owner));
1259				return -ENOEXEC;
1260			}
1261		}
1262	}
1263	return 0;
1264}
1265
1266static bool ignore_undef_symbol(Elf_Half emachine, const char *name)
1267{
1268	/*
1269	 * On x86, PIC code and Clang non-PIC code may have call foo@PLT. GNU as
1270	 * before 2.37 produces an unreferenced _GLOBAL_OFFSET_TABLE_ on x86-64.
1271	 * i386 has a similar problem but may not deserve a fix.
1272	 *
1273	 * If we ever have to ignore many symbols, consider refactoring the code to
1274	 * only warn if referenced by a relocation.
1275	 */
1276	if (emachine == EM_386 || emachine == EM_X86_64)
1277		return !strcmp(name, "_GLOBAL_OFFSET_TABLE_");
1278	return false;
1279}
1280
1281/* Change all symbols so that st_value encodes the pointer directly. */
1282static int simplify_symbols(struct module *mod, const struct load_info *info)
1283{
1284	Elf_Shdr *symsec = &info->sechdrs[info->index.sym];
1285	Elf_Sym *sym = (void *)symsec->sh_addr;
1286	unsigned long secbase;
1287	unsigned int i;
1288	int ret = 0;
1289	const struct kernel_symbol *ksym;
1290
1291	for (i = 1; i < symsec->sh_size / sizeof(Elf_Sym); i++) {
1292		const char *name = info->strtab + sym[i].st_name;
1293
1294		switch (sym[i].st_shndx) {
1295		case SHN_COMMON:
1296			/* Ignore common symbols */
1297			if (!strncmp(name, "__gnu_lto", 9))
1298				break;
1299
1300			/*
1301			 * We compiled with -fno-common.  These are not
1302			 * supposed to happen.
1303			 */
1304			pr_debug("Common symbol: %s\n", name);
1305			pr_warn("%s: please compile with -fno-common\n",
1306			       mod->name);
1307			ret = -ENOEXEC;
1308			break;
1309
1310		case SHN_ABS:
1311			/* Don't need to do anything */
1312			pr_debug("Absolute symbol: 0x%08lx\n",
1313			       (long)sym[i].st_value);
1314			break;
1315
1316		case SHN_LIVEPATCH:
1317			/* Livepatch symbols are resolved by livepatch */
1318			break;
1319
1320		case SHN_UNDEF:
1321			ksym = resolve_symbol_wait(mod, info, name);
1322			/* Ok if resolved.  */
1323			if (ksym && !IS_ERR(ksym)) {
1324				sym[i].st_value = kernel_symbol_value(ksym);
1325				break;
1326			}
1327
1328			/* Ok if weak or ignored.  */
1329			if (!ksym &&
1330			    (ELF_ST_BIND(sym[i].st_info) == STB_WEAK ||
1331			     ignore_undef_symbol(info->hdr->e_machine, name)))
1332				break;
1333
1334			ret = PTR_ERR(ksym) ?: -ENOENT;
1335			pr_warn("%s: Unknown symbol %s (err %d)\n",
1336				mod->name, name, ret);
1337			break;
1338
1339		default:
1340			/* Divert to percpu allocation if a percpu var. */
1341			if (sym[i].st_shndx == info->index.pcpu)
1342				secbase = (unsigned long)mod_percpu(mod);
1343			else
1344				secbase = info->sechdrs[sym[i].st_shndx].sh_addr;
1345			sym[i].st_value += secbase;
1346			break;
1347		}
1348	}
1349
1350	return ret;
1351}
1352
1353static int apply_relocations(struct module *mod, const struct load_info *info)
1354{
1355	unsigned int i;
1356	int err = 0;
1357
1358	/* Now do relocations. */
1359	for (i = 1; i < info->hdr->e_shnum; i++) {
1360		unsigned int infosec = info->sechdrs[i].sh_info;
1361
1362		/* Not a valid relocation section? */
1363		if (infosec >= info->hdr->e_shnum)
1364			continue;
1365
1366		/* Don't bother with non-allocated sections */
1367		if (!(info->sechdrs[infosec].sh_flags & SHF_ALLOC))
1368			continue;
1369
1370		if (info->sechdrs[i].sh_flags & SHF_RELA_LIVEPATCH)
1371			err = klp_apply_section_relocs(mod, info->sechdrs,
1372						       info->secstrings,
1373						       info->strtab,
1374						       info->index.sym, i,
1375						       NULL);
1376		else if (info->sechdrs[i].sh_type == SHT_REL)
1377			err = apply_relocate(info->sechdrs, info->strtab,
1378					     info->index.sym, i, mod);
1379		else if (info->sechdrs[i].sh_type == SHT_RELA)
1380			err = apply_relocate_add(info->sechdrs, info->strtab,
1381						 info->index.sym, i, mod);
1382		if (err < 0)
1383			break;
1384	}
1385	return err;
1386}
1387
1388/* Additional bytes needed by arch in front of individual sections */
1389unsigned int __weak arch_mod_section_prepend(struct module *mod,
1390					     unsigned int section)
1391{
1392	/* default implementation just returns zero */
1393	return 0;
1394}
1395
1396/* Update size with this section: return offset. */
1397long module_get_offset(struct module *mod, unsigned int *size,
1398		       Elf_Shdr *sechdr, unsigned int section)
1399{
1400	long ret;
1401
1402	*size += arch_mod_section_prepend(mod, section);
1403	ret = ALIGN(*size, sechdr->sh_addralign ?: 1);
1404	*size = ret + sechdr->sh_size;
1405	return ret;
1406}
1407
1408static bool module_init_layout_section(const char *sname)
1409{
1410#ifndef CONFIG_MODULE_UNLOAD
1411	if (module_exit_section(sname))
1412		return true;
1413#endif
1414	return module_init_section(sname);
1415}
1416
1417/*
1418 * Lay out the SHF_ALLOC sections in a way not dissimilar to how ld
1419 * might -- code, read-only data, read-write data, small data.  Tally
1420 * sizes, and place the offsets into sh_entsize fields: high bit means it
1421 * belongs in init.
1422 */
1423static void layout_sections(struct module *mod, struct load_info *info)
1424{
1425	static unsigned long const masks[][2] = {
1426		/*
1427		 * NOTE: all executable code must be the first section
1428		 * in this array; otherwise modify the text_size
1429		 * finder in the two loops below
1430		 */
1431		{ SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL },
1432		{ SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL },
1433		{ SHF_RO_AFTER_INIT | SHF_ALLOC, ARCH_SHF_SMALL },
1434		{ SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL },
1435		{ ARCH_SHF_SMALL | SHF_ALLOC, 0 }
1436	};
1437	unsigned int m, i;
1438
1439	for (i = 0; i < info->hdr->e_shnum; i++)
1440		info->sechdrs[i].sh_entsize = ~0UL;
1441
1442	pr_debug("Core section allocation order:\n");
1443	for (m = 0; m < ARRAY_SIZE(masks); ++m) {
1444		for (i = 0; i < info->hdr->e_shnum; ++i) {
1445			Elf_Shdr *s = &info->sechdrs[i];
1446			const char *sname = info->secstrings + s->sh_name;
1447			unsigned int *sizep;
1448
1449			if ((s->sh_flags & masks[m][0]) != masks[m][0]
1450			    || (s->sh_flags & masks[m][1])
1451			    || s->sh_entsize != ~0UL
1452			    || module_init_layout_section(sname))
1453				continue;
1454			sizep = m ? &mod->data_layout.size : &mod->core_layout.size;
1455			s->sh_entsize = module_get_offset(mod, sizep, s, i);
1456			pr_debug("\t%s\n", sname);
1457		}
1458		switch (m) {
1459		case 0: /* executable */
1460			mod->core_layout.size = strict_align(mod->core_layout.size);
1461			mod->core_layout.text_size = mod->core_layout.size;
1462			break;
1463		case 1: /* RO: text and ro-data */
1464			mod->data_layout.size = strict_align(mod->data_layout.size);
1465			mod->data_layout.ro_size = mod->data_layout.size;
1466			break;
1467		case 2: /* RO after init */
1468			mod->data_layout.size = strict_align(mod->data_layout.size);
1469			mod->data_layout.ro_after_init_size = mod->data_layout.size;
1470			break;
1471		case 4: /* whole core */
1472			mod->data_layout.size = strict_align(mod->data_layout.size);
1473			break;
1474		}
1475	}
1476
1477	pr_debug("Init section allocation order:\n");
1478	for (m = 0; m < ARRAY_SIZE(masks); ++m) {
1479		for (i = 0; i < info->hdr->e_shnum; ++i) {
1480			Elf_Shdr *s = &info->sechdrs[i];
1481			const char *sname = info->secstrings + s->sh_name;
1482
1483			if ((s->sh_flags & masks[m][0]) != masks[m][0]
1484			    || (s->sh_flags & masks[m][1])
1485			    || s->sh_entsize != ~0UL
1486			    || !module_init_layout_section(sname))
1487				continue;
1488			s->sh_entsize = (module_get_offset(mod, &mod->init_layout.size, s, i)
1489					 | INIT_OFFSET_MASK);
1490			pr_debug("\t%s\n", sname);
1491		}
1492		switch (m) {
1493		case 0: /* executable */
1494			mod->init_layout.size = strict_align(mod->init_layout.size);
1495			mod->init_layout.text_size = mod->init_layout.size;
1496			break;
1497		case 1: /* RO: text and ro-data */
1498			mod->init_layout.size = strict_align(mod->init_layout.size);
1499			mod->init_layout.ro_size = mod->init_layout.size;
1500			break;
1501		case 2:
1502			/*
1503			 * RO after init doesn't apply to init_layout (only
1504			 * core_layout), so it just takes the value of ro_size.
1505			 */
1506			mod->init_layout.ro_after_init_size = mod->init_layout.ro_size;
1507			break;
1508		case 4: /* whole init */
1509			mod->init_layout.size = strict_align(mod->init_layout.size);
1510			break;
1511		}
1512	}
1513}
1514
1515static void set_license(struct module *mod, const char *license)
1516{
1517	if (!license)
1518		license = "unspecified";
1519
1520	if (!license_is_gpl_compatible(license)) {
1521		if (!test_taint(TAINT_PROPRIETARY_MODULE))
1522			pr_warn("%s: module license '%s' taints kernel.\n",
1523				mod->name, license);
1524		add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
1525				 LOCKDEP_NOW_UNRELIABLE);
1526	}
1527}
1528
1529/* Parse tag=value strings from .modinfo section */
1530static char *next_string(char *string, unsigned long *secsize)
1531{
1532	/* Skip non-zero chars */
1533	while (string[0]) {
1534		string++;
1535		if ((*secsize)-- <= 1)
1536			return NULL;
1537	}
1538
1539	/* Skip any zero padding. */
1540	while (!string[0]) {
1541		string++;
1542		if ((*secsize)-- <= 1)
1543			return NULL;
1544	}
1545	return string;
1546}
1547
1548static char *get_next_modinfo(const struct load_info *info, const char *tag,
1549			      char *prev)
1550{
1551	char *p;
1552	unsigned int taglen = strlen(tag);
1553	Elf_Shdr *infosec = &info->sechdrs[info->index.info];
1554	unsigned long size = infosec->sh_size;
1555
1556	/*
1557	 * get_modinfo() calls made before rewrite_section_headers()
1558	 * must use sh_offset, as sh_addr isn't set!
1559	 */
1560	char *modinfo = (char *)info->hdr + infosec->sh_offset;
1561
1562	if (prev) {
1563		size -= prev - modinfo;
1564		modinfo = next_string(prev, &size);
1565	}
1566
1567	for (p = modinfo; p; p = next_string(p, &size)) {
1568		if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
1569			return p + taglen + 1;
1570	}
1571	return NULL;
1572}
1573
1574static char *get_modinfo(const struct load_info *info, const char *tag)
1575{
1576	return get_next_modinfo(info, tag, NULL);
1577}
1578
1579static void setup_modinfo(struct module *mod, struct load_info *info)
1580{
1581	struct module_attribute *attr;
1582	int i;
1583
1584	for (i = 0; (attr = modinfo_attrs[i]); i++) {
1585		if (attr->setup)
1586			attr->setup(mod, get_modinfo(info, attr->attr.name));
1587	}
1588}
1589
1590static void free_modinfo(struct module *mod)
1591{
1592	struct module_attribute *attr;
1593	int i;
1594
1595	for (i = 0; (attr = modinfo_attrs[i]); i++) {
1596		if (attr->free)
1597			attr->free(mod);
1598	}
1599}
1600
1601static void dynamic_debug_setup(struct module *mod, struct _ddebug *debug, unsigned int num)
1602{
1603	if (!debug)
1604		return;
1605	ddebug_add_module(debug, num, mod->name);
1606}
1607
1608static void dynamic_debug_remove(struct module *mod, struct _ddebug *debug)
1609{
1610	if (debug)
1611		ddebug_remove_module(mod->name);
1612}
1613
1614void * __weak module_alloc(unsigned long size)
1615{
1616	return __vmalloc_node_range(size, 1, VMALLOC_START, VMALLOC_END,
1617			GFP_KERNEL, PAGE_KERNEL_EXEC, VM_FLUSH_RESET_PERMS,
1618			NUMA_NO_NODE, __builtin_return_address(0));
1619}
1620
1621bool __weak module_init_section(const char *name)
1622{
1623	return strstarts(name, ".init");
1624}
1625
1626bool __weak module_exit_section(const char *name)
1627{
1628	return strstarts(name, ".exit");
1629}
1630
1631static int validate_section_offset(struct load_info *info, Elf_Shdr *shdr)
1632{
1633#if defined(CONFIG_64BIT)
1634	unsigned long long secend;
1635#else
1636	unsigned long secend;
1637#endif
1638
1639	/*
1640	 * Check for both overflow and offset/size being
1641	 * too large.
1642	 */
1643	secend = shdr->sh_offset + shdr->sh_size;
1644	if (secend < shdr->sh_offset || secend > info->len)
1645		return -ENOEXEC;
1646
1647	return 0;
1648}
1649
1650/*
1651 * Sanity checks against invalid binaries, wrong arch, weird elf version.
1652 *
1653 * Also do basic validity checks against section offsets and sizes, the
1654 * section name string table, and the indices used for it (sh_name).
1655 */
1656static int elf_validity_check(struct load_info *info)
1657{
1658	unsigned int i;
1659	Elf_Shdr *shdr, *strhdr;
1660	int err;
1661
1662	if (info->len < sizeof(*(info->hdr))) {
1663		pr_err("Invalid ELF header len %lu\n", info->len);
1664		goto no_exec;
1665	}
1666
1667	if (memcmp(info->hdr->e_ident, ELFMAG, SELFMAG) != 0) {
1668		pr_err("Invalid ELF header magic: != %s\n", ELFMAG);
1669		goto no_exec;
1670	}
1671	if (info->hdr->e_type != ET_REL) {
1672		pr_err("Invalid ELF header type: %u != %u\n",
1673		       info->hdr->e_type, ET_REL);
1674		goto no_exec;
1675	}
1676	if (!elf_check_arch(info->hdr)) {
1677		pr_err("Invalid architecture in ELF header: %u\n",
1678		       info->hdr->e_machine);
1679		goto no_exec;
1680	}
1681	if (info->hdr->e_shentsize != sizeof(Elf_Shdr)) {
1682		pr_err("Invalid ELF section header size\n");
1683		goto no_exec;
1684	}
1685
1686	/*
1687	 * e_shnum is 16 bits, and sizeof(Elf_Shdr) is
1688	 * known and small. So e_shnum * sizeof(Elf_Shdr)
1689	 * will not overflow unsigned long on any platform.
1690	 */
1691	if (info->hdr->e_shoff >= info->len
1692	    || (info->hdr->e_shnum * sizeof(Elf_Shdr) >
1693		info->len - info->hdr->e_shoff)) {
1694		pr_err("Invalid ELF section header overflow\n");
1695		goto no_exec;
1696	}
1697
1698	info->sechdrs = (void *)info->hdr + info->hdr->e_shoff;
1699
1700	/*
1701	 * Verify if the section name table index is valid.
1702	 */
1703	if (info->hdr->e_shstrndx == SHN_UNDEF
1704	    || info->hdr->e_shstrndx >= info->hdr->e_shnum) {
1705		pr_err("Invalid ELF section name index: %d || e_shstrndx (%d) >= e_shnum (%d)\n",
1706		       info->hdr->e_shstrndx, info->hdr->e_shstrndx,
1707		       info->hdr->e_shnum);
1708		goto no_exec;
1709	}
1710
1711	strhdr = &info->sechdrs[info->hdr->e_shstrndx];
1712	err = validate_section_offset(info, strhdr);
1713	if (err < 0) {
1714		pr_err("Invalid ELF section hdr(type %u)\n", strhdr->sh_type);
1715		return err;
1716	}
1717
1718	/*
1719	 * The section name table must be NUL-terminated, as required
1720	 * by the spec. This makes strcmp and pr_* calls that access
1721	 * strings in the section safe.
1722	 */
1723	info->secstrings = (void *)info->hdr + strhdr->sh_offset;
1724	if (strhdr->sh_size == 0) {
1725		pr_err("empty section name table\n");
1726		goto no_exec;
1727	}
1728	if (info->secstrings[strhdr->sh_size - 1] != '\0') {
1729		pr_err("ELF Spec violation: section name table isn't null terminated\n");
1730		goto no_exec;
1731	}
1732
1733	/*
1734	 * The code assumes that section 0 has a length of zero and
1735	 * an addr of zero, so check for it.
1736	 */
1737	if (info->sechdrs[0].sh_type != SHT_NULL
1738	    || info->sechdrs[0].sh_size != 0
1739	    || info->sechdrs[0].sh_addr != 0) {
1740		pr_err("ELF Spec violation: section 0 type(%d)!=SH_NULL or non-zero len or addr\n",
1741		       info->sechdrs[0].sh_type);
1742		goto no_exec;
1743	}
1744
1745	for (i = 1; i < info->hdr->e_shnum; i++) {
1746		shdr = &info->sechdrs[i];
1747		switch (shdr->sh_type) {
1748		case SHT_NULL:
1749		case SHT_NOBITS:
1750			continue;
1751		case SHT_SYMTAB:
1752			if (shdr->sh_link == SHN_UNDEF
1753			    || shdr->sh_link >= info->hdr->e_shnum) {
1754				pr_err("Invalid ELF sh_link!=SHN_UNDEF(%d) or (sh_link(%d) >= hdr->e_shnum(%d)\n",
1755				       shdr->sh_link, shdr->sh_link,
1756				       info->hdr->e_shnum);
1757				goto no_exec;
1758			}
1759			fallthrough;
1760		default:
1761			err = validate_section_offset(info, shdr);
1762			if (err < 0) {
1763				pr_err("Invalid ELF section in module (section %u type %u)\n",
1764					i, shdr->sh_type);
1765				return err;
1766			}
1767
1768			if (shdr->sh_flags & SHF_ALLOC) {
1769				if (shdr->sh_name >= strhdr->sh_size) {
1770					pr_err("Invalid ELF section name in module (section %u type %u)\n",
1771					       i, shdr->sh_type);
1772					return -ENOEXEC;
1773				}
1774			}
1775			break;
1776		}
1777	}
1778
1779	return 0;
1780
1781no_exec:
1782	return -ENOEXEC;
1783}
1784
1785#define COPY_CHUNK_SIZE (16*PAGE_SIZE)
1786
1787static int copy_chunked_from_user(void *dst, const void __user *usrc, unsigned long len)
1788{
1789	do {
1790		unsigned long n = min(len, COPY_CHUNK_SIZE);
1791
1792		if (copy_from_user(dst, usrc, n) != 0)
1793			return -EFAULT;
1794		cond_resched();
1795		dst += n;
1796		usrc += n;
1797		len -= n;
1798	} while (len);
1799	return 0;
1800}
1801
1802static int check_modinfo_livepatch(struct module *mod, struct load_info *info)
1803{
1804	if (!get_modinfo(info, "livepatch"))
1805		/* Nothing more to do */
1806		return 0;
1807
1808	if (set_livepatch_module(mod)) {
1809		add_taint_module(mod, TAINT_LIVEPATCH, LOCKDEP_STILL_OK);
1810		pr_notice_once("%s: tainting kernel with TAINT_LIVEPATCH\n",
1811				mod->name);
1812		return 0;
1813	}
1814
1815	pr_err("%s: module is marked as livepatch module, but livepatch support is disabled",
1816	       mod->name);
1817	return -ENOEXEC;
1818}
1819
1820static void check_modinfo_retpoline(struct module *mod, struct load_info *info)
1821{
1822	if (retpoline_module_ok(get_modinfo(info, "retpoline")))
1823		return;
1824
1825	pr_warn("%s: loading module not compiled with retpoline compiler.\n",
1826		mod->name);
1827}
1828
1829/* Sets info->hdr and info->len. */
1830static int copy_module_from_user(const void __user *umod, unsigned long len,
1831				  struct load_info *info)
1832{
1833	int err;
1834
1835	info->len = len;
1836	if (info->len < sizeof(*(info->hdr)))
1837		return -ENOEXEC;
1838
1839	err = security_kernel_load_data(LOADING_MODULE, true);
1840	if (err)
1841		return err;
1842
1843	/* Suck in entire file: we'll want most of it. */
1844	info->hdr = __vmalloc(info->len, GFP_KERNEL | __GFP_NOWARN);
1845	if (!info->hdr)
1846		return -ENOMEM;
1847
1848	if (copy_chunked_from_user(info->hdr, umod, info->len) != 0) {
1849		err = -EFAULT;
1850		goto out;
1851	}
1852
1853	err = security_kernel_post_load_data((char *)info->hdr, info->len,
1854					     LOADING_MODULE, "init_module");
1855out:
1856	if (err)
1857		vfree(info->hdr);
1858
1859	return err;
1860}
1861
1862static void free_copy(struct load_info *info, int flags)
1863{
1864	if (flags & MODULE_INIT_COMPRESSED_FILE)
1865		module_decompress_cleanup(info);
1866	else
1867		vfree(info->hdr);
1868}
1869
1870static int rewrite_section_headers(struct load_info *info, int flags)
1871{
1872	unsigned int i;
1873
1874	/* This should always be true, but let's be sure. */
1875	info->sechdrs[0].sh_addr = 0;
1876
1877	for (i = 1; i < info->hdr->e_shnum; i++) {
1878		Elf_Shdr *shdr = &info->sechdrs[i];
1879
1880		/*
1881		 * Mark all sections sh_addr with their address in the
1882		 * temporary image.
1883		 */
1884		shdr->sh_addr = (size_t)info->hdr + shdr->sh_offset;
1885
1886	}
1887
1888	/* Track but don't keep modinfo and version sections. */
1889	info->sechdrs[info->index.vers].sh_flags &= ~(unsigned long)SHF_ALLOC;
1890	info->sechdrs[info->index.info].sh_flags &= ~(unsigned long)SHF_ALLOC;
1891
1892	return 0;
1893}
1894
1895/*
1896 * Set up our basic convenience variables (pointers to section headers,
1897 * search for module section index etc), and do some basic section
1898 * verification.
1899 *
1900 * Set info->mod to the temporary copy of the module in info->hdr. The final one
1901 * will be allocated in move_module().
1902 */
1903static int setup_load_info(struct load_info *info, int flags)
1904{
1905	unsigned int i;
1906
1907	/* Try to find a name early so we can log errors with a module name */
1908	info->index.info = find_sec(info, ".modinfo");
1909	if (info->index.info)
1910		info->name = get_modinfo(info, "name");
1911
1912	/* Find internal symbols and strings. */
1913	for (i = 1; i < info->hdr->e_shnum; i++) {
1914		if (info->sechdrs[i].sh_type == SHT_SYMTAB) {
1915			info->index.sym = i;
1916			info->index.str = info->sechdrs[i].sh_link;
1917			info->strtab = (char *)info->hdr
1918				+ info->sechdrs[info->index.str].sh_offset;
1919			break;
1920		}
1921	}
1922
1923	if (info->index.sym == 0) {
1924		pr_warn("%s: module has no symbols (stripped?)\n",
1925			info->name ?: "(missing .modinfo section or name field)");
1926		return -ENOEXEC;
1927	}
1928
1929	info->index.mod = find_sec(info, ".gnu.linkonce.this_module");
1930	if (!info->index.mod) {
1931		pr_warn("%s: No module found in object\n",
1932			info->name ?: "(missing .modinfo section or name field)");
1933		return -ENOEXEC;
1934	}
1935	/* This is temporary: point mod into copy of data. */
1936	info->mod = (void *)info->hdr + info->sechdrs[info->index.mod].sh_offset;
1937
1938	/*
1939	 * If we didn't load the .modinfo 'name' field earlier, fall back to
1940	 * on-disk struct mod 'name' field.
1941	 */
1942	if (!info->name)
1943		info->name = info->mod->name;
1944
1945	if (flags & MODULE_INIT_IGNORE_MODVERSIONS)
1946		info->index.vers = 0; /* Pretend no __versions section! */
1947	else
1948		info->index.vers = find_sec(info, "__versions");
1949
1950	info->index.pcpu = find_pcpusec(info);
1951
1952	return 0;
1953}
1954
1955static int check_modinfo(struct module *mod, struct load_info *info, int flags)
1956{
1957	const char *modmagic = get_modinfo(info, "vermagic");
1958	int err;
1959
1960	if (flags & MODULE_INIT_IGNORE_VERMAGIC)
1961		modmagic = NULL;
1962
1963	/* This is allowed: modprobe --force will invalidate it. */
1964	if (!modmagic) {
1965		err = try_to_force_load(mod, "bad vermagic");
1966		if (err)
1967			return err;
1968	} else if (!same_magic(modmagic, vermagic, info->index.vers)) {
1969		pr_err("%s: version magic '%s' should be '%s'\n",
1970		       info->name, modmagic, vermagic);
1971		return -ENOEXEC;
1972	}
1973
1974	if (!get_modinfo(info, "intree")) {
1975		if (!test_taint(TAINT_OOT_MODULE))
1976			pr_warn("%s: loading out-of-tree module taints kernel.\n",
1977				mod->name);
1978		add_taint_module(mod, TAINT_OOT_MODULE, LOCKDEP_STILL_OK);
1979	}
1980
1981	check_modinfo_retpoline(mod, info);
1982
1983	if (get_modinfo(info, "staging")) {
1984		add_taint_module(mod, TAINT_CRAP, LOCKDEP_STILL_OK);
1985		pr_warn("%s: module is from the staging directory, the quality "
1986			"is unknown, you have been warned.\n", mod->name);
1987	}
1988
1989	err = check_modinfo_livepatch(mod, info);
1990	if (err)
1991		return err;
1992
1993	/* Set up license info based on the info section */
1994	set_license(mod, get_modinfo(info, "license"));
1995
1996	if (get_modinfo(info, "test")) {
1997		if (!test_taint(TAINT_TEST))
1998			pr_warn("%s: loading test module taints kernel.\n",
1999				mod->name);
2000		add_taint_module(mod, TAINT_TEST, LOCKDEP_STILL_OK);
2001	}
2002
2003	return 0;
2004}
2005
2006static int find_module_sections(struct module *mod, struct load_info *info)
2007{
2008	mod->kp = section_objs(info, "__param",
2009			       sizeof(*mod->kp), &mod->num_kp);
2010	mod->syms = section_objs(info, "__ksymtab",
2011				 sizeof(*mod->syms), &mod->num_syms);
2012	mod->crcs = section_addr(info, "__kcrctab");
2013	mod->gpl_syms = section_objs(info, "__ksymtab_gpl",
2014				     sizeof(*mod->gpl_syms),
2015				     &mod->num_gpl_syms);
2016	mod->gpl_crcs = section_addr(info, "__kcrctab_gpl");
2017
2018#ifdef CONFIG_CONSTRUCTORS
2019	mod->ctors = section_objs(info, ".ctors",
2020				  sizeof(*mod->ctors), &mod->num_ctors);
2021	if (!mod->ctors)
2022		mod->ctors = section_objs(info, ".init_array",
2023				sizeof(*mod->ctors), &mod->num_ctors);
2024	else if (find_sec(info, ".init_array")) {
2025		/*
2026		 * This shouldn't happen with same compiler and binutils
2027		 * building all parts of the module.
2028		 */
2029		pr_warn("%s: has both .ctors and .init_array.\n",
2030		       mod->name);
2031		return -EINVAL;
2032	}
2033#endif
2034
2035	mod->noinstr_text_start = section_objs(info, ".noinstr.text", 1,
2036						&mod->noinstr_text_size);
2037
2038#ifdef CONFIG_TRACEPOINTS
2039	mod->tracepoints_ptrs = section_objs(info, "__tracepoints_ptrs",
2040					     sizeof(*mod->tracepoints_ptrs),
2041					     &mod->num_tracepoints);
2042#endif
2043#ifdef CONFIG_TREE_SRCU
2044	mod->srcu_struct_ptrs = section_objs(info, "___srcu_struct_ptrs",
2045					     sizeof(*mod->srcu_struct_ptrs),
2046					     &mod->num_srcu_structs);
2047#endif
2048#ifdef CONFIG_BPF_EVENTS
2049	mod->bpf_raw_events = section_objs(info, "__bpf_raw_tp_map",
2050					   sizeof(*mod->bpf_raw_events),
2051					   &mod->num_bpf_raw_events);
2052#endif
2053#ifdef CONFIG_DEBUG_INFO_BTF_MODULES
2054	mod->btf_data = any_section_objs(info, ".BTF", 1, &mod->btf_data_size);
2055#endif
2056#ifdef CONFIG_JUMP_LABEL
2057	mod->jump_entries = section_objs(info, "__jump_table",
2058					sizeof(*mod->jump_entries),
2059					&mod->num_jump_entries);
2060#endif
2061#ifdef CONFIG_EVENT_TRACING
2062	mod->trace_events = section_objs(info, "_ftrace_events",
2063					 sizeof(*mod->trace_events),
2064					 &mod->num_trace_events);
2065	mod->trace_evals = section_objs(info, "_ftrace_eval_map",
2066					sizeof(*mod->trace_evals),
2067					&mod->num_trace_evals);
2068#endif
2069#ifdef CONFIG_TRACING
2070	mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
2071					 sizeof(*mod->trace_bprintk_fmt_start),
2072					 &mod->num_trace_bprintk_fmt);
2073#endif
2074#ifdef CONFIG_FTRACE_MCOUNT_RECORD
2075	/* sechdrs[0].sh_size is always zero */
2076	mod->ftrace_callsites = section_objs(info, FTRACE_CALLSITE_SECTION,
2077					     sizeof(*mod->ftrace_callsites),
2078					     &mod->num_ftrace_callsites);
2079#endif
2080#ifdef CONFIG_FUNCTION_ERROR_INJECTION
2081	mod->ei_funcs = section_objs(info, "_error_injection_whitelist",
2082					    sizeof(*mod->ei_funcs),
2083					    &mod->num_ei_funcs);
2084#endif
2085#ifdef CONFIG_KPROBES
2086	mod->kprobes_text_start = section_objs(info, ".kprobes.text", 1,
2087						&mod->kprobes_text_size);
2088	mod->kprobe_blacklist = section_objs(info, "_kprobe_blacklist",
2089						sizeof(unsigned long),
2090						&mod->num_kprobe_blacklist);
2091#endif
2092#ifdef CONFIG_PRINTK_INDEX
2093	mod->printk_index_start = section_objs(info, ".printk_index",
2094					       sizeof(*mod->printk_index_start),
2095					       &mod->printk_index_size);
2096#endif
2097#ifdef CONFIG_HAVE_STATIC_CALL_INLINE
2098	mod->static_call_sites = section_objs(info, ".static_call_sites",
2099					      sizeof(*mod->static_call_sites),
2100					      &mod->num_static_call_sites);
2101#endif
2102#if IS_ENABLED(CONFIG_KUNIT)
2103	mod->kunit_suites = section_objs(info, ".kunit_test_suites",
2104					      sizeof(*mod->kunit_suites),
2105					      &mod->num_kunit_suites);
2106#endif
2107
2108	mod->extable = section_objs(info, "__ex_table",
2109				    sizeof(*mod->extable), &mod->num_exentries);
2110
2111	if (section_addr(info, "__obsparm"))
2112		pr_warn("%s: Ignoring obsolete parameters\n", mod->name);
2113
2114	info->debug = section_objs(info, "__dyndbg",
2115				   sizeof(*info->debug), &info->num_debug);
2116
2117	return 0;
2118}
2119
2120static int move_module(struct module *mod, struct load_info *info)
2121{
2122	int i;
2123	void *ptr;
2124
2125	/* Do the allocs. */
2126	ptr = module_alloc(mod->core_layout.size);
2127	/*
2128	 * The pointer to this block is stored in the module structure
2129	 * which is inside the block. Just mark it as not being a
2130	 * leak.
2131	 */
2132	kmemleak_not_leak(ptr);
2133	if (!ptr)
2134		return -ENOMEM;
2135
2136	memset(ptr, 0, mod->core_layout.size);
2137	mod->core_layout.base = ptr;
2138
2139	if (mod->init_layout.size) {
2140		ptr = module_alloc(mod->init_layout.size);
2141		/*
2142		 * The pointer to this block is stored in the module structure
2143		 * which is inside the block. This block doesn't need to be
2144		 * scanned as it contains data and code that will be freed
2145		 * after the module is initialized.
2146		 */
2147		kmemleak_ignore(ptr);
2148		if (!ptr) {
2149			module_memfree(mod->core_layout.base);
2150			return -ENOMEM;
2151		}
2152		memset(ptr, 0, mod->init_layout.size);
2153		mod->init_layout.base = ptr;
2154	} else
2155		mod->init_layout.base = NULL;
2156
2157#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
2158	/* Do the allocs. */
2159	ptr = vzalloc(mod->data_layout.size);
2160	/*
2161	 * The pointer to this block is stored in the module structure
2162	 * which is inside the block. Just mark it as not being a
2163	 * leak.
2164	 */
2165	kmemleak_not_leak(ptr);
2166	if (!ptr) {
2167		module_memfree(mod->core_layout.base);
2168		module_memfree(mod->init_layout.base);
2169		return -ENOMEM;
2170	}
2171
2172	mod->data_layout.base = ptr;
2173#endif
2174	/* Transfer each section which specifies SHF_ALLOC */
2175	pr_debug("final section addresses:\n");
2176	for (i = 0; i < info->hdr->e_shnum; i++) {
2177		void *dest;
2178		Elf_Shdr *shdr = &info->sechdrs[i];
2179
2180		if (!(shdr->sh_flags & SHF_ALLOC))
2181			continue;
2182
2183		if (shdr->sh_entsize & INIT_OFFSET_MASK)
2184			dest = mod->init_layout.base
2185				+ (shdr->sh_entsize & ~INIT_OFFSET_MASK);
2186		else if (!(shdr->sh_flags & SHF_EXECINSTR))
2187			dest = mod->data_layout.base + shdr->sh_entsize;
2188		else
2189			dest = mod->core_layout.base + shdr->sh_entsize;
2190
2191		if (shdr->sh_type != SHT_NOBITS)
2192			memcpy(dest, (void *)shdr->sh_addr, shdr->sh_size);
2193		/* Update sh_addr to point to copy in image. */
2194		shdr->sh_addr = (unsigned long)dest;
2195		pr_debug("\t0x%lx %s\n",
2196			 (long)shdr->sh_addr, info->secstrings + shdr->sh_name);
2197	}
2198
2199	return 0;
2200}
2201
2202static int check_module_license_and_versions(struct module *mod)
2203{
2204	int prev_taint = test_taint(TAINT_PROPRIETARY_MODULE);
2205
2206	/*
2207	 * ndiswrapper is under GPL by itself, but loads proprietary modules.
2208	 * Don't use add_taint_module(), as it would prevent ndiswrapper from
2209	 * using GPL-only symbols it needs.
2210	 */
2211	if (strcmp(mod->name, "ndiswrapper") == 0)
2212		add_taint(TAINT_PROPRIETARY_MODULE, LOCKDEP_NOW_UNRELIABLE);
2213
2214	/* driverloader was caught wrongly pretending to be under GPL */
2215	if (strcmp(mod->name, "driverloader") == 0)
2216		add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2217				 LOCKDEP_NOW_UNRELIABLE);
2218
2219	/* lve claims to be GPL but upstream won't provide source */
2220	if (strcmp(mod->name, "lve") == 0)
2221		add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2222				 LOCKDEP_NOW_UNRELIABLE);
2223
2224	if (!prev_taint && test_taint(TAINT_PROPRIETARY_MODULE))
2225		pr_warn("%s: module license taints kernel.\n", mod->name);
2226
2227#ifdef CONFIG_MODVERSIONS
2228	if ((mod->num_syms && !mod->crcs) ||
2229	    (mod->num_gpl_syms && !mod->gpl_crcs)) {
2230		return try_to_force_load(mod,
2231					 "no versions for exported symbols");
2232	}
2233#endif
2234	return 0;
2235}
2236
2237static void flush_module_icache(const struct module *mod)
2238{
2239	/*
2240	 * Flush the instruction cache, since we've played with text.
2241	 * Do it before processing of module parameters, so the module
2242	 * can provide parameter accessor functions of its own.
2243	 */
2244	if (mod->init_layout.base)
2245		flush_icache_range((unsigned long)mod->init_layout.base,
2246				   (unsigned long)mod->init_layout.base
2247				   + mod->init_layout.size);
2248	flush_icache_range((unsigned long)mod->core_layout.base,
2249			   (unsigned long)mod->core_layout.base + mod->core_layout.size);
2250}
2251
2252int __weak module_frob_arch_sections(Elf_Ehdr *hdr,
2253				     Elf_Shdr *sechdrs,
2254				     char *secstrings,
2255				     struct module *mod)
2256{
2257	return 0;
2258}
2259
2260/* module_blacklist is a comma-separated list of module names */
2261static char *module_blacklist;
2262static bool blacklisted(const char *module_name)
2263{
2264	const char *p;
2265	size_t len;
2266
2267	if (!module_blacklist)
2268		return false;
2269
2270	for (p = module_blacklist; *p; p += len) {
2271		len = strcspn(p, ",");
2272		if (strlen(module_name) == len && !memcmp(module_name, p, len))
2273			return true;
2274		if (p[len] == ',')
2275			len++;
2276	}
2277	return false;
2278}
2279core_param(module_blacklist, module_blacklist, charp, 0400);
2280
2281static struct module *layout_and_allocate(struct load_info *info, int flags)
2282{
2283	struct module *mod;
2284	unsigned int ndx;
2285	int err;
2286
2287	err = check_modinfo(info->mod, info, flags);
2288	if (err)
2289		return ERR_PTR(err);
2290
2291	/* Allow arches to frob section contents and sizes.  */
2292	err = module_frob_arch_sections(info->hdr, info->sechdrs,
2293					info->secstrings, info->mod);
2294	if (err < 0)
2295		return ERR_PTR(err);
2296
2297	err = module_enforce_rwx_sections(info->hdr, info->sechdrs,
2298					  info->secstrings, info->mod);
2299	if (err < 0)
2300		return ERR_PTR(err);
2301
2302	/* We will do a special allocation for per-cpu sections later. */
2303	info->sechdrs[info->index.pcpu].sh_flags &= ~(unsigned long)SHF_ALLOC;
2304
2305	/*
2306	 * Mark ro_after_init section with SHF_RO_AFTER_INIT so that
2307	 * layout_sections() can put it in the right place.
2308	 * Note: ro_after_init sections also have SHF_{WRITE,ALLOC} set.
2309	 */
2310	ndx = find_sec(info, ".data..ro_after_init");
2311	if (ndx)
2312		info->sechdrs[ndx].sh_flags |= SHF_RO_AFTER_INIT;
2313	/*
2314	 * Mark the __jump_table section as ro_after_init as well: these data
2315	 * structures are never modified, with the exception of entries that
2316	 * refer to code in the __init section, which are annotated as such
2317	 * at module load time.
2318	 */
2319	ndx = find_sec(info, "__jump_table");
2320	if (ndx)
2321		info->sechdrs[ndx].sh_flags |= SHF_RO_AFTER_INIT;
2322
2323	/*
2324	 * Determine total sizes, and put offsets in sh_entsize.  For now
2325	 * this is done generically; there doesn't appear to be any
2326	 * special cases for the architectures.
2327	 */
2328	layout_sections(info->mod, info);
2329	layout_symtab(info->mod, info);
2330
2331	/* Allocate and move to the final place */
2332	err = move_module(info->mod, info);
2333	if (err)
2334		return ERR_PTR(err);
2335
2336	/* Module has been copied to its final place now: return it. */
2337	mod = (void *)info->sechdrs[info->index.mod].sh_addr;
2338	kmemleak_load_module(mod, info);
2339	return mod;
2340}
2341
2342/* mod is no longer valid after this! */
2343static void module_deallocate(struct module *mod, struct load_info *info)
2344{
2345	percpu_modfree(mod);
2346	module_arch_freeing_init(mod);
2347	module_memfree(mod->init_layout.base);
2348	module_memfree(mod->core_layout.base);
2349#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
2350	vfree(mod->data_layout.base);
2351#endif
2352}
2353
2354int __weak module_finalize(const Elf_Ehdr *hdr,
2355			   const Elf_Shdr *sechdrs,
2356			   struct module *me)
2357{
2358	return 0;
2359}
2360
2361static int post_relocation(struct module *mod, const struct load_info *info)
2362{
2363	/* Sort exception table now relocations are done. */
2364	sort_extable(mod->extable, mod->extable + mod->num_exentries);
2365
2366	/* Copy relocated percpu area over. */
2367	percpu_modcopy(mod, (void *)info->sechdrs[info->index.pcpu].sh_addr,
2368		       info->sechdrs[info->index.pcpu].sh_size);
2369
2370	/* Setup kallsyms-specific fields. */
2371	add_kallsyms(mod, info);
2372
2373	/* Arch-specific module finalizing. */
2374	return module_finalize(info->hdr, info->sechdrs, mod);
2375}
2376
2377/* Is this module of this name done loading?  No locks held. */
2378static bool finished_loading(const char *name)
2379{
2380	struct module *mod;
2381	bool ret;
2382
2383	/*
2384	 * The module_mutex should not be a heavily contended lock;
2385	 * if we get the occasional sleep here, we'll go an extra iteration
2386	 * in the wait_event_interruptible(), which is harmless.
2387	 */
2388	sched_annotate_sleep();
2389	mutex_lock(&module_mutex);
2390	mod = find_module_all(name, strlen(name), true);
2391	ret = !mod || mod->state == MODULE_STATE_LIVE;
2392	mutex_unlock(&module_mutex);
2393
2394	return ret;
2395}
2396
2397/* Call module constructors. */
2398static void do_mod_ctors(struct module *mod)
2399{
2400#ifdef CONFIG_CONSTRUCTORS
2401	unsigned long i;
2402
2403	for (i = 0; i < mod->num_ctors; i++)
2404		mod->ctors[i]();
2405#endif
2406}
2407
2408/* For freeing module_init on success, in case kallsyms traversing */
2409struct mod_initfree {
2410	struct llist_node node;
2411	void *module_init;
2412};
2413
2414static void do_free_init(struct work_struct *w)
2415{
2416	struct llist_node *pos, *n, *list;
2417	struct mod_initfree *initfree;
2418
2419	list = llist_del_all(&init_free_list);
2420
2421	synchronize_rcu();
2422
2423	llist_for_each_safe(pos, n, list) {
2424		initfree = container_of(pos, struct mod_initfree, node);
2425		module_memfree(initfree->module_init);
2426		kfree(initfree);
2427	}
2428}
2429
2430#undef MODULE_PARAM_PREFIX
2431#define MODULE_PARAM_PREFIX "module."
2432/* Default value for module->async_probe_requested */
2433static bool async_probe;
2434module_param(async_probe, bool, 0644);
2435
2436/*
2437 * This is where the real work happens.
2438 *
2439 * Keep it uninlined to provide a reliable breakpoint target, e.g. for the gdb
2440 * helper command 'lx-symbols'.
2441 */
2442static noinline int do_init_module(struct module *mod)
2443{
2444	int ret = 0;
2445	struct mod_initfree *freeinit;
2446
2447	freeinit = kmalloc(sizeof(*freeinit), GFP_KERNEL);
2448	if (!freeinit) {
2449		ret = -ENOMEM;
2450		goto fail;
2451	}
2452	freeinit->module_init = mod->init_layout.base;
2453
2454	do_mod_ctors(mod);
2455	/* Start the module */
2456	if (mod->init != NULL)
2457		ret = do_one_initcall(mod->init);
2458	if (ret < 0) {
2459		goto fail_free_freeinit;
2460	}
2461	if (ret > 0) {
2462		pr_warn("%s: '%s'->init suspiciously returned %d, it should "
2463			"follow 0/-E convention\n"
2464			"%s: loading module anyway...\n",
2465			__func__, mod->name, ret, __func__);
2466		dump_stack();
2467	}
2468
2469	/* Now it's a first class citizen! */
2470	mod->state = MODULE_STATE_LIVE;
2471	blocking_notifier_call_chain(&module_notify_list,
2472				     MODULE_STATE_LIVE, mod);
2473
2474	/* Delay uevent until module has finished its init routine */
2475	kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
2476
2477	/*
2478	 * We need to finish all async code before the module init sequence
2479	 * is done. This has potential to deadlock if synchronous module
2480	 * loading is requested from async (which is not allowed!).
2481	 *
2482	 * See commit 0fdff3ec6d87 ("async, kmod: warn on synchronous
2483	 * request_module() from async workers") for more details.
2484	 */
2485	if (!mod->async_probe_requested)
2486		async_synchronize_full();
2487
2488	ftrace_free_mem(mod, mod->init_layout.base, mod->init_layout.base +
2489			mod->init_layout.size);
2490	mutex_lock(&module_mutex);
2491	/* Drop initial reference. */
2492	module_put(mod);
2493	trim_init_extable(mod);
2494#ifdef CONFIG_KALLSYMS
2495	/* Switch to core kallsyms now init is done: kallsyms may be walking! */
2496	rcu_assign_pointer(mod->kallsyms, &mod->core_kallsyms);
2497#endif
2498	module_enable_ro(mod, true);
2499	mod_tree_remove_init(mod);
2500	module_arch_freeing_init(mod);
2501	mod->init_layout.base = NULL;
2502	mod->init_layout.size = 0;
2503	mod->init_layout.ro_size = 0;
2504	mod->init_layout.ro_after_init_size = 0;
2505	mod->init_layout.text_size = 0;
2506#ifdef CONFIG_DEBUG_INFO_BTF_MODULES
2507	/* .BTF is not SHF_ALLOC and will get removed, so sanitize pointer */
2508	mod->btf_data = NULL;
2509#endif
2510	/*
2511	 * We want to free module_init, but be aware that kallsyms may be
2512	 * walking this with preempt disabled.  In all the failure paths, we
2513	 * call synchronize_rcu(), but we don't want to slow down the success
2514	 * path. module_memfree() cannot be called in an interrupt, so do the
2515	 * work and call synchronize_rcu() in a work queue.
2516	 *
2517	 * Note that module_alloc() on most architectures creates W+X page
2518	 * mappings which won't be cleaned up until do_free_init() runs.  Any
2519	 * code such as mark_rodata_ro() which depends on those mappings to
2520	 * be cleaned up needs to sync with the queued work - ie
2521	 * rcu_barrier()
2522	 */
2523	if (llist_add(&freeinit->node, &init_free_list))
2524		schedule_work(&init_free_wq);
2525
2526	mutex_unlock(&module_mutex);
2527	wake_up_all(&module_wq);
2528
2529	return 0;
2530
2531fail_free_freeinit:
2532	kfree(freeinit);
2533fail:
2534	/* Try to protect us from buggy refcounters. */
2535	mod->state = MODULE_STATE_GOING;
2536	synchronize_rcu();
2537	module_put(mod);
2538	blocking_notifier_call_chain(&module_notify_list,
2539				     MODULE_STATE_GOING, mod);
2540	klp_module_going(mod);
2541	ftrace_release_mod(mod);
2542	free_module(mod);
2543	wake_up_all(&module_wq);
2544	return ret;
2545}
2546
2547static int may_init_module(void)
2548{
2549	if (!capable(CAP_SYS_MODULE) || modules_disabled)
2550		return -EPERM;
2551
2552	return 0;
2553}
2554
2555/*
2556 * We try to place it in the list now to make sure it's unique before
2557 * we dedicate too many resources.  In particular, temporary percpu
2558 * memory exhaustion.
2559 */
2560static int add_unformed_module(struct module *mod)
2561{
2562	int err;
2563	struct module *old;
2564
2565	mod->state = MODULE_STATE_UNFORMED;
2566
2567again:
2568	mutex_lock(&module_mutex);
2569	old = find_module_all(mod->name, strlen(mod->name), true);
2570	if (old != NULL) {
2571		if (old->state != MODULE_STATE_LIVE) {
2572			/* Wait in case it fails to load. */
2573			mutex_unlock(&module_mutex);
2574			err = wait_event_interruptible(module_wq,
2575					       finished_loading(mod->name));
2576			if (err)
2577				goto out_unlocked;
2578			goto again;
2579		}
2580		err = -EEXIST;
2581		goto out;
2582	}
2583	mod_update_bounds(mod);
2584	list_add_rcu(&mod->list, &modules);
2585	mod_tree_insert(mod);
2586	err = 0;
2587
2588out:
2589	mutex_unlock(&module_mutex);
2590out_unlocked:
2591	return err;
2592}
2593
2594static int complete_formation(struct module *mod, struct load_info *info)
2595{
2596	int err;
2597
2598	mutex_lock(&module_mutex);
2599
2600	/* Find duplicate symbols (must be called under lock). */
2601	err = verify_exported_symbols(mod);
2602	if (err < 0)
2603		goto out;
2604
2605	/* This relies on module_mutex for list integrity. */
2606	module_bug_finalize(info->hdr, info->sechdrs, mod);
2607
2608	if (module_check_misalignment(mod))
2609		goto out_misaligned;
2610
2611	module_enable_ro(mod, false);
2612	module_enable_nx(mod);
2613	module_enable_x(mod);
2614
2615	/*
2616	 * Mark state as coming so strong_try_module_get() ignores us,
2617	 * but kallsyms etc. can see us.
2618	 */
2619	mod->state = MODULE_STATE_COMING;
2620	mutex_unlock(&module_mutex);
2621
2622	return 0;
2623
2624out_misaligned:
2625	err = -EINVAL;
2626out:
2627	mutex_unlock(&module_mutex);
2628	return err;
2629}
2630
2631static int prepare_coming_module(struct module *mod)
2632{
2633	int err;
2634
2635	ftrace_module_enable(mod);
2636	err = klp_module_coming(mod);
2637	if (err)
2638		return err;
2639
2640	err = blocking_notifier_call_chain_robust(&module_notify_list,
2641			MODULE_STATE_COMING, MODULE_STATE_GOING, mod);
2642	err = notifier_to_errno(err);
2643	if (err)
2644		klp_module_going(mod);
2645
2646	return err;
2647}
2648
2649static int unknown_module_param_cb(char *param, char *val, const char *modname,
2650				   void *arg)
2651{
2652	struct module *mod = arg;
2653	int ret;
2654
2655	if (strcmp(param, "async_probe") == 0) {
2656		if (strtobool(val, &mod->async_probe_requested))
2657			mod->async_probe_requested = true;
2658		return 0;
2659	}
2660
2661	/* Check for magic 'dyndbg' arg */
2662	ret = ddebug_dyndbg_module_param_cb(param, val, modname);
2663	if (ret != 0)
2664		pr_warn("%s: unknown parameter '%s' ignored\n", modname, param);
2665	return 0;
2666}
2667
2668static void cfi_init(struct module *mod);
2669
2670/*
2671 * Allocate and load the module: note that size of section 0 is always
2672 * zero, and we rely on this for optional sections.
2673 */
2674static int load_module(struct load_info *info, const char __user *uargs,
2675		       int flags)
2676{
2677	struct module *mod;
2678	long err = 0;
2679	char *after_dashes;
2680
2681	/*
2682	 * Do the signature check (if any) first. All that
2683	 * the signature check needs is info->len, it does
2684	 * not need any of the section info. That can be
2685	 * set up later. This will minimize the chances
2686	 * of a corrupt module causing problems before
2687	 * we even get to the signature check.
2688	 *
2689	 * The check will also adjust info->len by stripping
2690	 * off the sig length at the end of the module, making
2691	 * checks against info->len more correct.
2692	 */
2693	err = module_sig_check(info, flags);
2694	if (err)
2695		goto free_copy;
2696
2697	/*
2698	 * Do basic sanity checks against the ELF header and
2699	 * sections.
2700	 */
2701	err = elf_validity_check(info);
2702	if (err)
2703		goto free_copy;
2704
2705	/*
2706	 * Everything checks out, so set up the section info
2707	 * in the info structure.
2708	 */
2709	err = setup_load_info(info, flags);
2710	if (err)
2711		goto free_copy;
2712
2713	/*
2714	 * Now that we know we have the correct module name, check
2715	 * if it's blacklisted.
2716	 */
2717	if (blacklisted(info->name)) {
2718		err = -EPERM;
2719		pr_err("Module %s is blacklisted\n", info->name);
2720		goto free_copy;
2721	}
2722
2723	err = rewrite_section_headers(info, flags);
2724	if (err)
2725		goto free_copy;
2726
2727	/* Check module struct version now, before we try to use module. */
2728	if (!check_modstruct_version(info, info->mod)) {
2729		err = -ENOEXEC;
2730		goto free_copy;
2731	}
2732
2733	/* Figure out module layout, and allocate all the memory. */
2734	mod = layout_and_allocate(info, flags);
2735	if (IS_ERR(mod)) {
2736		err = PTR_ERR(mod);
2737		goto free_copy;
2738	}
2739
2740	audit_log_kern_module(mod->name);
2741
2742	/* Reserve our place in the list. */
2743	err = add_unformed_module(mod);
2744	if (err)
2745		goto free_module;
2746
2747#ifdef CONFIG_MODULE_SIG
2748	mod->sig_ok = info->sig_ok;
2749	if (!mod->sig_ok) {
2750		pr_notice_once("%s: module verification failed: signature "
2751			       "and/or required key missing - tainting "
2752			       "kernel\n", mod->name);
2753		add_taint_module(mod, TAINT_UNSIGNED_MODULE, LOCKDEP_STILL_OK);
2754	}
2755#endif
2756
2757	/* To avoid stressing percpu allocator, do this once we're unique. */
2758	err = percpu_modalloc(mod, info);
2759	if (err)
2760		goto unlink_mod;
2761
2762	/* Now module is in final location, initialize linked lists, etc. */
2763	err = module_unload_init(mod);
2764	if (err)
2765		goto unlink_mod;
2766
2767	init_param_lock(mod);
2768
2769	/*
2770	 * Now we've got everything in the final locations, we can
2771	 * find optional sections.
2772	 */
2773	err = find_module_sections(mod, info);
2774	if (err)
2775		goto free_unload;
2776
2777	err = check_module_license_and_versions(mod);
2778	if (err)
2779		goto free_unload;
2780
2781	/* Set up MODINFO_ATTR fields */
2782	setup_modinfo(mod, info);
2783
2784	/* Fix up syms, so that st_value is a pointer to location. */
2785	err = simplify_symbols(mod, info);
2786	if (err < 0)
2787		goto free_modinfo;
2788
2789	err = apply_relocations(mod, info);
2790	if (err < 0)
2791		goto free_modinfo;
2792
2793	err = post_relocation(mod, info);
2794	if (err < 0)
2795		goto free_modinfo;
2796
2797	flush_module_icache(mod);
2798
2799	/* Setup CFI for the module. */
2800	cfi_init(mod);
2801
2802	/* Now copy in args */
2803	mod->args = strndup_user(uargs, ~0UL >> 1);
2804	if (IS_ERR(mod->args)) {
2805		err = PTR_ERR(mod->args);
2806		goto free_arch_cleanup;
2807	}
2808
2809	init_build_id(mod, info);
2810	dynamic_debug_setup(mod, info->debug, info->num_debug);
2811
2812	/* Ftrace init must be called in the MODULE_STATE_UNFORMED state */
2813	ftrace_module_init(mod);
2814
2815	/* Finally it's fully formed, ready to start executing. */
2816	err = complete_formation(mod, info);
2817	if (err)
2818		goto ddebug_cleanup;
2819
2820	err = prepare_coming_module(mod);
2821	if (err)
2822		goto bug_cleanup;
2823
2824	mod->async_probe_requested = async_probe;
2825
2826	/* Module is ready to execute: parsing args may do that. */
2827	after_dashes = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,
2828				  -32768, 32767, mod,
2829				  unknown_module_param_cb);
2830	if (IS_ERR(after_dashes)) {
2831		err = PTR_ERR(after_dashes);
2832		goto coming_cleanup;
2833	} else if (after_dashes) {
2834		pr_warn("%s: parameters '%s' after `--' ignored\n",
2835		       mod->name, after_dashes);
2836	}
2837
2838	/* Link in to sysfs. */
2839	err = mod_sysfs_setup(mod, info, mod->kp, mod->num_kp);
2840	if (err < 0)
2841		goto coming_cleanup;
2842
2843	if (is_livepatch_module(mod)) {
2844		err = copy_module_elf(mod, info);
2845		if (err < 0)
2846			goto sysfs_cleanup;
2847	}
2848
2849	/* Get rid of temporary copy. */
2850	free_copy(info, flags);
2851
2852	/* Done! */
2853	trace_module_load(mod);
2854
2855	return do_init_module(mod);
2856
2857 sysfs_cleanup:
2858	mod_sysfs_teardown(mod);
2859 coming_cleanup:
2860	mod->state = MODULE_STATE_GOING;
2861	destroy_params(mod->kp, mod->num_kp);
2862	blocking_notifier_call_chain(&module_notify_list,
2863				     MODULE_STATE_GOING, mod);
2864	klp_module_going(mod);
2865 bug_cleanup:
2866	mod->state = MODULE_STATE_GOING;
2867	/* module_bug_cleanup needs module_mutex protection */
2868	mutex_lock(&module_mutex);
2869	module_bug_cleanup(mod);
2870	mutex_unlock(&module_mutex);
2871
2872 ddebug_cleanup:
2873	ftrace_release_mod(mod);
2874	dynamic_debug_remove(mod, info->debug);
2875	synchronize_rcu();
2876	kfree(mod->args);
2877 free_arch_cleanup:
2878	cfi_cleanup(mod);
2879	module_arch_cleanup(mod);
2880 free_modinfo:
2881	free_modinfo(mod);
2882 free_unload:
2883	module_unload_free(mod);
2884 unlink_mod:
2885	mutex_lock(&module_mutex);
2886	/* Unlink carefully: kallsyms could be walking list. */
2887	list_del_rcu(&mod->list);
2888	mod_tree_remove(mod);
2889	wake_up_all(&module_wq);
2890	/* Wait for RCU-sched synchronizing before releasing mod->list. */
2891	synchronize_rcu();
2892	mutex_unlock(&module_mutex);
2893 free_module:
2894	/* Free lock-classes; relies on the preceding sync_rcu() */
2895	lockdep_free_key_range(mod->data_layout.base, mod->data_layout.size);
2896
2897	module_deallocate(mod, info);
2898 free_copy:
2899	free_copy(info, flags);
2900	return err;
2901}
2902
2903SYSCALL_DEFINE3(init_module, void __user *, umod,
2904		unsigned long, len, const char __user *, uargs)
2905{
2906	int err;
2907	struct load_info info = { };
2908
2909	err = may_init_module();
2910	if (err)
2911		return err;
2912
2913	pr_debug("init_module: umod=%p, len=%lu, uargs=%p\n",
2914	       umod, len, uargs);
2915
2916	err = copy_module_from_user(umod, len, &info);
2917	if (err)
2918		return err;
2919
2920	return load_module(&info, uargs, 0);
2921}
2922
2923SYSCALL_DEFINE3(finit_module, int, fd, const char __user *, uargs, int, flags)
2924{
2925	struct load_info info = { };
2926	void *buf = NULL;
2927	int len;
2928	int err;
2929
2930	err = may_init_module();
2931	if (err)
2932		return err;
2933
2934	pr_debug("finit_module: fd=%d, uargs=%p, flags=%i\n", fd, uargs, flags);
2935
2936	if (flags & ~(MODULE_INIT_IGNORE_MODVERSIONS
2937		      |MODULE_INIT_IGNORE_VERMAGIC
2938		      |MODULE_INIT_COMPRESSED_FILE))
2939		return -EINVAL;
2940
2941	len = kernel_read_file_from_fd(fd, 0, &buf, INT_MAX, NULL,
2942				       READING_MODULE);
2943	if (len < 0)
2944		return len;
2945
2946	if (flags & MODULE_INIT_COMPRESSED_FILE) {
2947		err = module_decompress(&info, buf, len);
2948		vfree(buf); /* compressed data is no longer needed */
2949		if (err)
2950			return err;
2951	} else {
2952		info.hdr = buf;
2953		info.len = len;
2954	}
2955
2956	return load_module(&info, uargs, flags);
2957}
2958
2959static inline int within(unsigned long addr, void *start, unsigned long size)
2960{
2961	return ((void *)addr >= start && (void *)addr < start + size);
2962}
2963
2964static void cfi_init(struct module *mod)
2965{
2966#ifdef CONFIG_CFI_CLANG
2967	initcall_t *init;
2968#ifdef CONFIG_MODULE_UNLOAD
2969	exitcall_t *exit;
2970#endif
2971
2972	rcu_read_lock_sched();
2973	mod->cfi_check = (cfi_check_fn)
2974		find_kallsyms_symbol_value(mod, "__cfi_check");
2975	init = (initcall_t *)
2976		find_kallsyms_symbol_value(mod, "__cfi_jt_init_module");
2977	/* Fix init/exit functions to point to the CFI jump table */
2978	if (init)
2979		mod->init = *init;
2980#ifdef CONFIG_MODULE_UNLOAD
2981	exit = (exitcall_t *)
2982		find_kallsyms_symbol_value(mod, "__cfi_jt_cleanup_module");
2983	if (exit)
2984		mod->exit = *exit;
2985#endif
2986	rcu_read_unlock_sched();
2987
2988	cfi_module_add(mod, mod_tree.addr_min);
2989#endif
2990}
2991
2992static void cfi_cleanup(struct module *mod)
2993{
2994#ifdef CONFIG_CFI_CLANG
2995	cfi_module_remove(mod, mod_tree.addr_min);
2996#endif
2997}
2998
2999/* Keep in sync with MODULE_FLAGS_BUF_SIZE !!! */
3000char *module_flags(struct module *mod, char *buf, bool show_state)
3001{
3002	int bx = 0;
3003
3004	BUG_ON(mod->state == MODULE_STATE_UNFORMED);
3005	if (!mod->taints && !show_state)
3006		goto out;
3007	if (mod->taints ||
3008	    mod->state == MODULE_STATE_GOING ||
3009	    mod->state == MODULE_STATE_COMING) {
3010		buf[bx++] = '(';
3011		bx += module_flags_taint(mod->taints, buf + bx);
3012		/* Show a - for module-is-being-unloaded */
3013		if (mod->state == MODULE_STATE_GOING && show_state)
3014			buf[bx++] = '-';
3015		/* Show a + for module-is-being-loaded */
3016		if (mod->state == MODULE_STATE_COMING && show_state)
3017			buf[bx++] = '+';
3018		buf[bx++] = ')';
3019	}
3020out:
3021	buf[bx] = '\0';
3022
3023	return buf;
3024}
3025
3026/* Given an address, look for it in the module exception tables. */
3027const struct exception_table_entry *search_module_extables(unsigned long addr)
3028{
3029	const struct exception_table_entry *e = NULL;
3030	struct module *mod;
3031
3032	preempt_disable();
3033	mod = __module_address(addr);
3034	if (!mod)
3035		goto out;
3036
3037	if (!mod->num_exentries)
3038		goto out;
3039
3040	e = search_extable(mod->extable,
3041			   mod->num_exentries,
3042			   addr);
3043out:
3044	preempt_enable();
3045
3046	/*
3047	 * Now, if we found one, we are running inside it now, hence
3048	 * we cannot unload the module, hence no refcnt needed.
3049	 */
3050	return e;
3051}
3052
3053/**
3054 * is_module_address() - is this address inside a module?
3055 * @addr: the address to check.
3056 *
3057 * See is_module_text_address() if you simply want to see if the address
3058 * is code (not data).
3059 */
3060bool is_module_address(unsigned long addr)
3061{
3062	bool ret;
3063
3064	preempt_disable();
3065	ret = __module_address(addr) != NULL;
3066	preempt_enable();
3067
3068	return ret;
3069}
3070
3071/**
3072 * __module_address() - get the module which contains an address.
3073 * @addr: the address.
3074 *
3075 * Must be called with preempt disabled or module mutex held so that
3076 * module doesn't get freed during this.
3077 */
3078struct module *__module_address(unsigned long addr)
3079{
3080	struct module *mod;
3081	struct mod_tree_root *tree;
3082
3083	if (addr >= mod_tree.addr_min && addr <= mod_tree.addr_max)
3084		tree = &mod_tree;
3085#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
3086	else if (addr >= mod_data_tree.addr_min && addr <= mod_data_tree.addr_max)
3087		tree = &mod_data_tree;
3088#endif
3089	else
3090		return NULL;
3091
3092	module_assert_mutex_or_preempt();
3093
3094	mod = mod_find(addr, tree);
3095	if (mod) {
3096		BUG_ON(!within_module(addr, mod));
3097		if (mod->state == MODULE_STATE_UNFORMED)
3098			mod = NULL;
3099	}
3100	return mod;
3101}
3102
3103/**
3104 * is_module_text_address() - is this address inside module code?
3105 * @addr: the address to check.
3106 *
3107 * See is_module_address() if you simply want to see if the address is
3108 * anywhere in a module.  See kernel_text_address() for testing if an
3109 * address corresponds to kernel or module code.
3110 */
3111bool is_module_text_address(unsigned long addr)
3112{
3113	bool ret;
3114
3115	preempt_disable();
3116	ret = __module_text_address(addr) != NULL;
3117	preempt_enable();
3118
3119	return ret;
3120}
3121
3122/**
3123 * __module_text_address() - get the module whose code contains an address.
3124 * @addr: the address.
3125 *
3126 * Must be called with preempt disabled or module mutex held so that
3127 * module doesn't get freed during this.
3128 */
3129struct module *__module_text_address(unsigned long addr)
3130{
3131	struct module *mod = __module_address(addr);
3132	if (mod) {
3133		/* Make sure it's within the text section. */
3134		if (!within(addr, mod->init_layout.base, mod->init_layout.text_size)
3135		    && !within(addr, mod->core_layout.base, mod->core_layout.text_size))
3136			mod = NULL;
3137	}
3138	return mod;
3139}
3140
3141/* Don't grab lock, we're oopsing. */
3142void print_modules(void)
3143{
3144	struct module *mod;
3145	char buf[MODULE_FLAGS_BUF_SIZE];
3146
3147	printk(KERN_DEFAULT "Modules linked in:");
3148	/* Most callers should already have preempt disabled, but make sure */
3149	preempt_disable();
3150	list_for_each_entry_rcu(mod, &modules, list) {
3151		if (mod->state == MODULE_STATE_UNFORMED)
3152			continue;
3153		pr_cont(" %s%s", mod->name, module_flags(mod, buf, true));
3154	}
3155
3156	print_unloaded_tainted_modules();
3157	preempt_enable();
3158	if (last_unloaded_module.name[0])
3159		pr_cont(" [last unloaded: %s%s]", last_unloaded_module.name,
3160			last_unloaded_module.taints);
3161	pr_cont("\n");
3162}
3163