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

#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
69
/* List of modules, protected by module_mutex or preempt_disable
70
 * (delete uses stop_machine/add uses RCU list operations). */
71
static DEFINE_MUTEX(module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
72
73
static LIST_HEAD(modules);

74
75
76
/* Waiting for a module to finish initializing? */
static DECLARE_WAIT_QUEUE_HEAD(module_wq);

77
static BLOCKING_NOTIFIER_HEAD(module_notify_list);
Linus Torvalds's avatar
Linus Torvalds committed
78

79
80
81
/* 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
82
83
int register_module_notifier(struct notifier_block * nb)
{
84
	return blocking_notifier_chain_register(&module_notify_list, nb);
Linus Torvalds's avatar
Linus Torvalds committed
85
86
87
88
89
}
EXPORT_SYMBOL(register_module_notifier);

int unregister_module_notifier(struct notifier_block * nb)
{
90
	return blocking_notifier_chain_unregister(&module_notify_list, nb);
Linus Torvalds's avatar
Linus Torvalds committed
91
92
93
}
EXPORT_SYMBOL(unregister_module_notifier);

94
95
/* 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
96
97
98
static inline int strong_try_module_get(struct module *mod)
{
	if (mod && mod->state == MODULE_STATE_COMING)
99
100
		return -EBUSY;
	if (try_module_get(mod))
Linus Torvalds's avatar
Linus Torvalds committed
101
		return 0;
102
103
	else
		return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
104
105
}

106
107
108
static inline void add_taint_module(struct module *mod, unsigned flag)
{
	add_taint(flag);
Andi Kleen's avatar
Andi Kleen committed
109
	mod->taints |= (1U << flag);
110
111
}

112
113
114
/*
 * 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
115
116
117
118
119
120
121
 */
void __module_put_and_exit(struct module *mod, long code)
{
	module_put(mod);
	do_exit(code);
}
EXPORT_SYMBOL(__module_put_and_exit);
122

Linus Torvalds's avatar
Linus Torvalds committed
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/* 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;
}

Rusty Russell's avatar
Rusty Russell committed
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
/* Find a module section, or NULL. */
static void *section_addr(Elf_Ehdr *hdr, Elf_Shdr *shdrs,
			  const char *secstrings, const char *name)
{
	/* Section 0 has sh_addr 0. */
	return (void *)shdrs[find_sec(hdr, shdrs, secstrings, name)].sh_addr;
}

/* Find a module section, or NULL.  Fill in number of "objects" in section. */
static void *section_objs(Elf_Ehdr *hdr,
			  Elf_Shdr *sechdrs,
			  const char *secstrings,
			  const char *name,
			  size_t object_size,
			  unsigned int *num)
{
	unsigned int sec = find_sec(hdr, sechdrs, secstrings, name);

	/* Section 0 has sh_addr 0 and sh_size 0. */
	*num = sechdrs[sec].sh_size / object_size;
	return (void *)sechdrs[sec].sh_addr;
}

Linus Torvalds's avatar
Linus Torvalds committed
162
163
164
165
166
/* 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[];
167
168
extern const struct kernel_symbol __start___ksymtab_gpl_future[];
extern const struct kernel_symbol __stop___ksymtab_gpl_future[];
169
170
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
171
172
extern const unsigned long __start___kcrctab[];
extern const unsigned long __start___kcrctab_gpl[];
173
extern const unsigned long __start___kcrctab_gpl_future[];
174
175
176
177
178
#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[];
179
180
extern const unsigned long __start___kcrctab_unused[];
extern const unsigned long __start___kcrctab_unused_gpl[];
181
#endif
Linus Torvalds's avatar
Linus Torvalds committed
182
183
184
185

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

189
190
191
struct symsearch {
	const struct kernel_symbol *start, *stop;
	const unsigned long *crcs;
192
193
194
195
196
197
	enum {
		NOT_GPL_ONLY,
		GPL_ONLY,
		WILL_BE_GPL_ONLY,
	} licence;
	bool unused;
198
199
};

200
201
202
203
204
205
206
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)
207
{
208
	unsigned int i, j;
209

210
211
212
213
	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;
214
	}
215
216

	return false;
217
218
}

219
220
221
222
223
/* 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)
224
225
226
227
{
	struct module *mod;
	const struct symsearch arr[] = {
		{ __start___ksymtab, __stop___ksymtab, __start___kcrctab,
228
		  NOT_GPL_ONLY, false },
229
		{ __start___ksymtab_gpl, __stop___ksymtab_gpl,
230
231
		  __start___kcrctab_gpl,
		  GPL_ONLY, false },
232
		{ __start___ksymtab_gpl_future, __stop___ksymtab_gpl_future,
233
234
		  __start___kcrctab_gpl_future,
		  WILL_BE_GPL_ONLY, false },
235
#ifdef CONFIG_UNUSED_SYMBOLS
236
		{ __start___ksymtab_unused, __stop___ksymtab_unused,
237
238
		  __start___kcrctab_unused,
		  NOT_GPL_ONLY, true },
239
		{ __start___ksymtab_unused_gpl, __stop___ksymtab_unused_gpl,
240
241
		  __start___kcrctab_unused_gpl,
		  GPL_ONLY, true },
242
#endif
243
	};
244

245
246
	if (each_symbol_in_section(arr, ARRAY_SIZE(arr), NULL, fn, data))
		return true;
247

248
	list_for_each_entry_rcu(mod, &modules, list) {
249
250
		struct symsearch arr[] = {
			{ mod->syms, mod->syms + mod->num_syms, mod->crcs,
251
			  NOT_GPL_ONLY, false },
252
			{ mod->gpl_syms, mod->gpl_syms + mod->num_gpl_syms,
253
254
			  mod->gpl_crcs,
			  GPL_ONLY, false },
255
256
			{ mod->gpl_future_syms,
			  mod->gpl_future_syms + mod->num_gpl_future_syms,
257
258
			  mod->gpl_future_crcs,
			  WILL_BE_GPL_ONLY, false },
259
#ifdef CONFIG_UNUSED_SYMBOLS
260
261
			{ mod->unused_syms,
			  mod->unused_syms + mod->num_unused_syms,
262
263
			  mod->unused_crcs,
			  NOT_GPL_ONLY, true },
264
265
			{ mod->unused_gpl_syms,
			  mod->unused_gpl_syms + mod->num_unused_gpl_syms,
266
267
			  mod->unused_gpl_crcs,
			  GPL_ONLY, true },
268
#endif
269
270
		};

271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
		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");
308
		}
Linus Torvalds's avatar
Linus Torvalds committed
309
	}
310

311
#ifdef CONFIG_UNUSED_SYMBOLS
312
313
314
315
316
317
318
319
320
321
322
	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");
	}
323
#endif
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352

	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
353
	DEBUGP("Failed to find symbol %s\n", name);
354
	return -ENOENT;
Linus Torvalds's avatar
Linus Torvalds committed
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
}

/* 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
370
371
372
373
374
375
376
377
378
379
380
381
382
383

#ifdef CONFIG_HAVE_DYNAMIC_PER_CPU_AREA

static void *percpu_modalloc(unsigned long size, unsigned long align,
			     const char *name)
{
	void *ptr;

	if (align > PAGE_SIZE) {
		printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
		       name, align, PAGE_SIZE);
		align = PAGE_SIZE;
	}

384
	ptr = __alloc_reserved_percpu(size, align);
385
386
387
388
389
390
391
392
393
394
395
396
397
	if (!ptr)
		printk(KERN_WARNING
		       "Could not allocate %lu bytes percpu data\n", size);
	return ptr;
}

static void percpu_modfree(void *freeme)
{
	free_percpu(freeme);
}

#else /* ... !CONFIG_HAVE_DYNAMIC_PER_CPU_AREA */

Linus Torvalds's avatar
Linus Torvalds committed
398
399
400
401
402
403
404
405
406
/* 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
407
408
409
410
		int *new;

		new = krealloc(pcpu_size, sizeof(new[0])*pcpu_num_allocated*2,
			       GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
		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;
}

435
436
static void *percpu_modalloc(unsigned long size, unsigned long align,
			     const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
437
438
439
440
441
{
	unsigned long extra;
	unsigned int i;
	void *ptr;

442
443
444
445
	if (align > PAGE_SIZE) {
		printk(KERN_WARNING "%s: per-cpu alignment %li > %li\n",
		       name, align, PAGE_SIZE);
		align = PAGE_SIZE;
446
	}
Linus Torvalds's avatar
Linus Torvalds committed
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
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
508
509
510
511
512
513
514
515
516
517
518

	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 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). */
519
	pcpu_size[0] = -(__per_cpu_end-__per_cpu_start);
Linus Torvalds's avatar
Linus Torvalds committed
520
521
522
523
524
525
526
527
	/* 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;
528
}
Linus Torvalds's avatar
Linus Torvalds committed
529
__initcall(percpu_modinit);
530

531
532
#endif /* CONFIG_HAVE_DYNAMIC_PER_CPU_AREA */

533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
static unsigned int find_pcpusec(Elf_Ehdr *hdr,
				 Elf_Shdr *sechdrs,
				 const char *secstrings)
{
	return find_sec(hdr, sechdrs, secstrings, ".data.percpu");
}

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
548
#else /* ... !CONFIG_SMP */
549

550
551
static inline void *percpu_modalloc(unsigned long size, unsigned long align,
				    const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
{
	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);
}
571

Linus Torvalds's avatar
Linus Torvalds committed
572
573
#endif /* CONFIG_SMP */

574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
#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)                  \
{                                                                     \
590
591
	kfree(mod->field);                                            \
	mod->field = NULL;                                            \
592
593
}                                                                     \
static struct module_attribute modinfo_##field = {                    \
594
	.attr = { .name = __stringify(field), .mode = 0444 },         \
595
596
597
598
599
600
601
602
603
	.show = show_modinfo_##field,                                 \
	.setup = setup_modinfo_##field,                               \
	.test = modinfo_##field##_exists,                             \
	.free = free_modinfo_##field,                                 \
};

MODINFO_ATTR(version);
MODINFO_ATTR(srcversion);

604
605
static char last_unloaded_module[MODULE_NAME_LEN+1];

606
#ifdef CONFIG_MODULE_UNLOAD
Linus Torvalds's avatar
Linus Torvalds committed
607
608
609
/* Init the unload section of the module. */
static void module_unload_init(struct module *mod)
{
610
	int cpu;
Linus Torvalds's avatar
Linus Torvalds committed
611
612

	INIT_LIST_HEAD(&mod->modules_which_use_me);
613
614
	for_each_possible_cpu(cpu)
		local_set(__module_ref_addr(mod, cpu), 0);
Linus Torvalds's avatar
Linus Torvalds committed
615
	/* Hold reference count during initialization. */
616
	local_set(__module_ref_addr(mod, raw_smp_processor_id()), 1);
Linus Torvalds's avatar
Linus Torvalds committed
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
	/* 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;
647
	int no_warn, err;
Kay Sievers's avatar
Kay Sievers committed
648

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

651
652
653
654
655
656
657
658
659
660
661
	/* 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
662
663
664
665
666
667
668
669
670
671
672
673
		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
674
	no_warn = sysfs_create_link(b->holders_dir, &a->mkobj.kobj, a->name);
Linus Torvalds's avatar
Linus Torvalds committed
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
	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
692
				sysfs_remove_link(i->holders_dir, mod->name);
Linus Torvalds's avatar
Linus Torvalds committed
693
694
695
696
697
698
699
700
				/* There can be at most one match. */
				break;
			}
		}
	}
}

#ifdef CONFIG_MODULE_FORCE_UNLOAD
701
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
702
703
704
{
	int ret = (flags & O_TRUNC);
	if (ret)
705
		add_taint(TAINT_FORCED_RMMOD);
Linus Torvalds's avatar
Linus Torvalds committed
706
707
708
	return ret;
}
#else
709
static inline int try_force_unload(unsigned int flags)
Linus Torvalds's avatar
Linus Torvalds committed
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
{
	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;

727
728
	/* If it's not unused, quit unless we're forcing. */
	if (module_refcount(sref->mod) != 0) {
729
		if (!(*sref->forced = try_force_unload(sref->flags)))
Linus Torvalds's avatar
Linus Torvalds committed
730
731
732
733
734
735
736
737
738
739
			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)
{
740
741
	if (flags & O_NONBLOCK) {
		struct stopref sref = { mod, flags, forced };
Linus Torvalds's avatar
Linus Torvalds committed
742

743
		return stop_machine(__try_stop_module, &sref, NULL);
744
745
746
747
748
749
	} 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
750
751
752
753
}

unsigned int module_refcount(struct module *mod)
{
754
755
	unsigned int total = 0;
	int cpu;
Linus Torvalds's avatar
Linus Torvalds committed
756

757
758
	for_each_possible_cpu(cpu)
		total += local_read(__module_ref_addr(mod, cpu));
Linus Torvalds's avatar
Linus Torvalds committed
759
760
761
762
763
764
765
766
767
	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)
{
768
	/* Since we might sleep for some time, release the mutex first */
769
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
770
771
772
773
774
775
776
777
	for (;;) {
		DEBUGP("Looking at refcount...\n");
		set_current_state(TASK_UNINTERRUPTIBLE);
		if (module_refcount(mod) == 0)
			break;
		schedule();
	}
	current->state = TASK_RUNNING;
778
	mutex_lock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
779
780
}

781
782
783
/* Block module loading/unloading? */
int modules_disabled = 0;

784
785
SYSCALL_DEFINE2(delete_module, const char __user *, name_user,
		unsigned int, flags)
Linus Torvalds's avatar
Linus Torvalds committed
786
787
{
	struct module *mod;
788
	char name[MODULE_NAME_LEN];
Linus Torvalds's avatar
Linus Torvalds committed
789
790
	int ret, forced = 0;

791
	if (!capable(CAP_SYS_MODULE) || modules_disabled)
792
793
794
795
796
797
		return -EPERM;

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

798
799
800
801
802
803
804
805
806
807
	/* Create stop_machine threads since free_module relies on
	 * a non-failing stop_machine call. */
	ret = stop_machine_create();
	if (ret)
		return ret;

	if (mutex_lock_interruptible(&module_mutex) != 0) {
		ret = -EINTR;
		goto out_stop;
	}
Linus Torvalds's avatar
Linus Torvalds committed
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830

	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 */
831
	if (mod->init && !mod->exit) {
832
		forced = try_force_unload(flags);
Linus Torvalds's avatar
Linus Torvalds committed
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
		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);

852
	mutex_unlock(&module_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
853
	/* Final destruction now noone is using it. */
854
	if (mod->exit != NULL)
Linus Torvalds's avatar
Linus Torvalds committed
855
		mod->exit();
856
857
	blocking_notifier_call_chain(&module_notify_list,
				     MODULE_STATE_GOING, mod);
858
	async_synchronize_full();
859
	mutex_lock(&module_mutex);
860
	/* Store the name of the last unloaded module for diagnostic purposes */
861
	strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
862
	ddebug_remove_module(mod->name);
Linus Torvalds's avatar
Linus Torvalds committed
863
864
865
	free_module(mod);

 out:
866
	mutex_unlock(&module_mutex);
867
868
out_stop:
	stop_machine_destroy();
Linus Torvalds's avatar
Linus Torvalds committed
869
870
871
	return ret;
}

872
static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
{
	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
899
	preempt_disable();
900
	if (IS_ERR_VALUE(find_symbol(symbol, &owner, NULL, true, false)))
Linus Torvalds's avatar
Linus Torvalds committed
901
902
		BUG();
	module_put(owner);
Rusty Russell's avatar
Rusty Russell committed
903
	preempt_enable();
Linus Torvalds's avatar
Linus Torvalds committed
904
905
906
907
908
}
EXPORT_SYMBOL(__symbol_put);

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

911
912
	if (core_kernel_text((unsigned long)addr))
		return;
Linus Torvalds's avatar
Linus Torvalds committed
913

914
915
916
	if (!(modaddr = module_text_address((unsigned long)addr)))
		BUG();
	module_put(modaddr);
Linus Torvalds's avatar
Linus Torvalds committed
917
918
919
920
921
922
}
EXPORT_SYMBOL_GPL(symbol_put_addr);

static ssize_t show_refcnt(struct module_attribute *mattr,
			   struct module *mod, char *buffer)
{
923
	return sprintf(buffer, "%u\n", module_refcount(mod));
Linus Torvalds's avatar
Linus Torvalds committed
924
925
926
}

static struct module_attribute refcnt = {
927
	.attr = { .name = "refcnt", .mode = 0444 },
Linus Torvalds's avatar
Linus Torvalds committed
928
929
930
	.show = show_refcnt,
};

Al Viro's avatar
Al Viro committed
931
932
933
934
void module_put(struct module *module)
{
	if (module) {
		unsigned int cpu = get_cpu();
935
		local_dec(__module_ref_addr(module, cpu));
Al Viro's avatar
Al Viro committed
936
937
938
939
940
941
942
943
		/* 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
944
#else /* !CONFIG_MODULE_UNLOAD */
945
static inline void print_unload_info(struct seq_file *m, struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
946
947
948
949
950
951
952
953
954
955
956
{
	/* 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)
{
957
	return strong_try_module_get(b) == 0;
Linus Torvalds's avatar
Linus Torvalds committed
958
959
960
961
962
963
964
}

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

965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
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 = {
985
	.attr = { .name = "initstate", .mode = 0444 },
986
987
988
	.show = show_initstate,
};

989
990
991
static struct module_attribute *modinfo_attrs[] = {
	&modinfo_version,
	&modinfo_srcversion,
992
	&initstate,
993
994
995
996
997
998
#ifdef CONFIG_MODULE_UNLOAD
	&refcnt,
#endif
	NULL,
};

Linus Torvalds's avatar
Linus Torvalds committed
999
1000
static const char vermagic[] = VERMAGIC_STRING;

1001
1002
1003
static int try_to_force_load(struct module *mod, const char *symname)
{
#ifdef CONFIG_MODULE_FORCE_LOAD
Andi Kleen's avatar
Andi Kleen committed
1004
	if (!test_taint(TAINT_FORCED_MODULE))
1005
1006
1007
1008
1009
1010
1011
1012
1013
		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
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
#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;

1028
1029
1030
1031
	/* 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
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
	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);
1044
		goto bad_version;
Linus Torvalds's avatar
Linus Torvalds committed
1045
	}
1046

1047
1048
1049
	printk(KERN_WARNING "%s: no symbol version for %s\n",
	       mod->name, symname);
	return 0;
1050
1051
1052
1053
1054

bad_version:
	printk("%s: disagrees about version of symbol %s\n",
	       mod->name, symname);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1055
1056
1057
1058
1059
1060
1061
1062
}

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

1063
	if (IS_ERR_VALUE(find_symbol("struct_module", NULL, &crc, true, false)))
Linus Torvalds's avatar
Linus Torvalds committed
1064
		BUG();
1065
	return check_version(sechdrs, versindex, "struct_module", mod, crc);
Linus Torvalds's avatar
Linus Torvalds committed
1066
1067
}

1068
1069
1070
/* 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
1071
{
1072
1073
1074
1075
	if (has_crcs) {
		amagic += strcspn(amagic, " ");
		bmagic += strcspn(bmagic, " ");
	}
Linus Torvalds's avatar
Linus Torvalds committed
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
	return strcmp(amagic, bmagic) == 0;
}
#else
static inline int check_version(Elf_Shdr *sechdrs,
				unsigned int versindex,
				const char *symname,
				struct module *mod, 
				const unsigned long *crc)
{
	return 1;
}

static inline int check_modstruct_version(Elf_Shdr *sechdrs,
					  unsigned int versindex,
					  struct module *mod)
{
	return 1;
}

1095
1096
static inline int same_magic(const char *amagic, const char *bmagic,
			     bool has_crcs)
Linus Torvalds's avatar
Linus Torvalds committed
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
{
	return strcmp(amagic, bmagic) == 0;
}
#endif /* CONFIG_MODVERSIONS */

/* Resolve a symbol for this module.  I.e. if we find one, record usage.
   Must be holding module_mutex. */
static unsigned long resolve_symbol(Elf_Shdr *sechdrs,
				    unsigned int versindex,
				    const char *name,
				    struct module *mod)
{
	struct module *owner;
	unsigned long ret;
	const unsigned long *crc;

1113
	ret = find_symbol(name, &owner, &crc,
Andi Kleen's avatar
Andi Kleen committed
1114
			  !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
1115
	if (!IS_ERR_VALUE(ret)) {
1116
1117
		/* use_module can fail due to OOM,
		   or module initialization or unloading */
Linus Torvalds's avatar
Linus Torvalds committed
1118
1119
		if (!check_version(sechdrs, versindex, name, mod, crc) ||
		    !use_module(mod, owner))
1120
			ret = -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
1121
1122
1123
1124
1125
1126
1127
1128
	}
	return ret;
}

/*
 * /sys/module/foo/sections stuff
 * J. Corbet <corbet@lwn.net>
 */
1129
#if defined(CONFIG_KALLSYMS) && defined(CONFIG_SYSFS)
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
struct module_sect_attr
{
	struct module_attribute mattr;
	char *name;
	unsigned long address;
};

struct module_sect_attrs
{
	struct attribute_group grp;
	unsigned int nsections;
	struct module_sect_attr attrs[0];
};

Linus Torvalds's avatar
Linus Torvalds committed
1144
1145
1146
1147
1148
1149
1150
1151
static ssize_t module_sect_show(struct module_attribute *mattr,
				struct module *mod, char *buf)
{
	struct module_sect_attr *sattr =
		container_of(mattr, struct module_sect_attr, mattr);
	return sprintf(buf, "0x%lx\n", sattr->address);
}

1152
1153
static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
{
1154
	unsigned int section;
1155
1156
1157
1158
1159
1160

	for (section = 0; section < sect_attrs->nsections; section++)
		kfree(sect_attrs->attrs[section].name);
	kfree(sect_attrs);
}

Linus Torvalds's avatar
Linus Torvalds committed
1161
1162
1163
1164
1165
1166
1167
static void add_sect_attrs(struct module *mod, unsigned int nsect,
		char *secstrings, Elf_Shdr *sechdrs)
{
	unsigned int nloaded = 0, i, size[2];
	struct module_sect_attrs *sect_attrs;
	struct module_sect_attr *sattr;
	struct attribute **gattr;
1168

Linus Torvalds's avatar
Linus Torvalds committed
1169
1170
1171
1172
1173
1174
1175
1176
	/* Count loaded sections and allocate structures */
	for (i = 0; i < nsect; i++)
		if (sechdrs[i].sh_flags & SHF_ALLOC)
			nloaded++;
	size[0] = ALIGN(sizeof(*sect_attrs)
			+ nloaded * sizeof(sect_attrs->attrs[0]),
			sizeof(sect_attrs->grp.attrs[0]));
	size[1] = (nloaded + 1) * sizeof(sect_attrs->grp.attrs[0]);
1177
1178
	sect_attrs = kzalloc(size[0] + size[1], GFP_KERNEL);
	if (sect_attrs == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
1179
1180
1181
1182
1183
1184
		return;

	/* Setup section attributes. */
	sect_attrs->grp.name = "sections";
	sect_attrs->grp.attrs = (void *)sect_attrs + size[0];

1185
	sect_attrs->nsections = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1186
1187
1188
1189
1190
1191
	sattr = &sect_attrs->attrs[0];
	gattr = &sect_attrs->grp.attrs[0];
	for (i = 0; i < nsect; i++) {
		if (! (sechdrs[i].sh_flags & SHF_ALLOC))
			continue;
		sattr->address = sechdrs[i].sh_addr;
1192
1193
1194
1195
1196
		sattr->name = kstrdup(secstrings + sechdrs[i].sh_name,
					GFP_KERNEL);
		if (sattr->name == NULL)
			goto out;
		sect_attrs->nsections++;
Linus Torvalds's avatar
Linus Torvalds committed
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
		sattr->mattr.show = module_sect_show;
		sattr->mattr.store = NULL;
		sattr->mattr.attr.name = sattr->name;
		sattr->mattr.attr.mode = S_IRUGO;
		*(gattr++) = &(sattr++)->mattr.attr;
	}
	*gattr = NULL;

	if (sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp))
		goto out;

	mod->sect_attrs = sect_attrs;
	return;
  out:
1211
	free_sect_attrs(sect_attrs);
Linus Torvalds's avatar
Linus Torvalds committed
1212
1213
1214
1215
1216
1217
1218
1219
1220
}

static void remove_sect_attrs(struct module *mod)
{
	if (mod->sect_attrs) {
		sysfs_remove_group(&mod->mkobj.kobj,
				   &mod->sect_attrs->grp);
		/* We are positive that no one is using any sect attrs
		 * at this point.  Deallocate immediately. */
1221
		free_sect_attrs(mod->sect_attrs);
Linus Torvalds's avatar
Linus Torvalds committed
1222
1223
1224
1225
		mod->sect_attrs = NULL;
	}
}

Roland McGrath's avatar
Roland McGrath committed
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
/*
 * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
 */

struct module_notes_attrs {
	struct kobject *dir;
	unsigned int notes;
	struct bin_attribute attrs[0];
};

static ssize_t module_notes_read(struct kobject *kobj,
				 struct bin_attribute *bin_attr,
				 char *buf, loff_t pos, size_t count)
{
	/*
	 * The caller checked the pos and count against our size.
	 */
	memcpy(buf, bin_attr->private + pos, count);
	return count;
}

static void free_notes_attrs(struct module_notes_attrs *notes_attrs,
			     unsigned int i)
{
	if (notes_attrs->dir) {
		while (i-- > 0)
			sysfs_remove_bin_file(notes_attrs->dir,
					      &notes_attrs->attrs[i]);
1254
		kobject_put(notes_attrs->dir);
Roland McGrath's avatar
Roland McGrath committed
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
	}
	kfree(notes_attrs);
}

static void add_notes_attrs(struct module *mod, unsigned int nsect,
			    char *secstrings, Elf_Shdr *sechdrs)
{
	unsigned int notes, loaded, i;
	struct module_notes_attrs *notes_attrs;
	struct bin_attribute *nattr;

	/* Count notes sections and allocate structures.  */
	notes = 0;
	for (i = 0; i < nsect; i++)
		if ((sechdrs[i].sh_flags & SHF_ALLOC) &&
		    (sechdrs[i].sh_type == SHT_NOTE))
			++notes;

	if (notes == 0)
		return;

	notes_attrs = kzalloc(sizeof(*notes_attrs)
			      + notes * sizeof(notes_attrs->attrs[0]),
			      GFP_KERNEL);
	if (notes_attrs == NULL)
		return;

	notes_attrs->notes = notes;
	nattr = &notes_attrs->attrs[0];
	for (loaded = i = 0; i < nsect; ++i) {
		if (!(sechdrs[i].sh_flags & SHF_ALLOC))
			continue;
		if (sechdrs[i].sh_type == SHT_NOTE) {
			nattr->attr.name = mod->sect_attrs->attrs[loaded].name;
			nattr->attr.mode = S_IRUGO;
			nattr->size = sechdrs[i].sh_size;
			nattr->private = (void *) sechdrs[i].sh_addr;
			nattr->read = module_notes_read;
			++nattr;
		}
		++loaded;
	}

1298
	notes_attrs->dir = kobject_create_and_add("notes", &mod->mkobj.kobj);
Roland McGrath's avatar
Roland McGrath committed
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
	if (!notes_attrs->dir)
		goto out;

	for (i = 0; i < notes; ++i)
		if (sysfs_create_bin_file(notes_attrs->dir,
					  &notes_attrs->attrs[i]))
			goto out;

	mod->notes_attrs = notes_attrs;
	return;

  out:
	free_notes_attrs(notes_attrs, i);
}

static void remove_notes_attrs(struct module *mod)
{
	if (mod->notes_attrs)
		free_notes_attrs(mod->notes_attrs, mod->notes_attrs->notes);
}

Linus Torvalds's avatar
Linus Torvalds committed
1320
#else
1321

Linus Torvalds's avatar
Linus Torvalds committed
1322
1323
1324
1325
1326
1327
1328
1329
static inline void add_sect_attrs(struct module *mod, unsigned int nsect,
		char *sectstrings, Elf_Shdr *sechdrs)
{
}

static inline void remove_sect_attrs(struct module *mod)
{
}
Roland McGrath's avatar
Roland McGrath committed
1330
1331
1332
1333
1334
1335
1336
1337
1338

static inline void add_notes_attrs(struct module *mod, unsigned int nsect,
				   char *sectstrings, Elf_Shdr *sechdrs)
{
}

static inline void remove_notes_attrs(struct module *mod)
{
}
1339
#endif
Linus Torvalds's avatar
Linus Torvalds committed
1340

1341
1342
#ifdef CONFIG_SYSFS
int module_add_modinfo_attrs(struct module *mod)
1343
1344
{
	struct module_attribute *attr;
1345
	struct module_attribute *temp_attr;
1346
1347
1348
	int error = 0;
	int i;

1349
1350
1351
1352
1353
1354
1355
	mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *
					(ARRAY_SIZE(modinfo_attrs) + 1)),
					GFP_KERNEL);
	if (!mod->modinfo_attrs)
		return -ENOMEM;

	temp_attr = mod->modinfo_attrs;
1356
1357
	for (i = 0; (attr = modinfo_attrs[i]) && !error; i++) {
		if (!attr->test ||
1358
1359
1360
1361
1362
		    (attr->test && attr->test(mod))) {
			memcpy(temp_attr, attr, sizeof(*temp_attr));
			error = sysfs_create_file(&mod->mkobj.kobj,&temp_attr->attr);
			++temp_attr;
		}
1363
1364
1365
1366
	}
	return error;
}

1367
void module_remove_modinfo_attrs(struct module *mod)
1368
1369
1370
1371
{
	struct module_attribute *attr;
	int i;

1372
1373
1374
1375
	for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {
		/* pick a field to test for end of list */
		if (!attr->attr.name)
			break;
1376
		sysfs_remove_file(&mod->mkobj.kobj,&attr->attr);
1377
1378
		if (attr->free)
			attr->free(mod);
1379
	}
1380
	kfree(mod->modinfo_attrs);
1381
}
Linus Torvalds's avatar
Linus Torvalds committed
1382

1383
int mod_sysfs_init(struct module *mod)
Linus Torvalds's avatar
Linus Torvalds committed
1384
1385
{
	int err;
1386
	struct kobject *kobj;
Linus Torvalds's avatar
Linus Torvalds committed
1387

1388
1389
	if (!module_sysfs_initialized) {
		printk(KERN_ERR "%s: module sysfs not initialized\n",
1390
1391
1392
1393
		       mod->name);
		err = -EINVAL;
		goto out;
	}
1394
1395
1396
1397
1398
1399
1400
1401
1402

	kobj = kset_find_obj(module_kset, mod->name);
	if (kobj) {
		printk(KERN_ERR "%s: module is already loaded\n", mod->name);
		kobject_put(kobj);
		err = -EINVAL;
		goto out;
	}

Linus Torvalds's avatar
Linus Torvalds committed
1403
	mod->mkobj.mod = mod;
1404

1405
1406
1407
1408
1409
1410
	memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
	mod->mkobj.kobj.kset = module_kset;
	err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
				   "%s", mod->name);
	if (err)
		kobject_put(&mod->mkobj.kobj);
Kay Sievers's avatar
Kay Sievers committed
1411

1412
	/* delay uevent until full sysfs population */
Kay Sievers's avatar
Kay Sievers committed
1413
1414
1415
1416
out:
	return err;
}

1417
int mod_sysfs_setup(struct module *mod,
Kay Sievers's avatar
Kay Sievers committed
1418
1419
1420
1421
1422
			   struct kernel_param *kparam,
			   unsigned int num_params)
{
	int err;

1423
	mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);
1424
1425
	if (!mod->holders_dir) {
		err = -ENOMEM;
Kay Sievers's avatar
Kay Sievers committed
1426
		goto out_unreg;
1427
	}
Kay Sievers's avatar
Kay Sievers committed
1428

Linus Torvalds's avatar
Linus Torvalds committed
1429
1430
	err = module_param_sysfs_setup(mod, kparam, num_params);
	if (err)
Kay Sievers's avatar
Kay Sievers committed
1431
		goto out_unreg_holders;
Linus Torvalds's avatar
Linus Torvalds committed
1432

1433
1434
	err = module_add_modinfo_attrs(mod);
	if (err)
1435
		goto out_unreg_param;
1436

1437
	kobject_uevent(&mod->mkobj.kobj, KOBJ_ADD);
Linus Torvalds's avatar
Linus Torvalds committed
1438
1439
	return 0;

1440
1441
out_unreg_param:
	module_param_sysfs_remove(mod);
Kay Sievers's avatar
Kay Sievers committed
1442
out_unreg_holders:
1443
	kobject_put(mod->holders_dir);
Kay Sievers's avatar
Kay Sievers committed
1444
out_unreg:
1445
	kobject_put(&mod->mkobj.kobj);
Linus Torvalds's avatar
Linus Torvalds committed
1446
1447
	return err;
}
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460

static void mod_sysfs_fini(struct module *mod)
{
	kobject_put(&mod->mkobj.kobj);
}

#else /* CONFIG_SYSFS */

static void mod_sysfs_fini(struct module *mod)
{
}

#endif /* CONFIG_SYSFS */
Linus Torvalds's avatar
Linus Torvalds committed
1461
1462
1463

static void mod_kobject_remove(struct module *mod)
{
1464
	module_remove_modinfo_attrs(mod);
Linus Torvalds's avatar
Linus Torvalds committed
1465
	module_param_sysfs_remove(mod);
1466
1467
	kobject_put(mod->mkobj.drivers_dir);
	kobject_put(mod->holders_dir);
1468
	mod_sysfs_fini(mod);
Linus Torvalds's avatar
Linus Torvalds committed
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
}

/*
 * unlink the module with the whole machine is stopped with interrupts off
 * - this defends against kallsyms not taking locks
 */
static int __unlink_module(void *_mod)
{
	struct module *mod = _mod;
	list_del(&mod->list);
	return 0;
}

1482
/* Free a module, remove from lists, etc (must hold module_mutex). */
Linus Torvalds's avatar
Linus Torvalds committed
1483
1484
1485
static void free_module(struct module *mod)
{
	/* Delete from various lists */
1486
	stop_machine(__unlink_module, mod, NULL);