Root/kernel/module.c

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

Archive Download this file



interactive