1 /* Postprocess module symbol versions
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
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
11 * Usage: modpost vmlinux module1.o module2.o ...
23 #include "../../include/linux/license.h"
25 /* Are we using CONFIG_MODVERSIONS? */
26 static int modversions = 0;
27 /* Warn about undefined symbols? (do so if we have vmlinux) */
28 static int have_vmlinux = 0;
29 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
30 static int all_versions = 0;
31 /* If we are modposting external module set to 1 */
32 static int external_module = 0;
33 /* Only warn about unresolved symbols */
34 static int warn_unresolved = 0;
35 /* How a symbol is exported */
36 static int sec_mismatch_count = 0;
37 static int sec_mismatch_warn_only = true;
38 /* ignore missing files */
39 static int ignore_missing_files;
40 /* If set to 1, only warn (instead of error) about missing ns imports */
41 static int allow_missing_ns_imports;
43 static bool error_occurred;
46 export_plain, export_unused, export_gpl,
47 export_unused_gpl, export_gpl_future, export_unknown
50 /* In kernel, this size is defined in linux/module.h;
51 * here we use Elf_Addr instead of long for covering cross-compile
54 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
56 void __attribute__((format(printf, 2, 3)))
57 modpost_log(enum loglevel loglevel, const char *fmt, ...)
63 fprintf(stderr, "WARNING: ");
66 fprintf(stderr, "ERROR: ");
69 fprintf(stderr, "FATAL: ");
71 default: /* invalid loglevel, ignore */
75 fprintf(stderr, "modpost: ");
77 va_start(arglist, fmt);
78 vfprintf(stderr, fmt, arglist);
81 if (loglevel == LOG_FATAL)
83 if (loglevel == LOG_ERROR)
84 error_occurred = true;
87 static inline bool strends(const char *str, const char *postfix)
89 if (strlen(str) < strlen(postfix))
92 return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
95 void *do_nofail(void *ptr, const char *expr)
98 fatal("Memory allocation failure: %s.\n", expr);
103 char *read_text_file(const char *filename)
110 fd = open(filename, O_RDONLY);
116 if (fstat(fd, &st) < 0) {
121 buf = NOFAIL(malloc(st.st_size + 1));
128 bytes_read = read(fd, buf, nbytes);
129 if (bytes_read < 0) {
134 nbytes -= bytes_read;
136 buf[st.st_size] = '\0';
143 char *get_line(char **stringp)
145 char *orig = *stringp, *next;
147 /* do not return the unwanted extra line at EOF */
148 if (!orig || *orig == '\0')
151 /* don't use strsep here, it is not available everywhere */
152 next = strchr(orig, '\n');
161 /* A list of all modules we processed */
162 static struct module *modules;
164 static struct module *find_module(const char *modname)
168 for (mod = modules; mod; mod = mod->next)
169 if (strcmp(mod->name, modname) == 0)
174 static struct module *new_module(const char *modname)
178 mod = NOFAIL(malloc(sizeof(*mod) + strlen(modname) + 1));
179 memset(mod, 0, sizeof(*mod));
182 strcpy(mod->name, modname);
183 mod->is_vmlinux = (strcmp(modname, "vmlinux") == 0);
184 mod->gpl_compatible = -1;
194 /* A hash of all exported symbols,
195 * struct symbol is also used for lists of unresolved symbols */
197 #define SYMBOL_HASH_SIZE 1024
201 struct module *module;
206 unsigned int is_static:1; /* 1 if symbol is not global */
207 enum export export; /* Type of export */
211 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
213 /* This is based on the hash agorithm from gdbm, via tdb */
214 static inline unsigned int tdb_hash(const char *name)
216 unsigned value; /* Used to compute the hash value. */
217 unsigned i; /* Used to cycle through random values. */
219 /* Set the initial value from the key size. */
220 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
221 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
223 return (1103515243 * value + 12345);
227 * Allocate a new symbols for use in the hash of exported symbols or
228 * the list of unresolved symbols per module
230 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
233 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
235 memset(s, 0, sizeof(*s));
236 strcpy(s->name, name);
243 /* For the hash of exported symbols */
244 static struct symbol *new_symbol(const char *name, struct module *module,
249 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
250 symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
252 return symbolhash[hash];
255 static struct symbol *find_symbol(const char *name)
259 /* For our purposes, .foo matches foo. PPC64 needs this. */
263 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
264 if (strcmp(s->name, name) == 0)
270 static bool contains_namespace(struct namespace_list *list,
271 const char *namespace)
273 for (; list; list = list->next)
274 if (!strcmp(list->namespace, namespace))
280 static void add_namespace(struct namespace_list **list, const char *namespace)
282 struct namespace_list *ns_entry;
284 if (!contains_namespace(*list, namespace)) {
285 ns_entry = NOFAIL(malloc(sizeof(struct namespace_list) +
286 strlen(namespace) + 1));
287 strcpy(ns_entry->namespace, namespace);
288 ns_entry->next = *list;
293 static bool module_imports_namespace(struct module *module,
294 const char *namespace)
296 return contains_namespace(module->imported_namespaces, namespace);
299 static const struct {
303 { .str = "EXPORT_SYMBOL", .export = export_plain },
304 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
305 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
306 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
307 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
308 { .str = "(unknown)", .export = export_unknown },
312 static const char *export_str(enum export ex)
314 return export_list[ex].str;
317 static enum export export_no(const char *s)
322 return export_unknown;
323 for (i = 0; export_list[i].export != export_unknown; i++) {
324 if (strcmp(export_list[i].str, s) == 0)
325 return export_list[i].export;
327 return export_unknown;
330 static void *sym_get_data_by_offset(const struct elf_info *info,
331 unsigned int secindex, unsigned long offset)
333 Elf_Shdr *sechdr = &info->sechdrs[secindex];
335 if (info->hdr->e_type != ET_REL)
336 offset -= sechdr->sh_addr;
338 return (void *)info->hdr + sechdr->sh_offset + offset;
341 static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym)
343 return sym_get_data_by_offset(info, get_secindex(info, sym),
347 static const char *sech_name(const struct elf_info *info, Elf_Shdr *sechdr)
349 return sym_get_data_by_offset(info, info->secindex_strings,
353 static const char *sec_name(const struct elf_info *info, int secindex)
355 return sech_name(info, &info->sechdrs[secindex]);
358 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
360 static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
362 const char *secname = sec_name(elf, sec);
364 if (strstarts(secname, "___ksymtab+"))
366 else if (strstarts(secname, "___ksymtab_unused+"))
367 return export_unused;
368 else if (strstarts(secname, "___ksymtab_gpl+"))
370 else if (strstarts(secname, "___ksymtab_unused_gpl+"))
371 return export_unused_gpl;
372 else if (strstarts(secname, "___ksymtab_gpl_future+"))
373 return export_gpl_future;
375 return export_unknown;
378 static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
380 if (sec == elf->export_sec)
382 else if (sec == elf->export_unused_sec)
383 return export_unused;
384 else if (sec == elf->export_gpl_sec)
386 else if (sec == elf->export_unused_gpl_sec)
387 return export_unused_gpl;
388 else if (sec == elf->export_gpl_future_sec)
389 return export_gpl_future;
391 return export_unknown;
394 static const char *namespace_from_kstrtabns(const struct elf_info *info,
397 const char *value = sym_get_data(info, sym);
398 return value[0] ? value : NULL;
401 static void sym_update_namespace(const char *symname, const char *namespace)
403 struct symbol *s = find_symbol(symname);
406 * That symbol should have been created earlier and thus this is
407 * actually an assertion.
410 error("Could not update namespace(%s) for symbol %s\n",
417 namespace && namespace[0] ? NOFAIL(strdup(namespace)) : NULL;
421 * Add an exported symbol - it may have already been added without a
422 * CRC, in this case just update the CRC
424 static struct symbol *sym_add_exported(const char *name, struct module *mod,
427 struct symbol *s = find_symbol(name);
430 s = new_symbol(name, mod, export);
431 } else if (!external_module || s->module->is_vmlinux ||
433 warn("%s: '%s' exported twice. Previous export was in %s%s\n",
434 mod->name, name, s->module->name,
435 s->module->is_vmlinux ? "" : ".ko");
444 static void sym_set_crc(const char *name, unsigned int crc)
446 struct symbol *s = find_symbol(name);
449 * Ignore stand-alone __crc_*, which might be auto-generated symbols
450 * such as __*_veneer in ARM ELF.
459 static void *grab_file(const char *filename, size_t *size)
462 void *map = MAP_FAILED;
465 fd = open(filename, O_RDONLY);
472 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
476 if (map == MAP_FAILED)
481 static void release_file(void *file, size_t size)
486 static int parse_elf(struct elf_info *info, const char *filename)
492 const char *secstrings;
493 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
495 hdr = grab_file(filename, &info->size);
497 if (ignore_missing_files) {
498 fprintf(stderr, "%s: %s (ignored)\n", filename,
506 if (info->size < sizeof(*hdr)) {
507 /* file too small, assume this is an empty .o file */
510 /* Is this a valid ELF file? */
511 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
512 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
513 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
514 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
515 /* Not an ELF file - silently ignore it */
518 /* Fix endianness in ELF header */
519 hdr->e_type = TO_NATIVE(hdr->e_type);
520 hdr->e_machine = TO_NATIVE(hdr->e_machine);
521 hdr->e_version = TO_NATIVE(hdr->e_version);
522 hdr->e_entry = TO_NATIVE(hdr->e_entry);
523 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
524 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
525 hdr->e_flags = TO_NATIVE(hdr->e_flags);
526 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
527 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
528 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
529 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
530 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
531 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
532 sechdrs = (void *)hdr + hdr->e_shoff;
533 info->sechdrs = sechdrs;
535 /* Check if file offset is correct */
536 if (hdr->e_shoff > info->size) {
537 fatal("section header offset=%lu in file '%s' is bigger than filesize=%zu\n",
538 (unsigned long)hdr->e_shoff, filename, info->size);
542 if (hdr->e_shnum == SHN_UNDEF) {
544 * There are more than 64k sections,
545 * read count from .sh_size.
547 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
550 info->num_sections = hdr->e_shnum;
552 if (hdr->e_shstrndx == SHN_XINDEX) {
553 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
556 info->secindex_strings = hdr->e_shstrndx;
559 /* Fix endianness in section headers */
560 for (i = 0; i < info->num_sections; i++) {
561 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
562 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
563 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
564 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
565 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
566 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
567 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
568 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
569 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
570 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
572 /* Find symbol table. */
573 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
574 for (i = 1; i < info->num_sections; i++) {
576 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
578 if (!nobits && sechdrs[i].sh_offset > info->size) {
579 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
580 "sizeof(*hrd)=%zu\n", filename,
581 (unsigned long)sechdrs[i].sh_offset,
585 secname = secstrings + sechdrs[i].sh_name;
586 if (strcmp(secname, ".modinfo") == 0) {
588 fatal("%s has NOBITS .modinfo\n", filename);
589 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
590 info->modinfo_len = sechdrs[i].sh_size;
591 } else if (strcmp(secname, "__ksymtab") == 0)
592 info->export_sec = i;
593 else if (strcmp(secname, "__ksymtab_unused") == 0)
594 info->export_unused_sec = i;
595 else if (strcmp(secname, "__ksymtab_gpl") == 0)
596 info->export_gpl_sec = i;
597 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
598 info->export_unused_gpl_sec = i;
599 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
600 info->export_gpl_future_sec = i;
602 if (sechdrs[i].sh_type == SHT_SYMTAB) {
603 unsigned int sh_link_idx;
605 info->symtab_start = (void *)hdr +
606 sechdrs[i].sh_offset;
607 info->symtab_stop = (void *)hdr +
608 sechdrs[i].sh_offset + sechdrs[i].sh_size;
609 sh_link_idx = sechdrs[i].sh_link;
610 info->strtab = (void *)hdr +
611 sechdrs[sh_link_idx].sh_offset;
614 /* 32bit section no. table? ("more than 64k sections") */
615 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
616 symtab_shndx_idx = i;
617 info->symtab_shndx_start = (void *)hdr +
618 sechdrs[i].sh_offset;
619 info->symtab_shndx_stop = (void *)hdr +
620 sechdrs[i].sh_offset + sechdrs[i].sh_size;
623 if (!info->symtab_start)
624 fatal("%s has no symtab?\n", filename);
626 /* Fix endianness in symbols */
627 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
628 sym->st_shndx = TO_NATIVE(sym->st_shndx);
629 sym->st_name = TO_NATIVE(sym->st_name);
630 sym->st_value = TO_NATIVE(sym->st_value);
631 sym->st_size = TO_NATIVE(sym->st_size);
634 if (symtab_shndx_idx != ~0U) {
636 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
637 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
638 filename, sechdrs[symtab_shndx_idx].sh_link,
641 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
649 static void parse_elf_finish(struct elf_info *info)
651 release_file(info->hdr, info->size);
654 static int ignore_undef_symbol(struct elf_info *info, const char *symname)
656 /* ignore __this_module, it will be resolved shortly */
657 if (strcmp(symname, "__this_module") == 0)
659 /* ignore global offset table */
660 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
662 if (info->hdr->e_machine == EM_PPC)
663 /* Special register function linked on all modules during final link of .ko */
664 if (strstarts(symname, "_restgpr_") ||
665 strstarts(symname, "_savegpr_") ||
666 strstarts(symname, "_rest32gpr_") ||
667 strstarts(symname, "_save32gpr_") ||
668 strstarts(symname, "_restvr_") ||
669 strstarts(symname, "_savevr_"))
671 if (info->hdr->e_machine == EM_PPC64)
672 /* Special register function linked on all modules during final link of .ko */
673 if (strstarts(symname, "_restgpr0_") ||
674 strstarts(symname, "_savegpr0_") ||
675 strstarts(symname, "_restvr_") ||
676 strstarts(symname, "_savevr_") ||
677 strcmp(symname, ".TOC.") == 0)
679 /* Do not ignore this symbol */
683 static void handle_modversion(const struct module *mod,
684 const struct elf_info *info,
685 const Elf_Sym *sym, const char *symname)
689 if (sym->st_shndx == SHN_UNDEF) {
690 warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n",
691 symname, mod->name, mod->is_vmlinux ? "" : ".ko");
695 if (sym->st_shndx == SHN_ABS) {
700 /* symbol points to the CRC in the ELF object */
701 crcp = sym_get_data(info, sym);
702 crc = TO_NATIVE(*crcp);
704 sym_set_crc(symname, crc);
707 static void handle_symbol(struct module *mod, struct elf_info *info,
708 const Elf_Sym *sym, const char *symname)
713 if (strstarts(symname, "__ksymtab"))
714 export = export_from_secname(info, get_secindex(info, sym));
716 export = export_from_sec(info, get_secindex(info, sym));
718 switch (sym->st_shndx) {
720 if (strstarts(symname, "__gnu_lto_")) {
721 /* Should warn here, but modpost runs before the linker */
723 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
726 /* undefined symbol */
727 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
728 ELF_ST_BIND(sym->st_info) != STB_WEAK)
730 if (ignore_undef_symbol(info, symname))
732 if (info->hdr->e_machine == EM_SPARC ||
733 info->hdr->e_machine == EM_SPARCV9) {
734 /* Ignore register directives. */
735 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
737 if (symname[0] == '.') {
738 char *munged = NOFAIL(strdup(symname));
740 munged[1] = toupper(munged[1]);
745 mod->unres = alloc_symbol(symname,
746 ELF_ST_BIND(sym->st_info) == STB_WEAK,
750 /* All exported symbols */
751 if (strstarts(symname, "__ksymtab_")) {
752 name = symname + strlen("__ksymtab_");
753 sym_add_exported(name, mod, export);
755 if (strcmp(symname, "init_module") == 0)
757 if (strcmp(symname, "cleanup_module") == 0)
758 mod->has_cleanup = 1;
764 * Parse tag=value strings from .modinfo section
766 static char *next_string(char *string, unsigned long *secsize)
768 /* Skip non-zero chars */
771 if ((*secsize)-- <= 1)
775 /* Skip any zero padding. */
778 if ((*secsize)-- <= 1)
784 static char *get_next_modinfo(struct elf_info *info, const char *tag,
788 unsigned int taglen = strlen(tag);
789 char *modinfo = info->modinfo;
790 unsigned long size = info->modinfo_len;
793 size -= prev - modinfo;
794 modinfo = next_string(prev, &size);
797 for (p = modinfo; p; p = next_string(p, &size)) {
798 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
799 return p + taglen + 1;
804 static char *get_modinfo(struct elf_info *info, const char *tag)
807 return get_next_modinfo(info, tag, NULL);
811 * Test if string s ends in string sub
814 static int strrcmp(const char *s, const char *sub)
822 sublen = strlen(sub);
824 if ((slen == 0) || (sublen == 0))
830 return memcmp(s + slen - sublen, sub, sublen);
833 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
836 return elf->strtab + sym->st_name;
841 /* The pattern is an array of simple patterns.
842 * "foo" will match an exact string equal to "foo"
843 * "*foo" will match a string that ends with "foo"
844 * "foo*" will match a string that begins with "foo"
845 * "*foo*" will match a string that contains "foo"
847 static int match(const char *sym, const char * const pat[])
852 const char *endp = p + strlen(p) - 1;
855 if (*p == '*' && *endp == '*') {
856 char *bare = NOFAIL(strndup(p + 1, strlen(p) - 2));
857 char *here = strstr(sym, bare);
864 else if (*p == '*') {
865 if (strrcmp(sym, p + 1) == 0)
869 else if (*endp == '*') {
870 if (strncmp(sym, p, strlen(p) - 1) == 0)
875 if (strcmp(p, sym) == 0)
883 /* sections that we do not want to do full section mismatch check on */
884 static const char *const section_white_list[] =
888 ".cranges", /* sh64 */
889 ".zdebug*", /* Compressed debug sections. */
890 ".GCC.command.line", /* record-gcc-switches */
891 ".mdebug*", /* alpha, score, mips etc. */
892 ".pdr", /* alpha, score, mips etc. */
897 ".xt.prop", /* xtensa */
898 ".xt.lit", /* xtensa */
899 ".arcextmap*", /* arc */
900 ".gnu.linkonce.arcext*", /* arc : modules */
901 ".cmem*", /* EZchip */
902 ".fmt_slot*", /* EZchip */
909 * This is used to find sections missing the SHF_ALLOC flag.
910 * The cause of this is often a section specified in assembler
911 * without "ax" / "aw".
913 static void check_section(const char *modname, struct elf_info *elf,
916 const char *sec = sech_name(elf, sechdr);
918 if (sechdr->sh_type == SHT_PROGBITS &&
919 !(sechdr->sh_flags & SHF_ALLOC) &&
920 !match(sec, section_white_list)) {
921 warn("%s (%s): unexpected non-allocatable section.\n"
922 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
923 "Note that for example <linux/init.h> contains\n"
924 "section definitions for use in .S files.\n\n",
931 #define ALL_INIT_DATA_SECTIONS \
932 ".init.setup", ".init.rodata", ".meminit.rodata", \
933 ".init.data", ".meminit.data"
934 #define ALL_EXIT_DATA_SECTIONS \
935 ".exit.data", ".memexit.data"
937 #define ALL_INIT_TEXT_SECTIONS \
938 ".init.text", ".meminit.text"
939 #define ALL_EXIT_TEXT_SECTIONS \
940 ".exit.text", ".memexit.text"
942 #define ALL_PCI_INIT_SECTIONS \
943 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
944 ".pci_fixup_enable", ".pci_fixup_resume", \
945 ".pci_fixup_resume_early", ".pci_fixup_suspend"
947 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
948 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
950 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
951 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
953 #define DATA_SECTIONS ".data", ".data.rel"
954 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
955 ".kprobes.text", ".cpuidle.text", ".noinstr.text"
956 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
957 ".fixup", ".entry.text", ".exception.text", ".text.*", \
960 #define INIT_SECTIONS ".init.*"
961 #define MEM_INIT_SECTIONS ".meminit.*"
963 #define EXIT_SECTIONS ".exit.*"
964 #define MEM_EXIT_SECTIONS ".memexit.*"
966 #define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
967 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
969 /* init data sections */
970 static const char *const init_data_sections[] =
971 { ALL_INIT_DATA_SECTIONS, NULL };
973 /* all init sections */
974 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
976 /* All init and exit sections (code + data) */
977 static const char *const init_exit_sections[] =
978 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
980 /* all text sections */
981 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
984 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
987 /* symbols in .data that may refer to init/exit sections */
988 #define DEFAULT_SYMBOL_WHITE_LIST \
990 "*_template", /* scsi uses *_template a lot */ \
991 "*_timer", /* arm uses ops structures named _timer a lot */ \
992 "*_sht", /* scsi also used *_sht to some extent */ \
998 static const char *const head_sections[] = { ".head.text*", NULL };
999 static const char *const linker_symbols[] =
1000 { "__init_begin", "_sinittext", "_einittext", NULL };
1001 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
1008 XXXINIT_TO_SOME_INIT,
1009 XXXEXIT_TO_SOME_EXIT,
1010 ANY_INIT_TO_ANY_EXIT,
1011 ANY_EXIT_TO_ANY_INIT,
1012 EXPORT_TO_INIT_EXIT,
1013 EXTABLE_TO_NON_TEXT,
1017 * Describe how to match sections on different criterias:
1019 * @fromsec: Array of sections to be matched.
1021 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
1022 * this array is forbidden (black-list). Can be empty.
1024 * @good_tosec: Relocations applied to a section in @fromsec must be
1025 * targetting sections in this array (white-list). Can be empty.
1027 * @mismatch: Type of mismatch.
1029 * @symbol_white_list: Do not match a relocation to a symbol in this list
1030 * even if it is targetting a section in @bad_to_sec.
1032 * @handler: Specific handler to call when a match is found. If NULL,
1033 * default_mismatch_handler() will be called.
1036 struct sectioncheck {
1037 const char *fromsec[20];
1038 const char *bad_tosec[20];
1039 const char *good_tosec[20];
1040 enum mismatch mismatch;
1041 const char *symbol_white_list[20];
1042 void (*handler)(const char *modname, struct elf_info *elf,
1043 const struct sectioncheck* const mismatch,
1044 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
1048 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
1049 const struct sectioncheck* const mismatch,
1050 Elf_Rela *r, Elf_Sym *sym,
1051 const char *fromsec);
1053 static const struct sectioncheck sectioncheck[] = {
1054 /* Do not reference init/exit code/data from
1055 * normal code and data
1058 .fromsec = { TEXT_SECTIONS, NULL },
1059 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1060 .mismatch = TEXT_TO_ANY_INIT,
1061 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1064 .fromsec = { DATA_SECTIONS, NULL },
1065 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1066 .mismatch = DATA_TO_ANY_INIT,
1067 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1070 .fromsec = { DATA_SECTIONS, NULL },
1071 .bad_tosec = { INIT_SECTIONS, NULL },
1072 .mismatch = DATA_TO_ANY_INIT,
1073 .symbol_white_list = {
1074 "*_template", "*_timer", "*_sht", "*_ops",
1075 "*_probe", "*_probe_one", "*_console", NULL
1079 .fromsec = { TEXT_SECTIONS, NULL },
1080 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1081 .mismatch = TEXT_TO_ANY_EXIT,
1082 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1085 .fromsec = { DATA_SECTIONS, NULL },
1086 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1087 .mismatch = DATA_TO_ANY_EXIT,
1088 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1090 /* Do not reference init code/data from meminit code/data */
1092 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1093 .bad_tosec = { INIT_SECTIONS, NULL },
1094 .mismatch = XXXINIT_TO_SOME_INIT,
1095 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1097 /* Do not reference exit code/data from memexit code/data */
1099 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1100 .bad_tosec = { EXIT_SECTIONS, NULL },
1101 .mismatch = XXXEXIT_TO_SOME_EXIT,
1102 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1104 /* Do not use exit code/data from init code */
1106 .fromsec = { ALL_INIT_SECTIONS, NULL },
1107 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1108 .mismatch = ANY_INIT_TO_ANY_EXIT,
1109 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1111 /* Do not use init code/data from exit code */
1113 .fromsec = { ALL_EXIT_SECTIONS, NULL },
1114 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1115 .mismatch = ANY_EXIT_TO_ANY_INIT,
1116 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1119 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1120 .bad_tosec = { INIT_SECTIONS, NULL },
1121 .mismatch = ANY_INIT_TO_ANY_EXIT,
1122 .symbol_white_list = { NULL },
1124 /* Do not export init/exit functions or data */
1126 .fromsec = { "__ksymtab*", NULL },
1127 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1128 .mismatch = EXPORT_TO_INIT_EXIT,
1129 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1132 .fromsec = { "__ex_table", NULL },
1133 /* If you're adding any new black-listed sections in here, consider
1134 * adding a special 'printer' for them in scripts/check_extable.
1136 .bad_tosec = { ".altinstr_replacement", NULL },
1137 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1138 .mismatch = EXTABLE_TO_NON_TEXT,
1139 .handler = extable_mismatch_handler,
1143 static const struct sectioncheck *section_mismatch(
1144 const char *fromsec, const char *tosec)
1147 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1148 const struct sectioncheck *check = §ioncheck[0];
1151 * The target section could be the SHT_NUL section when we're
1152 * handling relocations to un-resolved symbols, trying to match it
1153 * doesn't make much sense and causes build failures on parisc
1159 for (i = 0; i < elems; i++) {
1160 if (match(fromsec, check->fromsec)) {
1161 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1163 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1172 * Whitelist to allow certain references to pass with no warning.
1175 * If a module parameter is declared __initdata and permissions=0
1176 * then this is legal despite the warning generated.
1177 * We cannot see value of permissions here, so just ignore
1179 * The pattern is identified by:
1180 * tosec = .init.data
1185 * module_param_call() ops can refer to __init set function if permissions=0
1186 * The pattern is identified by:
1187 * tosec = .init.text
1189 * atsym = __param_ops_*
1192 * Many drivers utilise a *driver container with references to
1193 * add, remove, probe functions etc.
1194 * the pattern is identified by:
1195 * tosec = init or exit section
1196 * fromsec = data section
1197 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1198 * *probe_one, *_console, *_timer
1201 * Whitelist all references from .head.text to any init section
1204 * Some symbols belong to init section but still it is ok to reference
1205 * these from non-init sections as these symbols don't have any memory
1206 * allocated for them and symbol address and value are same. So even
1207 * if init section is freed, its ok to reference those symbols.
1208 * For ex. symbols marking the init section boundaries.
1209 * This pattern is identified by
1210 * refsymname = __init_begin, _sinittext, _einittext
1213 * GCC may optimize static inlines when fed constant arg(s) resulting
1214 * in functions like cpumask_empty() -- generating an associated symbol
1215 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1216 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1217 * meaningless section warning. May need to add isra symbols too...
1218 * This pattern is identified by
1219 * tosec = init section
1220 * fromsec = text section
1221 * refsymname = *.constprop.*
1224 * Hide section mismatch warnings for ELF local symbols. The goal
1225 * is to eliminate false positive modpost warnings caused by
1226 * compiler-generated ELF local symbol names such as ".LANCHOR1".
1227 * Autogenerated symbol names bypass modpost's "Pattern 2"
1228 * whitelisting, which relies on pattern-matching against symbol
1229 * names to work. (One situation where gcc can autogenerate ELF
1230 * local symbols is when "-fsection-anchors" is used.)
1232 static int secref_whitelist(const struct sectioncheck *mismatch,
1233 const char *fromsec, const char *fromsym,
1234 const char *tosec, const char *tosym)
1236 /* Check for pattern 1 */
1237 if (match(tosec, init_data_sections) &&
1238 match(fromsec, data_sections) &&
1239 strstarts(fromsym, "__param"))
1242 /* Check for pattern 1a */
1243 if (strcmp(tosec, ".init.text") == 0 &&
1244 match(fromsec, data_sections) &&
1245 strstarts(fromsym, "__param_ops_"))
1248 /* Check for pattern 2 */
1249 if (match(tosec, init_exit_sections) &&
1250 match(fromsec, data_sections) &&
1251 match(fromsym, mismatch->symbol_white_list))
1254 /* Check for pattern 3 */
1255 if (match(fromsec, head_sections) &&
1256 match(tosec, init_sections))
1259 /* Check for pattern 4 */
1260 if (match(tosym, linker_symbols))
1263 /* Check for pattern 5 */
1264 if (match(fromsec, text_sections) &&
1265 match(tosec, init_sections) &&
1266 match(fromsym, optim_symbols))
1269 /* Check for pattern 6 */
1270 if (strstarts(fromsym, ".L"))
1276 static inline int is_arm_mapping_symbol(const char *str)
1278 return str[0] == '$' && strchr("axtd", str[1])
1279 && (str[2] == '\0' || str[2] == '.');
1283 * If there's no name there, ignore it; likewise, ignore it if it's
1284 * one of the magic symbols emitted used by current ARM tools.
1286 * Otherwise if find_symbols_between() returns those symbols, they'll
1287 * fail the whitelist tests and cause lots of false alarms ... fixable
1288 * only by merging __exit and __init sections into __text, bloating
1289 * the kernel (which is especially evil on embedded platforms).
1291 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1293 const char *name = elf->strtab + sym->st_name;
1295 if (!name || !strlen(name))
1297 return !is_arm_mapping_symbol(name);
1301 * Find symbol based on relocation record info.
1302 * In some cases the symbol supplied is a valid symbol so
1303 * return refsym. If st_name != 0 we assume this is a valid symbol.
1304 * In other cases the symbol needs to be looked up in the symbol table
1305 * based on section and address.
1307 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1311 Elf_Sym *near = NULL;
1312 Elf64_Sword distance = 20;
1314 unsigned int relsym_secindex;
1316 if (relsym->st_name != 0)
1319 relsym_secindex = get_secindex(elf, relsym);
1320 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1321 if (get_secindex(elf, sym) != relsym_secindex)
1323 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1325 if (!is_valid_name(elf, sym))
1327 if (sym->st_value == addr)
1329 /* Find a symbol nearby - addr are maybe negative */
1330 d = sym->st_value - addr;
1332 d = addr - sym->st_value;
1338 /* We need a close match */
1346 * Find symbols before or equal addr and after addr - in the section sec.
1347 * If we find two symbols with equal offset prefer one with a valid name.
1348 * The ELF format may have a better way to detect what type of symbol
1349 * it is, but this works for now.
1351 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1355 Elf_Sym *near = NULL;
1356 Elf_Addr distance = ~0;
1358 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1361 if (is_shndx_special(sym->st_shndx))
1363 symsec = sec_name(elf, get_secindex(elf, sym));
1364 if (strcmp(symsec, sec) != 0)
1366 if (!is_valid_name(elf, sym))
1368 if (sym->st_value <= addr) {
1369 if ((addr - sym->st_value) < distance) {
1370 distance = addr - sym->st_value;
1372 } else if ((addr - sym->st_value) == distance) {
1381 * Convert a section name to the function/data attribute
1382 * .init.text => __init
1383 * .memexitconst => __memconst
1386 * The memory of returned value has been allocated on a heap. The user of this
1387 * method should free it after usage.
1389 static char *sec2annotation(const char *s)
1391 if (match(s, init_exit_sections)) {
1392 char *p = NOFAIL(malloc(20));
1399 while (*s && *s != '.')
1404 if (strstr(s, "rodata") != NULL)
1405 strcat(p, "const ");
1406 else if (strstr(s, "data") != NULL)
1412 return NOFAIL(strdup(""));
1416 static int is_function(Elf_Sym *sym)
1419 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1424 static void print_section_list(const char * const list[20])
1426 const char *const *s = list;
1429 fprintf(stderr, "%s", *s);
1432 fprintf(stderr, ", ");
1434 fprintf(stderr, "\n");
1437 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1440 case 0: *name = "variable"; *name_p = ""; break;
1441 case 1: *name = "function"; *name_p = "()"; break;
1442 default: *name = "(unknown reference)"; *name_p = ""; break;
1447 * Print a warning about a section mismatch.
1448 * Try to find symbols near it so user can find it.
1449 * Check whitelist before warning - it may be a false positive.
1451 static void report_sec_mismatch(const char *modname,
1452 const struct sectioncheck *mismatch,
1453 const char *fromsec,
1454 unsigned long long fromaddr,
1455 const char *fromsym,
1457 const char *tosec, const char *tosym,
1460 const char *from, *from_p;
1461 const char *to, *to_p;
1465 sec_mismatch_count++;
1467 get_pretty_name(from_is_func, &from, &from_p);
1468 get_pretty_name(to_is_func, &to, &to_p);
1470 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1471 "to the %s %s:%s%s\n",
1472 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1475 switch (mismatch->mismatch) {
1476 case TEXT_TO_ANY_INIT:
1477 prl_from = sec2annotation(fromsec);
1478 prl_to = sec2annotation(tosec);
1480 "The function %s%s() references\n"
1482 "This is often because %s lacks a %s\n"
1483 "annotation or the annotation of %s is wrong.\n",
1485 to, prl_to, tosym, to_p,
1486 fromsym, prl_to, tosym);
1490 case DATA_TO_ANY_INIT: {
1491 prl_to = sec2annotation(tosec);
1493 "The variable %s references\n"
1495 "If the reference is valid then annotate the\n"
1496 "variable with __init* or __refdata (see linux/init.h) "
1497 "or name the variable:\n",
1498 fromsym, to, prl_to, tosym, to_p);
1499 print_section_list(mismatch->symbol_white_list);
1503 case TEXT_TO_ANY_EXIT:
1504 prl_to = sec2annotation(tosec);
1506 "The function %s() references a %s in an exit section.\n"
1507 "Often the %s %s%s has valid usage outside the exit section\n"
1508 "and the fix is to remove the %sannotation of %s.\n",
1509 fromsym, to, to, tosym, to_p, prl_to, tosym);
1512 case DATA_TO_ANY_EXIT: {
1513 prl_to = sec2annotation(tosec);
1515 "The variable %s references\n"
1517 "If the reference is valid then annotate the\n"
1518 "variable with __exit* (see linux/init.h) or "
1519 "name the variable:\n",
1520 fromsym, to, prl_to, tosym, to_p);
1521 print_section_list(mismatch->symbol_white_list);
1525 case XXXINIT_TO_SOME_INIT:
1526 case XXXEXIT_TO_SOME_EXIT:
1527 prl_from = sec2annotation(fromsec);
1528 prl_to = sec2annotation(tosec);
1530 "The %s %s%s%s references\n"
1532 "If %s is only used by %s then\n"
1533 "annotate %s with a matching annotation.\n",
1534 from, prl_from, fromsym, from_p,
1535 to, prl_to, tosym, to_p,
1536 tosym, fromsym, tosym);
1540 case ANY_INIT_TO_ANY_EXIT:
1541 prl_from = sec2annotation(fromsec);
1542 prl_to = sec2annotation(tosec);
1544 "The %s %s%s%s references\n"
1546 "This is often seen when error handling "
1547 "in the init function\n"
1548 "uses functionality in the exit path.\n"
1549 "The fix is often to remove the %sannotation of\n"
1550 "%s%s so it may be used outside an exit section.\n",
1551 from, prl_from, fromsym, from_p,
1552 to, prl_to, tosym, to_p,
1553 prl_to, tosym, to_p);
1557 case ANY_EXIT_TO_ANY_INIT:
1558 prl_from = sec2annotation(fromsec);
1559 prl_to = sec2annotation(tosec);
1561 "The %s %s%s%s references\n"
1563 "This is often seen when error handling "
1564 "in the exit function\n"
1565 "uses functionality in the init path.\n"
1566 "The fix is often to remove the %sannotation of\n"
1567 "%s%s so it may be used outside an init section.\n",
1568 from, prl_from, fromsym, from_p,
1569 to, prl_to, tosym, to_p,
1570 prl_to, tosym, to_p);
1574 case EXPORT_TO_INIT_EXIT:
1575 prl_to = sec2annotation(tosec);
1577 "The symbol %s is exported and annotated %s\n"
1578 "Fix this by removing the %sannotation of %s "
1579 "or drop the export.\n",
1580 tosym, prl_to, prl_to, tosym);
1583 case EXTABLE_TO_NON_TEXT:
1584 fatal("There's a special handler for this mismatch type, "
1585 "we should never get here.");
1588 fprintf(stderr, "\n");
1591 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1592 const struct sectioncheck* const mismatch,
1593 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1599 const char *fromsym;
1601 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1602 fromsym = sym_name(elf, from);
1604 if (strstarts(fromsym, "reference___initcall"))
1607 tosec = sec_name(elf, get_secindex(elf, sym));
1608 to = find_elf_symbol(elf, r->r_addend, sym);
1609 tosym = sym_name(elf, to);
1611 /* check whitelist - we may ignore it */
1612 if (secref_whitelist(mismatch,
1613 fromsec, fromsym, tosec, tosym)) {
1614 report_sec_mismatch(modname, mismatch,
1615 fromsec, r->r_offset, fromsym,
1616 is_function(from), tosec, tosym,
1621 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1623 if (section_index > elf->num_sections)
1624 fatal("section_index is outside elf->num_sections!\n");
1626 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1630 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1631 * to know the sizeof(struct exception_table_entry) for the target architecture.
1633 static unsigned int extable_entry_size = 0;
1634 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1637 * If we're currently checking the second relocation within __ex_table,
1638 * that relocation offset tells us the offsetof(struct
1639 * exception_table_entry, fixup) which is equal to sizeof(struct
1640 * exception_table_entry) divided by two. We use that to our advantage
1641 * since there's no portable way to get that size as every architecture
1642 * seems to go with different sized types. Not pretty but better than
1643 * hard-coding the size for every architecture..
1645 if (!extable_entry_size)
1646 extable_entry_size = r->r_offset * 2;
1649 static inline bool is_extable_fault_address(Elf_Rela *r)
1652 * extable_entry_size is only discovered after we've handled the
1653 * _second_ relocation in __ex_table, so only abort when we're not
1654 * handling the first reloc and extable_entry_size is zero.
1656 if (r->r_offset && extable_entry_size == 0)
1657 fatal("extable_entry size hasn't been discovered!\n");
1659 return ((r->r_offset == 0) ||
1660 (r->r_offset % extable_entry_size == 0));
1663 #define is_second_extable_reloc(Start, Cur, Sec) \
1664 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1666 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1667 const struct sectioncheck* const mismatch,
1668 Elf_Rela* r, Elf_Sym* sym,
1669 const char* fromsec, const char* tosec)
1671 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1672 const char* fromsym_name = sym_name(elf, fromsym);
1673 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1674 const char* tosym_name = sym_name(elf, tosym);
1675 const char* from_pretty_name;
1676 const char* from_pretty_name_p;
1677 const char* to_pretty_name;
1678 const char* to_pretty_name_p;
1680 get_pretty_name(is_function(fromsym),
1681 &from_pretty_name, &from_pretty_name_p);
1682 get_pretty_name(is_function(tosym),
1683 &to_pretty_name, &to_pretty_name_p);
1685 warn("%s(%s+0x%lx): Section mismatch in reference"
1686 " from the %s %s%s to the %s %s:%s%s\n",
1687 modname, fromsec, (long)r->r_offset, from_pretty_name,
1688 fromsym_name, from_pretty_name_p,
1689 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1691 if (!match(tosec, mismatch->bad_tosec) &&
1692 is_executable_section(elf, get_secindex(elf, sym)))
1694 "The relocation at %s+0x%lx references\n"
1695 "section \"%s\" which is not in the list of\n"
1696 "authorized sections. If you're adding a new section\n"
1697 "and/or if this reference is valid, add \"%s\" to the\n"
1698 "list of authorized sections to jump to on fault.\n"
1699 "This can be achieved by adding \"%s\" to \n"
1700 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1701 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1704 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1705 const struct sectioncheck* const mismatch,
1706 Elf_Rela* r, Elf_Sym* sym,
1707 const char *fromsec)
1709 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1711 sec_mismatch_count++;
1713 report_extable_warnings(modname, elf, mismatch, r, sym, fromsec, tosec);
1715 if (match(tosec, mismatch->bad_tosec))
1716 fatal("The relocation at %s+0x%lx references\n"
1717 "section \"%s\" which is black-listed.\n"
1718 "Something is seriously wrong and should be fixed.\n"
1719 "You might get more information about where this is\n"
1720 "coming from by using scripts/check_extable.sh %s\n",
1721 fromsec, (long)r->r_offset, tosec, modname);
1722 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1723 if (is_extable_fault_address(r))
1724 fatal("The relocation at %s+0x%lx references\n"
1725 "section \"%s\" which is not executable, IOW\n"
1726 "it is not possible for the kernel to fault\n"
1727 "at that address. Something is seriously wrong\n"
1728 "and should be fixed.\n",
1729 fromsec, (long)r->r_offset, tosec);
1731 fatal("The relocation at %s+0x%lx references\n"
1732 "section \"%s\" which is not executable, IOW\n"
1733 "the kernel will fault if it ever tries to\n"
1734 "jump to it. Something is seriously wrong\n"
1735 "and should be fixed.\n",
1736 fromsec, (long)r->r_offset, tosec);
1740 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1741 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1743 const char *tosec = sec_name(elf, get_secindex(elf, sym));
1744 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1747 if (mismatch->handler)
1748 mismatch->handler(modname, elf, mismatch,
1751 default_mismatch_handler(modname, elf, mismatch,
1756 static unsigned int *reloc_location(struct elf_info *elf,
1757 Elf_Shdr *sechdr, Elf_Rela *r)
1759 return sym_get_data_by_offset(elf, sechdr->sh_info, r->r_offset);
1762 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1764 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1765 unsigned int *location = reloc_location(elf, sechdr, r);
1769 r->r_addend = TO_NATIVE(*location);
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;
1782 #define R_ARM_CALL 28
1784 #ifndef R_ARM_JUMP24
1785 #define R_ARM_JUMP24 29
1788 #ifndef R_ARM_THM_CALL
1789 #define R_ARM_THM_CALL 10
1791 #ifndef R_ARM_THM_JUMP24
1792 #define R_ARM_THM_JUMP24 30
1794 #ifndef R_ARM_THM_JUMP19
1795 #define R_ARM_THM_JUMP19 51
1798 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1800 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1804 /* From ARM ABI: (S + A) | T */
1805 r->r_addend = (int)(long)
1806 (elf->symtab_start + ELF_R_SYM(r->r_info));
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 +
1817 (r->r_offset - sechdr->sh_addr));
1825 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1827 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1828 unsigned int *location = reloc_location(elf, sechdr, r);
1831 if (r_typ == R_MIPS_HI16)
1832 return 1; /* skip this */
1833 inst = TO_NATIVE(*location);
1836 r->r_addend = inst & 0xffff;
1839 r->r_addend = (inst & 0x03ffffff) << 2;
1848 static void section_rela(const char *modname, struct elf_info *elf,
1855 const char *fromsec;
1857 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1858 Elf_Rela *stop = (void *)start + sechdr->sh_size;
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))
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) {
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);
1876 r.r_info = TO_NATIVE(rela->r_info);
1877 r_sym = ELF_R_SYM(r.r_info);
1880 r.r_info = TO_NATIVE(rela->r_info);
1881 r_sym = ELF_R_SYM(r.r_info);
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))
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);
1894 static void section_rel(const char *modname, struct elf_info *elf,
1901 const char *fromsec;
1903 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1904 Elf_Rel *stop = (void *)start + sechdr->sh_size;
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))
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) {
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);
1922 r.r_info = TO_NATIVE(rel->r_info);
1923 r_sym = ELF_R_SYM(r.r_info);
1926 r.r_info = TO_NATIVE(rel->r_info);
1927 r_sym = ELF_R_SYM(r.r_info);
1930 switch (elf->hdr->e_machine) {
1932 if (addend_386_rel(elf, sechdr, &r))
1936 if (addend_arm_rel(elf, sechdr, &r))
1940 if (addend_mips_rel(elf, sechdr, &r))
1944 sym = elf->symtab_start + r_sym;
1945 /* Skip special sections */
1946 if (is_shndx_special(sym->st_shndx))
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);
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.
1966 static void check_sec_ref(struct module *mod, const char *modname,
1967 struct elf_info *elf)
1970 Elf_Shdr *sechdrs = elf->sechdrs;
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]);
1983 static char *remove_dot(char *s)
1985 size_t n = strcspn(s, ".");
1988 size_t m = strspn(s + n + 1, "0123456789");
1989 if (m && (s[n + m] == '.' || s[n + m] == 0))
1995 static void read_symbols(const char *modname)
1997 const char *symname;
2002 struct elf_info info = { };
2005 if (!parse_elf(&info, modname))
2011 /* strip trailing .o */
2012 tmp = NOFAIL(strdup(modname));
2013 tmp[strlen(tmp) - 2] = '\0';
2014 mod = new_module(tmp);
2018 if (!mod->is_vmlinux) {
2019 license = get_modinfo(&info, "license");
2021 error("missing MODULE_LICENSE() in %s\n", modname);
2023 if (license_is_gpl_compatible(license))
2024 mod->gpl_compatible = 1;
2026 mod->gpl_compatible = 0;
2029 license = get_next_modinfo(&info, "license", license);
2032 namespace = get_modinfo(&info, "import_ns");
2034 add_namespace(&mod->imported_namespaces, namespace);
2035 namespace = get_next_modinfo(&info, "import_ns",
2040 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2041 symname = remove_dot(info.strtab + sym->st_name);
2043 handle_symbol(mod, &info, sym, symname);
2044 handle_moddevtable(mod, &info, sym, symname);
2047 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2048 symname = remove_dot(info.strtab + sym->st_name);
2050 /* Apply symbol namespaces from __kstrtabns_<symbol> entries. */
2051 if (strstarts(symname, "__kstrtabns_"))
2052 sym_update_namespace(symname + strlen("__kstrtabns_"),
2053 namespace_from_kstrtabns(&info,
2056 if (strstarts(symname, "__crc_"))
2057 handle_modversion(mod, &info, sym,
2058 symname + strlen("__crc_"));
2061 // check for static EXPORT_SYMBOL_* functions && global vars
2062 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2063 unsigned char bind = ELF_ST_BIND(sym->st_info);
2065 if (bind == STB_GLOBAL || bind == STB_WEAK) {
2067 find_symbol(remove_dot(info.strtab +
2075 check_sec_ref(mod, modname, &info);
2077 if (!mod->is_vmlinux) {
2078 version = get_modinfo(&info, "version");
2079 if (version || all_versions)
2080 get_src_version(modname, mod->srcversion,
2081 sizeof(mod->srcversion) - 1);
2084 parse_elf_finish(&info);
2086 /* Our trick to get versioning for module struct etc. - it's
2087 * never passed as an argument to an exported function, so
2088 * the automatic versioning doesn't pick it up, but it's really
2089 * important anyhow */
2091 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
2094 static void read_symbols_from_files(const char *filename)
2097 char fname[PATH_MAX];
2099 if (strcmp(filename, "-") != 0) {
2100 in = fopen(filename, "r");
2102 fatal("Can't open filenames file %s: %m", filename);
2105 while (fgets(fname, PATH_MAX, in) != NULL) {
2106 if (strends(fname, "\n"))
2107 fname[strlen(fname)-1] = '\0';
2108 read_symbols(fname);
2117 /* We first write the generated file into memory using the
2118 * following helper, then compare to the file on disk and
2119 * only update the later if anything changed */
2121 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2122 const char *fmt, ...)
2129 len = vsnprintf(tmp, SZ, fmt, ap);
2130 buf_write(buf, tmp, len);
2134 void buf_write(struct buffer *buf, const char *s, int len)
2136 if (buf->size - buf->pos < len) {
2137 buf->size += len + SZ;
2138 buf->p = NOFAIL(realloc(buf->p, buf->size));
2140 strncpy(buf->p + buf->pos, s, len);
2144 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2148 error("GPL-incompatible module %s.ko uses GPL-only symbol '%s'\n",
2151 case export_unused_gpl:
2152 error("GPL-incompatible module %s.ko uses GPL-only symbol marked UNUSED '%s'\n",
2155 case export_gpl_future:
2156 warn("GPL-incompatible module %s.ko uses future GPL-only symbol '%s'\n",
2161 case export_unknown:
2167 static void check_for_unused(enum export exp, const char *m, const char *s)
2171 case export_unused_gpl:
2172 warn("module %s.ko uses symbol '%s' marked UNUSED\n",
2181 static void check_exports(struct module *mod)
2183 struct symbol *s, *exp;
2185 for (s = mod->unres; s; s = s->next) {
2186 const char *basename;
2187 exp = find_symbol(s->name);
2188 if (!exp || exp->module == mod) {
2189 if (have_vmlinux && !s->weak)
2190 modpost_log(warn_unresolved ? LOG_WARN : LOG_ERROR,
2191 "\"%s\" [%s.ko] undefined!\n",
2192 s->name, mod->name);
2195 basename = strrchr(mod->name, '/');
2199 basename = mod->name;
2201 if (exp->namespace &&
2202 !module_imports_namespace(mod, exp->namespace)) {
2203 modpost_log(allow_missing_ns_imports ? LOG_WARN : LOG_ERROR,
2204 "module %s uses symbol %s from namespace %s, but does not import it.\n",
2205 basename, exp->name, exp->namespace);
2206 add_namespace(&mod->missing_namespaces, exp->namespace);
2209 if (!mod->gpl_compatible)
2210 check_for_gpl_usage(exp->export, basename, exp->name);
2211 check_for_unused(exp->export, basename, exp->name);
2215 static void check_modname_len(struct module *mod)
2217 const char *mod_name;
2219 mod_name = strrchr(mod->name, '/');
2220 if (mod_name == NULL)
2221 mod_name = mod->name;
2224 if (strlen(mod_name) >= MODULE_NAME_LEN)
2225 error("module name is too long [%s.ko]\n", mod->name);
2229 * Header for the generated file
2231 static void add_header(struct buffer *b, struct module *mod)
2233 buf_printf(b, "#include <linux/module.h>\n");
2235 * Include build-salt.h after module.h in order to
2236 * inherit the definitions.
2238 buf_printf(b, "#define INCLUDE_VERMAGIC\n");
2239 buf_printf(b, "#include <linux/build-salt.h>\n");
2240 buf_printf(b, "#include <linux/vermagic.h>\n");
2241 buf_printf(b, "#include <linux/compiler.h>\n");
2242 buf_printf(b, "\n");
2243 buf_printf(b, "BUILD_SALT;\n");
2244 buf_printf(b, "\n");
2245 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2246 buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
2247 buf_printf(b, "\n");
2248 buf_printf(b, "__visible struct module __this_module\n");
2249 buf_printf(b, "__section(\".gnu.linkonce.this_module\") = {\n");
2250 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2252 buf_printf(b, "\t.init = init_module,\n");
2253 if (mod->has_cleanup)
2254 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2255 "\t.exit = cleanup_module,\n"
2257 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2258 buf_printf(b, "};\n");
2261 static void add_intree_flag(struct buffer *b, int is_intree)
2264 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2267 /* Cannot check for assembler */
2268 static void add_retpoline(struct buffer *b)
2270 buf_printf(b, "\n#ifdef CONFIG_RETPOLINE\n");
2271 buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n");
2272 buf_printf(b, "#endif\n");
2275 static void add_staging_flag(struct buffer *b, const char *name)
2277 if (strstarts(name, "drivers/staging"))
2278 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2282 * Record CRCs for unresolved symbols
2284 static void add_versions(struct buffer *b, struct module *mod)
2286 struct symbol *s, *exp;
2288 for (s = mod->unres; s; s = s->next) {
2289 exp = find_symbol(s->name);
2290 if (!exp || exp->module == mod)
2292 s->module = exp->module;
2293 s->crc_valid = exp->crc_valid;
2300 buf_printf(b, "\n");
2301 buf_printf(b, "static const struct modversion_info ____versions[]\n");
2302 buf_printf(b, "__used __section(\"__versions\") = {\n");
2304 for (s = mod->unres; s; s = s->next) {
2307 if (!s->crc_valid) {
2308 warn("\"%s\" [%s.ko] has no CRC!\n",
2309 s->name, mod->name);
2312 if (strlen(s->name) >= MODULE_NAME_LEN) {
2313 error("too long symbol \"%s\" [%s.ko]\n",
2314 s->name, mod->name);
2317 buf_printf(b, "\t{ %#8x, \"%s\" },\n",
2321 buf_printf(b, "};\n");
2324 static void add_depends(struct buffer *b, struct module *mod)
2329 /* Clear ->seen flag of modules that own symbols needed by this. */
2330 for (s = mod->unres; s; s = s->next)
2332 s->module->seen = s->module->is_vmlinux;
2334 buf_printf(b, "\n");
2335 buf_printf(b, "MODULE_INFO(depends, \"");
2336 for (s = mod->unres; s; s = s->next) {
2341 if (s->module->seen)
2344 s->module->seen = 1;
2345 p = strrchr(s->module->name, '/');
2349 p = s->module->name;
2350 buf_printf(b, "%s%s", first ? "" : ",", p);
2353 buf_printf(b, "\");\n");
2356 static void add_srcversion(struct buffer *b, struct module *mod)
2358 if (mod->srcversion[0]) {
2359 buf_printf(b, "\n");
2360 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2365 static void write_buf(struct buffer *b, const char *fname)
2369 file = fopen(fname, "w");
2374 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2378 if (fclose(file) != 0) {
2384 static void write_if_changed(struct buffer *b, const char *fname)
2390 file = fopen(fname, "r");
2394 if (fstat(fileno(file), &st) < 0)
2397 if (st.st_size != b->pos)
2400 tmp = NOFAIL(malloc(b->pos));
2401 if (fread(tmp, 1, b->pos, file) != b->pos)
2404 if (memcmp(tmp, b->p, b->pos) != 0)
2416 write_buf(b, fname);
2419 /* parse Module.symvers file. line format:
2420 * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
2422 static void read_dump(const char *fname)
2424 char *buf, *pos, *line;
2426 buf = read_text_file(fname);
2428 /* No symbol versions, silently ignore */
2433 while ((line = get_line(&pos))) {
2434 char *symname, *namespace, *modname, *d, *export;
2439 if (!(symname = strchr(line, '\t')))
2442 if (!(modname = strchr(symname, '\t')))
2445 if (!(export = strchr(modname, '\t')))
2448 if (!(namespace = strchr(export, '\t')))
2450 *namespace++ = '\0';
2452 crc = strtoul(line, &d, 16);
2453 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2455 mod = find_module(modname);
2457 mod = new_module(modname);
2460 s = sym_add_exported(symname, mod, export_no(export));
2462 sym_set_crc(symname, crc);
2463 sym_update_namespace(symname, namespace);
2469 fatal("parse error in symbol dump file\n");
2472 /* For normal builds always dump all symbols.
2473 * For external modules only dump symbols
2474 * that are not read from kernel Module.symvers.
2476 static int dump_sym(struct symbol *sym)
2478 if (!external_module)
2480 if (sym->module->from_dump)
2485 static void write_dump(const char *fname)
2487 struct buffer buf = { };
2488 struct symbol *symbol;
2489 const char *namespace;
2492 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2493 symbol = symbolhash[n];
2495 if (dump_sym(symbol)) {
2496 namespace = symbol->namespace;
2497 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\t%s\n",
2498 symbol->crc, symbol->name,
2499 symbol->module->name,
2500 export_str(symbol->export),
2501 namespace ? namespace : "");
2503 symbol = symbol->next;
2506 write_buf(&buf, fname);
2510 static void write_namespace_deps_files(const char *fname)
2513 struct namespace_list *ns;
2514 struct buffer ns_deps_buf = {};
2516 for (mod = modules; mod; mod = mod->next) {
2518 if (mod->from_dump || !mod->missing_namespaces)
2521 buf_printf(&ns_deps_buf, "%s.ko:", mod->name);
2523 for (ns = mod->missing_namespaces; ns; ns = ns->next)
2524 buf_printf(&ns_deps_buf, " %s", ns->namespace);
2526 buf_printf(&ns_deps_buf, "\n");
2529 write_if_changed(&ns_deps_buf, fname);
2530 free(ns_deps_buf.p);
2534 struct dump_list *next;
2538 int main(int argc, char **argv)
2541 struct buffer buf = { };
2542 char *missing_namespace_deps = NULL;
2543 char *dump_write = NULL, *files_source = NULL;
2546 struct dump_list *dump_read_start = NULL;
2547 struct dump_list **dump_read_iter = &dump_read_start;
2549 while ((opt = getopt(argc, argv, "ei:mnT:o:awENd:")) != -1) {
2552 external_module = 1;
2556 NOFAIL(calloc(1, sizeof(**dump_read_iter)));
2557 (*dump_read_iter)->file = optarg;
2558 dump_read_iter = &(*dump_read_iter)->next;
2564 ignore_missing_files = 1;
2567 dump_write = optarg;
2573 files_source = optarg;
2576 warn_unresolved = 1;
2579 sec_mismatch_warn_only = false;
2582 allow_missing_ns_imports = 1;
2585 missing_namespace_deps = optarg;
2592 while (dump_read_start) {
2593 struct dump_list *tmp;
2595 read_dump(dump_read_start->file);
2596 tmp = dump_read_start->next;
2597 free(dump_read_start);
2598 dump_read_start = tmp;
2601 while (optind < argc)
2602 read_symbols(argv[optind++]);
2605 read_symbols_from_files(files_source);
2608 * When there's no vmlinux, don't print warnings about
2609 * unresolved symbols (since there'll be too many ;)
2612 warn("Symbol info of vmlinux is missing. Unresolved symbol check will be entirely skipped.\n");
2614 for (mod = modules; mod; mod = mod->next) {
2615 char fname[PATH_MAX];
2617 if (mod->is_vmlinux || mod->from_dump)
2622 check_modname_len(mod);
2625 add_header(&buf, mod);
2626 add_intree_flag(&buf, !external_module);
2627 add_retpoline(&buf);
2628 add_staging_flag(&buf, mod->name);
2629 add_versions(&buf, mod);
2630 add_depends(&buf, mod);
2631 add_moddevtable(&buf, mod);
2632 add_srcversion(&buf, mod);
2634 sprintf(fname, "%s.mod.c", mod->name);
2635 write_if_changed(&buf, fname);
2638 if (missing_namespace_deps)
2639 write_namespace_deps_files(missing_namespace_deps);
2642 write_dump(dump_write);
2643 if (sec_mismatch_count && !sec_mismatch_warn_only)
2644 error("Section mismatches detected.\n"
2645 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2646 for (n = 0; n < SYMBOL_HASH_SIZE; n++) {
2649 for (s = symbolhash[n]; s; s = s->next) {
2651 error("\"%s\" [%s] is a static %s\n",
2652 s->name, s->module->name,
2653 export_str(s->export));
2659 return error_occurred ? 1 : 0;