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 ...
23 #include "../../include/linux/license.h"
25 /* Are we using CONFIG_MODVERSIONS? */
26 static int modversions
= 0;
27 /* Warn about undefined symbols? (do so if we have vmlinux) */
28 static int have_vmlinux
= 0;
29 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
30 static int all_versions
= 0;
31 /* If we are modposting external module set to 1 */
32 static int external_module
= 0;
33 /* Warn about section mismatch in vmlinux if set to 1 */
34 static int vmlinux_section_warnings
= 1;
35 /* Only warn about unresolved symbols */
36 static int warn_unresolved
= 0;
37 /* How a symbol is exported */
38 static int sec_mismatch_count
= 0;
39 static int sec_mismatch_fatal
= 0;
40 /* ignore missing files */
41 static int ignore_missing_files
;
44 export_plain
, export_unused
, export_gpl
,
45 export_unused_gpl
, export_gpl_future
, export_unknown
48 /* In kernel, this size is defined in linux/module.h;
49 * here we use Elf_Addr instead of long for covering cross-compile
52 #define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
54 #define PRINTF __attribute__ ((format (printf, 1, 2)))
56 PRINTF
void fatal(const char *fmt
, ...)
60 fprintf(stderr
, "FATAL: ");
62 va_start(arglist
, fmt
);
63 vfprintf(stderr
, fmt
, arglist
);
69 PRINTF
void warn(const char *fmt
, ...)
73 fprintf(stderr
, "WARNING: ");
75 va_start(arglist
, fmt
);
76 vfprintf(stderr
, fmt
, arglist
);
80 PRINTF
void merror(const char *fmt
, ...)
84 fprintf(stderr
, "ERROR: ");
86 va_start(arglist
, fmt
);
87 vfprintf(stderr
, fmt
, arglist
);
91 static inline bool strends(const char *str
, const char *postfix
)
93 if (strlen(str
) < strlen(postfix
))
96 return strcmp(str
+ strlen(str
) - strlen(postfix
), postfix
) == 0;
99 static int is_vmlinux(const char *modname
)
103 myname
= strrchr(modname
, '/');
109 return (strcmp(myname
, "vmlinux") == 0) ||
110 (strcmp(myname
, "vmlinux.o") == 0);
113 void *do_nofail(void *ptr
, const char *expr
)
116 fatal("modpost: Memory allocation failure: %s.\n", expr
);
121 /* A list of all modules we processed */
122 static struct module
*modules
;
124 static struct module
*find_module(const char *modname
)
128 for (mod
= modules
; mod
; mod
= mod
->next
)
129 if (strcmp(mod
->name
, modname
) == 0)
134 static struct module
*new_module(const char *modname
)
139 mod
= NOFAIL(malloc(sizeof(*mod
)));
140 memset(mod
, 0, sizeof(*mod
));
141 p
= NOFAIL(strdup(modname
));
143 /* strip trailing .o */
144 if (strends(p
, ".o")) {
145 p
[strlen(p
) - 2] = '\0';
151 mod
->gpl_compatible
= -1;
158 /* A hash of all exported symbols,
159 * struct symbol is also used for lists of unresolved symbols */
161 #define SYMBOL_HASH_SIZE 1024
165 struct module
*module
;
170 unsigned int vmlinux
:1; /* 1 if symbol is defined in vmlinux */
171 unsigned int kernel
:1; /* 1 if symbol is from kernel
172 * (only for external modules) **/
173 unsigned int is_static
:1; /* 1 if symbol is not global */
174 enum export export
; /* Type of export */
178 static struct symbol
*symbolhash
[SYMBOL_HASH_SIZE
];
180 /* This is based on the hash agorithm from gdbm, via tdb */
181 static inline unsigned int tdb_hash(const char *name
)
183 unsigned value
; /* Used to compute the hash value. */
184 unsigned i
; /* Used to cycle through random values. */
186 /* Set the initial value from the key size. */
187 for (value
= 0x238F13AF * strlen(name
), i
= 0; name
[i
]; i
++)
188 value
= (value
+ (((unsigned char *)name
)[i
] << (i
*5 % 24)));
190 return (1103515243 * value
+ 12345);
194 * Allocate a new symbols for use in the hash of exported symbols or
195 * the list of unresolved symbols per module
197 static struct symbol
*alloc_symbol(const char *name
, unsigned int weak
,
200 struct symbol
*s
= NOFAIL(malloc(sizeof(*s
) + strlen(name
) + 1));
202 memset(s
, 0, sizeof(*s
));
203 strcpy(s
->name
, name
);
210 /* For the hash of exported symbols */
211 static struct symbol
*new_symbol(const char *name
, struct module
*module
,
216 hash
= tdb_hash(name
) % SYMBOL_HASH_SIZE
;
217 symbolhash
[hash
] = alloc_symbol(name
, 0, symbolhash
[hash
]);
219 return symbolhash
[hash
];
222 static struct symbol
*find_symbol(const char *name
)
226 /* For our purposes, .foo matches foo. PPC64 needs this. */
230 for (s
= symbolhash
[tdb_hash(name
) % SYMBOL_HASH_SIZE
]; s
; s
= s
->next
) {
231 if (strcmp(s
->name
, name
) == 0)
237 static bool contains_namespace(struct namespace_list
*list
,
238 const char *namespace)
240 for (; list
; list
= list
->next
)
241 if (!strcmp(list
->namespace, namespace))
247 static void add_namespace(struct namespace_list
**list
, const char *namespace)
249 struct namespace_list
*ns_entry
;
251 if (!contains_namespace(*list
, namespace)) {
252 ns_entry
= NOFAIL(malloc(sizeof(struct namespace_list
) +
253 strlen(namespace) + 1));
254 strcpy(ns_entry
->namespace, namespace);
255 ns_entry
->next
= *list
;
260 static bool module_imports_namespace(struct module
*module
,
261 const char *namespace)
263 return contains_namespace(module
->imported_namespaces
, namespace);
266 static const struct {
270 { .str
= "EXPORT_SYMBOL", .export
= export_plain
},
271 { .str
= "EXPORT_UNUSED_SYMBOL", .export
= export_unused
},
272 { .str
= "EXPORT_SYMBOL_GPL", .export
= export_gpl
},
273 { .str
= "EXPORT_UNUSED_SYMBOL_GPL", .export
= export_unused_gpl
},
274 { .str
= "EXPORT_SYMBOL_GPL_FUTURE", .export
= export_gpl_future
},
275 { .str
= "(unknown)", .export
= export_unknown
},
279 static const char *export_str(enum export ex
)
281 return export_list
[ex
].str
;
284 static enum export
export_no(const char *s
)
289 return export_unknown
;
290 for (i
= 0; export_list
[i
].export
!= export_unknown
; i
++) {
291 if (strcmp(export_list
[i
].str
, s
) == 0)
292 return export_list
[i
].export
;
294 return export_unknown
;
297 static const char *sech_name(struct elf_info
*elf
, Elf_Shdr
*sechdr
)
299 return (void *)elf
->hdr
+
300 elf
->sechdrs
[elf
->secindex_strings
].sh_offset
+
304 static const char *sec_name(struct elf_info
*elf
, int secindex
)
306 return sech_name(elf
, &elf
->sechdrs
[secindex
]);
309 static void *sym_get_data(const struct elf_info
*info
, const Elf_Sym
*sym
)
311 unsigned int secindex
= get_secindex(info
, sym
);
312 Elf_Shdr
*sechdr
= &info
->sechdrs
[secindex
];
313 unsigned long offset
;
315 offset
= sym
->st_value
;
316 if (info
->hdr
->e_type
!= ET_REL
)
317 offset
-= sechdr
->sh_addr
;
319 return (void *)info
->hdr
+ sechdr
->sh_offset
+ offset
;
322 #define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
324 static enum export
export_from_secname(struct elf_info
*elf
, unsigned int sec
)
326 const char *secname
= sec_name(elf
, sec
);
328 if (strstarts(secname
, "___ksymtab+"))
330 else if (strstarts(secname
, "___ksymtab_unused+"))
331 return export_unused
;
332 else if (strstarts(secname
, "___ksymtab_gpl+"))
334 else if (strstarts(secname
, "___ksymtab_unused_gpl+"))
335 return export_unused_gpl
;
336 else if (strstarts(secname
, "___ksymtab_gpl_future+"))
337 return export_gpl_future
;
339 return export_unknown
;
342 static enum export
export_from_sec(struct elf_info
*elf
, unsigned int sec
)
344 if (sec
== elf
->export_sec
)
346 else if (sec
== elf
->export_unused_sec
)
347 return export_unused
;
348 else if (sec
== elf
->export_gpl_sec
)
350 else if (sec
== elf
->export_unused_gpl_sec
)
351 return export_unused_gpl
;
352 else if (sec
== elf
->export_gpl_future_sec
)
353 return export_gpl_future
;
355 return export_unknown
;
358 static const char *namespace_from_kstrtabns(const struct elf_info
*info
,
361 const char *value
= sym_get_data(info
, sym
);
362 return value
[0] ? value
: NULL
;
365 static void sym_update_namespace(const char *symname
, const char *namespace)
367 struct symbol
*s
= find_symbol(symname
);
370 * That symbol should have been created earlier and thus this is
371 * actually an assertion.
374 merror("Could not update namespace(%s) for symbol %s\n",
381 namespace && namespace[0] ? NOFAIL(strdup(namespace)) : NULL
;
385 * Add an exported symbol - it may have already been added without a
386 * CRC, in this case just update the CRC
388 static struct symbol
*sym_add_exported(const char *name
, struct module
*mod
,
391 struct symbol
*s
= find_symbol(name
);
394 s
= new_symbol(name
, mod
, export
);
395 } else if (!external_module
|| is_vmlinux(s
->module
->name
) ||
397 warn("%s: '%s' exported twice. Previous export was in %s%s\n",
398 mod
->name
, name
, s
->module
->name
,
399 is_vmlinux(s
->module
->name
) ? "" : ".ko");
404 s
->vmlinux
= is_vmlinux(mod
->name
);
410 static void sym_set_crc(const char *name
, unsigned int crc
)
412 struct symbol
*s
= find_symbol(name
);
415 * Ignore stand-alone __crc_*, which might be auto-generated symbols
416 * such as __*_veneer in ARM ELF.
425 void *grab_file(const char *filename
, unsigned long *size
)
428 void *map
= MAP_FAILED
;
431 fd
= open(filename
, O_RDONLY
);
438 map
= mmap(NULL
, *size
, PROT_READ
|PROT_WRITE
, MAP_PRIVATE
, fd
, 0);
442 if (map
== MAP_FAILED
)
448 * Return a copy of the next line in a mmap'ed file.
449 * spaces in the beginning of the line is trimmed away.
450 * Return a pointer to a static buffer.
452 char *get_next_line(unsigned long *pos
, void *file
, unsigned long size
)
454 static char line
[4096];
457 signed char *p
= (signed char *)file
+ *pos
;
460 for (; *pos
< size
; (*pos
)++) {
461 if (skip
&& isspace(*p
)) {
466 if (*p
!= '\n' && (*pos
< size
)) {
470 break; /* Too long, stop */
481 void release_file(void *file
, unsigned long size
)
486 static int parse_elf(struct elf_info
*info
, const char *filename
)
492 const char *secstrings
;
493 unsigned int symtab_idx
= ~0U, symtab_shndx_idx
= ~0U;
495 hdr
= grab_file(filename
, &info
->size
);
497 if (ignore_missing_files
) {
498 fprintf(stderr
, "%s: %s (ignored)\n", filename
,
506 if (info
->size
< sizeof(*hdr
)) {
507 /* file too small, assume this is an empty .o file */
510 /* Is this a valid ELF file? */
511 if ((hdr
->e_ident
[EI_MAG0
] != ELFMAG0
) ||
512 (hdr
->e_ident
[EI_MAG1
] != ELFMAG1
) ||
513 (hdr
->e_ident
[EI_MAG2
] != ELFMAG2
) ||
514 (hdr
->e_ident
[EI_MAG3
] != ELFMAG3
)) {
515 /* Not an ELF file - silently ignore it */
518 /* Fix endianness in ELF header */
519 hdr
->e_type
= TO_NATIVE(hdr
->e_type
);
520 hdr
->e_machine
= TO_NATIVE(hdr
->e_machine
);
521 hdr
->e_version
= TO_NATIVE(hdr
->e_version
);
522 hdr
->e_entry
= TO_NATIVE(hdr
->e_entry
);
523 hdr
->e_phoff
= TO_NATIVE(hdr
->e_phoff
);
524 hdr
->e_shoff
= TO_NATIVE(hdr
->e_shoff
);
525 hdr
->e_flags
= TO_NATIVE(hdr
->e_flags
);
526 hdr
->e_ehsize
= TO_NATIVE(hdr
->e_ehsize
);
527 hdr
->e_phentsize
= TO_NATIVE(hdr
->e_phentsize
);
528 hdr
->e_phnum
= TO_NATIVE(hdr
->e_phnum
);
529 hdr
->e_shentsize
= TO_NATIVE(hdr
->e_shentsize
);
530 hdr
->e_shnum
= TO_NATIVE(hdr
->e_shnum
);
531 hdr
->e_shstrndx
= TO_NATIVE(hdr
->e_shstrndx
);
532 sechdrs
= (void *)hdr
+ hdr
->e_shoff
;
533 info
->sechdrs
= sechdrs
;
535 /* Check if file offset is correct */
536 if (hdr
->e_shoff
> info
->size
) {
537 fatal("section header offset=%lu in file '%s' is bigger than "
538 "filesize=%lu\n", (unsigned long)hdr
->e_shoff
,
539 filename
, info
->size
);
543 if (hdr
->e_shnum
== SHN_UNDEF
) {
545 * There are more than 64k sections,
546 * read count from .sh_size.
548 info
->num_sections
= TO_NATIVE(sechdrs
[0].sh_size
);
551 info
->num_sections
= hdr
->e_shnum
;
553 if (hdr
->e_shstrndx
== SHN_XINDEX
) {
554 info
->secindex_strings
= TO_NATIVE(sechdrs
[0].sh_link
);
557 info
->secindex_strings
= hdr
->e_shstrndx
;
560 /* Fix endianness in section headers */
561 for (i
= 0; i
< info
->num_sections
; i
++) {
562 sechdrs
[i
].sh_name
= TO_NATIVE(sechdrs
[i
].sh_name
);
563 sechdrs
[i
].sh_type
= TO_NATIVE(sechdrs
[i
].sh_type
);
564 sechdrs
[i
].sh_flags
= TO_NATIVE(sechdrs
[i
].sh_flags
);
565 sechdrs
[i
].sh_addr
= TO_NATIVE(sechdrs
[i
].sh_addr
);
566 sechdrs
[i
].sh_offset
= TO_NATIVE(sechdrs
[i
].sh_offset
);
567 sechdrs
[i
].sh_size
= TO_NATIVE(sechdrs
[i
].sh_size
);
568 sechdrs
[i
].sh_link
= TO_NATIVE(sechdrs
[i
].sh_link
);
569 sechdrs
[i
].sh_info
= TO_NATIVE(sechdrs
[i
].sh_info
);
570 sechdrs
[i
].sh_addralign
= TO_NATIVE(sechdrs
[i
].sh_addralign
);
571 sechdrs
[i
].sh_entsize
= TO_NATIVE(sechdrs
[i
].sh_entsize
);
573 /* Find symbol table. */
574 secstrings
= (void *)hdr
+ sechdrs
[info
->secindex_strings
].sh_offset
;
575 for (i
= 1; i
< info
->num_sections
; i
++) {
577 int nobits
= sechdrs
[i
].sh_type
== SHT_NOBITS
;
579 if (!nobits
&& sechdrs
[i
].sh_offset
> info
->size
) {
580 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
581 "sizeof(*hrd)=%zu\n", filename
,
582 (unsigned long)sechdrs
[i
].sh_offset
,
586 secname
= secstrings
+ sechdrs
[i
].sh_name
;
587 if (strcmp(secname
, ".modinfo") == 0) {
589 fatal("%s has NOBITS .modinfo\n", filename
);
590 info
->modinfo
= (void *)hdr
+ sechdrs
[i
].sh_offset
;
591 info
->modinfo_len
= sechdrs
[i
].sh_size
;
592 } else if (strcmp(secname
, "__ksymtab") == 0)
593 info
->export_sec
= i
;
594 else if (strcmp(secname
, "__ksymtab_unused") == 0)
595 info
->export_unused_sec
= i
;
596 else if (strcmp(secname
, "__ksymtab_gpl") == 0)
597 info
->export_gpl_sec
= i
;
598 else if (strcmp(secname
, "__ksymtab_unused_gpl") == 0)
599 info
->export_unused_gpl_sec
= i
;
600 else if (strcmp(secname
, "__ksymtab_gpl_future") == 0)
601 info
->export_gpl_future_sec
= i
;
603 if (sechdrs
[i
].sh_type
== SHT_SYMTAB
) {
604 unsigned int sh_link_idx
;
606 info
->symtab_start
= (void *)hdr
+
607 sechdrs
[i
].sh_offset
;
608 info
->symtab_stop
= (void *)hdr
+
609 sechdrs
[i
].sh_offset
+ sechdrs
[i
].sh_size
;
610 sh_link_idx
= sechdrs
[i
].sh_link
;
611 info
->strtab
= (void *)hdr
+
612 sechdrs
[sh_link_idx
].sh_offset
;
615 /* 32bit section no. table? ("more than 64k sections") */
616 if (sechdrs
[i
].sh_type
== SHT_SYMTAB_SHNDX
) {
617 symtab_shndx_idx
= i
;
618 info
->symtab_shndx_start
= (void *)hdr
+
619 sechdrs
[i
].sh_offset
;
620 info
->symtab_shndx_stop
= (void *)hdr
+
621 sechdrs
[i
].sh_offset
+ sechdrs
[i
].sh_size
;
624 if (!info
->symtab_start
)
625 fatal("%s has no symtab?\n", filename
);
627 /* Fix endianness in symbols */
628 for (sym
= info
->symtab_start
; sym
< info
->symtab_stop
; sym
++) {
629 sym
->st_shndx
= TO_NATIVE(sym
->st_shndx
);
630 sym
->st_name
= TO_NATIVE(sym
->st_name
);
631 sym
->st_value
= TO_NATIVE(sym
->st_value
);
632 sym
->st_size
= TO_NATIVE(sym
->st_size
);
635 if (symtab_shndx_idx
!= ~0U) {
637 if (symtab_idx
!= sechdrs
[symtab_shndx_idx
].sh_link
)
638 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
639 filename
, sechdrs
[symtab_shndx_idx
].sh_link
,
642 for (p
= info
->symtab_shndx_start
; p
< info
->symtab_shndx_stop
;
650 static void parse_elf_finish(struct elf_info
*info
)
652 release_file(info
->hdr
, info
->size
);
655 static int ignore_undef_symbol(struct elf_info
*info
, const char *symname
)
657 /* ignore __this_module, it will be resolved shortly */
658 if (strcmp(symname
, "__this_module") == 0)
660 /* ignore global offset table */
661 if (strcmp(symname
, "_GLOBAL_OFFSET_TABLE_") == 0)
663 if (info
->hdr
->e_machine
== EM_PPC
)
664 /* Special register function linked on all modules during final link of .ko */
665 if (strstarts(symname
, "_restgpr_") ||
666 strstarts(symname
, "_savegpr_") ||
667 strstarts(symname
, "_rest32gpr_") ||
668 strstarts(symname
, "_save32gpr_") ||
669 strstarts(symname
, "_restvr_") ||
670 strstarts(symname
, "_savevr_"))
672 if (info
->hdr
->e_machine
== EM_PPC64
)
673 /* Special register function linked on all modules during final link of .ko */
674 if (strstarts(symname
, "_restgpr0_") ||
675 strstarts(symname
, "_savegpr0_") ||
676 strstarts(symname
, "_restvr_") ||
677 strstarts(symname
, "_savevr_") ||
678 strcmp(symname
, ".TOC.") == 0)
680 /* Do not ignore this symbol */
684 static void handle_modversion(const struct module
*mod
,
685 const struct elf_info
*info
,
686 const Elf_Sym
*sym
, const char *symname
)
690 if (sym
->st_shndx
== SHN_UNDEF
) {
691 warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n",
692 symname
, mod
->name
, is_vmlinux(mod
->name
) ? "":".ko");
696 if (sym
->st_shndx
== SHN_ABS
) {
701 /* symbol points to the CRC in the ELF object */
702 crcp
= sym_get_data(info
, sym
);
703 crc
= TO_NATIVE(*crcp
);
705 sym_set_crc(symname
, crc
);
708 static void handle_symbol(struct module
*mod
, struct elf_info
*info
,
709 const Elf_Sym
*sym
, const char *symname
)
714 if ((!is_vmlinux(mod
->name
) || mod
->is_dot_o
) &&
715 strstarts(symname
, "__ksymtab"))
716 export
= export_from_secname(info
, get_secindex(info
, sym
));
718 export
= export_from_sec(info
, get_secindex(info
, sym
));
720 switch (sym
->st_shndx
) {
722 if (strstarts(symname
, "__gnu_lto_")) {
723 /* Should warn here, but modpost runs before the linker */
725 warn("\"%s\" [%s] is COMMON symbol\n", symname
, mod
->name
);
728 /* undefined symbol */
729 if (ELF_ST_BIND(sym
->st_info
) != STB_GLOBAL
&&
730 ELF_ST_BIND(sym
->st_info
) != STB_WEAK
)
732 if (ignore_undef_symbol(info
, symname
))
734 if (info
->hdr
->e_machine
== EM_SPARC
||
735 info
->hdr
->e_machine
== EM_SPARCV9
) {
736 /* Ignore register directives. */
737 if (ELF_ST_TYPE(sym
->st_info
) == STT_SPARC_REGISTER
)
739 if (symname
[0] == '.') {
740 char *munged
= NOFAIL(strdup(symname
));
742 munged
[1] = toupper(munged
[1]);
747 mod
->unres
= alloc_symbol(symname
,
748 ELF_ST_BIND(sym
->st_info
) == STB_WEAK
,
752 /* All exported symbols */
753 if (strstarts(symname
, "__ksymtab_")) {
754 name
= symname
+ strlen("__ksymtab_");
755 sym_add_exported(name
, mod
, export
);
757 if (strcmp(symname
, "init_module") == 0)
759 if (strcmp(symname
, "cleanup_module") == 0)
760 mod
->has_cleanup
= 1;
766 * Parse tag=value strings from .modinfo section
768 static char *next_string(char *string
, unsigned long *secsize
)
770 /* Skip non-zero chars */
773 if ((*secsize
)-- <= 1)
777 /* Skip any zero padding. */
780 if ((*secsize
)-- <= 1)
786 static char *get_next_modinfo(struct elf_info
*info
, const char *tag
,
790 unsigned int taglen
= strlen(tag
);
791 char *modinfo
= info
->modinfo
;
792 unsigned long size
= info
->modinfo_len
;
795 size
-= prev
- modinfo
;
796 modinfo
= next_string(prev
, &size
);
799 for (p
= modinfo
; p
; p
= next_string(p
, &size
)) {
800 if (strncmp(p
, tag
, taglen
) == 0 && p
[taglen
] == '=')
801 return p
+ taglen
+ 1;
806 static char *get_modinfo(struct elf_info
*info
, const char *tag
)
809 return get_next_modinfo(info
, tag
, NULL
);
813 * Test if string s ends in string sub
816 static int strrcmp(const char *s
, const char *sub
)
824 sublen
= strlen(sub
);
826 if ((slen
== 0) || (sublen
== 0))
832 return memcmp(s
+ slen
- sublen
, sub
, sublen
);
835 static const char *sym_name(struct elf_info
*elf
, Elf_Sym
*sym
)
838 return elf
->strtab
+ sym
->st_name
;
843 /* The pattern is an array of simple patterns.
844 * "foo" will match an exact string equal to "foo"
845 * "*foo" will match a string that ends with "foo"
846 * "foo*" will match a string that begins with "foo"
847 * "*foo*" will match a string that contains "foo"
849 static int match(const char *sym
, const char * const pat
[])
854 const char *endp
= p
+ strlen(p
) - 1;
857 if (*p
== '*' && *endp
== '*') {
858 char *bare
= NOFAIL(strndup(p
+ 1, strlen(p
) - 2));
859 char *here
= strstr(sym
, bare
);
866 else if (*p
== '*') {
867 if (strrcmp(sym
, p
+ 1) == 0)
871 else if (*endp
== '*') {
872 if (strncmp(sym
, p
, strlen(p
) - 1) == 0)
877 if (strcmp(p
, sym
) == 0)
885 /* sections that we do not want to do full section mismatch check on */
886 static const char *const section_white_list
[] =
890 ".cranges", /* sh64 */
891 ".zdebug*", /* Compressed debug sections. */
892 ".GCC.command.line", /* record-gcc-switches */
893 ".mdebug*", /* alpha, score, mips etc. */
894 ".pdr", /* alpha, score, mips etc. */
899 ".xt.prop", /* xtensa */
900 ".xt.lit", /* xtensa */
901 ".arcextmap*", /* arc */
902 ".gnu.linkonce.arcext*", /* arc : modules */
903 ".cmem*", /* EZchip */
904 ".fmt_slot*", /* EZchip */
911 * This is used to find sections missing the SHF_ALLOC flag.
912 * The cause of this is often a section specified in assembler
913 * without "ax" / "aw".
915 static void check_section(const char *modname
, struct elf_info
*elf
,
918 const char *sec
= sech_name(elf
, sechdr
);
920 if (sechdr
->sh_type
== SHT_PROGBITS
&&
921 !(sechdr
->sh_flags
& SHF_ALLOC
) &&
922 !match(sec
, section_white_list
)) {
923 warn("%s (%s): unexpected non-allocatable section.\n"
924 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
925 "Note that for example <linux/init.h> contains\n"
926 "section definitions for use in .S files.\n\n",
933 #define ALL_INIT_DATA_SECTIONS \
934 ".init.setup", ".init.rodata", ".meminit.rodata", \
935 ".init.data", ".meminit.data"
936 #define ALL_EXIT_DATA_SECTIONS \
937 ".exit.data", ".memexit.data"
939 #define ALL_INIT_TEXT_SECTIONS \
940 ".init.text", ".meminit.text"
941 #define ALL_EXIT_TEXT_SECTIONS \
942 ".exit.text", ".memexit.text"
944 #define ALL_PCI_INIT_SECTIONS \
945 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
946 ".pci_fixup_enable", ".pci_fixup_resume", \
947 ".pci_fixup_resume_early", ".pci_fixup_suspend"
949 #define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
950 #define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
952 #define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
953 #define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
955 #define DATA_SECTIONS ".data", ".data.rel"
956 #define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
957 ".kprobes.text", ".cpuidle.text"
958 #define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
959 ".fixup", ".entry.text", ".exception.text", ".text.*", \
962 #define INIT_SECTIONS ".init.*"
963 #define MEM_INIT_SECTIONS ".meminit.*"
965 #define EXIT_SECTIONS ".exit.*"
966 #define MEM_EXIT_SECTIONS ".memexit.*"
968 #define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
969 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
971 /* init data sections */
972 static const char *const init_data_sections
[] =
973 { ALL_INIT_DATA_SECTIONS
, NULL
};
975 /* all init sections */
976 static const char *const init_sections
[] = { ALL_INIT_SECTIONS
, NULL
};
978 /* All init and exit sections (code + data) */
979 static const char *const init_exit_sections
[] =
980 {ALL_INIT_SECTIONS
, ALL_EXIT_SECTIONS
, NULL
};
982 /* all text sections */
983 static const char *const text_sections
[] = { ALL_TEXT_SECTIONS
, NULL
};
986 static const char *const data_sections
[] = { DATA_SECTIONS
, NULL
};
989 /* symbols in .data that may refer to init/exit sections */
990 #define DEFAULT_SYMBOL_WHITE_LIST \
992 "*_template", /* scsi uses *_template a lot */ \
993 "*_timer", /* arm uses ops structures named _timer a lot */ \
994 "*_sht", /* scsi also used *_sht to some extent */ \
1000 static const char *const head_sections
[] = { ".head.text*", NULL
};
1001 static const char *const linker_symbols
[] =
1002 { "__init_begin", "_sinittext", "_einittext", NULL
};
1003 static const char *const optim_symbols
[] = { "*.constprop.*", NULL
};
1010 XXXINIT_TO_SOME_INIT
,
1011 XXXEXIT_TO_SOME_EXIT
,
1012 ANY_INIT_TO_ANY_EXIT
,
1013 ANY_EXIT_TO_ANY_INIT
,
1014 EXPORT_TO_INIT_EXIT
,
1015 EXTABLE_TO_NON_TEXT
,
1019 * Describe how to match sections on different criterias:
1021 * @fromsec: Array of sections to be matched.
1023 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
1024 * this array is forbidden (black-list). Can be empty.
1026 * @good_tosec: Relocations applied to a section in @fromsec must be
1027 * targetting sections in this array (white-list). Can be empty.
1029 * @mismatch: Type of mismatch.
1031 * @symbol_white_list: Do not match a relocation to a symbol in this list
1032 * even if it is targetting a section in @bad_to_sec.
1034 * @handler: Specific handler to call when a match is found. If NULL,
1035 * default_mismatch_handler() will be called.
1038 struct sectioncheck
{
1039 const char *fromsec
[20];
1040 const char *bad_tosec
[20];
1041 const char *good_tosec
[20];
1042 enum mismatch mismatch
;
1043 const char *symbol_white_list
[20];
1044 void (*handler
)(const char *modname
, struct elf_info
*elf
,
1045 const struct sectioncheck
* const mismatch
,
1046 Elf_Rela
*r
, Elf_Sym
*sym
, const char *fromsec
);
1050 static void extable_mismatch_handler(const char *modname
, struct elf_info
*elf
,
1051 const struct sectioncheck
* const mismatch
,
1052 Elf_Rela
*r
, Elf_Sym
*sym
,
1053 const char *fromsec
);
1055 static const struct sectioncheck sectioncheck
[] = {
1056 /* Do not reference init/exit code/data from
1057 * normal code and data
1060 .fromsec
= { TEXT_SECTIONS
, NULL
},
1061 .bad_tosec
= { ALL_INIT_SECTIONS
, NULL
},
1062 .mismatch
= TEXT_TO_ANY_INIT
,
1063 .symbol_white_list
= { DEFAULT_SYMBOL_WHITE_LIST
, NULL
},
1066 .fromsec
= { DATA_SECTIONS
, NULL
},
1067 .bad_tosec
= { ALL_XXXINIT_SECTIONS
, NULL
},
1068 .mismatch
= DATA_TO_ANY_INIT
,
1069 .symbol_white_list
= { DEFAULT_SYMBOL_WHITE_LIST
, NULL
},
1072 .fromsec
= { DATA_SECTIONS
, NULL
},
1073 .bad_tosec
= { INIT_SECTIONS
, NULL
},
1074 .mismatch
= DATA_TO_ANY_INIT
,
1075 .symbol_white_list
= {
1076 "*_template", "*_timer", "*_sht", "*_ops",
1077 "*_probe", "*_probe_one", "*_console", NULL
1081 .fromsec
= { TEXT_SECTIONS
, NULL
},
1082 .bad_tosec
= { ALL_EXIT_SECTIONS
, NULL
},
1083 .mismatch
= TEXT_TO_ANY_EXIT
,
1084 .symbol_white_list
= { DEFAULT_SYMBOL_WHITE_LIST
, NULL
},
1087 .fromsec
= { DATA_SECTIONS
, NULL
},
1088 .bad_tosec
= { ALL_EXIT_SECTIONS
, NULL
},
1089 .mismatch
= DATA_TO_ANY_EXIT
,
1090 .symbol_white_list
= { DEFAULT_SYMBOL_WHITE_LIST
, NULL
},
1092 /* Do not reference init code/data from meminit code/data */
1094 .fromsec
= { ALL_XXXINIT_SECTIONS
, NULL
},
1095 .bad_tosec
= { INIT_SECTIONS
, NULL
},
1096 .mismatch
= XXXINIT_TO_SOME_INIT
,
1097 .symbol_white_list
= { DEFAULT_SYMBOL_WHITE_LIST
, NULL
},
1099 /* Do not reference exit code/data from memexit code/data */
1101 .fromsec
= { ALL_XXXEXIT_SECTIONS
, NULL
},
1102 .bad_tosec
= { EXIT_SECTIONS
, NULL
},
1103 .mismatch
= XXXEXIT_TO_SOME_EXIT
,
1104 .symbol_white_list
= { DEFAULT_SYMBOL_WHITE_LIST
, NULL
},
1106 /* Do not use exit code/data from init code */
1108 .fromsec
= { ALL_INIT_SECTIONS
, NULL
},
1109 .bad_tosec
= { ALL_EXIT_SECTIONS
, NULL
},
1110 .mismatch
= ANY_INIT_TO_ANY_EXIT
,
1111 .symbol_white_list
= { DEFAULT_SYMBOL_WHITE_LIST
, NULL
},
1113 /* Do not use init code/data from exit code */
1115 .fromsec
= { ALL_EXIT_SECTIONS
, NULL
},
1116 .bad_tosec
= { ALL_INIT_SECTIONS
, NULL
},
1117 .mismatch
= ANY_EXIT_TO_ANY_INIT
,
1118 .symbol_white_list
= { DEFAULT_SYMBOL_WHITE_LIST
, NULL
},
1121 .fromsec
= { ALL_PCI_INIT_SECTIONS
, NULL
},
1122 .bad_tosec
= { INIT_SECTIONS
, NULL
},
1123 .mismatch
= ANY_INIT_TO_ANY_EXIT
,
1124 .symbol_white_list
= { NULL
},
1126 /* Do not export init/exit functions or data */
1128 .fromsec
= { "__ksymtab*", NULL
},
1129 .bad_tosec
= { INIT_SECTIONS
, EXIT_SECTIONS
, NULL
},
1130 .mismatch
= EXPORT_TO_INIT_EXIT
,
1131 .symbol_white_list
= { DEFAULT_SYMBOL_WHITE_LIST
, NULL
},
1134 .fromsec
= { "__ex_table", NULL
},
1135 /* If you're adding any new black-listed sections in here, consider
1136 * adding a special 'printer' for them in scripts/check_extable.
1138 .bad_tosec
= { ".altinstr_replacement", NULL
},
1139 .good_tosec
= {ALL_TEXT_SECTIONS
, NULL
},
1140 .mismatch
= EXTABLE_TO_NON_TEXT
,
1141 .handler
= extable_mismatch_handler
,
1145 static const struct sectioncheck
*section_mismatch(
1146 const char *fromsec
, const char *tosec
)
1149 int elems
= sizeof(sectioncheck
) / sizeof(struct sectioncheck
);
1150 const struct sectioncheck
*check
= §ioncheck
[0];
1153 * The target section could be the SHT_NUL section when we're
1154 * handling relocations to un-resolved symbols, trying to match it
1155 * doesn't make much sense and causes build failures on parisc
1161 for (i
= 0; i
< elems
; i
++) {
1162 if (match(fromsec
, check
->fromsec
)) {
1163 if (check
->bad_tosec
[0] && match(tosec
, check
->bad_tosec
))
1165 if (check
->good_tosec
[0] && !match(tosec
, check
->good_tosec
))
1174 * Whitelist to allow certain references to pass with no warning.
1177 * If a module parameter is declared __initdata and permissions=0
1178 * then this is legal despite the warning generated.
1179 * We cannot see value of permissions here, so just ignore
1181 * The pattern is identified by:
1182 * tosec = .init.data
1187 * module_param_call() ops can refer to __init set function if permissions=0
1188 * The pattern is identified by:
1189 * tosec = .init.text
1191 * atsym = __param_ops_*
1194 * Many drivers utilise a *driver container with references to
1195 * add, remove, probe functions etc.
1196 * the pattern is identified by:
1197 * tosec = init or exit section
1198 * fromsec = data section
1199 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1200 * *probe_one, *_console, *_timer
1203 * Whitelist all references from .head.text to any init section
1206 * Some symbols belong to init section but still it is ok to reference
1207 * these from non-init sections as these symbols don't have any memory
1208 * allocated for them and symbol address and value are same. So even
1209 * if init section is freed, its ok to reference those symbols.
1210 * For ex. symbols marking the init section boundaries.
1211 * This pattern is identified by
1212 * refsymname = __init_begin, _sinittext, _einittext
1215 * GCC may optimize static inlines when fed constant arg(s) resulting
1216 * in functions like cpumask_empty() -- generating an associated symbol
1217 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1218 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1219 * meaningless section warning. May need to add isra symbols too...
1220 * This pattern is identified by
1221 * tosec = init section
1222 * fromsec = text section
1223 * refsymname = *.constprop.*
1226 * Hide section mismatch warnings for ELF local symbols. The goal
1227 * is to eliminate false positive modpost warnings caused by
1228 * compiler-generated ELF local symbol names such as ".LANCHOR1".
1229 * Autogenerated symbol names bypass modpost's "Pattern 2"
1230 * whitelisting, which relies on pattern-matching against symbol
1231 * names to work. (One situation where gcc can autogenerate ELF
1232 * local symbols is when "-fsection-anchors" is used.)
1234 static int secref_whitelist(const struct sectioncheck
*mismatch
,
1235 const char *fromsec
, const char *fromsym
,
1236 const char *tosec
, const char *tosym
)
1238 /* Check for pattern 1 */
1239 if (match(tosec
, init_data_sections
) &&
1240 match(fromsec
, data_sections
) &&
1241 strstarts(fromsym
, "__param"))
1244 /* Check for pattern 1a */
1245 if (strcmp(tosec
, ".init.text") == 0 &&
1246 match(fromsec
, data_sections
) &&
1247 strstarts(fromsym
, "__param_ops_"))
1250 /* Check for pattern 2 */
1251 if (match(tosec
, init_exit_sections
) &&
1252 match(fromsec
, data_sections
) &&
1253 match(fromsym
, mismatch
->symbol_white_list
))
1256 /* Check for pattern 3 */
1257 if (match(fromsec
, head_sections
) &&
1258 match(tosec
, init_sections
))
1261 /* Check for pattern 4 */
1262 if (match(tosym
, linker_symbols
))
1265 /* Check for pattern 5 */
1266 if (match(fromsec
, text_sections
) &&
1267 match(tosec
, init_sections
) &&
1268 match(fromsym
, optim_symbols
))
1271 /* Check for pattern 6 */
1272 if (strstarts(fromsym
, ".L"))
1278 static inline int is_arm_mapping_symbol(const char *str
)
1280 return str
[0] == '$' && strchr("axtd", str
[1])
1281 && (str
[2] == '\0' || str
[2] == '.');
1285 * If there's no name there, ignore it; likewise, ignore it if it's
1286 * one of the magic symbols emitted used by current ARM tools.
1288 * Otherwise if find_symbols_between() returns those symbols, they'll
1289 * fail the whitelist tests and cause lots of false alarms ... fixable
1290 * only by merging __exit and __init sections into __text, bloating
1291 * the kernel (which is especially evil on embedded platforms).
1293 static inline int is_valid_name(struct elf_info
*elf
, Elf_Sym
*sym
)
1295 const char *name
= elf
->strtab
+ sym
->st_name
;
1297 if (!name
|| !strlen(name
))
1299 return !is_arm_mapping_symbol(name
);
1303 * Find symbol based on relocation record info.
1304 * In some cases the symbol supplied is a valid symbol so
1305 * return refsym. If st_name != 0 we assume this is a valid symbol.
1306 * In other cases the symbol needs to be looked up in the symbol table
1307 * based on section and address.
1309 static Elf_Sym
*find_elf_symbol(struct elf_info
*elf
, Elf64_Sword addr
,
1313 Elf_Sym
*near
= NULL
;
1314 Elf64_Sword distance
= 20;
1316 unsigned int relsym_secindex
;
1318 if (relsym
->st_name
!= 0)
1321 relsym_secindex
= get_secindex(elf
, relsym
);
1322 for (sym
= elf
->symtab_start
; sym
< elf
->symtab_stop
; sym
++) {
1323 if (get_secindex(elf
, sym
) != relsym_secindex
)
1325 if (ELF_ST_TYPE(sym
->st_info
) == STT_SECTION
)
1327 if (!is_valid_name(elf
, sym
))
1329 if (sym
->st_value
== addr
)
1331 /* Find a symbol nearby - addr are maybe negative */
1332 d
= sym
->st_value
- addr
;
1334 d
= addr
- sym
->st_value
;
1340 /* We need a close match */
1348 * Find symbols before or equal addr and after addr - in the section sec.
1349 * If we find two symbols with equal offset prefer one with a valid name.
1350 * The ELF format may have a better way to detect what type of symbol
1351 * it is, but this works for now.
1353 static Elf_Sym
*find_elf_symbol2(struct elf_info
*elf
, Elf_Addr addr
,
1357 Elf_Sym
*near
= NULL
;
1358 Elf_Addr distance
= ~0;
1360 for (sym
= elf
->symtab_start
; sym
< elf
->symtab_stop
; sym
++) {
1363 if (is_shndx_special(sym
->st_shndx
))
1365 symsec
= sec_name(elf
, get_secindex(elf
, sym
));
1366 if (strcmp(symsec
, sec
) != 0)
1368 if (!is_valid_name(elf
, sym
))
1370 if (sym
->st_value
<= addr
) {
1371 if ((addr
- sym
->st_value
) < distance
) {
1372 distance
= addr
- sym
->st_value
;
1374 } else if ((addr
- sym
->st_value
) == distance
) {
1383 * Convert a section name to the function/data attribute
1384 * .init.text => __init
1385 * .memexitconst => __memconst
1388 * The memory of returned value has been allocated on a heap. The user of this
1389 * method should free it after usage.
1391 static char *sec2annotation(const char *s
)
1393 if (match(s
, init_exit_sections
)) {
1394 char *p
= NOFAIL(malloc(20));
1401 while (*s
&& *s
!= '.')
1406 if (strstr(s
, "rodata") != NULL
)
1407 strcat(p
, "const ");
1408 else if (strstr(s
, "data") != NULL
)
1414 return NOFAIL(strdup(""));
1418 static int is_function(Elf_Sym
*sym
)
1421 return ELF_ST_TYPE(sym
->st_info
) == STT_FUNC
;
1426 static void print_section_list(const char * const list
[20])
1428 const char *const *s
= list
;
1431 fprintf(stderr
, "%s", *s
);
1434 fprintf(stderr
, ", ");
1436 fprintf(stderr
, "\n");
1439 static inline void get_pretty_name(int is_func
, const char** name
, const char** name_p
)
1442 case 0: *name
= "variable"; *name_p
= ""; break;
1443 case 1: *name
= "function"; *name_p
= "()"; break;
1444 default: *name
= "(unknown reference)"; *name_p
= ""; break;
1449 * Print a warning about a section mismatch.
1450 * Try to find symbols near it so user can find it.
1451 * Check whitelist before warning - it may be a false positive.
1453 static void report_sec_mismatch(const char *modname
,
1454 const struct sectioncheck
*mismatch
,
1455 const char *fromsec
,
1456 unsigned long long fromaddr
,
1457 const char *fromsym
,
1459 const char *tosec
, const char *tosym
,
1462 const char *from
, *from_p
;
1463 const char *to
, *to_p
;
1467 sec_mismatch_count
++;
1469 get_pretty_name(from_is_func
, &from
, &from_p
);
1470 get_pretty_name(to_is_func
, &to
, &to_p
);
1472 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1473 "to the %s %s:%s%s\n",
1474 modname
, fromsec
, fromaddr
, from
, fromsym
, from_p
, to
, tosec
,
1477 switch (mismatch
->mismatch
) {
1478 case TEXT_TO_ANY_INIT
:
1479 prl_from
= sec2annotation(fromsec
);
1480 prl_to
= sec2annotation(tosec
);
1482 "The function %s%s() references\n"
1484 "This is often because %s lacks a %s\n"
1485 "annotation or the annotation of %s is wrong.\n",
1487 to
, prl_to
, tosym
, to_p
,
1488 fromsym
, prl_to
, tosym
);
1492 case DATA_TO_ANY_INIT
: {
1493 prl_to
= sec2annotation(tosec
);
1495 "The variable %s references\n"
1497 "If the reference is valid then annotate the\n"
1498 "variable with __init* or __refdata (see linux/init.h) "
1499 "or name the variable:\n",
1500 fromsym
, to
, prl_to
, tosym
, to_p
);
1501 print_section_list(mismatch
->symbol_white_list
);
1505 case TEXT_TO_ANY_EXIT
:
1506 prl_to
= sec2annotation(tosec
);
1508 "The function %s() references a %s in an exit section.\n"
1509 "Often the %s %s%s has valid usage outside the exit section\n"
1510 "and the fix is to remove the %sannotation of %s.\n",
1511 fromsym
, to
, to
, tosym
, to_p
, prl_to
, tosym
);
1514 case DATA_TO_ANY_EXIT
: {
1515 prl_to
= sec2annotation(tosec
);
1517 "The variable %s references\n"
1519 "If the reference is valid then annotate the\n"
1520 "variable with __exit* (see linux/init.h) or "
1521 "name the variable:\n",
1522 fromsym
, to
, prl_to
, tosym
, to_p
);
1523 print_section_list(mismatch
->symbol_white_list
);
1527 case XXXINIT_TO_SOME_INIT
:
1528 case XXXEXIT_TO_SOME_EXIT
:
1529 prl_from
= sec2annotation(fromsec
);
1530 prl_to
= sec2annotation(tosec
);
1532 "The %s %s%s%s references\n"
1534 "If %s is only used by %s then\n"
1535 "annotate %s with a matching annotation.\n",
1536 from
, prl_from
, fromsym
, from_p
,
1537 to
, prl_to
, tosym
, to_p
,
1538 tosym
, fromsym
, tosym
);
1542 case ANY_INIT_TO_ANY_EXIT
:
1543 prl_from
= sec2annotation(fromsec
);
1544 prl_to
= sec2annotation(tosec
);
1546 "The %s %s%s%s references\n"
1548 "This is often seen when error handling "
1549 "in the init function\n"
1550 "uses functionality in the exit path.\n"
1551 "The fix is often to remove the %sannotation of\n"
1552 "%s%s so it may be used outside an exit section.\n",
1553 from
, prl_from
, fromsym
, from_p
,
1554 to
, prl_to
, tosym
, to_p
,
1555 prl_to
, tosym
, to_p
);
1559 case ANY_EXIT_TO_ANY_INIT
:
1560 prl_from
= sec2annotation(fromsec
);
1561 prl_to
= sec2annotation(tosec
);
1563 "The %s %s%s%s references\n"
1565 "This is often seen when error handling "
1566 "in the exit function\n"
1567 "uses functionality in the init path.\n"
1568 "The fix is often to remove the %sannotation of\n"
1569 "%s%s so it may be used outside an init section.\n",
1570 from
, prl_from
, fromsym
, from_p
,
1571 to
, prl_to
, tosym
, to_p
,
1572 prl_to
, tosym
, to_p
);
1576 case EXPORT_TO_INIT_EXIT
:
1577 prl_to
= sec2annotation(tosec
);
1579 "The symbol %s is exported and annotated %s\n"
1580 "Fix this by removing the %sannotation of %s "
1581 "or drop the export.\n",
1582 tosym
, prl_to
, prl_to
, tosym
);
1585 case EXTABLE_TO_NON_TEXT
:
1586 fatal("There's a special handler for this mismatch type, "
1587 "we should never get here.");
1590 fprintf(stderr
, "\n");
1593 static void default_mismatch_handler(const char *modname
, struct elf_info
*elf
,
1594 const struct sectioncheck
* const mismatch
,
1595 Elf_Rela
*r
, Elf_Sym
*sym
, const char *fromsec
)
1601 const char *fromsym
;
1603 from
= find_elf_symbol2(elf
, r
->r_offset
, fromsec
);
1604 fromsym
= sym_name(elf
, from
);
1606 if (strstarts(fromsym
, "reference___initcall"))
1609 tosec
= sec_name(elf
, get_secindex(elf
, sym
));
1610 to
= find_elf_symbol(elf
, r
->r_addend
, sym
);
1611 tosym
= sym_name(elf
, to
);
1613 /* check whitelist - we may ignore it */
1614 if (secref_whitelist(mismatch
,
1615 fromsec
, fromsym
, tosec
, tosym
)) {
1616 report_sec_mismatch(modname
, mismatch
,
1617 fromsec
, r
->r_offset
, fromsym
,
1618 is_function(from
), tosec
, tosym
,
1623 static int is_executable_section(struct elf_info
* elf
, unsigned int section_index
)
1625 if (section_index
> elf
->num_sections
)
1626 fatal("section_index is outside elf->num_sections!\n");
1628 return ((elf
->sechdrs
[section_index
].sh_flags
& SHF_EXECINSTR
) == SHF_EXECINSTR
);
1632 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1633 * to know the sizeof(struct exception_table_entry) for the target architecture.
1635 static unsigned int extable_entry_size
= 0;
1636 static void find_extable_entry_size(const char* const sec
, const Elf_Rela
* r
)
1639 * If we're currently checking the second relocation within __ex_table,
1640 * that relocation offset tells us the offsetof(struct
1641 * exception_table_entry, fixup) which is equal to sizeof(struct
1642 * exception_table_entry) divided by two. We use that to our advantage
1643 * since there's no portable way to get that size as every architecture
1644 * seems to go with different sized types. Not pretty but better than
1645 * hard-coding the size for every architecture..
1647 if (!extable_entry_size
)
1648 extable_entry_size
= r
->r_offset
* 2;
1651 static inline bool is_extable_fault_address(Elf_Rela
*r
)
1654 * extable_entry_size is only discovered after we've handled the
1655 * _second_ relocation in __ex_table, so only abort when we're not
1656 * handling the first reloc and extable_entry_size is zero.
1658 if (r
->r_offset
&& extable_entry_size
== 0)
1659 fatal("extable_entry size hasn't been discovered!\n");
1661 return ((r
->r_offset
== 0) ||
1662 (r
->r_offset
% extable_entry_size
== 0));
1665 #define is_second_extable_reloc(Start, Cur, Sec) \
1666 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1668 static void report_extable_warnings(const char* modname
, struct elf_info
* elf
,
1669 const struct sectioncheck
* const mismatch
,
1670 Elf_Rela
* r
, Elf_Sym
* sym
,
1671 const char* fromsec
, const char* tosec
)
1673 Elf_Sym
* fromsym
= find_elf_symbol2(elf
, r
->r_offset
, fromsec
);
1674 const char* fromsym_name
= sym_name(elf
, fromsym
);
1675 Elf_Sym
* tosym
= find_elf_symbol(elf
, r
->r_addend
, sym
);
1676 const char* tosym_name
= sym_name(elf
, tosym
);
1677 const char* from_pretty_name
;
1678 const char* from_pretty_name_p
;
1679 const char* to_pretty_name
;
1680 const char* to_pretty_name_p
;
1682 get_pretty_name(is_function(fromsym
),
1683 &from_pretty_name
, &from_pretty_name_p
);
1684 get_pretty_name(is_function(tosym
),
1685 &to_pretty_name
, &to_pretty_name_p
);
1687 warn("%s(%s+0x%lx): Section mismatch in reference"
1688 " from the %s %s%s to the %s %s:%s%s\n",
1689 modname
, fromsec
, (long)r
->r_offset
, from_pretty_name
,
1690 fromsym_name
, from_pretty_name_p
,
1691 to_pretty_name
, tosec
, tosym_name
, to_pretty_name_p
);
1693 if (!match(tosec
, mismatch
->bad_tosec
) &&
1694 is_executable_section(elf
, get_secindex(elf
, sym
)))
1696 "The relocation at %s+0x%lx references\n"
1697 "section \"%s\" which is not in the list of\n"
1698 "authorized sections. If you're adding a new section\n"
1699 "and/or if this reference is valid, add \"%s\" to the\n"
1700 "list of authorized sections to jump to on fault.\n"
1701 "This can be achieved by adding \"%s\" to \n"
1702 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1703 fromsec
, (long)r
->r_offset
, tosec
, tosec
, tosec
);
1706 static void extable_mismatch_handler(const char* modname
, struct elf_info
*elf
,
1707 const struct sectioncheck
* const mismatch
,
1708 Elf_Rela
* r
, Elf_Sym
* sym
,
1709 const char *fromsec
)
1711 const char* tosec
= sec_name(elf
, get_secindex(elf
, sym
));
1713 sec_mismatch_count
++;
1715 report_extable_warnings(modname
, elf
, mismatch
, r
, sym
, fromsec
, tosec
);
1717 if (match(tosec
, mismatch
->bad_tosec
))
1718 fatal("The relocation at %s+0x%lx references\n"
1719 "section \"%s\" which is black-listed.\n"
1720 "Something is seriously wrong and should be fixed.\n"
1721 "You might get more information about where this is\n"
1722 "coming from by using scripts/check_extable.sh %s\n",
1723 fromsec
, (long)r
->r_offset
, tosec
, modname
);
1724 else if (!is_executable_section(elf
, get_secindex(elf
, sym
))) {
1725 if (is_extable_fault_address(r
))
1726 fatal("The relocation at %s+0x%lx references\n"
1727 "section \"%s\" which is not executable, IOW\n"
1728 "it is not possible for the kernel to fault\n"
1729 "at that address. Something is seriously wrong\n"
1730 "and should be fixed.\n",
1731 fromsec
, (long)r
->r_offset
, tosec
);
1733 fatal("The relocation at %s+0x%lx references\n"
1734 "section \"%s\" which is not executable, IOW\n"
1735 "the kernel will fault if it ever tries to\n"
1736 "jump to it. Something is seriously wrong\n"
1737 "and should be fixed.\n",
1738 fromsec
, (long)r
->r_offset
, tosec
);
1742 static void check_section_mismatch(const char *modname
, struct elf_info
*elf
,
1743 Elf_Rela
*r
, Elf_Sym
*sym
, const char *fromsec
)
1745 const char *tosec
= sec_name(elf
, get_secindex(elf
, sym
));
1746 const struct sectioncheck
*mismatch
= section_mismatch(fromsec
, tosec
);
1749 if (mismatch
->handler
)
1750 mismatch
->handler(modname
, elf
, mismatch
,
1753 default_mismatch_handler(modname
, elf
, mismatch
,
1758 static unsigned int *reloc_location(struct elf_info
*elf
,
1759 Elf_Shdr
*sechdr
, Elf_Rela
*r
)
1761 Elf_Shdr
*sechdrs
= elf
->sechdrs
;
1762 int section
= sechdr
->sh_info
;
1764 return (void *)elf
->hdr
+ sechdrs
[section
].sh_offset
+
1768 static int addend_386_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
);
1775 r
->r_addend
= TO_NATIVE(*location
);
1778 r
->r_addend
= TO_NATIVE(*location
) + 4;
1779 /* For CONFIG_RELOCATABLE=y */
1780 if (elf
->hdr
->e_type
== ET_EXEC
)
1781 r
->r_addend
+= r
->r_offset
;
1788 #define R_ARM_CALL 28
1790 #ifndef R_ARM_JUMP24
1791 #define R_ARM_JUMP24 29
1794 #ifndef R_ARM_THM_CALL
1795 #define R_ARM_THM_CALL 10
1797 #ifndef R_ARM_THM_JUMP24
1798 #define R_ARM_THM_JUMP24 30
1800 #ifndef R_ARM_THM_JUMP19
1801 #define R_ARM_THM_JUMP19 51
1804 static int addend_arm_rel(struct elf_info
*elf
, Elf_Shdr
*sechdr
, Elf_Rela
*r
)
1806 unsigned int r_typ
= ELF_R_TYPE(r
->r_info
);
1810 /* From ARM ABI: (S + A) | T */
1811 r
->r_addend
= (int)(long)
1812 (elf
->symtab_start
+ ELF_R_SYM(r
->r_info
));
1817 case R_ARM_THM_CALL
:
1818 case R_ARM_THM_JUMP24
:
1819 case R_ARM_THM_JUMP19
:
1820 /* From ARM ABI: ((S + A) | T) - P */
1821 r
->r_addend
= (int)(long)(elf
->hdr
+
1823 (r
->r_offset
- sechdr
->sh_addr
));
1831 static int addend_mips_rel(struct elf_info
*elf
, Elf_Shdr
*sechdr
, Elf_Rela
*r
)
1833 unsigned int r_typ
= ELF_R_TYPE(r
->r_info
);
1834 unsigned int *location
= reloc_location(elf
, sechdr
, r
);
1837 if (r_typ
== R_MIPS_HI16
)
1838 return 1; /* skip this */
1839 inst
= TO_NATIVE(*location
);
1842 r
->r_addend
= inst
& 0xffff;
1845 r
->r_addend
= (inst
& 0x03ffffff) << 2;
1854 static void section_rela(const char *modname
, struct elf_info
*elf
,
1861 const char *fromsec
;
1863 Elf_Rela
*start
= (void *)elf
->hdr
+ sechdr
->sh_offset
;
1864 Elf_Rela
*stop
= (void *)start
+ sechdr
->sh_size
;
1866 fromsec
= sech_name(elf
, sechdr
);
1867 fromsec
+= strlen(".rela");
1868 /* if from section (name) is know good then skip it */
1869 if (match(fromsec
, section_white_list
))
1872 for (rela
= start
; rela
< stop
; rela
++) {
1873 r
.r_offset
= TO_NATIVE(rela
->r_offset
);
1874 #if KERNEL_ELFCLASS == ELFCLASS64
1875 if (elf
->hdr
->e_machine
== EM_MIPS
) {
1877 r_sym
= ELF64_MIPS_R_SYM(rela
->r_info
);
1878 r_sym
= TO_NATIVE(r_sym
);
1879 r_typ
= ELF64_MIPS_R_TYPE(rela
->r_info
);
1880 r
.r_info
= ELF64_R_INFO(r_sym
, r_typ
);
1882 r
.r_info
= TO_NATIVE(rela
->r_info
);
1883 r_sym
= ELF_R_SYM(r
.r_info
);
1886 r
.r_info
= TO_NATIVE(rela
->r_info
);
1887 r_sym
= ELF_R_SYM(r
.r_info
);
1889 r
.r_addend
= TO_NATIVE(rela
->r_addend
);
1890 sym
= elf
->symtab_start
+ r_sym
;
1891 /* Skip special sections */
1892 if (is_shndx_special(sym
->st_shndx
))
1894 if (is_second_extable_reloc(start
, rela
, fromsec
))
1895 find_extable_entry_size(fromsec
, &r
);
1896 check_section_mismatch(modname
, elf
, &r
, sym
, fromsec
);
1900 static void section_rel(const char *modname
, struct elf_info
*elf
,
1907 const char *fromsec
;
1909 Elf_Rel
*start
= (void *)elf
->hdr
+ sechdr
->sh_offset
;
1910 Elf_Rel
*stop
= (void *)start
+ sechdr
->sh_size
;
1912 fromsec
= sech_name(elf
, sechdr
);
1913 fromsec
+= strlen(".rel");
1914 /* if from section (name) is know good then skip it */
1915 if (match(fromsec
, section_white_list
))
1918 for (rel
= start
; rel
< stop
; rel
++) {
1919 r
.r_offset
= TO_NATIVE(rel
->r_offset
);
1920 #if KERNEL_ELFCLASS == ELFCLASS64
1921 if (elf
->hdr
->e_machine
== EM_MIPS
) {
1923 r_sym
= ELF64_MIPS_R_SYM(rel
->r_info
);
1924 r_sym
= TO_NATIVE(r_sym
);
1925 r_typ
= ELF64_MIPS_R_TYPE(rel
->r_info
);
1926 r
.r_info
= ELF64_R_INFO(r_sym
, r_typ
);
1928 r
.r_info
= TO_NATIVE(rel
->r_info
);
1929 r_sym
= ELF_R_SYM(r
.r_info
);
1932 r
.r_info
= TO_NATIVE(rel
->r_info
);
1933 r_sym
= ELF_R_SYM(r
.r_info
);
1936 switch (elf
->hdr
->e_machine
) {
1938 if (addend_386_rel(elf
, sechdr
, &r
))
1942 if (addend_arm_rel(elf
, sechdr
, &r
))
1946 if (addend_mips_rel(elf
, sechdr
, &r
))
1950 sym
= elf
->symtab_start
+ r_sym
;
1951 /* Skip special sections */
1952 if (is_shndx_special(sym
->st_shndx
))
1954 if (is_second_extable_reloc(start
, rel
, fromsec
))
1955 find_extable_entry_size(fromsec
, &r
);
1956 check_section_mismatch(modname
, elf
, &r
, sym
, fromsec
);
1961 * A module includes a number of sections that are discarded
1962 * either when loaded or when used as built-in.
1963 * For loaded modules all functions marked __init and all data
1964 * marked __initdata will be discarded when the module has been initialized.
1965 * Likewise for modules used built-in the sections marked __exit
1966 * are discarded because __exit marked function are supposed to be called
1967 * only when a module is unloaded which never happens for built-in modules.
1968 * The check_sec_ref() function traverses all relocation records
1969 * to find all references to a section that reference a section that will
1970 * be discarded and warns about it.
1972 static void check_sec_ref(struct module
*mod
, const char *modname
,
1973 struct elf_info
*elf
)
1976 Elf_Shdr
*sechdrs
= elf
->sechdrs
;
1978 /* Walk through all sections */
1979 for (i
= 0; i
< elf
->num_sections
; i
++) {
1980 check_section(modname
, elf
, &elf
->sechdrs
[i
]);
1981 /* We want to process only relocation sections and not .init */
1982 if (sechdrs
[i
].sh_type
== SHT_RELA
)
1983 section_rela(modname
, elf
, &elf
->sechdrs
[i
]);
1984 else if (sechdrs
[i
].sh_type
== SHT_REL
)
1985 section_rel(modname
, elf
, &elf
->sechdrs
[i
]);
1989 static char *remove_dot(char *s
)
1991 size_t n
= strcspn(s
, ".");
1994 size_t m
= strspn(s
+ n
+ 1, "0123456789");
1995 if (m
&& (s
[n
+ m
] == '.' || s
[n
+ m
] == 0))
2001 static void read_symbols(const char *modname
)
2003 const char *symname
;
2008 struct elf_info info
= { };
2011 if (!parse_elf(&info
, modname
))
2014 mod
= new_module(modname
);
2016 /* When there's no vmlinux, don't print warnings about
2017 * unresolved symbols (since there'll be too many ;) */
2018 if (is_vmlinux(modname
)) {
2023 license
= get_modinfo(&info
, "license");
2024 if (!license
&& !is_vmlinux(modname
))
2025 warn("modpost: missing MODULE_LICENSE() in %s\n"
2026 "see include/linux/module.h for "
2027 "more information\n", modname
);
2029 if (license_is_gpl_compatible(license
))
2030 mod
->gpl_compatible
= 1;
2032 mod
->gpl_compatible
= 0;
2035 license
= get_next_modinfo(&info
, "license", license
);
2038 namespace = get_modinfo(&info
, "import_ns");
2040 add_namespace(&mod
->imported_namespaces
, namespace);
2041 namespace = get_next_modinfo(&info
, "import_ns", namespace);
2044 for (sym
= info
.symtab_start
; sym
< info
.symtab_stop
; sym
++) {
2045 symname
= remove_dot(info
.strtab
+ sym
->st_name
);
2047 handle_symbol(mod
, &info
, sym
, symname
);
2048 handle_moddevtable(mod
, &info
, sym
, symname
);
2051 for (sym
= info
.symtab_start
; sym
< info
.symtab_stop
; sym
++) {
2052 symname
= remove_dot(info
.strtab
+ sym
->st_name
);
2054 /* Apply symbol namespaces from __kstrtabns_<symbol> entries. */
2055 if (strstarts(symname
, "__kstrtabns_"))
2056 sym_update_namespace(symname
+ strlen("__kstrtabns_"),
2057 namespace_from_kstrtabns(&info
,
2060 if (strstarts(symname
, "__crc_"))
2061 handle_modversion(mod
, &info
, sym
,
2062 symname
+ strlen("__crc_"));
2065 // check for static EXPORT_SYMBOL_* functions && global vars
2066 for (sym
= info
.symtab_start
; sym
< info
.symtab_stop
; sym
++) {
2067 unsigned char bind
= ELF_ST_BIND(sym
->st_info
);
2069 if (bind
== STB_GLOBAL
|| bind
== STB_WEAK
) {
2071 find_symbol(remove_dot(info
.strtab
+
2079 if (!is_vmlinux(modname
) || vmlinux_section_warnings
)
2080 check_sec_ref(mod
, modname
, &info
);
2082 version
= get_modinfo(&info
, "version");
2084 maybe_frob_rcs_version(modname
, version
, info
.modinfo
,
2085 version
- (char *)info
.hdr
);
2086 if (version
|| (all_versions
&& !is_vmlinux(modname
)))
2087 get_src_version(modname
, mod
->srcversion
,
2088 sizeof(mod
->srcversion
)-1);
2090 parse_elf_finish(&info
);
2092 /* Our trick to get versioning for module struct etc. - it's
2093 * never passed as an argument to an exported function, so
2094 * the automatic versioning doesn't pick it up, but it's really
2095 * important anyhow */
2097 mod
->unres
= alloc_symbol("module_layout", 0, mod
->unres
);
2100 static void read_symbols_from_files(const char *filename
)
2103 char fname
[PATH_MAX
];
2105 if (strcmp(filename
, "-") != 0) {
2106 in
= fopen(filename
, "r");
2108 fatal("Can't open filenames file %s: %m", filename
);
2111 while (fgets(fname
, PATH_MAX
, in
) != NULL
) {
2112 if (strends(fname
, "\n"))
2113 fname
[strlen(fname
)-1] = '\0';
2114 read_symbols(fname
);
2123 /* We first write the generated file into memory using the
2124 * following helper, then compare to the file on disk and
2125 * only update the later if anything changed */
2127 void __attribute__((format(printf
, 2, 3))) buf_printf(struct buffer
*buf
,
2128 const char *fmt
, ...)
2135 len
= vsnprintf(tmp
, SZ
, fmt
, ap
);
2136 buf_write(buf
, tmp
, len
);
2140 void buf_write(struct buffer
*buf
, const char *s
, int len
)
2142 if (buf
->size
- buf
->pos
< len
) {
2143 buf
->size
+= len
+ SZ
;
2144 buf
->p
= NOFAIL(realloc(buf
->p
, buf
->size
));
2146 strncpy(buf
->p
+ buf
->pos
, s
, len
);
2150 static void check_for_gpl_usage(enum export exp
, const char *m
, const char *s
)
2152 const char *e
= is_vmlinux(m
) ?"":".ko";
2156 fatal("modpost: GPL-incompatible module %s%s "
2157 "uses GPL-only symbol '%s'\n", m
, e
, s
);
2159 case export_unused_gpl
:
2160 fatal("modpost: GPL-incompatible module %s%s "
2161 "uses GPL-only symbol marked UNUSED '%s'\n", m
, e
, s
);
2163 case export_gpl_future
:
2164 warn("modpost: GPL-incompatible module %s%s "
2165 "uses future GPL-only symbol '%s'\n", m
, e
, s
);
2169 case export_unknown
:
2175 static void check_for_unused(enum export exp
, const char *m
, const char *s
)
2177 const char *e
= is_vmlinux(m
) ?"":".ko";
2181 case export_unused_gpl
:
2182 warn("modpost: module %s%s "
2183 "uses symbol '%s' marked UNUSED\n", m
, e
, s
);
2191 static int check_exports(struct module
*mod
)
2193 struct symbol
*s
, *exp
;
2196 for (s
= mod
->unres
; s
; s
= s
->next
) {
2197 const char *basename
;
2198 exp
= find_symbol(s
->name
);
2199 if (!exp
|| exp
->module
== mod
) {
2200 if (have_vmlinux
&& !s
->weak
) {
2201 if (warn_unresolved
) {
2202 warn("\"%s\" [%s.ko] undefined!\n",
2203 s
->name
, mod
->name
);
2205 merror("\"%s\" [%s.ko] undefined!\n",
2206 s
->name
, mod
->name
);
2212 basename
= strrchr(mod
->name
, '/');
2216 basename
= mod
->name
;
2218 if (exp
->namespace &&
2219 !module_imports_namespace(mod
, exp
->namespace)) {
2220 warn("module %s uses symbol %s from namespace %s, but does not import it.\n",
2221 basename
, exp
->name
, exp
->namespace);
2222 add_namespace(&mod
->missing_namespaces
, exp
->namespace);
2225 if (!mod
->gpl_compatible
)
2226 check_for_gpl_usage(exp
->export
, basename
, exp
->name
);
2227 check_for_unused(exp
->export
, basename
, exp
->name
);
2233 static int check_modname_len(struct module
*mod
)
2235 const char *mod_name
;
2237 mod_name
= strrchr(mod
->name
, '/');
2238 if (mod_name
== NULL
)
2239 mod_name
= mod
->name
;
2242 if (strlen(mod_name
) >= MODULE_NAME_LEN
) {
2243 merror("module name is too long [%s.ko]\n", mod
->name
);
2251 * Header for the generated file
2253 static void add_header(struct buffer
*b
, struct module
*mod
)
2255 buf_printf(b
, "#include <linux/module.h>\n");
2257 * Include build-salt.h after module.h in order to
2258 * inherit the definitions.
2260 buf_printf(b
, "#include <linux/build-salt.h>\n");
2261 buf_printf(b
, "#include <linux/vermagic.h>\n");
2262 buf_printf(b
, "#include <linux/compiler.h>\n");
2263 buf_printf(b
, "\n");
2264 buf_printf(b
, "BUILD_SALT;\n");
2265 buf_printf(b
, "\n");
2266 buf_printf(b
, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2267 buf_printf(b
, "MODULE_INFO(name, KBUILD_MODNAME);\n");
2268 buf_printf(b
, "\n");
2269 buf_printf(b
, "__visible struct module __this_module\n");
2270 buf_printf(b
, "__section(.gnu.linkonce.this_module) = {\n");
2271 buf_printf(b
, "\t.name = KBUILD_MODNAME,\n");
2273 buf_printf(b
, "\t.init = init_module,\n");
2274 if (mod
->has_cleanup
)
2275 buf_printf(b
, "#ifdef CONFIG_MODULE_UNLOAD\n"
2276 "\t.exit = cleanup_module,\n"
2278 buf_printf(b
, "\t.arch = MODULE_ARCH_INIT,\n");
2279 buf_printf(b
, "};\n");
2282 static void add_intree_flag(struct buffer
*b
, int is_intree
)
2285 buf_printf(b
, "\nMODULE_INFO(intree, \"Y\");\n");
2288 /* Cannot check for assembler */
2289 static void add_retpoline(struct buffer
*b
)
2291 buf_printf(b
, "\n#ifdef CONFIG_RETPOLINE\n");
2292 buf_printf(b
, "MODULE_INFO(retpoline, \"Y\");\n");
2293 buf_printf(b
, "#endif\n");
2296 static void add_staging_flag(struct buffer
*b
, const char *name
)
2298 if (strstarts(name
, "drivers/staging"))
2299 buf_printf(b
, "\nMODULE_INFO(staging, \"Y\");\n");
2303 * Record CRCs for unresolved symbols
2305 static int add_versions(struct buffer
*b
, struct module
*mod
)
2307 struct symbol
*s
, *exp
;
2310 for (s
= mod
->unres
; s
; s
= s
->next
) {
2311 exp
= find_symbol(s
->name
);
2312 if (!exp
|| exp
->module
== mod
)
2314 s
->module
= exp
->module
;
2315 s
->crc_valid
= exp
->crc_valid
;
2322 buf_printf(b
, "\n");
2323 buf_printf(b
, "static const struct modversion_info ____versions[]\n");
2324 buf_printf(b
, "__used __section(__versions) = {\n");
2326 for (s
= mod
->unres
; s
; s
= s
->next
) {
2329 if (!s
->crc_valid
) {
2330 warn("\"%s\" [%s.ko] has no CRC!\n",
2331 s
->name
, mod
->name
);
2334 if (strlen(s
->name
) >= MODULE_NAME_LEN
) {
2335 merror("too long symbol \"%s\" [%s.ko]\n",
2336 s
->name
, mod
->name
);
2340 buf_printf(b
, "\t{ %#8x, \"%s\" },\n",
2344 buf_printf(b
, "};\n");
2349 static void add_depends(struct buffer
*b
, struct module
*mod
)
2354 /* Clear ->seen flag of modules that own symbols needed by this. */
2355 for (s
= mod
->unres
; s
; s
= s
->next
)
2357 s
->module
->seen
= is_vmlinux(s
->module
->name
);
2359 buf_printf(b
, "\n");
2360 buf_printf(b
, "MODULE_INFO(depends, \"");
2361 for (s
= mod
->unres
; s
; s
= s
->next
) {
2366 if (s
->module
->seen
)
2369 s
->module
->seen
= 1;
2370 p
= strrchr(s
->module
->name
, '/');
2374 p
= s
->module
->name
;
2375 buf_printf(b
, "%s%s", first
? "" : ",", p
);
2378 buf_printf(b
, "\");\n");
2381 static void add_srcversion(struct buffer
*b
, struct module
*mod
)
2383 if (mod
->srcversion
[0]) {
2384 buf_printf(b
, "\n");
2385 buf_printf(b
, "MODULE_INFO(srcversion, \"%s\");\n",
2390 static void write_if_changed(struct buffer
*b
, const char *fname
)
2396 file
= fopen(fname
, "r");
2400 if (fstat(fileno(file
), &st
) < 0)
2403 if (st
.st_size
!= b
->pos
)
2406 tmp
= NOFAIL(malloc(b
->pos
));
2407 if (fread(tmp
, 1, b
->pos
, file
) != b
->pos
)
2410 if (memcmp(tmp
, b
->p
, b
->pos
) != 0)
2422 file
= fopen(fname
, "w");
2427 if (fwrite(b
->p
, 1, b
->pos
, file
) != b
->pos
) {
2434 /* parse Module.symvers file. line format:
2435 * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
2437 static void read_dump(const char *fname
, unsigned int kernel
)
2439 unsigned long size
, pos
= 0;
2440 void *file
= grab_file(fname
, &size
);
2444 /* No symbol versions, silently ignore */
2447 while ((line
= get_next_line(&pos
, file
, size
))) {
2448 char *symname
, *namespace, *modname
, *d
, *export
;
2453 if (!(symname
= strchr(line
, '\t')))
2456 if (!(modname
= strchr(symname
, '\t')))
2459 if (!(export
= strchr(modname
, '\t')))
2462 if (!(namespace = strchr(export
, '\t')))
2464 *namespace++ = '\0';
2466 crc
= strtoul(line
, &d
, 16);
2467 if (*symname
== '\0' || *modname
== '\0' || *d
!= '\0')
2469 mod
= find_module(modname
);
2471 if (is_vmlinux(modname
))
2473 mod
= new_module(modname
);
2476 s
= sym_add_exported(symname
, mod
, export_no(export
));
2479 sym_set_crc(symname
, crc
);
2480 sym_update_namespace(symname
, namespace);
2482 release_file(file
, size
);
2485 release_file(file
, size
);
2486 fatal("parse error in symbol dump file\n");
2489 /* For normal builds always dump all symbols.
2490 * For external modules only dump symbols
2491 * that are not read from kernel Module.symvers.
2493 static int dump_sym(struct symbol
*sym
)
2495 if (!external_module
)
2497 if (sym
->vmlinux
|| sym
->kernel
)
2502 static void write_dump(const char *fname
)
2504 struct buffer buf
= { };
2505 struct symbol
*symbol
;
2506 const char *namespace;
2509 for (n
= 0; n
< SYMBOL_HASH_SIZE
; n
++) {
2510 symbol
= symbolhash
[n
];
2512 if (dump_sym(symbol
)) {
2513 namespace = symbol
->namespace;
2514 buf_printf(&buf
, "0x%08x\t%s\t%s\t%s\t%s\n",
2515 symbol
->crc
, symbol
->name
,
2516 symbol
->module
->name
,
2517 export_str(symbol
->export
),
2518 namespace ? namespace : "");
2520 symbol
= symbol
->next
;
2523 write_if_changed(&buf
, fname
);
2527 static void write_namespace_deps_files(const char *fname
)
2530 struct namespace_list
*ns
;
2531 struct buffer ns_deps_buf
= {};
2533 for (mod
= modules
; mod
; mod
= mod
->next
) {
2535 if (mod
->skip
|| !mod
->missing_namespaces
)
2538 buf_printf(&ns_deps_buf
, "%s.ko:", mod
->name
);
2540 for (ns
= mod
->missing_namespaces
; ns
; ns
= ns
->next
)
2541 buf_printf(&ns_deps_buf
, " %s", ns
->namespace);
2543 buf_printf(&ns_deps_buf
, "\n");
2546 write_if_changed(&ns_deps_buf
, fname
);
2547 free(ns_deps_buf
.p
);
2550 struct ext_sym_list
{
2551 struct ext_sym_list
*next
;
2555 int main(int argc
, char **argv
)
2558 struct buffer buf
= { };
2559 char *kernel_read
= NULL
;
2560 char *missing_namespace_deps
= NULL
;
2561 char *dump_write
= NULL
, *files_source
= NULL
;
2565 struct ext_sym_list
*extsym_iter
;
2566 struct ext_sym_list
*extsym_start
= NULL
;
2568 while ((opt
= getopt(argc
, argv
, "i:e:mnsT:o:awEd:")) != -1) {
2571 kernel_read
= optarg
;
2572 external_module
= 1;
2575 external_module
= 1;
2577 NOFAIL(malloc(sizeof(*extsym_iter
)));
2578 extsym_iter
->next
= extsym_start
;
2579 extsym_iter
->file
= optarg
;
2580 extsym_start
= extsym_iter
;
2586 ignore_missing_files
= 1;
2589 dump_write
= optarg
;
2595 vmlinux_section_warnings
= 0;
2598 files_source
= optarg
;
2601 warn_unresolved
= 1;
2604 sec_mismatch_fatal
= 1;
2607 missing_namespace_deps
= optarg
;
2615 read_dump(kernel_read
, 1);
2616 while (extsym_start
) {
2617 read_dump(extsym_start
->file
, 0);
2618 extsym_iter
= extsym_start
->next
;
2620 extsym_start
= extsym_iter
;
2623 while (optind
< argc
)
2624 read_symbols(argv
[optind
++]);
2627 read_symbols_from_files(files_source
);
2631 for (mod
= modules
; mod
; mod
= mod
->next
) {
2632 char fname
[PATH_MAX
];
2639 err
|= check_modname_len(mod
);
2640 err
|= check_exports(mod
);
2642 add_header(&buf
, mod
);
2643 add_intree_flag(&buf
, !external_module
);
2644 add_retpoline(&buf
);
2645 add_staging_flag(&buf
, mod
->name
);
2646 err
|= add_versions(&buf
, mod
);
2647 add_depends(&buf
, mod
);
2648 add_moddevtable(&buf
, mod
);
2649 add_srcversion(&buf
, mod
);
2651 sprintf(fname
, "%s.mod.c", mod
->name
);
2652 write_if_changed(&buf
, fname
);
2655 if (missing_namespace_deps
)
2656 write_namespace_deps_files(missing_namespace_deps
);
2659 write_dump(dump_write
);
2660 if (sec_mismatch_count
&& sec_mismatch_fatal
)
2661 fatal("modpost: Section mismatches detected.\n"
2662 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2663 for (n
= 0; n
< SYMBOL_HASH_SIZE
; n
++) {
2666 for (s
= symbolhash
[n
]; s
; s
= s
->next
) {
2668 * Do not check "vmlinux". This avoids the same warnings
2669 * shown twice, and false-positives for ARCH=um.
2671 if (is_vmlinux(s
->module
->name
) && !s
->module
->is_dot_o
)
2675 warn("\"%s\" [%s] is a static %s\n",
2676 s
->name
, s
->module
->name
,
2677 export_str(s
->export
));