2 Copyright (C) 2002 Richard Henderson
3 Copyright (C) 2001 Rusty Russell, 2002, 2010 Rusty Russell IBM.
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.
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.
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
19 #include <linux/export.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/file.h>
26 #include <linux/sysfs.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/vmalloc.h>
30 #include <linux/elf.h>
31 #include <linux/proc_fs.h>
32 #include <linux/security.h>
33 #include <linux/seq_file.h>
34 #include <linux/syscalls.h>
35 #include <linux/fcntl.h>
36 #include <linux/rcupdate.h>
37 #include <linux/capability.h>
38 #include <linux/cpu.h>
39 #include <linux/moduleparam.h>
40 #include <linux/errno.h>
41 #include <linux/err.h>
42 #include <linux/vermagic.h>
43 #include <linux/notifier.h>
44 #include <linux/sched.h>
45 #include <linux/device.h>
46 #include <linux/string.h>
47 #include <linux/mutex.h>
48 #include <linux/rculist.h>
49 #include <asm/uaccess.h>
50 #include <asm/cacheflush.h>
51 #include <asm/mmu_context.h>
52 #include <linux/license.h>
53 #include <asm/sections.h>
54 #include <linux/tracepoint.h>
55 #include <linux/ftrace.h>
56 #include <linux/async.h>
57 #include <linux/percpu.h>
58 #include <linux/kmemleak.h>
59 #include <linux/jump_label.h>
60 #include <linux/pfn.h>
61 #include <linux/bsearch.h>
62 #include <uapi/linux/module.h>
63 #include "module-internal.h"
65 #define CREATE_TRACE_POINTS
66 #include <trace/events/module.h>
68 #ifndef ARCH_SHF_SMALL
69 #define ARCH_SHF_SMALL 0
73 * Modules' sections will be aligned on page boundaries
74 * to ensure complete separation of code and data, but
75 * only when CONFIG_DEBUG_SET_MODULE_RONX=y
77 #ifdef CONFIG_DEBUG_SET_MODULE_RONX
78 # define debug_align(X) ALIGN(X, PAGE_SIZE)
80 # define debug_align(X) (X)
84 * Given BASE and SIZE this macro calculates the number of pages the
85 * memory regions occupies
87 #define MOD_NUMBER_OF_PAGES(BASE, SIZE) (((SIZE) > 0) ? \
88 (PFN_DOWN((unsigned long)(BASE) + (SIZE) - 1) - \
89 PFN_DOWN((unsigned long)BASE) + 1) \
92 /* If this is set, the section belongs in the init part of the module */
93 #define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
97 * 1) List of modules (also safely readable with preempt_disable),
98 * 2) module_use links,
99 * 3) module_addr_min/module_addr_max.
100 * (delete and add uses RCU list operations). */
101 DEFINE_MUTEX(module_mutex
);
102 EXPORT_SYMBOL_GPL(module_mutex
);
103 static LIST_HEAD(modules
);
104 #ifdef CONFIG_KGDB_KDB
105 struct list_head
*kdb_modules
= &modules
; /* kdb needs the list of modules */
106 #endif /* CONFIG_KGDB_KDB */
108 #ifdef CONFIG_MODULE_SIG
109 #ifdef CONFIG_MODULE_SIG_FORCE
110 static bool sig_enforce
= true;
112 static bool sig_enforce
= false;
114 static int param_set_bool_enable_only(const char *val
,
115 const struct kernel_param
*kp
)
119 struct kernel_param dummy_kp
= *kp
;
121 dummy_kp
.arg
= &test
;
123 err
= param_set_bool(val
, &dummy_kp
);
127 /* Don't let them unset it once it's set! */
128 if (!test
&& sig_enforce
)
136 static const struct kernel_param_ops param_ops_bool_enable_only
= {
137 .flags
= KERNEL_PARAM_OPS_FL_NOARG
,
138 .set
= param_set_bool_enable_only
,
139 .get
= param_get_bool
,
141 #define param_check_bool_enable_only param_check_bool
143 module_param(sig_enforce
, bool_enable_only
, 0644);
144 #endif /* !CONFIG_MODULE_SIG_FORCE */
145 #endif /* CONFIG_MODULE_SIG */
147 /* Block module loading/unloading? */
148 int modules_disabled
= 0;
149 core_param(nomodule
, modules_disabled
, bint
, 0);
151 /* Waiting for a module to finish initializing? */
152 static DECLARE_WAIT_QUEUE_HEAD(module_wq
);
154 static BLOCKING_NOTIFIER_HEAD(module_notify_list
);
156 /* Bounds of module allocation, for speeding __module_address.
157 * Protected by module_mutex. */
158 static unsigned long module_addr_min
= -1UL, module_addr_max
= 0;
160 int register_module_notifier(struct notifier_block
* nb
)
162 return blocking_notifier_chain_register(&module_notify_list
, nb
);
164 EXPORT_SYMBOL(register_module_notifier
);
166 int unregister_module_notifier(struct notifier_block
* nb
)
168 return blocking_notifier_chain_unregister(&module_notify_list
, nb
);
170 EXPORT_SYMBOL(unregister_module_notifier
);
176 char *secstrings
, *strtab
;
177 unsigned long symoffs
, stroffs
;
178 struct _ddebug
*debug
;
179 unsigned int num_debug
;
182 unsigned int sym
, str
, mod
, vers
, info
, pcpu
;
186 /* We require a truly strong try_module_get(): 0 means failure due to
187 ongoing or failed initialization etc. */
188 static inline int strong_try_module_get(struct module
*mod
)
190 BUG_ON(mod
&& mod
->state
== MODULE_STATE_UNFORMED
);
191 if (mod
&& mod
->state
== MODULE_STATE_COMING
)
193 if (try_module_get(mod
))
199 static inline void add_taint_module(struct module
*mod
, unsigned flag
,
200 enum lockdep_ok lockdep_ok
)
202 add_taint(flag
, lockdep_ok
);
203 mod
->taints
|= (1U << flag
);
207 * A thread that wants to hold a reference to a module only while it
208 * is running can call this to safely exit. nfsd and lockd use this.
210 void __module_put_and_exit(struct module
*mod
, long code
)
215 EXPORT_SYMBOL(__module_put_and_exit
);
217 /* Find a module section: 0 means not found. */
218 static unsigned int find_sec(const struct load_info
*info
, const char *name
)
222 for (i
= 1; i
< info
->hdr
->e_shnum
; i
++) {
223 Elf_Shdr
*shdr
= &info
->sechdrs
[i
];
224 /* Alloc bit cleared means "ignore it." */
225 if ((shdr
->sh_flags
& SHF_ALLOC
)
226 && strcmp(info
->secstrings
+ shdr
->sh_name
, name
) == 0)
232 /* Find a module section, or NULL. */
233 static void *section_addr(const struct load_info
*info
, const char *name
)
235 /* Section 0 has sh_addr 0. */
236 return (void *)info
->sechdrs
[find_sec(info
, name
)].sh_addr
;
239 /* Find a module section, or NULL. Fill in number of "objects" in section. */
240 static void *section_objs(const struct load_info
*info
,
245 unsigned int sec
= find_sec(info
, name
);
247 /* Section 0 has sh_addr 0 and sh_size 0. */
248 *num
= info
->sechdrs
[sec
].sh_size
/ object_size
;
249 return (void *)info
->sechdrs
[sec
].sh_addr
;
252 /* Provided by the linker */
253 extern const struct kernel_symbol __start___ksymtab
[];
254 extern const struct kernel_symbol __stop___ksymtab
[];
255 extern const struct kernel_symbol __start___ksymtab_gpl
[];
256 extern const struct kernel_symbol __stop___ksymtab_gpl
[];
257 extern const struct kernel_symbol __start___ksymtab_gpl_future
[];
258 extern const struct kernel_symbol __stop___ksymtab_gpl_future
[];
259 extern const unsigned long __start___kcrctab
[];
260 extern const unsigned long __start___kcrctab_gpl
[];
261 extern const unsigned long __start___kcrctab_gpl_future
[];
262 #ifdef CONFIG_UNUSED_SYMBOLS
263 extern const struct kernel_symbol __start___ksymtab_unused
[];
264 extern const struct kernel_symbol __stop___ksymtab_unused
[];
265 extern const struct kernel_symbol __start___ksymtab_unused_gpl
[];
266 extern const struct kernel_symbol __stop___ksymtab_unused_gpl
[];
267 extern const unsigned long __start___kcrctab_unused
[];
268 extern const unsigned long __start___kcrctab_unused_gpl
[];
271 #ifndef CONFIG_MODVERSIONS
272 #define symversion(base, idx) NULL
274 #define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
277 static bool each_symbol_in_section(const struct symsearch
*arr
,
278 unsigned int arrsize
,
279 struct module
*owner
,
280 bool (*fn
)(const struct symsearch
*syms
,
281 struct module
*owner
,
287 for (j
= 0; j
< arrsize
; j
++) {
288 if (fn(&arr
[j
], owner
, data
))
295 /* Returns true as soon as fn returns true, otherwise false. */
296 bool each_symbol_section(bool (*fn
)(const struct symsearch
*arr
,
297 struct module
*owner
,
302 static const struct symsearch arr
[] = {
303 { __start___ksymtab
, __stop___ksymtab
, __start___kcrctab
,
304 NOT_GPL_ONLY
, false },
305 { __start___ksymtab_gpl
, __stop___ksymtab_gpl
,
306 __start___kcrctab_gpl
,
308 { __start___ksymtab_gpl_future
, __stop___ksymtab_gpl_future
,
309 __start___kcrctab_gpl_future
,
310 WILL_BE_GPL_ONLY
, false },
311 #ifdef CONFIG_UNUSED_SYMBOLS
312 { __start___ksymtab_unused
, __stop___ksymtab_unused
,
313 __start___kcrctab_unused
,
314 NOT_GPL_ONLY
, true },
315 { __start___ksymtab_unused_gpl
, __stop___ksymtab_unused_gpl
,
316 __start___kcrctab_unused_gpl
,
321 if (each_symbol_in_section(arr
, ARRAY_SIZE(arr
), NULL
, fn
, data
))
324 list_for_each_entry_rcu(mod
, &modules
, list
) {
325 struct symsearch arr
[] = {
326 { mod
->syms
, mod
->syms
+ mod
->num_syms
, mod
->crcs
,
327 NOT_GPL_ONLY
, false },
328 { mod
->gpl_syms
, mod
->gpl_syms
+ mod
->num_gpl_syms
,
331 { mod
->gpl_future_syms
,
332 mod
->gpl_future_syms
+ mod
->num_gpl_future_syms
,
333 mod
->gpl_future_crcs
,
334 WILL_BE_GPL_ONLY
, false },
335 #ifdef CONFIG_UNUSED_SYMBOLS
337 mod
->unused_syms
+ mod
->num_unused_syms
,
339 NOT_GPL_ONLY
, true },
340 { mod
->unused_gpl_syms
,
341 mod
->unused_gpl_syms
+ mod
->num_unused_gpl_syms
,
342 mod
->unused_gpl_crcs
,
347 if (mod
->state
== MODULE_STATE_UNFORMED
)
350 if (each_symbol_in_section(arr
, ARRAY_SIZE(arr
), mod
, fn
, data
))
355 EXPORT_SYMBOL_GPL(each_symbol_section
);
357 struct find_symbol_arg
{
364 struct module
*owner
;
365 const unsigned long *crc
;
366 const struct kernel_symbol
*sym
;
369 static bool check_symbol(const struct symsearch
*syms
,
370 struct module
*owner
,
371 unsigned int symnum
, void *data
)
373 struct find_symbol_arg
*fsa
= data
;
376 if (syms
->licence
== GPL_ONLY
)
378 if (syms
->licence
== WILL_BE_GPL_ONLY
&& fsa
->warn
) {
379 pr_warn("Symbol %s is being used by a non-GPL module, "
380 "which will not be allowed in the future\n",
385 #ifdef CONFIG_UNUSED_SYMBOLS
386 if (syms
->unused
&& fsa
->warn
) {
387 pr_warn("Symbol %s is marked as UNUSED, however this module is "
388 "using it.\n", fsa
->name
);
389 pr_warn("This symbol will go away in the future.\n");
390 pr_warn("Please evalute if this is the right api to use and if "
391 "it really is, submit a report the linux kernel "
392 "mailinglist together with submitting your code for "
398 fsa
->crc
= symversion(syms
->crcs
, symnum
);
399 fsa
->sym
= &syms
->start
[symnum
];
403 static int cmp_name(const void *va
, const void *vb
)
406 const struct kernel_symbol
*b
;
408 return strcmp(a
, b
->name
);
411 static bool find_symbol_in_section(const struct symsearch
*syms
,
412 struct module
*owner
,
415 struct find_symbol_arg
*fsa
= data
;
416 struct kernel_symbol
*sym
;
418 sym
= bsearch(fsa
->name
, syms
->start
, syms
->stop
- syms
->start
,
419 sizeof(struct kernel_symbol
), cmp_name
);
421 if (sym
!= NULL
&& check_symbol(syms
, owner
, sym
- syms
->start
, data
))
427 /* Find a symbol and return it, along with, (optional) crc and
428 * (optional) module which owns it. Needs preempt disabled or module_mutex. */
429 const struct kernel_symbol
*find_symbol(const char *name
,
430 struct module
**owner
,
431 const unsigned long **crc
,
435 struct find_symbol_arg fsa
;
441 if (each_symbol_section(find_symbol_in_section
, &fsa
)) {
449 pr_debug("Failed to find symbol %s\n", name
);
452 EXPORT_SYMBOL_GPL(find_symbol
);
454 /* Search for module by name: must hold module_mutex. */
455 static struct module
*find_module_all(const char *name
, size_t len
,
460 list_for_each_entry(mod
, &modules
, list
) {
461 if (!even_unformed
&& mod
->state
== MODULE_STATE_UNFORMED
)
463 if (strlen(mod
->name
) == len
&& !memcmp(mod
->name
, name
, len
))
469 struct module
*find_module(const char *name
)
471 return find_module_all(name
, strlen(name
), false);
473 EXPORT_SYMBOL_GPL(find_module
);
477 static inline void __percpu
*mod_percpu(struct module
*mod
)
482 static int percpu_modalloc(struct module
*mod
, struct load_info
*info
)
484 Elf_Shdr
*pcpusec
= &info
->sechdrs
[info
->index
.pcpu
];
485 unsigned long align
= pcpusec
->sh_addralign
;
487 if (!pcpusec
->sh_size
)
490 if (align
> PAGE_SIZE
) {
491 pr_warn("%s: per-cpu alignment %li > %li\n",
492 mod
->name
, align
, PAGE_SIZE
);
496 mod
->percpu
= __alloc_reserved_percpu(pcpusec
->sh_size
, align
);
498 pr_warn("%s: Could not allocate %lu bytes percpu data\n",
499 mod
->name
, (unsigned long)pcpusec
->sh_size
);
502 mod
->percpu_size
= pcpusec
->sh_size
;
506 static void percpu_modfree(struct module
*mod
)
508 free_percpu(mod
->percpu
);
511 static unsigned int find_pcpusec(struct load_info
*info
)
513 return find_sec(info
, ".data..percpu");
516 static void percpu_modcopy(struct module
*mod
,
517 const void *from
, unsigned long size
)
521 for_each_possible_cpu(cpu
)
522 memcpy(per_cpu_ptr(mod
->percpu
, cpu
), from
, size
);
526 * is_module_percpu_address - test whether address is from module static percpu
527 * @addr: address to test
529 * Test whether @addr belongs to module static percpu area.
532 * %true if @addr is from module static percpu area
534 bool is_module_percpu_address(unsigned long addr
)
541 list_for_each_entry_rcu(mod
, &modules
, list
) {
542 if (mod
->state
== MODULE_STATE_UNFORMED
)
544 if (!mod
->percpu_size
)
546 for_each_possible_cpu(cpu
) {
547 void *start
= per_cpu_ptr(mod
->percpu
, cpu
);
549 if ((void *)addr
>= start
&&
550 (void *)addr
< start
+ mod
->percpu_size
) {
561 #else /* ... !CONFIG_SMP */
563 static inline void __percpu
*mod_percpu(struct module
*mod
)
567 static int percpu_modalloc(struct module
*mod
, struct load_info
*info
)
569 /* UP modules shouldn't have this section: ENOMEM isn't quite right */
570 if (info
->sechdrs
[info
->index
.pcpu
].sh_size
!= 0)
574 static inline void percpu_modfree(struct module
*mod
)
577 static unsigned int find_pcpusec(struct load_info
*info
)
581 static inline void percpu_modcopy(struct module
*mod
,
582 const void *from
, unsigned long size
)
584 /* pcpusec should be 0, and size of that section should be 0. */
587 bool is_module_percpu_address(unsigned long addr
)
592 #endif /* CONFIG_SMP */
594 #define MODINFO_ATTR(field) \
595 static void setup_modinfo_##field(struct module *mod, const char *s) \
597 mod->field = kstrdup(s, GFP_KERNEL); \
599 static ssize_t show_modinfo_##field(struct module_attribute *mattr, \
600 struct module_kobject *mk, char *buffer) \
602 return scnprintf(buffer, PAGE_SIZE, "%s\n", mk->mod->field); \
604 static int modinfo_##field##_exists(struct module *mod) \
606 return mod->field != NULL; \
608 static void free_modinfo_##field(struct module *mod) \
613 static struct module_attribute modinfo_##field = { \
614 .attr = { .name = __stringify(field), .mode = 0444 }, \
615 .show = show_modinfo_##field, \
616 .setup = setup_modinfo_##field, \
617 .test = modinfo_##field##_exists, \
618 .free = free_modinfo_##field, \
621 MODINFO_ATTR(version
);
622 MODINFO_ATTR(srcversion
);
624 static char last_unloaded_module
[MODULE_NAME_LEN
+1];
626 #ifdef CONFIG_MODULE_UNLOAD
628 EXPORT_TRACEPOINT_SYMBOL(module_get
);
630 /* MODULE_REF_BASE is the base reference count by kmodule loader. */
631 #define MODULE_REF_BASE 1
633 /* Init the unload section of the module. */
634 static int module_unload_init(struct module
*mod
)
637 * Initialize reference counter to MODULE_REF_BASE.
638 * refcnt == 0 means module is going.
640 atomic_set(&mod
->refcnt
, MODULE_REF_BASE
);
642 INIT_LIST_HEAD(&mod
->source_list
);
643 INIT_LIST_HEAD(&mod
->target_list
);
645 /* Hold reference count during initialization. */
646 atomic_inc(&mod
->refcnt
);
651 /* Does a already use b? */
652 static int already_uses(struct module
*a
, struct module
*b
)
654 struct module_use
*use
;
656 list_for_each_entry(use
, &b
->source_list
, source_list
) {
657 if (use
->source
== a
) {
658 pr_debug("%s uses %s!\n", a
->name
, b
->name
);
662 pr_debug("%s does not use %s!\n", a
->name
, b
->name
);
668 * - we add 'a' as a "source", 'b' as a "target" of module use
669 * - the module_use is added to the list of 'b' sources (so
670 * 'b' can walk the list to see who sourced them), and of 'a'
671 * targets (so 'a' can see what modules it targets).
673 static int add_module_usage(struct module
*a
, struct module
*b
)
675 struct module_use
*use
;
677 pr_debug("Allocating new usage for %s.\n", a
->name
);
678 use
= kmalloc(sizeof(*use
), GFP_ATOMIC
);
680 pr_warn("%s: out of memory loading\n", a
->name
);
686 list_add(&use
->source_list
, &b
->source_list
);
687 list_add(&use
->target_list
, &a
->target_list
);
691 /* Module a uses b: caller needs module_mutex() */
692 int ref_module(struct module
*a
, struct module
*b
)
696 if (b
== NULL
|| already_uses(a
, b
))
699 /* If module isn't available, we fail. */
700 err
= strong_try_module_get(b
);
704 err
= add_module_usage(a
, b
);
711 EXPORT_SYMBOL_GPL(ref_module
);
713 /* Clear the unload stuff of the module. */
714 static void module_unload_free(struct module
*mod
)
716 struct module_use
*use
, *tmp
;
718 mutex_lock(&module_mutex
);
719 list_for_each_entry_safe(use
, tmp
, &mod
->target_list
, target_list
) {
720 struct module
*i
= use
->target
;
721 pr_debug("%s unusing %s\n", mod
->name
, i
->name
);
723 list_del(&use
->source_list
);
724 list_del(&use
->target_list
);
727 mutex_unlock(&module_mutex
);
730 #ifdef CONFIG_MODULE_FORCE_UNLOAD
731 static inline int try_force_unload(unsigned int flags
)
733 int ret
= (flags
& O_TRUNC
);
735 add_taint(TAINT_FORCED_RMMOD
, LOCKDEP_NOW_UNRELIABLE
);
739 static inline int try_force_unload(unsigned int flags
)
743 #endif /* CONFIG_MODULE_FORCE_UNLOAD */
745 /* Try to release refcount of module, 0 means success. */
746 static int try_release_module_ref(struct module
*mod
)
750 /* Try to decrement refcnt which we set at loading */
751 ret
= atomic_sub_return(MODULE_REF_BASE
, &mod
->refcnt
);
754 /* Someone can put this right now, recover with checking */
755 ret
= atomic_add_unless(&mod
->refcnt
, MODULE_REF_BASE
, 0);
760 static int try_stop_module(struct module
*mod
, int flags
, int *forced
)
762 /* If it's not unused, quit unless we're forcing. */
763 if (try_release_module_ref(mod
) != 0) {
764 *forced
= try_force_unload(flags
);
769 /* Mark it as dying. */
770 mod
->state
= MODULE_STATE_GOING
;
775 unsigned long module_refcount(struct module
*mod
)
777 return (unsigned long)atomic_read(&mod
->refcnt
) - MODULE_REF_BASE
;
779 EXPORT_SYMBOL(module_refcount
);
781 /* This exists whether we can unload or not */
782 static void free_module(struct module
*mod
);
784 SYSCALL_DEFINE2(delete_module
, const char __user
*, name_user
,
788 char name
[MODULE_NAME_LEN
];
791 if (!capable(CAP_SYS_MODULE
) || modules_disabled
)
794 if (strncpy_from_user(name
, name_user
, MODULE_NAME_LEN
-1) < 0)
796 name
[MODULE_NAME_LEN
-1] = '\0';
798 if (mutex_lock_interruptible(&module_mutex
) != 0)
801 mod
= find_module(name
);
807 if (!list_empty(&mod
->source_list
)) {
808 /* Other modules depend on us: get rid of them first. */
813 /* Doing init or already dying? */
814 if (mod
->state
!= MODULE_STATE_LIVE
) {
815 /* FIXME: if (force), slam module count damn the torpedoes */
816 pr_debug("%s already dying\n", mod
->name
);
821 /* If it has an init func, it must have an exit func to unload */
822 if (mod
->init
&& !mod
->exit
) {
823 forced
= try_force_unload(flags
);
825 /* This module can't be removed */
831 /* Stop the machine so refcounts can't move and disable module. */
832 ret
= try_stop_module(mod
, flags
, &forced
);
836 mutex_unlock(&module_mutex
);
837 /* Final destruction now no one is using it. */
838 if (mod
->exit
!= NULL
)
840 blocking_notifier_call_chain(&module_notify_list
,
841 MODULE_STATE_GOING
, mod
);
842 async_synchronize_full();
844 /* Store the name of the last unloaded module for diagnostic purposes */
845 strlcpy(last_unloaded_module
, mod
->name
, sizeof(last_unloaded_module
));
850 mutex_unlock(&module_mutex
);
854 static inline void print_unload_info(struct seq_file
*m
, struct module
*mod
)
856 struct module_use
*use
;
857 int printed_something
= 0;
859 seq_printf(m
, " %lu ", module_refcount(mod
));
861 /* Always include a trailing , so userspace can differentiate
862 between this and the old multi-field proc format. */
863 list_for_each_entry(use
, &mod
->source_list
, source_list
) {
864 printed_something
= 1;
865 seq_printf(m
, "%s,", use
->source
->name
);
868 if (mod
->init
!= NULL
&& mod
->exit
== NULL
) {
869 printed_something
= 1;
870 seq_printf(m
, "[permanent],");
873 if (!printed_something
)
877 void __symbol_put(const char *symbol
)
879 struct module
*owner
;
882 if (!find_symbol(symbol
, &owner
, NULL
, true, false))
887 EXPORT_SYMBOL(__symbol_put
);
889 /* Note this assumes addr is a function, which it currently always is. */
890 void symbol_put_addr(void *addr
)
892 struct module
*modaddr
;
893 unsigned long a
= (unsigned long)dereference_function_descriptor(addr
);
895 if (core_kernel_text(a
))
898 /* module_text_address is safe here: we're supposed to have reference
899 * to module from symbol_get, so it can't go away. */
900 modaddr
= __module_text_address(a
);
904 EXPORT_SYMBOL_GPL(symbol_put_addr
);
906 static ssize_t
show_refcnt(struct module_attribute
*mattr
,
907 struct module_kobject
*mk
, char *buffer
)
909 return sprintf(buffer
, "%lu\n", module_refcount(mk
->mod
));
912 static struct module_attribute modinfo_refcnt
=
913 __ATTR(refcnt
, 0444, show_refcnt
, NULL
);
915 void __module_get(struct module
*module
)
919 atomic_inc(&module
->refcnt
);
920 trace_module_get(module
, _RET_IP_
);
924 EXPORT_SYMBOL(__module_get
);
926 bool try_module_get(struct module
*module
)
932 /* Note: here, we can fail to get a reference */
933 if (likely(module_is_live(module
) &&
934 atomic_inc_not_zero(&module
->refcnt
) != 0))
935 trace_module_get(module
, _RET_IP_
);
943 EXPORT_SYMBOL(try_module_get
);
945 void module_put(struct module
*module
)
951 ret
= atomic_dec_if_positive(&module
->refcnt
);
952 WARN_ON(ret
< 0); /* Failed to put refcount */
953 trace_module_put(module
, _RET_IP_
);
957 EXPORT_SYMBOL(module_put
);
959 #else /* !CONFIG_MODULE_UNLOAD */
960 static inline void print_unload_info(struct seq_file
*m
, struct module
*mod
)
962 /* We don't know the usage count, or what modules are using. */
963 seq_printf(m
, " - -");
966 static inline void module_unload_free(struct module
*mod
)
970 int ref_module(struct module
*a
, struct module
*b
)
972 return strong_try_module_get(b
);
974 EXPORT_SYMBOL_GPL(ref_module
);
976 static inline int module_unload_init(struct module
*mod
)
980 #endif /* CONFIG_MODULE_UNLOAD */
982 static size_t module_flags_taint(struct module
*mod
, char *buf
)
986 if (mod
->taints
& (1 << TAINT_PROPRIETARY_MODULE
))
988 if (mod
->taints
& (1 << TAINT_OOT_MODULE
))
990 if (mod
->taints
& (1 << TAINT_FORCED_MODULE
))
992 if (mod
->taints
& (1 << TAINT_CRAP
))
994 if (mod
->taints
& (1 << TAINT_UNSIGNED_MODULE
))
997 * TAINT_FORCED_RMMOD: could be added.
998 * TAINT_CPU_OUT_OF_SPEC, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
1004 static ssize_t
show_initstate(struct module_attribute
*mattr
,
1005 struct module_kobject
*mk
, char *buffer
)
1007 const char *state
= "unknown";
1009 switch (mk
->mod
->state
) {
1010 case MODULE_STATE_LIVE
:
1013 case MODULE_STATE_COMING
:
1016 case MODULE_STATE_GOING
:
1022 return sprintf(buffer
, "%s\n", state
);
1025 static struct module_attribute modinfo_initstate
=
1026 __ATTR(initstate
, 0444, show_initstate
, NULL
);
1028 static ssize_t
store_uevent(struct module_attribute
*mattr
,
1029 struct module_kobject
*mk
,
1030 const char *buffer
, size_t count
)
1032 enum kobject_action action
;
1034 if (kobject_action_type(buffer
, count
, &action
) == 0)
1035 kobject_uevent(&mk
->kobj
, action
);
1039 struct module_attribute module_uevent
=
1040 __ATTR(uevent
, 0200, NULL
, store_uevent
);
1042 static ssize_t
show_coresize(struct module_attribute
*mattr
,
1043 struct module_kobject
*mk
, char *buffer
)
1045 return sprintf(buffer
, "%u\n", mk
->mod
->core_size
);
1048 static struct module_attribute modinfo_coresize
=
1049 __ATTR(coresize
, 0444, show_coresize
, NULL
);
1051 static ssize_t
show_initsize(struct module_attribute
*mattr
,
1052 struct module_kobject
*mk
, char *buffer
)
1054 return sprintf(buffer
, "%u\n", mk
->mod
->init_size
);
1057 static struct module_attribute modinfo_initsize
=
1058 __ATTR(initsize
, 0444, show_initsize
, NULL
);
1060 static ssize_t
show_taint(struct module_attribute
*mattr
,
1061 struct module_kobject
*mk
, char *buffer
)
1065 l
= module_flags_taint(mk
->mod
, buffer
);
1070 static struct module_attribute modinfo_taint
=
1071 __ATTR(taint
, 0444, show_taint
, NULL
);
1073 static struct module_attribute
*modinfo_attrs
[] = {
1076 &modinfo_srcversion
,
1081 #ifdef CONFIG_MODULE_UNLOAD
1087 static const char vermagic
[] = VERMAGIC_STRING
;
1089 static int try_to_force_load(struct module
*mod
, const char *reason
)
1091 #ifdef CONFIG_MODULE_FORCE_LOAD
1092 if (!test_taint(TAINT_FORCED_MODULE
))
1093 pr_warn("%s: %s: kernel tainted.\n", mod
->name
, reason
);
1094 add_taint_module(mod
, TAINT_FORCED_MODULE
, LOCKDEP_NOW_UNRELIABLE
);
1101 #ifdef CONFIG_MODVERSIONS
1102 /* If the arch applies (non-zero) relocations to kernel kcrctab, unapply it. */
1103 static unsigned long maybe_relocated(unsigned long crc
,
1104 const struct module
*crc_owner
)
1106 #ifdef ARCH_RELOCATES_KCRCTAB
1107 if (crc_owner
== NULL
)
1108 return crc
- (unsigned long)reloc_start
;
1113 static int check_version(Elf_Shdr
*sechdrs
,
1114 unsigned int versindex
,
1115 const char *symname
,
1117 const unsigned long *crc
,
1118 const struct module
*crc_owner
)
1120 unsigned int i
, num_versions
;
1121 struct modversion_info
*versions
;
1123 /* Exporting module didn't supply crcs? OK, we're already tainted. */
1127 /* No versions at all? modprobe --force does this. */
1129 return try_to_force_load(mod
, symname
) == 0;
1131 versions
= (void *) sechdrs
[versindex
].sh_addr
;
1132 num_versions
= sechdrs
[versindex
].sh_size
1133 / sizeof(struct modversion_info
);
1135 for (i
= 0; i
< num_versions
; i
++) {
1136 if (strcmp(versions
[i
].name
, symname
) != 0)
1139 if (versions
[i
].crc
== maybe_relocated(*crc
, crc_owner
))
1141 pr_debug("Found checksum %lX vs module %lX\n",
1142 maybe_relocated(*crc
, crc_owner
), versions
[i
].crc
);
1146 pr_warn("%s: no symbol version for %s\n", mod
->name
, symname
);
1150 printk("%s: disagrees about version of symbol %s\n",
1151 mod
->name
, symname
);
1155 static inline int check_modstruct_version(Elf_Shdr
*sechdrs
,
1156 unsigned int versindex
,
1159 const unsigned long *crc
;
1161 /* Since this should be found in kernel (which can't be removed),
1162 * no locking is necessary. */
1163 if (!find_symbol(VMLINUX_SYMBOL_STR(module_layout
), NULL
,
1166 return check_version(sechdrs
, versindex
,
1167 VMLINUX_SYMBOL_STR(module_layout
), mod
, crc
,
1171 /* First part is kernel version, which we ignore if module has crcs. */
1172 static inline int same_magic(const char *amagic
, const char *bmagic
,
1176 amagic
+= strcspn(amagic
, " ");
1177 bmagic
+= strcspn(bmagic
, " ");
1179 return strcmp(amagic
, bmagic
) == 0;
1182 static inline int check_version(Elf_Shdr
*sechdrs
,
1183 unsigned int versindex
,
1184 const char *symname
,
1186 const unsigned long *crc
,
1187 const struct module
*crc_owner
)
1192 static inline int check_modstruct_version(Elf_Shdr
*sechdrs
,
1193 unsigned int versindex
,
1199 static inline int same_magic(const char *amagic
, const char *bmagic
,
1202 return strcmp(amagic
, bmagic
) == 0;
1204 #endif /* CONFIG_MODVERSIONS */
1206 /* Resolve a symbol for this module. I.e. if we find one, record usage. */
1207 static const struct kernel_symbol
*resolve_symbol(struct module
*mod
,
1208 const struct load_info
*info
,
1212 struct module
*owner
;
1213 const struct kernel_symbol
*sym
;
1214 const unsigned long *crc
;
1217 mutex_lock(&module_mutex
);
1218 sym
= find_symbol(name
, &owner
, &crc
,
1219 !(mod
->taints
& (1 << TAINT_PROPRIETARY_MODULE
)), true);
1223 if (!check_version(info
->sechdrs
, info
->index
.vers
, name
, mod
, crc
,
1225 sym
= ERR_PTR(-EINVAL
);
1229 err
= ref_module(mod
, owner
);
1236 /* We must make copy under the lock if we failed to get ref. */
1237 strncpy(ownername
, module_name(owner
), MODULE_NAME_LEN
);
1239 mutex_unlock(&module_mutex
);
1243 static const struct kernel_symbol
*
1244 resolve_symbol_wait(struct module
*mod
,
1245 const struct load_info
*info
,
1248 const struct kernel_symbol
*ksym
;
1249 char owner
[MODULE_NAME_LEN
];
1251 if (wait_event_interruptible_timeout(module_wq
,
1252 !IS_ERR(ksym
= resolve_symbol(mod
, info
, name
, owner
))
1253 || PTR_ERR(ksym
) != -EBUSY
,
1255 pr_warn("%s: gave up waiting for init of module %s.\n",
1262 * /sys/module/foo/sections stuff
1263 * J. Corbet <corbet@lwn.net>
1267 #ifdef CONFIG_KALLSYMS
1268 static inline bool sect_empty(const Elf_Shdr
*sect
)
1270 return !(sect
->sh_flags
& SHF_ALLOC
) || sect
->sh_size
== 0;
1273 struct module_sect_attr
1275 struct module_attribute mattr
;
1277 unsigned long address
;
1280 struct module_sect_attrs
1282 struct attribute_group grp
;
1283 unsigned int nsections
;
1284 struct module_sect_attr attrs
[0];
1287 static ssize_t
module_sect_show(struct module_attribute
*mattr
,
1288 struct module_kobject
*mk
, char *buf
)
1290 struct module_sect_attr
*sattr
=
1291 container_of(mattr
, struct module_sect_attr
, mattr
);
1292 return sprintf(buf
, "0x%pK\n", (void *)sattr
->address
);
1295 static void free_sect_attrs(struct module_sect_attrs
*sect_attrs
)
1297 unsigned int section
;
1299 for (section
= 0; section
< sect_attrs
->nsections
; section
++)
1300 kfree(sect_attrs
->attrs
[section
].name
);
1304 static void add_sect_attrs(struct module
*mod
, const struct load_info
*info
)
1306 unsigned int nloaded
= 0, i
, size
[2];
1307 struct module_sect_attrs
*sect_attrs
;
1308 struct module_sect_attr
*sattr
;
1309 struct attribute
**gattr
;
1311 /* Count loaded sections and allocate structures */
1312 for (i
= 0; i
< info
->hdr
->e_shnum
; i
++)
1313 if (!sect_empty(&info
->sechdrs
[i
]))
1315 size
[0] = ALIGN(sizeof(*sect_attrs
)
1316 + nloaded
* sizeof(sect_attrs
->attrs
[0]),
1317 sizeof(sect_attrs
->grp
.attrs
[0]));
1318 size
[1] = (nloaded
+ 1) * sizeof(sect_attrs
->grp
.attrs
[0]);
1319 sect_attrs
= kzalloc(size
[0] + size
[1], GFP_KERNEL
);
1320 if (sect_attrs
== NULL
)
1323 /* Setup section attributes. */
1324 sect_attrs
->grp
.name
= "sections";
1325 sect_attrs
->grp
.attrs
= (void *)sect_attrs
+ size
[0];
1327 sect_attrs
->nsections
= 0;
1328 sattr
= §_attrs
->attrs
[0];
1329 gattr
= §_attrs
->grp
.attrs
[0];
1330 for (i
= 0; i
< info
->hdr
->e_shnum
; i
++) {
1331 Elf_Shdr
*sec
= &info
->sechdrs
[i
];
1332 if (sect_empty(sec
))
1334 sattr
->address
= sec
->sh_addr
;
1335 sattr
->name
= kstrdup(info
->secstrings
+ sec
->sh_name
,
1337 if (sattr
->name
== NULL
)
1339 sect_attrs
->nsections
++;
1340 sysfs_attr_init(&sattr
->mattr
.attr
);
1341 sattr
->mattr
.show
= module_sect_show
;
1342 sattr
->mattr
.store
= NULL
;
1343 sattr
->mattr
.attr
.name
= sattr
->name
;
1344 sattr
->mattr
.attr
.mode
= S_IRUGO
;
1345 *(gattr
++) = &(sattr
++)->mattr
.attr
;
1349 if (sysfs_create_group(&mod
->mkobj
.kobj
, §_attrs
->grp
))
1352 mod
->sect_attrs
= sect_attrs
;
1355 free_sect_attrs(sect_attrs
);
1358 static void remove_sect_attrs(struct module
*mod
)
1360 if (mod
->sect_attrs
) {
1361 sysfs_remove_group(&mod
->mkobj
.kobj
,
1362 &mod
->sect_attrs
->grp
);
1363 /* We are positive that no one is using any sect attrs
1364 * at this point. Deallocate immediately. */
1365 free_sect_attrs(mod
->sect_attrs
);
1366 mod
->sect_attrs
= NULL
;
1371 * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
1374 struct module_notes_attrs
{
1375 struct kobject
*dir
;
1377 struct bin_attribute attrs
[0];
1380 static ssize_t
module_notes_read(struct file
*filp
, struct kobject
*kobj
,
1381 struct bin_attribute
*bin_attr
,
1382 char *buf
, loff_t pos
, size_t count
)
1385 * The caller checked the pos and count against our size.
1387 memcpy(buf
, bin_attr
->private + pos
, count
);
1391 static void free_notes_attrs(struct module_notes_attrs
*notes_attrs
,
1394 if (notes_attrs
->dir
) {
1396 sysfs_remove_bin_file(notes_attrs
->dir
,
1397 ¬es_attrs
->attrs
[i
]);
1398 kobject_put(notes_attrs
->dir
);
1403 static void add_notes_attrs(struct module
*mod
, const struct load_info
*info
)
1405 unsigned int notes
, loaded
, i
;
1406 struct module_notes_attrs
*notes_attrs
;
1407 struct bin_attribute
*nattr
;
1409 /* failed to create section attributes, so can't create notes */
1410 if (!mod
->sect_attrs
)
1413 /* Count notes sections and allocate structures. */
1415 for (i
= 0; i
< info
->hdr
->e_shnum
; i
++)
1416 if (!sect_empty(&info
->sechdrs
[i
]) &&
1417 (info
->sechdrs
[i
].sh_type
== SHT_NOTE
))
1423 notes_attrs
= kzalloc(sizeof(*notes_attrs
)
1424 + notes
* sizeof(notes_attrs
->attrs
[0]),
1426 if (notes_attrs
== NULL
)
1429 notes_attrs
->notes
= notes
;
1430 nattr
= ¬es_attrs
->attrs
[0];
1431 for (loaded
= i
= 0; i
< info
->hdr
->e_shnum
; ++i
) {
1432 if (sect_empty(&info
->sechdrs
[i
]))
1434 if (info
->sechdrs
[i
].sh_type
== SHT_NOTE
) {
1435 sysfs_bin_attr_init(nattr
);
1436 nattr
->attr
.name
= mod
->sect_attrs
->attrs
[loaded
].name
;
1437 nattr
->attr
.mode
= S_IRUGO
;
1438 nattr
->size
= info
->sechdrs
[i
].sh_size
;
1439 nattr
->private = (void *) info
->sechdrs
[i
].sh_addr
;
1440 nattr
->read
= module_notes_read
;
1446 notes_attrs
->dir
= kobject_create_and_add("notes", &mod
->mkobj
.kobj
);
1447 if (!notes_attrs
->dir
)
1450 for (i
= 0; i
< notes
; ++i
)
1451 if (sysfs_create_bin_file(notes_attrs
->dir
,
1452 ¬es_attrs
->attrs
[i
]))
1455 mod
->notes_attrs
= notes_attrs
;
1459 free_notes_attrs(notes_attrs
, i
);
1462 static void remove_notes_attrs(struct module
*mod
)
1464 if (mod
->notes_attrs
)
1465 free_notes_attrs(mod
->notes_attrs
, mod
->notes_attrs
->notes
);
1470 static inline void add_sect_attrs(struct module
*mod
,
1471 const struct load_info
*info
)
1475 static inline void remove_sect_attrs(struct module
*mod
)
1479 static inline void add_notes_attrs(struct module
*mod
,
1480 const struct load_info
*info
)
1484 static inline void remove_notes_attrs(struct module
*mod
)
1487 #endif /* CONFIG_KALLSYMS */
1489 static void add_usage_links(struct module
*mod
)
1491 #ifdef CONFIG_MODULE_UNLOAD
1492 struct module_use
*use
;
1495 mutex_lock(&module_mutex
);
1496 list_for_each_entry(use
, &mod
->target_list
, target_list
) {
1497 nowarn
= sysfs_create_link(use
->target
->holders_dir
,
1498 &mod
->mkobj
.kobj
, mod
->name
);
1500 mutex_unlock(&module_mutex
);
1504 static void del_usage_links(struct module
*mod
)
1506 #ifdef CONFIG_MODULE_UNLOAD
1507 struct module_use
*use
;
1509 mutex_lock(&module_mutex
);
1510 list_for_each_entry(use
, &mod
->target_list
, target_list
)
1511 sysfs_remove_link(use
->target
->holders_dir
, mod
->name
);
1512 mutex_unlock(&module_mutex
);
1516 static int module_add_modinfo_attrs(struct module
*mod
)
1518 struct module_attribute
*attr
;
1519 struct module_attribute
*temp_attr
;
1523 mod
->modinfo_attrs
= kzalloc((sizeof(struct module_attribute
) *
1524 (ARRAY_SIZE(modinfo_attrs
) + 1)),
1526 if (!mod
->modinfo_attrs
)
1529 temp_attr
= mod
->modinfo_attrs
;
1530 for (i
= 0; (attr
= modinfo_attrs
[i
]) && !error
; i
++) {
1532 (attr
->test
&& attr
->test(mod
))) {
1533 memcpy(temp_attr
, attr
, sizeof(*temp_attr
));
1534 sysfs_attr_init(&temp_attr
->attr
);
1535 error
= sysfs_create_file(&mod
->mkobj
.kobj
,&temp_attr
->attr
);
1542 static void module_remove_modinfo_attrs(struct module
*mod
)
1544 struct module_attribute
*attr
;
1547 for (i
= 0; (attr
= &mod
->modinfo_attrs
[i
]); i
++) {
1548 /* pick a field to test for end of list */
1549 if (!attr
->attr
.name
)
1551 sysfs_remove_file(&mod
->mkobj
.kobj
,&attr
->attr
);
1555 kfree(mod
->modinfo_attrs
);
1558 static void mod_kobject_put(struct module
*mod
)
1560 DECLARE_COMPLETION_ONSTACK(c
);
1561 mod
->mkobj
.kobj_completion
= &c
;
1562 kobject_put(&mod
->mkobj
.kobj
);
1563 wait_for_completion(&c
);
1566 static int mod_sysfs_init(struct module
*mod
)
1569 struct kobject
*kobj
;
1571 if (!module_sysfs_initialized
) {
1572 pr_err("%s: module sysfs not initialized\n", mod
->name
);
1577 kobj
= kset_find_obj(module_kset
, mod
->name
);
1579 pr_err("%s: module is already loaded\n", mod
->name
);
1585 mod
->mkobj
.mod
= mod
;
1587 memset(&mod
->mkobj
.kobj
, 0, sizeof(mod
->mkobj
.kobj
));
1588 mod
->mkobj
.kobj
.kset
= module_kset
;
1589 err
= kobject_init_and_add(&mod
->mkobj
.kobj
, &module_ktype
, NULL
,
1592 mod_kobject_put(mod
);
1594 /* delay uevent until full sysfs population */
1599 static int mod_sysfs_setup(struct module
*mod
,
1600 const struct load_info
*info
,
1601 struct kernel_param
*kparam
,
1602 unsigned int num_params
)
1606 err
= mod_sysfs_init(mod
);
1610 mod
->holders_dir
= kobject_create_and_add("holders", &mod
->mkobj
.kobj
);
1611 if (!mod
->holders_dir
) {
1616 err
= module_param_sysfs_setup(mod
, kparam
, num_params
);
1618 goto out_unreg_holders
;
1620 err
= module_add_modinfo_attrs(mod
);
1622 goto out_unreg_param
;
1624 add_usage_links(mod
);
1625 add_sect_attrs(mod
, info
);
1626 add_notes_attrs(mod
, info
);
1628 kobject_uevent(&mod
->mkobj
.kobj
, KOBJ_ADD
);
1632 module_param_sysfs_remove(mod
);
1634 kobject_put(mod
->holders_dir
);
1636 mod_kobject_put(mod
);
1641 static void mod_sysfs_fini(struct module
*mod
)
1643 remove_notes_attrs(mod
);
1644 remove_sect_attrs(mod
);
1645 mod_kobject_put(mod
);
1648 #else /* !CONFIG_SYSFS */
1650 static int mod_sysfs_setup(struct module
*mod
,
1651 const struct load_info
*info
,
1652 struct kernel_param
*kparam
,
1653 unsigned int num_params
)
1658 static void mod_sysfs_fini(struct module
*mod
)
1662 static void module_remove_modinfo_attrs(struct module
*mod
)
1666 static void del_usage_links(struct module
*mod
)
1670 #endif /* CONFIG_SYSFS */
1672 static void mod_sysfs_teardown(struct module
*mod
)
1674 del_usage_links(mod
);
1675 module_remove_modinfo_attrs(mod
);
1676 module_param_sysfs_remove(mod
);
1677 kobject_put(mod
->mkobj
.drivers_dir
);
1678 kobject_put(mod
->holders_dir
);
1679 mod_sysfs_fini(mod
);
1682 #ifdef CONFIG_DEBUG_SET_MODULE_RONX
1684 * LKM RO/NX protection: protect module's text/ro-data
1685 * from modification and any data from execution.
1687 void set_page_attributes(void *start
, void *end
, int (*set
)(unsigned long start
, int num_pages
))
1689 unsigned long begin_pfn
= PFN_DOWN((unsigned long)start
);
1690 unsigned long end_pfn
= PFN_DOWN((unsigned long)end
);
1692 if (end_pfn
> begin_pfn
)
1693 set(begin_pfn
<< PAGE_SHIFT
, end_pfn
- begin_pfn
);
1696 static void set_section_ro_nx(void *base
,
1697 unsigned long text_size
,
1698 unsigned long ro_size
,
1699 unsigned long total_size
)
1701 /* begin and end PFNs of the current subsection */
1702 unsigned long begin_pfn
;
1703 unsigned long end_pfn
;
1706 * Set RO for module text and RO-data:
1707 * - Always protect first page.
1708 * - Do not protect last partial page.
1711 set_page_attributes(base
, base
+ ro_size
, set_memory_ro
);
1714 * Set NX permissions for module data:
1715 * - Do not protect first partial page.
1716 * - Always protect last page.
1718 if (total_size
> text_size
) {
1719 begin_pfn
= PFN_UP((unsigned long)base
+ text_size
);
1720 end_pfn
= PFN_UP((unsigned long)base
+ total_size
);
1721 if (end_pfn
> begin_pfn
)
1722 set_memory_nx(begin_pfn
<< PAGE_SHIFT
, end_pfn
- begin_pfn
);
1726 static void unset_module_core_ro_nx(struct module
*mod
)
1728 set_page_attributes(mod
->module_core
+ mod
->core_text_size
,
1729 mod
->module_core
+ mod
->core_size
,
1731 set_page_attributes(mod
->module_core
,
1732 mod
->module_core
+ mod
->core_ro_size
,
1736 static void unset_module_init_ro_nx(struct module
*mod
)
1738 set_page_attributes(mod
->module_init
+ mod
->init_text_size
,
1739 mod
->module_init
+ mod
->init_size
,
1741 set_page_attributes(mod
->module_init
,
1742 mod
->module_init
+ mod
->init_ro_size
,
1746 /* Iterate through all modules and set each module's text as RW */
1747 void set_all_modules_text_rw(void)
1751 mutex_lock(&module_mutex
);
1752 list_for_each_entry_rcu(mod
, &modules
, list
) {
1753 if (mod
->state
== MODULE_STATE_UNFORMED
)
1755 if ((mod
->module_core
) && (mod
->core_text_size
)) {
1756 set_page_attributes(mod
->module_core
,
1757 mod
->module_core
+ mod
->core_text_size
,
1760 if ((mod
->module_init
) && (mod
->init_text_size
)) {
1761 set_page_attributes(mod
->module_init
,
1762 mod
->module_init
+ mod
->init_text_size
,
1766 mutex_unlock(&module_mutex
);
1769 /* Iterate through all modules and set each module's text as RO */
1770 void set_all_modules_text_ro(void)
1774 mutex_lock(&module_mutex
);
1775 list_for_each_entry_rcu(mod
, &modules
, list
) {
1776 if (mod
->state
== MODULE_STATE_UNFORMED
)
1778 if ((mod
->module_core
) && (mod
->core_text_size
)) {
1779 set_page_attributes(mod
->module_core
,
1780 mod
->module_core
+ mod
->core_text_size
,
1783 if ((mod
->module_init
) && (mod
->init_text_size
)) {
1784 set_page_attributes(mod
->module_init
,
1785 mod
->module_init
+ mod
->init_text_size
,
1789 mutex_unlock(&module_mutex
);
1792 static inline void set_section_ro_nx(void *base
, unsigned long text_size
, unsigned long ro_size
, unsigned long total_size
) { }
1793 static void unset_module_core_ro_nx(struct module
*mod
) { }
1794 static void unset_module_init_ro_nx(struct module
*mod
) { }
1797 void __weak
module_free(struct module
*mod
, void *module_region
)
1799 vfree(module_region
);
1802 void __weak
module_arch_cleanup(struct module
*mod
)
1806 /* Free a module, remove from lists, etc. */
1807 static void free_module(struct module
*mod
)
1809 trace_module_free(mod
);
1811 mod_sysfs_teardown(mod
);
1813 /* We leave it in list to prevent duplicate loads, but make sure
1814 * that noone uses it while it's being deconstructed. */
1815 mutex_lock(&module_mutex
);
1816 mod
->state
= MODULE_STATE_UNFORMED
;
1817 mutex_unlock(&module_mutex
);
1819 /* Remove dynamic debug info */
1820 ddebug_remove_module(mod
->name
);
1822 /* Arch-specific cleanup. */
1823 module_arch_cleanup(mod
);
1825 /* Module unload stuff */
1826 module_unload_free(mod
);
1828 /* Free any allocated parameters. */
1829 destroy_params(mod
->kp
, mod
->num_kp
);
1831 /* Now we can delete it from the lists */
1832 mutex_lock(&module_mutex
);
1833 /* Unlink carefully: kallsyms could be walking list. */
1834 list_del_rcu(&mod
->list
);
1835 /* Remove this module from bug list, this uses list_del_rcu */
1836 module_bug_cleanup(mod
);
1837 /* Wait for RCU synchronizing before releasing mod->list and buglist. */
1839 mutex_unlock(&module_mutex
);
1841 /* This may be NULL, but that's OK */
1842 unset_module_init_ro_nx(mod
);
1843 module_free(mod
, mod
->module_init
);
1845 percpu_modfree(mod
);
1847 /* Free lock-classes: */
1848 lockdep_free_key_range(mod
->module_core
, mod
->core_size
);
1850 /* Finally, free the core (containing the module structure) */
1851 unset_module_core_ro_nx(mod
);
1852 module_free(mod
, mod
->module_core
);
1855 update_protections(current
->mm
);
1859 void *__symbol_get(const char *symbol
)
1861 struct module
*owner
;
1862 const struct kernel_symbol
*sym
;
1865 sym
= find_symbol(symbol
, &owner
, NULL
, true, true);
1866 if (sym
&& strong_try_module_get(owner
))
1870 return sym
? (void *)sym
->value
: NULL
;
1872 EXPORT_SYMBOL_GPL(__symbol_get
);
1875 * Ensure that an exported symbol [global namespace] does not already exist
1876 * in the kernel or in some other module's exported symbol table.
1878 * You must hold the module_mutex.
1880 static int verify_export_symbols(struct module
*mod
)
1883 struct module
*owner
;
1884 const struct kernel_symbol
*s
;
1886 const struct kernel_symbol
*sym
;
1889 { mod
->syms
, mod
->num_syms
},
1890 { mod
->gpl_syms
, mod
->num_gpl_syms
},
1891 { mod
->gpl_future_syms
, mod
->num_gpl_future_syms
},
1892 #ifdef CONFIG_UNUSED_SYMBOLS
1893 { mod
->unused_syms
, mod
->num_unused_syms
},
1894 { mod
->unused_gpl_syms
, mod
->num_unused_gpl_syms
},
1898 for (i
= 0; i
< ARRAY_SIZE(arr
); i
++) {
1899 for (s
= arr
[i
].sym
; s
< arr
[i
].sym
+ arr
[i
].num
; s
++) {
1900 if (find_symbol(s
->name
, &owner
, NULL
, true, false)) {
1901 pr_err("%s: exports duplicate symbol %s"
1903 mod
->name
, s
->name
, module_name(owner
));
1911 /* Change all symbols so that st_value encodes the pointer directly. */
1912 static int simplify_symbols(struct module
*mod
, const struct load_info
*info
)
1914 Elf_Shdr
*symsec
= &info
->sechdrs
[info
->index
.sym
];
1915 Elf_Sym
*sym
= (void *)symsec
->sh_addr
;
1916 unsigned long secbase
;
1919 const struct kernel_symbol
*ksym
;
1921 for (i
= 1; i
< symsec
->sh_size
/ sizeof(Elf_Sym
); i
++) {
1922 const char *name
= info
->strtab
+ sym
[i
].st_name
;
1924 switch (sym
[i
].st_shndx
) {
1926 /* Ignore common symbols */
1927 if (!strncmp(name
, "__gnu_lto", 9))
1930 /* We compiled with -fno-common. These are not
1931 supposed to happen. */
1932 pr_debug("Common symbol: %s\n", name
);
1933 printk("%s: please compile with -fno-common\n",
1939 /* Don't need to do anything */
1940 pr_debug("Absolute symbol: 0x%08lx\n",
1941 (long)sym
[i
].st_value
);
1945 ksym
= resolve_symbol_wait(mod
, info
, name
);
1946 /* Ok if resolved. */
1947 if (ksym
&& !IS_ERR(ksym
)) {
1948 sym
[i
].st_value
= ksym
->value
;
1953 if (!ksym
&& ELF_ST_BIND(sym
[i
].st_info
) == STB_WEAK
)
1956 pr_warn("%s: Unknown symbol %s (err %li)\n",
1957 mod
->name
, name
, PTR_ERR(ksym
));
1958 ret
= PTR_ERR(ksym
) ?: -ENOENT
;
1962 /* Divert to percpu allocation if a percpu var. */
1963 if (sym
[i
].st_shndx
== info
->index
.pcpu
)
1964 secbase
= (unsigned long)mod_percpu(mod
);
1966 secbase
= info
->sechdrs
[sym
[i
].st_shndx
].sh_addr
;
1967 sym
[i
].st_value
+= secbase
;
1975 static int apply_relocations(struct module
*mod
, const struct load_info
*info
)
1980 /* Now do relocations. */
1981 for (i
= 1; i
< info
->hdr
->e_shnum
; i
++) {
1982 unsigned int infosec
= info
->sechdrs
[i
].sh_info
;
1984 /* Not a valid relocation section? */
1985 if (infosec
>= info
->hdr
->e_shnum
)
1988 /* Don't bother with non-allocated sections */
1989 if (!(info
->sechdrs
[infosec
].sh_flags
& SHF_ALLOC
))
1992 if (info
->sechdrs
[i
].sh_type
== SHT_REL
)
1993 err
= apply_relocate(info
->sechdrs
, info
->strtab
,
1994 info
->index
.sym
, i
, mod
);
1995 else if (info
->sechdrs
[i
].sh_type
== SHT_RELA
)
1996 err
= apply_relocate_add(info
->sechdrs
, info
->strtab
,
1997 info
->index
.sym
, i
, mod
);
2004 /* Additional bytes needed by arch in front of individual sections */
2005 unsigned int __weak
arch_mod_section_prepend(struct module
*mod
,
2006 unsigned int section
)
2008 /* default implementation just returns zero */
2012 /* Update size with this section: return offset. */
2013 static long get_offset(struct module
*mod
, unsigned int *size
,
2014 Elf_Shdr
*sechdr
, unsigned int section
)
2018 *size
+= arch_mod_section_prepend(mod
, section
);
2019 ret
= ALIGN(*size
, sechdr
->sh_addralign
?: 1);
2020 *size
= ret
+ sechdr
->sh_size
;
2024 /* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld
2025 might -- code, read-only data, read-write data, small data. Tally
2026 sizes, and place the offsets into sh_entsize fields: high bit means it
2028 static void layout_sections(struct module
*mod
, struct load_info
*info
)
2030 static unsigned long const masks
[][2] = {
2031 /* NOTE: all executable code must be the first section
2032 * in this array; otherwise modify the text_size
2033 * finder in the two loops below */
2034 { SHF_EXECINSTR
| SHF_ALLOC
, ARCH_SHF_SMALL
},
2035 { SHF_ALLOC
, SHF_WRITE
| ARCH_SHF_SMALL
},
2036 { SHF_WRITE
| SHF_ALLOC
, ARCH_SHF_SMALL
},
2037 { ARCH_SHF_SMALL
| SHF_ALLOC
, 0 }
2041 for (i
= 0; i
< info
->hdr
->e_shnum
; i
++)
2042 info
->sechdrs
[i
].sh_entsize
= ~0UL;
2044 pr_debug("Core section allocation order:\n");
2045 for (m
= 0; m
< ARRAY_SIZE(masks
); ++m
) {
2046 for (i
= 0; i
< info
->hdr
->e_shnum
; ++i
) {
2047 Elf_Shdr
*s
= &info
->sechdrs
[i
];
2048 const char *sname
= info
->secstrings
+ s
->sh_name
;
2050 if ((s
->sh_flags
& masks
[m
][0]) != masks
[m
][0]
2051 || (s
->sh_flags
& masks
[m
][1])
2052 || s
->sh_entsize
!= ~0UL
2053 || strstarts(sname
, ".init"))
2055 s
->sh_entsize
= get_offset(mod
, &mod
->core_size
, s
, i
);
2056 pr_debug("\t%s\n", sname
);
2059 case 0: /* executable */
2060 mod
->core_size
= debug_align(mod
->core_size
);
2061 mod
->core_text_size
= mod
->core_size
;
2063 case 1: /* RO: text and ro-data */
2064 mod
->core_size
= debug_align(mod
->core_size
);
2065 mod
->core_ro_size
= mod
->core_size
;
2067 case 3: /* whole core */
2068 mod
->core_size
= debug_align(mod
->core_size
);
2073 pr_debug("Init section allocation order:\n");
2074 for (m
= 0; m
< ARRAY_SIZE(masks
); ++m
) {
2075 for (i
= 0; i
< info
->hdr
->e_shnum
; ++i
) {
2076 Elf_Shdr
*s
= &info
->sechdrs
[i
];
2077 const char *sname
= info
->secstrings
+ s
->sh_name
;
2079 if ((s
->sh_flags
& masks
[m
][0]) != masks
[m
][0]
2080 || (s
->sh_flags
& masks
[m
][1])
2081 || s
->sh_entsize
!= ~0UL
2082 || !strstarts(sname
, ".init"))
2084 s
->sh_entsize
= (get_offset(mod
, &mod
->init_size
, s
, i
)
2085 | INIT_OFFSET_MASK
);
2086 pr_debug("\t%s\n", sname
);
2089 case 0: /* executable */
2090 mod
->init_size
= debug_align(mod
->init_size
);
2091 mod
->init_text_size
= mod
->init_size
;
2093 case 1: /* RO: text and ro-data */
2094 mod
->init_size
= debug_align(mod
->init_size
);
2095 mod
->init_ro_size
= mod
->init_size
;
2097 case 3: /* whole init */
2098 mod
->init_size
= debug_align(mod
->init_size
);
2104 static void set_license(struct module
*mod
, const char *license
)
2107 license
= "unspecified";
2109 if (!license_is_gpl_compatible(license
)) {
2110 if (!test_taint(TAINT_PROPRIETARY_MODULE
))
2111 pr_warn("%s: module license '%s' taints kernel.\n",
2112 mod
->name
, license
);
2113 add_taint_module(mod
, TAINT_PROPRIETARY_MODULE
,
2114 LOCKDEP_NOW_UNRELIABLE
);
2118 /* Parse tag=value strings from .modinfo section */
2119 static char *next_string(char *string
, unsigned long *secsize
)
2121 /* Skip non-zero chars */
2124 if ((*secsize
)-- <= 1)
2128 /* Skip any zero padding. */
2129 while (!string
[0]) {
2131 if ((*secsize
)-- <= 1)
2137 static char *get_modinfo(struct load_info
*info
, const char *tag
)
2140 unsigned int taglen
= strlen(tag
);
2141 Elf_Shdr
*infosec
= &info
->sechdrs
[info
->index
.info
];
2142 unsigned long size
= infosec
->sh_size
;
2144 for (p
= (char *)infosec
->sh_addr
; p
; p
= next_string(p
, &size
)) {
2145 if (strncmp(p
, tag
, taglen
) == 0 && p
[taglen
] == '=')
2146 return p
+ taglen
+ 1;
2151 static void setup_modinfo(struct module
*mod
, struct load_info
*info
)
2153 struct module_attribute
*attr
;
2156 for (i
= 0; (attr
= modinfo_attrs
[i
]); i
++) {
2158 attr
->setup(mod
, get_modinfo(info
, attr
->attr
.name
));
2162 static void free_modinfo(struct module
*mod
)
2164 struct module_attribute
*attr
;
2167 for (i
= 0; (attr
= modinfo_attrs
[i
]); i
++) {
2173 #ifdef CONFIG_KALLSYMS
2175 /* lookup symbol in given range of kernel_symbols */
2176 static const struct kernel_symbol
*lookup_symbol(const char *name
,
2177 const struct kernel_symbol
*start
,
2178 const struct kernel_symbol
*stop
)
2180 return bsearch(name
, start
, stop
- start
,
2181 sizeof(struct kernel_symbol
), cmp_name
);
2184 static int is_exported(const char *name
, unsigned long value
,
2185 const struct module
*mod
)
2187 const struct kernel_symbol
*ks
;
2189 ks
= lookup_symbol(name
, __start___ksymtab
, __stop___ksymtab
);
2191 ks
= lookup_symbol(name
, mod
->syms
, mod
->syms
+ mod
->num_syms
);
2192 return ks
!= NULL
&& ks
->value
== value
;
2196 static char elf_type(const Elf_Sym
*sym
, const struct load_info
*info
)
2198 const Elf_Shdr
*sechdrs
= info
->sechdrs
;
2200 if (ELF_ST_BIND(sym
->st_info
) == STB_WEAK
) {
2201 if (ELF_ST_TYPE(sym
->st_info
) == STT_OBJECT
)
2206 if (sym
->st_shndx
== SHN_UNDEF
)
2208 if (sym
->st_shndx
== SHN_ABS
)
2210 if (sym
->st_shndx
>= SHN_LORESERVE
)
2212 if (sechdrs
[sym
->st_shndx
].sh_flags
& SHF_EXECINSTR
)
2214 if (sechdrs
[sym
->st_shndx
].sh_flags
& SHF_ALLOC
2215 && sechdrs
[sym
->st_shndx
].sh_type
!= SHT_NOBITS
) {
2216 if (!(sechdrs
[sym
->st_shndx
].sh_flags
& SHF_WRITE
))
2218 else if (sechdrs
[sym
->st_shndx
].sh_flags
& ARCH_SHF_SMALL
)
2223 if (sechdrs
[sym
->st_shndx
].sh_type
== SHT_NOBITS
) {
2224 if (sechdrs
[sym
->st_shndx
].sh_flags
& ARCH_SHF_SMALL
)
2229 if (strstarts(info
->secstrings
+ sechdrs
[sym
->st_shndx
].sh_name
,
2236 static bool is_core_symbol(const Elf_Sym
*src
, const Elf_Shdr
*sechdrs
,
2239 const Elf_Shdr
*sec
;
2241 if (src
->st_shndx
== SHN_UNDEF
2242 || src
->st_shndx
>= shnum
2246 sec
= sechdrs
+ src
->st_shndx
;
2247 if (!(sec
->sh_flags
& SHF_ALLOC
)
2248 #ifndef CONFIG_KALLSYMS_ALL
2249 || !(sec
->sh_flags
& SHF_EXECINSTR
)
2251 || (sec
->sh_entsize
& INIT_OFFSET_MASK
))
2258 * We only allocate and copy the strings needed by the parts of symtab
2259 * we keep. This is simple, but has the effect of making multiple
2260 * copies of duplicates. We could be more sophisticated, see
2261 * linux-kernel thread starting with
2262 * <73defb5e4bca04a6431392cc341112b1@localhost>.
2264 static void layout_symtab(struct module
*mod
, struct load_info
*info
)
2266 Elf_Shdr
*symsect
= info
->sechdrs
+ info
->index
.sym
;
2267 Elf_Shdr
*strsect
= info
->sechdrs
+ info
->index
.str
;
2269 unsigned int i
, nsrc
, ndst
, strtab_size
= 0;
2271 /* Put symbol section at end of init part of module. */
2272 symsect
->sh_flags
|= SHF_ALLOC
;
2273 symsect
->sh_entsize
= get_offset(mod
, &mod
->init_size
, symsect
,
2274 info
->index
.sym
) | INIT_OFFSET_MASK
;
2275 pr_debug("\t%s\n", info
->secstrings
+ symsect
->sh_name
);
2277 src
= (void *)info
->hdr
+ symsect
->sh_offset
;
2278 nsrc
= symsect
->sh_size
/ sizeof(*src
);
2280 /* Compute total space required for the core symbols' strtab. */
2281 for (ndst
= i
= 0; i
< nsrc
; i
++) {
2283 is_core_symbol(src
+i
, info
->sechdrs
, info
->hdr
->e_shnum
)) {
2284 strtab_size
+= strlen(&info
->strtab
[src
[i
].st_name
])+1;
2289 /* Append room for core symbols at end of core part. */
2290 info
->symoffs
= ALIGN(mod
->core_size
, symsect
->sh_addralign
?: 1);
2291 info
->stroffs
= mod
->core_size
= info
->symoffs
+ ndst
* sizeof(Elf_Sym
);
2292 mod
->core_size
+= strtab_size
;
2294 /* Put string table section at end of init part of module. */
2295 strsect
->sh_flags
|= SHF_ALLOC
;
2296 strsect
->sh_entsize
= get_offset(mod
, &mod
->init_size
, strsect
,
2297 info
->index
.str
) | INIT_OFFSET_MASK
;
2298 pr_debug("\t%s\n", info
->secstrings
+ strsect
->sh_name
);
2301 static void add_kallsyms(struct module
*mod
, const struct load_info
*info
)
2303 unsigned int i
, ndst
;
2307 Elf_Shdr
*symsec
= &info
->sechdrs
[info
->index
.sym
];
2309 mod
->symtab
= (void *)symsec
->sh_addr
;
2310 mod
->num_symtab
= symsec
->sh_size
/ sizeof(Elf_Sym
);
2311 /* Make sure we get permanent strtab: don't use info->strtab. */
2312 mod
->strtab
= (void *)info
->sechdrs
[info
->index
.str
].sh_addr
;
2314 /* Set types up while we still have access to sections. */
2315 for (i
= 0; i
< mod
->num_symtab
; i
++)
2316 mod
->symtab
[i
].st_info
= elf_type(&mod
->symtab
[i
], info
);
2318 mod
->core_symtab
= dst
= mod
->module_core
+ info
->symoffs
;
2319 mod
->core_strtab
= s
= mod
->module_core
+ info
->stroffs
;
2321 for (ndst
= i
= 0; i
< mod
->num_symtab
; i
++) {
2323 is_core_symbol(src
+i
, info
->sechdrs
, info
->hdr
->e_shnum
)) {
2325 dst
[ndst
++].st_name
= s
- mod
->core_strtab
;
2326 s
+= strlcpy(s
, &mod
->strtab
[src
[i
].st_name
],
2330 mod
->core_num_syms
= ndst
;
2333 static inline void layout_symtab(struct module
*mod
, struct load_info
*info
)
2337 static void add_kallsyms(struct module
*mod
, const struct load_info
*info
)
2340 #endif /* CONFIG_KALLSYMS */
2342 static void dynamic_debug_setup(struct _ddebug
*debug
, unsigned int num
)
2346 #ifdef CONFIG_DYNAMIC_DEBUG
2347 if (ddebug_add_module(debug
, num
, debug
->modname
))
2348 pr_err("dynamic debug error adding module: %s\n",
2353 static void dynamic_debug_remove(struct _ddebug
*debug
)
2356 ddebug_remove_module(debug
->modname
);
2359 void * __weak
module_alloc(unsigned long size
)
2361 return vmalloc_exec(size
);
2364 static void *module_alloc_update_bounds(unsigned long size
)
2366 void *ret
= module_alloc(size
);
2369 mutex_lock(&module_mutex
);
2370 /* Update module bounds. */
2371 if ((unsigned long)ret
< module_addr_min
)
2372 module_addr_min
= (unsigned long)ret
;
2373 if ((unsigned long)ret
+ size
> module_addr_max
)
2374 module_addr_max
= (unsigned long)ret
+ size
;
2375 mutex_unlock(&module_mutex
);
2380 #ifdef CONFIG_DEBUG_KMEMLEAK
2381 static void kmemleak_load_module(const struct module
*mod
,
2382 const struct load_info
*info
)
2386 /* only scan the sections containing data */
2387 kmemleak_scan_area(mod
, sizeof(struct module
), GFP_KERNEL
);
2389 for (i
= 1; i
< info
->hdr
->e_shnum
; i
++) {
2390 /* Scan all writable sections that's not executable */
2391 if (!(info
->sechdrs
[i
].sh_flags
& SHF_ALLOC
) ||
2392 !(info
->sechdrs
[i
].sh_flags
& SHF_WRITE
) ||
2393 (info
->sechdrs
[i
].sh_flags
& SHF_EXECINSTR
))
2396 kmemleak_scan_area((void *)info
->sechdrs
[i
].sh_addr
,
2397 info
->sechdrs
[i
].sh_size
, GFP_KERNEL
);
2401 static inline void kmemleak_load_module(const struct module
*mod
,
2402 const struct load_info
*info
)
2407 #ifdef CONFIG_MODULE_SIG
2408 static int module_sig_check(struct load_info
*info
)
2411 const unsigned long markerlen
= sizeof(MODULE_SIG_STRING
) - 1;
2412 const void *mod
= info
->hdr
;
2414 if (info
->len
> markerlen
&&
2415 memcmp(mod
+ info
->len
- markerlen
, MODULE_SIG_STRING
, markerlen
) == 0) {
2416 /* We truncate the module to discard the signature */
2417 info
->len
-= markerlen
;
2418 err
= mod_verify_sig(mod
, &info
->len
);
2422 info
->sig_ok
= true;
2426 /* Not having a signature is only an error if we're strict. */
2427 if (err
== -ENOKEY
&& !sig_enforce
)
2432 #else /* !CONFIG_MODULE_SIG */
2433 static int module_sig_check(struct load_info
*info
)
2437 #endif /* !CONFIG_MODULE_SIG */
2439 /* Sanity checks against invalid binaries, wrong arch, weird elf version. */
2440 static int elf_header_check(struct load_info
*info
)
2442 if (info
->len
< sizeof(*(info
->hdr
)))
2445 if (memcmp(info
->hdr
->e_ident
, ELFMAG
, SELFMAG
) != 0
2446 || info
->hdr
->e_type
!= ET_REL
2447 || !elf_check_arch(info
->hdr
)
2448 || info
->hdr
->e_shentsize
!= sizeof(Elf_Shdr
))
2451 if (info
->hdr
->e_shoff
>= info
->len
2452 || (info
->hdr
->e_shnum
* sizeof(Elf_Shdr
) >
2453 info
->len
- info
->hdr
->e_shoff
))
2459 /* Sets info->hdr and info->len. */
2460 static int copy_module_from_user(const void __user
*umod
, unsigned long len
,
2461 struct load_info
*info
)
2466 if (info
->len
< sizeof(*(info
->hdr
)))
2469 err
= security_kernel_module_from_file(NULL
);
2473 /* Suck in entire file: we'll want most of it. */
2474 info
->hdr
= vmalloc(info
->len
);
2478 if (copy_from_user(info
->hdr
, umod
, info
->len
) != 0) {
2486 /* Sets info->hdr and info->len. */
2487 static int copy_module_from_fd(int fd
, struct load_info
*info
)
2489 struct fd f
= fdget(fd
);
2498 err
= security_kernel_module_from_file(f
.file
);
2502 err
= vfs_getattr(&f
.file
->f_path
, &stat
);
2506 if (stat
.size
> INT_MAX
) {
2511 /* Don't hand 0 to vmalloc, it whines. */
2512 if (stat
.size
== 0) {
2517 info
->hdr
= vmalloc(stat
.size
);
2524 while (pos
< stat
.size
) {
2525 bytes
= kernel_read(f
.file
, pos
, (char *)(info
->hdr
) + pos
,
2543 static void free_copy(struct load_info
*info
)
2548 static int rewrite_section_headers(struct load_info
*info
, int flags
)
2552 /* This should always be true, but let's be sure. */
2553 info
->sechdrs
[0].sh_addr
= 0;
2555 for (i
= 1; i
< info
->hdr
->e_shnum
; i
++) {
2556 Elf_Shdr
*shdr
= &info
->sechdrs
[i
];
2557 if (shdr
->sh_type
!= SHT_NOBITS
2558 && info
->len
< shdr
->sh_offset
+ shdr
->sh_size
) {
2559 pr_err("Module len %lu truncated\n", info
->len
);
2563 /* Mark all sections sh_addr with their address in the
2565 shdr
->sh_addr
= (size_t)info
->hdr
+ shdr
->sh_offset
;
2567 #ifndef CONFIG_MODULE_UNLOAD
2568 /* Don't load .exit sections */
2569 if (strstarts(info
->secstrings
+shdr
->sh_name
, ".exit"))
2570 shdr
->sh_flags
&= ~(unsigned long)SHF_ALLOC
;
2574 /* Track but don't keep modinfo and version sections. */
2575 if (flags
& MODULE_INIT_IGNORE_MODVERSIONS
)
2576 info
->index
.vers
= 0; /* Pretend no __versions section! */
2578 info
->index
.vers
= find_sec(info
, "__versions");
2579 info
->index
.info
= find_sec(info
, ".modinfo");
2580 info
->sechdrs
[info
->index
.info
].sh_flags
&= ~(unsigned long)SHF_ALLOC
;
2581 info
->sechdrs
[info
->index
.vers
].sh_flags
&= ~(unsigned long)SHF_ALLOC
;
2586 * Set up our basic convenience variables (pointers to section headers,
2587 * search for module section index etc), and do some basic section
2590 * Return the temporary module pointer (we'll replace it with the final
2591 * one when we move the module sections around).
2593 static struct module
*setup_load_info(struct load_info
*info
, int flags
)
2599 /* Set up the convenience variables */
2600 info
->sechdrs
= (void *)info
->hdr
+ info
->hdr
->e_shoff
;
2601 info
->secstrings
= (void *)info
->hdr
2602 + info
->sechdrs
[info
->hdr
->e_shstrndx
].sh_offset
;
2604 err
= rewrite_section_headers(info
, flags
);
2606 return ERR_PTR(err
);
2608 /* Find internal symbols and strings. */
2609 for (i
= 1; i
< info
->hdr
->e_shnum
; i
++) {
2610 if (info
->sechdrs
[i
].sh_type
== SHT_SYMTAB
) {
2611 info
->index
.sym
= i
;
2612 info
->index
.str
= info
->sechdrs
[i
].sh_link
;
2613 info
->strtab
= (char *)info
->hdr
2614 + info
->sechdrs
[info
->index
.str
].sh_offset
;
2619 info
->index
.mod
= find_sec(info
, ".gnu.linkonce.this_module");
2620 if (!info
->index
.mod
) {
2621 pr_warn("No module found in object\n");
2622 return ERR_PTR(-ENOEXEC
);
2624 /* This is temporary: point mod into copy of data. */
2625 mod
= (void *)info
->sechdrs
[info
->index
.mod
].sh_addr
;
2627 if (info
->index
.sym
== 0) {
2628 pr_warn("%s: module has no symbols (stripped?)\n", mod
->name
);
2629 return ERR_PTR(-ENOEXEC
);
2632 info
->index
.pcpu
= find_pcpusec(info
);
2634 /* Check module struct version now, before we try to use module. */
2635 if (!check_modstruct_version(info
->sechdrs
, info
->index
.vers
, mod
))
2636 return ERR_PTR(-ENOEXEC
);
2641 static int check_modinfo(struct module
*mod
, struct load_info
*info
, int flags
)
2643 const char *modmagic
= get_modinfo(info
, "vermagic");
2646 if (flags
& MODULE_INIT_IGNORE_VERMAGIC
)
2649 /* This is allowed: modprobe --force will invalidate it. */
2651 err
= try_to_force_load(mod
, "bad vermagic");
2654 } else if (!same_magic(modmagic
, vermagic
, info
->index
.vers
)) {
2655 pr_err("%s: version magic '%s' should be '%s'\n",
2656 mod
->name
, modmagic
, vermagic
);
2660 if (!get_modinfo(info
, "intree"))
2661 add_taint_module(mod
, TAINT_OOT_MODULE
, LOCKDEP_STILL_OK
);
2663 if (get_modinfo(info
, "staging")) {
2664 add_taint_module(mod
, TAINT_CRAP
, LOCKDEP_STILL_OK
);
2665 pr_warn("%s: module is from the staging directory, the quality "
2666 "is unknown, you have been warned.\n", mod
->name
);
2669 /* Set up license info based on the info section */
2670 set_license(mod
, get_modinfo(info
, "license"));
2675 static int find_module_sections(struct module
*mod
, struct load_info
*info
)
2677 mod
->kp
= section_objs(info
, "__param",
2678 sizeof(*mod
->kp
), &mod
->num_kp
);
2679 mod
->syms
= section_objs(info
, "__ksymtab",
2680 sizeof(*mod
->syms
), &mod
->num_syms
);
2681 mod
->crcs
= section_addr(info
, "__kcrctab");
2682 mod
->gpl_syms
= section_objs(info
, "__ksymtab_gpl",
2683 sizeof(*mod
->gpl_syms
),
2684 &mod
->num_gpl_syms
);
2685 mod
->gpl_crcs
= section_addr(info
, "__kcrctab_gpl");
2686 mod
->gpl_future_syms
= section_objs(info
,
2687 "__ksymtab_gpl_future",
2688 sizeof(*mod
->gpl_future_syms
),
2689 &mod
->num_gpl_future_syms
);
2690 mod
->gpl_future_crcs
= section_addr(info
, "__kcrctab_gpl_future");
2692 #ifdef CONFIG_UNUSED_SYMBOLS
2693 mod
->unused_syms
= section_objs(info
, "__ksymtab_unused",
2694 sizeof(*mod
->unused_syms
),
2695 &mod
->num_unused_syms
);
2696 mod
->unused_crcs
= section_addr(info
, "__kcrctab_unused");
2697 mod
->unused_gpl_syms
= section_objs(info
, "__ksymtab_unused_gpl",
2698 sizeof(*mod
->unused_gpl_syms
),
2699 &mod
->num_unused_gpl_syms
);
2700 mod
->unused_gpl_crcs
= section_addr(info
, "__kcrctab_unused_gpl");
2702 #ifdef CONFIG_CONSTRUCTORS
2703 mod
->ctors
= section_objs(info
, ".ctors",
2704 sizeof(*mod
->ctors
), &mod
->num_ctors
);
2706 mod
->ctors
= section_objs(info
, ".init_array",
2707 sizeof(*mod
->ctors
), &mod
->num_ctors
);
2708 else if (find_sec(info
, ".init_array")) {
2710 * This shouldn't happen with same compiler and binutils
2711 * building all parts of the module.
2713 printk(KERN_WARNING
"%s: has both .ctors and .init_array.\n",
2719 #ifdef CONFIG_TRACEPOINTS
2720 mod
->tracepoints_ptrs
= section_objs(info
, "__tracepoints_ptrs",
2721 sizeof(*mod
->tracepoints_ptrs
),
2722 &mod
->num_tracepoints
);
2724 #ifdef HAVE_JUMP_LABEL
2725 mod
->jump_entries
= section_objs(info
, "__jump_table",
2726 sizeof(*mod
->jump_entries
),
2727 &mod
->num_jump_entries
);
2729 #ifdef CONFIG_EVENT_TRACING
2730 mod
->trace_events
= section_objs(info
, "_ftrace_events",
2731 sizeof(*mod
->trace_events
),
2732 &mod
->num_trace_events
);
2734 #ifdef CONFIG_TRACING
2735 mod
->trace_bprintk_fmt_start
= section_objs(info
, "__trace_printk_fmt",
2736 sizeof(*mod
->trace_bprintk_fmt_start
),
2737 &mod
->num_trace_bprintk_fmt
);
2739 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
2740 /* sechdrs[0].sh_size is always zero */
2741 mod
->ftrace_callsites
= section_objs(info
, "__mcount_loc",
2742 sizeof(*mod
->ftrace_callsites
),
2743 &mod
->num_ftrace_callsites
);
2746 mod
->extable
= section_objs(info
, "__ex_table",
2747 sizeof(*mod
->extable
), &mod
->num_exentries
);
2749 if (section_addr(info
, "__obsparm"))
2750 pr_warn("%s: Ignoring obsolete parameters\n", mod
->name
);
2752 info
->debug
= section_objs(info
, "__verbose",
2753 sizeof(*info
->debug
), &info
->num_debug
);
2758 static int move_module(struct module
*mod
, struct load_info
*info
)
2763 /* Do the allocs. */
2764 ptr
= module_alloc_update_bounds(mod
->core_size
);
2766 * The pointer to this block is stored in the module structure
2767 * which is inside the block. Just mark it as not being a
2770 kmemleak_not_leak(ptr
);
2774 memset(ptr
, 0, mod
->core_size
);
2775 mod
->module_core
= ptr
;
2777 if (mod
->init_size
) {
2778 ptr
= module_alloc_update_bounds(mod
->init_size
);
2780 * The pointer to this block is stored in the module structure
2781 * which is inside the block. This block doesn't need to be
2782 * scanned as it contains data and code that will be freed
2783 * after the module is initialized.
2785 kmemleak_ignore(ptr
);
2787 module_free(mod
, mod
->module_core
);
2790 memset(ptr
, 0, mod
->init_size
);
2791 mod
->module_init
= ptr
;
2793 mod
->module_init
= NULL
;
2795 /* Transfer each section which specifies SHF_ALLOC */
2796 pr_debug("final section addresses:\n");
2797 for (i
= 0; i
< info
->hdr
->e_shnum
; i
++) {
2799 Elf_Shdr
*shdr
= &info
->sechdrs
[i
];
2801 if (!(shdr
->sh_flags
& SHF_ALLOC
))
2804 if (shdr
->sh_entsize
& INIT_OFFSET_MASK
)
2805 dest
= mod
->module_init
2806 + (shdr
->sh_entsize
& ~INIT_OFFSET_MASK
);
2808 dest
= mod
->module_core
+ shdr
->sh_entsize
;
2810 if (shdr
->sh_type
!= SHT_NOBITS
)
2811 memcpy(dest
, (void *)shdr
->sh_addr
, shdr
->sh_size
);
2812 /* Update sh_addr to point to copy in image. */
2813 shdr
->sh_addr
= (unsigned long)dest
;
2814 pr_debug("\t0x%lx %s\n",
2815 (long)shdr
->sh_addr
, info
->secstrings
+ shdr
->sh_name
);
2821 static int check_module_license_and_versions(struct module
*mod
)
2824 * ndiswrapper is under GPL by itself, but loads proprietary modules.
2825 * Don't use add_taint_module(), as it would prevent ndiswrapper from
2826 * using GPL-only symbols it needs.
2828 if (strcmp(mod
->name
, "ndiswrapper") == 0)
2829 add_taint(TAINT_PROPRIETARY_MODULE
, LOCKDEP_NOW_UNRELIABLE
);
2831 /* driverloader was caught wrongly pretending to be under GPL */
2832 if (strcmp(mod
->name
, "driverloader") == 0)
2833 add_taint_module(mod
, TAINT_PROPRIETARY_MODULE
,
2834 LOCKDEP_NOW_UNRELIABLE
);
2836 /* lve claims to be GPL but upstream won't provide source */
2837 if (strcmp(mod
->name
, "lve") == 0)
2838 add_taint_module(mod
, TAINT_PROPRIETARY_MODULE
,
2839 LOCKDEP_NOW_UNRELIABLE
);
2841 #ifdef CONFIG_MODVERSIONS
2842 if ((mod
->num_syms
&& !mod
->crcs
)
2843 || (mod
->num_gpl_syms
&& !mod
->gpl_crcs
)
2844 || (mod
->num_gpl_future_syms
&& !mod
->gpl_future_crcs
)
2845 #ifdef CONFIG_UNUSED_SYMBOLS
2846 || (mod
->num_unused_syms
&& !mod
->unused_crcs
)
2847 || (mod
->num_unused_gpl_syms
&& !mod
->unused_gpl_crcs
)
2850 return try_to_force_load(mod
,
2851 "no versions for exported symbols");
2857 static void flush_module_icache(const struct module
*mod
)
2859 mm_segment_t old_fs
;
2861 /* flush the icache in correct context */
2866 * Flush the instruction cache, since we've played with text.
2867 * Do it before processing of module parameters, so the module
2868 * can provide parameter accessor functions of its own.
2870 if (mod
->module_init
)
2871 flush_icache_range((unsigned long)mod
->module_init
,
2872 (unsigned long)mod
->module_init
2874 flush_icache_range((unsigned long)mod
->module_core
,
2875 (unsigned long)mod
->module_core
+ mod
->core_size
);
2880 int __weak
module_frob_arch_sections(Elf_Ehdr
*hdr
,
2888 static struct module
*layout_and_allocate(struct load_info
*info
, int flags
)
2890 /* Module within temporary copy. */
2894 mod
= setup_load_info(info
, flags
);
2898 err
= check_modinfo(mod
, info
, flags
);
2900 return ERR_PTR(err
);
2902 /* Allow arches to frob section contents and sizes. */
2903 err
= module_frob_arch_sections(info
->hdr
, info
->sechdrs
,
2904 info
->secstrings
, mod
);
2906 return ERR_PTR(err
);
2908 /* We will do a special allocation for per-cpu sections later. */
2909 info
->sechdrs
[info
->index
.pcpu
].sh_flags
&= ~(unsigned long)SHF_ALLOC
;
2911 /* Determine total sizes, and put offsets in sh_entsize. For now
2912 this is done generically; there doesn't appear to be any
2913 special cases for the architectures. */
2914 layout_sections(mod
, info
);
2915 layout_symtab(mod
, info
);
2917 /* Allocate and move to the final place */
2918 err
= move_module(mod
, info
);
2920 return ERR_PTR(err
);
2922 /* Module has been copied to its final place now: return it. */
2923 mod
= (void *)info
->sechdrs
[info
->index
.mod
].sh_addr
;
2924 kmemleak_load_module(mod
, info
);
2928 /* mod is no longer valid after this! */
2929 static void module_deallocate(struct module
*mod
, struct load_info
*info
)
2931 percpu_modfree(mod
);
2932 module_free(mod
, mod
->module_init
);
2933 module_free(mod
, mod
->module_core
);
2936 int __weak
module_finalize(const Elf_Ehdr
*hdr
,
2937 const Elf_Shdr
*sechdrs
,
2943 static int post_relocation(struct module
*mod
, const struct load_info
*info
)
2945 /* Sort exception table now relocations are done. */
2946 sort_extable(mod
->extable
, mod
->extable
+ mod
->num_exentries
);
2948 /* Copy relocated percpu area over. */
2949 percpu_modcopy(mod
, (void *)info
->sechdrs
[info
->index
.pcpu
].sh_addr
,
2950 info
->sechdrs
[info
->index
.pcpu
].sh_size
);
2952 /* Setup kallsyms-specific fields. */
2953 add_kallsyms(mod
, info
);
2955 /* Arch-specific module finalizing. */
2956 return module_finalize(info
->hdr
, info
->sechdrs
, mod
);
2959 /* Is this module of this name done loading? No locks held. */
2960 static bool finished_loading(const char *name
)
2965 mutex_lock(&module_mutex
);
2966 mod
= find_module_all(name
, strlen(name
), true);
2967 ret
= !mod
|| mod
->state
== MODULE_STATE_LIVE
2968 || mod
->state
== MODULE_STATE_GOING
;
2969 mutex_unlock(&module_mutex
);
2974 /* Call module constructors. */
2975 static void do_mod_ctors(struct module
*mod
)
2977 #ifdef CONFIG_CONSTRUCTORS
2980 for (i
= 0; i
< mod
->num_ctors
; i
++)
2985 /* This is where the real work happens */
2986 static int do_init_module(struct module
*mod
)
2991 * We want to find out whether @mod uses async during init. Clear
2992 * PF_USED_ASYNC. async_schedule*() will set it.
2994 current
->flags
&= ~PF_USED_ASYNC
;
2997 /* Start the module */
2998 if (mod
->init
!= NULL
)
2999 ret
= do_one_initcall(mod
->init
);
3001 /* Init routine failed: abort. Try to protect us from
3002 buggy refcounters. */
3003 mod
->state
= MODULE_STATE_GOING
;
3004 synchronize_sched();
3006 blocking_notifier_call_chain(&module_notify_list
,
3007 MODULE_STATE_GOING
, mod
);
3009 wake_up_all(&module_wq
);
3013 pr_warn("%s: '%s'->init suspiciously returned %d, it should "
3014 "follow 0/-E convention\n"
3015 "%s: loading module anyway...\n",
3016 __func__
, mod
->name
, ret
, __func__
);
3020 /* Now it's a first class citizen! */
3021 mod
->state
= MODULE_STATE_LIVE
;
3022 blocking_notifier_call_chain(&module_notify_list
,
3023 MODULE_STATE_LIVE
, mod
);
3026 * We need to finish all async code before the module init sequence
3027 * is done. This has potential to deadlock. For example, a newly
3028 * detected block device can trigger request_module() of the
3029 * default iosched from async probing task. Once userland helper
3030 * reaches here, async_synchronize_full() will wait on the async
3031 * task waiting on request_module() and deadlock.
3033 * This deadlock is avoided by perfomring async_synchronize_full()
3034 * iff module init queued any async jobs. This isn't a full
3035 * solution as it will deadlock the same if module loading from
3036 * async jobs nests more than once; however, due to the various
3037 * constraints, this hack seems to be the best option for now.
3038 * Please refer to the following thread for details.
3040 * http://thread.gmane.org/gmane.linux.kernel/1420814
3042 if (current
->flags
& PF_USED_ASYNC
)
3043 async_synchronize_full();
3045 mutex_lock(&module_mutex
);
3046 /* Drop initial reference. */
3048 trim_init_extable(mod
);
3049 #ifdef CONFIG_KALLSYMS
3050 mod
->num_symtab
= mod
->core_num_syms
;
3051 mod
->symtab
= mod
->core_symtab
;
3052 mod
->strtab
= mod
->core_strtab
;
3054 unset_module_init_ro_nx(mod
);
3055 module_free(mod
, mod
->module_init
);
3056 mod
->module_init
= NULL
;
3058 mod
->init_ro_size
= 0;
3059 mod
->init_text_size
= 0;
3060 mutex_unlock(&module_mutex
);
3061 wake_up_all(&module_wq
);
3066 static int may_init_module(void)
3068 if (!capable(CAP_SYS_MODULE
) || modules_disabled
)
3075 * We try to place it in the list now to make sure it's unique before
3076 * we dedicate too many resources. In particular, temporary percpu
3077 * memory exhaustion.
3079 static int add_unformed_module(struct module
*mod
)
3084 mod
->state
= MODULE_STATE_UNFORMED
;
3087 mutex_lock(&module_mutex
);
3088 old
= find_module_all(mod
->name
, strlen(mod
->name
), true);
3090 if (old
->state
== MODULE_STATE_COMING
3091 || old
->state
== MODULE_STATE_UNFORMED
) {
3092 /* Wait in case it fails to load. */
3093 mutex_unlock(&module_mutex
);
3094 err
= wait_event_interruptible(module_wq
,
3095 finished_loading(mod
->name
));
3103 list_add_rcu(&mod
->list
, &modules
);
3107 mutex_unlock(&module_mutex
);
3112 static int complete_formation(struct module
*mod
, struct load_info
*info
)
3116 mutex_lock(&module_mutex
);
3118 /* Find duplicate symbols (must be called under lock). */
3119 err
= verify_export_symbols(mod
);
3123 /* This relies on module_mutex for list integrity. */
3124 module_bug_finalize(info
->hdr
, info
->sechdrs
, mod
);
3126 /* Set RO and NX regions for core */
3127 set_section_ro_nx(mod
->module_core
,
3128 mod
->core_text_size
,
3132 /* Set RO and NX regions for init */
3133 set_section_ro_nx(mod
->module_init
,
3134 mod
->init_text_size
,
3138 /* Mark state as coming so strong_try_module_get() ignores us,
3139 * but kallsyms etc. can see us. */
3140 mod
->state
= MODULE_STATE_COMING
;
3141 mutex_unlock(&module_mutex
);
3143 blocking_notifier_call_chain(&module_notify_list
,
3144 MODULE_STATE_COMING
, mod
);
3148 mutex_unlock(&module_mutex
);
3152 static int unknown_module_param_cb(char *param
, char *val
, const char *modname
)
3154 /* Check for magic 'dyndbg' arg */
3155 int ret
= ddebug_dyndbg_module_param_cb(param
, val
, modname
);
3157 pr_warn("%s: unknown parameter '%s' ignored\n", modname
, param
);
3161 /* Allocate and load the module: note that size of section 0 is always
3162 zero, and we rely on this for optional sections. */
3163 static int load_module(struct load_info
*info
, const char __user
*uargs
,
3170 err
= module_sig_check(info
);
3174 err
= elf_header_check(info
);
3178 /* Figure out module layout, and allocate all the memory. */
3179 mod
= layout_and_allocate(info
, flags
);
3185 /* Reserve our place in the list. */
3186 err
= add_unformed_module(mod
);
3190 #ifdef CONFIG_MODULE_SIG
3191 mod
->sig_ok
= info
->sig_ok
;
3193 pr_notice_once("%s: module verification failed: signature "
3194 "and/or required key missing - tainting "
3195 "kernel\n", mod
->name
);
3196 add_taint_module(mod
, TAINT_UNSIGNED_MODULE
, LOCKDEP_STILL_OK
);
3200 /* To avoid stressing percpu allocator, do this once we're unique. */
3201 err
= percpu_modalloc(mod
, info
);
3205 /* Now module is in final location, initialize linked lists, etc. */
3206 err
= module_unload_init(mod
);
3210 /* Now we've got everything in the final locations, we can
3211 * find optional sections. */
3212 err
= find_module_sections(mod
, info
);
3216 err
= check_module_license_and_versions(mod
);
3220 /* Set up MODINFO_ATTR fields */
3221 setup_modinfo(mod
, info
);
3223 /* Fix up syms, so that st_value is a pointer to location. */
3224 err
= simplify_symbols(mod
, info
);
3228 err
= apply_relocations(mod
, info
);
3232 err
= post_relocation(mod
, info
);
3236 flush_module_icache(mod
);
3238 /* Now copy in args */
3239 mod
->args
= strndup_user(uargs
, ~0UL >> 1);
3240 if (IS_ERR(mod
->args
)) {
3241 err
= PTR_ERR(mod
->args
);
3242 goto free_arch_cleanup
;
3245 dynamic_debug_setup(info
->debug
, info
->num_debug
);
3247 /* Ftrace init must be called in the MODULE_STATE_UNFORMED state */
3248 ftrace_module_init(mod
);
3250 /* Finally it's fully formed, ready to start executing. */
3251 err
= complete_formation(mod
, info
);
3253 goto ddebug_cleanup
;
3255 /* Module is ready to execute: parsing args may do that. */
3256 after_dashes
= parse_args(mod
->name
, mod
->args
, mod
->kp
, mod
->num_kp
,
3257 -32768, 32767, unknown_module_param_cb
);
3258 if (IS_ERR(after_dashes
)) {
3259 err
= PTR_ERR(after_dashes
);
3261 } else if (after_dashes
) {
3262 pr_warn("%s: parameters '%s' after `--' ignored\n",
3263 mod
->name
, after_dashes
);
3266 /* Link in to syfs. */
3267 err
= mod_sysfs_setup(mod
, info
, mod
->kp
, mod
->num_kp
);
3271 /* Get rid of temporary copy. */
3275 trace_module_load(mod
);
3277 return do_init_module(mod
);
3280 /* module_bug_cleanup needs module_mutex protection */
3281 mutex_lock(&module_mutex
);
3282 module_bug_cleanup(mod
);
3283 mutex_unlock(&module_mutex
);
3285 /* we can't deallocate the module until we clear memory protection */
3286 unset_module_init_ro_nx(mod
);
3287 unset_module_core_ro_nx(mod
);
3290 dynamic_debug_remove(info
->debug
);
3291 synchronize_sched();
3294 module_arch_cleanup(mod
);
3298 module_unload_free(mod
);
3300 mutex_lock(&module_mutex
);
3301 /* Unlink carefully: kallsyms could be walking list. */
3302 list_del_rcu(&mod
->list
);
3303 wake_up_all(&module_wq
);
3304 /* Wait for RCU synchronizing before releasing mod->list. */
3306 mutex_unlock(&module_mutex
);
3308 module_deallocate(mod
, info
);
3314 SYSCALL_DEFINE3(init_module
, void __user
*, umod
,
3315 unsigned long, len
, const char __user
*, uargs
)
3318 struct load_info info
= { };
3320 err
= may_init_module();
3324 pr_debug("init_module: umod=%p, len=%lu, uargs=%p\n",
3327 err
= copy_module_from_user(umod
, len
, &info
);
3331 return load_module(&info
, uargs
, 0);
3334 SYSCALL_DEFINE3(finit_module
, int, fd
, const char __user
*, uargs
, int, flags
)
3337 struct load_info info
= { };
3339 err
= may_init_module();
3343 pr_debug("finit_module: fd=%d, uargs=%p, flags=%i\n", fd
, uargs
, flags
);
3345 if (flags
& ~(MODULE_INIT_IGNORE_MODVERSIONS
3346 |MODULE_INIT_IGNORE_VERMAGIC
))
3349 err
= copy_module_from_fd(fd
, &info
);
3353 return load_module(&info
, uargs
, flags
);
3356 static inline int within(unsigned long addr
, void *start
, unsigned long size
)
3358 return ((void *)addr
>= start
&& (void *)addr
< start
+ size
);
3361 #ifdef CONFIG_KALLSYMS
3363 * This ignores the intensely annoying "mapping symbols" found
3364 * in ARM ELF files: $a, $t and $d.
3366 static inline int is_arm_mapping_symbol(const char *str
)
3368 if (str
[0] == '.' && str
[1] == 'L')
3370 return str
[0] == '$' && strchr("axtd", str
[1])
3371 && (str
[2] == '\0' || str
[2] == '.');
3374 static const char *get_ksymbol(struct module
*mod
,
3376 unsigned long *size
,
3377 unsigned long *offset
)
3379 unsigned int i
, best
= 0;
3380 unsigned long nextval
;
3382 /* At worse, next value is at end of module */
3383 if (within_module_init(addr
, mod
))
3384 nextval
= (unsigned long)mod
->module_init
+mod
->init_text_size
;
3386 nextval
= (unsigned long)mod
->module_core
+mod
->core_text_size
;
3388 /* Scan for closest preceding symbol, and next symbol. (ELF
3389 starts real symbols at 1). */
3390 for (i
= 1; i
< mod
->num_symtab
; i
++) {
3391 if (mod
->symtab
[i
].st_shndx
== SHN_UNDEF
)
3394 /* We ignore unnamed symbols: they're uninformative
3395 * and inserted at a whim. */
3396 if (mod
->symtab
[i
].st_value
<= addr
3397 && mod
->symtab
[i
].st_value
> mod
->symtab
[best
].st_value
3398 && *(mod
->strtab
+ mod
->symtab
[i
].st_name
) != '\0'
3399 && !is_arm_mapping_symbol(mod
->strtab
+ mod
->symtab
[i
].st_name
))
3401 if (mod
->symtab
[i
].st_value
> addr
3402 && mod
->symtab
[i
].st_value
< nextval
3403 && *(mod
->strtab
+ mod
->symtab
[i
].st_name
) != '\0'
3404 && !is_arm_mapping_symbol(mod
->strtab
+ mod
->symtab
[i
].st_name
))
3405 nextval
= mod
->symtab
[i
].st_value
;
3412 *size
= nextval
- mod
->symtab
[best
].st_value
;
3414 *offset
= addr
- mod
->symtab
[best
].st_value
;
3415 return mod
->strtab
+ mod
->symtab
[best
].st_name
;
3418 /* For kallsyms to ask for address resolution. NULL means not found. Careful
3419 * not to lock to avoid deadlock on oopses, simply disable preemption. */
3420 const char *module_address_lookup(unsigned long addr
,
3421 unsigned long *size
,
3422 unsigned long *offset
,
3427 const char *ret
= NULL
;
3430 list_for_each_entry_rcu(mod
, &modules
, list
) {
3431 if (mod
->state
== MODULE_STATE_UNFORMED
)
3433 if (within_module(addr
, mod
)) {
3435 *modname
= mod
->name
;
3436 ret
= get_ksymbol(mod
, addr
, size
, offset
);
3440 /* Make a copy in here where it's safe */
3442 strncpy(namebuf
, ret
, KSYM_NAME_LEN
- 1);
3449 int lookup_module_symbol_name(unsigned long addr
, char *symname
)
3454 list_for_each_entry_rcu(mod
, &modules
, list
) {
3455 if (mod
->state
== MODULE_STATE_UNFORMED
)
3457 if (within_module(addr
, mod
)) {
3460 sym
= get_ksymbol(mod
, addr
, NULL
, NULL
);
3463 strlcpy(symname
, sym
, KSYM_NAME_LEN
);
3473 int lookup_module_symbol_attrs(unsigned long addr
, unsigned long *size
,
3474 unsigned long *offset
, char *modname
, char *name
)
3479 list_for_each_entry_rcu(mod
, &modules
, list
) {
3480 if (mod
->state
== MODULE_STATE_UNFORMED
)
3482 if (within_module(addr
, mod
)) {
3485 sym
= get_ksymbol(mod
, addr
, size
, offset
);
3489 strlcpy(modname
, mod
->name
, MODULE_NAME_LEN
);
3491 strlcpy(name
, sym
, KSYM_NAME_LEN
);
3501 int module_get_kallsym(unsigned int symnum
, unsigned long *value
, char *type
,
3502 char *name
, char *module_name
, int *exported
)
3507 list_for_each_entry_rcu(mod
, &modules
, list
) {
3508 if (mod
->state
== MODULE_STATE_UNFORMED
)
3510 if (symnum
< mod
->num_symtab
) {
3511 *value
= mod
->symtab
[symnum
].st_value
;
3512 *type
= mod
->symtab
[symnum
].st_info
;
3513 strlcpy(name
, mod
->strtab
+ mod
->symtab
[symnum
].st_name
,
3515 strlcpy(module_name
, mod
->name
, MODULE_NAME_LEN
);
3516 *exported
= is_exported(name
, *value
, mod
);
3520 symnum
-= mod
->num_symtab
;
3526 static unsigned long mod_find_symname(struct module
*mod
, const char *name
)
3530 for (i
= 0; i
< mod
->num_symtab
; i
++)
3531 if (strcmp(name
, mod
->strtab
+mod
->symtab
[i
].st_name
) == 0 &&
3532 mod
->symtab
[i
].st_info
!= 'U')
3533 return mod
->symtab
[i
].st_value
;
3537 /* Look for this name: can be of form module:name. */
3538 unsigned long module_kallsyms_lookup_name(const char *name
)
3542 unsigned long ret
= 0;
3544 /* Don't lock: we're in enough trouble already. */
3546 if ((colon
= strchr(name
, ':')) != NULL
) {
3547 if ((mod
= find_module_all(name
, colon
- name
, false)) != NULL
)
3548 ret
= mod_find_symname(mod
, colon
+1);
3550 list_for_each_entry_rcu(mod
, &modules
, list
) {
3551 if (mod
->state
== MODULE_STATE_UNFORMED
)
3553 if ((ret
= mod_find_symname(mod
, name
)) != 0)
3561 int module_kallsyms_on_each_symbol(int (*fn
)(void *, const char *,
3562 struct module
*, unsigned long),
3569 list_for_each_entry(mod
, &modules
, list
) {
3570 if (mod
->state
== MODULE_STATE_UNFORMED
)
3572 for (i
= 0; i
< mod
->num_symtab
; i
++) {
3573 ret
= fn(data
, mod
->strtab
+ mod
->symtab
[i
].st_name
,
3574 mod
, mod
->symtab
[i
].st_value
);
3581 #endif /* CONFIG_KALLSYMS */
3583 static char *module_flags(struct module
*mod
, char *buf
)
3587 BUG_ON(mod
->state
== MODULE_STATE_UNFORMED
);
3589 mod
->state
== MODULE_STATE_GOING
||
3590 mod
->state
== MODULE_STATE_COMING
) {
3592 bx
+= module_flags_taint(mod
, buf
+ bx
);
3593 /* Show a - for module-is-being-unloaded */
3594 if (mod
->state
== MODULE_STATE_GOING
)
3596 /* Show a + for module-is-being-loaded */
3597 if (mod
->state
== MODULE_STATE_COMING
)
3606 #ifdef CONFIG_PROC_FS
3607 /* Called by the /proc file system to return a list of modules. */
3608 static void *m_start(struct seq_file
*m
, loff_t
*pos
)
3610 mutex_lock(&module_mutex
);
3611 return seq_list_start(&modules
, *pos
);
3614 static void *m_next(struct seq_file
*m
, void *p
, loff_t
*pos
)
3616 return seq_list_next(p
, &modules
, pos
);
3619 static void m_stop(struct seq_file
*m
, void *p
)
3621 mutex_unlock(&module_mutex
);
3624 static int m_show(struct seq_file
*m
, void *p
)
3626 struct module
*mod
= list_entry(p
, struct module
, list
);
3629 /* We always ignore unformed modules. */
3630 if (mod
->state
== MODULE_STATE_UNFORMED
)
3633 seq_printf(m
, "%s %u",
3634 mod
->name
, mod
->init_size
+ mod
->core_size
);
3635 print_unload_info(m
, mod
);
3637 /* Informative for users. */
3638 seq_printf(m
, " %s",
3639 mod
->state
== MODULE_STATE_GOING
? "Unloading":
3640 mod
->state
== MODULE_STATE_COMING
? "Loading":
3642 /* Used by oprofile and other similar tools. */
3643 seq_printf(m
, " 0x%pK", mod
->module_core
);
3647 seq_printf(m
, " %s", module_flags(mod
, buf
));
3649 seq_printf(m
, "\n");
3653 /* Format: modulename size refcount deps address
3655 Where refcount is a number or -, and deps is a comma-separated list
3658 static const struct seq_operations modules_op
= {
3665 static int modules_open(struct inode
*inode
, struct file
*file
)
3667 return seq_open(file
, &modules_op
);
3670 static const struct file_operations proc_modules_operations
= {
3671 .open
= modules_open
,
3673 .llseek
= seq_lseek
,
3674 .release
= seq_release
,
3677 static int __init
proc_modules_init(void)
3679 proc_create("modules", 0, NULL
, &proc_modules_operations
);
3682 module_init(proc_modules_init
);
3685 /* Given an address, look for it in the module exception tables. */
3686 const struct exception_table_entry
*search_module_extables(unsigned long addr
)
3688 const struct exception_table_entry
*e
= NULL
;
3692 list_for_each_entry_rcu(mod
, &modules
, list
) {
3693 if (mod
->state
== MODULE_STATE_UNFORMED
)
3695 if (mod
->num_exentries
== 0)
3698 e
= search_extable(mod
->extable
,
3699 mod
->extable
+ mod
->num_exentries
- 1,
3706 /* Now, if we found one, we are running inside it now, hence
3707 we cannot unload the module, hence no refcnt needed. */
3712 * is_module_address - is this address inside a module?
3713 * @addr: the address to check.
3715 * See is_module_text_address() if you simply want to see if the address
3716 * is code (not data).
3718 bool is_module_address(unsigned long addr
)
3723 ret
= __module_address(addr
) != NULL
;
3730 * __module_address - get the module which contains an address.
3731 * @addr: the address.
3733 * Must be called with preempt disabled or module mutex held so that
3734 * module doesn't get freed during this.
3736 struct module
*__module_address(unsigned long addr
)
3740 if (addr
< module_addr_min
|| addr
> module_addr_max
)
3743 list_for_each_entry_rcu(mod
, &modules
, list
) {
3744 if (mod
->state
== MODULE_STATE_UNFORMED
)
3746 if (within_module(addr
, mod
))
3751 EXPORT_SYMBOL_GPL(__module_address
);
3754 * is_module_text_address - is this address inside module code?
3755 * @addr: the address to check.
3757 * See is_module_address() if you simply want to see if the address is
3758 * anywhere in a module. See kernel_text_address() for testing if an
3759 * address corresponds to kernel or module code.
3761 bool is_module_text_address(unsigned long addr
)
3766 ret
= __module_text_address(addr
) != NULL
;
3773 * __module_text_address - get the module whose code contains an address.
3774 * @addr: the address.
3776 * Must be called with preempt disabled or module mutex held so that
3777 * module doesn't get freed during this.
3779 struct module
*__module_text_address(unsigned long addr
)
3781 struct module
*mod
= __module_address(addr
);
3783 /* Make sure it's within the text section. */
3784 if (!within(addr
, mod
->module_init
, mod
->init_text_size
)
3785 && !within(addr
, mod
->module_core
, mod
->core_text_size
))
3790 EXPORT_SYMBOL_GPL(__module_text_address
);
3792 /* Don't grab lock, we're oopsing. */
3793 void print_modules(void)
3798 printk(KERN_DEFAULT
"Modules linked in:");
3799 /* Most callers should already have preempt disabled, but make sure */
3801 list_for_each_entry_rcu(mod
, &modules
, list
) {
3802 if (mod
->state
== MODULE_STATE_UNFORMED
)
3804 pr_cont(" %s%s", mod
->name
, module_flags(mod
, buf
));
3807 if (last_unloaded_module
[0])
3808 pr_cont(" [last unloaded: %s]", last_unloaded_module
);
3812 #ifdef CONFIG_MODVERSIONS
3813 /* Generate the signature for all relevant module structures here.
3814 * If these change, we don't want to try to parse the module. */
3815 void module_layout(struct module
*mod
,
3816 struct modversion_info
*ver
,
3817 struct kernel_param
*kp
,
3818 struct kernel_symbol
*ks
,
3819 struct tracepoint
* const *tp
)
3822 EXPORT_SYMBOL(module_layout
);