xref: /openbmc/linux/scripts/mod/modpost.c (revision 8795a739)
1 /* Postprocess module symbol versions
2  *
3  * Copyright 2003       Kai Germaschewski
4  * Copyright 2002-2004  Rusty Russell, IBM Corporation
5  * Copyright 2006-2008  Sam Ravnborg
6  * Based in part on module-init-tools/depmod.c,file2alias
7  *
8  * This software may be used and distributed according to the terms
9  * of the GNU General Public License, incorporated herein by reference.
10  *
11  * Usage: modpost vmlinux module1.o module2.o ...
12  */
13 
14 #define _GNU_SOURCE
15 #include <stdio.h>
16 #include <ctype.h>
17 #include <string.h>
18 #include <limits.h>
19 #include <stdbool.h>
20 #include <errno.h>
21 #include "modpost.h"
22 #include "../../include/linux/license.h"
23 
24 /* Are we using CONFIG_MODVERSIONS? */
25 static int modversions = 0;
26 /* Warn about undefined symbols? (do so if we have vmlinux) */
27 static int have_vmlinux = 0;
28 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
29 static int all_versions = 0;
30 /* If we are modposting external module set to 1 */
31 static int external_module = 0;
32 /* Warn about section mismatch in vmlinux if set to 1 */
33 static int vmlinux_section_warnings = 1;
34 /* Only warn about unresolved symbols */
35 static int warn_unresolved = 0;
36 /* How a symbol is exported */
37 static int sec_mismatch_count = 0;
38 static int sec_mismatch_fatal = 0;
39 /* ignore missing files */
40 static int ignore_missing_files;
41 /* write namespace dependencies */
42 static int write_namespace_deps;
43 
44 enum export {
45 	export_plain,      export_unused,     export_gpl,
46 	export_unused_gpl, export_gpl_future, export_unknown
47 };
48 
49 /* In kernel, this size is defined in linux/module.h;
50  * here we use Elf_Addr instead of long for covering cross-compile
51  */
52 
53 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
54 
55 #define PRINTF __attribute__ ((format (printf, 1, 2)))
56 
57 PRINTF void fatal(const char *fmt, ...)
58 {
59 	va_list arglist;
60 
61 	fprintf(stderr, "FATAL: ");
62 
63 	va_start(arglist, fmt);
64 	vfprintf(stderr, fmt, arglist);
65 	va_end(arglist);
66 
67 	exit(1);
68 }
69 
70 PRINTF void warn(const char *fmt, ...)
71 {
72 	va_list arglist;
73 
74 	fprintf(stderr, "WARNING: ");
75 
76 	va_start(arglist, fmt);
77 	vfprintf(stderr, fmt, arglist);
78 	va_end(arglist);
79 }
80 
81 PRINTF void merror(const char *fmt, ...)
82 {
83 	va_list arglist;
84 
85 	fprintf(stderr, "ERROR: ");
86 
87 	va_start(arglist, fmt);
88 	vfprintf(stderr, fmt, arglist);
89 	va_end(arglist);
90 }
91 
92 static inline bool strends(const char *str, const char *postfix)
93 {
94 	if (strlen(str) < strlen(postfix))
95 		return false;
96 
97 	return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
98 }
99 
100 static int is_vmlinux(const char *modname)
101 {
102 	const char *myname;
103 
104 	myname = strrchr(modname, '/');
105 	if (myname)
106 		myname++;
107 	else
108 		myname = modname;
109 
110 	return (strcmp(myname, "vmlinux") == 0) ||
111 	       (strcmp(myname, "vmlinux.o") == 0);
112 }
113 
114 void *do_nofail(void *ptr, const char *expr)
115 {
116 	if (!ptr)
117 		fatal("modpost: Memory allocation failure: %s.\n", expr);
118 
119 	return ptr;
120 }
121 
122 /* A list of all modules we processed */
123 static struct module *modules;
124 
125 static struct module *find_module(const char *modname)
126 {
127 	struct module *mod;
128 
129 	for (mod = modules; mod; mod = mod->next)
130 		if (strcmp(mod->name, modname) == 0)
131 			break;
132 	return mod;
133 }
134 
135 static struct module *new_module(const char *modname)
136 {
137 	struct module *mod;
138 	char *p;
139 
140 	mod = NOFAIL(malloc(sizeof(*mod)));
141 	memset(mod, 0, sizeof(*mod));
142 	p = NOFAIL(strdup(modname));
143 
144 	/* strip trailing .o */
145 	if (strends(p, ".o")) {
146 		p[strlen(p) - 2] = '\0';
147 		mod->is_dot_o = 1;
148 	}
149 
150 	/* add to list */
151 	mod->name = p;
152 	mod->gpl_compatible = -1;
153 	mod->next = modules;
154 	modules = mod;
155 
156 	return mod;
157 }
158 
159 /* A hash of all exported symbols,
160  * struct symbol is also used for lists of unresolved symbols */
161 
162 #define SYMBOL_HASH_SIZE 1024
163 
164 struct symbol {
165 	struct symbol *next;
166 	struct module *module;
167 	unsigned int crc;
168 	int crc_valid;
169 	const char *namespace;
170 	unsigned int weak:1;
171 	unsigned int vmlinux:1;    /* 1 if symbol is defined in vmlinux */
172 	unsigned int kernel:1;     /* 1 if symbol is from kernel
173 				    *  (only for external modules) **/
174 	unsigned int preloaded:1;  /* 1 if symbol from Module.symvers, or crc */
175 	unsigned int is_static:1;  /* 1 if symbol is not global */
176 	enum export  export;       /* Type of export */
177 	char name[0];
178 };
179 
180 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
181 
182 /* This is based on the hash agorithm from gdbm, via tdb */
183 static inline unsigned int tdb_hash(const char *name)
184 {
185 	unsigned value;	/* Used to compute the hash value.  */
186 	unsigned   i;	/* Used to cycle through random values. */
187 
188 	/* Set the initial value from the key size. */
189 	for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
190 		value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
191 
192 	return (1103515243 * value + 12345);
193 }
194 
195 /**
196  * Allocate a new symbols for use in the hash of exported symbols or
197  * the list of unresolved symbols per module
198  **/
199 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
200 				   struct symbol *next)
201 {
202 	struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
203 
204 	memset(s, 0, sizeof(*s));
205 	strcpy(s->name, name);
206 	s->weak = weak;
207 	s->next = next;
208 	s->is_static = 1;
209 	return s;
210 }
211 
212 /* For the hash of exported symbols */
213 static struct symbol *new_symbol(const char *name, struct module *module,
214 				 enum export export)
215 {
216 	unsigned int hash;
217 	struct symbol *new;
218 
219 	hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
220 	new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
221 	new->module = module;
222 	new->export = export;
223 	return new;
224 }
225 
226 static struct symbol *find_symbol(const char *name)
227 {
228 	struct symbol *s;
229 
230 	/* For our purposes, .foo matches foo.  PPC64 needs this. */
231 	if (name[0] == '.')
232 		name++;
233 
234 	for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
235 		if (strcmp(s->name, name) == 0)
236 			return s;
237 	}
238 	return NULL;
239 }
240 
241 static bool contains_namespace(struct namespace_list *list,
242 			       const char *namespace)
243 {
244 	struct namespace_list *ns_entry;
245 
246 	for (ns_entry = list; ns_entry != NULL; ns_entry = ns_entry->next)
247 		if (strcmp(ns_entry->namespace, namespace) == 0)
248 			return true;
249 
250 	return false;
251 }
252 
253 static void add_namespace(struct namespace_list **list, const char *namespace)
254 {
255 	struct namespace_list *ns_entry;
256 
257 	if (!contains_namespace(*list, namespace)) {
258 		ns_entry = NOFAIL(malloc(sizeof(struct namespace_list) +
259 					 strlen(namespace) + 1));
260 		strcpy(ns_entry->namespace, namespace);
261 		ns_entry->next = *list;
262 		*list = ns_entry;
263 	}
264 }
265 
266 static bool module_imports_namespace(struct module *module,
267 				     const char *namespace)
268 {
269 	return contains_namespace(module->imported_namespaces, namespace);
270 }
271 
272 static const struct {
273 	const char *str;
274 	enum export export;
275 } export_list[] = {
276 	{ .str = "EXPORT_SYMBOL",            .export = export_plain },
277 	{ .str = "EXPORT_UNUSED_SYMBOL",     .export = export_unused },
278 	{ .str = "EXPORT_SYMBOL_GPL",        .export = export_gpl },
279 	{ .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
280 	{ .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
281 	{ .str = "(unknown)",                .export = export_unknown },
282 };
283 
284 
285 static const char *export_str(enum export ex)
286 {
287 	return export_list[ex].str;
288 }
289 
290 static enum export export_no(const char *s)
291 {
292 	int i;
293 
294 	if (!s)
295 		return export_unknown;
296 	for (i = 0; export_list[i].export != export_unknown; i++) {
297 		if (strcmp(export_list[i].str, s) == 0)
298 			return export_list[i].export;
299 	}
300 	return export_unknown;
301 }
302 
303 static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
304 {
305 	return (void *)elf->hdr +
306 		elf->sechdrs[elf->secindex_strings].sh_offset +
307 		sechdr->sh_name;
308 }
309 
310 static const char *sec_name(struct elf_info *elf, int secindex)
311 {
312 	return sech_name(elf, &elf->sechdrs[secindex]);
313 }
314 
315 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
316 
317 static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
318 {
319 	const char *secname = sec_name(elf, sec);
320 
321 	if (strstarts(secname, "___ksymtab+"))
322 		return export_plain;
323 	else if (strstarts(secname, "___ksymtab_unused+"))
324 		return export_unused;
325 	else if (strstarts(secname, "___ksymtab_gpl+"))
326 		return export_gpl;
327 	else if (strstarts(secname, "___ksymtab_unused_gpl+"))
328 		return export_unused_gpl;
329 	else if (strstarts(secname, "___ksymtab_gpl_future+"))
330 		return export_gpl_future;
331 	else
332 		return export_unknown;
333 }
334 
335 static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
336 {
337 	if (sec == elf->export_sec)
338 		return export_plain;
339 	else if (sec == elf->export_unused_sec)
340 		return export_unused;
341 	else if (sec == elf->export_gpl_sec)
342 		return export_gpl;
343 	else if (sec == elf->export_unused_gpl_sec)
344 		return export_unused_gpl;
345 	else if (sec == elf->export_gpl_future_sec)
346 		return export_gpl_future;
347 	else
348 		return export_unknown;
349 }
350 
351 static const char *sym_extract_namespace(const char **symname)
352 {
353 	size_t n;
354 	char *dupsymname;
355 
356 	n = strcspn(*symname, ".");
357 	if (n < strlen(*symname) - 1) {
358 		dupsymname = NOFAIL(strdup(*symname));
359 		dupsymname[n] = '\0';
360 		*symname = dupsymname;
361 		return dupsymname + n + 1;
362 	}
363 
364 	return NULL;
365 }
366 
367 /**
368  * Add an exported symbol - it may have already been added without a
369  * CRC, in this case just update the CRC
370  **/
371 static struct symbol *sym_add_exported(const char *name, const char *namespace,
372 				       struct module *mod, enum export export)
373 {
374 	struct symbol *s = find_symbol(name);
375 
376 	if (!s) {
377 		s = new_symbol(name, mod, export);
378 		s->namespace = namespace;
379 	} else {
380 		if (!s->preloaded) {
381 			warn("%s: '%s' exported twice. Previous export was in %s%s\n",
382 			     mod->name, name, s->module->name,
383 			     is_vmlinux(s->module->name) ? "" : ".ko");
384 		} else {
385 			/* In case Module.symvers was out of date */
386 			s->module = mod;
387 		}
388 	}
389 	s->preloaded = 0;
390 	s->vmlinux   = is_vmlinux(mod->name);
391 	s->kernel    = 0;
392 	s->export    = export;
393 	return s;
394 }
395 
396 static void sym_update_crc(const char *name, struct module *mod,
397 			   unsigned int crc, enum export export)
398 {
399 	struct symbol *s = find_symbol(name);
400 
401 	if (!s) {
402 		s = new_symbol(name, mod, export);
403 		/* Don't complain when we find it later. */
404 		s->preloaded = 1;
405 	}
406 	s->crc = crc;
407 	s->crc_valid = 1;
408 }
409 
410 void *grab_file(const char *filename, unsigned long *size)
411 {
412 	struct stat st;
413 	void *map = MAP_FAILED;
414 	int fd;
415 
416 	fd = open(filename, O_RDONLY);
417 	if (fd < 0)
418 		return NULL;
419 	if (fstat(fd, &st))
420 		goto failed;
421 
422 	*size = st.st_size;
423 	map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
424 
425 failed:
426 	close(fd);
427 	if (map == MAP_FAILED)
428 		return NULL;
429 	return map;
430 }
431 
432 /**
433   * Return a copy of the next line in a mmap'ed file.
434   * spaces in the beginning of the line is trimmed away.
435   * Return a pointer to a static buffer.
436   **/
437 char *get_next_line(unsigned long *pos, void *file, unsigned long size)
438 {
439 	static char line[4096];
440 	int skip = 1;
441 	size_t len = 0;
442 	signed char *p = (signed char *)file + *pos;
443 	char *s = line;
444 
445 	for (; *pos < size ; (*pos)++) {
446 		if (skip && isspace(*p)) {
447 			p++;
448 			continue;
449 		}
450 		skip = 0;
451 		if (*p != '\n' && (*pos < size)) {
452 			len++;
453 			*s++ = *p++;
454 			if (len > 4095)
455 				break; /* Too long, stop */
456 		} else {
457 			/* End of string */
458 			*s = '\0';
459 			return line;
460 		}
461 	}
462 	/* End of buffer */
463 	return NULL;
464 }
465 
466 void release_file(void *file, unsigned long size)
467 {
468 	munmap(file, size);
469 }
470 
471 static int parse_elf(struct elf_info *info, const char *filename)
472 {
473 	unsigned int i;
474 	Elf_Ehdr *hdr;
475 	Elf_Shdr *sechdrs;
476 	Elf_Sym  *sym;
477 	const char *secstrings;
478 	unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
479 
480 	hdr = grab_file(filename, &info->size);
481 	if (!hdr) {
482 		if (ignore_missing_files) {
483 			fprintf(stderr, "%s: %s (ignored)\n", filename,
484 				strerror(errno));
485 			return 0;
486 		}
487 		perror(filename);
488 		exit(1);
489 	}
490 	info->hdr = hdr;
491 	if (info->size < sizeof(*hdr)) {
492 		/* file too small, assume this is an empty .o file */
493 		return 0;
494 	}
495 	/* Is this a valid ELF file? */
496 	if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
497 	    (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
498 	    (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
499 	    (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
500 		/* Not an ELF file - silently ignore it */
501 		return 0;
502 	}
503 	/* Fix endianness in ELF header */
504 	hdr->e_type      = TO_NATIVE(hdr->e_type);
505 	hdr->e_machine   = TO_NATIVE(hdr->e_machine);
506 	hdr->e_version   = TO_NATIVE(hdr->e_version);
507 	hdr->e_entry     = TO_NATIVE(hdr->e_entry);
508 	hdr->e_phoff     = TO_NATIVE(hdr->e_phoff);
509 	hdr->e_shoff     = TO_NATIVE(hdr->e_shoff);
510 	hdr->e_flags     = TO_NATIVE(hdr->e_flags);
511 	hdr->e_ehsize    = TO_NATIVE(hdr->e_ehsize);
512 	hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
513 	hdr->e_phnum     = TO_NATIVE(hdr->e_phnum);
514 	hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
515 	hdr->e_shnum     = TO_NATIVE(hdr->e_shnum);
516 	hdr->e_shstrndx  = TO_NATIVE(hdr->e_shstrndx);
517 	sechdrs = (void *)hdr + hdr->e_shoff;
518 	info->sechdrs = sechdrs;
519 
520 	/* Check if file offset is correct */
521 	if (hdr->e_shoff > info->size) {
522 		fatal("section header offset=%lu in file '%s' is bigger than "
523 		      "filesize=%lu\n", (unsigned long)hdr->e_shoff,
524 		      filename, info->size);
525 		return 0;
526 	}
527 
528 	if (hdr->e_shnum == SHN_UNDEF) {
529 		/*
530 		 * There are more than 64k sections,
531 		 * read count from .sh_size.
532 		 */
533 		info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
534 	}
535 	else {
536 		info->num_sections = hdr->e_shnum;
537 	}
538 	if (hdr->e_shstrndx == SHN_XINDEX) {
539 		info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
540 	}
541 	else {
542 		info->secindex_strings = hdr->e_shstrndx;
543 	}
544 
545 	/* Fix endianness in section headers */
546 	for (i = 0; i < info->num_sections; i++) {
547 		sechdrs[i].sh_name      = TO_NATIVE(sechdrs[i].sh_name);
548 		sechdrs[i].sh_type      = TO_NATIVE(sechdrs[i].sh_type);
549 		sechdrs[i].sh_flags     = TO_NATIVE(sechdrs[i].sh_flags);
550 		sechdrs[i].sh_addr      = TO_NATIVE(sechdrs[i].sh_addr);
551 		sechdrs[i].sh_offset    = TO_NATIVE(sechdrs[i].sh_offset);
552 		sechdrs[i].sh_size      = TO_NATIVE(sechdrs[i].sh_size);
553 		sechdrs[i].sh_link      = TO_NATIVE(sechdrs[i].sh_link);
554 		sechdrs[i].sh_info      = TO_NATIVE(sechdrs[i].sh_info);
555 		sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
556 		sechdrs[i].sh_entsize   = TO_NATIVE(sechdrs[i].sh_entsize);
557 	}
558 	/* Find symbol table. */
559 	secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
560 	for (i = 1; i < info->num_sections; i++) {
561 		const char *secname;
562 		int nobits = sechdrs[i].sh_type == SHT_NOBITS;
563 
564 		if (!nobits && sechdrs[i].sh_offset > info->size) {
565 			fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
566 			      "sizeof(*hrd)=%zu\n", filename,
567 			      (unsigned long)sechdrs[i].sh_offset,
568 			      sizeof(*hdr));
569 			return 0;
570 		}
571 		secname = secstrings + sechdrs[i].sh_name;
572 		if (strcmp(secname, ".modinfo") == 0) {
573 			if (nobits)
574 				fatal("%s has NOBITS .modinfo\n", filename);
575 			info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
576 			info->modinfo_len = sechdrs[i].sh_size;
577 		} else if (strcmp(secname, "__ksymtab") == 0)
578 			info->export_sec = i;
579 		else if (strcmp(secname, "__ksymtab_unused") == 0)
580 			info->export_unused_sec = i;
581 		else if (strcmp(secname, "__ksymtab_gpl") == 0)
582 			info->export_gpl_sec = i;
583 		else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
584 			info->export_unused_gpl_sec = i;
585 		else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
586 			info->export_gpl_future_sec = i;
587 
588 		if (sechdrs[i].sh_type == SHT_SYMTAB) {
589 			unsigned int sh_link_idx;
590 			symtab_idx = i;
591 			info->symtab_start = (void *)hdr +
592 			    sechdrs[i].sh_offset;
593 			info->symtab_stop  = (void *)hdr +
594 			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
595 			sh_link_idx = sechdrs[i].sh_link;
596 			info->strtab       = (void *)hdr +
597 			    sechdrs[sh_link_idx].sh_offset;
598 		}
599 
600 		/* 32bit section no. table? ("more than 64k sections") */
601 		if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
602 			symtab_shndx_idx = i;
603 			info->symtab_shndx_start = (void *)hdr +
604 			    sechdrs[i].sh_offset;
605 			info->symtab_shndx_stop  = (void *)hdr +
606 			    sechdrs[i].sh_offset + sechdrs[i].sh_size;
607 		}
608 	}
609 	if (!info->symtab_start)
610 		fatal("%s has no symtab?\n", filename);
611 
612 	/* Fix endianness in symbols */
613 	for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
614 		sym->st_shndx = TO_NATIVE(sym->st_shndx);
615 		sym->st_name  = TO_NATIVE(sym->st_name);
616 		sym->st_value = TO_NATIVE(sym->st_value);
617 		sym->st_size  = TO_NATIVE(sym->st_size);
618 	}
619 
620 	if (symtab_shndx_idx != ~0U) {
621 		Elf32_Word *p;
622 		if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
623 			fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
624 			      filename, sechdrs[symtab_shndx_idx].sh_link,
625 			      symtab_idx);
626 		/* Fix endianness */
627 		for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
628 		     p++)
629 			*p = TO_NATIVE(*p);
630 	}
631 
632 	return 1;
633 }
634 
635 static void parse_elf_finish(struct elf_info *info)
636 {
637 	release_file(info->hdr, info->size);
638 }
639 
640 static int ignore_undef_symbol(struct elf_info *info, const char *symname)
641 {
642 	/* ignore __this_module, it will be resolved shortly */
643 	if (strcmp(symname, "__this_module") == 0)
644 		return 1;
645 	/* ignore global offset table */
646 	if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
647 		return 1;
648 	if (info->hdr->e_machine == EM_PPC)
649 		/* Special register function linked on all modules during final link of .ko */
650 		if (strstarts(symname, "_restgpr_") ||
651 		    strstarts(symname, "_savegpr_") ||
652 		    strstarts(symname, "_rest32gpr_") ||
653 		    strstarts(symname, "_save32gpr_") ||
654 		    strstarts(symname, "_restvr_") ||
655 		    strstarts(symname, "_savevr_"))
656 			return 1;
657 	if (info->hdr->e_machine == EM_PPC64)
658 		/* Special register function linked on all modules during final link of .ko */
659 		if (strstarts(symname, "_restgpr0_") ||
660 		    strstarts(symname, "_savegpr0_") ||
661 		    strstarts(symname, "_restvr_") ||
662 		    strstarts(symname, "_savevr_") ||
663 		    strcmp(symname, ".TOC.") == 0)
664 			return 1;
665 	/* Do not ignore this symbol */
666 	return 0;
667 }
668 
669 static void handle_modversions(struct module *mod, struct elf_info *info,
670 			       Elf_Sym *sym, const char *symname)
671 {
672 	unsigned int crc;
673 	enum export export;
674 	bool is_crc = false;
675 	const char *name, *namespace;
676 
677 	if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
678 	    strstarts(symname, "__ksymtab"))
679 		export = export_from_secname(info, get_secindex(info, sym));
680 	else
681 		export = export_from_sec(info, get_secindex(info, sym));
682 
683 	/* CRC'd symbol */
684 	if (strstarts(symname, "__crc_")) {
685 		is_crc = true;
686 		crc = (unsigned int) sym->st_value;
687 		if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS) {
688 			unsigned int *crcp;
689 
690 			/* symbol points to the CRC in the ELF object */
691 			crcp = (void *)info->hdr + sym->st_value +
692 			       info->sechdrs[sym->st_shndx].sh_offset -
693 			       (info->hdr->e_type != ET_REL ?
694 				info->sechdrs[sym->st_shndx].sh_addr : 0);
695 			crc = TO_NATIVE(*crcp);
696 		}
697 		sym_update_crc(symname + strlen("__crc_"), mod, crc,
698 				export);
699 	}
700 
701 	switch (sym->st_shndx) {
702 	case SHN_COMMON:
703 		if (strstarts(symname, "__gnu_lto_")) {
704 			/* Should warn here, but modpost runs before the linker */
705 		} else
706 			warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
707 		break;
708 	case SHN_UNDEF:
709 		/* undefined symbol */
710 		if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
711 		    ELF_ST_BIND(sym->st_info) != STB_WEAK)
712 			break;
713 		if (ignore_undef_symbol(info, symname))
714 			break;
715 /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
716 #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
717 /* add compatibility with older glibc */
718 #ifndef STT_SPARC_REGISTER
719 #define STT_SPARC_REGISTER STT_REGISTER
720 #endif
721 		if (info->hdr->e_machine == EM_SPARC ||
722 		    info->hdr->e_machine == EM_SPARCV9) {
723 			/* Ignore register directives. */
724 			if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
725 				break;
726 			if (symname[0] == '.') {
727 				char *munged = NOFAIL(strdup(symname));
728 				munged[0] = '_';
729 				munged[1] = toupper(munged[1]);
730 				symname = munged;
731 			}
732 		}
733 #endif
734 
735 		if (is_crc) {
736 			const char *e = is_vmlinux(mod->name) ?"":".ko";
737 			warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n",
738 			     symname + strlen("__crc_"), mod->name, e);
739 		}
740 		mod->unres = alloc_symbol(symname,
741 					  ELF_ST_BIND(sym->st_info) == STB_WEAK,
742 					  mod->unres);
743 		break;
744 	default:
745 		/* All exported symbols */
746 		if (strstarts(symname, "__ksymtab_")) {
747 			name = symname + strlen("__ksymtab_");
748 			namespace = sym_extract_namespace(&name);
749 			sym_add_exported(name, namespace, mod, export);
750 		}
751 		if (strcmp(symname, "init_module") == 0)
752 			mod->has_init = 1;
753 		if (strcmp(symname, "cleanup_module") == 0)
754 			mod->has_cleanup = 1;
755 		break;
756 	}
757 }
758 
759 /**
760  * Parse tag=value strings from .modinfo section
761  **/
762 static char *next_string(char *string, unsigned long *secsize)
763 {
764 	/* Skip non-zero chars */
765 	while (string[0]) {
766 		string++;
767 		if ((*secsize)-- <= 1)
768 			return NULL;
769 	}
770 
771 	/* Skip any zero padding. */
772 	while (!string[0]) {
773 		string++;
774 		if ((*secsize)-- <= 1)
775 			return NULL;
776 	}
777 	return string;
778 }
779 
780 static char *get_next_modinfo(struct elf_info *info, const char *tag,
781 			      char *prev)
782 {
783 	char *p;
784 	unsigned int taglen = strlen(tag);
785 	char *modinfo = info->modinfo;
786 	unsigned long size = info->modinfo_len;
787 
788 	if (prev) {
789 		size -= prev - modinfo;
790 		modinfo = next_string(prev, &size);
791 	}
792 
793 	for (p = modinfo; p; p = next_string(p, &size)) {
794 		if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
795 			return p + taglen + 1;
796 	}
797 	return NULL;
798 }
799 
800 static char *get_modinfo(struct elf_info *info, const char *tag)
801 
802 {
803 	return get_next_modinfo(info, tag, NULL);
804 }
805 
806 /**
807  * Test if string s ends in string sub
808  * return 0 if match
809  **/
810 static int strrcmp(const char *s, const char *sub)
811 {
812 	int slen, sublen;
813 
814 	if (!s || !sub)
815 		return 1;
816 
817 	slen = strlen(s);
818 	sublen = strlen(sub);
819 
820 	if ((slen == 0) || (sublen == 0))
821 		return 1;
822 
823 	if (sublen > slen)
824 		return 1;
825 
826 	return memcmp(s + slen - sublen, sub, sublen);
827 }
828 
829 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
830 {
831 	if (sym)
832 		return elf->strtab + sym->st_name;
833 	else
834 		return "(unknown)";
835 }
836 
837 /* The pattern is an array of simple patterns.
838  * "foo" will match an exact string equal to "foo"
839  * "*foo" will match a string that ends with "foo"
840  * "foo*" will match a string that begins with "foo"
841  * "*foo*" will match a string that contains "foo"
842  */
843 static int match(const char *sym, const char * const pat[])
844 {
845 	const char *p;
846 	while (*pat) {
847 		p = *pat++;
848 		const char *endp = p + strlen(p) - 1;
849 
850 		/* "*foo*" */
851 		if (*p == '*' && *endp == '*') {
852 			char *bare = NOFAIL(strndup(p + 1, strlen(p) - 2));
853 			char *here = strstr(sym, bare);
854 
855 			free(bare);
856 			if (here != NULL)
857 				return 1;
858 		}
859 		/* "*foo" */
860 		else if (*p == '*') {
861 			if (strrcmp(sym, p + 1) == 0)
862 				return 1;
863 		}
864 		/* "foo*" */
865 		else if (*endp == '*') {
866 			if (strncmp(sym, p, strlen(p) - 1) == 0)
867 				return 1;
868 		}
869 		/* no wildcards */
870 		else {
871 			if (strcmp(p, sym) == 0)
872 				return 1;
873 		}
874 	}
875 	/* no match */
876 	return 0;
877 }
878 
879 /* sections that we do not want to do full section mismatch check on */
880 static const char *const section_white_list[] =
881 {
882 	".comment*",
883 	".debug*",
884 	".cranges",		/* sh64 */
885 	".zdebug*",		/* Compressed debug sections. */
886 	".GCC.command.line",	/* record-gcc-switches */
887 	".mdebug*",        /* alpha, score, mips etc. */
888 	".pdr",            /* alpha, score, mips etc. */
889 	".stab*",
890 	".note*",
891 	".got*",
892 	".toc*",
893 	".xt.prop",				 /* xtensa */
894 	".xt.lit",         /* xtensa */
895 	".arcextmap*",			/* arc */
896 	".gnu.linkonce.arcext*",	/* arc : modules */
897 	".cmem*",			/* EZchip */
898 	".fmt_slot*",			/* EZchip */
899 	".gnu.lto*",
900 	".discard.*",
901 	NULL
902 };
903 
904 /*
905  * This is used to find sections missing the SHF_ALLOC flag.
906  * The cause of this is often a section specified in assembler
907  * without "ax" / "aw".
908  */
909 static void check_section(const char *modname, struct elf_info *elf,
910 			  Elf_Shdr *sechdr)
911 {
912 	const char *sec = sech_name(elf, sechdr);
913 
914 	if (sechdr->sh_type == SHT_PROGBITS &&
915 	    !(sechdr->sh_flags & SHF_ALLOC) &&
916 	    !match(sec, section_white_list)) {
917 		warn("%s (%s): unexpected non-allocatable section.\n"
918 		     "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
919 		     "Note that for example <linux/init.h> contains\n"
920 		     "section definitions for use in .S files.\n\n",
921 		     modname, sec);
922 	}
923 }
924 
925 
926 
927 #define ALL_INIT_DATA_SECTIONS \
928 	".init.setup", ".init.rodata", ".meminit.rodata", \
929 	".init.data", ".meminit.data"
930 #define ALL_EXIT_DATA_SECTIONS \
931 	".exit.data", ".memexit.data"
932 
933 #define ALL_INIT_TEXT_SECTIONS \
934 	".init.text", ".meminit.text"
935 #define ALL_EXIT_TEXT_SECTIONS \
936 	".exit.text", ".memexit.text"
937 
938 #define ALL_PCI_INIT_SECTIONS	\
939 	".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
940 	".pci_fixup_enable", ".pci_fixup_resume", \
941 	".pci_fixup_resume_early", ".pci_fixup_suspend"
942 
943 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
944 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
945 
946 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
947 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
948 
949 #define DATA_SECTIONS ".data", ".data.rel"
950 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
951 		".kprobes.text", ".cpuidle.text"
952 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
953 		".fixup", ".entry.text", ".exception.text", ".text.*", \
954 		".coldtext"
955 
956 #define INIT_SECTIONS      ".init.*"
957 #define MEM_INIT_SECTIONS  ".meminit.*"
958 
959 #define EXIT_SECTIONS      ".exit.*"
960 #define MEM_EXIT_SECTIONS  ".memexit.*"
961 
962 #define ALL_TEXT_SECTIONS  ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
963 		TEXT_SECTIONS, OTHER_TEXT_SECTIONS
964 
965 /* init data sections */
966 static const char *const init_data_sections[] =
967 	{ ALL_INIT_DATA_SECTIONS, NULL };
968 
969 /* all init sections */
970 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
971 
972 /* All init and exit sections (code + data) */
973 static const char *const init_exit_sections[] =
974 	{ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
975 
976 /* all text sections */
977 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
978 
979 /* data section */
980 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
981 
982 
983 /* symbols in .data that may refer to init/exit sections */
984 #define DEFAULT_SYMBOL_WHITE_LIST					\
985 	"*driver",							\
986 	"*_template", /* scsi uses *_template a lot */			\
987 	"*_timer",    /* arm uses ops structures named _timer a lot */	\
988 	"*_sht",      /* scsi also used *_sht to some extent */		\
989 	"*_ops",							\
990 	"*_probe",							\
991 	"*_probe_one",							\
992 	"*_console"
993 
994 static const char *const head_sections[] = { ".head.text*", NULL };
995 static const char *const linker_symbols[] =
996 	{ "__init_begin", "_sinittext", "_einittext", NULL };
997 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
998 
999 enum mismatch {
1000 	TEXT_TO_ANY_INIT,
1001 	DATA_TO_ANY_INIT,
1002 	TEXT_TO_ANY_EXIT,
1003 	DATA_TO_ANY_EXIT,
1004 	XXXINIT_TO_SOME_INIT,
1005 	XXXEXIT_TO_SOME_EXIT,
1006 	ANY_INIT_TO_ANY_EXIT,
1007 	ANY_EXIT_TO_ANY_INIT,
1008 	EXPORT_TO_INIT_EXIT,
1009 	EXTABLE_TO_NON_TEXT,
1010 };
1011 
1012 /**
1013  * Describe how to match sections on different criterias:
1014  *
1015  * @fromsec: Array of sections to be matched.
1016  *
1017  * @bad_tosec: Relocations applied to a section in @fromsec to a section in
1018  * this array is forbidden (black-list).  Can be empty.
1019  *
1020  * @good_tosec: Relocations applied to a section in @fromsec must be
1021  * targetting sections in this array (white-list).  Can be empty.
1022  *
1023  * @mismatch: Type of mismatch.
1024  *
1025  * @symbol_white_list: Do not match a relocation to a symbol in this list
1026  * even if it is targetting a section in @bad_to_sec.
1027  *
1028  * @handler: Specific handler to call when a match is found.  If NULL,
1029  * default_mismatch_handler() will be called.
1030  *
1031  */
1032 struct sectioncheck {
1033 	const char *fromsec[20];
1034 	const char *bad_tosec[20];
1035 	const char *good_tosec[20];
1036 	enum mismatch mismatch;
1037 	const char *symbol_white_list[20];
1038 	void (*handler)(const char *modname, struct elf_info *elf,
1039 			const struct sectioncheck* const mismatch,
1040 			Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
1041 
1042 };
1043 
1044 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
1045 				     const struct sectioncheck* const mismatch,
1046 				     Elf_Rela *r, Elf_Sym *sym,
1047 				     const char *fromsec);
1048 
1049 static const struct sectioncheck sectioncheck[] = {
1050 /* Do not reference init/exit code/data from
1051  * normal code and data
1052  */
1053 {
1054 	.fromsec = { TEXT_SECTIONS, NULL },
1055 	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
1056 	.mismatch = TEXT_TO_ANY_INIT,
1057 	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1058 },
1059 {
1060 	.fromsec = { DATA_SECTIONS, NULL },
1061 	.bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1062 	.mismatch = DATA_TO_ANY_INIT,
1063 	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1064 },
1065 {
1066 	.fromsec = { DATA_SECTIONS, NULL },
1067 	.bad_tosec = { INIT_SECTIONS, NULL },
1068 	.mismatch = DATA_TO_ANY_INIT,
1069 	.symbol_white_list = {
1070 		"*_template", "*_timer", "*_sht", "*_ops",
1071 		"*_probe", "*_probe_one", "*_console", NULL
1072 	},
1073 },
1074 {
1075 	.fromsec = { TEXT_SECTIONS, NULL },
1076 	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1077 	.mismatch = TEXT_TO_ANY_EXIT,
1078 	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1079 },
1080 {
1081 	.fromsec = { DATA_SECTIONS, NULL },
1082 	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1083 	.mismatch = DATA_TO_ANY_EXIT,
1084 	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1085 },
1086 /* Do not reference init code/data from meminit code/data */
1087 {
1088 	.fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1089 	.bad_tosec = { INIT_SECTIONS, NULL },
1090 	.mismatch = XXXINIT_TO_SOME_INIT,
1091 	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1092 },
1093 /* Do not reference exit code/data from memexit code/data */
1094 {
1095 	.fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1096 	.bad_tosec = { EXIT_SECTIONS, NULL },
1097 	.mismatch = XXXEXIT_TO_SOME_EXIT,
1098 	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1099 },
1100 /* Do not use exit code/data from init code */
1101 {
1102 	.fromsec = { ALL_INIT_SECTIONS, NULL },
1103 	.bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1104 	.mismatch = ANY_INIT_TO_ANY_EXIT,
1105 	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1106 },
1107 /* Do not use init code/data from exit code */
1108 {
1109 	.fromsec = { ALL_EXIT_SECTIONS, NULL },
1110 	.bad_tosec = { ALL_INIT_SECTIONS, NULL },
1111 	.mismatch = ANY_EXIT_TO_ANY_INIT,
1112 	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1113 },
1114 {
1115 	.fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1116 	.bad_tosec = { INIT_SECTIONS, NULL },
1117 	.mismatch = ANY_INIT_TO_ANY_EXIT,
1118 	.symbol_white_list = { NULL },
1119 },
1120 /* Do not export init/exit functions or data */
1121 {
1122 	.fromsec = { "__ksymtab*", NULL },
1123 	.bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1124 	.mismatch = EXPORT_TO_INIT_EXIT,
1125 	.symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1126 },
1127 {
1128 	.fromsec = { "__ex_table", NULL },
1129 	/* If you're adding any new black-listed sections in here, consider
1130 	 * adding a special 'printer' for them in scripts/check_extable.
1131 	 */
1132 	.bad_tosec = { ".altinstr_replacement", NULL },
1133 	.good_tosec = {ALL_TEXT_SECTIONS , NULL},
1134 	.mismatch = EXTABLE_TO_NON_TEXT,
1135 	.handler = extable_mismatch_handler,
1136 }
1137 };
1138 
1139 static const struct sectioncheck *section_mismatch(
1140 		const char *fromsec, const char *tosec)
1141 {
1142 	int i;
1143 	int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1144 	const struct sectioncheck *check = &sectioncheck[0];
1145 
1146 	/*
1147 	 * The target section could be the SHT_NUL section when we're
1148 	 * handling relocations to un-resolved symbols, trying to match it
1149 	 * doesn't make much sense and causes build failures on parisc
1150 	 * architectures.
1151 	 */
1152 	if (*tosec == '\0')
1153 		return NULL;
1154 
1155 	for (i = 0; i < elems; i++) {
1156 		if (match(fromsec, check->fromsec)) {
1157 			if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1158 				return check;
1159 			if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1160 				return check;
1161 		}
1162 		check++;
1163 	}
1164 	return NULL;
1165 }
1166 
1167 /**
1168  * Whitelist to allow certain references to pass with no warning.
1169  *
1170  * Pattern 1:
1171  *   If a module parameter is declared __initdata and permissions=0
1172  *   then this is legal despite the warning generated.
1173  *   We cannot see value of permissions here, so just ignore
1174  *   this pattern.
1175  *   The pattern is identified by:
1176  *   tosec   = .init.data
1177  *   fromsec = .data*
1178  *   atsym   =__param*
1179  *
1180  * Pattern 1a:
1181  *   module_param_call() ops can refer to __init set function if permissions=0
1182  *   The pattern is identified by:
1183  *   tosec   = .init.text
1184  *   fromsec = .data*
1185  *   atsym   = __param_ops_*
1186  *
1187  * Pattern 2:
1188  *   Many drivers utilise a *driver container with references to
1189  *   add, remove, probe functions etc.
1190  *   the pattern is identified by:
1191  *   tosec   = init or exit section
1192  *   fromsec = data section
1193  *   atsym = *driver, *_template, *_sht, *_ops, *_probe,
1194  *           *probe_one, *_console, *_timer
1195  *
1196  * Pattern 3:
1197  *   Whitelist all references from .head.text to any init section
1198  *
1199  * Pattern 4:
1200  *   Some symbols belong to init section but still it is ok to reference
1201  *   these from non-init sections as these symbols don't have any memory
1202  *   allocated for them and symbol address and value are same. So even
1203  *   if init section is freed, its ok to reference those symbols.
1204  *   For ex. symbols marking the init section boundaries.
1205  *   This pattern is identified by
1206  *   refsymname = __init_begin, _sinittext, _einittext
1207  *
1208  * Pattern 5:
1209  *   GCC may optimize static inlines when fed constant arg(s) resulting
1210  *   in functions like cpumask_empty() -- generating an associated symbol
1211  *   cpumask_empty.constprop.3 that appears in the audit.  If the const that
1212  *   is passed in comes from __init, like say nmi_ipi_mask, we get a
1213  *   meaningless section warning.  May need to add isra symbols too...
1214  *   This pattern is identified by
1215  *   tosec   = init section
1216  *   fromsec = text section
1217  *   refsymname = *.constprop.*
1218  *
1219  * Pattern 6:
1220  *   Hide section mismatch warnings for ELF local symbols.  The goal
1221  *   is to eliminate false positive modpost warnings caused by
1222  *   compiler-generated ELF local symbol names such as ".LANCHOR1".
1223  *   Autogenerated symbol names bypass modpost's "Pattern 2"
1224  *   whitelisting, which relies on pattern-matching against symbol
1225  *   names to work.  (One situation where gcc can autogenerate ELF
1226  *   local symbols is when "-fsection-anchors" is used.)
1227  **/
1228 static int secref_whitelist(const struct sectioncheck *mismatch,
1229 			    const char *fromsec, const char *fromsym,
1230 			    const char *tosec, const char *tosym)
1231 {
1232 	/* Check for pattern 1 */
1233 	if (match(tosec, init_data_sections) &&
1234 	    match(fromsec, data_sections) &&
1235 	    strstarts(fromsym, "__param"))
1236 		return 0;
1237 
1238 	/* Check for pattern 1a */
1239 	if (strcmp(tosec, ".init.text") == 0 &&
1240 	    match(fromsec, data_sections) &&
1241 	    strstarts(fromsym, "__param_ops_"))
1242 		return 0;
1243 
1244 	/* Check for pattern 2 */
1245 	if (match(tosec, init_exit_sections) &&
1246 	    match(fromsec, data_sections) &&
1247 	    match(fromsym, mismatch->symbol_white_list))
1248 		return 0;
1249 
1250 	/* Check for pattern 3 */
1251 	if (match(fromsec, head_sections) &&
1252 	    match(tosec, init_sections))
1253 		return 0;
1254 
1255 	/* Check for pattern 4 */
1256 	if (match(tosym, linker_symbols))
1257 		return 0;
1258 
1259 	/* Check for pattern 5 */
1260 	if (match(fromsec, text_sections) &&
1261 	    match(tosec, init_sections) &&
1262 	    match(fromsym, optim_symbols))
1263 		return 0;
1264 
1265 	/* Check for pattern 6 */
1266 	if (strstarts(fromsym, ".L"))
1267 		return 0;
1268 
1269 	return 1;
1270 }
1271 
1272 static inline int is_arm_mapping_symbol(const char *str)
1273 {
1274 	return str[0] == '$' && strchr("axtd", str[1])
1275 	       && (str[2] == '\0' || str[2] == '.');
1276 }
1277 
1278 /*
1279  * If there's no name there, ignore it; likewise, ignore it if it's
1280  * one of the magic symbols emitted used by current ARM tools.
1281  *
1282  * Otherwise if find_symbols_between() returns those symbols, they'll
1283  * fail the whitelist tests and cause lots of false alarms ... fixable
1284  * only by merging __exit and __init sections into __text, bloating
1285  * the kernel (which is especially evil on embedded platforms).
1286  */
1287 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1288 {
1289 	const char *name = elf->strtab + sym->st_name;
1290 
1291 	if (!name || !strlen(name))
1292 		return 0;
1293 	return !is_arm_mapping_symbol(name);
1294 }
1295 
1296 /**
1297  * Find symbol based on relocation record info.
1298  * In some cases the symbol supplied is a valid symbol so
1299  * return refsym. If st_name != 0 we assume this is a valid symbol.
1300  * In other cases the symbol needs to be looked up in the symbol table
1301  * based on section and address.
1302  *  **/
1303 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1304 				Elf_Sym *relsym)
1305 {
1306 	Elf_Sym *sym;
1307 	Elf_Sym *near = NULL;
1308 	Elf64_Sword distance = 20;
1309 	Elf64_Sword d;
1310 	unsigned int relsym_secindex;
1311 
1312 	if (relsym->st_name != 0)
1313 		return relsym;
1314 
1315 	relsym_secindex = get_secindex(elf, relsym);
1316 	for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1317 		if (get_secindex(elf, sym) != relsym_secindex)
1318 			continue;
1319 		if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1320 			continue;
1321 		if (!is_valid_name(elf, sym))
1322 			continue;
1323 		if (sym->st_value == addr)
1324 			return sym;
1325 		/* Find a symbol nearby - addr are maybe negative */
1326 		d = sym->st_value - addr;
1327 		if (d < 0)
1328 			d = addr - sym->st_value;
1329 		if (d < distance) {
1330 			distance = d;
1331 			near = sym;
1332 		}
1333 	}
1334 	/* We need a close match */
1335 	if (distance < 20)
1336 		return near;
1337 	else
1338 		return NULL;
1339 }
1340 
1341 /*
1342  * Find symbols before or equal addr and after addr - in the section sec.
1343  * If we find two symbols with equal offset prefer one with a valid name.
1344  * The ELF format may have a better way to detect what type of symbol
1345  * it is, but this works for now.
1346  **/
1347 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1348 				 const char *sec)
1349 {
1350 	Elf_Sym *sym;
1351 	Elf_Sym *near = NULL;
1352 	Elf_Addr distance = ~0;
1353 
1354 	for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1355 		const char *symsec;
1356 
1357 		if (is_shndx_special(sym->st_shndx))
1358 			continue;
1359 		symsec = sec_name(elf, get_secindex(elf, sym));
1360 		if (strcmp(symsec, sec) != 0)
1361 			continue;
1362 		if (!is_valid_name(elf, sym))
1363 			continue;
1364 		if (sym->st_value <= addr) {
1365 			if ((addr - sym->st_value) < distance) {
1366 				distance = addr - sym->st_value;
1367 				near = sym;
1368 			} else if ((addr - sym->st_value) == distance) {
1369 				near = sym;
1370 			}
1371 		}
1372 	}
1373 	return near;
1374 }
1375 
1376 /*
1377  * Convert a section name to the function/data attribute
1378  * .init.text => __init
1379  * .memexitconst => __memconst
1380  * etc.
1381  *
1382  * The memory of returned value has been allocated on a heap. The user of this
1383  * method should free it after usage.
1384 */
1385 static char *sec2annotation(const char *s)
1386 {
1387 	if (match(s, init_exit_sections)) {
1388 		char *p = NOFAIL(malloc(20));
1389 		char *r = p;
1390 
1391 		*p++ = '_';
1392 		*p++ = '_';
1393 		if (*s == '.')
1394 			s++;
1395 		while (*s && *s != '.')
1396 			*p++ = *s++;
1397 		*p = '\0';
1398 		if (*s == '.')
1399 			s++;
1400 		if (strstr(s, "rodata") != NULL)
1401 			strcat(p, "const ");
1402 		else if (strstr(s, "data") != NULL)
1403 			strcat(p, "data ");
1404 		else
1405 			strcat(p, " ");
1406 		return r;
1407 	} else {
1408 		return NOFAIL(strdup(""));
1409 	}
1410 }
1411 
1412 static int is_function(Elf_Sym *sym)
1413 {
1414 	if (sym)
1415 		return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1416 	else
1417 		return -1;
1418 }
1419 
1420 static void print_section_list(const char * const list[20])
1421 {
1422 	const char *const *s = list;
1423 
1424 	while (*s) {
1425 		fprintf(stderr, "%s", *s);
1426 		s++;
1427 		if (*s)
1428 			fprintf(stderr, ", ");
1429 	}
1430 	fprintf(stderr, "\n");
1431 }
1432 
1433 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1434 {
1435 	switch (is_func) {
1436 	case 0:	*name = "variable"; *name_p = ""; break;
1437 	case 1:	*name = "function"; *name_p = "()"; break;
1438 	default: *name = "(unknown reference)"; *name_p = ""; break;
1439 	}
1440 }
1441 
1442 /*
1443  * Print a warning about a section mismatch.
1444  * Try to find symbols near it so user can find it.
1445  * Check whitelist before warning - it may be a false positive.
1446  */
1447 static void report_sec_mismatch(const char *modname,
1448 				const struct sectioncheck *mismatch,
1449 				const char *fromsec,
1450 				unsigned long long fromaddr,
1451 				const char *fromsym,
1452 				int from_is_func,
1453 				const char *tosec, const char *tosym,
1454 				int to_is_func)
1455 {
1456 	const char *from, *from_p;
1457 	const char *to, *to_p;
1458 	char *prl_from;
1459 	char *prl_to;
1460 
1461 	sec_mismatch_count++;
1462 
1463 	get_pretty_name(from_is_func, &from, &from_p);
1464 	get_pretty_name(to_is_func, &to, &to_p);
1465 
1466 	warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1467 	     "to the %s %s:%s%s\n",
1468 	     modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1469 	     tosym, to_p);
1470 
1471 	switch (mismatch->mismatch) {
1472 	case TEXT_TO_ANY_INIT:
1473 		prl_from = sec2annotation(fromsec);
1474 		prl_to = sec2annotation(tosec);
1475 		fprintf(stderr,
1476 		"The function %s%s() references\n"
1477 		"the %s %s%s%s.\n"
1478 		"This is often because %s lacks a %s\n"
1479 		"annotation or the annotation of %s is wrong.\n",
1480 		prl_from, fromsym,
1481 		to, prl_to, tosym, to_p,
1482 		fromsym, prl_to, tosym);
1483 		free(prl_from);
1484 		free(prl_to);
1485 		break;
1486 	case DATA_TO_ANY_INIT: {
1487 		prl_to = sec2annotation(tosec);
1488 		fprintf(stderr,
1489 		"The variable %s references\n"
1490 		"the %s %s%s%s\n"
1491 		"If the reference is valid then annotate the\n"
1492 		"variable with __init* or __refdata (see linux/init.h) "
1493 		"or name the variable:\n",
1494 		fromsym, to, prl_to, tosym, to_p);
1495 		print_section_list(mismatch->symbol_white_list);
1496 		free(prl_to);
1497 		break;
1498 	}
1499 	case TEXT_TO_ANY_EXIT:
1500 		prl_to = sec2annotation(tosec);
1501 		fprintf(stderr,
1502 		"The function %s() references a %s in an exit section.\n"
1503 		"Often the %s %s%s has valid usage outside the exit section\n"
1504 		"and the fix is to remove the %sannotation of %s.\n",
1505 		fromsym, to, to, tosym, to_p, prl_to, tosym);
1506 		free(prl_to);
1507 		break;
1508 	case DATA_TO_ANY_EXIT: {
1509 		prl_to = sec2annotation(tosec);
1510 		fprintf(stderr,
1511 		"The variable %s references\n"
1512 		"the %s %s%s%s\n"
1513 		"If the reference is valid then annotate the\n"
1514 		"variable with __exit* (see linux/init.h) or "
1515 		"name the variable:\n",
1516 		fromsym, to, prl_to, tosym, to_p);
1517 		print_section_list(mismatch->symbol_white_list);
1518 		free(prl_to);
1519 		break;
1520 	}
1521 	case XXXINIT_TO_SOME_INIT:
1522 	case XXXEXIT_TO_SOME_EXIT:
1523 		prl_from = sec2annotation(fromsec);
1524 		prl_to = sec2annotation(tosec);
1525 		fprintf(stderr,
1526 		"The %s %s%s%s references\n"
1527 		"a %s %s%s%s.\n"
1528 		"If %s is only used by %s then\n"
1529 		"annotate %s with a matching annotation.\n",
1530 		from, prl_from, fromsym, from_p,
1531 		to, prl_to, tosym, to_p,
1532 		tosym, fromsym, tosym);
1533 		free(prl_from);
1534 		free(prl_to);
1535 		break;
1536 	case ANY_INIT_TO_ANY_EXIT:
1537 		prl_from = sec2annotation(fromsec);
1538 		prl_to = sec2annotation(tosec);
1539 		fprintf(stderr,
1540 		"The %s %s%s%s references\n"
1541 		"a %s %s%s%s.\n"
1542 		"This is often seen when error handling "
1543 		"in the init function\n"
1544 		"uses functionality in the exit path.\n"
1545 		"The fix is often to remove the %sannotation of\n"
1546 		"%s%s so it may be used outside an exit section.\n",
1547 		from, prl_from, fromsym, from_p,
1548 		to, prl_to, tosym, to_p,
1549 		prl_to, tosym, to_p);
1550 		free(prl_from);
1551 		free(prl_to);
1552 		break;
1553 	case ANY_EXIT_TO_ANY_INIT:
1554 		prl_from = sec2annotation(fromsec);
1555 		prl_to = sec2annotation(tosec);
1556 		fprintf(stderr,
1557 		"The %s %s%s%s references\n"
1558 		"a %s %s%s%s.\n"
1559 		"This is often seen when error handling "
1560 		"in the exit function\n"
1561 		"uses functionality in the init path.\n"
1562 		"The fix is often to remove the %sannotation of\n"
1563 		"%s%s so it may be used outside an init section.\n",
1564 		from, prl_from, fromsym, from_p,
1565 		to, prl_to, tosym, to_p,
1566 		prl_to, tosym, to_p);
1567 		free(prl_from);
1568 		free(prl_to);
1569 		break;
1570 	case EXPORT_TO_INIT_EXIT:
1571 		prl_to = sec2annotation(tosec);
1572 		fprintf(stderr,
1573 		"The symbol %s is exported and annotated %s\n"
1574 		"Fix this by removing the %sannotation of %s "
1575 		"or drop the export.\n",
1576 		tosym, prl_to, prl_to, tosym);
1577 		free(prl_to);
1578 		break;
1579 	case EXTABLE_TO_NON_TEXT:
1580 		fatal("There's a special handler for this mismatch type, "
1581 		      "we should never get here.");
1582 		break;
1583 	}
1584 	fprintf(stderr, "\n");
1585 }
1586 
1587 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1588 				     const struct sectioncheck* const mismatch,
1589 				     Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1590 {
1591 	const char *tosec;
1592 	Elf_Sym *to;
1593 	Elf_Sym *from;
1594 	const char *tosym;
1595 	const char *fromsym;
1596 
1597 	from = find_elf_symbol2(elf, r->r_offset, fromsec);
1598 	fromsym = sym_name(elf, from);
1599 
1600 	if (strstarts(fromsym, "reference___initcall"))
1601 		return;
1602 
1603 	tosec = sec_name(elf, get_secindex(elf, sym));
1604 	to = find_elf_symbol(elf, r->r_addend, sym);
1605 	tosym = sym_name(elf, to);
1606 
1607 	/* check whitelist - we may ignore it */
1608 	if (secref_whitelist(mismatch,
1609 			     fromsec, fromsym, tosec, tosym)) {
1610 		report_sec_mismatch(modname, mismatch,
1611 				    fromsec, r->r_offset, fromsym,
1612 				    is_function(from), tosec, tosym,
1613 				    is_function(to));
1614 	}
1615 }
1616 
1617 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1618 {
1619 	if (section_index > elf->num_sections)
1620 		fatal("section_index is outside elf->num_sections!\n");
1621 
1622 	return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1623 }
1624 
1625 /*
1626  * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1627  * to know the sizeof(struct exception_table_entry) for the target architecture.
1628  */
1629 static unsigned int extable_entry_size = 0;
1630 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1631 {
1632 	/*
1633 	 * If we're currently checking the second relocation within __ex_table,
1634 	 * that relocation offset tells us the offsetof(struct
1635 	 * exception_table_entry, fixup) which is equal to sizeof(struct
1636 	 * exception_table_entry) divided by two.  We use that to our advantage
1637 	 * since there's no portable way to get that size as every architecture
1638 	 * seems to go with different sized types.  Not pretty but better than
1639 	 * hard-coding the size for every architecture..
1640 	 */
1641 	if (!extable_entry_size)
1642 		extable_entry_size = r->r_offset * 2;
1643 }
1644 
1645 static inline bool is_extable_fault_address(Elf_Rela *r)
1646 {
1647 	/*
1648 	 * extable_entry_size is only discovered after we've handled the
1649 	 * _second_ relocation in __ex_table, so only abort when we're not
1650 	 * handling the first reloc and extable_entry_size is zero.
1651 	 */
1652 	if (r->r_offset && extable_entry_size == 0)
1653 		fatal("extable_entry size hasn't been discovered!\n");
1654 
1655 	return ((r->r_offset == 0) ||
1656 		(r->r_offset % extable_entry_size == 0));
1657 }
1658 
1659 #define is_second_extable_reloc(Start, Cur, Sec)			\
1660 	(((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1661 
1662 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1663 				    const struct sectioncheck* const mismatch,
1664 				    Elf_Rela* r, Elf_Sym* sym,
1665 				    const char* fromsec, const char* tosec)
1666 {
1667 	Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1668 	const char* fromsym_name = sym_name(elf, fromsym);
1669 	Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1670 	const char* tosym_name = sym_name(elf, tosym);
1671 	const char* from_pretty_name;
1672 	const char* from_pretty_name_p;
1673 	const char* to_pretty_name;
1674 	const char* to_pretty_name_p;
1675 
1676 	get_pretty_name(is_function(fromsym),
1677 			&from_pretty_name, &from_pretty_name_p);
1678 	get_pretty_name(is_function(tosym),
1679 			&to_pretty_name, &to_pretty_name_p);
1680 
1681 	warn("%s(%s+0x%lx): Section mismatch in reference"
1682 	     " from the %s %s%s to the %s %s:%s%s\n",
1683 	     modname, fromsec, (long)r->r_offset, from_pretty_name,
1684 	     fromsym_name, from_pretty_name_p,
1685 	     to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1686 
1687 	if (!match(tosec, mismatch->bad_tosec) &&
1688 	    is_executable_section(elf, get_secindex(elf, sym)))
1689 		fprintf(stderr,
1690 			"The relocation at %s+0x%lx references\n"
1691 			"section \"%s\" which is not in the list of\n"
1692 			"authorized sections.  If you're adding a new section\n"
1693 			"and/or if this reference is valid, add \"%s\" to the\n"
1694 			"list of authorized sections to jump to on fault.\n"
1695 			"This can be achieved by adding \"%s\" to \n"
1696 			"OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1697 			fromsec, (long)r->r_offset, tosec, tosec, tosec);
1698 }
1699 
1700 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1701 				     const struct sectioncheck* const mismatch,
1702 				     Elf_Rela* r, Elf_Sym* sym,
1703 				     const char *fromsec)
1704 {
1705 	const char* tosec = sec_name(elf, get_secindex(elf, sym));
1706 
1707 	sec_mismatch_count++;
1708 
1709 	report_extable_warnings(modname, elf, mismatch, r, sym, fromsec, tosec);
1710 
1711 	if (match(tosec, mismatch->bad_tosec))
1712 		fatal("The relocation at %s+0x%lx references\n"
1713 		      "section \"%s\" which is black-listed.\n"
1714 		      "Something is seriously wrong and should be fixed.\n"
1715 		      "You might get more information about where this is\n"
1716 		      "coming from by using scripts/check_extable.sh %s\n",
1717 		      fromsec, (long)r->r_offset, tosec, modname);
1718 	else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1719 		if (is_extable_fault_address(r))
1720 			fatal("The relocation at %s+0x%lx references\n"
1721 			      "section \"%s\" which is not executable, IOW\n"
1722 			      "it is not possible for the kernel to fault\n"
1723 			      "at that address.  Something is seriously wrong\n"
1724 			      "and should be fixed.\n",
1725 			      fromsec, (long)r->r_offset, tosec);
1726 		else
1727 			fatal("The relocation at %s+0x%lx references\n"
1728 			      "section \"%s\" which is not executable, IOW\n"
1729 			      "the kernel will fault if it ever tries to\n"
1730 			      "jump to it.  Something is seriously wrong\n"
1731 			      "and should be fixed.\n",
1732 			      fromsec, (long)r->r_offset, tosec);
1733 	}
1734 }
1735 
1736 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1737 				   Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1738 {
1739 	const char *tosec = sec_name(elf, get_secindex(elf, sym));
1740 	const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1741 
1742 	if (mismatch) {
1743 		if (mismatch->handler)
1744 			mismatch->handler(modname, elf,  mismatch,
1745 					  r, sym, fromsec);
1746 		else
1747 			default_mismatch_handler(modname, elf, mismatch,
1748 						 r, sym, fromsec);
1749 	}
1750 }
1751 
1752 static unsigned int *reloc_location(struct elf_info *elf,
1753 				    Elf_Shdr *sechdr, Elf_Rela *r)
1754 {
1755 	Elf_Shdr *sechdrs = elf->sechdrs;
1756 	int section = sechdr->sh_info;
1757 
1758 	return (void *)elf->hdr + sechdrs[section].sh_offset +
1759 		r->r_offset;
1760 }
1761 
1762 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1763 {
1764 	unsigned int r_typ = ELF_R_TYPE(r->r_info);
1765 	unsigned int *location = reloc_location(elf, sechdr, r);
1766 
1767 	switch (r_typ) {
1768 	case R_386_32:
1769 		r->r_addend = TO_NATIVE(*location);
1770 		break;
1771 	case R_386_PC32:
1772 		r->r_addend = TO_NATIVE(*location) + 4;
1773 		/* For CONFIG_RELOCATABLE=y */
1774 		if (elf->hdr->e_type == ET_EXEC)
1775 			r->r_addend += r->r_offset;
1776 		break;
1777 	}
1778 	return 0;
1779 }
1780 
1781 #ifndef R_ARM_CALL
1782 #define R_ARM_CALL	28
1783 #endif
1784 #ifndef R_ARM_JUMP24
1785 #define R_ARM_JUMP24	29
1786 #endif
1787 
1788 #ifndef	R_ARM_THM_CALL
1789 #define	R_ARM_THM_CALL		10
1790 #endif
1791 #ifndef	R_ARM_THM_JUMP24
1792 #define	R_ARM_THM_JUMP24	30
1793 #endif
1794 #ifndef	R_ARM_THM_JUMP19
1795 #define	R_ARM_THM_JUMP19	51
1796 #endif
1797 
1798 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1799 {
1800 	unsigned int r_typ = ELF_R_TYPE(r->r_info);
1801 
1802 	switch (r_typ) {
1803 	case R_ARM_ABS32:
1804 		/* From ARM ABI: (S + A) | T */
1805 		r->r_addend = (int)(long)
1806 			      (elf->symtab_start + ELF_R_SYM(r->r_info));
1807 		break;
1808 	case R_ARM_PC24:
1809 	case R_ARM_CALL:
1810 	case R_ARM_JUMP24:
1811 	case R_ARM_THM_CALL:
1812 	case R_ARM_THM_JUMP24:
1813 	case R_ARM_THM_JUMP19:
1814 		/* From ARM ABI: ((S + A) | T) - P */
1815 		r->r_addend = (int)(long)(elf->hdr +
1816 			      sechdr->sh_offset +
1817 			      (r->r_offset - sechdr->sh_addr));
1818 		break;
1819 	default:
1820 		return 1;
1821 	}
1822 	return 0;
1823 }
1824 
1825 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1826 {
1827 	unsigned int r_typ = ELF_R_TYPE(r->r_info);
1828 	unsigned int *location = reloc_location(elf, sechdr, r);
1829 	unsigned int inst;
1830 
1831 	if (r_typ == R_MIPS_HI16)
1832 		return 1;	/* skip this */
1833 	inst = TO_NATIVE(*location);
1834 	switch (r_typ) {
1835 	case R_MIPS_LO16:
1836 		r->r_addend = inst & 0xffff;
1837 		break;
1838 	case R_MIPS_26:
1839 		r->r_addend = (inst & 0x03ffffff) << 2;
1840 		break;
1841 	case R_MIPS_32:
1842 		r->r_addend = inst;
1843 		break;
1844 	}
1845 	return 0;
1846 }
1847 
1848 static void section_rela(const char *modname, struct elf_info *elf,
1849 			 Elf_Shdr *sechdr)
1850 {
1851 	Elf_Sym  *sym;
1852 	Elf_Rela *rela;
1853 	Elf_Rela r;
1854 	unsigned int r_sym;
1855 	const char *fromsec;
1856 
1857 	Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1858 	Elf_Rela *stop  = (void *)start + sechdr->sh_size;
1859 
1860 	fromsec = sech_name(elf, sechdr);
1861 	fromsec += strlen(".rela");
1862 	/* if from section (name) is know good then skip it */
1863 	if (match(fromsec, section_white_list))
1864 		return;
1865 
1866 	for (rela = start; rela < stop; rela++) {
1867 		r.r_offset = TO_NATIVE(rela->r_offset);
1868 #if KERNEL_ELFCLASS == ELFCLASS64
1869 		if (elf->hdr->e_machine == EM_MIPS) {
1870 			unsigned int r_typ;
1871 			r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1872 			r_sym = TO_NATIVE(r_sym);
1873 			r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1874 			r.r_info = ELF64_R_INFO(r_sym, r_typ);
1875 		} else {
1876 			r.r_info = TO_NATIVE(rela->r_info);
1877 			r_sym = ELF_R_SYM(r.r_info);
1878 		}
1879 #else
1880 		r.r_info = TO_NATIVE(rela->r_info);
1881 		r_sym = ELF_R_SYM(r.r_info);
1882 #endif
1883 		r.r_addend = TO_NATIVE(rela->r_addend);
1884 		sym = elf->symtab_start + r_sym;
1885 		/* Skip special sections */
1886 		if (is_shndx_special(sym->st_shndx))
1887 			continue;
1888 		if (is_second_extable_reloc(start, rela, fromsec))
1889 			find_extable_entry_size(fromsec, &r);
1890 		check_section_mismatch(modname, elf, &r, sym, fromsec);
1891 	}
1892 }
1893 
1894 static void section_rel(const char *modname, struct elf_info *elf,
1895 			Elf_Shdr *sechdr)
1896 {
1897 	Elf_Sym *sym;
1898 	Elf_Rel *rel;
1899 	Elf_Rela r;
1900 	unsigned int r_sym;
1901 	const char *fromsec;
1902 
1903 	Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1904 	Elf_Rel *stop  = (void *)start + sechdr->sh_size;
1905 
1906 	fromsec = sech_name(elf, sechdr);
1907 	fromsec += strlen(".rel");
1908 	/* if from section (name) is know good then skip it */
1909 	if (match(fromsec, section_white_list))
1910 		return;
1911 
1912 	for (rel = start; rel < stop; rel++) {
1913 		r.r_offset = TO_NATIVE(rel->r_offset);
1914 #if KERNEL_ELFCLASS == ELFCLASS64
1915 		if (elf->hdr->e_machine == EM_MIPS) {
1916 			unsigned int r_typ;
1917 			r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1918 			r_sym = TO_NATIVE(r_sym);
1919 			r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1920 			r.r_info = ELF64_R_INFO(r_sym, r_typ);
1921 		} else {
1922 			r.r_info = TO_NATIVE(rel->r_info);
1923 			r_sym = ELF_R_SYM(r.r_info);
1924 		}
1925 #else
1926 		r.r_info = TO_NATIVE(rel->r_info);
1927 		r_sym = ELF_R_SYM(r.r_info);
1928 #endif
1929 		r.r_addend = 0;
1930 		switch (elf->hdr->e_machine) {
1931 		case EM_386:
1932 			if (addend_386_rel(elf, sechdr, &r))
1933 				continue;
1934 			break;
1935 		case EM_ARM:
1936 			if (addend_arm_rel(elf, sechdr, &r))
1937 				continue;
1938 			break;
1939 		case EM_MIPS:
1940 			if (addend_mips_rel(elf, sechdr, &r))
1941 				continue;
1942 			break;
1943 		}
1944 		sym = elf->symtab_start + r_sym;
1945 		/* Skip special sections */
1946 		if (is_shndx_special(sym->st_shndx))
1947 			continue;
1948 		if (is_second_extable_reloc(start, rel, fromsec))
1949 			find_extable_entry_size(fromsec, &r);
1950 		check_section_mismatch(modname, elf, &r, sym, fromsec);
1951 	}
1952 }
1953 
1954 /**
1955  * A module includes a number of sections that are discarded
1956  * either when loaded or when used as built-in.
1957  * For loaded modules all functions marked __init and all data
1958  * marked __initdata will be discarded when the module has been initialized.
1959  * Likewise for modules used built-in the sections marked __exit
1960  * are discarded because __exit marked function are supposed to be called
1961  * only when a module is unloaded which never happens for built-in modules.
1962  * The check_sec_ref() function traverses all relocation records
1963  * to find all references to a section that reference a section that will
1964  * be discarded and warns about it.
1965  **/
1966 static void check_sec_ref(struct module *mod, const char *modname,
1967 			  struct elf_info *elf)
1968 {
1969 	int i;
1970 	Elf_Shdr *sechdrs = elf->sechdrs;
1971 
1972 	/* Walk through all sections */
1973 	for (i = 0; i < elf->num_sections; i++) {
1974 		check_section(modname, elf, &elf->sechdrs[i]);
1975 		/* We want to process only relocation sections and not .init */
1976 		if (sechdrs[i].sh_type == SHT_RELA)
1977 			section_rela(modname, elf, &elf->sechdrs[i]);
1978 		else if (sechdrs[i].sh_type == SHT_REL)
1979 			section_rel(modname, elf, &elf->sechdrs[i]);
1980 	}
1981 }
1982 
1983 static char *remove_dot(char *s)
1984 {
1985 	size_t n = strcspn(s, ".");
1986 
1987 	if (n && s[n]) {
1988 		size_t m = strspn(s + n + 1, "0123456789");
1989 		if (m && (s[n + m] == '.' || s[n + m] == 0))
1990 			s[n] = 0;
1991 	}
1992 	return s;
1993 }
1994 
1995 static void read_symbols(const char *modname)
1996 {
1997 	const char *symname;
1998 	char *version;
1999 	char *license;
2000 	char *namespace;
2001 	struct module *mod;
2002 	struct elf_info info = { };
2003 	Elf_Sym *sym;
2004 
2005 	if (!parse_elf(&info, modname))
2006 		return;
2007 
2008 	mod = new_module(modname);
2009 
2010 	/* When there's no vmlinux, don't print warnings about
2011 	 * unresolved symbols (since there'll be too many ;) */
2012 	if (is_vmlinux(modname)) {
2013 		have_vmlinux = 1;
2014 		mod->skip = 1;
2015 	}
2016 
2017 	license = get_modinfo(&info, "license");
2018 	if (!license && !is_vmlinux(modname))
2019 		warn("modpost: missing MODULE_LICENSE() in %s\n"
2020 		     "see include/linux/module.h for "
2021 		     "more information\n", modname);
2022 	while (license) {
2023 		if (license_is_gpl_compatible(license))
2024 			mod->gpl_compatible = 1;
2025 		else {
2026 			mod->gpl_compatible = 0;
2027 			break;
2028 		}
2029 		license = get_next_modinfo(&info, "license", license);
2030 	}
2031 
2032 	namespace = get_modinfo(&info, "import_ns");
2033 	while (namespace) {
2034 		add_namespace(&mod->imported_namespaces, namespace);
2035 		namespace = get_next_modinfo(&info, "import_ns", namespace);
2036 	}
2037 
2038 	for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2039 		symname = remove_dot(info.strtab + sym->st_name);
2040 
2041 		handle_modversions(mod, &info, sym, symname);
2042 		handle_moddevtable(mod, &info, sym, symname);
2043 	}
2044 
2045 	// check for static EXPORT_SYMBOL_* functions && global vars
2046 	for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2047 		unsigned char bind = ELF_ST_BIND(sym->st_info);
2048 
2049 		if (bind == STB_GLOBAL || bind == STB_WEAK) {
2050 			struct symbol *s =
2051 				find_symbol(remove_dot(info.strtab +
2052 						       sym->st_name));
2053 
2054 			if (s)
2055 				s->is_static = 0;
2056 		}
2057 	}
2058 
2059 	if (!is_vmlinux(modname) || vmlinux_section_warnings)
2060 		check_sec_ref(mod, modname, &info);
2061 
2062 	version = get_modinfo(&info, "version");
2063 	if (version)
2064 		maybe_frob_rcs_version(modname, version, info.modinfo,
2065 				       version - (char *)info.hdr);
2066 	if (version || (all_versions && !is_vmlinux(modname)))
2067 		get_src_version(modname, mod->srcversion,
2068 				sizeof(mod->srcversion)-1);
2069 
2070 	parse_elf_finish(&info);
2071 
2072 	/* Our trick to get versioning for module struct etc. - it's
2073 	 * never passed as an argument to an exported function, so
2074 	 * the automatic versioning doesn't pick it up, but it's really
2075 	 * important anyhow */
2076 	if (modversions)
2077 		mod->unres = alloc_symbol("module_layout", 0, mod->unres);
2078 }
2079 
2080 static void read_symbols_from_files(const char *filename)
2081 {
2082 	FILE *in = stdin;
2083 	char fname[PATH_MAX];
2084 
2085 	if (strcmp(filename, "-") != 0) {
2086 		in = fopen(filename, "r");
2087 		if (!in)
2088 			fatal("Can't open filenames file %s: %m", filename);
2089 	}
2090 
2091 	while (fgets(fname, PATH_MAX, in) != NULL) {
2092 		if (strends(fname, "\n"))
2093 			fname[strlen(fname)-1] = '\0';
2094 		read_symbols(fname);
2095 	}
2096 
2097 	if (in != stdin)
2098 		fclose(in);
2099 }
2100 
2101 #define SZ 500
2102 
2103 /* We first write the generated file into memory using the
2104  * following helper, then compare to the file on disk and
2105  * only update the later if anything changed */
2106 
2107 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2108 						      const char *fmt, ...)
2109 {
2110 	char tmp[SZ];
2111 	int len;
2112 	va_list ap;
2113 
2114 	va_start(ap, fmt);
2115 	len = vsnprintf(tmp, SZ, fmt, ap);
2116 	buf_write(buf, tmp, len);
2117 	va_end(ap);
2118 }
2119 
2120 void buf_write(struct buffer *buf, const char *s, int len)
2121 {
2122 	if (buf->size - buf->pos < len) {
2123 		buf->size += len + SZ;
2124 		buf->p = NOFAIL(realloc(buf->p, buf->size));
2125 	}
2126 	strncpy(buf->p + buf->pos, s, len);
2127 	buf->pos += len;
2128 }
2129 
2130 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2131 {
2132 	const char *e = is_vmlinux(m) ?"":".ko";
2133 
2134 	switch (exp) {
2135 	case export_gpl:
2136 		fatal("modpost: GPL-incompatible module %s%s "
2137 		      "uses GPL-only symbol '%s'\n", m, e, s);
2138 		break;
2139 	case export_unused_gpl:
2140 		fatal("modpost: GPL-incompatible module %s%s "
2141 		      "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2142 		break;
2143 	case export_gpl_future:
2144 		warn("modpost: GPL-incompatible module %s%s "
2145 		      "uses future GPL-only symbol '%s'\n", m, e, s);
2146 		break;
2147 	case export_plain:
2148 	case export_unused:
2149 	case export_unknown:
2150 		/* ignore */
2151 		break;
2152 	}
2153 }
2154 
2155 static void check_for_unused(enum export exp, const char *m, const char *s)
2156 {
2157 	const char *e = is_vmlinux(m) ?"":".ko";
2158 
2159 	switch (exp) {
2160 	case export_unused:
2161 	case export_unused_gpl:
2162 		warn("modpost: module %s%s "
2163 		      "uses symbol '%s' marked UNUSED\n", m, e, s);
2164 		break;
2165 	default:
2166 		/* ignore */
2167 		break;
2168 	}
2169 }
2170 
2171 static int check_exports(struct module *mod)
2172 {
2173 	struct symbol *s, *exp;
2174 	int err = 0;
2175 
2176 	for (s = mod->unres; s; s = s->next) {
2177 		const char *basename;
2178 		exp = find_symbol(s->name);
2179 		if (!exp || exp->module == mod) {
2180 			if (have_vmlinux && !s->weak) {
2181 				if (warn_unresolved) {
2182 					warn("\"%s\" [%s.ko] undefined!\n",
2183 					     s->name, mod->name);
2184 				} else {
2185 					merror("\"%s\" [%s.ko] undefined!\n",
2186 					       s->name, mod->name);
2187 					err = 1;
2188 				}
2189 			}
2190 			continue;
2191 		}
2192 		basename = strrchr(mod->name, '/');
2193 		if (basename)
2194 			basename++;
2195 		else
2196 			basename = mod->name;
2197 
2198 		if (exp->namespace) {
2199 			add_namespace(&mod->required_namespaces,
2200 				      exp->namespace);
2201 
2202 			if (!write_namespace_deps &&
2203 			    !module_imports_namespace(mod, exp->namespace)) {
2204 				warn("module %s uses symbol %s from namespace %s, but does not import it.\n",
2205 				     basename, exp->name, exp->namespace);
2206 			}
2207 		}
2208 
2209 		if (!mod->gpl_compatible)
2210 			check_for_gpl_usage(exp->export, basename, exp->name);
2211 		check_for_unused(exp->export, basename, exp->name);
2212 	}
2213 
2214 	return err;
2215 }
2216 
2217 static int check_modname_len(struct module *mod)
2218 {
2219 	const char *mod_name;
2220 
2221 	mod_name = strrchr(mod->name, '/');
2222 	if (mod_name == NULL)
2223 		mod_name = mod->name;
2224 	else
2225 		mod_name++;
2226 	if (strlen(mod_name) >= MODULE_NAME_LEN) {
2227 		merror("module name is too long [%s.ko]\n", mod->name);
2228 		return 1;
2229 	}
2230 
2231 	return 0;
2232 }
2233 
2234 /**
2235  * Header for the generated file
2236  **/
2237 static void add_header(struct buffer *b, struct module *mod)
2238 {
2239 	buf_printf(b, "#include <linux/build-salt.h>\n");
2240 	buf_printf(b, "#include <linux/module.h>\n");
2241 	buf_printf(b, "#include <linux/vermagic.h>\n");
2242 	buf_printf(b, "#include <linux/compiler.h>\n");
2243 	buf_printf(b, "\n");
2244 	buf_printf(b, "BUILD_SALT;\n");
2245 	buf_printf(b, "\n");
2246 	buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2247 	buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
2248 	buf_printf(b, "\n");
2249 	buf_printf(b, "__visible struct module __this_module\n");
2250 	buf_printf(b, "__section(.gnu.linkonce.this_module) = {\n");
2251 	buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2252 	if (mod->has_init)
2253 		buf_printf(b, "\t.init = init_module,\n");
2254 	if (mod->has_cleanup)
2255 		buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2256 			      "\t.exit = cleanup_module,\n"
2257 			      "#endif\n");
2258 	buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2259 	buf_printf(b, "};\n");
2260 }
2261 
2262 static void add_intree_flag(struct buffer *b, int is_intree)
2263 {
2264 	if (is_intree)
2265 		buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2266 }
2267 
2268 /* Cannot check for assembler */
2269 static void add_retpoline(struct buffer *b)
2270 {
2271 	buf_printf(b, "\n#ifdef CONFIG_RETPOLINE\n");
2272 	buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n");
2273 	buf_printf(b, "#endif\n");
2274 }
2275 
2276 static void add_staging_flag(struct buffer *b, const char *name)
2277 {
2278 	if (strstarts(name, "drivers/staging"))
2279 		buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2280 }
2281 
2282 /**
2283  * Record CRCs for unresolved symbols
2284  **/
2285 static int add_versions(struct buffer *b, struct module *mod)
2286 {
2287 	struct symbol *s, *exp;
2288 	int err = 0;
2289 
2290 	for (s = mod->unres; s; s = s->next) {
2291 		exp = find_symbol(s->name);
2292 		if (!exp || exp->module == mod)
2293 			continue;
2294 		s->module = exp->module;
2295 		s->crc_valid = exp->crc_valid;
2296 		s->crc = exp->crc;
2297 	}
2298 
2299 	if (!modversions)
2300 		return err;
2301 
2302 	buf_printf(b, "\n");
2303 	buf_printf(b, "static const struct modversion_info ____versions[]\n");
2304 	buf_printf(b, "__used __section(__versions) = {\n");
2305 
2306 	for (s = mod->unres; s; s = s->next) {
2307 		if (!s->module)
2308 			continue;
2309 		if (!s->crc_valid) {
2310 			warn("\"%s\" [%s.ko] has no CRC!\n",
2311 				s->name, mod->name);
2312 			continue;
2313 		}
2314 		if (strlen(s->name) >= MODULE_NAME_LEN) {
2315 			merror("too long symbol \"%s\" [%s.ko]\n",
2316 			       s->name, mod->name);
2317 			err = 1;
2318 			break;
2319 		}
2320 		buf_printf(b, "\t{ %#8x, \"%s\" },\n",
2321 			   s->crc, s->name);
2322 	}
2323 
2324 	buf_printf(b, "};\n");
2325 
2326 	return err;
2327 }
2328 
2329 static void add_depends(struct buffer *b, struct module *mod)
2330 {
2331 	struct symbol *s;
2332 	int first = 1;
2333 
2334 	/* Clear ->seen flag of modules that own symbols needed by this. */
2335 	for (s = mod->unres; s; s = s->next)
2336 		if (s->module)
2337 			s->module->seen = is_vmlinux(s->module->name);
2338 
2339 	buf_printf(b, "\n");
2340 	buf_printf(b, "MODULE_INFO(depends, \"");
2341 	for (s = mod->unres; s; s = s->next) {
2342 		const char *p;
2343 		if (!s->module)
2344 			continue;
2345 
2346 		if (s->module->seen)
2347 			continue;
2348 
2349 		s->module->seen = 1;
2350 		p = strrchr(s->module->name, '/');
2351 		if (p)
2352 			p++;
2353 		else
2354 			p = s->module->name;
2355 		buf_printf(b, "%s%s", first ? "" : ",", p);
2356 		first = 0;
2357 	}
2358 	buf_printf(b, "\");\n");
2359 }
2360 
2361 static void add_srcversion(struct buffer *b, struct module *mod)
2362 {
2363 	if (mod->srcversion[0]) {
2364 		buf_printf(b, "\n");
2365 		buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2366 			   mod->srcversion);
2367 	}
2368 }
2369 
2370 static void write_if_changed(struct buffer *b, const char *fname)
2371 {
2372 	char *tmp;
2373 	FILE *file;
2374 	struct stat st;
2375 
2376 	file = fopen(fname, "r");
2377 	if (!file)
2378 		goto write;
2379 
2380 	if (fstat(fileno(file), &st) < 0)
2381 		goto close_write;
2382 
2383 	if (st.st_size != b->pos)
2384 		goto close_write;
2385 
2386 	tmp = NOFAIL(malloc(b->pos));
2387 	if (fread(tmp, 1, b->pos, file) != b->pos)
2388 		goto free_write;
2389 
2390 	if (memcmp(tmp, b->p, b->pos) != 0)
2391 		goto free_write;
2392 
2393 	free(tmp);
2394 	fclose(file);
2395 	return;
2396 
2397  free_write:
2398 	free(tmp);
2399  close_write:
2400 	fclose(file);
2401  write:
2402 	file = fopen(fname, "w");
2403 	if (!file) {
2404 		perror(fname);
2405 		exit(1);
2406 	}
2407 	if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2408 		perror(fname);
2409 		exit(1);
2410 	}
2411 	fclose(file);
2412 }
2413 
2414 /* parse Module.symvers file. line format:
2415  * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2416  **/
2417 static void read_dump(const char *fname, unsigned int kernel)
2418 {
2419 	unsigned long size, pos = 0;
2420 	void *file = grab_file(fname, &size);
2421 	char *line;
2422 
2423 	if (!file)
2424 		/* No symbol versions, silently ignore */
2425 		return;
2426 
2427 	while ((line = get_next_line(&pos, file, size))) {
2428 		char *symname, *namespace, *modname, *d, *export, *end;
2429 		unsigned int crc;
2430 		struct module *mod;
2431 		struct symbol *s;
2432 
2433 		if (!(symname = strchr(line, '\t')))
2434 			goto fail;
2435 		*symname++ = '\0';
2436 		if (!(namespace = strchr(symname, '\t')))
2437 			goto fail;
2438 		*namespace++ = '\0';
2439 		if (!(modname = strchr(namespace, '\t')))
2440 			goto fail;
2441 		*modname++ = '\0';
2442 		if ((export = strchr(modname, '\t')) != NULL)
2443 			*export++ = '\0';
2444 		if (export && ((end = strchr(export, '\t')) != NULL))
2445 			*end = '\0';
2446 		crc = strtoul(line, &d, 16);
2447 		if (*symname == '\0' || *modname == '\0' || *d != '\0')
2448 			goto fail;
2449 		mod = find_module(modname);
2450 		if (!mod) {
2451 			if (is_vmlinux(modname))
2452 				have_vmlinux = 1;
2453 			mod = new_module(modname);
2454 			mod->skip = 1;
2455 		}
2456 		s = sym_add_exported(symname, namespace, mod,
2457 				     export_no(export));
2458 		s->kernel    = kernel;
2459 		s->preloaded = 1;
2460 		s->is_static = 0;
2461 		sym_update_crc(symname, mod, crc, export_no(export));
2462 	}
2463 	release_file(file, size);
2464 	return;
2465 fail:
2466 	release_file(file, size);
2467 	fatal("parse error in symbol dump file\n");
2468 }
2469 
2470 /* For normal builds always dump all symbols.
2471  * For external modules only dump symbols
2472  * that are not read from kernel Module.symvers.
2473  **/
2474 static int dump_sym(struct symbol *sym)
2475 {
2476 	if (!external_module)
2477 		return 1;
2478 	if (sym->vmlinux || sym->kernel)
2479 		return 0;
2480 	return 1;
2481 }
2482 
2483 static void write_dump(const char *fname)
2484 {
2485 	struct buffer buf = { };
2486 	struct symbol *symbol;
2487 	const char *namespace;
2488 	int n;
2489 
2490 	for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2491 		symbol = symbolhash[n];
2492 		while (symbol) {
2493 			if (dump_sym(symbol)) {
2494 				namespace = symbol->namespace;
2495 				buf_printf(&buf, "0x%08x\t%s\t%s\t%s\t%s\n",
2496 					   symbol->crc, symbol->name,
2497 					   namespace ? namespace : "",
2498 					   symbol->module->name,
2499 					   export_str(symbol->export));
2500 			}
2501 			symbol = symbol->next;
2502 		}
2503 	}
2504 	write_if_changed(&buf, fname);
2505 	free(buf.p);
2506 }
2507 
2508 static void write_namespace_deps_files(void)
2509 {
2510 	struct module *mod;
2511 	struct namespace_list *ns;
2512 	struct buffer ns_deps_buf = {};
2513 
2514 	for (mod = modules; mod; mod = mod->next) {
2515 		char fname[PATH_MAX];
2516 
2517 		if (mod->skip)
2518 			continue;
2519 
2520 		ns_deps_buf.pos = 0;
2521 
2522 		for (ns = mod->required_namespaces; ns; ns = ns->next)
2523 			buf_printf(&ns_deps_buf, "%s\n", ns->namespace);
2524 
2525 		if (ns_deps_buf.pos == 0)
2526 			continue;
2527 
2528 		sprintf(fname, "%s.ns_deps", mod->name);
2529 		write_if_changed(&ns_deps_buf, fname);
2530 	}
2531 }
2532 
2533 struct ext_sym_list {
2534 	struct ext_sym_list *next;
2535 	const char *file;
2536 };
2537 
2538 int main(int argc, char **argv)
2539 {
2540 	struct module *mod;
2541 	struct buffer buf = { };
2542 	char *kernel_read = NULL, *module_read = NULL;
2543 	char *dump_write = NULL, *files_source = NULL;
2544 	int opt;
2545 	int err;
2546 	int n;
2547 	struct ext_sym_list *extsym_iter;
2548 	struct ext_sym_list *extsym_start = NULL;
2549 
2550 	while ((opt = getopt(argc, argv, "i:I:e:mnsT:o:awEd")) != -1) {
2551 		switch (opt) {
2552 		case 'i':
2553 			kernel_read = optarg;
2554 			break;
2555 		case 'I':
2556 			module_read = optarg;
2557 			external_module = 1;
2558 			break;
2559 		case 'e':
2560 			external_module = 1;
2561 			extsym_iter =
2562 			   NOFAIL(malloc(sizeof(*extsym_iter)));
2563 			extsym_iter->next = extsym_start;
2564 			extsym_iter->file = optarg;
2565 			extsym_start = extsym_iter;
2566 			break;
2567 		case 'm':
2568 			modversions = 1;
2569 			break;
2570 		case 'n':
2571 			ignore_missing_files = 1;
2572 			break;
2573 		case 'o':
2574 			dump_write = optarg;
2575 			break;
2576 		case 'a':
2577 			all_versions = 1;
2578 			break;
2579 		case 's':
2580 			vmlinux_section_warnings = 0;
2581 			break;
2582 		case 'T':
2583 			files_source = optarg;
2584 			break;
2585 		case 'w':
2586 			warn_unresolved = 1;
2587 			break;
2588 		case 'E':
2589 			sec_mismatch_fatal = 1;
2590 			break;
2591 		case 'd':
2592 			write_namespace_deps = 1;
2593 			break;
2594 		default:
2595 			exit(1);
2596 		}
2597 	}
2598 
2599 	if (kernel_read)
2600 		read_dump(kernel_read, 1);
2601 	if (module_read)
2602 		read_dump(module_read, 0);
2603 	while (extsym_start) {
2604 		read_dump(extsym_start->file, 0);
2605 		extsym_iter = extsym_start->next;
2606 		free(extsym_start);
2607 		extsym_start = extsym_iter;
2608 	}
2609 
2610 	while (optind < argc)
2611 		read_symbols(argv[optind++]);
2612 
2613 	if (files_source)
2614 		read_symbols_from_files(files_source);
2615 
2616 	err = 0;
2617 
2618 	for (mod = modules; mod; mod = mod->next) {
2619 		char fname[PATH_MAX];
2620 
2621 		if (mod->skip)
2622 			continue;
2623 
2624 		buf.pos = 0;
2625 
2626 		err |= check_modname_len(mod);
2627 		err |= check_exports(mod);
2628 		if (write_namespace_deps)
2629 			continue;
2630 
2631 		add_header(&buf, mod);
2632 		add_intree_flag(&buf, !external_module);
2633 		add_retpoline(&buf);
2634 		add_staging_flag(&buf, mod->name);
2635 		err |= add_versions(&buf, mod);
2636 		add_depends(&buf, mod);
2637 		add_moddevtable(&buf, mod);
2638 		add_srcversion(&buf, mod);
2639 
2640 		sprintf(fname, "%s.mod.c", mod->name);
2641 		write_if_changed(&buf, fname);
2642 	}
2643 
2644 	if (write_namespace_deps) {
2645 		write_namespace_deps_files();
2646 		return 0;
2647 	}
2648 
2649 	if (dump_write)
2650 		write_dump(dump_write);
2651 	if (sec_mismatch_count && sec_mismatch_fatal)
2652 		fatal("modpost: Section mismatches detected.\n"
2653 		      "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2654 	for (n = 0; n < SYMBOL_HASH_SIZE; n++) {
2655 		struct symbol *s;
2656 
2657 		for (s = symbolhash[n]; s; s = s->next) {
2658 			/*
2659 			 * Do not check "vmlinux". This avoids the same warnings
2660 			 * shown twice, and false-positives for ARCH=um.
2661 			 */
2662 			if (is_vmlinux(s->module->name) && !s->module->is_dot_o)
2663 				continue;
2664 
2665 			if (s->is_static)
2666 				warn("\"%s\" [%s] is a static %s\n",
2667 				     s->name, s->module->name,
2668 				     export_str(s->export));
2669 		}
2670 	}
2671 
2672 	free(buf.p);
2673 
2674 	return err;
2675 }
2676