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 ...
24 #include "../../include/linux/license.h"
25 #include "../../include/linux/module_symbol.h"
27 /* Are we using CONFIG_MODVERSIONS? */
28 static bool modversions;
29 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
30 static bool all_versions;
31 /* If we are modposting external module set to 1 */
32 static bool external_module;
33 /* Only warn about unresolved symbols */
34 static bool warn_unresolved;
36 static int sec_mismatch_count;
37 static bool sec_mismatch_warn_only = true;
38 /* ignore missing files */
39 static bool ignore_missing_files;
40 /* If set to 1, only warn (instead of error) about missing ns imports */
41 static bool allow_missing_ns_imports;
43 static bool error_occurred;
46 * Cut off the warnings when there are too many. This typically occurs when
47 * vmlinux is missing. ('make modules' without building vmlinux.)
49 #define MAX_UNRESOLVED_REPORTS 10
50 static unsigned int nr_unresolved;
52 /* In kernel, this size is defined in linux/module.h;
53 * here we use Elf_Addr instead of long for covering cross-compile
56 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
58 void __attribute__((format(printf, 2, 3)))
59 modpost_log(enum loglevel loglevel, const char *fmt, ...)
65 fprintf(stderr, "WARNING: ");
68 fprintf(stderr, "ERROR: ");
71 fprintf(stderr, "FATAL: ");
73 default: /* invalid loglevel, ignore */
77 fprintf(stderr, "modpost: ");
79 va_start(arglist, fmt);
80 vfprintf(stderr, fmt, arglist);
83 if (loglevel == LOG_FATAL)
85 if (loglevel == LOG_ERROR)
86 error_occurred = true;
89 static inline bool strends(const char *str, const char *postfix)
91 if (strlen(str) < strlen(postfix))
94 return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
97 void *do_nofail(void *ptr, const char *expr)
100 fatal("Memory allocation failure: %s.\n", expr);
105 char *read_text_file(const char *filename)
112 fd = open(filename, O_RDONLY);
118 if (fstat(fd, &st) < 0) {
123 buf = NOFAIL(malloc(st.st_size + 1));
130 bytes_read = read(fd, buf, nbytes);
131 if (bytes_read < 0) {
136 nbytes -= bytes_read;
138 buf[st.st_size] = '\0';
145 char *get_line(char **stringp)
147 char *orig = *stringp, *next;
149 /* do not return the unwanted extra line at EOF */
150 if (!orig || *orig == '\0')
153 /* don't use strsep here, it is not available everywhere */
154 next = strchr(orig, '\n');
163 /* A list of all modules we processed */
166 static struct module *find_module(const char *modname)
170 list_for_each_entry(mod, &modules, list) {
171 if (strcmp(mod->name, modname) == 0)
177 static struct module *new_module(const char *name, size_t namelen)
181 mod = NOFAIL(malloc(sizeof(*mod) + namelen + 1));
182 memset(mod, 0, sizeof(*mod));
184 INIT_LIST_HEAD(&mod->exported_symbols);
185 INIT_LIST_HEAD(&mod->unresolved_symbols);
186 INIT_LIST_HEAD(&mod->missing_namespaces);
187 INIT_LIST_HEAD(&mod->imported_namespaces);
189 memcpy(mod->name, name, namelen);
190 mod->name[namelen] = '\0';
191 mod->is_vmlinux = (strcmp(mod->name, "vmlinux") == 0);
194 * Set mod->is_gpl_compatible to true by default. If MODULE_LICENSE()
195 * is missing, do not check the use for EXPORT_SYMBOL_GPL() becasue
196 * modpost will exit wiht error anyway.
198 mod->is_gpl_compatible = true;
200 list_add_tail(&mod->list, &modules);
205 /* A hash of all exported symbols,
206 * struct symbol is also used for lists of unresolved symbols */
208 #define SYMBOL_HASH_SIZE 1024
212 struct list_head list; /* link to module::exported_symbols or module::unresolved_symbols */
213 struct module *module;
218 bool is_gpl_only; /* exported by EXPORT_SYMBOL_GPL */
222 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
224 /* This is based on the hash algorithm from gdbm, via tdb */
225 static inline unsigned int tdb_hash(const char *name)
227 unsigned value; /* Used to compute the hash value. */
228 unsigned i; /* Used to cycle through random values. */
230 /* Set the initial value from the key size. */
231 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
232 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
234 return (1103515243 * value + 12345);
238 * Allocate a new symbols for use in the hash of exported symbols or
239 * the list of unresolved symbols per module
241 static struct symbol *alloc_symbol(const char *name)
243 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
245 memset(s, 0, sizeof(*s));
246 strcpy(s->name, name);
251 /* For the hash of exported symbols */
252 static void hash_add_symbol(struct symbol *sym)
256 hash = tdb_hash(sym->name) % SYMBOL_HASH_SIZE;
257 sym->next = symbolhash[hash];
258 symbolhash[hash] = sym;
261 static void sym_add_unresolved(const char *name, struct module *mod, bool weak)
265 sym = alloc_symbol(name);
268 list_add_tail(&sym->list, &mod->unresolved_symbols);
271 static struct symbol *sym_find_with_module(const char *name, struct module *mod)
275 /* For our purposes, .foo matches foo. PPC64 needs this. */
279 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
280 if (strcmp(s->name, name) == 0 && (!mod || s->module == mod))
286 static struct symbol *find_symbol(const char *name)
288 return sym_find_with_module(name, NULL);
291 struct namespace_list {
292 struct list_head list;
296 static bool contains_namespace(struct list_head *head, const char *namespace)
298 struct namespace_list *list;
300 list_for_each_entry(list, head, list) {
301 if (!strcmp(list->namespace, namespace))
308 static void add_namespace(struct list_head *head, const char *namespace)
310 struct namespace_list *ns_entry;
312 if (!contains_namespace(head, namespace)) {
313 ns_entry = NOFAIL(malloc(sizeof(*ns_entry) +
314 strlen(namespace) + 1));
315 strcpy(ns_entry->namespace, namespace);
316 list_add_tail(&ns_entry->list, head);
320 static void *sym_get_data_by_offset(const struct elf_info *info,
321 unsigned int secindex, unsigned long offset)
323 Elf_Shdr *sechdr = &info->sechdrs[secindex];
325 return (void *)info->hdr + sechdr->sh_offset + offset;
328 void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym)
330 return sym_get_data_by_offset(info, get_secindex(info, sym),
334 static const char *sech_name(const struct elf_info *info, Elf_Shdr *sechdr)
336 return sym_get_data_by_offset(info, info->secindex_strings,
340 static const char *sec_name(const struct elf_info *info, unsigned int secindex)
343 * If sym->st_shndx is a special section index, there is no
344 * corresponding section header.
345 * Return "" if the index is out of range of info->sechdrs[] array.
347 if (secindex >= info->num_sections)
350 return sech_name(info, &info->sechdrs[secindex]);
353 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
355 static void sym_update_namespace(const char *symname, const char *namespace)
357 struct symbol *s = find_symbol(symname);
360 * That symbol should have been created earlier and thus this is
361 * actually an assertion.
364 error("Could not update namespace(%s) for symbol %s\n",
370 s->namespace = namespace[0] ? NOFAIL(strdup(namespace)) : NULL;
373 static struct symbol *sym_add_exported(const char *name, struct module *mod,
376 struct symbol *s = find_symbol(name);
378 if (s && (!external_module || s->module->is_vmlinux || s->module == mod)) {
379 error("%s: '%s' exported twice. Previous export was in %s%s\n",
380 mod->name, name, s->module->name,
381 s->module->is_vmlinux ? "" : ".ko");
384 s = alloc_symbol(name);
386 s->is_gpl_only = gpl_only;
387 list_add_tail(&s->list, &mod->exported_symbols);
393 static void sym_set_crc(struct symbol *sym, unsigned int crc)
396 sym->crc_valid = true;
399 static void *grab_file(const char *filename, size_t *size)
402 void *map = MAP_FAILED;
405 fd = open(filename, O_RDONLY);
412 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
416 if (map == MAP_FAILED)
421 static void release_file(void *file, size_t size)
426 static int parse_elf(struct elf_info *info, const char *filename)
432 const char *secstrings;
433 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
435 hdr = grab_file(filename, &info->size);
437 if (ignore_missing_files) {
438 fprintf(stderr, "%s: %s (ignored)\n", filename,
446 if (info->size < sizeof(*hdr)) {
447 /* file too small, assume this is an empty .o file */
450 /* Is this a valid ELF file? */
451 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
452 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
453 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
454 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
455 /* Not an ELF file - silently ignore it */
458 /* Fix endianness in ELF header */
459 hdr->e_type = TO_NATIVE(hdr->e_type);
460 hdr->e_machine = TO_NATIVE(hdr->e_machine);
461 hdr->e_version = TO_NATIVE(hdr->e_version);
462 hdr->e_entry = TO_NATIVE(hdr->e_entry);
463 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
464 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
465 hdr->e_flags = TO_NATIVE(hdr->e_flags);
466 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
467 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
468 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
469 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
470 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
471 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
472 sechdrs = (void *)hdr + hdr->e_shoff;
473 info->sechdrs = sechdrs;
475 /* modpost only works for relocatable objects */
476 if (hdr->e_type != ET_REL)
477 fatal("%s: not relocatable object.", filename);
479 /* Check if file offset is correct */
480 if (hdr->e_shoff > info->size) {
481 fatal("section header offset=%lu in file '%s' is bigger than filesize=%zu\n",
482 (unsigned long)hdr->e_shoff, filename, info->size);
486 if (hdr->e_shnum == SHN_UNDEF) {
488 * There are more than 64k sections,
489 * read count from .sh_size.
491 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
494 info->num_sections = hdr->e_shnum;
496 if (hdr->e_shstrndx == SHN_XINDEX) {
497 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
500 info->secindex_strings = hdr->e_shstrndx;
503 /* Fix endianness in section headers */
504 for (i = 0; i < info->num_sections; i++) {
505 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
506 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
507 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
508 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
509 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
510 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
511 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
512 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
513 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
514 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
516 /* Find symbol table. */
517 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
518 for (i = 1; i < info->num_sections; i++) {
520 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
522 if (!nobits && sechdrs[i].sh_offset > info->size) {
523 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > sizeof(*hrd)=%zu\n",
524 filename, (unsigned long)sechdrs[i].sh_offset,
528 secname = secstrings + sechdrs[i].sh_name;
529 if (strcmp(secname, ".modinfo") == 0) {
531 fatal("%s has NOBITS .modinfo\n", filename);
532 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
533 info->modinfo_len = sechdrs[i].sh_size;
536 if (sechdrs[i].sh_type == SHT_SYMTAB) {
537 unsigned int sh_link_idx;
539 info->symtab_start = (void *)hdr +
540 sechdrs[i].sh_offset;
541 info->symtab_stop = (void *)hdr +
542 sechdrs[i].sh_offset + sechdrs[i].sh_size;
543 sh_link_idx = sechdrs[i].sh_link;
544 info->strtab = (void *)hdr +
545 sechdrs[sh_link_idx].sh_offset;
548 /* 32bit section no. table? ("more than 64k sections") */
549 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
550 symtab_shndx_idx = i;
551 info->symtab_shndx_start = (void *)hdr +
552 sechdrs[i].sh_offset;
553 info->symtab_shndx_stop = (void *)hdr +
554 sechdrs[i].sh_offset + sechdrs[i].sh_size;
557 if (!info->symtab_start)
558 fatal("%s has no symtab?\n", filename);
560 /* Fix endianness in symbols */
561 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
562 sym->st_shndx = TO_NATIVE(sym->st_shndx);
563 sym->st_name = TO_NATIVE(sym->st_name);
564 sym->st_value = TO_NATIVE(sym->st_value);
565 sym->st_size = TO_NATIVE(sym->st_size);
568 if (symtab_shndx_idx != ~0U) {
570 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
571 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
572 filename, sechdrs[symtab_shndx_idx].sh_link,
575 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
583 static void parse_elf_finish(struct elf_info *info)
585 release_file(info->hdr, info->size);
588 static int ignore_undef_symbol(struct elf_info *info, const char *symname)
590 /* ignore __this_module, it will be resolved shortly */
591 if (strcmp(symname, "__this_module") == 0)
593 /* ignore global offset table */
594 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
596 if (info->hdr->e_machine == EM_PPC)
597 /* Special register function linked on all modules during final link of .ko */
598 if (strstarts(symname, "_restgpr_") ||
599 strstarts(symname, "_savegpr_") ||
600 strstarts(symname, "_rest32gpr_") ||
601 strstarts(symname, "_save32gpr_") ||
602 strstarts(symname, "_restvr_") ||
603 strstarts(symname, "_savevr_"))
605 if (info->hdr->e_machine == EM_PPC64)
606 /* Special register function linked on all modules during final link of .ko */
607 if (strstarts(symname, "_restgpr0_") ||
608 strstarts(symname, "_savegpr0_") ||
609 strstarts(symname, "_restvr_") ||
610 strstarts(symname, "_savevr_") ||
611 strcmp(symname, ".TOC.") == 0)
614 if (info->hdr->e_machine == EM_S390)
615 /* Expoline thunks are linked on all kernel modules during final link of .ko */
616 if (strstarts(symname, "__s390_indirect_jump_r"))
618 /* Do not ignore this symbol */
622 static void handle_symbol(struct module *mod, struct elf_info *info,
623 const Elf_Sym *sym, const char *symname)
625 switch (sym->st_shndx) {
627 if (strstarts(symname, "__gnu_lto_")) {
628 /* Should warn here, but modpost runs before the linker */
630 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
633 /* undefined symbol */
634 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
635 ELF_ST_BIND(sym->st_info) != STB_WEAK)
637 if (ignore_undef_symbol(info, symname))
639 if (info->hdr->e_machine == EM_SPARC ||
640 info->hdr->e_machine == EM_SPARCV9) {
641 /* Ignore register directives. */
642 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
644 if (symname[0] == '.') {
645 char *munged = NOFAIL(strdup(symname));
647 munged[1] = toupper(munged[1]);
652 sym_add_unresolved(symname, mod,
653 ELF_ST_BIND(sym->st_info) == STB_WEAK);
656 /* All exported symbols */
657 if (strstarts(symname, "__ksymtab_")) {
658 const char *name, *secname;
660 name = symname + strlen("__ksymtab_");
661 secname = sec_name(info, get_secindex(info, sym));
663 if (strstarts(secname, "___ksymtab_gpl+"))
664 sym_add_exported(name, mod, true);
665 else if (strstarts(secname, "___ksymtab+"))
666 sym_add_exported(name, mod, false);
668 if (strcmp(symname, "init_module") == 0)
669 mod->has_init = true;
670 if (strcmp(symname, "cleanup_module") == 0)
671 mod->has_cleanup = true;
677 * Parse tag=value strings from .modinfo section
679 static char *next_string(char *string, unsigned long *secsize)
681 /* Skip non-zero chars */
684 if ((*secsize)-- <= 1)
688 /* Skip any zero padding. */
691 if ((*secsize)-- <= 1)
697 static char *get_next_modinfo(struct elf_info *info, const char *tag,
701 unsigned int taglen = strlen(tag);
702 char *modinfo = info->modinfo;
703 unsigned long size = info->modinfo_len;
706 size -= prev - modinfo;
707 modinfo = next_string(prev, &size);
710 for (p = modinfo; p; p = next_string(p, &size)) {
711 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
712 return p + taglen + 1;
717 static char *get_modinfo(struct elf_info *info, const char *tag)
720 return get_next_modinfo(info, tag, NULL);
723 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
726 return elf->strtab + sym->st_name;
732 * Check whether the 'string' argument matches one of the 'patterns',
733 * an array of shell wildcard patterns (glob).
735 * Return true is there is a match.
737 static bool match(const char *string, const char *const patterns[])
741 while ((pattern = *patterns++)) {
742 if (!fnmatch(pattern, string, 0))
749 /* useful to pass patterns to match() directly */
750 #define PATTERNS(...) \
752 static const char *const patterns[] = {__VA_ARGS__, NULL}; \
756 /* sections that we do not want to do full section mismatch check on */
757 static const char *const section_white_list[] =
761 ".zdebug*", /* Compressed debug sections. */
762 ".GCC.command.line", /* record-gcc-switches */
763 ".mdebug*", /* alpha, score, mips etc. */
764 ".pdr", /* alpha, score, mips etc. */
769 ".xt.prop", /* xtensa */
770 ".xt.lit", /* xtensa */
771 ".arcextmap*", /* arc */
772 ".gnu.linkonce.arcext*", /* arc : modules */
773 ".cmem*", /* EZchip */
774 ".fmt_slot*", /* EZchip */
781 * This is used to find sections missing the SHF_ALLOC flag.
782 * The cause of this is often a section specified in assembler
783 * without "ax" / "aw".
785 static void check_section(const char *modname, struct elf_info *elf,
788 const char *sec = sech_name(elf, sechdr);
790 if (sechdr->sh_type == SHT_PROGBITS &&
791 !(sechdr->sh_flags & SHF_ALLOC) &&
792 !match(sec, section_white_list)) {
793 warn("%s (%s): unexpected non-allocatable section.\n"
794 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
795 "Note that for example <linux/init.h> contains\n"
796 "section definitions for use in .S files.\n\n",
803 #define ALL_INIT_DATA_SECTIONS \
804 ".init.setup", ".init.rodata", ".meminit.rodata", \
805 ".init.data", ".meminit.data"
806 #define ALL_EXIT_DATA_SECTIONS \
807 ".exit.data", ".memexit.data"
809 #define ALL_INIT_TEXT_SECTIONS \
810 ".init.text", ".meminit.text"
811 #define ALL_EXIT_TEXT_SECTIONS \
812 ".exit.text", ".memexit.text"
814 #define ALL_PCI_INIT_SECTIONS \
815 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
816 ".pci_fixup_enable", ".pci_fixup_resume", \
817 ".pci_fixup_resume_early", ".pci_fixup_suspend"
819 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
820 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
822 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
823 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
825 #define DATA_SECTIONS ".data", ".data.rel"
826 #define TEXT_SECTIONS ".text", ".text.*", ".sched.text", \
827 ".kprobes.text", ".cpuidle.text", ".noinstr.text"
828 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
829 ".fixup", ".entry.text", ".exception.text", \
830 ".coldtext", ".softirqentry.text"
832 #define INIT_SECTIONS ".init.*"
833 #define MEM_INIT_SECTIONS ".meminit.*"
835 #define EXIT_SECTIONS ".exit.*"
836 #define MEM_EXIT_SECTIONS ".memexit.*"
838 #define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
839 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
841 /* init data sections */
842 static const char *const init_data_sections[] =
843 { ALL_INIT_DATA_SECTIONS, NULL };
845 /* all init sections */
846 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
848 /* all text sections */
849 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
852 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
854 static const char *const head_sections[] = { ".head.text*", NULL };
855 static const char *const linker_symbols[] =
856 { "__init_begin", "_sinittext", "_einittext", NULL };
857 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
864 XXXINIT_TO_SOME_INIT,
865 XXXEXIT_TO_SOME_EXIT,
866 ANY_INIT_TO_ANY_EXIT,
867 ANY_EXIT_TO_ANY_INIT,
873 * Describe how to match sections on different criteria:
875 * @fromsec: Array of sections to be matched.
877 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
878 * this array is forbidden (black-list). Can be empty.
880 * @good_tosec: Relocations applied to a section in @fromsec must be
881 * targeting sections in this array (white-list). Can be empty.
883 * @mismatch: Type of mismatch.
885 * @handler: Specific handler to call when a match is found. If NULL,
886 * default_mismatch_handler() will be called.
889 struct sectioncheck {
890 const char *fromsec[20];
891 const char *bad_tosec[20];
892 const char *good_tosec[20];
893 enum mismatch mismatch;
894 void (*handler)(const char *modname, struct elf_info *elf,
895 const struct sectioncheck* const mismatch,
896 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
900 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
901 const struct sectioncheck* const mismatch,
902 Elf_Rela *r, Elf_Sym *sym,
903 const char *fromsec);
905 static const struct sectioncheck sectioncheck[] = {
906 /* Do not reference init/exit code/data from
907 * normal code and data
910 .fromsec = { TEXT_SECTIONS, NULL },
911 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
912 .mismatch = TEXT_TO_ANY_INIT,
915 .fromsec = { DATA_SECTIONS, NULL },
916 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
917 .mismatch = DATA_TO_ANY_INIT,
920 .fromsec = { DATA_SECTIONS, NULL },
921 .bad_tosec = { INIT_SECTIONS, NULL },
922 .mismatch = DATA_TO_ANY_INIT,
925 .fromsec = { TEXT_SECTIONS, NULL },
926 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
927 .mismatch = TEXT_TO_ANY_EXIT,
930 .fromsec = { DATA_SECTIONS, NULL },
931 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
932 .mismatch = DATA_TO_ANY_EXIT,
934 /* Do not reference init code/data from meminit code/data */
936 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
937 .bad_tosec = { INIT_SECTIONS, NULL },
938 .mismatch = XXXINIT_TO_SOME_INIT,
940 /* Do not reference exit code/data from memexit code/data */
942 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
943 .bad_tosec = { EXIT_SECTIONS, NULL },
944 .mismatch = XXXEXIT_TO_SOME_EXIT,
946 /* Do not use exit code/data from init code */
948 .fromsec = { ALL_INIT_SECTIONS, NULL },
949 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
950 .mismatch = ANY_INIT_TO_ANY_EXIT,
952 /* Do not use init code/data from exit code */
954 .fromsec = { ALL_EXIT_SECTIONS, NULL },
955 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
956 .mismatch = ANY_EXIT_TO_ANY_INIT,
959 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
960 .bad_tosec = { INIT_SECTIONS, NULL },
961 .mismatch = ANY_INIT_TO_ANY_EXIT,
963 /* Do not export init/exit functions or data */
965 .fromsec = { "___ksymtab*", NULL },
966 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
967 .mismatch = EXPORT_TO_INIT_EXIT,
970 .fromsec = { "__ex_table", NULL },
971 /* If you're adding any new black-listed sections in here, consider
972 * adding a special 'printer' for them in scripts/check_extable.
974 .bad_tosec = { ".altinstr_replacement", NULL },
975 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
976 .mismatch = EXTABLE_TO_NON_TEXT,
977 .handler = extable_mismatch_handler,
981 static const struct sectioncheck *section_mismatch(
982 const char *fromsec, const char *tosec)
987 * The target section could be the SHT_NUL section when we're
988 * handling relocations to un-resolved symbols, trying to match it
989 * doesn't make much sense and causes build failures on parisc
995 for (i = 0; i < ARRAY_SIZE(sectioncheck); i++) {
996 const struct sectioncheck *check = §ioncheck[i];
998 if (match(fromsec, check->fromsec)) {
999 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1001 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1009 * Whitelist to allow certain references to pass with no warning.
1012 * If a module parameter is declared __initdata and permissions=0
1013 * then this is legal despite the warning generated.
1014 * We cannot see value of permissions here, so just ignore
1016 * The pattern is identified by:
1017 * tosec = .init.data
1022 * module_param_call() ops can refer to __init set function if permissions=0
1023 * The pattern is identified by:
1024 * tosec = .init.text
1026 * atsym = __param_ops_*
1029 * Whitelist all references from .head.text to any init section
1032 * Some symbols belong to init section but still it is ok to reference
1033 * these from non-init sections as these symbols don't have any memory
1034 * allocated for them and symbol address and value are same. So even
1035 * if init section is freed, its ok to reference those symbols.
1036 * For ex. symbols marking the init section boundaries.
1037 * This pattern is identified by
1038 * refsymname = __init_begin, _sinittext, _einittext
1041 * GCC may optimize static inlines when fed constant arg(s) resulting
1042 * in functions like cpumask_empty() -- generating an associated symbol
1043 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1044 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1045 * meaningless section warning. May need to add isra symbols too...
1046 * This pattern is identified by
1047 * tosec = init section
1048 * fromsec = text section
1049 * refsymname = *.constprop.*
1052 * Hide section mismatch warnings for ELF local symbols. The goal
1053 * is to eliminate false positive modpost warnings caused by
1054 * compiler-generated ELF local symbol names such as ".LANCHOR1".
1055 * Autogenerated symbol names bypass modpost's "Pattern 2"
1056 * whitelisting, which relies on pattern-matching against symbol
1057 * names to work. (One situation where gcc can autogenerate ELF
1058 * local symbols is when "-fsection-anchors" is used.)
1060 static int secref_whitelist(const struct sectioncheck *mismatch,
1061 const char *fromsec, const char *fromsym,
1062 const char *tosec, const char *tosym)
1064 /* Check for pattern 1 */
1065 if (match(tosec, init_data_sections) &&
1066 match(fromsec, data_sections) &&
1067 strstarts(fromsym, "__param"))
1070 /* Check for pattern 1a */
1071 if (strcmp(tosec, ".init.text") == 0 &&
1072 match(fromsec, data_sections) &&
1073 strstarts(fromsym, "__param_ops_"))
1076 /* symbols in data sections that may refer to any init/exit sections */
1077 if (match(fromsec, PATTERNS(DATA_SECTIONS)) &&
1078 match(tosec, PATTERNS(ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS)) &&
1079 match(fromsym, PATTERNS("*_template", // scsi uses *_template a lot
1080 "*_timer", // arm uses ops structures named _timer a lot
1081 "*_sht", // scsi also used *_sht to some extent
1088 /* symbols in data sections that may refer to meminit/exit sections */
1089 if (match(fromsec, PATTERNS(DATA_SECTIONS)) &&
1090 match(tosec, PATTERNS(ALL_XXXINIT_SECTIONS, ALL_EXIT_SECTIONS)) &&
1091 match(fromsym, PATTERNS("*driver")))
1094 /* Check for pattern 3 */
1095 if (match(fromsec, head_sections) &&
1096 match(tosec, init_sections))
1099 /* Check for pattern 4 */
1100 if (match(tosym, linker_symbols))
1103 /* Check for pattern 5 */
1104 if (match(fromsec, text_sections) &&
1105 match(tosec, init_sections) &&
1106 match(fromsym, optim_symbols))
1109 /* Check for pattern 6 */
1110 if (strstarts(fromsym, ".L"))
1117 * If there's no name there, ignore it; likewise, ignore it if it's
1118 * one of the magic symbols emitted used by current tools.
1120 * Otherwise if find_symbols_between() returns those symbols, they'll
1121 * fail the whitelist tests and cause lots of false alarms ... fixable
1122 * only by merging __exit and __init sections into __text, bloating
1123 * the kernel (which is especially evil on embedded platforms).
1125 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1127 const char *name = elf->strtab + sym->st_name;
1129 if (!name || !strlen(name))
1131 return !is_mapping_symbol(name);
1135 * Find symbol based on relocation record info.
1136 * In some cases the symbol supplied is a valid symbol so
1137 * return refsym. If st_name != 0 we assume this is a valid symbol.
1138 * In other cases the symbol needs to be looked up in the symbol table
1139 * based on section and address.
1141 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1145 Elf_Sym *near = NULL;
1146 Elf64_Sword distance = 20;
1148 unsigned int relsym_secindex;
1150 if (relsym->st_name != 0)
1153 relsym_secindex = get_secindex(elf, relsym);
1154 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1155 if (get_secindex(elf, sym) != relsym_secindex)
1157 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1159 if (!is_valid_name(elf, sym))
1161 if (sym->st_value == addr)
1163 /* Find a symbol nearby - addr are maybe negative */
1164 d = sym->st_value - addr;
1166 d = addr - sym->st_value;
1172 /* We need a close match */
1180 * Find symbols before or equal addr and after addr - in the section sec.
1181 * If we find two symbols with equal offset prefer one with a valid name.
1182 * The ELF format may have a better way to detect what type of symbol
1183 * it is, but this works for now.
1185 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1189 Elf_Sym *near = NULL;
1190 Elf_Addr distance = ~0;
1192 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1195 if (is_shndx_special(sym->st_shndx))
1197 symsec = sec_name(elf, get_secindex(elf, sym));
1198 if (strcmp(symsec, sec) != 0)
1200 if (!is_valid_name(elf, sym))
1202 if (sym->st_value <= addr && addr - sym->st_value <= distance) {
1203 distance = addr - sym->st_value;
1210 static int is_function(Elf_Sym *sym)
1213 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1218 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1221 case 0: *name = "variable"; *name_p = ""; break;
1222 case 1: *name = "function"; *name_p = "()"; break;
1223 default: *name = "(unknown reference)"; *name_p = ""; break;
1228 * Print a warning about a section mismatch.
1229 * Try to find symbols near it so user can find it.
1230 * Check whitelist before warning - it may be a false positive.
1232 static void report_sec_mismatch(const char *modname,
1233 const struct sectioncheck *mismatch,
1234 const char *fromsec,
1235 const char *fromsym,
1236 const char *tosec, const char *tosym)
1238 sec_mismatch_count++;
1240 switch (mismatch->mismatch) {
1241 case TEXT_TO_ANY_INIT:
1242 case DATA_TO_ANY_INIT:
1243 case TEXT_TO_ANY_EXIT:
1244 case DATA_TO_ANY_EXIT:
1245 case XXXINIT_TO_SOME_INIT:
1246 case XXXEXIT_TO_SOME_EXIT:
1247 case ANY_INIT_TO_ANY_EXIT:
1248 case ANY_EXIT_TO_ANY_INIT:
1249 warn("%s: section mismatch in reference: %s (section: %s) -> %s (section: %s)\n",
1250 modname, fromsym, fromsec, tosym, tosec);
1252 case EXPORT_TO_INIT_EXIT:
1253 warn("%s: EXPORT_SYMBOL used for init/exit symbol: %s (section: %s)\n",
1254 modname, tosym, tosec);
1256 case EXTABLE_TO_NON_TEXT:
1257 fatal("There's a special handler for this mismatch type, we should never get here.\n");
1262 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1263 const struct sectioncheck* const mismatch,
1264 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1270 const char *fromsym;
1272 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1273 fromsym = sym_name(elf, from);
1275 tosec = sec_name(elf, get_secindex(elf, sym));
1276 to = find_elf_symbol(elf, r->r_addend, sym);
1277 tosym = sym_name(elf, to);
1279 /* check whitelist - we may ignore it */
1280 if (secref_whitelist(mismatch,
1281 fromsec, fromsym, tosec, tosym)) {
1282 report_sec_mismatch(modname, mismatch,
1283 fromsec, fromsym, tosec, tosym);
1287 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1289 if (section_index > elf->num_sections)
1290 fatal("section_index is outside elf->num_sections!\n");
1292 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1296 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1297 * to know the sizeof(struct exception_table_entry) for the target architecture.
1299 static unsigned int extable_entry_size = 0;
1300 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1303 * If we're currently checking the second relocation within __ex_table,
1304 * that relocation offset tells us the offsetof(struct
1305 * exception_table_entry, fixup) which is equal to sizeof(struct
1306 * exception_table_entry) divided by two. We use that to our advantage
1307 * since there's no portable way to get that size as every architecture
1308 * seems to go with different sized types. Not pretty but better than
1309 * hard-coding the size for every architecture..
1311 if (!extable_entry_size)
1312 extable_entry_size = r->r_offset * 2;
1315 static inline bool is_extable_fault_address(Elf_Rela *r)
1318 * extable_entry_size is only discovered after we've handled the
1319 * _second_ relocation in __ex_table, so only abort when we're not
1320 * handling the first reloc and extable_entry_size is zero.
1322 if (r->r_offset && extable_entry_size == 0)
1323 fatal("extable_entry size hasn't been discovered!\n");
1325 return ((r->r_offset == 0) ||
1326 (r->r_offset % extable_entry_size == 0));
1329 #define is_second_extable_reloc(Start, Cur, Sec) \
1330 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1332 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1333 const struct sectioncheck* const mismatch,
1334 Elf_Rela* r, Elf_Sym* sym,
1335 const char* fromsec, const char* tosec)
1337 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1338 const char* fromsym_name = sym_name(elf, fromsym);
1339 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1340 const char* tosym_name = sym_name(elf, tosym);
1341 const char* from_pretty_name;
1342 const char* from_pretty_name_p;
1343 const char* to_pretty_name;
1344 const char* to_pretty_name_p;
1346 get_pretty_name(is_function(fromsym),
1347 &from_pretty_name, &from_pretty_name_p);
1348 get_pretty_name(is_function(tosym),
1349 &to_pretty_name, &to_pretty_name_p);
1351 warn("%s(%s+0x%lx): Section mismatch in reference from the %s %s%s to the %s %s:%s%s\n",
1352 modname, fromsec, (long)r->r_offset, from_pretty_name,
1353 fromsym_name, from_pretty_name_p,
1354 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1356 if (!match(tosec, mismatch->bad_tosec) &&
1357 is_executable_section(elf, get_secindex(elf, sym)))
1359 "The relocation at %s+0x%lx references\n"
1360 "section \"%s\" which is not in the list of\n"
1361 "authorized sections. If you're adding a new section\n"
1362 "and/or if this reference is valid, add \"%s\" to the\n"
1363 "list of authorized sections to jump to on fault.\n"
1364 "This can be achieved by adding \"%s\" to \n"
1365 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1366 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1369 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1370 const struct sectioncheck* const mismatch,
1371 Elf_Rela* r, Elf_Sym* sym,
1372 const char *fromsec)
1374 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1376 sec_mismatch_count++;
1378 report_extable_warnings(modname, elf, mismatch, r, sym, fromsec, tosec);
1380 if (match(tosec, mismatch->bad_tosec))
1381 fatal("The relocation at %s+0x%lx references\n"
1382 "section \"%s\" which is black-listed.\n"
1383 "Something is seriously wrong and should be fixed.\n"
1384 "You might get more information about where this is\n"
1385 "coming from by using scripts/check_extable.sh %s\n",
1386 fromsec, (long)r->r_offset, tosec, modname);
1387 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1388 if (is_extable_fault_address(r))
1389 fatal("The relocation at %s+0x%lx references\n"
1390 "section \"%s\" which is not executable, IOW\n"
1391 "it is not possible for the kernel to fault\n"
1392 "at that address. Something is seriously wrong\n"
1393 "and should be fixed.\n",
1394 fromsec, (long)r->r_offset, tosec);
1396 fatal("The relocation at %s+0x%lx references\n"
1397 "section \"%s\" which is not executable, IOW\n"
1398 "the kernel will fault if it ever tries to\n"
1399 "jump to it. Something is seriously wrong\n"
1400 "and should be fixed.\n",
1401 fromsec, (long)r->r_offset, tosec);
1405 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1406 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1408 const char *tosec = sec_name(elf, get_secindex(elf, sym));
1409 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1412 if (mismatch->handler)
1413 mismatch->handler(modname, elf, mismatch,
1416 default_mismatch_handler(modname, elf, mismatch,
1421 static unsigned int *reloc_location(struct elf_info *elf,
1422 Elf_Shdr *sechdr, Elf_Rela *r)
1424 return sym_get_data_by_offset(elf, sechdr->sh_info, r->r_offset);
1427 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1429 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1430 unsigned int *location = reloc_location(elf, sechdr, r);
1434 r->r_addend = TO_NATIVE(*location);
1437 r->r_addend = TO_NATIVE(*location) + 4;
1444 #define R_ARM_CALL 28
1446 #ifndef R_ARM_JUMP24
1447 #define R_ARM_JUMP24 29
1450 #ifndef R_ARM_THM_CALL
1451 #define R_ARM_THM_CALL 10
1453 #ifndef R_ARM_THM_JUMP24
1454 #define R_ARM_THM_JUMP24 30
1456 #ifndef R_ARM_THM_JUMP19
1457 #define R_ARM_THM_JUMP19 51
1460 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1462 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1466 /* From ARM ABI: (S + A) | T */
1467 r->r_addend = (int)(long)
1468 (elf->symtab_start + ELF_R_SYM(r->r_info));
1473 case R_ARM_THM_CALL:
1474 case R_ARM_THM_JUMP24:
1475 case R_ARM_THM_JUMP19:
1476 /* From ARM ABI: ((S + A) | T) - P */
1477 r->r_addend = (int)(long)(elf->hdr +
1479 (r->r_offset - sechdr->sh_addr));
1487 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1489 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1490 unsigned int *location = reloc_location(elf, sechdr, r);
1493 if (r_typ == R_MIPS_HI16)
1494 return 1; /* skip this */
1495 inst = TO_NATIVE(*location);
1498 r->r_addend = inst & 0xffff;
1501 r->r_addend = (inst & 0x03ffffff) << 2;
1511 #define EM_RISCV 243
1514 #ifndef R_RISCV_SUB32
1515 #define R_RISCV_SUB32 39
1518 #ifndef EM_LOONGARCH
1519 #define EM_LOONGARCH 258
1522 #ifndef R_LARCH_SUB32
1523 #define R_LARCH_SUB32 55
1526 static void section_rela(const char *modname, struct elf_info *elf,
1533 const char *fromsec;
1535 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1536 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1538 fromsec = sec_name(elf, sechdr->sh_info);
1539 /* if from section (name) is know good then skip it */
1540 if (match(fromsec, section_white_list))
1543 for (rela = start; rela < stop; rela++) {
1544 r.r_offset = TO_NATIVE(rela->r_offset);
1545 #if KERNEL_ELFCLASS == ELFCLASS64
1546 if (elf->hdr->e_machine == EM_MIPS) {
1548 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1549 r_sym = TO_NATIVE(r_sym);
1550 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1551 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1553 r.r_info = TO_NATIVE(rela->r_info);
1554 r_sym = ELF_R_SYM(r.r_info);
1557 r.r_info = TO_NATIVE(rela->r_info);
1558 r_sym = ELF_R_SYM(r.r_info);
1560 r.r_addend = TO_NATIVE(rela->r_addend);
1561 switch (elf->hdr->e_machine) {
1563 if (!strcmp("__ex_table", fromsec) &&
1564 ELF_R_TYPE(r.r_info) == R_RISCV_SUB32)
1568 if (!strcmp("__ex_table", fromsec) &&
1569 ELF_R_TYPE(r.r_info) == R_LARCH_SUB32)
1573 sym = elf->symtab_start + r_sym;
1574 /* Skip special sections */
1575 if (is_shndx_special(sym->st_shndx))
1577 if (is_second_extable_reloc(start, rela, fromsec))
1578 find_extable_entry_size(fromsec, &r);
1579 check_section_mismatch(modname, elf, &r, sym, fromsec);
1583 static void section_rel(const char *modname, struct elf_info *elf,
1590 const char *fromsec;
1592 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1593 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1595 fromsec = sec_name(elf, sechdr->sh_info);
1596 /* if from section (name) is know good then skip it */
1597 if (match(fromsec, section_white_list))
1600 for (rel = start; rel < stop; rel++) {
1601 r.r_offset = TO_NATIVE(rel->r_offset);
1602 #if KERNEL_ELFCLASS == ELFCLASS64
1603 if (elf->hdr->e_machine == EM_MIPS) {
1605 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1606 r_sym = TO_NATIVE(r_sym);
1607 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1608 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1610 r.r_info = TO_NATIVE(rel->r_info);
1611 r_sym = ELF_R_SYM(r.r_info);
1614 r.r_info = TO_NATIVE(rel->r_info);
1615 r_sym = ELF_R_SYM(r.r_info);
1618 switch (elf->hdr->e_machine) {
1620 if (addend_386_rel(elf, sechdr, &r))
1624 if (addend_arm_rel(elf, sechdr, &r))
1628 if (addend_mips_rel(elf, sechdr, &r))
1632 sym = elf->symtab_start + r_sym;
1633 /* Skip special sections */
1634 if (is_shndx_special(sym->st_shndx))
1636 if (is_second_extable_reloc(start, rel, fromsec))
1637 find_extable_entry_size(fromsec, &r);
1638 check_section_mismatch(modname, elf, &r, sym, fromsec);
1643 * A module includes a number of sections that are discarded
1644 * either when loaded or when used as built-in.
1645 * For loaded modules all functions marked __init and all data
1646 * marked __initdata will be discarded when the module has been initialized.
1647 * Likewise for modules used built-in the sections marked __exit
1648 * are discarded because __exit marked function are supposed to be called
1649 * only when a module is unloaded which never happens for built-in modules.
1650 * The check_sec_ref() function traverses all relocation records
1651 * to find all references to a section that reference a section that will
1652 * be discarded and warns about it.
1654 static void check_sec_ref(const char *modname, struct elf_info *elf)
1657 Elf_Shdr *sechdrs = elf->sechdrs;
1659 /* Walk through all sections */
1660 for (i = 0; i < elf->num_sections; i++) {
1661 check_section(modname, elf, &elf->sechdrs[i]);
1662 /* We want to process only relocation sections and not .init */
1663 if (sechdrs[i].sh_type == SHT_RELA)
1664 section_rela(modname, elf, &elf->sechdrs[i]);
1665 else if (sechdrs[i].sh_type == SHT_REL)
1666 section_rel(modname, elf, &elf->sechdrs[i]);
1670 static char *remove_dot(char *s)
1672 size_t n = strcspn(s, ".");
1675 size_t m = strspn(s + n + 1, "0123456789");
1676 if (m && (s[n + m + 1] == '.' || s[n + m + 1] == 0))
1683 * The CRCs are recorded in .*.cmd files in the form of:
1684 * #SYMVER <name> <crc>
1686 static void extract_crcs_for_object(const char *object, struct module *mod)
1688 char cmd_file[PATH_MAX];
1693 base = strrchr(object, '/');
1696 dirlen = base - object;
1702 ret = snprintf(cmd_file, sizeof(cmd_file), "%.*s.%s.cmd",
1703 dirlen, object, base);
1704 if (ret >= sizeof(cmd_file)) {
1705 error("%s: too long path was truncated\n", cmd_file);
1709 buf = read_text_file(cmd_file);
1712 while ((p = strstr(p, "\n#SYMVER "))) {
1718 name = p + strlen("\n#SYMVER ");
1720 p = strchr(name, ' ');
1728 continue; /* skip this line */
1730 crc = strtoul(p, &p, 0);
1732 continue; /* skip this line */
1734 name[namelen] = '\0';
1737 * sym_find_with_module() may return NULL here.
1738 * It typically occurs when CONFIG_TRIM_UNUSED_KSYMS=y.
1739 * Since commit e1327a127703, genksyms calculates CRCs of all
1740 * symbols, including trimmed ones. Ignore orphan CRCs.
1742 sym = sym_find_with_module(name, mod);
1744 sym_set_crc(sym, crc);
1751 * The symbol versions (CRC) are recorded in the .*.cmd files.
1752 * Parse them to retrieve CRCs for the current module.
1754 static void mod_set_crcs(struct module *mod)
1756 char objlist[PATH_MAX];
1757 char *buf, *p, *obj;
1760 if (mod->is_vmlinux) {
1761 strcpy(objlist, ".vmlinux.objs");
1763 /* objects for a module are listed in the *.mod file. */
1764 ret = snprintf(objlist, sizeof(objlist), "%s.mod", mod->name);
1765 if (ret >= sizeof(objlist)) {
1766 error("%s: too long path was truncated\n", objlist);
1771 buf = read_text_file(objlist);
1774 while ((obj = strsep(&p, "\n")) && obj[0])
1775 extract_crcs_for_object(obj, mod);
1780 static void read_symbols(const char *modname)
1782 const char *symname;
1787 struct elf_info info = { };
1790 if (!parse_elf(&info, modname))
1793 if (!strends(modname, ".o")) {
1794 error("%s: filename must be suffixed with .o\n", modname);
1798 /* strip trailing .o */
1799 mod = new_module(modname, strlen(modname) - strlen(".o"));
1801 if (!mod->is_vmlinux) {
1802 license = get_modinfo(&info, "license");
1804 error("missing MODULE_LICENSE() in %s\n", modname);
1806 if (!license_is_gpl_compatible(license)) {
1807 mod->is_gpl_compatible = false;
1810 license = get_next_modinfo(&info, "license", license);
1813 namespace = get_modinfo(&info, "import_ns");
1815 add_namespace(&mod->imported_namespaces, namespace);
1816 namespace = get_next_modinfo(&info, "import_ns",
1821 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1822 symname = remove_dot(info.strtab + sym->st_name);
1824 handle_symbol(mod, &info, sym, symname);
1825 handle_moddevtable(mod, &info, sym, symname);
1828 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1829 symname = remove_dot(info.strtab + sym->st_name);
1831 /* Apply symbol namespaces from __kstrtabns_<symbol> entries. */
1832 if (strstarts(symname, "__kstrtabns_"))
1833 sym_update_namespace(symname + strlen("__kstrtabns_"),
1834 sym_get_data(&info, sym));
1837 check_sec_ref(modname, &info);
1839 if (!mod->is_vmlinux) {
1840 version = get_modinfo(&info, "version");
1841 if (version || all_versions)
1842 get_src_version(mod->name, mod->srcversion,
1843 sizeof(mod->srcversion) - 1);
1846 parse_elf_finish(&info);
1850 * Our trick to get versioning for module struct etc. - it's
1851 * never passed as an argument to an exported function, so
1852 * the automatic versioning doesn't pick it up, but it's really
1855 sym_add_unresolved("module_layout", mod, false);
1861 static void read_symbols_from_files(const char *filename)
1864 char fname[PATH_MAX];
1866 in = fopen(filename, "r");
1868 fatal("Can't open filenames file %s: %m", filename);
1870 while (fgets(fname, PATH_MAX, in) != NULL) {
1871 if (strends(fname, "\n"))
1872 fname[strlen(fname)-1] = '\0';
1873 read_symbols(fname);
1881 /* We first write the generated file into memory using the
1882 * following helper, then compare to the file on disk and
1883 * only update the later if anything changed */
1885 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
1886 const char *fmt, ...)
1893 len = vsnprintf(tmp, SZ, fmt, ap);
1894 buf_write(buf, tmp, len);
1898 void buf_write(struct buffer *buf, const char *s, int len)
1900 if (buf->size - buf->pos < len) {
1901 buf->size += len + SZ;
1902 buf->p = NOFAIL(realloc(buf->p, buf->size));
1904 strncpy(buf->p + buf->pos, s, len);
1908 static void check_exports(struct module *mod)
1910 struct symbol *s, *exp;
1912 list_for_each_entry(s, &mod->unresolved_symbols, list) {
1913 const char *basename;
1914 exp = find_symbol(s->name);
1916 if (!s->weak && nr_unresolved++ < MAX_UNRESOLVED_REPORTS)
1917 modpost_log(warn_unresolved ? LOG_WARN : LOG_ERROR,
1918 "\"%s\" [%s.ko] undefined!\n",
1919 s->name, mod->name);
1922 if (exp->module == mod) {
1923 error("\"%s\" [%s.ko] was exported without definition\n",
1924 s->name, mod->name);
1928 s->module = exp->module;
1929 s->crc_valid = exp->crc_valid;
1932 basename = strrchr(mod->name, '/');
1936 basename = mod->name;
1938 if (exp->namespace &&
1939 !contains_namespace(&mod->imported_namespaces, exp->namespace)) {
1940 modpost_log(allow_missing_ns_imports ? LOG_WARN : LOG_ERROR,
1941 "module %s uses symbol %s from namespace %s, but does not import it.\n",
1942 basename, exp->name, exp->namespace);
1943 add_namespace(&mod->missing_namespaces, exp->namespace);
1946 if (!mod->is_gpl_compatible && exp->is_gpl_only)
1947 error("GPL-incompatible module %s.ko uses GPL-only symbol '%s'\n",
1948 basename, exp->name);
1952 static void check_modname_len(struct module *mod)
1954 const char *mod_name;
1956 mod_name = strrchr(mod->name, '/');
1957 if (mod_name == NULL)
1958 mod_name = mod->name;
1961 if (strlen(mod_name) >= MODULE_NAME_LEN)
1962 error("module name is too long [%s.ko]\n", mod->name);
1966 * Header for the generated file
1968 static void add_header(struct buffer *b, struct module *mod)
1970 buf_printf(b, "#include <linux/module.h>\n");
1972 * Include build-salt.h after module.h in order to
1973 * inherit the definitions.
1975 buf_printf(b, "#define INCLUDE_VERMAGIC\n");
1976 buf_printf(b, "#include <linux/build-salt.h>\n");
1977 buf_printf(b, "#include <linux/elfnote-lto.h>\n");
1978 buf_printf(b, "#include <linux/export-internal.h>\n");
1979 buf_printf(b, "#include <linux/vermagic.h>\n");
1980 buf_printf(b, "#include <linux/compiler.h>\n");
1981 buf_printf(b, "\n");
1982 buf_printf(b, "BUILD_SALT;\n");
1983 buf_printf(b, "BUILD_LTO_INFO;\n");
1984 buf_printf(b, "\n");
1985 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
1986 buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
1987 buf_printf(b, "\n");
1988 buf_printf(b, "__visible struct module __this_module\n");
1989 buf_printf(b, "__section(\".gnu.linkonce.this_module\") = {\n");
1990 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
1992 buf_printf(b, "\t.init = init_module,\n");
1993 if (mod->has_cleanup)
1994 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
1995 "\t.exit = cleanup_module,\n"
1997 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
1998 buf_printf(b, "};\n");
2000 if (!external_module)
2001 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2005 "#ifdef CONFIG_RETPOLINE\n"
2006 "MODULE_INFO(retpoline, \"Y\");\n"
2009 if (strstarts(mod->name, "drivers/staging"))
2010 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2012 if (strstarts(mod->name, "tools/testing"))
2013 buf_printf(b, "\nMODULE_INFO(test, \"Y\");\n");
2016 static void add_exported_symbols(struct buffer *buf, struct module *mod)
2023 /* record CRCs for exported symbols */
2024 buf_printf(buf, "\n");
2025 list_for_each_entry(sym, &mod->exported_symbols, list) {
2026 if (!sym->crc_valid)
2027 warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n"
2028 "Is \"%s\" prototyped in <asm/asm-prototypes.h>?\n",
2029 sym->name, mod->name, mod->is_vmlinux ? "" : ".ko",
2032 buf_printf(buf, "SYMBOL_CRC(%s, 0x%08x, \"%s\");\n",
2033 sym->name, sym->crc, sym->is_gpl_only ? "_gpl" : "");
2038 * Record CRCs for unresolved symbols
2040 static void add_versions(struct buffer *b, struct module *mod)
2047 buf_printf(b, "\n");
2048 buf_printf(b, "static const struct modversion_info ____versions[]\n");
2049 buf_printf(b, "__used __section(\"__versions\") = {\n");
2051 list_for_each_entry(s, &mod->unresolved_symbols, list) {
2054 if (!s->crc_valid) {
2055 warn("\"%s\" [%s.ko] has no CRC!\n",
2056 s->name, mod->name);
2059 if (strlen(s->name) >= MODULE_NAME_LEN) {
2060 error("too long symbol \"%s\" [%s.ko]\n",
2061 s->name, mod->name);
2064 buf_printf(b, "\t{ %#8x, \"%s\" },\n",
2068 buf_printf(b, "};\n");
2071 static void add_depends(struct buffer *b, struct module *mod)
2076 /* Clear ->seen flag of modules that own symbols needed by this. */
2077 list_for_each_entry(s, &mod->unresolved_symbols, list) {
2079 s->module->seen = s->module->is_vmlinux;
2082 buf_printf(b, "\n");
2083 buf_printf(b, "MODULE_INFO(depends, \"");
2084 list_for_each_entry(s, &mod->unresolved_symbols, list) {
2089 if (s->module->seen)
2092 s->module->seen = true;
2093 p = strrchr(s->module->name, '/');
2097 p = s->module->name;
2098 buf_printf(b, "%s%s", first ? "" : ",", p);
2101 buf_printf(b, "\");\n");
2104 static void add_srcversion(struct buffer *b, struct module *mod)
2106 if (mod->srcversion[0]) {
2107 buf_printf(b, "\n");
2108 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2113 static void write_buf(struct buffer *b, const char *fname)
2120 file = fopen(fname, "w");
2125 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2129 if (fclose(file) != 0) {
2135 static void write_if_changed(struct buffer *b, const char *fname)
2141 file = fopen(fname, "r");
2145 if (fstat(fileno(file), &st) < 0)
2148 if (st.st_size != b->pos)
2151 tmp = NOFAIL(malloc(b->pos));
2152 if (fread(tmp, 1, b->pos, file) != b->pos)
2155 if (memcmp(tmp, b->p, b->pos) != 0)
2167 write_buf(b, fname);
2170 static void write_vmlinux_export_c_file(struct module *mod)
2172 struct buffer buf = { };
2175 "#include <linux/export-internal.h>\n");
2177 add_exported_symbols(&buf, mod);
2178 write_if_changed(&buf, ".vmlinux.export.c");
2182 /* do sanity checks, and generate *.mod.c file */
2183 static void write_mod_c_file(struct module *mod)
2185 struct buffer buf = { };
2186 char fname[PATH_MAX];
2189 check_modname_len(mod);
2192 add_header(&buf, mod);
2193 add_exported_symbols(&buf, mod);
2194 add_versions(&buf, mod);
2195 add_depends(&buf, mod);
2196 add_moddevtable(&buf, mod);
2197 add_srcversion(&buf, mod);
2199 ret = snprintf(fname, sizeof(fname), "%s.mod.c", mod->name);
2200 if (ret >= sizeof(fname)) {
2201 error("%s: too long path was truncated\n", fname);
2205 write_if_changed(&buf, fname);
2211 /* parse Module.symvers file. line format:
2212 * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
2214 static void read_dump(const char *fname)
2216 char *buf, *pos, *line;
2218 buf = read_text_file(fname);
2220 /* No symbol versions, silently ignore */
2225 while ((line = get_line(&pos))) {
2226 char *symname, *namespace, *modname, *d, *export;
2232 if (!(symname = strchr(line, '\t')))
2235 if (!(modname = strchr(symname, '\t')))
2238 if (!(export = strchr(modname, '\t')))
2241 if (!(namespace = strchr(export, '\t')))
2243 *namespace++ = '\0';
2245 crc = strtoul(line, &d, 16);
2246 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2249 if (!strcmp(export, "EXPORT_SYMBOL_GPL")) {
2251 } else if (!strcmp(export, "EXPORT_SYMBOL")) {
2254 error("%s: unknown license %s. skip", symname, export);
2258 mod = find_module(modname);
2260 mod = new_module(modname, strlen(modname));
2261 mod->from_dump = true;
2263 s = sym_add_exported(symname, mod, gpl_only);
2264 sym_set_crc(s, crc);
2265 sym_update_namespace(symname, namespace);
2271 fatal("parse error in symbol dump file\n");
2274 static void write_dump(const char *fname)
2276 struct buffer buf = { };
2280 list_for_each_entry(mod, &modules, list) {
2283 list_for_each_entry(sym, &mod->exported_symbols, list) {
2284 buf_printf(&buf, "0x%08x\t%s\t%s\tEXPORT_SYMBOL%s\t%s\n",
2285 sym->crc, sym->name, mod->name,
2286 sym->is_gpl_only ? "_GPL" : "",
2287 sym->namespace ?: "");
2290 write_buf(&buf, fname);
2294 static void write_namespace_deps_files(const char *fname)
2297 struct namespace_list *ns;
2298 struct buffer ns_deps_buf = {};
2300 list_for_each_entry(mod, &modules, list) {
2302 if (mod->from_dump || list_empty(&mod->missing_namespaces))
2305 buf_printf(&ns_deps_buf, "%s.ko:", mod->name);
2307 list_for_each_entry(ns, &mod->missing_namespaces, list)
2308 buf_printf(&ns_deps_buf, " %s", ns->namespace);
2310 buf_printf(&ns_deps_buf, "\n");
2313 write_if_changed(&ns_deps_buf, fname);
2314 free(ns_deps_buf.p);
2318 struct list_head list;
2322 int main(int argc, char **argv)
2325 char *missing_namespace_deps = NULL;
2326 char *dump_write = NULL, *files_source = NULL;
2328 LIST_HEAD(dump_lists);
2329 struct dump_list *dl, *dl2;
2331 while ((opt = getopt(argc, argv, "ei:mnT:o:awENd:")) != -1) {
2334 external_module = true;
2337 dl = NOFAIL(malloc(sizeof(*dl)));
2339 list_add_tail(&dl->list, &dump_lists);
2345 ignore_missing_files = true;
2348 dump_write = optarg;
2351 all_versions = true;
2354 files_source = optarg;
2357 warn_unresolved = true;
2360 sec_mismatch_warn_only = false;
2363 allow_missing_ns_imports = true;
2366 missing_namespace_deps = optarg;
2373 list_for_each_entry_safe(dl, dl2, &dump_lists, list) {
2374 read_dump(dl->file);
2375 list_del(&dl->list);
2379 while (optind < argc)
2380 read_symbols(argv[optind++]);
2383 read_symbols_from_files(files_source);
2385 list_for_each_entry(mod, &modules, list) {
2389 if (mod->is_vmlinux)
2390 write_vmlinux_export_c_file(mod);
2392 write_mod_c_file(mod);
2395 if (missing_namespace_deps)
2396 write_namespace_deps_files(missing_namespace_deps);
2399 write_dump(dump_write);
2400 if (sec_mismatch_count && !sec_mismatch_warn_only)
2401 error("Section mismatches detected.\n"
2402 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2404 if (nr_unresolved > MAX_UNRESOLVED_REPORTS)
2405 warn("suppressed %u unresolved symbol warnings because there were too many)\n",
2406 nr_unresolved - MAX_UNRESOLVED_REPORTS);
2408 return error_occurred ? 1 : 0;