projects/linux·blob 2e94de8a · refs

3079 lines · 78.8 KiB

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