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/generated/autoconf.h"
23 #include "../../include/linux/license.h"
24 #include "../../include/linux/export.h"
26 /* Are we using CONFIG_MODVERSIONS? */
27 static int modversions = 0;
28 /* Warn about undefined symbols? (do so if we have vmlinux) */
29 static int have_vmlinux = 0;
30 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
31 static int all_versions = 0;
32 /* If we are modposting external module set to 1 */
33 static int external_module = 0;
34 /* Warn about section mismatch in vmlinux if set to 1 */
35 static int vmlinux_section_warnings = 1;
36 /* Only warn about unresolved symbols */
37 static int warn_unresolved = 0;
38 /* How a symbol is exported */
39 static int sec_mismatch_count = 0;
40 static int sec_mismatch_verbose = 1;
41 static int sec_mismatch_fatal = 0;
42 /* ignore missing files */
43 static int ignore_missing_files;
46 export_plain, export_unused, export_gpl,
47 export_unused_gpl, export_gpl_future, export_unknown
50 #define PRINTF __attribute__ ((format (printf, 1, 2)))
52 PRINTF void fatal(const char *fmt, ...)
56 fprintf(stderr, "FATAL: ");
58 va_start(arglist, fmt);
59 vfprintf(stderr, fmt, arglist);
65 PRINTF void warn(const char *fmt, ...)
69 fprintf(stderr, "WARNING: ");
71 va_start(arglist, fmt);
72 vfprintf(stderr, fmt, arglist);
76 PRINTF void merror(const char *fmt, ...)
80 fprintf(stderr, "ERROR: ");
82 va_start(arglist, fmt);
83 vfprintf(stderr, fmt, arglist);
87 static inline bool strends(const char *str, const char *postfix)
89 if (strlen(str) < strlen(postfix))
92 return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
95 static int is_vmlinux(const char *modname)
99 myname = strrchr(modname, '/');
105 return (strcmp(myname, "vmlinux") == 0) ||
106 (strcmp(myname, "vmlinux.o") == 0);
109 void *do_nofail(void *ptr, const char *expr)
112 fatal("modpost: Memory allocation failure: %s.\n", expr);
117 /* A list of all modules we processed */
118 static struct module *modules;
120 static struct module *find_module(char *modname)
124 for (mod = modules; mod; mod = mod->next)
125 if (strcmp(mod->name, modname) == 0)
130 static struct module *new_module(const char *modname)
135 mod = NOFAIL(malloc(sizeof(*mod)));
136 memset(mod, 0, sizeof(*mod));
137 p = NOFAIL(strdup(modname));
139 /* strip trailing .o */
140 if (strends(p, ".o")) {
141 p[strlen(p) - 2] = '\0';
147 mod->gpl_compatible = -1;
154 /* A hash of all exported symbols,
155 * struct symbol is also used for lists of unresolved symbols */
157 #define SYMBOL_HASH_SIZE 1024
161 struct module *module;
165 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */
166 unsigned int kernel:1; /* 1 if symbol is from kernel
167 * (only for external modules) **/
168 unsigned int preloaded:1; /* 1 if symbol from Module.symvers, or crc */
169 enum export export; /* Type of export */
173 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
175 /* This is based on the hash agorithm from gdbm, via tdb */
176 static inline unsigned int tdb_hash(const char *name)
178 unsigned value; /* Used to compute the hash value. */
179 unsigned i; /* Used to cycle through random values. */
181 /* Set the initial value from the key size. */
182 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
183 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
185 return (1103515243 * value + 12345);
189 * Allocate a new symbols for use in the hash of exported symbols or
190 * the list of unresolved symbols per module
192 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
195 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
197 memset(s, 0, sizeof(*s));
198 strcpy(s->name, name);
204 /* For the hash of exported symbols */
205 static struct symbol *new_symbol(const char *name, struct module *module,
211 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
212 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
213 new->module = module;
214 new->export = export;
218 static struct symbol *find_symbol(const char *name)
222 /* For our purposes, .foo matches foo. PPC64 needs this. */
226 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
227 if (strcmp(s->name, name) == 0)
233 static const struct {
237 { .str = "EXPORT_SYMBOL", .export = export_plain },
238 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
239 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
240 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
241 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
242 { .str = "(unknown)", .export = export_unknown },
246 static const char *export_str(enum export ex)
248 return export_list[ex].str;
251 static enum export export_no(const char *s)
256 return export_unknown;
257 for (i = 0; export_list[i].export != export_unknown; i++) {
258 if (strcmp(export_list[i].str, s) == 0)
259 return export_list[i].export;
261 return export_unknown;
264 static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
266 return (void *)elf->hdr +
267 elf->sechdrs[elf->secindex_strings].sh_offset +
271 static const char *sec_name(struct elf_info *elf, int secindex)
273 return sech_name(elf, &elf->sechdrs[secindex]);
276 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
278 static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
280 const char *secname = sec_name(elf, sec);
282 if (strstarts(secname, "___ksymtab+"))
284 else if (strstarts(secname, "___ksymtab_unused+"))
285 return export_unused;
286 else if (strstarts(secname, "___ksymtab_gpl+"))
288 else if (strstarts(secname, "___ksymtab_unused_gpl+"))
289 return export_unused_gpl;
290 else if (strstarts(secname, "___ksymtab_gpl_future+"))
291 return export_gpl_future;
293 return export_unknown;
296 static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
298 if (sec == elf->export_sec)
300 else if (sec == elf->export_unused_sec)
301 return export_unused;
302 else if (sec == elf->export_gpl_sec)
304 else if (sec == elf->export_unused_gpl_sec)
305 return export_unused_gpl;
306 else if (sec == elf->export_gpl_future_sec)
307 return export_gpl_future;
309 return export_unknown;
313 * Add an exported symbol - it may have already been added without a
314 * CRC, in this case just update the CRC
316 static struct symbol *sym_add_exported(const char *name, struct module *mod,
319 struct symbol *s = find_symbol(name);
322 s = new_symbol(name, mod, export);
325 warn("%s: '%s' exported twice. Previous export "
326 "was in %s%s\n", mod->name, name,
328 is_vmlinux(s->module->name) ?"":".ko");
330 /* In case Module.symvers was out of date */
335 s->vmlinux = is_vmlinux(mod->name);
341 static void sym_update_crc(const char *name, struct module *mod,
342 unsigned int crc, enum export export)
344 struct symbol *s = find_symbol(name);
347 s = new_symbol(name, mod, export);
348 /* Don't complain when we find it later. */
355 void *grab_file(const char *filename, unsigned long *size)
358 void *map = MAP_FAILED;
361 fd = open(filename, O_RDONLY);
368 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
372 if (map == MAP_FAILED)
378 * Return a copy of the next line in a mmap'ed file.
379 * spaces in the beginning of the line is trimmed away.
380 * Return a pointer to a static buffer.
382 char *get_next_line(unsigned long *pos, void *file, unsigned long size)
384 static char line[4096];
387 signed char *p = (signed char *)file + *pos;
390 for (; *pos < size ; (*pos)++) {
391 if (skip && isspace(*p)) {
396 if (*p != '\n' && (*pos < size)) {
400 break; /* Too long, stop */
411 void release_file(void *file, unsigned long size)
416 static int parse_elf(struct elf_info *info, const char *filename)
422 const char *secstrings;
423 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
425 hdr = grab_file(filename, &info->size);
427 if (ignore_missing_files) {
428 fprintf(stderr, "%s: %s (ignored)\n", filename,
436 if (info->size < sizeof(*hdr)) {
437 /* file too small, assume this is an empty .o file */
440 /* Is this a valid ELF file? */
441 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
442 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
443 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
444 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
445 /* Not an ELF file - silently ignore it */
448 /* Fix endianness in ELF header */
449 hdr->e_type = TO_NATIVE(hdr->e_type);
450 hdr->e_machine = TO_NATIVE(hdr->e_machine);
451 hdr->e_version = TO_NATIVE(hdr->e_version);
452 hdr->e_entry = TO_NATIVE(hdr->e_entry);
453 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
454 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
455 hdr->e_flags = TO_NATIVE(hdr->e_flags);
456 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
457 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
458 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
459 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
460 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
461 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
462 sechdrs = (void *)hdr + hdr->e_shoff;
463 info->sechdrs = sechdrs;
465 /* Check if file offset is correct */
466 if (hdr->e_shoff > info->size) {
467 fatal("section header offset=%lu in file '%s' is bigger than "
468 "filesize=%lu\n", (unsigned long)hdr->e_shoff,
469 filename, info->size);
473 if (hdr->e_shnum == SHN_UNDEF) {
475 * There are more than 64k sections,
476 * read count from .sh_size.
478 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
481 info->num_sections = hdr->e_shnum;
483 if (hdr->e_shstrndx == SHN_XINDEX) {
484 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
487 info->secindex_strings = hdr->e_shstrndx;
490 /* Fix endianness in section headers */
491 for (i = 0; i < info->num_sections; i++) {
492 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
493 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
494 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
495 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
496 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
497 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
498 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
499 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
500 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
501 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
503 /* Find symbol table. */
504 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
505 for (i = 1; i < info->num_sections; i++) {
507 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
509 if (!nobits && sechdrs[i].sh_offset > info->size) {
510 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
511 "sizeof(*hrd)=%zu\n", filename,
512 (unsigned long)sechdrs[i].sh_offset,
516 secname = secstrings + sechdrs[i].sh_name;
517 if (strcmp(secname, ".modinfo") == 0) {
519 fatal("%s has NOBITS .modinfo\n", filename);
520 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
521 info->modinfo_len = sechdrs[i].sh_size;
522 } else if (strcmp(secname, "__ksymtab") == 0)
523 info->export_sec = i;
524 else if (strcmp(secname, "__ksymtab_unused") == 0)
525 info->export_unused_sec = i;
526 else if (strcmp(secname, "__ksymtab_gpl") == 0)
527 info->export_gpl_sec = i;
528 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
529 info->export_unused_gpl_sec = i;
530 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
531 info->export_gpl_future_sec = i;
533 if (sechdrs[i].sh_type == SHT_SYMTAB) {
534 unsigned int sh_link_idx;
536 info->symtab_start = (void *)hdr +
537 sechdrs[i].sh_offset;
538 info->symtab_stop = (void *)hdr +
539 sechdrs[i].sh_offset + sechdrs[i].sh_size;
540 sh_link_idx = sechdrs[i].sh_link;
541 info->strtab = (void *)hdr +
542 sechdrs[sh_link_idx].sh_offset;
545 /* 32bit section no. table? ("more than 64k sections") */
546 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
547 symtab_shndx_idx = i;
548 info->symtab_shndx_start = (void *)hdr +
549 sechdrs[i].sh_offset;
550 info->symtab_shndx_stop = (void *)hdr +
551 sechdrs[i].sh_offset + sechdrs[i].sh_size;
554 if (!info->symtab_start)
555 fatal("%s has no symtab?\n", filename);
557 /* Fix endianness in symbols */
558 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
559 sym->st_shndx = TO_NATIVE(sym->st_shndx);
560 sym->st_name = TO_NATIVE(sym->st_name);
561 sym->st_value = TO_NATIVE(sym->st_value);
562 sym->st_size = TO_NATIVE(sym->st_size);
565 if (symtab_shndx_idx != ~0U) {
567 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
568 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
569 filename, sechdrs[symtab_shndx_idx].sh_link,
572 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
580 static void parse_elf_finish(struct elf_info *info)
582 release_file(info->hdr, info->size);
585 static int ignore_undef_symbol(struct elf_info *info, const char *symname)
587 /* ignore __this_module, it will be resolved shortly */
588 if (strcmp(symname, VMLINUX_SYMBOL_STR(__this_module)) == 0)
590 /* ignore global offset table */
591 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
593 if (info->hdr->e_machine == EM_PPC)
594 /* Special register function linked on all modules during final link of .ko */
595 if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
596 strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
597 strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
598 strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0 ||
599 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
600 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
602 if (info->hdr->e_machine == EM_PPC64)
603 /* Special register function linked on all modules during final link of .ko */
604 if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
605 strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0 ||
606 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
607 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0 ||
608 strcmp(symname, ".TOC.") == 0)
610 /* Do not ignore this symbol */
614 #define CRC_PFX VMLINUX_SYMBOL_STR(__crc_)
615 #define KSYMTAB_PFX VMLINUX_SYMBOL_STR(__ksymtab_)
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 strncmp(symname, "__ksymtab", 9) == 0)
626 export = export_from_secname(info, get_secindex(info, sym));
628 export = export_from_sec(info, get_secindex(info, sym));
631 if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
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);
644 sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
648 switch (sym->st_shndx) {
650 if (!strncmp(symname, "__gnu_lto_", sizeof("__gnu_lto_")-1)) {
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 = strdup(symname);
676 munged[1] = toupper(munged[1]);
682 #ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
683 if (symname[0] != '_')
689 const char *e = is_vmlinux(mod->name) ?"":".ko";
690 warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n", symname + strlen(CRC_PFX), mod->name, e);
692 mod->unres = alloc_symbol(symname,
693 ELF_ST_BIND(sym->st_info) == STB_WEAK,
697 /* All exported symbols */
698 if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
699 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
702 if (strcmp(symname, VMLINUX_SYMBOL_STR(init_module)) == 0)
704 if (strcmp(symname, VMLINUX_SYMBOL_STR(cleanup_module)) == 0)
705 mod->has_cleanup = 1;
711 * Parse tag=value strings from .modinfo section
713 static char *next_string(char *string, unsigned long *secsize)
715 /* Skip non-zero chars */
718 if ((*secsize)-- <= 1)
722 /* Skip any zero padding. */
725 if ((*secsize)-- <= 1)
731 static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
732 const char *tag, char *info)
735 unsigned int taglen = strlen(tag);
736 unsigned long size = modinfo_len;
739 size -= info - (char *)modinfo;
740 modinfo = next_string(info, &size);
743 for (p = modinfo; p; p = next_string(p, &size)) {
744 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
745 return p + taglen + 1;
750 static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
754 return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
758 * Test if string s ends in string sub
761 static int strrcmp(const char *s, const char *sub)
769 sublen = strlen(sub);
771 if ((slen == 0) || (sublen == 0))
777 return memcmp(s + slen - sublen, sub, sublen);
780 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
783 return elf->strtab + sym->st_name;
788 /* The pattern is an array of simple patterns.
789 * "foo" will match an exact string equal to "foo"
790 * "*foo" will match a string that ends with "foo"
791 * "foo*" will match a string that begins with "foo"
792 * "*foo*" will match a string that contains "foo"
794 static int match(const char *sym, const char * const pat[])
799 const char *endp = p + strlen(p) - 1;
802 if (*p == '*' && *endp == '*') {
803 char *here, *bare = strndup(p + 1, strlen(p) - 2);
805 here = strstr(sym, bare);
811 else if (*p == '*') {
812 if (strrcmp(sym, p + 1) == 0)
816 else if (*endp == '*') {
817 if (strncmp(sym, p, strlen(p) - 1) == 0)
822 if (strcmp(p, sym) == 0)
830 /* sections that we do not want to do full section mismatch check on */
831 static const char *const section_white_list[] =
835 ".cranges", /* sh64 */
836 ".zdebug*", /* Compressed debug sections. */
837 ".GCC-command-line", /* mn10300 */
838 ".GCC.command.line", /* record-gcc-switches, non mn10300 */
839 ".mdebug*", /* alpha, score, mips etc. */
840 ".pdr", /* alpha, score, mips etc. */
845 ".xt.prop", /* xtensa */
846 ".xt.lit", /* xtensa */
847 ".arcextmap*", /* arc */
848 ".gnu.linkonce.arcext*", /* arc : modules */
849 ".cmem*", /* EZchip */
850 ".fmt_slot*", /* EZchip */
857 * This is used to find sections missing the SHF_ALLOC flag.
858 * The cause of this is often a section specified in assembler
859 * without "ax" / "aw".
861 static void check_section(const char *modname, struct elf_info *elf,
864 const char *sec = sech_name(elf, sechdr);
866 if (sechdr->sh_type == SHT_PROGBITS &&
867 !(sechdr->sh_flags & SHF_ALLOC) &&
868 !match(sec, section_white_list)) {
869 warn("%s (%s): unexpected non-allocatable section.\n"
870 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
871 "Note that for example <linux/init.h> contains\n"
872 "section definitions for use in .S files.\n\n",
879 #define ALL_INIT_DATA_SECTIONS \
880 ".init.setup", ".init.rodata", ".meminit.rodata", \
881 ".init.data", ".meminit.data"
882 #define ALL_EXIT_DATA_SECTIONS \
883 ".exit.data", ".memexit.data"
885 #define ALL_INIT_TEXT_SECTIONS \
886 ".init.text", ".meminit.text"
887 #define ALL_EXIT_TEXT_SECTIONS \
888 ".exit.text", ".memexit.text"
890 #define ALL_PCI_INIT_SECTIONS \
891 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
892 ".pci_fixup_enable", ".pci_fixup_resume", \
893 ".pci_fixup_resume_early", ".pci_fixup_suspend"
895 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
896 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
898 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
899 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
901 #define DATA_SECTIONS ".data", ".data.rel"
902 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
903 ".kprobes.text", ".cpuidle.text"
904 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
905 ".fixup", ".entry.text", ".exception.text", ".text.*", \
908 #define INIT_SECTIONS ".init.*"
909 #define MEM_INIT_SECTIONS ".meminit.*"
911 #define EXIT_SECTIONS ".exit.*"
912 #define MEM_EXIT_SECTIONS ".memexit.*"
914 #define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
915 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
917 /* init data sections */
918 static const char *const init_data_sections[] =
919 { ALL_INIT_DATA_SECTIONS, NULL };
921 /* all init sections */
922 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
924 /* All init and exit sections (code + data) */
925 static const char *const init_exit_sections[] =
926 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
928 /* all text sections */
929 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
932 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
935 /* symbols in .data that may refer to init/exit sections */
936 #define DEFAULT_SYMBOL_WHITE_LIST \
938 "*_template", /* scsi uses *_template a lot */ \
939 "*_timer", /* arm uses ops structures named _timer a lot */ \
940 "*_sht", /* scsi also used *_sht to some extent */ \
946 static const char *const head_sections[] = { ".head.text*", NULL };
947 static const char *const linker_symbols[] =
948 { "__init_begin", "_sinittext", "_einittext", NULL };
949 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
956 XXXINIT_TO_SOME_INIT,
957 XXXEXIT_TO_SOME_EXIT,
958 ANY_INIT_TO_ANY_EXIT,
959 ANY_EXIT_TO_ANY_INIT,
965 * Describe how to match sections on different criterias:
967 * @fromsec: Array of sections to be matched.
969 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
970 * this array is forbidden (black-list). Can be empty.
972 * @good_tosec: Relocations applied to a section in @fromsec must be
973 * targetting sections in this array (white-list). Can be empty.
975 * @mismatch: Type of mismatch.
977 * @symbol_white_list: Do not match a relocation to a symbol in this list
978 * even if it is targetting a section in @bad_to_sec.
980 * @handler: Specific handler to call when a match is found. If NULL,
981 * default_mismatch_handler() will be called.
984 struct sectioncheck {
985 const char *fromsec[20];
986 const char *bad_tosec[20];
987 const char *good_tosec[20];
988 enum mismatch mismatch;
989 const char *symbol_white_list[20];
990 void (*handler)(const char *modname, struct elf_info *elf,
991 const struct sectioncheck* const mismatch,
992 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
996 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
997 const struct sectioncheck* const mismatch,
998 Elf_Rela *r, Elf_Sym *sym,
999 const char *fromsec);
1001 static const struct sectioncheck sectioncheck[] = {
1002 /* Do not reference init/exit code/data from
1003 * normal code and data
1006 .fromsec = { TEXT_SECTIONS, NULL },
1007 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1008 .mismatch = TEXT_TO_ANY_INIT,
1009 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1012 .fromsec = { DATA_SECTIONS, NULL },
1013 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1014 .mismatch = DATA_TO_ANY_INIT,
1015 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1018 .fromsec = { DATA_SECTIONS, NULL },
1019 .bad_tosec = { INIT_SECTIONS, NULL },
1020 .mismatch = DATA_TO_ANY_INIT,
1021 .symbol_white_list = {
1022 "*_template", "*_timer", "*_sht", "*_ops",
1023 "*_probe", "*_probe_one", "*_console", NULL
1027 .fromsec = { TEXT_SECTIONS, NULL },
1028 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1029 .mismatch = TEXT_TO_ANY_EXIT,
1030 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1033 .fromsec = { DATA_SECTIONS, NULL },
1034 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1035 .mismatch = DATA_TO_ANY_EXIT,
1036 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1038 /* Do not reference init code/data from meminit code/data */
1040 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1041 .bad_tosec = { INIT_SECTIONS, NULL },
1042 .mismatch = XXXINIT_TO_SOME_INIT,
1043 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1045 /* Do not reference exit code/data from memexit code/data */
1047 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1048 .bad_tosec = { EXIT_SECTIONS, NULL },
1049 .mismatch = XXXEXIT_TO_SOME_EXIT,
1050 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1052 /* Do not use exit code/data from init code */
1054 .fromsec = { ALL_INIT_SECTIONS, NULL },
1055 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1056 .mismatch = ANY_INIT_TO_ANY_EXIT,
1057 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1059 /* Do not use init code/data from exit code */
1061 .fromsec = { ALL_EXIT_SECTIONS, NULL },
1062 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1063 .mismatch = ANY_EXIT_TO_ANY_INIT,
1064 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1067 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1068 .bad_tosec = { INIT_SECTIONS, NULL },
1069 .mismatch = ANY_INIT_TO_ANY_EXIT,
1070 .symbol_white_list = { NULL },
1072 /* Do not export init/exit functions or data */
1074 .fromsec = { "__ksymtab*", NULL },
1075 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1076 .mismatch = EXPORT_TO_INIT_EXIT,
1077 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1080 .fromsec = { "__ex_table", NULL },
1081 /* If you're adding any new black-listed sections in here, consider
1082 * adding a special 'printer' for them in scripts/check_extable.
1084 .bad_tosec = { ".altinstr_replacement", NULL },
1085 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1086 .mismatch = EXTABLE_TO_NON_TEXT,
1087 .handler = extable_mismatch_handler,
1091 static const struct sectioncheck *section_mismatch(
1092 const char *fromsec, const char *tosec)
1095 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1096 const struct sectioncheck *check = §ioncheck[0];
1099 * The target section could be the SHT_NUL section when we're
1100 * handling relocations to un-resolved symbols, trying to match it
1101 * doesn't make much sense and causes build failures on parisc and
1102 * mn10300 architectures.
1107 for (i = 0; i < elems; i++) {
1108 if (match(fromsec, check->fromsec)) {
1109 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1111 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1120 * Whitelist to allow certain references to pass with no warning.
1123 * If a module parameter is declared __initdata and permissions=0
1124 * then this is legal despite the warning generated.
1125 * We cannot see value of permissions here, so just ignore
1127 * The pattern is identified by:
1128 * tosec = .init.data
1133 * module_param_call() ops can refer to __init set function if permissions=0
1134 * The pattern is identified by:
1135 * tosec = .init.text
1137 * atsym = __param_ops_*
1140 * Many drivers utilise a *driver container with references to
1141 * add, remove, probe functions etc.
1142 * the pattern is identified by:
1143 * tosec = init or exit section
1144 * fromsec = data section
1145 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1146 * *probe_one, *_console, *_timer
1149 * Whitelist all references from .head.text to any init section
1152 * Some symbols belong to init section but still it is ok to reference
1153 * these from non-init sections as these symbols don't have any memory
1154 * allocated for them and symbol address and value are same. So even
1155 * if init section is freed, its ok to reference those symbols.
1156 * For ex. symbols marking the init section boundaries.
1157 * This pattern is identified by
1158 * refsymname = __init_begin, _sinittext, _einittext
1161 * GCC may optimize static inlines when fed constant arg(s) resulting
1162 * in functions like cpumask_empty() -- generating an associated symbol
1163 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1164 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1165 * meaningless section warning. May need to add isra symbols too...
1166 * This pattern is identified by
1167 * tosec = init section
1168 * fromsec = text section
1169 * refsymname = *.constprop.*
1172 static int secref_whitelist(const struct sectioncheck *mismatch,
1173 const char *fromsec, const char *fromsym,
1174 const char *tosec, const char *tosym)
1176 /* Check for pattern 1 */
1177 if (match(tosec, init_data_sections) &&
1178 match(fromsec, data_sections) &&
1179 (strncmp(fromsym, "__param", strlen("__param")) == 0))
1182 /* Check for pattern 1a */
1183 if (strcmp(tosec, ".init.text") == 0 &&
1184 match(fromsec, data_sections) &&
1185 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1188 /* Check for pattern 2 */
1189 if (match(tosec, init_exit_sections) &&
1190 match(fromsec, data_sections) &&
1191 match(fromsym, mismatch->symbol_white_list))
1194 /* Check for pattern 3 */
1195 if (match(fromsec, head_sections) &&
1196 match(tosec, init_sections))
1199 /* Check for pattern 4 */
1200 if (match(tosym, linker_symbols))
1203 /* Check for pattern 5 */
1204 if (match(fromsec, text_sections) &&
1205 match(tosec, init_sections) &&
1206 match(fromsym, optim_symbols))
1213 * Find symbol based on relocation record info.
1214 * In some cases the symbol supplied is a valid symbol so
1215 * return refsym. If st_name != 0 we assume this is a valid symbol.
1216 * In other cases the symbol needs to be looked up in the symbol table
1217 * based on section and address.
1219 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1223 Elf_Sym *near = NULL;
1224 Elf64_Sword distance = 20;
1226 unsigned int relsym_secindex;
1228 if (relsym->st_name != 0)
1231 relsym_secindex = get_secindex(elf, relsym);
1232 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1233 if (get_secindex(elf, sym) != relsym_secindex)
1235 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1237 if (sym->st_value == addr)
1239 /* Find a symbol nearby - addr are maybe negative */
1240 d = sym->st_value - addr;
1242 d = addr - sym->st_value;
1248 /* We need a close match */
1255 static inline int is_arm_mapping_symbol(const char *str)
1257 return str[0] == '$' && strchr("axtd", str[1])
1258 && (str[2] == '\0' || str[2] == '.');
1262 * If there's no name there, ignore it; likewise, ignore it if it's
1263 * one of the magic symbols emitted used by current ARM tools.
1265 * Otherwise if find_symbols_between() returns those symbols, they'll
1266 * fail the whitelist tests and cause lots of false alarms ... fixable
1267 * only by merging __exit and __init sections into __text, bloating
1268 * the kernel (which is especially evil on embedded platforms).
1270 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1272 const char *name = elf->strtab + sym->st_name;
1274 if (!name || !strlen(name))
1276 return !is_arm_mapping_symbol(name);
1280 * Find symbols before or equal addr and after addr - in the section sec.
1281 * If we find two symbols with equal offset prefer one with a valid name.
1282 * The ELF format may have a better way to detect what type of symbol
1283 * it is, but this works for now.
1285 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1289 Elf_Sym *near = NULL;
1290 Elf_Addr distance = ~0;
1292 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1295 if (is_shndx_special(sym->st_shndx))
1297 symsec = sec_name(elf, get_secindex(elf, sym));
1298 if (strcmp(symsec, sec) != 0)
1300 if (!is_valid_name(elf, sym))
1302 if (sym->st_value <= addr) {
1303 if ((addr - sym->st_value) < distance) {
1304 distance = addr - sym->st_value;
1306 } else if ((addr - sym->st_value) == distance) {
1315 * Convert a section name to the function/data attribute
1316 * .init.text => __init
1317 * .memexitconst => __memconst
1320 * The memory of returned value has been allocated on a heap. The user of this
1321 * method should free it after usage.
1323 static char *sec2annotation(const char *s)
1325 if (match(s, init_exit_sections)) {
1326 char *p = malloc(20);
1333 while (*s && *s != '.')
1338 if (strstr(s, "rodata") != NULL)
1339 strcat(p, "const ");
1340 else if (strstr(s, "data") != NULL)
1350 static int is_function(Elf_Sym *sym)
1353 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1358 static void print_section_list(const char * const list[20])
1360 const char *const *s = list;
1363 fprintf(stderr, "%s", *s);
1366 fprintf(stderr, ", ");
1368 fprintf(stderr, "\n");
1371 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1374 case 0: *name = "variable"; *name_p = ""; break;
1375 case 1: *name = "function"; *name_p = "()"; break;
1376 default: *name = "(unknown reference)"; *name_p = ""; break;
1381 * Print a warning about a section mismatch.
1382 * Try to find symbols near it so user can find it.
1383 * Check whitelist before warning - it may be a false positive.
1385 static void report_sec_mismatch(const char *modname,
1386 const struct sectioncheck *mismatch,
1387 const char *fromsec,
1388 unsigned long long fromaddr,
1389 const char *fromsym,
1391 const char *tosec, const char *tosym,
1394 const char *from, *from_p;
1395 const char *to, *to_p;
1399 sec_mismatch_count++;
1400 if (!sec_mismatch_verbose)
1403 get_pretty_name(from_is_func, &from, &from_p);
1404 get_pretty_name(to_is_func, &to, &to_p);
1406 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1407 "to the %s %s:%s%s\n",
1408 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1411 switch (mismatch->mismatch) {
1412 case TEXT_TO_ANY_INIT:
1413 prl_from = sec2annotation(fromsec);
1414 prl_to = sec2annotation(tosec);
1416 "The function %s%s() references\n"
1418 "This is often because %s lacks a %s\n"
1419 "annotation or the annotation of %s is wrong.\n",
1421 to, prl_to, tosym, to_p,
1422 fromsym, prl_to, tosym);
1426 case DATA_TO_ANY_INIT: {
1427 prl_to = sec2annotation(tosec);
1429 "The variable %s references\n"
1431 "If the reference is valid then annotate the\n"
1432 "variable with __init* or __refdata (see linux/init.h) "
1433 "or name the variable:\n",
1434 fromsym, to, prl_to, tosym, to_p);
1435 print_section_list(mismatch->symbol_white_list);
1439 case TEXT_TO_ANY_EXIT:
1440 prl_to = sec2annotation(tosec);
1442 "The function %s() references a %s in an exit section.\n"
1443 "Often the %s %s%s has valid usage outside the exit section\n"
1444 "and the fix is to remove the %sannotation of %s.\n",
1445 fromsym, to, to, tosym, to_p, prl_to, tosym);
1448 case DATA_TO_ANY_EXIT: {
1449 prl_to = sec2annotation(tosec);
1451 "The variable %s references\n"
1453 "If the reference is valid then annotate the\n"
1454 "variable with __exit* (see linux/init.h) or "
1455 "name the variable:\n",
1456 fromsym, to, prl_to, tosym, to_p);
1457 print_section_list(mismatch->symbol_white_list);
1461 case XXXINIT_TO_SOME_INIT:
1462 case XXXEXIT_TO_SOME_EXIT:
1463 prl_from = sec2annotation(fromsec);
1464 prl_to = sec2annotation(tosec);
1466 "The %s %s%s%s references\n"
1468 "If %s is only used by %s then\n"
1469 "annotate %s with a matching annotation.\n",
1470 from, prl_from, fromsym, from_p,
1471 to, prl_to, tosym, to_p,
1472 tosym, fromsym, tosym);
1476 case ANY_INIT_TO_ANY_EXIT:
1477 prl_from = sec2annotation(fromsec);
1478 prl_to = sec2annotation(tosec);
1480 "The %s %s%s%s references\n"
1482 "This is often seen when error handling "
1483 "in the init function\n"
1484 "uses functionality in the exit path.\n"
1485 "The fix is often to remove the %sannotation of\n"
1486 "%s%s so it may be used outside an exit section.\n",
1487 from, prl_from, fromsym, from_p,
1488 to, prl_to, tosym, to_p,
1489 prl_to, tosym, to_p);
1493 case ANY_EXIT_TO_ANY_INIT:
1494 prl_from = sec2annotation(fromsec);
1495 prl_to = sec2annotation(tosec);
1497 "The %s %s%s%s references\n"
1499 "This is often seen when error handling "
1500 "in the exit function\n"
1501 "uses functionality in the init path.\n"
1502 "The fix is often to remove the %sannotation of\n"
1503 "%s%s so it may be used outside an init section.\n",
1504 from, prl_from, fromsym, from_p,
1505 to, prl_to, tosym, to_p,
1506 prl_to, tosym, to_p);
1510 case EXPORT_TO_INIT_EXIT:
1511 prl_to = sec2annotation(tosec);
1513 "The symbol %s is exported and annotated %s\n"
1514 "Fix this by removing the %sannotation of %s "
1515 "or drop the export.\n",
1516 tosym, prl_to, prl_to, tosym);
1519 case EXTABLE_TO_NON_TEXT:
1520 fatal("There's a special handler for this mismatch type, "
1521 "we should never get here.");
1524 fprintf(stderr, "\n");
1527 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1528 const struct sectioncheck* const mismatch,
1529 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1535 const char *fromsym;
1537 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1538 fromsym = sym_name(elf, from);
1540 if (!strncmp(fromsym, "reference___initcall",
1541 sizeof("reference___initcall")-1))
1544 tosec = sec_name(elf, get_secindex(elf, sym));
1545 to = find_elf_symbol(elf, r->r_addend, sym);
1546 tosym = sym_name(elf, to);
1548 /* check whitelist - we may ignore it */
1549 if (secref_whitelist(mismatch,
1550 fromsec, fromsym, tosec, tosym)) {
1551 report_sec_mismatch(modname, mismatch,
1552 fromsec, r->r_offset, fromsym,
1553 is_function(from), tosec, tosym,
1558 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1560 if (section_index > elf->num_sections)
1561 fatal("section_index is outside elf->num_sections!\n");
1563 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1567 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1568 * to know the sizeof(struct exception_table_entry) for the target architecture.
1570 static unsigned int extable_entry_size = 0;
1571 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1574 * If we're currently checking the second relocation within __ex_table,
1575 * that relocation offset tells us the offsetof(struct
1576 * exception_table_entry, fixup) which is equal to sizeof(struct
1577 * exception_table_entry) divided by two. We use that to our advantage
1578 * since there's no portable way to get that size as every architecture
1579 * seems to go with different sized types. Not pretty but better than
1580 * hard-coding the size for every architecture..
1582 if (!extable_entry_size)
1583 extable_entry_size = r->r_offset * 2;
1586 static inline bool is_extable_fault_address(Elf_Rela *r)
1589 * extable_entry_size is only discovered after we've handled the
1590 * _second_ relocation in __ex_table, so only abort when we're not
1591 * handling the first reloc and extable_entry_size is zero.
1593 if (r->r_offset && extable_entry_size == 0)
1594 fatal("extable_entry size hasn't been discovered!\n");
1596 return ((r->r_offset == 0) ||
1597 (r->r_offset % extable_entry_size == 0));
1600 #define is_second_extable_reloc(Start, Cur, Sec) \
1601 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1603 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1604 const struct sectioncheck* const mismatch,
1605 Elf_Rela* r, Elf_Sym* sym,
1606 const char* fromsec, const char* tosec)
1608 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1609 const char* fromsym_name = sym_name(elf, fromsym);
1610 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1611 const char* tosym_name = sym_name(elf, tosym);
1612 const char* from_pretty_name;
1613 const char* from_pretty_name_p;
1614 const char* to_pretty_name;
1615 const char* to_pretty_name_p;
1617 get_pretty_name(is_function(fromsym),
1618 &from_pretty_name, &from_pretty_name_p);
1619 get_pretty_name(is_function(tosym),
1620 &to_pretty_name, &to_pretty_name_p);
1622 warn("%s(%s+0x%lx): Section mismatch in reference"
1623 " from the %s %s%s to the %s %s:%s%s\n",
1624 modname, fromsec, (long)r->r_offset, from_pretty_name,
1625 fromsym_name, from_pretty_name_p,
1626 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1628 if (!match(tosec, mismatch->bad_tosec) &&
1629 is_executable_section(elf, get_secindex(elf, sym)))
1631 "The relocation at %s+0x%lx references\n"
1632 "section \"%s\" which is not in the list of\n"
1633 "authorized sections. If you're adding a new section\n"
1634 "and/or if this reference is valid, add \"%s\" to the\n"
1635 "list of authorized sections to jump to on fault.\n"
1636 "This can be achieved by adding \"%s\" to \n"
1637 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1638 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1641 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1642 const struct sectioncheck* const mismatch,
1643 Elf_Rela* r, Elf_Sym* sym,
1644 const char *fromsec)
1646 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1648 sec_mismatch_count++;
1650 if (sec_mismatch_verbose)
1651 report_extable_warnings(modname, elf, mismatch, r, sym,
1654 if (match(tosec, mismatch->bad_tosec))
1655 fatal("The relocation at %s+0x%lx references\n"
1656 "section \"%s\" which is black-listed.\n"
1657 "Something is seriously wrong and should be fixed.\n"
1658 "You might get more information about where this is\n"
1659 "coming from by using scripts/check_extable.sh %s\n",
1660 fromsec, (long)r->r_offset, tosec, modname);
1661 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1662 if (is_extable_fault_address(r))
1663 fatal("The relocation at %s+0x%lx references\n"
1664 "section \"%s\" which is not executable, IOW\n"
1665 "it is not possible for the kernel to fault\n"
1666 "at that address. Something is seriously wrong\n"
1667 "and should be fixed.\n",
1668 fromsec, (long)r->r_offset, tosec);
1670 fatal("The relocation at %s+0x%lx references\n"
1671 "section \"%s\" which is not executable, IOW\n"
1672 "the kernel will fault if it ever tries to\n"
1673 "jump to it. Something is seriously wrong\n"
1674 "and should be fixed.\n",
1675 fromsec, (long)r->r_offset, tosec);
1679 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1680 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1682 const char *tosec = sec_name(elf, get_secindex(elf, sym));;
1683 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1686 if (mismatch->handler)
1687 mismatch->handler(modname, elf, mismatch,
1690 default_mismatch_handler(modname, elf, mismatch,
1695 static unsigned int *reloc_location(struct elf_info *elf,
1696 Elf_Shdr *sechdr, Elf_Rela *r)
1698 Elf_Shdr *sechdrs = elf->sechdrs;
1699 int section = sechdr->sh_info;
1701 return (void *)elf->hdr + sechdrs[section].sh_offset +
1705 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1707 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1708 unsigned int *location = reloc_location(elf, sechdr, r);
1712 r->r_addend = TO_NATIVE(*location);
1715 r->r_addend = TO_NATIVE(*location) + 4;
1716 /* For CONFIG_RELOCATABLE=y */
1717 if (elf->hdr->e_type == ET_EXEC)
1718 r->r_addend += r->r_offset;
1725 #define R_ARM_CALL 28
1727 #ifndef R_ARM_JUMP24
1728 #define R_ARM_JUMP24 29
1731 #ifndef R_ARM_THM_CALL
1732 #define R_ARM_THM_CALL 10
1734 #ifndef R_ARM_THM_JUMP24
1735 #define R_ARM_THM_JUMP24 30
1737 #ifndef R_ARM_THM_JUMP19
1738 #define R_ARM_THM_JUMP19 51
1741 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1743 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1747 /* From ARM ABI: (S + A) | T */
1748 r->r_addend = (int)(long)
1749 (elf->symtab_start + ELF_R_SYM(r->r_info));
1754 case R_ARM_THM_CALL:
1755 case R_ARM_THM_JUMP24:
1756 case R_ARM_THM_JUMP19:
1757 /* From ARM ABI: ((S + A) | T) - P */
1758 r->r_addend = (int)(long)(elf->hdr +
1760 (r->r_offset - sechdr->sh_addr));
1768 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1770 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1771 unsigned int *location = reloc_location(elf, sechdr, r);
1774 if (r_typ == R_MIPS_HI16)
1775 return 1; /* skip this */
1776 inst = TO_NATIVE(*location);
1779 r->r_addend = inst & 0xffff;
1782 r->r_addend = (inst & 0x03ffffff) << 2;
1791 static void section_rela(const char *modname, struct elf_info *elf,
1798 const char *fromsec;
1800 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1801 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1803 fromsec = sech_name(elf, sechdr);
1804 fromsec += strlen(".rela");
1805 /* if from section (name) is know good then skip it */
1806 if (match(fromsec, section_white_list))
1809 for (rela = start; rela < stop; rela++) {
1810 r.r_offset = TO_NATIVE(rela->r_offset);
1811 #if KERNEL_ELFCLASS == ELFCLASS64
1812 if (elf->hdr->e_machine == EM_MIPS) {
1814 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1815 r_sym = TO_NATIVE(r_sym);
1816 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1817 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1819 r.r_info = TO_NATIVE(rela->r_info);
1820 r_sym = ELF_R_SYM(r.r_info);
1823 r.r_info = TO_NATIVE(rela->r_info);
1824 r_sym = ELF_R_SYM(r.r_info);
1826 r.r_addend = TO_NATIVE(rela->r_addend);
1827 sym = elf->symtab_start + r_sym;
1828 /* Skip special sections */
1829 if (is_shndx_special(sym->st_shndx))
1831 if (is_second_extable_reloc(start, rela, fromsec))
1832 find_extable_entry_size(fromsec, &r);
1833 check_section_mismatch(modname, elf, &r, sym, fromsec);
1837 static void section_rel(const char *modname, struct elf_info *elf,
1844 const char *fromsec;
1846 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1847 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1849 fromsec = sech_name(elf, sechdr);
1850 fromsec += strlen(".rel");
1851 /* if from section (name) is know good then skip it */
1852 if (match(fromsec, section_white_list))
1855 for (rel = start; rel < stop; rel++) {
1856 r.r_offset = TO_NATIVE(rel->r_offset);
1857 #if KERNEL_ELFCLASS == ELFCLASS64
1858 if (elf->hdr->e_machine == EM_MIPS) {
1860 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1861 r_sym = TO_NATIVE(r_sym);
1862 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1863 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1865 r.r_info = TO_NATIVE(rel->r_info);
1866 r_sym = ELF_R_SYM(r.r_info);
1869 r.r_info = TO_NATIVE(rel->r_info);
1870 r_sym = ELF_R_SYM(r.r_info);
1873 switch (elf->hdr->e_machine) {
1875 if (addend_386_rel(elf, sechdr, &r))
1879 if (addend_arm_rel(elf, sechdr, &r))
1883 if (addend_mips_rel(elf, sechdr, &r))
1887 sym = elf->symtab_start + r_sym;
1888 /* Skip special sections */
1889 if (is_shndx_special(sym->st_shndx))
1891 if (is_second_extable_reloc(start, rel, fromsec))
1892 find_extable_entry_size(fromsec, &r);
1893 check_section_mismatch(modname, elf, &r, sym, fromsec);
1898 * A module includes a number of sections that are discarded
1899 * either when loaded or when used as built-in.
1900 * For loaded modules all functions marked __init and all data
1901 * marked __initdata will be discarded when the module has been initialized.
1902 * Likewise for modules used built-in the sections marked __exit
1903 * are discarded because __exit marked function are supposed to be called
1904 * only when a module is unloaded which never happens for built-in modules.
1905 * The check_sec_ref() function traverses all relocation records
1906 * to find all references to a section that reference a section that will
1907 * be discarded and warns about it.
1909 static void check_sec_ref(struct module *mod, const char *modname,
1910 struct elf_info *elf)
1913 Elf_Shdr *sechdrs = elf->sechdrs;
1915 /* Walk through all sections */
1916 for (i = 0; i < elf->num_sections; i++) {
1917 check_section(modname, elf, &elf->sechdrs[i]);
1918 /* We want to process only relocation sections and not .init */
1919 if (sechdrs[i].sh_type == SHT_RELA)
1920 section_rela(modname, elf, &elf->sechdrs[i]);
1921 else if (sechdrs[i].sh_type == SHT_REL)
1922 section_rel(modname, elf, &elf->sechdrs[i]);
1926 static char *remove_dot(char *s)
1928 size_t n = strcspn(s, ".");
1931 size_t m = strspn(s + n + 1, "0123456789");
1932 if (m && (s[n + m] == '.' || s[n + m] == 0))
1938 static void read_symbols(char *modname)
1940 const char *symname;
1944 struct elf_info info = { };
1947 if (!parse_elf(&info, modname))
1950 mod = new_module(modname);
1952 /* When there's no vmlinux, don't print warnings about
1953 * unresolved symbols (since there'll be too many ;) */
1954 if (is_vmlinux(modname)) {
1959 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1960 if (info.modinfo && !license && !is_vmlinux(modname))
1961 warn("modpost: missing MODULE_LICENSE() in %s\n"
1962 "see include/linux/module.h for "
1963 "more information\n", modname);
1965 if (license_is_gpl_compatible(license))
1966 mod->gpl_compatible = 1;
1968 mod->gpl_compatible = 0;
1971 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1972 "license", license);
1975 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1976 symname = remove_dot(info.strtab + sym->st_name);
1978 handle_modversions(mod, &info, sym, symname);
1979 handle_moddevtable(mod, &info, sym, symname);
1981 if (!is_vmlinux(modname) ||
1982 (is_vmlinux(modname) && vmlinux_section_warnings))
1983 check_sec_ref(mod, modname, &info);
1985 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1987 maybe_frob_rcs_version(modname, version, info.modinfo,
1988 version - (char *)info.hdr);
1989 if (version || (all_versions && !is_vmlinux(modname)))
1990 get_src_version(modname, mod->srcversion,
1991 sizeof(mod->srcversion)-1);
1993 parse_elf_finish(&info);
1995 /* Our trick to get versioning for module struct etc. - it's
1996 * never passed as an argument to an exported function, so
1997 * the automatic versioning doesn't pick it up, but it's really
1998 * important anyhow */
2000 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
2003 static void read_symbols_from_files(const char *filename)
2006 char fname[PATH_MAX];
2008 if (strcmp(filename, "-") != 0) {
2009 in = fopen(filename, "r");
2011 fatal("Can't open filenames file %s: %m", filename);
2014 while (fgets(fname, PATH_MAX, in) != NULL) {
2015 if (strends(fname, "\n"))
2016 fname[strlen(fname)-1] = '\0';
2017 read_symbols(fname);
2026 /* We first write the generated file into memory using the
2027 * following helper, then compare to the file on disk and
2028 * only update the later if anything changed */
2030 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2031 const char *fmt, ...)
2038 len = vsnprintf(tmp, SZ, fmt, ap);
2039 buf_write(buf, tmp, len);
2043 void buf_write(struct buffer *buf, const char *s, int len)
2045 if (buf->size - buf->pos < len) {
2046 buf->size += len + SZ;
2047 buf->p = realloc(buf->p, buf->size);
2049 strncpy(buf->p + buf->pos, s, len);
2053 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2055 const char *e = is_vmlinux(m) ?"":".ko";
2059 fatal("modpost: GPL-incompatible module %s%s "
2060 "uses GPL-only symbol '%s'\n", m, e, s);
2062 case export_unused_gpl:
2063 fatal("modpost: GPL-incompatible module %s%s "
2064 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2066 case export_gpl_future:
2067 warn("modpost: GPL-incompatible module %s%s "
2068 "uses future GPL-only symbol '%s'\n", m, e, s);
2072 case export_unknown:
2078 static void check_for_unused(enum export exp, const char *m, const char *s)
2080 const char *e = is_vmlinux(m) ?"":".ko";
2084 case export_unused_gpl:
2085 warn("modpost: module %s%s "
2086 "uses symbol '%s' marked UNUSED\n", m, e, s);
2094 static void check_exports(struct module *mod)
2096 struct symbol *s, *exp;
2098 for (s = mod->unres; s; s = s->next) {
2099 const char *basename;
2100 exp = find_symbol(s->name);
2101 if (!exp || exp->module == mod)
2103 basename = strrchr(mod->name, '/');
2107 basename = mod->name;
2108 if (!mod->gpl_compatible)
2109 check_for_gpl_usage(exp->export, basename, exp->name);
2110 check_for_unused(exp->export, basename, exp->name);
2115 * Header for the generated file
2117 static void add_header(struct buffer *b, struct module *mod)
2119 buf_printf(b, "#include <linux/module.h>\n");
2120 buf_printf(b, "#include <linux/vermagic.h>\n");
2121 buf_printf(b, "#include <linux/compiler.h>\n");
2122 buf_printf(b, "\n");
2123 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2124 buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
2125 buf_printf(b, "\n");
2126 buf_printf(b, "__visible struct module __this_module\n");
2127 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
2128 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2130 buf_printf(b, "\t.init = init_module,\n");
2131 if (mod->has_cleanup)
2132 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2133 "\t.exit = cleanup_module,\n"
2135 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2136 buf_printf(b, "};\n");
2139 static void add_intree_flag(struct buffer *b, int is_intree)
2142 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2145 static void add_staging_flag(struct buffer *b, const char *name)
2147 static const char *staging_dir = "drivers/staging";
2149 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2150 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2153 /* In kernel, this size is defined in linux/module.h;
2154 * here we use Elf_Addr instead of long for covering cross-compile
2156 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
2159 * Record CRCs for unresolved symbols
2161 static int add_versions(struct buffer *b, struct module *mod)
2163 struct symbol *s, *exp;
2166 for (s = mod->unres; s; s = s->next) {
2167 exp = find_symbol(s->name);
2168 if (!exp || exp->module == mod) {
2169 if (have_vmlinux && !s->weak) {
2170 if (warn_unresolved) {
2171 warn("\"%s\" [%s.ko] undefined!\n",
2172 s->name, mod->name);
2174 merror("\"%s\" [%s.ko] undefined!\n",
2175 s->name, mod->name);
2181 s->module = exp->module;
2182 s->crc_valid = exp->crc_valid;
2189 buf_printf(b, "\n");
2190 buf_printf(b, "static const struct modversion_info ____versions[]\n");
2191 buf_printf(b, "__used\n");
2192 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2194 for (s = mod->unres; s; s = s->next) {
2197 if (!s->crc_valid) {
2198 warn("\"%s\" [%s.ko] has no CRC!\n",
2199 s->name, mod->name);
2202 if (strlen(s->name) >= MODULE_NAME_LEN) {
2203 merror("too long symbol \"%s\" [%s.ko]\n",
2204 s->name, mod->name);
2208 buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
2212 buf_printf(b, "};\n");
2217 static void add_depends(struct buffer *b, struct module *mod,
2218 struct module *modules)
2224 for (m = modules; m; m = m->next)
2225 m->seen = is_vmlinux(m->name);
2227 buf_printf(b, "\n");
2228 buf_printf(b, "static const char __module_depends[]\n");
2229 buf_printf(b, "__used\n");
2230 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2231 buf_printf(b, "\"depends=");
2232 for (s = mod->unres; s; s = s->next) {
2237 if (s->module->seen)
2240 s->module->seen = 1;
2241 p = strrchr(s->module->name, '/');
2245 p = s->module->name;
2246 buf_printf(b, "%s%s", first ? "" : ",", p);
2249 buf_printf(b, "\";\n");
2252 static void add_srcversion(struct buffer *b, struct module *mod)
2254 if (mod->srcversion[0]) {
2255 buf_printf(b, "\n");
2256 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2261 static void write_if_changed(struct buffer *b, const char *fname)
2267 file = fopen(fname, "r");
2271 if (fstat(fileno(file), &st) < 0)
2274 if (st.st_size != b->pos)
2277 tmp = NOFAIL(malloc(b->pos));
2278 if (fread(tmp, 1, b->pos, file) != b->pos)
2281 if (memcmp(tmp, b->p, b->pos) != 0)
2293 file = fopen(fname, "w");
2298 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2305 /* parse Module.symvers file. line format:
2306 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2308 static void read_dump(const char *fname, unsigned int kernel)
2310 unsigned long size, pos = 0;
2311 void *file = grab_file(fname, &size);
2315 /* No symbol versions, silently ignore */
2318 while ((line = get_next_line(&pos, file, size))) {
2319 char *symname, *modname, *d, *export, *end;
2324 if (!(symname = strchr(line, '\t')))
2327 if (!(modname = strchr(symname, '\t')))
2330 if ((export = strchr(modname, '\t')) != NULL)
2332 if (export && ((end = strchr(export, '\t')) != NULL))
2334 crc = strtoul(line, &d, 16);
2335 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2337 mod = find_module(modname);
2339 if (is_vmlinux(modname))
2341 mod = new_module(modname);
2344 s = sym_add_exported(symname, mod, export_no(export));
2347 sym_update_crc(symname, mod, crc, export_no(export));
2349 release_file(file, size);
2352 release_file(file, size);
2353 fatal("parse error in symbol dump file\n");
2356 /* For normal builds always dump all symbols.
2357 * For external modules only dump symbols
2358 * that are not read from kernel Module.symvers.
2360 static int dump_sym(struct symbol *sym)
2362 if (!external_module)
2364 if (sym->vmlinux || sym->kernel)
2369 static void write_dump(const char *fname)
2371 struct buffer buf = { };
2372 struct symbol *symbol;
2375 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2376 symbol = symbolhash[n];
2378 if (dump_sym(symbol))
2379 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2380 symbol->crc, symbol->name,
2381 symbol->module->name,
2382 export_str(symbol->export));
2383 symbol = symbol->next;
2386 write_if_changed(&buf, fname);
2390 struct ext_sym_list {
2391 struct ext_sym_list *next;
2395 int main(int argc, char **argv)
2398 struct buffer buf = { };
2399 char *kernel_read = NULL, *module_read = NULL;
2400 char *dump_write = NULL, *files_source = NULL;
2403 struct ext_sym_list *extsym_iter;
2404 struct ext_sym_list *extsym_start = NULL;
2406 while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:E")) != -1) {
2409 kernel_read = optarg;
2412 module_read = optarg;
2413 external_module = 1;
2416 external_module = 1;
2418 NOFAIL(malloc(sizeof(*extsym_iter)));
2419 extsym_iter->next = extsym_start;
2420 extsym_iter->file = optarg;
2421 extsym_start = extsym_iter;
2427 ignore_missing_files = 1;
2430 dump_write = optarg;
2436 vmlinux_section_warnings = 0;
2439 sec_mismatch_verbose = 0;
2442 files_source = optarg;
2445 warn_unresolved = 1;
2448 sec_mismatch_fatal = 1;
2456 read_dump(kernel_read, 1);
2458 read_dump(module_read, 0);
2459 while (extsym_start) {
2460 read_dump(extsym_start->file, 0);
2461 extsym_iter = extsym_start->next;
2463 extsym_start = extsym_iter;
2466 while (optind < argc)
2467 read_symbols(argv[optind++]);
2470 read_symbols_from_files(files_source);
2472 for (mod = modules; mod; mod = mod->next) {
2480 for (mod = modules; mod; mod = mod->next) {
2481 char fname[PATH_MAX];
2488 add_header(&buf, mod);
2489 add_intree_flag(&buf, !external_module);
2490 add_staging_flag(&buf, mod->name);
2491 err |= add_versions(&buf, mod);
2492 add_depends(&buf, mod, modules);
2493 add_moddevtable(&buf, mod);
2494 add_srcversion(&buf, mod);
2496 sprintf(fname, "%s.mod.c", mod->name);
2497 write_if_changed(&buf, fname);
2500 write_dump(dump_write);
2501 if (sec_mismatch_count) {
2502 if (!sec_mismatch_verbose) {
2503 warn("modpost: Found %d section mismatch(es).\n"
2504 "To see full details build your kernel with:\n"
2505 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2506 sec_mismatch_count);
2508 if (sec_mismatch_fatal) {
2509 fatal("modpost: Section mismatches detected.\n"
2510 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");