modpost.c 66.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
/* Postprocess module symbol versions
 *
 * Copyright 2003       Kai Germaschewski
 * Copyright 2002-2004  Rusty Russell, IBM Corporation
Sam Ravnborg's avatar
Sam Ravnborg committed
5
 * Copyright 2006-2008  Sam Ravnborg
Linus Torvalds's avatar
Linus Torvalds committed
6
7
8
9
10
11
12
13
 * Based in part on module-init-tools/depmod.c,file2alias
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 *
 * Usage: modpost vmlinux module1.o module2.o ...
 */

14
15
#define _GNU_SOURCE
#include <stdio.h>
Linus Torvalds's avatar
Linus Torvalds committed
16
#include <ctype.h>
17
#include <string.h>
18
#include <limits.h>
Rusty Russell's avatar
Rusty Russell committed
19
#include <stdbool.h>
20
#include <errno.h>
Linus Torvalds's avatar
Linus Torvalds committed
21
#include "modpost.h"
22
#include "../../include/linux/license.h"
23

Linus Torvalds's avatar
Linus Torvalds committed
24
/* Are we using CONFIG_MODVERSIONS? */
25
static int modversions = 0;
Linus Torvalds's avatar
Linus Torvalds committed
26
/* Warn about undefined symbols? (do so if we have vmlinux) */
27
static int have_vmlinux = 0;
Linus Torvalds's avatar
Linus Torvalds committed
28
29
/* Is CONFIG_MODULE_SRCVERSION_ALL set? */
static int all_versions = 0;
30
31
/* If we are modposting external module set to 1 */
static int external_module = 0;
32
33
/* Warn about section mismatch in vmlinux if set to 1 */
static int vmlinux_section_warnings = 1;
34
35
/* Only warn about unresolved symbols */
static int warn_unresolved = 0;
36
/* How a symbol is exported */
37
38
static int sec_mismatch_count = 0;
static int sec_mismatch_verbose = 1;
39
static int sec_mismatch_fatal = 0;
40
41
/* ignore missing files */
static int ignore_missing_files;
42

43
44
45
46
enum export {
	export_plain,      export_unused,     export_gpl,
	export_unused_gpl, export_gpl_future, export_unknown
};
Linus Torvalds's avatar
Linus Torvalds committed
47

48
49
50
51
52
53
/* In kernel, this size is defined in linux/module.h;
 * here we use Elf_Addr instead of long for covering cross-compile
 */

#define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))

54
55
56
#define PRINTF __attribute__ ((format (printf, 1, 2)))

PRINTF void fatal(const char *fmt, ...)
Linus Torvalds's avatar
Linus Torvalds committed
57
58
59
60
61
62
63
64
65
66
67
68
{
	va_list arglist;

	fprintf(stderr, "FATAL: ");

	va_start(arglist, fmt);
	vfprintf(stderr, fmt, arglist);
	va_end(arglist);

	exit(1);
}

69
PRINTF void warn(const char *fmt, ...)
Linus Torvalds's avatar
Linus Torvalds committed
70
71
72
73
74
75
76
77
78
79
{
	va_list arglist;

	fprintf(stderr, "WARNING: ");

	va_start(arglist, fmt);
	vfprintf(stderr, fmt, arglist);
	va_end(arglist);
}

80
PRINTF void merror(const char *fmt, ...)
81
82
83
84
85
86
87
88
89
90
{
	va_list arglist;

	fprintf(stderr, "ERROR: ");

	va_start(arglist, fmt);
	vfprintf(stderr, fmt, arglist);
	va_end(arglist);
}

Rusty Russell's avatar
Rusty Russell committed
91
92
93
94
95
96
97
98
static inline bool strends(const char *str, const char *postfix)
{
	if (strlen(str) < strlen(postfix))
		return false;

	return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
}

99
100
101
102
static int is_vmlinux(const char *modname)
{
	const char *myname;

Sam Ravnborg's avatar
Sam Ravnborg committed
103
104
	myname = strrchr(modname, '/');
	if (myname)
105
106
107
108
		myname++;
	else
		myname = modname;

109
110
	return (strcmp(myname, "vmlinux") == 0) ||
	       (strcmp(myname, "vmlinux.o") == 0);
111
112
}

Linus Torvalds's avatar
Linus Torvalds committed
113
114
void *do_nofail(void *ptr, const char *expr)
{
Sam Ravnborg's avatar
Sam Ravnborg committed
115
	if (!ptr)
Linus Torvalds's avatar
Linus Torvalds committed
116
		fatal("modpost: Memory allocation failure: %s.\n", expr);
Sam Ravnborg's avatar
Sam Ravnborg committed
117

Linus Torvalds's avatar
Linus Torvalds committed
118
119
120
121
122
123
	return ptr;
}

/* A list of all modules we processed */
static struct module *modules;

124
static struct module *find_module(const char *modname)
Linus Torvalds's avatar
Linus Torvalds committed
125
126
127
128
129
130
131
132
133
{
	struct module *mod;

	for (mod = modules; mod; mod = mod->next)
		if (strcmp(mod->name, modname) == 0)
			break;
	return mod;
}

Rusty Russell's avatar
Rusty Russell committed
134
static struct module *new_module(const char *modname)
Linus Torvalds's avatar
Linus Torvalds committed
135
136
{
	struct module *mod;
Rusty Russell's avatar
Rusty Russell committed
137
	char *p;
138

Linus Torvalds's avatar
Linus Torvalds committed
139
140
141
142
143
	mod = NOFAIL(malloc(sizeof(*mod)));
	memset(mod, 0, sizeof(*mod));
	p = NOFAIL(strdup(modname));

	/* strip trailing .o */
Rusty Russell's avatar
Rusty Russell committed
144
145
146
147
	if (strends(p, ".o")) {
		p[strlen(p) - 2] = '\0';
		mod->is_dot_o = 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
148
149
150

	/* add to list */
	mod->name = p;
151
	mod->gpl_compatible = -1;
Linus Torvalds's avatar
Linus Torvalds committed
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
	mod->next = modules;
	modules = mod;

	return mod;
}

/* A hash of all exported symbols,
 * struct symbol is also used for lists of unresolved symbols */

#define SYMBOL_HASH_SIZE 1024

struct symbol {
	struct symbol *next;
	struct module *module;
	unsigned int crc;
	int crc_valid;
	unsigned int weak:1;
169
170
171
	unsigned int vmlinux:1;    /* 1 if symbol is defined in vmlinux */
	unsigned int kernel:1;     /* 1 if symbol is from kernel
				    *  (only for external modules) **/
172
	unsigned int preloaded:1;  /* 1 if symbol from Module.symvers, or crc */
173
	enum export  export;       /* Type of export */
Linus Torvalds's avatar
Linus Torvalds committed
174
175
176
177
178
179
180
181
182
183
184
185
	char name[0];
};

static struct symbol *symbolhash[SYMBOL_HASH_SIZE];

/* This is based on the hash agorithm from gdbm, via tdb */
static inline unsigned int tdb_hash(const char *name)
{
	unsigned value;	/* Used to compute the hash value.  */
	unsigned   i;	/* Used to cycle through random values. */

	/* Set the initial value from the key size. */
Sam Ravnborg's avatar
Sam Ravnborg committed
186
	for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
Linus Torvalds's avatar
Linus Torvalds committed
187
188
189
190
191
		value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));

	return (1103515243 * value + 12345);
}

192
193
194
195
196
197
/**
 * Allocate a new symbols for use in the hash of exported symbols or
 * the list of unresolved symbols per module
 **/
static struct symbol *alloc_symbol(const char *name, unsigned int weak,
				   struct symbol *next)
Linus Torvalds's avatar
Linus Torvalds committed
198
199
200
201
202
203
204
205
206
207
208
{
	struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));

	memset(s, 0, sizeof(*s));
	strcpy(s->name, name);
	s->weak = weak;
	s->next = next;
	return s;
}

/* For the hash of exported symbols */
209
210
static struct symbol *new_symbol(const char *name, struct module *module,
				 enum export export)
Linus Torvalds's avatar
Linus Torvalds committed
211
212
213
214
215
216
217
{
	unsigned int hash;
	struct symbol *new;

	hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
	new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
	new->module = module;
218
	new->export = export;
219
	return new;
Linus Torvalds's avatar
Linus Torvalds committed
220
221
}

222
static struct symbol *find_symbol(const char *name)
Linus Torvalds's avatar
Linus Torvalds committed
223
224
225
226
227
228
229
{
	struct symbol *s;

	/* For our purposes, .foo matches foo.  PPC64 needs this. */
	if (name[0] == '.')
		name++;

Sam Ravnborg's avatar
Sam Ravnborg committed
230
	for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
Linus Torvalds's avatar
Linus Torvalds committed
231
232
233
234
235
236
		if (strcmp(s->name, name) == 0)
			return s;
	}
	return NULL;
}

237
static const struct {
238
239
240
241
	const char *str;
	enum export export;
} export_list[] = {
	{ .str = "EXPORT_SYMBOL",            .export = export_plain },
242
	{ .str = "EXPORT_UNUSED_SYMBOL",     .export = export_unused },
243
	{ .str = "EXPORT_SYMBOL_GPL",        .export = export_gpl },
244
	{ .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
245
246
247
248
249
250
251
252
253
254
	{ .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
	{ .str = "(unknown)",                .export = export_unknown },
};


static const char *export_str(enum export ex)
{
	return export_list[ex].str;
}

Sam Ravnborg's avatar
Sam Ravnborg committed
255
static enum export export_no(const char *s)
256
257
{
	int i;
Sam Ravnborg's avatar
Sam Ravnborg committed
258

Sam Ravnborg's avatar
Sam Ravnborg committed
259
260
	if (!s)
		return export_unknown;
261
262
263
264
265
266
267
	for (i = 0; export_list[i].export != export_unknown; i++) {
		if (strcmp(export_list[i].str, s) == 0)
			return export_list[i].export;
	}
	return export_unknown;
}

Masahiro Yamada's avatar
Masahiro Yamada committed
268
269
270
271
272
273
274
275
276
277
278
static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
{
	return (void *)elf->hdr +
		elf->sechdrs[elf->secindex_strings].sh_offset +
		sechdr->sh_name;
}

static const char *sec_name(struct elf_info *elf, int secindex)
{
	return sech_name(elf, &elf->sechdrs[secindex]);
}
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299

#define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)

static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
{
	const char *secname = sec_name(elf, sec);

	if (strstarts(secname, "___ksymtab+"))
		return export_plain;
	else if (strstarts(secname, "___ksymtab_unused+"))
		return export_unused;
	else if (strstarts(secname, "___ksymtab_gpl+"))
		return export_gpl;
	else if (strstarts(secname, "___ksymtab_unused_gpl+"))
		return export_unused_gpl;
	else if (strstarts(secname, "___ksymtab_gpl_future+"))
		return export_gpl_future;
	else
		return export_unknown;
}

300
static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
301
302
303
{
	if (sec == elf->export_sec)
		return export_plain;
304
305
	else if (sec == elf->export_unused_sec)
		return export_unused;
306
307
	else if (sec == elf->export_gpl_sec)
		return export_gpl;
308
309
	else if (sec == elf->export_unused_gpl_sec)
		return export_unused_gpl;
310
311
312
313
314
315
	else if (sec == elf->export_gpl_future_sec)
		return export_gpl_future;
	else
		return export_unknown;
}

316
317
318
319
/**
 * Add an exported symbol - it may have already been added without a
 * CRC, in this case just update the CRC
 **/
320
321
static struct symbol *sym_add_exported(const char *name, struct module *mod,
				       enum export export)
Linus Torvalds's avatar
Linus Torvalds committed
322
323
324
325
{
	struct symbol *s = find_symbol(name);

	if (!s) {
326
		s = new_symbol(name, mod, export);
327
328
	} else {
		if (!s->preloaded) {
329
			warn("%s: '%s' exported twice. Previous export "
330
331
332
			     "was in %s%s\n", mod->name, name,
			     s->module->name,
			     is_vmlinux(s->module->name) ?"":".ko");
333
		} else {
334
			/* In case Module.symvers was out of date */
335
			s->module = mod;
336
		}
Linus Torvalds's avatar
Linus Torvalds committed
337
	}
338
	s->preloaded = 0;
339
340
	s->vmlinux   = is_vmlinux(mod->name);
	s->kernel    = 0;
341
	s->export    = export;
342
343
344
345
	return s;
}

static void sym_update_crc(const char *name, struct module *mod,
346
			   unsigned int crc, enum export export)
347
348
349
{
	struct symbol *s = find_symbol(name);

350
	if (!s) {
351
		s = new_symbol(name, mod, export);
352
353
354
		/* Don't complain when we find it later. */
		s->preloaded = 1;
	}
355
356
	s->crc = crc;
	s->crc_valid = 1;
Linus Torvalds's avatar
Linus Torvalds committed
357
358
}

359
void *grab_file(const char *filename, unsigned long *size)
Linus Torvalds's avatar
Linus Torvalds committed
360
361
{
	struct stat st;
362
	void *map = MAP_FAILED;
Linus Torvalds's avatar
Linus Torvalds committed
363
364
365
	int fd;

	fd = open(filename, O_RDONLY);
366
	if (fd < 0)
Linus Torvalds's avatar
Linus Torvalds committed
367
		return NULL;
368
369
	if (fstat(fd, &st))
		goto failed;
Linus Torvalds's avatar
Linus Torvalds committed
370
371
372
373

	*size = st.st_size;
	map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);

374
375
failed:
	close(fd);
Linus Torvalds's avatar
Linus Torvalds committed
376
377
378
379
380
	if (map == MAP_FAILED)
		return NULL;
	return map;
}

381
382
383
384
385
/**
  * Return a copy of the next line in a mmap'ed file.
  * spaces in the beginning of the line is trimmed away.
  * Return a pointer to a static buffer.
  **/
Sam Ravnborg's avatar
Sam Ravnborg committed
386
char *get_next_line(unsigned long *pos, void *file, unsigned long size)
Linus Torvalds's avatar
Linus Torvalds committed
387
388
389
390
391
392
393
{
	static char line[4096];
	int skip = 1;
	size_t len = 0;
	signed char *p = (signed char *)file + *pos;
	char *s = line;

Sam Ravnborg's avatar
Sam Ravnborg committed
394
	for (; *pos < size ; (*pos)++) {
Linus Torvalds's avatar
Linus Torvalds committed
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
		if (skip && isspace(*p)) {
			p++;
			continue;
		}
		skip = 0;
		if (*p != '\n' && (*pos < size)) {
			len++;
			*s++ = *p++;
			if (len > 4095)
				break; /* Too long, stop */
		} else {
			/* End of string */
			*s = '\0';
			return line;
		}
	}
	/* End of buffer */
	return NULL;
}

415
void release_file(void *file, unsigned long size)
Linus Torvalds's avatar
Linus Torvalds committed
416
417
418
419
{
	munmap(file, size);
}

420
static int parse_elf(struct elf_info *info, const char *filename)
Linus Torvalds's avatar
Linus Torvalds committed
421
422
{
	unsigned int i;
423
	Elf_Ehdr *hdr;
Linus Torvalds's avatar
Linus Torvalds committed
424
425
	Elf_Shdr *sechdrs;
	Elf_Sym  *sym;
426
427
	const char *secstrings;
	unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
Linus Torvalds's avatar
Linus Torvalds committed
428
429
430

	hdr = grab_file(filename, &info->size);
	if (!hdr) {
431
432
433
434
435
		if (ignore_missing_files) {
			fprintf(stderr, "%s: %s (ignored)\n", filename,
				strerror(errno));
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
436
		perror(filename);
437
		exit(1);
Linus Torvalds's avatar
Linus Torvalds committed
438
439
	}
	info->hdr = hdr;
440
441
442
443
444
445
446
447
448
449
450
451
	if (info->size < sizeof(*hdr)) {
		/* file too small, assume this is an empty .o file */
		return 0;
	}
	/* Is this a valid ELF file? */
	if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
	    (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
	    (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
	    (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
		/* Not an ELF file - silently ignore it */
		return 0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
452
	/* Fix endianness in ELF header */
453
454
455
456
457
458
459
460
461
462
463
464
465
	hdr->e_type      = TO_NATIVE(hdr->e_type);
	hdr->e_machine   = TO_NATIVE(hdr->e_machine);
	hdr->e_version   = TO_NATIVE(hdr->e_version);
	hdr->e_entry     = TO_NATIVE(hdr->e_entry);
	hdr->e_phoff     = TO_NATIVE(hdr->e_phoff);
	hdr->e_shoff     = TO_NATIVE(hdr->e_shoff);
	hdr->e_flags     = TO_NATIVE(hdr->e_flags);
	hdr->e_ehsize    = TO_NATIVE(hdr->e_ehsize);
	hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
	hdr->e_phnum     = TO_NATIVE(hdr->e_phnum);
	hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
	hdr->e_shnum     = TO_NATIVE(hdr->e_shnum);
	hdr->e_shstrndx  = TO_NATIVE(hdr->e_shstrndx);
Linus Torvalds's avatar
Linus Torvalds committed
466
467
468
	sechdrs = (void *)hdr + hdr->e_shoff;
	info->sechdrs = sechdrs;

Petr Stetiar's avatar
Petr Stetiar committed
469
470
	/* Check if file offset is correct */
	if (hdr->e_shoff > info->size) {
Sam Ravnborg's avatar
Sam Ravnborg committed
471
472
473
		fatal("section header offset=%lu in file '%s' is bigger than "
		      "filesize=%lu\n", (unsigned long)hdr->e_shoff,
		      filename, info->size);
Petr Stetiar's avatar
Petr Stetiar committed
474
475
476
		return 0;
	}

477
	if (hdr->e_shnum == SHN_UNDEF) {
478
479
480
481
482
483
484
485
486
487
		/*
		 * There are more than 64k sections,
		 * read count from .sh_size.
		 */
		info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
	}
	else {
		info->num_sections = hdr->e_shnum;
	}
	if (hdr->e_shstrndx == SHN_XINDEX) {
488
		info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
489
490
491
492
493
	}
	else {
		info->secindex_strings = hdr->e_shstrndx;
	}

Linus Torvalds's avatar
Linus Torvalds committed
494
	/* Fix endianness in section headers */
495
	for (i = 0; i < info->num_sections; i++) {
496
497
498
499
500
501
502
503
504
505
		sechdrs[i].sh_name      = TO_NATIVE(sechdrs[i].sh_name);
		sechdrs[i].sh_type      = TO_NATIVE(sechdrs[i].sh_type);
		sechdrs[i].sh_flags     = TO_NATIVE(sechdrs[i].sh_flags);
		sechdrs[i].sh_addr      = TO_NATIVE(sechdrs[i].sh_addr);
		sechdrs[i].sh_offset    = TO_NATIVE(sechdrs[i].sh_offset);
		sechdrs[i].sh_size      = TO_NATIVE(sechdrs[i].sh_size);
		sechdrs[i].sh_link      = TO_NATIVE(sechdrs[i].sh_link);
		sechdrs[i].sh_info      = TO_NATIVE(sechdrs[i].sh_info);
		sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
		sechdrs[i].sh_entsize   = TO_NATIVE(sechdrs[i].sh_entsize);
Linus Torvalds's avatar
Linus Torvalds committed
506
507
	}
	/* Find symbol table. */
508
509
	secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
	for (i = 1; i < info->num_sections; i++) {
510
		const char *secname;
511
		int nobits = sechdrs[i].sh_type == SHT_NOBITS;
Linus Torvalds's avatar
Linus Torvalds committed
512

513
		if (!nobits && sechdrs[i].sh_offset > info->size) {
Sam Ravnborg's avatar
Sam Ravnborg committed
514
515
516
517
			fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
			      "sizeof(*hrd)=%zu\n", filename,
			      (unsigned long)sechdrs[i].sh_offset,
			      sizeof(*hdr));
518
519
			return 0;
		}
520
521
		secname = secstrings + sechdrs[i].sh_name;
		if (strcmp(secname, ".modinfo") == 0) {
522
523
			if (nobits)
				fatal("%s has NOBITS .modinfo\n", filename);
Linus Torvalds's avatar
Linus Torvalds committed
524
525
			info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
			info->modinfo_len = sechdrs[i].sh_size;
526
527
		} else if (strcmp(secname, "__ksymtab") == 0)
			info->export_sec = i;
528
529
		else if (strcmp(secname, "__ksymtab_unused") == 0)
			info->export_unused_sec = i;
530
531
		else if (strcmp(secname, "__ksymtab_gpl") == 0)
			info->export_gpl_sec = i;
532
533
		else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
			info->export_unused_gpl_sec = i;
534
535
536
		else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
			info->export_gpl_future_sec = i;

537
538
539
540
541
542
543
		if (sechdrs[i].sh_type == SHT_SYMTAB) {
			unsigned int sh_link_idx;
			symtab_idx = i;
			info->symtab_start = (void *)hdr +
			    sechdrs[i].sh_offset;
			info->symtab_stop  = (void *)hdr +
			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
544
			sh_link_idx = sechdrs[i].sh_link;
545
546
547
			info->strtab       = (void *)hdr +
			    sechdrs[sh_link_idx].sh_offset;
		}
Linus Torvalds's avatar
Linus Torvalds committed
548

549
550
551
552
553
554
555
556
		/* 32bit section no. table? ("more than 64k sections") */
		if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
			symtab_shndx_idx = i;
			info->symtab_shndx_start = (void *)hdr +
			    sechdrs[i].sh_offset;
			info->symtab_shndx_stop  = (void *)hdr +
			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
		}
Linus Torvalds's avatar
Linus Torvalds committed
557
	}
Sam Ravnborg's avatar
Sam Ravnborg committed
558
	if (!info->symtab_start)
559
		fatal("%s has no symtab?\n", filename);
Sam Ravnborg's avatar
Sam Ravnborg committed
560

Linus Torvalds's avatar
Linus Torvalds committed
561
562
563
564
565
566
567
	/* Fix endianness in symbols */
	for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
		sym->st_shndx = TO_NATIVE(sym->st_shndx);
		sym->st_name  = TO_NATIVE(sym->st_name);
		sym->st_value = TO_NATIVE(sym->st_value);
		sym->st_size  = TO_NATIVE(sym->st_size);
	}
568
569
570

	if (symtab_shndx_idx != ~0U) {
		Elf32_Word *p;
571
		if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
572
			fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
573
			      filename, sechdrs[symtab_shndx_idx].sh_link,
574
575
576
577
578
579
580
			      symtab_idx);
		/* Fix endianness */
		for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
		     p++)
			*p = TO_NATIVE(*p);
	}

581
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
582
583
}

584
static void parse_elf_finish(struct elf_info *info)
Linus Torvalds's avatar
Linus Torvalds committed
585
586
587
588
{
	release_file(info->hdr, info->size);
}

589
590
591
static int ignore_undef_symbol(struct elf_info *info, const char *symname)
{
	/* ignore __this_module, it will be resolved shortly */
592
	if (strcmp(symname, "__this_module") == 0)
593
594
595
596
597
598
		return 1;
	/* ignore global offset table */
	if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
		return 1;
	if (info->hdr->e_machine == EM_PPC)
		/* Special register function linked on all modules during final link of .ko */
599
600
601
602
603
604
		if (strstarts(symname, "_restgpr_") ||
		    strstarts(symname, "_savegpr_") ||
		    strstarts(symname, "_rest32gpr_") ||
		    strstarts(symname, "_save32gpr_") ||
		    strstarts(symname, "_restvr_") ||
		    strstarts(symname, "_savevr_"))
605
			return 1;
606
607
	if (info->hdr->e_machine == EM_PPC64)
		/* Special register function linked on all modules during final link of .ko */
608
609
610
611
		if (strstarts(symname, "_restgpr0_") ||
		    strstarts(symname, "_savegpr0_") ||
		    strstarts(symname, "_restvr_") ||
		    strstarts(symname, "_savevr_") ||
612
		    strcmp(symname, ".TOC.") == 0)
613
			return 1;
614
615
616
617
	/* Do not ignore this symbol */
	return 0;
}

618
619
static void handle_modversions(struct module *mod, struct elf_info *info,
			       Elf_Sym *sym, const char *symname)
Linus Torvalds's avatar
Linus Torvalds committed
620
621
{
	unsigned int crc;
622
	enum export export;
623
	bool is_crc = false;
624

625
	if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
626
	    strstarts(symname, "__ksymtab"))
627
628
629
		export = export_from_secname(info, get_secindex(info, sym));
	else
		export = export_from_sec(info, get_secindex(info, sym));
Linus Torvalds's avatar
Linus Torvalds committed
630

631
	/* CRC'd symbol */
632
	if (strstarts(symname, "__crc_")) {
633
		is_crc = true;
634
		crc = (unsigned int) sym->st_value;
635
636
637
638
639
640
641
642
643
644
		if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS) {
			unsigned int *crcp;

			/* symbol points to the CRC in the ELF object */
			crcp = (void *)info->hdr + sym->st_value +
			       info->sechdrs[sym->st_shndx].sh_offset -
			       (info->hdr->e_type != ET_REL ?
				info->sechdrs[sym->st_shndx].sh_addr : 0);
			crc = *crcp;
		}
645
		sym_update_crc(symname + strlen("__crc_"), mod, crc,
646
647
648
				export);
	}

Linus Torvalds's avatar
Linus Torvalds committed
649
650
	switch (sym->st_shndx) {
	case SHN_COMMON:
651
		if (strstarts(symname, "__gnu_lto_")) {
652
653
654
			/* Should warn here, but modpost runs before the linker */
		} else
			warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
Linus Torvalds's avatar
Linus Torvalds committed
655
656
657
658
659
660
		break;
	case SHN_UNDEF:
		/* undefined symbol */
		if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
		    ELF_ST_BIND(sym->st_info) != STB_WEAK)
			break;
661
		if (ignore_undef_symbol(info, symname))
Linus Torvalds's avatar
Linus Torvalds committed
662
			break;
663
664
665
666
667
668
/* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
#if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
/* add compatibility with older glibc */
#ifndef STT_SPARC_REGISTER
#define STT_SPARC_REGISTER STT_REGISTER
#endif
Linus Torvalds's avatar
Linus Torvalds committed
669
670
671
		if (info->hdr->e_machine == EM_SPARC ||
		    info->hdr->e_machine == EM_SPARCV9) {
			/* Ignore register directives. */
672
			if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
Linus Torvalds's avatar
Linus Torvalds committed
673
				break;
674
			if (symname[0] == '.') {
675
				char *munged = NOFAIL(strdup(symname));
676
677
678
679
				munged[0] = '_';
				munged[1] = toupper(munged[1]);
				symname = munged;
			}
Linus Torvalds's avatar
Linus Torvalds committed
680
681
		}
#endif
682

683
684
		if (is_crc) {
			const char *e = is_vmlinux(mod->name) ?"":".ko";
685
686
			warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n",
			     symname + strlen("__crc_"), mod->name, e);
687
		}
Rusty Russell's avatar
Rusty Russell committed
688
689
690
		mod->unres = alloc_symbol(symname,
					  ELF_ST_BIND(sym->st_info) == STB_WEAK,
					  mod->unres);
Linus Torvalds's avatar
Linus Torvalds committed
691
692
693
		break;
	default:
		/* All exported symbols */
694
		if (strstarts(symname, "__ksymtab_")) {
695
			sym_add_exported(symname + strlen("__ksymtab_"), mod,
696
					export);
Linus Torvalds's avatar
Linus Torvalds committed
697
		}
698
		if (strcmp(symname, "init_module") == 0)
Linus Torvalds's avatar
Linus Torvalds committed
699
			mod->has_init = 1;
700
		if (strcmp(symname, "cleanup_module") == 0)
Linus Torvalds's avatar
Linus Torvalds committed
701
702
703
704
705
			mod->has_cleanup = 1;
		break;
	}
}

706
707
708
/**
 * Parse tag=value strings from .modinfo section
 **/
Linus Torvalds's avatar
Linus Torvalds committed
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
static char *next_string(char *string, unsigned long *secsize)
{
	/* Skip non-zero chars */
	while (string[0]) {
		string++;
		if ((*secsize)-- <= 1)
			return NULL;
	}

	/* Skip any zero padding. */
	while (!string[0]) {
		string++;
		if ((*secsize)-- <= 1)
			return NULL;
	}
	return string;
}

727
728
static char *get_next_modinfo(struct elf_info *info, const char *tag,
			      char *prev)
Linus Torvalds's avatar
Linus Torvalds committed
729
730
731
{
	char *p;
	unsigned int taglen = strlen(tag);
732
733
	char *modinfo = info->modinfo;
	unsigned long size = info->modinfo_len;
Linus Torvalds's avatar
Linus Torvalds committed
734

735
736
737
	if (prev) {
		size -= prev - modinfo;
		modinfo = next_string(prev, &size);
738
739
	}

Linus Torvalds's avatar
Linus Torvalds committed
740
741
742
743
744
745
746
	for (p = modinfo; p; p = next_string(p, &size)) {
		if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
			return p + taglen + 1;
	}
	return NULL;
}

747
static char *get_modinfo(struct elf_info *info, const char *tag)
748
749

{
750
	return get_next_modinfo(info, tag, NULL);
751
752
}

753
754
755
756
757
758
/**
 * Test if string s ends in string sub
 * return 0 if match
 **/
static int strrcmp(const char *s, const char *sub)
{
Sam Ravnborg's avatar
Sam Ravnborg committed
759
	int slen, sublen;
760

761
762
	if (!s || !sub)
		return 1;
763

764
	slen = strlen(s);
Sam Ravnborg's avatar
Sam Ravnborg committed
765
	sublen = strlen(sub);
766

767
768
769
	if ((slen == 0) || (sublen == 0))
		return 1;

Sam Ravnborg's avatar
Sam Ravnborg committed
770
771
	if (sublen > slen)
		return 1;
772

Sam Ravnborg's avatar
Sam Ravnborg committed
773
	return memcmp(s + slen - sublen, sub, sublen);
774
775
}

776
777
static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
{
778
779
780
	if (sym)
		return elf->strtab + sym->st_name;
	else
781
		return "(unknown)";
782
783
}

784
785
/* The pattern is an array of simple patterns.
 * "foo" will match an exact string equal to "foo"
786
 * "*foo" will match a string that ends with "foo"
787
 * "foo*" will match a string that begins with "foo"
788
 * "*foo*" will match a string that contains "foo"
789
 */
790
static int match(const char *sym, const char * const pat[])
791
792
793
794
795
796
{
	const char *p;
	while (*pat) {
		p = *pat++;
		const char *endp = p + strlen(p) - 1;

797
798
799
800
801
802
803
804
805
		/* "*foo*" */
		if (*p == '*' && *endp == '*') {
			char *here, *bare = strndup(p + 1, strlen(p) - 2);

			here = strstr(sym, bare);
			free(bare);
			if (here != NULL)
				return 1;
		}
806
		/* "*foo" */
807
		else if (*p == '*') {
808
809
810
			if (strrcmp(sym, p + 1) == 0)
				return 1;
		}
811
		/* "foo*" */
812
		else if (*endp == '*') {
813
814
815
816
817
818
819
820
821
822
823
824
825
826
			if (strncmp(sym, p, strlen(p) - 1) == 0)
				return 1;
		}
		/* no wildcards */
		else {
			if (strcmp(p, sym) == 0)
				return 1;
		}
	}
	/* no match */
	return 0;
}

/* sections that we do not want to do full section mismatch check on */
827
static const char *const section_white_list[] =
828
829
830
{
	".comment*",
	".debug*",
831
	".cranges",		/* sh64 */
832
	".zdebug*",		/* Compressed debug sections. */
833
	".GCC.command.line",	/* record-gcc-switches */
834
835
836
837
838
839
	".mdebug*",        /* alpha, score, mips etc. */
	".pdr",            /* alpha, score, mips etc. */
	".stab*",
	".note*",
	".got*",
	".toc*",
840
841
	".xt.prop",				 /* xtensa */
	".xt.lit",         /* xtensa */
842
843
	".arcextmap*",			/* arc */
	".gnu.linkonce.arcext*",	/* arc : modules */
844
845
	".cmem*",			/* EZchip */
	".fmt_slot*",			/* EZchip */
846
	".gnu.lto*",
847
	".discard.*",
848
849
	NULL
};
850

851
/*
852
 * This is used to find sections missing the SHF_ALLOC flag.
853
 * The cause of this is often a section specified in assembler
854
 * without "ax" / "aw".
855
 */
856
static void check_section(const char *modname, struct elf_info *elf,
857
			  Elf_Shdr *sechdr)
858
{
859
860
861
862
863
864
865
866
867
868
	const char *sec = sech_name(elf, sechdr);

	if (sechdr->sh_type == SHT_PROGBITS &&
	    !(sechdr->sh_flags & SHF_ALLOC) &&
	    !match(sec, section_white_list)) {
		warn("%s (%s): unexpected non-allocatable section.\n"
		     "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
		     "Note that for example <linux/init.h> contains\n"
		     "section definitions for use in .S files.\n\n",
		     modname, sec);
869
870
871
872
873
	}
}



874
#define ALL_INIT_DATA_SECTIONS \
875
876
	".init.setup", ".init.rodata", ".meminit.rodata", \
	".init.data", ".meminit.data"
877
#define ALL_EXIT_DATA_SECTIONS \
878
	".exit.data", ".memexit.data"
879

880
#define ALL_INIT_TEXT_SECTIONS \
881
	".init.text", ".meminit.text"
882
#define ALL_EXIT_TEXT_SECTIONS \
883
	".exit.text", ".memexit.text"
884

885
#define ALL_PCI_INIT_SECTIONS	\
886
887
888
	".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
	".pci_fixup_enable", ".pci_fixup_resume", \
	".pci_fixup_resume_early", ".pci_fixup_suspend"
889

890
891
#define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
892
893
894

#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
895

896
#define DATA_SECTIONS ".data", ".data.rel"
897
#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
898
		".kprobes.text", ".cpuidle.text"
899
#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
900
901
		".fixup", ".entry.text", ".exception.text", ".text.*", \
		".coldtext"
902

Jan Beulich's avatar
Jan Beulich committed
903
904
#define INIT_SECTIONS      ".init.*"
#define MEM_INIT_SECTIONS  ".meminit.*"
905

Jan Beulich's avatar
Jan Beulich committed
906
907
#define EXIT_SECTIONS      ".exit.*"
#define MEM_EXIT_SECTIONS  ".memexit.*"
908

909
910
911
#define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
		TEXT_SECTIONS, OTHER_TEXT_SECTIONS

912
/* init data sections */
913
914
static const char *const init_data_sections[] =
	{ ALL_INIT_DATA_SECTIONS, NULL };
915
916

/* all init sections */
917
static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
918
919

/* All init and exit sections (code + data) */
920
static const char *const init_exit_sections[] =
921
	{ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
922

923
924
925
/* all text sections */
static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };

926
/* data section */
927
static const char *const data_sections[] = { DATA_SECTIONS, NULL };
928
929
930


/* symbols in .data that may refer to init/exit sections */
931
932
933
934
935
936
937
938
939
#define DEFAULT_SYMBOL_WHITE_LIST					\
	"*driver",							\
	"*_template", /* scsi uses *_template a lot */			\
	"*_timer",    /* arm uses ops structures named _timer a lot */	\
	"*_sht",      /* scsi also used *_sht to some extent */		\
	"*_ops",							\
	"*_probe",							\
	"*_probe_one",							\
	"*_console"
940

941
942
static const char *const head_sections[] = { ".head.text*", NULL };
static const char *const linker_symbols[] =
943
	{ "__init_begin", "_sinittext", "_einittext", NULL };
944
static const char *const optim_symbols[] = { "*.constprop.*", NULL };
945

946
enum mismatch {
947
948
949
950
951
952
953
954
	TEXT_TO_ANY_INIT,
	DATA_TO_ANY_INIT,
	TEXT_TO_ANY_EXIT,
	DATA_TO_ANY_EXIT,
	XXXINIT_TO_SOME_INIT,
	XXXEXIT_TO_SOME_EXIT,
	ANY_INIT_TO_ANY_EXIT,
	ANY_EXIT_TO_ANY_INIT,
955
	EXPORT_TO_INIT_EXIT,
956
	EXTABLE_TO_NON_TEXT,
957
958
};

959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
/**
 * Describe how to match sections on different criterias:
 *
 * @fromsec: Array of sections to be matched.
 *
 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
 * this array is forbidden (black-list).  Can be empty.
 *
 * @good_tosec: Relocations applied to a section in @fromsec must be
 * targetting sections in this array (white-list).  Can be empty.
 *
 * @mismatch: Type of mismatch.
 *
 * @symbol_white_list: Do not match a relocation to a symbol in this list
 * even if it is targetting a section in @bad_to_sec.
 *
 * @handler: Specific handler to call when a match is found.  If NULL,
 * default_mismatch_handler() will be called.
 *
 */
979
980
struct sectioncheck {
	const char *fromsec[20];
981
982
	const char *bad_tosec[20];
	const char *good_tosec[20];
983
	enum mismatch mismatch;
984
	const char *symbol_white_list[20];
985
986
987
988
	void (*handler)(const char *modname, struct elf_info *elf,
			const struct sectioncheck* const mismatch,
			Elf_Rela *r, Elf_Sym *sym, const char *fromsec);

989
990
};

991
992
993
994
995
static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
				     const struct sectioncheck* const mismatch,
				     Elf_Rela *r, Elf_Sym *sym,
				     const char *fromsec);

996
static const struct sectioncheck sectioncheck[] = {
997
998
999
1000
/* Do not reference init/exit code/data from
 * normal code and data
 */
{
1001
	.fromsec = { TEXT_SECTIONS, NULL },
1002
	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
1003
	.mismatch = TEXT_TO_ANY_INIT,
1004
	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1005
1006
1007
},
{
	.fromsec = { DATA_SECTIONS, NULL },
1008
	.bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1009
	.mismatch = DATA_TO_ANY_INIT,
1010
	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1011
},
1012
1013
{
	.fromsec = { DATA_SECTIONS, NULL },
1014
	.bad_tosec = { INIT_SECTIONS, NULL },
1015
1016
1017
1018
1019
1020
	.mismatch = DATA_TO_ANY_INIT,
	.symbol_white_list = {
		"*_template", "*_timer", "*_sht", "*_ops",
		"*_probe", "*_probe_one", "*_console", NULL
	},
},
1021
1022
{
	.fromsec = { TEXT_SECTIONS, NULL },
1023
	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1024
	.mismatch = TEXT_TO_ANY_EXIT,
1025
	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1026
1027
1028
},
{
	.fromsec = { DATA_SECTIONS, NULL },
1029
	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1030
	.mismatch = DATA_TO_ANY_EXIT,
1031
	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1032
},
1033
/* Do not reference init code/data from meminit code/data */
1034
{
1035
	.fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1036
	.bad_tosec = { INIT_SECTIONS, NULL },
1037
	.mismatch = XXXINIT_TO_SOME_INIT,
1038
	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1039
},
1040
/* Do not reference exit code/data from memexit code/data */
1041
{
1042
	.fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1043
	.bad_tosec = { EXIT_SECTIONS, NULL },
1044
	.mismatch = XXXEXIT_TO_SOME_EXIT,
1045
	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1046
1047
1048
},
/* Do not use exit code/data from init code */
{
1049
	.fromsec = { ALL_INIT_SECTIONS, NULL },
1050
	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1051
	.mismatch = ANY_INIT_TO_ANY_EXIT,
1052
	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1053
1054
1055
},
/* Do not use init code/data from exit code */
{
1056
	.fromsec = { ALL_EXIT_SECTIONS, NULL },
1057
	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
1058
	.mismatch = ANY_EXIT_TO_ANY_INIT,
1059
	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1060
},
1061
1062
{
	.fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1063
	.bad_tosec = { INIT_SECTIONS, NULL },
1064
1065
1066
	.mismatch = ANY_INIT_TO_ANY_EXIT,
	.symbol_white_list = { NULL },
},
1067
1068
1069
/* Do not export init/exit functions or data */
{
	.fromsec = { "__ksymtab*", NULL },
1070
	.bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1071
1072
	.mismatch = EXPORT_TO_INIT_EXIT,
	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
},
{
	.fromsec = { "__ex_table", NULL },
	/* If you're adding any new black-listed sections in here, consider
	 * adding a special 'printer' for them in scripts/check_extable.
	 */
	.bad_tosec = { ".altinstr_replacement", NULL },
	.good_tosec = {ALL_TEXT_SECTIONS , NULL},
	.mismatch = EXTABLE_TO_NON_TEXT,
	.handler = extable_mismatch_handler,
1083
1084
1085
}
};

1086
1087
static const struct sectioncheck *section_mismatch(
		const char *fromsec, const char *tosec)
1088
1089
1090
1091
1092
{
	int i;
	int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
	const struct sectioncheck *check = &sectioncheck[0];

1093
1094
1095
	/*
	 * The target section could be the SHT_NUL section when we're
	 * handling relocations to un-resolved symbols, trying to match it
1096
1097
	 * doesn't make much sense and causes build failures on parisc
	 * architectures.
1098
1099
1100
1101
	 */
	if (*tosec == '\0')
		return NULL;

1102
	for (i = 0; i < elems; i++) {
1103
1104
1105
1106
1107
1108
		if (match(fromsec, check->fromsec)) {
			if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
				return check;
			if (check->good_tosec[0] && !match(tosec, check->good_tosec))
				return check;
		}
1109
1110
		check++;
	}
1111
	return NULL;
1112
1113
}

1114
1115
/**
 * Whitelist to allow certain references to pass with no warning.
1116
 *