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 /* ignore missing files */
42 static int ignore_missing_files;
45 export_plain, export_unused, export_gpl,
46 export_unused_gpl, export_gpl_future, export_unknown
49 #define PRINTF __attribute__ ((format (printf, 1, 2)))
51 PRINTF void fatal(const char *fmt, ...)
55 fprintf(stderr, "FATAL: ");
57 va_start(arglist, fmt);
58 vfprintf(stderr, fmt, arglist);
64 PRINTF void warn(const char *fmt, ...)
68 fprintf(stderr, "WARNING: ");
70 va_start(arglist, fmt);
71 vfprintf(stderr, fmt, arglist);
75 PRINTF void merror(const char *fmt, ...)
79 fprintf(stderr, "ERROR: ");
81 va_start(arglist, fmt);
82 vfprintf(stderr, fmt, arglist);
86 static inline bool strends(const char *str, const char *postfix)
88 if (strlen(str) < strlen(postfix))
91 return strcmp(str + strlen(str) - strlen(postfix), postfix) == 0;
94 static int is_vmlinux(const char *modname)
98 myname = strrchr(modname, '/');
104 return (strcmp(myname, "vmlinux") == 0) ||
105 (strcmp(myname, "vmlinux.o") == 0);
108 void *do_nofail(void *ptr, const char *expr)
111 fatal("modpost: Memory allocation failure: %s.\n", expr);
116 /* A list of all modules we processed */
117 static struct module *modules;
119 static struct module *find_module(char *modname)
123 for (mod = modules; mod; mod = mod->next)
124 if (strcmp(mod->name, modname) == 0)
129 static struct module *new_module(const char *modname)
134 mod = NOFAIL(malloc(sizeof(*mod)));
135 memset(mod, 0, sizeof(*mod));
136 p = NOFAIL(strdup(modname));
138 /* strip trailing .o */
139 if (strends(p, ".o")) {
140 p[strlen(p) - 2] = '\0';
146 mod->gpl_compatible = -1;
153 /* A hash of all exported symbols,
154 * struct symbol is also used for lists of unresolved symbols */
156 #define SYMBOL_HASH_SIZE 1024
160 struct module *module;
164 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */
165 unsigned int kernel:1; /* 1 if symbol is from kernel
166 * (only for external modules) **/
167 unsigned int preloaded:1; /* 1 if symbol from Module.symvers, or crc */
168 enum export export; /* Type of export */
172 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
174 /* This is based on the hash agorithm from gdbm, via tdb */
175 static inline unsigned int tdb_hash(const char *name)
177 unsigned value; /* Used to compute the hash value. */
178 unsigned i; /* Used to cycle through random values. */
180 /* Set the initial value from the key size. */
181 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
182 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
184 return (1103515243 * value + 12345);
188 * Allocate a new symbols for use in the hash of exported symbols or
189 * the list of unresolved symbols per module
191 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
194 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
196 memset(s, 0, sizeof(*s));
197 strcpy(s->name, name);
203 /* For the hash of exported symbols */
204 static struct symbol *new_symbol(const char *name, struct module *module,
210 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
211 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
212 new->module = module;
213 new->export = export;
217 static struct symbol *find_symbol(const char *name)
221 /* For our purposes, .foo matches foo. PPC64 needs this. */
225 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
226 if (strcmp(s->name, name) == 0)
232 static const struct {
236 { .str = "EXPORT_SYMBOL", .export = export_plain },
237 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
238 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
239 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
240 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
241 { .str = "(unknown)", .export = export_unknown },
245 static const char *export_str(enum export ex)
247 return export_list[ex].str;
250 static enum export export_no(const char *s)
255 return export_unknown;
256 for (i = 0; export_list[i].export != export_unknown; i++) {
257 if (strcmp(export_list[i].str, s) == 0)
258 return export_list[i].export;
260 return export_unknown;
263 static const char *sec_name(struct elf_info *elf, int secindex);
265 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
267 static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
269 const char *secname = sec_name(elf, sec);
271 if (strstarts(secname, "___ksymtab+"))
273 else if (strstarts(secname, "___ksymtab_unused+"))
274 return export_unused;
275 else if (strstarts(secname, "___ksymtab_gpl+"))
277 else if (strstarts(secname, "___ksymtab_unused_gpl+"))
278 return export_unused_gpl;
279 else if (strstarts(secname, "___ksymtab_gpl_future+"))
280 return export_gpl_future;
282 return export_unknown;
285 static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
287 if (sec == elf->export_sec)
289 else if (sec == elf->export_unused_sec)
290 return export_unused;
291 else if (sec == elf->export_gpl_sec)
293 else if (sec == elf->export_unused_gpl_sec)
294 return export_unused_gpl;
295 else if (sec == elf->export_gpl_future_sec)
296 return export_gpl_future;
298 return export_unknown;
302 * Add an exported symbol - it may have already been added without a
303 * CRC, in this case just update the CRC
305 static struct symbol *sym_add_exported(const char *name, struct module *mod,
308 struct symbol *s = find_symbol(name);
311 s = new_symbol(name, mod, export);
314 warn("%s: '%s' exported twice. Previous export "
315 "was in %s%s\n", mod->name, name,
317 is_vmlinux(s->module->name) ?"":".ko");
319 /* In case Module.symvers was out of date */
324 s->vmlinux = is_vmlinux(mod->name);
330 static void sym_update_crc(const char *name, struct module *mod,
331 unsigned int crc, enum export export)
333 struct symbol *s = find_symbol(name);
336 s = new_symbol(name, mod, export);
337 /* Don't complain when we find it later. */
344 void *grab_file(const char *filename, unsigned long *size)
347 void *map = MAP_FAILED;
350 fd = open(filename, O_RDONLY);
357 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
361 if (map == MAP_FAILED)
367 * Return a copy of the next line in a mmap'ed file.
368 * spaces in the beginning of the line is trimmed away.
369 * Return a pointer to a static buffer.
371 char *get_next_line(unsigned long *pos, void *file, unsigned long size)
373 static char line[4096];
376 signed char *p = (signed char *)file + *pos;
379 for (; *pos < size ; (*pos)++) {
380 if (skip && isspace(*p)) {
385 if (*p != '\n' && (*pos < size)) {
389 break; /* Too long, stop */
400 void release_file(void *file, unsigned long size)
405 static int parse_elf(struct elf_info *info, const char *filename)
411 const char *secstrings;
412 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
414 hdr = grab_file(filename, &info->size);
416 if (ignore_missing_files) {
417 fprintf(stderr, "%s: %s (ignored)\n", filename,
425 if (info->size < sizeof(*hdr)) {
426 /* file too small, assume this is an empty .o file */
429 /* Is this a valid ELF file? */
430 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
431 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
432 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
433 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
434 /* Not an ELF file - silently ignore it */
437 /* Fix endianness in ELF header */
438 hdr->e_type = TO_NATIVE(hdr->e_type);
439 hdr->e_machine = TO_NATIVE(hdr->e_machine);
440 hdr->e_version = TO_NATIVE(hdr->e_version);
441 hdr->e_entry = TO_NATIVE(hdr->e_entry);
442 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
443 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
444 hdr->e_flags = TO_NATIVE(hdr->e_flags);
445 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
446 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
447 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
448 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
449 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
450 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
451 sechdrs = (void *)hdr + hdr->e_shoff;
452 info->sechdrs = sechdrs;
454 /* Check if file offset is correct */
455 if (hdr->e_shoff > info->size) {
456 fatal("section header offset=%lu in file '%s' is bigger than "
457 "filesize=%lu\n", (unsigned long)hdr->e_shoff,
458 filename, info->size);
462 if (hdr->e_shnum == SHN_UNDEF) {
464 * There are more than 64k sections,
465 * read count from .sh_size.
467 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
470 info->num_sections = hdr->e_shnum;
472 if (hdr->e_shstrndx == SHN_XINDEX) {
473 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
476 info->secindex_strings = hdr->e_shstrndx;
479 /* Fix endianness in section headers */
480 for (i = 0; i < info->num_sections; i++) {
481 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
482 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
483 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
484 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
485 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
486 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
487 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
488 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
489 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
490 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
492 /* Find symbol table. */
493 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
494 for (i = 1; i < info->num_sections; i++) {
496 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
498 if (!nobits && sechdrs[i].sh_offset > info->size) {
499 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
500 "sizeof(*hrd)=%zu\n", filename,
501 (unsigned long)sechdrs[i].sh_offset,
505 secname = secstrings + sechdrs[i].sh_name;
506 if (strcmp(secname, ".modinfo") == 0) {
508 fatal("%s has NOBITS .modinfo\n", filename);
509 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
510 info->modinfo_len = sechdrs[i].sh_size;
511 } else if (strcmp(secname, "__ksymtab") == 0)
512 info->export_sec = i;
513 else if (strcmp(secname, "__ksymtab_unused") == 0)
514 info->export_unused_sec = i;
515 else if (strcmp(secname, "__ksymtab_gpl") == 0)
516 info->export_gpl_sec = i;
517 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
518 info->export_unused_gpl_sec = i;
519 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
520 info->export_gpl_future_sec = i;
522 if (sechdrs[i].sh_type == SHT_SYMTAB) {
523 unsigned int sh_link_idx;
525 info->symtab_start = (void *)hdr +
526 sechdrs[i].sh_offset;
527 info->symtab_stop = (void *)hdr +
528 sechdrs[i].sh_offset + sechdrs[i].sh_size;
529 sh_link_idx = sechdrs[i].sh_link;
530 info->strtab = (void *)hdr +
531 sechdrs[sh_link_idx].sh_offset;
534 /* 32bit section no. table? ("more than 64k sections") */
535 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
536 symtab_shndx_idx = i;
537 info->symtab_shndx_start = (void *)hdr +
538 sechdrs[i].sh_offset;
539 info->symtab_shndx_stop = (void *)hdr +
540 sechdrs[i].sh_offset + sechdrs[i].sh_size;
543 if (!info->symtab_start)
544 fatal("%s has no symtab?\n", filename);
546 /* Fix endianness in symbols */
547 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
548 sym->st_shndx = TO_NATIVE(sym->st_shndx);
549 sym->st_name = TO_NATIVE(sym->st_name);
550 sym->st_value = TO_NATIVE(sym->st_value);
551 sym->st_size = TO_NATIVE(sym->st_size);
554 if (symtab_shndx_idx != ~0U) {
556 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
557 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
558 filename, sechdrs[symtab_shndx_idx].sh_link,
561 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
569 static void parse_elf_finish(struct elf_info *info)
571 release_file(info->hdr, info->size);
574 static int ignore_undef_symbol(struct elf_info *info, const char *symname)
576 /* ignore __this_module, it will be resolved shortly */
577 if (strcmp(symname, VMLINUX_SYMBOL_STR(__this_module)) == 0)
579 /* ignore global offset table */
580 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
582 if (info->hdr->e_machine == EM_PPC)
583 /* Special register function linked on all modules during final link of .ko */
584 if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
585 strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
586 strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
587 strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0 ||
588 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
589 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
591 if (info->hdr->e_machine == EM_PPC64)
592 /* Special register function linked on all modules during final link of .ko */
593 if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
594 strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0 ||
595 strncmp(symname, "_restvr_", sizeof("_restvr_") - 1) == 0 ||
596 strncmp(symname, "_savevr_", sizeof("_savevr_") - 1) == 0)
598 /* Do not ignore this symbol */
602 #define CRC_PFX VMLINUX_SYMBOL_STR(__crc_)
603 #define KSYMTAB_PFX VMLINUX_SYMBOL_STR(__ksymtab_)
605 static void handle_modversions(struct module *mod, struct elf_info *info,
606 Elf_Sym *sym, const char *symname)
611 if ((!is_vmlinux(mod->name) || mod->is_dot_o) &&
612 strncmp(symname, "__ksymtab", 9) == 0)
613 export = export_from_secname(info, get_secindex(info, sym));
615 export = export_from_sec(info, get_secindex(info, sym));
618 if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
619 crc = (unsigned int) sym->st_value;
620 sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
624 switch (sym->st_shndx) {
626 if (!strncmp(symname, "__gnu_lto_", sizeof("__gnu_lto_")-1)) {
627 /* Should warn here, but modpost runs before the linker */
629 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
632 /* undefined symbol */
633 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
634 ELF_ST_BIND(sym->st_info) != STB_WEAK)
636 if (ignore_undef_symbol(info, symname))
638 /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
639 #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
640 /* add compatibility with older glibc */
641 #ifndef STT_SPARC_REGISTER
642 #define STT_SPARC_REGISTER STT_REGISTER
644 if (info->hdr->e_machine == EM_SPARC ||
645 info->hdr->e_machine == EM_SPARCV9) {
646 /* Ignore register directives. */
647 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
649 if (symname[0] == '.') {
650 char *munged = strdup(symname);
652 munged[1] = toupper(munged[1]);
658 #ifdef CONFIG_HAVE_UNDERSCORE_SYMBOL_PREFIX
659 if (symname[0] != '_')
664 mod->unres = alloc_symbol(symname,
665 ELF_ST_BIND(sym->st_info) == STB_WEAK,
669 /* All exported symbols */
670 if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
671 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
674 if (strcmp(symname, VMLINUX_SYMBOL_STR(init_module)) == 0)
676 if (strcmp(symname, VMLINUX_SYMBOL_STR(cleanup_module)) == 0)
677 mod->has_cleanup = 1;
683 * Parse tag=value strings from .modinfo section
685 static char *next_string(char *string, unsigned long *secsize)
687 /* Skip non-zero chars */
690 if ((*secsize)-- <= 1)
694 /* Skip any zero padding. */
697 if ((*secsize)-- <= 1)
703 static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
704 const char *tag, char *info)
707 unsigned int taglen = strlen(tag);
708 unsigned long size = modinfo_len;
711 size -= info - (char *)modinfo;
712 modinfo = next_string(info, &size);
715 for (p = modinfo; p; p = next_string(p, &size)) {
716 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
717 return p + taglen + 1;
722 static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
726 return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
730 * Test if string s ends in string sub
733 static int strrcmp(const char *s, const char *sub)
741 sublen = strlen(sub);
743 if ((slen == 0) || (sublen == 0))
749 return memcmp(s + slen - sublen, sub, sublen);
752 static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
755 return elf->strtab + sym->st_name;
760 static const char *sec_name(struct elf_info *elf, int secindex)
762 Elf_Shdr *sechdrs = elf->sechdrs;
763 return (void *)elf->hdr +
764 elf->sechdrs[elf->secindex_strings].sh_offset +
765 sechdrs[secindex].sh_name;
768 static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
770 return (void *)elf->hdr +
771 elf->sechdrs[elf->secindex_strings].sh_offset +
775 /* The pattern is an array of simple patterns.
776 * "foo" will match an exact string equal to "foo"
777 * "*foo" will match a string that ends with "foo"
778 * "foo*" will match a string that begins with "foo"
779 * "*foo*" will match a string that contains "foo"
781 static int match(const char *sym, const char * const pat[])
786 const char *endp = p + strlen(p) - 1;
789 if (*p == '*' && *endp == '*') {
790 char *here, *bare = strndup(p + 1, strlen(p) - 2);
792 here = strstr(sym, bare);
798 else if (*p == '*') {
799 if (strrcmp(sym, p + 1) == 0)
803 else if (*endp == '*') {
804 if (strncmp(sym, p, strlen(p) - 1) == 0)
809 if (strcmp(p, sym) == 0)
817 /* sections that we do not want to do full section mismatch check on */
818 static const char *const section_white_list[] =
822 ".cranges", /* sh64 */
823 ".zdebug*", /* Compressed debug sections. */
824 ".GCC-command-line", /* mn10300 */
825 ".GCC.command.line", /* record-gcc-switches, non mn10300 */
826 ".mdebug*", /* alpha, score, mips etc. */
827 ".pdr", /* alpha, score, mips etc. */
832 ".xt.prop", /* xtensa */
833 ".xt.lit", /* xtensa */
834 ".arcextmap*", /* arc */
835 ".gnu.linkonce.arcext*", /* arc : modules */
841 * This is used to find sections missing the SHF_ALLOC flag.
842 * The cause of this is often a section specified in assembler
843 * without "ax" / "aw".
845 static void check_section(const char *modname, struct elf_info *elf,
848 const char *sec = sech_name(elf, sechdr);
850 if (sechdr->sh_type == SHT_PROGBITS &&
851 !(sechdr->sh_flags & SHF_ALLOC) &&
852 !match(sec, section_white_list)) {
853 warn("%s (%s): unexpected non-allocatable section.\n"
854 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
855 "Note that for example <linux/init.h> contains\n"
856 "section definitions for use in .S files.\n\n",
863 #define ALL_INIT_DATA_SECTIONS \
864 ".init.setup", ".init.rodata", ".meminit.rodata", \
865 ".init.data", ".meminit.data"
866 #define ALL_EXIT_DATA_SECTIONS \
867 ".exit.data", ".memexit.data"
869 #define ALL_INIT_TEXT_SECTIONS \
870 ".init.text", ".meminit.text"
871 #define ALL_EXIT_TEXT_SECTIONS \
872 ".exit.text", ".memexit.text"
874 #define ALL_PCI_INIT_SECTIONS \
875 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
876 ".pci_fixup_enable", ".pci_fixup_resume", \
877 ".pci_fixup_resume_early", ".pci_fixup_suspend"
879 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
880 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
882 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
883 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
885 #define DATA_SECTIONS ".data", ".data.rel"
886 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
888 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
889 ".fixup", ".entry.text", ".exception.text", ".text.*", \
892 #define INIT_SECTIONS ".init.*"
893 #define MEM_INIT_SECTIONS ".meminit.*"
895 #define EXIT_SECTIONS ".exit.*"
896 #define MEM_EXIT_SECTIONS ".memexit.*"
898 #define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
899 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
901 /* init data sections */
902 static const char *const init_data_sections[] =
903 { ALL_INIT_DATA_SECTIONS, NULL };
905 /* all init sections */
906 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
908 /* All init and exit sections (code + data) */
909 static const char *const init_exit_sections[] =
910 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
912 /* all text sections */
913 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
916 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
919 /* symbols in .data that may refer to init/exit sections */
920 #define DEFAULT_SYMBOL_WHITE_LIST \
922 "*_template", /* scsi uses *_template a lot */ \
923 "*_timer", /* arm uses ops structures named _timer a lot */ \
924 "*_sht", /* scsi also used *_sht to some extent */ \
930 static const char *const head_sections[] = { ".head.text*", NULL };
931 static const char *const linker_symbols[] =
932 { "__init_begin", "_sinittext", "_einittext", NULL };
933 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
940 XXXINIT_TO_SOME_INIT,
941 XXXEXIT_TO_SOME_EXIT,
942 ANY_INIT_TO_ANY_EXIT,
943 ANY_EXIT_TO_ANY_INIT,
949 * Describe how to match sections on different criterias:
951 * @fromsec: Array of sections to be matched.
953 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
954 * this array is forbidden (black-list). Can be empty.
956 * @good_tosec: Relocations applied to a section in @fromsec must be
957 * targetting sections in this array (white-list). Can be empty.
959 * @mismatch: Type of mismatch.
961 * @symbol_white_list: Do not match a relocation to a symbol in this list
962 * even if it is targetting a section in @bad_to_sec.
964 * @handler: Specific handler to call when a match is found. If NULL,
965 * default_mismatch_handler() will be called.
968 struct sectioncheck {
969 const char *fromsec[20];
970 const char *bad_tosec[20];
971 const char *good_tosec[20];
972 enum mismatch mismatch;
973 const char *symbol_white_list[20];
974 void (*handler)(const char *modname, struct elf_info *elf,
975 const struct sectioncheck* const mismatch,
976 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
980 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
981 const struct sectioncheck* const mismatch,
982 Elf_Rela *r, Elf_Sym *sym,
983 const char *fromsec);
985 static const struct sectioncheck sectioncheck[] = {
986 /* Do not reference init/exit code/data from
987 * normal code and data
990 .fromsec = { TEXT_SECTIONS, NULL },
991 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
992 .mismatch = TEXT_TO_ANY_INIT,
993 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
996 .fromsec = { DATA_SECTIONS, NULL },
997 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
998 .mismatch = DATA_TO_ANY_INIT,
999 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1002 .fromsec = { DATA_SECTIONS, NULL },
1003 .bad_tosec = { INIT_SECTIONS, NULL },
1004 .mismatch = DATA_TO_ANY_INIT,
1005 .symbol_white_list = {
1006 "*_template", "*_timer", "*_sht", "*_ops",
1007 "*_probe", "*_probe_one", "*_console", NULL
1011 .fromsec = { TEXT_SECTIONS, NULL },
1012 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1013 .mismatch = TEXT_TO_ANY_EXIT,
1014 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1017 .fromsec = { DATA_SECTIONS, NULL },
1018 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1019 .mismatch = DATA_TO_ANY_EXIT,
1020 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1022 /* Do not reference init code/data from meminit code/data */
1024 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1025 .bad_tosec = { INIT_SECTIONS, NULL },
1026 .mismatch = XXXINIT_TO_SOME_INIT,
1027 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1029 /* Do not reference exit code/data from memexit code/data */
1031 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1032 .bad_tosec = { EXIT_SECTIONS, NULL },
1033 .mismatch = XXXEXIT_TO_SOME_EXIT,
1034 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1036 /* Do not use exit code/data from init code */
1038 .fromsec = { ALL_INIT_SECTIONS, NULL },
1039 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1040 .mismatch = ANY_INIT_TO_ANY_EXIT,
1041 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1043 /* Do not use init code/data from exit code */
1045 .fromsec = { ALL_EXIT_SECTIONS, NULL },
1046 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1047 .mismatch = ANY_EXIT_TO_ANY_INIT,
1048 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1051 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1052 .bad_tosec = { INIT_SECTIONS, NULL },
1053 .mismatch = ANY_INIT_TO_ANY_EXIT,
1054 .symbol_white_list = { NULL },
1056 /* Do not export init/exit functions or data */
1058 .fromsec = { "__ksymtab*", NULL },
1059 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1060 .mismatch = EXPORT_TO_INIT_EXIT,
1061 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1064 .fromsec = { "__ex_table", NULL },
1065 /* If you're adding any new black-listed sections in here, consider
1066 * adding a special 'printer' for them in scripts/check_extable.
1068 .bad_tosec = { ".altinstr_replacement", NULL },
1069 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1070 .mismatch = EXTABLE_TO_NON_TEXT,
1071 .handler = extable_mismatch_handler,
1075 static const struct sectioncheck *section_mismatch(
1076 const char *fromsec, const char *tosec)
1079 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1080 const struct sectioncheck *check = §ioncheck[0];
1083 * The target section could be the SHT_NUL section when we're
1084 * handling relocations to un-resolved symbols, trying to match it
1085 * doesn't make much sense and causes build failures on parisc and
1086 * mn10300 architectures.
1091 for (i = 0; i < elems; i++) {
1092 if (match(fromsec, check->fromsec)) {
1093 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1095 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1104 * Whitelist to allow certain references to pass with no warning.
1107 * If a module parameter is declared __initdata and permissions=0
1108 * then this is legal despite the warning generated.
1109 * We cannot see value of permissions here, so just ignore
1111 * The pattern is identified by:
1112 * tosec = .init.data
1117 * module_param_call() ops can refer to __init set function if permissions=0
1118 * The pattern is identified by:
1119 * tosec = .init.text
1121 * atsym = __param_ops_*
1124 * Many drivers utilise a *driver container with references to
1125 * add, remove, probe functions etc.
1126 * the pattern is identified by:
1127 * tosec = init or exit section
1128 * fromsec = data section
1129 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1130 * *probe_one, *_console, *_timer
1133 * Whitelist all references from .head.text to any init section
1136 * Some symbols belong to init section but still it is ok to reference
1137 * these from non-init sections as these symbols don't have any memory
1138 * allocated for them and symbol address and value are same. So even
1139 * if init section is freed, its ok to reference those symbols.
1140 * For ex. symbols marking the init section boundaries.
1141 * This pattern is identified by
1142 * refsymname = __init_begin, _sinittext, _einittext
1145 * GCC may optimize static inlines when fed constant arg(s) resulting
1146 * in functions like cpumask_empty() -- generating an associated symbol
1147 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1148 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1149 * meaningless section warning. May need to add isra symbols too...
1150 * This pattern is identified by
1151 * tosec = init section
1152 * fromsec = text section
1153 * refsymname = *.constprop.*
1156 static int secref_whitelist(const struct sectioncheck *mismatch,
1157 const char *fromsec, const char *fromsym,
1158 const char *tosec, const char *tosym)
1160 /* Check for pattern 1 */
1161 if (match(tosec, init_data_sections) &&
1162 match(fromsec, data_sections) &&
1163 (strncmp(fromsym, "__param", strlen("__param")) == 0))
1166 /* Check for pattern 1a */
1167 if (strcmp(tosec, ".init.text") == 0 &&
1168 match(fromsec, data_sections) &&
1169 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1172 /* Check for pattern 2 */
1173 if (match(tosec, init_exit_sections) &&
1174 match(fromsec, data_sections) &&
1175 match(fromsym, mismatch->symbol_white_list))
1178 /* Check for pattern 3 */
1179 if (match(fromsec, head_sections) &&
1180 match(tosec, init_sections))
1183 /* Check for pattern 4 */
1184 if (match(tosym, linker_symbols))
1187 /* Check for pattern 5 */
1188 if (match(fromsec, text_sections) &&
1189 match(tosec, init_sections) &&
1190 match(fromsym, optim_symbols))
1197 * Find symbol based on relocation record info.
1198 * In some cases the symbol supplied is a valid symbol so
1199 * return refsym. If st_name != 0 we assume this is a valid symbol.
1200 * In other cases the symbol needs to be looked up in the symbol table
1201 * based on section and address.
1203 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1207 Elf_Sym *near = NULL;
1208 Elf64_Sword distance = 20;
1210 unsigned int relsym_secindex;
1212 if (relsym->st_name != 0)
1215 relsym_secindex = get_secindex(elf, relsym);
1216 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1217 if (get_secindex(elf, sym) != relsym_secindex)
1219 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1221 if (sym->st_value == addr)
1223 /* Find a symbol nearby - addr are maybe negative */
1224 d = sym->st_value - addr;
1226 d = addr - sym->st_value;
1232 /* We need a close match */
1239 static inline int is_arm_mapping_symbol(const char *str)
1241 return str[0] == '$' && strchr("axtd", str[1])
1242 && (str[2] == '\0' || str[2] == '.');
1246 * If there's no name there, ignore it; likewise, ignore it if it's
1247 * one of the magic symbols emitted used by current ARM tools.
1249 * Otherwise if find_symbols_between() returns those symbols, they'll
1250 * fail the whitelist tests and cause lots of false alarms ... fixable
1251 * only by merging __exit and __init sections into __text, bloating
1252 * the kernel (which is especially evil on embedded platforms).
1254 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1256 const char *name = elf->strtab + sym->st_name;
1258 if (!name || !strlen(name))
1260 return !is_arm_mapping_symbol(name);
1264 * Find symbols before or equal addr and after addr - in the section sec.
1265 * If we find two symbols with equal offset prefer one with a valid name.
1266 * The ELF format may have a better way to detect what type of symbol
1267 * it is, but this works for now.
1269 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1273 Elf_Sym *near = NULL;
1274 Elf_Addr distance = ~0;
1276 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1279 if (is_shndx_special(sym->st_shndx))
1281 symsec = sec_name(elf, get_secindex(elf, sym));
1282 if (strcmp(symsec, sec) != 0)
1284 if (!is_valid_name(elf, sym))
1286 if (sym->st_value <= addr) {
1287 if ((addr - sym->st_value) < distance) {
1288 distance = addr - sym->st_value;
1290 } else if ((addr - sym->st_value) == distance) {
1299 * Convert a section name to the function/data attribute
1300 * .init.text => __init
1301 * .memexitconst => __memconst
1304 * The memory of returned value has been allocated on a heap. The user of this
1305 * method should free it after usage.
1307 static char *sec2annotation(const char *s)
1309 if (match(s, init_exit_sections)) {
1310 char *p = malloc(20);
1317 while (*s && *s != '.')
1322 if (strstr(s, "rodata") != NULL)
1323 strcat(p, "const ");
1324 else if (strstr(s, "data") != NULL)
1334 static int is_function(Elf_Sym *sym)
1337 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1342 static void print_section_list(const char * const list[20])
1344 const char *const *s = list;
1347 fprintf(stderr, "%s", *s);
1350 fprintf(stderr, ", ");
1352 fprintf(stderr, "\n");
1355 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1358 case 0: *name = "variable"; *name_p = ""; break;
1359 case 1: *name = "function"; *name_p = "()"; break;
1360 default: *name = "(unknown reference)"; *name_p = ""; break;
1365 * Print a warning about a section mismatch.
1366 * Try to find symbols near it so user can find it.
1367 * Check whitelist before warning - it may be a false positive.
1369 static void report_sec_mismatch(const char *modname,
1370 const struct sectioncheck *mismatch,
1371 const char *fromsec,
1372 unsigned long long fromaddr,
1373 const char *fromsym,
1375 const char *tosec, const char *tosym,
1378 const char *from, *from_p;
1379 const char *to, *to_p;
1383 sec_mismatch_count++;
1384 if (!sec_mismatch_verbose)
1387 get_pretty_name(from_is_func, &from, &from_p);
1388 get_pretty_name(to_is_func, &to, &to_p);
1390 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1391 "to the %s %s:%s%s\n",
1392 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1395 switch (mismatch->mismatch) {
1396 case TEXT_TO_ANY_INIT:
1397 prl_from = sec2annotation(fromsec);
1398 prl_to = sec2annotation(tosec);
1400 "The function %s%s() references\n"
1402 "This is often because %s lacks a %s\n"
1403 "annotation or the annotation of %s is wrong.\n",
1405 to, prl_to, tosym, to_p,
1406 fromsym, prl_to, tosym);
1410 case DATA_TO_ANY_INIT: {
1411 prl_to = sec2annotation(tosec);
1413 "The variable %s references\n"
1415 "If the reference is valid then annotate the\n"
1416 "variable with __init* or __refdata (see linux/init.h) "
1417 "or name the variable:\n",
1418 fromsym, to, prl_to, tosym, to_p);
1419 print_section_list(mismatch->symbol_white_list);
1423 case TEXT_TO_ANY_EXIT:
1424 prl_to = sec2annotation(tosec);
1426 "The function %s() references a %s in an exit section.\n"
1427 "Often the %s %s%s has valid usage outside the exit section\n"
1428 "and the fix is to remove the %sannotation of %s.\n",
1429 fromsym, to, to, tosym, to_p, prl_to, tosym);
1432 case DATA_TO_ANY_EXIT: {
1433 prl_to = sec2annotation(tosec);
1435 "The variable %s references\n"
1437 "If the reference is valid then annotate the\n"
1438 "variable with __exit* (see linux/init.h) or "
1439 "name the variable:\n",
1440 fromsym, to, prl_to, tosym, to_p);
1441 print_section_list(mismatch->symbol_white_list);
1445 case XXXINIT_TO_SOME_INIT:
1446 case XXXEXIT_TO_SOME_EXIT:
1447 prl_from = sec2annotation(fromsec);
1448 prl_to = sec2annotation(tosec);
1450 "The %s %s%s%s references\n"
1452 "If %s is only used by %s then\n"
1453 "annotate %s with a matching annotation.\n",
1454 from, prl_from, fromsym, from_p,
1455 to, prl_to, tosym, to_p,
1456 tosym, fromsym, tosym);
1460 case ANY_INIT_TO_ANY_EXIT:
1461 prl_from = sec2annotation(fromsec);
1462 prl_to = sec2annotation(tosec);
1464 "The %s %s%s%s references\n"
1466 "This is often seen when error handling "
1467 "in the init function\n"
1468 "uses functionality in the exit path.\n"
1469 "The fix is often to remove the %sannotation of\n"
1470 "%s%s so it may be used outside an exit section.\n",
1471 from, prl_from, fromsym, from_p,
1472 to, prl_to, tosym, to_p,
1473 prl_to, tosym, to_p);
1477 case ANY_EXIT_TO_ANY_INIT:
1478 prl_from = sec2annotation(fromsec);
1479 prl_to = sec2annotation(tosec);
1481 "The %s %s%s%s references\n"
1483 "This is often seen when error handling "
1484 "in the exit function\n"
1485 "uses functionality in the init path.\n"
1486 "The fix is often to remove the %sannotation of\n"
1487 "%s%s so it may be used outside an init section.\n",
1488 from, prl_from, fromsym, from_p,
1489 to, prl_to, tosym, to_p,
1490 prl_to, tosym, to_p);
1494 case EXPORT_TO_INIT_EXIT:
1495 prl_to = sec2annotation(tosec);
1497 "The symbol %s is exported and annotated %s\n"
1498 "Fix this by removing the %sannotation of %s "
1499 "or drop the export.\n",
1500 tosym, prl_to, prl_to, tosym);
1503 case EXTABLE_TO_NON_TEXT:
1504 fatal("There's a special handler for this mismatch type, "
1505 "we should never get here.");
1508 fprintf(stderr, "\n");
1511 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1512 const struct sectioncheck* const mismatch,
1513 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1519 const char *fromsym;
1521 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1522 fromsym = sym_name(elf, from);
1524 if (!strncmp(fromsym, "reference___initcall",
1525 sizeof("reference___initcall")-1))
1528 tosec = sec_name(elf, get_secindex(elf, sym));
1529 to = find_elf_symbol(elf, r->r_addend, sym);
1530 tosym = sym_name(elf, to);
1532 /* check whitelist - we may ignore it */
1533 if (secref_whitelist(mismatch,
1534 fromsec, fromsym, tosec, tosym)) {
1535 report_sec_mismatch(modname, mismatch,
1536 fromsec, r->r_offset, fromsym,
1537 is_function(from), tosec, tosym,
1542 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1544 if (section_index > elf->num_sections)
1545 fatal("section_index is outside elf->num_sections!\n");
1547 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1551 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1552 * to know the sizeof(struct exception_table_entry) for the target architecture.
1554 static unsigned int extable_entry_size = 0;
1555 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1558 * If we're currently checking the second relocation within __ex_table,
1559 * that relocation offset tells us the offsetof(struct
1560 * exception_table_entry, fixup) which is equal to sizeof(struct
1561 * exception_table_entry) divided by two. We use that to our advantage
1562 * since there's no portable way to get that size as every architecture
1563 * seems to go with different sized types. Not pretty but better than
1564 * hard-coding the size for every architecture..
1566 if (!extable_entry_size)
1567 extable_entry_size = r->r_offset * 2;
1570 static inline bool is_extable_fault_address(Elf_Rela *r)
1573 * extable_entry_size is only discovered after we've handled the
1574 * _second_ relocation in __ex_table, so only abort when we're not
1575 * handling the first reloc and extable_entry_size is zero.
1577 if (r->r_offset && extable_entry_size == 0)
1578 fatal("extable_entry size hasn't been discovered!\n");
1580 return ((r->r_offset == 0) ||
1581 (r->r_offset % extable_entry_size == 0));
1584 #define is_second_extable_reloc(Start, Cur, Sec) \
1585 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1587 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1588 const struct sectioncheck* const mismatch,
1589 Elf_Rela* r, Elf_Sym* sym,
1590 const char* fromsec, const char* tosec)
1592 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1593 const char* fromsym_name = sym_name(elf, fromsym);
1594 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1595 const char* tosym_name = sym_name(elf, tosym);
1596 const char* from_pretty_name;
1597 const char* from_pretty_name_p;
1598 const char* to_pretty_name;
1599 const char* to_pretty_name_p;
1601 get_pretty_name(is_function(fromsym),
1602 &from_pretty_name, &from_pretty_name_p);
1603 get_pretty_name(is_function(tosym),
1604 &to_pretty_name, &to_pretty_name_p);
1606 warn("%s(%s+0x%lx): Section mismatch in reference"
1607 " from the %s %s%s to the %s %s:%s%s\n",
1608 modname, fromsec, (long)r->r_offset, from_pretty_name,
1609 fromsym_name, from_pretty_name_p,
1610 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1612 if (!match(tosec, mismatch->bad_tosec) &&
1613 is_executable_section(elf, get_secindex(elf, sym)))
1615 "The relocation at %s+0x%lx references\n"
1616 "section \"%s\" which is not in the list of\n"
1617 "authorized sections. If you're adding a new section\n"
1618 "and/or if this reference is valid, add \"%s\" to the\n"
1619 "list of authorized sections to jump to on fault.\n"
1620 "This can be achieved by adding \"%s\" to \n"
1621 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1622 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1625 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1626 const struct sectioncheck* const mismatch,
1627 Elf_Rela* r, Elf_Sym* sym,
1628 const char *fromsec)
1630 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1632 sec_mismatch_count++;
1634 if (sec_mismatch_verbose)
1635 report_extable_warnings(modname, elf, mismatch, r, sym,
1638 if (match(tosec, mismatch->bad_tosec))
1639 fatal("The relocation at %s+0x%lx references\n"
1640 "section \"%s\" which is black-listed.\n"
1641 "Something is seriously wrong and should be fixed.\n"
1642 "You might get more information about where this is\n"
1643 "coming from by using scripts/check_extable.sh %s\n",
1644 fromsec, (long)r->r_offset, tosec, modname);
1645 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1646 if (is_extable_fault_address(r))
1647 fatal("The relocation at %s+0x%lx references\n"
1648 "section \"%s\" which is not executable, IOW\n"
1649 "it is not possible for the kernel to fault\n"
1650 "at that address. Something is seriously wrong\n"
1651 "and should be fixed.\n",
1652 fromsec, (long)r->r_offset, tosec);
1654 fatal("The relocation at %s+0x%lx references\n"
1655 "section \"%s\" which is not executable, IOW\n"
1656 "the kernel will fault if it ever tries to\n"
1657 "jump to it. Something is seriously wrong\n"
1658 "and should be fixed.\n",
1659 fromsec, (long)r->r_offset, tosec);
1663 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1664 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1666 const char *tosec = sec_name(elf, get_secindex(elf, sym));;
1667 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1670 if (mismatch->handler)
1671 mismatch->handler(modname, elf, mismatch,
1674 default_mismatch_handler(modname, elf, mismatch,
1679 static unsigned int *reloc_location(struct elf_info *elf,
1680 Elf_Shdr *sechdr, Elf_Rela *r)
1682 Elf_Shdr *sechdrs = elf->sechdrs;
1683 int section = sechdr->sh_info;
1685 return (void *)elf->hdr + sechdrs[section].sh_offset +
1689 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1691 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1692 unsigned int *location = reloc_location(elf, sechdr, r);
1696 r->r_addend = TO_NATIVE(*location);
1699 r->r_addend = TO_NATIVE(*location) + 4;
1700 /* For CONFIG_RELOCATABLE=y */
1701 if (elf->hdr->e_type == ET_EXEC)
1702 r->r_addend += r->r_offset;
1709 #define R_ARM_CALL 28
1711 #ifndef R_ARM_JUMP24
1712 #define R_ARM_JUMP24 29
1715 #ifndef R_ARM_THM_CALL
1716 #define R_ARM_THM_CALL 10
1718 #ifndef R_ARM_THM_JUMP24
1719 #define R_ARM_THM_JUMP24 30
1721 #ifndef R_ARM_THM_JUMP19
1722 #define R_ARM_THM_JUMP19 51
1725 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1727 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1731 /* From ARM ABI: (S + A) | T */
1732 r->r_addend = (int)(long)
1733 (elf->symtab_start + ELF_R_SYM(r->r_info));
1738 case R_ARM_THM_CALL:
1739 case R_ARM_THM_JUMP24:
1740 case R_ARM_THM_JUMP19:
1741 /* From ARM ABI: ((S + A) | T) - P */
1742 r->r_addend = (int)(long)(elf->hdr +
1744 (r->r_offset - sechdr->sh_addr));
1752 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1754 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1755 unsigned int *location = reloc_location(elf, sechdr, r);
1758 if (r_typ == R_MIPS_HI16)
1759 return 1; /* skip this */
1760 inst = TO_NATIVE(*location);
1763 r->r_addend = inst & 0xffff;
1766 r->r_addend = (inst & 0x03ffffff) << 2;
1775 static void section_rela(const char *modname, struct elf_info *elf,
1782 const char *fromsec;
1784 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1785 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1787 fromsec = sech_name(elf, sechdr);
1788 fromsec += strlen(".rela");
1789 /* if from section (name) is know good then skip it */
1790 if (match(fromsec, section_white_list))
1793 for (rela = start; rela < stop; rela++) {
1794 r.r_offset = TO_NATIVE(rela->r_offset);
1795 #if KERNEL_ELFCLASS == ELFCLASS64
1796 if (elf->hdr->e_machine == EM_MIPS) {
1798 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1799 r_sym = TO_NATIVE(r_sym);
1800 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1801 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1803 r.r_info = TO_NATIVE(rela->r_info);
1804 r_sym = ELF_R_SYM(r.r_info);
1807 r.r_info = TO_NATIVE(rela->r_info);
1808 r_sym = ELF_R_SYM(r.r_info);
1810 r.r_addend = TO_NATIVE(rela->r_addend);
1811 sym = elf->symtab_start + r_sym;
1812 /* Skip special sections */
1813 if (is_shndx_special(sym->st_shndx))
1815 if (is_second_extable_reloc(start, rela, fromsec))
1816 find_extable_entry_size(fromsec, &r);
1817 check_section_mismatch(modname, elf, &r, sym, fromsec);
1821 static void section_rel(const char *modname, struct elf_info *elf,
1828 const char *fromsec;
1830 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1831 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1833 fromsec = sech_name(elf, sechdr);
1834 fromsec += strlen(".rel");
1835 /* if from section (name) is know good then skip it */
1836 if (match(fromsec, section_white_list))
1839 for (rel = start; rel < stop; rel++) {
1840 r.r_offset = TO_NATIVE(rel->r_offset);
1841 #if KERNEL_ELFCLASS == ELFCLASS64
1842 if (elf->hdr->e_machine == EM_MIPS) {
1844 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1845 r_sym = TO_NATIVE(r_sym);
1846 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1847 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1849 r.r_info = TO_NATIVE(rel->r_info);
1850 r_sym = ELF_R_SYM(r.r_info);
1853 r.r_info = TO_NATIVE(rel->r_info);
1854 r_sym = ELF_R_SYM(r.r_info);
1857 switch (elf->hdr->e_machine) {
1859 if (addend_386_rel(elf, sechdr, &r))
1863 if (addend_arm_rel(elf, sechdr, &r))
1867 if (addend_mips_rel(elf, sechdr, &r))
1871 sym = elf->symtab_start + r_sym;
1872 /* Skip special sections */
1873 if (is_shndx_special(sym->st_shndx))
1875 if (is_second_extable_reloc(start, rel, fromsec))
1876 find_extable_entry_size(fromsec, &r);
1877 check_section_mismatch(modname, elf, &r, sym, fromsec);
1882 * A module includes a number of sections that are discarded
1883 * either when loaded or when used as built-in.
1884 * For loaded modules all functions marked __init and all data
1885 * marked __initdata will be discarded when the module has been initialized.
1886 * Likewise for modules used built-in the sections marked __exit
1887 * are discarded because __exit marked function are supposed to be called
1888 * only when a module is unloaded which never happens for built-in modules.
1889 * The check_sec_ref() function traverses all relocation records
1890 * to find all references to a section that reference a section that will
1891 * be discarded and warns about it.
1893 static void check_sec_ref(struct module *mod, const char *modname,
1894 struct elf_info *elf)
1897 Elf_Shdr *sechdrs = elf->sechdrs;
1899 /* Walk through all sections */
1900 for (i = 0; i < elf->num_sections; i++) {
1901 check_section(modname, elf, &elf->sechdrs[i]);
1902 /* We want to process only relocation sections and not .init */
1903 if (sechdrs[i].sh_type == SHT_RELA)
1904 section_rela(modname, elf, &elf->sechdrs[i]);
1905 else if (sechdrs[i].sh_type == SHT_REL)
1906 section_rel(modname, elf, &elf->sechdrs[i]);
1910 static char *remove_dot(char *s)
1912 size_t n = strcspn(s, ".");
1915 size_t m = strspn(s + n + 1, "0123456789");
1916 if (m && (s[n + m] == '.' || s[n + m] == 0))
1922 static void read_symbols(char *modname)
1924 const char *symname;
1928 struct elf_info info = { };
1931 if (!parse_elf(&info, modname))
1934 mod = new_module(modname);
1936 /* When there's no vmlinux, don't print warnings about
1937 * unresolved symbols (since there'll be too many ;) */
1938 if (is_vmlinux(modname)) {
1943 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1944 if (info.modinfo && !license && !is_vmlinux(modname))
1945 warn("modpost: missing MODULE_LICENSE() in %s\n"
1946 "see include/linux/module.h for "
1947 "more information\n", modname);
1949 if (license_is_gpl_compatible(license))
1950 mod->gpl_compatible = 1;
1952 mod->gpl_compatible = 0;
1955 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1956 "license", license);
1959 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1960 symname = remove_dot(info.strtab + sym->st_name);
1962 handle_modversions(mod, &info, sym, symname);
1963 handle_moddevtable(mod, &info, sym, symname);
1965 if (!is_vmlinux(modname) ||
1966 (is_vmlinux(modname) && vmlinux_section_warnings))
1967 check_sec_ref(mod, modname, &info);
1969 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1971 maybe_frob_rcs_version(modname, version, info.modinfo,
1972 version - (char *)info.hdr);
1973 if (version || (all_versions && !is_vmlinux(modname)))
1974 get_src_version(modname, mod->srcversion,
1975 sizeof(mod->srcversion)-1);
1977 parse_elf_finish(&info);
1979 /* Our trick to get versioning for module struct etc. - it's
1980 * never passed as an argument to an exported function, so
1981 * the automatic versioning doesn't pick it up, but it's really
1982 * important anyhow */
1984 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
1987 static void read_symbols_from_files(const char *filename)
1990 char fname[PATH_MAX];
1992 if (strcmp(filename, "-") != 0) {
1993 in = fopen(filename, "r");
1995 fatal("Can't open filenames file %s: %m", filename);
1998 while (fgets(fname, PATH_MAX, in) != NULL) {
1999 if (strends(fname, "\n"))
2000 fname[strlen(fname)-1] = '\0';
2001 read_symbols(fname);
2010 /* We first write the generated file into memory using the
2011 * following helper, then compare to the file on disk and
2012 * only update the later if anything changed */
2014 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2015 const char *fmt, ...)
2022 len = vsnprintf(tmp, SZ, fmt, ap);
2023 buf_write(buf, tmp, len);
2027 void buf_write(struct buffer *buf, const char *s, int len)
2029 if (buf->size - buf->pos < len) {
2030 buf->size += len + SZ;
2031 buf->p = realloc(buf->p, buf->size);
2033 strncpy(buf->p + buf->pos, s, len);
2037 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2039 const char *e = is_vmlinux(m) ?"":".ko";
2043 fatal("modpost: GPL-incompatible module %s%s "
2044 "uses GPL-only symbol '%s'\n", m, e, s);
2046 case export_unused_gpl:
2047 fatal("modpost: GPL-incompatible module %s%s "
2048 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2050 case export_gpl_future:
2051 warn("modpost: GPL-incompatible module %s%s "
2052 "uses future GPL-only symbol '%s'\n", m, e, s);
2056 case export_unknown:
2062 static void check_for_unused(enum export exp, const char *m, const char *s)
2064 const char *e = is_vmlinux(m) ?"":".ko";
2068 case export_unused_gpl:
2069 warn("modpost: module %s%s "
2070 "uses symbol '%s' marked UNUSED\n", m, e, s);
2078 static void check_exports(struct module *mod)
2080 struct symbol *s, *exp;
2082 for (s = mod->unres; s; s = s->next) {
2083 const char *basename;
2084 exp = find_symbol(s->name);
2085 if (!exp || exp->module == mod)
2087 basename = strrchr(mod->name, '/');
2091 basename = mod->name;
2092 if (!mod->gpl_compatible)
2093 check_for_gpl_usage(exp->export, basename, exp->name);
2094 check_for_unused(exp->export, basename, exp->name);
2099 * Header for the generated file
2101 static void add_header(struct buffer *b, struct module *mod)
2103 buf_printf(b, "#include <linux/module.h>\n");
2104 buf_printf(b, "#include <linux/vermagic.h>\n");
2105 buf_printf(b, "#include <linux/compiler.h>\n");
2106 buf_printf(b, "\n");
2107 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2108 buf_printf(b, "\n");
2109 buf_printf(b, "__visible struct module __this_module\n");
2110 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
2111 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2113 buf_printf(b, "\t.init = init_module,\n");
2114 if (mod->has_cleanup)
2115 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2116 "\t.exit = cleanup_module,\n"
2118 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2119 buf_printf(b, "};\n");
2122 static void add_intree_flag(struct buffer *b, int is_intree)
2125 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2128 static void add_staging_flag(struct buffer *b, const char *name)
2130 static const char *staging_dir = "drivers/staging";
2132 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2133 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2137 * Record CRCs for unresolved symbols
2139 static int add_versions(struct buffer *b, struct module *mod)
2141 struct symbol *s, *exp;
2144 for (s = mod->unres; s; s = s->next) {
2145 exp = find_symbol(s->name);
2146 if (!exp || exp->module == mod) {
2147 if (have_vmlinux && !s->weak) {
2148 if (warn_unresolved) {
2149 warn("\"%s\" [%s.ko] undefined!\n",
2150 s->name, mod->name);
2152 merror("\"%s\" [%s.ko] undefined!\n",
2153 s->name, mod->name);
2159 s->module = exp->module;
2160 s->crc_valid = exp->crc_valid;
2167 buf_printf(b, "\n");
2168 buf_printf(b, "static const struct modversion_info ____versions[]\n");
2169 buf_printf(b, "__used\n");
2170 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2172 for (s = mod->unres; s; s = s->next) {
2175 if (!s->crc_valid) {
2176 warn("\"%s\" [%s.ko] has no CRC!\n",
2177 s->name, mod->name);
2180 buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
2184 buf_printf(b, "};\n");
2189 static void add_depends(struct buffer *b, struct module *mod,
2190 struct module *modules)
2196 for (m = modules; m; m = m->next)
2197 m->seen = is_vmlinux(m->name);
2199 buf_printf(b, "\n");
2200 buf_printf(b, "static const char __module_depends[]\n");
2201 buf_printf(b, "__used\n");
2202 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2203 buf_printf(b, "\"depends=");
2204 for (s = mod->unres; s; s = s->next) {
2209 if (s->module->seen)
2212 s->module->seen = 1;
2213 p = strrchr(s->module->name, '/');
2217 p = s->module->name;
2218 buf_printf(b, "%s%s", first ? "" : ",", p);
2221 buf_printf(b, "\";\n");
2224 static void add_srcversion(struct buffer *b, struct module *mod)
2226 if (mod->srcversion[0]) {
2227 buf_printf(b, "\n");
2228 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2233 static void write_if_changed(struct buffer *b, const char *fname)
2239 file = fopen(fname, "r");
2243 if (fstat(fileno(file), &st) < 0)
2246 if (st.st_size != b->pos)
2249 tmp = NOFAIL(malloc(b->pos));
2250 if (fread(tmp, 1, b->pos, file) != b->pos)
2253 if (memcmp(tmp, b->p, b->pos) != 0)
2265 file = fopen(fname, "w");
2270 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2277 /* parse Module.symvers file. line format:
2278 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2280 static void read_dump(const char *fname, unsigned int kernel)
2282 unsigned long size, pos = 0;
2283 void *file = grab_file(fname, &size);
2287 /* No symbol versions, silently ignore */
2290 while ((line = get_next_line(&pos, file, size))) {
2291 char *symname, *modname, *d, *export, *end;
2296 if (!(symname = strchr(line, '\t')))
2299 if (!(modname = strchr(symname, '\t')))
2302 if ((export = strchr(modname, '\t')) != NULL)
2304 if (export && ((end = strchr(export, '\t')) != NULL))
2306 crc = strtoul(line, &d, 16);
2307 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2309 mod = find_module(modname);
2311 if (is_vmlinux(modname))
2313 mod = new_module(modname);
2316 s = sym_add_exported(symname, mod, export_no(export));
2319 sym_update_crc(symname, mod, crc, export_no(export));
2321 release_file(file, size);
2324 release_file(file, size);
2325 fatal("parse error in symbol dump file\n");
2328 /* For normal builds always dump all symbols.
2329 * For external modules only dump symbols
2330 * that are not read from kernel Module.symvers.
2332 static int dump_sym(struct symbol *sym)
2334 if (!external_module)
2336 if (sym->vmlinux || sym->kernel)
2341 static void write_dump(const char *fname)
2343 struct buffer buf = { };
2344 struct symbol *symbol;
2347 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2348 symbol = symbolhash[n];
2350 if (dump_sym(symbol))
2351 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2352 symbol->crc, symbol->name,
2353 symbol->module->name,
2354 export_str(symbol->export));
2355 symbol = symbol->next;
2358 write_if_changed(&buf, fname);
2361 struct ext_sym_list {
2362 struct ext_sym_list *next;
2366 int main(int argc, char **argv)
2369 struct buffer buf = { };
2370 char *kernel_read = NULL, *module_read = NULL;
2371 char *dump_write = NULL, *files_source = NULL;
2374 struct ext_sym_list *extsym_iter;
2375 struct ext_sym_list *extsym_start = NULL;
2377 while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:")) != -1) {
2380 kernel_read = optarg;
2383 module_read = optarg;
2384 external_module = 1;
2387 external_module = 1;
2389 NOFAIL(malloc(sizeof(*extsym_iter)));
2390 extsym_iter->next = extsym_start;
2391 extsym_iter->file = optarg;
2392 extsym_start = extsym_iter;
2398 ignore_missing_files = 1;
2401 dump_write = optarg;
2407 vmlinux_section_warnings = 0;
2410 sec_mismatch_verbose = 0;
2413 files_source = optarg;
2416 warn_unresolved = 1;
2424 read_dump(kernel_read, 1);
2426 read_dump(module_read, 0);
2427 while (extsym_start) {
2428 read_dump(extsym_start->file, 0);
2429 extsym_iter = extsym_start->next;
2431 extsym_start = extsym_iter;
2434 while (optind < argc)
2435 read_symbols(argv[optind++]);
2438 read_symbols_from_files(files_source);
2440 for (mod = modules; mod; mod = mod->next) {
2448 for (mod = modules; mod; mod = mod->next) {
2449 char fname[PATH_MAX];
2456 add_header(&buf, mod);
2457 add_intree_flag(&buf, !external_module);
2458 add_staging_flag(&buf, mod->name);
2459 err |= add_versions(&buf, mod);
2460 add_depends(&buf, mod, modules);
2461 add_moddevtable(&buf, mod);
2462 add_srcversion(&buf, mod);
2464 sprintf(fname, "%s.mod.c", mod->name);
2465 write_if_changed(&buf, fname);
2469 write_dump(dump_write);
2470 if (sec_mismatch_count && !sec_mismatch_verbose)
2471 warn("modpost: Found %d section mismatch(es).\n"
2472 "To see full details build your kernel with:\n"
2473 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2474 sec_mismatch_count);