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 ...
22 #include "../../include/linux/license.h"
24 /* Are we using CONFIG_MODVERSIONS? */
25 static int modversions = 0;
26 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
27 static int all_versions = 0;
28 /* If we are modposting external module set to 1 */
29 static int external_module = 0;
30 /* Only warn about unresolved symbols */
31 static int warn_unresolved = 0;
32 /* How a symbol is exported */
33 static int sec_mismatch_count = 0;
34 static int sec_mismatch_warn_only = true;
35 /* ignore missing files */
36 static int ignore_missing_files;
37 /* If set to 1, only warn (instead of error) about missing ns imports */
38 static int allow_missing_ns_imports;
40 static bool error_occurred;
43 * Cut off the warnings when there are too many. This typically occurs when
44 * vmlinux is missing. ('make modules' without building vmlinux.)
46 #define MAX_UNRESOLVED_REPORTS 10
47 static unsigned int nr_unresolved;
55 /* In kernel, this size is defined in linux/module.h;
56 * here we use Elf_Addr instead of long for covering cross-compile
59 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
61 void __attribute__((format(printf, 2, 3)))
62 modpost_log(enum loglevel loglevel, const char *fmt, ...)
68 fprintf(stderr, "WARNING: ");
71 fprintf(stderr, "ERROR: ");
74 fprintf(stderr, "FATAL: ");
76 default: /* invalid loglevel, ignore */
80 fprintf(stderr, "modpost: ");
82 va_start(arglist, fmt);
83 vfprintf(stderr, fmt, arglist);
86 if (loglevel == LOG_FATAL)
88 if (loglevel == LOG_ERROR)
89 error_occurred = true;
92 void *do_nofail(void *ptr, const char *expr)
95 fatal("Memory allocation failure: %s.\n", expr);
100 char *read_text_file(const char *filename)
107 fd = open(filename, O_RDONLY);
113 if (fstat(fd, &st) < 0) {
118 buf = NOFAIL(malloc(st.st_size + 1));
125 bytes_read = read(fd, buf, nbytes);
126 if (bytes_read < 0) {
131 nbytes -= bytes_read;
133 buf[st.st_size] = '\0';
140 char *get_line(char **stringp)
142 char *orig = *stringp, *next;
144 /* do not return the unwanted extra line at EOF */
145 if (!orig || *orig == '\0')
148 /* don't use strsep here, it is not available everywhere */
149 next = strchr(orig, '\n');
158 /* A list of all modules we processed */
159 static struct module *modules;
161 static struct module *find_module(const char *modname)
165 for (mod = modules; mod; mod = mod->next)
166 if (strcmp(mod->name, modname) == 0)
171 static struct module *new_module(const char *modname)
175 mod = NOFAIL(malloc(sizeof(*mod) + strlen(modname) + 1));
176 memset(mod, 0, sizeof(*mod));
179 strcpy(mod->name, modname);
180 mod->is_vmlinux = (strcmp(modname, "vmlinux") == 0);
181 mod->gpl_compatible = -1;
188 /* A hash of all exported symbols,
189 * struct symbol is also used for lists of unresolved symbols */
191 #define SYMBOL_HASH_SIZE 1024
195 struct module *module;
200 unsigned int is_static:1; /* 1 if symbol is not global */
201 enum export export; /* Type of export */
205 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
207 /* This is based on the hash algorithm from gdbm, via tdb */
208 static inline unsigned int tdb_hash(const char *name)
210 unsigned value; /* Used to compute the hash value. */
211 unsigned i; /* Used to cycle through random values. */
213 /* Set the initial value from the key size. */
214 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
215 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
217 return (1103515243 * value + 12345);
221 * Allocate a new symbols for use in the hash of exported symbols or
222 * the list of unresolved symbols per module
224 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
227 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
229 memset(s, 0, sizeof(*s));
230 strcpy(s->name, name);
237 /* For the hash of exported symbols */
238 static struct symbol *new_symbol(const char *name, struct module *module,
243 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
244 symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
246 return symbolhash[hash];
249 static struct symbol *find_symbol(const char *name)
253 /* For our purposes, .foo matches foo. PPC64 needs this. */
257 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
258 if (strcmp(s->name, name) == 0)
264 static bool contains_namespace(struct namespace_list *list,
265 const char *namespace)
267 for (; list; list = list->next)
268 if (!strcmp(list->namespace, namespace))
274 static void add_namespace(struct namespace_list **list, const char *namespace)
276 struct namespace_list *ns_entry;
278 if (!contains_namespace(*list, namespace)) {
279 ns_entry = NOFAIL(malloc(sizeof(struct namespace_list) +
280 strlen(namespace) + 1));
281 strcpy(ns_entry->namespace, namespace);
282 ns_entry->next = *list;
287 static bool module_imports_namespace(struct module *module,
288 const char *namespace)
290 return contains_namespace(module->imported_namespaces, namespace);
293 static const struct {
297 { .str = "EXPORT_SYMBOL", .export = export_plain },
298 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
299 { .str = "(unknown)", .export = export_unknown },
303 static const char *export_str(enum export ex)
305 return export_list[ex].str;
308 static enum export export_no(const char *s)
313 return export_unknown;
314 for (i = 0; export_list[i].export != export_unknown; i++) {
315 if (strcmp(export_list[i].str, s) == 0)
316 return export_list[i].export;
318 return export_unknown;
321 static void *sym_get_data_by_offset(const struct elf_info *info,
322 unsigned int secindex, unsigned long offset)
324 Elf_Shdr *sechdr = &info->sechdrs[secindex];
326 if (info->hdr->e_type != ET_REL)
327 offset -= sechdr->sh_addr;
329 return (void *)info->hdr + sechdr->sh_offset + offset;
332 static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym)
334 return sym_get_data_by_offset(info, get_secindex(info, sym),
338 static const char *sech_name(const struct elf_info *info, Elf_Shdr *sechdr)
340 return sym_get_data_by_offset(info, info->secindex_strings,
344 static const char *sec_name(const struct elf_info *info, int secindex)
346 return sech_name(info, &info->sechdrs[secindex]);
349 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
351 static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
353 const char *secname = sec_name(elf, sec);
355 if (strstarts(secname, "___ksymtab+"))
357 else if (strstarts(secname, "___ksymtab_gpl+"))
360 return export_unknown;
363 static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
365 if (sec == elf->export_sec)
367 else if (sec == elf->export_gpl_sec)
370 return export_unknown;
373 static const char *namespace_from_kstrtabns(const struct elf_info *info,
376 const char *value = sym_get_data(info, sym);
377 return value[0] ? value : NULL;
380 static void sym_update_namespace(const char *symname, const char *namespace)
382 struct symbol *s = find_symbol(symname);
385 * That symbol should have been created earlier and thus this is
386 * actually an assertion.
389 error("Could not update namespace(%s) for symbol %s\n",
396 namespace && namespace[0] ? NOFAIL(strdup(namespace)) : NULL;
400 * Add an exported symbol - it may have already been added without a
401 * CRC, in this case just update the CRC
403 static struct symbol *sym_add_exported(const char *name, struct module *mod,
406 struct symbol *s = find_symbol(name);
409 s = new_symbol(name, mod, export);
410 } else if (!external_module || s->module->is_vmlinux ||
412 warn("%s: '%s' exported twice. Previous export was in %s%s\n",
413 mod->name, name, s->module->name,
414 s->module->is_vmlinux ? "" : ".ko");
423 static void sym_set_crc(const char *name, unsigned int crc)
425 struct symbol *s = find_symbol(name);
428 * Ignore stand-alone __crc_*, which might be auto-generated symbols
429 * such as __*_veneer in ARM ELF.
438 static void *grab_file(const char *filename, size_t *size)
441 void *map = MAP_FAILED;
444 fd = open(filename, O_RDONLY);
451 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
455 if (map == MAP_FAILED)
460 static void release_file(void *file, size_t size)
465 static int parse_elf(struct elf_info *info, const char *filename)
471 const char *secstrings;
472 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
474 hdr = grab_file(filename, &info->size);
476 if (ignore_missing_files) {
477 fprintf(stderr, "%s: %s (ignored)\n", filename,
485 if (info->size < sizeof(*hdr)) {
486 /* file too small, assume this is an empty .o file */
489 /* Is this a valid ELF file? */
490 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
491 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
492 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
493 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
494 /* Not an ELF file - silently ignore it */
497 /* Fix endianness in ELF header */
498 hdr->e_type = TO_NATIVE(hdr->e_type);
499 hdr->e_machine = TO_NATIVE(hdr->e_machine);
500 hdr->e_version = TO_NATIVE(hdr->e_version);
501 hdr->e_entry = TO_NATIVE(hdr->e_entry);
502 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
503 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
504 hdr->e_flags = TO_NATIVE(hdr->e_flags);
505 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
506 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
507 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
508 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
509 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
510 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
511 sechdrs = (void *)hdr + hdr->e_shoff;
512 info->sechdrs = sechdrs;
514 /* Check if file offset is correct */
515 if (hdr->e_shoff > info->size) {
516 fatal("section header offset=%lu in file '%s' is bigger than filesize=%zu\n",
517 (unsigned long)hdr->e_shoff, filename, info->size);
521 if (hdr->e_shnum == SHN_UNDEF) {
523 * There are more than 64k sections,
524 * read count from .sh_size.
526 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
529 info->num_sections = hdr->e_shnum;
531 if (hdr->e_shstrndx == SHN_XINDEX) {
532 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
535 info->secindex_strings = hdr->e_shstrndx;
538 /* Fix endianness in section headers */
539 for (i = 0; i < info->num_sections; i++) {
540 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
541 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
542 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
543 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
544 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
545 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
546 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
547 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
548 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
549 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
551 /* Find symbol table. */
552 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
553 for (i = 1; i < info->num_sections; i++) {
555 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
557 if (!nobits && sechdrs[i].sh_offset > info->size) {
558 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
559 "sizeof(*hrd)=%zu\n", filename,
560 (unsigned long)sechdrs[i].sh_offset,
564 secname = secstrings + sechdrs[i].sh_name;
565 if (strcmp(secname, ".modinfo") == 0) {
567 fatal("%s has NOBITS .modinfo\n", filename);
568 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
569 info->modinfo_len = sechdrs[i].sh_size;
570 } else if (strcmp(secname, "__ksymtab") == 0)
571 info->export_sec = i;
572 else if (strcmp(secname, "__ksymtab_gpl") == 0)
573 info->export_gpl_sec = i;
575 if (sechdrs[i].sh_type == SHT_SYMTAB) {
576 unsigned int sh_link_idx;
578 info->symtab_start = (void *)hdr +
579 sechdrs[i].sh_offset;
580 info->symtab_stop = (void *)hdr +
581 sechdrs[i].sh_offset + sechdrs[i].sh_size;
582 sh_link_idx = sechdrs[i].sh_link;
583 info->strtab = (void *)hdr +
584 sechdrs[sh_link_idx].sh_offset;
587 /* 32bit section no. table? ("more than 64k sections") */
588 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
589 symtab_shndx_idx = i;
590 info->symtab_shndx_start = (void *)hdr +
591 sechdrs[i].sh_offset;
592 info->symtab_shndx_stop = (void *)hdr +
593 sechdrs[i].sh_offset + sechdrs[i].sh_size;
596 if (!info->symtab_start)
597 fatal("%s has no symtab?\n", filename);
599 /* Fix endianness in symbols */
600 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
601 sym->st_shndx = TO_NATIVE(sym->st_shndx);
602 sym->st_name = TO_NATIVE(sym->st_name);
603 sym->st_value = TO_NATIVE(sym->st_value);
604 sym->st_size = TO_NATIVE(sym->st_size);
607 if (symtab_shndx_idx != ~0U) {
609 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
610 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
611 filename, sechdrs[symtab_shndx_idx].sh_link,
614 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
622 static void parse_elf_finish(struct elf_info *info)
624 release_file(info->hdr, info->size);
627 static int ignore_undef_symbol(struct elf_info *info, const char *symname)
629 /* ignore __this_module, it will be resolved shortly */
630 if (strcmp(symname, "__this_module") == 0)
632 /* ignore global offset table */
633 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
635 if (info->hdr->e_machine == EM_PPC)
636 /* Special register function linked on all modules during final link of .ko */
637 if (strstarts(symname, "_restgpr_") ||
638 strstarts(symname, "_savegpr_") ||
639 strstarts(symname, "_rest32gpr_") ||
640 strstarts(symname, "_save32gpr_") ||
641 strstarts(symname, "_restvr_") ||
642 strstarts(symname, "_savevr_"))
644 if (info->hdr->e_machine == EM_PPC64)
645 /* Special register function linked on all modules during final link of .ko */
646 if (strstarts(symname, "_restgpr0_") ||
647 strstarts(symname, "_savegpr0_") ||
648 strstarts(symname, "_restvr_") ||
649 strstarts(symname, "_savevr_") ||
650 strcmp(symname, ".TOC.") == 0)
652 /* Do not ignore this symbol */
656 static void handle_modversion(const struct module *mod,
657 const struct elf_info *info,
658 const Elf_Sym *sym, const char *symname)
662 if (sym->st_shndx == SHN_UNDEF) {
663 warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n",
664 symname, mod->name, mod->is_vmlinux ? "" : ".ko");
668 if (sym->st_shndx == SHN_ABS) {
673 /* symbol points to the CRC in the ELF object */
674 crcp = sym_get_data(info, sym);
675 crc = TO_NATIVE(*crcp);
677 sym_set_crc(symname, crc);
680 static void handle_symbol(struct module *mod, struct elf_info *info,
681 const Elf_Sym *sym, const char *symname)
686 if (strstarts(symname, "__ksymtab"))
687 export = export_from_secname(info, get_secindex(info, sym));
689 export = export_from_sec(info, get_secindex(info, sym));
691 switch (sym->st_shndx) {
693 if (strstarts(symname, "__gnu_lto_")) {
694 /* Should warn here, but modpost runs before the linker */
696 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
699 /* undefined symbol */
700 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
701 ELF_ST_BIND(sym->st_info) != STB_WEAK)
703 if (ignore_undef_symbol(info, symname))
705 if (info->hdr->e_machine == EM_SPARC ||
706 info->hdr->e_machine == EM_SPARCV9) {
707 /* Ignore register directives. */
708 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
710 if (symname[0] == '.') {
711 char *munged = NOFAIL(strdup(symname));
713 munged[1] = toupper(munged[1]);
718 mod->unres = alloc_symbol(symname,
719 ELF_ST_BIND(sym->st_info) == STB_WEAK,
723 /* All exported symbols */
724 if (strstarts(symname, "__ksymtab_")) {
725 name = symname + strlen("__ksymtab_");
726 sym_add_exported(name, mod, export);
728 if (strcmp(symname, "init_module") == 0)
730 if (strcmp(symname, "cleanup_module") == 0)
731 mod->has_cleanup = 1;
737 * Parse tag=value strings from .modinfo section
739 static char *next_string(char *string, unsigned long *secsize)
741 /* Skip non-zero chars */
744 if ((*secsize)-- <= 1)
748 /* Skip any zero padding. */
751 if ((*secsize)-- <= 1)
757 static char *get_next_modinfo(struct elf_info *info, const char *tag,
761 unsigned int taglen = strlen(tag);
762 char *modinfo = info->modinfo;
763 unsigned long size = info->modinfo_len;
766 size -= prev - modinfo;
767 modinfo = next_string(prev, &size);
770 for (p = modinfo; p; p = next_string(p, &size)) {
771 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
772 return p + taglen + 1;
777 static char *get_modinfo(struct elf_info *info, const char *tag)
780 return get_next_modinfo(info, tag, NULL);
784 * Test if string s ends in string sub
787 static int strrcmp(const char *s, const char *sub)
795 sublen = strlen(sub);
797 if ((slen == 0) || (sublen == 0))
803 return memcmp(s + slen - sublen, sub, sublen);
806 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
809 return elf->strtab + sym->st_name;
814 /* The pattern is an array of simple patterns.
815 * "foo" will match an exact string equal to "foo"
816 * "*foo" will match a string that ends with "foo"
817 * "foo*" will match a string that begins with "foo"
818 * "*foo*" will match a string that contains "foo"
820 static int match(const char *sym, const char * const pat[])
825 const char *endp = p + strlen(p) - 1;
828 if (*p == '*' && *endp == '*') {
829 char *bare = NOFAIL(strndup(p + 1, strlen(p) - 2));
830 char *here = strstr(sym, bare);
837 else if (*p == '*') {
838 if (strrcmp(sym, p + 1) == 0)
842 else if (*endp == '*') {
843 if (strncmp(sym, p, strlen(p) - 1) == 0)
848 if (strcmp(p, sym) == 0)
856 /* sections that we do not want to do full section mismatch check on */
857 static const char *const section_white_list[] =
861 ".cranges", /* sh64 */
862 ".zdebug*", /* Compressed debug sections. */
863 ".GCC.command.line", /* record-gcc-switches */
864 ".mdebug*", /* alpha, score, mips etc. */
865 ".pdr", /* alpha, score, mips etc. */
870 ".xt.prop", /* xtensa */
871 ".xt.lit", /* xtensa */
872 ".arcextmap*", /* arc */
873 ".gnu.linkonce.arcext*", /* arc : modules */
874 ".cmem*", /* EZchip */
875 ".fmt_slot*", /* EZchip */
882 * This is used to find sections missing the SHF_ALLOC flag.
883 * The cause of this is often a section specified in assembler
884 * without "ax" / "aw".
886 static void check_section(const char *modname, struct elf_info *elf,
889 const char *sec = sech_name(elf, sechdr);
891 if (sechdr->sh_type == SHT_PROGBITS &&
892 !(sechdr->sh_flags & SHF_ALLOC) &&
893 !match(sec, section_white_list)) {
894 warn("%s (%s): unexpected non-allocatable section.\n"
895 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
896 "Note that for example <linux/init.h> contains\n"
897 "section definitions for use in .S files.\n\n",
904 #define ALL_INIT_DATA_SECTIONS \
905 ".init.setup", ".init.rodata", ".meminit.rodata", \
906 ".init.data", ".meminit.data"
907 #define ALL_EXIT_DATA_SECTIONS \
908 ".exit.data", ".memexit.data"
910 #define ALL_INIT_TEXT_SECTIONS \
911 ".init.text", ".meminit.text"
912 #define ALL_EXIT_TEXT_SECTIONS \
913 ".exit.text", ".memexit.text"
915 #define ALL_PCI_INIT_SECTIONS \
916 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
917 ".pci_fixup_enable", ".pci_fixup_resume", \
918 ".pci_fixup_resume_early", ".pci_fixup_suspend"
920 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
921 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
923 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
924 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
926 #define DATA_SECTIONS ".data", ".data.rel"
927 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
928 ".kprobes.text", ".cpuidle.text", ".noinstr.text"
929 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
930 ".fixup", ".entry.text", ".exception.text", ".text.*", \
933 #define INIT_SECTIONS ".init.*"
934 #define MEM_INIT_SECTIONS ".meminit.*"
936 #define EXIT_SECTIONS ".exit.*"
937 #define MEM_EXIT_SECTIONS ".memexit.*"
939 #define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
940 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
942 /* init data sections */
943 static const char *const init_data_sections[] =
944 { ALL_INIT_DATA_SECTIONS, NULL };
946 /* all init sections */
947 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
949 /* All init and exit sections (code + data) */
950 static const char *const init_exit_sections[] =
951 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
953 /* all text sections */
954 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
957 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
960 /* symbols in .data that may refer to init/exit sections */
961 #define DEFAULT_SYMBOL_WHITE_LIST \
963 "*_template", /* scsi uses *_template a lot */ \
964 "*_timer", /* arm uses ops structures named _timer a lot */ \
965 "*_sht", /* scsi also used *_sht to some extent */ \
971 static const char *const head_sections[] = { ".head.text*", NULL };
972 static const char *const linker_symbols[] =
973 { "__init_begin", "_sinittext", "_einittext", NULL };
974 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
981 XXXINIT_TO_SOME_INIT,
982 XXXEXIT_TO_SOME_EXIT,
983 ANY_INIT_TO_ANY_EXIT,
984 ANY_EXIT_TO_ANY_INIT,
990 * Describe how to match sections on different criteria:
992 * @fromsec: Array of sections to be matched.
994 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
995 * this array is forbidden (black-list). Can be empty.
997 * @good_tosec: Relocations applied to a section in @fromsec must be
998 * targeting sections in this array (white-list). Can be empty.
1000 * @mismatch: Type of mismatch.
1002 * @symbol_white_list: Do not match a relocation to a symbol in this list
1003 * even if it is targeting a section in @bad_to_sec.
1005 * @handler: Specific handler to call when a match is found. If NULL,
1006 * default_mismatch_handler() will be called.
1009 struct sectioncheck {
1010 const char *fromsec[20];
1011 const char *bad_tosec[20];
1012 const char *good_tosec[20];
1013 enum mismatch mismatch;
1014 const char *symbol_white_list[20];
1015 void (*handler)(const char *modname, struct elf_info *elf,
1016 const struct sectioncheck* const mismatch,
1017 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
1021 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
1022 const struct sectioncheck* const mismatch,
1023 Elf_Rela *r, Elf_Sym *sym,
1024 const char *fromsec);
1026 static const struct sectioncheck sectioncheck[] = {
1027 /* Do not reference init/exit code/data from
1028 * normal code and data
1031 .fromsec = { TEXT_SECTIONS, NULL },
1032 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1033 .mismatch = TEXT_TO_ANY_INIT,
1034 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1037 .fromsec = { DATA_SECTIONS, NULL },
1038 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1039 .mismatch = DATA_TO_ANY_INIT,
1040 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1043 .fromsec = { DATA_SECTIONS, NULL },
1044 .bad_tosec = { INIT_SECTIONS, NULL },
1045 .mismatch = DATA_TO_ANY_INIT,
1046 .symbol_white_list = {
1047 "*_template", "*_timer", "*_sht", "*_ops",
1048 "*_probe", "*_probe_one", "*_console", NULL
1052 .fromsec = { TEXT_SECTIONS, NULL },
1053 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1054 .mismatch = TEXT_TO_ANY_EXIT,
1055 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1058 .fromsec = { DATA_SECTIONS, NULL },
1059 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1060 .mismatch = DATA_TO_ANY_EXIT,
1061 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1063 /* Do not reference init code/data from meminit code/data */
1065 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1066 .bad_tosec = { INIT_SECTIONS, NULL },
1067 .mismatch = XXXINIT_TO_SOME_INIT,
1068 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1070 /* Do not reference exit code/data from memexit code/data */
1072 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1073 .bad_tosec = { EXIT_SECTIONS, NULL },
1074 .mismatch = XXXEXIT_TO_SOME_EXIT,
1075 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1077 /* Do not use exit code/data from init code */
1079 .fromsec = { ALL_INIT_SECTIONS, NULL },
1080 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1081 .mismatch = ANY_INIT_TO_ANY_EXIT,
1082 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1084 /* Do not use init code/data from exit code */
1086 .fromsec = { ALL_EXIT_SECTIONS, NULL },
1087 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1088 .mismatch = ANY_EXIT_TO_ANY_INIT,
1089 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1092 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1093 .bad_tosec = { INIT_SECTIONS, NULL },
1094 .mismatch = ANY_INIT_TO_ANY_EXIT,
1095 .symbol_white_list = { NULL },
1097 /* Do not export init/exit functions or data */
1099 .fromsec = { "__ksymtab*", NULL },
1100 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1101 .mismatch = EXPORT_TO_INIT_EXIT,
1102 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1105 .fromsec = { "__ex_table", NULL },
1106 /* If you're adding any new black-listed sections in here, consider
1107 * adding a special 'printer' for them in scripts/check_extable.
1109 .bad_tosec = { ".altinstr_replacement", NULL },
1110 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1111 .mismatch = EXTABLE_TO_NON_TEXT,
1112 .handler = extable_mismatch_handler,
1116 static const struct sectioncheck *section_mismatch(
1117 const char *fromsec, const char *tosec)
1120 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1121 const struct sectioncheck *check = §ioncheck[0];
1124 * The target section could be the SHT_NUL section when we're
1125 * handling relocations to un-resolved symbols, trying to match it
1126 * doesn't make much sense and causes build failures on parisc
1132 for (i = 0; i < elems; i++) {
1133 if (match(fromsec, check->fromsec)) {
1134 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1136 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1145 * Whitelist to allow certain references to pass with no warning.
1148 * If a module parameter is declared __initdata and permissions=0
1149 * then this is legal despite the warning generated.
1150 * We cannot see value of permissions here, so just ignore
1152 * The pattern is identified by:
1153 * tosec = .init.data
1158 * module_param_call() ops can refer to __init set function if permissions=0
1159 * The pattern is identified by:
1160 * tosec = .init.text
1162 * atsym = __param_ops_*
1165 * Many drivers utilise a *driver container with references to
1166 * add, remove, probe functions etc.
1167 * the pattern is identified by:
1168 * tosec = init or exit section
1169 * fromsec = data section
1170 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1171 * *probe_one, *_console, *_timer
1174 * Whitelist all references from .head.text to any init section
1177 * Some symbols belong to init section but still it is ok to reference
1178 * these from non-init sections as these symbols don't have any memory
1179 * allocated for them and symbol address and value are same. So even
1180 * if init section is freed, its ok to reference those symbols.
1181 * For ex. symbols marking the init section boundaries.
1182 * This pattern is identified by
1183 * refsymname = __init_begin, _sinittext, _einittext
1186 * GCC may optimize static inlines when fed constant arg(s) resulting
1187 * in functions like cpumask_empty() -- generating an associated symbol
1188 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1189 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1190 * meaningless section warning. May need to add isra symbols too...
1191 * This pattern is identified by
1192 * tosec = init section
1193 * fromsec = text section
1194 * refsymname = *.constprop.*
1197 * Hide section mismatch warnings for ELF local symbols. The goal
1198 * is to eliminate false positive modpost warnings caused by
1199 * compiler-generated ELF local symbol names such as ".LANCHOR1".
1200 * Autogenerated symbol names bypass modpost's "Pattern 2"
1201 * whitelisting, which relies on pattern-matching against symbol
1202 * names to work. (One situation where gcc can autogenerate ELF
1203 * local symbols is when "-fsection-anchors" is used.)
1205 static int secref_whitelist(const struct sectioncheck *mismatch,
1206 const char *fromsec, const char *fromsym,
1207 const char *tosec, const char *tosym)
1209 /* Check for pattern 1 */
1210 if (match(tosec, init_data_sections) &&
1211 match(fromsec, data_sections) &&
1212 strstarts(fromsym, "__param"))
1215 /* Check for pattern 1a */
1216 if (strcmp(tosec, ".init.text") == 0 &&
1217 match(fromsec, data_sections) &&
1218 strstarts(fromsym, "__param_ops_"))
1221 /* Check for pattern 2 */
1222 if (match(tosec, init_exit_sections) &&
1223 match(fromsec, data_sections) &&
1224 match(fromsym, mismatch->symbol_white_list))
1227 /* Check for pattern 3 */
1228 if (match(fromsec, head_sections) &&
1229 match(tosec, init_sections))
1232 /* Check for pattern 4 */
1233 if (match(tosym, linker_symbols))
1236 /* Check for pattern 5 */
1237 if (match(fromsec, text_sections) &&
1238 match(tosec, init_sections) &&
1239 match(fromsym, optim_symbols))
1242 /* Check for pattern 6 */
1243 if (strstarts(fromsym, ".L"))
1249 static inline int is_arm_mapping_symbol(const char *str)
1251 return str[0] == '$' && strchr("axtd", str[1])
1252 && (str[2] == '\0' || str[2] == '.');
1256 * If there's no name there, ignore it; likewise, ignore it if it's
1257 * one of the magic symbols emitted used by current ARM tools.
1259 * Otherwise if find_symbols_between() returns those symbols, they'll
1260 * fail the whitelist tests and cause lots of false alarms ... fixable
1261 * only by merging __exit and __init sections into __text, bloating
1262 * the kernel (which is especially evil on embedded platforms).
1264 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1266 const char *name = elf->strtab + sym->st_name;
1268 if (!name || !strlen(name))
1270 return !is_arm_mapping_symbol(name);
1274 * Find symbol based on relocation record info.
1275 * In some cases the symbol supplied is a valid symbol so
1276 * return refsym. If st_name != 0 we assume this is a valid symbol.
1277 * In other cases the symbol needs to be looked up in the symbol table
1278 * based on section and address.
1280 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1284 Elf_Sym *near = NULL;
1285 Elf64_Sword distance = 20;
1287 unsigned int relsym_secindex;
1289 if (relsym->st_name != 0)
1292 relsym_secindex = get_secindex(elf, relsym);
1293 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1294 if (get_secindex(elf, sym) != relsym_secindex)
1296 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1298 if (!is_valid_name(elf, sym))
1300 if (sym->st_value == addr)
1302 /* Find a symbol nearby - addr are maybe negative */
1303 d = sym->st_value - addr;
1305 d = addr - sym->st_value;
1311 /* We need a close match */
1319 * Find symbols before or equal addr and after addr - in the section sec.
1320 * If we find two symbols with equal offset prefer one with a valid name.
1321 * The ELF format may have a better way to detect what type of symbol
1322 * it is, but this works for now.
1324 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1328 Elf_Sym *near = NULL;
1329 Elf_Addr distance = ~0;
1331 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1334 if (is_shndx_special(sym->st_shndx))
1336 symsec = sec_name(elf, get_secindex(elf, sym));
1337 if (strcmp(symsec, sec) != 0)
1339 if (!is_valid_name(elf, sym))
1341 if (sym->st_value <= addr) {
1342 if ((addr - sym->st_value) < distance) {
1343 distance = addr - sym->st_value;
1345 } else if ((addr - sym->st_value) == distance) {
1354 * Convert a section name to the function/data attribute
1355 * .init.text => __init
1356 * .memexitconst => __memconst
1359 * The memory of returned value has been allocated on a heap. The user of this
1360 * method should free it after usage.
1362 static char *sec2annotation(const char *s)
1364 if (match(s, init_exit_sections)) {
1365 char *p = NOFAIL(malloc(20));
1372 while (*s && *s != '.')
1377 if (strstr(s, "rodata") != NULL)
1378 strcat(p, "const ");
1379 else if (strstr(s, "data") != NULL)
1385 return NOFAIL(strdup(""));
1389 static int is_function(Elf_Sym *sym)
1392 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1397 static void print_section_list(const char * const list[20])
1399 const char *const *s = list;
1402 fprintf(stderr, "%s", *s);
1405 fprintf(stderr, ", ");
1407 fprintf(stderr, "\n");
1410 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1413 case 0: *name = "variable"; *name_p = ""; break;
1414 case 1: *name = "function"; *name_p = "()"; break;
1415 default: *name = "(unknown reference)"; *name_p = ""; break;
1420 * Print a warning about a section mismatch.
1421 * Try to find symbols near it so user can find it.
1422 * Check whitelist before warning - it may be a false positive.
1424 static void report_sec_mismatch(const char *modname,
1425 const struct sectioncheck *mismatch,
1426 const char *fromsec,
1427 unsigned long long fromaddr,
1428 const char *fromsym,
1430 const char *tosec, const char *tosym,
1433 const char *from, *from_p;
1434 const char *to, *to_p;
1438 sec_mismatch_count++;
1440 get_pretty_name(from_is_func, &from, &from_p);
1441 get_pretty_name(to_is_func, &to, &to_p);
1443 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1444 "to the %s %s:%s%s\n",
1445 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1448 switch (mismatch->mismatch) {
1449 case TEXT_TO_ANY_INIT:
1450 prl_from = sec2annotation(fromsec);
1451 prl_to = sec2annotation(tosec);
1453 "The function %s%s() references\n"
1455 "This is often because %s lacks a %s\n"
1456 "annotation or the annotation of %s is wrong.\n",
1458 to, prl_to, tosym, to_p,
1459 fromsym, prl_to, tosym);
1463 case DATA_TO_ANY_INIT: {
1464 prl_to = sec2annotation(tosec);
1466 "The variable %s references\n"
1468 "If the reference is valid then annotate the\n"
1469 "variable with __init* or __refdata (see linux/init.h) "
1470 "or name the variable:\n",
1471 fromsym, to, prl_to, tosym, to_p);
1472 print_section_list(mismatch->symbol_white_list);
1476 case TEXT_TO_ANY_EXIT:
1477 prl_to = sec2annotation(tosec);
1479 "The function %s() references a %s in an exit section.\n"
1480 "Often the %s %s%s has valid usage outside the exit section\n"
1481 "and the fix is to remove the %sannotation of %s.\n",
1482 fromsym, to, to, tosym, to_p, prl_to, tosym);
1485 case DATA_TO_ANY_EXIT: {
1486 prl_to = sec2annotation(tosec);
1488 "The variable %s references\n"
1490 "If the reference is valid then annotate the\n"
1491 "variable with __exit* (see linux/init.h) or "
1492 "name the variable:\n",
1493 fromsym, to, prl_to, tosym, to_p);
1494 print_section_list(mismatch->symbol_white_list);
1498 case XXXINIT_TO_SOME_INIT:
1499 case XXXEXIT_TO_SOME_EXIT:
1500 prl_from = sec2annotation(fromsec);
1501 prl_to = sec2annotation(tosec);
1503 "The %s %s%s%s references\n"
1505 "If %s is only used by %s then\n"
1506 "annotate %s with a matching annotation.\n",
1507 from, prl_from, fromsym, from_p,
1508 to, prl_to, tosym, to_p,
1509 tosym, fromsym, tosym);
1513 case ANY_INIT_TO_ANY_EXIT:
1514 prl_from = sec2annotation(fromsec);
1515 prl_to = sec2annotation(tosec);
1517 "The %s %s%s%s references\n"
1519 "This is often seen when error handling "
1520 "in the init function\n"
1521 "uses functionality in the exit path.\n"
1522 "The fix is often to remove the %sannotation of\n"
1523 "%s%s so it may be used outside an exit section.\n",
1524 from, prl_from, fromsym, from_p,
1525 to, prl_to, tosym, to_p,
1526 prl_to, tosym, to_p);
1530 case ANY_EXIT_TO_ANY_INIT:
1531 prl_from = sec2annotation(fromsec);
1532 prl_to = sec2annotation(tosec);
1534 "The %s %s%s%s references\n"
1536 "This is often seen when error handling "
1537 "in the exit function\n"
1538 "uses functionality in the init path.\n"
1539 "The fix is often to remove the %sannotation of\n"
1540 "%s%s so it may be used outside an init section.\n",
1541 from, prl_from, fromsym, from_p,
1542 to, prl_to, tosym, to_p,
1543 prl_to, tosym, to_p);
1547 case EXPORT_TO_INIT_EXIT:
1548 prl_to = sec2annotation(tosec);
1550 "The symbol %s is exported and annotated %s\n"
1551 "Fix this by removing the %sannotation of %s "
1552 "or drop the export.\n",
1553 tosym, prl_to, prl_to, tosym);
1556 case EXTABLE_TO_NON_TEXT:
1557 fatal("There's a special handler for this mismatch type, "
1558 "we should never get here.");
1561 fprintf(stderr, "\n");
1564 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1565 const struct sectioncheck* const mismatch,
1566 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1572 const char *fromsym;
1574 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1575 fromsym = sym_name(elf, from);
1577 if (strstarts(fromsym, "reference___initcall"))
1580 tosec = sec_name(elf, get_secindex(elf, sym));
1581 to = find_elf_symbol(elf, r->r_addend, sym);
1582 tosym = sym_name(elf, to);
1584 /* check whitelist - we may ignore it */
1585 if (secref_whitelist(mismatch,
1586 fromsec, fromsym, tosec, tosym)) {
1587 report_sec_mismatch(modname, mismatch,
1588 fromsec, r->r_offset, fromsym,
1589 is_function(from), tosec, tosym,
1594 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1596 if (section_index > elf->num_sections)
1597 fatal("section_index is outside elf->num_sections!\n");
1599 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1603 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1604 * to know the sizeof(struct exception_table_entry) for the target architecture.
1606 static unsigned int extable_entry_size = 0;
1607 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1610 * If we're currently checking the second relocation within __ex_table,
1611 * that relocation offset tells us the offsetof(struct
1612 * exception_table_entry, fixup) which is equal to sizeof(struct
1613 * exception_table_entry) divided by two. We use that to our advantage
1614 * since there's no portable way to get that size as every architecture
1615 * seems to go with different sized types. Not pretty but better than
1616 * hard-coding the size for every architecture..
1618 if (!extable_entry_size)
1619 extable_entry_size = r->r_offset * 2;
1622 static inline bool is_extable_fault_address(Elf_Rela *r)
1625 * extable_entry_size is only discovered after we've handled the
1626 * _second_ relocation in __ex_table, so only abort when we're not
1627 * handling the first reloc and extable_entry_size is zero.
1629 if (r->r_offset && extable_entry_size == 0)
1630 fatal("extable_entry size hasn't been discovered!\n");
1632 return ((r->r_offset == 0) ||
1633 (r->r_offset % extable_entry_size == 0));
1636 #define is_second_extable_reloc(Start, Cur, Sec) \
1637 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1639 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1640 const struct sectioncheck* const mismatch,
1641 Elf_Rela* r, Elf_Sym* sym,
1642 const char* fromsec, const char* tosec)
1644 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1645 const char* fromsym_name = sym_name(elf, fromsym);
1646 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1647 const char* tosym_name = sym_name(elf, tosym);
1648 const char* from_pretty_name;
1649 const char* from_pretty_name_p;
1650 const char* to_pretty_name;
1651 const char* to_pretty_name_p;
1653 get_pretty_name(is_function(fromsym),
1654 &from_pretty_name, &from_pretty_name_p);
1655 get_pretty_name(is_function(tosym),
1656 &to_pretty_name, &to_pretty_name_p);
1658 warn("%s(%s+0x%lx): Section mismatch in reference"
1659 " from the %s %s%s to the %s %s:%s%s\n",
1660 modname, fromsec, (long)r->r_offset, from_pretty_name,
1661 fromsym_name, from_pretty_name_p,
1662 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1664 if (!match(tosec, mismatch->bad_tosec) &&
1665 is_executable_section(elf, get_secindex(elf, sym)))
1667 "The relocation at %s+0x%lx references\n"
1668 "section \"%s\" which is not in the list of\n"
1669 "authorized sections. If you're adding a new section\n"
1670 "and/or if this reference is valid, add \"%s\" to the\n"
1671 "list of authorized sections to jump to on fault.\n"
1672 "This can be achieved by adding \"%s\" to \n"
1673 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1674 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1677 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1678 const struct sectioncheck* const mismatch,
1679 Elf_Rela* r, Elf_Sym* sym,
1680 const char *fromsec)
1682 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1684 sec_mismatch_count++;
1686 report_extable_warnings(modname, elf, mismatch, r, sym, fromsec, tosec);
1688 if (match(tosec, mismatch->bad_tosec))
1689 fatal("The relocation at %s+0x%lx references\n"
1690 "section \"%s\" which is black-listed.\n"
1691 "Something is seriously wrong and should be fixed.\n"
1692 "You might get more information about where this is\n"
1693 "coming from by using scripts/check_extable.sh %s\n",
1694 fromsec, (long)r->r_offset, tosec, modname);
1695 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1696 if (is_extable_fault_address(r))
1697 fatal("The relocation at %s+0x%lx references\n"
1698 "section \"%s\" which is not executable, IOW\n"
1699 "it is not possible for the kernel to fault\n"
1700 "at that address. Something is seriously wrong\n"
1701 "and should be fixed.\n",
1702 fromsec, (long)r->r_offset, tosec);
1704 fatal("The relocation at %s+0x%lx references\n"
1705 "section \"%s\" which is not executable, IOW\n"
1706 "the kernel will fault if it ever tries to\n"
1707 "jump to it. Something is seriously wrong\n"
1708 "and should be fixed.\n",
1709 fromsec, (long)r->r_offset, tosec);
1713 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1714 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1716 const char *tosec = sec_name(elf, get_secindex(elf, sym));
1717 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1720 if (mismatch->handler)
1721 mismatch->handler(modname, elf, mismatch,
1724 default_mismatch_handler(modname, elf, mismatch,
1729 static unsigned int *reloc_location(struct elf_info *elf,
1730 Elf_Shdr *sechdr, Elf_Rela *r)
1732 return sym_get_data_by_offset(elf, sechdr->sh_info, r->r_offset);
1735 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1737 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1738 unsigned int *location = reloc_location(elf, sechdr, r);
1742 r->r_addend = TO_NATIVE(*location);
1745 r->r_addend = TO_NATIVE(*location) + 4;
1746 /* For CONFIG_RELOCATABLE=y */
1747 if (elf->hdr->e_type == ET_EXEC)
1748 r->r_addend += r->r_offset;
1755 #define R_ARM_CALL 28
1757 #ifndef R_ARM_JUMP24
1758 #define R_ARM_JUMP24 29
1761 #ifndef R_ARM_THM_CALL
1762 #define R_ARM_THM_CALL 10
1764 #ifndef R_ARM_THM_JUMP24
1765 #define R_ARM_THM_JUMP24 30
1767 #ifndef R_ARM_THM_JUMP19
1768 #define R_ARM_THM_JUMP19 51
1771 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1773 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1777 /* From ARM ABI: (S + A) | T */
1778 r->r_addend = (int)(long)
1779 (elf->symtab_start + ELF_R_SYM(r->r_info));
1784 case R_ARM_THM_CALL:
1785 case R_ARM_THM_JUMP24:
1786 case R_ARM_THM_JUMP19:
1787 /* From ARM ABI: ((S + A) | T) - P */
1788 r->r_addend = (int)(long)(elf->hdr +
1790 (r->r_offset - sechdr->sh_addr));
1798 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1800 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1801 unsigned int *location = reloc_location(elf, sechdr, r);
1804 if (r_typ == R_MIPS_HI16)
1805 return 1; /* skip this */
1806 inst = TO_NATIVE(*location);
1809 r->r_addend = inst & 0xffff;
1812 r->r_addend = (inst & 0x03ffffff) << 2;
1821 static void section_rela(const char *modname, struct elf_info *elf,
1828 const char *fromsec;
1830 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1831 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1833 fromsec = sech_name(elf, sechdr);
1834 fromsec += strlen(".rela");
1835 /* if from section (name) is know good then skip it */
1836 if (match(fromsec, section_white_list))
1839 for (rela = start; rela < stop; rela++) {
1840 r.r_offset = TO_NATIVE(rela->r_offset);
1841 #if KERNEL_ELFCLASS == ELFCLASS64
1842 if (elf->hdr->e_machine == EM_MIPS) {
1844 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1845 r_sym = TO_NATIVE(r_sym);
1846 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1847 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1849 r.r_info = TO_NATIVE(rela->r_info);
1850 r_sym = ELF_R_SYM(r.r_info);
1853 r.r_info = TO_NATIVE(rela->r_info);
1854 r_sym = ELF_R_SYM(r.r_info);
1856 r.r_addend = TO_NATIVE(rela->r_addend);
1857 sym = elf->symtab_start + r_sym;
1858 /* Skip special sections */
1859 if (is_shndx_special(sym->st_shndx))
1861 if (is_second_extable_reloc(start, rela, fromsec))
1862 find_extable_entry_size(fromsec, &r);
1863 check_section_mismatch(modname, elf, &r, sym, fromsec);
1867 static void section_rel(const char *modname, struct elf_info *elf,
1874 const char *fromsec;
1876 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1877 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1879 fromsec = sech_name(elf, sechdr);
1880 fromsec += strlen(".rel");
1881 /* if from section (name) is know good then skip it */
1882 if (match(fromsec, section_white_list))
1885 for (rel = start; rel < stop; rel++) {
1886 r.r_offset = TO_NATIVE(rel->r_offset);
1887 #if KERNEL_ELFCLASS == ELFCLASS64
1888 if (elf->hdr->e_machine == EM_MIPS) {
1890 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1891 r_sym = TO_NATIVE(r_sym);
1892 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1893 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1895 r.r_info = TO_NATIVE(rel->r_info);
1896 r_sym = ELF_R_SYM(r.r_info);
1899 r.r_info = TO_NATIVE(rel->r_info);
1900 r_sym = ELF_R_SYM(r.r_info);
1903 switch (elf->hdr->e_machine) {
1905 if (addend_386_rel(elf, sechdr, &r))
1909 if (addend_arm_rel(elf, sechdr, &r))
1913 if (addend_mips_rel(elf, sechdr, &r))
1917 sym = elf->symtab_start + r_sym;
1918 /* Skip special sections */
1919 if (is_shndx_special(sym->st_shndx))
1921 if (is_second_extable_reloc(start, rel, fromsec))
1922 find_extable_entry_size(fromsec, &r);
1923 check_section_mismatch(modname, elf, &r, sym, fromsec);
1928 * A module includes a number of sections that are discarded
1929 * either when loaded or when used as built-in.
1930 * For loaded modules all functions marked __init and all data
1931 * marked __initdata will be discarded when the module has been initialized.
1932 * Likewise for modules used built-in the sections marked __exit
1933 * are discarded because __exit marked function are supposed to be called
1934 * only when a module is unloaded which never happens for built-in modules.
1935 * The check_sec_ref() function traverses all relocation records
1936 * to find all references to a section that reference a section that will
1937 * be discarded and warns about it.
1939 static void check_sec_ref(struct module *mod, const char *modname,
1940 struct elf_info *elf)
1943 Elf_Shdr *sechdrs = elf->sechdrs;
1945 /* Walk through all sections */
1946 for (i = 0; i < elf->num_sections; i++) {
1947 check_section(modname, elf, &elf->sechdrs[i]);
1948 /* We want to process only relocation sections and not .init */
1949 if (sechdrs[i].sh_type == SHT_RELA)
1950 section_rela(modname, elf, &elf->sechdrs[i]);
1951 else if (sechdrs[i].sh_type == SHT_REL)
1952 section_rel(modname, elf, &elf->sechdrs[i]);
1956 static char *remove_dot(char *s)
1958 size_t n = strcspn(s, ".");
1961 size_t m = strspn(s + n + 1, "0123456789");
1962 if (m && (s[n + m] == '.' || s[n + m] == 0))
1965 /* strip trailing .lto */
1966 if (strends(s, ".lto"))
1967 s[strlen(s) - 4] = '\0';
1972 static void read_symbols(const char *modname)
1974 const char *symname;
1979 struct elf_info info = { };
1982 if (!parse_elf(&info, modname))
1988 /* strip trailing .o */
1989 tmp = NOFAIL(strdup(modname));
1990 tmp[strlen(tmp) - 2] = '\0';
1991 /* strip trailing .lto */
1992 if (strends(tmp, ".lto"))
1993 tmp[strlen(tmp) - 4] = '\0';
1994 mod = new_module(tmp);
1998 if (!mod->is_vmlinux) {
1999 license = get_modinfo(&info, "license");
2001 error("missing MODULE_LICENSE() in %s\n", modname);
2003 if (license_is_gpl_compatible(license))
2004 mod->gpl_compatible = 1;
2006 mod->gpl_compatible = 0;
2009 license = get_next_modinfo(&info, "license", license);
2012 namespace = get_modinfo(&info, "import_ns");
2014 add_namespace(&mod->imported_namespaces, namespace);
2015 namespace = get_next_modinfo(&info, "import_ns",
2020 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2021 symname = remove_dot(info.strtab + sym->st_name);
2023 handle_symbol(mod, &info, sym, symname);
2024 handle_moddevtable(mod, &info, sym, symname);
2027 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2028 symname = remove_dot(info.strtab + sym->st_name);
2030 /* Apply symbol namespaces from __kstrtabns_<symbol> entries. */
2031 if (strstarts(symname, "__kstrtabns_"))
2032 sym_update_namespace(symname + strlen("__kstrtabns_"),
2033 namespace_from_kstrtabns(&info,
2036 if (strstarts(symname, "__crc_"))
2037 handle_modversion(mod, &info, sym,
2038 symname + strlen("__crc_"));
2041 // check for static EXPORT_SYMBOL_* functions && global vars
2042 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2043 unsigned char bind = ELF_ST_BIND(sym->st_info);
2045 if (bind == STB_GLOBAL || bind == STB_WEAK) {
2047 find_symbol(remove_dot(info.strtab +
2055 check_sec_ref(mod, modname, &info);
2057 if (!mod->is_vmlinux) {
2058 version = get_modinfo(&info, "version");
2059 if (version || all_versions)
2060 get_src_version(modname, mod->srcversion,
2061 sizeof(mod->srcversion) - 1);
2064 parse_elf_finish(&info);
2066 /* Our trick to get versioning for module struct etc. - it's
2067 * never passed as an argument to an exported function, so
2068 * the automatic versioning doesn't pick it up, but it's really
2069 * important anyhow */
2071 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
2074 static void read_symbols_from_files(const char *filename)
2077 char fname[PATH_MAX];
2079 if (strcmp(filename, "-") != 0) {
2080 in = fopen(filename, "r");
2082 fatal("Can't open filenames file %s: %m", filename);
2085 while (fgets(fname, PATH_MAX, in) != NULL) {
2086 if (strends(fname, "\n"))
2087 fname[strlen(fname)-1] = '\0';
2088 read_symbols(fname);
2097 /* We first write the generated file into memory using the
2098 * following helper, then compare to the file on disk and
2099 * only update the later if anything changed */
2101 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2102 const char *fmt, ...)
2109 len = vsnprintf(tmp, SZ, fmt, ap);
2110 buf_write(buf, tmp, len);
2114 void buf_write(struct buffer *buf, const char *s, int len)
2116 if (buf->size - buf->pos < len) {
2117 buf->size += len + SZ;
2118 buf->p = NOFAIL(realloc(buf->p, buf->size));
2120 strncpy(buf->p + buf->pos, s, len);
2124 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2128 error("GPL-incompatible module %s.ko uses GPL-only symbol '%s'\n",
2132 case export_unknown:
2138 static void check_exports(struct module *mod)
2140 struct symbol *s, *exp;
2142 for (s = mod->unres; s; s = s->next) {
2143 const char *basename;
2144 exp = find_symbol(s->name);
2145 if (!exp || exp->module == mod) {
2146 if (!s->weak && nr_unresolved++ < MAX_UNRESOLVED_REPORTS)
2147 modpost_log(warn_unresolved ? LOG_WARN : LOG_ERROR,
2148 "\"%s\" [%s.ko] undefined!\n",
2149 s->name, mod->name);
2152 basename = strrchr(mod->name, '/');
2156 basename = mod->name;
2158 if (exp->namespace &&
2159 !module_imports_namespace(mod, exp->namespace)) {
2160 modpost_log(allow_missing_ns_imports ? LOG_WARN : LOG_ERROR,
2161 "module %s uses symbol %s from namespace %s, but does not import it.\n",
2162 basename, exp->name, exp->namespace);
2163 add_namespace(&mod->missing_namespaces, exp->namespace);
2166 if (!mod->gpl_compatible)
2167 check_for_gpl_usage(exp->export, basename, exp->name);
2171 static void check_modname_len(struct module *mod)
2173 const char *mod_name;
2175 mod_name = strrchr(mod->name, '/');
2176 if (mod_name == NULL)
2177 mod_name = mod->name;
2180 if (strlen(mod_name) >= MODULE_NAME_LEN)
2181 error("module name is too long [%s.ko]\n", mod->name);
2185 * Header for the generated file
2187 static void add_header(struct buffer *b, struct module *mod)
2189 buf_printf(b, "#include <linux/module.h>\n");
2191 * Include build-salt.h after module.h in order to
2192 * inherit the definitions.
2194 buf_printf(b, "#define INCLUDE_VERMAGIC\n");
2195 buf_printf(b, "#include <linux/build-salt.h>\n");
2196 buf_printf(b, "#include <linux/elfnote-lto.h>\n");
2197 buf_printf(b, "#include <linux/vermagic.h>\n");
2198 buf_printf(b, "#include <linux/compiler.h>\n");
2199 buf_printf(b, "\n");
2200 buf_printf(b, "BUILD_SALT;\n");
2201 buf_printf(b, "BUILD_LTO_INFO;\n");
2202 buf_printf(b, "\n");
2203 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2204 buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
2205 buf_printf(b, "\n");
2206 buf_printf(b, "__visible struct module __this_module\n");
2207 buf_printf(b, "__section(\".gnu.linkonce.this_module\") = {\n");
2208 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2210 buf_printf(b, "\t.init = init_module,\n");
2211 if (mod->has_cleanup)
2212 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2213 "\t.exit = cleanup_module,\n"
2215 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2216 buf_printf(b, "};\n");
2219 static void add_intree_flag(struct buffer *b, int is_intree)
2222 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2225 /* Cannot check for assembler */
2226 static void add_retpoline(struct buffer *b)
2228 buf_printf(b, "\n#ifdef CONFIG_RETPOLINE\n");
2229 buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n");
2230 buf_printf(b, "#endif\n");
2233 static void add_staging_flag(struct buffer *b, const char *name)
2235 if (strstarts(name, "drivers/staging"))
2236 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2240 * Record CRCs for unresolved symbols
2242 static void add_versions(struct buffer *b, struct module *mod)
2244 struct symbol *s, *exp;
2246 for (s = mod->unres; s; s = s->next) {
2247 exp = find_symbol(s->name);
2248 if (!exp || exp->module == mod)
2250 s->module = exp->module;
2251 s->crc_valid = exp->crc_valid;
2258 buf_printf(b, "\n");
2259 buf_printf(b, "static const struct modversion_info ____versions[]\n");
2260 buf_printf(b, "__used __section(\"__versions\") = {\n");
2262 for (s = mod->unres; s; s = s->next) {
2265 if (!s->crc_valid) {
2266 warn("\"%s\" [%s.ko] has no CRC!\n",
2267 s->name, mod->name);
2270 if (strlen(s->name) >= MODULE_NAME_LEN) {
2271 error("too long symbol \"%s\" [%s.ko]\n",
2272 s->name, mod->name);
2275 buf_printf(b, "\t{ %#8x, \"%s\" },\n",
2279 buf_printf(b, "};\n");
2282 static void add_depends(struct buffer *b, struct module *mod)
2287 /* Clear ->seen flag of modules that own symbols needed by this. */
2288 for (s = mod->unres; s; s = s->next)
2290 s->module->seen = s->module->is_vmlinux;
2292 buf_printf(b, "\n");
2293 buf_printf(b, "MODULE_INFO(depends, \"");
2294 for (s = mod->unres; s; s = s->next) {
2299 if (s->module->seen)
2302 s->module->seen = 1;
2303 p = strrchr(s->module->name, '/');
2307 p = s->module->name;
2308 buf_printf(b, "%s%s", first ? "" : ",", p);
2311 buf_printf(b, "\");\n");
2314 static void add_srcversion(struct buffer *b, struct module *mod)
2316 if (mod->srcversion[0]) {
2317 buf_printf(b, "\n");
2318 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2323 static void write_buf(struct buffer *b, const char *fname)
2327 file = fopen(fname, "w");
2332 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2336 if (fclose(file) != 0) {
2342 static void write_if_changed(struct buffer *b, const char *fname)
2348 file = fopen(fname, "r");
2352 if (fstat(fileno(file), &st) < 0)
2355 if (st.st_size != b->pos)
2358 tmp = NOFAIL(malloc(b->pos));
2359 if (fread(tmp, 1, b->pos, file) != b->pos)
2362 if (memcmp(tmp, b->p, b->pos) != 0)
2374 write_buf(b, fname);
2377 /* parse Module.symvers file. line format:
2378 * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
2380 static void read_dump(const char *fname)
2382 char *buf, *pos, *line;
2384 buf = read_text_file(fname);
2386 /* No symbol versions, silently ignore */
2391 while ((line = get_line(&pos))) {
2392 char *symname, *namespace, *modname, *d, *export;
2397 if (!(symname = strchr(line, '\t')))
2400 if (!(modname = strchr(symname, '\t')))
2403 if (!(export = strchr(modname, '\t')))
2406 if (!(namespace = strchr(export, '\t')))
2408 *namespace++ = '\0';
2410 crc = strtoul(line, &d, 16);
2411 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2413 mod = find_module(modname);
2415 mod = new_module(modname);
2418 s = sym_add_exported(symname, mod, export_no(export));
2420 sym_set_crc(symname, crc);
2421 sym_update_namespace(symname, namespace);
2427 fatal("parse error in symbol dump file\n");
2430 static void write_dump(const char *fname)
2432 struct buffer buf = { };
2433 struct symbol *symbol;
2434 const char *namespace;
2437 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2438 symbol = symbolhash[n];
2440 if (!symbol->module->from_dump) {
2441 namespace = symbol->namespace;
2442 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\t%s\n",
2443 symbol->crc, symbol->name,
2444 symbol->module->name,
2445 export_str(symbol->export),
2446 namespace ? namespace : "");
2448 symbol = symbol->next;
2451 write_buf(&buf, fname);
2455 static void write_namespace_deps_files(const char *fname)
2458 struct namespace_list *ns;
2459 struct buffer ns_deps_buf = {};
2461 for (mod = modules; mod; mod = mod->next) {
2463 if (mod->from_dump || !mod->missing_namespaces)
2466 buf_printf(&ns_deps_buf, "%s.ko:", mod->name);
2468 for (ns = mod->missing_namespaces; ns; ns = ns->next)
2469 buf_printf(&ns_deps_buf, " %s", ns->namespace);
2471 buf_printf(&ns_deps_buf, "\n");
2474 write_if_changed(&ns_deps_buf, fname);
2475 free(ns_deps_buf.p);
2479 struct dump_list *next;
2483 int main(int argc, char **argv)
2486 struct buffer buf = { };
2487 char *missing_namespace_deps = NULL;
2488 char *dump_write = NULL, *files_source = NULL;
2491 struct dump_list *dump_read_start = NULL;
2492 struct dump_list **dump_read_iter = &dump_read_start;
2494 while ((opt = getopt(argc, argv, "ei:mnT:o:awENd:")) != -1) {
2497 external_module = 1;
2501 NOFAIL(calloc(1, sizeof(**dump_read_iter)));
2502 (*dump_read_iter)->file = optarg;
2503 dump_read_iter = &(*dump_read_iter)->next;
2509 ignore_missing_files = 1;
2512 dump_write = optarg;
2518 files_source = optarg;
2521 warn_unresolved = 1;
2524 sec_mismatch_warn_only = false;
2527 allow_missing_ns_imports = 1;
2530 missing_namespace_deps = optarg;
2537 while (dump_read_start) {
2538 struct dump_list *tmp;
2540 read_dump(dump_read_start->file);
2541 tmp = dump_read_start->next;
2542 free(dump_read_start);
2543 dump_read_start = tmp;
2546 while (optind < argc)
2547 read_symbols(argv[optind++]);
2550 read_symbols_from_files(files_source);
2552 for (mod = modules; mod; mod = mod->next) {
2553 char fname[PATH_MAX];
2555 if (mod->is_vmlinux || mod->from_dump)
2560 check_modname_len(mod);
2563 add_header(&buf, mod);
2564 add_intree_flag(&buf, !external_module);
2565 add_retpoline(&buf);
2566 add_staging_flag(&buf, mod->name);
2567 add_versions(&buf, mod);
2568 add_depends(&buf, mod);
2569 add_moddevtable(&buf, mod);
2570 add_srcversion(&buf, mod);
2572 sprintf(fname, "%s.mod.c", mod->name);
2573 write_if_changed(&buf, fname);
2576 if (missing_namespace_deps)
2577 write_namespace_deps_files(missing_namespace_deps);
2580 write_dump(dump_write);
2581 if (sec_mismatch_count && !sec_mismatch_warn_only)
2582 error("Section mismatches detected.\n"
2583 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2584 for (n = 0; n < SYMBOL_HASH_SIZE; n++) {
2587 for (s = symbolhash[n]; s; s = s->next) {
2589 error("\"%s\" [%s] is a static %s\n",
2590 s->name, s->module->name,
2591 export_str(s->export));
2595 if (nr_unresolved > MAX_UNRESOLVED_REPORTS)
2596 warn("suppressed %u unresolved symbol warnings because there were too many)\n",
2597 nr_unresolved - MAX_UNRESOLVED_REPORTS);
2601 return error_occurred ? 1 : 0;