module.c 88.3 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/fs.h>
Roland McGrath's avatar
Roland McGrath committed
25
#include <linux/sysfs.h>
26
#include <linux/kernel.h>
Linus Torvalds's avatar
Linus Torvalds committed
27 28 29
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/elf.h>
30
#include <linux/proc_fs.h>
Linus Torvalds's avatar
Linus Torvalds committed
31 32 33 34
#include <linux/seq_file.h>
#include <linux/syscalls.h>
#include <linux/fcntl.h>
#include <linux/rcupdate.h>
35
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
36 37 38 39 40 41
#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
42
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
43 44
#include <linux/stop_machine.h>
#include <linux/device.h>
45
#include <linux/string.h>
Arjan van de Ven's avatar
Arjan van de Ven committed
46
#include <linux/mutex.h>
47
#include <linux/rculist.h>
Linus Torvalds's avatar
Linus Torvalds committed
48 49
#include <asm/uaccess.h>
#include <asm/cacheflush.h>
50
#include <asm/mmu_context.h>
51
#include <linux/license.h>
52
#include <asm/sections.h>
53
#include <linux/tracepoint.h>
54
#include <linux/ftrace.h>
55
#include <linux/async.h>
56
#include <linux/percpu.h>
57
#include <linux/kmemleak.h>
58
#include <linux/jump_label.h>
59
#include <linux/pfn.h>
60
#include <linux/bsearch.h>
Linus Torvalds's avatar
Linus Torvalds committed
61

62 63 64
#define CREATE_TRACE_POINTS
#include <trace/events/module.h>

Linus Torvalds's avatar
Linus Torvalds committed
65 66 67 68 69 70 71 72 73 74
#if 0
#define DEBUGP printk
#else
#define DEBUGP(fmt , a...)
#endif

#ifndef ARCH_SHF_SMALL
#define ARCH_SHF_SMALL 0
#endif

75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
/*
 * 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
95 96 97
/* If this is set, the section belongs in the init part of the module */
#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))

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

Linus Torvalds's avatar
Linus Torvalds committed
111

112 113 114
/* Block module loading/unloading? */
int modules_disabled = 0;

115 116 117
/* Waiting for a module to finish initializing? */
static DECLARE_WAIT_QUEUE_HEAD(module_wq);

118
static BLOCKING_NOTIFIER_HEAD(module_notify_list);
Linus Torvalds's avatar
Linus Torvalds committed
119

120 121
/* Bounds of module allocation, for speeding __module_address.
 * Protected by module_mutex. */
122 123
static unsigned long module_addr_min = -1UL, module_addr_max = 0;

Linus Torvalds's avatar
Linus Torvalds committed
124 125
int register_module_notifier(struct notifier_block * nb)
{
126
	return blocking_notifier_chain_register(&module_notify_list, nb);
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130 131
}
EXPORT_SYMBOL(register_module_notifier);

int unregister_module_notifier(struct notifier_block * nb)
{
132
	return blocking_notifier_chain_unregister(&module_notify_list, nb);
Linus Torvalds's avatar
Linus Torvalds committed
133 134 135
}
EXPORT_SYMBOL(unregister_module_notifier);

136 137 138 139
struct load_info {
	Elf_Ehdr *hdr;
	unsigned long len;
	Elf_Shdr *sechdrs;
140
	char *secstrings, *strtab;
Rusty Russell's avatar
Rusty Russell committed
141
	unsigned long symoffs, stroffs;
142 143
	struct _ddebug *debug;
	unsigned int num_debug;
144 145 146 147 148
	struct {
		unsigned int sym, str, mod, vers, info, pcpu;
	} index;
};

149 150
/* 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
151 152 153
static inline int strong_try_module_get(struct module *mod)
{
	if (mod && mod->state == MODULE_STATE_COMING)
154 155
		return -EBUSY;
	if (try_module_get(mod))
Linus Torvalds's avatar
Linus Torvalds committed
156
		return 0;
157 158
	else
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
159 160
}

161 162 163
static inline void add_taint_module(struct module *mod, unsigned flag)
{
	add_taint(flag);
Andi Kleen's avatar
Andi Kleen committed
164
	mod->taints |= (1U << flag);
165 166
}

167 168 169
/*
 * 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
170 171 172 173 174 175 176
 */
void __module_put_and_exit(struct module *mod, long code)
{
	module_put(mod);
	do_exit(code);
}
EXPORT_SYMBOL(__module_put_and_exit);
177

Linus Torvalds's avatar
Linus Torvalds committed
178
/* Find a module section: 0 means not found. */
179
static unsigned int find_sec(const struct load_info *info, const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
180 181 182
{
	unsigned int i;

183 184
	for (i = 1; i < info->hdr->e_shnum; i++) {
		Elf_Shdr *shdr = &info->sechdrs[i];
Linus Torvalds's avatar
Linus Torvalds committed
185
		/* Alloc bit cleared means "ignore it." */
186 187
		if ((shdr->sh_flags & SHF_ALLOC)
		    && strcmp(info->secstrings + shdr->sh_name, name) == 0)
Linus Torvalds's avatar
Linus Torvalds committed
188
			return i;
189
	}
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192
	return 0;
}

Rusty Russell's avatar
Rusty Russell committed
193
/* Find a module section, or NULL. */
194
static void *section_addr(const struct load_info *info, const char *name)
Rusty Russell's avatar
Rusty Russell committed
195 196
{
	/* Section 0 has sh_addr 0. */
197
	return (void *)info->sechdrs[find_sec(info, name)].sh_addr;
Rusty Russell's avatar
Rusty Russell committed
198 199 200
}

/* Find a module section, or NULL.  Fill in number of "objects" in section. */
201
static void *section_objs(const struct load_info *info,
Rusty Russell's avatar
Rusty Russell committed
202 203 204 205
			  const char *name,
			  size_t object_size,
			  unsigned int *num)
{
206
	unsigned int sec = find_sec(info, name);
Rusty Russell's avatar
Rusty Russell committed
207 208

	/* Section 0 has sh_addr 0 and sh_size 0. */
209 210
	*num = info->sechdrs[sec].sh_size / object_size;
	return (void *)info->sechdrs[sec].sh_addr;
Rusty Russell's avatar
Rusty Russell committed
211 212
}

Linus Torvalds's avatar
Linus Torvalds committed
213 214 215 216 217
/* 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[];
218 219
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
220 221
extern const unsigned long __start___kcrctab[];
extern const unsigned long __start___kcrctab_gpl[];
222
extern const unsigned long __start___kcrctab_gpl_future[];
223 224 225 226 227
#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[];
228 229
extern const unsigned long __start___kcrctab_unused[];
extern const unsigned long __start___kcrctab_unused_gpl[];
230
#endif
Linus Torvalds's avatar
Linus Torvalds committed
231 232 233 234

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

238 239 240 241 242
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,
243
					      void *data),
244
				   void *data)
245
{
246
	unsigned int j;
247

248
	for (j = 0; j < arrsize; j++) {
249 250
		if (fn(&arr[j], owner, data))
			return true;
251
	}
252 253

	return false;
254 255
}

256
/* Returns true as soon as fn returns true, otherwise false. */
257 258 259 260
bool each_symbol_section(bool (*fn)(const struct symsearch *arr,
				    struct module *owner,
				    void *data),
			 void *data)
261 262
{
	struct module *mod;
263
	static const struct symsearch arr[] = {
264
		{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,
265
		  NOT_GPL_ONLY, false },
266
		{ __start___ksymtab_gpl, __stop___ksymtab_gpl,
267 268
		  __start___kcrctab_gpl,
		  GPL_ONLY, false },
269
		{ __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,
270 271
		  __start___kcrctab_gpl_future,
		  WILL_BE_GPL_ONLY, false },
272
#ifdef CONFIG_UNUSED_SYMBOLS
273
		{ __start___ksymtab_unused, __stop___ksymtab_unused,
274 275
		  __start___kcrctab_unused,
		  NOT_GPL_ONLY, true },
276
		{ __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,
277 278
		  __start___kcrctab_unused_gpl,
		  GPL_ONLY, true },
279
#endif
280
	};
281

282 283
	if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
		return true;
284

285
	list_for_each_entry_rcu(mod, &modules, list) {
286 287
		struct symsearch arr[] = {
			{ mod->syms, mod->syms + mod->num_syms, mod->crcs,
288
			  NOT_GPL_ONLY, false },
289
			{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
290 291
			  mod->gpl_crcs,
			  GPL_ONLY, false },
292 293
			{ mod->gpl_future_syms,
			  mod->gpl_future_syms + mod->num_gpl_future_syms,
294 295
			  mod->gpl_future_crcs,
			  WILL_BE_GPL_ONLY, false },
296
#ifdef CONFIG_UNUSED_SYMBOLS
297 298
			{ mod->unused_syms,
			  mod->unused_syms + mod->num_unused_syms,
299 300
			  mod->unused_crcs,
			  NOT_GPL_ONLY, true },
301 302
			{ mod->unused_gpl_syms,
			  mod->unused_gpl_syms + mod->num_unused_gpl_syms,
303 304
			  mod->unused_gpl_crcs,
			  GPL_ONLY, true },
305
#endif
306 307
		};

308 309 310 311 312
		if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
			return true;
	}
	return false;
}
313
EXPORT_SYMBOL_GPL(each_symbol_section);
314 315 316 317 318 319 320 321 322 323

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

	/* Output */
	struct module *owner;
	const unsigned long *crc;
324
	const struct kernel_symbol *sym;
325 326
};

327 328 329
static bool check_symbol(const struct symsearch *syms,
				 struct module *owner,
				 unsigned int symnum, void *data)
330 331 332 333 334 335 336 337 338 339 340 341 342
{
	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");
343
		}
Linus Torvalds's avatar
Linus Torvalds committed
344
	}
345

346
#ifdef CONFIG_UNUSED_SYMBOLS
347 348 349 350 351 352 353 354 355 356 357
	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");
	}
358
#endif
359 360 361

	fsa->owner = owner;
	fsa->crc = symversion(syms->crcs, symnum);
362
	fsa->sym = &syms->start[symnum];
363 364 365
	return true;
}

366 367 368 369 370 371 372 373
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);
}

374 375 376 377 378
static bool find_symbol_in_section(const struct symsearch *syms,
				   struct module *owner,
				   void *data)
{
	struct find_symbol_arg *fsa = data;
379 380 381 382 383 384 385
	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;
386 387 388 389

	return false;
}

390
/* Find a symbol and return it, along with, (optional) crc and
391
 * (optional) module which owns it.  Needs preempt disabled or module_mutex. */
392 393 394 395 396
const struct kernel_symbol *find_symbol(const char *name,
					struct module **owner,
					const unsigned long **crc,
					bool gplok,
					bool warn)
397 398 399 400 401 402 403
{
	struct find_symbol_arg fsa;

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

404
	if (each_symbol_section(find_symbol_in_section, &fsa)) {
405 406 407 408
		if (owner)
			*owner = fsa.owner;
		if (crc)
			*crc = fsa.crc;
409
		return fsa.sym;
410 411
	}

Linus Torvalds's avatar
Linus Torvalds committed
412
	DEBUGP("Failed to find symbol %s\n", name);
413
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
414
}
415
EXPORT_SYMBOL_GPL(find_symbol);
Linus Torvalds's avatar
Linus Torvalds committed
416 417

/* Search for module by name: must hold module_mutex. */
418
struct module *find_module(const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
419 420 421 422 423 424 425 426 427
{
	struct module *mod;

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

#ifdef CONFIG_SMP
431

432
static inline void __percpu *mod_percpu(struct module *mod)
433
{
434 435
	return mod->percpu;
}
436

437 438 439
static int percpu_modalloc(struct module *mod,
			   unsigned long size, unsigned long align)
{
440 441
	if (align > PAGE_SIZE) {
		printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
442
		       mod->name, align, PAGE_SIZE);
443 444 445
		align = PAGE_SIZE;
	}

446 447
	mod->percpu = __alloc_reserved_percpu(size, align);
	if (!mod->percpu) {
448
		printk(KERN_WARNING
Rusty Russell's avatar
Rusty Russell committed
449 450
		       "%s: Could not allocate %lu bytes percpu data\n",
		       mod->name, size);
451 452 453 454
		return -ENOMEM;
	}
	mod->percpu_size = size;
	return 0;
455 456
}

457
static void percpu_modfree(struct module *mod)
458
{
459
	free_percpu(mod->percpu);
460 461
}

462
static unsigned int find_pcpusec(struct load_info *info)
463
{
464
	return find_sec(info, ".data..percpu");
465 466
}

467 468
static void percpu_modcopy(struct module *mod,
			   const void *from, unsigned long size)
469 470 471 472
{
	int cpu;

	for_each_possible_cpu(cpu)
473
		memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);
474 475
}

476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
/**
 * 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;
508 509
}

Linus Torvalds's avatar
Linus Torvalds committed
510
#else /* ... !CONFIG_SMP */
511

512
static inline void __percpu *mod_percpu(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
513 514 515
{
	return NULL;
}
516 517 518 519 520 521
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
522 523
{
}
524
static unsigned int find_pcpusec(struct load_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
525 526 527
{
	return 0;
}
528 529
static inline void percpu_modcopy(struct module *mod,
				  const void *from, unsigned long size)
Linus Torvalds's avatar
Linus Torvalds committed
530 531 532 533
{
	/* pcpusec should be 0, and size of that section should be 0. */
	BUG_ON(size != 0);
}
534 535 536 537
bool is_module_percpu_address(unsigned long addr)
{
	return false;
}
538

Linus Torvalds's avatar
Linus Torvalds committed
539 540
#endif /* CONFIG_SMP */

541 542 543 544 545 546
#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,   \
547
			struct module_kobject *mk, char *buffer)      \
548
{                                                                     \
549
	return sprintf(buffer, "%s\n", mk->mod->field);               \
550 551 552 553 554 555 556
}                                                                     \
static int modinfo_##field##_exists(struct module *mod)               \
{                                                                     \
	return mod->field != NULL;                                    \
}                                                                     \
static void free_modinfo_##field(struct module *mod)                  \
{                                                                     \
557 558
	kfree(mod->field);                                            \
	mod->field = NULL;                                            \
559 560
}                                                                     \
static struct module_attribute modinfo_##field = {                    \
561
	.attr = { .name = __stringify(field), .mode = 0444 },         \
562 563 564 565 566 567 568 569 570
	.show = show_modinfo_##field,                                 \
	.setup = setup_modinfo_##field,                               \
	.test = modinfo_##field##_exists,                             \
	.free = free_modinfo_##field,                                 \
};

MODINFO_ATTR(version);
MODINFO_ATTR(srcversion);

571 572
static char last_unloaded_module[MODULE_NAME_LEN+1];

573
#ifdef CONFIG_MODULE_UNLOAD
574 575 576

EXPORT_TRACEPOINT_SYMBOL(module_get);

Linus Torvalds's avatar
Linus Torvalds committed
577
/* Init the unload section of the module. */
578
static int module_unload_init(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
579
{
580 581 582 583
	mod->refptr = alloc_percpu(struct module_ref);
	if (!mod->refptr)
		return -ENOMEM;

584 585
	INIT_LIST_HEAD(&mod->source_list);
	INIT_LIST_HEAD(&mod->target_list);
586

Linus Torvalds's avatar
Linus Torvalds committed
587
	/* Hold reference count during initialization. */
588
	__this_cpu_write(mod->refptr->incs, 1);
Linus Torvalds's avatar
Linus Torvalds committed
589 590
	/* Backwards compatibility macros put refcount during init. */
	mod->waiter = current;
591 592

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
593 594 595 596 597 598 599
}

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

600 601
	list_for_each_entry(use, &b->source_list, source_list) {
		if (use->source == a) {
Linus Torvalds's avatar
Linus Torvalds committed
602 603 604 605 606 607 608 609
			DEBUGP("%s uses %s!\n", a->name, b->name);
			return 1;
		}
	}
	DEBUGP("%s does not use %s!\n", a->name, b->name);
	return 0;
}

610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
/*
 * 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;

	DEBUGP("Allocating new usage for %s.\n", a->name);
	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;
}

635
/* Module a uses b: caller needs module_mutex() */
636
int ref_module(struct module *a, struct module *b)
Linus Torvalds's avatar
Linus Torvalds committed
637
{
638
	int err;
Kay Sievers's avatar
Kay Sievers committed
639

640
	if (b == NULL || already_uses(a, b))
641 642
		return 0;

643 644
	/* If module isn't available, we fail. */
	err = strong_try_module_get(b);
645
	if (err)
646
		return err;
Linus Torvalds's avatar
Linus Torvalds committed
647

648 649
	err = add_module_usage(a, b);
	if (err) {
Linus Torvalds's avatar
Linus Torvalds committed
650
		module_put(b);
651
		return err;
Linus Torvalds's avatar
Linus Torvalds committed
652
	}
653
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
654
}
655
EXPORT_SYMBOL_GPL(ref_module);
Linus Torvalds's avatar
Linus Torvalds committed
656 657 658 659

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

662
	mutex_lock(&module_mutex);
663 664 665 666 667 668 669
	list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
		struct module *i = use->target;
		DEBUGP("%s unusing %s\n", mod->name, i->name);
		module_put(i);
		list_del(&use->source_list);
		list_del(&use->target_list);
		kfree(use);
Linus Torvalds's avatar
Linus Torvalds committed
670
	}
671
	mutex_unlock(&module_mutex);
672 673

	free_percpu(mod->refptr);
Linus Torvalds's avatar
Linus Torvalds committed
674 675 676
}

#ifdef CONFIG_MODULE_FORCE_UNLOAD
677
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
678 679 680
{
	int ret = (flags & O_TRUNC);
	if (ret)
681
		add_taint(TAINT_FORCED_RMMOD);
Linus Torvalds's avatar
Linus Torvalds committed
682 683 684
	return ret;
}
#else
685
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
{
	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;

703 704
	/* If it's not unused, quit unless we're forcing. */
	if (module_refcount(sref->mod) != 0) {
705
		if (!(*sref->forced = try_force_unload(sref->flags)))
Linus Torvalds's avatar
Linus Torvalds committed
706 707 708 709 710 711 712 713 714 715
			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)
{
716 717
	if (flags & O_NONBLOCK) {
		struct stopref sref = { mod, flags, forced };
Linus Torvalds's avatar
Linus Torvalds committed
718

719
		return stop_machine(__try_stop_module, &sref, NULL);
720 721 722 723 724 725
	} 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
726 727
}

728
unsigned long module_refcount(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
729
{
730
	unsigned long incs = 0, decs = 0;
731
	int cpu;
Linus Torvalds's avatar
Linus Torvalds committed
732

733
	for_each_possible_cpu(cpu)
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
		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
752 753 754 755 756 757 758 759
}
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)
{
760
	/* Since we might sleep for some time, release the mutex first */
761
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
762 763 764 765 766 767 768 769
	for (;;) {
		DEBUGP("Looking at refcount...\n");
		set_current_state(TASK_UNINTERRUPTIBLE);
		if (module_refcount(mod) == 0)
			break;
		schedule();
	}
	current->state = TASK_RUNNING;
770
	mutex_lock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
771 772
}

773 774
SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
		unsigned int, flags)
Linus Torvalds's avatar
Linus Torvalds committed
775 776
{
	struct module *mod;
777
	char name[MODULE_NAME_LEN];
Linus Torvalds's avatar
Linus Torvalds committed
778 779
	int ret, forced = 0;

780
	if (!capable(CAP_SYS_MODULE) || modules_disabled)
781 782 783 784 785 786
		return -EPERM;

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

787 788
	if (mutex_lock_interruptible(&module_mutex) != 0)
		return -EINTR;
Linus Torvalds's avatar
Linus Torvalds committed
789 790 791 792 793 794 795

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

796
	if (!list_empty(&mod->source_list)) {
Linus Torvalds's avatar
Linus Torvalds committed
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
		/* 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 */
		DEBUGP("%s already dying\n", mod->name);
		ret = -EBUSY;
		goto out;
	}

	/* If it has an init func, it must have an exit func to unload */
812
	if (mod->init && !mod->exit) {
813
		forced = try_force_unload(flags);
Linus Torvalds's avatar
Linus Torvalds committed
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
		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);

833
	mutex_unlock(&module_mutex);
Lucas De Marchi's avatar
Lucas De Marchi committed
834
	/* Final destruction now no one is using it. */
835
	if (mod->exit != NULL)
Linus Torvalds's avatar
Linus Torvalds committed
836
		mod->exit();
837 838
	blocking_notifier_call_chain(&module_notify_list,
				     MODULE_STATE_GOING, mod);
839
	async_synchronize_full();
840

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

844 845 846
	free_module(mod);
	return 0;
out:
847
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
848 849 850
	return ret;
}

851
static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
852 853 854 855
{
	struct module_use *use;
	int printed_something = 0;

856
	seq_printf(m, " %lu ", module_refcount(mod));
Linus Torvalds's avatar
Linus Torvalds committed
857 858 859

	/* Always include a trailing , so userspace can differentiate
           between this and the old multi-field proc format. */
860
	list_for_each_entry(use, &mod->source_list, source_list) {
Linus Torvalds's avatar
Linus Torvalds committed
861
		printed_something = 1;
862
		seq_printf(m, "%s,", use->source->name);
Linus Torvalds's avatar
Linus Torvalds committed
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877
	}

	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
878
	preempt_disable();
879
	if (!find_symbol(symbol, &owner, NULL, true, false))
Linus Torvalds's avatar
Linus Torvalds committed
880 881
		BUG();
	module_put(owner);
Rusty Russell's avatar
Rusty Russell committed
882
	preempt_enable();
Linus Torvalds's avatar
Linus Torvalds committed
883 884 885
}
EXPORT_SYMBOL(__symbol_put);

886
/* Note this assumes addr is a function, which it currently always is. */
Linus Torvalds's avatar
Linus Torvalds committed
887 888
void symbol_put_addr(void *addr)
{
889
	struct module *modaddr;
890
	unsigned long a = (unsigned long)dereference_function_descriptor(addr);
Linus Torvalds's avatar
Linus Torvalds committed
891

892
	if (core_kernel_text(a))
893
		return;
Linus Torvalds's avatar
Linus Torvalds committed
894

895 896
	/* module_text_address is safe here: we're supposed to have reference
	 * to module from symbol_get, so it can't go away. */
897
	modaddr = __module_text_address(a);
898
	BUG_ON(!modaddr);
899
	module_put(modaddr);
Linus Torvalds's avatar
Linus Torvalds committed
900 901 902 903
}
EXPORT_SYMBOL_GPL(symbol_put_addr);

static ssize_t show_refcnt(struct module_attribute *mattr,
904
			   struct module_kobject *mk, char *buffer)
Linus Torvalds's avatar
Linus Torvalds committed
905
{
906
	return sprintf(buffer, "%lu\n", module_refcount(mk->mod));
Linus Torvalds's avatar
Linus Torvalds committed
907 908 909
}

static struct module_attribute refcnt = {
910
	.attr = { .name = "refcnt", .mode = 0444 },
Linus Torvalds's avatar
Linus Torvalds committed
911 912 913
	.show = show_refcnt,
};

Al Viro's avatar
Al Viro committed
914 915 916
void module_put(struct module *module)
{
	if (module) {
917
		preempt_disable();
918 919
		smp_wmb(); /* see comment in module_refcount */
		__this_cpu_inc(module->refptr->decs);
920

921
		trace_module_put(module, _RET_IP_);
Al Viro's avatar
Al Viro committed
922 923 924
		/* Maybe they're waiting for us to drop reference? */
		if (unlikely(!module_is_live(module)))
			wake_up_process(module->waiter);
925
		preempt_enable();
Al Viro's avatar
Al Viro committed
926 927 928 929
	}
}
EXPORT_SYMBOL(module_put);

Linus Torvalds's avatar
Linus Torvalds committed
930
#else /* !CONFIG_MODULE_UNLOAD */
931
static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
932 933 934 935 936 937 938 939 940
{
	/* We don't know the usage count, or what modules are using. */
	seq_printf(m, " - -");
}

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

941
int ref_module(struct module *a, struct module *b)
Linus Torvalds's avatar
Linus Torvalds committed
942
{
943
	return strong_try_module_get(b);
Linus Torvalds's avatar
Linus Torvalds committed
944
}
945
EXPORT_SYMBOL_GPL(ref_module);
Linus Torvalds's avatar
Linus Torvalds committed
946

947
static inline int module_unload_init(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
948
{
949
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
950 951 952
}
#endif /* CONFIG_MODULE_UNLOAD */

953
static ssize_t show_initstate(struct module_attribute *mattr,
954
			      struct module_kobject *mk, char *buffer)
955 956 957
{
	const char *state = "unknown";

958
	switch (mk->mod->state) {
959 960 961 962 963 964 965 966 967 968 969 970 971 972
	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);
}

static struct module_attribute initstate = {
973
	.attr = { .name = "initstate", .mode = 0444 },
974 975 976
	.show = show_initstate,
};

977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992
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;
}

struct module_attribute module_uevent = {
	.attr = { .name = "uevent", .mode = 0200 },
	.store = store_uevent,
};

993 994 995
static struct module_attribute *modinfo_attrs[] = {
	&modinfo_version,
	&modinfo_srcversion,
996
	&initstate,
997
	&module_uevent,
998 999 1000 1001 1002 1003
#ifdef CONFIG_MODULE_UNLOAD
	&refcnt,
#endif
	NULL,
};

Linus Torvalds's avatar
Linus Torvalds committed
1004 1005
static const char vermagic[] = VERMAGIC_STRING;

1006
static int try_to_force_load(struct module *mod, const char *reason)
1007 1008
{
#ifdef CONFIG_MODULE_FORCE_LOAD
Andi Kleen's avatar
Andi Kleen committed
1009
	if (!test_taint(TAINT_FORCED_MODULE))
1010 1011
		printk(KERN_WARNING "%s: %s: kernel tainted.\n",
		       mod->name, reason);
1012 1013 1014 1015 1016 1017 1018
	add_taint_module(mod, TAINT_FORCED_MODULE);
	return 0;
#else
	return -ENOEXEC;
#endif
}

Linus Torvalds's avatar
Linus Torvalds committed
1019
#ifdef CONFIG_MODVERSIONS
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
/* If the arch applies (non-zero) relocations to kernel kcrctab, unapply it. */
static unsigned long maybe_relocated(unsigned long crc,
				     const struct module *crc_owner)
{
#ifdef ARCH_RELOCATES_KCRCTAB
	if (crc_owner == NULL)
		return crc - (unsigned long)reloc_start;
#endif
	return crc;
}

Linus Torvalds's avatar
Linus Torvalds committed
1031 1032 1033 1034
static int check_version(Elf_Shdr *sechdrs,
			 unsigned int versindex,
			 const char *symname,
			 struct module *mod, 
1035 1036
			 const unsigned long *crc,
			 const struct module *crc_owner)
Linus Torvalds's avatar
Linus Torvalds committed
1037 1038 1039 1040 1041 1042 1043 1044
{
	unsigned int i, num_versions;
	struct modversion_info *versions;

	/* Exporting module didn't supply crcs?  OK, we're already tainted. */
	if (!crc)
		return 1;

1045 1046 1047 1048
	/* No versions at all?  modprobe --force does this. */
	if (versindex == 0)
		return try_to_force_load(mod, symname) == 0;

Linus Torvalds's avatar
Linus Torvalds committed
1049 1050 1051 1052 1053 1054 1055 1056
	versions = (void *) sechdrs[versindex].sh_addr;
	num_versions = sechdrs[versindex].sh_size
		/ sizeof(struct modversion_info);

	for (i = 0; i < num_versions; i++) {
		if (strcmp(versions[i].name, symname) != 0)
			continue;

1057
		if (versions[i].crc == maybe_relocated(*crc, crc_owner))
Linus Torvalds's avatar
Linus Torvalds committed
1058 1059
			return 1;
		DEBUGP("Found checksum %lX vs module %lX\n",
1060
		       maybe_relocated(*crc, crc_owner), versions[i].crc);
1061
		goto bad_version;
Linus Torvalds's avatar
Linus Torvalds committed
1062
	}
1063

1064 1065 1066
	printk(KERN_WARNING "%s: no symbol version for %s\n",
	       mod->name, symname);
	return 0;
1067 1068 1069 1070 1071

bad_version:
	printk("%s: disagrees about version of symbol %s\n",
	       mod->name, symname);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1072 1073 1074 1075 1076 1077 1078 1079
}

static inline int check_modstruct_version(Elf_Shdr *sechdrs,
					  unsigned int versindex,
					  struct module *mod)
{
	const unsigned long *crc;

1080 1081
	/* Since this should be found in kernel (which can't be removed),
	 * no locking is necessary. */
1082 1083