Line data Source code
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/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>
25 : #include <linux/fs.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"
64 :
65 : #define CREATE_TRACE_POINTS
66 : #include <trace/events/module.h>
67 :
68 : #ifndef ARCH_SHF_SMALL
69 : #define ARCH_SHF_SMALL 0
70 : #endif
71 :
72 : /*
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
76 : */
77 : #ifdef CONFIG_DEBUG_SET_MODULE_RONX
78 : # define debug_align(X) ALIGN(X, PAGE_SIZE)
79 : #else
80 : # define debug_align(X) (X)
81 : #endif
82 :
83 : /*
84 : * Given BASE and SIZE this macro calculates the number of pages the
85 : * memory regions occupies
86 : */
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) \
90 : : (0UL))
91 :
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))
94 :
95 : /*
96 : * Mutex protects:
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 */
107 :
108 : #ifdef CONFIG_MODULE_SIG
109 : #ifdef CONFIG_MODULE_SIG_FORCE
110 : static bool sig_enforce = true;
111 : #else
112 : static bool sig_enforce = false;
113 :
114 : static int param_set_bool_enable_only(const char *val,
115 : const struct kernel_param *kp)
116 : {
117 : int err;
118 : bool test;
119 : struct kernel_param dummy_kp = *kp;
120 :
121 : dummy_kp.arg = &test;
122 :
123 : err = param_set_bool(val, &dummy_kp);
124 : if (err)
125 : return err;
126 :
127 : /* Don't let them unset it once it's set! */
128 : if (!test && sig_enforce)
129 : return -EROFS;
130 :
131 : if (test)
132 : sig_enforce = true;
133 : return 0;
134 : }
135 :
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,
140 : };
141 : #define param_check_bool_enable_only param_check_bool
142 :
143 : module_param(sig_enforce, bool_enable_only, 0644);
144 : #endif /* !CONFIG_MODULE_SIG_FORCE */
145 : #endif /* CONFIG_MODULE_SIG */
146 :
147 : /* Block module loading/unloading? */
148 : int modules_disabled = 0;
149 : core_param(nomodule, modules_disabled, bint, 0);
150 :
151 : /* Waiting for a module to finish initializing? */
152 : static DECLARE_WAIT_QUEUE_HEAD(module_wq);
153 :
154 : static BLOCKING_NOTIFIER_HEAD(module_notify_list);
155 :
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;
159 :
160 2 : int register_module_notifier(struct notifier_block *nb)
161 : {
162 2 : return blocking_notifier_chain_register(&module_notify_list, nb);
163 : }
164 : EXPORT_SYMBOL(register_module_notifier);
165 :
166 0 : int unregister_module_notifier(struct notifier_block *nb)
167 : {
168 0 : return blocking_notifier_chain_unregister(&module_notify_list, nb);
169 : }
170 : EXPORT_SYMBOL(unregister_module_notifier);
171 :
172 : struct load_info {
173 : Elf_Ehdr *hdr;
174 : unsigned long len;
175 : Elf_Shdr *sechdrs;
176 : char *secstrings, *strtab;
177 : unsigned long symoffs, stroffs;
178 : struct _ddebug *debug;
179 : unsigned int num_debug;
180 : bool sig_ok;
181 : struct {
182 : unsigned int sym, str, mod, vers, info, pcpu;
183 : } index;
184 : };
185 :
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)
189 : {
190 : BUG_ON(mod && mod->state == MODULE_STATE_UNFORMED);
191 24 : if (mod && mod->state == MODULE_STATE_COMING)
192 : return -EBUSY;
193 24 : if (try_module_get(mod))
194 : return 0;
195 : else
196 : return -ENOENT;
197 : }
198 :
199 : static inline void add_taint_module(struct module *mod, unsigned flag,
200 : enum lockdep_ok lockdep_ok)
201 : {
202 0 : add_taint(flag, lockdep_ok);
203 0 : mod->taints |= (1U << flag);
204 : }
205 :
206 : /*
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.
209 : */
210 5 : void __module_put_and_exit(struct module *mod, long code)
211 : {
212 5 : module_put(mod);
213 5 : do_exit(code);
214 : }
215 : EXPORT_SYMBOL(__module_put_and_exit);
216 :
217 : /* Find a module section: 0 means not found. */
218 289 : static unsigned int find_sec(const struct load_info *info, const char *name)
219 : {
220 : unsigned int i;
221 :
222 7337 : for (i = 1; i < info->hdr->e_shnum; i++) {
223 7179 : Elf_Shdr *shdr = &info->sechdrs[i];
224 : /* Alloc bit cleared means "ignore it." */
225 7179 : if ((shdr->sh_flags & SHF_ALLOC)
226 3405 : && strcmp(info->secstrings + shdr->sh_name, name) == 0)
227 : return i;
228 : }
229 : return 0;
230 : }
231 :
232 : /* Find a module section, or NULL. */
233 : static void *section_addr(const struct load_info *info, const char *name)
234 : {
235 : /* Section 0 has sh_addr 0. */
236 64 : return (void *)info->sechdrs[find_sec(info, name)].sh_addr;
237 : }
238 :
239 : /* Find a module section, or NULL. Fill in number of "objects" in section. */
240 144 : static void *section_objs(const struct load_info *info,
241 : const char *name,
242 : size_t object_size,
243 : unsigned int *num)
244 : {
245 144 : unsigned int sec = find_sec(info, name);
246 :
247 : /* Section 0 has sh_addr 0 and sh_size 0. */
248 144 : *num = info->sechdrs[sec].sh_size / object_size;
249 144 : return (void *)info->sechdrs[sec].sh_addr;
250 : }
251 :
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[];
269 : #endif
270 :
271 : #ifndef CONFIG_MODVERSIONS
272 : #define symversion(base, idx) NULL
273 : #else
274 : #define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
275 : #endif
276 :
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,
282 : void *data),
283 : void *data)
284 : {
285 : unsigned int j;
286 :
287 7798 : for (j = 0; j < arrsize; j++) {
288 8730 : if (fn(&arr[j], owner, data))
289 : return true;
290 : }
291 :
292 : return false;
293 : }
294 :
295 : /* Returns true as soon as fn returns true, otherwise false. */
296 1136 : bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
297 : struct module *owner,
298 : void *data),
299 : void *data)
300 : {
301 : struct module *mod;
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,
307 : GPL_ONLY, false },
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,
317 : GPL_ONLY, true },
318 : #endif
319 : };
320 :
321 1136 : if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
322 : return true;
323 :
324 2948 : list_for_each_entry_rcu(mod, &modules, list) {
325 24696 : struct symsearch arr[] = {
326 8232 : { mod->syms, mod->syms + mod->num_syms, mod->crcs,
327 : NOT_GPL_ONLY, false },
328 5488 : { mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
329 2744 : mod->gpl_crcs,
330 : GPL_ONLY, false },
331 2744 : { mod->gpl_future_syms,
332 2744 : mod->gpl_future_syms + mod->num_gpl_future_syms,
333 2744 : mod->gpl_future_crcs,
334 : WILL_BE_GPL_ONLY, false },
335 : #ifdef CONFIG_UNUSED_SYMBOLS
336 : { mod->unused_syms,
337 : mod->unused_syms + mod->num_unused_syms,
338 : mod->unused_crcs,
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,
343 : GPL_ONLY, true },
344 : #endif
345 : };
346 :
347 2744 : if (mod->state == MODULE_STATE_UNFORMED)
348 385 : continue;
349 :
350 2359 : if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
351 181 : return true;
352 : }
353 : return false;
354 : }
355 : EXPORT_SYMBOL_GPL(each_symbol_section);
356 :
357 : struct find_symbol_arg {
358 : /* Input */
359 : const char *name;
360 : bool gplok;
361 : bool warn;
362 :
363 : /* Output */
364 : struct module *owner;
365 : const unsigned long *crc;
366 : const struct kernel_symbol *sym;
367 : };
368 :
369 932 : static bool check_symbol(const struct symsearch *syms,
370 : struct module *owner,
371 : unsigned int symnum, void *data)
372 : {
373 : struct find_symbol_arg *fsa = data;
374 :
375 932 : if (!fsa->gplok) {
376 0 : if (syms->licence == GPL_ONLY)
377 : return false;
378 0 : if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) {
379 0 : pr_warn("Symbol %s is being used by a non-GPL module, "
380 : "which will not be allowed in the future\n",
381 : fsa->name);
382 : }
383 : }
384 :
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 "
393 : "inclusion.\n");
394 : }
395 : #endif
396 :
397 932 : fsa->owner = owner;
398 932 : fsa->crc = symversion(syms->crcs, symnum);
399 932 : fsa->sym = &syms->start[symnum];
400 932 : return true;
401 : }
402 :
403 25173 : static int cmp_name(const void *va, const void *vb)
404 : {
405 : const char *a;
406 : const struct kernel_symbol *b;
407 : a = va; b = vb;
408 25173 : return strcmp(a, b->name);
409 : }
410 :
411 8730 : static bool find_symbol_in_section(const struct symsearch *syms,
412 : struct module *owner,
413 : void *data)
414 : {
415 : struct find_symbol_arg *fsa = data;
416 : struct kernel_symbol *sym;
417 :
418 8730 : sym = bsearch(fsa->name, syms->start, syms->stop - syms->start,
419 : sizeof(struct kernel_symbol), cmp_name);
420 :
421 8730 : if (sym != NULL && check_symbol(syms, owner, sym - syms->start, data))
422 : return true;
423 :
424 : return false;
425 : }
426 :
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 1136 : const struct kernel_symbol *find_symbol(const char *name,
430 : struct module **owner,
431 : const unsigned long **crc,
432 : bool gplok,
433 : bool warn)
434 : {
435 : struct find_symbol_arg fsa;
436 :
437 1136 : fsa.name = name;
438 1136 : fsa.gplok = gplok;
439 1136 : fsa.warn = warn;
440 :
441 1136 : if (each_symbol_section(find_symbol_in_section, &fsa)) {
442 932 : if (owner)
443 905 : *owner = fsa.owner;
444 932 : if (crc)
445 932 : *crc = fsa.crc;
446 932 : return fsa.sym;
447 : }
448 :
449 : pr_debug("Failed to find symbol %s\n", name);
450 : return NULL;
451 : }
452 : EXPORT_SYMBOL_GPL(find_symbol);
453 :
454 : /* Search for module by name: must hold module_mutex. */
455 56 : static struct module *find_module_all(const char *name, size_t len,
456 : bool even_unformed)
457 : {
458 : struct module *mod;
459 :
460 185 : list_for_each_entry(mod, &modules, list) {
461 169 : if (!even_unformed && mod->state == MODULE_STATE_UNFORMED)
462 0 : continue;
463 169 : if (strlen(mod->name) == len && !memcmp(mod->name, name, len))
464 : return mod;
465 : }
466 : return NULL;
467 : }
468 :
469 0 : struct module *find_module(const char *name)
470 : {
471 0 : return find_module_all(name, strlen(name), false);
472 : }
473 : EXPORT_SYMBOL_GPL(find_module);
474 :
475 : #ifdef CONFIG_SMP
476 :
477 : static inline void __percpu *mod_percpu(struct module *mod)
478 : {
479 : return mod->percpu;
480 : }
481 :
482 : static int percpu_modalloc(struct module *mod, struct load_info *info)
483 : {
484 : Elf_Shdr *pcpusec = &info->sechdrs[info->index.pcpu];
485 : unsigned long align = pcpusec->sh_addralign;
486 :
487 : if (!pcpusec->sh_size)
488 : return 0;
489 :
490 : if (align > PAGE_SIZE) {
491 : pr_warn("%s: per-cpu alignment %li > %li\n",
492 : mod->name, align, PAGE_SIZE);
493 : align = PAGE_SIZE;
494 : }
495 :
496 : mod->percpu = __alloc_reserved_percpu(pcpusec->sh_size, align);
497 : if (!mod->percpu) {
498 : pr_warn("%s: Could not allocate %lu bytes percpu data\n",
499 : mod->name, (unsigned long)pcpusec->sh_size);
500 : return -ENOMEM;
501 : }
502 : mod->percpu_size = pcpusec->sh_size;
503 : return 0;
504 : }
505 :
506 : static void percpu_modfree(struct module *mod)
507 : {
508 : free_percpu(mod->percpu);
509 : }
510 :
511 : static unsigned int find_pcpusec(struct load_info *info)
512 : {
513 : return find_sec(info, ".data..percpu");
514 : }
515 :
516 : static void percpu_modcopy(struct module *mod,
517 : const void *from, unsigned long size)
518 : {
519 : int cpu;
520 :
521 : for_each_possible_cpu(cpu)
522 : memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);
523 : }
524 :
525 : /**
526 : * is_module_percpu_address - test whether address is from module static percpu
527 : * @addr: address to test
528 : *
529 : * Test whether @addr belongs to module static percpu area.
530 : *
531 : * RETURNS:
532 : * %true if @addr is from module static percpu area
533 : */
534 : bool is_module_percpu_address(unsigned long addr)
535 : {
536 : struct module *mod;
537 : unsigned int cpu;
538 :
539 : preempt_disable();
540 :
541 : list_for_each_entry_rcu(mod, &modules, list) {
542 : if (mod->state == MODULE_STATE_UNFORMED)
543 : continue;
544 : if (!mod->percpu_size)
545 : continue;
546 : for_each_possible_cpu(cpu) {
547 : void *start = per_cpu_ptr(mod->percpu, cpu);
548 :
549 : if ((void *)addr >= start &&
550 : (void *)addr < start + mod->percpu_size) {
551 : preempt_enable();
552 : return true;
553 : }
554 : }
555 : }
556 :
557 : preempt_enable();
558 : return false;
559 : }
560 :
561 : #else /* ... !CONFIG_SMP */
562 :
563 : static inline void __percpu *mod_percpu(struct module *mod)
564 : {
565 : return NULL;
566 : }
567 : static int percpu_modalloc(struct module *mod, struct load_info *info)
568 : {
569 : /* UP modules shouldn't have this section: ENOMEM isn't quite right */
570 16 : if (info->sechdrs[info->index.pcpu].sh_size != 0)
571 : return -ENOMEM;
572 : return 0;
573 : }
574 : static inline void percpu_modfree(struct module *mod)
575 : {
576 : }
577 : static unsigned int find_pcpusec(struct load_info *info)
578 : {
579 : return 0;
580 : }
581 : static inline void percpu_modcopy(struct module *mod,
582 : const void *from, unsigned long size)
583 : {
584 : /* pcpusec should be 0, and size of that section should be 0. */
585 : BUG_ON(size != 0);
586 : }
587 0 : bool is_module_percpu_address(unsigned long addr)
588 : {
589 0 : return false;
590 : }
591 :
592 : #endif /* CONFIG_SMP */
593 :
594 : #define MODINFO_ATTR(field) \
595 : static void setup_modinfo_##field(struct module *mod, const char *s) \
596 : { \
597 : mod->field = kstrdup(s, GFP_KERNEL); \
598 : } \
599 : static ssize_t show_modinfo_##field(struct module_attribute *mattr, \
600 : struct module_kobject *mk, char *buffer) \
601 : { \
602 : return scnprintf(buffer, PAGE_SIZE, "%s\n", mk->mod->field); \
603 : } \
604 : static int modinfo_##field##_exists(struct module *mod) \
605 : { \
606 : return mod->field != NULL; \
607 : } \
608 : static void free_modinfo_##field(struct module *mod) \
609 : { \
610 : kfree(mod->field); \
611 : mod->field = NULL; \
612 : } \
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, \
619 : };
620 :
621 32 : MODINFO_ATTR(version);
622 32 : MODINFO_ATTR(srcversion);
623 :
624 : static char last_unloaded_module[MODULE_NAME_LEN+1];
625 :
626 : #ifdef CONFIG_MODULE_UNLOAD
627 :
628 : EXPORT_TRACEPOINT_SYMBOL(module_get);
629 :
630 : /* MODULE_REF_BASE is the base reference count by kmodule loader. */
631 : #define MODULE_REF_BASE 1
632 :
633 : /* Init the unload section of the module. */
634 : static int module_unload_init(struct module *mod)
635 : {
636 : /*
637 : * Initialize reference counter to MODULE_REF_BASE.
638 : * refcnt == 0 means module is going.
639 : */
640 16 : atomic_set(&mod->refcnt, MODULE_REF_BASE);
641 :
642 16 : INIT_LIST_HEAD(&mod->source_list);
643 16 : INIT_LIST_HEAD(&mod->target_list);
644 :
645 : /* Hold reference count during initialization. */
646 16 : atomic_inc(&mod->refcnt);
647 :
648 : return 0;
649 : }
650 :
651 : /* Does a already use b? */
652 : static int already_uses(struct module *a, struct module *b)
653 : {
654 : struct module_use *use;
655 :
656 224 : list_for_each_entry(use, &b->source_list, source_list) {
657 200 : if (use->source == a) {
658 : pr_debug("%s uses %s!\n", a->name, b->name);
659 : return 1;
660 : }
661 : }
662 : pr_debug("%s does not use %s!\n", a->name, b->name);
663 : return 0;
664 : }
665 :
666 : /*
667 : * Module a uses b
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).
672 : */
673 24 : static int add_module_usage(struct module *a, struct module *b)
674 : {
675 : struct module_use *use;
676 :
677 : pr_debug("Allocating new usage for %s.\n", a->name);
678 : use = kmalloc(sizeof(*use), GFP_ATOMIC);
679 24 : if (!use) {
680 0 : pr_warn("%s: out of memory loading\n", a->name);
681 0 : return -ENOMEM;
682 : }
683 :
684 24 : use->source = a;
685 24 : use->target = b;
686 24 : list_add(&use->source_list, &b->source_list);
687 24 : list_add(&use->target_list, &a->target_list);
688 24 : return 0;
689 : }
690 :
691 : /* Module a uses b: caller needs module_mutex() */
692 905 : int ref_module(struct module *a, struct module *b)
693 : {
694 : int err;
695 :
696 1086 : if (b == NULL || already_uses(a, b))
697 : return 0;
698 :
699 : /* If module isn't available, we fail. */
700 : err = strong_try_module_get(b);
701 24 : if (err)
702 : return err;
703 :
704 24 : err = add_module_usage(a, b);
705 24 : if (err) {
706 0 : module_put(b);
707 0 : return err;
708 : }
709 : return 0;
710 : }
711 : EXPORT_SYMBOL_GPL(ref_module);
712 :
713 : /* Clear the unload stuff of the module. */
714 0 : static void module_unload_free(struct module *mod)
715 : {
716 : struct module_use *use, *tmp;
717 :
718 0 : mutex_lock(&module_mutex);
719 0 : list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
720 0 : struct module *i = use->target;
721 : pr_debug("%s unusing %s\n", mod->name, i->name);
722 0 : module_put(i);
723 : list_del(&use->source_list);
724 : list_del(&use->target_list);
725 0 : kfree(use);
726 : }
727 0 : mutex_unlock(&module_mutex);
728 0 : }
729 :
730 : #ifdef CONFIG_MODULE_FORCE_UNLOAD
731 : static inline int try_force_unload(unsigned int flags)
732 : {
733 : int ret = (flags & O_TRUNC);
734 : if (ret)
735 : add_taint(TAINT_FORCED_RMMOD, LOCKDEP_NOW_UNRELIABLE);
736 : return ret;
737 : }
738 : #else
739 : static inline int try_force_unload(unsigned int flags)
740 : {
741 : return 0;
742 : }
743 : #endif /* CONFIG_MODULE_FORCE_UNLOAD */
744 :
745 : /* Try to release refcount of module, 0 means success. */
746 0 : static int try_release_module_ref(struct module *mod)
747 : {
748 : int ret;
749 :
750 : /* Try to decrement refcnt which we set at loading */
751 0 : ret = atomic_sub_return(MODULE_REF_BASE, &mod->refcnt);
752 : BUG_ON(ret < 0);
753 0 : if (ret)
754 : /* Someone can put this right now, recover with checking */
755 : ret = atomic_add_unless(&mod->refcnt, MODULE_REF_BASE, 0);
756 :
757 0 : return ret;
758 : }
759 :
760 0 : static int try_stop_module(struct module *mod, int flags, int *forced)
761 : {
762 : /* If it's not unused, quit unless we're forcing. */
763 0 : if (try_release_module_ref(mod) != 0) {
764 0 : *forced = try_force_unload(flags);
765 : if (!(*forced))
766 : return -EWOULDBLOCK;
767 : }
768 :
769 : /* Mark it as dying. */
770 0 : mod->state = MODULE_STATE_GOING;
771 :
772 : return 0;
773 : }
774 :
775 : /**
776 : * module_refcount - return the refcount or -1 if unloading
777 : *
778 : * @mod: the module we're checking
779 : *
780 : * Returns:
781 : * -1 if the module is in the process of unloading
782 : * otherwise the number of references in the kernel to the module
783 : */
784 0 : int module_refcount(struct module *mod)
785 : {
786 0 : return atomic_read(&mod->refcnt) - MODULE_REF_BASE;
787 : }
788 : EXPORT_SYMBOL(module_refcount);
789 :
790 : /* This exists whether we can unload or not */
791 : static void free_module(struct module *mod);
792 :
793 0 : SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
794 : unsigned int, flags)
795 : {
796 : struct module *mod;
797 : char name[MODULE_NAME_LEN];
798 0 : int ret, forced = 0;
799 :
800 0 : if (!capable(CAP_SYS_MODULE) || modules_disabled)
801 : return -EPERM;
802 :
803 0 : if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
804 : return -EFAULT;
805 0 : name[MODULE_NAME_LEN-1] = '\0';
806 :
807 0 : if (mutex_lock_interruptible(&module_mutex) != 0)
808 : return -EINTR;
809 :
810 0 : mod = find_module(name);
811 0 : if (!mod) {
812 : ret = -ENOENT;
813 : goto out;
814 : }
815 :
816 0 : if (!list_empty(&mod->source_list)) {
817 : /* Other modules depend on us: get rid of them first. */
818 : ret = -EWOULDBLOCK;
819 : goto out;
820 : }
821 :
822 : /* Doing init or already dying? */
823 0 : if (mod->state != MODULE_STATE_LIVE) {
824 : /* FIXME: if (force), slam module count damn the torpedoes */
825 : pr_debug("%s already dying\n", mod->name);
826 : ret = -EBUSY;
827 : goto out;
828 : }
829 :
830 : /* If it has an init func, it must have an exit func to unload */
831 0 : if (mod->init && !mod->exit) {
832 0 : forced = try_force_unload(flags);
833 : if (!forced) {
834 : /* This module can't be removed */
835 : ret = -EBUSY;
836 : goto out;
837 : }
838 : }
839 :
840 : /* Stop the machine so refcounts can't move and disable module. */
841 0 : ret = try_stop_module(mod, flags, &forced);
842 0 : if (ret != 0)
843 : goto out;
844 :
845 0 : mutex_unlock(&module_mutex);
846 : /* Final destruction now no one is using it. */
847 0 : if (mod->exit != NULL)
848 0 : mod->exit();
849 0 : blocking_notifier_call_chain(&module_notify_list,
850 : MODULE_STATE_GOING, mod);
851 0 : async_synchronize_full();
852 :
853 : /* Store the name of the last unloaded module for diagnostic purposes */
854 0 : strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
855 :
856 0 : free_module(mod);
857 : return 0;
858 : out:
859 0 : mutex_unlock(&module_mutex);
860 : return ret;
861 : }
862 :
863 : static inline void print_unload_info(struct seq_file *m, struct module *mod)
864 : {
865 : struct module_use *use;
866 : int printed_something = 0;
867 :
868 0 : seq_printf(m, " %i ", module_refcount(mod));
869 :
870 : /*
871 : * Always include a trailing , so userspace can differentiate
872 : * between this and the old multi-field proc format.
873 : */
874 0 : list_for_each_entry(use, &mod->source_list, source_list) {
875 : printed_something = 1;
876 0 : seq_printf(m, "%s,", use->source->name);
877 : }
878 :
879 0 : if (mod->init != NULL && mod->exit == NULL) {
880 : printed_something = 1;
881 0 : seq_puts(m, "[permanent],");
882 : }
883 :
884 0 : if (!printed_something)
885 0 : seq_puts(m, "-");
886 : }
887 :
888 0 : void __symbol_put(const char *symbol)
889 : {
890 : struct module *owner;
891 :
892 0 : preempt_disable();
893 0 : if (!find_symbol(symbol, &owner, NULL, true, false))
894 : BUG();
895 0 : module_put(owner);
896 0 : preempt_enable();
897 0 : }
898 : EXPORT_SYMBOL(__symbol_put);
899 :
900 : /* Note this assumes addr is a function, which it currently always is. */
901 0 : void symbol_put_addr(void *addr)
902 : {
903 : struct module *modaddr;
904 0 : unsigned long a = (unsigned long)dereference_function_descriptor(addr);
905 :
906 0 : if (core_kernel_text(a))
907 0 : return;
908 :
909 : /* module_text_address is safe here: we're supposed to have reference
910 : * to module from symbol_get, so it can't go away. */
911 0 : modaddr = __module_text_address(a);
912 : BUG_ON(!modaddr);
913 0 : module_put(modaddr);
914 : }
915 : EXPORT_SYMBOL_GPL(symbol_put_addr);
916 :
917 0 : static ssize_t show_refcnt(struct module_attribute *mattr,
918 : struct module_kobject *mk, char *buffer)
919 : {
920 0 : return sprintf(buffer, "%i\n", module_refcount(mk->mod));
921 : }
922 :
923 : static struct module_attribute modinfo_refcnt =
924 : __ATTR(refcnt, 0444, show_refcnt, NULL);
925 :
926 2263 : void __module_get(struct module *module)
927 : {
928 2263 : if (module) {
929 0 : preempt_disable();
930 0 : atomic_inc(&module->refcnt);
931 0 : trace_module_get(module, _RET_IP_);
932 0 : preempt_enable();
933 : }
934 2263 : }
935 : EXPORT_SYMBOL(__module_get);
936 :
937 64004 : bool try_module_get(struct module *module)
938 : {
939 : bool ret = true;
940 :
941 62960 : if (module) {
942 1044 : preempt_disable();
943 : /* Note: here, we can fail to get a reference */
944 2088 : if (likely(module_is_live(module) &&
945 : atomic_inc_not_zero(&module->refcnt) != 0))
946 1044 : trace_module_get(module, _RET_IP_);
947 : else
948 : ret = false;
949 :
950 2088 : preempt_enable();
951 : }
952 62960 : return ret;
953 : }
954 : EXPORT_SYMBOL(try_module_get);
955 :
956 70603 : void module_put(struct module *module)
957 : {
958 : int ret;
959 :
960 70603 : if (module) {
961 1026 : preempt_disable();
962 1026 : ret = atomic_dec_if_positive(&module->refcnt);
963 : WARN_ON(ret < 0); /* Failed to put refcount */
964 1026 : trace_module_put(module, _RET_IP_);
965 2052 : preempt_enable();
966 : }
967 70603 : }
968 : EXPORT_SYMBOL(module_put);
969 :
970 : #else /* !CONFIG_MODULE_UNLOAD */
971 : static inline void print_unload_info(struct seq_file *m, struct module *mod)
972 : {
973 : /* We don't know the usage count, or what modules are using. */
974 : seq_puts(m, " - -");
975 : }
976 :
977 : static inline void module_unload_free(struct module *mod)
978 : {
979 : }
980 :
981 : int ref_module(struct module *a, struct module *b)
982 : {
983 : return strong_try_module_get(b);
984 : }
985 : EXPORT_SYMBOL_GPL(ref_module);
986 :
987 : static inline int module_unload_init(struct module *mod)
988 : {
989 : return 0;
990 : }
991 : #endif /* CONFIG_MODULE_UNLOAD */
992 :
993 0 : static size_t module_flags_taint(struct module *mod, char *buf)
994 : {
995 : size_t l = 0;
996 :
997 0 : if (mod->taints & (1 << TAINT_PROPRIETARY_MODULE))
998 0 : buf[l++] = 'P';
999 0 : if (mod->taints & (1 << TAINT_OOT_MODULE))
1000 0 : buf[l++] = 'O';
1001 0 : if (mod->taints & (1 << TAINT_FORCED_MODULE))
1002 0 : buf[l++] = 'F';
1003 0 : if (mod->taints & (1 << TAINT_CRAP))
1004 0 : buf[l++] = 'C';
1005 0 : if (mod->taints & (1 << TAINT_UNSIGNED_MODULE))
1006 0 : buf[l++] = 'E';
1007 : /*
1008 : * TAINT_FORCED_RMMOD: could be added.
1009 : * TAINT_CPU_OUT_OF_SPEC, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
1010 : * apply to modules.
1011 : */
1012 0 : return l;
1013 : }
1014 :
1015 36 : static ssize_t show_initstate(struct module_attribute *mattr,
1016 : struct module_kobject *mk, char *buffer)
1017 : {
1018 : const char *state = "unknown";
1019 :
1020 36 : switch (mk->mod->state) {
1021 : case MODULE_STATE_LIVE:
1022 : state = "live";
1023 : break;
1024 : case MODULE_STATE_COMING:
1025 : state = "coming";
1026 2 : break;
1027 : case MODULE_STATE_GOING:
1028 : state = "going";
1029 0 : break;
1030 : default:
1031 0 : BUG();
1032 : }
1033 36 : return sprintf(buffer, "%s\n", state);
1034 : }
1035 :
1036 : static struct module_attribute modinfo_initstate =
1037 : __ATTR(initstate, 0444, show_initstate, NULL);
1038 :
1039 0 : static ssize_t store_uevent(struct module_attribute *mattr,
1040 : struct module_kobject *mk,
1041 : const char *buffer, size_t count)
1042 : {
1043 : enum kobject_action action;
1044 :
1045 0 : if (kobject_action_type(buffer, count, &action) == 0)
1046 0 : kobject_uevent(&mk->kobj, action);
1047 0 : return count;
1048 : }
1049 :
1050 : struct module_attribute module_uevent =
1051 : __ATTR(uevent, 0200, NULL, store_uevent);
1052 :
1053 0 : static ssize_t show_coresize(struct module_attribute *mattr,
1054 : struct module_kobject *mk, char *buffer)
1055 : {
1056 0 : return sprintf(buffer, "%u\n", mk->mod->core_size);
1057 : }
1058 :
1059 : static struct module_attribute modinfo_coresize =
1060 : __ATTR(coresize, 0444, show_coresize, NULL);
1061 :
1062 0 : static ssize_t show_initsize(struct module_attribute *mattr,
1063 : struct module_kobject *mk, char *buffer)
1064 : {
1065 0 : return sprintf(buffer, "%u\n", mk->mod->init_size);
1066 : }
1067 :
1068 : static struct module_attribute modinfo_initsize =
1069 : __ATTR(initsize, 0444, show_initsize, NULL);
1070 :
1071 0 : static ssize_t show_taint(struct module_attribute *mattr,
1072 : struct module_kobject *mk, char *buffer)
1073 : {
1074 : size_t l;
1075 :
1076 0 : l = module_flags_taint(mk->mod, buffer);
1077 0 : buffer[l++] = '\n';
1078 0 : return l;
1079 : }
1080 :
1081 : static struct module_attribute modinfo_taint =
1082 : __ATTR(taint, 0444, show_taint, NULL);
1083 :
1084 : static struct module_attribute *modinfo_attrs[] = {
1085 : &module_uevent,
1086 : &modinfo_version,
1087 : &modinfo_srcversion,
1088 : &modinfo_initstate,
1089 : &modinfo_coresize,
1090 : &modinfo_initsize,
1091 : &modinfo_taint,
1092 : #ifdef CONFIG_MODULE_UNLOAD
1093 : &modinfo_refcnt,
1094 : #endif
1095 : NULL,
1096 : };
1097 :
1098 : static const char vermagic[] = VERMAGIC_STRING;
1099 :
1100 : static int try_to_force_load(struct module *mod, const char *reason)
1101 : {
1102 : #ifdef CONFIG_MODULE_FORCE_LOAD
1103 : if (!test_taint(TAINT_FORCED_MODULE))
1104 : pr_warn("%s: %s: kernel tainted.\n", mod->name, reason);
1105 : add_taint_module(mod, TAINT_FORCED_MODULE, LOCKDEP_NOW_UNRELIABLE);
1106 : return 0;
1107 : #else
1108 : return -ENOEXEC;
1109 : #endif
1110 : }
1111 :
1112 : #ifdef CONFIG_MODVERSIONS
1113 : /* If the arch applies (non-zero) relocations to kernel kcrctab, unapply it. */
1114 : static unsigned long maybe_relocated(unsigned long crc,
1115 : const struct module *crc_owner)
1116 : {
1117 : #ifdef ARCH_RELOCATES_KCRCTAB
1118 : if (crc_owner == NULL)
1119 : return crc - (unsigned long)reloc_start;
1120 : #endif
1121 : return crc;
1122 : }
1123 :
1124 932 : static int check_version(Elf_Shdr *sechdrs,
1125 : unsigned int versindex,
1126 : const char *symname,
1127 : struct module *mod,
1128 : const unsigned long *crc,
1129 : const struct module *crc_owner)
1130 : {
1131 : unsigned int i, num_versions;
1132 : struct modversion_info *versions;
1133 :
1134 : /* Exporting module didn't supply crcs? OK, we're already tainted. */
1135 932 : if (!crc)
1136 : return 1;
1137 :
1138 : /* No versions at all? modprobe --force does this. */
1139 932 : if (versindex == 0)
1140 : return try_to_force_load(mod, symname) == 0;
1141 :
1142 932 : versions = (void *) sechdrs[versindex].sh_addr;
1143 932 : num_versions = sechdrs[versindex].sh_size
1144 : / sizeof(struct modversion_info);
1145 :
1146 66164 : for (i = 0; i < num_versions; i++) {
1147 33548 : if (strcmp(versions[i].name, symname) != 0)
1148 32616 : continue;
1149 :
1150 932 : if (versions[i].crc == maybe_relocated(*crc, crc_owner))
1151 : return 1;
1152 : pr_debug("Found checksum %lX vs module %lX\n",
1153 : maybe_relocated(*crc, crc_owner), versions[i].crc);
1154 : goto bad_version;
1155 : }
1156 :
1157 0 : pr_warn("%s: no symbol version for %s\n", mod->name, symname);
1158 : return 0;
1159 :
1160 : bad_version:
1161 0 : pr_warn("%s: disagrees about version of symbol %s\n",
1162 : mod->name, symname);
1163 : return 0;
1164 : }
1165 :
1166 : static inline int check_modstruct_version(Elf_Shdr *sechdrs,
1167 : unsigned int versindex,
1168 : struct module *mod)
1169 : {
1170 : const unsigned long *crc;
1171 :
1172 : /* Since this should be found in kernel (which can't be removed),
1173 : * no locking is necessary. */
1174 27 : if (!find_symbol(VMLINUX_SYMBOL_STR(module_layout), NULL,
1175 : &crc, true, false))
1176 : BUG();
1177 27 : return check_version(sechdrs, versindex,
1178 : VMLINUX_SYMBOL_STR(module_layout), mod, crc,
1179 : NULL);
1180 : }
1181 :
1182 : /* First part is kernel version, which we ignore if module has crcs. */
1183 : static inline int same_magic(const char *amagic, const char *bmagic,
1184 : bool has_crcs)
1185 : {
1186 27 : if (has_crcs) {
1187 27 : amagic += strcspn(amagic, " ");
1188 : bmagic += strcspn(bmagic, " ");
1189 : }
1190 27 : return strcmp(amagic, bmagic) == 0;
1191 : }
1192 : #else
1193 : static inline int check_version(Elf_Shdr *sechdrs,
1194 : unsigned int versindex,
1195 : const char *symname,
1196 : struct module *mod,
1197 : const unsigned long *crc,
1198 : const struct module *crc_owner)
1199 : {
1200 : return 1;
1201 : }
1202 :
1203 : static inline int check_modstruct_version(Elf_Shdr *sechdrs,
1204 : unsigned int versindex,
1205 : struct module *mod)
1206 : {
1207 : return 1;
1208 : }
1209 :
1210 : static inline int same_magic(const char *amagic, const char *bmagic,
1211 : bool has_crcs)
1212 : {
1213 : return strcmp(amagic, bmagic) == 0;
1214 : }
1215 : #endif /* CONFIG_MODVERSIONS */
1216 :
1217 : /* Resolve a symbol for this module. I.e. if we find one, record usage. */
1218 905 : static const struct kernel_symbol *resolve_symbol(struct module *mod,
1219 : const struct load_info *info,
1220 : const char *name,
1221 : char ownername[])
1222 : {
1223 : struct module *owner;
1224 : const struct kernel_symbol *sym;
1225 : const unsigned long *crc;
1226 : int err;
1227 :
1228 905 : mutex_lock(&module_mutex);
1229 905 : sym = find_symbol(name, &owner, &crc,
1230 905 : !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
1231 905 : if (!sym)
1232 : goto unlock;
1233 :
1234 905 : if (!check_version(info->sechdrs, info->index.vers, name, mod, crc,
1235 : owner)) {
1236 : sym = ERR_PTR(-EINVAL);
1237 : goto getname;
1238 : }
1239 :
1240 905 : err = ref_module(mod, owner);
1241 905 : if (err) {
1242 : sym = ERR_PTR(err);
1243 : goto getname;
1244 : }
1245 :
1246 : getname:
1247 : /* We must make copy under the lock if we failed to get ref. */
1248 905 : strncpy(ownername, module_name(owner), MODULE_NAME_LEN);
1249 : unlock:
1250 905 : mutex_unlock(&module_mutex);
1251 905 : return sym;
1252 : }
1253 :
1254 : static const struct kernel_symbol *
1255 905 : resolve_symbol_wait(struct module *mod,
1256 : const struct load_info *info,
1257 : const char *name)
1258 : {
1259 : const struct kernel_symbol *ksym;
1260 : char owner[MODULE_NAME_LEN];
1261 :
1262 1810 : if (wait_event_interruptible_timeout(module_wq,
1263 : !IS_ERR(ksym = resolve_symbol(mod, info, name, owner))
1264 : || PTR_ERR(ksym) != -EBUSY,
1265 : 30 * HZ) <= 0) {
1266 0 : pr_warn("%s: gave up waiting for init of module %s.\n",
1267 : mod->name, owner);
1268 : }
1269 905 : return ksym;
1270 : }
1271 :
1272 : /*
1273 : * /sys/module/foo/sections stuff
1274 : * J. Corbet <corbet@lwn.net>
1275 : */
1276 : #ifdef CONFIG_SYSFS
1277 :
1278 : #ifdef CONFIG_KALLSYMS
1279 : static inline bool sect_empty(const Elf_Shdr *sect)
1280 : {
1281 : return !(sect->sh_flags & SHF_ALLOC) || sect->sh_size == 0;
1282 : }
1283 :
1284 : struct module_sect_attr {
1285 : struct module_attribute mattr;
1286 : char *name;
1287 : unsigned long address;
1288 : };
1289 :
1290 : struct module_sect_attrs {
1291 : struct attribute_group grp;
1292 : unsigned int nsections;
1293 : struct module_sect_attr attrs[0];
1294 : };
1295 :
1296 : static ssize_t module_sect_show(struct module_attribute *mattr,
1297 : struct module_kobject *mk, char *buf)
1298 : {
1299 : struct module_sect_attr *sattr =
1300 : container_of(mattr, struct module_sect_attr, mattr);
1301 : return sprintf(buf, "0x%pK\n", (void *)sattr->address);
1302 : }
1303 :
1304 : static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
1305 : {
1306 : unsigned int section;
1307 :
1308 : for (section = 0; section < sect_attrs->nsections; section++)
1309 : kfree(sect_attrs->attrs[section].name);
1310 : kfree(sect_attrs);
1311 : }
1312 :
1313 : static void add_sect_attrs(struct module *mod, const struct load_info *info)
1314 : {
1315 : unsigned int nloaded = 0, i, size[2];
1316 : struct module_sect_attrs *sect_attrs;
1317 : struct module_sect_attr *sattr;
1318 : struct attribute **gattr;
1319 :
1320 : /* Count loaded sections and allocate structures */
1321 : for (i = 0; i < info->hdr->e_shnum; i++)
1322 : if (!sect_empty(&info->sechdrs[i]))
1323 : nloaded++;
1324 : size[0] = ALIGN(sizeof(*sect_attrs)
1325 : + nloaded * sizeof(sect_attrs->attrs[0]),
1326 : sizeof(sect_attrs->grp.attrs[0]));
1327 : size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]);
1328 : sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);
1329 : if (sect_attrs == NULL)
1330 : return;
1331 :
1332 : /* Setup section attributes. */
1333 : sect_attrs->grp.name = "sections";
1334 : sect_attrs->grp.attrs = (void *)sect_attrs + size[0];
1335 :
1336 : sect_attrs->nsections = 0;
1337 : sattr = §_attrs->attrs[0];
1338 : gattr = §_attrs->grp.attrs[0];
1339 : for (i = 0; i < info->hdr->e_shnum; i++) {
1340 : Elf_Shdr *sec = &info->sechdrs[i];
1341 : if (sect_empty(sec))
1342 : continue;
1343 : sattr->address = sec->sh_addr;
1344 : sattr->name = kstrdup(info->secstrings + sec->sh_name,
1345 : GFP_KERNEL);
1346 : if (sattr->name == NULL)
1347 : goto out;
1348 : sect_attrs->nsections++;
1349 : sysfs_attr_init(&sattr->mattr.attr);
1350 : sattr->mattr.show = module_sect_show;
1351 : sattr->mattr.store = NULL;
1352 : sattr->mattr.attr.name = sattr->name;
1353 : sattr->mattr.attr.mode = S_IRUGO;
1354 : *(gattr++) = &(sattr++)->mattr.attr;
1355 : }
1356 : *gattr = NULL;
1357 :
1358 : if (sysfs_create_group(&mod->mkobj.kobj, §_attrs->grp))
1359 : goto out;
1360 :
1361 : mod->sect_attrs = sect_attrs;
1362 : return;
1363 : out:
1364 : free_sect_attrs(sect_attrs);
1365 : }
1366 :
1367 : static void remove_sect_attrs(struct module *mod)
1368 : {
1369 : if (mod->sect_attrs) {
1370 : sysfs_remove_group(&mod->mkobj.kobj,
1371 : &mod->sect_attrs->grp);
1372 : /* We are positive that no one is using any sect attrs
1373 : * at this point. Deallocate immediately. */
1374 : free_sect_attrs(mod->sect_attrs);
1375 : mod->sect_attrs = NULL;
1376 : }
1377 : }
1378 :
1379 : /*
1380 : * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
1381 : */
1382 :
1383 : struct module_notes_attrs {
1384 : struct kobject *dir;
1385 : unsigned int notes;
1386 : struct bin_attribute attrs[0];
1387 : };
1388 :
1389 : static ssize_t module_notes_read(struct file *filp, struct kobject *kobj,
1390 : struct bin_attribute *bin_attr,
1391 : char *buf, loff_t pos, size_t count)
1392 : {
1393 : /*
1394 : * The caller checked the pos and count against our size.
1395 : */
1396 : memcpy(buf, bin_attr->private + pos, count);
1397 : return count;
1398 : }
1399 :
1400 : static void free_notes_attrs(struct module_notes_attrs *notes_attrs,
1401 : unsigned int i)
1402 : {
1403 : if (notes_attrs->dir) {
1404 : while (i-- > 0)
1405 : sysfs_remove_bin_file(notes_attrs->dir,
1406 : ¬es_attrs->attrs[i]);
1407 : kobject_put(notes_attrs->dir);
1408 : }
1409 : kfree(notes_attrs);
1410 : }
1411 :
1412 : static void add_notes_attrs(struct module *mod, const struct load_info *info)
1413 : {
1414 : unsigned int notes, loaded, i;
1415 : struct module_notes_attrs *notes_attrs;
1416 : struct bin_attribute *nattr;
1417 :
1418 : /* failed to create section attributes, so can't create notes */
1419 : if (!mod->sect_attrs)
1420 : return;
1421 :
1422 : /* Count notes sections and allocate structures. */
1423 : notes = 0;
1424 : for (i = 0; i < info->hdr->e_shnum; i++)
1425 : if (!sect_empty(&info->sechdrs[i]) &&
1426 : (info->sechdrs[i].sh_type == SHT_NOTE))
1427 : ++notes;
1428 :
1429 : if (notes == 0)
1430 : return;
1431 :
1432 : notes_attrs = kzalloc(sizeof(*notes_attrs)
1433 : + notes * sizeof(notes_attrs->attrs[0]),
1434 : GFP_KERNEL);
1435 : if (notes_attrs == NULL)
1436 : return;
1437 :
1438 : notes_attrs->notes = notes;
1439 : nattr = ¬es_attrs->attrs[0];
1440 : for (loaded = i = 0; i < info->hdr->e_shnum; ++i) {
1441 : if (sect_empty(&info->sechdrs[i]))
1442 : continue;
1443 : if (info->sechdrs[i].sh_type == SHT_NOTE) {
1444 : sysfs_bin_attr_init(nattr);
1445 : nattr->attr.name = mod->sect_attrs->attrs[loaded].name;
1446 : nattr->attr.mode = S_IRUGO;
1447 : nattr->size = info->sechdrs[i].sh_size;
1448 : nattr->private = (void *) info->sechdrs[i].sh_addr;
1449 : nattr->read = module_notes_read;
1450 : ++nattr;
1451 : }
1452 : ++loaded;
1453 : }
1454 :
1455 : notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);
1456 : if (!notes_attrs->dir)
1457 : goto out;
1458 :
1459 : for (i = 0; i < notes; ++i)
1460 : if (sysfs_create_bin_file(notes_attrs->dir,
1461 : ¬es_attrs->attrs[i]))
1462 : goto out;
1463 :
1464 : mod->notes_attrs = notes_attrs;
1465 : return;
1466 :
1467 : out:
1468 : free_notes_attrs(notes_attrs, i);
1469 : }
1470 :
1471 : static void remove_notes_attrs(struct module *mod)
1472 : {
1473 : if (mod->notes_attrs)
1474 : free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);
1475 : }
1476 :
1477 : #else
1478 :
1479 : static inline void add_sect_attrs(struct module *mod,
1480 : const struct load_info *info)
1481 : {
1482 : }
1483 :
1484 : static inline void remove_sect_attrs(struct module *mod)
1485 : {
1486 : }
1487 :
1488 : static inline void add_notes_attrs(struct module *mod,
1489 : const struct load_info *info)
1490 : {
1491 : }
1492 :
1493 : static inline void remove_notes_attrs(struct module *mod)
1494 : {
1495 : }
1496 : #endif /* CONFIG_KALLSYMS */
1497 :
1498 16 : static void add_usage_links(struct module *mod)
1499 : {
1500 : #ifdef CONFIG_MODULE_UNLOAD
1501 : struct module_use *use;
1502 : int nowarn;
1503 :
1504 16 : mutex_lock(&module_mutex);
1505 40 : list_for_each_entry(use, &mod->target_list, target_list) {
1506 48 : nowarn = sysfs_create_link(use->target->holders_dir,
1507 24 : &mod->mkobj.kobj, mod->name);
1508 : }
1509 16 : mutex_unlock(&module_mutex);
1510 : #endif
1511 16 : }
1512 :
1513 0 : static void del_usage_links(struct module *mod)
1514 : {
1515 : #ifdef CONFIG_MODULE_UNLOAD
1516 : struct module_use *use;
1517 :
1518 0 : mutex_lock(&module_mutex);
1519 0 : list_for_each_entry(use, &mod->target_list, target_list)
1520 0 : sysfs_remove_link(use->target->holders_dir, mod->name);
1521 0 : mutex_unlock(&module_mutex);
1522 : #endif
1523 0 : }
1524 :
1525 16 : static int module_add_modinfo_attrs(struct module *mod)
1526 : {
1527 : struct module_attribute *attr;
1528 : struct module_attribute *temp_attr;
1529 : int error = 0;
1530 : int i;
1531 :
1532 16 : mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *
1533 : (ARRAY_SIZE(modinfo_attrs) + 1)),
1534 : GFP_KERNEL);
1535 16 : if (!mod->modinfo_attrs)
1536 : return -ENOMEM;
1537 :
1538 : temp_attr = mod->modinfo_attrs;
1539 128 : for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) {
1540 128 : if (!attr->test ||
1541 32 : (attr->test && attr->test(mod))) {
1542 96 : memcpy(temp_attr, attr, sizeof(*temp_attr));
1543 : sysfs_attr_init(&temp_attr->attr);
1544 96 : error = sysfs_create_file(&mod->mkobj.kobj,
1545 96 : &temp_attr->attr);
1546 96 : ++temp_attr;
1547 : }
1548 : }
1549 : return error;
1550 : }
1551 :
1552 0 : static void module_remove_modinfo_attrs(struct module *mod)
1553 : {
1554 : struct module_attribute *attr;
1555 : int i;
1556 :
1557 0 : for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {
1558 : /* pick a field to test for end of list */
1559 0 : if (!attr->attr.name)
1560 : break;
1561 0 : sysfs_remove_file(&mod->mkobj.kobj, &attr->attr);
1562 0 : if (attr->free)
1563 0 : attr->free(mod);
1564 : }
1565 0 : kfree(mod->modinfo_attrs);
1566 0 : }
1567 :
1568 0 : static void mod_kobject_put(struct module *mod)
1569 : {
1570 0 : DECLARE_COMPLETION_ONSTACK(c);
1571 0 : mod->mkobj.kobj_completion = &c;
1572 0 : kobject_put(&mod->mkobj.kobj);
1573 0 : wait_for_completion(&c);
1574 0 : }
1575 :
1576 16 : static int mod_sysfs_init(struct module *mod)
1577 : {
1578 : int err;
1579 : struct kobject *kobj;
1580 :
1581 16 : if (!module_sysfs_initialized) {
1582 0 : pr_err("%s: module sysfs not initialized\n", mod->name);
1583 : err = -EINVAL;
1584 0 : goto out;
1585 : }
1586 :
1587 16 : kobj = kset_find_obj(module_kset, mod->name);
1588 16 : if (kobj) {
1589 0 : pr_err("%s: module is already loaded\n", mod->name);
1590 0 : kobject_put(kobj);
1591 : err = -EINVAL;
1592 0 : goto out;
1593 : }
1594 :
1595 16 : mod->mkobj.mod = mod;
1596 :
1597 16 : memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
1598 16 : mod->mkobj.kobj.kset = module_kset;
1599 16 : err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
1600 : "%s", mod->name);
1601 16 : if (err)
1602 0 : mod_kobject_put(mod);
1603 :
1604 : /* delay uevent until full sysfs population */
1605 : out:
1606 16 : return err;
1607 : }
1608 :
1609 16 : static int mod_sysfs_setup(struct module *mod,
1610 : const struct load_info *info,
1611 : struct kernel_param *kparam,
1612 : unsigned int num_params)
1613 : {
1614 : int err;
1615 :
1616 16 : err = mod_sysfs_init(mod);
1617 16 : if (err)
1618 : goto out;
1619 :
1620 16 : mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);
1621 16 : if (!mod->holders_dir) {
1622 : err = -ENOMEM;
1623 : goto out_unreg;
1624 : }
1625 :
1626 16 : err = module_param_sysfs_setup(mod, kparam, num_params);
1627 16 : if (err)
1628 : goto out_unreg_holders;
1629 :
1630 16 : err = module_add_modinfo_attrs(mod);
1631 16 : if (err)
1632 : goto out_unreg_param;
1633 :
1634 16 : add_usage_links(mod);
1635 : add_sect_attrs(mod, info);
1636 : add_notes_attrs(mod, info);
1637 :
1638 16 : kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
1639 : return 0;
1640 :
1641 : out_unreg_param:
1642 0 : module_param_sysfs_remove(mod);
1643 : out_unreg_holders:
1644 0 : kobject_put(mod->holders_dir);
1645 : out_unreg:
1646 0 : mod_kobject_put(mod);
1647 : out:
1648 : return err;
1649 : }
1650 :
1651 : static void mod_sysfs_fini(struct module *mod)
1652 : {
1653 : remove_notes_attrs(mod);
1654 : remove_sect_attrs(mod);
1655 0 : mod_kobject_put(mod);
1656 : }
1657 :
1658 : #else /* !CONFIG_SYSFS */
1659 :
1660 : static int mod_sysfs_setup(struct module *mod,
1661 : const struct load_info *info,
1662 : struct kernel_param *kparam,
1663 : unsigned int num_params)
1664 : {
1665 : return 0;
1666 : }
1667 :
1668 : static void mod_sysfs_fini(struct module *mod)
1669 : {
1670 : }
1671 :
1672 : static void module_remove_modinfo_attrs(struct module *mod)
1673 : {
1674 : }
1675 :
1676 : static void del_usage_links(struct module *mod)
1677 : {
1678 : }
1679 :
1680 : #endif /* CONFIG_SYSFS */
1681 :
1682 0 : static void mod_sysfs_teardown(struct module *mod)
1683 : {
1684 0 : del_usage_links(mod);
1685 0 : module_remove_modinfo_attrs(mod);
1686 0 : module_param_sysfs_remove(mod);
1687 0 : kobject_put(mod->mkobj.drivers_dir);
1688 0 : kobject_put(mod->holders_dir);
1689 : mod_sysfs_fini(mod);
1690 0 : }
1691 :
1692 : #ifdef CONFIG_DEBUG_SET_MODULE_RONX
1693 : /*
1694 : * LKM RO/NX protection: protect module's text/ro-data
1695 : * from modification and any data from execution.
1696 : */
1697 : void set_page_attributes(void *start, void *end, int (*set)(unsigned long start, int num_pages))
1698 : {
1699 : unsigned long begin_pfn = PFN_DOWN((unsigned long)start);
1700 : unsigned long end_pfn = PFN_DOWN((unsigned long)end);
1701 :
1702 : if (end_pfn > begin_pfn)
1703 : set(begin_pfn << PAGE_SHIFT, end_pfn - begin_pfn);
1704 : }
1705 :
1706 : static void set_section_ro_nx(void *base,
1707 : unsigned long text_size,
1708 : unsigned long ro_size,
1709 : unsigned long total_size)
1710 : {
1711 : /* begin and end PFNs of the current subsection */
1712 : unsigned long begin_pfn;
1713 : unsigned long end_pfn;
1714 :
1715 : /*
1716 : * Set RO for module text and RO-data:
1717 : * - Always protect first page.
1718 : * - Do not protect last partial page.
1719 : */
1720 : if (ro_size > 0)
1721 : set_page_attributes(base, base + ro_size, set_memory_ro);
1722 :
1723 : /*
1724 : * Set NX permissions for module data:
1725 : * - Do not protect first partial page.
1726 : * - Always protect last page.
1727 : */
1728 : if (total_size > text_size) {
1729 : begin_pfn = PFN_UP((unsigned long)base + text_size);
1730 : end_pfn = PFN_UP((unsigned long)base + total_size);
1731 : if (end_pfn > begin_pfn)
1732 : set_memory_nx(begin_pfn << PAGE_SHIFT, end_pfn - begin_pfn);
1733 : }
1734 : }
1735 :
1736 : static void unset_module_core_ro_nx(struct module *mod)
1737 : {
1738 : set_page_attributes(mod->module_core + mod->core_text_size,
1739 : mod->module_core + mod->core_size,
1740 : set_memory_x);
1741 : set_page_attributes(mod->module_core,
1742 : mod->module_core + mod->core_ro_size,
1743 : set_memory_rw);
1744 : }
1745 :
1746 : static void unset_module_init_ro_nx(struct module *mod)
1747 : {
1748 : set_page_attributes(mod->module_init + mod->init_text_size,
1749 : mod->module_init + mod->init_size,
1750 : set_memory_x);
1751 : set_page_attributes(mod->module_init,
1752 : mod->module_init + mod->init_ro_size,
1753 : set_memory_rw);
1754 : }
1755 :
1756 : /* Iterate through all modules and set each module's text as RW */
1757 : void set_all_modules_text_rw(void)
1758 : {
1759 : struct module *mod;
1760 :
1761 : mutex_lock(&module_mutex);
1762 : list_for_each_entry_rcu(mod, &modules, list) {
1763 : if (mod->state == MODULE_STATE_UNFORMED)
1764 : continue;
1765 : if ((mod->module_core) && (mod->core_text_size)) {
1766 : set_page_attributes(mod->module_core,
1767 : mod->module_core + mod->core_text_size,
1768 : set_memory_rw);
1769 : }
1770 : if ((mod->module_init) && (mod->init_text_size)) {
1771 : set_page_attributes(mod->module_init,
1772 : mod->module_init + mod->init_text_size,
1773 : set_memory_rw);
1774 : }
1775 : }
1776 : mutex_unlock(&module_mutex);
1777 : }
1778 :
1779 : /* Iterate through all modules and set each module's text as RO */
1780 : void set_all_modules_text_ro(void)
1781 : {
1782 : struct module *mod;
1783 :
1784 : mutex_lock(&module_mutex);
1785 : list_for_each_entry_rcu(mod, &modules, list) {
1786 : if (mod->state == MODULE_STATE_UNFORMED)
1787 : continue;
1788 : if ((mod->module_core) && (mod->core_text_size)) {
1789 : set_page_attributes(mod->module_core,
1790 : mod->module_core + mod->core_text_size,
1791 : set_memory_ro);
1792 : }
1793 : if ((mod->module_init) && (mod->init_text_size)) {
1794 : set_page_attributes(mod->module_init,
1795 : mod->module_init + mod->init_text_size,
1796 : set_memory_ro);
1797 : }
1798 : }
1799 : mutex_unlock(&module_mutex);
1800 : }
1801 : #else
1802 : static inline void set_section_ro_nx(void *base, unsigned long text_size, unsigned long ro_size, unsigned long total_size) { }
1803 : static void unset_module_core_ro_nx(struct module *mod) { }
1804 : static void unset_module_init_ro_nx(struct module *mod) { }
1805 : #endif
1806 :
1807 38 : void __weak module_memfree(void *module_region)
1808 : {
1809 38 : vfree(module_region);
1810 38 : }
1811 :
1812 0 : void __weak module_arch_cleanup(struct module *mod)
1813 : {
1814 0 : }
1815 :
1816 27 : void __weak module_arch_freeing_init(struct module *mod)
1817 : {
1818 27 : }
1819 :
1820 : /* Free a module, remove from lists, etc. */
1821 0 : static void free_module(struct module *mod)
1822 : {
1823 : trace_module_free(mod);
1824 :
1825 0 : mod_sysfs_teardown(mod);
1826 :
1827 : /* We leave it in list to prevent duplicate loads, but make sure
1828 : * that noone uses it while it's being deconstructed. */
1829 0 : mutex_lock(&module_mutex);
1830 0 : mod->state = MODULE_STATE_UNFORMED;
1831 0 : mutex_unlock(&module_mutex);
1832 :
1833 : /* Remove dynamic debug info */
1834 : ddebug_remove_module(mod->name);
1835 :
1836 : /* Arch-specific cleanup. */
1837 0 : module_arch_cleanup(mod);
1838 :
1839 : /* Module unload stuff */
1840 0 : module_unload_free(mod);
1841 :
1842 : /* Free any allocated parameters. */
1843 0 : destroy_params(mod->kp, mod->num_kp);
1844 :
1845 : /* Now we can delete it from the lists */
1846 0 : mutex_lock(&module_mutex);
1847 : /* Unlink carefully: kallsyms could be walking list. */
1848 : list_del_rcu(&mod->list);
1849 : /* Remove this module from bug list, this uses list_del_rcu */
1850 : module_bug_cleanup(mod);
1851 : /* Wait for RCU synchronizing before releasing mod->list and buglist. */
1852 0 : synchronize_rcu();
1853 0 : mutex_unlock(&module_mutex);
1854 :
1855 : /* This may be NULL, but that's OK */
1856 : unset_module_init_ro_nx(mod);
1857 0 : module_arch_freeing_init(mod);
1858 0 : module_memfree(mod->module_init);
1859 0 : kfree(mod->args);
1860 : percpu_modfree(mod);
1861 :
1862 : /* Free lock-classes: */
1863 : lockdep_free_key_range(mod->module_core, mod->core_size);
1864 :
1865 : /* Finally, free the core (containing the module structure) */
1866 : unset_module_core_ro_nx(mod);
1867 0 : module_memfree(mod->module_core);
1868 :
1869 : #ifdef CONFIG_MPU
1870 : update_protections(current->mm);
1871 : #endif
1872 0 : }
1873 :
1874 0 : void *__symbol_get(const char *symbol)
1875 : {
1876 : struct module *owner;
1877 : const struct kernel_symbol *sym;
1878 :
1879 0 : preempt_disable();
1880 0 : sym = find_symbol(symbol, &owner, NULL, true, true);
1881 0 : if (sym && strong_try_module_get(owner))
1882 : sym = NULL;
1883 0 : preempt_enable();
1884 :
1885 0 : return sym ? (void *)sym->value : NULL;
1886 : }
1887 : EXPORT_SYMBOL_GPL(__symbol_get);
1888 :
1889 : /*
1890 : * Ensure that an exported symbol [global namespace] does not already exist
1891 : * in the kernel or in some other module's exported symbol table.
1892 : *
1893 : * You must hold the module_mutex.
1894 : */
1895 16 : static int verify_export_symbols(struct module *mod)
1896 : {
1897 : unsigned int i;
1898 : struct module *owner;
1899 : const struct kernel_symbol *s;
1900 : struct {
1901 : const struct kernel_symbol *sym;
1902 : unsigned int num;
1903 96 : } arr[] = {
1904 32 : { mod->syms, mod->num_syms },
1905 32 : { mod->gpl_syms, mod->num_gpl_syms },
1906 32 : { mod->gpl_future_syms, mod->num_gpl_future_syms },
1907 : #ifdef CONFIG_UNUSED_SYMBOLS
1908 : { mod->unused_syms, mod->num_unused_syms },
1909 : { mod->unused_gpl_syms, mod->num_unused_gpl_syms },
1910 : #endif
1911 : };
1912 :
1913 64 : for (i = 0; i < ARRAY_SIZE(arr); i++) {
1914 252 : for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) {
1915 204 : if (find_symbol(s->name, &owner, NULL, true, false)) {
1916 0 : pr_err("%s: exports duplicate symbol %s"
1917 : " (owned by %s)\n",
1918 : mod->name, s->name, module_name(owner));
1919 0 : return -ENOEXEC;
1920 : }
1921 : }
1922 : }
1923 : return 0;
1924 : }
1925 :
1926 : /* Change all symbols so that st_value encodes the pointer directly. */
1927 16 : static int simplify_symbols(struct module *mod, const struct load_info *info)
1928 : {
1929 16 : Elf_Shdr *symsec = &info->sechdrs[info->index.sym];
1930 16 : Elf_Sym *sym = (void *)symsec->sh_addr;
1931 : unsigned long secbase;
1932 : unsigned int i;
1933 : int ret = 0;
1934 : const struct kernel_symbol *ksym;
1935 :
1936 2612 : for (i = 1; i < symsec->sh_size / sizeof(Elf_Sym); i++) {
1937 2596 : const char *name = info->strtab + sym[i].st_name;
1938 :
1939 2596 : switch (sym[i].st_shndx) {
1940 : case SHN_COMMON:
1941 : /* Ignore common symbols */
1942 0 : if (!strncmp(name, "__gnu_lto", 9))
1943 : break;
1944 :
1945 : /* We compiled with -fno-common. These are not
1946 : supposed to happen. */
1947 : pr_debug("Common symbol: %s\n", name);
1948 0 : pr_warn("%s: please compile with -fno-common\n",
1949 : mod->name);
1950 : ret = -ENOEXEC;
1951 0 : break;
1952 :
1953 : case SHN_ABS:
1954 : /* Don't need to do anything */
1955 : pr_debug("Absolute symbol: 0x%08lx\n",
1956 : (long)sym[i].st_value);
1957 : break;
1958 :
1959 : case SHN_UNDEF:
1960 905 : ksym = resolve_symbol_wait(mod, info, name);
1961 : /* Ok if resolved. */
1962 1810 : if (ksym && !IS_ERR(ksym)) {
1963 905 : sym[i].st_value = ksym->value;
1964 905 : break;
1965 : }
1966 :
1967 : /* Ok if weak. */
1968 0 : if (!ksym && ELF_ST_BIND(sym[i].st_info) == STB_WEAK)
1969 : break;
1970 :
1971 0 : pr_warn("%s: Unknown symbol %s (err %li)\n",
1972 : mod->name, name, PTR_ERR(ksym));
1973 0 : ret = PTR_ERR(ksym) ?: -ENOENT;
1974 0 : break;
1975 :
1976 : default:
1977 : /* Divert to percpu allocation if a percpu var. */
1978 1487 : if (sym[i].st_shndx == info->index.pcpu)
1979 : secbase = (unsigned long)mod_percpu(mod);
1980 : else
1981 1487 : secbase = info->sechdrs[sym[i].st_shndx].sh_addr;
1982 1487 : sym[i].st_value += secbase;
1983 1487 : break;
1984 : }
1985 : }
1986 :
1987 16 : return ret;
1988 : }
1989 :
1990 16 : static int apply_relocations(struct module *mod, const struct load_info *info)
1991 : {
1992 : unsigned int i;
1993 : int err = 0;
1994 :
1995 : /* Now do relocations. */
1996 517 : for (i = 1; i < info->hdr->e_shnum; i++) {
1997 501 : unsigned int infosec = info->sechdrs[i].sh_info;
1998 :
1999 : /* Not a valid relocation section? */
2000 501 : if (infosec >= info->hdr->e_shnum)
2001 13 : continue;
2002 :
2003 : /* Don't bother with non-allocated sections */
2004 488 : if (!(info->sechdrs[infosec].sh_flags & SHF_ALLOC))
2005 332 : continue;
2006 :
2007 156 : if (info->sechdrs[i].sh_type == SHT_REL)
2008 156 : err = apply_relocate(info->sechdrs, info->strtab,
2009 : info->index.sym, i, mod);
2010 0 : else if (info->sechdrs[i].sh_type == SHT_RELA)
2011 : err = apply_relocate_add(info->sechdrs, info->strtab,
2012 : info->index.sym, i, mod);
2013 156 : if (err < 0)
2014 : break;
2015 : }
2016 16 : return err;
2017 : }
2018 :
2019 : /* Additional bytes needed by arch in front of individual sections */
2020 375 : unsigned int __weak arch_mod_section_prepend(struct module *mod,
2021 : unsigned int section)
2022 : {
2023 : /* default implementation just returns zero */
2024 375 : return 0;
2025 : }
2026 :
2027 : /* Update size with this section: return offset. */
2028 375 : static long get_offset(struct module *mod, unsigned int *size,
2029 : Elf_Shdr *sechdr, unsigned int section)
2030 : {
2031 : long ret;
2032 :
2033 375 : *size += arch_mod_section_prepend(mod, section);
2034 375 : ret = ALIGN(*size, sechdr->sh_addralign ?: 1);
2035 375 : *size = ret + sechdr->sh_size;
2036 375 : return ret;
2037 : }
2038 :
2039 : /* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld
2040 : might -- code, read-only data, read-write data, small data. Tally
2041 : sizes, and place the offsets into sh_entsize fields: high bit means it
2042 : belongs in init. */
2043 27 : static void layout_sections(struct module *mod, struct load_info *info)
2044 : {
2045 : static unsigned long const masks[][2] = {
2046 : /* NOTE: all executable code must be the first section
2047 : * in this array; otherwise modify the text_size
2048 : * finder in the two loops below */
2049 : { SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL },
2050 : { SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL },
2051 : { SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL },
2052 : { ARCH_SHF_SMALL | SHF_ALLOC, 0 }
2053 : };
2054 : unsigned int m, i;
2055 :
2056 916 : for (i = 0; i < info->hdr->e_shnum; i++)
2057 889 : info->sechdrs[i].sh_entsize = ~0UL;
2058 :
2059 : pr_debug("Core section allocation order:\n");
2060 108 : for (m = 0; m < ARRAY_SIZE(masks); ++m) {
2061 3556 : for (i = 0; i < info->hdr->e_shnum; ++i) {
2062 3556 : Elf_Shdr *s = &info->sechdrs[i];
2063 3556 : const char *sname = info->secstrings + s->sh_name;
2064 :
2065 3556 : if ((s->sh_flags & masks[m][0]) != masks[m][0]
2066 964 : || (s->sh_flags & masks[m][1])
2067 856 : || s->sh_entsize != ~0UL
2068 450 : || strstarts(sname, ".init"))
2069 3232 : continue;
2070 324 : s->sh_entsize = get_offset(mod, &mod->core_size, s, i);
2071 : pr_debug("\t%s\n", sname);
2072 : }
2073 108 : switch (m) {
2074 : case 0: /* executable */
2075 27 : mod->core_size = debug_align(mod->core_size);
2076 27 : mod->core_text_size = mod->core_size;
2077 27 : break;
2078 : case 1: /* RO: text and ro-data */
2079 27 : mod->core_size = debug_align(mod->core_size);
2080 27 : mod->core_ro_size = mod->core_size;
2081 27 : break;
2082 : case 3: /* whole core */
2083 : mod->core_size = debug_align(mod->core_size);
2084 : break;
2085 : }
2086 : }
2087 :
2088 : pr_debug("Init section allocation order:\n");
2089 108 : for (m = 0; m < ARRAY_SIZE(masks); ++m) {
2090 3556 : for (i = 0; i < info->hdr->e_shnum; ++i) {
2091 3556 : Elf_Shdr *s = &info->sechdrs[i];
2092 3556 : const char *sname = info->secstrings + s->sh_name;
2093 :
2094 3556 : if ((s->sh_flags & masks[m][0]) != masks[m][0]
2095 964 : || (s->sh_flags & masks[m][1])
2096 856 : || s->sh_entsize != ~0UL
2097 51 : || !strstarts(sname, ".init"))
2098 3505 : continue;
2099 102 : s->sh_entsize = (get_offset(mod, &mod->init_size, s, i)
2100 51 : | INIT_OFFSET_MASK);
2101 : pr_debug("\t%s\n", sname);
2102 : }
2103 108 : switch (m) {
2104 : case 0: /* executable */
2105 27 : mod->init_size = debug_align(mod->init_size);
2106 27 : mod->init_text_size = mod->init_size;
2107 27 : break;
2108 : case 1: /* RO: text and ro-data */
2109 27 : mod->init_size = debug_align(mod->init_size);
2110 27 : mod->init_ro_size = mod->init_size;
2111 27 : break;
2112 : case 3: /* whole init */
2113 : mod->init_size = debug_align(mod->init_size);
2114 : break;
2115 : }
2116 : }
2117 27 : }
2118 :
2119 27 : static void set_license(struct module *mod, const char *license)
2120 : {
2121 27 : if (!license)
2122 : license = "unspecified";
2123 :
2124 27 : if (!license_is_gpl_compatible(license)) {
2125 0 : if (!test_taint(TAINT_PROPRIETARY_MODULE))
2126 0 : pr_warn("%s: module license '%s' taints kernel.\n",
2127 : mod->name, license);
2128 : add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2129 : LOCKDEP_NOW_UNRELIABLE);
2130 : }
2131 27 : }
2132 :
2133 : /* Parse tag=value strings from .modinfo section */
2134 3256 : static char *next_string(char *string, unsigned long *secsize)
2135 : {
2136 : /* Skip non-zero chars */
2137 142851 : while (string[0]) {
2138 136339 : string++;
2139 136339 : if ((*secsize)-- <= 1)
2140 : return NULL;
2141 : }
2142 :
2143 : /* Skip any zero padding. */
2144 6747 : while (!string[0]) {
2145 3550 : string++;
2146 3550 : if ((*secsize)-- <= 1)
2147 : return NULL;
2148 : }
2149 : return string;
2150 : }
2151 :
2152 140 : static char *get_modinfo(struct load_info *info, const char *tag)
2153 : {
2154 : char *p;
2155 140 : unsigned int taglen = strlen(tag);
2156 140 : Elf_Shdr *infosec = &info->sechdrs[info->index.info];
2157 140 : unsigned long size = infosec->sh_size;
2158 :
2159 3396 : for (p = (char *)infosec->sh_addr; p; p = next_string(p, &size)) {
2160 3337 : if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
2161 81 : return p + taglen + 1;
2162 : }
2163 : return NULL;
2164 : }
2165 :
2166 48 : static void setup_modinfo(struct module *mod, struct load_info *info)
2167 : {
2168 : struct module_attribute *attr;
2169 : int i;
2170 :
2171 144 : for (i = 0; (attr = modinfo_attrs[i]); i++) {
2172 128 : if (attr->setup)
2173 64 : attr->setup(mod, get_modinfo(info, attr->attr.name));
2174 : }
2175 16 : }
2176 :
2177 : static void free_modinfo(struct module *mod)
2178 : {
2179 : struct module_attribute *attr;
2180 : int i;
2181 :
2182 0 : for (i = 0; (attr = modinfo_attrs[i]); i++) {
2183 0 : if (attr->free)
2184 0 : attr->free(mod);
2185 : }
2186 : }
2187 :
2188 : #ifdef CONFIG_KALLSYMS
2189 :
2190 : /* lookup symbol in given range of kernel_symbols */
2191 : static const struct kernel_symbol *lookup_symbol(const char *name,
2192 : const struct kernel_symbol *start,
2193 : const struct kernel_symbol *stop)
2194 : {
2195 : return bsearch(name, start, stop - start,
2196 : sizeof(struct kernel_symbol), cmp_name);
2197 : }
2198 :
2199 : static int is_exported(const char *name, unsigned long value,
2200 : const struct module *mod)
2201 : {
2202 : const struct kernel_symbol *ks;
2203 : if (!mod)
2204 : ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab);
2205 : else
2206 : ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms);
2207 : return ks != NULL && ks->value == value;
2208 : }
2209 :
2210 : /* As per nm */
2211 : static char elf_type(const Elf_Sym *sym, const struct load_info *info)
2212 : {
2213 : const Elf_Shdr *sechdrs = info->sechdrs;
2214 :
2215 : if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {
2216 : if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)
2217 : return 'v';
2218 : else
2219 : return 'w';
2220 : }
2221 : if (sym->st_shndx == SHN_UNDEF)
2222 : return 'U';
2223 : if (sym->st_shndx == SHN_ABS)
2224 : return 'a';
2225 : if (sym->st_shndx >= SHN_LORESERVE)
2226 : return '?';
2227 : if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR)
2228 : return 't';
2229 : if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC
2230 : && sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) {
2231 : if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE))
2232 : return 'r';
2233 : else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
2234 : return 'g';
2235 : else
2236 : return 'd';
2237 : }
2238 : if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) {
2239 : if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
2240 : return 's';
2241 : else
2242 : return 'b';
2243 : }
2244 : if (strstarts(info->secstrings + sechdrs[sym->st_shndx].sh_name,
2245 : ".debug")) {
2246 : return 'n';
2247 : }
2248 : return '?';
2249 : }
2250 :
2251 : static bool is_core_symbol(const Elf_Sym *src, const Elf_Shdr *sechdrs,
2252 : unsigned int shnum)
2253 : {
2254 : const Elf_Shdr *sec;
2255 :
2256 : if (src->st_shndx == SHN_UNDEF
2257 : || src->st_shndx >= shnum
2258 : || !src->st_name)
2259 : return false;
2260 :
2261 : sec = sechdrs + src->st_shndx;
2262 : if (!(sec->sh_flags & SHF_ALLOC)
2263 : #ifndef CONFIG_KALLSYMS_ALL
2264 : || !(sec->sh_flags & SHF_EXECINSTR)
2265 : #endif
2266 : || (sec->sh_entsize & INIT_OFFSET_MASK))
2267 : return false;
2268 :
2269 : return true;
2270 : }
2271 :
2272 : /*
2273 : * We only allocate and copy the strings needed by the parts of symtab
2274 : * we keep. This is simple, but has the effect of making multiple
2275 : * copies of duplicates. We could be more sophisticated, see
2276 : * linux-kernel thread starting with
2277 : * <73defb5e4bca04a6431392cc341112b1@localhost>.
2278 : */
2279 : static void layout_symtab(struct module *mod, struct load_info *info)
2280 : {
2281 : Elf_Shdr *symsect = info->sechdrs + info->index.sym;
2282 : Elf_Shdr *strsect = info->sechdrs + info->index.str;
2283 : const Elf_Sym *src;
2284 : unsigned int i, nsrc, ndst, strtab_size = 0;
2285 :
2286 : /* Put symbol section at end of init part of module. */
2287 : symsect->sh_flags |= SHF_ALLOC;
2288 : symsect->sh_entsize = get_offset(mod, &mod->init_size, symsect,
2289 : info->index.sym) | INIT_OFFSET_MASK;
2290 : pr_debug("\t%s\n", info->secstrings + symsect->sh_name);
2291 :
2292 : src = (void *)info->hdr + symsect->sh_offset;
2293 : nsrc = symsect->sh_size / sizeof(*src);
2294 :
2295 : /* Compute total space required for the core symbols' strtab. */
2296 : for (ndst = i = 0; i < nsrc; i++) {
2297 : if (i == 0 ||
2298 : is_core_symbol(src+i, info->sechdrs, info->hdr->e_shnum)) {
2299 : strtab_size += strlen(&info->strtab[src[i].st_name])+1;
2300 : ndst++;
2301 : }
2302 : }
2303 :
2304 : /* Append room for core symbols at end of core part. */
2305 : info->symoffs = ALIGN(mod->core_size, symsect->sh_addralign ?: 1);
2306 : info->stroffs = mod->core_size = info->symoffs + ndst * sizeof(Elf_Sym);
2307 : mod->core_size += strtab_size;
2308 :
2309 : /* Put string table section at end of init part of module. */
2310 : strsect->sh_flags |= SHF_ALLOC;
2311 : strsect->sh_entsize = get_offset(mod, &mod->init_size, strsect,
2312 : info->index.str) | INIT_OFFSET_MASK;
2313 : pr_debug("\t%s\n", info->secstrings + strsect->sh_name);
2314 : }
2315 :
2316 : static void add_kallsyms(struct module *mod, const struct load_info *info)
2317 : {
2318 : unsigned int i, ndst;
2319 : const Elf_Sym *src;
2320 : Elf_Sym *dst;
2321 : char *s;
2322 : Elf_Shdr *symsec = &info->sechdrs[info->index.sym];
2323 :
2324 : mod->symtab = (void *)symsec->sh_addr;
2325 : mod->num_symtab = symsec->sh_size / sizeof(Elf_Sym);
2326 : /* Make sure we get permanent strtab: don't use info->strtab. */
2327 : mod->strtab = (void *)info->sechdrs[info->index.str].sh_addr;
2328 :
2329 : /* Set types up while we still have access to sections. */
2330 : for (i = 0; i < mod->num_symtab; i++)
2331 : mod->symtab[i].st_info = elf_type(&mod->symtab[i], info);
2332 :
2333 : mod->core_symtab = dst = mod->module_core + info->symoffs;
2334 : mod->core_strtab = s = mod->module_core + info->stroffs;
2335 : src = mod->symtab;
2336 : for (ndst = i = 0; i < mod->num_symtab; i++) {
2337 : if (i == 0 ||
2338 : is_core_symbol(src+i, info->sechdrs, info->hdr->e_shnum)) {
2339 : dst[ndst] = src[i];
2340 : dst[ndst++].st_name = s - mod->core_strtab;
2341 : s += strlcpy(s, &mod->strtab[src[i].st_name],
2342 : KSYM_NAME_LEN) + 1;
2343 : }
2344 : }
2345 : mod->core_num_syms = ndst;
2346 : }
2347 : #else
2348 : static inline void layout_symtab(struct module *mod, struct load_info *info)
2349 : {
2350 : }
2351 :
2352 : static void add_kallsyms(struct module *mod, const struct load_info *info)
2353 : {
2354 : }
2355 : #endif /* CONFIG_KALLSYMS */
2356 :
2357 : static void dynamic_debug_setup(struct _ddebug *debug, unsigned int num)
2358 : {
2359 : if (!debug)
2360 : return;
2361 : #ifdef CONFIG_DYNAMIC_DEBUG
2362 : if (ddebug_add_module(debug, num, debug->modname))
2363 : pr_err("dynamic debug error adding module: %s\n",
2364 : debug->modname);
2365 : #endif
2366 : }
2367 :
2368 : static void dynamic_debug_remove(struct _ddebug *debug)
2369 : {
2370 : if (debug)
2371 : ddebug_remove_module(debug->modname);
2372 : }
2373 :
2374 0 : void * __weak module_alloc(unsigned long size)
2375 : {
2376 0 : return vmalloc_exec(size);
2377 : }
2378 :
2379 54 : static void *module_alloc_update_bounds(unsigned long size)
2380 : {
2381 54 : void *ret = module_alloc(size);
2382 :
2383 54 : if (ret) {
2384 54 : mutex_lock(&module_mutex);
2385 : /* Update module bounds. */
2386 54 : if ((unsigned long)ret < module_addr_min)
2387 1 : module_addr_min = (unsigned long)ret;
2388 54 : if ((unsigned long)ret + size > module_addr_max)
2389 53 : module_addr_max = (unsigned long)ret + size;
2390 54 : mutex_unlock(&module_mutex);
2391 : }
2392 54 : return ret;
2393 : }
2394 :
2395 : #ifdef CONFIG_DEBUG_KMEMLEAK
2396 : static void kmemleak_load_module(const struct module *mod,
2397 : const struct load_info *info)
2398 : {
2399 : unsigned int i;
2400 :
2401 : /* only scan the sections containing data */
2402 : kmemleak_scan_area(mod, sizeof(struct module), GFP_KERNEL);
2403 :
2404 : for (i = 1; i < info->hdr->e_shnum; i++) {
2405 : /* Scan all writable sections that's not executable */
2406 : if (!(info->sechdrs[i].sh_flags & SHF_ALLOC) ||
2407 : !(info->sechdrs[i].sh_flags & SHF_WRITE) ||
2408 : (info->sechdrs[i].sh_flags & SHF_EXECINSTR))
2409 : continue;
2410 :
2411 : kmemleak_scan_area((void *)info->sechdrs[i].sh_addr,
2412 : info->sechdrs[i].sh_size, GFP_KERNEL);
2413 : }
2414 : }
2415 : #else
2416 : static inline void kmemleak_load_module(const struct module *mod,
2417 : const struct load_info *info)
2418 : {
2419 : }
2420 : #endif
2421 :
2422 : #ifdef CONFIG_MODULE_SIG
2423 : static int module_sig_check(struct load_info *info)
2424 : {
2425 : int err = -ENOKEY;
2426 : const unsigned long markerlen = sizeof(MODULE_SIG_STRING) - 1;
2427 : const void *mod = info->hdr;
2428 :
2429 : if (info->len > markerlen &&
2430 : memcmp(mod + info->len - markerlen, MODULE_SIG_STRING, markerlen) == 0) {
2431 : /* We truncate the module to discard the signature */
2432 : info->len -= markerlen;
2433 : err = mod_verify_sig(mod, &info->len);
2434 : }
2435 :
2436 : if (!err) {
2437 : info->sig_ok = true;
2438 : return 0;
2439 : }
2440 :
2441 : /* Not having a signature is only an error if we're strict. */
2442 : if (err == -ENOKEY && !sig_enforce)
2443 : err = 0;
2444 :
2445 : return err;
2446 : }
2447 : #else /* !CONFIG_MODULE_SIG */
2448 : static int module_sig_check(struct load_info *info)
2449 : {
2450 : return 0;
2451 : }
2452 : #endif /* !CONFIG_MODULE_SIG */
2453 :
2454 : /* Sanity checks against invalid binaries, wrong arch, weird elf version. */
2455 27 : static int elf_header_check(struct load_info *info)
2456 : {
2457 27 : if (info->len < sizeof(*(info->hdr)))
2458 : return -ENOEXEC;
2459 :
2460 27 : if (memcmp(info->hdr->e_ident, ELFMAG, SELFMAG) != 0
2461 27 : || info->hdr->e_type != ET_REL
2462 27 : || !elf_check_arch(info->hdr)
2463 27 : || info->hdr->e_shentsize != sizeof(Elf_Shdr))
2464 : return -ENOEXEC;
2465 :
2466 27 : if (info->hdr->e_shoff >= info->len
2467 54 : || (info->hdr->e_shnum * sizeof(Elf_Shdr) >
2468 27 : info->len - info->hdr->e_shoff))
2469 : return -ENOEXEC;
2470 :
2471 : return 0;
2472 : }
2473 :
2474 : /* Sets info->hdr and info->len. */
2475 27 : static int copy_module_from_user(const void __user *umod, unsigned long len,
2476 : struct load_info *info)
2477 : {
2478 : int err;
2479 :
2480 27 : info->len = len;
2481 27 : if (info->len < sizeof(*(info->hdr)))
2482 : return -ENOEXEC;
2483 :
2484 : err = security_kernel_module_from_file(NULL);
2485 : if (err)
2486 : return err;
2487 :
2488 : /* Suck in entire file: we'll want most of it. */
2489 27 : info->hdr = vmalloc(info->len);
2490 27 : if (!info->hdr)
2491 : return -ENOMEM;
2492 :
2493 54 : if (copy_from_user(info->hdr, umod, info->len) != 0) {
2494 0 : vfree(info->hdr);
2495 : return -EFAULT;
2496 : }
2497 :
2498 : return 0;
2499 : }
2500 :
2501 : /* Sets info->hdr and info->len. */
2502 0 : static int copy_module_from_fd(int fd, struct load_info *info)
2503 : {
2504 0 : struct fd f = fdget(fd);
2505 : int err;
2506 : struct kstat stat;
2507 : loff_t pos;
2508 : ssize_t bytes = 0;
2509 :
2510 0 : if (!f.file)
2511 : return -ENOEXEC;
2512 :
2513 : err = security_kernel_module_from_file(f.file);
2514 : if (err)
2515 : goto out;
2516 :
2517 0 : err = vfs_getattr(&f.file->f_path, &stat);
2518 0 : if (err)
2519 : goto out;
2520 :
2521 0 : if (stat.size > INT_MAX) {
2522 : err = -EFBIG;
2523 : goto out;
2524 : }
2525 :
2526 : /* Don't hand 0 to vmalloc, it whines. */
2527 0 : if (stat.size == 0) {
2528 : err = -EINVAL;
2529 : goto out;
2530 : }
2531 :
2532 0 : info->hdr = vmalloc(stat.size);
2533 0 : if (!info->hdr) {
2534 : err = -ENOMEM;
2535 : goto out;
2536 : }
2537 :
2538 : pos = 0;
2539 0 : while (pos < stat.size) {
2540 0 : bytes = kernel_read(f.file, pos, (char *)(info->hdr) + pos,
2541 : stat.size - pos);
2542 0 : if (bytes < 0) {
2543 0 : vfree(info->hdr);
2544 : err = bytes;
2545 : goto out;
2546 : }
2547 0 : if (bytes == 0)
2548 : break;
2549 0 : pos += bytes;
2550 : }
2551 0 : info->len = pos;
2552 :
2553 : out:
2554 : fdput(f);
2555 : return err;
2556 : }
2557 :
2558 : static void free_copy(struct load_info *info)
2559 : {
2560 27 : vfree(info->hdr);
2561 : }
2562 :
2563 27 : static int rewrite_section_headers(struct load_info *info, int flags)
2564 : {
2565 : unsigned int i;
2566 :
2567 : /* This should always be true, but let's be sure. */
2568 27 : info->sechdrs[0].sh_addr = 0;
2569 :
2570 889 : for (i = 1; i < info->hdr->e_shnum; i++) {
2571 862 : Elf_Shdr *shdr = &info->sechdrs[i];
2572 862 : if (shdr->sh_type != SHT_NOBITS
2573 835 : && info->len < shdr->sh_offset + shdr->sh_size) {
2574 0 : pr_err("Module len %lu truncated\n", info->len);
2575 0 : return -ENOEXEC;
2576 : }
2577 :
2578 : /* Mark all sections sh_addr with their address in the
2579 : temporary image. */
2580 862 : shdr->sh_addr = (size_t)info->hdr + shdr->sh_offset;
2581 :
2582 : #ifndef CONFIG_MODULE_UNLOAD
2583 : /* Don't load .exit sections */
2584 : if (strstarts(info->secstrings+shdr->sh_name, ".exit"))
2585 : shdr->sh_flags &= ~(unsigned long)SHF_ALLOC;
2586 : #endif
2587 : }
2588 :
2589 : /* Track but don't keep modinfo and version sections. */
2590 27 : if (flags & MODULE_INIT_IGNORE_MODVERSIONS)
2591 0 : info->index.vers = 0; /* Pretend no __versions section! */
2592 : else
2593 27 : info->index.vers = find_sec(info, "__versions");
2594 27 : info->index.info = find_sec(info, ".modinfo");
2595 27 : info->sechdrs[info->index.info].sh_flags &= ~(unsigned long)SHF_ALLOC;
2596 27 : info->sechdrs[info->index.vers].sh_flags &= ~(unsigned long)SHF_ALLOC;
2597 27 : return 0;
2598 : }
2599 :
2600 : /*
2601 : * Set up our basic convenience variables (pointers to section headers,
2602 : * search for module section index etc), and do some basic section
2603 : * verification.
2604 : *
2605 : * Return the temporary module pointer (we'll replace it with the final
2606 : * one when we move the module sections around).
2607 : */
2608 27 : static struct module *setup_load_info(struct load_info *info, int flags)
2609 : {
2610 : unsigned int i;
2611 : int err;
2612 : struct module *mod;
2613 :
2614 : /* Set up the convenience variables */
2615 27 : info->sechdrs = (void *)info->hdr + info->hdr->e_shoff;
2616 27 : info->secstrings = (void *)info->hdr
2617 27 : + info->sechdrs[info->hdr->e_shstrndx].sh_offset;
2618 :
2619 27 : err = rewrite_section_headers(info, flags);
2620 27 : if (err)
2621 0 : return ERR_PTR(err);
2622 :
2623 : /* Find internal symbols and strings. */
2624 808 : for (i = 1; i < info->hdr->e_shnum; i++) {
2625 835 : if (info->sechdrs[i].sh_type == SHT_SYMTAB) {
2626 27 : info->index.sym = i;
2627 27 : info->index.str = info->sechdrs[i].sh_link;
2628 27 : info->strtab = (char *)info->hdr
2629 27 : + info->sechdrs[info->index.str].sh_offset;
2630 27 : break;
2631 : }
2632 : }
2633 :
2634 27 : info->index.mod = find_sec(info, ".gnu.linkonce.this_module");
2635 27 : if (!info->index.mod) {
2636 0 : pr_warn("No module found in object\n");
2637 0 : return ERR_PTR(-ENOEXEC);
2638 : }
2639 : /* This is temporary: point mod into copy of data. */
2640 27 : mod = (void *)info->sechdrs[info->index.mod].sh_addr;
2641 :
2642 27 : if (info->index.sym == 0) {
2643 0 : pr_warn("%s: module has no symbols (stripped?)\n", mod->name);
2644 0 : return ERR_PTR(-ENOEXEC);
2645 : }
2646 :
2647 27 : info->index.pcpu = find_pcpusec(info);
2648 :
2649 : /* Check module struct version now, before we try to use module. */
2650 54 : if (!check_modstruct_version(info->sechdrs, info->index.vers, mod))
2651 : return ERR_PTR(-ENOEXEC);
2652 :
2653 27 : return mod;
2654 : }
2655 :
2656 108 : static int check_modinfo(struct module *mod, struct load_info *info, int flags)
2657 : {
2658 27 : const char *modmagic = get_modinfo(info, "vermagic");
2659 : int err;
2660 :
2661 27 : if (flags & MODULE_INIT_IGNORE_VERMAGIC)
2662 : modmagic = NULL;
2663 :
2664 : /* This is allowed: modprobe --force will invalidate it. */
2665 27 : if (!modmagic) {
2666 : err = try_to_force_load(mod, "bad vermagic");
2667 : if (err)
2668 : return err;
2669 54 : } else if (!same_magic(modmagic, vermagic, info->index.vers)) {
2670 0 : pr_err("%s: version magic '%s' should be '%s'\n",
2671 : mod->name, modmagic, vermagic);
2672 0 : return -ENOEXEC;
2673 : }
2674 :
2675 27 : if (!get_modinfo(info, "intree"))
2676 : add_taint_module(mod, TAINT_OOT_MODULE, LOCKDEP_STILL_OK);
2677 :
2678 27 : if (get_modinfo(info, "staging")) {
2679 : add_taint_module(mod, TAINT_CRAP, LOCKDEP_STILL_OK);
2680 0 : pr_warn("%s: module is from the staging directory, the quality "
2681 : "is unknown, you have been warned.\n", mod->name);
2682 : }
2683 :
2684 : /* Set up license info based on the info section */
2685 27 : set_license(mod, get_modinfo(info, "license"));
2686 :
2687 27 : return 0;
2688 : }
2689 :
2690 16 : static int find_module_sections(struct module *mod, struct load_info *info)
2691 : {
2692 16 : mod->kp = section_objs(info, "__param",
2693 : sizeof(*mod->kp), &mod->num_kp);
2694 16 : mod->syms = section_objs(info, "__ksymtab",
2695 : sizeof(*mod->syms), &mod->num_syms);
2696 16 : mod->crcs = section_addr(info, "__kcrctab");
2697 16 : mod->gpl_syms = section_objs(info, "__ksymtab_gpl",
2698 : sizeof(*mod->gpl_syms),
2699 : &mod->num_gpl_syms);
2700 16 : mod->gpl_crcs = section_addr(info, "__kcrctab_gpl");
2701 16 : mod->gpl_future_syms = section_objs(info,
2702 : "__ksymtab_gpl_future",
2703 : sizeof(*mod->gpl_future_syms),
2704 : &mod->num_gpl_future_syms);
2705 16 : mod->gpl_future_crcs = section_addr(info, "__kcrctab_gpl_future");
2706 :
2707 : #ifdef CONFIG_UNUSED_SYMBOLS
2708 : mod->unused_syms = section_objs(info, "__ksymtab_unused",
2709 : sizeof(*mod->unused_syms),
2710 : &mod->num_unused_syms);
2711 : mod->unused_crcs = section_addr(info, "__kcrctab_unused");
2712 : mod->unused_gpl_syms = section_objs(info, "__ksymtab_unused_gpl",
2713 : sizeof(*mod->unused_gpl_syms),
2714 : &mod->num_unused_gpl_syms);
2715 : mod->unused_gpl_crcs = section_addr(info, "__kcrctab_unused_gpl");
2716 : #endif
2717 : #ifdef CONFIG_CONSTRUCTORS
2718 16 : mod->ctors = section_objs(info, ".ctors",
2719 : sizeof(*mod->ctors), &mod->num_ctors);
2720 16 : if (!mod->ctors)
2721 16 : mod->ctors = section_objs(info, ".init_array",
2722 : sizeof(*mod->ctors), &mod->num_ctors);
2723 0 : else if (find_sec(info, ".init_array")) {
2724 : /*
2725 : * This shouldn't happen with same compiler and binutils
2726 : * building all parts of the module.
2727 : */
2728 0 : pr_warn("%s: has both .ctors and .init_array.\n",
2729 : mod->name);
2730 0 : return -EINVAL;
2731 : }
2732 : #endif
2733 :
2734 : #ifdef CONFIG_TRACEPOINTS
2735 : mod->tracepoints_ptrs = section_objs(info, "__tracepoints_ptrs",
2736 : sizeof(*mod->tracepoints_ptrs),
2737 : &mod->num_tracepoints);
2738 : #endif
2739 : #ifdef HAVE_JUMP_LABEL
2740 16 : mod->jump_entries = section_objs(info, "__jump_table",
2741 : sizeof(*mod->jump_entries),
2742 : &mod->num_jump_entries);
2743 : #endif
2744 : #ifdef CONFIG_EVENT_TRACING
2745 : mod->trace_events = section_objs(info, "_ftrace_events",
2746 : sizeof(*mod->trace_events),
2747 : &mod->num_trace_events);
2748 : #endif
2749 : #ifdef CONFIG_TRACING
2750 : mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
2751 : sizeof(*mod->trace_bprintk_fmt_start),
2752 : &mod->num_trace_bprintk_fmt);
2753 : #endif
2754 : #ifdef CONFIG_FTRACE_MCOUNT_RECORD
2755 : /* sechdrs[0].sh_size is always zero */
2756 : mod->ftrace_callsites = section_objs(info, "__mcount_loc",
2757 : sizeof(*mod->ftrace_callsites),
2758 : &mod->num_ftrace_callsites);
2759 : #endif
2760 :
2761 16 : mod->extable = section_objs(info, "__ex_table",
2762 : sizeof(*mod->extable), &mod->num_exentries);
2763 :
2764 16 : if (section_addr(info, "__obsparm"))
2765 0 : pr_warn("%s: Ignoring obsolete parameters\n", mod->name);
2766 :
2767 16 : info->debug = section_objs(info, "__verbose",
2768 : sizeof(*info->debug), &info->num_debug);
2769 :
2770 16 : return 0;
2771 : }
2772 :
2773 27 : static int move_module(struct module *mod, struct load_info *info)
2774 : {
2775 : int i;
2776 : void *ptr;
2777 :
2778 : /* Do the allocs. */
2779 27 : ptr = module_alloc_update_bounds(mod->core_size);
2780 : /*
2781 : * The pointer to this block is stored in the module structure
2782 : * which is inside the block. Just mark it as not being a
2783 : * leak.
2784 : */
2785 : kmemleak_not_leak(ptr);
2786 27 : if (!ptr)
2787 : return -ENOMEM;
2788 :
2789 27 : memset(ptr, 0, mod->core_size);
2790 27 : mod->module_core = ptr;
2791 :
2792 27 : if (mod->init_size) {
2793 27 : ptr = module_alloc_update_bounds(mod->init_size);
2794 : /*
2795 : * The pointer to this block is stored in the module structure
2796 : * which is inside the block. This block doesn't need to be
2797 : * scanned as it contains data and code that will be freed
2798 : * after the module is initialized.
2799 : */
2800 : kmemleak_ignore(ptr);
2801 27 : if (!ptr) {
2802 0 : module_memfree(mod->module_core);
2803 : return -ENOMEM;
2804 : }
2805 27 : memset(ptr, 0, mod->init_size);
2806 27 : mod->module_init = ptr;
2807 : } else
2808 0 : mod->module_init = NULL;
2809 :
2810 : /* Transfer each section which specifies SHF_ALLOC */
2811 : pr_debug("final section addresses:\n");
2812 889 : for (i = 0; i < info->hdr->e_shnum; i++) {
2813 : void *dest;
2814 889 : Elf_Shdr *shdr = &info->sechdrs[i];
2815 :
2816 889 : if (!(shdr->sh_flags & SHF_ALLOC))
2817 514 : continue;
2818 :
2819 375 : if (shdr->sh_entsize & INIT_OFFSET_MASK)
2820 102 : dest = mod->module_init
2821 51 : + (shdr->sh_entsize & ~INIT_OFFSET_MASK);
2822 : else
2823 324 : dest = mod->module_core + shdr->sh_entsize;
2824 :
2825 375 : if (shdr->sh_type != SHT_NOBITS)
2826 348 : memcpy(dest, (void *)shdr->sh_addr, shdr->sh_size);
2827 : /* Update sh_addr to point to copy in image. */
2828 375 : shdr->sh_addr = (unsigned long)dest;
2829 : pr_debug("\t0x%lx %s\n",
2830 : (long)shdr->sh_addr, info->secstrings + shdr->sh_name);
2831 : }
2832 :
2833 : return 0;
2834 : }
2835 :
2836 16 : static int check_module_license_and_versions(struct module *mod)
2837 : {
2838 : /*
2839 : * ndiswrapper is under GPL by itself, but loads proprietary modules.
2840 : * Don't use add_taint_module(), as it would prevent ndiswrapper from
2841 : * using GPL-only symbols it needs.
2842 : */
2843 16 : if (strcmp(mod->name, "ndiswrapper") == 0)
2844 0 : add_taint(TAINT_PROPRIETARY_MODULE, LOCKDEP_NOW_UNRELIABLE);
2845 :
2846 : /* driverloader was caught wrongly pretending to be under GPL */
2847 16 : if (strcmp(mod->name, "driverloader") == 0)
2848 : add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2849 : LOCKDEP_NOW_UNRELIABLE);
2850 :
2851 : /* lve claims to be GPL but upstream won't provide source */
2852 16 : if (strcmp(mod->name, "lve") == 0)
2853 : add_taint_module(mod, TAINT_PROPRIETARY_MODULE,
2854 : LOCKDEP_NOW_UNRELIABLE);
2855 :
2856 : #ifdef CONFIG_MODVERSIONS
2857 16 : if ((mod->num_syms && !mod->crcs)
2858 16 : || (mod->num_gpl_syms && !mod->gpl_crcs)
2859 16 : || (mod->num_gpl_future_syms && !mod->gpl_future_crcs)
2860 : #ifdef CONFIG_UNUSED_SYMBOLS
2861 : || (mod->num_unused_syms && !mod->unused_crcs)
2862 : || (mod->num_unused_gpl_syms && !mod->unused_gpl_crcs)
2863 : #endif
2864 : ) {
2865 : return try_to_force_load(mod,
2866 : "no versions for exported symbols");
2867 : }
2868 : #endif
2869 16 : return 0;
2870 : }
2871 :
2872 16 : static void flush_module_icache(const struct module *mod)
2873 : {
2874 : mm_segment_t old_fs;
2875 :
2876 : /* flush the icache in correct context */
2877 16 : old_fs = get_fs();
2878 : set_fs(KERNEL_DS);
2879 :
2880 : /*
2881 : * Flush the instruction cache, since we've played with text.
2882 : * Do it before processing of module parameters, so the module
2883 : * can provide parameter accessor functions of its own.
2884 : */
2885 16 : if (mod->module_init)
2886 16 : flush_icache_range((unsigned long)mod->module_init,
2887 : (unsigned long)mod->module_init
2888 : + mod->init_size);
2889 16 : flush_icache_range((unsigned long)mod->module_core,
2890 : (unsigned long)mod->module_core + mod->core_size);
2891 :
2892 : set_fs(old_fs);
2893 16 : }
2894 :
2895 27 : int __weak module_frob_arch_sections(Elf_Ehdr *hdr,
2896 : Elf_Shdr *sechdrs,
2897 : char *secstrings,
2898 : struct module *mod)
2899 : {
2900 27 : return 0;
2901 : }
2902 :
2903 27 : static struct module *layout_and_allocate(struct load_info *info, int flags)
2904 : {
2905 : /* Module within temporary copy. */
2906 : struct module *mod;
2907 : int err;
2908 :
2909 27 : mod = setup_load_info(info, flags);
2910 27 : if (IS_ERR(mod))
2911 : return mod;
2912 :
2913 27 : err = check_modinfo(mod, info, flags);
2914 27 : if (err)
2915 0 : return ERR_PTR(err);
2916 :
2917 : /* Allow arches to frob section contents and sizes. */
2918 27 : err = module_frob_arch_sections(info->hdr, info->sechdrs,
2919 : info->secstrings, mod);
2920 27 : if (err < 0)
2921 0 : return ERR_PTR(err);
2922 :
2923 : /* We will do a special allocation for per-cpu sections later. */
2924 27 : info->sechdrs[info->index.pcpu].sh_flags &= ~(unsigned long)SHF_ALLOC;
2925 :
2926 : /* Determine total sizes, and put offsets in sh_entsize. For now
2927 : this is done generically; there doesn't appear to be any
2928 : special cases for the architectures. */
2929 27 : layout_sections(mod, info);
2930 : layout_symtab(mod, info);
2931 :
2932 : /* Allocate and move to the final place */
2933 27 : err = move_module(mod, info);
2934 27 : if (err)
2935 0 : return ERR_PTR(err);
2936 :
2937 : /* Module has been copied to its final place now: return it. */
2938 27 : mod = (void *)info->sechdrs[info->index.mod].sh_addr;
2939 : kmemleak_load_module(mod, info);
2940 27 : return mod;
2941 : }
2942 :
2943 : /* mod is no longer valid after this! */
2944 11 : static void module_deallocate(struct module *mod, struct load_info *info)
2945 : {
2946 : percpu_modfree(mod);
2947 11 : module_arch_freeing_init(mod);
2948 11 : module_memfree(mod->module_init);
2949 11 : module_memfree(mod->module_core);
2950 11 : }
2951 :
2952 0 : int __weak module_finalize(const Elf_Ehdr *hdr,
2953 : const Elf_Shdr *sechdrs,
2954 : struct module *me)
2955 : {
2956 0 : return 0;
2957 : }
2958 :
2959 16 : static int post_relocation(struct module *mod, const struct load_info *info)
2960 : {
2961 : /* Sort exception table now relocations are done. */
2962 16 : sort_extable(mod->extable, mod->extable + mod->num_exentries);
2963 :
2964 : /* Copy relocated percpu area over. */
2965 : percpu_modcopy(mod, (void *)info->sechdrs[info->index.pcpu].sh_addr,
2966 : info->sechdrs[info->index.pcpu].sh_size);
2967 :
2968 : /* Setup kallsyms-specific fields. */
2969 : add_kallsyms(mod, info);
2970 :
2971 : /* Arch-specific module finalizing. */
2972 16 : return module_finalize(info->hdr, info->sechdrs, mod);
2973 : }
2974 :
2975 : /* Is this module of this name done loading? No locks held. */
2976 20 : static bool finished_loading(const char *name)
2977 : {
2978 : struct module *mod;
2979 : bool ret;
2980 :
2981 20 : mutex_lock(&module_mutex);
2982 20 : mod = find_module_all(name, strlen(name), true);
2983 40 : ret = !mod || mod->state == MODULE_STATE_LIVE
2984 31 : || mod->state == MODULE_STATE_GOING;
2985 20 : mutex_unlock(&module_mutex);
2986 :
2987 20 : return ret;
2988 : }
2989 :
2990 : /* Call module constructors. */
2991 : static void do_mod_ctors(struct module *mod)
2992 : {
2993 : #ifdef CONFIG_CONSTRUCTORS
2994 : unsigned long i;
2995 :
2996 55 : for (i = 0; i < mod->num_ctors; i++)
2997 55 : mod->ctors[i]();
2998 : #endif
2999 : }
3000 :
3001 : /* For freeing module_init on success, in case kallsyms traversing */
3002 : struct mod_initfree {
3003 : struct rcu_head rcu;
3004 : void *module_init;
3005 : };
3006 :
3007 16 : static void do_free_init(struct rcu_head *head)
3008 : {
3009 : struct mod_initfree *m = container_of(head, struct mod_initfree, rcu);
3010 16 : module_memfree(m->module_init);
3011 16 : kfree(m);
3012 16 : }
3013 :
3014 : /* This is where the real work happens */
3015 16 : static int do_init_module(struct module *mod)
3016 : {
3017 : int ret = 0;
3018 : struct mod_initfree *freeinit;
3019 :
3020 : freeinit = kmalloc(sizeof(*freeinit), GFP_KERNEL);
3021 16 : if (!freeinit) {
3022 : ret = -ENOMEM;
3023 : goto fail;
3024 : }
3025 16 : freeinit->module_init = mod->module_init;
3026 :
3027 : /*
3028 : * We want to find out whether @mod uses async during init. Clear
3029 : * PF_USED_ASYNC. async_schedule*() will set it.
3030 : */
3031 16 : current->flags &= ~PF_USED_ASYNC;
3032 :
3033 : do_mod_ctors(mod);
3034 : /* Start the module */
3035 16 : if (mod->init != NULL)
3036 15 : ret = do_one_initcall(mod->init);
3037 16 : if (ret < 0) {
3038 : goto fail_free_freeinit;
3039 : }
3040 16 : if (ret > 0) {
3041 0 : pr_warn("%s: '%s'->init suspiciously returned %d, it should "
3042 : "follow 0/-E convention\n"
3043 : "%s: loading module anyway...\n",
3044 : __func__, mod->name, ret, __func__);
3045 0 : dump_stack();
3046 : }
3047 :
3048 : /* Now it's a first class citizen! */
3049 16 : mod->state = MODULE_STATE_LIVE;
3050 16 : blocking_notifier_call_chain(&module_notify_list,
3051 : MODULE_STATE_LIVE, mod);
3052 :
3053 : /*
3054 : * We need to finish all async code before the module init sequence
3055 : * is done. This has potential to deadlock. For example, a newly
3056 : * detected block device can trigger request_module() of the
3057 : * default iosched from async probing task. Once userland helper
3058 : * reaches here, async_synchronize_full() will wait on the async
3059 : * task waiting on request_module() and deadlock.
3060 : *
3061 : * This deadlock is avoided by perfomring async_synchronize_full()
3062 : * iff module init queued any async jobs. This isn't a full
3063 : * solution as it will deadlock the same if module loading from
3064 : * async jobs nests more than once; however, due to the various
3065 : * constraints, this hack seems to be the best option for now.
3066 : * Please refer to the following thread for details.
3067 : *
3068 : * http://thread.gmane.org/gmane.linux.kernel/1420814
3069 : */
3070 16 : if (current->flags & PF_USED_ASYNC)
3071 0 : async_synchronize_full();
3072 :
3073 16 : mutex_lock(&module_mutex);
3074 : /* Drop initial reference. */
3075 16 : module_put(mod);
3076 16 : trim_init_extable(mod);
3077 : #ifdef CONFIG_KALLSYMS
3078 : mod->num_symtab = mod->core_num_syms;
3079 : mod->symtab = mod->core_symtab;
3080 : mod->strtab = mod->core_strtab;
3081 : #endif
3082 : unset_module_init_ro_nx(mod);
3083 16 : module_arch_freeing_init(mod);
3084 16 : mod->module_init = NULL;
3085 16 : mod->init_size = 0;
3086 16 : mod->init_ro_size = 0;
3087 16 : mod->init_text_size = 0;
3088 : /*
3089 : * We want to free module_init, but be aware that kallsyms may be
3090 : * walking this with preempt disabled. In all the failure paths,
3091 : * we call synchronize_rcu/synchronize_sched, but we don't want
3092 : * to slow down the success path, so use actual RCU here.
3093 : */
3094 16 : call_rcu(&freeinit->rcu, do_free_init);
3095 16 : mutex_unlock(&module_mutex);
3096 16 : wake_up_all(&module_wq);
3097 :
3098 16 : return 0;
3099 :
3100 : fail_free_freeinit:
3101 0 : kfree(freeinit);
3102 : fail:
3103 : /* Try to protect us from buggy refcounters. */
3104 0 : mod->state = MODULE_STATE_GOING;
3105 0 : synchronize_sched();
3106 0 : module_put(mod);
3107 0 : blocking_notifier_call_chain(&module_notify_list,
3108 : MODULE_STATE_GOING, mod);
3109 0 : free_module(mod);
3110 0 : wake_up_all(&module_wq);
3111 0 : return ret;
3112 : }
3113 :
3114 27 : static int may_init_module(void)
3115 : {
3116 27 : if (!capable(CAP_SYS_MODULE) || modules_disabled)
3117 : return -EPERM;
3118 :
3119 27 : return 0;
3120 : }
3121 :
3122 : /*
3123 : * Can't use wait_event_interruptible() because our condition
3124 : * 'finished_loading()' contains a blocking primitive itself (mutex_lock).
3125 : */
3126 9 : static int wait_finished_loading(struct module *mod)
3127 : {
3128 18 : DEFINE_WAIT_FUNC(wait, woken_wake_function);
3129 : int ret = 0;
3130 :
3131 9 : add_wait_queue(&module_wq, &wait);
3132 : for (;;) {
3133 20 : if (finished_loading(mod->name))
3134 : break;
3135 :
3136 22 : if (signal_pending(current)) {
3137 : ret = -ERESTARTSYS;
3138 : break;
3139 : }
3140 :
3141 11 : wait_woken(&wait, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
3142 11 : }
3143 9 : remove_wait_queue(&module_wq, &wait);
3144 :
3145 9 : return ret;
3146 : }
3147 :
3148 : /*
3149 : * We try to place it in the list now to make sure it's unique before
3150 : * we dedicate too many resources. In particular, temporary percpu
3151 : * memory exhaustion.
3152 : */
3153 27 : static int add_unformed_module(struct module *mod)
3154 : {
3155 : int err;
3156 : struct module *old;
3157 :
3158 27 : mod->state = MODULE_STATE_UNFORMED;
3159 :
3160 : again:
3161 36 : mutex_lock(&module_mutex);
3162 36 : old = find_module_all(mod->name, strlen(mod->name), true);
3163 36 : if (old != NULL) {
3164 40 : if (old->state == MODULE_STATE_COMING
3165 20 : || old->state == MODULE_STATE_UNFORMED) {
3166 : /* Wait in case it fails to load. */
3167 9 : mutex_unlock(&module_mutex);
3168 :
3169 9 : err = wait_finished_loading(mod);
3170 9 : if (err)
3171 : goto out_unlocked;
3172 : goto again;
3173 : }
3174 : err = -EEXIST;
3175 : goto out;
3176 : }
3177 16 : list_add_rcu(&mod->list, &modules);
3178 : err = 0;
3179 :
3180 : out:
3181 27 : mutex_unlock(&module_mutex);
3182 : out_unlocked:
3183 27 : return err;
3184 : }
3185 :
3186 16 : static int complete_formation(struct module *mod, struct load_info *info)
3187 : {
3188 : int err;
3189 :
3190 16 : mutex_lock(&module_mutex);
3191 :
3192 : /* Find duplicate symbols (must be called under lock). */
3193 16 : err = verify_export_symbols(mod);
3194 16 : if (err < 0)
3195 : goto out;
3196 :
3197 : /* This relies on module_mutex for list integrity. */
3198 : module_bug_finalize(info->hdr, info->sechdrs, mod);
3199 :
3200 : /* Set RO and NX regions for core */
3201 : set_section_ro_nx(mod->module_core,
3202 : mod->core_text_size,
3203 : mod->core_ro_size,
3204 : mod->core_size);
3205 :
3206 : /* Set RO and NX regions for init */
3207 : set_section_ro_nx(mod->module_init,
3208 : mod->init_text_size,
3209 : mod->init_ro_size,
3210 : mod->init_size);
3211 :
3212 : /* Mark state as coming so strong_try_module_get() ignores us,
3213 : * but kallsyms etc. can see us. */
3214 16 : mod->state = MODULE_STATE_COMING;
3215 16 : mutex_unlock(&module_mutex);
3216 :
3217 16 : blocking_notifier_call_chain(&module_notify_list,
3218 : MODULE_STATE_COMING, mod);
3219 : return 0;
3220 :
3221 : out:
3222 0 : mutex_unlock(&module_mutex);
3223 : return err;
3224 : }
3225 :
3226 0 : static int unknown_module_param_cb(char *param, char *val, const char *modname)
3227 : {
3228 : /* Check for magic 'dyndbg' arg */
3229 : int ret = ddebug_dyndbg_module_param_cb(param, val, modname);
3230 0 : if (ret != 0)
3231 0 : pr_warn("%s: unknown parameter '%s' ignored\n", modname, param);
3232 0 : return 0;
3233 : }
3234 :
3235 : /* Allocate and load the module: note that size of section 0 is always
3236 : zero, and we rely on this for optional sections. */
3237 70 : static int load_module(struct load_info *info, const char __user *uargs,
3238 : int flags)
3239 : {
3240 : struct module *mod;
3241 : long err;
3242 : char *after_dashes;
3243 :
3244 : err = module_sig_check(info);
3245 : if (err)
3246 : goto free_copy;
3247 :
3248 27 : err = elf_header_check(info);
3249 27 : if (err)
3250 : goto free_copy;
3251 :
3252 : /* Figure out module layout, and allocate all the memory. */
3253 27 : mod = layout_and_allocate(info, flags);
3254 27 : if (IS_ERR(mod)) {
3255 : err = PTR_ERR(mod);
3256 0 : goto free_copy;
3257 : }
3258 :
3259 : /* Reserve our place in the list. */
3260 27 : err = add_unformed_module(mod);
3261 27 : if (err)
3262 : goto free_module;
3263 :
3264 : #ifdef CONFIG_MODULE_SIG
3265 : mod->sig_ok = info->sig_ok;
3266 : if (!mod->sig_ok) {
3267 : pr_notice_once("%s: module verification failed: signature "
3268 : "and/or required key missing - tainting "
3269 : "kernel\n", mod->name);
3270 : add_taint_module(mod, TAINT_UNSIGNED_MODULE, LOCKDEP_STILL_OK);
3271 : }
3272 : #endif
3273 :
3274 : /* To avoid stressing percpu allocator, do this once we're unique. */
3275 : err = percpu_modalloc(mod, info);
3276 16 : if (err)
3277 : goto unlink_mod;
3278 :
3279 : /* Now module is in final location, initialize linked lists, etc. */
3280 : err = module_unload_init(mod);
3281 : if (err)
3282 : goto unlink_mod;
3283 :
3284 : /* Now we've got everything in the final locations, we can
3285 : * find optional sections. */
3286 16 : err = find_module_sections(mod, info);
3287 16 : if (err)
3288 : goto free_unload;
3289 :
3290 16 : err = check_module_license_and_versions(mod);
3291 16 : if (err)
3292 : goto free_unload;
3293 :
3294 : /* Set up MODINFO_ATTR fields */
3295 16 : setup_modinfo(mod, info);
3296 :
3297 : /* Fix up syms, so that st_value is a pointer to location. */
3298 16 : err = simplify_symbols(mod, info);
3299 16 : if (err < 0)
3300 : goto free_modinfo;
3301 :
3302 16 : err = apply_relocations(mod, info);
3303 16 : if (err < 0)
3304 : goto free_modinfo;
3305 :
3306 16 : err = post_relocation(mod, info);
3307 16 : if (err < 0)
3308 : goto free_modinfo;
3309 :
3310 16 : flush_module_icache(mod);
3311 :
3312 : /* Now copy in args */
3313 16 : mod->args = strndup_user(uargs, ~0UL >> 1);
3314 16 : if (IS_ERR(mod->args)) {
3315 : err = PTR_ERR(mod->args);
3316 0 : goto free_arch_cleanup;
3317 : }
3318 :
3319 : dynamic_debug_setup(info->debug, info->num_debug);
3320 :
3321 : /* Ftrace init must be called in the MODULE_STATE_UNFORMED state */
3322 : ftrace_module_init(mod);
3323 :
3324 : /* Finally it's fully formed, ready to start executing. */
3325 16 : err = complete_formation(mod, info);
3326 16 : if (err)
3327 : goto ddebug_cleanup;
3328 :
3329 : /* Module is ready to execute: parsing args may do that. */
3330 16 : after_dashes = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,
3331 : -32768, 32767, unknown_module_param_cb);
3332 16 : if (IS_ERR(after_dashes)) {
3333 : err = PTR_ERR(after_dashes);
3334 0 : goto bug_cleanup;
3335 16 : } else if (after_dashes) {
3336 0 : pr_warn("%s: parameters '%s' after `--' ignored\n",
3337 : mod->name, after_dashes);
3338 : }
3339 :
3340 : /* Link in to syfs. */
3341 16 : err = mod_sysfs_setup(mod, info, mod->kp, mod->num_kp);
3342 16 : if (err < 0)
3343 : goto bug_cleanup;
3344 :
3345 : /* Get rid of temporary copy. */
3346 : free_copy(info);
3347 :
3348 : /* Done! */
3349 : trace_module_load(mod);
3350 :
3351 16 : return do_init_module(mod);
3352 :
3353 : bug_cleanup:
3354 : /* module_bug_cleanup needs module_mutex protection */
3355 0 : mutex_lock(&module_mutex);
3356 : module_bug_cleanup(mod);
3357 0 : mutex_unlock(&module_mutex);
3358 :
3359 : /* we can't deallocate the module until we clear memory protection */
3360 : unset_module_init_ro_nx(mod);
3361 : unset_module_core_ro_nx(mod);
3362 :
3363 : ddebug_cleanup:
3364 : dynamic_debug_remove(info->debug);
3365 0 : synchronize_sched();
3366 0 : kfree(mod->args);
3367 : free_arch_cleanup:
3368 0 : module_arch_cleanup(mod);
3369 : free_modinfo:
3370 : free_modinfo(mod);
3371 : free_unload:
3372 0 : module_unload_free(mod);
3373 : unlink_mod:
3374 0 : mutex_lock(&module_mutex);
3375 : /* Unlink carefully: kallsyms could be walking list. */
3376 : list_del_rcu(&mod->list);
3377 0 : wake_up_all(&module_wq);
3378 : /* Wait for RCU synchronizing before releasing mod->list. */
3379 0 : synchronize_rcu();
3380 0 : mutex_unlock(&module_mutex);
3381 : free_module:
3382 11 : module_deallocate(mod, info);
3383 : free_copy:
3384 : free_copy(info);
3385 11 : return err;
3386 : }
3387 :
3388 54 : SYSCALL_DEFINE3(init_module, void __user *, umod,
3389 : unsigned long, len, const char __user *, uargs)
3390 : {
3391 : int err;
3392 27 : struct load_info info = { };
3393 :
3394 27 : err = may_init_module();
3395 27 : if (err)
3396 : return err;
3397 :
3398 : pr_debug("init_module: umod=%p, len=%lu, uargs=%p\n",
3399 : umod, len, uargs);
3400 :
3401 27 : err = copy_module_from_user(umod, len, &info);
3402 27 : if (err)
3403 : return err;
3404 :
3405 27 : return load_module(&info, uargs, 0);
3406 : }
3407 :
3408 0 : SYSCALL_DEFINE3(finit_module, int, fd, const char __user *, uargs, int, flags)
3409 : {
3410 : int err;
3411 0 : struct load_info info = { };
3412 :
3413 0 : err = may_init_module();
3414 0 : if (err)
3415 : return err;
3416 :
3417 : pr_debug("finit_module: fd=%d, uargs=%p, flags=%i\n", fd, uargs, flags);
3418 :
3419 0 : if (flags & ~(MODULE_INIT_IGNORE_MODVERSIONS
3420 : |MODULE_INIT_IGNORE_VERMAGIC))
3421 : return -EINVAL;
3422 :
3423 0 : err = copy_module_from_fd(fd, &info);
3424 0 : if (err)
3425 : return err;
3426 :
3427 0 : return load_module(&info, uargs, flags);
3428 : }
3429 :
3430 : static inline int within(unsigned long addr, void *start, unsigned long size)
3431 : {
3432 0 : return ((void *)addr >= start && (void *)addr < start + size);
3433 : }
3434 :
3435 : #ifdef CONFIG_KALLSYMS
3436 : /*
3437 : * This ignores the intensely annoying "mapping symbols" found
3438 : * in ARM ELF files: $a, $t and $d.
3439 : */
3440 : static inline int is_arm_mapping_symbol(const char *str)
3441 : {
3442 : if (str[0] == '.' && str[1] == 'L')
3443 : return true;
3444 : return str[0] == '$' && strchr("axtd", str[1])
3445 : && (str[2] == '\0' || str[2] == '.');
3446 : }
3447 :
3448 : static const char *get_ksymbol(struct module *mod,
3449 : unsigned long addr,
3450 : unsigned long *size,
3451 : unsigned long *offset)
3452 : {
3453 : unsigned int i, best = 0;
3454 : unsigned long nextval;
3455 :
3456 : /* At worse, next value is at end of module */
3457 : if (within_module_init(addr, mod))
3458 : nextval = (unsigned long)mod->module_init+mod->init_text_size;
3459 : else
3460 : nextval = (unsigned long)mod->module_core+mod->core_text_size;
3461 :
3462 : /* Scan for closest preceding symbol, and next symbol. (ELF
3463 : starts real symbols at 1). */
3464 : for (i = 1; i < mod->num_symtab; i++) {
3465 : if (mod->symtab[i].st_shndx == SHN_UNDEF)
3466 : continue;
3467 :
3468 : /* We ignore unnamed symbols: they're uninformative
3469 : * and inserted at a whim. */
3470 : if (mod->symtab[i].st_value <= addr
3471 : && mod->symtab[i].st_value > mod->symtab[best].st_value
3472 : && *(mod->strtab + mod->symtab[i].st_name) != '\0'
3473 : && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
3474 : best = i;
3475 : if (mod->symtab[i].st_value > addr
3476 : && mod->symtab[i].st_value < nextval
3477 : && *(mod->strtab + mod->symtab[i].st_name) != '\0'
3478 : && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
3479 : nextval = mod->symtab[i].st_value;
3480 : }
3481 :
3482 : if (!best)
3483 : return NULL;
3484 :
3485 : if (size)
3486 : *size = nextval - mod->symtab[best].st_value;
3487 : if (offset)
3488 : *offset = addr - mod->symtab[best].st_value;
3489 : return mod->strtab + mod->symtab[best].st_name;
3490 : }
3491 :
3492 : /* For kallsyms to ask for address resolution. NULL means not found. Careful
3493 : * not to lock to avoid deadlock on oopses, simply disable preemption. */
3494 : const char *module_address_lookup(unsigned long addr,
3495 : unsigned long *size,
3496 : unsigned long *offset,
3497 : char **modname,
3498 : char *namebuf)
3499 : {
3500 : struct module *mod;
3501 : const char *ret = NULL;
3502 :
3503 : preempt_disable();
3504 : list_for_each_entry_rcu(mod, &modules, list) {
3505 : if (mod->state == MODULE_STATE_UNFORMED)
3506 : continue;
3507 : if (within_module(addr, mod)) {
3508 : if (modname)
3509 : *modname = mod->name;
3510 : ret = get_ksymbol(mod, addr, size, offset);
3511 : break;
3512 : }
3513 : }
3514 : /* Make a copy in here where it's safe */
3515 : if (ret) {
3516 : strncpy(namebuf, ret, KSYM_NAME_LEN - 1);
3517 : ret = namebuf;
3518 : }
3519 : preempt_enable();
3520 : return ret;
3521 : }
3522 :
3523 : int lookup_module_symbol_name(unsigned long addr, char *symname)
3524 : {
3525 : struct module *mod;
3526 :
3527 : preempt_disable();
3528 : list_for_each_entry_rcu(mod, &modules, list) {
3529 : if (mod->state == MODULE_STATE_UNFORMED)
3530 : continue;
3531 : if (within_module(addr, mod)) {
3532 : const char *sym;
3533 :
3534 : sym = get_ksymbol(mod, addr, NULL, NULL);
3535 : if (!sym)
3536 : goto out;
3537 : strlcpy(symname, sym, KSYM_NAME_LEN);
3538 : preempt_enable();
3539 : return 0;
3540 : }
3541 : }
3542 : out:
3543 : preempt_enable();
3544 : return -ERANGE;
3545 : }
3546 :
3547 : int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,
3548 : unsigned long *offset, char *modname, char *name)
3549 : {
3550 : struct module *mod;
3551 :
3552 : preempt_disable();
3553 : list_for_each_entry_rcu(mod, &modules, list) {
3554 : if (mod->state == MODULE_STATE_UNFORMED)
3555 : continue;
3556 : if (within_module(addr, mod)) {
3557 : const char *sym;
3558 :
3559 : sym = get_ksymbol(mod, addr, size, offset);
3560 : if (!sym)
3561 : goto out;
3562 : if (modname)
3563 : strlcpy(modname, mod->name, MODULE_NAME_LEN);
3564 : if (name)
3565 : strlcpy(name, sym, KSYM_NAME_LEN);
3566 : preempt_enable();
3567 : return 0;
3568 : }
3569 : }
3570 : out:
3571 : preempt_enable();
3572 : return -ERANGE;
3573 : }
3574 :
3575 : int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
3576 : char *name, char *module_name, int *exported)
3577 : {
3578 : struct module *mod;
3579 :
3580 : preempt_disable();
3581 : list_for_each_entry_rcu(mod, &modules, list) {
3582 : if (mod->state == MODULE_STATE_UNFORMED)
3583 : continue;
3584 : if (symnum < mod->num_symtab) {
3585 : *value = mod->symtab[symnum].st_value;
3586 : *type = mod->symtab[symnum].st_info;
3587 : strlcpy(name, mod->strtab + mod->symtab[symnum].st_name,
3588 : KSYM_NAME_LEN);
3589 : strlcpy(module_name, mod->name, MODULE_NAME_LEN);
3590 : *exported = is_exported(name, *value, mod);
3591 : preempt_enable();
3592 : return 0;
3593 : }
3594 : symnum -= mod->num_symtab;
3595 : }
3596 : preempt_enable();
3597 : return -ERANGE;
3598 : }
3599 :
3600 : static unsigned long mod_find_symname(struct module *mod, const char *name)
3601 : {
3602 : unsigned int i;
3603 :
3604 : for (i = 0; i < mod->num_symtab; i++)
3605 : if (strcmp(name, mod->strtab+mod->symtab[i].st_name) == 0 &&
3606 : mod->symtab[i].st_info != 'U')
3607 : return mod->symtab[i].st_value;
3608 : return 0;
3609 : }
3610 :
3611 : /* Look for this name: can be of form module:name. */
3612 : unsigned long module_kallsyms_lookup_name(const char *name)
3613 : {
3614 : struct module *mod;
3615 : char *colon;
3616 : unsigned long ret = 0;
3617 :
3618 : /* Don't lock: we're in enough trouble already. */
3619 : preempt_disable();
3620 : if ((colon = strchr(name, ':')) != NULL) {
3621 : if ((mod = find_module_all(name, colon - name, false)) != NULL)
3622 : ret = mod_find_symname(mod, colon+1);
3623 : } else {
3624 : list_for_each_entry_rcu(mod, &modules, list) {
3625 : if (mod->state == MODULE_STATE_UNFORMED)
3626 : continue;
3627 : if ((ret = mod_find_symname(mod, name)) != 0)
3628 : break;
3629 : }
3630 : }
3631 : preempt_enable();
3632 : return ret;
3633 : }
3634 :
3635 : int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
3636 : struct module *, unsigned long),
3637 : void *data)
3638 : {
3639 : struct module *mod;
3640 : unsigned int i;
3641 : int ret;
3642 :
3643 : list_for_each_entry(mod, &modules, list) {
3644 : if (mod->state == MODULE_STATE_UNFORMED)
3645 : continue;
3646 : for (i = 0; i < mod->num_symtab; i++) {
3647 : ret = fn(data, mod->strtab + mod->symtab[i].st_name,
3648 : mod, mod->symtab[i].st_value);
3649 : if (ret != 0)
3650 : return ret;
3651 : }
3652 : }
3653 : return 0;
3654 : }
3655 : #endif /* CONFIG_KALLSYMS */
3656 :
3657 0 : static char *module_flags(struct module *mod, char *buf)
3658 : {
3659 : int bx = 0;
3660 :
3661 : BUG_ON(mod->state == MODULE_STATE_UNFORMED);
3662 0 : if (mod->taints ||
3663 0 : mod->state == MODULE_STATE_GOING ||
3664 : mod->state == MODULE_STATE_COMING) {
3665 0 : buf[bx++] = '(';
3666 0 : bx += module_flags_taint(mod, buf + bx);
3667 : /* Show a - for module-is-being-unloaded */
3668 0 : if (mod->state == MODULE_STATE_GOING)
3669 0 : buf[bx++] = '-';
3670 : /* Show a + for module-is-being-loaded */
3671 0 : if (mod->state == MODULE_STATE_COMING)
3672 0 : buf[bx++] = '+';
3673 0 : buf[bx++] = ')';
3674 : }
3675 0 : buf[bx] = '\0';
3676 :
3677 0 : return buf;
3678 : }
3679 :
3680 : #ifdef CONFIG_PROC_FS
3681 : /* Called by the /proc file system to return a list of modules. */
3682 0 : static void *m_start(struct seq_file *m, loff_t *pos)
3683 : {
3684 0 : mutex_lock(&module_mutex);
3685 0 : return seq_list_start(&modules, *pos);
3686 : }
3687 :
3688 0 : static void *m_next(struct seq_file *m, void *p, loff_t *pos)
3689 : {
3690 0 : return seq_list_next(p, &modules, pos);
3691 : }
3692 :
3693 0 : static void m_stop(struct seq_file *m, void *p)
3694 : {
3695 0 : mutex_unlock(&module_mutex);
3696 0 : }
3697 :
3698 0 : static int m_show(struct seq_file *m, void *p)
3699 : {
3700 0 : struct module *mod = list_entry(p, struct module, list);
3701 : char buf[8];
3702 :
3703 : /* We always ignore unformed modules. */
3704 0 : if (mod->state == MODULE_STATE_UNFORMED)
3705 : return 0;
3706 :
3707 0 : seq_printf(m, "%s %u",
3708 0 : mod->name, mod->init_size + mod->core_size);
3709 : print_unload_info(m, mod);
3710 :
3711 : /* Informative for users. */
3712 0 : seq_printf(m, " %s",
3713 0 : mod->state == MODULE_STATE_GOING ? "Unloading" :
3714 0 : mod->state == MODULE_STATE_COMING ? "Loading" :
3715 : "Live");
3716 : /* Used by oprofile and other similar tools. */
3717 0 : seq_printf(m, " 0x%pK", mod->module_core);
3718 :
3719 : /* Taints info */
3720 0 : if (mod->taints)
3721 0 : seq_printf(m, " %s", module_flags(mod, buf));
3722 :
3723 0 : seq_puts(m, "\n");
3724 0 : return 0;
3725 : }
3726 :
3727 : /* Format: modulename size refcount deps address
3728 :
3729 : Where refcount is a number or -, and deps is a comma-separated list
3730 : of depends or -.
3731 : */
3732 : static const struct seq_operations modules_op = {
3733 : .start = m_start,
3734 : .next = m_next,
3735 : .stop = m_stop,
3736 : .show = m_show
3737 : };
3738 :
3739 0 : static int modules_open(struct inode *inode, struct file *file)
3740 : {
3741 0 : return seq_open(file, &modules_op);
3742 : }
3743 :
3744 : static const struct file_operations proc_modules_operations = {
3745 : .open = modules_open,
3746 : .read = seq_read,
3747 : .llseek = seq_lseek,
3748 : .release = seq_release,
3749 : };
3750 :
3751 1 : static int __init proc_modules_init(void)
3752 : {
3753 : proc_create("modules", 0, NULL, &proc_modules_operations);
3754 1 : return 0;
3755 : }
3756 : module_init(proc_modules_init);
3757 : #endif
3758 :
3759 : /* Given an address, look for it in the module exception tables. */
3760 0 : const struct exception_table_entry *search_module_extables(unsigned long addr)
3761 : {
3762 : const struct exception_table_entry *e = NULL;
3763 : struct module *mod;
3764 :
3765 0 : preempt_disable();
3766 0 : list_for_each_entry_rcu(mod, &modules, list) {
3767 0 : if (mod->state == MODULE_STATE_UNFORMED)
3768 0 : continue;
3769 0 : if (mod->num_exentries == 0)
3770 0 : continue;
3771 :
3772 0 : e = search_extable(mod->extable,
3773 0 : mod->extable + mod->num_exentries - 1,
3774 : addr);
3775 0 : if (e)
3776 : break;
3777 : }
3778 0 : preempt_enable();
3779 :
3780 : /* Now, if we found one, we are running inside it now, hence
3781 : we cannot unload the module, hence no refcnt needed. */
3782 0 : return e;
3783 : }
3784 :
3785 : /*
3786 : * is_module_address - is this address inside a module?
3787 : * @addr: the address to check.
3788 : *
3789 : * See is_module_text_address() if you simply want to see if the address
3790 : * is code (not data).
3791 : */
3792 0 : bool is_module_address(unsigned long addr)
3793 : {
3794 : bool ret;
3795 :
3796 0 : preempt_disable();
3797 0 : ret = __module_address(addr) != NULL;
3798 0 : preempt_enable();
3799 :
3800 0 : return ret;
3801 : }
3802 :
3803 : /*
3804 : * __module_address - get the module which contains an address.
3805 : * @addr: the address.
3806 : *
3807 : * Must be called with preempt disabled or module mutex held so that
3808 : * module doesn't get freed during this.
3809 : */
3810 5 : struct module *__module_address(unsigned long addr)
3811 : {
3812 : struct module *mod;
3813 :
3814 5 : if (addr < module_addr_min || addr > module_addr_max)
3815 : return NULL;
3816 :
3817 0 : list_for_each_entry_rcu(mod, &modules, list) {
3818 0 : if (mod->state == MODULE_STATE_UNFORMED)
3819 0 : continue;
3820 0 : if (within_module(addr, mod))
3821 : return mod;
3822 : }
3823 : return NULL;
3824 : }
3825 : EXPORT_SYMBOL_GPL(__module_address);
3826 :
3827 : /*
3828 : * is_module_text_address - is this address inside module code?
3829 : * @addr: the address to check.
3830 : *
3831 : * See is_module_address() if you simply want to see if the address is
3832 : * anywhere in a module. See kernel_text_address() for testing if an
3833 : * address corresponds to kernel or module code.
3834 : */
3835 0 : bool is_module_text_address(unsigned long addr)
3836 : {
3837 : bool ret;
3838 :
3839 0 : preempt_disable();
3840 0 : ret = __module_text_address(addr) != NULL;
3841 0 : preempt_enable();
3842 :
3843 0 : return ret;
3844 : }
3845 :
3846 : /*
3847 : * __module_text_address - get the module whose code contains an address.
3848 : * @addr: the address.
3849 : *
3850 : * Must be called with preempt disabled or module mutex held so that
3851 : * module doesn't get freed during this.
3852 : */
3853 0 : struct module *__module_text_address(unsigned long addr)
3854 : {
3855 0 : struct module *mod = __module_address(addr);
3856 0 : if (mod) {
3857 : /* Make sure it's within the text section. */
3858 0 : if (!within(addr, mod->module_init, mod->init_text_size)
3859 0 : && !within(addr, mod->module_core, mod->core_text_size))
3860 : mod = NULL;
3861 : }
3862 0 : return mod;
3863 : }
3864 : EXPORT_SYMBOL_GPL(__module_text_address);
3865 :
3866 : /* Don't grab lock, we're oopsing. */
3867 0 : void print_modules(void)
3868 : {
3869 : struct module *mod;
3870 : char buf[8];
3871 :
3872 0 : printk(KERN_DEFAULT "Modules linked in:");
3873 : /* Most callers should already have preempt disabled, but make sure */
3874 0 : preempt_disable();
3875 0 : list_for_each_entry_rcu(mod, &modules, list) {
3876 0 : if (mod->state == MODULE_STATE_UNFORMED)
3877 0 : continue;
3878 0 : pr_cont(" %s%s", mod->name, module_flags(mod, buf));
3879 : }
3880 0 : preempt_enable();
3881 0 : if (last_unloaded_module[0])
3882 0 : pr_cont(" [last unloaded: %s]", last_unloaded_module);
3883 0 : pr_cont("\n");
3884 0 : }
3885 :
3886 : #ifdef CONFIG_MODVERSIONS
3887 : /* Generate the signature for all relevant module structures here.
3888 : * If these change, we don't want to try to parse the module. */
3889 0 : void module_layout(struct module *mod,
3890 : struct modversion_info *ver,
3891 : struct kernel_param *kp,
3892 : struct kernel_symbol *ks,
3893 : struct tracepoint * const *tp)
3894 : {
3895 0 : }
3896 : EXPORT_SYMBOL(module_layout);
3897 : #endif
|
