Kernel

Kernel Git Source Tree

Root/kernel/module.c

1	/*
2	Copyright (C) 2002 Richard Henderson
3	Copyright (C) 2001 Rusty Russell, 2002 Rusty Russell IBM.
4
5	This program is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published by
7	the Free Software Foundation; either version 2 of the License, or
8	(at your option) any later version.
9
10	This program is distributed in the hope that it will be useful,
11	but WITHOUT ANY WARRANTY; without even the implied warranty of
12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	GNU General Public License for more details.
14
15	You should have received a copy of the GNU General Public License
16	along with this program; if not, write to the Free Software
17	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	*/
19	#include <linux/module.h>
20	#include <linux/moduleloader.h>
21	#include <linux/ftrace_event.h>
22	#include <linux/init.h>
23	#include <linux/kallsyms.h>
24	#include <linux/fs.h>
25	#include <linux/sysfs.h>
26	#include <linux/kernel.h>
27	#include <linux/slab.h>
28	#include <linux/vmalloc.h>
29	#include <linux/elf.h>
30	#include <linux/proc_fs.h>
31	#include <linux/seq_file.h>
32	#include <linux/syscalls.h>
33	#include <linux/fcntl.h>
34	#include <linux/rcupdate.h>
35	#include <linux/capability.h>
36	#include <linux/cpu.h>
37	#include <linux/moduleparam.h>
38	#include <linux/errno.h>
39	#include <linux/err.h>
40	#include <linux/vermagic.h>
41	#include <linux/notifier.h>
42	#include <linux/sched.h>
43	#include <linux/stop_machine.h>
44	#include <linux/device.h>
45	#include <linux/string.h>
46	#include <linux/mutex.h>
47	#include <linux/rculist.h>
48	#include <asm/uaccess.h>
49	#include <asm/cacheflush.h>
50	#include <asm/mmu_context.h>
51	#include <linux/license.h>
52	#include <asm/sections.h>
53	#include <linux/tracepoint.h>
54	#include <linux/ftrace.h>
55	#include <linux/async.h>
56	#include <linux/percpu.h>
57	#include <linux/kmemleak.h>
58
59	#define CREATE_TRACE_POINTS
60	#include <trace/events/module.h>
61
62	EXPORT_TRACEPOINT_SYMBOL(module_get);
63
64	#if 0
65	#define DEBUGP printk
66	#else
67	#define DEBUGP(fmt , a...)
68	#endif
69
70	#ifndef ARCH_SHF_SMALL
71	#define ARCH_SHF_SMALL 0
72	#endif
73
74	/* If this is set, the section belongs in the init part of the module */
75	#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
76
77	/* List of modules, protected by module_mutex or preempt_disable
78	* (delete uses stop_machine/add uses RCU list operations). */
79	DEFINE_MUTEX(module_mutex);
80	EXPORT_SYMBOL_GPL(module_mutex);
81	static LIST_HEAD(modules);
82
83	/* Block module loading/unloading? */
84	int modules_disabled = 0;
85
86	/* Waiting for a module to finish initializing? */
87	static DECLARE_WAIT_QUEUE_HEAD(module_wq);
88
89	static BLOCKING_NOTIFIER_HEAD(module_notify_list);
90
91	/* Bounds of module allocation, for speeding __module_address */
92	static unsigned long module_addr_min = -1UL, module_addr_max = 0;
93
94	int register_module_notifier(struct notifier_block * nb)
95	{
96	return blocking_notifier_chain_register(&module_notify_list, nb);
97	}
98	EXPORT_SYMBOL(register_module_notifier);
99
100	int unregister_module_notifier(struct notifier_block * nb)
101	{
102	return blocking_notifier_chain_unregister(&module_notify_list, nb);
103	}
104	EXPORT_SYMBOL(unregister_module_notifier);
105
106	/* We require a truly strong try_module_get(): 0 means failure due to
107	ongoing or failed initialization etc. */
108	static inline int strong_try_module_get(struct module *mod)
109	{
110	if (mod && mod->state == MODULE_STATE_COMING)
111	return -EBUSY;
112	if (try_module_get(mod))
113	return 0;
114	else
115	return -ENOENT;
116	}
117
118	static inline void add_taint_module(struct module *mod, unsigned flag)
119	{
120	add_taint(flag);
121	mod->taints \|= (1U << flag);
122	}
123
124	/*
125	* A thread that wants to hold a reference to a module only while it
126	* is running can call this to safely exit. nfsd and lockd use this.
127	*/
128	void __module_put_and_exit(struct module *mod, long code)
129	{
130	module_put(mod);
131	do_exit(code);
132	}
133	EXPORT_SYMBOL(__module_put_and_exit);
134
135	/* Find a module section: 0 means not found. */
136	static unsigned int find_sec(Elf_Ehdr *hdr,
137	Elf_Shdr *sechdrs,
138	const char *secstrings,
139	const char *name)
140	{
141	unsigned int i;
142
143	for (i = 1; i < hdr->e_shnum; i++)
144	/* Alloc bit cleared means "ignore it." */
145	if ((sechdrs[i].sh_flags & SHF_ALLOC)
146	&& strcmp(secstrings+sechdrs[i].sh_name, name) == 0)
147	return i;
148	return 0;
149	}
150
151	/* Find a module section, or NULL. */
152	static void section_addr(Elf_Ehdr hdr, Elf_Shdr *shdrs,
153	const char secstrings, const char name)
154	{
155	/* Section 0 has sh_addr 0. */
156	return (void *)shdrs[find_sec(hdr, shdrs, secstrings, name)].sh_addr;
157	}
158
159	/* Find a module section, or NULL. Fill in number of "objects" in section. */
160	static void section_objs(Elf_Ehdr hdr,
161	Elf_Shdr *sechdrs,
162	const char *secstrings,
163	const char *name,
164	size_t object_size,
165	unsigned int *num)
166	{
167	unsigned int sec = find_sec(hdr, sechdrs, secstrings, name);
168
169	/* Section 0 has sh_addr 0 and sh_size 0. */
170	*num = sechdrs[sec].sh_size / object_size;
171	return (void *)sechdrs[sec].sh_addr;
172	}
173
174	/* Provided by the linker */
175	extern const struct kernel_symbol __start___ksymtab[];
176	extern const struct kernel_symbol __stop___ksymtab[];
177	extern const struct kernel_symbol __start___ksymtab_gpl[];
178	extern const struct kernel_symbol __stop___ksymtab_gpl[];
179	extern const struct kernel_symbol __start___ksymtab_gpl_future[];
180	extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
181	extern const struct kernel_symbol __start___ksymtab_gpl_future[];
182	extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
183	extern const unsigned long __start___kcrctab[];
184	extern const unsigned long __start___kcrctab_gpl[];
185	extern const unsigned long __start___kcrctab_gpl_future[];
186	#ifdef CONFIG_UNUSED_SYMBOLS
187	extern const struct kernel_symbol __start___ksymtab_unused[];
188	extern const struct kernel_symbol __stop___ksymtab_unused[];
189	extern const struct kernel_symbol __start___ksymtab_unused_gpl[];
190	extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];
191	extern const unsigned long __start___kcrctab_unused[];
192	extern const unsigned long __start___kcrctab_unused_gpl[];
193	#endif
194
195	#ifndef CONFIG_MODVERSIONS
196	#define symversion(base, idx) NULL
197	#else
198	#define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
199	#endif
200
201	static bool each_symbol_in_section(const struct symsearch *arr,
202	unsigned int arrsize,
203	struct module *owner,
204	bool (fn)(const struct symsearch syms,
205	struct module *owner,
206	unsigned int symnum, void *data),
207	void *data)
208	{
209	unsigned int i, j;
210
211	for (j = 0; j < arrsize; j++) {
212	for (i = 0; i < arr[j].stop - arr[j].start; i++)
213	if (fn(&arr[j], owner, i, data))
214	return true;
215	}
216
217	return false;
218	}
219
220	/* Returns true as soon as fn returns true, otherwise false. */
221	bool each_symbol(bool (fn)(const struct symsearch arr, struct module *owner,
222	unsigned int symnum, void data), void data)
223	{
224	struct module *mod;
225	const struct symsearch arr[] = {
226	{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,
227	NOT_GPL_ONLY, false },
228	{ __start___ksymtab_gpl, __stop___ksymtab_gpl,
229	__start___kcrctab_gpl,
230	GPL_ONLY, false },
231	{ __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,
232	__start___kcrctab_gpl_future,
233	WILL_BE_GPL_ONLY, false },
234	#ifdef CONFIG_UNUSED_SYMBOLS
235	{ __start___ksymtab_unused, __stop___ksymtab_unused,
236	__start___kcrctab_unused,
237	NOT_GPL_ONLY, true },
238	{ __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,
239	__start___kcrctab_unused_gpl,
240	GPL_ONLY, true },
241	#endif
242	};
243
244	if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
245	return true;
246
247	list_for_each_entry_rcu(mod, &modules, list) {
248	struct symsearch arr[] = {
249	{ mod->syms, mod->syms + mod->num_syms, mod->crcs,
250	NOT_GPL_ONLY, false },
251	{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
252	mod->gpl_crcs,
253	GPL_ONLY, false },
254	{ mod->gpl_future_syms,
255	mod->gpl_future_syms + mod->num_gpl_future_syms,
256	mod->gpl_future_crcs,
257	WILL_BE_GPL_ONLY, false },
258	#ifdef CONFIG_UNUSED_SYMBOLS
259	{ mod->unused_syms,
260	mod->unused_syms + mod->num_unused_syms,
261	mod->unused_crcs,
262	NOT_GPL_ONLY, true },
263	{ mod->unused_gpl_syms,
264	mod->unused_gpl_syms + mod->num_unused_gpl_syms,
265	mod->unused_gpl_crcs,
266	GPL_ONLY, true },
267	#endif
268	};
269
270	if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
271	return true;
272	}
273	return false;
274	}
275	EXPORT_SYMBOL_GPL(each_symbol);
276
277	struct find_symbol_arg {
278	/* Input */
279	const char *name;
280	bool gplok;
281	bool warn;
282
283	/* Output */
284	struct module *owner;
285	const unsigned long *crc;
286	const struct kernel_symbol *sym;
287	};
288
289	static bool find_symbol_in_section(const struct symsearch *syms,
290	struct module *owner,
291	unsigned int symnum, void *data)
292	{
293	struct find_symbol_arg *fsa = data;
294
295	if (strcmp(syms->start[symnum].name, fsa->name) != 0)
296	return false;
297
298	if (!fsa->gplok) {
299	if (syms->licence == GPL_ONLY)
300	return false;
301	if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) {
302	printk(KERN_WARNING "Symbol %s is being used "
303	"by a non-GPL module, which will not "
304	"be allowed in the future\n", fsa->name);
305	printk(KERN_WARNING "Please see the file "
306	"Documentation/feature-removal-schedule.txt "
307	"in the kernel source tree for more details.\n");
308	}
309	}
310
311	#ifdef CONFIG_UNUSED_SYMBOLS
312	if (syms->unused && fsa->warn) {
313	printk(KERN_WARNING "Symbol %s is marked as UNUSED, "
314	"however this module is using it.\n", fsa->name);
315	printk(KERN_WARNING
316	"This symbol will go away in the future.\n");
317	printk(KERN_WARNING
318	"Please evalute if this is the right api to use and if "
319	"it really is, submit a report the linux kernel "
320	"mailinglist together with submitting your code for "
321	"inclusion.\n");
322	}
323	#endif
324
325	fsa->owner = owner;
326	fsa->crc = symversion(syms->crcs, symnum);
327	fsa->sym = &syms->start[symnum];
328	return true;
329	}
330
331	/* Find a symbol and return it, along with, (optional) crc and
332	* (optional) module which owns it */
333	const struct kernel_symbol find_symbol(const char name,
334	struct module **owner,
335	const unsigned long **crc,
336	bool gplok,
337	bool warn)
338	{
339	struct find_symbol_arg fsa;
340
341	fsa.name = name;
342	fsa.gplok = gplok;
343	fsa.warn = warn;
344
345	if (each_symbol(find_symbol_in_section, &fsa)) {
346	if (owner)
347	*owner = fsa.owner;
348	if (crc)
349	*crc = fsa.crc;
350	return fsa.sym;
351	}
352
353	DEBUGP("Failed to find symbol %s\n", name);
354	return NULL;
355	}
356	EXPORT_SYMBOL_GPL(find_symbol);
357
358	/* Search for module by name: must hold module_mutex. */
359	struct module find_module(const char name)
360	{
361	struct module *mod;
362
363	list_for_each_entry(mod, &modules, list) {
364	if (strcmp(mod->name, name) == 0)
365	return mod;
366	}
367	return NULL;
368	}
369	EXPORT_SYMBOL_GPL(find_module);
370
371	#ifdef CONFIG_SMP
372
373	static inline void __percpu mod_percpu(struct module mod)
374	{
375	return mod->percpu;
376	}
377
378	static int percpu_modalloc(struct module *mod,
379	unsigned long size, unsigned long align)
380	{
381	if (align > PAGE_SIZE) {
382	printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
383	mod->name, align, PAGE_SIZE);
384	align = PAGE_SIZE;
385	}
386
387	mod->percpu = __alloc_reserved_percpu(size, align);
388	if (!mod->percpu) {
389	printk(KERN_WARNING
390	"Could not allocate %lu bytes percpu data\n", size);
391	return -ENOMEM;
392	}
393	mod->percpu_size = size;
394	return 0;
395	}
396
397	static void percpu_modfree(struct module *mod)
398	{
399	free_percpu(mod->percpu);
400	}
401
402	static unsigned int find_pcpusec(Elf_Ehdr *hdr,
403	Elf_Shdr *sechdrs,
404	const char *secstrings)
405	{
406	return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
407	}
408
409	static void percpu_modcopy(struct module *mod,
410	const void *from, unsigned long size)
411	{
412	int cpu;
413
414	for_each_possible_cpu(cpu)
415	memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);
416	}
417
418	/**
419	* is_module_percpu_address - test whether address is from module static percpu
420	* @addr: address to test
421	*
422	* Test whether @addr belongs to module static percpu area.
423	*
424	* RETURNS:
425	* %true if @addr is from module static percpu area
426	*/
427	bool is_module_percpu_address(unsigned long addr)
428	{
429	struct module *mod;
430	unsigned int cpu;
431
432	preempt_disable();
433
434	list_for_each_entry_rcu(mod, &modules, list) {
435	if (!mod->percpu_size)
436	continue;
437	for_each_possible_cpu(cpu) {
438	void *start = per_cpu_ptr(mod->percpu, cpu);
439
440	if ((void *)addr >= start &&
441	(void *)addr < start + mod->percpu_size) {
442	preempt_enable();
443	return true;
444	}
445	}
446	}
447
448	preempt_enable();
449	return false;
450	}
451
452	#else /* ... !CONFIG_SMP */
453
454	static inline void __percpu mod_percpu(struct module mod)
455	{
456	return NULL;
457	}
458	static inline int percpu_modalloc(struct module *mod,
459	unsigned long size, unsigned long align)
460	{
461	return -ENOMEM;
462	}
463	static inline void percpu_modfree(struct module *mod)
464	{
465	}
466	static inline unsigned int find_pcpusec(Elf_Ehdr *hdr,
467	Elf_Shdr *sechdrs,
468	const char *secstrings)
469	{
470	return 0;
471	}
472	static inline void percpu_modcopy(struct module *mod,
473	const void *from, unsigned long size)
474	{
475	/* pcpusec should be 0, and size of that section should be 0. */
476	BUG_ON(size != 0);
477	}
478	bool is_module_percpu_address(unsigned long addr)
479	{
480	return false;
481	}
482
483	#endif /* CONFIG_SMP */
484
485	#define MODINFO_ATTR(field) \
486	static void setup_modinfo_##field(struct module mod, const char s) \
487	{ \
488	mod->field = kstrdup(s, GFP_KERNEL); \
489	} \
490	static ssize_t show_modinfo_##field(struct module_attribute *mattr, \
491	struct module mod, char buffer) \
492	{ \
493	return sprintf(buffer, "%s\n", mod->field); \
494	} \
495	static int modinfo_##field##_exists(struct module *mod) \
496	{ \
497	return mod->field != NULL; \
498	} \
499	static void free_modinfo_##field(struct module *mod) \
500	{ \
501	kfree(mod->field); \
502	mod->field = NULL; \
503	} \
504	static struct module_attribute modinfo_##field = { \
505	.attr = { .name = __stringify(field), .mode = 0444 }, \
506	.show = show_modinfo_##field, \
507	.setup = setup_modinfo_##field, \
508	.test = modinfo_##field##_exists, \
509	.free = free_modinfo_##field, \
510	};
511
512	MODINFO_ATTR(version);
513	MODINFO_ATTR(srcversion);
514
515	static char last_unloaded_module[MODULE_NAME_LEN+1];
516
517	#ifdef CONFIG_MODULE_UNLOAD
518	/* Init the unload section of the module. */
519	static void module_unload_init(struct module *mod)
520	{
521	int cpu;
522
523	INIT_LIST_HEAD(&mod->modules_which_use_me);
524	for_each_possible_cpu(cpu) {
525	per_cpu_ptr(mod->refptr, cpu)->incs = 0;
526	per_cpu_ptr(mod->refptr, cpu)->decs = 0;
527	}
528
529	/* Hold reference count during initialization. */
530	__this_cpu_write(mod->refptr->incs, 1);
531	/* Backwards compatibility macros put refcount during init. */
532	mod->waiter = current;
533	}
534
535	/* modules using other modules */
536	struct module_use
537	{
538	struct list_head list;
539	struct module *module_which_uses;
540	};
541
542	/* Does a already use b? */
543	static int already_uses(struct module a, struct module b)
544	{
545	struct module_use *use;
546
547	list_for_each_entry(use, &b->modules_which_use_me, list) {
548	if (use->module_which_uses == a) {
549	DEBUGP("%s uses %s!\n", a->name, b->name);
550	return 1;
551	}
552	}
553	DEBUGP("%s does not use %s!\n", a->name, b->name);
554	return 0;
555	}
556
557	/* Module a uses b */
558	int use_module(struct module a, struct module b)
559	{
560	struct module_use *use;
561	int no_warn, err;
562
563	if (b == NULL \|\| already_uses(a, b)) return 1;
564
565	/* If we're interrupted or time out, we fail. */
566	if (wait_event_interruptible_timeout(
567	module_wq, (err = strong_try_module_get(b)) != -EBUSY,
568	30 * HZ) <= 0) {
569	printk("%s: gave up waiting for init of module %s.\n",
570	a->name, b->name);
571	return 0;
572	}
573
574	/* If strong_try_module_get() returned a different error, we fail. */
575	if (err)
576	return 0;
577
578	DEBUGP("Allocating new usage for %s.\n", a->name);
579	use = kmalloc(sizeof(*use), GFP_ATOMIC);
580	if (!use) {
581	printk("%s: out of memory loading\n", a->name);
582	module_put(b);
583	return 0;
584	}
585
586	use->module_which_uses = a;
587	list_add(&use->list, &b->modules_which_use_me);
588	no_warn = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name);
589	return 1;
590	}
591	EXPORT_SYMBOL_GPL(use_module);
592
593	/* Clear the unload stuff of the module. */
594	static void module_unload_free(struct module *mod)
595	{
596	struct module *i;
597
598	list_for_each_entry(i, &modules, list) {
599	struct module_use *use;
600
601	list_for_each_entry(use, &i->modules_which_use_me, list) {
602	if (use->module_which_uses == mod) {
603	DEBUGP("%s unusing %s\n", mod->name, i->name);
604	module_put(i);
605	list_del(&use->list);
606	kfree(use);
607	sysfs_remove_link(i->holders_dir, mod->name);
608	/* There can be at most one match. */
609	break;
610	}
611	}
612	}
613	}
614
615	#ifdef CONFIG_MODULE_FORCE_UNLOAD
616	static inline int try_force_unload(unsigned int flags)
617	{
618	int ret = (flags & O_TRUNC);
619	if (ret)
620	add_taint(TAINT_FORCED_RMMOD);
621	return ret;
622	}
623	#else
624	static inline int try_force_unload(unsigned int flags)
625	{
626	return 0;
627	}
628	#endif /* CONFIG_MODULE_FORCE_UNLOAD */
629
630	struct stopref
631	{
632	struct module *mod;
633	int flags;
634	int *forced;
635	};
636
637	/* Whole machine is stopped with interrupts off when this runs. */
638	static int __try_stop_module(void *_sref)
639	{
640	struct stopref *sref = _sref;
641
642	/* If it's not unused, quit unless we're forcing. */
643	if (module_refcount(sref->mod) != 0) {
644	if (!(*sref->forced = try_force_unload(sref->flags)))
645	return -EWOULDBLOCK;
646	}
647
648	/* Mark it as dying. */
649	sref->mod->state = MODULE_STATE_GOING;
650	return 0;
651	}
652
653	static int try_stop_module(struct module mod, int flags, int forced)
654	{
655	if (flags & O_NONBLOCK) {
656	struct stopref sref = { mod, flags, forced };
657
658	return stop_machine(__try_stop_module, &sref, NULL);
659	} else {
660	/* We don't need to stop the machine for this. */
661	mod->state = MODULE_STATE_GOING;
662	synchronize_sched();
663	return 0;
664	}
665	}
666
667	unsigned int module_refcount(struct module *mod)
668	{
669	unsigned int incs = 0, decs = 0;
670	int cpu;
671
672	for_each_possible_cpu(cpu)
673	decs += per_cpu_ptr(mod->refptr, cpu)->decs;
674	/*
675	* ensure the incs are added up after the decs.
676	* module_put ensures incs are visible before decs with smp_wmb.
677	*
678	* This 2-count scheme avoids the situation where the refcount
679	* for CPU0 is read, then CPU0 increments the module refcount,
680	* then CPU1 drops that refcount, then the refcount for CPU1 is
681	* read. We would record a decrement but not its corresponding
682	* increment so we would see a low count (disaster).
683	*
684	* Rare situation? But module_refcount can be preempted, and we
685	* might be tallying up 4096+ CPUs. So it is not impossible.
686	*/
687	smp_rmb();
688	for_each_possible_cpu(cpu)
689	incs += per_cpu_ptr(mod->refptr, cpu)->incs;
690	return incs - decs;
691	}
692	EXPORT_SYMBOL(module_refcount);
693
694	/* This exists whether we can unload or not */
695	static void free_module(struct module *mod);
696
697	static void wait_for_zero_refcount(struct module *mod)
698	{
699	/* Since we might sleep for some time, release the mutex first */
700	mutex_unlock(&module_mutex);
701	for (;;) {
702	DEBUGP("Looking at refcount...\n");
703	set_current_state(TASK_UNINTERRUPTIBLE);
704	if (module_refcount(mod) == 0)
705	break;
706	schedule();
707	}
708	current->state = TASK_RUNNING;
709	mutex_lock(&module_mutex);
710	}
711
712	SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
713	unsigned int, flags)
714	{
715	struct module *mod;
716	char name[MODULE_NAME_LEN];
717	int ret, forced = 0;
718
719	if (!capable(CAP_SYS_MODULE) \|\| modules_disabled)
720	return -EPERM;
721
722	if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
723	return -EFAULT;
724	name[MODULE_NAME_LEN-1] = '\0';
725
726	/* Create stop_machine threads since free_module relies on
727	* a non-failing stop_machine call. */
728	ret = stop_machine_create();
729	if (ret)
730	return ret;
731
732	if (mutex_lock_interruptible(&module_mutex) != 0) {
733	ret = -EINTR;
734	goto out_stop;
735	}
736
737	mod = find_module(name);
738	if (!mod) {
739	ret = -ENOENT;
740	goto out;
741	}
742
743	if (!list_empty(&mod->modules_which_use_me)) {
744	/* Other modules depend on us: get rid of them first. */
745	ret = -EWOULDBLOCK;
746	goto out;
747	}
748
749	/* Doing init or already dying? */
750	if (mod->state != MODULE_STATE_LIVE) {
751	/* FIXME: if (force), slam module count and wake up
752	waiter --RR */
753	DEBUGP("%s already dying\n", mod->name);
754	ret = -EBUSY;
755	goto out;
756	}
757
758	/* If it has an init func, it must have an exit func to unload */
759	if (mod->init && !mod->exit) {
760	forced = try_force_unload(flags);
761	if (!forced) {
762	/* This module can't be removed */
763	ret = -EBUSY;
764	goto out;
765	}
766	}
767
768	/* Set this up before setting mod->state */
769	mod->waiter = current;
770
771	/* Stop the machine so refcounts can't move and disable module. */
772	ret = try_stop_module(mod, flags, &forced);
773	if (ret != 0)
774	goto out;
775
776	/* Never wait if forced. */
777	if (!forced && module_refcount(mod) != 0)
778	wait_for_zero_refcount(mod);
779
780	mutex_unlock(&module_mutex);
781	/* Final destruction now noone is using it. */
782	if (mod->exit != NULL)
783	mod->exit();
784	blocking_notifier_call_chain(&module_notify_list,
785	MODULE_STATE_GOING, mod);
786	async_synchronize_full();
787	mutex_lock(&module_mutex);
788	/* Store the name of the last unloaded module for diagnostic purposes */
789	strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
790	ddebug_remove_module(mod->name);
791	free_module(mod);
792
793	out:
794	mutex_unlock(&module_mutex);
795	out_stop:
796	stop_machine_destroy();
797	return ret;
798	}
799
800	static inline void print_unload_info(struct seq_file m, struct module mod)
801	{
802	struct module_use *use;
803	int printed_something = 0;
804
805	seq_printf(m, " %u ", module_refcount(mod));
806
807	/* Always include a trailing , so userspace can differentiate
808	between this and the old multi-field proc format. */
809	list_for_each_entry(use, &mod->modules_which_use_me, list) {
810	printed_something = 1;
811	seq_printf(m, "%s,", use->module_which_uses->name);
812	}
813
814	if (mod->init != NULL && mod->exit == NULL) {
815	printed_something = 1;
816	seq_printf(m, "[permanent],");
817	}
818
819	if (!printed_something)
820	seq_printf(m, "-");
821	}
822
823	void __symbol_put(const char *symbol)
824	{
825	struct module *owner;
826
827	preempt_disable();
828	if (!find_symbol(symbol, &owner, NULL, true, false))
829	BUG();
830	module_put(owner);
831	preempt_enable();
832	}
833	EXPORT_SYMBOL(__symbol_put);
834
835	/* Note this assumes addr is a function, which it currently always is. */
836	void symbol_put_addr(void *addr)
837	{
838	struct module *modaddr;
839	unsigned long a = (unsigned long)dereference_function_descriptor(addr);
840
841	if (core_kernel_text(a))
842	return;
843
844	/* module_text_address is safe here: we're supposed to have reference
845	* to module from symbol_get, so it can't go away. */
846	modaddr = __module_text_address(a);
847	BUG_ON(!modaddr);
848	module_put(modaddr);
849	}
850	EXPORT_SYMBOL_GPL(symbol_put_addr);
851
852	static ssize_t show_refcnt(struct module_attribute *mattr,
853	struct module mod, char buffer)
854	{
855	return sprintf(buffer, "%u\n", module_refcount(mod));
856	}
857
858	static struct module_attribute refcnt = {
859	.attr = { .name = "refcnt", .mode = 0444 },
860	.show = show_refcnt,
861	};
862
863	void module_put(struct module *module)
864	{
865	if (module) {
866	preempt_disable();
867	smp_wmb(); /* see comment in module_refcount */
868	__this_cpu_inc(module->refptr->decs);
869
870	trace_module_put(module, _RET_IP_,
871	__this_cpu_read(module->refptr->decs));
872	/* Maybe they're waiting for us to drop reference? */
873	if (unlikely(!module_is_live(module)))
874	wake_up_process(module->waiter);
875	preempt_enable();
876	}
877	}
878	EXPORT_SYMBOL(module_put);
879
880	#else /* !CONFIG_MODULE_UNLOAD */
881	static inline void print_unload_info(struct seq_file m, struct module mod)
882	{
883	/* We don't know the usage count, or what modules are using. */
884	seq_printf(m, " - -");
885	}
886
887	static inline void module_unload_free(struct module *mod)
888	{
889	}
890
891	int use_module(struct module a, struct module b)
892	{
893	return strong_try_module_get(b) == 0;
894	}
895	EXPORT_SYMBOL_GPL(use_module);
896
897	static inline void module_unload_init(struct module *mod)
898	{
899	}
900	#endif /* CONFIG_MODULE_UNLOAD */
901
902	static ssize_t show_initstate(struct module_attribute *mattr,
903	struct module mod, char buffer)
904	{
905	const char *state = "unknown";
906
907	switch (mod->state) {
908	case MODULE_STATE_LIVE:
909	state = "live";
910	break;
911	case MODULE_STATE_COMING:
912	state = "coming";
913	break;
914	case MODULE_STATE_GOING:
915	state = "going";
916	break;
917	}
918	return sprintf(buffer, "%s\n", state);
919	}
920
921	static struct module_attribute initstate = {
922	.attr = { .name = "initstate", .mode = 0444 },
923	.show = show_initstate,
924	};
925
926	static struct module_attribute *modinfo_attrs[] = {
927	&modinfo_version,
928	&modinfo_srcversion,
929	&initstate,
930	#ifdef CONFIG_MODULE_UNLOAD
931	&refcnt,
932	#endif
933	NULL,
934	};
935
936	static const char vermagic[] = VERMAGIC_STRING;
937
938	static int try_to_force_load(struct module mod, const char reason)
939	{
940	#ifdef CONFIG_MODULE_FORCE_LOAD
941	if (!test_taint(TAINT_FORCED_MODULE))
942	printk(KERN_WARNING "%s: %s: kernel tainted.\n",
943	mod->name, reason);
944	add_taint_module(mod, TAINT_FORCED_MODULE);
945	return 0;
946	#else
947	return -ENOEXEC;
948	#endif
949	}
950
951	#ifdef CONFIG_MODVERSIONS
952	/* If the arch applies (non-zero) relocations to kernel kcrctab, unapply it. */
953	static unsigned long maybe_relocated(unsigned long crc,
954	const struct module *crc_owner)
955	{
956	#ifdef ARCH_RELOCATES_KCRCTAB
957	if (crc_owner == NULL)
958	return crc - (unsigned long)reloc_start;
959	#endif
960	return crc;
961	}
962
963	static int check_version(Elf_Shdr *sechdrs,
964	unsigned int versindex,
965	const char *symname,
966	struct module *mod,
967	const unsigned long *crc,
968	const struct module *crc_owner)
969	{
970	unsigned int i, num_versions;
971	struct modversion_info *versions;
972
973	/* Exporting module didn't supply crcs? OK, we're already tainted. */
974	if (!crc)
975	return 1;
976
977	/* No versions at all? modprobe --force does this. */
978	if (versindex == 0)
979	return try_to_force_load(mod, symname) == 0;
980
981	versions = (void *) sechdrs[versindex].sh_addr;
982	num_versions = sechdrs[versindex].sh_size
983	/ sizeof(struct modversion_info);
984
985	for (i = 0; i < num_versions; i++) {
986	if (strcmp(versions[i].name, symname) != 0)
987	continue;
988
989	if (versions[i].crc == maybe_relocated(*crc, crc_owner))
990	return 1;
991	DEBUGP("Found checksum %lX vs module %lX\n",
992	maybe_relocated(*crc, crc_owner), versions[i].crc);
993	goto bad_version;
994	}
995
996	printk(KERN_WARNING "%s: no symbol version for %s\n",
997	mod->name, symname);
998	return 0;
999
1000	bad_version:
1001	printk("%s: disagrees about version of symbol %s\n",
1002	mod->name, symname);
1003	return 0;
1004	}
1005
1006	static inline int check_modstruct_version(Elf_Shdr *sechdrs,
1007	unsigned int versindex,
1008	struct module *mod)
1009	{
1010	const unsigned long *crc;
1011
1012	if (!find_symbol(MODULE_SYMBOL_PREFIX "module_layout", NULL,
1013	&crc, true, false))
1014	BUG();
1015	return check_version(sechdrs, versindex, "module_layout", mod, crc,
1016	NULL);
1017	}
1018
1019	/* First part is kernel version, which we ignore if module has crcs. */
1020	static inline int same_magic(const char amagic, const char bmagic,
1021	bool has_crcs)
1022	{
1023	if (has_crcs) {
1024	amagic += strcspn(amagic, " ");
1025	bmagic += strcspn(bmagic, " ");
1026	}
1027	return strcmp(amagic, bmagic) == 0;
1028	}
1029	#else
1030	static inline int check_version(Elf_Shdr *sechdrs,
1031	unsigned int versindex,
1032	const char *symname,
1033	struct module *mod,
1034	const unsigned long *crc,
1035	const struct module *crc_owner)
1036	{
1037	return 1;
1038	}
1039
1040	static inline int check_modstruct_version(Elf_Shdr *sechdrs,
1041	unsigned int versindex,
1042	struct module *mod)
1043	{
1044	return 1;
1045	}
1046
1047	static inline int same_magic(const char amagic, const char bmagic,
1048	bool has_crcs)
1049	{
1050	return strcmp(amagic, bmagic) == 0;
1051	}
1052	#endif /* CONFIG_MODVERSIONS */
1053
1054	/* Resolve a symbol for this module. I.e. if we find one, record usage.
1055	Must be holding module_mutex. */
1056	static const struct kernel_symbol resolve_symbol(Elf_Shdr sechdrs,
1057	unsigned int versindex,
1058	const char *name,
1059	struct module *mod)
1060	{
1061	struct module *owner;
1062	const struct kernel_symbol *sym;
1063	const unsigned long *crc;
1064
1065	sym = find_symbol(name, &owner, &crc,
1066	!(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
1067	/* use_module can fail due to OOM,
1068	or module initialization or unloading */
1069	if (sym) {
1070	if (!check_version(sechdrs, versindex, name, mod, crc, owner)
1071	\|\| !use_module(mod, owner))
1072	sym = NULL;
1073	}
1074	return sym;
1075	}
1076
1077	/*
1078	* /sys/module/foo/sections stuff
1079	* J. Corbet <corbet@lwn.net>
1080	*/
1081	#if defined(CONFIG_KALLSYMS) && defined(CONFIG_SYSFS)
1082
1083	static inline bool sect_empty(const Elf_Shdr *sect)
1084	{
1085	return !(sect->sh_flags & SHF_ALLOC) \|\| sect->sh_size == 0;
1086	}
1087
1088	struct module_sect_attr
1089	{
1090	struct module_attribute mattr;
1091	char *name;
1092	unsigned long address;
1093	};
1094
1095	struct module_sect_attrs
1096	{
1097	struct attribute_group grp;
1098	unsigned int nsections;
1099	struct module_sect_attr attrs[0];
1100	};
1101
1102	static ssize_t module_sect_show(struct module_attribute *mattr,
1103	struct module mod, char buf)
1104	{
1105	struct module_sect_attr *sattr =
1106	container_of(mattr, struct module_sect_attr, mattr);
1107	return sprintf(buf, "0x%lx\n", sattr->address);
1108	}
1109
1110	static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
1111	{
1112	unsigned int section;
1113
1114	for (section = 0; section < sect_attrs->nsections; section++)
1115	kfree(sect_attrs->attrs[section].name);
1116	kfree(sect_attrs);
1117	}
1118
1119	static void add_sect_attrs(struct module *mod, unsigned int nsect,
1120	char secstrings, Elf_Shdr sechdrs)
1121	{
1122	unsigned int nloaded = 0, i, size[2];
1123	struct module_sect_attrs *sect_attrs;
1124	struct module_sect_attr *sattr;
1125	struct attribute **gattr;
1126
1127	/* Count loaded sections and allocate structures */
1128	for (i = 0; i < nsect; i++)
1129	if (!sect_empty(&sechdrs[i]))
1130	nloaded++;
1131	size[0] = ALIGN(sizeof(*sect_attrs)
1132	+ nloaded * sizeof(sect_attrs->attrs[0]),
1133	sizeof(sect_attrs->grp.attrs[0]));
1134	size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]);
1135	sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);
1136	if (sect_attrs == NULL)
1137	return;
1138
1139	/* Setup section attributes. */
1140	sect_attrs->grp.name = "sections";
1141	sect_attrs->grp.attrs = (void *)sect_attrs + size[0];
1142
1143	sect_attrs->nsections = 0;
1144	sattr = &sect_attrs->attrs[0];
1145	gattr = &sect_attrs->grp.attrs[0];
1146	for (i = 0; i < nsect; i++) {
1147	if (sect_empty(&sechdrs[i]))
1148	continue;
1149	sattr->address = sechdrs[i].sh_addr;
1150	sattr->name = kstrdup(secstrings + sechdrs[i].sh_name,
1151	GFP_KERNEL);
1152	if (sattr->name == NULL)
1153	goto out;
1154	sect_attrs->nsections++;
1155	sysfs_attr_init(&sattr->mattr.attr);
1156	sattr->mattr.show = module_sect_show;
1157	sattr->mattr.store = NULL;
1158	sattr->mattr.attr.name = sattr->name;
1159	sattr->mattr.attr.mode = S_IRUGO;
1160	*(gattr++) = &(sattr++)->mattr.attr;
1161	}
1162	*gattr = NULL;
1163
1164	if (sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp))
1165	goto out;
1166
1167	mod->sect_attrs = sect_attrs;
1168	return;
1169	out:
1170	free_sect_attrs(sect_attrs);
1171	}
1172
1173	static void remove_sect_attrs(struct module *mod)
1174	{
1175	if (mod->sect_attrs) {
1176	sysfs_remove_group(&mod->mkobj.kobj,
1177	&mod->sect_attrs->grp);
1178	/* We are positive that no one is using any sect attrs
1179	* at this point. Deallocate immediately. */
1180	free_sect_attrs(mod->sect_attrs);
1181	mod->sect_attrs = NULL;
1182	}
1183	}
1184
1185	/*
1186	* /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
1187	*/
1188
1189	struct module_notes_attrs {
1190	struct kobject *dir;
1191	unsigned int notes;
1192	struct bin_attribute attrs[0];
1193	};
1194
1195	static ssize_t module_notes_read(struct kobject *kobj,
1196	struct bin_attribute *bin_attr,
1197	char *buf, loff_t pos, size_t count)
1198	{
1199	/*
1200	* The caller checked the pos and count against our size.
1201	*/
1202	memcpy(buf, bin_attr->private + pos, count);
1203	return count;
1204	}
1205
1206	static void free_notes_attrs(struct module_notes_attrs *notes_attrs,
1207	unsigned int i)
1208	{
1209	if (notes_attrs->dir) {
1210	while (i-- > 0)
1211	sysfs_remove_bin_file(notes_attrs->dir,
1212	&notes_attrs->attrs[i]);
1213	kobject_put(notes_attrs->dir);
1214	}
1215	kfree(notes_attrs);
1216	}
1217
1218	static void add_notes_attrs(struct module *mod, unsigned int nsect,
1219	char secstrings, Elf_Shdr sechdrs)
1220	{
1221	unsigned int notes, loaded, i;
1222	struct module_notes_attrs *notes_attrs;
1223	struct bin_attribute *nattr;
1224
1225	/* failed to create section attributes, so can't create notes */
1226	if (!mod->sect_attrs)
1227	return;
1228
1229	/* Count notes sections and allocate structures. */
1230	notes = 0;
1231	for (i = 0; i < nsect; i++)
1232	if (!sect_empty(&sechdrs[i]) &&
1233	(sechdrs[i].sh_type == SHT_NOTE))
1234	++notes;
1235
1236	if (notes == 0)
1237	return;
1238
1239	notes_attrs = kzalloc(sizeof(*notes_attrs)
1240	+ notes * sizeof(notes_attrs->attrs[0]),
1241	GFP_KERNEL);
1242	if (notes_attrs == NULL)
1243	return;
1244
1245	notes_attrs->notes = notes;
1246	nattr = &notes_attrs->attrs[0];
1247	for (loaded = i = 0; i < nsect; ++i) {
1248	if (sect_empty(&sechdrs[i]))
1249	continue;
1250	if (sechdrs[i].sh_type == SHT_NOTE) {
1251	sysfs_bin_attr_init(nattr);
1252	nattr->attr.name = mod->sect_attrs->attrs[loaded].name;
1253	nattr->attr.mode = S_IRUGO;
1254	nattr->size = sechdrs[i].sh_size;
1255	nattr->private = (void *) sechdrs[i].sh_addr;
1256	nattr->read = module_notes_read;
1257	++nattr;
1258	}
1259	++loaded;
1260	}
1261
1262	notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);
1263	if (!notes_attrs->dir)
1264	goto out;
1265
1266	for (i = 0; i < notes; ++i)
1267	if (sysfs_create_bin_file(notes_attrs->dir,
1268	&notes_attrs->attrs[i]))
1269	goto out;
1270
1271	mod->notes_attrs = notes_attrs;
1272	return;
1273
1274	out:
1275	free_notes_attrs(notes_attrs, i);
1276	}
1277
1278	static void remove_notes_attrs(struct module *mod)
1279	{
1280	if (mod->notes_attrs)
1281	free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);
1282	}
1283
1284	#else
1285
1286	static inline void add_sect_attrs(struct module *mod, unsigned int nsect,
1287	char sectstrings, Elf_Shdr sechdrs)
1288	{
1289	}
1290
1291	static inline void remove_sect_attrs(struct module *mod)
1292	{
1293	}
1294
1295	static inline void add_notes_attrs(struct module *mod, unsigned int nsect,
1296	char sectstrings, Elf_Shdr sechdrs)
1297	{
1298	}
1299
1300	static inline void remove_notes_attrs(struct module *mod)
1301	{
1302	}
1303	#endif
1304
1305	#ifdef CONFIG_SYSFS
1306	int module_add_modinfo_attrs(struct module *mod)
1307	{
1308	struct module_attribute *attr;
1309	struct module_attribute *temp_attr;
1310	int error = 0;
1311	int i;
1312
1313	mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *
1314	(ARRAY_SIZE(modinfo_attrs) + 1)),
1315	GFP_KERNEL);
1316	if (!mod->modinfo_attrs)
1317	return -ENOMEM;
1318
1319	temp_attr = mod->modinfo_attrs;
1320	for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) {
1321	if (!attr->test \|\|
1322	(attr->test && attr->test(mod))) {
1323	memcpy(temp_attr, attr, sizeof(*temp_attr));
1324	sysfs_attr_init(&temp_attr->attr);
1325	error = sysfs_create_file(&mod->mkobj.kobj,&temp_attr->attr);
1326	++temp_attr;
1327	}
1328	}
1329	return error;
1330	}
1331
1332	void module_remove_modinfo_attrs(struct module *mod)
1333	{
1334	struct module_attribute *attr;
1335	int i;
1336
1337	for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {
1338	/* pick a field to test for end of list */
1339	if (!attr->attr.name)
1340	break;
1341	sysfs_remove_file(&mod->mkobj.kobj,&attr->attr);
1342	if (attr->free)
1343	attr->free(mod);
1344	}
1345	kfree(mod->modinfo_attrs);
1346	}
1347
1348	int mod_sysfs_init(struct module *mod)
1349	{
1350	int err;
1351	struct kobject *kobj;
1352
1353	if (!module_sysfs_initialized) {
1354	printk(KERN_ERR "%s: module sysfs not initialized\n",
1355	mod->name);
1356	err = -EINVAL;
1357	goto out;
1358	}
1359
1360	kobj = kset_find_obj(module_kset, mod->name);
1361	if (kobj) {
1362	printk(KERN_ERR "%s: module is already loaded\n", mod->name);
1363	kobject_put(kobj);
1364	err = -EINVAL;
1365	goto out;
1366	}
1367
1368	mod->mkobj.mod = mod;
1369
1370	memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
1371	mod->mkobj.kobj.kset = module_kset;
1372	err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
1373	"%s", mod->name);
1374	if (err)
1375	kobject_put(&mod->mkobj.kobj);
1376
1377	/* delay uevent until full sysfs population */
1378	out:
1379	return err;
1380	}
1381
1382	int mod_sysfs_setup(struct module *mod,
1383	struct kernel_param *kparam,
1384	unsigned int num_params)
1385	{
1386	int err;
1387
1388	mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);
1389	if (!mod->holders_dir) {
1390	err = -ENOMEM;
1391	goto out_unreg;
1392	}
1393
1394	err = module_param_sysfs_setup(mod, kparam, num_params);
1395	if (err)
1396	goto out_unreg_holders;
1397
1398	err = module_add_modinfo_attrs(mod);
1399	if (err)
1400	goto out_unreg_param;
1401
1402	kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
1403	return 0;
1404
1405	out_unreg_param:
1406	module_param_sysfs_remove(mod);
1407	out_unreg_holders:
1408	kobject_put(mod->holders_dir);
1409	out_unreg:
1410	kobject_put(&mod->mkobj.kobj);
1411	return err;
1412	}
1413
1414	static void mod_sysfs_fini(struct module *mod)
1415	{
1416	kobject_put(&mod->mkobj.kobj);
1417	}
1418
1419	#else /* CONFIG_SYSFS */
1420
1421	static void mod_sysfs_fini(struct module *mod)
1422	{
1423	}
1424
1425	#endif /* CONFIG_SYSFS */
1426
1427	static void mod_kobject_remove(struct module *mod)
1428	{
1429	module_remove_modinfo_attrs(mod);
1430	module_param_sysfs_remove(mod);
1431	kobject_put(mod->mkobj.drivers_dir);
1432	kobject_put(mod->holders_dir);
1433	mod_sysfs_fini(mod);
1434	}
1435
1436	/*
1437	* unlink the module with the whole machine is stopped with interrupts off
1438	* - this defends against kallsyms not taking locks
1439	*/
1440	static int __unlink_module(void *_mod)
1441	{
1442	struct module *mod = _mod;
1443	list_del(&mod->list);
1444	return 0;
1445	}
1446
1447	/* Free a module, remove from lists, etc (must hold module_mutex). */
1448	static void free_module(struct module *mod)
1449	{
1450	trace_module_free(mod);
1451
1452	/* Delete from various lists */
1453	stop_machine(__unlink_module, mod, NULL);
1454	remove_notes_attrs(mod);
1455	remove_sect_attrs(mod);
1456	mod_kobject_remove(mod);
1457
1458	/* Arch-specific cleanup. */
1459	module_arch_cleanup(mod);
1460
1461	/* Module unload stuff */
1462	module_unload_free(mod);
1463
1464	/* Free any allocated parameters. */
1465	destroy_params(mod->kp, mod->num_kp);
1466
1467	/* This may be NULL, but that's OK */
1468	module_free(mod, mod->module_init);
1469	kfree(mod->args);
1470	percpu_modfree(mod);
1471	#if defined(CONFIG_MODULE_UNLOAD)
1472	if (mod->refptr)
1473	free_percpu(mod->refptr);
1474	#endif
1475	/* Free lock-classes: */
1476	lockdep_free_key_range(mod->module_core, mod->core_size);
1477
1478	/* Finally, free the core (containing the module structure) */
1479	module_free(mod, mod->module_core);
1480
1481	#ifdef CONFIG_MPU
1482	update_protections(current->mm);
1483	#endif
1484	}
1485
1486	void __symbol_get(const char symbol)
1487	{
1488	struct module *owner;
1489	const struct kernel_symbol *sym;
1490
1491	preempt_disable();
1492	sym = find_symbol(symbol, &owner, NULL, true, true);
1493	if (sym && strong_try_module_get(owner))
1494	sym = NULL;
1495	preempt_enable();
1496
1497	return sym ? (void *)sym->value : NULL;
1498	}
1499	EXPORT_SYMBOL_GPL(__symbol_get);
1500
1501	/*
1502	* Ensure that an exported symbol [global namespace] does not already exist
1503	* in the kernel or in some other module's exported symbol table.
1504	*/
1505	static int verify_export_symbols(struct module *mod)
1506	{
1507	unsigned int i;
1508	struct module *owner;
1509	const struct kernel_symbol *s;
1510	struct {
1511	const struct kernel_symbol *sym;
1512	unsigned int num;
1513	} arr[] = {
1514	{ mod->syms, mod->num_syms },
1515	{ mod->gpl_syms, mod->num_gpl_syms },
1516	{ mod->gpl_future_syms, mod->num_gpl_future_syms },
1517	#ifdef CONFIG_UNUSED_SYMBOLS
1518	{ mod->unused_syms, mod->num_unused_syms },
1519	{ mod->unused_gpl_syms, mod->num_unused_gpl_syms },
1520	#endif
1521	};
1522
1523	for (i = 0; i < ARRAY_SIZE(arr); i++) {
1524	for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) {
1525	if (find_symbol(s->name, &owner, NULL, true, false)) {
1526	printk(KERN_ERR
1527	"%s: exports duplicate symbol %s"
1528	" (owned by %s)\n",
1529	mod->name, s->name, module_name(owner));
1530	return -ENOEXEC;
1531	}
1532	}
1533	}
1534	return 0;
1535	}
1536
1537	/* Change all symbols so that st_value encodes the pointer directly. */
1538	static int simplify_symbols(Elf_Shdr *sechdrs,
1539	unsigned int symindex,
1540	const char *strtab,
1541	unsigned int versindex,
1542	unsigned int pcpuindex,
1543	struct module *mod)
1544	{
1545	Elf_Sym sym = (void )sechdrs[symindex].sh_addr;
1546	unsigned long secbase;
1547	unsigned int i, n = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
1548	int ret = 0;
1549	const struct kernel_symbol *ksym;
1550
1551	for (i = 1; i < n; i++) {
1552	switch (sym[i].st_shndx) {
1553	case SHN_COMMON:
1554	/* We compiled with -fno-common. These are not
1555	supposed to happen. */
1556	DEBUGP("Common symbol: %s\n", strtab + sym[i].st_name);
1557	printk("%s: please compile with -fno-common\n",
1558	mod->name);
1559	ret = -ENOEXEC;
1560	break;
1561
1562	case SHN_ABS:
1563	/* Don't need to do anything */
1564	DEBUGP("Absolute symbol: 0x%08lx\n",
1565	(long)sym[i].st_value);
1566	break;
1567
1568	case SHN_UNDEF:
1569	ksym = resolve_symbol(sechdrs, versindex,
1570	strtab + sym[i].st_name, mod);
1571	/* Ok if resolved. */
1572	if (ksym) {
1573	sym[i].st_value = ksym->value;
1574	break;
1575	}
1576
1577	/* Ok if weak. */
1578	if (ELF_ST_BIND(sym[i].st_info) == STB_WEAK)
1579	break;
1580
1581	printk(KERN_WARNING "%s: Unknown symbol %s\n",
1582	mod->name, strtab + sym[i].st_name);
1583	ret = -ENOENT;
1584	break;
1585
1586	default:
1587	/* Divert to percpu allocation if a percpu var. */
1588	if (sym[i].st_shndx == pcpuindex)
1589	secbase = (unsigned long)mod_percpu(mod);
1590	else
1591	secbase = sechdrs[sym[i].st_shndx].sh_addr;
1592	sym[i].st_value += secbase;
1593	break;
1594	}
1595	}
1596
1597	return ret;
1598	}
1599
1600	/* Additional bytes needed by arch in front of individual sections */
1601	unsigned int __weak arch_mod_section_prepend(struct module *mod,
1602	unsigned int section)
1603	{
1604	/* default implementation just returns zero */
1605	return 0;
1606	}
1607
1608	/* Update size with this section: return offset. */
1609	static long get_offset(struct module mod, unsigned int size,
1610	Elf_Shdr *sechdr, unsigned int section)
1611	{
1612	long ret;
1613
1614	*size += arch_mod_section_prepend(mod, section);
1615	ret = ALIGN(*size, sechdr->sh_addralign ?: 1);
1616	*size = ret + sechdr->sh_size;
1617	return ret;
1618	}
1619
1620	/* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld
1621	might -- code, read-only data, read-write data, small data. Tally
1622	sizes, and place the offsets into sh_entsize fields: high bit means it
1623	belongs in init. */
1624	static void layout_sections(struct module *mod,
1625	const Elf_Ehdr *hdr,
1626	Elf_Shdr *sechdrs,
1627	const char *secstrings)
1628	{
1629	static unsigned long const masks[][2] = {
1630	/* NOTE: all executable code must be the first section
1631	* in this array; otherwise modify the text_size
1632	* finder in the two loops below */
1633	{ SHF_EXECINSTR \| SHF_ALLOC, ARCH_SHF_SMALL },
1634	{ SHF_ALLOC, SHF_WRITE \| ARCH_SHF_SMALL },
1635	{ SHF_WRITE \| SHF_ALLOC, ARCH_SHF_SMALL },
1636	{ ARCH_SHF_SMALL \| SHF_ALLOC, 0 }
1637	};
1638	unsigned int m, i;
1639
1640	for (i = 0; i < hdr->e_shnum; i++)
1641	sechdrs[i].sh_entsize = ~0UL;
1642
1643	DEBUGP("Core section allocation order:\n");
1644	for (m = 0; m < ARRAY_SIZE(masks); ++m) {
1645	for (i = 0; i < hdr->e_shnum; ++i) {
1646	Elf_Shdr *s = &sechdrs[i];
1647
1648	if ((s->sh_flags & masks[m][0]) != masks[m][0]
1649	\|\| (s->sh_flags & masks[m][1])
1650	\|\| s->sh_entsize != ~0UL
1651	\|\| strstarts(secstrings + s->sh_name, ".init"))
1652	continue;
1653	s->sh_entsize = get_offset(mod, &mod->core_size, s, i);
1654	DEBUGP("\t%s\n", secstrings + s->sh_name);
1655	}
1656	if (m == 0)
1657	mod->core_text_size = mod->core_size;
1658	}
1659
1660	DEBUGP("Init section allocation order:\n");
1661	for (m = 0; m < ARRAY_SIZE(masks); ++m) {
1662	for (i = 0; i < hdr->e_shnum; ++i) {
1663	Elf_Shdr *s = &sechdrs[i];
1664
1665	if ((s->sh_flags & masks[m][0]) != masks[m][0]
1666	\|\| (s->sh_flags & masks[m][1])
1667	\|\| s->sh_entsize != ~0UL
1668	\|\| !strstarts(secstrings + s->sh_name, ".init"))
1669	continue;
1670	s->sh_entsize = (get_offset(mod, &mod->init_size, s, i)
1671	\| INIT_OFFSET_MASK);
1672	DEBUGP("\t%s\n", secstrings + s->sh_name);
1673	}
1674	if (m == 0)
1675	mod->init_text_size = mod->init_size;
1676	}
1677	}
1678
1679	static void set_license(struct module mod, const char license)
1680	{
1681	if (!license)
1682	license = "unspecified";
1683
1684	if (!license_is_gpl_compatible(license)) {
1685	if (!test_taint(TAINT_PROPRIETARY_MODULE))
1686	printk(KERN_WARNING "%s: module license '%s' taints "
1687	"kernel.\n", mod->name, license);
1688	add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
1689	}
1690	}
1691
1692	/* Parse tag=value strings from .modinfo section */
1693	static char next_string(char string, unsigned long *secsize)
1694	{
1695	/* Skip non-zero chars */
1696	while (string[0]) {
1697	string++;
1698	if ((*secsize)-- <= 1)
1699	return NULL;
1700	}
1701
1702	/* Skip any zero padding. */
1703	while (!string[0]) {
1704	string++;
1705	if ((*secsize)-- <= 1)
1706	return NULL;
1707	}
1708	return string;
1709	}
1710
1711	static char get_modinfo(Elf_Shdr sechdrs,
1712	unsigned int info,
1713	const char *tag)
1714	{
1715	char *p;
1716	unsigned int taglen = strlen(tag);
1717	unsigned long size = sechdrs[info].sh_size;
1718
1719	for (p = (char *)sechdrs[info].sh_addr; p; p = next_string(p, &size)) {
1720	if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
1721	return p + taglen + 1;
1722	}
1723	return NULL;
1724	}
1725
1726	static void setup_modinfo(struct module mod, Elf_Shdr sechdrs,
1727	unsigned int infoindex)
1728	{
1729	struct module_attribute *attr;
1730	int i;
1731
1732	for (i = 0; (attr = modinfo_attrs[i]); i++) {
1733	if (attr->setup)
1734	attr->setup(mod,
1735	get_modinfo(sechdrs,
1736	infoindex,
1737	attr->attr.name));
1738	}
1739	}
1740
1741	static void free_modinfo(struct module *mod)
1742	{
1743	struct module_attribute *attr;
1744	int i;
1745
1746	for (i = 0; (attr = modinfo_attrs[i]); i++) {
1747	if (attr->free)
1748	attr->free(mod);
1749	}
1750	}
1751
1752	#ifdef CONFIG_KALLSYMS
1753
1754	/* lookup symbol in given range of kernel_symbols */
1755	static const struct kernel_symbol lookup_symbol(const char name,
1756	const struct kernel_symbol *start,
1757	const struct kernel_symbol *stop)
1758	{
1759	const struct kernel_symbol *ks = start;
1760	for (; ks < stop; ks++)
1761	if (strcmp(ks->name, name) == 0)
1762	return ks;
1763	return NULL;
1764	}
1765
1766	static int is_exported(const char *name, unsigned long value,
1767	const struct module *mod)
1768	{
1769	const struct kernel_symbol *ks;
1770	if (!mod)
1771	ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab);
1772	else
1773	ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms);
1774	return ks != NULL && ks->value == value;
1775	}
1776
1777	/* As per nm */
1778	static char elf_type(const Elf_Sym *sym,
1779	Elf_Shdr *sechdrs,
1780	const char *secstrings,
1781	struct module *mod)
1782	{
1783	if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {
1784	if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)
1785	return 'v';
1786	else
1787	return 'w';
1788	}
1789	if (sym->st_shndx == SHN_UNDEF)
1790	return 'U';
1791	if (sym->st_shndx == SHN_ABS)
1792	return 'a';
1793	if (sym->st_shndx >= SHN_LORESERVE)
1794	return '?';
1795	if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR)
1796	return 't';
1797	if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC
1798	&& sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) {
1799	if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE))
1800	return 'r';
1801	else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
1802	return 'g';
1803	else
1804	return 'd';
1805	}
1806	if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) {
1807	if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
1808	return 's';
1809	else
1810	return 'b';
1811	}
1812	if (strstarts(secstrings + sechdrs[sym->st_shndx].sh_name, ".debug"))
1813	return 'n';
1814	return '?';
1815	}
1816
1817	static bool is_core_symbol(const Elf_Sym src, const Elf_Shdr sechdrs,
1818	unsigned int shnum)
1819	{
1820	const Elf_Shdr *sec;
1821
1822	if (src->st_shndx == SHN_UNDEF
1823	\|\| src->st_shndx >= shnum
1824	\|\| !src->st_name)
1825	return false;
1826
1827	sec = sechdrs + src->st_shndx;
1828	if (!(sec->sh_flags & SHF_ALLOC)
1829	#ifndef CONFIG_KALLSYMS_ALL
1830	\|\| !(sec->sh_flags & SHF_EXECINSTR)
1831	#endif
1832	\|\| (sec->sh_entsize & INIT_OFFSET_MASK))
1833	return false;
1834
1835	return true;
1836	}
1837
1838	static unsigned long layout_symtab(struct module *mod,
1839	Elf_Shdr *sechdrs,
1840	unsigned int symindex,
1841	unsigned int strindex,
1842	const Elf_Ehdr *hdr,
1843	const char *secstrings,
1844	unsigned long *pstroffs,
1845	unsigned long *strmap)
1846	{
1847	unsigned long symoffs;
1848	Elf_Shdr *symsect = sechdrs + symindex;
1849	Elf_Shdr *strsect = sechdrs + strindex;
1850	const Elf_Sym *src;
1851	const char *strtab;
1852	unsigned int i, nsrc, ndst;
1853
1854	/* Put symbol section at end of init part of module. */
1855	symsect->sh_flags \|= SHF_ALLOC;
1856	symsect->sh_entsize = get_offset(mod, &mod->init_size, symsect,
1857	symindex) \| INIT_OFFSET_MASK;
1858	DEBUGP("\t%s\n", secstrings + symsect->sh_name);
1859
1860	src = (void *)hdr + symsect->sh_offset;
1861	nsrc = symsect->sh_size / sizeof(*src);
1862	strtab = (void *)hdr + strsect->sh_offset;
1863	for (ndst = i = 1; i < nsrc; ++i, ++src)
1864	if (is_core_symbol(src, sechdrs, hdr->e_shnum)) {
1865	unsigned int j = src->st_name;
1866
1867	while(!__test_and_set_bit(j, strmap) && strtab[j])
1868	++j;
1869	++ndst;
1870	}
1871
1872	/* Append room for core symbols at end of core part. */
1873	symoffs = ALIGN(mod->core_size, symsect->sh_addralign ?: 1);
1874	mod->core_size = symoffs + ndst * sizeof(Elf_Sym);
1875
1876	/* Put string table section at end of init part of module. */
1877	strsect->sh_flags \|= SHF_ALLOC;
1878	strsect->sh_entsize = get_offset(mod, &mod->init_size, strsect,
1879	strindex) \| INIT_OFFSET_MASK;
1880	DEBUGP("\t%s\n", secstrings + strsect->sh_name);
1881
1882	/* Append room for core symbols' strings at end of core part. */
1883	*pstroffs = mod->core_size;
1884	__set_bit(0, strmap);
1885	mod->core_size += bitmap_weight(strmap, strsect->sh_size);
1886
1887	return symoffs;
1888	}
1889
1890	static void add_kallsyms(struct module *mod,
1891	Elf_Shdr *sechdrs,
1892	unsigned int shnum,
1893	unsigned int symindex,
1894	unsigned int strindex,
1895	unsigned long symoffs,
1896	unsigned long stroffs,
1897	const char *secstrings,
1898	unsigned long *strmap)
1899	{
1900	unsigned int i, ndst;
1901	const Elf_Sym *src;
1902	Elf_Sym *dst;
1903	char *s;
1904
1905	mod->symtab = (void *)sechdrs[symindex].sh_addr;
1906	mod->num_symtab = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
1907	mod->strtab = (void *)sechdrs[strindex].sh_addr;
1908
1909	/* Set types up while we still have access to sections. */
1910	for (i = 0; i < mod->num_symtab; i++)
1911	mod->symtab[i].st_info
1912	= elf_type(&mod->symtab[i], sechdrs, secstrings, mod);
1913
1914	mod->core_symtab = dst = mod->module_core + symoffs;
1915	src = mod->symtab;
1916	dst = src;
1917	for (ndst = i = 1; i < mod->num_symtab; ++i, ++src) {
1918	if (!is_core_symbol(src, sechdrs, shnum))
1919	continue;
1920	dst[ndst] = *src;
1921	dst[ndst].st_name = bitmap_weight(strmap, dst[ndst].st_name);
1922	++ndst;
1923	}
1924	mod->core_num_syms = ndst;
1925
1926	mod->core_strtab = s = mod->module_core + stroffs;
1927	for (*s = 0, i = 1; i < sechdrs[strindex].sh_size; ++i)
1928	if (test_bit(i, strmap))
1929	*++s = mod->strtab[i];
1930	}
1931	#else
1932	static inline unsigned long layout_symtab(struct module *mod,
1933	Elf_Shdr *sechdrs,
1934	unsigned int symindex,
1935	unsigned int strindex,
1936	const Elf_Ehdr *hdr,
1937	const char *secstrings,
1938	unsigned long *pstroffs,
1939	unsigned long *strmap)
1940	{
1941	return 0;
1942	}
1943
1944	static inline void add_kallsyms(struct module *mod,
1945	Elf_Shdr *sechdrs,
1946	unsigned int shnum,
1947	unsigned int symindex,
1948	unsigned int strindex,
1949	unsigned long symoffs,
1950	unsigned long stroffs,
1951	const char *secstrings,
1952	const unsigned long *strmap)
1953	{
1954	}
1955	#endif /* CONFIG_KALLSYMS */
1956
1957	static void dynamic_debug_setup(struct _ddebug *debug, unsigned int num)
1958	{
1959	#ifdef CONFIG_DYNAMIC_DEBUG
1960	if (ddebug_add_module(debug, num, debug->modname))
1961	printk(KERN_ERR "dynamic debug error adding module: %s\n",
1962	debug->modname);
1963	#endif
1964	}
1965
1966	static void *module_alloc_update_bounds(unsigned long size)
1967	{
1968	void *ret = module_alloc(size);
1969
1970	if (ret) {
1971	/* Update module bounds. */
1972	if ((unsigned long)ret < module_addr_min)
1973	module_addr_min = (unsigned long)ret;
1974	if ((unsigned long)ret + size > module_addr_max)
1975	module_addr_max = (unsigned long)ret + size;
1976	}
1977	return ret;
1978	}
1979
1980	#ifdef CONFIG_DEBUG_KMEMLEAK
1981	static void kmemleak_load_module(struct module mod, Elf_Ehdr hdr,
1982	Elf_Shdr sechdrs, char secstrings)
1983	{
1984	unsigned int i;
1985
1986	/* only scan the sections containing data */
1987	kmemleak_scan_area(mod, sizeof(struct module), GFP_KERNEL);
1988
1989	for (i = 1; i < hdr->e_shnum; i++) {
1990	if (!(sechdrs[i].sh_flags & SHF_ALLOC))
1991	continue;
1992	if (strncmp(secstrings + sechdrs[i].sh_name, ".data", 5) != 0
1993	&& strncmp(secstrings + sechdrs[i].sh_name, ".bss", 4) != 0)
1994	continue;
1995
1996	kmemleak_scan_area((void *)sechdrs[i].sh_addr,
1997	sechdrs[i].sh_size, GFP_KERNEL);
1998	}
1999	}
2000	#else
2001	static inline void kmemleak_load_module(struct module mod, Elf_Ehdr hdr,
2002	Elf_Shdr sechdrs, char secstrings)
2003	{
2004	}
2005	#endif
2006
2007	/* Allocate and load the module: note that size of section 0 is always
2008	zero, and we rely on this for optional sections. */
2009	static noinline struct module load_module(void __user umod,
2010	unsigned long len,
2011	const char __user *uargs)
2012	{
2013	Elf_Ehdr *hdr;
2014	Elf_Shdr *sechdrs;
2015	char secstrings, args, modmagic, strtab = NULL;
2016	char *staging;
2017	unsigned int i;
2018	unsigned int symindex = 0;
2019	unsigned int strindex = 0;
2020	unsigned int modindex, versindex, infoindex, pcpuindex;
2021	struct module *mod;
2022	long err = 0;
2023	void ptr = NULL; / Stops spurious gcc warning */
2024	unsigned long symoffs, stroffs, *strmap;
2025
2026	mm_segment_t old_fs;
2027
2028	DEBUGP("load_module: umod=%p, len=%lu, uargs=%p\n",
2029	umod, len, uargs);
2030	if (len < sizeof(*hdr))
2031	return ERR_PTR(-ENOEXEC);
2032
2033	/* Suck in entire file: we'll want most of it. */
2034	/* vmalloc barfs on "unusual" numbers. Check here */
2035	if (len > 64 * 1024 * 1024 \|\| (hdr = vmalloc(len)) == NULL)
2036	return ERR_PTR(-ENOMEM);
2037
2038	if (copy_from_user(hdr, umod, len) != 0) {
2039	err = -EFAULT;
2040	goto free_hdr;
2041	}
2042
2043	/* Sanity checks against insmoding binaries or wrong arch,
2044	weird elf version */
2045	if (memcmp(hdr->e_ident, ELFMAG, SELFMAG) != 0
2046	\|\| hdr->e_type != ET_REL
2047	\|\| !elf_check_arch(hdr)
2048	\|\| hdr->e_shentsize != sizeof(*sechdrs)) {
2049	err = -ENOEXEC;
2050	goto free_hdr;
2051	}
2052
2053	if (len < hdr->e_shoff + hdr->e_shnum * sizeof(Elf_Shdr))
2054	goto truncated;
2055
2056	/* Convenience variables */
2057	sechdrs = (void *)hdr + hdr->e_shoff;
2058	secstrings = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
2059	sechdrs[0].sh_addr = 0;
2060
2061	for (i = 1; i < hdr->e_shnum; i++) {
2062	if (sechdrs[i].sh_type != SHT_NOBITS
2063	&& len < sechdrs[i].sh_offset + sechdrs[i].sh_size)
2064	goto truncated;
2065
2066	/* Mark all sections sh_addr with their address in the
2067	temporary image. */
2068	sechdrs[i].sh_addr = (size_t)hdr + sechdrs[i].sh_offset;
2069
2070	/* Internal symbols and strings. */
2071	if (sechdrs[i].sh_type == SHT_SYMTAB) {
2072	symindex = i;
2073	strindex = sechdrs[i].sh_link;
2074	strtab = (char *)hdr + sechdrs[strindex].sh_offset;
2075	}
2076	#ifndef CONFIG_MODULE_UNLOAD
2077	/* Don't load .exit sections */
2078	if (strstarts(secstrings+sechdrs[i].sh_name, ".exit"))
2079	sechdrs[i].sh_flags &= ~(unsigned long)SHF_ALLOC;
2080	#endif
2081	}
2082
2083	modindex = find_sec(hdr, sechdrs, secstrings,
2084	".gnu.linkonce.this_module");
2085	if (!modindex) {
2086	printk(KERN_WARNING "No module found in object\n");
2087	err = -ENOEXEC;
2088	goto free_hdr;
2089	}
2090	/* This is temporary: point mod into copy of data. */
2091	mod = (void *)sechdrs[modindex].sh_addr;
2092
2093	if (symindex == 0) {
2094	printk(KERN_WARNING "%s: module has no symbols (stripped?)\n",
2095	mod->name);
2096	err = -ENOEXEC;
2097	goto free_hdr;
2098	}
2099
2100	versindex = find_sec(hdr, sechdrs, secstrings, "__versions");
2101	infoindex = find_sec(hdr, sechdrs, secstrings, ".modinfo");
2102	pcpuindex = find_pcpusec(hdr, sechdrs, secstrings);
2103
2104	/* Don't keep modinfo and version sections. */
2105	sechdrs[infoindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
2106	sechdrs[versindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
2107
2108	/* Check module struct version now, before we try to use module. */
2109	if (!check_modstruct_version(sechdrs, versindex, mod)) {
2110	err = -ENOEXEC;
2111	goto free_hdr;
2112	}
2113
2114	modmagic = get_modinfo(sechdrs, infoindex, "vermagic");
2115	/* This is allowed: modprobe --force will invalidate it. */
2116	if (!modmagic) {
2117	err = try_to_force_load(mod, "bad vermagic");
2118	if (err)
2119	goto free_hdr;
2120	} else if (!same_magic(modmagic, vermagic, versindex)) {
2121	printk(KERN_ERR "%s: version magic '%s' should be '%s'\n",
2122	mod->name, modmagic, vermagic);
2123	err = -ENOEXEC;
2124	goto free_hdr;
2125	}
2126
2127	staging = get_modinfo(sechdrs, infoindex, "staging");
2128	if (staging) {
2129	add_taint_module(mod, TAINT_CRAP);
2130	printk(KERN_WARNING "%s: module is from the staging directory,"
2131	" the quality is unknown, you have been warned.\n",
2132	mod->name);
2133	}
2134
2135	/* Now copy in args */
2136	args = strndup_user(uargs, ~0UL >> 1);
2137	if (IS_ERR(args)) {
2138	err = PTR_ERR(args);
2139	goto free_hdr;
2140	}
2141
2142	strmap = kzalloc(BITS_TO_LONGS(sechdrs[strindex].sh_size)
2143	* sizeof(long), GFP_KERNEL);
2144	if (!strmap) {
2145	err = -ENOMEM;
2146	goto free_mod;
2147	}
2148
2149	if (find_module(mod->name)) {
2150	err = -EEXIST;
2151	goto free_mod;
2152	}
2153
2154	mod->state = MODULE_STATE_COMING;
2155
2156	/* Allow arches to frob section contents and sizes. */
2157	err = module_frob_arch_sections(hdr, sechdrs, secstrings, mod);
2158	if (err < 0)
2159	goto free_mod;
2160
2161	if (pcpuindex) {
2162	/* We have a special allocation for this section. */
2163	err = percpu_modalloc(mod, sechdrs[pcpuindex].sh_size,
2164	sechdrs[pcpuindex].sh_addralign);
2165	if (err)
2166	goto free_mod;
2167	sechdrs[pcpuindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
2168	}
2169
2170	/* Determine total sizes, and put offsets in sh_entsize. For now
2171	this is done generically; there doesn't appear to be any
2172	special cases for the architectures. */
2173	layout_sections(mod, hdr, sechdrs, secstrings);
2174	symoffs = layout_symtab(mod, sechdrs, symindex, strindex, hdr,
2175	secstrings, &stroffs, strmap);
2176
2177	/* Do the allocs. */
2178	ptr = module_alloc_update_bounds(mod->core_size);
2179	/*
2180	* The pointer to this block is stored in the module structure
2181	* which is inside the block. Just mark it as not being a
2182	* leak.
2183	*/
2184	kmemleak_not_leak(ptr);
2185	if (!ptr) {
2186	err = -ENOMEM;
2187	goto free_percpu;
2188	}
2189	memset(ptr, 0, mod->core_size);
2190	mod->module_core = ptr;
2191
2192	ptr = module_alloc_update_bounds(mod->init_size);
2193	/*
2194	* The pointer to this block is stored in the module structure
2195	* which is inside the block. This block doesn't need to be
2196	* scanned as it contains data and code that will be freed
2197	* after the module is initialized.
2198	*/
2199	kmemleak_ignore(ptr);
2200	if (!ptr && mod->init_size) {
2201	err = -ENOMEM;
2202	goto free_core;
2203	}
2204	memset(ptr, 0, mod->init_size);
2205	mod->module_init = ptr;
2206
2207	/* Transfer each section which specifies SHF_ALLOC */
2208	DEBUGP("final section addresses:\n");
2209	for (i = 0; i < hdr->e_shnum; i++) {
2210	void *dest;
2211
2212	if (!(sechdrs[i].sh_flags & SHF_ALLOC))
2213	continue;
2214
2215	if (sechdrs[i].sh_entsize & INIT_OFFSET_MASK)
2216	dest = mod->module_init
2217	+ (sechdrs[i].sh_entsize & ~INIT_OFFSET_MASK);
2218	else
2219	dest = mod->module_core + sechdrs[i].sh_entsize;
2220
2221	if (sechdrs[i].sh_type != SHT_NOBITS)
2222	memcpy(dest, (void *)sechdrs[i].sh_addr,
2223	sechdrs[i].sh_size);
2224	/* Update sh_addr to point to copy in image. */
2225	sechdrs[i].sh_addr = (unsigned long)dest;
2226	DEBUGP("\t0x%lx %s\n", sechdrs[i].sh_addr, secstrings + sechdrs[i].sh_name);
2227	}
2228	/* Module has been moved. */
2229	mod = (void *)sechdrs[modindex].sh_addr;
2230	kmemleak_load_module(mod, hdr, sechdrs, secstrings);
2231
2232	#if defined(CONFIG_MODULE_UNLOAD)
2233	mod->refptr = alloc_percpu(struct module_ref);
2234	if (!mod->refptr) {
2235	err = -ENOMEM;
2236	goto free_init;
2237	}
2238	#endif
2239	/* Now we've moved module, initialize linked lists, etc. */
2240	module_unload_init(mod);
2241
2242	/* add kobject, so we can reference it. */
2243	err = mod_sysfs_init(mod);
2244	if (err)
2245	goto free_unload;
2246
2247	/* Set up license info based on the info section */
2248	set_license(mod, get_modinfo(sechdrs, infoindex, "license"));
2249
2250	/*
2251	* ndiswrapper is under GPL by itself, but loads proprietary modules.
2252	* Don't use add_taint_module(), as it would prevent ndiswrapper from
2253	* using GPL-only symbols it needs.
2254	*/
2255	if (strcmp(mod->name, "ndiswrapper") == 0)
2256	add_taint(TAINT_PROPRIETARY_MODULE);
2257
2258	/* driverloader was caught wrongly pretending to be under GPL */
2259	if (strcmp(mod->name, "driverloader") == 0)
2260	add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
2261
2262	/* Set up MODINFO_ATTR fields */
2263	setup_modinfo(mod, sechdrs, infoindex);
2264
2265	/* Fix up syms, so that st_value is a pointer to location. */
2266	err = simplify_symbols(sechdrs, symindex, strtab, versindex, pcpuindex,
2267	mod);
2268	if (err < 0)
2269	goto cleanup;
2270
2271	/* Now we've got everything in the final locations, we can
2272	* find optional sections. */
2273	mod->kp = section_objs(hdr, sechdrs, secstrings, "__param",
2274	sizeof(*mod->kp), &mod->num_kp);
2275	mod->syms = section_objs(hdr, sechdrs, secstrings, "__ksymtab",
2276	sizeof(*mod->syms), &mod->num_syms);
2277	mod->crcs = section_addr(hdr, sechdrs, secstrings, "__kcrctab");
2278	mod->gpl_syms = section_objs(hdr, sechdrs, secstrings, "__ksymtab_gpl",
2279	sizeof(*mod->gpl_syms),
2280	&mod->num_gpl_syms);
2281	mod->gpl_crcs = section_addr(hdr, sechdrs, secstrings, "__kcrctab_gpl");
2282	mod->gpl_future_syms = section_objs(hdr, sechdrs, secstrings,
2283	"__ksymtab_gpl_future",
2284	sizeof(*mod->gpl_future_syms),
2285	&mod->num_gpl_future_syms);
2286	mod->gpl_future_crcs = section_addr(hdr, sechdrs, secstrings,
2287	"__kcrctab_gpl_future");
2288
2289	#ifdef CONFIG_UNUSED_SYMBOLS
2290	mod->unused_syms = section_objs(hdr, sechdrs, secstrings,
2291	"__ksymtab_unused",
2292	sizeof(*mod->unused_syms),
2293	&mod->num_unused_syms);
2294	mod->unused_crcs = section_addr(hdr, sechdrs, secstrings,
2295	"__kcrctab_unused");
2296	mod->unused_gpl_syms = section_objs(hdr, sechdrs, secstrings,
2297	"__ksymtab_unused_gpl",
2298	sizeof(*mod->unused_gpl_syms),
2299	&mod->num_unused_gpl_syms);
2300	mod->unused_gpl_crcs = section_addr(hdr, sechdrs, secstrings,
2301	"__kcrctab_unused_gpl");
2302	#endif
2303	#ifdef CONFIG_CONSTRUCTORS
2304	mod->ctors = section_objs(hdr, sechdrs, secstrings, ".ctors",
2305	sizeof(*mod->ctors), &mod->num_ctors);
2306	#endif
2307
2308	#ifdef CONFIG_TRACEPOINTS
2309	mod->tracepoints = section_objs(hdr, sechdrs, secstrings,
2310	"__tracepoints",
2311	sizeof(*mod->tracepoints),
2312	&mod->num_tracepoints);
2313	#endif
2314	#ifdef CONFIG_EVENT_TRACING
2315	mod->trace_events = section_objs(hdr, sechdrs, secstrings,
2316	"_ftrace_events",
2317	sizeof(*mod->trace_events),
2318	&mod->num_trace_events);
2319	/*
2320	* This section contains pointers to allocated objects in the trace
2321	* code and not scanning it leads to false positives.
2322	*/
2323	kmemleak_scan_area(mod->trace_events, sizeof(mod->trace_events)
2324	mod->num_trace_events, GFP_KERNEL);
2325	#endif
2326	#ifdef CONFIG_FTRACE_MCOUNT_RECORD
2327	/* sechdrs[0].sh_size is always zero */
2328	mod->ftrace_callsites = section_objs(hdr, sechdrs, secstrings,
2329	"__mcount_loc",
2330	sizeof(*mod->ftrace_callsites),
2331	&mod->num_ftrace_callsites);
2332	#endif
2333	#ifdef CONFIG_MODVERSIONS
2334	if ((mod->num_syms && !mod->crcs)
2335	\|\| (mod->num_gpl_syms && !mod->gpl_crcs)
2336	\|\| (mod->num_gpl_future_syms && !mod->gpl_future_crcs)
2337	#ifdef CONFIG_UNUSED_SYMBOLS
2338	\|\| (mod->num_unused_syms && !mod->unused_crcs)
2339	\|\| (mod->num_unused_gpl_syms && !mod->unused_gpl_crcs)
2340	#endif
2341	) {
2342	err = try_to_force_load(mod,
2343	"no versions for exported symbols");
2344	if (err)
2345	goto cleanup;
2346	}
2347	#endif
2348
2349	/* Now do relocations. */
2350	for (i = 1; i < hdr->e_shnum; i++) {
2351	const char strtab = (char )sechdrs[strindex].sh_addr;
2352	unsigned int info = sechdrs[i].sh_info;
2353
2354	/* Not a valid relocation section? */
2355	if (info >= hdr->e_shnum)
2356	continue;
2357
2358	/* Don't bother with non-allocated sections */
2359	if (!(sechdrs[info].sh_flags & SHF_ALLOC))
2360	continue;
2361
2362	if (sechdrs[i].sh_type == SHT_REL)
2363	err = apply_relocate(sechdrs, strtab, symindex, i,mod);
2364	else if (sechdrs[i].sh_type == SHT_RELA)
2365	err = apply_relocate_add(sechdrs, strtab, symindex, i,
2366	mod);
2367	if (err < 0)
2368	goto cleanup;
2369	}
2370
2371	/* Find duplicate symbols */
2372	err = verify_export_symbols(mod);
2373	if (err < 0)
2374	goto cleanup;
2375
2376	/* Set up and sort exception table */
2377	mod->extable = section_objs(hdr, sechdrs, secstrings, "__ex_table",
2378	sizeof(*mod->extable), &mod->num_exentries);
2379	sort_extable(mod->extable, mod->extable + mod->num_exentries);
2380
2381	/* Finally, copy percpu area over. */
2382	percpu_modcopy(mod, (void *)sechdrs[pcpuindex].sh_addr,
2383	sechdrs[pcpuindex].sh_size);
2384
2385	add_kallsyms(mod, sechdrs, hdr->e_shnum, symindex, strindex,
2386	symoffs, stroffs, secstrings, strmap);
2387	kfree(strmap);
2388	strmap = NULL;
2389
2390	if (!mod->taints) {
2391	struct _ddebug *debug;
2392	unsigned int num_debug;
2393
2394	debug = section_objs(hdr, sechdrs, secstrings, "__verbose",
2395	sizeof(*debug), &num_debug);
2396	if (debug)
2397	dynamic_debug_setup(debug, num_debug);
2398	}
2399
2400	err = module_finalize(hdr, sechdrs, mod);
2401	if (err < 0)
2402	goto cleanup;
2403
2404	/* flush the icache in correct context */
2405	old_fs = get_fs();
2406	set_fs(KERNEL_DS);
2407
2408	/*
2409	* Flush the instruction cache, since we've played with text.
2410	* Do it before processing of module parameters, so the module
2411	* can provide parameter accessor functions of its own.
2412	*/
2413	if (mod->module_init)
2414	flush_icache_range((unsigned long)mod->module_init,
2415	(unsigned long)mod->module_init
2416	+ mod->init_size);
2417	flush_icache_range((unsigned long)mod->module_core,
2418	(unsigned long)mod->module_core + mod->core_size);
2419
2420	set_fs(old_fs);
2421
2422	mod->args = args;
2423	if (section_addr(hdr, sechdrs, secstrings, "__obsparm"))
2424	printk(KERN_WARNING "%s: Ignoring obsolete parameters\n",
2425	mod->name);
2426
2427	/* Now sew it into the lists so we can get lockdep and oops
2428	* info during argument parsing. Noone should access us, since
2429	* strong_try_module_get() will fail.
2430	* lockdep/oops can run asynchronous, so use the RCU list insertion
2431	* function to insert in a way safe to concurrent readers.
2432	* The mutex protects against concurrent writers.
2433	*/
2434	list_add_rcu(&mod->list, &modules);
2435
2436	err = parse_args(mod->name, mod->args, mod->kp, mod->num_kp, NULL);
2437	if (err < 0)
2438	goto unlink;
2439
2440	err = mod_sysfs_setup(mod, mod->kp, mod->num_kp);
2441	if (err < 0)
2442	goto unlink;
2443	add_sect_attrs(mod, hdr->e_shnum, secstrings, sechdrs);
2444	add_notes_attrs(mod, hdr->e_shnum, secstrings, sechdrs);
2445
2446	/* Get rid of temporary copy */
2447	vfree(hdr);
2448
2449	trace_module_load(mod);
2450
2451	/* Done! */
2452	return mod;
2453
2454	unlink:
2455	/* Unlink carefully: kallsyms could be walking list. */
2456	list_del_rcu(&mod->list);
2457	synchronize_sched();
2458	module_arch_cleanup(mod);
2459	cleanup:
2460	free_modinfo(mod);
2461	kobject_del(&mod->mkobj.kobj);
2462	kobject_put(&mod->mkobj.kobj);
2463	free_unload:
2464	module_unload_free(mod);
2465	#if defined(CONFIG_MODULE_UNLOAD)
2466	free_percpu(mod->refptr);
2467	free_init:
2468	#endif
2469	module_free(mod, mod->module_init);
2470	free_core:
2471	module_free(mod, mod->module_core);
2472	/* mod will be freed with core. Don't access it beyond this line! */
2473	free_percpu:
2474	percpu_modfree(mod);
2475	free_mod:
2476	kfree(args);
2477	kfree(strmap);
2478	free_hdr:
2479	vfree(hdr);
2480	return ERR_PTR(err);
2481
2482	truncated:
2483	printk(KERN_ERR "Module len %lu truncated\n", len);
2484	err = -ENOEXEC;
2485	goto free_hdr;
2486	}
2487
2488	/* Call module constructors. */
2489	static void do_mod_ctors(struct module *mod)
2490	{
2491	#ifdef CONFIG_CONSTRUCTORS
2492	unsigned long i;
2493
2494	for (i = 0; i < mod->num_ctors; i++)
2495	mod->ctors[i]();
2496	#endif
2497	}
2498
2499	/* This is where the real work happens */
2500	SYSCALL_DEFINE3(init_module, void __user *, umod,
2501	unsigned long, len, const char __user *, uargs)
2502	{
2503	struct module *mod;
2504	int ret = 0;
2505
2506	/* Must have permission */
2507	if (!capable(CAP_SYS_MODULE) \|\| modules_disabled)
2508	return -EPERM;
2509
2510	/* Only one module load at a time, please */
2511	if (mutex_lock_interruptible(&module_mutex) != 0)
2512	return -EINTR;
2513
2514	/* Do all the hard work */
2515	mod = load_module(umod, len, uargs);
2516	if (IS_ERR(mod)) {
2517	mutex_unlock(&module_mutex);
2518	return PTR_ERR(mod);
2519	}
2520
2521	/* Drop lock so they can recurse */
2522	mutex_unlock(&module_mutex);
2523
2524	blocking_notifier_call_chain(&module_notify_list,
2525	MODULE_STATE_COMING, mod);
2526
2527	do_mod_ctors(mod);
2528	/* Start the module */
2529	if (mod->init != NULL)
2530	ret = do_one_initcall(mod->init);
2531	if (ret < 0) {
2532	/* Init routine failed: abort. Try to protect us from
2533	buggy refcounters. */
2534	mod->state = MODULE_STATE_GOING;
2535	synchronize_sched();
2536	module_put(mod);
2537	blocking_notifier_call_chain(&module_notify_list,
2538	MODULE_STATE_GOING, mod);
2539	mutex_lock(&module_mutex);
2540	free_module(mod);
2541	mutex_unlock(&module_mutex);
2542	wake_up(&module_wq);
2543	return ret;
2544	}
2545	if (ret > 0) {
2546	printk(KERN_WARNING
2547	"%s: '%s'->init suspiciously returned %d, it should follow 0/-E convention\n"
2548	"%s: loading module anyway...\n",
2549	__func__, mod->name, ret,
2550	__func__);
2551	dump_stack();
2552	}
2553
2554	/* Now it's a first class citizen! Wake up anyone waiting for it. */
2555	mod->state = MODULE_STATE_LIVE;
2556	wake_up(&module_wq);
2557	blocking_notifier_call_chain(&module_notify_list,
2558	MODULE_STATE_LIVE, mod);
2559
2560	/* We need to finish all async code before the module init sequence is done */
2561	async_synchronize_full();
2562
2563	mutex_lock(&module_mutex);
2564	/* Drop initial reference. */
2565	module_put(mod);
2566	trim_init_extable(mod);
2567	#ifdef CONFIG_KALLSYMS
2568	mod->num_symtab = mod->core_num_syms;
2569	mod->symtab = mod->core_symtab;
2570	mod->strtab = mod->core_strtab;
2571	#endif
2572	module_free(mod, mod->module_init);
2573	mod->module_init = NULL;
2574	mod->init_size = 0;
2575	mod->init_text_size = 0;
2576	mutex_unlock(&module_mutex);
2577
2578	return 0;
2579	}
2580
2581	static inline int within(unsigned long addr, void *start, unsigned long size)
2582	{
2583	return ((void )addr >= start && (void )addr < start + size);
2584	}
2585
2586	#ifdef CONFIG_KALLSYMS
2587	/*
2588	* This ignores the intensely annoying "mapping symbols" found
2589	* in ARM ELF files: $a, $t and $d.
2590	*/
2591	static inline int is_arm_mapping_symbol(const char *str)
2592	{
2593	return str[0] == '$' && strchr("atd", str[1])
2594	&& (str[2] == '\0' \|\| str[2] == '.');
2595	}
2596
2597	static const char get_ksymbol(struct module mod,
2598	unsigned long addr,
2599	unsigned long *size,
2600	unsigned long *offset)
2601	{
2602	unsigned int i, best = 0;
2603	unsigned long nextval;
2604
2605	/* At worse, next value is at end of module */
2606	if (within_module_init(addr, mod))
2607	nextval = (unsigned long)mod->module_init+mod->init_text_size;
2608	else
2609	nextval = (unsigned long)mod->module_core+mod->core_text_size;
2610
2611	/* Scan for closest preceeding symbol, and next symbol. (ELF
2612	starts real symbols at 1). */
2613	for (i = 1; i < mod->num_symtab; i++) {
2614	if (mod->symtab[i].st_shndx == SHN_UNDEF)
2615	continue;
2616
2617	/* We ignore unnamed symbols: they're uninformative
2618	* and inserted at a whim. */
2619	if (mod->symtab[i].st_value <= addr
2620	&& mod->symtab[i].st_value > mod->symtab[best].st_value
2621	&& *(mod->strtab + mod->symtab[i].st_name) != '\0'
2622	&& !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
2623	best = i;
2624	if (mod->symtab[i].st_value > addr
2625	&& mod->symtab[i].st_value < nextval
2626	&& *(mod->strtab + mod->symtab[i].st_name) != '\0'
2627	&& !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
2628	nextval = mod->symtab[i].st_value;
2629	}
2630
2631	if (!best)
2632	return NULL;
2633
2634	if (size)
2635	*size = nextval - mod->symtab[best].st_value;
2636	if (offset)
2637	*offset = addr - mod->symtab[best].st_value;
2638	return mod->strtab + mod->symtab[best].st_name;
2639	}
2640
2641	/* For kallsyms to ask for address resolution. NULL means not found. Careful
2642	* not to lock to avoid deadlock on oopses, simply disable preemption. */
2643	const char *module_address_lookup(unsigned long addr,
2644	unsigned long *size,
2645	unsigned long *offset,
2646	char **modname,
2647	char *namebuf)
2648	{
2649	struct module *mod;
2650	const char *ret = NULL;
2651
2652	preempt_disable();
2653	list_for_each_entry_rcu(mod, &modules, list) {
2654	if (within_module_init(addr, mod) \|\|
2655	within_module_core(addr, mod)) {
2656	if (modname)
2657	*modname = mod->name;
2658	ret = get_ksymbol(mod, addr, size, offset);
2659	break;
2660	}
2661	}
2662	/* Make a copy in here where it's safe */
2663	if (ret) {
2664	strncpy(namebuf, ret, KSYM_NAME_LEN - 1);
2665	ret = namebuf;
2666	}
2667	preempt_enable();
2668	return ret;
2669	}
2670
2671	int lookup_module_symbol_name(unsigned long addr, char *symname)
2672	{
2673	struct module *mod;
2674
2675	preempt_disable();
2676	list_for_each_entry_rcu(mod, &modules, list) {
2677	if (within_module_init(addr, mod) \|\|
2678	within_module_core(addr, mod)) {
2679	const char *sym;
2680
2681	sym = get_ksymbol(mod, addr, NULL, NULL);
2682	if (!sym)
2683	goto out;
2684	strlcpy(symname, sym, KSYM_NAME_LEN);
2685	preempt_enable();
2686	return 0;
2687	}
2688	}
2689	out:
2690	preempt_enable();
2691	return -ERANGE;
2692	}
2693
2694	int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,
2695	unsigned long offset, char modname, char *name)
2696	{
2697	struct module *mod;
2698
2699	preempt_disable();
2700	list_for_each_entry_rcu(mod, &modules, list) {
2701	if (within_module_init(addr, mod) \|\|
2702	within_module_core(addr, mod)) {
2703	const char *sym;
2704
2705	sym = get_ksymbol(mod, addr, size, offset);
2706	if (!sym)
2707	goto out;
2708	if (modname)
2709	strlcpy(modname, mod->name, MODULE_NAME_LEN);
2710	if (name)
2711	strlcpy(name, sym, KSYM_NAME_LEN);
2712	preempt_enable();
2713	return 0;
2714	}
2715	}
2716	out:
2717	preempt_enable();
2718	return -ERANGE;
2719	}
2720
2721	int module_get_kallsym(unsigned int symnum, unsigned long value, char type,
2722	char name, char module_name, int *exported)
2723	{
2724	struct module *mod;
2725
2726	preempt_disable();
2727	list_for_each_entry_rcu(mod, &modules, list) {
2728	if (symnum < mod->num_symtab) {
2729	*value = mod->symtab[symnum].st_value;
2730	*type = mod->symtab[symnum].st_info;
2731	strlcpy(name, mod->strtab + mod->symtab[symnum].st_name,
2732	KSYM_NAME_LEN);
2733	strlcpy(module_name, mod->name, MODULE_NAME_LEN);
2734	exported = is_exported(name, value, mod);
2735	preempt_enable();
2736	return 0;
2737	}
2738	symnum -= mod->num_symtab;
2739	}
2740	preempt_enable();
2741	return -ERANGE;
2742	}
2743
2744	static unsigned long mod_find_symname(struct module mod, const char name)
2745	{
2746	unsigned int i;
2747
2748	for (i = 0; i < mod->num_symtab; i++)
2749	if (strcmp(name, mod->strtab+mod->symtab[i].st_name) == 0 &&
2750	mod->symtab[i].st_info != 'U')
2751	return mod->symtab[i].st_value;
2752	return 0;
2753	}
2754
2755	/* Look for this name: can be of form module:name. */
2756	unsigned long module_kallsyms_lookup_name(const char *name)
2757	{
2758	struct module *mod;
2759	char *colon;
2760	unsigned long ret = 0;
2761
2762	/* Don't lock: we're in enough trouble already. */
2763	preempt_disable();
2764	if ((colon = strchr(name, ':')) != NULL) {
2765	*colon = '\0';
2766	if ((mod = find_module(name)) != NULL)
2767	ret = mod_find_symname(mod, colon+1);
2768	*colon = ':';
2769	} else {
2770	list_for_each_entry_rcu(mod, &modules, list)
2771	if ((ret = mod_find_symname(mod, name)) != 0)
2772	break;
2773	}
2774	preempt_enable();
2775	return ret;
2776	}
2777
2778	int module_kallsyms_on_each_symbol(int (fn)(void , const char *,
2779	struct module *, unsigned long),
2780	void *data)
2781	{
2782	struct module *mod;
2783	unsigned int i;
2784	int ret;
2785
2786	list_for_each_entry(mod, &modules, list) {
2787	for (i = 0; i < mod->num_symtab; i++) {
2788	ret = fn(data, mod->strtab + mod->symtab[i].st_name,
2789	mod, mod->symtab[i].st_value);
2790	if (ret != 0)
2791	return ret;
2792	}
2793	}
2794	return 0;
2795	}
2796	#endif /* CONFIG_KALLSYMS */
2797
2798	static char module_flags(struct module mod, char *buf)
2799	{
2800	int bx = 0;
2801
2802	if (mod->taints \|\|
2803	mod->state == MODULE_STATE_GOING \|\|
2804	mod->state == MODULE_STATE_COMING) {
2805	buf[bx++] = '(';
2806	if (mod->taints & (1 << TAINT_PROPRIETARY_MODULE))
2807	buf[bx++] = 'P';
2808	if (mod->taints & (1 << TAINT_FORCED_MODULE))
2809	buf[bx++] = 'F';
2810	if (mod->taints & (1 << TAINT_CRAP))
2811	buf[bx++] = 'C';
2812	/*
2813	* TAINT_FORCED_RMMOD: could be added.
2814	* TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
2815	* apply to modules.
2816	*/
2817
2818	/* Show a - for module-is-being-unloaded */
2819	if (mod->state == MODULE_STATE_GOING)
2820	buf[bx++] = '-';
2821	/* Show a + for module-is-being-loaded */
2822	if (mod->state == MODULE_STATE_COMING)
2823	buf[bx++] = '+';
2824	buf[bx++] = ')';
2825	}
2826	buf[bx] = '\0';
2827
2828	return buf;
2829	}
2830
2831	#ifdef CONFIG_PROC_FS
2832	/* Called by the /proc file system to return a list of modules. */
2833	static void m_start(struct seq_file m, loff_t *pos)
2834	{
2835	mutex_lock(&module_mutex);
2836	return seq_list_start(&modules, *pos);
2837	}
2838
2839	static void m_next(struct seq_file m, void p, loff_t pos)
2840	{
2841	return seq_list_next(p, &modules, pos);
2842	}
2843
2844	static void m_stop(struct seq_file m, void p)
2845	{
2846	mutex_unlock(&module_mutex);
2847	}
2848
2849	static int m_show(struct seq_file m, void p)
2850	{
2851	struct module *mod = list_entry(p, struct module, list);
2852	char buf[8];
2853
2854	seq_printf(m, "%s %u",
2855	mod->name, mod->init_size + mod->core_size);
2856	print_unload_info(m, mod);
2857
2858	/* Informative for users. */
2859	seq_printf(m, " %s",
2860	mod->state == MODULE_STATE_GOING ? "Unloading":
2861	mod->state == MODULE_STATE_COMING ? "Loading":
2862	"Live");
2863	/* Used by oprofile and other similar tools. */
2864	seq_printf(m, " 0x%p", mod->module_core);
2865
2866	/* Taints info */
2867	if (mod->taints)
2868	seq_printf(m, " %s", module_flags(mod, buf));
2869
2870	seq_printf(m, "\n");
2871	return 0;
2872	}
2873
2874	/* Format: modulename size refcount deps address
2875
2876	Where refcount is a number or -, and deps is a comma-separated list
2877	of depends or -.
2878	*/
2879	static const struct seq_operations modules_op = {
2880	.start = m_start,
2881	.next = m_next,
2882	.stop = m_stop,
2883	.show = m_show
2884	};
2885
2886	static int modules_open(struct inode inode, struct file file)
2887	{
2888	return seq_open(file, &modules_op);
2889	}
2890
2891	static const struct file_operations proc_modules_operations = {
2892	.open = modules_open,
2893	.read = seq_read,
2894	.llseek = seq_lseek,
2895	.release = seq_release,
2896	};
2897
2898	static int __init proc_modules_init(void)
2899	{
2900	proc_create("modules", 0, NULL, &proc_modules_operations);
2901	return 0;
2902	}
2903	module_init(proc_modules_init);
2904	#endif
2905
2906	/* Given an address, look for it in the module exception tables. */
2907	const struct exception_table_entry *search_module_extables(unsigned long addr)
2908	{
2909	const struct exception_table_entry *e = NULL;
2910	struct module *mod;
2911
2912	preempt_disable();
2913	list_for_each_entry_rcu(mod, &modules, list) {
2914	if (mod->num_exentries == 0)
2915	continue;
2916
2917	e = search_extable(mod->extable,
2918	mod->extable + mod->num_exentries - 1,
2919	addr);
2920	if (e)
2921	break;
2922	}
2923	preempt_enable();
2924
2925	/* Now, if we found one, we are running inside it now, hence
2926	we cannot unload the module, hence no refcnt needed. */
2927	return e;
2928	}
2929
2930	/*
2931	* is_module_address - is this address inside a module?
2932	* @addr: the address to check.
2933	*
2934	* See is_module_text_address() if you simply want to see if the address
2935	* is code (not data).
2936	*/
2937	bool is_module_address(unsigned long addr)
2938	{
2939	bool ret;
2940
2941	preempt_disable();
2942	ret = __module_address(addr) != NULL;
2943	preempt_enable();
2944
2945	return ret;
2946	}
2947
2948	/*
2949	* __module_address - get the module which contains an address.
2950	* @addr: the address.
2951	*
2952	* Must be called with preempt disabled or module mutex held so that
2953	* module doesn't get freed during this.
2954	*/
2955	struct module *__module_address(unsigned long addr)
2956	{
2957	struct module *mod;
2958
2959	if (addr < module_addr_min \|\| addr > module_addr_max)
2960	return NULL;
2961
2962	list_for_each_entry_rcu(mod, &modules, list)
2963	if (within_module_core(addr, mod)
2964	\|\| within_module_init(addr, mod))
2965	return mod;
2966	return NULL;
2967	}
2968	EXPORT_SYMBOL_GPL(__module_address);
2969
2970	/*
2971	* is_module_text_address - is this address inside module code?
2972	* @addr: the address to check.
2973	*
2974	* See is_module_address() if you simply want to see if the address is
2975	* anywhere in a module. See kernel_text_address() for testing if an
2976	* address corresponds to kernel or module code.
2977	*/
2978	bool is_module_text_address(unsigned long addr)
2979	{
2980	bool ret;
2981
2982	preempt_disable();
2983	ret = __module_text_address(addr) != NULL;
2984	preempt_enable();
2985
2986	return ret;
2987	}
2988
2989	/*
2990	* __module_text_address - get the module whose code contains an address.
2991	* @addr: the address.
2992	*
2993	* Must be called with preempt disabled or module mutex held so that
2994	* module doesn't get freed during this.
2995	*/
2996	struct module *__module_text_address(unsigned long addr)
2997	{
2998	struct module *mod = __module_address(addr);
2999	if (mod) {
3000	/* Make sure it's within the text section. */
3001	if (!within(addr, mod->module_init, mod->init_text_size)
3002	&& !within(addr, mod->module_core, mod->core_text_size))
3003	mod = NULL;
3004	}
3005	return mod;
3006	}
3007	EXPORT_SYMBOL_GPL(__module_text_address);
3008
3009	/* Don't grab lock, we're oopsing. */
3010	void print_modules(void)
3011	{
3012	struct module *mod;
3013	char buf[8];
3014
3015	printk(KERN_DEFAULT "Modules linked in:");
3016	/* Most callers should already have preempt disabled, but make sure */
3017	preempt_disable();
3018	list_for_each_entry_rcu(mod, &modules, list)
3019	printk(" %s%s", mod->name, module_flags(mod, buf));
3020	preempt_enable();
3021	if (last_unloaded_module[0])
3022	printk(" [last unloaded: %s]", last_unloaded_module);
3023	printk("\n");
3024	}
3025
3026	#ifdef CONFIG_MODVERSIONS
3027	/* Generate the signature for all relevant module structures here.
3028	* If these change, we don't want to try to parse the module. */
3029	void module_layout(struct module *mod,
3030	struct modversion_info *ver,
3031	struct kernel_param *kp,
3032	struct kernel_symbol *ks,
3033	struct tracepoint *tp)
3034	{
3035	}
3036	EXPORT_SYMBOL(module_layout);
3037	#endif
3038
3039	#ifdef CONFIG_TRACEPOINTS
3040	void module_update_tracepoints(void)
3041	{
3042	struct module *mod;
3043
3044	mutex_lock(&module_mutex);
3045	list_for_each_entry(mod, &modules, list)
3046	if (!mod->taints)
3047	tracepoint_update_probe_range(mod->tracepoints,
3048	mod->tracepoints + mod->num_tracepoints);
3049	mutex_unlock(&module_mutex);
3050	}
3051
3052	/*
3053	* Returns 0 if current not found.
3054	* Returns 1 if current found.
3055	*/
3056	int module_get_iter_tracepoints(struct tracepoint_iter *iter)
3057	{
3058	struct module *iter_mod;
3059	int found = 0;
3060
3061	mutex_lock(&module_mutex);
3062	list_for_each_entry(iter_mod, &modules, list) {
3063	if (!iter_mod->taints) {
3064	/*
3065	* Sorted module list
3066	*/
3067	if (iter_mod < iter->module)
3068	continue;
3069	else if (iter_mod > iter->module)
3070	iter->tracepoint = NULL;
3071	found = tracepoint_get_iter_range(&iter->tracepoint,
3072	iter_mod->tracepoints,
3073	iter_mod->tracepoints
3074	+ iter_mod->num_tracepoints);
3075	if (found) {
3076	iter->module = iter_mod;
3077	break;
3078	}
3079	}
3080	}
3081	mutex_unlock(&module_mutex);
3082	return found;
3083	}
3084	#endif
3085

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/kernel/module.c

interactive