module.c 97.7 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>
32
#include <linux/security.h>
Linus Torvalds's avatar
Linus Torvalds committed
33
34
35
36
#include <linux/seq_file.h>
#include <linux/syscalls.h>
#include <linux/fcntl.h>
#include <linux/rcupdate.h>
37
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
38
39
40
41
42
43
#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
44
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
45
#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/kasan.h>
60
#include <linux/jump_label.h>
61
#include <linux/pfn.h>
62
#include <linux/bsearch.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 and 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
#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 = {
138
	.flags = KERNEL_PARAM_OPS_FL_NOARG,
139
140
141
142
143
144
145
146
	.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
147

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

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

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

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

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

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

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

187
188
/* 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
189
190
static inline int strong_try_module_get(struct module *mod)
{
191
	BUG_ON(mod && mod->state == MODULE_STATE_UNFORMED);
Linus Torvalds's avatar
Linus Torvalds committed
192
	if (mod && mod->state == MODULE_STATE_COMING)
193
194
		return -EBUSY;
	if (try_module_get(mod))
Linus Torvalds's avatar
Linus Torvalds committed
195
		return 0;
196
197
	else
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
198
199
}

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

207
208
209
/*
 * 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
210
211
212
213
214
215
216
 */
void __module_put_and_exit(struct module *mod, long code)
{
	module_put(mod);
	do_exit(code);
}
EXPORT_SYMBOL(__module_put_and_exit);
217

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

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

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

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

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

Linus Torvalds's avatar
Linus Torvalds committed
253
254
255
256
257
/* 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[];
258
259
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
260
261
extern const unsigned long __start___kcrctab[];
extern const unsigned long __start___kcrctab_gpl[];
262
extern const unsigned long __start___kcrctab_gpl_future[];
263
264
265
266
267
#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[];
268
269
extern const unsigned long __start___kcrctab_unused[];
extern const unsigned long __start___kcrctab_unused_gpl[];
270
#endif
Linus Torvalds's avatar
Linus Torvalds committed
271
272
273
274

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

278
279
280
281
282
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,
283
					      void *data),
284
				   void *data)
285
{
286
	unsigned int j;
287

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

	return false;
294
295
}

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

322
323
	if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
		return true;
324

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

348
349
350
		if (mod->state == MODULE_STATE_UNFORMED)
			continue;

351
352
353
354
355
		if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
			return true;
	}
	return false;
}
356
EXPORT_SYMBOL_GPL(each_symbol_section);
357
358
359
360
361
362
363
364
365
366

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

	/* Output */
	struct module *owner;
	const unsigned long *crc;
367
	const struct kernel_symbol *sym;
368
369
};

370
371
372
static bool check_symbol(const struct symsearch *syms,
				 struct module *owner,
				 unsigned int symnum, void *data)
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) {
Andrew Morton's avatar
Andrew Morton committed
380
381
382
			pr_warn("Symbol %s is being used by a non-GPL module, "
				"which will not be allowed in the future\n",
				fsa->name);
383
		}
Linus Torvalds's avatar
Linus Torvalds committed
384
	}
385

386
#ifdef CONFIG_UNUSED_SYMBOLS
387
	if (syms->unused && fsa->warn) {
Andrew Morton's avatar
Andrew Morton committed
388
389
390
391
392
393
394
		pr_warn("Symbol %s is marked as UNUSED, however this module is "
			"using it.\n", fsa->name);
		pr_warn("This symbol will go away in the future.\n");
		pr_warn("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
	}
396
#endif
397
398
399

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

404
405
406
407
408
409
410
411
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);
}

412
413
414
415
416
static bool find_symbol_in_section(const struct symsearch *syms,
				   struct module *owner,
				   void *data)
{
	struct find_symbol_arg *fsa = data;
417
418
419
420
421
422
423
	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;
424
425
426
427

	return false;
}

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

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

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

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

/* Search for module by name: must hold module_mutex. */
456
static struct module *find_module_all(const char *name, size_t len,
457
				      bool even_unformed)
Linus Torvalds's avatar
Linus Torvalds committed
458
459
460
461
{
	struct module *mod;

	list_for_each_entry(mod, &modules, list) {
462
463
		if (!even_unformed && mod->state == MODULE_STATE_UNFORMED)
			continue;
464
		if (strlen(mod->name) == len && !memcmp(mod->name, name, len))
Linus Torvalds's avatar
Linus Torvalds committed
465
466
467
468
			return mod;
	}
	return NULL;
}
469
470
471

struct module *find_module(const char *name)
{
472
	return find_module_all(name, strlen(name), false);
473
}
474
EXPORT_SYMBOL_GPL(find_module);
Linus Torvalds's avatar
Linus Torvalds committed
475
476

#ifdef CONFIG_SMP
477

478
static inline void __percpu *mod_percpu(struct module *mod)
479
{
480
481
	return mod->percpu;
}
482

Rusty Russell's avatar
Rusty Russell committed
483
static int percpu_modalloc(struct module *mod, struct load_info *info)
484
{
Rusty Russell's avatar
Rusty Russell committed
485
486
487
488
489
490
	Elf_Shdr *pcpusec = &info->sechdrs[info->index.pcpu];
	unsigned long align = pcpusec->sh_addralign;

	if (!pcpusec->sh_size)
		return 0;

491
	if (align > PAGE_SIZE) {
Andrew Morton's avatar
Andrew Morton committed
492
493
		pr_warn("%s: per-cpu alignment %li > %li\n",
			mod->name, align, PAGE_SIZE);
494
495
496
		align = PAGE_SIZE;
	}

Rusty Russell's avatar
Rusty Russell committed
497
	mod->percpu = __alloc_reserved_percpu(pcpusec->sh_size, align);
498
	if (!mod->percpu) {
Andrew Morton's avatar
Andrew Morton committed
499
500
		pr_warn("%s: Could not allocate %lu bytes percpu data\n",
			mod->name, (unsigned long)pcpusec->sh_size);
501
502
		return -ENOMEM;
	}
Rusty Russell's avatar
Rusty Russell committed
503
	mod->percpu_size = pcpusec->sh_size;
504
	return 0;
505
506
}

507
static void percpu_modfree(struct module *mod)
508
{
509
	free_percpu(mod->percpu);
510
511
}

512
static unsigned int find_pcpusec(struct load_info *info)
513
{
514
	return find_sec(info, ".data..percpu");
515
516
}

517
518
static void percpu_modcopy(struct module *mod,
			   const void *from, unsigned long size)
519
520
521
522
{
	int cpu;

	for_each_possible_cpu(cpu)
523
		memcpy(per_cpu_ptr(mod->percpu, cpu), from, size);
524
525
}

526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
/**
 * 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) {
543
544
		if (mod->state == MODULE_STATE_UNFORMED)
			continue;
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
		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;
560
561
}

Linus Torvalds's avatar
Linus Torvalds committed
562
#else /* ... !CONFIG_SMP */
563

564
static inline void __percpu *mod_percpu(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
565
566
567
{
	return NULL;
}
Rusty Russell's avatar
Rusty Russell committed
568
static int percpu_modalloc(struct module *mod, struct load_info *info)
569
{
Rusty Russell's avatar
Rusty Russell committed
570
571
572
573
	/* UP modules shouldn't have this section: ENOMEM isn't quite right */
	if (info->sechdrs[info->index.pcpu].sh_size != 0)
		return -ENOMEM;
	return 0;
574
575
}
static inline void percpu_modfree(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
576
577
{
}
578
static unsigned int find_pcpusec(struct load_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
579
580
581
{
	return 0;
}
582
583
static inline void percpu_modcopy(struct module *mod,
				  const void *from, unsigned long size)
Linus Torvalds's avatar
Linus Torvalds committed
584
585
586
587
{
	/* pcpusec should be 0, and size of that section should be 0. */
	BUG_ON(size != 0);
}
588
589
590
591
bool is_module_percpu_address(unsigned long addr)
{
	return false;
}
592

Linus Torvalds's avatar
Linus Torvalds committed
593
594
#endif /* CONFIG_SMP */

595
596
597
598
599
600
#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,   \
601
			struct module_kobject *mk, char *buffer)      \
602
{                                                                     \
603
	return scnprintf(buffer, PAGE_SIZE, "%s\n", mk->mod->field);  \
604
605
606
607
608
609
610
}                                                                     \
static int modinfo_##field##_exists(struct module *mod)               \
{                                                                     \
	return mod->field != NULL;                                    \
}                                                                     \
static void free_modinfo_##field(struct module *mod)                  \
{                                                                     \
611
612
	kfree(mod->field);                                            \
	mod->field = NULL;                                            \
613
614
}                                                                     \
static struct module_attribute modinfo_##field = {                    \
615
	.attr = { .name = __stringify(field), .mode = 0444 },         \
616
617
618
619
620
621
622
623
624
	.show = show_modinfo_##field,                                 \
	.setup = setup_modinfo_##field,                               \
	.test = modinfo_##field##_exists,                             \
	.free = free_modinfo_##field,                                 \
};

MODINFO_ATTR(version);
MODINFO_ATTR(srcversion);

625
626
static char last_unloaded_module[MODULE_NAME_LEN+1];

627
#ifdef CONFIG_MODULE_UNLOAD
628
629
630

EXPORT_TRACEPOINT_SYMBOL(module_get);

631
632
633
/* MODULE_REF_BASE is the base reference count by kmodule loader. */
#define MODULE_REF_BASE	1

Linus Torvalds's avatar
Linus Torvalds committed
634
/* Init the unload section of the module. */
635
static int module_unload_init(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
636
{
637
638
639
640
641
	/*
	 * Initialize reference counter to MODULE_REF_BASE.
	 * refcnt == 0 means module is going.
	 */
	atomic_set(&mod->refcnt, MODULE_REF_BASE);
642

643
644
	INIT_LIST_HEAD(&mod->source_list);
	INIT_LIST_HEAD(&mod->target_list);
645

Linus Torvalds's avatar
Linus Torvalds committed
646
	/* Hold reference count during initialization. */
647
	atomic_inc(&mod->refcnt);
648
649

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
650
651
652
653
654
655
656
}

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

657
658
	list_for_each_entry(use, &b->source_list, source_list) {
		if (use->source == a) {
659
			pr_debug("%s uses %s!\n", a->name, b->name);
Linus Torvalds's avatar
Linus Torvalds committed
660
661
662
			return 1;
		}
	}
663
	pr_debug("%s does not use %s!\n", a->name, b->name);
Linus Torvalds's avatar
Linus Torvalds committed
664
665
666
	return 0;
}

667
668
669
670
671
672
673
674
675
676
677
/*
 * 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;

678
	pr_debug("Allocating new usage for %s.\n", a->name);
679
680
	use = kmalloc(sizeof(*use), GFP_ATOMIC);
	if (!use) {
Andrew Morton's avatar
Andrew Morton committed
681
		pr_warn("%s: out of memory loading\n", a->name);
682
683
684
685
686
687
688
689
690
691
		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;
}

692
/* Module a uses b: caller needs module_mutex() */
693
int ref_module(struct module *a, struct module *b)
Linus Torvalds's avatar
Linus Torvalds committed
694
{
695
	int err;
Kay Sievers's avatar
Kay Sievers committed
696

697
	if (b == NULL || already_uses(a, b))
698
699
		return 0;

700
701
	/* If module isn't available, we fail. */
	err = strong_try_module_get(b);
702
	if (err)
703
		return err;
Linus Torvalds's avatar
Linus Torvalds committed
704

705
706
	err = add_module_usage(a, b);
	if (err) {
Linus Torvalds's avatar
Linus Torvalds committed
707
		module_put(b);
708
		return err;
Linus Torvalds's avatar
Linus Torvalds committed
709
	}
710
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
711
}
712
EXPORT_SYMBOL_GPL(ref_module);
Linus Torvalds's avatar
Linus Torvalds committed
713
714
715
716

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

719
	mutex_lock(&module_mutex);
720
721
	list_for_each_entry_safe(use, tmp, &mod->target_list, target_list) {
		struct module *i = use->target;
722
		pr_debug("%s unusing %s\n", mod->name, i->name);
723
724
725
726
		module_put(i);
		list_del(&use->source_list);
		list_del(&use->target_list);
		kfree(use);
Linus Torvalds's avatar
Linus Torvalds committed
727
	}
728
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
729
730
731
}

#ifdef CONFIG_MODULE_FORCE_UNLOAD
732
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
733
734
735
{
	int ret = (flags & O_TRUNC);
	if (ret)
736
		add_taint(TAINT_FORCED_RMMOD, LOCKDEP_NOW_UNRELIABLE);
Linus Torvalds's avatar
Linus Torvalds committed
737
738
739
	return ret;
}
#else
740
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
741
742
743
744
745
{
	return 0;
}
#endif /* CONFIG_MODULE_FORCE_UNLOAD */

746
747
/* Try to release refcount of module, 0 means success. */
static int try_release_module_ref(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
748
{
749
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
750

751
752
753
754
755
756
	/* Try to decrement refcnt which we set at loading */
	ret = atomic_sub_return(MODULE_REF_BASE, &mod->refcnt);
	BUG_ON(ret < 0);
	if (ret)
		/* Someone can put this right now, recover with checking */
		ret = atomic_add_unless(&mod->refcnt, MODULE_REF_BASE, 0);
Linus Torvalds's avatar
Linus Torvalds committed
757

758
759
	return ret;
}
Linus Torvalds's avatar
Linus Torvalds committed
760

761
762
static int try_stop_module(struct module *mod, int flags, int *forced)
{
763
	/* If it's not unused, quit unless we're forcing. */
764
765
766
	if (try_release_module_ref(mod) != 0) {
		*forced = try_force_unload(flags);
		if (!(*forced))
Linus Torvalds's avatar
Linus Torvalds committed
767
768
769
770
			return -EWOULDBLOCK;
	}

	/* Mark it as dying. */
771
	mod->state = MODULE_STATE_GOING;
Linus Torvalds's avatar
Linus Torvalds committed
772

773
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
774
775
}

776
777
778
779
780
781
782
783
784
785
/**
 * module_refcount - return the refcount or -1 if unloading
 *
 * @mod:	the module we're checking
 *
 * Returns:
 *	-1 if the module is in the process of unloading
 *	otherwise the number of references in the kernel to the module
 */
int module_refcount(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
786
{
787
	return atomic_read(&mod->refcnt) - MODULE_REF_BASE;
Linus Torvalds's avatar
Linus Torvalds committed
788
789
790
791
792
793
}
EXPORT_SYMBOL(module_refcount);

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

794
795
SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
		unsigned int, flags)
Linus Torvalds's avatar
Linus Torvalds committed
796
797
{
	struct module *mod;
798
	char name[MODULE_NAME_LEN];
Linus Torvalds's avatar
Linus Torvalds committed
799
800
	int ret, forced = 0;

801
	if (!capable(CAP_SYS_MODULE) || modules_disabled)
802
803
804
805
806
807
		return -EPERM;

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

808
809
	if (mutex_lock_interruptible(&module_mutex) != 0)
		return -EINTR;
Linus Torvalds's avatar
Linus Torvalds committed
810
811
812
813
814
815
816

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

817
	if (!list_empty(&mod->source_list)) {
Linus Torvalds's avatar
Linus Torvalds committed
818
819
820
821
822
823
824
		/* 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) {
825
		/* FIXME: if (force), slam module count damn the torpedoes */
826
		pr_debug("%s already dying\n", mod->name);
Linus Torvalds's avatar
Linus Torvalds committed
827
828
829
830
831
		ret = -EBUSY;
		goto out;
	}

	/* If it has an init func, it must have an exit func to unload */
832
	if (mod->init && !mod->exit) {
833
		forced = try_force_unload(flags);
Linus Torvalds's avatar
Linus Torvalds committed
834
835
836
837
838
839
840
841
842
843
844
845
		if (!forced) {
			/* This module can't be removed */
			ret = -EBUSY;
			goto out;
		}
	}

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

846
	mutex_unlock(&module_mutex);
Lucas De Marchi's avatar
Lucas De Marchi committed
847
	/* Final destruction now no one is using it. */
848
	if (mod->exit != NULL)
Linus Torvalds's avatar
Linus Torvalds committed
849
		mod->exit();
850
851
	blocking_notifier_call_chain(&module_notify_list,
				     MODULE_STATE_GOING, mod);
852
	async_synchronize_full();
853

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

857
858
859
	free_module(mod);
	return 0;
out:
860
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
861
862
863
	return ret;
}

864
static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
865
866
867
868
{
	struct module_use *use;
	int printed_something = 0;

869
	seq_printf(m, " %i ", module_refcount(mod));
Linus Torvalds's avatar
Linus Torvalds committed
870

871
872
873
874
	/*
	 * Always include a trailing , so userspace can differentiate
	 * between this and the old multi-field proc format.
	 */
875
	list_for_each_entry(use, &mod->source_list, source_list) {
Linus Torvalds's avatar
Linus Torvalds committed
876
		printed_something = 1;
877
		seq_printf(m, "%s,", use->source->name);
Linus Torvalds's avatar
Linus Torvalds committed
878
879
880
881
	}

	if (mod->init != NULL && mod->exit == NULL) {
		printed_something = 1;
882
		seq_puts(m, "[permanent],");
Linus Torvalds's avatar
Linus Torvalds committed
883
884
885
	}

	if (!printed_something)
886
		seq_puts(m, "-");
Linus Torvalds's avatar
Linus Torvalds committed
887
888
889
890
891
892
}

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

Rusty Russell's avatar
Rusty Russell committed
893
	preempt_disable();
894
	if (!find_symbol(symbol, &owner, NULL, true, false))
Linus Torvalds's avatar
Linus Torvalds committed
895
896
		BUG();
	module_put(owner);
Rusty Russell's avatar
Rusty Russell committed
897
	preempt_enable();
Linus Torvalds's avatar
Linus Torvalds committed
898
899
900
}
EXPORT_SYMBOL(__symbol_put);

901
/* Note this assumes addr is a function, which it currently always is. */
Linus Torvalds's avatar
Linus Torvalds committed
902
903
void symbol_put_addr(void *addr)
{
904
	struct module *modaddr;
905
	unsigned long a = (unsigned long)dereference_function_descriptor(addr);
Linus Torvalds's avatar
Linus Torvalds committed
906

907
	if (core_kernel_text(a))
908
		return;
Linus Torvalds's avatar
Linus Torvalds committed
909

910
911
	/* module_text_address is safe here: we're supposed to have reference
	 * to module from symbol_get, so it can't go away. */
912
	modaddr = __module_text_address(a);
913
	BUG_ON(!modaddr);
914
	module_put(modaddr);
Linus Torvalds's avatar
Linus Torvalds committed
915
916
917
918
}
EXPORT_SYMBOL_GPL(symbol_put_addr);

static ssize_t show_refcnt(struct module_attribute *mattr,
919
			   struct module_kobject *mk, char *buffer)
Linus Torvalds's avatar
Linus Torvalds committed
920
{
921
	return sprintf(buffer, "%i\n", module_refcount(mk->mod));
Linus Torvalds's avatar
Linus Torvalds committed
922
923
}

924
925
static struct module_attribute modinfo_refcnt =
	__ATTR(refcnt, 0444, show_refcnt, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
926

927
928
929
930
void __module_get(struct module *module)
{
	if (module) {
		preempt_disable();
931
		atomic_inc(&module->refcnt);
932
933
934
935
936
937
938
939
940
941
942
943
		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();
944
945
946
		/* Note: here, we can fail to get a reference */
		if (likely(module_is_live(module) &&
			   atomic_inc_not_zero(&module->refcnt) != 0))
947
			trace_module_get(module, _RET_IP_);
948
		else
949
950
951
952
953
954
955
956
			ret = false;

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

Al Viro's avatar
Al Viro committed
957
958
void module_put(struct module *module)
{
959
960
	int ret;

Al Viro's avatar
Al Viro committed
961
	if (module) {
962
		preempt_disable();
963
964
		ret = atomic_dec_if_positive(&module->refcnt);
		WARN_ON(ret < 0);	/* Failed to put refcount */
965
		trace_module_put(module, _RET_IP_);
966
		preempt_enable();
Al Viro's avatar
Al Viro committed
967
968
969
970
	}
}
EXPORT_SYMBOL(module_put);

Linus Torvalds's avatar
Linus Torvalds committed
971
#else /* !CONFIG_MODULE_UNLOAD */
972
static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
973
974
{
	/* We don't know the usage count, or what modules are using. */
975
	seq_puts(m, " - -");
Linus Torvalds's avatar
Linus Torvalds committed
976
977
978
979
980
981
}

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

982
int ref_module(struct module *a, struct module *b)
Linus Torvalds's avatar
Linus Torvalds committed
983
{
984
	return strong_try_module_get(b);
Linus Torvalds's avatar
Linus Torvalds committed
985
}
986
EXPORT_SYMBOL_GPL(ref_module);
Linus Torvalds's avatar
Linus Torvalds committed
987

988
static inline int module_unload_init(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
989
{
990
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
991
992
993
}
#endif /* CONFIG_MODULE_UNLOAD */

994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
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';
1006
	if (mod->taints & (1 << TAINT_UNSIGNED_MODULE))
1007
		buf[l++] = 'E';
1008
1009
	/*
	 * TAINT_FORCED_RMMOD: could be added.
1010
	 * TAINT_CPU_OUT_OF_SPEC, TAINT_MACHINE_CHECK, TAINT_BAD_PAGE don't
1011
1012
1013
1014
1015
	 * apply to modules.
	 */
	return l;
}

1016
static ssize_t show_initstate(struct module_attribute *mattr,
1017
			      struct module_kobject *mk, char *buffer)
1018
1019
1020
{
	const char *state = "unknown";

Kay Sievers's avatar