linux - kernel/module/main.c

3162 lines · 80.0 KiB

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	*/
69	DEFINE_MUTEX(module_mutex);
70	LIST_HEAD(modules);
71
72	/* Work queue for freeing init sections in success case */
73	static void do_free_init(struct work_struct *w);
74	static DECLARE_WORK(init_free_wq, do_free_init);
75	static LLIST_HEAD(init_free_list);
76
77	struct mod_tree_root mod_tree __cacheline_aligned = {
78	.addr_min = -1UL,
79	};
80
81	#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
82	struct 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
90	struct 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	*/
100	static 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
111	static 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? */
122	int modules_disabled;
123	core_param(nomodule, modules_disabled, bint, 0);
124
125	/* Waiting for a module to finish initializing? */
126	static DECLARE_WAIT_QUEUE_HEAD(module_wq);
127
128	static BLOCKING_NOTIFIER_HEAD(module_notify_list);
129
130	int register_module_notifier(struct notifier_block *nb)
131	{
132	return blocking_notifier_chain_register(&module_notify_list, nb);
133	}
134	EXPORT_SYMBOL(register_module_notifier);
135
136	int unregister_module_notifier(struct notifier_block *nb)
137	{
138	return blocking_notifier_chain_unregister(&module_notify_list, nb);
139	}
140	EXPORT_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	*/
147	static 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
158	static 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	*/
169	void __noreturn __module_put_and_kthread_exit(struct module *mod, long code)
170	{
171	module_put(mod);
172	kthread_exit(code);
173	}
174	EXPORT_SYMBOL(__module_put_and_kthread_exit);
175
176	/* Find a module section: 0 means not found. */
177	static 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. */
192	static 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. */
199	static 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. */
212	static 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	*/
228	static __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
246	static 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
255	static 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
266	int cmp_name(const void name, const void sym)
267	{
268	return strcmp(name, kernel_symbol_name(sym));
269	}
270
271	static 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	*/
297	bool 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	*/
341	struct 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
358	struct module find_module(const char name)
359	{
360	return find_module_all(name, strlen(name), false);
361	}
362
363	#ifdef CONFIG_SMP
364
365	static inline void __percpu mod_percpu(struct module mod)
366	{
367	return mod->percpu;
368	}
369
370	static 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
394	static void percpu_modfree(struct module *mod)
395	{
396	free_percpu(mod->percpu);
397	}
398
399	static unsigned int find_pcpusec(struct load_info *info)
400	{
401	return find_sec(info, ".data..percpu");
402	}
403
404	static 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
413	bool __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	*/
454	bool is_module_percpu_address(unsigned long addr)
455	{
456	return __is_module_percpu_address(addr, NULL);
457	}
458
459	#else /* ... !CONFIG_SMP */
460
461	static inline void __percpu mod_percpu(struct module mod)
462	{
463	return NULL;
464	}
465	static 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	}
472	static inline void percpu_modfree(struct module *mod)
473	{
474	}
475	static unsigned int find_pcpusec(struct load_info *info)
476	{
477	return 0;
478	}
479	static 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	}
485	bool is_module_percpu_address(unsigned long addr)
486	{
487	return false;
488	}
489
490	bool __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) \
498	static void setup_modinfo_##field(struct module mod, const char s) \
499	{ \
500	mod->field = kstrdup(s, GFP_KERNEL); \
501	} \
502	static 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	} \
507	static int modinfo_##field##_exists(struct module *mod) \
508	{ \
509	return mod->field != NULL; \
510	} \
511	static void free_modinfo_##field(struct module *mod) \
512	{ \
513	kfree(mod->field); \
514	mod->field = NULL; \
515	} \
516	static 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
524	MODINFO_ATTR(version);
525	MODINFO_ATTR(srcversion);
526
527	static 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
534	EXPORT_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. */
540	static 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? */
558	static 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	*/
579	static 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() */
596	static 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. */
617	static 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
634	static 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
642	static 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. */
649	static 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
663	static 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	*/
686	int module_refcount(struct module *mod)
687	{
688	return atomic_read(&mod->refcnt) - MODULE_REF_BASE;
689	}
690	EXPORT_SYMBOL(module_refcount);
691
692	/* This exists whether we can unload or not */
693	static void free_module(struct module *mod);
694
695	SYSCALL_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;
768	out:
769	mutex_unlock(&module_mutex);
770	return ret;
771	}
772
773	void __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	}
785	EXPORT_SYMBOL(__symbol_put);
786
787	/* Note this assumes addr is a function, which it currently always is. */
788	void 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	}
806	EXPORT_SYMBOL_GPL(symbol_put_addr);
807
808	static 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
814	static struct module_attribute modinfo_refcnt =
815	__ATTR(refcnt, 0444, show_refcnt, NULL);
816
817	void __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	}
826	EXPORT_SYMBOL(__module_get);
827
828	bool 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	}
845	EXPORT_SYMBOL(try_module_get);
846
847	void 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	}
859	EXPORT_SYMBOL(module_put);
860
861	#else /* !CONFIG_MODULE_UNLOAD */
862	static inline void module_unload_free(struct module *mod)
863	{
864	}
865
866	static int ref_module(struct module a, struct module b)
867	{
868	return strong_try_module_get(b);
869	}
870
871	static inline int module_unload_init(struct module *mod)
872	{
873	return 0;
874	}
875	#endif /* CONFIG_MODULE_UNLOAD */
876
877	size_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
890	static 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
911	static struct module_attribute modinfo_initstate =
912	__ATTR(initstate, 0444, show_initstate, NULL);
913
914	static 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
924	struct module_attribute module_uevent =
925	__ATTR(uevent, 0200, NULL, store_uevent);
926
927	static 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
933	static struct module_attribute modinfo_coresize =
934	__ATTR(coresize, 0444, show_coresize, NULL);
935
936	#ifdef CONFIG_ARCH_WANTS_MODULES_DATA_IN_VMALLOC
937	static 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
943	static struct module_attribute modinfo_datasize =
944	__ATTR(datasize, 0444, show_datasize, NULL);
945	#endif
946
947	static 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
953	static struct module_attribute modinfo_initsize =
954	__ATTR(initsize, 0444, show_initsize, NULL);
955
956	static 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
966	static struct module_attribute modinfo_taint =
967	__ATTR(taint, 0444, show_taint, NULL);
968
969	struct 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
986	size_t modinfo_attrs_count = ARRAY_SIZE(modinfo_attrs);
987
988	static const char vermagic[] = VERMAGIC_STRING;
989
990	int 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
1002	static char get_modinfo(const struct load_info info, const char *tag);
1003	static char get_next_modinfo(const struct load_info info, const char *tag,
1004	char *prev);
1005
1006	static 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
1036	static 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. */
1056	static 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
1103	getname:
1104	/* We must make copy under the lock if we failed to get ref. */
1105	strncpy(ownername, module_name(fsa.owner), MODULE_NAME_LEN);
1106	unlock:
1107	mutex_unlock(&module_mutex);
1108	return fsa.sym;
1109	}
1110
1111	static const struct kernel_symbol *
1112	resolve_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
1129	void __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
1139	void __weak module_arch_cleanup(struct module *mod)
1140	{
1141	}
1142
1143	void __weak module_arch_freeing_init(struct module *mod)
1144	{
1145	}
1146
1147	static void cfi_cleanup(struct module *mod);
1148
1149	/* Free a module, remove from lists, etc. */
1150	static 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
1212	void __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	}
1228	EXPORT_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	*/
1236	static 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
1266	static 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. */
1282	static 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
1353	static 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 */
1389	unsigned 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. */
1397	long 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
1408	static 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	*/
1423	static 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
1515	static 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 */
1530	static 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
1548	static 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
1574	static char get_modinfo(const struct load_info info, const char *tag)
1575	{
1576	return get_next_modinfo(info, tag, NULL);
1577	}
1578
1579	static 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
1590	static 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
1601	static 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
1608	static void dynamic_debug_remove(struct module mod, struct _ddebug debug)
1609	{
1610	if (debug)
1611	ddebug_remove_module(mod->name);
1612	}
1613
1614	void * __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
1621	bool __weak module_init_section(const char *name)
1622	{
1623	return strstarts(name, ".init");
1624	}
1625
1626	bool __weak module_exit_section(const char *name)
1627	{
1628	return strstarts(name, ".exit");
1629	}
1630
1631	static 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	*/
1656	static 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
1781	no_exec:
1782	return -ENOEXEC;
1783	}
1784
1785	#define COPY_CHUNK_SIZE (16*PAGE_SIZE)
1786
1787	static 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
1802	static 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
1820	static 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. */
1830	static 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");
1855	out:
1856	if (err)
1857	vfree(info->hdr);
1858
1859	return err;
1860	}
1861
1862	static 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
1870	static 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	*/
1903	static 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
1955	static 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
2006	static 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
2120	static 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
2202	static 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
2237	static 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
2252	int __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 */
2261	static char *module_blacklist;
2262	static 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	}
2279	core_param(module_blacklist, module_blacklist, charp, 0400);
2280
2281	static 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! */
2343	static 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
2354	int __weak module_finalize(const Elf_Ehdr *hdr,
2355	const Elf_Shdr *sechdrs,
2356	struct module *me)
2357	{
2358	return 0;
2359	}
2360
2361	static 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. */
2378	static 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. */
2398	static 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 */
2409	struct mod_initfree {
2410	struct llist_node node;
2411	void *module_init;
2412	};
2413
2414	static 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 */
2433	static bool async_probe;
2434	module_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	*/
2442	static 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
2531	fail_free_freeinit:
2532	kfree(freeinit);
2533	fail:
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
2547	static 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	*/
2560	static int add_unformed_module(struct module *mod)
2561	{
2562	int err;
2563	struct module *old;
2564
2565	mod->state = MODULE_STATE_UNFORMED;
2566
2567	again:
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
2588	out:
2589	mutex_unlock(&module_mutex);
2590	out_unlocked:
2591	return err;
2592	}
2593
2594	static 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
2624	out_misaligned:
2625	err = -EINVAL;
2626	out:
2627	mutex_unlock(&module_mutex);
2628	return err;
2629	}
2630
2631	static 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
2649	static 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
2668	static 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	*/
2674	static 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
2903	SYSCALL_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
2923	SYSCALL_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
2959	static inline int within(unsigned long addr, void *start, unsigned long size)
2960	{
2961	return ((void )addr >= start && (void )addr < start + size);
2962	}
2963
2964	static 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
2992	static 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 !!! */
3000	char 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	}
3020	out:
3021	buf[bx] = '\0';
3022
3023	return buf;
3024	}
3025
3026	/* Given an address, look for it in the module exception tables. */
3027	const 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);
3043	out:
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	*/
3060	bool 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	*/
3078	struct 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	*/
3111	bool 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	*/
3129	struct 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. */
3142	void 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	}