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

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.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
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-clk
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