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 /* Warn about undefined symbols? (do so if we have vmlinux) */
27 static int have_vmlinux = 0;
28 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
29 static int all_versions = 0;
30 /* If we are modposting external module set to 1 */
31 static int external_module = 0;
32 /* Warn about section mismatch in vmlinux if set to 1 */
33 static int vmlinux_section_warnings = 1;
34 /* Only warn about unresolved symbols */
35 static int warn_unresolved = 0;
36 /* How a symbol is exported */
37 static int sec_mismatch_count = 0;
38 static int sec_mismatch_fatal = 0;
39 /* ignore missing files */
40 static int ignore_missing_files;
43 export_plain, export_unused, export_gpl,
44 export_unused_gpl, export_gpl_future, export_unknown
47 /* In kernel, this size is defined in linux/module.h;
48 * here we use Elf_Addr instead of long for covering cross-compile
51 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
53 #define PRINTF __attribute__ ((format (printf, 1, 2)))
55 PRINTF void fatal(const char *fmt, ...)
59 fprintf(stderr, "FATAL: ");
61 va_start(arglist, fmt);
62 vfprintf(stderr, fmt, arglist);
68 PRINTF void warn(const char *fmt, ...)
72 fprintf(stderr, "WARNING: ");
74 va_start(arglist, fmt);
75 vfprintf(stderr, fmt, arglist);
79 PRINTF void merror(const char *fmt, ...)
83 fprintf(stderr, "ERROR: ");
85 va_start(arglist, fmt);
86 vfprintf(stderr, fmt, arglist);
90 static inline bool strends(const char *str, const char *postfix)
92 if (strlen(str) < strlen(postfix))
95 return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
98 static int is_vmlinux(const char *modname)
102 myname = strrchr(modname, '/');
108 return (strcmp(myname, "vmlinux") == 0) ||
109 (strcmp(myname, "vmlinux.o") == 0);
112 void *do_nofail(void *ptr, const char *expr)
115 fatal("modpost: Memory allocation failure: %s.\n", expr);
120 /* A list of all modules we processed */
121 static struct module *modules;
123 static struct module *find_module(const char *modname)
127 for (mod = modules; mod; mod = mod->next)
128 if (strcmp(mod->name, modname) == 0)
133 static struct module *new_module(const char *modname)
138 mod = NOFAIL(malloc(sizeof(*mod)));
139 memset(mod, 0, sizeof(*mod));
140 p = NOFAIL(strdup(modname));
142 /* strip trailing .o */
143 if (strends(p, ".o")) {
144 p[strlen(p) - 2] = '\0';
150 mod->gpl_compatible = -1;
157 /* A hash of all exported symbols,
158 * struct symbol is also used for lists of unresolved symbols */
160 #define SYMBOL_HASH_SIZE 1024
164 struct module *module;
168 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */
169 unsigned int kernel:1; /* 1 if symbol is from kernel
170 * (only for external modules) **/
171 unsigned int preloaded:1; /* 1 if symbol from Module.symvers, or crc */
172 enum export export; /* Type of export */
176 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
178 /* This is based on the hash agorithm from gdbm, via tdb */
179 static inline unsigned int tdb_hash(const char *name)
181 unsigned value; /* Used to compute the hash value. */
182 unsigned i; /* Used to cycle through random values. */
184 /* Set the initial value from the key size. */
185 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
186 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
188 return (1103515243 * value + 12345);
192 * Allocate a new symbols for use in the hash of exported symbols or
193 * the list of unresolved symbols per module
195 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
198 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
200 memset(s, 0, sizeof(*s));
201 strcpy(s->name, name);
207 /* For the hash of exported symbols */
208 static struct symbol *new_symbol(const char *name, struct module *module,
214 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
215 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
216 new->module = module;
217 new->export = export;
221 static struct symbol *find_symbol(const char *name)
225 /* For our purposes, .foo matches foo. PPC64 needs this. */
229 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
230 if (strcmp(s->name, name) == 0)
236 static const struct {
240 { .str = "EXPORT_SYMBOL", .export = export_plain },
241 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
242 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
243 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
244 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
245 { .str = "(unknown)", .export = export_unknown },
249 static const char *export_str(enum export ex)
251 return export_list[ex].str;
254 static enum export export_no(const char *s)
259 return export_unknown;
260 for (i = 0; export_list[i].export != export_unknown; i++) {
261 if (strcmp(export_list[i].str, s) == 0)
262 return export_list[i].export;
264 return export_unknown;
267 static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
269 return (void *)elf->hdr +
270 elf->sechdrs[elf->secindex_strings].sh_offset +
274 static const char *sec_name(struct elf_info *elf, int secindex)
276 return sech_name(elf, &elf->sechdrs[secindex]);
279 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
281 static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
283 const char *secname = sec_name(elf, sec);
285 if (strstarts(secname, "___ksymtab+"))
287 else if (strstarts(secname, "___ksymtab_unused+"))
288 return export_unused;
289 else if (strstarts(secname, "___ksymtab_gpl+"))
291 else if (strstarts(secname, "___ksymtab_unused_gpl+"))
292 return export_unused_gpl;
293 else if (strstarts(secname, "___ksymtab_gpl_future+"))
294 return export_gpl_future;
296 return export_unknown;
299 static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
301 if (sec == elf->export_sec)
303 else if (sec == elf->export_unused_sec)
304 return export_unused;
305 else if (sec == elf->export_gpl_sec)
307 else if (sec == elf->export_unused_gpl_sec)
308 return export_unused_gpl;
309 else if (sec == elf->export_gpl_future_sec)
310 return export_gpl_future;
312 return export_unknown;
316 * Add an exported symbol - it may have already been added without a
317 * CRC, in this case just update the CRC
319 static struct symbol *sym_add_exported(const char *name, struct module *mod,
322 struct symbol *s = find_symbol(name);
325 s = new_symbol(name, mod, export);
328 warn("%s: '%s' exported twice. Previous export "
329 "was in %s%s\n", mod->name, name,
331 is_vmlinux(s->module->name) ?"":".ko");
333 /* In case Module.symvers was out of date */
338 s->vmlinux = is_vmlinux(mod->name);
344 static void sym_update_crc(const char *name, struct module *mod,
345 unsigned int crc, enum export export)
347 struct symbol *s = find_symbol(name);
350 s = new_symbol(name, mod, export);
351 /* Don't complain when we find it later. */
358 void *grab_file(const char *filename, unsigned long *size)
361 void *map = MAP_FAILED;
364 fd = open(filename, O_RDONLY);
371 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
375 if (map == MAP_FAILED)
381 * Return a copy of the next line in a mmap'ed file.
382 * spaces in the beginning of the line is trimmed away.
383 * Return a pointer to a static buffer.
385 char *get_next_line(unsigned long *pos, void *file, unsigned long size)
387 static char line[4096];
390 signed char *p = (signed char *)file + *pos;
393 for (; *pos < size ; (*pos)++) {
394 if (skip && isspace(*p)) {
399 if (*p != '\n' && (*pos < size)) {
403 break; /* Too long, stop */
414 void release_file(void *file, unsigned long size)
419 static int parse_elf(struct elf_info *info, const char *filename)
425 const char *secstrings;
426 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
428 hdr = grab_file(filename, &info->size);
430 if (ignore_missing_files) {
431 fprintf(stderr, "%s: %s (ignored)\n", filename,
439 if (info->size < sizeof(*hdr)) {
440 /* file too small, assume this is an empty .o file */
443 /* Is this a valid ELF file? */
444 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
445 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
446 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
447 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
448 /* Not an ELF file - silently ignore it */
451 /* Fix endianness in ELF header */
452 hdr->e_type = TO_NATIVE(hdr->e_type);
453 hdr->e_machine = TO_NATIVE(hdr->e_machine);
454 hdr->e_version = TO_NATIVE(hdr->e_version);
455 hdr->e_entry = TO_NATIVE(hdr->e_entry);
456 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
457 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
458 hdr->e_flags = TO_NATIVE(hdr->e_flags);
459 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
460 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
461 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
462 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
463 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
464 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
465 sechdrs = (void *)hdr + hdr->e_shoff;
466 info->sechdrs = sechdrs;
468 /* Check if file offset is correct */
469 if (hdr->e_shoff > info->size) {
470 fatal("section header offset=%lu in file '%s' is bigger than "
471 "filesize=%lu\n", (unsigned long)hdr->e_shoff,
472 filename, info->size);
476 if (hdr->e_shnum == SHN_UNDEF) {
478 * There are more than 64k sections,
479 * read count from .sh_size.
481 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
484 info->num_sections = hdr->e_shnum;
486 if (hdr->e_shstrndx == SHN_XINDEX) {
487 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
490 info->secindex_strings = hdr->e_shstrndx;
493 /* Fix endianness in section headers */
494 for (i = 0; i < info->num_sections; i++) {
495 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
496 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
497 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
498 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
499 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
500 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
501 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
502 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
503 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
504 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
506 /* Find symbol table. */
507 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
508 for (i = 1; i < info->num_sections; i++) {
510 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
512 if (!nobits && sechdrs[i].sh_offset > info->size) {
513 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
514 "sizeof(*hrd)=%zu\n", filename,
515 (unsigned long)sechdrs[i].sh_offset,
519 secname = secstrings + sechdrs[i].sh_name;
520 if (strcmp(secname, ".modinfo") == 0) {
522 fatal("%s has NOBITS .modinfo\n", filename);
523 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
524 info->modinfo_len = sechdrs[i].sh_size;
525 } else if (strcmp(secname, "__ksymtab") == 0)
526 info->export_sec = i;
527 else if (strcmp(secname, "__ksymtab_unused") == 0)
528 info->export_unused_sec = i;
529 else if (strcmp(secname, "__ksymtab_gpl") == 0)
530 info->export_gpl_sec = i;
531 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
532 info->export_unused_gpl_sec = i;
533 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
534 info->export_gpl_future_sec = i;
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)
613 /* Do not ignore this symbol */
617 static void handle_modversions(struct module *mod, struct elf_info *info,
618 Elf_Sym *sym, const char *symname)
624 if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
625 strstarts(symname, "__ksymtab"))
626 export = export_from_secname(info, get_secindex(info, sym));
628 export = export_from_sec(info, get_secindex(info, sym));
631 if (strstarts(symname, "__crc_")) {
633 crc = (unsigned int) sym->st_value;
634 if (sym->st_shndx != SHN_UNDEF && sym->st_shndx != SHN_ABS) {
637 /* symbol points to the CRC in the ELF object */
638 crcp = (void *)info->hdr + sym->st_value +
639 info->sechdrs[sym->st_shndx].sh_offset -
640 (info->hdr->e_type != ET_REL ?
641 info->sechdrs[sym->st_shndx].sh_addr : 0);
642 crc = TO_NATIVE(*crcp);
644 sym_update_crc(symname + strlen("__crc_"), mod, crc,
648 switch (sym->st_shndx) {
650 if (strstarts(symname, "__gnu_lto_")) {
651 /* Should warn here, but modpost runs before the linker */
653 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
656 /* undefined symbol */
657 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
658 ELF_ST_BIND(sym->st_info) != STB_WEAK)
660 if (ignore_undef_symbol(info, symname))
662 /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
663 #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
664 /* add compatibility with older glibc */
665 #ifndef STT_SPARC_REGISTER
666 #define STT_SPARC_REGISTER STT_REGISTER
668 if (info->hdr->e_machine == EM_SPARC ||
669 info->hdr->e_machine == EM_SPARCV9) {
670 /* Ignore register directives. */
671 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
673 if (symname[0] == '.') {
674 char *munged = NOFAIL(strdup(symname));
676 munged[1] = toupper(munged[1]);
683 const char *e = is_vmlinux(mod->name) ?"":".ko";
684 warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n",
685 symname + strlen("__crc_"), mod->name, e);
687 mod->unres = alloc_symbol(symname,
688 ELF_ST_BIND(sym->st_info) == STB_WEAK,
692 /* All exported symbols */
693 if (strstarts(symname, "__ksymtab_")) {
694 sym_add_exported(symname + strlen("__ksymtab_"), mod,
697 if (strcmp(symname, "init_module") == 0)
699 if (strcmp(symname, "cleanup_module") == 0)
700 mod->has_cleanup = 1;
706 * Parse tag=value strings from .modinfo section
708 static char *next_string(char *string, unsigned long *secsize)
710 /* Skip non-zero chars */
713 if ((*secsize)-- <= 1)
717 /* Skip any zero padding. */
720 if ((*secsize)-- <= 1)
726 static char *get_next_modinfo(struct elf_info *info, const char *tag,
730 unsigned int taglen = strlen(tag);
731 char *modinfo = info->modinfo;
732 unsigned long size = info->modinfo_len;
735 size -= prev - modinfo;
736 modinfo = next_string(prev, &size);
739 for (p = modinfo; p; p = next_string(p, &size)) {
740 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
741 return p + taglen + 1;
746 static char *get_modinfo(struct elf_info *info, const char *tag)
749 return get_next_modinfo(info, tag, NULL);
753 * Test if string s ends in string sub
756 static int strrcmp(const char *s, const char *sub)
764 sublen = strlen(sub);
766 if ((slen == 0) || (sublen == 0))
772 return memcmp(s + slen - sublen, sub, sublen);
775 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
778 return elf->strtab + sym->st_name;
783 /* The pattern is an array of simple patterns.
784 * "foo" will match an exact string equal to "foo"
785 * "*foo" will match a string that ends with "foo"
786 * "foo*" will match a string that begins with "foo"
787 * "*foo*" will match a string that contains "foo"
789 static int match(const char *sym, const char * const pat[])
794 const char *endp = p + strlen(p) - 1;
797 if (*p == '*' && *endp == '*') {
798 char *here, *bare = strndup(p + 1, strlen(p) - 2);
800 here = strstr(sym, bare);
806 else if (*p == '*') {
807 if (strrcmp(sym, p + 1) == 0)
811 else if (*endp == '*') {
812 if (strncmp(sym, p, strlen(p) - 1) == 0)
817 if (strcmp(p, sym) == 0)
825 /* sections that we do not want to do full section mismatch check on */
826 static const char *const section_white_list[] =
830 ".cranges", /* sh64 */
831 ".zdebug*", /* Compressed debug sections. */
832 ".GCC.command.line", /* record-gcc-switches */
833 ".mdebug*", /* alpha, score, mips etc. */
834 ".pdr", /* alpha, score, mips etc. */
839 ".xt.prop", /* xtensa */
840 ".xt.lit", /* xtensa */
841 ".arcextmap*", /* arc */
842 ".gnu.linkonce.arcext*", /* arc : modules */
843 ".cmem*", /* EZchip */
844 ".fmt_slot*", /* EZchip */
851 * This is used to find sections missing the SHF_ALLOC flag.
852 * The cause of this is often a section specified in assembler
853 * without "ax" / "aw".
855 static void check_section(const char *modname, struct elf_info *elf,
858 const char *sec = sech_name(elf, sechdr);
860 if (sechdr->sh_type == SHT_PROGBITS &&
861 !(sechdr->sh_flags & SHF_ALLOC) &&
862 !match(sec, section_white_list)) {
863 warn("%s (%s): unexpected non-allocatable section.\n"
864 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
865 "Note that for example <linux/init.h> contains\n"
866 "section definitions for use in .S files.\n\n",
873 #define ALL_INIT_DATA_SECTIONS \
874 ".init.setup", ".init.rodata", ".meminit.rodata", \
875 ".init.data", ".meminit.data"
876 #define ALL_EXIT_DATA_SECTIONS \
877 ".exit.data", ".memexit.data"
879 #define ALL_INIT_TEXT_SECTIONS \
880 ".init.text", ".meminit.text"
881 #define ALL_EXIT_TEXT_SECTIONS \
882 ".exit.text", ".memexit.text"
884 #define ALL_PCI_INIT_SECTIONS \
885 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
886 ".pci_fixup_enable", ".pci_fixup_resume", \
887 ".pci_fixup_resume_early", ".pci_fixup_suspend"
889 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
890 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
892 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
893 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
895 #define DATA_SECTIONS ".data", ".data.rel"
896 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
897 ".kprobes.text", ".cpuidle.text"
898 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
899 ".fixup", ".entry.text", ".exception.text", ".text.*", \
902 #define INIT_SECTIONS ".init.*"
903 #define MEM_INIT_SECTIONS ".meminit.*"
905 #define EXIT_SECTIONS ".exit.*"
906 #define MEM_EXIT_SECTIONS ".memexit.*"
908 #define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
909 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
911 /* init data sections */
912 static const char *const init_data_sections[] =
913 { ALL_INIT_DATA_SECTIONS, NULL };
915 /* all init sections */
916 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
918 /* All init and exit sections (code + data) */
919 static const char *const init_exit_sections[] =
920 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
922 /* all text sections */
923 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
926 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
929 /* symbols in .data that may refer to init/exit sections */
930 #define DEFAULT_SYMBOL_WHITE_LIST \
932 "*_template", /* scsi uses *_template a lot */ \
933 "*_timer", /* arm uses ops structures named _timer a lot */ \
934 "*_sht", /* scsi also used *_sht to some extent */ \
940 static const char *const head_sections[] = { ".head.text*", NULL };
941 static const char *const linker_symbols[] =
942 { "__init_begin", "_sinittext", "_einittext", NULL };
943 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
950 XXXINIT_TO_SOME_INIT,
951 XXXEXIT_TO_SOME_EXIT,
952 ANY_INIT_TO_ANY_EXIT,
953 ANY_EXIT_TO_ANY_INIT,
959 * Describe how to match sections on different criterias:
961 * @fromsec: Array of sections to be matched.
963 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
964 * this array is forbidden (black-list). Can be empty.
966 * @good_tosec: Relocations applied to a section in @fromsec must be
967 * targetting sections in this array (white-list). Can be empty.
969 * @mismatch: Type of mismatch.
971 * @symbol_white_list: Do not match a relocation to a symbol in this list
972 * even if it is targetting a section in @bad_to_sec.
974 * @handler: Specific handler to call when a match is found. If NULL,
975 * default_mismatch_handler() will be called.
978 struct sectioncheck {
979 const char *fromsec[20];
980 const char *bad_tosec[20];
981 const char *good_tosec[20];
982 enum mismatch mismatch;
983 const char *symbol_white_list[20];
984 void (*handler)(const char *modname, struct elf_info *elf,
985 const struct sectioncheck* const mismatch,
986 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
990 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
991 const struct sectioncheck* const mismatch,
992 Elf_Rela *r, Elf_Sym *sym,
993 const char *fromsec);
995 static const struct sectioncheck sectioncheck[] = {
996 /* Do not reference init/exit code/data from
997 * normal code and data
1000 .fromsec = { TEXT_SECTIONS, NULL },
1001 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1002 .mismatch = TEXT_TO_ANY_INIT,
1003 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1006 .fromsec = { DATA_SECTIONS, NULL },
1007 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1008 .mismatch = DATA_TO_ANY_INIT,
1009 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1012 .fromsec = { DATA_SECTIONS, NULL },
1013 .bad_tosec = { INIT_SECTIONS, NULL },
1014 .mismatch = DATA_TO_ANY_INIT,
1015 .symbol_white_list = {
1016 "*_template", "*_timer", "*_sht", "*_ops",
1017 "*_probe", "*_probe_one", "*_console", NULL
1021 .fromsec = { TEXT_SECTIONS, NULL },
1022 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1023 .mismatch = TEXT_TO_ANY_EXIT,
1024 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1027 .fromsec = { DATA_SECTIONS, NULL },
1028 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1029 .mismatch = DATA_TO_ANY_EXIT,
1030 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1032 /* Do not reference init code/data from meminit code/data */
1034 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1035 .bad_tosec = { INIT_SECTIONS, NULL },
1036 .mismatch = XXXINIT_TO_SOME_INIT,
1037 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1039 /* Do not reference exit code/data from memexit code/data */
1041 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1042 .bad_tosec = { EXIT_SECTIONS, NULL },
1043 .mismatch = XXXEXIT_TO_SOME_EXIT,
1044 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1046 /* Do not use exit code/data from init code */
1048 .fromsec = { ALL_INIT_SECTIONS, NULL },
1049 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1050 .mismatch = ANY_INIT_TO_ANY_EXIT,
1051 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1053 /* Do not use init code/data from exit code */
1055 .fromsec = { ALL_EXIT_SECTIONS, NULL },
1056 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1057 .mismatch = ANY_EXIT_TO_ANY_INIT,
1058 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1061 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1062 .bad_tosec = { INIT_SECTIONS, NULL },
1063 .mismatch = ANY_INIT_TO_ANY_EXIT,
1064 .symbol_white_list = { NULL },
1066 /* Do not export init/exit functions or data */
1068 .fromsec = { "__ksymtab*", NULL },
1069 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1070 .mismatch = EXPORT_TO_INIT_EXIT,
1071 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1074 .fromsec = { "__ex_table", NULL },
1075 /* If you're adding any new black-listed sections in here, consider
1076 * adding a special 'printer' for them in scripts/check_extable.
1078 .bad_tosec = { ".altinstr_replacement", NULL },
1079 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1080 .mismatch = EXTABLE_TO_NON_TEXT,
1081 .handler = extable_mismatch_handler,
1085 static const struct sectioncheck *section_mismatch(
1086 const char *fromsec, const char *tosec)
1089 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1090 const struct sectioncheck *check = §ioncheck[0];
1093 * The target section could be the SHT_NUL section when we're
1094 * handling relocations to un-resolved symbols, trying to match it
1095 * doesn't make much sense and causes build failures on parisc
1101 for (i = 0; i < elems; i++) {
1102 if (match(fromsec, check->fromsec)) {
1103 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1105 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1114 * Whitelist to allow certain references to pass with no warning.
1117 * If a module parameter is declared __initdata and permissions=0
1118 * then this is legal despite the warning generated.
1119 * We cannot see value of permissions here, so just ignore
1121 * The pattern is identified by:
1122 * tosec = .init.data
1127 * module_param_call() ops can refer to __init set function if permissions=0
1128 * The pattern is identified by:
1129 * tosec = .init.text
1131 * atsym = __param_ops_*
1134 * Many drivers utilise a *driver container with references to
1135 * add, remove, probe functions etc.
1136 * the pattern is identified by:
1137 * tosec = init or exit section
1138 * fromsec = data section
1139 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1140 * *probe_one, *_console, *_timer
1143 * Whitelist all references from .head.text to any init section
1146 * Some symbols belong to init section but still it is ok to reference
1147 * these from non-init sections as these symbols don't have any memory
1148 * allocated for them and symbol address and value are same. So even
1149 * if init section is freed, its ok to reference those symbols.
1150 * For ex. symbols marking the init section boundaries.
1151 * This pattern is identified by
1152 * refsymname = __init_begin, _sinittext, _einittext
1155 * GCC may optimize static inlines when fed constant arg(s) resulting
1156 * in functions like cpumask_empty() -- generating an associated symbol
1157 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1158 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1159 * meaningless section warning. May need to add isra symbols too...
1160 * This pattern is identified by
1161 * tosec = init section
1162 * fromsec = text section
1163 * refsymname = *.constprop.*
1166 * Hide section mismatch warnings for ELF local symbols. The goal
1167 * is to eliminate false positive modpost warnings caused by
1168 * compiler-generated ELF local symbol names such as ".LANCHOR1".
1169 * Autogenerated symbol names bypass modpost's "Pattern 2"
1170 * whitelisting, which relies on pattern-matching against symbol
1171 * names to work. (One situation where gcc can autogenerate ELF
1172 * local symbols is when "-fsection-anchors" is used.)
1174 static int secref_whitelist(const struct sectioncheck *mismatch,
1175 const char *fromsec, const char *fromsym,
1176 const char *tosec, const char *tosym)
1178 /* Check for pattern 1 */
1179 if (match(tosec, init_data_sections) &&
1180 match(fromsec, data_sections) &&
1181 strstarts(fromsym, "__param"))
1184 /* Check for pattern 1a */
1185 if (strcmp(tosec, ".init.text") == 0 &&
1186 match(fromsec, data_sections) &&
1187 strstarts(fromsym, "__param_ops_"))
1190 /* Check for pattern 2 */
1191 if (match(tosec, init_exit_sections) &&
1192 match(fromsec, data_sections) &&
1193 match(fromsym, mismatch->symbol_white_list))
1196 /* Check for pattern 3 */
1197 if (match(fromsec, head_sections) &&
1198 match(tosec, init_sections))
1201 /* Check for pattern 4 */
1202 if (match(tosym, linker_symbols))
1205 /* Check for pattern 5 */
1206 if (match(fromsec, text_sections) &&
1207 match(tosec, init_sections) &&
1208 match(fromsym, optim_symbols))
1211 /* Check for pattern 6 */
1212 if (strstarts(fromsym, ".L"))
1218 static inline int is_arm_mapping_symbol(const char *str)
1220 return str[0] == '$' && strchr("axtd", str[1])
1221 && (str[2] == '\0' || str[2] == '.');
1225 * If there's no name there, ignore it; likewise, ignore it if it's
1226 * one of the magic symbols emitted used by current ARM tools.
1228 * Otherwise if find_symbols_between() returns those symbols, they'll
1229 * fail the whitelist tests and cause lots of false alarms ... fixable
1230 * only by merging __exit and __init sections into __text, bloating
1231 * the kernel (which is especially evil on embedded platforms).
1233 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1235 const char *name = elf->strtab + sym->st_name;
1237 if (!name || !strlen(name))
1239 return !is_arm_mapping_symbol(name);
1243 * Find symbol based on relocation record info.
1244 * In some cases the symbol supplied is a valid symbol so
1245 * return refsym. If st_name != 0 we assume this is a valid symbol.
1246 * In other cases the symbol needs to be looked up in the symbol table
1247 * based on section and address.
1249 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1253 Elf_Sym *near = NULL;
1254 Elf64_Sword distance = 20;
1256 unsigned int relsym_secindex;
1258 if (relsym->st_name != 0)
1261 relsym_secindex = get_secindex(elf, relsym);
1262 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1263 if (get_secindex(elf, sym) != relsym_secindex)
1265 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1267 if (!is_valid_name(elf, sym))
1269 if (sym->st_value == addr)
1271 /* Find a symbol nearby - addr are maybe negative */
1272 d = sym->st_value - addr;
1274 d = addr - sym->st_value;
1280 /* We need a close match */
1288 * Find symbols before or equal addr and after addr - in the section sec.
1289 * If we find two symbols with equal offset prefer one with a valid name.
1290 * The ELF format may have a better way to detect what type of symbol
1291 * it is, but this works for now.
1293 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1297 Elf_Sym *near = NULL;
1298 Elf_Addr distance = ~0;
1300 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1303 if (is_shndx_special(sym->st_shndx))
1305 symsec = sec_name(elf, get_secindex(elf, sym));
1306 if (strcmp(symsec, sec) != 0)
1308 if (!is_valid_name(elf, sym))
1310 if (sym->st_value <= addr) {
1311 if ((addr - sym->st_value) < distance) {
1312 distance = addr - sym->st_value;
1314 } else if ((addr - sym->st_value) == distance) {
1323 * Convert a section name to the function/data attribute
1324 * .init.text => __init
1325 * .memexitconst => __memconst
1328 * The memory of returned value has been allocated on a heap. The user of this
1329 * method should free it after usage.
1331 static char *sec2annotation(const char *s)
1333 if (match(s, init_exit_sections)) {
1334 char *p = NOFAIL(malloc(20));
1341 while (*s && *s != '.')
1346 if (strstr(s, "rodata") != NULL)
1347 strcat(p, "const ");
1348 else if (strstr(s, "data") != NULL)
1354 return NOFAIL(strdup(""));
1358 static int is_function(Elf_Sym *sym)
1361 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1366 static void print_section_list(const char * const list[20])
1368 const char *const *s = list;
1371 fprintf(stderr, "%s", *s);
1374 fprintf(stderr, ", ");
1376 fprintf(stderr, "\n");
1379 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1382 case 0: *name = "variable"; *name_p = ""; break;
1383 case 1: *name = "function"; *name_p = "()"; break;
1384 default: *name = "(unknown reference)"; *name_p = ""; break;
1389 * Print a warning about a section mismatch.
1390 * Try to find symbols near it so user can find it.
1391 * Check whitelist before warning - it may be a false positive.
1393 static void report_sec_mismatch(const char *modname,
1394 const struct sectioncheck *mismatch,
1395 const char *fromsec,
1396 unsigned long long fromaddr,
1397 const char *fromsym,
1399 const char *tosec, const char *tosym,
1402 const char *from, *from_p;
1403 const char *to, *to_p;
1407 sec_mismatch_count++;
1409 get_pretty_name(from_is_func, &from, &from_p);
1410 get_pretty_name(to_is_func, &to, &to_p);
1412 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1413 "to the %s %s:%s%s\n",
1414 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1417 switch (mismatch->mismatch) {
1418 case TEXT_TO_ANY_INIT:
1419 prl_from = sec2annotation(fromsec);
1420 prl_to = sec2annotation(tosec);
1422 "The function %s%s() references\n"
1424 "This is often because %s lacks a %s\n"
1425 "annotation or the annotation of %s is wrong.\n",
1427 to, prl_to, tosym, to_p,
1428 fromsym, prl_to, tosym);
1432 case DATA_TO_ANY_INIT: {
1433 prl_to = sec2annotation(tosec);
1435 "The variable %s references\n"
1437 "If the reference is valid then annotate the\n"
1438 "variable with __init* or __refdata (see linux/init.h) "
1439 "or name the variable:\n",
1440 fromsym, to, prl_to, tosym, to_p);
1441 print_section_list(mismatch->symbol_white_list);
1445 case TEXT_TO_ANY_EXIT:
1446 prl_to = sec2annotation(tosec);
1448 "The function %s() references a %s in an exit section.\n"
1449 "Often the %s %s%s has valid usage outside the exit section\n"
1450 "and the fix is to remove the %sannotation of %s.\n",
1451 fromsym, to, to, tosym, to_p, prl_to, tosym);
1454 case DATA_TO_ANY_EXIT: {
1455 prl_to = sec2annotation(tosec);
1457 "The variable %s references\n"
1459 "If the reference is valid then annotate the\n"
1460 "variable with __exit* (see linux/init.h) or "
1461 "name the variable:\n",
1462 fromsym, to, prl_to, tosym, to_p);
1463 print_section_list(mismatch->symbol_white_list);
1467 case XXXINIT_TO_SOME_INIT:
1468 case XXXEXIT_TO_SOME_EXIT:
1469 prl_from = sec2annotation(fromsec);
1470 prl_to = sec2annotation(tosec);
1472 "The %s %s%s%s references\n"
1474 "If %s is only used by %s then\n"
1475 "annotate %s with a matching annotation.\n",
1476 from, prl_from, fromsym, from_p,
1477 to, prl_to, tosym, to_p,
1478 tosym, fromsym, tosym);
1482 case ANY_INIT_TO_ANY_EXIT:
1483 prl_from = sec2annotation(fromsec);
1484 prl_to = sec2annotation(tosec);
1486 "The %s %s%s%s references\n"
1488 "This is often seen when error handling "
1489 "in the init function\n"
1490 "uses functionality in the exit path.\n"
1491 "The fix is often to remove the %sannotation of\n"
1492 "%s%s so it may be used outside an exit section.\n",
1493 from, prl_from, fromsym, from_p,
1494 to, prl_to, tosym, to_p,
1495 prl_to, tosym, to_p);
1499 case ANY_EXIT_TO_ANY_INIT:
1500 prl_from = sec2annotation(fromsec);
1501 prl_to = sec2annotation(tosec);
1503 "The %s %s%s%s references\n"
1505 "This is often seen when error handling "
1506 "in the exit function\n"
1507 "uses functionality in the init path.\n"
1508 "The fix is often to remove the %sannotation of\n"
1509 "%s%s so it may be used outside an init section.\n",
1510 from, prl_from, fromsym, from_p,
1511 to, prl_to, tosym, to_p,
1512 prl_to, tosym, to_p);
1516 case EXPORT_TO_INIT_EXIT:
1517 prl_to = sec2annotation(tosec);
1519 "The symbol %s is exported and annotated %s\n"
1520 "Fix this by removing the %sannotation of %s "
1521 "or drop the export.\n",
1522 tosym, prl_to, prl_to, tosym);
1525 case EXTABLE_TO_NON_TEXT:
1526 fatal("There's a special handler for this mismatch type, "
1527 "we should never get here.");
1530 fprintf(stderr, "\n");
1533 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1534 const struct sectioncheck* const mismatch,
1535 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1541 const char *fromsym;
1543 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1544 fromsym = sym_name(elf, from);
1546 if (strstarts(fromsym, "reference___initcall"))
1549 tosec = sec_name(elf, get_secindex(elf, sym));
1550 to = find_elf_symbol(elf, r->r_addend, sym);
1551 tosym = sym_name(elf, to);
1553 /* check whitelist - we may ignore it */
1554 if (secref_whitelist(mismatch,
1555 fromsec, fromsym, tosec, tosym)) {
1556 report_sec_mismatch(modname, mismatch,
1557 fromsec, r->r_offset, fromsym,
1558 is_function(from), tosec, tosym,
1563 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1565 if (section_index > elf->num_sections)
1566 fatal("section_index is outside elf->num_sections!\n");
1568 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1572 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1573 * to know the sizeof(struct exception_table_entry) for the target architecture.
1575 static unsigned int extable_entry_size = 0;
1576 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1579 * If we're currently checking the second relocation within __ex_table,
1580 * that relocation offset tells us the offsetof(struct
1581 * exception_table_entry, fixup) which is equal to sizeof(struct
1582 * exception_table_entry) divided by two. We use that to our advantage
1583 * since there's no portable way to get that size as every architecture
1584 * seems to go with different sized types. Not pretty but better than
1585 * hard-coding the size for every architecture..
1587 if (!extable_entry_size)
1588 extable_entry_size = r->r_offset * 2;
1591 static inline bool is_extable_fault_address(Elf_Rela *r)
1594 * extable_entry_size is only discovered after we've handled the
1595 * _second_ relocation in __ex_table, so only abort when we're not
1596 * handling the first reloc and extable_entry_size is zero.
1598 if (r->r_offset && extable_entry_size == 0)
1599 fatal("extable_entry size hasn't been discovered!\n");
1601 return ((r->r_offset == 0) ||
1602 (r->r_offset % extable_entry_size == 0));
1605 #define is_second_extable_reloc(Start, Cur, Sec) \
1606 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1608 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1609 const struct sectioncheck* const mismatch,
1610 Elf_Rela* r, Elf_Sym* sym,
1611 const char* fromsec, const char* tosec)
1613 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1614 const char* fromsym_name = sym_name(elf, fromsym);
1615 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1616 const char* tosym_name = sym_name(elf, tosym);
1617 const char* from_pretty_name;
1618 const char* from_pretty_name_p;
1619 const char* to_pretty_name;
1620 const char* to_pretty_name_p;
1622 get_pretty_name(is_function(fromsym),
1623 &from_pretty_name, &from_pretty_name_p);
1624 get_pretty_name(is_function(tosym),
1625 &to_pretty_name, &to_pretty_name_p);
1627 warn("%s(%s+0x%lx): Section mismatch in reference"
1628 " from the %s %s%s to the %s %s:%s%s\n",
1629 modname, fromsec, (long)r->r_offset, from_pretty_name,
1630 fromsym_name, from_pretty_name_p,
1631 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1633 if (!match(tosec, mismatch->bad_tosec) &&
1634 is_executable_section(elf, get_secindex(elf, sym)))
1636 "The relocation at %s+0x%lx references\n"
1637 "section \"%s\" which is not in the list of\n"
1638 "authorized sections. If you're adding a new section\n"
1639 "and/or if this reference is valid, add \"%s\" to the\n"
1640 "list of authorized sections to jump to on fault.\n"
1641 "This can be achieved by adding \"%s\" to \n"
1642 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1643 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1646 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1647 const struct sectioncheck* const mismatch,
1648 Elf_Rela* r, Elf_Sym* sym,
1649 const char *fromsec)
1651 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1653 sec_mismatch_count++;
1655 report_extable_warnings(modname, elf, mismatch, r, sym, fromsec, tosec);
1657 if (match(tosec, mismatch->bad_tosec))
1658 fatal("The relocation at %s+0x%lx references\n"
1659 "section \"%s\" which is black-listed.\n"
1660 "Something is seriously wrong and should be fixed.\n"
1661 "You might get more information about where this is\n"
1662 "coming from by using scripts/check_extable.sh %s\n",
1663 fromsec, (long)r->r_offset, tosec, modname);
1664 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1665 if (is_extable_fault_address(r))
1666 fatal("The relocation at %s+0x%lx references\n"
1667 "section \"%s\" which is not executable, IOW\n"
1668 "it is not possible for the kernel to fault\n"
1669 "at that address. Something is seriously wrong\n"
1670 "and should be fixed.\n",
1671 fromsec, (long)r->r_offset, tosec);
1673 fatal("The relocation at %s+0x%lx references\n"
1674 "section \"%s\" which is not executable, IOW\n"
1675 "the kernel will fault if it ever tries to\n"
1676 "jump to it. Something is seriously wrong\n"
1677 "and should be fixed.\n",
1678 fromsec, (long)r->r_offset, tosec);
1682 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1683 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1685 const char *tosec = sec_name(elf, get_secindex(elf, sym));
1686 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1689 if (mismatch->handler)
1690 mismatch->handler(modname, elf, mismatch,
1693 default_mismatch_handler(modname, elf, mismatch,
1698 static unsigned int *reloc_location(struct elf_info *elf,
1699 Elf_Shdr *sechdr, Elf_Rela *r)
1701 Elf_Shdr *sechdrs = elf->sechdrs;
1702 int section = sechdr->sh_info;
1704 return (void *)elf->hdr + sechdrs[section].sh_offset +
1708 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1710 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1711 unsigned int *location = reloc_location(elf, sechdr, r);
1715 r->r_addend = TO_NATIVE(*location);
1718 r->r_addend = TO_NATIVE(*location) + 4;
1719 /* For CONFIG_RELOCATABLE=y */
1720 if (elf->hdr->e_type == ET_EXEC)
1721 r->r_addend += r->r_offset;
1728 #define R_ARM_CALL 28
1730 #ifndef R_ARM_JUMP24
1731 #define R_ARM_JUMP24 29
1734 #ifndef R_ARM_THM_CALL
1735 #define R_ARM_THM_CALL 10
1737 #ifndef R_ARM_THM_JUMP24
1738 #define R_ARM_THM_JUMP24 30
1740 #ifndef R_ARM_THM_JUMP19
1741 #define R_ARM_THM_JUMP19 51
1744 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1746 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1750 /* From ARM ABI: (S + A) | T */
1751 r->r_addend = (int)(long)
1752 (elf->symtab_start + ELF_R_SYM(r->r_info));
1757 case R_ARM_THM_CALL:
1758 case R_ARM_THM_JUMP24:
1759 case R_ARM_THM_JUMP19:
1760 /* From ARM ABI: ((S + A) | T) - P */
1761 r->r_addend = (int)(long)(elf->hdr +
1763 (r->r_offset - sechdr->sh_addr));
1771 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1773 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1774 unsigned int *location = reloc_location(elf, sechdr, r);
1777 if (r_typ == R_MIPS_HI16)
1778 return 1; /* skip this */
1779 inst = TO_NATIVE(*location);
1782 r->r_addend = inst & 0xffff;
1785 r->r_addend = (inst & 0x03ffffff) << 2;
1794 static void section_rela(const char *modname, struct elf_info *elf,
1801 const char *fromsec;
1803 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1804 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1806 fromsec = sech_name(elf, sechdr);
1807 fromsec += strlen(".rela");
1808 /* if from section (name) is know good then skip it */
1809 if (match(fromsec, section_white_list))
1812 for (rela = start; rela < stop; rela++) {
1813 r.r_offset = TO_NATIVE(rela->r_offset);
1814 #if KERNEL_ELFCLASS == ELFCLASS64
1815 if (elf->hdr->e_machine == EM_MIPS) {
1817 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1818 r_sym = TO_NATIVE(r_sym);
1819 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1820 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1822 r.r_info = TO_NATIVE(rela->r_info);
1823 r_sym = ELF_R_SYM(r.r_info);
1826 r.r_info = TO_NATIVE(rela->r_info);
1827 r_sym = ELF_R_SYM(r.r_info);
1829 r.r_addend = TO_NATIVE(rela->r_addend);
1830 sym = elf->symtab_start + r_sym;
1831 /* Skip special sections */
1832 if (is_shndx_special(sym->st_shndx))
1834 if (is_second_extable_reloc(start, rela, fromsec))
1835 find_extable_entry_size(fromsec, &r);
1836 check_section_mismatch(modname, elf, &r, sym, fromsec);
1840 static void section_rel(const char *modname, struct elf_info *elf,
1847 const char *fromsec;
1849 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1850 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1852 fromsec = sech_name(elf, sechdr);
1853 fromsec += strlen(".rel");
1854 /* if from section (name) is know good then skip it */
1855 if (match(fromsec, section_white_list))
1858 for (rel = start; rel < stop; rel++) {
1859 r.r_offset = TO_NATIVE(rel->r_offset);
1860 #if KERNEL_ELFCLASS == ELFCLASS64
1861 if (elf->hdr->e_machine == EM_MIPS) {
1863 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1864 r_sym = TO_NATIVE(r_sym);
1865 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1866 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1868 r.r_info = TO_NATIVE(rel->r_info);
1869 r_sym = ELF_R_SYM(r.r_info);
1872 r.r_info = TO_NATIVE(rel->r_info);
1873 r_sym = ELF_R_SYM(r.r_info);
1876 switch (elf->hdr->e_machine) {
1878 if (addend_386_rel(elf, sechdr, &r))
1882 if (addend_arm_rel(elf, sechdr, &r))
1886 if (addend_mips_rel(elf, sechdr, &r))
1890 sym = elf->symtab_start + r_sym;
1891 /* Skip special sections */
1892 if (is_shndx_special(sym->st_shndx))
1894 if (is_second_extable_reloc(start, rel, fromsec))
1895 find_extable_entry_size(fromsec, &r);
1896 check_section_mismatch(modname, elf, &r, sym, fromsec);
1901 * A module includes a number of sections that are discarded
1902 * either when loaded or when used as built-in.
1903 * For loaded modules all functions marked __init and all data
1904 * marked __initdata will be discarded when the module has been initialized.
1905 * Likewise for modules used built-in the sections marked __exit
1906 * are discarded because __exit marked function are supposed to be called
1907 * only when a module is unloaded which never happens for built-in modules.
1908 * The check_sec_ref() function traverses all relocation records
1909 * to find all references to a section that reference a section that will
1910 * be discarded and warns about it.
1912 static void check_sec_ref(struct module *mod, const char *modname,
1913 struct elf_info *elf)
1916 Elf_Shdr *sechdrs = elf->sechdrs;
1918 /* Walk through all sections */
1919 for (i = 0; i < elf->num_sections; i++) {
1920 check_section(modname, elf, &elf->sechdrs[i]);
1921 /* We want to process only relocation sections and not .init */
1922 if (sechdrs[i].sh_type == SHT_RELA)
1923 section_rela(modname, elf, &elf->sechdrs[i]);
1924 else if (sechdrs[i].sh_type == SHT_REL)
1925 section_rel(modname, elf, &elf->sechdrs[i]);
1929 static char *remove_dot(char *s)
1931 size_t n = strcspn(s, ".");
1934 size_t m = strspn(s + n + 1, "0123456789");
1935 if (m && (s[n + m] == '.' || s[n + m] == 0))
1941 static void read_symbols(const char *modname)
1943 const char *symname;
1947 struct elf_info info = { };
1950 if (!parse_elf(&info, modname))
1953 mod = new_module(modname);
1955 /* When there's no vmlinux, don't print warnings about
1956 * unresolved symbols (since there'll be too many ;) */
1957 if (is_vmlinux(modname)) {
1962 license = get_modinfo(&info, "license");
1963 if (!license && !is_vmlinux(modname))
1964 warn("modpost: missing MODULE_LICENSE() in %s\n"
1965 "see include/linux/module.h for "
1966 "more information\n", modname);
1968 if (license_is_gpl_compatible(license))
1969 mod->gpl_compatible = 1;
1971 mod->gpl_compatible = 0;
1974 license = get_next_modinfo(&info, "license", license);
1977 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1978 symname = remove_dot(info.strtab + sym->st_name);
1980 handle_modversions(mod, &info, sym, symname);
1981 handle_moddevtable(mod, &info, sym, symname);
1983 if (!is_vmlinux(modname) || vmlinux_section_warnings)
1984 check_sec_ref(mod, modname, &info);
1986 version = get_modinfo(&info, "version");
1988 maybe_frob_rcs_version(modname, version, info.modinfo,
1989 version - (char *)info.hdr);
1990 if (version || (all_versions && !is_vmlinux(modname)))
1991 get_src_version(modname, mod->srcversion,
1992 sizeof(mod->srcversion)-1);
1994 parse_elf_finish(&info);
1996 /* Our trick to get versioning for module struct etc. - it's
1997 * never passed as an argument to an exported function, so
1998 * the automatic versioning doesn't pick it up, but it's really
1999 * important anyhow */
2001 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
2004 static void read_symbols_from_files(const char *filename)
2007 char fname[PATH_MAX];
2009 if (strcmp(filename, "-") != 0) {
2010 in = fopen(filename, "r");
2012 fatal("Can't open filenames file %s: %m", filename);
2015 while (fgets(fname, PATH_MAX, in) != NULL) {
2016 if (strends(fname, "\n"))
2017 fname[strlen(fname)-1] = '\0';
2018 read_symbols(fname);
2027 /* We first write the generated file into memory using the
2028 * following helper, then compare to the file on disk and
2029 * only update the later if anything changed */
2031 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2032 const char *fmt, ...)
2039 len = vsnprintf(tmp, SZ, fmt, ap);
2040 buf_write(buf, tmp, len);
2044 void buf_write(struct buffer *buf, const char *s, int len)
2046 if (buf->size - buf->pos < len) {
2047 buf->size += len + SZ;
2048 buf->p = NOFAIL(realloc(buf->p, buf->size));
2050 strncpy(buf->p + buf->pos, s, len);
2054 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2056 const char *e = is_vmlinux(m) ?"":".ko";
2060 fatal("modpost: GPL-incompatible module %s%s "
2061 "uses GPL-only symbol '%s'\n", m, e, s);
2063 case export_unused_gpl:
2064 fatal("modpost: GPL-incompatible module %s%s "
2065 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2067 case export_gpl_future:
2068 warn("modpost: GPL-incompatible module %s%s "
2069 "uses future GPL-only symbol '%s'\n", m, e, s);
2073 case export_unknown:
2079 static void check_for_unused(enum export exp, const char *m, const char *s)
2081 const char *e = is_vmlinux(m) ?"":".ko";
2085 case export_unused_gpl:
2086 warn("modpost: module %s%s "
2087 "uses symbol '%s' marked UNUSED\n", m, e, s);
2095 static int check_exports(struct module *mod)
2097 struct symbol *s, *exp;
2100 for (s = mod->unres; s; s = s->next) {
2101 const char *basename;
2102 exp = find_symbol(s->name);
2103 if (!exp || exp->module == mod) {
2104 if (have_vmlinux && !s->weak) {
2105 if (warn_unresolved) {
2106 warn("\"%s\" [%s.ko] undefined!\n",
2107 s->name, mod->name);
2109 merror("\"%s\" [%s.ko] undefined!\n",
2110 s->name, mod->name);
2116 basename = strrchr(mod->name, '/');
2120 basename = mod->name;
2121 if (!mod->gpl_compatible)
2122 check_for_gpl_usage(exp->export, basename, exp->name);
2123 check_for_unused(exp->export, basename, exp->name);
2129 static int check_modname_len(struct module *mod)
2131 const char *mod_name;
2133 mod_name = strrchr(mod->name, '/');
2134 if (mod_name == NULL)
2135 mod_name = mod->name;
2138 if (strlen(mod_name) >= MODULE_NAME_LEN) {
2139 merror("module name is too long [%s.ko]\n", mod->name);
2147 * Header for the generated file
2149 static void add_header(struct buffer *b, struct module *mod)
2151 buf_printf(b, "#include <linux/build-salt.h>\n");
2152 buf_printf(b, "#include <linux/module.h>\n");
2153 buf_printf(b, "#include <linux/vermagic.h>\n");
2154 buf_printf(b, "#include <linux/compiler.h>\n");
2155 buf_printf(b, "\n");
2156 buf_printf(b, "BUILD_SALT;\n");
2157 buf_printf(b, "\n");
2158 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2159 buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
2160 buf_printf(b, "\n");
2161 buf_printf(b, "__visible struct module __this_module\n");
2162 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
2163 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2165 buf_printf(b, "\t.init = init_module,\n");
2166 if (mod->has_cleanup)
2167 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2168 "\t.exit = cleanup_module,\n"
2170 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2171 buf_printf(b, "};\n");
2174 static void add_intree_flag(struct buffer *b, int is_intree)
2177 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2180 /* Cannot check for assembler */
2181 static void add_retpoline(struct buffer *b)
2183 buf_printf(b, "\n#ifdef CONFIG_RETPOLINE\n");
2184 buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n");
2185 buf_printf(b, "#endif\n");
2188 static void add_staging_flag(struct buffer *b, const char *name)
2190 if (strstarts(name, "drivers/staging"))
2191 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2195 * Record CRCs for unresolved symbols
2197 static int add_versions(struct buffer *b, struct module *mod)
2199 struct symbol *s, *exp;
2202 for (s = mod->unres; s; s = s->next) {
2203 exp = find_symbol(s->name);
2204 if (!exp || exp->module == mod)
2206 s->module = exp->module;
2207 s->crc_valid = exp->crc_valid;
2214 buf_printf(b, "\n");
2215 buf_printf(b, "static const struct modversion_info ____versions[]\n");
2216 buf_printf(b, "__used\n");
2217 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2219 for (s = mod->unres; s; s = s->next) {
2222 if (!s->crc_valid) {
2223 warn("\"%s\" [%s.ko] has no CRC!\n",
2224 s->name, mod->name);
2227 if (strlen(s->name) >= MODULE_NAME_LEN) {
2228 merror("too long symbol \"%s\" [%s.ko]\n",
2229 s->name, mod->name);
2233 buf_printf(b, "\t{ %#8x, \"%s\" },\n",
2237 buf_printf(b, "};\n");
2242 static void add_depends(struct buffer *b, struct module *mod)
2247 /* Clear ->seen flag of modules that own symbols needed by this. */
2248 for (s = mod->unres; s; s = s->next)
2250 s->module->seen = is_vmlinux(s->module->name);
2252 buf_printf(b, "\n");
2253 buf_printf(b, "static const char __module_depends[]\n");
2254 buf_printf(b, "__used\n");
2255 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2256 buf_printf(b, "\"depends=");
2257 for (s = mod->unres; s; s = s->next) {
2262 if (s->module->seen)
2265 s->module->seen = 1;
2266 p = strrchr(s->module->name, '/');
2270 p = s->module->name;
2271 buf_printf(b, "%s%s", first ? "" : ",", p);
2274 buf_printf(b, "\";\n");
2277 static void add_srcversion(struct buffer *b, struct module *mod)
2279 if (mod->srcversion[0]) {
2280 buf_printf(b, "\n");
2281 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2286 static void write_if_changed(struct buffer *b, const char *fname)
2292 file = fopen(fname, "r");
2296 if (fstat(fileno(file), &st) < 0)
2299 if (st.st_size != b->pos)
2302 tmp = NOFAIL(malloc(b->pos));
2303 if (fread(tmp, 1, b->pos, file) != b->pos)
2306 if (memcmp(tmp, b->p, b->pos) != 0)
2318 file = fopen(fname, "w");
2323 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2330 /* parse Module.symvers file. line format:
2331 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2333 static void read_dump(const char *fname, unsigned int kernel)
2335 unsigned long size, pos = 0;
2336 void *file = grab_file(fname, &size);
2340 /* No symbol versions, silently ignore */
2343 while ((line = get_next_line(&pos, file, size))) {
2344 char *symname, *modname, *d, *export, *end;
2349 if (!(symname = strchr(line, '\t')))
2352 if (!(modname = strchr(symname, '\t')))
2355 if ((export = strchr(modname, '\t')) != NULL)
2357 if (export && ((end = strchr(export, '\t')) != NULL))
2359 crc = strtoul(line, &d, 16);
2360 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2362 mod = find_module(modname);
2364 if (is_vmlinux(modname))
2366 mod = new_module(modname);
2369 s = sym_add_exported(symname, mod, export_no(export));
2372 sym_update_crc(symname, mod, crc, export_no(export));
2374 release_file(file, size);
2377 release_file(file, size);
2378 fatal("parse error in symbol dump file\n");
2381 /* For normal builds always dump all symbols.
2382 * For external modules only dump symbols
2383 * that are not read from kernel Module.symvers.
2385 static int dump_sym(struct symbol *sym)
2387 if (!external_module)
2389 if (sym->vmlinux || sym->kernel)
2394 static void write_dump(const char *fname)
2396 struct buffer buf = { };
2397 struct symbol *symbol;
2400 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2401 symbol = symbolhash[n];
2403 if (dump_sym(symbol))
2404 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2405 symbol->crc, symbol->name,
2406 symbol->module->name,
2407 export_str(symbol->export));
2408 symbol = symbol->next;
2411 write_if_changed(&buf, fname);
2415 struct ext_sym_list {
2416 struct ext_sym_list *next;
2420 int main(int argc, char **argv)
2423 struct buffer buf = { };
2424 char *kernel_read = NULL, *module_read = NULL;
2425 char *dump_write = NULL, *files_source = NULL;
2428 struct ext_sym_list *extsym_iter;
2429 struct ext_sym_list *extsym_start = NULL;
2431 while ((opt = getopt(argc, argv, "i:I:e:mnsT:o:awE")) != -1) {
2434 kernel_read = optarg;
2437 module_read = optarg;
2438 external_module = 1;
2441 external_module = 1;
2443 NOFAIL(malloc(sizeof(*extsym_iter)));
2444 extsym_iter->next = extsym_start;
2445 extsym_iter->file = optarg;
2446 extsym_start = extsym_iter;
2452 ignore_missing_files = 1;
2455 dump_write = optarg;
2461 vmlinux_section_warnings = 0;
2464 files_source = optarg;
2467 warn_unresolved = 1;
2470 sec_mismatch_fatal = 1;
2478 read_dump(kernel_read, 1);
2480 read_dump(module_read, 0);
2481 while (extsym_start) {
2482 read_dump(extsym_start->file, 0);
2483 extsym_iter = extsym_start->next;
2485 extsym_start = extsym_iter;
2488 while (optind < argc)
2489 read_symbols(argv[optind++]);
2492 read_symbols_from_files(files_source);
2496 for (mod = modules; mod; mod = mod->next) {
2497 char fname[PATH_MAX];
2504 err |= check_modname_len(mod);
2505 err |= check_exports(mod);
2506 add_header(&buf, mod);
2507 add_intree_flag(&buf, !external_module);
2508 add_retpoline(&buf);
2509 add_staging_flag(&buf, mod->name);
2510 err |= add_versions(&buf, mod);
2511 add_depends(&buf, mod);
2512 add_moddevtable(&buf, mod);
2513 add_srcversion(&buf, mod);
2515 sprintf(fname, "%s.mod.c", mod->name);
2516 write_if_changed(&buf, fname);
2519 write_dump(dump_write);
2520 if (sec_mismatch_count && sec_mismatch_fatal)
2521 fatal("modpost: Section mismatches detected.\n"
2522 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");