module.c 93.5 KB
Newer Older
1
/*
Linus Torvalds's avatar
Linus Torvalds committed
2
   Copyright (C) 2002 Richard Henderson
3
   Copyright (C) 2001 Rusty Russell, 2002, 2010 Rusty Russell IBM.
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
19
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
20
#include <linux/moduleloader.h>
21
#include <linux/ftrace_event.h>
Linus Torvalds's avatar
Linus Torvalds committed
22
#include <linux/init.h>
23
#include <linux/kallsyms.h>
24
#include <linux/file.h>
25
#include <linux/fs.h>
Roland McGrath's avatar
Roland McGrath committed
26
#include <linux/sysfs.h>
27
#include <linux/kernel.h>
Linus Torvalds's avatar
Linus Torvalds committed
28 29 30
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/elf.h>
31
#include <linux/proc_fs.h>
Linus Torvalds's avatar
Linus Torvalds committed
32 33 34 35
#include <linux/seq_file.h>
#include <linux/syscalls.h>
#include <linux/fcntl.h>
#include <linux/rcupdate.h>
36
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
37 38 39 40 41 42
#include <linux/cpu.h>
#include <linux/moduleparam.h>
#include <linux/errno.h>
#include <linux/err.h>
#include <linux/vermagic.h>
#include <linux/notifier.h>
Al Viro's avatar
Al Viro committed
43
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
44 45
#include <linux/stop_machine.h>
#include <linux/device.h>
46
#include <linux/string.h>
Arjan van de Ven's avatar
Arjan van de Ven committed
47
#include <linux/mutex.h>
48
#include <linux/rculist.h>
Linus Torvalds's avatar
Linus Torvalds committed
49 50
#include <asm/uaccess.h>
#include <asm/cacheflush.h>
51
#include <asm/mmu_context.h>
52
#include <linux/license.h>
53
#include <asm/sections.h>
54
#include <linux/tracepoint.h>
55
#include <linux/ftrace.h>
56
#include <linux/async.h>
57
#include <linux/percpu.h>
58
#include <linux/kmemleak.h>
59
#include <linux/jump_label.h>
60
#include <linux/pfn.h>
61
#include <linux/bsearch.h>
David Howells's avatar
David Howells committed
62
#include <linux/fips.h>
63
#include <uapi/linux/module.h>
64
#include "module-internal.h"
Linus Torvalds's avatar
Linus Torvalds committed
65

66 67 68
#define CREATE_TRACE_POINTS
#include <trace/events/module.h>

Linus Torvalds's avatar
Linus Torvalds committed
69 70 71 72
#ifndef ARCH_SHF_SMALL
#define ARCH_SHF_SMALL 0
#endif

73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
/*
 * Modules' sections will be aligned on page boundaries
 * to ensure complete separation of code and data, but
 * only when CONFIG_DEBUG_SET_MODULE_RONX=y
 */
#ifdef CONFIG_DEBUG_SET_MODULE_RONX
# define debug_align(X) ALIGN(X, PAGE_SIZE)
#else
# define debug_align(X) (X)
#endif

/*
 * Given BASE and SIZE this macro calculates the number of pages the
 * memory regions occupies
 */
#define MOD_NUMBER_OF_PAGES(BASE, SIZE) (((SIZE) > 0) ?		\
		(PFN_DOWN((unsigned long)(BASE) + (SIZE) - 1) -	\
			 PFN_DOWN((unsigned long)BASE) + 1)	\
		: (0UL))

Linus Torvalds's avatar
Linus Torvalds committed
93 94 95
/* If this is set, the section belongs in the init part of the module */
#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))

96 97 98 99 100
/*
 * Mutex protects:
 * 1) List of modules (also safely readable with preempt_disable),
 * 2) module_use links,
 * 3) module_addr_min/module_addr_max.
101
 * (delete uses stop_machine/add uses RCU list operations). */
102 103
DEFINE_MUTEX(module_mutex);
EXPORT_SYMBOL_GPL(module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
104
static LIST_HEAD(modules);
105 106 107 108
#ifdef CONFIG_KGDB_KDB
struct list_head *kdb_modules = &modules; /* kdb needs the list of modules */
#endif /* CONFIG_KGDB_KDB */

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
#ifdef CONFIG_MODULE_SIG
#ifdef CONFIG_MODULE_SIG_FORCE
static bool sig_enforce = true;
#else
static bool sig_enforce = false;

static int param_set_bool_enable_only(const char *val,
				      const struct kernel_param *kp)
{
	int err;
	bool test;
	struct kernel_param dummy_kp = *kp;

	dummy_kp.arg = &test;

	err = param_set_bool(val, &dummy_kp);
	if (err)
		return err;

	/* Don't let them unset it once it's set! */
	if (!test && sig_enforce)
		return -EROFS;

	if (test)
		sig_enforce = true;
	return 0;
}

static const struct kernel_param_ops param_ops_bool_enable_only = {
	.set = param_set_bool_enable_only,
	.get = param_get_bool,
};
#define param_check_bool_enable_only param_check_bool

module_param(sig_enforce, bool_enable_only, 0644);
#endif /* !CONFIG_MODULE_SIG_FORCE */
#endif /* CONFIG_MODULE_SIG */
Linus Torvalds's avatar
Linus Torvalds committed
146

147 148
/* Block module loading/unloading? */
int modules_disabled = 0;
149
core_param(nomodule, modules_disabled, bint, 0);
150

151 152 153
/* Waiting for a module to finish initializing? */
static DECLARE_WAIT_QUEUE_HEAD(module_wq);

154
static BLOCKING_NOTIFIER_HEAD(module_notify_list);
Linus Torvalds's avatar
Linus Torvalds committed
155

156 157
/* Bounds of module allocation, for speeding __module_address.
 * Protected by module_mutex. */
158 159
static unsigned long module_addr_min = -1UL, module_addr_max = 0;

Linus Torvalds's avatar
Linus Torvalds committed
160 161
int register_module_notifier(struct notifier_block * nb)
{
162
	return blocking_notifier_chain_register(&module_notify_list, nb);
Linus Torvalds's avatar
Linus Torvalds committed
163 164 165 166 167
}
EXPORT_SYMBOL(register_module_notifier);

int unregister_module_notifier(struct notifier_block * nb)
{
168
	return blocking_notifier_chain_unregister(&module_notify_list, nb);
Linus Torvalds's avatar
Linus Torvalds committed
169 170 171
}
EXPORT_SYMBOL(unregister_module_notifier);

172 173 174 175
struct load_info {
	Elf_Ehdr *hdr;
	unsigned long len;
	Elf_Shdr *sechdrs;
176
	char *secstrings, *strtab;
Rusty Russell's avatar
Rusty Russell committed
177
	unsigned long symoffs, stroffs;
178 179
	struct _ddebug *debug;
	unsigned int num_debug;
180
	bool sig_ok;
181 182 183 184 185
	struct {
		unsigned int sym, str, mod, vers, info, pcpu;
	} index;
};

186 187
/* We require a truly strong try_module_get(): 0 means failure due to
   ongoing or failed initialization etc. */
Linus Torvalds's avatar
Linus Torvalds committed
188 189 190
static inline int strong_try_module_get(struct module *mod)
{
	if (mod && mod->state == MODULE_STATE_COMING)
191 192
		return -EBUSY;
	if (try_module_get(mod))
Linus Torvalds's avatar
Linus Torvalds committed
193
		return 0;
194 195
	else
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
196 197
}

198 199 200
static inline void add_taint_module(struct module *mod, unsigned flag)
{
	add_taint(flag);
Andi Kleen's avatar
Andi Kleen committed
201
	mod->taints |= (1U << flag);
202 203
}

204 205 206
/*
 * A thread that wants to hold a reference to a module only while it
 * is running can call this to safely exit.  nfsd and lockd use this.
Linus Torvalds's avatar
Linus Torvalds committed
207 208 209 210 211 212 213
 */
void __module_put_and_exit(struct module *mod, long code)
{
	module_put(mod);
	do_exit(code);
}
EXPORT_SYMBOL(__module_put_and_exit);
214

Linus Torvalds's avatar
Linus Torvalds committed
215
/* Find a module section: 0 means not found. */
216
static unsigned int find_sec(const struct load_info *info, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
217 218 219
{
	unsigned int i;

220 221
	for (i = 1; i < info->hdr->e_shnum; i++) {
		Elf_Shdr *shdr = &info->sechdrs[i];
Linus Torvalds's avatar
Linus Torvalds committed
222
		/* Alloc bit cleared means "ignore it." */
223 224
		if ((shdr->sh_flags & SHF_ALLOC)
		    && strcmp(info->secstrings + shdr->sh_name, name) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
225
			return i;
226
	}
Linus Torvalds's avatar
Linus Torvalds committed
227 228 229
	return 0;
}

Rusty Russell's avatar
Rusty Russell committed
230
/* Find a module section, or NULL. */
231
static void *section_addr(const struct load_info *info, const char *name)
Rusty Russell's avatar
Rusty Russell committed
232 233
{
	/* Section 0 has sh_addr 0. */
234
	return (void *)info->sechdrs[find_sec(info, name)].sh_addr;
Rusty Russell's avatar
Rusty Russell committed
235 236 237
}

/* Find a module section, or NULL.  Fill in number of "objects" in section. */
238
static void *section_objs(const struct load_info *info,
Rusty Russell's avatar
Rusty Russell committed
239 240 241 242
			  const char *name,
			  size_t object_size,
			  unsigned int *num)
{
243
	unsigned int sec = find_sec(info, name);
Rusty Russell's avatar
Rusty Russell committed
244 245

	/* Section 0 has sh_addr 0 and sh_size 0. */
246 247
	*num = info->sechdrs[sec].sh_size / object_size;
	return (void *)info->sechdrs[sec].sh_addr;
Rusty Russell's avatar
Rusty Russell committed
248 249
}

Linus Torvalds's avatar
Linus Torvalds committed
250 251 252 253 254
/* Provided by the linker */
extern const struct kernel_symbol __start___ksymtab[];
extern const struct kernel_symbol __stop___ksymtab[];
extern const struct kernel_symbol __start___ksymtab_gpl[];
extern const struct kernel_symbol __stop___ksymtab_gpl[];
255 256
extern const struct kernel_symbol __start___ksymtab_gpl_future[];
extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
Linus Torvalds's avatar
Linus Torvalds committed
257 258
extern const unsigned long __start___kcrctab[];
extern const unsigned long __start___kcrctab_gpl[];
259
extern const unsigned long __start___kcrctab_gpl_future[];
260 261 262 263 264
#ifdef CONFIG_UNUSED_SYMBOLS
extern const struct kernel_symbol __start___ksymtab_unused[];
extern const struct kernel_symbol __stop___ksymtab_unused[];
extern const struct kernel_symbol __start___ksymtab_unused_gpl[];
extern const struct kernel_symbol __stop___ksymtab_unused_gpl[];
265 266
extern const unsigned long __start___kcrctab_unused[];
extern const unsigned long __start___kcrctab_unused_gpl[];
267
#endif
Linus Torvalds's avatar
Linus Torvalds committed
268 269 270 271

#ifndef CONFIG_MODVERSIONS
#define symversion(base, idx) NULL
#else
Andrew Morton's avatar
Andrew Morton committed
272
#define symversion(base, idx) ((base != NULL) ? ((base) + (idx)) : NULL)
Linus Torvalds's avatar
Linus Torvalds committed
273 274
#endif

275 276 277 278 279
static bool each_symbol_in_section(const struct symsearch *arr,
				   unsigned int arrsize,
				   struct module *owner,
				   bool (*fn)(const struct symsearch *syms,
					      struct module *owner,
280
					      void *data),
281
				   void *data)
282
{
283
	unsigned int j;
284

285
	for (j = 0; j < arrsize; j++) {
286 287
		if (fn(&arr[j], owner, data))
			return true;
288
	}
289 290

	return false;
291 292
}

293
/* Returns true as soon as fn returns true, otherwise false. */
294 295 296 297
bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
				    struct module *owner,
				    void *data),
			 void *data)
298 299
{
	struct module *mod;
300
	static const struct symsearch arr[] = {
301
		{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,
302
		  NOT_GPL_ONLY, false },
303
		{ __start___ksymtab_gpl, __stop___ksymtab_gpl,
304 305
		  __start___kcrctab_gpl,
		  GPL_ONLY, false },
306
		{ __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,
307 308
		  __start___kcrctab_gpl_future,
		  WILL_BE_GPL_ONLY, false },
309
#ifdef CONFIG_UNUSED_SYMBOLS
310
		{ __start___ksymtab_unused, __stop___ksymtab_unused,
311 312
		  __start___kcrctab_unused,
		  NOT_GPL_ONLY, true },
313
		{ __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,
314 315
		  __start___kcrctab_unused_gpl,
		  GPL_ONLY, true },
316
#endif
317
	};
318

319 320
	if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
		return true;
321

322
	list_for_each_entry_rcu(mod, &modules, list) {
323 324
		struct symsearch arr[] = {
			{ mod->syms, mod->syms + mod->num_syms, mod->crcs,
325
			  NOT_GPL_ONLY, false },
326
			{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
327 328
			  mod->gpl_crcs,
			  GPL_ONLY, false },
329 330
			{ mod->gpl_future_syms,
			  mod->gpl_future_syms + mod->num_gpl_future_syms,
331 332
			  mod->gpl_future_crcs,
			  WILL_BE_GPL_ONLY, false },
333
#ifdef CONFIG_UNUSED_SYMBOLS
334 335
			{ mod->unused_syms,
			  mod->unused_syms + mod->num_unused_syms,
336 337
			  mod->unused_crcs,
			  NOT_GPL_ONLY, true },
338 339
			{ mod->unused_gpl_syms,
			  mod->unused_gpl_syms + mod->num_unused_gpl_syms,
340 341
			  mod->unused_gpl_crcs,
			  GPL_ONLY, true },
342
#endif
343 344
		};

345 346 347 348 349
		if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
			return true;
	}
	return false;
}
350
EXPORT_SYMBOL_GPL(each_symbol_section);
351 352 353 354 355 356 357 358 359 360

struct find_symbol_arg {
	/* Input */
	const char *name;
	bool gplok;
	bool warn;

	/* Output */
	struct module *owner;
	const unsigned long *crc;
361
	const struct kernel_symbol *sym;
362 363
};

364 365 366
static bool check_symbol(const struct symsearch *syms,
				 struct module *owner,
				 unsigned int symnum, void *data)
367 368 369 370 371 372 373 374 375 376 377 378 379
{
	struct find_symbol_arg *fsa = data;

	if (!fsa->gplok) {
		if (syms->licence == GPL_ONLY)
			return false;
		if (syms->licence == WILL_BE_GPL_ONLY && fsa->warn) {
			printk(KERN_WARNING "Symbol %s is being used "
			       "by a non-GPL module, which will not "
			       "be allowed in the future\n", fsa->name);
			printk(KERN_WARNING "Please see the file "
			       "Documentation/feature-removal-schedule.txt "
			       "in the kernel source tree for more details.\n");
380
		}
Linus Torvalds's avatar
Linus Torvalds committed
381
	}
382

383
#ifdef CONFIG_UNUSED_SYMBOLS
384 385 386 387 388 389 390 391 392 393 394
	if (syms->unused && fsa->warn) {
		printk(KERN_WARNING "Symbol %s is marked as UNUSED, "
		       "however this module is using it.\n", fsa->name);
		printk(KERN_WARNING
		       "This symbol will go away in the future.\n");
		printk(KERN_WARNING
		       "Please evalute if this is the right api to use and if "
		       "it really is, submit a report the linux kernel "
		       "mailinglist together with submitting your code for "
		       "inclusion.\n");
	}
395
#endif
396 397 398

	fsa->owner = owner;
	fsa->crc = symversion(syms->crcs, symnum);
399
	fsa->sym = &syms->start[symnum];
400 401 402
	return true;
}

403 404 405 406 407 408 409 410
static int cmp_name(const void *va, const void *vb)
{
	const char *a;
	const struct kernel_symbol *b;
	a = va; b = vb;
	return strcmp(a, b->name);
}

411 412 413 414 415
static bool find_symbol_in_section(const struct symsearch *syms,
				   struct module *owner,
				   void *data)
{
	struct find_symbol_arg *fsa = data;
416 417 418 419 420 421 422
	struct kernel_symbol *sym;

	sym = bsearch(fsa->name, syms->start, syms->stop - syms->start,
			sizeof(struct kernel_symbol), cmp_name);

	if (sym != NULL && check_symbol(syms, owner, sym - syms->start, data))
		return true;
423 424 425 426

	return false;
}

427
/* Find a symbol and return it, along with, (optional) crc and
428
 * (optional) module which owns it.  Needs preempt disabled or module_mutex. */
429 430 431 432 433
const struct kernel_symbol *find_symbol(const char *name,
					struct module **owner,
					const unsigned long **crc,
					bool gplok,
					bool warn)
434 435 436 437 438 439 440
{
	struct find_symbol_arg fsa;

	fsa.name = name;
	fsa.gplok = gplok;
	fsa.warn = warn;

441
	if (each_symbol_section(find_symbol_in_section, &fsa)) {
442 443 444 445
		if (owner)
			*owner = fsa.owner;
		if (crc)
			*crc = fsa.crc;
446
		return fsa.sym;
447 448
	}

449
	pr_debug("Failed to find symbol %s\n", name);
450
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
451
}
452
EXPORT_SYMBOL_GPL(find_symbol);
Linus Torvalds's avatar
Linus Torvalds committed
453 454

/* Search for module by name: must hold module_mutex. */
455
struct module *find_module(const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
456 457 458 459 460 461 462 463 464
{
	struct module *mod;

	list_for_each_entry(mod, &modules, list) {
		if (strcmp(mod->name, name) == 0)
			return mod;
	}
	return NULL;
}
465
EXPORT_SYMBOL_GPL(find_module);
Linus Torvalds's avatar
Linus Torvalds committed
466 467

#ifdef CONFIG_SMP
468

469
static inline void __percpu *mod_percpu(struct module *mod)
470
{
471 472
	return mod->percpu;
}
473

474 475 476
static int percpu_modalloc(struct module *mod,
			   unsigned long size, unsigned long align)
{
477 478
	if (align > PAGE_SIZE) {
		printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
479
		       mod->name, align, PAGE_SIZE);
480 481 482
		align = PAGE_SIZE;
	}

483 484
	mod->percpu = __alloc_reserved_percpu(size, align);
	if (!mod->percpu) {
485
		printk(KERN_WARNING
Rusty Russell's avatar
Rusty Russell committed
486 487
		       "%s: Could not allocate %lu bytes percpu data\n",
		       mod->name, size);
488 489 490 491
		return -ENOMEM;
	}
	mod->percpu_size = size;
	return 0;
492 493
}

494
static void percpu_modfree(struct module *mod)
495
{
496
	free_percpu(mod->percpu);
497 498
}

499
static unsigned int find_pcpusec(struct load_info *info)
500
{
501
	return find_sec(info, ".data..percpu");
502 503
}

504 505
static void percpu_modcopy(struct module *mod,
			   const void *from, unsigned long size)
506 507 508 509
{
	int cpu;

	for_each_possible_cpu(cpu)
510
		memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);
511 512
}

513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
/**
 * is_module_percpu_address - test whether address is from module static percpu
 * @addr: address to test
 *
 * Test whether @addr belongs to module static percpu area.
 *
 * RETURNS:
 * %true if @addr is from module static percpu area
 */
bool is_module_percpu_address(unsigned long addr)
{
	struct module *mod;
	unsigned int cpu;

	preempt_disable();

	list_for_each_entry_rcu(mod, &modules, list) {
		if (!mod->percpu_size)
			continue;
		for_each_possible_cpu(cpu) {
			void *start = per_cpu_ptr(mod->percpu, cpu);

			if ((void *)addr >= start &&
			    (void *)addr < start + mod->percpu_size) {
				preempt_enable();
				return true;
			}
		}
	}

	preempt_enable();
	return false;
545 546
}

Linus Torvalds's avatar
Linus Torvalds committed
547
#else /* ... !CONFIG_SMP */
548

549
static inline void __percpu *mod_percpu(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
550 551 552
{
	return NULL;
}
553 554 555 556 557 558
static inline int percpu_modalloc(struct module *mod,
				  unsigned long size, unsigned long align)
{
	return -ENOMEM;
}
static inline void percpu_modfree(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
559 560
{
}
561
static unsigned int find_pcpusec(struct load_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
562 563 564
{
	return 0;
}
565 566
static inline void percpu_modcopy(struct module *mod,
				  const void *from, unsigned long size)
Linus Torvalds's avatar
Linus Torvalds committed
567 568 569 570
{
	/* pcpusec should be 0, and size of that section should be 0. */
	BUG_ON(size != 0);
}
571 572 573 574
bool is_module_percpu_address(unsigned long addr)
{
	return false;
}
575

Linus Torvalds's avatar
Linus Torvalds committed
576 577
#endif /* CONFIG_SMP */

578 579 580 581 582 583
#define MODINFO_ATTR(field)	\
static void setup_modinfo_##field(struct module *mod, const char *s)  \
{                                                                     \
	mod->field = kstrdup(s, GFP_KERNEL);                          \
}                                                                     \
static ssize_t show_modinfo_##field(struct module_attribute *mattr,   \
584
			struct module_kobject *mk, char *buffer)      \
585
{                                                                     \
586
	return sprintf(buffer, "%s\n", mk->mod->field);               \
587 588 589 590 591 592 593
}                                                                     \
static int modinfo_##field##_exists(struct module *mod)               \
{                                                                     \
	return mod->field != NULL;                                    \
}                                                                     \
static void free_modinfo_##field(struct module *mod)                  \
{                                                                     \
594 595
	kfree(mod->field);                                            \
	mod->field = NULL;                                            \
596 597
}                                                                     \
static struct module_attribute modinfo_##field = {                    \
598
	.attr = { .name = __stringify(field), .mode = 0444 },         \
599 600 601 602 603 604 605 606 607
	.show = show_modinfo_##field,                                 \
	.setup = setup_modinfo_##field,                               \
	.test = modinfo_##field##_exists,                             \
	.free = free_modinfo_##field,                                 \
};

MODINFO_ATTR(version);
MODINFO_ATTR(srcversion);

608 609
static char last_unloaded_module[MODULE_NAME_LEN+1];

610
#ifdef CONFIG_MODULE_UNLOAD
611 612 613

EXPORT_TRACEPOINT_SYMBOL(module_get);

Linus Torvalds's avatar
Linus Torvalds committed
614
/* Init the unload section of the module. */
615
static int module_unload_init(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
616
{
617 618 619 620
	mod->refptr = alloc_percpu(struct module_ref);
	if (!mod->refptr)
		return -ENOMEM;

621 622
	INIT_LIST_HEAD(&mod->source_list);
	INIT_LIST_HEAD(&mod->target_list);
623

Linus Torvalds's avatar
Linus Torvalds committed
624
	/* Hold reference count during initialization. */
625
	__this_cpu_write(mod->refptr->incs, 1);
Linus Torvalds's avatar
Linus Torvalds committed
626 627
	/* Backwards compatibility macros put refcount during init. */
	mod->waiter = current;
628 629

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
630 631 632 633 634 635 636
}

/* Does a already use b? */
static int already_uses(struct module *a, struct module *b)
{
	struct module_use *use;

637 638
	list_for_each_entry(use, &b->source_list, source_list) {
		if (use->source == a) {
639
			pr_debug("%s uses %s!\n", a->name, b->name);
Linus Torvalds's avatar
Linus Torvalds committed
640 641 642
			return 1;
		}
	}
643
	pr_debug("%s does not use %s!\n", a->name, b->name);
Linus Torvalds's avatar
Linus Torvalds committed
644 645 646
	return 0;
}

647 648 649 650 651 652 653 654 655 656 657
/*
 * Module a uses b
 *  - we add 'a' as a "source", 'b' as a "target" of module use
 *  - the module_use is added to the list of 'b' sources (so
 *    'b' can walk the list to see who sourced them), and of 'a'
 *    targets (so 'a' can see what modules it targets).
 */
static int add_module_usage(struct module *a, struct module *b)
{
	struct module_use *use;

658
	pr_debug("Allocating new usage for %s.\n", a->name);
659 660 661 662 663 664 665 666 667 668 669 670 671
	use = kmalloc(sizeof(*use), GFP_ATOMIC);
	if (!use) {
		printk(KERN_WARNING "%s: out of memory loading\n", a->name);
		return -ENOMEM;
	}

	use->source = a;
	use->target = b;
	list_add(&use->source_list, &b->source_list);
	list_add(&use->target_list, &a->target_list);
	return 0;
}

672
/* Module a uses b: caller needs module_mutex() */
673
int ref_module(struct module *a, struct module *b)
Linus Torvalds's avatar
Linus Torvalds committed
674
{
675
	int err;
Kay Sievers's avatar
Kay Sievers committed
676

677
	if (b == NULL || already_uses(a, b))
678 679
		return 0;

680 681
	/* If module isn't available, we fail. */
	err = strong_try_module_get(b);
682
	if (err)
683
		return err;
Linus Torvalds's avatar
Linus Torvalds committed
684

685 686
	err = add_module_usage(a, b);
	if (err) {
Linus Torvalds's avatar
Linus Torvalds committed
687
		module_put(b);
688
		return err;
Linus Torvalds's avatar
Linus Torvalds committed
689
	}
690
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
691
}
692
EXPORT_SYMBOL_GPL(ref_module);
Linus Torvalds's avatar
Linus Torvalds committed
693 694 695 696

/* Clear the unload stuff of the module. */
static void module_unload_free(struct module *mod)
{
697
	struct module_use *use, *tmp;
Linus Torvalds's avatar
Linus Torvalds committed
698

699
	mutex_lock(&module_mutex);
700 701
	list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
		struct module *i = use->target;
702
		pr_debug("%s unusing %s\n", mod->name, i->name);
703 704 705 706
		module_put(i);
		list_del(&use->source_list);
		list_del(&use->target_list);
		kfree(use);
Linus Torvalds's avatar
Linus Torvalds committed
707
	}
708
	mutex_unlock(&module_mutex);
709 710

	free_percpu(mod->refptr);
Linus Torvalds's avatar
Linus Torvalds committed
711 712 713
}

#ifdef CONFIG_MODULE_FORCE_UNLOAD
714
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
715 716 717
{
	int ret = (flags & O_TRUNC);
	if (ret)
718
		add_taint(TAINT_FORCED_RMMOD);
Linus Torvalds's avatar
Linus Torvalds committed
719 720 721
	return ret;
}
#else
722
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
{
	return 0;
}
#endif /* CONFIG_MODULE_FORCE_UNLOAD */

struct stopref
{
	struct module *mod;
	int flags;
	int *forced;
};

/* Whole machine is stopped with interrupts off when this runs. */
static int __try_stop_module(void *_sref)
{
	struct stopref *sref = _sref;

740 741
	/* If it's not unused, quit unless we're forcing. */
	if (module_refcount(sref->mod) != 0) {
742
		if (!(*sref->forced = try_force_unload(sref->flags)))
Linus Torvalds's avatar
Linus Torvalds committed
743 744 745 746 747 748 749 750 751 752
			return -EWOULDBLOCK;
	}

	/* Mark it as dying. */
	sref->mod->state = MODULE_STATE_GOING;
	return 0;
}

static int try_stop_module(struct module *mod, int flags, int *forced)
{
753 754
	if (flags & O_NONBLOCK) {
		struct stopref sref = { mod, flags, forced };
Linus Torvalds's avatar
Linus Torvalds committed
755

756
		return stop_machine(__try_stop_module, &sref, NULL);
757 758 759 760 761 762
	} else {
		/* We don't need to stop the machine for this. */
		mod->state = MODULE_STATE_GOING;
		synchronize_sched();
		return 0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
763 764
}

765
unsigned long module_refcount(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
766
{
767
	unsigned long incs = 0, decs = 0;
768
	int cpu;
Linus Torvalds's avatar
Linus Torvalds committed
769

770
	for_each_possible_cpu(cpu)
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
		decs += per_cpu_ptr(mod->refptr, cpu)->decs;
	/*
	 * ensure the incs are added up after the decs.
	 * module_put ensures incs are visible before decs with smp_wmb.
	 *
	 * This 2-count scheme avoids the situation where the refcount
	 * for CPU0 is read, then CPU0 increments the module refcount,
	 * then CPU1 drops that refcount, then the refcount for CPU1 is
	 * read. We would record a decrement but not its corresponding
	 * increment so we would see a low count (disaster).
	 *
	 * Rare situation? But module_refcount can be preempted, and we
	 * might be tallying up 4096+ CPUs. So it is not impossible.
	 */
	smp_rmb();
	for_each_possible_cpu(cpu)
		incs += per_cpu_ptr(mod->refptr, cpu)->incs;
	return incs - decs;
Linus Torvalds's avatar
Linus Torvalds committed
789 790 791 792 793 794 795 796
}
EXPORT_SYMBOL(module_refcount);

/* This exists whether we can unload or not */
static void free_module(struct module *mod);

static void wait_for_zero_refcount(struct module *mod)
{
797
	/* Since we might sleep for some time, release the mutex first */
798
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
799
	for (;;) {
800
		pr_debug("Looking at refcount...\n");
Linus Torvalds's avatar
Linus Torvalds committed
801 802 803 804 805 806
		set_current_state(TASK_UNINTERRUPTIBLE);
		if (module_refcount(mod) == 0)
			break;
		schedule();
	}
	current->state = TASK_RUNNING;
807
	mutex_lock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
808 809
}

810 811
SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
		unsigned int, flags)
Linus Torvalds's avatar
Linus Torvalds committed
812 813
{
	struct module *mod;
814
	char name[MODULE_NAME_LEN];
Linus Torvalds's avatar
Linus Torvalds committed
815 816
	int ret, forced = 0;

817
	if (!capable(CAP_SYS_MODULE) || modules_disabled)
818 819 820 821 822 823
		return -EPERM;

	if (strncpy_from_user(name, name_user, MODULE_NAME_LEN-1) < 0)
		return -EFAULT;
	name[MODULE_NAME_LEN-1] = '\0';

824 825
	if (mutex_lock_interruptible(&module_mutex) != 0)
		return -EINTR;
Linus Torvalds's avatar
Linus Torvalds committed
826 827 828 829 830 831 832

	mod = find_module(name);
	if (!mod) {
		ret = -ENOENT;
		goto out;
	}

833
	if (!list_empty(&mod->source_list)) {
Linus Torvalds's avatar
Linus Torvalds committed
834 835 836 837 838 839 840 841 842
		/* Other modules depend on us: get rid of them first. */
		ret = -EWOULDBLOCK;
		goto out;
	}

	/* Doing init or already dying? */
	if (mod->state != MODULE_STATE_LIVE) {
		/* FIXME: if (force), slam module count and wake up
                   waiter --RR */
843
		pr_debug("%s already dying\n", mod->name);
Linus Torvalds's avatar
Linus Torvalds committed
844 845 846 847 848
		ret = -EBUSY;
		goto out;
	}

	/* If it has an init func, it must have an exit func to unload */
849
	if (mod->init && !mod->exit) {
850
		forced = try_force_unload(flags);
Linus Torvalds's avatar
Linus Torvalds committed
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869
		if (!forced) {
			/* This module can't be removed */
			ret = -EBUSY;
			goto out;
		}
	}

	/* Set this up before setting mod->state */
	mod->waiter = current;

	/* Stop the machine so refcounts can't move and disable module. */
	ret = try_stop_module(mod, flags, &forced);
	if (ret != 0)
		goto out;

	/* Never wait if forced. */
	if (!forced && module_refcount(mod) != 0)
		wait_for_zero_refcount(mod);

870
	mutex_unlock(&module_mutex);
Lucas De Marchi's avatar
Lucas De Marchi committed
871
	/* Final destruction now no one is using it. */
872
	if (mod->exit != NULL)
Linus Torvalds's avatar
Linus Torvalds committed
873
		mod->exit();
874 875
	blocking_notifier_call_chain(&module_notify_list,
				     MODULE_STATE_GOING, mod);
876
	async_synchronize_full();
877

878
	/* Store the name of the last unloaded module for diagnostic purposes */
879
	strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
Linus Torvalds's avatar
Linus Torvalds committed
880

881 882 883
	free_module(mod);
	return 0;
out:
884
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
885 886 887
	return ret;
}

888
static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
889 890 891 892
{
	struct module_use *use;
	int printed_something = 0;

893
	seq_printf(m, " %lu ", module_refcount(mod));
Linus Torvalds's avatar
Linus Torvalds committed
894 895 896

	/* Always include a trailing , so userspace can differentiate
           between this and the old multi-field proc format. */
897
	list_for_each_entry(use, &mod->source_list, source_list) {
Linus Torvalds's avatar
Linus Torvalds committed
898
		printed_something = 1;
899
		seq_printf(m, "%s,", use->source->name);
Linus Torvalds's avatar
Linus Torvalds committed
900 901 902 903 904 905 906 907 908 909 910 911 912 913 914
	}

	if (mod->init != NULL && mod->exit == NULL) {
		printed_something = 1;
		seq_printf(m, "[permanent],");
	}

	if (!printed_something)
		seq_printf(m, "-");
}

void __symbol_put(const char *symbol)
{
	struct module *owner;

Rusty Russell's avatar
Rusty Russell committed
915
	preempt_disable();
916
	if (!find_symbol(symbol, &owner, NULL, true, false))
Linus Torvalds's avatar
Linus Torvalds committed
917 918
		BUG();
	module_put(owner);
Rusty Russell's avatar
Rusty Russell committed
919
	preempt_enable();
Linus Torvalds's avatar
Linus Torvalds committed
920 921 922
}
EXPORT_SYMBOL(__symbol_put);

923
/* Note this assumes addr is a function, which it currently always is. */
Linus Torvalds's avatar
Linus Torvalds committed
924 925
void symbol_put_addr(void *addr)
{
926
	struct module *modaddr;
927
	unsigned long a = (unsigned long)dereference_function_descriptor(addr);
Linus Torvalds's avatar
Linus Torvalds committed
928

929
	if (core_kernel_text(a))
930
		return;
Linus Torvalds's avatar
Linus Torvalds committed
931

932 933
	/* module_text_address is safe here: we're supposed to have reference
	 * to module from symbol_get, so it can't go away. */
934
	modaddr = __module_text_address(a);
935
	BUG_ON(!modaddr);
936
	module_put(modaddr);
Linus Torvalds's avatar
Linus Torvalds committed
937 938 939 940
}
EXPORT_SYMBOL_GPL(symbol_put_addr);

static ssize_t show_refcnt(struct module_attribute *mattr,
941
			   struct module_kobject *mk, char *buffer)
Linus Torvalds's avatar
Linus Torvalds committed
942
{
943
	return sprintf(buffer, "%lu\n", module_refcount(mk->mod));
Linus Torvalds's avatar
Linus Torvalds committed
944 945
}

946 947
static struct module_attribute modinfo_refcnt =
	__ATTR(refcnt, 0444, show_refcnt, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
948

949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978
void __module_get(struct module *module)
{
	if (module) {
		preempt_disable();
		__this_cpu_inc(module->refptr->incs);
		trace_module_get(module, _RET_IP_);
		preempt_enable();
	}
}
EXPORT_SYMBOL(__module_get);

bool try_module_get(struct module *module)
{
	bool ret = true;

	if (module) {
		preempt_disable();

		if (likely(module_is_live(module))) {
			__this_cpu_inc(module->refptr->incs);
			trace_module_get(module, _RET_IP_);
		} else
			ret = false;

		preempt_enable();
	}
	return ret;
}
EXPORT_SYMBOL(try_module_get);

Al Viro's avatar
Al Viro committed
979 980 981
void module_put(struct module *module)
{
	if (module) {
982
		preempt_disable();
983 984
		smp_wmb(); /* see comment in module_refcount */
		__this_cpu_inc(module->refptr->decs);
985

986
		trace_module_put(module, _RET_IP_);
Al Viro's avatar
Al Viro committed
987 988 989
		/* Maybe they're waiting for us to drop reference? */
		if (unlikely(!module_is_live(module)))
			wake_up_process(module->waiter);
990
		preempt_enable();
Al Viro's avatar
Al Viro committed
991 992 993 994
	}
}
EXPORT_SYMBOL(module_put);

Linus Torvalds's avatar
Linus Torvalds committed
995
#else /* !CONFIG_MODULE_UNLOAD */
996
static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
997 998 999 1000 1001 1002 1003 1004 1005
{
	/* We don't know the usage count, or what modules are using. */
	seq_printf(m, " - -");
}

static inline void module_unload_free(struct module *mod)
{
}

1006
int ref_module(struct module *a, struct module *b)
Linus Torvalds's avatar
Linus Torvalds committed
1007
{
1008
	return strong_try_module_get(b);
Linus Torvalds's avatar
Linus Torvalds committed
1009
}
1010
EXPORT_SYMBOL_GPL(ref_module);
Linus Torvalds's avatar
Linus Torvalds committed
1011

1012
static inline int module_unload_init(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
1013
{
1014
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1015 1016 1017
}
#endif /* CONFIG_MODULE_UNLOAD */

1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
static size_t module_flags_taint(struct module *mod, char *buf)
{
	size_t l = 0;

	if (mod->taints & (1 << TAINT_PROPRIETARY_MODULE))
		buf[l++] = 'P';
	if (mod->taints & (1 << TAINT_OOT_MODULE))
		buf[l++] = 'O';
	if (mod->taints & (1 << TAINT_FORCED_MODULE))
		buf[l++] = 'F';
	if (mod->taints & (1 << TAINT_CRAP))
		buf[l++] = 'C';
	/*
	 * TAINT_FORCED_RMMOD: could be added.
	 * TAINT_UNSAFE_SMP, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
	 * apply to modules.
	 */
	return l;
}

1038
static ssize_t show_initstate(struct module_attribute *mattr,
1039
			      struct module_kobject *mk, char *buffer)
1040 1041 1042
{
	const char *state = "unknown";

1043
	switch (mk->mod->state) {
1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
	case MODULE_STATE_LIVE:
		state = "live";
		break;
	case MODULE_STATE_COMING:
		state = "coming";
		break;
	case MODULE_STATE_GOING:
		state = "going";
		break;
	}
	return sprintf(buffer, "%s\n", state);
}

1057 1058
static struct module_attribute modinfo_initstate =
	__ATTR(initstate, 0444, show_initstate, NULL);
1059

1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070
static ssize_t store_uevent(struct module_attribute *mattr,
			    struct module_kobject *mk,
			    const char *buffer, size_t count)
{
	enum kobject_action action;

	if (kobject_action_type(buffer, count, &action) == 0)
		kobject_uevent(&mk->kobj, action);
	return count;
}

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
struct module_attribute module_uevent =
	__ATTR(uevent, 0200, NULL, store_uevent);

static ssize_t show_coresize(struct module_attribute *mattr,
			     struct module_kobject *mk, char *buffer)
{
	return sprintf(buffer, "%u\n", mk->mod->core_size);
}

static struct module_attribute modinfo_coresize =
	__ATTR(coresize, 0444, show_coresize, NULL);

static ssize_t show_initsize(struct module_attribute *mattr,
			     struct module_kobject *mk, char *buffer)
{
	return sprintf(buffer, "%u\n", mk->mod->init_size);
}

static struct module_attribute modinfo_initsize =