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

    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
*/
#include <linux/module.h>
#include <linux/moduleloader.h>
#include <linux/init.h>
22
#include <linux/kallsyms.h>
Roland McGrath's avatar
Roland McGrath committed
23
#include <linux/sysfs.h>
24
#include <linux/kernel.h>
Linus Torvalds's avatar
Linus Torvalds committed
25
26
27
28
29
30
31
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/elf.h>
#include <linux/seq_file.h>
#include <linux/syscalls.h>
#include <linux/fcntl.h>
#include <linux/rcupdate.h>
32
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
33
34
35
36
37
38
#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
39
#include <linux/sched.h>
Linus Torvalds's avatar
Linus Torvalds committed
40
41
#include <linux/stop_machine.h>
#include <linux/device.h>
42
#include <linux/string.h>
Arjan van de Ven's avatar
Arjan van de Ven committed
43
#include <linux/mutex.h>
44
#include <linux/unwind.h>
Linus Torvalds's avatar
Linus Torvalds committed
45
46
#include <asm/uaccess.h>
#include <asm/cacheflush.h>
47
#include <linux/license.h>
48
#include <asm/sections.h>
Linus Torvalds's avatar
Linus Torvalds committed
49
50
51
52
53
54
55
56
57
58
59
60
61
62

#if 0
#define DEBUGP printk
#else
#define DEBUGP(fmt , a...)
#endif

#ifndef ARCH_SHF_SMALL
#define ARCH_SHF_SMALL 0
#endif

/* If this is set, the section belongs in the init part of the module */
#define INIT_OFFSET_MASK (1UL << (BITS_PER_LONG-1))

Rusty Russell's avatar
Rusty Russell committed
63
64
/* List of modules, protected by module_mutex or preempt_disable
 * (add/delete uses stop_machine). */
65
static DEFINE_MUTEX(module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
66
67
static LIST_HEAD(modules);

68
69
70
/* Waiting for a module to finish initializing? */
static DECLARE_WAIT_QUEUE_HEAD(module_wq);

71
static BLOCKING_NOTIFIER_HEAD(module_notify_list);
Linus Torvalds's avatar
Linus Torvalds committed
72

73
74
75
/* Bounds of module allocation, for speeding __module_text_address */
static unsigned long module_addr_min = -1UL, module_addr_max = 0;

Linus Torvalds's avatar
Linus Torvalds committed
76
77
int register_module_notifier(struct notifier_block * nb)
{
78
	return blocking_notifier_chain_register(&module_notify_list, nb);
Linus Torvalds's avatar
Linus Torvalds committed
79
80
81
82
83
}
EXPORT_SYMBOL(register_module_notifier);

int unregister_module_notifier(struct notifier_block * nb)
{
84
	return blocking_notifier_chain_unregister(&module_notify_list, nb);
Linus Torvalds's avatar
Linus Torvalds committed
85
86
87
}
EXPORT_SYMBOL(unregister_module_notifier);

88
89
/* 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
90
91
92
static inline int strong_try_module_get(struct module *mod)
{
	if (mod && mod->state == MODULE_STATE_COMING)
93
94
		return -EBUSY;
	if (try_module_get(mod))
Linus Torvalds's avatar
Linus Torvalds committed
95
		return 0;
96
97
	else
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
98
99
}

100
101
102
103
104
105
static inline void add_taint_module(struct module *mod, unsigned flag)
{
	add_taint(flag);
	mod->taints |= flag;
}

106
107
108
/*
 * 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
109
110
111
112
113
114
115
 */
void __module_put_and_exit(struct module *mod, long code)
{
	module_put(mod);
	do_exit(code);
}
EXPORT_SYMBOL(__module_put_and_exit);
116

Linus Torvalds's avatar
Linus Torvalds committed
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
/* Find a module section: 0 means not found. */
static unsigned int find_sec(Elf_Ehdr *hdr,
			     Elf_Shdr *sechdrs,
			     const char *secstrings,
			     const char *name)
{
	unsigned int i;

	for (i = 1; i < hdr->e_shnum; i++)
		/* Alloc bit cleared means "ignore it." */
		if ((sechdrs[i].sh_flags & SHF_ALLOC)
		    && strcmp(secstrings+sechdrs[i].sh_name, name) == 0)
			return i;
	return 0;
}

/* 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[];
138
139
extern const struct kernel_symbol __start___ksymtab_gpl_future[];
extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
140
141
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
142
143
extern const unsigned long __start___kcrctab[];
extern const unsigned long __start___kcrctab_gpl[];
144
extern const unsigned long __start___kcrctab_gpl_future[];
145
146
147
148
149
#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[];
150
151
extern const unsigned long __start___kcrctab_unused[];
extern const unsigned long __start___kcrctab_unused_gpl[];
152
#endif
Linus Torvalds's avatar
Linus Torvalds committed
153
154
155
156

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

160
161
162
struct symsearch {
	const struct kernel_symbol *start, *stop;
	const unsigned long *crcs;
163
164
165
166
167
168
	enum {
		NOT_GPL_ONLY,
		GPL_ONLY,
		WILL_BE_GPL_ONLY,
	} licence;
	bool unused;
169
170
};

171
172
173
174
175
176
177
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,
					      unsigned int symnum, void *data),
				   void *data)
178
{
179
	unsigned int i, j;
180

181
182
183
184
	for (j = 0; j < arrsize; j++) {
		for (i = 0; i < arr[j].stop - arr[j].start; i++)
			if (fn(&arr[j], owner, i, data))
				return true;
185
	}
186
187

	return false;
188
189
}

190
191
192
193
194
/* Returns true as soon as fn returns true, otherwise false. */
static bool each_symbol(bool (*fn)(const struct symsearch *arr,
				   struct module *owner,
				   unsigned int symnum, void *data),
			void *data)
195
196
197
198
{
	struct module *mod;
	const struct symsearch arr[] = {
		{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,
199
		  NOT_GPL_ONLY, false },
200
		{ __start___ksymtab_gpl, __stop___ksymtab_gpl,
201
202
		  __start___kcrctab_gpl,
		  GPL_ONLY, false },
203
		{ __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,
204
205
		  __start___kcrctab_gpl_future,
		  WILL_BE_GPL_ONLY, false },
206
#ifdef CONFIG_UNUSED_SYMBOLS
207
		{ __start___ksymtab_unused, __stop___ksymtab_unused,
208
209
		  __start___kcrctab_unused,
		  NOT_GPL_ONLY, true },
210
		{ __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,
211
212
		  __start___kcrctab_unused_gpl,
		  GPL_ONLY, true },
213
#endif
214
	};
215

216
217
	if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
		return true;
218

Linus Torvalds's avatar
Linus Torvalds committed
219
	list_for_each_entry(mod, &modules, list) {
220
221
		struct symsearch arr[] = {
			{ mod->syms, mod->syms + mod->num_syms, mod->crcs,
222
			  NOT_GPL_ONLY, false },
223
			{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
224
225
			  mod->gpl_crcs,
			  GPL_ONLY, false },
226
227
			{ mod->gpl_future_syms,
			  mod->gpl_future_syms + mod->num_gpl_future_syms,
228
229
			  mod->gpl_future_crcs,
			  WILL_BE_GPL_ONLY, false },
230
#ifdef CONFIG_UNUSED_SYMBOLS
231
232
			{ mod->unused_syms,
			  mod->unused_syms + mod->num_unused_syms,
233
234
			  mod->unused_crcs,
			  NOT_GPL_ONLY, true },
235
236
			{ mod->unused_gpl_syms,
			  mod->unused_gpl_syms + mod->num_unused_gpl_syms,
237
238
			  mod->unused_gpl_crcs,
			  GPL_ONLY, true },
239
#endif
240
241
		};

242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
		if (each_symbol_in_section(arr, ARRAY_SIZE(arr), mod, fn, data))
			return true;
	}
	return false;
}

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

	/* Output */
	struct module *owner;
	const unsigned long *crc;
	unsigned long value;
};

static bool find_symbol_in_section(const struct symsearch *syms,
				   struct module *owner,
				   unsigned int symnum, void *data)
{
	struct find_symbol_arg *fsa = data;

	if (strcmp(syms->start[symnum].name, fsa->name) != 0)
		return false;

	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");
279
		}
Linus Torvalds's avatar
Linus Torvalds committed
280
	}
281

282
#ifdef CONFIG_UNUSED_SYMBOLS
283
284
285
286
287
288
289
290
291
292
293
	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");
	}
294
#endif
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323

	fsa->owner = owner;
	fsa->crc = symversion(syms->crcs, symnum);
	fsa->value = syms->start[symnum].value;
	return true;
}

/* Find a symbol, return value, (optional) crc and (optional) module
 * which owns it */
static unsigned long find_symbol(const char *name,
				 struct module **owner,
				 const unsigned long **crc,
				 bool gplok,
				 bool warn)
{
	struct find_symbol_arg fsa;

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

	if (each_symbol(find_symbol_in_section, &fsa)) {
		if (owner)
			*owner = fsa.owner;
		if (crc)
			*crc = fsa.crc;
		return fsa.value;
	}

Linus Torvalds's avatar
Linus Torvalds committed
324
	DEBUGP("Failed to find symbol %s\n", name);
325
	return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
}

/* Search for module by name: must hold module_mutex. */
static struct module *find_module(const char *name)
{
	struct module *mod;

	list_for_each_entry(mod, &modules, list) {
		if (strcmp(mod->name, name) == 0)
			return mod;
	}
	return NULL;
}

#ifdef CONFIG_SMP
/* Number of blocks used and allocated. */
static unsigned int pcpu_num_used, pcpu_num_allocated;
/* Size of each block.  -ve means used. */
static int *pcpu_size;

static int split_block(unsigned int i, unsigned short size)
{
	/* Reallocation required? */
	if (pcpu_num_used + 1 > pcpu_num_allocated) {
Pekka Enberg's avatar
Pekka Enberg committed
350
351
352
353
		int *new;

		new = krealloc(pcpu_size, sizeof(new[0])*pcpu_num_allocated*2,
			       GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
		if (!new)
			return 0;

		pcpu_num_allocated *= 2;
		pcpu_size = new;
	}

	/* Insert a new subblock */
	memmove(&pcpu_size[i+1], &pcpu_size[i],
		sizeof(pcpu_size[0]) * (pcpu_num_used - i));
	pcpu_num_used++;

	pcpu_size[i+1] -= size;
	pcpu_size[i] = size;
	return 1;
}

static inline unsigned int block_size(int val)
{
	if (val < 0)
		return -val;
	return val;
}

378
379
static void *percpu_modalloc(unsigned long size, unsigned long align,
			     const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
380
381
382
383
384
{
	unsigned long extra;
	unsigned int i;
	void *ptr;

385
386
387
388
	if (align > PAGE_SIZE) {
		printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
		       name, align, PAGE_SIZE);
		align = PAGE_SIZE;
389
	}
Linus Torvalds's avatar
Linus Torvalds committed
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461

	ptr = __per_cpu_start;
	for (i = 0; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) {
		/* Extra for alignment requirement. */
		extra = ALIGN((unsigned long)ptr, align) - (unsigned long)ptr;
		BUG_ON(i == 0 && extra != 0);

		if (pcpu_size[i] < 0 || pcpu_size[i] < extra + size)
			continue;

		/* Transfer extra to previous block. */
		if (pcpu_size[i-1] < 0)
			pcpu_size[i-1] -= extra;
		else
			pcpu_size[i-1] += extra;
		pcpu_size[i] -= extra;
		ptr += extra;

		/* Split block if warranted */
		if (pcpu_size[i] - size > sizeof(unsigned long))
			if (!split_block(i, size))
				return NULL;

		/* Mark allocated */
		pcpu_size[i] = -pcpu_size[i];
		return ptr;
	}

	printk(KERN_WARNING "Could not allocate %lu bytes percpu data\n",
	       size);
	return NULL;
}

static void percpu_modfree(void *freeme)
{
	unsigned int i;
	void *ptr = __per_cpu_start + block_size(pcpu_size[0]);

	/* First entry is core kernel percpu data. */
	for (i = 1; i < pcpu_num_used; ptr += block_size(pcpu_size[i]), i++) {
		if (ptr == freeme) {
			pcpu_size[i] = -pcpu_size[i];
			goto free;
		}
	}
	BUG();

 free:
	/* Merge with previous? */
	if (pcpu_size[i-1] >= 0) {
		pcpu_size[i-1] += pcpu_size[i];
		pcpu_num_used--;
		memmove(&pcpu_size[i], &pcpu_size[i+1],
			(pcpu_num_used - i) * sizeof(pcpu_size[0]));
		i--;
	}
	/* Merge with next? */
	if (i+1 < pcpu_num_used && pcpu_size[i+1] >= 0) {
		pcpu_size[i] += pcpu_size[i+1];
		pcpu_num_used--;
		memmove(&pcpu_size[i+1], &pcpu_size[i+2],
			(pcpu_num_used - (i+1)) * sizeof(pcpu_size[0]));
	}
}

static unsigned int find_pcpusec(Elf_Ehdr *hdr,
				 Elf_Shdr *sechdrs,
				 const char *secstrings)
{
	return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
}

462
463
464
465
466
467
468
469
static void percpu_modcopy(void *pcpudest, const void *from, unsigned long size)
{
	int cpu;

	for_each_possible_cpu(cpu)
		memcpy(pcpudest + per_cpu_offset(cpu), from, size);
}

Linus Torvalds's avatar
Linus Torvalds committed
470
471
472
473
474
475
476
static int percpu_modinit(void)
{
	pcpu_num_used = 2;
	pcpu_num_allocated = 2;
	pcpu_size = kmalloc(sizeof(pcpu_size[0]) * pcpu_num_allocated,
			    GFP_KERNEL);
	/* Static in-kernel percpu data (used). */
477
	pcpu_size[0] = -(__per_cpu_end-__per_cpu_start);
Linus Torvalds's avatar
Linus Torvalds committed
478
479
480
481
482
483
484
485
	/* Free room. */
	pcpu_size[1] = PERCPU_ENOUGH_ROOM + pcpu_size[0];
	if (pcpu_size[1] < 0) {
		printk(KERN_ERR "No per-cpu room for modules.\n");
		pcpu_num_used = 1;
	}

	return 0;
486
}
Linus Torvalds's avatar
Linus Torvalds committed
487
488
__initcall(percpu_modinit);
#else /* ... !CONFIG_SMP */
489
490
static inline void *percpu_modalloc(unsigned long size, unsigned long align,
				    const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
{
	return NULL;
}
static inline void percpu_modfree(void *pcpuptr)
{
	BUG();
}
static inline unsigned int find_pcpusec(Elf_Ehdr *hdr,
					Elf_Shdr *sechdrs,
					const char *secstrings)
{
	return 0;
}
static inline void percpu_modcopy(void *pcpudst, const void *src,
				  unsigned long size)
{
	/* pcpusec should be 0, and size of that section should be 0. */
	BUG_ON(size != 0);
}
#endif /* CONFIG_SMP */

512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
#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,   \
	                struct module *mod, char *buffer)             \
{                                                                     \
	return sprintf(buffer, "%s\n", mod->field);                   \
}                                                                     \
static int modinfo_##field##_exists(struct module *mod)               \
{                                                                     \
	return mod->field != NULL;                                    \
}                                                                     \
static void free_modinfo_##field(struct module *mod)                  \
{                                                                     \
528
529
	kfree(mod->field);                                            \
	mod->field = NULL;                                            \
530
531
}                                                                     \
static struct module_attribute modinfo_##field = {                    \
532
	.attr = { .name = __stringify(field), .mode = 0444 },         \
533
534
535
536
537
538
539
540
541
	.show = show_modinfo_##field,                                 \
	.setup = setup_modinfo_##field,                               \
	.test = modinfo_##field##_exists,                             \
	.free = free_modinfo_##field,                                 \
};

MODINFO_ATTR(version);
MODINFO_ATTR(srcversion);

542
543
static char last_unloaded_module[MODULE_NAME_LEN+1];

544
#ifdef CONFIG_MODULE_UNLOAD
Linus Torvalds's avatar
Linus Torvalds committed
545
546
547
548
549
550
551
552
553
/* Init the unload section of the module. */
static void module_unload_init(struct module *mod)
{
	unsigned int i;

	INIT_LIST_HEAD(&mod->modules_which_use_me);
	for (i = 0; i < NR_CPUS; i++)
		local_set(&mod->ref[i].count, 0);
	/* Hold reference count during initialization. */
554
	local_set(&mod->ref[raw_smp_processor_id()].count, 1);
Linus Torvalds's avatar
Linus Torvalds committed
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
	/* Backwards compatibility macros put refcount during init. */
	mod->waiter = current;
}

/* modules using other modules */
struct module_use
{
	struct list_head list;
	struct module *module_which_uses;
};

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

	list_for_each_entry(use, &b->modules_which_use_me, list) {
		if (use->module_which_uses == a) {
			DEBUGP("%s uses %s!\n", a->name, b->name);
			return 1;
		}
	}
	DEBUGP("%s does not use %s!\n", a->name, b->name);
	return 0;
}

/* Module a uses b */
static int use_module(struct module *a, struct module *b)
{
	struct module_use *use;
585
	int no_warn, err;
Kay Sievers's avatar
Kay Sievers committed
586

Linus Torvalds's avatar
Linus Torvalds committed
587
588
	if (b == NULL || already_uses(a, b)) return 1;

589
590
591
592
593
594
595
596
597
598
599
	/* If we're interrupted or time out, we fail. */
	if (wait_event_interruptible_timeout(
		    module_wq, (err = strong_try_module_get(b)) != -EBUSY,
		    30 * HZ) <= 0) {
		printk("%s: gave up waiting for init of module %s.\n",
		       a->name, b->name);
		return 0;
	}

	/* If strong_try_module_get() returned a different error, we fail. */
	if (err)
Linus Torvalds's avatar
Linus Torvalds committed
600
601
602
603
604
605
606
607
608
609
610
611
		return 0;

	DEBUGP("Allocating new usage for %s.\n", a->name);
	use = kmalloc(sizeof(*use), GFP_ATOMIC);
	if (!use) {
		printk("%s: out of memory loading\n", a->name);
		module_put(b);
		return 0;
	}

	use->module_which_uses = a;
	list_add(&use->list, &b->modules_which_use_me);
Kay Sievers's avatar
Kay Sievers committed
612
	no_warn = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name);
Linus Torvalds's avatar
Linus Torvalds committed
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
	return 1;
}

/* Clear the unload stuff of the module. */
static void module_unload_free(struct module *mod)
{
	struct module *i;

	list_for_each_entry(i, &modules, list) {
		struct module_use *use;

		list_for_each_entry(use, &i->modules_which_use_me, list) {
			if (use->module_which_uses == mod) {
				DEBUGP("%s unusing %s\n", mod->name, i->name);
				module_put(i);
				list_del(&use->list);
				kfree(use);
Kay Sievers's avatar
Kay Sievers committed
630
				sysfs_remove_link(i->holders_dir, mod->name);
Linus Torvalds's avatar
Linus Torvalds committed
631
632
633
634
635
636
637
638
				/* There can be at most one match. */
				break;
			}
		}
	}
}

#ifdef CONFIG_MODULE_FORCE_UNLOAD
639
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
640
641
642
{
	int ret = (flags & O_TRUNC);
	if (ret)
643
		add_taint(TAINT_FORCED_RMMOD);
Linus Torvalds's avatar
Linus Torvalds committed
644
645
646
	return ret;
}
#else
647
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
{
	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;

665
666
	/* If it's not unused, quit unless we're forcing. */
	if (module_refcount(sref->mod) != 0) {
667
		if (!(*sref->forced = try_force_unload(sref->flags)))
Linus Torvalds's avatar
Linus Torvalds committed
668
669
670
671
672
673
674
675
676
677
			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)
{
678
679
	if (flags & O_NONBLOCK) {
		struct stopref sref = { mod, flags, forced };
Linus Torvalds's avatar
Linus Torvalds committed
680

681
		return stop_machine(__try_stop_module, &sref, NULL);
682
683
684
685
686
687
	} 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
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
}

unsigned int module_refcount(struct module *mod)
{
	unsigned int i, total = 0;

	for (i = 0; i < NR_CPUS; i++)
		total += local_read(&mod->ref[i].count);
	return total;
}
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)
{
705
	/* Since we might sleep for some time, release the mutex first */
706
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
707
708
709
710
711
712
713
714
	for (;;) {
		DEBUGP("Looking at refcount...\n");
		set_current_state(TASK_UNINTERRUPTIBLE);
		if (module_refcount(mod) == 0)
			break;
		schedule();
	}
	current->state = TASK_RUNNING;
715
	mutex_lock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
716
717
}

718
719
asmlinkage long
sys_delete_module(const char __user *name_user, unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
720
721
{
	struct module *mod;
722
	char name[MODULE_NAME_LEN];
Linus Torvalds's avatar
Linus Torvalds committed
723
724
	int ret, forced = 0;

725
726
727
728
729
730
731
	if (!capable(CAP_SYS_MODULE))
		return -EPERM;

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

732
	if (mutex_lock_interruptible(&module_mutex) != 0)
Linus Torvalds's avatar
Linus Torvalds committed
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
		return -EINTR;

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

	if (!list_empty(&mod->modules_which_use_me)) {
		/* 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 */
757
	if (mod->init && !mod->exit) {
758
		forced = try_force_unload(flags);
Linus Torvalds's avatar
Linus Torvalds committed
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
		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);

778
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
779
	/* Final destruction now noone is using it. */
780
	if (mod->exit != NULL)
Linus Torvalds's avatar
Linus Torvalds committed
781
		mod->exit();
782
783
784
	blocking_notifier_call_chain(&module_notify_list,
				     MODULE_STATE_GOING, mod);
	mutex_lock(&module_mutex);
785
	/* Store the name of the last unloaded module for diagnostic purposes */
786
	strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
Linus Torvalds's avatar
Linus Torvalds committed
787
788
789
	free_module(mod);

 out:
790
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
	return ret;
}

static void print_unload_info(struct seq_file *m, struct module *mod)
{
	struct module_use *use;
	int printed_something = 0;

	seq_printf(m, " %u ", module_refcount(mod));

	/* Always include a trailing , so userspace can differentiate
           between this and the old multi-field proc format. */
	list_for_each_entry(use, &mod->modules_which_use_me, list) {
		printed_something = 1;
		seq_printf(m, "%s,", use->module_which_uses->name);
	}

	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
821
	preempt_disable();
822
	if (IS_ERR_VALUE(find_symbol(symbol, &owner, NULL, true, false)))
Linus Torvalds's avatar
Linus Torvalds committed
823
824
		BUG();
	module_put(owner);
Rusty Russell's avatar
Rusty Russell committed
825
	preempt_enable();
Linus Torvalds's avatar
Linus Torvalds committed
826
827
828
829
830
}
EXPORT_SYMBOL(__symbol_put);

void symbol_put_addr(void *addr)
{
831
	struct module *modaddr;
Linus Torvalds's avatar
Linus Torvalds committed
832

833
834
	if (core_kernel_text((unsigned long)addr))
		return;
Linus Torvalds's avatar
Linus Torvalds committed
835

836
837
838
	if (!(modaddr = module_text_address((unsigned long)addr)))
		BUG();
	module_put(modaddr);
Linus Torvalds's avatar
Linus Torvalds committed
839
840
841
842
843
844
}
EXPORT_SYMBOL_GPL(symbol_put_addr);

static ssize_t show_refcnt(struct module_attribute *mattr,
			   struct module *mod, char *buffer)
{
845
	return sprintf(buffer, "%u\n", module_refcount(mod));
Linus Torvalds's avatar
Linus Torvalds committed
846
847
848
}

static struct module_attribute refcnt = {
849
	.attr = { .name = "refcnt", .mode = 0444 },
Linus Torvalds's avatar
Linus Torvalds committed
850
851
852
	.show = show_refcnt,
};

Al Viro's avatar
Al Viro committed
853
854
855
856
857
858
859
860
861
862
863
864
865
void module_put(struct module *module)
{
	if (module) {
		unsigned int cpu = get_cpu();
		local_dec(&module->ref[cpu].count);
		/* Maybe they're waiting for us to drop reference? */
		if (unlikely(!module_is_live(module)))
			wake_up_process(module->waiter);
		put_cpu();
	}
}
EXPORT_SYMBOL(module_put);

Linus Torvalds's avatar
Linus Torvalds committed
866
867
868
869
870
871
872
873
874
875
876
877
878
#else /* !CONFIG_MODULE_UNLOAD */
static void print_unload_info(struct seq_file *m, struct module *mod)
{
	/* We don't know the usage count, or what modules are using. */
	seq_printf(m, " - -");
}

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

static inline int use_module(struct module *a, struct module *b)
{
879
	return strong_try_module_get(b) == 0;
Linus Torvalds's avatar
Linus Torvalds committed
880
881
882
883
884
885
886
}

static inline void module_unload_init(struct module *mod)
{
}
#endif /* CONFIG_MODULE_UNLOAD */

887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
static ssize_t show_initstate(struct module_attribute *mattr,
			   struct module *mod, char *buffer)
{
	const char *state = "unknown";

	switch (mod->state) {
	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 = {
907
	.attr = { .name = "initstate", .mode = 0444 },
908
909
910
	.show = show_initstate,
};

911
912
913
static struct module_attribute *modinfo_attrs[] = {
	&modinfo_version,
	&modinfo_srcversion,
914
	&initstate,
915
916
917
918
919
920
#ifdef CONFIG_MODULE_UNLOAD
	&refcnt,
#endif
	NULL,
};

Linus Torvalds's avatar
Linus Torvalds committed
921
922
static const char vermagic[] = VERMAGIC_STRING;

923
924
925
926
927
928
929
930
931
932
933
934
935
static int try_to_force_load(struct module *mod, const char *symname)
{
#ifdef CONFIG_MODULE_FORCE_LOAD
	if (!(tainted & TAINT_FORCED_MODULE))
		printk("%s: no version for \"%s\" found: kernel tainted.\n",
		       mod->name, symname);
	add_taint_module(mod, TAINT_FORCED_MODULE);
	return 0;
#else
	return -ENOEXEC;
#endif
}

Linus Torvalds's avatar
Linus Torvalds committed
936
937
938
939
940
941
942
943
944
945
946
947
948
949
#ifdef CONFIG_MODVERSIONS
static int check_version(Elf_Shdr *sechdrs,
			 unsigned int versindex,
			 const char *symname,
			 struct module *mod, 
			 const unsigned long *crc)
{
	unsigned int i, num_versions;
	struct modversion_info *versions;

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

950
951
952
953
	/* 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
954
955
956
957
958
959
960
961
962
963
964
965
	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;

		if (versions[i].crc == *crc)
			return 1;
		DEBUGP("Found checksum %lX vs module %lX\n",
		       *crc, versions[i].crc);
966
		goto bad_version;
Linus Torvalds's avatar
Linus Torvalds committed
967
	}
968

969
970
971
	printk(KERN_WARNING "%s: no symbol version for %s\n",
	       mod->name, symname);
	return 0;
972
973
974
975
976

bad_version:
	printk("%s: disagrees about version of symbol %s\n",
	       mod->name, symname);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
977
978
979
980
981
982
983
984
}

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

985
	if (IS_ERR_VALUE(find_symbol("struct_module", NULL, &crc, true, false)))
Linus Torvalds's avatar
Linus Torvalds committed
986
		BUG();
987
	return check_version(sechdrs, versindex, "struct_module", mod, crc);
Linus Torvalds's avatar
Linus Torvalds committed
988
989
}

990
991
992
/* First part is kernel version, which we ignore if module has crcs. */
static inline int same_magic(const char *amagic, const char *bmagic,
			     bool has_crcs)
Linus Torvalds's avatar
Linus Torvalds committed
993
{
994
995
996
997
	if (has_crcs) {
		amagic += strcspn(amagic, " ");
		bmagic += strcspn(bmagic, " ");
	}
Linus Torvalds's avatar
Linus Torvalds committed
998
999
1000
	return strcmp(amagic, bmagic) == 0;
}
#else