blob: b10b048367e14b0e89f6b7bfc5e740afd666516b [file] [log] [blame]
Arjan van de Venf71d20e2006-06-28 04:26:45 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 Copyright (C) 2002 Richard Henderson
Rusty Russell51f3d0f2010-08-05 12:59:13 -06003 Copyright (C) 2001 Rusty Russell, 2002, 2010 Rusty Russell IBM.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004
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*/
Paul Gortmaker9984de12011-05-23 14:51:41 -040019#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/moduleloader.h>
Steven Rostedt6d723732009-04-10 14:53:50 -040021#include <linux/ftrace_event.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/init.h>
Alexey Dobriyanae84e322007-05-08 00:28:38 -070023#include <linux/kallsyms.h>
Kees Cook34e11692012-10-16 07:31:07 +103024#include <linux/file.h>
Alexey Dobriyan3b5d5c62008-10-06 13:19:27 +040025#include <linux/fs.h>
Roland McGrath6d760132007-10-16 23:26:40 -070026#include <linux/sysfs.h>
Randy Dunlap9f158332005-09-13 01:25:16 -070027#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/slab.h>
29#include <linux/vmalloc.h>
30#include <linux/elf.h>
Alexey Dobriyan3b5d5c62008-10-06 13:19:27 +040031#include <linux/proc_fs.h>
Kees Cook2e72d512012-10-16 07:32:07 +103032#include <linux/security.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/seq_file.h>
34#include <linux/syscalls.h>
35#include <linux/fcntl.h>
36#include <linux/rcupdate.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080037#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#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>
Al Virof6a57032006-10-18 01:47:25 -040044#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/stop_machine.h>
46#include <linux/device.h>
Matt Domschc988d2b2005-06-23 22:05:15 -070047#include <linux/string.h>
Arjan van de Ven97d1f152006-03-23 03:00:24 -080048#include <linux/mutex.h>
Andi Kleend72b3752008-08-30 10:09:00 +020049#include <linux/rculist.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include <asm/cacheflush.h>
Bernd Schmidteb8cdec2009-09-21 17:03:57 -070052#include <asm/mmu_context.h>
Sam Ravnborgb817f6f2006-06-09 21:53:55 +020053#include <linux/license.h>
Christoph Lameter6d762392008-02-08 04:18:42 -080054#include <asm/sections.h>
Mathieu Desnoyers97e1c182008-07-18 12:16:16 -040055#include <linux/tracepoint.h>
Steven Rostedt90d595f2008-08-14 15:45:09 -040056#include <linux/ftrace.h>
Arjan van de Ven22a9d642009-01-07 08:45:46 -080057#include <linux/async.h>
Tejun Heofbf59bc2009-02-20 16:29:08 +090058#include <linux/percpu.h>
Catalin Marinas4f2294b2009-06-11 13:23:20 +010059#include <linux/kmemleak.h>
Jason Baronbf5438fc2010-09-17 11:09:00 -040060#include <linux/jump_label.h>
matthieu castet84e1c6b2010-11-16 22:35:16 +010061#include <linux/pfn.h>
Alessio Igor Bogani403ed272011-04-20 11:10:52 +020062#include <linux/bsearch.h>
David Howells1d0059f2012-09-26 10:09:50 +010063#include <linux/fips.h>
Rusty Russell2f3238a2012-10-22 18:09:41 +103064#include <uapi/linux/module.h>
Rusty Russell106a4ee2012-09-26 10:09:40 +010065#include "module-internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Li Zefan7ead8b82009-08-17 16:56:28 +080067#define CREATE_TRACE_POINTS
68#include <trace/events/module.h>
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#ifndef ARCH_SHF_SMALL
71#define ARCH_SHF_SMALL 0
72#endif
73
matthieu castet84e1c6b2010-11-16 22:35:16 +010074/*
75 * Modules' sections will be aligned on page boundaries
76 * to ensure complete separation of code and data, but
77 * only when CONFIG_DEBUG_SET_MODULE_RONX=y
78 */
79#ifdef CONFIG_DEBUG_SET_MODULE_RONX
80# define debug_align(X) ALIGN(X, PAGE_SIZE)
81#else
82# define debug_align(X) (X)
83#endif
84
85/*
86 * Given BASE and SIZE this macro calculates the number of pages the
87 * memory regions occupies
88 */
89#define MOD_NUMBER_OF_PAGES(BASE, SIZE) (((SIZE) > 0) ? \
90 (PFN_DOWN((unsigned long)(BASE) + (SIZE) - 1) - \
91 PFN_DOWN((unsigned long)BASE) + 1) \
92 : (0UL))
93
Linus Torvalds1da177e2005-04-16 15:20:36 -070094/* If this is set, the section belongs in the init part of the module */
95#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))
96
Rusty Russell75676502010-06-05 11:17:36 -060097/*
98 * Mutex protects:
99 * 1) List of modules (also safely readable with preempt_disable),
100 * 2) module_use links,
101 * 3) module_addr_min/module_addr_max.
Andi Kleend72b3752008-08-30 10:09:00 +0200102 * (delete uses stop_machine/add uses RCU list operations). */
Tim Abbottc6b37802008-12-05 19:03:59 -0500103DEFINE_MUTEX(module_mutex);
104EXPORT_SYMBOL_GPL(module_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105static LIST_HEAD(modules);
Jason Wessel67fc4e02010-05-20 21:04:21 -0500106#ifdef CONFIG_KGDB_KDB
107struct list_head *kdb_modules = &modules; /* kdb needs the list of modules */
108#endif /* CONFIG_KGDB_KDB */
109
Rusty Russell106a4ee2012-09-26 10:09:40 +0100110#ifdef CONFIG_MODULE_SIG
111#ifdef CONFIG_MODULE_SIG_FORCE
112static bool sig_enforce = true;
113#else
114static bool sig_enforce = false;
115
116static int param_set_bool_enable_only(const char *val,
117 const struct kernel_param *kp)
118{
119 int err;
120 bool test;
121 struct kernel_param dummy_kp = *kp;
122
123 dummy_kp.arg = &test;
124
125 err = param_set_bool(val, &dummy_kp);
126 if (err)
127 return err;
128
129 /* Don't let them unset it once it's set! */
130 if (!test && sig_enforce)
131 return -EROFS;
132
133 if (test)
134 sig_enforce = true;
135 return 0;
136}
137
138static const struct kernel_param_ops param_ops_bool_enable_only = {
139 .set = param_set_bool_enable_only,
140 .get = param_get_bool,
141};
142#define param_check_bool_enable_only param_check_bool
143
144module_param(sig_enforce, bool_enable_only, 0644);
145#endif /* !CONFIG_MODULE_SIG_FORCE */
146#endif /* CONFIG_MODULE_SIG */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Stephen Rothwell19e45292009-04-14 17:27:18 +1000148/* Block module loading/unloading? */
149int modules_disabled = 0;
Dave Young02608be2012-02-01 10:33:14 +0800150core_param(nomodule, modules_disabled, bint, 0);
Stephen Rothwell19e45292009-04-14 17:27:18 +1000151
Rusty Russellc9a3ba52008-01-29 17:13:18 -0500152/* Waiting for a module to finish initializing? */
153static DECLARE_WAIT_QUEUE_HEAD(module_wq);
154
Alan Sterne041c682006-03-27 01:16:30 -0800155static BLOCKING_NOTIFIER_HEAD(module_notify_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
Rusty Russell75676502010-06-05 11:17:36 -0600157/* Bounds of module allocation, for speeding __module_address.
158 * Protected by module_mutex. */
Rusty Russell3a642e92008-07-22 19:24:28 -0500159static unsigned long module_addr_min = -1UL, module_addr_max = 0;
160
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161int register_module_notifier(struct notifier_block * nb)
162{
Alan Sterne041c682006-03-27 01:16:30 -0800163 return blocking_notifier_chain_register(&module_notify_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164}
165EXPORT_SYMBOL(register_module_notifier);
166
167int unregister_module_notifier(struct notifier_block * nb)
168{
Alan Sterne041c682006-03-27 01:16:30 -0800169 return blocking_notifier_chain_unregister(&module_notify_list, nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170}
171EXPORT_SYMBOL(unregister_module_notifier);
172
Rusty Russelleded41c2010-08-05 12:59:07 -0600173struct load_info {
174 Elf_Ehdr *hdr;
175 unsigned long len;
176 Elf_Shdr *sechdrs;
Rusty Russell6526c532010-08-05 12:59:10 -0600177 char *secstrings, *strtab;
Rusty Russelld9131882010-08-05 12:59:08 -0600178 unsigned long symoffs, stroffs;
Rusty Russell811d66a2010-08-05 12:59:12 -0600179 struct _ddebug *debug;
180 unsigned int num_debug;
Rusty Russell106a4ee2012-09-26 10:09:40 +0100181 bool sig_ok;
Rusty Russelleded41c2010-08-05 12:59:07 -0600182 struct {
183 unsigned int sym, str, mod, vers, info, pcpu;
184 } index;
185};
186
Matti Linnanvuori9a4b9702007-11-08 08:37:38 -0800187/* We require a truly strong try_module_get(): 0 means failure due to
188 ongoing or failed initialization etc. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189static inline int strong_try_module_get(struct module *mod)
190{
191 if (mod && mod->state == MODULE_STATE_COMING)
Rusty Russellc9a3ba52008-01-29 17:13:18 -0500192 return -EBUSY;
193 if (try_module_get(mod))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 return 0;
Rusty Russellc9a3ba52008-01-29 17:13:18 -0500195 else
196 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197}
198
Florin Malitafa3ba2e82006-10-11 01:21:48 -0700199static inline void add_taint_module(struct module *mod, unsigned flag)
200{
201 add_taint(flag);
Andi Kleen25ddbb12008-10-15 22:01:41 -0700202 mod->taints |= (1U << flag);
Florin Malitafa3ba2e82006-10-11 01:21:48 -0700203}
204
Robert P. J. Day02a3e592007-05-09 07:26:28 +0200205/*
206 * A thread that wants to hold a reference to a module only while it
207 * is running can call this to safely exit. nfsd and lockd use this.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 */
209void __module_put_and_exit(struct module *mod, long code)
210{
211 module_put(mod);
212 do_exit(code);
213}
214EXPORT_SYMBOL(__module_put_and_exit);
Daniel Walker22a8bde2007-10-18 03:06:07 -0700215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216/* Find a module section: 0 means not found. */
Rusty Russell49668682010-08-05 12:59:10 -0600217static unsigned int find_sec(const struct load_info *info, const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218{
219 unsigned int i;
220
Rusty Russell49668682010-08-05 12:59:10 -0600221 for (i = 1; i < info->hdr->e_shnum; i++) {
222 Elf_Shdr *shdr = &info->sechdrs[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 /* Alloc bit cleared means "ignore it." */
Rusty Russell49668682010-08-05 12:59:10 -0600224 if ((shdr->sh_flags & SHF_ALLOC)
225 && strcmp(info->secstrings + shdr->sh_name, name) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 return i;
Rusty Russell49668682010-08-05 12:59:10 -0600227 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 return 0;
229}
230
Rusty Russell5e458cc2008-10-22 10:00:13 -0500231/* Find a module section, or NULL. */
Rusty Russell49668682010-08-05 12:59:10 -0600232static void *section_addr(const struct load_info *info, const char *name)
Rusty Russell5e458cc2008-10-22 10:00:13 -0500233{
234 /* Section 0 has sh_addr 0. */
Rusty Russell49668682010-08-05 12:59:10 -0600235 return (void *)info->sechdrs[find_sec(info, name)].sh_addr;
Rusty Russell5e458cc2008-10-22 10:00:13 -0500236}
237
238/* Find a module section, or NULL. Fill in number of "objects" in section. */
Rusty Russell49668682010-08-05 12:59:10 -0600239static void *section_objs(const struct load_info *info,
Rusty Russell5e458cc2008-10-22 10:00:13 -0500240 const char *name,
241 size_t object_size,
242 unsigned int *num)
243{
Rusty Russell49668682010-08-05 12:59:10 -0600244 unsigned int sec = find_sec(info, name);
Rusty Russell5e458cc2008-10-22 10:00:13 -0500245
246 /* Section 0 has sh_addr 0 and sh_size 0. */
Rusty Russell49668682010-08-05 12:59:10 -0600247 *num = info->sechdrs[sec].sh_size / object_size;
248 return (void *)info->sechdrs[sec].sh_addr;
Rusty Russell5e458cc2008-10-22 10:00:13 -0500249}
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251/* Provided by the linker */
252extern const struct kernel_symbol __start___ksymtab[];
253extern const struct kernel_symbol __stop___ksymtab[];
254extern const struct kernel_symbol __start___ksymtab_gpl[];
255extern const struct kernel_symbol __stop___ksymtab_gpl[];
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800256extern const struct kernel_symbol __start___ksymtab_gpl_future[];
257extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258extern const unsigned long __start___kcrctab[];
259extern const unsigned long __start___kcrctab_gpl[];
Greg Kroah-Hartman9f28bb72006-03-20 13:17:13 -0800260extern const unsigned long __start___kcrctab_gpl_future[];
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500261#ifdef CONFIG_UNUSED_SYMBOLS
262extern const struct kernel_symbol __start___ksymtab_unused[];
263extern const struct kernel_symbol __stop___ksymtab_unused[];
264extern const struct kernel_symbol __start___ksymtab_unused_gpl[];
265extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700266extern const unsigned long __start___kcrctab_unused[];
267extern const unsigned long __start___kcrctab_unused_gpl[];
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500268#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270#ifndef CONFIG_MODVERSIONS
271#define symversion(base, idx) NULL
272#else
Andrew Mortonf83ca9f2006-03-28 01:56:20 -0800273#define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274#endif
275
Rusty Russelldafd0942008-07-22 19:24:25 -0500276static bool each_symbol_in_section(const struct symsearch *arr,
277 unsigned int arrsize,
278 struct module *owner,
279 bool (*fn)(const struct symsearch *syms,
280 struct module *owner,
Rusty Russellde4d8d52011-04-19 21:49:58 +0200281 void *data),
Rusty Russelldafd0942008-07-22 19:24:25 -0500282 void *data)
Sam Ravnborg3fd68052006-02-08 21:16:45 +0100283{
Rusty Russellde4d8d52011-04-19 21:49:58 +0200284 unsigned int j;
Rusty Russelldafd0942008-07-22 19:24:25 -0500285
286 for (j = 0; j < arrsize; j++) {
Rusty Russellde4d8d52011-04-19 21:49:58 +0200287 if (fn(&arr[j], owner, data))
288 return true;
Rusty Russelldafd0942008-07-22 19:24:25 -0500289 }
290
291 return false;
Sam Ravnborg3fd68052006-02-08 21:16:45 +0100292}
293
Rusty Russelldafd0942008-07-22 19:24:25 -0500294/* Returns true as soon as fn returns true, otherwise false. */
Rusty Russellde4d8d52011-04-19 21:49:58 +0200295bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
296 struct module *owner,
297 void *data),
298 void *data)
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700299{
Rusty Russelldafd0942008-07-22 19:24:25 -0500300 struct module *mod;
Linus Torvalds44032e62010-08-05 12:59:05 -0600301 static const struct symsearch arr[] = {
Rusty Russelldafd0942008-07-22 19:24:25 -0500302 { __start___ksymtab, __stop___ksymtab, __start___kcrctab,
303 NOT_GPL_ONLY, false },
304 { __start___ksymtab_gpl, __stop___ksymtab_gpl,
305 __start___kcrctab_gpl,
306 GPL_ONLY, false },
307 { __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,
308 __start___kcrctab_gpl_future,
309 WILL_BE_GPL_ONLY, false },
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500310#ifdef CONFIG_UNUSED_SYMBOLS
Rusty Russelldafd0942008-07-22 19:24:25 -0500311 { __start___ksymtab_unused, __stop___ksymtab_unused,
312 __start___kcrctab_unused,
313 NOT_GPL_ONLY, true },
314 { __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,
315 __start___kcrctab_unused_gpl,
316 GPL_ONLY, true },
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500317#endif
Rusty Russelldafd0942008-07-22 19:24:25 -0500318 };
319
320 if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
321 return true;
322
Andi Kleend72b3752008-08-30 10:09:00 +0200323 list_for_each_entry_rcu(mod, &modules, list) {
Rusty Russelldafd0942008-07-22 19:24:25 -0500324 struct symsearch arr[] = {
325 { mod->syms, mod->syms + mod->num_syms, mod->crcs,
326 NOT_GPL_ONLY, false },
327 { mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
328 mod->gpl_crcs,
329 GPL_ONLY, false },
330 { mod->gpl_future_syms,
331 mod->gpl_future_syms + mod->num_gpl_future_syms,
332 mod->gpl_future_crcs,
333 WILL_BE_GPL_ONLY, false },
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500334#ifdef CONFIG_UNUSED_SYMBOLS
Rusty Russelldafd0942008-07-22 19:24:25 -0500335 { mod->unused_syms,
336 mod->unused_syms + mod->num_unused_syms,
337 mod->unused_crcs,
338 NOT_GPL_ONLY, true },
339 { mod->unused_gpl_syms,
340 mod->unused_gpl_syms + mod->num_unused_gpl_syms,
341 mod->unused_gpl_crcs,
342 GPL_ONLY, true },
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500343#endif
Rusty Russelldafd0942008-07-22 19:24:25 -0500344 };
345
346 if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
347 return true;
348 }
349 return false;
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700350}
Rusty Russellde4d8d52011-04-19 21:49:58 +0200351EXPORT_SYMBOL_GPL(each_symbol_section);
Arjan van de Venf71d20e2006-06-28 04:26:45 -0700352
Rusty Russelldafd0942008-07-22 19:24:25 -0500353struct find_symbol_arg {
354 /* Input */
355 const char *name;
356 bool gplok;
357 bool warn;
358
359 /* Output */
360 struct module *owner;
361 const unsigned long *crc;
Tim Abbott414fd312008-12-05 19:03:56 -0500362 const struct kernel_symbol *sym;
Rusty Russelldafd0942008-07-22 19:24:25 -0500363};
364
Rusty Russellde4d8d52011-04-19 21:49:58 +0200365static bool check_symbol(const struct symsearch *syms,
366 struct module *owner,
367 unsigned int symnum, void *data)
Rusty Russellad9546c2008-05-01 21:14:59 -0500368{
Rusty Russelldafd0942008-07-22 19:24:25 -0500369 struct find_symbol_arg *fsa = data;
370
Rusty Russelldafd0942008-07-22 19:24:25 -0500371 if (!fsa->gplok) {
372 if (syms->licence == GPL_ONLY)
373 return false;
374 if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) {
375 printk(KERN_WARNING "Symbol %s is being used "
376 "by a non-GPL module, which will not "
377 "be allowed in the future\n", fsa->name);
Rusty Russelldafd0942008-07-22 19:24:25 -0500378 }
379 }
380
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500381#ifdef CONFIG_UNUSED_SYMBOLS
Rusty Russelldafd0942008-07-22 19:24:25 -0500382 if (syms->unused && fsa->warn) {
Rusty Russellad9546c2008-05-01 21:14:59 -0500383 printk(KERN_WARNING "Symbol %s is marked as UNUSED, "
Rusty Russelldafd0942008-07-22 19:24:25 -0500384 "however this module is using it.\n", fsa->name);
Rusty Russellad9546c2008-05-01 21:14:59 -0500385 printk(KERN_WARNING
386 "This symbol will go away in the future.\n");
387 printk(KERN_WARNING
388 "Please evalute if this is the right api to use and if "
389 "it really is, submit a report the linux kernel "
390 "mailinglist together with submitting your code for "
391 "inclusion.\n");
392 }
Denys Vlasenkof7f5b672008-07-22 19:24:26 -0500393#endif
Rusty Russelldafd0942008-07-22 19:24:25 -0500394
395 fsa->owner = owner;
396 fsa->crc = symversion(syms->crcs, symnum);
Tim Abbott414fd312008-12-05 19:03:56 -0500397 fsa->sym = &syms->start[symnum];
Rusty Russellad9546c2008-05-01 21:14:59 -0500398 return true;
399}
400
Alessio Igor Bogani403ed272011-04-20 11:10:52 +0200401static int cmp_name(const void *va, const void *vb)
402{
403 const char *a;
404 const struct kernel_symbol *b;
405 a = va; b = vb;
406 return strcmp(a, b->name);
407}
408
Rusty Russellde4d8d52011-04-19 21:49:58 +0200409static bool find_symbol_in_section(const struct symsearch *syms,
410 struct module *owner,
411 void *data)
412{
413 struct find_symbol_arg *fsa = data;
Alessio Igor Bogani403ed272011-04-20 11:10:52 +0200414 struct kernel_symbol *sym;
Rusty Russellde4d8d52011-04-19 21:49:58 +0200415
Alessio Igor Bogani403ed272011-04-20 11:10:52 +0200416 sym = bsearch(fsa->name, syms->start, syms->stop - syms->start,
417 sizeof(struct kernel_symbol), cmp_name);
418
419 if (sym != NULL && check_symbol(syms, owner, sym - syms->start, data))
420 return true;
421
Rusty Russellde4d8d52011-04-19 21:49:58 +0200422 return false;
423}
424
Tim Abbott414fd312008-12-05 19:03:56 -0500425/* Find a symbol and return it, along with, (optional) crc and
Rusty Russell75676502010-06-05 11:17:36 -0600426 * (optional) module which owns it. Needs preempt disabled or module_mutex. */
Tim Abbottc6b37802008-12-05 19:03:59 -0500427const struct kernel_symbol *find_symbol(const char *name,
428 struct module **owner,
429 const unsigned long **crc,
430 bool gplok,
431 bool warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432{
Rusty Russelldafd0942008-07-22 19:24:25 -0500433 struct find_symbol_arg fsa;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434
Rusty Russelldafd0942008-07-22 19:24:25 -0500435 fsa.name = name;
436 fsa.gplok = gplok;
437 fsa.warn = warn;
438
Rusty Russellde4d8d52011-04-19 21:49:58 +0200439 if (each_symbol_section(find_symbol_in_section, &fsa)) {
Rusty Russellad9546c2008-05-01 21:14:59 -0500440 if (owner)
Rusty Russelldafd0942008-07-22 19:24:25 -0500441 *owner = fsa.owner;
442 if (crc)
443 *crc = fsa.crc;
Tim Abbott414fd312008-12-05 19:03:56 -0500444 return fsa.sym;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 }
Rusty Russellad9546c2008-05-01 21:14:59 -0500446
Jim Cromie5e124162011-12-06 12:11:31 -0700447 pr_debug("Failed to find symbol %s\n", name);
Tim Abbott414fd312008-12-05 19:03:56 -0500448 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449}
Tim Abbottc6b37802008-12-05 19:03:59 -0500450EXPORT_SYMBOL_GPL(find_symbol);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452/* Search for module by name: must hold module_mutex. */
Tim Abbottc6b37802008-12-05 19:03:59 -0500453struct module *find_module(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454{
455 struct module *mod;
456
457 list_for_each_entry(mod, &modules, list) {
458 if (strcmp(mod->name, name) == 0)
459 return mod;
460 }
461 return NULL;
462}
Tim Abbottc6b37802008-12-05 19:03:59 -0500463EXPORT_SYMBOL_GPL(find_module);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
465#ifdef CONFIG_SMP
Tejun Heofbf59bc2009-02-20 16:29:08 +0900466
Tejun Heo259354d2010-03-10 18:56:10 +0900467static inline void __percpu *mod_percpu(struct module *mod)
Tejun Heofbf59bc2009-02-20 16:29:08 +0900468{
Tejun Heo259354d2010-03-10 18:56:10 +0900469 return mod->percpu;
470}
Tejun Heofbf59bc2009-02-20 16:29:08 +0900471
Tejun Heo259354d2010-03-10 18:56:10 +0900472static int percpu_modalloc(struct module *mod,
473 unsigned long size, unsigned long align)
474{
Tejun Heofbf59bc2009-02-20 16:29:08 +0900475 if (align > PAGE_SIZE) {
476 printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
Tejun Heo259354d2010-03-10 18:56:10 +0900477 mod->name, align, PAGE_SIZE);
Tejun Heofbf59bc2009-02-20 16:29:08 +0900478 align = PAGE_SIZE;
479 }
480
Tejun Heo259354d2010-03-10 18:56:10 +0900481 mod->percpu = __alloc_reserved_percpu(size, align);
482 if (!mod->percpu) {
Tejun Heofbf59bc2009-02-20 16:29:08 +0900483 printk(KERN_WARNING
Rusty Russelld9131882010-08-05 12:59:08 -0600484 "%s: Could not allocate %lu bytes percpu data\n",
485 mod->name, size);
Tejun Heo259354d2010-03-10 18:56:10 +0900486 return -ENOMEM;
487 }
488 mod->percpu_size = size;
489 return 0;
Tejun Heofbf59bc2009-02-20 16:29:08 +0900490}
491
Tejun Heo259354d2010-03-10 18:56:10 +0900492static void percpu_modfree(struct module *mod)
Tejun Heofbf59bc2009-02-20 16:29:08 +0900493{
Tejun Heo259354d2010-03-10 18:56:10 +0900494 free_percpu(mod->percpu);
Tejun Heofbf59bc2009-02-20 16:29:08 +0900495}
496
Rusty Russell49668682010-08-05 12:59:10 -0600497static unsigned int find_pcpusec(struct load_info *info)
Tejun Heo6b588c12009-02-20 16:29:07 +0900498{
Rusty Russell49668682010-08-05 12:59:10 -0600499 return find_sec(info, ".data..percpu");
Tejun Heo6b588c12009-02-20 16:29:07 +0900500}
501
Tejun Heo259354d2010-03-10 18:56:10 +0900502static void percpu_modcopy(struct module *mod,
503 const void *from, unsigned long size)
Tejun Heo6b588c12009-02-20 16:29:07 +0900504{
505 int cpu;
506
507 for_each_possible_cpu(cpu)
Tejun Heo259354d2010-03-10 18:56:10 +0900508 memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);
Tejun Heo6b588c12009-02-20 16:29:07 +0900509}
510
Tejun Heo10fad5e2010-03-10 18:57:54 +0900511/**
512 * is_module_percpu_address - test whether address is from module static percpu
513 * @addr: address to test
514 *
515 * Test whether @addr belongs to module static percpu area.
516 *
517 * RETURNS:
518 * %true if @addr is from module static percpu area
519 */
520bool is_module_percpu_address(unsigned long addr)
521{
522 struct module *mod;
523 unsigned int cpu;
524
525 preempt_disable();
526
527 list_for_each_entry_rcu(mod, &modules, list) {
528 if (!mod->percpu_size)
529 continue;
530 for_each_possible_cpu(cpu) {
531 void *start = per_cpu_ptr(mod->percpu, cpu);
532
533 if ((void *)addr >= start &&
534 (void *)addr < start + mod->percpu_size) {
535 preempt_enable();
536 return true;
537 }
538 }
539 }
540
541 preempt_enable();
542 return false;
Daniel Walker22a8bde2007-10-18 03:06:07 -0700543}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
545#else /* ... !CONFIG_SMP */
Tejun Heo6b588c12009-02-20 16:29:07 +0900546
Tejun Heo259354d2010-03-10 18:56:10 +0900547static inline void __percpu *mod_percpu(struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
549 return NULL;
550}
Tejun Heo259354d2010-03-10 18:56:10 +0900551static inline int percpu_modalloc(struct module *mod,
552 unsigned long size, unsigned long align)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553{
Tejun Heo259354d2010-03-10 18:56:10 +0900554 return -ENOMEM;
555}
556static inline void percpu_modfree(struct module *mod)
557{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558}
Rusty Russell49668682010-08-05 12:59:10 -0600559static unsigned int find_pcpusec(struct load_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560{
561 return 0;
562}
Tejun Heo259354d2010-03-10 18:56:10 +0900563static inline void percpu_modcopy(struct module *mod,
564 const void *from, unsigned long size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{
566 /* pcpusec should be 0, and size of that section should be 0. */
567 BUG_ON(size != 0);
568}
Tejun Heo10fad5e2010-03-10 18:57:54 +0900569bool is_module_percpu_address(unsigned long addr)
570{
571 return false;
572}
Tejun Heo6b588c12009-02-20 16:29:07 +0900573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574#endif /* CONFIG_SMP */
575
Matt Domschc988d2b2005-06-23 22:05:15 -0700576#define MODINFO_ATTR(field) \
577static void setup_modinfo_##field(struct module *mod, const char *s) \
578{ \
579 mod->field = kstrdup(s, GFP_KERNEL); \
580} \
581static ssize_t show_modinfo_##field(struct module_attribute *mattr, \
Kay Sievers4befb022011-07-24 22:06:04 +0930582 struct module_kobject *mk, char *buffer) \
Matt Domschc988d2b2005-06-23 22:05:15 -0700583{ \
Kay Sievers4befb022011-07-24 22:06:04 +0930584 return sprintf(buffer, "%s\n", mk->mod->field); \
Matt Domschc988d2b2005-06-23 22:05:15 -0700585} \
586static int modinfo_##field##_exists(struct module *mod) \
587{ \
588 return mod->field != NULL; \
589} \
590static void free_modinfo_##field(struct module *mod) \
591{ \
Daniel Walker22a8bde2007-10-18 03:06:07 -0700592 kfree(mod->field); \
593 mod->field = NULL; \
Matt Domschc988d2b2005-06-23 22:05:15 -0700594} \
595static struct module_attribute modinfo_##field = { \
Tejun Heo7b595752007-06-14 03:45:17 +0900596 .attr = { .name = __stringify(field), .mode = 0444 }, \
Matt Domschc988d2b2005-06-23 22:05:15 -0700597 .show = show_modinfo_##field, \
598 .setup = setup_modinfo_##field, \
599 .test = modinfo_##field##_exists, \
600 .free = free_modinfo_##field, \
601};
602
603MODINFO_ATTR(version);
604MODINFO_ATTR(srcversion);
605
Arjan van de Vene14af7e2008-01-25 21:08:33 +0100606static char last_unloaded_module[MODULE_NAME_LEN+1];
607
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -0800608#ifdef CONFIG_MODULE_UNLOAD
Steven Rostedteb0c5372010-03-29 14:25:18 -0400609
610EXPORT_TRACEPOINT_SYMBOL(module_get);
611
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612/* Init the unload section of the module. */
Rusty Russell9f85a4b2010-08-05 12:59:04 -0600613static int module_unload_init(struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614{
Rusty Russell9f85a4b2010-08-05 12:59:04 -0600615 mod->refptr = alloc_percpu(struct module_ref);
616 if (!mod->refptr)
617 return -ENOMEM;
618
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700619 INIT_LIST_HEAD(&mod->source_list);
620 INIT_LIST_HEAD(&mod->target_list);
Christoph Lametere1783a22010-01-05 15:34:50 +0900621
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 /* Hold reference count during initialization. */
Nick Piggin5fbfb182010-04-01 19:09:40 +1100623 __this_cpu_write(mod->refptr->incs, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 /* Backwards compatibility macros put refcount during init. */
625 mod->waiter = current;
Rusty Russell9f85a4b2010-08-05 12:59:04 -0600626
627 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628}
629
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630/* Does a already use b? */
631static int already_uses(struct module *a, struct module *b)
632{
633 struct module_use *use;
634
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700635 list_for_each_entry(use, &b->source_list, source_list) {
636 if (use->source == a) {
Jim Cromie5e124162011-12-06 12:11:31 -0700637 pr_debug("%s uses %s!\n", a->name, b->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 return 1;
639 }
640 }
Jim Cromie5e124162011-12-06 12:11:31 -0700641 pr_debug("%s does not use %s!\n", a->name, b->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 return 0;
643}
644
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700645/*
646 * Module a uses b
647 * - we add 'a' as a "source", 'b' as a "target" of module use
648 * - the module_use is added to the list of 'b' sources (so
649 * 'b' can walk the list to see who sourced them), and of 'a'
650 * targets (so 'a' can see what modules it targets).
651 */
652static int add_module_usage(struct module *a, struct module *b)
653{
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700654 struct module_use *use;
655
Jim Cromie5e124162011-12-06 12:11:31 -0700656 pr_debug("Allocating new usage for %s.\n", a->name);
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700657 use = kmalloc(sizeof(*use), GFP_ATOMIC);
658 if (!use) {
659 printk(KERN_WARNING "%s: out of memory loading\n", a->name);
660 return -ENOMEM;
661 }
662
663 use->source = a;
664 use->target = b;
665 list_add(&use->source_list, &b->source_list);
666 list_add(&use->target_list, &a->target_list);
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700667 return 0;
668}
669
Rusty Russell75676502010-06-05 11:17:36 -0600670/* Module a uses b: caller needs module_mutex() */
Rusty Russell9bea7f22010-06-05 11:17:37 -0600671int ref_module(struct module *a, struct module *b)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672{
Rusty Russellc8e21ce2010-06-05 11:17:35 -0600673 int err;
Kay Sievers270a6c42007-01-18 13:26:15 +0100674
Rusty Russell9bea7f22010-06-05 11:17:37 -0600675 if (b == NULL || already_uses(a, b))
Linus Torvalds218ce732010-05-25 16:48:30 -0700676 return 0;
Linus Torvalds218ce732010-05-25 16:48:30 -0700677
Rusty Russell9bea7f22010-06-05 11:17:37 -0600678 /* If module isn't available, we fail. */
679 err = strong_try_module_get(b);
Rusty Russellc9a3ba52008-01-29 17:13:18 -0500680 if (err)
Rusty Russell9bea7f22010-06-05 11:17:37 -0600681 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700683 err = add_module_usage(a, b);
684 if (err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 module_put(b);
Rusty Russell9bea7f22010-06-05 11:17:37 -0600686 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 }
Rusty Russell9bea7f22010-06-05 11:17:37 -0600688 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689}
Rusty Russell9bea7f22010-06-05 11:17:37 -0600690EXPORT_SYMBOL_GPL(ref_module);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
692/* Clear the unload stuff of the module. */
693static void module_unload_free(struct module *mod)
694{
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700695 struct module_use *use, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
Rusty Russell75676502010-06-05 11:17:36 -0600697 mutex_lock(&module_mutex);
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700698 list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
699 struct module *i = use->target;
Jim Cromie5e124162011-12-06 12:11:31 -0700700 pr_debug("%s unusing %s\n", mod->name, i->name);
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700701 module_put(i);
702 list_del(&use->source_list);
703 list_del(&use->target_list);
704 kfree(use);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 }
Rusty Russell75676502010-06-05 11:17:36 -0600706 mutex_unlock(&module_mutex);
Rusty Russell9f85a4b2010-08-05 12:59:04 -0600707
708 free_percpu(mod->refptr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709}
710
711#ifdef CONFIG_MODULE_FORCE_UNLOAD
Akinobu Mitafb169792006-01-08 01:04:29 -0800712static inline int try_force_unload(unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
714 int ret = (flags & O_TRUNC);
715 if (ret)
Akinobu Mitafb169792006-01-08 01:04:29 -0800716 add_taint(TAINT_FORCED_RMMOD);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 return ret;
718}
719#else
Akinobu Mitafb169792006-01-08 01:04:29 -0800720static inline int try_force_unload(unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721{
722 return 0;
723}
724#endif /* CONFIG_MODULE_FORCE_UNLOAD */
725
726struct stopref
727{
728 struct module *mod;
729 int flags;
730 int *forced;
731};
732
733/* Whole machine is stopped with interrupts off when this runs. */
734static int __try_stop_module(void *_sref)
735{
736 struct stopref *sref = _sref;
737
Rusty Russellda39ba52008-07-22 19:24:25 -0500738 /* If it's not unused, quit unless we're forcing. */
739 if (module_refcount(sref->mod) != 0) {
Akinobu Mitafb169792006-01-08 01:04:29 -0800740 if (!(*sref->forced = try_force_unload(sref->flags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 return -EWOULDBLOCK;
742 }
743
744 /* Mark it as dying. */
745 sref->mod->state = MODULE_STATE_GOING;
746 return 0;
747}
748
749static int try_stop_module(struct module *mod, int flags, int *forced)
750{
Rusty Russellda39ba52008-07-22 19:24:25 -0500751 if (flags & O_NONBLOCK) {
752 struct stopref sref = { mod, flags, forced };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
Rusty Russell9b1a4d32008-07-28 12:16:30 -0500754 return stop_machine(__try_stop_module, &sref, NULL);
Rusty Russellda39ba52008-07-22 19:24:25 -0500755 } else {
756 /* We don't need to stop the machine for this. */
757 mod->state = MODULE_STATE_GOING;
758 synchronize_sched();
759 return 0;
760 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761}
762
Eric Dumazetbd77c042012-01-13 09:32:14 +1030763unsigned long module_refcount(struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764{
Eric Dumazetbd77c042012-01-13 09:32:14 +1030765 unsigned long incs = 0, decs = 0;
Eric Dumazet720eba32009-02-03 13:31:36 +1030766 int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767
Eric Dumazet720eba32009-02-03 13:31:36 +1030768 for_each_possible_cpu(cpu)
Nick Piggin5fbfb182010-04-01 19:09:40 +1100769 decs += per_cpu_ptr(mod->refptr, cpu)->decs;
770 /*
771 * ensure the incs are added up after the decs.
772 * module_put ensures incs are visible before decs with smp_wmb.
773 *
774 * This 2-count scheme avoids the situation where the refcount
775 * for CPU0 is read, then CPU0 increments the module refcount,
776 * then CPU1 drops that refcount, then the refcount for CPU1 is
777 * read. We would record a decrement but not its corresponding
778 * increment so we would see a low count (disaster).
779 *
780 * Rare situation? But module_refcount can be preempted, and we
781 * might be tallying up 4096+ CPUs. So it is not impossible.
782 */
783 smp_rmb();
784 for_each_possible_cpu(cpu)
785 incs += per_cpu_ptr(mod->refptr, cpu)->incs;
786 return incs - decs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787}
788EXPORT_SYMBOL(module_refcount);
789
790/* This exists whether we can unload or not */
791static void free_module(struct module *mod);
792
793static void wait_for_zero_refcount(struct module *mod)
794{
Matthew Wilcoxa6550202008-02-26 10:47:18 -0500795 /* Since we might sleep for some time, release the mutex first */
Ashutosh Naik6389a382006-03-23 03:00:46 -0800796 mutex_unlock(&module_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 for (;;) {
Jim Cromie5e124162011-12-06 12:11:31 -0700798 pr_debug("Looking at refcount...\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 set_current_state(TASK_UNINTERRUPTIBLE);
800 if (module_refcount(mod) == 0)
801 break;
802 schedule();
803 }
804 current->state = TASK_RUNNING;
Ashutosh Naik6389a382006-03-23 03:00:46 -0800805 mutex_lock(&module_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806}
807
Heiko Carstens17da2bd2009-01-14 14:14:10 +0100808SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
809 unsigned int, flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810{
811 struct module *mod;
Greg Kroah-Hartmandfff0a02007-02-23 14:54:57 -0800812 char name[MODULE_NAME_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 int ret, forced = 0;
814
Kees Cook3d433212009-04-02 15:49:29 -0700815 if (!capable(CAP_SYS_MODULE) || modules_disabled)
Greg Kroah-Hartmandfff0a02007-02-23 14:54:57 -0800816 return -EPERM;
817
818 if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
819 return -EFAULT;
820 name[MODULE_NAME_LEN-1] = '\0';
821
Tejun Heo3fc1f1e2010-05-06 18:49:20 +0200822 if (mutex_lock_interruptible(&module_mutex) != 0)
823 return -EINTR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 mod = find_module(name);
826 if (!mod) {
827 ret = -ENOENT;
828 goto out;
829 }
830
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700831 if (!list_empty(&mod->source_list)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 /* Other modules depend on us: get rid of them first. */
833 ret = -EWOULDBLOCK;
834 goto out;
835 }
836
837 /* Doing init or already dying? */
838 if (mod->state != MODULE_STATE_LIVE) {
839 /* FIXME: if (force), slam module count and wake up
840 waiter --RR */
Jim Cromie5e124162011-12-06 12:11:31 -0700841 pr_debug("%s already dying\n", mod->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 ret = -EBUSY;
843 goto out;
844 }
845
846 /* If it has an init func, it must have an exit func to unload */
Rusty Russellaf49d922007-10-16 23:26:27 -0700847 if (mod->init && !mod->exit) {
Akinobu Mitafb169792006-01-08 01:04:29 -0800848 forced = try_force_unload(flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 if (!forced) {
850 /* This module can't be removed */
851 ret = -EBUSY;
852 goto out;
853 }
854 }
855
856 /* Set this up before setting mod->state */
857 mod->waiter = current;
858
859 /* Stop the machine so refcounts can't move and disable module. */
860 ret = try_stop_module(mod, flags, &forced);
861 if (ret != 0)
862 goto out;
863
864 /* Never wait if forced. */
865 if (!forced && module_refcount(mod) != 0)
866 wait_for_zero_refcount(mod);
867
Peter Oberparleiterdf4b5652008-04-21 14:34:31 +0200868 mutex_unlock(&module_mutex);
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300869 /* Final destruction now no one is using it. */
Peter Oberparleiterdf4b5652008-04-21 14:34:31 +0200870 if (mod->exit != NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 mod->exit();
Peter Oberparleiterdf4b5652008-04-21 14:34:31 +0200872 blocking_notifier_call_chain(&module_notify_list,
873 MODULE_STATE_GOING, mod);
Arjan van de Ven22a9d642009-01-07 08:45:46 -0800874 async_synchronize_full();
Rusty Russell75676502010-06-05 11:17:36 -0600875
Arjan van de Vene14af7e2008-01-25 21:08:33 +0100876 /* Store the name of the last unloaded module for diagnostic purposes */
Rusty Russellefa53452008-01-29 17:13:20 -0500877 strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
Rusty Russell75676502010-06-05 11:17:36 -0600879 free_module(mod);
880 return 0;
881out:
Ashutosh Naik6389a382006-03-23 03:00:46 -0800882 mutex_unlock(&module_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 return ret;
884}
885
Jianjun Kongd1e99d72008-12-08 14:26:29 +0800886static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887{
888 struct module_use *use;
889 int printed_something = 0;
890
Eric Dumazetbd77c042012-01-13 09:32:14 +1030891 seq_printf(m, " %lu ", module_refcount(mod));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
893 /* Always include a trailing , so userspace can differentiate
894 between this and the old multi-field proc format. */
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700895 list_for_each_entry(use, &mod->source_list, source_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 printed_something = 1;
Linus Torvalds2c02dfe2010-05-31 12:19:37 -0700897 seq_printf(m, "%s,", use->source->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 }
899
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 if (mod->init != NULL && mod->exit == NULL) {
901 printed_something = 1;
902 seq_printf(m, "[permanent],");
903 }
904
905 if (!printed_something)
906 seq_printf(m, "-");
907}
908
909void __symbol_put(const char *symbol)
910{
911 struct module *owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Rusty Russell24da1cb2007-07-15 23:41:46 -0700913 preempt_disable();
Tim Abbott414fd312008-12-05 19:03:56 -0500914 if (!find_symbol(symbol, &owner, NULL, true, false))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 BUG();
916 module_put(owner);
Rusty Russell24da1cb2007-07-15 23:41:46 -0700917 preempt_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918}
919EXPORT_SYMBOL(__symbol_put);
920
Rusty Russell7d1d16e2009-08-26 22:02:54 +0930921/* Note this assumes addr is a function, which it currently always is. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922void symbol_put_addr(void *addr)
923{
Trent Piepho5e376612006-05-15 09:44:06 -0700924 struct module *modaddr;
Rusty Russell7d1d16e2009-08-26 22:02:54 +0930925 unsigned long a = (unsigned long)dereference_function_descriptor(addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
Rusty Russell7d1d16e2009-08-26 22:02:54 +0930927 if (core_kernel_text(a))
Trent Piepho5e376612006-05-15 09:44:06 -0700928 return;
929
Rusty Russella6e6abd2009-03-31 13:05:31 -0600930 /* module_text_address is safe here: we're supposed to have reference
931 * to module from symbol_get, so it can't go away. */
Rusty Russell7d1d16e2009-08-26 22:02:54 +0930932 modaddr = __module_text_address(a);
Rusty Russella6e6abd2009-03-31 13:05:31 -0600933 BUG_ON(!modaddr);
Trent Piepho5e376612006-05-15 09:44:06 -0700934 module_put(modaddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935}
936EXPORT_SYMBOL_GPL(symbol_put_addr);
937
938static ssize_t show_refcnt(struct module_attribute *mattr,
Kay Sievers4befb022011-07-24 22:06:04 +0930939 struct module_kobject *mk, char *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940{
Eric Dumazetbd77c042012-01-13 09:32:14 +1030941 return sprintf(buffer, "%lu\n", module_refcount(mk->mod));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942}
943
Kay Sieverscca3e702012-01-13 09:32:15 +1030944static struct module_attribute modinfo_refcnt =
945 __ATTR(refcnt, 0444, show_refcnt, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946
Steven Rostedtd53799b2012-03-26 12:50:52 +1030947void __module_get(struct module *module)
948{
949 if (module) {
950 preempt_disable();
951 __this_cpu_inc(module->refptr->incs);
952 trace_module_get(module, _RET_IP_);
953 preempt_enable();
954 }
955}
956EXPORT_SYMBOL(__module_get);
957
958bool try_module_get(struct module *module)
959{
960 bool ret = true;
961
962 if (module) {
963 preempt_disable();
964
965 if (likely(module_is_live(module))) {
966 __this_cpu_inc(module->refptr->incs);
967 trace_module_get(module, _RET_IP_);
968 } else
969 ret = false;
970
971 preempt_enable();
972 }
973 return ret;
974}
975EXPORT_SYMBOL(try_module_get);
976
Al Virof6a57032006-10-18 01:47:25 -0400977void module_put(struct module *module)
978{
979 if (module) {
Christoph Lametere1783a22010-01-05 15:34:50 +0900980 preempt_disable();
Nick Piggin5fbfb182010-04-01 19:09:40 +1100981 smp_wmb(); /* see comment in module_refcount */
982 __this_cpu_inc(module->refptr->decs);
Christoph Lametere1783a22010-01-05 15:34:50 +0900983
Li Zefanae832d12010-03-24 10:57:43 +0800984 trace_module_put(module, _RET_IP_);
Al Virof6a57032006-10-18 01:47:25 -0400985 /* Maybe they're waiting for us to drop reference? */
986 if (unlikely(!module_is_live(module)))
987 wake_up_process(module->waiter);
Christoph Lametere1783a22010-01-05 15:34:50 +0900988 preempt_enable();
Al Virof6a57032006-10-18 01:47:25 -0400989 }
990}
991EXPORT_SYMBOL(module_put);
992
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993#else /* !CONFIG_MODULE_UNLOAD */
Jianjun Kongd1e99d72008-12-08 14:26:29 +0800994static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995{
996 /* We don't know the usage count, or what modules are using. */
997 seq_printf(m, " - -");
998}
999
1000static inline void module_unload_free(struct module *mod)
1001{
1002}
1003
Rusty Russell9bea7f22010-06-05 11:17:37 -06001004int ref_module(struct module *a, struct module *b)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005{
Rusty Russell9bea7f22010-06-05 11:17:37 -06001006 return strong_try_module_get(b);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007}
Rusty Russell9bea7f22010-06-05 11:17:37 -06001008EXPORT_SYMBOL_GPL(ref_module);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009
Rusty Russell9f85a4b2010-08-05 12:59:04 -06001010static inline int module_unload_init(struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011{
Rusty Russell9f85a4b2010-08-05 12:59:04 -06001012 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013}
1014#endif /* CONFIG_MODULE_UNLOAD */
1015
Kevin Winchester53999bf2012-01-15 19:32:55 -04001016static size_t module_flags_taint(struct module *mod, char *buf)
1017{
1018 size_t l = 0;
1019
1020 if (mod->taints & (1 << TAINT_PROPRIETARY_MODULE))
1021 buf[l++] = 'P';
1022 if (mod->taints & (1 << TAINT_OOT_MODULE))
1023 buf[l++] = 'O';
1024 if (mod->taints & (1 << TAINT_FORCED_MODULE))
1025 buf[l++] = 'F';
1026 if (mod->taints & (1 << TAINT_CRAP))
1027 buf[l++] = 'C';
1028 /*
1029 * TAINT_FORCED_RMMOD: could be added.
1030 * TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
1031 * apply to modules.
1032 */
1033 return l;
1034}
1035
Kay Sievers1f717402006-11-24 12:15:25 +01001036static ssize_t show_initstate(struct module_attribute *mattr,
Kay Sievers4befb022011-07-24 22:06:04 +09301037 struct module_kobject *mk, char *buffer)
Kay Sievers1f717402006-11-24 12:15:25 +01001038{
1039 const char *state = "unknown";
1040
Kay Sievers4befb022011-07-24 22:06:04 +09301041 switch (mk->mod->state) {
Kay Sievers1f717402006-11-24 12:15:25 +01001042 case MODULE_STATE_LIVE:
1043 state = "live";
1044 break;
1045 case MODULE_STATE_COMING:
1046 state = "coming";
1047 break;
1048 case MODULE_STATE_GOING:
1049 state = "going";
1050 break;
1051 }
1052 return sprintf(buffer, "%s\n", state);
1053}
1054
Kay Sieverscca3e702012-01-13 09:32:15 +10301055static struct module_attribute modinfo_initstate =
1056 __ATTR(initstate, 0444, show_initstate, NULL);
Kay Sievers1f717402006-11-24 12:15:25 +01001057
Kay Sievers88bfa322011-07-24 22:06:04 +09301058static ssize_t store_uevent(struct module_attribute *mattr,
1059 struct module_kobject *mk,
1060 const char *buffer, size_t count)
1061{
1062 enum kobject_action action;
1063
1064 if (kobject_action_type(buffer, count, &action) == 0)
1065 kobject_uevent(&mk->kobj, action);
1066 return count;
1067}
1068
Kay Sieverscca3e702012-01-13 09:32:15 +10301069struct module_attribute module_uevent =
1070 __ATTR(uevent, 0200, NULL, store_uevent);
1071
1072static ssize_t show_coresize(struct module_attribute *mattr,
1073 struct module_kobject *mk, char *buffer)
1074{
1075 return sprintf(buffer, "%u\n", mk->mod->core_size);
1076}
1077
1078static struct module_attribute modinfo_coresize =
1079 __ATTR(coresize, 0444, show_coresize, NULL);
1080
1081static ssize_t show_initsize(struct module_attribute *mattr,
1082 struct module_kobject *mk, char *buffer)
1083{
1084 return sprintf(buffer, "%u\n", mk->mod->init_size);
1085}
1086
1087static struct module_attribute modinfo_initsize =
1088 __ATTR(initsize, 0444, show_initsize, NULL);
1089
1090static ssize_t show_taint(struct module_attribute *mattr,
1091 struct module_kobject *mk, char *buffer)
1092{
1093 size_t l;
1094
1095 l = module_flags_taint(mk->mod, buffer);
1096 buffer[l++] = '\n';
1097 return l;
1098}
1099
1100static struct module_attribute modinfo_taint =
1101 __ATTR(taint, 0444, show_taint, NULL);
Kay Sievers88bfa322011-07-24 22:06:04 +09301102
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001103static struct module_attribute *modinfo_attrs[] = {
Kay Sieverscca3e702012-01-13 09:32:15 +10301104 &module_uevent,
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001105 &modinfo_version,
1106 &modinfo_srcversion,
Kay Sieverscca3e702012-01-13 09:32:15 +10301107 &modinfo_initstate,
1108 &modinfo_coresize,
1109 &modinfo_initsize,
1110 &modinfo_taint,
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001111#ifdef CONFIG_MODULE_UNLOAD
Kay Sieverscca3e702012-01-13 09:32:15 +10301112 &modinfo_refcnt,
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001113#endif
1114 NULL,
1115};
1116
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117static const char vermagic[] = VERMAGIC_STRING;
1118
Rusty Russellc6e665c2009-03-31 13:05:33 -06001119static int try_to_force_load(struct module *mod, const char *reason)
Linus Torvalds826e4502008-05-04 17:04:16 -07001120{
1121#ifdef CONFIG_MODULE_FORCE_LOAD
Andi Kleen25ddbb12008-10-15 22:01:41 -07001122 if (!test_taint(TAINT_FORCED_MODULE))
Rusty Russellc6e665c2009-03-31 13:05:33 -06001123 printk(KERN_WARNING "%s: %s: kernel tainted.\n",
1124 mod->name, reason);
Linus Torvalds826e4502008-05-04 17:04:16 -07001125 add_taint_module(mod, TAINT_FORCED_MODULE);
1126 return 0;
1127#else
1128 return -ENOEXEC;
1129#endif
1130}
1131
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132#ifdef CONFIG_MODVERSIONS
Rusty Russelld4703ae2009-12-15 16:28:32 -06001133/* If the arch applies (non-zero) relocations to kernel kcrctab, unapply it. */
1134static unsigned long maybe_relocated(unsigned long crc,
1135 const struct module *crc_owner)
1136{
1137#ifdef ARCH_RELOCATES_KCRCTAB
1138 if (crc_owner == NULL)
1139 return crc - (unsigned long)reloc_start;
1140#endif
1141 return crc;
1142}
1143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144static int check_version(Elf_Shdr *sechdrs,
1145 unsigned int versindex,
1146 const char *symname,
1147 struct module *mod,
Rusty Russelld4703ae2009-12-15 16:28:32 -06001148 const unsigned long *crc,
1149 const struct module *crc_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150{
1151 unsigned int i, num_versions;
1152 struct modversion_info *versions;
1153
1154 /* Exporting module didn't supply crcs? OK, we're already tainted. */
1155 if (!crc)
1156 return 1;
1157
Rusty Russella5dd6972008-05-09 16:24:21 +10001158 /* No versions at all? modprobe --force does this. */
1159 if (versindex == 0)
1160 return try_to_force_load(mod, symname) == 0;
1161
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 versions = (void *) sechdrs[versindex].sh_addr;
1163 num_versions = sechdrs[versindex].sh_size
1164 / sizeof(struct modversion_info);
1165
1166 for (i = 0; i < num_versions; i++) {
1167 if (strcmp(versions[i].name, symname) != 0)
1168 continue;
1169
Rusty Russelld4703ae2009-12-15 16:28:32 -06001170 if (versions[i].crc == maybe_relocated(*crc, crc_owner))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 return 1;
Jim Cromie5e124162011-12-06 12:11:31 -07001172 pr_debug("Found checksum %lX vs module %lX\n",
Rusty Russelld4703ae2009-12-15 16:28:32 -06001173 maybe_relocated(*crc, crc_owner), versions[i].crc);
Linus Torvalds826e4502008-05-04 17:04:16 -07001174 goto bad_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 }
Linus Torvalds826e4502008-05-04 17:04:16 -07001176
Rusty Russella5dd6972008-05-09 16:24:21 +10001177 printk(KERN_WARNING "%s: no symbol version for %s\n",
1178 mod->name, symname);
1179 return 0;
Linus Torvalds826e4502008-05-04 17:04:16 -07001180
1181bad_version:
1182 printk("%s: disagrees about version of symbol %s\n",
1183 mod->name, symname);
1184 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185}
1186
1187static inline int check_modstruct_version(Elf_Shdr *sechdrs,
1188 unsigned int versindex,
1189 struct module *mod)
1190{
1191 const unsigned long *crc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
Rusty Russell75676502010-06-05 11:17:36 -06001193 /* Since this should be found in kernel (which can't be removed),
1194 * no locking is necessary. */
Mike Frysinger6560dc12009-07-23 23:42:08 +09301195 if (!find_symbol(MODULE_SYMBOL_PREFIX "module_layout", NULL,
1196 &crc, true, false))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 BUG();
Rusty Russelld4703ae2009-12-15 16:28:32 -06001198 return check_version(sechdrs, versindex, "module_layout", mod, crc,
1199 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200}
1201
Rusty Russell91e37a72008-05-09 16:25:28 +10001202/* First part is kernel version, which we ignore if module has crcs. */
1203static inline int same_magic(const char *amagic, const char *bmagic,
1204 bool has_crcs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205{
Rusty Russell91e37a72008-05-09 16:25:28 +10001206 if (has_crcs) {
1207 amagic += strcspn(amagic, " ");
1208 bmagic += strcspn(bmagic, " ");
1209 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 return strcmp(amagic, bmagic) == 0;
1211}
1212#else
1213static inline int check_version(Elf_Shdr *sechdrs,
1214 unsigned int versindex,
1215 const char *symname,
1216 struct module *mod,
Rusty Russelld4703ae2009-12-15 16:28:32 -06001217 const unsigned long *crc,
1218 const struct module *crc_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219{
1220 return 1;
1221}
1222
1223static inline int check_modstruct_version(Elf_Shdr *sechdrs,
1224 unsigned int versindex,
1225 struct module *mod)
1226{
1227 return 1;
1228}
1229
Rusty Russell91e37a72008-05-09 16:25:28 +10001230static inline int same_magic(const char *amagic, const char *bmagic,
1231 bool has_crcs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232{
1233 return strcmp(amagic, bmagic) == 0;
1234}
1235#endif /* CONFIG_MODVERSIONS */
1236
Rusty Russell75676502010-06-05 11:17:36 -06001237/* Resolve a symbol for this module. I.e. if we find one, record usage. */
Rusty Russell49668682010-08-05 12:59:10 -06001238static const struct kernel_symbol *resolve_symbol(struct module *mod,
1239 const struct load_info *info,
Tim Abbott414fd312008-12-05 19:03:56 -05001240 const char *name,
Rusty Russell9bea7f22010-06-05 11:17:37 -06001241 char ownername[])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242{
1243 struct module *owner;
Tim Abbott414fd312008-12-05 19:03:56 -05001244 const struct kernel_symbol *sym;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 const unsigned long *crc;
Rusty Russell9bea7f22010-06-05 11:17:37 -06001246 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247
Rusty Russell75676502010-06-05 11:17:36 -06001248 mutex_lock(&module_mutex);
Tim Abbott414fd312008-12-05 19:03:56 -05001249 sym = find_symbol(name, &owner, &crc,
Andi Kleen25ddbb12008-10-15 22:01:41 -07001250 !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
Rusty Russell9bea7f22010-06-05 11:17:37 -06001251 if (!sym)
1252 goto unlock;
1253
Rusty Russell49668682010-08-05 12:59:10 -06001254 if (!check_version(info->sechdrs, info->index.vers, name, mod, crc,
1255 owner)) {
Rusty Russell9bea7f22010-06-05 11:17:37 -06001256 sym = ERR_PTR(-EINVAL);
1257 goto getname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 }
Rusty Russell9bea7f22010-06-05 11:17:37 -06001259
1260 err = ref_module(mod, owner);
1261 if (err) {
1262 sym = ERR_PTR(err);
1263 goto getname;
1264 }
1265
1266getname:
1267 /* We must make copy under the lock if we failed to get ref. */
1268 strncpy(ownername, module_name(owner), MODULE_NAME_LEN);
1269unlock:
Rusty Russell75676502010-06-05 11:17:36 -06001270 mutex_unlock(&module_mutex);
Linus Torvalds218ce732010-05-25 16:48:30 -07001271 return sym;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272}
1273
Rusty Russell49668682010-08-05 12:59:10 -06001274static const struct kernel_symbol *
1275resolve_symbol_wait(struct module *mod,
1276 const struct load_info *info,
1277 const char *name)
Rusty Russell9bea7f22010-06-05 11:17:37 -06001278{
1279 const struct kernel_symbol *ksym;
Rusty Russell49668682010-08-05 12:59:10 -06001280 char owner[MODULE_NAME_LEN];
Rusty Russell9bea7f22010-06-05 11:17:37 -06001281
1282 if (wait_event_interruptible_timeout(module_wq,
Rusty Russell49668682010-08-05 12:59:10 -06001283 !IS_ERR(ksym = resolve_symbol(mod, info, name, owner))
1284 || PTR_ERR(ksym) != -EBUSY,
Rusty Russell9bea7f22010-06-05 11:17:37 -06001285 30 * HZ) <= 0) {
1286 printk(KERN_WARNING "%s: gave up waiting for init of module %s.\n",
Rusty Russell49668682010-08-05 12:59:10 -06001287 mod->name, owner);
Rusty Russell9bea7f22010-06-05 11:17:37 -06001288 }
1289 return ksym;
1290}
1291
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292/*
1293 * /sys/module/foo/sections stuff
1294 * J. Corbet <corbet@lwn.net>
1295 */
Rusty Russell8f6d0372010-08-05 12:59:09 -06001296#ifdef CONFIG_SYSFS
Ben Hutchings10b465a2009-12-19 14:43:01 +00001297
Rusty Russell8f6d0372010-08-05 12:59:09 -06001298#ifdef CONFIG_KALLSYMS
Ben Hutchings10b465a2009-12-19 14:43:01 +00001299static inline bool sect_empty(const Elf_Shdr *sect)
1300{
1301 return !(sect->sh_flags & SHF_ALLOC) || sect->sh_size == 0;
1302}
1303
Rusty Russella58730c2008-03-13 09:03:44 +00001304struct module_sect_attr
1305{
1306 struct module_attribute mattr;
1307 char *name;
1308 unsigned long address;
1309};
1310
1311struct module_sect_attrs
1312{
1313 struct attribute_group grp;
1314 unsigned int nsections;
1315 struct module_sect_attr attrs[0];
1316};
1317
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318static ssize_t module_sect_show(struct module_attribute *mattr,
Kay Sievers4befb022011-07-24 22:06:04 +09301319 struct module_kobject *mk, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320{
1321 struct module_sect_attr *sattr =
1322 container_of(mattr, struct module_sect_attr, mattr);
Kees Cook9f36e2c2011-03-22 16:34:22 -07001323 return sprintf(buf, "0x%pK\n", (void *)sattr->address);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324}
1325
Ian S. Nelson04b1db92006-09-29 02:01:31 -07001326static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
1327{
Rusty Russella58730c2008-03-13 09:03:44 +00001328 unsigned int section;
Ian S. Nelson04b1db92006-09-29 02:01:31 -07001329
1330 for (section = 0; section < sect_attrs->nsections; section++)
1331 kfree(sect_attrs->attrs[section].name);
1332 kfree(sect_attrs);
1333}
1334
Rusty Russell8f6d0372010-08-05 12:59:09 -06001335static void add_sect_attrs(struct module *mod, const struct load_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336{
1337 unsigned int nloaded = 0, i, size[2];
1338 struct module_sect_attrs *sect_attrs;
1339 struct module_sect_attr *sattr;
1340 struct attribute **gattr;
Daniel Walker22a8bde2007-10-18 03:06:07 -07001341
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 /* Count loaded sections and allocate structures */
Rusty Russell8f6d0372010-08-05 12:59:09 -06001343 for (i = 0; i < info->hdr->e_shnum; i++)
1344 if (!sect_empty(&info->sechdrs[i]))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 nloaded++;
1346 size[0] = ALIGN(sizeof(*sect_attrs)
1347 + nloaded * sizeof(sect_attrs->attrs[0]),
1348 sizeof(sect_attrs->grp.attrs[0]));
1349 size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]);
Ian S. Nelson04b1db92006-09-29 02:01:31 -07001350 sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);
1351 if (sect_attrs == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 return;
1353
1354 /* Setup section attributes. */
1355 sect_attrs->grp.name = "sections";
1356 sect_attrs->grp.attrs = (void *)sect_attrs + size[0];
1357
Ian S. Nelson04b1db92006-09-29 02:01:31 -07001358 sect_attrs->nsections = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 sattr = &sect_attrs->attrs[0];
1360 gattr = &sect_attrs->grp.attrs[0];
Rusty Russell8f6d0372010-08-05 12:59:09 -06001361 for (i = 0; i < info->hdr->e_shnum; i++) {
1362 Elf_Shdr *sec = &info->sechdrs[i];
1363 if (sect_empty(sec))
Helge Deller35dead42009-12-03 00:29:15 +01001364 continue;
Rusty Russell8f6d0372010-08-05 12:59:09 -06001365 sattr->address = sec->sh_addr;
1366 sattr->name = kstrdup(info->secstrings + sec->sh_name,
Ian S. Nelson04b1db92006-09-29 02:01:31 -07001367 GFP_KERNEL);
1368 if (sattr->name == NULL)
1369 goto out;
1370 sect_attrs->nsections++;
Eric W. Biederman361795b2010-02-12 13:41:56 -08001371 sysfs_attr_init(&sattr->mattr.attr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 sattr->mattr.show = module_sect_show;
1373 sattr->mattr.store = NULL;
1374 sattr->mattr.attr.name = sattr->name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001375 sattr->mattr.attr.mode = S_IRUGO;
1376 *(gattr++) = &(sattr++)->mattr.attr;
1377 }
1378 *gattr = NULL;
1379
1380 if (sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp))
1381 goto out;
1382
1383 mod->sect_attrs = sect_attrs;
1384 return;
1385 out:
Ian S. Nelson04b1db92006-09-29 02:01:31 -07001386 free_sect_attrs(sect_attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387}
1388
1389static void remove_sect_attrs(struct module *mod)
1390{
1391 if (mod->sect_attrs) {
1392 sysfs_remove_group(&mod->mkobj.kobj,
1393 &mod->sect_attrs->grp);
1394 /* We are positive that no one is using any sect attrs
1395 * at this point. Deallocate immediately. */
Ian S. Nelson04b1db92006-09-29 02:01:31 -07001396 free_sect_attrs(mod->sect_attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 mod->sect_attrs = NULL;
1398 }
1399}
1400
Roland McGrath6d760132007-10-16 23:26:40 -07001401/*
1402 * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
1403 */
1404
1405struct module_notes_attrs {
1406 struct kobject *dir;
1407 unsigned int notes;
1408 struct bin_attribute attrs[0];
1409};
1410
Chris Wright2c3c8be2010-05-12 18:28:57 -07001411static ssize_t module_notes_read(struct file *filp, struct kobject *kobj,
Roland McGrath6d760132007-10-16 23:26:40 -07001412 struct bin_attribute *bin_attr,
1413 char *buf, loff_t pos, size_t count)
1414{
1415 /*
1416 * The caller checked the pos and count against our size.
1417 */
1418 memcpy(buf, bin_attr->private + pos, count);
1419 return count;
1420}
1421
1422static void free_notes_attrs(struct module_notes_attrs *notes_attrs,
1423 unsigned int i)
1424{
1425 if (notes_attrs->dir) {
1426 while (i-- > 0)
1427 sysfs_remove_bin_file(notes_attrs->dir,
1428 &notes_attrs->attrs[i]);
Alexey Dobriyane9432092008-09-23 23:51:11 +04001429 kobject_put(notes_attrs->dir);
Roland McGrath6d760132007-10-16 23:26:40 -07001430 }
1431 kfree(notes_attrs);
1432}
1433
Rusty Russell8f6d0372010-08-05 12:59:09 -06001434static void add_notes_attrs(struct module *mod, const struct load_info *info)
Roland McGrath6d760132007-10-16 23:26:40 -07001435{
1436 unsigned int notes, loaded, i;
1437 struct module_notes_attrs *notes_attrs;
1438 struct bin_attribute *nattr;
1439
Ingo Molnarea6bff32009-08-28 10:44:56 +02001440 /* failed to create section attributes, so can't create notes */
1441 if (!mod->sect_attrs)
1442 return;
1443
Roland McGrath6d760132007-10-16 23:26:40 -07001444 /* Count notes sections and allocate structures. */
1445 notes = 0;
Rusty Russell8f6d0372010-08-05 12:59:09 -06001446 for (i = 0; i < info->hdr->e_shnum; i++)
1447 if (!sect_empty(&info->sechdrs[i]) &&
1448 (info->sechdrs[i].sh_type == SHT_NOTE))
Roland McGrath6d760132007-10-16 23:26:40 -07001449 ++notes;
1450
1451 if (notes == 0)
1452 return;
1453
1454 notes_attrs = kzalloc(sizeof(*notes_attrs)
1455 + notes * sizeof(notes_attrs->attrs[0]),
1456 GFP_KERNEL);
1457 if (notes_attrs == NULL)
1458 return;
1459
1460 notes_attrs->notes = notes;
1461 nattr = &notes_attrs->attrs[0];
Rusty Russell8f6d0372010-08-05 12:59:09 -06001462 for (loaded = i = 0; i < info->hdr->e_shnum; ++i) {
1463 if (sect_empty(&info->sechdrs[i]))
Roland McGrath6d760132007-10-16 23:26:40 -07001464 continue;
Rusty Russell8f6d0372010-08-05 12:59:09 -06001465 if (info->sechdrs[i].sh_type == SHT_NOTE) {
Eric W. Biederman361795b2010-02-12 13:41:56 -08001466 sysfs_bin_attr_init(nattr);
Roland McGrath6d760132007-10-16 23:26:40 -07001467 nattr->attr.name = mod->sect_attrs->attrs[loaded].name;
1468 nattr->attr.mode = S_IRUGO;
Rusty Russell8f6d0372010-08-05 12:59:09 -06001469 nattr->size = info->sechdrs[i].sh_size;
1470 nattr->private = (void *) info->sechdrs[i].sh_addr;
Roland McGrath6d760132007-10-16 23:26:40 -07001471 nattr->read = module_notes_read;
1472 ++nattr;
1473 }
1474 ++loaded;
1475 }
1476
Greg Kroah-Hartman4ff6abf2007-11-05 22:24:43 -08001477 notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);
Roland McGrath6d760132007-10-16 23:26:40 -07001478 if (!notes_attrs->dir)
1479 goto out;
1480
1481 for (i = 0; i < notes; ++i)
1482 if (sysfs_create_bin_file(notes_attrs->dir,
1483 &notes_attrs->attrs[i]))
1484 goto out;
1485
1486 mod->notes_attrs = notes_attrs;
1487 return;
1488
1489 out:
1490 free_notes_attrs(notes_attrs, i);
1491}
1492
1493static void remove_notes_attrs(struct module *mod)
1494{
1495 if (mod->notes_attrs)
1496 free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);
1497}
1498
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499#else
Ian S. Nelson04b1db92006-09-29 02:01:31 -07001500
Rusty Russell8f6d0372010-08-05 12:59:09 -06001501static inline void add_sect_attrs(struct module *mod,
1502 const struct load_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503{
1504}
1505
1506static inline void remove_sect_attrs(struct module *mod)
1507{
1508}
Roland McGrath6d760132007-10-16 23:26:40 -07001509
Rusty Russell8f6d0372010-08-05 12:59:09 -06001510static inline void add_notes_attrs(struct module *mod,
1511 const struct load_info *info)
Roland McGrath6d760132007-10-16 23:26:40 -07001512{
1513}
1514
1515static inline void remove_notes_attrs(struct module *mod)
1516{
1517}
Rusty Russell8f6d0372010-08-05 12:59:09 -06001518#endif /* CONFIG_KALLSYMS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001520static void add_usage_links(struct module *mod)
1521{
1522#ifdef CONFIG_MODULE_UNLOAD
1523 struct module_use *use;
1524 int nowarn;
1525
Rusty Russell75676502010-06-05 11:17:36 -06001526 mutex_lock(&module_mutex);
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001527 list_for_each_entry(use, &mod->target_list, target_list) {
1528 nowarn = sysfs_create_link(use->target->holders_dir,
1529 &mod->mkobj.kobj, mod->name);
1530 }
Rusty Russell75676502010-06-05 11:17:36 -06001531 mutex_unlock(&module_mutex);
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001532#endif
1533}
1534
1535static void del_usage_links(struct module *mod)
1536{
1537#ifdef CONFIG_MODULE_UNLOAD
1538 struct module_use *use;
1539
Rusty Russell75676502010-06-05 11:17:36 -06001540 mutex_lock(&module_mutex);
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001541 list_for_each_entry(use, &mod->target_list, target_list)
1542 sysfs_remove_link(use->target->holders_dir, mod->name);
Rusty Russell75676502010-06-05 11:17:36 -06001543 mutex_unlock(&module_mutex);
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001544#endif
1545}
1546
Rusty Russell6407ebb22010-06-05 11:17:36 -06001547static int module_add_modinfo_attrs(struct module *mod)
Matt Domschc988d2b2005-06-23 22:05:15 -07001548{
1549 struct module_attribute *attr;
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001550 struct module_attribute *temp_attr;
Matt Domschc988d2b2005-06-23 22:05:15 -07001551 int error = 0;
1552 int i;
1553
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001554 mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *
1555 (ARRAY_SIZE(modinfo_attrs) + 1)),
1556 GFP_KERNEL);
1557 if (!mod->modinfo_attrs)
1558 return -ENOMEM;
1559
1560 temp_attr = mod->modinfo_attrs;
Matt Domschc988d2b2005-06-23 22:05:15 -07001561 for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) {
1562 if (!attr->test ||
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001563 (attr->test && attr->test(mod))) {
1564 memcpy(temp_attr, attr, sizeof(*temp_attr));
Eric W. Biederman361795b2010-02-12 13:41:56 -08001565 sysfs_attr_init(&temp_attr->attr);
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001566 error = sysfs_create_file(&mod->mkobj.kobj,&temp_attr->attr);
1567 ++temp_attr;
1568 }
Matt Domschc988d2b2005-06-23 22:05:15 -07001569 }
1570 return error;
1571}
1572
Rusty Russell6407ebb22010-06-05 11:17:36 -06001573static void module_remove_modinfo_attrs(struct module *mod)
Matt Domschc988d2b2005-06-23 22:05:15 -07001574{
1575 struct module_attribute *attr;
1576 int i;
1577
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001578 for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {
1579 /* pick a field to test for end of list */
1580 if (!attr->attr.name)
1581 break;
Matt Domschc988d2b2005-06-23 22:05:15 -07001582 sysfs_remove_file(&mod->mkobj.kobj,&attr->attr);
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001583 if (attr->free)
1584 attr->free(mod);
Matt Domschc988d2b2005-06-23 22:05:15 -07001585 }
Greg Kroah-Hartman03e88ae12006-02-16 13:50:23 -08001586 kfree(mod->modinfo_attrs);
Matt Domschc988d2b2005-06-23 22:05:15 -07001587}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588
Rusty Russell6407ebb22010-06-05 11:17:36 -06001589static int mod_sysfs_init(struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590{
1591 int err;
Greg Kroah-Hartman6494a932008-01-27 15:38:40 -08001592 struct kobject *kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Greg Kroah-Hartman823bccf2007-04-13 13:15:19 -07001594 if (!module_sysfs_initialized) {
1595 printk(KERN_ERR "%s: module sysfs not initialized\n",
Ed Swierk1cc5f712006-09-25 16:25:36 -07001596 mod->name);
1597 err = -EINVAL;
1598 goto out;
1599 }
Greg Kroah-Hartman6494a932008-01-27 15:38:40 -08001600
1601 kobj = kset_find_obj(module_kset, mod->name);
1602 if (kobj) {
1603 printk(KERN_ERR "%s: module is already loaded\n", mod->name);
1604 kobject_put(kobj);
1605 err = -EINVAL;
1606 goto out;
1607 }
1608
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 mod->mkobj.mod = mod;
Kay Sieverse17e0f52006-11-24 12:15:25 +01001610
Greg Kroah-Hartmanac3c8142007-12-17 23:05:35 -07001611 memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
1612 mod->mkobj.kobj.kset = module_kset;
1613 err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
1614 "%s", mod->name);
1615 if (err)
1616 kobject_put(&mod->mkobj.kobj);
Kay Sievers270a6c42007-01-18 13:26:15 +01001617
Kay Sievers97c146e2007-11-29 23:46:11 +01001618 /* delay uevent until full sysfs population */
Kay Sievers270a6c42007-01-18 13:26:15 +01001619out:
1620 return err;
1621}
1622
Rusty Russell6407ebb22010-06-05 11:17:36 -06001623static int mod_sysfs_setup(struct module *mod,
Rusty Russell8f6d0372010-08-05 12:59:09 -06001624 const struct load_info *info,
Kay Sievers270a6c42007-01-18 13:26:15 +01001625 struct kernel_param *kparam,
1626 unsigned int num_params)
1627{
1628 int err;
1629
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001630 err = mod_sysfs_init(mod);
1631 if (err)
1632 goto out;
1633
Greg Kroah-Hartman4ff6abf2007-11-05 22:24:43 -08001634 mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);
Akinobu Mita240936e2007-04-26 00:12:09 -07001635 if (!mod->holders_dir) {
1636 err = -ENOMEM;
Kay Sievers270a6c42007-01-18 13:26:15 +01001637 goto out_unreg;
Akinobu Mita240936e2007-04-26 00:12:09 -07001638 }
Kay Sievers270a6c42007-01-18 13:26:15 +01001639
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 err = module_param_sysfs_setup(mod, kparam, num_params);
1641 if (err)
Kay Sievers270a6c42007-01-18 13:26:15 +01001642 goto out_unreg_holders;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
Matt Domschc988d2b2005-06-23 22:05:15 -07001644 err = module_add_modinfo_attrs(mod);
1645 if (err)
Kay Sieverse17e0f52006-11-24 12:15:25 +01001646 goto out_unreg_param;
Matt Domschc988d2b2005-06-23 22:05:15 -07001647
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001648 add_usage_links(mod);
Rusty Russell8f6d0372010-08-05 12:59:09 -06001649 add_sect_attrs(mod, info);
1650 add_notes_attrs(mod, info);
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001651
Kay Sieverse17e0f52006-11-24 12:15:25 +01001652 kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 return 0;
1654
Kay Sieverse17e0f52006-11-24 12:15:25 +01001655out_unreg_param:
1656 module_param_sysfs_remove(mod);
Kay Sievers270a6c42007-01-18 13:26:15 +01001657out_unreg_holders:
Greg Kroah-Hartman78a2d902007-12-20 08:13:05 -08001658 kobject_put(mod->holders_dir);
Kay Sievers270a6c42007-01-18 13:26:15 +01001659out_unreg:
Kay Sieverse17e0f52006-11-24 12:15:25 +01001660 kobject_put(&mod->mkobj.kobj);
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001661out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 return err;
1663}
Denis V. Lunev34e4e2f2008-05-20 13:59:48 +04001664
1665static void mod_sysfs_fini(struct module *mod)
1666{
Rusty Russell8f6d0372010-08-05 12:59:09 -06001667 remove_notes_attrs(mod);
1668 remove_sect_attrs(mod);
Denis V. Lunev34e4e2f2008-05-20 13:59:48 +04001669 kobject_put(&mod->mkobj.kobj);
1670}
1671
Rusty Russell8f6d0372010-08-05 12:59:09 -06001672#else /* !CONFIG_SYSFS */
Denis V. Lunev34e4e2f2008-05-20 13:59:48 +04001673
Rusty Russell8f6d0372010-08-05 12:59:09 -06001674static int mod_sysfs_setup(struct module *mod,
1675 const struct load_info *info,
Rusty Russell6407ebb22010-06-05 11:17:36 -06001676 struct kernel_param *kparam,
1677 unsigned int num_params)
1678{
1679 return 0;
1680}
1681
Denis V. Lunev34e4e2f2008-05-20 13:59:48 +04001682static void mod_sysfs_fini(struct module *mod)
1683{
1684}
1685
Rusty Russell36b03602010-08-05 12:59:09 -06001686static void module_remove_modinfo_attrs(struct module *mod)
1687{
1688}
1689
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001690static void del_usage_links(struct module *mod)
1691{
1692}
1693
Denis V. Lunev34e4e2f2008-05-20 13:59:48 +04001694#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695
Rusty Russell36b03602010-08-05 12:59:09 -06001696static void mod_sysfs_teardown(struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697{
Rusty Russell80a3d1b2010-06-05 11:17:36 -06001698 del_usage_links(mod);
Matt Domschc988d2b2005-06-23 22:05:15 -07001699 module_remove_modinfo_attrs(mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 module_param_sysfs_remove(mod);
Greg Kroah-Hartman78a2d902007-12-20 08:13:05 -08001701 kobject_put(mod->mkobj.drivers_dir);
1702 kobject_put(mod->holders_dir);
Denis V. Lunev34e4e2f2008-05-20 13:59:48 +04001703 mod_sysfs_fini(mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704}
1705
1706/*
1707 * unlink the module with the whole machine is stopped with interrupts off
1708 * - this defends against kallsyms not taking locks
1709 */
1710static int __unlink_module(void *_mod)
1711{
1712 struct module *mod = _mod;
1713 list_del(&mod->list);
Linus Torvalds53363772010-10-05 11:29:27 -07001714 module_bug_cleanup(mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 return 0;
1716}
1717
matthieu castet84e1c6b2010-11-16 22:35:16 +01001718#ifdef CONFIG_DEBUG_SET_MODULE_RONX
1719/*
1720 * LKM RO/NX protection: protect module's text/ro-data
1721 * from modification and any data from execution.
1722 */
1723void set_page_attributes(void *start, void *end, int (*set)(unsigned long start, int num_pages))
1724{
1725 unsigned long begin_pfn = PFN_DOWN((unsigned long)start);
1726 unsigned long end_pfn = PFN_DOWN((unsigned long)end);
1727
1728 if (end_pfn > begin_pfn)
1729 set(begin_pfn << PAGE_SHIFT, end_pfn - begin_pfn);
1730}
1731
1732static void set_section_ro_nx(void *base,
1733 unsigned long text_size,
1734 unsigned long ro_size,
1735 unsigned long total_size)
1736{
1737 /* begin and end PFNs of the current subsection */
1738 unsigned long begin_pfn;
1739 unsigned long end_pfn;
1740
1741 /*
1742 * Set RO for module text and RO-data:
1743 * - Always protect first page.
1744 * - Do not protect last partial page.
1745 */
1746 if (ro_size > 0)
1747 set_page_attributes(base, base + ro_size, set_memory_ro);
1748
1749 /*
1750 * Set NX permissions for module data:
1751 * - Do not protect first partial page.
1752 * - Always protect last page.
1753 */
1754 if (total_size > text_size) {
1755 begin_pfn = PFN_UP((unsigned long)base + text_size);
1756 end_pfn = PFN_UP((unsigned long)base + total_size);
1757 if (end_pfn > begin_pfn)
1758 set_memory_nx(begin_pfn << PAGE_SHIFT, end_pfn - begin_pfn);
1759 }
1760}
1761
Jan Glauber01526ed2011-05-19 16:55:26 -06001762static void unset_module_core_ro_nx(struct module *mod)
matthieu castet84e1c6b2010-11-16 22:35:16 +01001763{
Jan Glauber01526ed2011-05-19 16:55:26 -06001764 set_page_attributes(mod->module_core + mod->core_text_size,
1765 mod->module_core + mod->core_size,
1766 set_memory_x);
1767 set_page_attributes(mod->module_core,
1768 mod->module_core + mod->core_ro_size,
1769 set_memory_rw);
1770}
1771
1772static void unset_module_init_ro_nx(struct module *mod)
1773{
1774 set_page_attributes(mod->module_init + mod->init_text_size,
1775 mod->module_init + mod->init_size,
1776 set_memory_x);
1777 set_page_attributes(mod->module_init,
1778 mod->module_init + mod->init_ro_size,
1779 set_memory_rw);
matthieu castet84e1c6b2010-11-16 22:35:16 +01001780}
1781
1782/* Iterate through all modules and set each module's text as RW */
Daniel J Blueman5d05c702011-03-08 22:01:47 +08001783void set_all_modules_text_rw(void)
matthieu castet84e1c6b2010-11-16 22:35:16 +01001784{
1785 struct module *mod;
1786
1787 mutex_lock(&module_mutex);
1788 list_for_each_entry_rcu(mod, &modules, list) {
1789 if ((mod->module_core) && (mod->core_text_size)) {
1790 set_page_attributes(mod->module_core,
1791 mod->module_core + mod->core_text_size,
1792 set_memory_rw);
1793 }
1794 if ((mod->module_init) && (mod->init_text_size)) {
1795 set_page_attributes(mod->module_init,
1796 mod->module_init + mod->init_text_size,
1797 set_memory_rw);
1798 }
1799 }
1800 mutex_unlock(&module_mutex);
1801}
1802
1803/* Iterate through all modules and set each module's text as RO */
Daniel J Blueman5d05c702011-03-08 22:01:47 +08001804void set_all_modules_text_ro(void)
matthieu castet84e1c6b2010-11-16 22:35:16 +01001805{
1806 struct module *mod;
1807
1808 mutex_lock(&module_mutex);
1809 list_for_each_entry_rcu(mod, &modules, list) {
1810 if ((mod->module_core) && (mod->core_text_size)) {
1811 set_page_attributes(mod->module_core,
1812 mod->module_core + mod->core_text_size,
1813 set_memory_ro);
1814 }
1815 if ((mod->module_init) && (mod->init_text_size)) {
1816 set_page_attributes(mod->module_init,
1817 mod->module_init + mod->init_text_size,
1818 set_memory_ro);
1819 }
1820 }
1821 mutex_unlock(&module_mutex);
1822}
1823#else
1824static inline void set_section_ro_nx(void *base, unsigned long text_size, unsigned long ro_size, unsigned long total_size) { }
Jan Glauber01526ed2011-05-19 16:55:26 -06001825static void unset_module_core_ro_nx(struct module *mod) { }
1826static void unset_module_init_ro_nx(struct module *mod) { }
matthieu castet84e1c6b2010-11-16 22:35:16 +01001827#endif
1828
Jonas Bonn74e08fc2011-06-30 21:22:11 +02001829void __weak module_free(struct module *mod, void *module_region)
1830{
1831 vfree(module_region);
1832}
1833
1834void __weak module_arch_cleanup(struct module *mod)
1835{
1836}
1837
Rusty Russell75676502010-06-05 11:17:36 -06001838/* Free a module, remove from lists, etc. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839static void free_module(struct module *mod)
1840{
Li Zefan7ead8b82009-08-17 16:56:28 +08001841 trace_module_free(mod);
1842
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 /* Delete from various lists */
Rusty Russell75676502010-06-05 11:17:36 -06001844 mutex_lock(&module_mutex);
Rusty Russell9b1a4d32008-07-28 12:16:30 -05001845 stop_machine(__unlink_module, mod, NULL);
Rusty Russell75676502010-06-05 11:17:36 -06001846 mutex_unlock(&module_mutex);
Rusty Russell36b03602010-08-05 12:59:09 -06001847 mod_sysfs_teardown(mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848
Jason Baronb82bab4b2010-07-27 13:18:01 -07001849 /* Remove dynamic debug info */
1850 ddebug_remove_module(mod->name);
1851
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 /* Arch-specific cleanup. */
1853 module_arch_cleanup(mod);
1854
1855 /* Module unload stuff */
1856 module_unload_free(mod);
1857
Rusty Russelle180a6b2009-03-31 13:05:29 -06001858 /* Free any allocated parameters. */
1859 destroy_params(mod->kp, mod->num_kp);
1860
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 /* This may be NULL, but that's OK */
Jan Glauber01526ed2011-05-19 16:55:26 -06001862 unset_module_init_ro_nx(mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 module_free(mod, mod->module_init);
1864 kfree(mod->args);
Tejun Heo259354d2010-03-10 18:56:10 +09001865 percpu_modfree(mod);
Rusty Russell9f85a4b2010-08-05 12:59:04 -06001866
Ingo Molnarfbb9ce952006-07-03 00:24:50 -07001867 /* Free lock-classes: */
1868 lockdep_free_key_range(mod->module_core, mod->core_size);
1869
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 /* Finally, free the core (containing the module structure) */
Jan Glauber01526ed2011-05-19 16:55:26 -06001871 unset_module_core_ro_nx(mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 module_free(mod, mod->module_core);
Bernd Schmidteb8cdec2009-09-21 17:03:57 -07001873
1874#ifdef CONFIG_MPU
1875 update_protections(current->mm);
1876#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877}
1878
1879void *__symbol_get(const char *symbol)
1880{
1881 struct module *owner;
Tim Abbott414fd312008-12-05 19:03:56 -05001882 const struct kernel_symbol *sym;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883
Rusty Russell24da1cb2007-07-15 23:41:46 -07001884 preempt_disable();
Tim Abbott414fd312008-12-05 19:03:56 -05001885 sym = find_symbol(symbol, &owner, NULL, true, true);
1886 if (sym && strong_try_module_get(owner))
1887 sym = NULL;
Rusty Russell24da1cb2007-07-15 23:41:46 -07001888 preempt_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889
Tim Abbott414fd312008-12-05 19:03:56 -05001890 return sym ? (void *)sym->value : NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891}
1892EXPORT_SYMBOL_GPL(__symbol_get);
1893
Ashutosh Naikeea8b542006-01-08 01:04:25 -08001894/*
1895 * Ensure that an exported symbol [global namespace] does not already exist
Robert P. J. Day02a3e592007-05-09 07:26:28 +02001896 * in the kernel or in some other module's exported symbol table.
Rusty Russellbe593f42010-06-05 11:17:37 -06001897 *
1898 * You must hold the module_mutex.
Ashutosh Naikeea8b542006-01-08 01:04:25 -08001899 */
1900static int verify_export_symbols(struct module *mod)
1901{
Rusty Russellb2111042008-05-01 21:15:00 -05001902 unsigned int i;
Ashutosh Naikeea8b542006-01-08 01:04:25 -08001903 struct module *owner;
Rusty Russellb2111042008-05-01 21:15:00 -05001904 const struct kernel_symbol *s;
1905 struct {
1906 const struct kernel_symbol *sym;
1907 unsigned int num;
1908 } arr[] = {
1909 { mod->syms, mod->num_syms },
1910 { mod->gpl_syms, mod->num_gpl_syms },
1911 { mod->gpl_future_syms, mod->num_gpl_future_syms },
Denys Vlasenkof7f5b672008-07-22 19:24:26 -05001912#ifdef CONFIG_UNUSED_SYMBOLS
Rusty Russellb2111042008-05-01 21:15:00 -05001913 { mod->unused_syms, mod->num_unused_syms },
1914 { mod->unused_gpl_syms, mod->num_unused_gpl_syms },
Denys Vlasenkof7f5b672008-07-22 19:24:26 -05001915#endif
Rusty Russellb2111042008-05-01 21:15:00 -05001916 };
Ashutosh Naikeea8b542006-01-08 01:04:25 -08001917
Rusty Russellb2111042008-05-01 21:15:00 -05001918 for (i = 0; i < ARRAY_SIZE(arr); i++) {
1919 for (s = arr[i].sym; s < arr[i].sym + arr[i].num; s++) {
Rusty Russellbe593f42010-06-05 11:17:37 -06001920 if (find_symbol(s->name, &owner, NULL, true, false)) {
Rusty Russellb2111042008-05-01 21:15:00 -05001921 printk(KERN_ERR
1922 "%s: exports duplicate symbol %s"
1923 " (owned by %s)\n",
1924 mod->name, s->name, module_name(owner));
1925 return -ENOEXEC;
1926 }
Ashutosh Naikeea8b542006-01-08 01:04:25 -08001927 }
Rusty Russellb2111042008-05-01 21:15:00 -05001928 }
1929 return 0;
Ashutosh Naikeea8b542006-01-08 01:04:25 -08001930}
1931
Matti Linnanvuori9a4b9702007-11-08 08:37:38 -08001932/* Change all symbols so that st_value encodes the pointer directly. */
Rusty Russell49668682010-08-05 12:59:10 -06001933static int simplify_symbols(struct module *mod, const struct load_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934{
Rusty Russell49668682010-08-05 12:59:10 -06001935 Elf_Shdr *symsec = &info->sechdrs[info->index.sym];
1936 Elf_Sym *sym = (void *)symsec->sh_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 unsigned long secbase;
Rusty Russell49668682010-08-05 12:59:10 -06001938 unsigned int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 int ret = 0;
Tim Abbott414fd312008-12-05 19:03:56 -05001940 const struct kernel_symbol *ksym;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941
Rusty Russell49668682010-08-05 12:59:10 -06001942 for (i = 1; i < symsec->sh_size / sizeof(Elf_Sym); i++) {
1943 const char *name = info->strtab + sym[i].st_name;
1944
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 switch (sym[i].st_shndx) {
1946 case SHN_COMMON:
1947 /* We compiled with -fno-common. These are not
1948 supposed to happen. */
Jim Cromie5e124162011-12-06 12:11:31 -07001949 pr_debug("Common symbol: %s\n", name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 printk("%s: please compile with -fno-common\n",
1951 mod->name);
1952 ret = -ENOEXEC;
1953 break;
1954
1955 case SHN_ABS:
1956 /* Don't need to do anything */
Jim Cromie5e124162011-12-06 12:11:31 -07001957 pr_debug("Absolute symbol: 0x%08lx\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 (long)sym[i].st_value);
1959 break;
1960
1961 case SHN_UNDEF:
Rusty Russell49668682010-08-05 12:59:10 -06001962 ksym = resolve_symbol_wait(mod, info, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 /* Ok if resolved. */
Rusty Russell9bea7f22010-06-05 11:17:37 -06001964 if (ksym && !IS_ERR(ksym)) {
Tim Abbott414fd312008-12-05 19:03:56 -05001965 sym[i].st_value = ksym->value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966 break;
Tim Abbott414fd312008-12-05 19:03:56 -05001967 }
1968
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 /* Ok if weak. */
Rusty Russell9bea7f22010-06-05 11:17:37 -06001970 if (!ksym && ELF_ST_BIND(sym[i].st_info) == STB_WEAK)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 break;
1972
Rusty Russell9bea7f22010-06-05 11:17:37 -06001973 printk(KERN_WARNING "%s: Unknown symbol %s (err %li)\n",
Rusty Russell49668682010-08-05 12:59:10 -06001974 mod->name, name, PTR_ERR(ksym));
Rusty Russell9bea7f22010-06-05 11:17:37 -06001975 ret = PTR_ERR(ksym) ?: -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 break;
1977
1978 default:
1979 /* Divert to percpu allocation if a percpu var. */
Rusty Russell49668682010-08-05 12:59:10 -06001980 if (sym[i].st_shndx == info->index.pcpu)
Tejun Heo259354d2010-03-10 18:56:10 +09001981 secbase = (unsigned long)mod_percpu(mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 else
Rusty Russell49668682010-08-05 12:59:10 -06001983 secbase = info->sechdrs[sym[i].st_shndx].sh_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 sym[i].st_value += secbase;
1985 break;
1986 }
1987 }
1988
1989 return ret;
1990}
1991
Rusty Russell49668682010-08-05 12:59:10 -06001992static int apply_relocations(struct module *mod, const struct load_info *info)
Rusty Russell22e268e2010-08-05 12:59:05 -06001993{
1994 unsigned int i;
1995 int err = 0;
1996
1997 /* Now do relocations. */
Rusty Russell49668682010-08-05 12:59:10 -06001998 for (i = 1; i < info->hdr->e_shnum; i++) {
1999 unsigned int infosec = info->sechdrs[i].sh_info;
Rusty Russell22e268e2010-08-05 12:59:05 -06002000
2001 /* Not a valid relocation section? */
Rusty Russell49668682010-08-05 12:59:10 -06002002 if (infosec >= info->hdr->e_shnum)
Rusty Russell22e268e2010-08-05 12:59:05 -06002003 continue;
2004
2005 /* Don't bother with non-allocated sections */
Rusty Russell49668682010-08-05 12:59:10 -06002006 if (!(info->sechdrs[infosec].sh_flags & SHF_ALLOC))
Rusty Russell22e268e2010-08-05 12:59:05 -06002007 continue;
2008
Rusty Russell49668682010-08-05 12:59:10 -06002009 if (info->sechdrs[i].sh_type == SHT_REL)
2010 err = apply_relocate(info->sechdrs, info->strtab,
2011 info->index.sym, i, mod);
2012 else if (info->sechdrs[i].sh_type == SHT_RELA)
2013 err = apply_relocate_add(info->sechdrs, info->strtab,
2014 info->index.sym, i, mod);
Rusty Russell22e268e2010-08-05 12:59:05 -06002015 if (err < 0)
2016 break;
2017 }
2018 return err;
2019}
2020
Helge Deller088af9a2008-12-31 12:31:18 +01002021/* Additional bytes needed by arch in front of individual sections */
2022unsigned int __weak arch_mod_section_prepend(struct module *mod,
2023 unsigned int section)
2024{
2025 /* default implementation just returns zero */
2026 return 0;
2027}
2028
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029/* Update size with this section: return offset. */
Helge Deller088af9a2008-12-31 12:31:18 +01002030static long get_offset(struct module *mod, unsigned int *size,
2031 Elf_Shdr *sechdr, unsigned int section)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032{
2033 long ret;
2034
Helge Deller088af9a2008-12-31 12:31:18 +01002035 *size += arch_mod_section_prepend(mod, section);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 ret = ALIGN(*size, sechdr->sh_addralign ?: 1);
2037 *size = ret + sechdr->sh_size;
2038 return ret;
2039}
2040
2041/* Lay out the SHF_ALLOC sections in a way not dissimilar to how ld
2042 might -- code, read-only data, read-write data, small data. Tally
2043 sizes, and place the offsets into sh_entsize fields: high bit means it
2044 belongs in init. */
Rusty Russell49668682010-08-05 12:59:10 -06002045static void layout_sections(struct module *mod, struct load_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046{
2047 static unsigned long const masks[][2] = {
2048 /* NOTE: all executable code must be the first section
2049 * in this array; otherwise modify the text_size
2050 * finder in the two loops below */
2051 { SHF_EXECINSTR | SHF_ALLOC, ARCH_SHF_SMALL },
2052 { SHF_ALLOC, SHF_WRITE | ARCH_SHF_SMALL },
2053 { SHF_WRITE | SHF_ALLOC, ARCH_SHF_SMALL },
2054 { ARCH_SHF_SMALL | SHF_ALLOC, 0 }
2055 };
2056 unsigned int m, i;
2057
Rusty Russell49668682010-08-05 12:59:10 -06002058 for (i = 0; i < info->hdr->e_shnum; i++)
2059 info->sechdrs[i].sh_entsize = ~0UL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060
Jim Cromie5e124162011-12-06 12:11:31 -07002061 pr_debug("Core section allocation order:\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 for (m = 0; m < ARRAY_SIZE(masks); ++m) {
Rusty Russell49668682010-08-05 12:59:10 -06002063 for (i = 0; i < info->hdr->e_shnum; ++i) {
2064 Elf_Shdr *s = &info->sechdrs[i];
2065 const char *sname = info->secstrings + s->sh_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
2067 if ((s->sh_flags & masks[m][0]) != masks[m][0]
2068 || (s->sh_flags & masks[m][1])
2069 || s->sh_entsize != ~0UL
Rusty Russell49668682010-08-05 12:59:10 -06002070 || strstarts(sname, ".init"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 continue;
Helge Deller088af9a2008-12-31 12:31:18 +01002072 s->sh_entsize = get_offset(mod, &mod->core_size, s, i);
Jim Cromie5e124162011-12-06 12:11:31 -07002073 pr_debug("\t%s\n", sname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 }
matthieu castet84e1c6b2010-11-16 22:35:16 +01002075 switch (m) {
2076 case 0: /* executable */
2077 mod->core_size = debug_align(mod->core_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 mod->core_text_size = mod->core_size;
matthieu castet84e1c6b2010-11-16 22:35:16 +01002079 break;
2080 case 1: /* RO: text and ro-data */
2081 mod->core_size = debug_align(mod->core_size);
2082 mod->core_ro_size = mod->core_size;
2083 break;
2084 case 3: /* whole core */
2085 mod->core_size = debug_align(mod->core_size);
2086 break;
2087 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 }
2089
Jim Cromie5e124162011-12-06 12:11:31 -07002090 pr_debug("Init section allocation order:\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 for (m = 0; m < ARRAY_SIZE(masks); ++m) {
Rusty Russell49668682010-08-05 12:59:10 -06002092 for (i = 0; i < info->hdr->e_shnum; ++i) {
2093 Elf_Shdr *s = &info->sechdrs[i];
2094 const char *sname = info->secstrings + s->sh_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095
2096 if ((s->sh_flags & masks[m][0]) != masks[m][0]
2097 || (s->sh_flags & masks[m][1])
2098 || s->sh_entsize != ~0UL
Rusty Russell49668682010-08-05 12:59:10 -06002099 || !strstarts(sname, ".init"))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 continue;
Helge Deller088af9a2008-12-31 12:31:18 +01002101 s->sh_entsize = (get_offset(mod, &mod->init_size, s, i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102 | INIT_OFFSET_MASK);
Jim Cromie5e124162011-12-06 12:11:31 -07002103 pr_debug("\t%s\n", sname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 }
matthieu castet84e1c6b2010-11-16 22:35:16 +01002105 switch (m) {
2106 case 0: /* executable */
2107 mod->init_size = debug_align(mod->init_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 mod->init_text_size = mod->init_size;
matthieu castet84e1c6b2010-11-16 22:35:16 +01002109 break;
2110 case 1: /* RO: text and ro-data */
2111 mod->init_size = debug_align(mod->init_size);
2112 mod->init_ro_size = mod->init_size;
2113 break;
2114 case 3: /* whole init */
2115 mod->init_size = debug_align(mod->init_size);
2116 break;
2117 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 }
2119}
2120
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121static void set_license(struct module *mod, const char *license)
2122{
2123 if (!license)
2124 license = "unspecified";
2125
Florin Malitafa3ba2e82006-10-11 01:21:48 -07002126 if (!license_is_gpl_compatible(license)) {
Andi Kleen25ddbb12008-10-15 22:01:41 -07002127 if (!test_taint(TAINT_PROPRIETARY_MODULE))
Jan Dittmer1d4d2622006-10-28 10:38:38 -07002128 printk(KERN_WARNING "%s: module license '%s' taints "
Florin Malitafa3ba2e82006-10-11 01:21:48 -07002129 "kernel.\n", mod->name, license);
2130 add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 }
2132}
2133
2134/* Parse tag=value strings from .modinfo section */
2135static char *next_string(char *string, unsigned long *secsize)
2136{
2137 /* Skip non-zero chars */
2138 while (string[0]) {
2139 string++;
2140 if ((*secsize)-- <= 1)
2141 return NULL;
2142 }
2143
2144 /* Skip any zero padding. */
2145 while (!string[0]) {
2146 string++;
2147 if ((*secsize)-- <= 1)
2148 return NULL;
2149 }
2150 return string;
2151}
2152
Rusty Russell49668682010-08-05 12:59:10 -06002153static char *get_modinfo(struct load_info *info, const char *tag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154{
2155 char *p;
2156 unsigned int taglen = strlen(tag);
Rusty Russell49668682010-08-05 12:59:10 -06002157 Elf_Shdr *infosec = &info->sechdrs[info->index.info];
2158 unsigned long size = infosec->sh_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159
Rusty Russell49668682010-08-05 12:59:10 -06002160 for (p = (char *)infosec->sh_addr; p; p = next_string(p, &size)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
2162 return p + taglen + 1;
2163 }
2164 return NULL;
2165}
2166
Rusty Russell49668682010-08-05 12:59:10 -06002167static void setup_modinfo(struct module *mod, struct load_info *info)
Matt Domschc988d2b2005-06-23 22:05:15 -07002168{
2169 struct module_attribute *attr;
2170 int i;
2171
2172 for (i = 0; (attr = modinfo_attrs[i]); i++) {
2173 if (attr->setup)
Rusty Russell49668682010-08-05 12:59:10 -06002174 attr->setup(mod, get_modinfo(info, attr->attr.name));
Matt Domschc988d2b2005-06-23 22:05:15 -07002175 }
2176}
Matt Domschc988d2b2005-06-23 22:05:15 -07002177
Rusty Russella263f772009-09-25 00:32:58 -06002178static void free_modinfo(struct module *mod)
2179{
2180 struct module_attribute *attr;
2181 int i;
2182
2183 for (i = 0; (attr = modinfo_attrs[i]); i++) {
2184 if (attr->free)
2185 attr->free(mod);
2186 }
2187}
2188
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189#ifdef CONFIG_KALLSYMS
WANG Cong15bba372008-07-24 15:41:48 +01002190
2191/* lookup symbol in given range of kernel_symbols */
2192static const struct kernel_symbol *lookup_symbol(const char *name,
2193 const struct kernel_symbol *start,
2194 const struct kernel_symbol *stop)
2195{
Alessio Igor Bogani9d634872011-05-18 22:35:59 +02002196 return bsearch(name, start, stop - start,
2197 sizeof(struct kernel_symbol), cmp_name);
WANG Cong15bba372008-07-24 15:41:48 +01002198}
2199
Tim Abbottca4787b2009-01-05 08:40:10 -06002200static int is_exported(const char *name, unsigned long value,
2201 const struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202{
Tim Abbottca4787b2009-01-05 08:40:10 -06002203 const struct kernel_symbol *ks;
2204 if (!mod)
2205 ks = lookup_symbol(name, __start___ksymtab, __stop___ksymtab);
Sam Ravnborg3fd68052006-02-08 21:16:45 +01002206 else
Tim Abbottca4787b2009-01-05 08:40:10 -06002207 ks = lookup_symbol(name, mod->syms, mod->syms + mod->num_syms);
2208 return ks != NULL && ks->value == value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209}
2210
2211/* As per nm */
Rusty Russelleded41c2010-08-05 12:59:07 -06002212static char elf_type(const Elf_Sym *sym, const struct load_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002213{
Rusty Russelleded41c2010-08-05 12:59:07 -06002214 const Elf_Shdr *sechdrs = info->sechdrs;
2215
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216 if (ELF_ST_BIND(sym->st_info) == STB_WEAK) {
2217 if (ELF_ST_TYPE(sym->st_info) == STT_OBJECT)
2218 return 'v';
2219 else
2220 return 'w';
2221 }
2222 if (sym->st_shndx == SHN_UNDEF)
2223 return 'U';
2224 if (sym->st_shndx == SHN_ABS)
2225 return 'a';
2226 if (sym->st_shndx >= SHN_LORESERVE)
2227 return '?';
2228 if (sechdrs[sym->st_shndx].sh_flags & SHF_EXECINSTR)
2229 return 't';
2230 if (sechdrs[sym->st_shndx].sh_flags & SHF_ALLOC
2231 && sechdrs[sym->st_shndx].sh_type != SHT_NOBITS) {
2232 if (!(sechdrs[sym->st_shndx].sh_flags & SHF_WRITE))
2233 return 'r';
2234 else if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
2235 return 'g';
2236 else
2237 return 'd';
2238 }
2239 if (sechdrs[sym->st_shndx].sh_type == SHT_NOBITS) {
2240 if (sechdrs[sym->st_shndx].sh_flags & ARCH_SHF_SMALL)
2241 return 's';
2242 else
2243 return 'b';
2244 }
Rusty Russelleded41c2010-08-05 12:59:07 -06002245 if (strstarts(info->secstrings + sechdrs[sym->st_shndx].sh_name,
2246 ".debug")) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 return 'n';
Rusty Russelleded41c2010-08-05 12:59:07 -06002248 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249 return '?';
2250}
2251
Jan Beulich4a496222009-07-06 14:50:42 +01002252static bool is_core_symbol(const Elf_Sym *src, const Elf_Shdr *sechdrs,
2253 unsigned int shnum)
2254{
2255 const Elf_Shdr *sec;
2256
2257 if (src->st_shndx == SHN_UNDEF
2258 || src->st_shndx >= shnum
2259 || !src->st_name)
2260 return false;
2261
2262 sec = sechdrs + src->st_shndx;
2263 if (!(sec->sh_flags & SHF_ALLOC)
2264#ifndef CONFIG_KALLSYMS_ALL
2265 || !(sec->sh_flags & SHF_EXECINSTR)
2266#endif
2267 || (sec->sh_entsize & INIT_OFFSET_MASK))
2268 return false;
2269
2270 return true;
2271}
2272
Kevin Cernekee48fd1182012-01-13 09:32:14 +10302273/*
2274 * We only allocate and copy the strings needed by the parts of symtab
2275 * we keep. This is simple, but has the effect of making multiple
2276 * copies of duplicates. We could be more sophisticated, see
2277 * linux-kernel thread starting with
2278 * <73defb5e4bca04a6431392cc341112b1@localhost>.
2279 */
Rusty Russell49668682010-08-05 12:59:10 -06002280static void layout_symtab(struct module *mod, struct load_info *info)
Jan Beulich4a496222009-07-06 14:50:42 +01002281{
Rusty Russell49668682010-08-05 12:59:10 -06002282 Elf_Shdr *symsect = info->sechdrs + info->index.sym;
2283 Elf_Shdr *strsect = info->sechdrs + info->index.str;
Jan Beulich4a496222009-07-06 14:50:42 +01002284 const Elf_Sym *src;
Satoru Takeuchi54523ec2012-12-05 12:29:04 +10302285 unsigned int i, nsrc, ndst, strtab_size = 0;
Jan Beulich4a496222009-07-06 14:50:42 +01002286
2287 /* Put symbol section at end of init part of module. */
2288 symsect->sh_flags |= SHF_ALLOC;
2289 symsect->sh_entsize = get_offset(mod, &mod->init_size, symsect,
Rusty Russell49668682010-08-05 12:59:10 -06002290 info->index.sym) | INIT_OFFSET_MASK;
Jim Cromie5e124162011-12-06 12:11:31 -07002291 pr_debug("\t%s\n", info->secstrings + symsect->sh_name);
Jan Beulich4a496222009-07-06 14:50:42 +01002292
Rusty Russell49668682010-08-05 12:59:10 -06002293 src = (void *)info->hdr + symsect->sh_offset;
Jan Beulich4a496222009-07-06 14:50:42 +01002294 nsrc = symsect->sh_size / sizeof(*src);
Kevin Cernekee70b1e9162011-11-12 19:08:55 -08002295
Kevin Cernekee48fd1182012-01-13 09:32:14 +10302296 /* Compute total space required for the core symbols' strtab. */
Rusty Russell59ef28b2012-10-25 10:49:25 +10302297 for (ndst = i = 0; i < nsrc; i++) {
2298 if (i == 0 ||
2299 is_core_symbol(src+i, info->sechdrs, info->hdr->e_shnum)) {
2300 strtab_size += strlen(&info->strtab[src[i].st_name])+1;
Kevin Cernekee48fd1182012-01-13 09:32:14 +10302301 ndst++;
Jan Beulich554bdfe2009-07-06 14:51:44 +01002302 }
Rusty Russell59ef28b2012-10-25 10:49:25 +10302303 }
Jan Beulich4a496222009-07-06 14:50:42 +01002304
2305 /* Append room for core symbols at end of core part. */
Rusty Russell49668682010-08-05 12:59:10 -06002306 info->symoffs = ALIGN(mod->core_size, symsect->sh_addralign ?: 1);
Kevin Cernekee48fd1182012-01-13 09:32:14 +10302307 info->stroffs = mod->core_size = info->symoffs + ndst * sizeof(Elf_Sym);
2308 mod->core_size += strtab_size;
Jan Beulich4a496222009-07-06 14:50:42 +01002309
Jan Beulich554bdfe2009-07-06 14:51:44 +01002310 /* Put string table section at end of init part of module. */
2311 strsect->sh_flags |= SHF_ALLOC;
2312 strsect->sh_entsize = get_offset(mod, &mod->init_size, strsect,
Rusty Russell49668682010-08-05 12:59:10 -06002313 info->index.str) | INIT_OFFSET_MASK;
Jim Cromie5e124162011-12-06 12:11:31 -07002314 pr_debug("\t%s\n", info->secstrings + strsect->sh_name);
Jan Beulich4a496222009-07-06 14:50:42 +01002315}
2316
Rusty Russell811d66a2010-08-05 12:59:12 -06002317static void add_kallsyms(struct module *mod, const struct load_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318{
Jan Beulich4a496222009-07-06 14:50:42 +01002319 unsigned int i, ndst;
2320 const Elf_Sym *src;
2321 Elf_Sym *dst;
Jan Beulich554bdfe2009-07-06 14:51:44 +01002322 char *s;
Rusty Russelleded41c2010-08-05 12:59:07 -06002323 Elf_Shdr *symsec = &info->sechdrs[info->index.sym];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002324
Rusty Russelleded41c2010-08-05 12:59:07 -06002325 mod->symtab = (void *)symsec->sh_addr;
2326 mod->num_symtab = symsec->sh_size / sizeof(Elf_Sym);
Rusty Russell511ca6a2010-08-05 12:59:08 -06002327 /* Make sure we get permanent strtab: don't use info->strtab. */
2328 mod->strtab = (void *)info->sechdrs[info->index.str].sh_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329
2330 /* Set types up while we still have access to sections. */
2331 for (i = 0; i < mod->num_symtab; i++)
Rusty Russelleded41c2010-08-05 12:59:07 -06002332 mod->symtab[i].st_info = elf_type(&mod->symtab[i], info);
Jan Beulich4a496222009-07-06 14:50:42 +01002333
Rusty Russelld9131882010-08-05 12:59:08 -06002334 mod->core_symtab = dst = mod->module_core + info->symoffs;
Kevin Cernekee48fd1182012-01-13 09:32:14 +10302335 mod->core_strtab = s = mod->module_core + info->stroffs;
Jan Beulich4a496222009-07-06 14:50:42 +01002336 src = mod->symtab;
Rusty Russell59ef28b2012-10-25 10:49:25 +10302337 for (ndst = i = 0; i < mod->num_symtab; i++) {
2338 if (i == 0 ||
2339 is_core_symbol(src+i, info->sechdrs, info->hdr->e_shnum)) {
2340 dst[ndst] = src[i];
2341 dst[ndst++].st_name = s - mod->core_strtab;
2342 s += strlcpy(s, &mod->strtab[src[i].st_name],
2343 KSYM_NAME_LEN) + 1;
2344 }
Jan Beulich4a496222009-07-06 14:50:42 +01002345 }
2346 mod->core_num_syms = ndst;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347}
2348#else
Rusty Russell49668682010-08-05 12:59:10 -06002349static inline void layout_symtab(struct module *mod, struct load_info *info)
Jan Beulich4a496222009-07-06 14:50:42 +01002350{
2351}
Paul Mundt3ae91c22009-10-01 15:43:54 -07002352
Michał Mirosławabbce902010-09-20 01:58:08 +02002353static void add_kallsyms(struct module *mod, const struct load_info *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354{
2355}
2356#endif /* CONFIG_KALLSYMS */
2357
Jason Barone9d376f2009-02-05 11:51:38 -05002358static void dynamic_debug_setup(struct _ddebug *debug, unsigned int num)
Rusty Russell5e458cc2008-10-22 10:00:13 -05002359{
Rusty Russell811d66a2010-08-05 12:59:12 -06002360 if (!debug)
2361 return;
Jason Barone9d376f2009-02-05 11:51:38 -05002362#ifdef CONFIG_DYNAMIC_DEBUG
2363 if (ddebug_add_module(debug, num, debug->modname))
2364 printk(KERN_ERR "dynamic debug error adding module: %s\n",
2365 debug->modname);
2366#endif
Rusty Russell5e458cc2008-10-22 10:00:13 -05002367}
Jason Baron346e15b2008-08-12 16:46:19 -04002368
Yehuda Sadehff49d742010-07-03 13:07:35 +10002369static void dynamic_debug_remove(struct _ddebug *debug)
2370{
2371 if (debug)
2372 ddebug_remove_module(debug->modname);
2373}
2374
Jonas Bonn74e08fc2011-06-30 21:22:11 +02002375void * __weak module_alloc(unsigned long size)
2376{
Rusty Russell82fab442012-12-11 09:38:33 +10302377 return vmalloc_exec(size);
Jonas Bonn74e08fc2011-06-30 21:22:11 +02002378}
2379
Rusty Russell3a642e92008-07-22 19:24:28 -05002380static void *module_alloc_update_bounds(unsigned long size)
2381{
2382 void *ret = module_alloc(size);
2383
2384 if (ret) {
Rusty Russell75676502010-06-05 11:17:36 -06002385 mutex_lock(&module_mutex);
Rusty Russell3a642e92008-07-22 19:24:28 -05002386 /* Update module bounds. */
2387 if ((unsigned long)ret < module_addr_min)
2388 module_addr_min = (unsigned long)ret;
2389 if ((unsigned long)ret + size > module_addr_max)
2390 module_addr_max = (unsigned long)ret + size;
Rusty Russell75676502010-06-05 11:17:36 -06002391 mutex_unlock(&module_mutex);
Rusty Russell3a642e92008-07-22 19:24:28 -05002392 }
2393 return ret;
2394}
2395
Catalin Marinas4f2294b2009-06-11 13:23:20 +01002396#ifdef CONFIG_DEBUG_KMEMLEAK
Rusty Russell49668682010-08-05 12:59:10 -06002397static void kmemleak_load_module(const struct module *mod,
2398 const struct load_info *info)
Catalin Marinas4f2294b2009-06-11 13:23:20 +01002399{
2400 unsigned int i;
2401
2402 /* only scan the sections containing data */
Catalin Marinasc017b4b2009-10-28 13:33:09 +00002403 kmemleak_scan_area(mod, sizeof(struct module), GFP_KERNEL);
Catalin Marinas4f2294b2009-06-11 13:23:20 +01002404
Rusty Russell49668682010-08-05 12:59:10 -06002405 for (i = 1; i < info->hdr->e_shnum; i++) {
2406 const char *name = info->secstrings + info->sechdrs[i].sh_name;
2407 if (!(info->sechdrs[i].sh_flags & SHF_ALLOC))
Catalin Marinas4f2294b2009-06-11 13:23:20 +01002408 continue;
Rusty Russell49668682010-08-05 12:59:10 -06002409 if (!strstarts(name, ".data") && !strstarts(name, ".bss"))
Catalin Marinas4f2294b2009-06-11 13:23:20 +01002410 continue;
2411
Rusty Russell49668682010-08-05 12:59:10 -06002412 kmemleak_scan_area((void *)info->sechdrs[i].sh_addr,
2413 info->sechdrs[i].sh_size, GFP_KERNEL);
Catalin Marinas4f2294b2009-06-11 13:23:20 +01002414 }
2415}
2416#else
Rusty Russell49668682010-08-05 12:59:10 -06002417static inline void kmemleak_load_module(const struct module *mod,
2418 const struct load_info *info)
Catalin Marinas4f2294b2009-06-11 13:23:20 +01002419{
2420}
2421#endif
2422
Rusty Russell106a4ee2012-09-26 10:09:40 +01002423#ifdef CONFIG_MODULE_SIG
Kees Cook34e11692012-10-16 07:31:07 +10302424static int module_sig_check(struct load_info *info)
Rusty Russell106a4ee2012-09-26 10:09:40 +01002425{
2426 int err = -ENOKEY;
Kees Cook34e11692012-10-16 07:31:07 +10302427 const unsigned long markerlen = sizeof(MODULE_SIG_STRING) - 1;
2428 const void *mod = info->hdr;
Rusty Russell106a4ee2012-09-26 10:09:40 +01002429
Kees Cook34e11692012-10-16 07:31:07 +10302430 if (info->len > markerlen &&
2431 memcmp(mod + info->len - markerlen, MODULE_SIG_STRING, markerlen) == 0) {
David Howellscaabe242012-10-20 01:19:29 +01002432 /* We truncate the module to discard the signature */
Kees Cook34e11692012-10-16 07:31:07 +10302433 info->len -= markerlen;
2434 err = mod_verify_sig(mod, &info->len);
Rusty Russell106a4ee2012-09-26 10:09:40 +01002435 }
2436
2437 if (!err) {
2438 info->sig_ok = true;
2439 return 0;
2440 }
2441
2442 /* Not having a signature is only an error if we're strict. */
David Howells1d0059f2012-09-26 10:09:50 +01002443 if (err < 0 && fips_enabled)
2444 panic("Module verification failed with error %d in FIPS mode\n",
2445 err);
Rusty Russell106a4ee2012-09-26 10:09:40 +01002446 if (err == -ENOKEY && !sig_enforce)
2447 err = 0;
2448
2449 return err;
2450}
2451#else /* !CONFIG_MODULE_SIG */
Kees Cook34e11692012-10-16 07:31:07 +10302452static int module_sig_check(struct load_info *info)
Rusty Russell106a4ee2012-09-26 10:09:40 +01002453{
2454 return 0;
2455}
2456#endif /* !CONFIG_MODULE_SIG */
2457
Kees Cook34e11692012-10-16 07:31:07 +10302458/* Sanity checks against invalid binaries, wrong arch, weird elf version. */
2459static int elf_header_check(struct load_info *info)
Rusty Russell40dd2562010-08-05 12:59:03 -06002460{
Kees Cook34e11692012-10-16 07:31:07 +10302461 if (info->len < sizeof(*(info->hdr)))
Rusty Russell40dd2562010-08-05 12:59:03 -06002462 return -ENOEXEC;
2463
Kees Cook34e11692012-10-16 07:31:07 +10302464 if (memcmp(info->hdr->e_ident, ELFMAG, SELFMAG) != 0
2465 || info->hdr->e_type != ET_REL
2466 || !elf_check_arch(info->hdr)
2467 || info->hdr->e_shentsize != sizeof(Elf_Shdr))
2468 return -ENOEXEC;
2469
2470 if (info->hdr->e_shoff >= info->len
2471 || (info->hdr->e_shnum * sizeof(Elf_Shdr) >
2472 info->len - info->hdr->e_shoff))
2473 return -ENOEXEC;
2474
2475 return 0;
2476}
2477
2478/* Sets info->hdr and info->len. */
2479static int copy_module_from_user(const void __user *umod, unsigned long len,
2480 struct load_info *info)
2481{
Kees Cook2e72d512012-10-16 07:32:07 +10302482 int err;
2483
Kees Cook34e11692012-10-16 07:31:07 +10302484 info->len = len;
2485 if (info->len < sizeof(*(info->hdr)))
Rusty Russell40dd2562010-08-05 12:59:03 -06002486 return -ENOEXEC;
2487
Kees Cook2e72d512012-10-16 07:32:07 +10302488 err = security_kernel_module_from_file(NULL);
2489 if (err)
2490 return err;
2491
Rusty Russell40dd2562010-08-05 12:59:03 -06002492 /* Suck in entire file: we'll want most of it. */
Kees Cook34e11692012-10-16 07:31:07 +10302493 info->hdr = vmalloc(info->len);
2494 if (!info->hdr)
Rusty Russell40dd2562010-08-05 12:59:03 -06002495 return -ENOMEM;
2496
Kees Cook34e11692012-10-16 07:31:07 +10302497 if (copy_from_user(info->hdr, umod, info->len) != 0) {
2498 vfree(info->hdr);
2499 return -EFAULT;
Rusty Russell40dd2562010-08-05 12:59:03 -06002500 }
2501
Rusty Russell40dd2562010-08-05 12:59:03 -06002502 return 0;
Kees Cook34e11692012-10-16 07:31:07 +10302503}
Rusty Russell40dd2562010-08-05 12:59:03 -06002504
Kees Cook34e11692012-10-16 07:31:07 +10302505/* Sets info->hdr and info->len. */
2506static int copy_module_from_fd(int fd, struct load_info *info)
2507{
2508 struct file *file;
2509 int err;
2510 struct kstat stat;
2511 loff_t pos;
2512 ssize_t bytes = 0;
2513
2514 file = fget(fd);
2515 if (!file)
2516 return -ENOEXEC;
2517
Kees Cook2e72d512012-10-16 07:32:07 +10302518 err = security_kernel_module_from_file(file);
2519 if (err)
2520 goto out;
2521
Kees Cook34e11692012-10-16 07:31:07 +10302522 err = vfs_getattr(file->f_vfsmnt, file->f_dentry, &stat);
2523 if (err)
2524 goto out;
2525
2526 if (stat.size > INT_MAX) {
2527 err = -EFBIG;
2528 goto out;
2529 }
2530 info->hdr = vmalloc(stat.size);
2531 if (!info->hdr) {
2532 err = -ENOMEM;
2533 goto out;
2534 }
2535
2536 pos = 0;
2537 while (pos < stat.size) {
2538 bytes = kernel_read(file, pos, (char *)(info->hdr) + pos,
2539 stat.size - pos);
2540 if (bytes < 0) {
2541 vfree(info->hdr);
2542 err = bytes;
2543 goto out;
2544 }
2545 if (bytes == 0)
2546 break;
2547 pos += bytes;
2548 }
2549 info->len = pos;
2550
2551out:
2552 fput(file);
Rusty Russell40dd2562010-08-05 12:59:03 -06002553 return err;
2554}
2555
Rusty Russelld9131882010-08-05 12:59:08 -06002556static void free_copy(struct load_info *info)
2557{
Rusty Russelld9131882010-08-05 12:59:08 -06002558 vfree(info->hdr);
2559}
2560
Rusty Russell2f3238a2012-10-22 18:09:41 +10302561static int rewrite_section_headers(struct load_info *info, int flags)
Rusty Russell8b5f61a2010-08-05 12:59:06 -06002562{
2563 unsigned int i;
2564
2565 /* This should always be true, but let's be sure. */
2566 info->sechdrs[0].sh_addr = 0;
2567
2568 for (i = 1; i < info->hdr->e_shnum; i++) {
2569 Elf_Shdr *shdr = &info->sechdrs[i];
2570 if (shdr->sh_type != SHT_NOBITS
2571 && info->len < shdr->sh_offset + shdr->sh_size) {
2572 printk(KERN_ERR "Module len %lu truncated\n",
2573 info->len);
2574 return -ENOEXEC;
2575 }
2576
2577 /* Mark all sections sh_addr with their address in the
2578 temporary image. */
2579 shdr->sh_addr = (size_t)info->hdr + shdr->sh_offset;
2580
2581#ifndef CONFIG_MODULE_UNLOAD
2582 /* Don't load .exit sections */
2583 if (strstarts(info->secstrings+shdr->sh_name, ".exit"))
2584 shdr->sh_flags &= ~(unsigned long)SHF_ALLOC;
2585#endif
Rusty Russell8b5f61a2010-08-05 12:59:06 -06002586 }
Rusty Russelld6df72a2010-08-05 12:59:07 -06002587
2588 /* Track but don't keep modinfo and version sections. */
Rusty Russell2f3238a2012-10-22 18:09:41 +10302589 if (flags & MODULE_INIT_IGNORE_MODVERSIONS)
2590 info->index.vers = 0; /* Pretend no __versions section! */
2591 else
2592 info->index.vers = find_sec(info, "__versions");
Rusty Russell49668682010-08-05 12:59:10 -06002593 info->index.info = find_sec(info, ".modinfo");
Rusty Russelld6df72a2010-08-05 12:59:07 -06002594 info->sechdrs[info->index.info].sh_flags &= ~(unsigned long)SHF_ALLOC;
2595 info->sechdrs[info->index.vers].sh_flags &= ~(unsigned long)SHF_ALLOC;
Rusty Russell8b5f61a2010-08-05 12:59:06 -06002596 return 0;
2597}
2598
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002599/*
2600 * Set up our basic convenience variables (pointers to section headers,
2601 * search for module section index etc), and do some basic section
2602 * verification.
2603 *
2604 * Return the temporary module pointer (we'll replace it with the final
2605 * one when we move the module sections around).
2606 */
Rusty Russell2f3238a2012-10-22 18:09:41 +10302607static struct module *setup_load_info(struct load_info *info, int flags)
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002608{
2609 unsigned int i;
Rusty Russell8b5f61a2010-08-05 12:59:06 -06002610 int err;
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002611 struct module *mod;
2612
2613 /* Set up the convenience variables */
2614 info->sechdrs = (void *)info->hdr + info->hdr->e_shoff;
Rusty Russell8b5f61a2010-08-05 12:59:06 -06002615 info->secstrings = (void *)info->hdr
2616 + info->sechdrs[info->hdr->e_shstrndx].sh_offset;
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002617
Rusty Russell2f3238a2012-10-22 18:09:41 +10302618 err = rewrite_section_headers(info, flags);
Rusty Russell8b5f61a2010-08-05 12:59:06 -06002619 if (err)
2620 return ERR_PTR(err);
2621
2622 /* Find internal symbols and strings. */
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002623 for (i = 1; i < info->hdr->e_shnum; i++) {
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002624 if (info->sechdrs[i].sh_type == SHT_SYMTAB) {
2625 info->index.sym = i;
2626 info->index.str = info->sechdrs[i].sh_link;
Rusty Russell8b5f61a2010-08-05 12:59:06 -06002627 info->strtab = (char *)info->hdr
2628 + info->sechdrs[info->index.str].sh_offset;
2629 break;
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002630 }
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002631 }
2632
Rusty Russell49668682010-08-05 12:59:10 -06002633 info->index.mod = find_sec(info, ".gnu.linkonce.this_module");
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002634 if (!info->index.mod) {
2635 printk(KERN_WARNING "No module found in object\n");
2636 return ERR_PTR(-ENOEXEC);
2637 }
2638 /* This is temporary: point mod into copy of data. */
2639 mod = (void *)info->sechdrs[info->index.mod].sh_addr;
2640
2641 if (info->index.sym == 0) {
2642 printk(KERN_WARNING "%s: module has no symbols (stripped?)\n",
2643 mod->name);
2644 return ERR_PTR(-ENOEXEC);
2645 }
2646
Rusty Russell49668682010-08-05 12:59:10 -06002647 info->index.pcpu = find_pcpusec(info);
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002648
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002649 /* Check module struct version now, before we try to use module. */
2650 if (!check_modstruct_version(info->sechdrs, info->index.vers, mod))
2651 return ERR_PTR(-ENOEXEC);
2652
2653 return mod;
Linus Torvalds3264d3f2010-06-02 11:01:06 -07002654}
2655
Rusty Russell2f3238a2012-10-22 18:09:41 +10302656static int check_modinfo(struct module *mod, struct load_info *info, int flags)
Rusty Russell40dd2562010-08-05 12:59:03 -06002657{
Rusty Russell49668682010-08-05 12:59:10 -06002658 const char *modmagic = get_modinfo(info, "vermagic");
Rusty Russell40dd2562010-08-05 12:59:03 -06002659 int err;
2660
Rusty Russell2f3238a2012-10-22 18:09:41 +10302661 if (flags & MODULE_INIT_IGNORE_VERMAGIC)
2662 modmagic = NULL;
2663
Rusty Russell40dd2562010-08-05 12:59:03 -06002664 /* This is allowed: modprobe --force will invalidate it. */
2665 if (!modmagic) {
2666 err = try_to_force_load(mod, "bad vermagic");
2667 if (err)
2668 return err;
Rusty Russell49668682010-08-05 12:59:10 -06002669 } else if (!same_magic(modmagic, vermagic, info->index.vers)) {
Rusty Russell40dd2562010-08-05 12:59:03 -06002670 printk(KERN_ERR "%s: version magic '%s' should be '%s'\n",
2671 mod->name, modmagic, vermagic);
2672 return -ENOEXEC;
2673 }
2674
Ben Hutchings2449b8b2011-10-24 15:12:28 +02002675 if (!get_modinfo(info, "intree"))
2676 add_taint_module(mod, TAINT_OOT_MODULE);
2677
Rusty Russell49668682010-08-05 12:59:10 -06002678 if (get_modinfo(info, "staging")) {
Rusty Russell40dd2562010-08-05 12:59:03 -06002679 add_taint_module(mod, TAINT_CRAP);
2680 printk(KERN_WARNING "%s: module is from the staging directory,"
2681 " the quality is unknown, you have been warned.\n",
2682 mod->name);
2683 }
Rusty Russell22e268e2010-08-05 12:59:05 -06002684
2685 /* Set up license info based on the info section */
Rusty Russell49668682010-08-05 12:59:10 -06002686 set_license(mod, get_modinfo(info, "license"));
Rusty Russell22e268e2010-08-05 12:59:05 -06002687
Rusty Russell40dd2562010-08-05 12:59:03 -06002688 return 0;
2689}
2690
Rusty Russell811d66a2010-08-05 12:59:12 -06002691static void find_module_sections(struct module *mod, struct load_info *info)
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002692{
Rusty Russell49668682010-08-05 12:59:10 -06002693 mod->kp = section_objs(info, "__param",
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002694 sizeof(*mod->kp), &mod->num_kp);
Rusty Russell49668682010-08-05 12:59:10 -06002695 mod->syms = section_objs(info, "__ksymtab",
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002696 sizeof(*mod->syms), &mod->num_syms);
Rusty Russell49668682010-08-05 12:59:10 -06002697 mod->crcs = section_addr(info, "__kcrctab");
2698 mod->gpl_syms = section_objs(info, "__ksymtab_gpl",
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002699 sizeof(*mod->gpl_syms),
2700 &mod->num_gpl_syms);
Rusty Russell49668682010-08-05 12:59:10 -06002701 mod->gpl_crcs = section_addr(info, "__kcrctab_gpl");
2702 mod->gpl_future_syms = section_objs(info,
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002703 "__ksymtab_gpl_future",
2704 sizeof(*mod->gpl_future_syms),
2705 &mod->num_gpl_future_syms);
Rusty Russell49668682010-08-05 12:59:10 -06002706 mod->gpl_future_crcs = section_addr(info, "__kcrctab_gpl_future");
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002707
2708#ifdef CONFIG_UNUSED_SYMBOLS
Rusty Russell49668682010-08-05 12:59:10 -06002709 mod->unused_syms = section_objs(info, "__ksymtab_unused",
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002710 sizeof(*mod->unused_syms),
2711 &mod->num_unused_syms);
Rusty Russell49668682010-08-05 12:59:10 -06002712 mod->unused_crcs = section_addr(info, "__kcrctab_unused");
2713 mod->unused_gpl_syms = section_objs(info, "__ksymtab_unused_gpl",
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002714 sizeof(*mod->unused_gpl_syms),
2715 &mod->num_unused_gpl_syms);
Rusty Russell49668682010-08-05 12:59:10 -06002716 mod->unused_gpl_crcs = section_addr(info, "__kcrctab_unused_gpl");
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002717#endif
2718#ifdef CONFIG_CONSTRUCTORS
Rusty Russell49668682010-08-05 12:59:10 -06002719 mod->ctors = section_objs(info, ".ctors",
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002720 sizeof(*mod->ctors), &mod->num_ctors);
2721#endif
2722
2723#ifdef CONFIG_TRACEPOINTS
Mathieu Desnoyers65498642011-01-26 17:26:22 -05002724 mod->tracepoints_ptrs = section_objs(info, "__tracepoints_ptrs",
2725 sizeof(*mod->tracepoints_ptrs),
2726 &mod->num_tracepoints);
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002727#endif
Jason Baronbf5438fc2010-09-17 11:09:00 -04002728#ifdef HAVE_JUMP_LABEL
2729 mod->jump_entries = section_objs(info, "__jump_table",
2730 sizeof(*mod->jump_entries),
2731 &mod->num_jump_entries);
2732#endif
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002733#ifdef CONFIG_EVENT_TRACING
Rusty Russell49668682010-08-05 12:59:10 -06002734 mod->trace_events = section_objs(info, "_ftrace_events",
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002735 sizeof(*mod->trace_events),
2736 &mod->num_trace_events);
2737 /*
2738 * This section contains pointers to allocated objects in the trace
2739 * code and not scanning it leads to false positives.
2740 */
2741 kmemleak_scan_area(mod->trace_events, sizeof(*mod->trace_events) *
2742 mod->num_trace_events, GFP_KERNEL);
2743#endif
Steven Rostedt13b9b6e2010-11-10 22:19:24 -05002744#ifdef CONFIG_TRACING
2745 mod->trace_bprintk_fmt_start = section_objs(info, "__trace_printk_fmt",
2746 sizeof(*mod->trace_bprintk_fmt_start),
2747 &mod->num_trace_bprintk_fmt);
2748 /*
2749 * This section contains pointers to allocated objects in the trace
2750 * code and not scanning it leads to false positives.
2751 */
2752 kmemleak_scan_area(mod->trace_bprintk_fmt_start,
2753 sizeof(*mod->trace_bprintk_fmt_start) *
2754 mod->num_trace_bprintk_fmt, GFP_KERNEL);
2755#endif
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002756#ifdef CONFIG_FTRACE_MCOUNT_RECORD
2757 /* sechdrs[0].sh_size is always zero */
Rusty Russell49668682010-08-05 12:59:10 -06002758 mod->ftrace_callsites = section_objs(info, "__mcount_loc",
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002759 sizeof(*mod->ftrace_callsites),
2760 &mod->num_ftrace_callsites);
2761#endif
Rusty Russell22e268e2010-08-05 12:59:05 -06002762
Rusty Russell811d66a2010-08-05 12:59:12 -06002763 mod->extable = section_objs(info, "__ex_table",
2764 sizeof(*mod->extable), &mod->num_exentries);
2765
Rusty Russell49668682010-08-05 12:59:10 -06002766 if (section_addr(info, "__obsparm"))
Rusty Russell22e268e2010-08-05 12:59:05 -06002767 printk(KERN_WARNING "%s: Ignoring obsolete parameters\n",
2768 mod->name);
Rusty Russell811d66a2010-08-05 12:59:12 -06002769
2770 info->debug = section_objs(info, "__verbose",
2771 sizeof(*info->debug), &info->num_debug);
Linus Torvaldsf91a13b2010-08-05 12:59:02 -06002772}
2773
Rusty Russell49668682010-08-05 12:59:10 -06002774static int move_module(struct module *mod, struct load_info *info)
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002775{
2776 int i;
2777 void *ptr;
2778
2779 /* Do the allocs. */
2780 ptr = module_alloc_update_bounds(mod->core_size);
2781 /*
2782 * The pointer to this block is stored in the module structure
2783 * which is inside the block. Just mark it as not being a
2784 * leak.
2785 */
2786 kmemleak_not_leak(ptr);
2787 if (!ptr)
Rusty Russelld9131882010-08-05 12:59:08 -06002788 return -ENOMEM;
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002789
2790 memset(ptr, 0, mod->core_size);
2791 mod->module_core = ptr;
2792
Rusty Russell82fab442012-12-11 09:38:33 +10302793 if (mod->init_size) {
2794 ptr = module_alloc_update_bounds(mod->init_size);
2795 /*
2796 * The pointer to this block is stored in the module structure
2797 * which is inside the block. This block doesn't need to be
2798 * scanned as it contains data and code that will be freed
2799 * after the module is initialized.
2800 */
2801 kmemleak_ignore(ptr);
2802 if (!ptr) {
2803 module_free(mod, mod->module_core);
2804 return -ENOMEM;
2805 }
2806 memset(ptr, 0, mod->init_size);
2807 mod->module_init = ptr;
2808 } else
2809 mod->module_init = NULL;
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002810
2811 /* Transfer each section which specifies SHF_ALLOC */
Jim Cromie5e124162011-12-06 12:11:31 -07002812 pr_debug("final section addresses:\n");
Rusty Russell49668682010-08-05 12:59:10 -06002813 for (i = 0; i < info->hdr->e_shnum; i++) {
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002814 void *dest;
Rusty Russell49668682010-08-05 12:59:10 -06002815 Elf_Shdr *shdr = &info->sechdrs[i];
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002816
Rusty Russell49668682010-08-05 12:59:10 -06002817 if (!(shdr->sh_flags & SHF_ALLOC))
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002818 continue;
2819
Rusty Russell49668682010-08-05 12:59:10 -06002820 if (shdr->sh_entsize & INIT_OFFSET_MASK)
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002821 dest = mod->module_init
Rusty Russell49668682010-08-05 12:59:10 -06002822 + (shdr->sh_entsize & ~INIT_OFFSET_MASK);
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002823 else
Rusty Russell49668682010-08-05 12:59:10 -06002824 dest = mod->module_core + shdr->sh_entsize;
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002825
Rusty Russell49668682010-08-05 12:59:10 -06002826 if (shdr->sh_type != SHT_NOBITS)
2827 memcpy(dest, (void *)shdr->sh_addr, shdr->sh_size);
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002828 /* Update sh_addr to point to copy in image. */
Rusty Russell49668682010-08-05 12:59:10 -06002829 shdr->sh_addr = (unsigned long)dest;
Jim Cromie5e124162011-12-06 12:11:31 -07002830 pr_debug("\t0x%lx %s\n",
2831 (long)shdr->sh_addr, info->secstrings + shdr->sh_name);
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002832 }
Rusty Russelld9131882010-08-05 12:59:08 -06002833
2834 return 0;
Linus Torvalds65b8a9b2010-08-05 12:59:02 -06002835}
2836
Rusty Russell49668682010-08-05 12:59:10 -06002837static int check_module_license_and_versions(struct module *mod)
Rusty Russell22e268e2010-08-05 12:59:05 -06002838{
2839 /*
2840 * ndiswrapper is under GPL by itself, but loads proprietary modules.
2841 * Don't use add_taint_module(), as it would prevent ndiswrapper from
2842 * using GPL-only symbols it needs.
2843 */
2844 if (strcmp(mod->name, "ndiswrapper") == 0)
2845 add_taint(TAINT_PROPRIETARY_MODULE);
2846
2847 /* driverloader was caught wrongly pretending to be under GPL */
2848 if (strcmp(mod->name, "driverloader") == 0)
2849 add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
2850
Matthew Garrettc99af372012-06-22 13:49:31 -04002851 /* lve claims to be GPL but upstream won't provide source */
2852 if (strcmp(mod->name, "lve") == 0)
2853 add_taint_module(mod, TAINT_PROPRIETARY_MODULE);
2854
Rusty Russell22e268e2010-08-05 12:59:05 -06002855#ifdef CONFIG_MODVERSIONS
2856 if ((mod->num_syms && !mod->crcs)
2857 || (mod->num_gpl_syms && !mod->gpl_crcs)
2858 || (mod->num_gpl_future_syms && !mod->gpl_future_crcs)
2859#ifdef CONFIG_UNUSED_SYMBOLS
2860 || (mod->num_unused_syms && !mod->unused_crcs)
2861 || (mod->num_unused_gpl_syms && !mod->unused_gpl_crcs)
2862#endif
2863 ) {
2864 return try_to_force_load(mod,
2865 "no versions for exported symbols");
2866 }
2867#endif
2868 return 0;
2869}
2870
2871static void flush_module_icache(const struct module *mod)
2872{
2873 mm_segment_t old_fs;
2874
2875 /* flush the icache in correct context */
2876 old_fs = get_fs();
2877 set_fs(KERNEL_DS);
2878
2879 /*
2880 * Flush the instruction cache, since we've played with text.
2881 * Do it before processing of module parameters, so the module
2882 * can provide parameter accessor functions of its own.
2883 */
2884 if (mod->module_init)
2885 flush_icache_range((unsigned long)mod->module_init,
2886 (unsigned long)mod->module_init
2887 + mod->init_size);
2888 flush_icache_range((unsigned long)mod->module_core,
2889 (unsigned long)mod->module_core + mod->core_size);
2890
2891 set_fs(old_fs);
2892}
2893
Jonas Bonn74e08fc2011-06-30 21:22:11 +02002894int __weak module_frob_arch_sections(Elf_Ehdr *hdr,
2895 Elf_Shdr *sechdrs,
2896 char *secstrings,
2897 struct module *mod)
2898{
2899 return 0;
2900}
2901
Rusty Russell2f3238a2012-10-22 18:09:41 +10302902static struct module *layout_and_allocate(struct load_info *info, int flags)
Rusty Russelld9131882010-08-05 12:59:08 -06002903{
2904 /* Module within temporary copy. */
2905 struct module *mod;
Rusty Russell49668682010-08-05 12:59:10 -06002906 Elf_Shdr *pcpusec;
Rusty Russelld9131882010-08-05 12:59:08 -06002907 int err;
2908
Rusty Russell2f3238a2012-10-22 18:09:41 +10302909 mod = setup_load_info(info, flags);
Rusty Russelld9131882010-08-05 12:59:08 -06002910 if (IS_ERR(mod))
2911 return mod;
2912
Rusty Russell2f3238a2012-10-22 18:09:41 +10302913 err = check_modinfo(mod, info, flags);
Rusty Russelld9131882010-08-05 12:59:08 -06002914 if (err)
2915 return ERR_PTR(err);
2916
2917 /* Allow arches to frob section contents and sizes. */
Rusty Russell49668682010-08-05 12:59:10 -06002918 err = module_frob_arch_sections(info->hdr, info->sechdrs,
2919 info->secstrings, mod);
Rusty Russelld9131882010-08-05 12:59:08 -06002920 if (err < 0)
Rusty Russell6526c532010-08-05 12:59:10 -06002921 goto out;
Rusty Russelld9131882010-08-05 12:59:08 -06002922
Rusty Russell49668682010-08-05 12:59:10 -06002923 pcpusec = &info->sechdrs[info->index.pcpu];
2924 if (pcpusec->sh_size) {
Rusty Russelld9131882010-08-05 12:59:08 -06002925 /* We have a special allocation for this section. */
Rusty Russell49668682010-08-05 12:59:10 -06002926 err = percpu_modalloc(mod,
2927 pcpusec->sh_size, pcpusec->sh_addralign);
Rusty Russelld9131882010-08-05 12:59:08 -06002928 if (err)
Rusty Russell6526c532010-08-05 12:59:10 -06002929 goto out;
Rusty Russell49668682010-08-05 12:59:10 -06002930 pcpusec->sh_flags &= ~(unsigned long)SHF_ALLOC;
Rusty Russelld9131882010-08-05 12:59:08 -06002931 }
2932
2933 /* Determine total sizes, and put offsets in sh_entsize. For now
2934 this is done generically; there doesn't appear to be any
2935 special cases for the architectures. */
Rusty Russell49668682010-08-05 12:59:10 -06002936 layout_sections(mod, info);
Rusty Russell49668682010-08-05 12:59:10 -06002937 layout_symtab(mod, info);
Rusty Russelld9131882010-08-05 12:59:08 -06002938
2939 /* Allocate and move to the final place */
Rusty Russell49668682010-08-05 12:59:10 -06002940 err = move_module(mod, info);
Rusty Russelld9131882010-08-05 12:59:08 -06002941 if (err)
Kevin Cernekee48fd1182012-01-13 09:32:14 +10302942 goto free_percpu;
Rusty Russelld9131882010-08-05 12:59:08 -06002943
2944 /* Module has been copied to its final place now: return it. */
2945 mod = (void *)info->sechdrs[info->index.mod].sh_addr;
Rusty Russell49668682010-08-05 12:59:10 -06002946 kmemleak_load_module(mod, info);
Rusty Russelld9131882010-08-05 12:59:08 -06002947 return mod;
2948
Rusty Russelld9131882010-08-05 12:59:08 -06002949free_percpu:
2950 percpu_modfree(mod);
Rusty Russell6526c532010-08-05 12:59:10 -06002951out:
Rusty Russelld9131882010-08-05 12:59:08 -06002952 return ERR_PTR(err);
2953}
2954
2955/* mod is no longer valid after this! */
2956static void module_deallocate(struct module *mod, struct load_info *info)
2957{
Rusty Russelld9131882010-08-05 12:59:08 -06002958 percpu_modfree(mod);
2959 module_free(mod, mod->module_init);
2960 module_free(mod, mod->module_core);
2961}
2962
Jonas Bonn74e08fc2011-06-30 21:22:11 +02002963int __weak module_finalize(const Elf_Ehdr *hdr,
2964 const Elf_Shdr *sechdrs,
2965 struct module *me)
2966{
2967 return 0;
2968}
2969
Rusty Russell811d66a2010-08-05 12:59:12 -06002970static int post_relocation(struct module *mod, const struct load_info *info)
2971{
Rusty Russell51f3d0f2010-08-05 12:59:13 -06002972 /* Sort exception table now relocations are done. */
Rusty Russell811d66a2010-08-05 12:59:12 -06002973 sort_extable(mod->extable, mod->extable + mod->num_exentries);
2974
2975 /* Copy relocated percpu area over. */
2976 percpu_modcopy(mod, (void *)info->sechdrs[info->index.pcpu].sh_addr,
2977 info->sechdrs[info->index.pcpu].sh_size);
2978
Rusty Russell51f3d0f2010-08-05 12:59:13 -06002979 /* Setup kallsyms-specific fields. */
Rusty Russell811d66a2010-08-05 12:59:12 -06002980 add_kallsyms(mod, info);
2981
2982 /* Arch-specific module finalizing. */
2983 return module_finalize(info->hdr, info->sechdrs, mod);
2984}
2985
Rusty Russell9bb9c3b2012-09-28 14:31:03 +09302986/* Is this module of this name done loading? No locks held. */
2987static bool finished_loading(const char *name)
2988{
2989 struct module *mod;
2990 bool ret;
2991
2992 mutex_lock(&module_mutex);
2993 mod = find_module(name);
2994 ret = !mod || mod->state != MODULE_STATE_COMING;
2995 mutex_unlock(&module_mutex);
2996
2997 return ret;
2998}
2999
Peter Oberparleiterb99b87f2009-06-17 16:28:03 -07003000/* Call module constructors. */
3001static void do_mod_ctors(struct module *mod)
3002{
3003#ifdef CONFIG_CONSTRUCTORS
3004 unsigned long i;
3005
3006 for (i = 0; i < mod->num_ctors; i++)
3007 mod->ctors[i]();
3008#endif
3009}
3010
Linus Torvalds1da177e2005-04-16 15:20:36 -07003011/* This is where the real work happens */
Kees Cook34e11692012-10-16 07:31:07 +10303012static int do_init_module(struct module *mod)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014 int ret = 0;
3015
Tejun Heo774a1222013-01-15 18:52:51 -08003016 /*
3017 * We want to find out whether @mod uses async during init. Clear
3018 * PF_USED_ASYNC. async_schedule*() will set it.
3019 */
3020 current->flags &= ~PF_USED_ASYNC;
3021
Alan Sterne041c682006-03-27 01:16:30 -08003022 blocking_notifier_call_chain(&module_notify_list,
3023 MODULE_STATE_COMING, mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024
Steven Rostedt94462ad2010-11-29 13:15:42 -05003025 /* Set RO and NX regions for core */
3026 set_section_ro_nx(mod->module_core,
3027 mod->core_text_size,
3028 mod->core_ro_size,
3029 mod->core_size);
3030
3031 /* Set RO and NX regions for init */
3032 set_section_ro_nx(mod->module_init,
3033 mod->init_text_size,
3034 mod->init_ro_size,
3035 mod->init_size);
3036
Peter Oberparleiterb99b87f2009-06-17 16:28:03 -07003037 do_mod_ctors(mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003038 /* Start the module */
3039 if (mod->init != NULL)
Arjan van de Ven59f94152008-07-30 12:49:02 -07003040 ret = do_one_initcall(mod->init);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041 if (ret < 0) {
3042 /* Init routine failed: abort. Try to protect us from
3043 buggy refcounters. */
3044 mod->state = MODULE_STATE_GOING;
Paul E. McKenneyfbd568a3e2005-05-01 08:59:04 -07003045 synchronize_sched();
Rusty Russellaf49d922007-10-16 23:26:27 -07003046 module_put(mod);
Peter Oberparleiterdf4b5652008-04-21 14:34:31 +02003047 blocking_notifier_call_chain(&module_notify_list,
3048 MODULE_STATE_GOING, mod);
Rusty Russellaf49d922007-10-16 23:26:27 -07003049 free_module(mod);
Rusty Russell6f139092012-09-28 14:31:03 +09303050 wake_up_all(&module_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051 return ret;
3052 }
Alexey Dobriyane24e2e62008-03-10 11:43:53 -07003053 if (ret > 0) {
Joe Perchesad361c92009-07-06 13:05:40 -07003054 printk(KERN_WARNING
3055"%s: '%s'->init suspiciously returned %d, it should follow 0/-E convention\n"
3056"%s: loading module anyway...\n",
Alexey Dobriyane24e2e62008-03-10 11:43:53 -07003057 __func__, mod->name, ret,
3058 __func__);
3059 dump_stack();
3060 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003061
Rusty Russell6f139092012-09-28 14:31:03 +09303062 /* Now it's a first class citizen! */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063 mod->state = MODULE_STATE_LIVE;
Masami Hiramatsu0deddf432009-01-06 14:41:54 -08003064 blocking_notifier_call_chain(&module_notify_list,
3065 MODULE_STATE_LIVE, mod);
Rusty Russell6c5db222008-03-10 11:43:52 -07003066
Tejun Heo774a1222013-01-15 18:52:51 -08003067 /*
3068 * We need to finish all async code before the module init sequence
3069 * is done. This has potential to deadlock. For example, a newly
3070 * detected block device can trigger request_module() of the
3071 * default iosched from async probing task. Once userland helper
3072 * reaches here, async_synchronize_full() will wait on the async
3073 * task waiting on request_module() and deadlock.
3074 *
3075 * This deadlock is avoided by perfomring async_synchronize_full()
3076 * iff module init queued any async jobs. This isn't a full
3077 * solution as it will deadlock the same if module loading from
3078 * async jobs nests more than once; however, due to the various
3079 * constraints, this hack seems to be the best option for now.
3080 * Please refer to the following thread for details.
3081 *
3082 * http://thread.gmane.org/gmane.linux.kernel/1420814
3083 */
3084 if (current->flags & PF_USED_ASYNC)
3085 async_synchronize_full();
Linus Torvaldsd6de2c82009-04-10 12:17:41 -07003086
Rusty Russell6c5db222008-03-10 11:43:52 -07003087 mutex_lock(&module_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003088 /* Drop initial reference. */
3089 module_put(mod);
Rusty Russellad6561d2009-06-12 21:47:03 -06003090 trim_init_extable(mod);
Jan Beulich4a496222009-07-06 14:50:42 +01003091#ifdef CONFIG_KALLSYMS
3092 mod->num_symtab = mod->core_num_syms;
3093 mod->symtab = mod->core_symtab;
Jan Beulich554bdfe2009-07-06 14:51:44 +01003094 mod->strtab = mod->core_strtab;
Jan Beulich4a496222009-07-06 14:50:42 +01003095#endif
Jan Glauber01526ed2011-05-19 16:55:26 -06003096 unset_module_init_ro_nx(mod);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097 module_free(mod, mod->module_init);
3098 mod->module_init = NULL;
3099 mod->init_size = 0;
Jan Glauber4d103802011-05-19 16:55:25 -06003100 mod->init_ro_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003101 mod->init_text_size = 0;
Ashutosh Naik6389a382006-03-23 03:00:46 -08003102 mutex_unlock(&module_mutex);
Rusty Russell6f139092012-09-28 14:31:03 +09303103 wake_up_all(&module_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003104
3105 return 0;
3106}
3107
Kees Cook34e11692012-10-16 07:31:07 +10303108static int may_init_module(void)
3109{
3110 if (!capable(CAP_SYS_MODULE) || modules_disabled)
3111 return -EPERM;
3112
3113 return 0;
3114}
3115
3116/* Allocate and load the module: note that size of section 0 is always
3117 zero, and we rely on this for optional sections. */
Rusty Russell2f3238a2012-10-22 18:09:41 +10303118static int load_module(struct load_info *info, const char __user *uargs,
3119 int flags)
Kees Cook34e11692012-10-16 07:31:07 +10303120{
3121 struct module *mod, *old;
3122 long err;
3123
3124 err = module_sig_check(info);
3125 if (err)
3126 goto free_copy;
3127
3128 err = elf_header_check(info);
3129 if (err)
3130 goto free_copy;
3131
3132 /* Figure out module layout, and allocate all the memory. */
Rusty Russell2f3238a2012-10-22 18:09:41 +10303133 mod = layout_and_allocate(info, flags);
Kees Cook34e11692012-10-16 07:31:07 +10303134 if (IS_ERR(mod)) {
3135 err = PTR_ERR(mod);
3136 goto free_copy;
3137 }
3138
3139#ifdef CONFIG_MODULE_SIG
3140 mod->sig_ok = info->sig_ok;
3141 if (!mod->sig_ok)
3142 add_taint_module(mod, TAINT_FORCED_MODULE);
3143#endif
3144
3145 /* Now module is in final location, initialize linked lists, etc. */
3146 err = module_unload_init(mod);
3147 if (err)
3148 goto free_module;
3149
3150 /* Now we've got everything in the final locations, we can
3151 * find optional sections. */
3152 find_module_sections(mod, info);
3153
3154 err = check_module_license_and_versions(mod);
3155 if (err)
3156 goto free_unload;
3157
3158 /* Set up MODINFO_ATTR fields */
3159 setup_modinfo(mod, info);
3160
3161 /* Fix up syms, so that st_value is a pointer to location. */
3162 err = simplify_symbols(mod, info);
3163 if (err < 0)
3164 goto free_modinfo;
3165
3166 err = apply_relocations(mod, info);
3167 if (err < 0)
3168 goto free_modinfo;
3169
3170 err = post_relocation(mod, info);
3171 if (err < 0)
3172 goto free_modinfo;
3173
3174 flush_module_icache(mod);
3175
3176 /* Now copy in args */
3177 mod->args = strndup_user(uargs, ~0UL >> 1);
3178 if (IS_ERR(mod->args)) {
3179 err = PTR_ERR(mod->args);
3180 goto free_arch_cleanup;
3181 }
3182
3183 /* Mark state as coming so strong_try_module_get() ignores us. */
3184 mod->state = MODULE_STATE_COMING;
3185
3186 /* Now sew it into the lists so we can get lockdep and oops
3187 * info during argument parsing. No one should access us, since
3188 * strong_try_module_get() will fail.
3189 * lockdep/oops can run asynchronous, so use the RCU list insertion
3190 * function to insert in a way safe to concurrent readers.
3191 * The mutex protects against concurrent writers.
3192 */
3193again:
3194 mutex_lock(&module_mutex);
3195 if ((old = find_module(mod->name)) != NULL) {
3196 if (old->state == MODULE_STATE_COMING) {
3197 /* Wait in case it fails to load. */
3198 mutex_unlock(&module_mutex);
3199 err = wait_event_interruptible(module_wq,
3200 finished_loading(mod->name));
3201 if (err)
3202 goto free_arch_cleanup;
3203 goto again;
3204 }
3205 err = -EEXIST;
3206 goto unlock;
3207 }
3208
3209 /* This has to be done once we're sure module name is unique. */
3210 dynamic_debug_setup(info->debug, info->num_debug);
3211
3212 /* Find duplicate symbols */
3213 err = verify_export_symbols(mod);
3214 if (err < 0)
3215 goto ddebug;
3216
3217 module_bug_finalize(info->hdr, info->sechdrs, mod);
3218 list_add_rcu(&mod->list, &modules);
3219 mutex_unlock(&module_mutex);
3220
3221 /* Module is ready to execute: parsing args may do that. */
3222 err = parse_args(mod->name, mod->args, mod->kp, mod->num_kp,
3223 -32768, 32767, &ddebug_dyndbg_module_param_cb);
3224 if (err < 0)
3225 goto unlink;
3226
3227 /* Link in to syfs. */
3228 err = mod_sysfs_setup(mod, info, mod->kp, mod->num_kp);
3229 if (err < 0)
3230 goto unlink;
3231
3232 /* Get rid of temporary copy. */
3233 free_copy(info);
3234
3235 /* Done! */
3236 trace_module_load(mod);
3237
3238 return do_init_module(mod);
3239
3240 unlink:
3241 mutex_lock(&module_mutex);
3242 /* Unlink carefully: kallsyms could be walking list. */
3243 list_del_rcu(&mod->list);
3244 module_bug_cleanup(mod);
3245 wake_up_all(&module_wq);
3246 ddebug:
3247 dynamic_debug_remove(info->debug);
3248 unlock:
3249 mutex_unlock(&module_mutex);
3250 synchronize_sched();
3251 kfree(mod->args);
3252 free_arch_cleanup:
3253 module_arch_cleanup(mod);
3254 free_modinfo:
3255 free_modinfo(mod);
3256 free_unload:
3257 module_unload_free(mod);
3258 free_module:
3259 module_deallocate(mod, info);
3260 free_copy:
3261 free_copy(info);
3262 return err;
3263}
3264
3265SYSCALL_DEFINE3(init_module, void __user *, umod,
3266 unsigned long, len, const char __user *, uargs)
3267{
3268 int err;
3269 struct load_info info = { };
3270
3271 err = may_init_module();
3272 if (err)
3273 return err;
3274
3275 pr_debug("init_module: umod=%p, len=%lu, uargs=%p\n",
3276 umod, len, uargs);
3277
3278 err = copy_module_from_user(umod, len, &info);
3279 if (err)
3280 return err;
3281
Rusty Russell2f3238a2012-10-22 18:09:41 +10303282 return load_module(&info, uargs, 0);
Kees Cook34e11692012-10-16 07:31:07 +10303283}
3284
Rusty Russell2f3238a2012-10-22 18:09:41 +10303285SYSCALL_DEFINE3(finit_module, int, fd, const char __user *, uargs, int, flags)
Kees Cook34e11692012-10-16 07:31:07 +10303286{
3287 int err;
3288 struct load_info info = { };
3289
3290 err = may_init_module();
3291 if (err)
3292 return err;
3293
Rusty Russell2f3238a2012-10-22 18:09:41 +10303294 pr_debug("finit_module: fd=%d, uargs=%p, flags=%i\n", fd, uargs, flags);
3295
3296 if (flags & ~(MODULE_INIT_IGNORE_MODVERSIONS
3297 |MODULE_INIT_IGNORE_VERMAGIC))
3298 return -EINVAL;
Kees Cook34e11692012-10-16 07:31:07 +10303299
3300 err = copy_module_from_fd(fd, &info);
3301 if (err)
3302 return err;
3303
Rusty Russell2f3238a2012-10-22 18:09:41 +10303304 return load_module(&info, uargs, flags);
Kees Cook34e11692012-10-16 07:31:07 +10303305}
3306
Linus Torvalds1da177e2005-04-16 15:20:36 -07003307static inline int within(unsigned long addr, void *start, unsigned long size)
3308{
3309 return ((void *)addr >= start && (void *)addr < start + size);
3310}
3311
3312#ifdef CONFIG_KALLSYMS
3313/*
3314 * This ignores the intensely annoying "mapping symbols" found
3315 * in ARM ELF files: $a, $t and $d.
3316 */
3317static inline int is_arm_mapping_symbol(const char *str)
3318{
Daniel Walker22a8bde2007-10-18 03:06:07 -07003319 return str[0] == '$' && strchr("atd", str[1])
Linus Torvalds1da177e2005-04-16 15:20:36 -07003320 && (str[2] == '\0' || str[2] == '.');
3321}
3322
3323static const char *get_ksymbol(struct module *mod,
3324 unsigned long addr,
3325 unsigned long *size,
3326 unsigned long *offset)
3327{
3328 unsigned int i, best = 0;
3329 unsigned long nextval;
3330
3331 /* At worse, next value is at end of module */
Masami Hiramatsua06f6212009-01-06 14:41:49 -08003332 if (within_module_init(addr, mod))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003333 nextval = (unsigned long)mod->module_init+mod->init_text_size;
Daniel Walker22a8bde2007-10-18 03:06:07 -07003334 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07003335 nextval = (unsigned long)mod->module_core+mod->core_text_size;
3336
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003337 /* Scan for closest preceding symbol, and next symbol. (ELF
Daniel Walker22a8bde2007-10-18 03:06:07 -07003338 starts real symbols at 1). */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003339 for (i = 1; i < mod->num_symtab; i++) {
3340 if (mod->symtab[i].st_shndx == SHN_UNDEF)
3341 continue;
3342
3343 /* We ignore unnamed symbols: they're uninformative
3344 * and inserted at a whim. */
3345 if (mod->symtab[i].st_value <= addr
3346 && mod->symtab[i].st_value > mod->symtab[best].st_value
3347 && *(mod->strtab + mod->symtab[i].st_name) != '\0'
3348 && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
3349 best = i;
3350 if (mod->symtab[i].st_value > addr
3351 && mod->symtab[i].st_value < nextval
3352 && *(mod->strtab + mod->symtab[i].st_name) != '\0'
3353 && !is_arm_mapping_symbol(mod->strtab + mod->symtab[i].st_name))
3354 nextval = mod->symtab[i].st_value;
3355 }
3356
3357 if (!best)
3358 return NULL;
3359
Alexey Dobriyanffb45122007-05-08 00:28:41 -07003360 if (size)
3361 *size = nextval - mod->symtab[best].st_value;
3362 if (offset)
3363 *offset = addr - mod->symtab[best].st_value;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003364 return mod->strtab + mod->symtab[best].st_name;
3365}
3366
Rusty Russell6dd06c92008-01-29 17:13:22 -05003367/* For kallsyms to ask for address resolution. NULL means not found. Careful
3368 * not to lock to avoid deadlock on oopses, simply disable preemption. */
Andrew Morton92dfc9d2008-02-08 04:18:43 -08003369const char *module_address_lookup(unsigned long addr,
Rusty Russell6dd06c92008-01-29 17:13:22 -05003370 unsigned long *size,
3371 unsigned long *offset,
3372 char **modname,
3373 char *namebuf)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374{
3375 struct module *mod;
Rusty Russellcb2a5202008-01-14 00:55:03 -08003376 const char *ret = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003377
Rusty Russellcb2a5202008-01-14 00:55:03 -08003378 preempt_disable();
Andi Kleend72b3752008-08-30 10:09:00 +02003379 list_for_each_entry_rcu(mod, &modules, list) {
Masami Hiramatsua06f6212009-01-06 14:41:49 -08003380 if (within_module_init(addr, mod) ||
3381 within_module_core(addr, mod)) {
Franck Bui-Huuffc50892006-10-03 01:13:48 -07003382 if (modname)
3383 *modname = mod->name;
Rusty Russellcb2a5202008-01-14 00:55:03 -08003384 ret = get_ksymbol(mod, addr, size, offset);
3385 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003386 }
3387 }
Rusty Russell6dd06c92008-01-29 17:13:22 -05003388 /* Make a copy in here where it's safe */
3389 if (ret) {
3390 strncpy(namebuf, ret, KSYM_NAME_LEN - 1);
3391 ret = namebuf;
3392 }
Rusty Russellcb2a5202008-01-14 00:55:03 -08003393 preempt_enable();
Andrew Morton92dfc9d2008-02-08 04:18:43 -08003394 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395}
3396
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -07003397int lookup_module_symbol_name(unsigned long addr, char *symname)
3398{
3399 struct module *mod;
3400
Rusty Russellcb2a5202008-01-14 00:55:03 -08003401 preempt_disable();
Andi Kleend72b3752008-08-30 10:09:00 +02003402 list_for_each_entry_rcu(mod, &modules, list) {
Masami Hiramatsua06f6212009-01-06 14:41:49 -08003403 if (within_module_init(addr, mod) ||
3404 within_module_core(addr, mod)) {
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -07003405 const char *sym;
3406
3407 sym = get_ksymbol(mod, addr, NULL, NULL);
3408 if (!sym)
3409 goto out;
Tejun Heo9281ace2007-07-17 04:03:51 -07003410 strlcpy(symname, sym, KSYM_NAME_LEN);
Rusty Russellcb2a5202008-01-14 00:55:03 -08003411 preempt_enable();
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -07003412 return 0;
3413 }
3414 }
3415out:
Rusty Russellcb2a5202008-01-14 00:55:03 -08003416 preempt_enable();
Alexey Dobriyan9d65cb42007-05-08 00:28:43 -07003417 return -ERANGE;
3418}
3419
Alexey Dobriyana5c43da2007-05-08 00:28:47 -07003420int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size,
3421 unsigned long *offset, char *modname, char *name)
3422{
3423 struct module *mod;
3424
Rusty Russellcb2a5202008-01-14 00:55:03 -08003425 preempt_disable();
Andi Kleend72b3752008-08-30 10:09:00 +02003426 list_for_each_entry_rcu(mod, &modules, list) {
Masami Hiramatsua06f6212009-01-06 14:41:49 -08003427 if (within_module_init(addr, mod) ||
3428 within_module_core(addr, mod)) {
Alexey Dobriyana5c43da2007-05-08 00:28:47 -07003429 const char *sym;
3430
3431 sym = get_ksymbol(mod, addr, size, offset);
3432 if (!sym)
3433 goto out;
3434 if (modname)
Tejun Heo9281ace2007-07-17 04:03:51 -07003435 strlcpy(modname, mod->name, MODULE_NAME_LEN);
Alexey Dobriyana5c43da2007-05-08 00:28:47 -07003436 if (name)
Tejun Heo9281ace2007-07-17 04:03:51 -07003437 strlcpy(name, sym, KSYM_NAME_LEN);
Rusty Russellcb2a5202008-01-14 00:55:03 -08003438 preempt_enable();
Alexey Dobriyana5c43da2007-05-08 00:28:47 -07003439 return 0;
3440 }
3441 }
3442out:
Rusty Russellcb2a5202008-01-14 00:55:03 -08003443 preempt_enable();
Alexey Dobriyana5c43da2007-05-08 00:28:47 -07003444 return -ERANGE;
3445}
3446
Alexey Dobriyanea078902007-05-08 00:28:39 -07003447int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
3448 char *name, char *module_name, int *exported)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449{
3450 struct module *mod;
3451
Rusty Russellcb2a5202008-01-14 00:55:03 -08003452 preempt_disable();
Andi Kleend72b3752008-08-30 10:09:00 +02003453 list_for_each_entry_rcu(mod, &modules, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003454 if (symnum < mod->num_symtab) {
3455 *value = mod->symtab[symnum].st_value;
3456 *type = mod->symtab[symnum].st_info;
Andreas Gruenbacher098c5ee2006-07-14 00:24:04 -07003457 strlcpy(name, mod->strtab + mod->symtab[symnum].st_name,
Tejun Heo9281ace2007-07-17 04:03:51 -07003458 KSYM_NAME_LEN);
3459 strlcpy(module_name, mod->name, MODULE_NAME_LEN);
Tim Abbottca4787b2009-01-05 08:40:10 -06003460 *exported = is_exported(name, *value, mod);
Rusty Russellcb2a5202008-01-14 00:55:03 -08003461 preempt_enable();
Alexey Dobriyanea078902007-05-08 00:28:39 -07003462 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463 }
3464 symnum -= mod->num_symtab;
3465 }
Rusty Russellcb2a5202008-01-14 00:55:03 -08003466 preempt_enable();
Alexey Dobriyanea078902007-05-08 00:28:39 -07003467 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003468}
3469
3470static unsigned long mod_find_symname(struct module *mod, const char *name)
3471{
3472 unsigned int i;
3473
3474 for (i = 0; i < mod->num_symtab; i++)
Keith Owens54e8ce42006-02-03 03:03:53 -08003475 if (strcmp(name, mod->strtab+mod->symtab[i].st_name) == 0 &&
3476 mod->symtab[i].st_info != 'U')
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 return mod->symtab[i].st_value;
3478 return 0;
3479}
3480
3481/* Look for this name: can be of form module:name. */
3482unsigned long module_kallsyms_lookup_name(const char *name)
3483{
3484 struct module *mod;
3485 char *colon;
3486 unsigned long ret = 0;
3487
3488 /* Don't lock: we're in enough trouble already. */
Rusty Russellcb2a5202008-01-14 00:55:03 -08003489 preempt_disable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003490 if ((colon = strchr(name, ':')) != NULL) {
3491 *colon = '\0';
3492 if ((mod = find_module(name)) != NULL)
3493 ret = mod_find_symname(mod, colon+1);
3494 *colon = ':';
3495 } else {
Andi Kleend72b3752008-08-30 10:09:00 +02003496 list_for_each_entry_rcu(mod, &modules, list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003497 if ((ret = mod_find_symname(mod, name)) != 0)
3498 break;
3499 }
Rusty Russellcb2a5202008-01-14 00:55:03 -08003500 preempt_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003501 return ret;
3502}
Anders Kaseorg75a66612008-12-05 19:03:58 -05003503
3504int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
3505 struct module *, unsigned long),
3506 void *data)
3507{
3508 struct module *mod;
3509 unsigned int i;
3510 int ret;
3511
3512 list_for_each_entry(mod, &modules, list) {
3513 for (i = 0; i < mod->num_symtab; i++) {
3514 ret = fn(data, mod->strtab + mod->symtab[i].st_name,
3515 mod, mod->symtab[i].st_value);
3516 if (ret != 0)
3517 return ret;
3518 }
3519 }
3520 return 0;
3521}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522#endif /* CONFIG_KALLSYMS */
3523
Arjan van de Ven21aa9282008-01-25 21:08:33 +01003524static char *module_flags(struct module *mod, char *buf)
Florin Malitafa3ba2e82006-10-11 01:21:48 -07003525{
3526 int bx = 0;
3527
Arjan van de Ven21aa9282008-01-25 21:08:33 +01003528 if (mod->taints ||
3529 mod->state == MODULE_STATE_GOING ||
3530 mod->state == MODULE_STATE_COMING) {
Florin Malitafa3ba2e82006-10-11 01:21:48 -07003531 buf[bx++] = '(';
Kay Sieverscca3e702012-01-13 09:32:15 +10303532 bx += module_flags_taint(mod, buf + bx);
Arjan van de Ven21aa9282008-01-25 21:08:33 +01003533 /* Show a - for module-is-being-unloaded */
3534 if (mod->state == MODULE_STATE_GOING)
3535 buf[bx++] = '-';
3536 /* Show a + for module-is-being-loaded */
3537 if (mod->state == MODULE_STATE_COMING)
3538 buf[bx++] = '+';
Florin Malitafa3ba2e82006-10-11 01:21:48 -07003539 buf[bx++] = ')';
3540 }
3541 buf[bx] = '\0';
3542
3543 return buf;
3544}
3545
Alexey Dobriyan3b5d5c62008-10-06 13:19:27 +04003546#ifdef CONFIG_PROC_FS
3547/* Called by the /proc file system to return a list of modules. */
3548static void *m_start(struct seq_file *m, loff_t *pos)
3549{
3550 mutex_lock(&module_mutex);
3551 return seq_list_start(&modules, *pos);
3552}
3553
3554static void *m_next(struct seq_file *m, void *p, loff_t *pos)
3555{
3556 return seq_list_next(p, &modules, pos);
3557}
3558
3559static void m_stop(struct seq_file *m, void *p)
3560{
3561 mutex_unlock(&module_mutex);
3562}
3563
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564static int m_show(struct seq_file *m, void *p)
3565{
3566 struct module *mod = list_entry(p, struct module, list);
Florin Malitafa3ba2e82006-10-11 01:21:48 -07003567 char buf[8];
3568
Denys Vlasenko2f0f2a32008-07-22 19:24:27 -05003569 seq_printf(m, "%s %u",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003570 mod->name, mod->init_size + mod->core_size);
3571 print_unload_info(m, mod);
3572
3573 /* Informative for users. */
3574 seq_printf(m, " %s",
3575 mod->state == MODULE_STATE_GOING ? "Unloading":
3576 mod->state == MODULE_STATE_COMING ? "Loading":
3577 "Live");
3578 /* Used by oprofile and other similar tools. */
Kees Cook9f36e2c2011-03-22 16:34:22 -07003579 seq_printf(m, " 0x%pK", mod->module_core);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003580
Florin Malitafa3ba2e82006-10-11 01:21:48 -07003581 /* Taints info */
3582 if (mod->taints)
Arjan van de Ven21aa9282008-01-25 21:08:33 +01003583 seq_printf(m, " %s", module_flags(mod, buf));
Florin Malitafa3ba2e82006-10-11 01:21:48 -07003584
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585 seq_printf(m, "\n");
3586 return 0;
3587}
3588
3589/* Format: modulename size refcount deps address
3590
3591 Where refcount is a number or -, and deps is a comma-separated list
3592 of depends or -.
3593*/
Alexey Dobriyan3b5d5c62008-10-06 13:19:27 +04003594static const struct seq_operations modules_op = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595 .start = m_start,
3596 .next = m_next,
3597 .stop = m_stop,
3598 .show = m_show
3599};
3600
Alexey Dobriyan3b5d5c62008-10-06 13:19:27 +04003601static int modules_open(struct inode *inode, struct file *file)
3602{
3603 return seq_open(file, &modules_op);
3604}
3605
3606static const struct file_operations proc_modules_operations = {
3607 .open = modules_open,
3608 .read = seq_read,
3609 .llseek = seq_lseek,
3610 .release = seq_release,
3611};
3612
3613static int __init proc_modules_init(void)
3614{
3615 proc_create("modules", 0, NULL, &proc_modules_operations);
3616 return 0;
3617}
3618module_init(proc_modules_init);
3619#endif
3620
Linus Torvalds1da177e2005-04-16 15:20:36 -07003621/* Given an address, look for it in the module exception tables. */
3622const struct exception_table_entry *search_module_extables(unsigned long addr)
3623{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003624 const struct exception_table_entry *e = NULL;
3625 struct module *mod;
3626
Rusty Russell24da1cb2007-07-15 23:41:46 -07003627 preempt_disable();
Andi Kleend72b3752008-08-30 10:09:00 +02003628 list_for_each_entry_rcu(mod, &modules, list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003629 if (mod->num_exentries == 0)
3630 continue;
Daniel Walker22a8bde2007-10-18 03:06:07 -07003631
Linus Torvalds1da177e2005-04-16 15:20:36 -07003632 e = search_extable(mod->extable,
3633 mod->extable + mod->num_exentries - 1,
3634 addr);
3635 if (e)
3636 break;
3637 }
Rusty Russell24da1cb2007-07-15 23:41:46 -07003638 preempt_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003639
3640 /* Now, if we found one, we are running inside it now, hence
Daniel Walker22a8bde2007-10-18 03:06:07 -07003641 we cannot unload the module, hence no refcnt needed. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003642 return e;
3643}
3644
Ingo Molnar4d435f92006-07-03 00:24:24 -07003645/*
Rusty Russelle6104992009-03-31 13:05:31 -06003646 * is_module_address - is this address inside a module?
3647 * @addr: the address to check.
3648 *
3649 * See is_module_text_address() if you simply want to see if the address
3650 * is code (not data).
Ingo Molnar4d435f92006-07-03 00:24:24 -07003651 */
Rusty Russelle6104992009-03-31 13:05:31 -06003652bool is_module_address(unsigned long addr)
Ingo Molnar4d435f92006-07-03 00:24:24 -07003653{
Rusty Russelle6104992009-03-31 13:05:31 -06003654 bool ret;
Ingo Molnar4d435f92006-07-03 00:24:24 -07003655
Rusty Russell24da1cb2007-07-15 23:41:46 -07003656 preempt_disable();
Rusty Russelle6104992009-03-31 13:05:31 -06003657 ret = __module_address(addr) != NULL;
Rusty Russell24da1cb2007-07-15 23:41:46 -07003658 preempt_enable();
Ingo Molnar4d435f92006-07-03 00:24:24 -07003659
Rusty Russelle6104992009-03-31 13:05:31 -06003660 return ret;
Ingo Molnar4d435f92006-07-03 00:24:24 -07003661}
3662
Rusty Russelle6104992009-03-31 13:05:31 -06003663/*
3664 * __module_address - get the module which contains an address.
3665 * @addr: the address.
3666 *
3667 * Must be called with preempt disabled or module mutex held so that
3668 * module doesn't get freed during this.
3669 */
Linus Torvalds714f83d2009-04-05 11:04:19 -07003670struct module *__module_address(unsigned long addr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003671{
3672 struct module *mod;
3673
Rusty Russell3a642e92008-07-22 19:24:28 -05003674 if (addr < module_addr_min || addr > module_addr_max)
3675 return NULL;
3676
Andi Kleend72b3752008-08-30 10:09:00 +02003677 list_for_each_entry_rcu(mod, &modules, list)
Rusty Russelle6104992009-03-31 13:05:31 -06003678 if (within_module_core(addr, mod)
3679 || within_module_init(addr, mod))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003680 return mod;
3681 return NULL;
3682}
Tim Abbottc6b37802008-12-05 19:03:59 -05003683EXPORT_SYMBOL_GPL(__module_address);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003684
Rusty Russelle6104992009-03-31 13:05:31 -06003685/*
3686 * is_module_text_address - is this address inside module code?
3687 * @addr: the address to check.
3688 *
3689 * See is_module_address() if you simply want to see if the address is
3690 * anywhere in a module. See kernel_text_address() for testing if an
3691 * address corresponds to kernel or module code.
3692 */
3693bool is_module_text_address(unsigned long addr)
3694{
3695 bool ret;
3696
3697 preempt_disable();
3698 ret = __module_text_address(addr) != NULL;
3699 preempt_enable();
3700
3701 return ret;
3702}
3703
3704/*
3705 * __module_text_address - get the module whose code contains an address.
3706 * @addr: the address.
3707 *
3708 * Must be called with preempt disabled or module mutex held so that
3709 * module doesn't get freed during this.
3710 */
3711struct module *__module_text_address(unsigned long addr)
3712{
3713 struct module *mod = __module_address(addr);
3714 if (mod) {
3715 /* Make sure it's within the text section. */
3716 if (!within(addr, mod->module_init, mod->init_text_size)
3717 && !within(addr, mod->module_core, mod->core_text_size))
3718 mod = NULL;
3719 }
3720 return mod;
3721}
Tim Abbottc6b37802008-12-05 19:03:59 -05003722EXPORT_SYMBOL_GPL(__module_text_address);
Rusty Russelle6104992009-03-31 13:05:31 -06003723
Linus Torvalds1da177e2005-04-16 15:20:36 -07003724/* Don't grab lock, we're oopsing. */
3725void print_modules(void)
3726{
3727 struct module *mod;
Randy Dunlap2bc2d612006-10-02 02:17:02 -07003728 char buf[8];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003729
Linus Torvaldsb2311252009-06-16 11:07:14 -07003730 printk(KERN_DEFAULT "Modules linked in:");
Andi Kleend72b3752008-08-30 10:09:00 +02003731 /* Most callers should already have preempt disabled, but make sure */
3732 preempt_disable();
3733 list_for_each_entry_rcu(mod, &modules, list)
Arjan van de Ven21aa9282008-01-25 21:08:33 +01003734 printk(" %s%s", mod->name, module_flags(mod, buf));
Andi Kleend72b3752008-08-30 10:09:00 +02003735 preempt_enable();
Arjan van de Vene14af7e2008-01-25 21:08:33 +01003736 if (last_unloaded_module[0])
3737 printk(" [last unloaded: %s]", last_unloaded_module);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003738 printk("\n");
3739}
3740
Linus Torvalds1da177e2005-04-16 15:20:36 -07003741#ifdef CONFIG_MODVERSIONS
Rusty Russell8c8ef422009-03-31 13:05:34 -06003742/* Generate the signature for all relevant module structures here.
3743 * If these change, we don't want to try to parse the module. */
3744void module_layout(struct module *mod,
3745 struct modversion_info *ver,
3746 struct kernel_param *kp,
3747 struct kernel_symbol *ks,
Mathieu Desnoyers65498642011-01-26 17:26:22 -05003748 struct tracepoint * const *tp)
Rusty Russell8c8ef422009-03-31 13:05:34 -06003749{
3750}
3751EXPORT_SYMBOL(module_layout);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752#endif