projects/linux·blob v5.13 · refs

2602 lines · 66.7 KiB

1/* Postprocess module symbol versions
2 *
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
7 *
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
10 *
11 * Usage: modpost vmlinux module1.o module2.o ...
12 */
13
14#define _GNU_SOURCE
15#include <elf.h>
16#include <stdio.h>
17#include <ctype.h>
18#include <string.h>
19#include <limits.h>
20#include <errno.h>
21#include "modpost.h"
22#include "../../include/linux/license.h"
23
24/* Are we using CONFIG_MODVERSIONS? */
25static int modversions = 0;
26/* Is CONFIG_MODULE_SRCVERSION_ALL set? */
27static int all_versions = 0;
28/* If we are modposting external module set to 1 */
29static int external_module = 0;
30/* Only warn about unresolved symbols */
31static int warn_unresolved = 0;
32/* How a symbol is exported */
33static int sec_mismatch_count = 0;
34static int sec_mismatch_warn_only = true;
35/* ignore missing files */
36static int ignore_missing_files;
37/* If set to 1, only warn (instead of error) about missing ns imports */
38static int allow_missing_ns_imports;
39
40static bool error_occurred;
41
42/*
43 * Cut off the warnings when there are too many. This typically occurs when
44 * vmlinux is missing. ('make modules' without building vmlinux.)
45 */
46#define MAX_UNRESOLVED_REPORTS 10
47static unsigned int nr_unresolved;
48
49enum export {
50 export_plain,
51 export_gpl,
52 export_unknown
53};
54
55/* In kernel, this size is defined in linux/module.h;
56 * here we use Elf_Addr instead of long for covering cross-compile
57 */
58
59#define MODULE_NAME_LEN (64 - sizeof(Elf_Addr))
60
61void __attribute__((format(printf, 2, 3)))
62modpost_log(enum loglevel loglevel, const char *fmt, ...)
63{
64 va_list arglist;
65
66 switch (loglevel) {
67 case LOG_WARN:
68 fprintf(stderr, "WARNING: ");
69 break;
70 case LOG_ERROR:
71 fprintf(stderr, "ERROR: ");
72 break;
73 case LOG_FATAL:
74 fprintf(stderr, "FATAL: ");
75 break;
76 default: /* invalid loglevel, ignore */
77 break;
78 }
79
80 fprintf(stderr, "modpost: ");
81
82 va_start(arglist, fmt);
83 vfprintf(stderr, fmt, arglist);
84 va_end(arglist);
85
86 if (loglevel == LOG_FATAL)
87 exit(1);
88 if (loglevel == LOG_ERROR)
89 error_occurred = true;
90}
91
92void *do_nofail(void *ptr, const char *expr)
93{
94 if (!ptr)
95 fatal("Memory allocation failure: %s.\n", expr);
96
97 return ptr;
98}
99
100char *read_text_file(const char *filename)
101{
102 struct stat st;
103 size_t nbytes;
104 int fd;
105 char *buf;
106
107 fd = open(filename, O_RDONLY);
108 if (fd < 0) {
109 perror(filename);
110 exit(1);
111 }
112
113 if (fstat(fd, &st) < 0) {
114 perror(filename);
115 exit(1);
116 }
117
118 buf = NOFAIL(malloc(st.st_size + 1));
119
120 nbytes = st.st_size;
121
122 while (nbytes) {
123 ssize_t bytes_read;
124
125 bytes_read = read(fd, buf, nbytes);
126 if (bytes_read < 0) {
127 perror(filename);
128 exit(1);
129 }
130
131 nbytes -= bytes_read;
132 }
133 buf[st.st_size] = '\0';
134
135 close(fd);
136
137 return buf;
138}
139
140char *get_line(char **stringp)
141{
142 char *orig = *stringp, *next;
143
144 /* do not return the unwanted extra line at EOF */
145 if (!orig || *orig == '\0')
146 return NULL;
147
148 /* don't use strsep here, it is not available everywhere */
149 next = strchr(orig, '\n');
150 if (next)
151 *next++ = '\0';
152
153 *stringp = next;
154
155 return orig;
156}
157
158/* A list of all modules we processed */
159static struct module *modules;
160
161static struct module *find_module(const char *modname)
162{
163 struct module *mod;
164
165 for (mod = modules; mod; mod = mod->next)
166 if (strcmp(mod->name, modname) == 0)
167 break;
168 return mod;
169}
170
171static struct module *new_module(const char *modname)
172{
173 struct module *mod;
174
175 mod = NOFAIL(malloc(sizeof(*mod) + strlen(modname) + 1));
176 memset(mod, 0, sizeof(*mod));
177
178 /* add to list */
179 strcpy(mod->name, modname);
180 mod->is_vmlinux = (strcmp(modname, "vmlinux") == 0);
181 mod->gpl_compatible = -1;
182 mod->next = modules;
183 modules = mod;
184
185 return mod;
186}
187
188/* A hash of all exported symbols,
189 * struct symbol is also used for lists of unresolved symbols */
190
191#define SYMBOL_HASH_SIZE 1024
192
193struct symbol {
194 struct symbol *next;
195 struct module *module;
196 unsigned int crc;
197 int crc_valid;
198 char *namespace;
199 unsigned int weak:1;
200 unsigned int is_static:1; /* 1 if symbol is not global */
201 enum export export; /* Type of export */
202 char name[];
203};
204
205static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
206
207/* This is based on the hash algorithm from gdbm, via tdb */
208static inline unsigned int tdb_hash(const char *name)
209{
210 unsigned value; /* Used to compute the hash value. */
211 unsigned i; /* Used to cycle through random values. */
212
213 /* Set the initial value from the key size. */
214 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
215 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
216
217 return (1103515243 * value + 12345);
218}
219
220/**
221 * Allocate a new symbols for use in the hash of exported symbols or
222 * the list of unresolved symbols per module
223 **/
224static struct symbol *alloc_symbol(const char *name, unsigned int weak,
225 struct symbol *next)
226{
227 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
228
229 memset(s, 0, sizeof(*s));
230 strcpy(s->name, name);
231 s->weak = weak;
232 s->next = next;
233 s->is_static = 1;
234 return s;
235}
236
237/* For the hash of exported symbols */
238static struct symbol *new_symbol(const char *name, struct module *module,
239 enum export export)
240{
241 unsigned int hash;
242
243 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
244 symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
245
246 return symbolhash[hash];
247}
248
249static struct symbol *find_symbol(const char *name)
250{
251 struct symbol *s;
252
253 /* For our purposes, .foo matches foo. PPC64 needs this. */
254 if (name[0] == '.')
255 name++;
256
257 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
258 if (strcmp(s->name, name) == 0)
259 return s;
260 }
261 return NULL;
262}
263
264static bool contains_namespace(struct namespace_list *list,
265 const char *namespace)
266{
267 for (; list; list = list->next)
268 if (!strcmp(list->namespace, namespace))
269 return true;
270
271 return false;
272}
273
274static void add_namespace(struct namespace_list **list, const char *namespace)
275{
276 struct namespace_list *ns_entry;
277
278 if (!contains_namespace(*list, namespace)) {
279 ns_entry = NOFAIL(malloc(sizeof(struct namespace_list) +
280 strlen(namespace) + 1));
281 strcpy(ns_entry->namespace, namespace);
282 ns_entry->next = *list;
283 *list = ns_entry;
284 }
285}
286
287static bool module_imports_namespace(struct module *module,
288 const char *namespace)
289{
290 return contains_namespace(module->imported_namespaces, namespace);
291}
292
293static const struct {
294 const char *str;
295 enum export export;
296} export_list[] = {
297 { .str = "EXPORT_SYMBOL", .export = export_plain },
298 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
299 { .str = "(unknown)", .export = export_unknown },
300};
301
302
303static const char *export_str(enum export ex)
304{
305 return export_list[ex].str;
306}
307
308static enum export export_no(const char *s)
309{
310 int i;
311
312 if (!s)
313 return export_unknown;
314 for (i = 0; export_list[i].export != export_unknown; i++) {
315 if (strcmp(export_list[i].str, s) == 0)
316 return export_list[i].export;
317 }
318 return export_unknown;
319}
320
321static void *sym_get_data_by_offset(const struct elf_info *info,
322 unsigned int secindex, unsigned long offset)
323{
324 Elf_Shdr *sechdr = &info->sechdrs[secindex];
325
326 if (info->hdr->e_type != ET_REL)
327 offset -= sechdr->sh_addr;
328
329 return (void *)info->hdr + sechdr->sh_offset + offset;
330}
331
332static void *sym_get_data(const struct elf_info *info, const Elf_Sym *sym)
333{
334 return sym_get_data_by_offset(info, get_secindex(info, sym),
335 sym->st_value);
336}
337
338static const char *sech_name(const struct elf_info *info, Elf_Shdr *sechdr)
339{
340 return sym_get_data_by_offset(info, info->secindex_strings,
341 sechdr->sh_name);
342}
343
344static const char *sec_name(const struct elf_info *info, int secindex)
345{
346 return sech_name(info, &info->sechdrs[secindex]);
347}
348
349#define strstarts(str, prefix) (strncmp(str, prefix, strlen(prefix)) == 0)
350
351static enum export export_from_secname(struct elf_info *elf, unsigned int sec)
352{
353 const char *secname = sec_name(elf, sec);
354
355 if (strstarts(secname, "___ksymtab+"))
356 return export_plain;
357 else if (strstarts(secname, "___ksymtab_gpl+"))
358 return export_gpl;
359 else
360 return export_unknown;
361}
362
363static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
364{
365 if (sec == elf->export_sec)
366 return export_plain;
367 else if (sec == elf->export_gpl_sec)
368 return export_gpl;
369 else
370 return export_unknown;
371}
372
373static const char *namespace_from_kstrtabns(const struct elf_info *info,
374 const Elf_Sym *sym)
375{
376 const char *value = sym_get_data(info, sym);
377 return value[0] ? value : NULL;
378}
379
380static void sym_update_namespace(const char *symname, const char *namespace)
381{
382 struct symbol *s = find_symbol(symname);
383
384 /*
385 * That symbol should have been created earlier and thus this is
386 * actually an assertion.
387 */
388 if (!s) {
389 error("Could not update namespace(%s) for symbol %s\n",
390 namespace, symname);
391 return;
392 }
393
394 free(s->namespace);
395 s->namespace =
396 namespace && namespace[0] ? NOFAIL(strdup(namespace)) : NULL;
397}
398
399/**
400 * Add an exported symbol - it may have already been added without a
401 * CRC, in this case just update the CRC
402 **/
403static struct symbol *sym_add_exported(const char *name, struct module *mod,
404 enum export export)
405{
406 struct symbol *s = find_symbol(name);
407
408 if (!s) {
409 s = new_symbol(name, mod, export);
410 } else if (!external_module || s->module->is_vmlinux ||
411 s->module == mod) {
412 warn("%s: '%s' exported twice. Previous export was in %s%s\n",
413 mod->name, name, s->module->name,
414 s->module->is_vmlinux ? "" : ".ko");
415 return s;
416 }
417
418 s->module = mod;
419 s->export = export;
420 return s;
421}
422
423static void sym_set_crc(const char *name, unsigned int crc)
424{
425 struct symbol *s = find_symbol(name);
426
427 /*
428 * Ignore stand-alone __crc_*, which might be auto-generated symbols
429 * such as __*_veneer in ARM ELF.
430 */
431 if (!s)
432 return;
433
434 s->crc = crc;
435 s->crc_valid = 1;
436}
437
438static void *grab_file(const char *filename, size_t *size)
439{
440 struct stat st;
441 void *map = MAP_FAILED;
442 int fd;
443
444 fd = open(filename, O_RDONLY);
445 if (fd < 0)
446 return NULL;
447 if (fstat(fd, &st))
448 goto failed;
449
450 *size = st.st_size;
451 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
452
453failed:
454 close(fd);
455 if (map == MAP_FAILED)
456 return NULL;
457 return map;
458}
459
460static void release_file(void *file, size_t size)
461{
462 munmap(file, size);
463}
464
465static int parse_elf(struct elf_info *info, const char *filename)
466{
467 unsigned int i;
468 Elf_Ehdr *hdr;
469 Elf_Shdr *sechdrs;
470 Elf_Sym *sym;
471 const char *secstrings;
472 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
473
474 hdr = grab_file(filename, &info->size);
475 if (!hdr) {
476 if (ignore_missing_files) {
477 fprintf(stderr, "%s: %s (ignored)\n", filename,
478 strerror(errno));
479 return 0;
480 }
481 perror(filename);
482 exit(1);
483 }
484 info->hdr = hdr;
485 if (info->size < sizeof(*hdr)) {
486 /* file too small, assume this is an empty .o file */
487 return 0;
488 }
489 /* Is this a valid ELF file? */
490 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
491 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
492 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
493 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
494 /* Not an ELF file - silently ignore it */
495 return 0;
496 }
497 /* Fix endianness in ELF header */
498 hdr->e_type = TO_NATIVE(hdr->e_type);
499 hdr->e_machine = TO_NATIVE(hdr->e_machine);
500 hdr->e_version = TO_NATIVE(hdr->e_version);
501 hdr->e_entry = TO_NATIVE(hdr->e_entry);
502 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
503 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
504 hdr->e_flags = TO_NATIVE(hdr->e_flags);
505 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
506 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
507 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
508 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
509 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
510 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
511 sechdrs = (void *)hdr + hdr->e_shoff;
512 info->sechdrs = sechdrs;
513
514 /* Check if file offset is correct */
515 if (hdr->e_shoff > info->size) {
516 fatal("section header offset=%lu in file '%s' is bigger than filesize=%zu\n",
517 (unsigned long)hdr->e_shoff, filename, info->size);
518 return 0;
519 }
520
521 if (hdr->e_shnum == SHN_UNDEF) {
522 /*
523 * There are more than 64k sections,
524 * read count from .sh_size.
525 */
526 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
527 }
528 else {
529 info->num_sections = hdr->e_shnum;
530 }
531 if (hdr->e_shstrndx == SHN_XINDEX) {
532 info->secindex_strings = TO_NATIVE(sechdrs[0].sh_link);
533 }
534 else {
535 info->secindex_strings = hdr->e_shstrndx;
536 }
537
538 /* Fix endianness in section headers */
539 for (i = 0; i < info->num_sections; i++) {
540 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
541 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
542 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
543 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
544 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
545 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
546 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
547 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
548 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
549 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
550 }
551 /* Find symbol table. */
552 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
553 for (i = 1; i < info->num_sections; i++) {
554 const char *secname;
555 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
556
557 if (!nobits && sechdrs[i].sh_offset > info->size) {
558 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
559 "sizeof(*hrd)=%zu\n", filename,
560 (unsigned long)sechdrs[i].sh_offset,
561 sizeof(*hdr));
562 return 0;
563 }
564 secname = secstrings + sechdrs[i].sh_name;
565 if (strcmp(secname, ".modinfo") == 0) {
566 if (nobits)
567 fatal("%s has NOBITS .modinfo\n", filename);
568 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
569 info->modinfo_len = sechdrs[i].sh_size;
570 } else if (strcmp(secname, "__ksymtab") == 0)
571 info->export_sec = i;
572 else if (strcmp(secname, "__ksymtab_gpl") == 0)
573 info->export_gpl_sec = i;
574
575 if (sechdrs[i].sh_type == SHT_SYMTAB) {
576 unsigned int sh_link_idx;
577 symtab_idx = i;
578 info->symtab_start = (void *)hdr +
579 sechdrs[i].sh_offset;
580 info->symtab_stop = (void *)hdr +
581 sechdrs[i].sh_offset + sechdrs[i].sh_size;
582 sh_link_idx = sechdrs[i].sh_link;
583 info->strtab = (void *)hdr +
584 sechdrs[sh_link_idx].sh_offset;
585 }
586
587 /* 32bit section no. table? ("more than 64k sections") */
588 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
589 symtab_shndx_idx = i;
590 info->symtab_shndx_start = (void *)hdr +
591 sechdrs[i].sh_offset;
592 info->symtab_shndx_stop = (void *)hdr +
593 sechdrs[i].sh_offset + sechdrs[i].sh_size;
594 }
595 }
596 if (!info->symtab_start)
597 fatal("%s has no symtab?\n", filename);
598
599 /* Fix endianness in symbols */
600 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
601 sym->st_shndx = TO_NATIVE(sym->st_shndx);
602 sym->st_name = TO_NATIVE(sym->st_name);
603 sym->st_value = TO_NATIVE(sym->st_value);
604 sym->st_size = TO_NATIVE(sym->st_size);
605 }
606
607 if (symtab_shndx_idx != ~0U) {
608 Elf32_Word *p;
609 if (symtab_idx != sechdrs[symtab_shndx_idx].sh_link)
610 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
611 filename, sechdrs[symtab_shndx_idx].sh_link,
612 symtab_idx);
613 /* Fix endianness */
614 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
615 p++)
616 *p = TO_NATIVE(*p);
617 }
618
619 return 1;
620}
621
622static void parse_elf_finish(struct elf_info *info)
623{
624 release_file(info->hdr, info->size);
625}
626
627static int ignore_undef_symbol(struct elf_info *info, const char *symname)
628{
629 /* ignore __this_module, it will be resolved shortly */
630 if (strcmp(symname, "__this_module") == 0)
631 return 1;
632 /* ignore global offset table */
633 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
634 return 1;
635 if (info->hdr->e_machine == EM_PPC)
636 /* Special register function linked on all modules during final link of .ko */
637 if (strstarts(symname, "_restgpr_") ||
638 strstarts(symname, "_savegpr_") ||
639 strstarts(symname, "_rest32gpr_") ||
640 strstarts(symname, "_save32gpr_") ||
641 strstarts(symname, "_restvr_") ||
642 strstarts(symname, "_savevr_"))
643 return 1;
644 if (info->hdr->e_machine == EM_PPC64)
645 /* Special register function linked on all modules during final link of .ko */
646 if (strstarts(symname, "_restgpr0_") ||
647 strstarts(symname, "_savegpr0_") ||
648 strstarts(symname, "_restvr_") ||
649 strstarts(symname, "_savevr_") ||
650 strcmp(symname, ".TOC.") == 0)
651 return 1;
652 /* Do not ignore this symbol */
653 return 0;
654}
655
656static void handle_modversion(const struct module *mod,
657 const struct elf_info *info,
658 const Elf_Sym *sym, const char *symname)
659{
660 unsigned int crc;
661
662 if (sym->st_shndx == SHN_UNDEF) {
663 warn("EXPORT symbol \"%s\" [%s%s] version generation failed, symbol will not be versioned.\n",
664 symname, mod->name, mod->is_vmlinux ? "" : ".ko");
665 return;
666 }
667
668 if (sym->st_shndx == SHN_ABS) {
669 crc = sym->st_value;
670 } else {
671 unsigned int *crcp;
672
673 /* symbol points to the CRC in the ELF object */
674 crcp = sym_get_data(info, sym);
675 crc = TO_NATIVE(*crcp);
676 }
677 sym_set_crc(symname, crc);
678}
679
680static void handle_symbol(struct module *mod, struct elf_info *info,
681 const Elf_Sym *sym, const char *symname)
682{
683 enum export export;
684 const char *name;
685
686 if (strstarts(symname, "__ksymtab"))
687 export = export_from_secname(info, get_secindex(info, sym));
688 else
689 export = export_from_sec(info, get_secindex(info, sym));
690
691 switch (sym->st_shndx) {
692 case SHN_COMMON:
693 if (strstarts(symname, "__gnu_lto_")) {
694 /* Should warn here, but modpost runs before the linker */
695 } else
696 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
697 break;
698 case SHN_UNDEF:
699 /* undefined symbol */
700 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
701 ELF_ST_BIND(sym->st_info) != STB_WEAK)
702 break;
703 if (ignore_undef_symbol(info, symname))
704 break;
705 if (info->hdr->e_machine == EM_SPARC ||
706 info->hdr->e_machine == EM_SPARCV9) {
707 /* Ignore register directives. */
708 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
709 break;
710 if (symname[0] == '.') {
711 char *munged = NOFAIL(strdup(symname));
712 munged[0] = '_';
713 munged[1] = toupper(munged[1]);
714 symname = munged;
715 }
716 }
717
718 mod->unres = alloc_symbol(symname,
719 ELF_ST_BIND(sym->st_info) == STB_WEAK,
720 mod->unres);
721 break;
722 default:
723 /* All exported symbols */
724 if (strstarts(symname, "__ksymtab_")) {
725 name = symname + strlen("__ksymtab_");
726 sym_add_exported(name, mod, export);
727 }
728 if (strcmp(symname, "init_module") == 0)
729 mod->has_init = 1;
730 if (strcmp(symname, "cleanup_module") == 0)
731 mod->has_cleanup = 1;
732 break;
733 }
734}
735
736/**
737 * Parse tag=value strings from .modinfo section
738 **/
739static char *next_string(char *string, unsigned long *secsize)
740{
741 /* Skip non-zero chars */
742 while (string[0]) {
743 string++;
744 if ((*secsize)-- <= 1)
745 return NULL;
746 }
747
748 /* Skip any zero padding. */
749 while (!string[0]) {
750 string++;
751 if ((*secsize)-- <= 1)
752 return NULL;
753 }
754 return string;
755}
756
757static char *get_next_modinfo(struct elf_info *info, const char *tag,
758 char *prev)
759{
760 char *p;
761 unsigned int taglen = strlen(tag);
762 char *modinfo = info->modinfo;
763 unsigned long size = info->modinfo_len;
764
765 if (prev) {
766 size -= prev - modinfo;
767 modinfo = next_string(prev, &size);
768 }
769
770 for (p = modinfo; p; p = next_string(p, &size)) {
771 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
772 return p + taglen + 1;
773 }
774 return NULL;
775}
776
777static char *get_modinfo(struct elf_info *info, const char *tag)
778
779{
780 return get_next_modinfo(info, tag, NULL);
781}
782
783/**
784 * Test if string s ends in string sub
785 * return 0 if match
786 **/
787static int strrcmp(const char *s, const char *sub)
788{
789 int slen, sublen;
790
791 if (!s || !sub)
792 return 1;
793
794 slen = strlen(s);
795 sublen = strlen(sub);
796
797 if ((slen == 0) || (sublen == 0))
798 return 1;
799
800 if (sublen > slen)
801 return 1;
802
803 return memcmp(s + slen - sublen, sub, sublen);
804}
805
806static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
807{
808 if (sym)
809 return elf->strtab + sym->st_name;
810 else
811 return "(unknown)";
812}
813
814/* The pattern is an array of simple patterns.
815 * "foo" will match an exact string equal to "foo"
816 * "*foo" will match a string that ends with "foo"
817 * "foo*" will match a string that begins with "foo"
818 * "*foo*" will match a string that contains "foo"
819 */
820static int match(const char *sym, const char * const pat[])
821{
822 const char *p;
823 while (*pat) {
824 p = *pat++;
825 const char *endp = p + strlen(p) - 1;
826
827 /* "*foo*" */
828 if (*p == '*' && *endp == '*') {
829 char *bare = NOFAIL(strndup(p + 1, strlen(p) - 2));
830 char *here = strstr(sym, bare);
831
832 free(bare);
833 if (here != NULL)
834 return 1;
835 }
836 /* "*foo" */
837 else if (*p == '*') {
838 if (strrcmp(sym, p + 1) == 0)
839 return 1;
840 }
841 /* "foo*" */
842 else if (*endp == '*') {
843 if (strncmp(sym, p, strlen(p) - 1) == 0)
844 return 1;
845 }
846 /* no wildcards */
847 else {
848 if (strcmp(p, sym) == 0)
849 return 1;
850 }
851 }
852 /* no match */
853 return 0;
854}
855
856/* sections that we do not want to do full section mismatch check on */
857static const char *const section_white_list[] =
858{
859 ".comment*",
860 ".debug*",
861 ".cranges", /* sh64 */
862 ".zdebug*", /* Compressed debug sections. */
863 ".GCC.command.line", /* record-gcc-switches */
864 ".mdebug*", /* alpha, score, mips etc. */
865 ".pdr", /* alpha, score, mips etc. */
866 ".stab*",
867 ".note*",
868 ".got*",
869 ".toc*",
870 ".xt.prop", /* xtensa */
871 ".xt.lit", /* xtensa */
872 ".arcextmap*", /* arc */
873 ".gnu.linkonce.arcext*", /* arc : modules */
874 ".cmem*", /* EZchip */
875 ".fmt_slot*", /* EZchip */
876 ".gnu.lto*",
877 ".discard.*",
878 NULL
879};
880
881/*
882 * This is used to find sections missing the SHF_ALLOC flag.
883 * The cause of this is often a section specified in assembler
884 * without "ax" / "aw".
885 */
886static void check_section(const char *modname, struct elf_info *elf,
887 Elf_Shdr *sechdr)
888{
889 const char *sec = sech_name(elf, sechdr);
890
891 if (sechdr->sh_type == SHT_PROGBITS &&
892 !(sechdr->sh_flags & SHF_ALLOC) &&
893 !match(sec, section_white_list)) {
894 warn("%s (%s): unexpected non-allocatable section.\n"
895 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
896 "Note that for example <linux/init.h> contains\n"
897 "section definitions for use in .S files.\n\n",
898 modname, sec);
899 }
900}
901
902
903
904#define ALL_INIT_DATA_SECTIONS \
905 ".init.setup", ".init.rodata", ".meminit.rodata", \
906 ".init.data", ".meminit.data"
907#define ALL_EXIT_DATA_SECTIONS \
908 ".exit.data", ".memexit.data"
909
910#define ALL_INIT_TEXT_SECTIONS \
911 ".init.text", ".meminit.text"
912#define ALL_EXIT_TEXT_SECTIONS \
913 ".exit.text", ".memexit.text"
914
915#define ALL_PCI_INIT_SECTIONS \
916 ".pci_fixup_early", ".pci_fixup_header", ".pci_fixup_final", \
917 ".pci_fixup_enable", ".pci_fixup_resume", \
918 ".pci_fixup_resume_early", ".pci_fixup_suspend"
919
920#define ALL_XXXINIT_SECTIONS MEM_INIT_SECTIONS
921#define ALL_XXXEXIT_SECTIONS MEM_EXIT_SECTIONS
922
923#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
924#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
925
926#define DATA_SECTIONS ".data", ".data.rel"
927#define TEXT_SECTIONS ".text", ".text.unlikely", ".sched.text", \
928 ".kprobes.text", ".cpuidle.text", ".noinstr.text"
929#define OTHER_TEXT_SECTIONS ".ref.text", ".head.text", ".spinlock.text", \
930 ".fixup", ".entry.text", ".exception.text", ".text.*", \
931 ".coldtext"
932
933#define INIT_SECTIONS ".init.*"
934#define MEM_INIT_SECTIONS ".meminit.*"
935
936#define EXIT_SECTIONS ".exit.*"
937#define MEM_EXIT_SECTIONS ".memexit.*"
938
939#define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
940 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
941
942/* init data sections */
943static const char *const init_data_sections[] =
944 { ALL_INIT_DATA_SECTIONS, NULL };
945
946/* all init sections */
947static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
948
949/* All init and exit sections (code + data) */
950static const char *const init_exit_sections[] =
951 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
952
953/* all text sections */
954static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
955
956/* data section */
957static const char *const data_sections[] = { DATA_SECTIONS, NULL };
958
959
960/* symbols in .data that may refer to init/exit sections */
961#define DEFAULT_SYMBOL_WHITE_LIST \
962 "*driver", \
963 "*_template", /* scsi uses *_template a lot */ \
964 "*_timer", /* arm uses ops structures named _timer a lot */ \
965 "*_sht", /* scsi also used *_sht to some extent */ \
966 "*_ops", \
967 "*_probe", \
968 "*_probe_one", \
969 "*_console"
970
971static const char *const head_sections[] = { ".head.text*", NULL };
972static const char *const linker_symbols[] =
973 { "__init_begin", "_sinittext", "_einittext", NULL };
974static const char *const optim_symbols[] = { "*.constprop.*", NULL };
975
976enum mismatch {
977 TEXT_TO_ANY_INIT,
978 DATA_TO_ANY_INIT,
979 TEXT_TO_ANY_EXIT,
980 DATA_TO_ANY_EXIT,
981 XXXINIT_TO_SOME_INIT,
982 XXXEXIT_TO_SOME_EXIT,
983 ANY_INIT_TO_ANY_EXIT,
984 ANY_EXIT_TO_ANY_INIT,
985 EXPORT_TO_INIT_EXIT,
986 EXTABLE_TO_NON_TEXT,
987};
988
989/**
990 * Describe how to match sections on different criteria:
991 *
992 * @fromsec: Array of sections to be matched.
993 *
994 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
995 * this array is forbidden (black-list). Can be empty.
996 *
997 * @good_tosec: Relocations applied to a section in @fromsec must be
998 * targeting sections in this array (white-list). Can be empty.
999 *
1000 * @mismatch: Type of mismatch.
1001 *
1002 * @symbol_white_list: Do not match a relocation to a symbol in this list
1003 * even if it is targeting a section in @bad_to_sec.
1004 *
1005 * @handler: Specific handler to call when a match is found. If NULL,
1006 * default_mismatch_handler() will be called.
1007 *
1008 */
1009struct sectioncheck {
1010 const char *fromsec[20];
1011 const char *bad_tosec[20];
1012 const char *good_tosec[20];
1013 enum mismatch mismatch;
1014 const char *symbol_white_list[20];
1015 void (*handler)(const char *modname, struct elf_info *elf,
1016 const struct sectioncheck* const mismatch,
1017 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
1018
1019};
1020
1021static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
1022 const struct sectioncheck* const mismatch,
1023 Elf_Rela *r, Elf_Sym *sym,
1024 const char *fromsec);
1025
1026static const struct sectioncheck sectioncheck[] = {
1027/* Do not reference init/exit code/data from
1028 * normal code and data
1029 */
1030{
1031 .fromsec = { TEXT_SECTIONS, NULL },
1032 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1033 .mismatch = TEXT_TO_ANY_INIT,
1034 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1035},
1036{
1037 .fromsec = { DATA_SECTIONS, NULL },
1038 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
1039 .mismatch = DATA_TO_ANY_INIT,
1040 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1041},
1042{
1043 .fromsec = { DATA_SECTIONS, NULL },
1044 .bad_tosec = { INIT_SECTIONS, NULL },
1045 .mismatch = DATA_TO_ANY_INIT,
1046 .symbol_white_list = {
1047 "*_template", "*_timer", "*_sht", "*_ops",
1048 "*_probe", "*_probe_one", "*_console", NULL
1049 },
1050},
1051{
1052 .fromsec = { TEXT_SECTIONS, NULL },
1053 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1054 .mismatch = TEXT_TO_ANY_EXIT,
1055 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1056},
1057{
1058 .fromsec = { DATA_SECTIONS, NULL },
1059 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1060 .mismatch = DATA_TO_ANY_EXIT,
1061 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1062},
1063/* Do not reference init code/data from meminit code/data */
1064{
1065 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1066 .bad_tosec = { INIT_SECTIONS, NULL },
1067 .mismatch = XXXINIT_TO_SOME_INIT,
1068 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1069},
1070/* Do not reference exit code/data from memexit code/data */
1071{
1072 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1073 .bad_tosec = { EXIT_SECTIONS, NULL },
1074 .mismatch = XXXEXIT_TO_SOME_EXIT,
1075 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1076},
1077/* Do not use exit code/data from init code */
1078{
1079 .fromsec = { ALL_INIT_SECTIONS, NULL },
1080 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1081 .mismatch = ANY_INIT_TO_ANY_EXIT,
1082 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1083},
1084/* Do not use init code/data from exit code */
1085{
1086 .fromsec = { ALL_EXIT_SECTIONS, NULL },
1087 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1088 .mismatch = ANY_EXIT_TO_ANY_INIT,
1089 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1090},
1091{
1092 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1093 .bad_tosec = { INIT_SECTIONS, NULL },
1094 .mismatch = ANY_INIT_TO_ANY_EXIT,
1095 .symbol_white_list = { NULL },
1096},
1097/* Do not export init/exit functions or data */
1098{
1099 .fromsec = { "__ksymtab*", NULL },
1100 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1101 .mismatch = EXPORT_TO_INIT_EXIT,
1102 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1103},
1104{
1105 .fromsec = { "__ex_table", NULL },
1106 /* If you're adding any new black-listed sections in here, consider
1107 * adding a special 'printer' for them in scripts/check_extable.
1108 */
1109 .bad_tosec = { ".altinstr_replacement", NULL },
1110 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1111 .mismatch = EXTABLE_TO_NON_TEXT,
1112 .handler = extable_mismatch_handler,
1113}
1114};
1115
1116static const struct sectioncheck *section_mismatch(
1117 const char *fromsec, const char *tosec)
1118{
1119 int i;
1120 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1121 const struct sectioncheck *check = &sectioncheck[0];
1122
1123 /*
1124 * The target section could be the SHT_NUL section when we're
1125 * handling relocations to un-resolved symbols, trying to match it
1126 * doesn't make much sense and causes build failures on parisc
1127 * architectures.
1128 */
1129 if (*tosec == '\0')
1130 return NULL;
1131
1132 for (i = 0; i < elems; i++) {
1133 if (match(fromsec, check->fromsec)) {
1134 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1135 return check;
1136 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1137 return check;
1138 }
1139 check++;
1140 }
1141 return NULL;
1142}
1143
1144/**
1145 * Whitelist to allow certain references to pass with no warning.
1146 *
1147 * Pattern 1:
1148 * If a module parameter is declared __initdata and permissions=0
1149 * then this is legal despite the warning generated.
1150 * We cannot see value of permissions here, so just ignore
1151 * this pattern.
1152 * The pattern is identified by:
1153 * tosec = .init.data
1154 * fromsec = .data*
1155 * atsym =__param*
1156 *
1157 * Pattern 1a:
1158 * module_param_call() ops can refer to __init set function if permissions=0
1159 * The pattern is identified by:
1160 * tosec = .init.text
1161 * fromsec = .data*
1162 * atsym = __param_ops_*
1163 *
1164 * Pattern 2:
1165 * Many drivers utilise a *driver container with references to
1166 * add, remove, probe functions etc.
1167 * the pattern is identified by:
1168 * tosec = init or exit section
1169 * fromsec = data section
1170 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1171 * *probe_one, *_console, *_timer
1172 *
1173 * Pattern 3:
1174 * Whitelist all references from .head.text to any init section
1175 *
1176 * Pattern 4:
1177 * Some symbols belong to init section but still it is ok to reference
1178 * these from non-init sections as these symbols don't have any memory
1179 * allocated for them and symbol address and value are same. So even
1180 * if init section is freed, its ok to reference those symbols.
1181 * For ex. symbols marking the init section boundaries.
1182 * This pattern is identified by
1183 * refsymname = __init_begin, _sinittext, _einittext
1184 *
1185 * Pattern 5:
1186 * GCC may optimize static inlines when fed constant arg(s) resulting
1187 * in functions like cpumask_empty() -- generating an associated symbol
1188 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1189 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1190 * meaningless section warning. May need to add isra symbols too...
1191 * This pattern is identified by
1192 * tosec = init section
1193 * fromsec = text section
1194 * refsymname = *.constprop.*
1195 *
1196 * Pattern 6:
1197 * Hide section mismatch warnings for ELF local symbols. The goal
1198 * is to eliminate false positive modpost warnings caused by
1199 * compiler-generated ELF local symbol names such as ".LANCHOR1".
1200 * Autogenerated symbol names bypass modpost's "Pattern 2"
1201 * whitelisting, which relies on pattern-matching against symbol
1202 * names to work. (One situation where gcc can autogenerate ELF
1203 * local symbols is when "-fsection-anchors" is used.)
1204 **/
1205static int secref_whitelist(const struct sectioncheck *mismatch,
1206 const char *fromsec, const char *fromsym,
1207 const char *tosec, const char *tosym)
1208{
1209 /* Check for pattern 1 */
1210 if (match(tosec, init_data_sections) &&
1211 match(fromsec, data_sections) &&
1212 strstarts(fromsym, "__param"))
1213 return 0;
1214
1215 /* Check for pattern 1a */
1216 if (strcmp(tosec, ".init.text") == 0 &&
1217 match(fromsec, data_sections) &&
1218 strstarts(fromsym, "__param_ops_"))
1219 return 0;
1220
1221 /* Check for pattern 2 */
1222 if (match(tosec, init_exit_sections) &&
1223 match(fromsec, data_sections) &&
1224 match(fromsym, mismatch->symbol_white_list))
1225 return 0;
1226
1227 /* Check for pattern 3 */
1228 if (match(fromsec, head_sections) &&
1229 match(tosec, init_sections))
1230 return 0;
1231
1232 /* Check for pattern 4 */
1233 if (match(tosym, linker_symbols))
1234 return 0;
1235
1236 /* Check for pattern 5 */
1237 if (match(fromsec, text_sections) &&
1238 match(tosec, init_sections) &&
1239 match(fromsym, optim_symbols))
1240 return 0;
1241
1242 /* Check for pattern 6 */
1243 if (strstarts(fromsym, ".L"))
1244 return 0;
1245
1246 return 1;
1247}
1248
1249static inline int is_arm_mapping_symbol(const char *str)
1250{
1251 return str[0] == '$' && strchr("axtd", str[1])
1252 && (str[2] == '\0' || str[2] == '.');
1253}
1254
1255/*
1256 * If there's no name there, ignore it; likewise, ignore it if it's
1257 * one of the magic symbols emitted used by current ARM tools.
1258 *
1259 * Otherwise if find_symbols_between() returns those symbols, they'll
1260 * fail the whitelist tests and cause lots of false alarms ... fixable
1261 * only by merging __exit and __init sections into __text, bloating
1262 * the kernel (which is especially evil on embedded platforms).
1263 */
1264static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1265{
1266 const char *name = elf->strtab + sym->st_name;
1267
1268 if (!name || !strlen(name))
1269 return 0;
1270 return !is_arm_mapping_symbol(name);
1271}
1272
1273/**
1274 * Find symbol based on relocation record info.
1275 * In some cases the symbol supplied is a valid symbol so
1276 * return refsym. If st_name != 0 we assume this is a valid symbol.
1277 * In other cases the symbol needs to be looked up in the symbol table
1278 * based on section and address.
1279 * **/
1280static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1281 Elf_Sym *relsym)
1282{
1283 Elf_Sym *sym;
1284 Elf_Sym *near = NULL;
1285 Elf64_Sword distance = 20;
1286 Elf64_Sword d;
1287 unsigned int relsym_secindex;
1288
1289 if (relsym->st_name != 0)
1290 return relsym;
1291
1292 relsym_secindex = get_secindex(elf, relsym);
1293 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1294 if (get_secindex(elf, sym) != relsym_secindex)
1295 continue;
1296 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1297 continue;
1298 if (!is_valid_name(elf, sym))
1299 continue;
1300 if (sym->st_value == addr)
1301 return sym;
1302 /* Find a symbol nearby - addr are maybe negative */
1303 d = sym->st_value - addr;
1304 if (d < 0)
1305 d = addr - sym->st_value;
1306 if (d < distance) {
1307 distance = d;
1308 near = sym;
1309 }
1310 }
1311 /* We need a close match */
1312 if (distance < 20)
1313 return near;
1314 else
1315 return NULL;
1316}
1317
1318/*
1319 * Find symbols before or equal addr and after addr - in the section sec.
1320 * If we find two symbols with equal offset prefer one with a valid name.
1321 * The ELF format may have a better way to detect what type of symbol
1322 * it is, but this works for now.
1323 **/
1324static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1325 const char *sec)
1326{
1327 Elf_Sym *sym;
1328 Elf_Sym *near = NULL;
1329 Elf_Addr distance = ~0;
1330
1331 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1332 const char *symsec;
1333
1334 if (is_shndx_special(sym->st_shndx))
1335 continue;
1336 symsec = sec_name(elf, get_secindex(elf, sym));
1337 if (strcmp(symsec, sec) != 0)
1338 continue;
1339 if (!is_valid_name(elf, sym))
1340 continue;
1341 if (sym->st_value <= addr) {
1342 if ((addr - sym->st_value) < distance) {
1343 distance = addr - sym->st_value;
1344 near = sym;
1345 } else if ((addr - sym->st_value) == distance) {
1346 near = sym;
1347 }
1348 }
1349 }
1350 return near;
1351}
1352
1353/*
1354 * Convert a section name to the function/data attribute
1355 * .init.text => __init
1356 * .memexitconst => __memconst
1357 * etc.
1358 *
1359 * The memory of returned value has been allocated on a heap. The user of this
1360 * method should free it after usage.
1361*/
1362static char *sec2annotation(const char *s)
1363{
1364 if (match(s, init_exit_sections)) {
1365 char *p = NOFAIL(malloc(20));
1366 char *r = p;
1367
1368 *p++ = '_';
1369 *p++ = '_';
1370 if (*s == '.')
1371 s++;
1372 while (*s && *s != '.')
1373 *p++ = *s++;
1374 *p = '\0';
1375 if (*s == '.')
1376 s++;
1377 if (strstr(s, "rodata") != NULL)
1378 strcat(p, "const ");
1379 else if (strstr(s, "data") != NULL)
1380 strcat(p, "data ");
1381 else
1382 strcat(p, " ");
1383 return r;
1384 } else {
1385 return NOFAIL(strdup(""));
1386 }
1387}
1388
1389static int is_function(Elf_Sym *sym)
1390{
1391 if (sym)
1392 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1393 else
1394 return -1;
1395}
1396
1397static void print_section_list(const char * const list[20])
1398{
1399 const char *const *s = list;
1400
1401 while (*s) {
1402 fprintf(stderr, "%s", *s);
1403 s++;
1404 if (*s)
1405 fprintf(stderr, ", ");
1406 }
1407 fprintf(stderr, "\n");
1408}
1409
1410static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1411{
1412 switch (is_func) {
1413 case 0: *name = "variable"; *name_p = ""; break;
1414 case 1: *name = "function"; *name_p = "()"; break;
1415 default: *name = "(unknown reference)"; *name_p = ""; break;
1416 }
1417}
1418
1419/*
1420 * Print a warning about a section mismatch.
1421 * Try to find symbols near it so user can find it.
1422 * Check whitelist before warning - it may be a false positive.
1423 */
1424static void report_sec_mismatch(const char *modname,
1425 const struct sectioncheck *mismatch,
1426 const char *fromsec,
1427 unsigned long long fromaddr,
1428 const char *fromsym,
1429 int from_is_func,
1430 const char *tosec, const char *tosym,
1431 int to_is_func)
1432{
1433 const char *from, *from_p;
1434 const char *to, *to_p;
1435 char *prl_from;
1436 char *prl_to;
1437
1438 sec_mismatch_count++;
1439
1440 get_pretty_name(from_is_func, &from, &from_p);
1441 get_pretty_name(to_is_func, &to, &to_p);
1442
1443 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1444 "to the %s %s:%s%s\n",
1445 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1446 tosym, to_p);
1447
1448 switch (mismatch->mismatch) {
1449 case TEXT_TO_ANY_INIT:
1450 prl_from = sec2annotation(fromsec);
1451 prl_to = sec2annotation(tosec);
1452 fprintf(stderr,
1453 "The function %s%s() references\n"
1454 "the %s %s%s%s.\n"
1455 "This is often because %s lacks a %s\n"
1456 "annotation or the annotation of %s is wrong.\n",
1457 prl_from, fromsym,
1458 to, prl_to, tosym, to_p,
1459 fromsym, prl_to, tosym);
1460 free(prl_from);
1461 free(prl_to);
1462 break;
1463 case DATA_TO_ANY_INIT: {
1464 prl_to = sec2annotation(tosec);
1465 fprintf(stderr,
1466 "The variable %s references\n"
1467 "the %s %s%s%s\n"
1468 "If the reference is valid then annotate the\n"
1469 "variable with __init* or __refdata (see linux/init.h) "
1470 "or name the variable:\n",
1471 fromsym, to, prl_to, tosym, to_p);
1472 print_section_list(mismatch->symbol_white_list);
1473 free(prl_to);
1474 break;
1475 }
1476 case TEXT_TO_ANY_EXIT:
1477 prl_to = sec2annotation(tosec);
1478 fprintf(stderr,
1479 "The function %s() references a %s in an exit section.\n"
1480 "Often the %s %s%s has valid usage outside the exit section\n"
1481 "and the fix is to remove the %sannotation of %s.\n",
1482 fromsym, to, to, tosym, to_p, prl_to, tosym);
1483 free(prl_to);
1484 break;
1485 case DATA_TO_ANY_EXIT: {
1486 prl_to = sec2annotation(tosec);
1487 fprintf(stderr,
1488 "The variable %s references\n"
1489 "the %s %s%s%s\n"
1490 "If the reference is valid then annotate the\n"
1491 "variable with __exit* (see linux/init.h) or "
1492 "name the variable:\n",
1493 fromsym, to, prl_to, tosym, to_p);
1494 print_section_list(mismatch->symbol_white_list);
1495 free(prl_to);
1496 break;
1497 }
1498 case XXXINIT_TO_SOME_INIT:
1499 case XXXEXIT_TO_SOME_EXIT:
1500 prl_from = sec2annotation(fromsec);
1501 prl_to = sec2annotation(tosec);
1502 fprintf(stderr,
1503 "The %s %s%s%s references\n"
1504 "a %s %s%s%s.\n"
1505 "If %s is only used by %s then\n"
1506 "annotate %s with a matching annotation.\n",
1507 from, prl_from, fromsym, from_p,
1508 to, prl_to, tosym, to_p,
1509 tosym, fromsym, tosym);
1510 free(prl_from);
1511 free(prl_to);
1512 break;
1513 case ANY_INIT_TO_ANY_EXIT:
1514 prl_from = sec2annotation(fromsec);
1515 prl_to = sec2annotation(tosec);
1516 fprintf(stderr,
1517 "The %s %s%s%s references\n"
1518 "a %s %s%s%s.\n"
1519 "This is often seen when error handling "
1520 "in the init function\n"
1521 "uses functionality in the exit path.\n"
1522 "The fix is often to remove the %sannotation of\n"
1523 "%s%s so it may be used outside an exit section.\n",
1524 from, prl_from, fromsym, from_p,
1525 to, prl_to, tosym, to_p,
1526 prl_to, tosym, to_p);
1527 free(prl_from);
1528 free(prl_to);
1529 break;
1530 case ANY_EXIT_TO_ANY_INIT:
1531 prl_from = sec2annotation(fromsec);
1532 prl_to = sec2annotation(tosec);
1533 fprintf(stderr,
1534 "The %s %s%s%s references\n"
1535 "a %s %s%s%s.\n"
1536 "This is often seen when error handling "
1537 "in the exit function\n"
1538 "uses functionality in the init path.\n"
1539 "The fix is often to remove the %sannotation of\n"
1540 "%s%s so it may be used outside an init section.\n",
1541 from, prl_from, fromsym, from_p,
1542 to, prl_to, tosym, to_p,
1543 prl_to, tosym, to_p);
1544 free(prl_from);
1545 free(prl_to);
1546 break;
1547 case EXPORT_TO_INIT_EXIT:
1548 prl_to = sec2annotation(tosec);
1549 fprintf(stderr,
1550 "The symbol %s is exported and annotated %s\n"
1551 "Fix this by removing the %sannotation of %s "
1552 "or drop the export.\n",
1553 tosym, prl_to, prl_to, tosym);
1554 free(prl_to);
1555 break;
1556 case EXTABLE_TO_NON_TEXT:
1557 fatal("There's a special handler for this mismatch type, "
1558 "we should never get here.");
1559 break;
1560 }
1561 fprintf(stderr, "\n");
1562}
1563
1564static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1565 const struct sectioncheck* const mismatch,
1566 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1567{
1568 const char *tosec;
1569 Elf_Sym *to;
1570 Elf_Sym *from;
1571 const char *tosym;
1572 const char *fromsym;
1573
1574 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1575 fromsym = sym_name(elf, from);
1576
1577 if (strstarts(fromsym, "reference___initcall"))
1578 return;
1579
1580 tosec = sec_name(elf, get_secindex(elf, sym));
1581 to = find_elf_symbol(elf, r->r_addend, sym);
1582 tosym = sym_name(elf, to);
1583
1584 /* check whitelist - we may ignore it */
1585 if (secref_whitelist(mismatch,
1586 fromsec, fromsym, tosec, tosym)) {
1587 report_sec_mismatch(modname, mismatch,
1588 fromsec, r->r_offset, fromsym,
1589 is_function(from), tosec, tosym,
1590 is_function(to));
1591 }
1592}
1593
1594static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1595{
1596 if (section_index > elf->num_sections)
1597 fatal("section_index is outside elf->num_sections!\n");
1598
1599 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1600}
1601
1602/*
1603 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1604 * to know the sizeof(struct exception_table_entry) for the target architecture.
1605 */
1606static unsigned int extable_entry_size = 0;
1607static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1608{
1609 /*
1610 * If we're currently checking the second relocation within __ex_table,
1611 * that relocation offset tells us the offsetof(struct
1612 * exception_table_entry, fixup) which is equal to sizeof(struct
1613 * exception_table_entry) divided by two. We use that to our advantage
1614 * since there's no portable way to get that size as every architecture
1615 * seems to go with different sized types. Not pretty but better than
1616 * hard-coding the size for every architecture..
1617 */
1618 if (!extable_entry_size)
1619 extable_entry_size = r->r_offset * 2;
1620}
1621
1622static inline bool is_extable_fault_address(Elf_Rela *r)
1623{
1624 /*
1625 * extable_entry_size is only discovered after we've handled the
1626 * _second_ relocation in __ex_table, so only abort when we're not
1627 * handling the first reloc and extable_entry_size is zero.
1628 */
1629 if (r->r_offset && extable_entry_size == 0)
1630 fatal("extable_entry size hasn't been discovered!\n");
1631
1632 return ((r->r_offset == 0) ||
1633 (r->r_offset % extable_entry_size == 0));
1634}
1635
1636#define is_second_extable_reloc(Start, Cur, Sec) \
1637 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1638
1639static void report_extable_warnings(const char* modname, struct elf_info* elf,
1640 const struct sectioncheck* const mismatch,
1641 Elf_Rela* r, Elf_Sym* sym,
1642 const char* fromsec, const char* tosec)
1643{
1644 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1645 const char* fromsym_name = sym_name(elf, fromsym);
1646 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1647 const char* tosym_name = sym_name(elf, tosym);
1648 const char* from_pretty_name;
1649 const char* from_pretty_name_p;
1650 const char* to_pretty_name;
1651 const char* to_pretty_name_p;
1652
1653 get_pretty_name(is_function(fromsym),
1654 &from_pretty_name, &from_pretty_name_p);
1655 get_pretty_name(is_function(tosym),
1656 &to_pretty_name, &to_pretty_name_p);
1657
1658 warn("%s(%s+0x%lx): Section mismatch in reference"
1659 " from the %s %s%s to the %s %s:%s%s\n",
1660 modname, fromsec, (long)r->r_offset, from_pretty_name,
1661 fromsym_name, from_pretty_name_p,
1662 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1663
1664 if (!match(tosec, mismatch->bad_tosec) &&
1665 is_executable_section(elf, get_secindex(elf, sym)))
1666 fprintf(stderr,
1667 "The relocation at %s+0x%lx references\n"
1668 "section \"%s\" which is not in the list of\n"
1669 "authorized sections. If you're adding a new section\n"
1670 "and/or if this reference is valid, add \"%s\" to the\n"
1671 "list of authorized sections to jump to on fault.\n"
1672 "This can be achieved by adding \"%s\" to \n"
1673 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1674 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1675}
1676
1677static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1678 const struct sectioncheck* const mismatch,
1679 Elf_Rela* r, Elf_Sym* sym,
1680 const char *fromsec)
1681{
1682 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1683
1684 sec_mismatch_count++;
1685
1686 report_extable_warnings(modname, elf, mismatch, r, sym, fromsec, tosec);
1687
1688 if (match(tosec, mismatch->bad_tosec))
1689 fatal("The relocation at %s+0x%lx references\n"
1690 "section \"%s\" which is black-listed.\n"
1691 "Something is seriously wrong and should be fixed.\n"
1692 "You might get more information about where this is\n"
1693 "coming from by using scripts/check_extable.sh %s\n",
1694 fromsec, (long)r->r_offset, tosec, modname);
1695 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1696 if (is_extable_fault_address(r))
1697 fatal("The relocation at %s+0x%lx references\n"
1698 "section \"%s\" which is not executable, IOW\n"
1699 "it is not possible for the kernel to fault\n"
1700 "at that address. Something is seriously wrong\n"
1701 "and should be fixed.\n",
1702 fromsec, (long)r->r_offset, tosec);
1703 else
1704 fatal("The relocation at %s+0x%lx references\n"
1705 "section \"%s\" which is not executable, IOW\n"
1706 "the kernel will fault if it ever tries to\n"
1707 "jump to it. Something is seriously wrong\n"
1708 "and should be fixed.\n",
1709 fromsec, (long)r->r_offset, tosec);
1710 }
1711}
1712
1713static void check_section_mismatch(const char *modname, struct elf_info *elf,
1714 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1715{
1716 const char *tosec = sec_name(elf, get_secindex(elf, sym));
1717 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1718
1719 if (mismatch) {
1720 if (mismatch->handler)
1721 mismatch->handler(modname, elf, mismatch,
1722 r, sym, fromsec);
1723 else
1724 default_mismatch_handler(modname, elf, mismatch,
1725 r, sym, fromsec);
1726 }
1727}
1728
1729static unsigned int *reloc_location(struct elf_info *elf,
1730 Elf_Shdr *sechdr, Elf_Rela *r)
1731{
1732 return sym_get_data_by_offset(elf, sechdr->sh_info, r->r_offset);
1733}
1734
1735static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1736{
1737 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1738 unsigned int *location = reloc_location(elf, sechdr, r);
1739
1740 switch (r_typ) {
1741 case R_386_32:
1742 r->r_addend = TO_NATIVE(*location);
1743 break;
1744 case R_386_PC32:
1745 r->r_addend = TO_NATIVE(*location) + 4;
1746 /* For CONFIG_RELOCATABLE=y */
1747 if (elf->hdr->e_type == ET_EXEC)
1748 r->r_addend += r->r_offset;
1749 break;
1750 }
1751 return 0;
1752}
1753
1754#ifndef R_ARM_CALL
1755#define R_ARM_CALL 28
1756#endif
1757#ifndef R_ARM_JUMP24
1758#define R_ARM_JUMP24 29
1759#endif
1760
1761#ifndef R_ARM_THM_CALL
1762#define R_ARM_THM_CALL 10
1763#endif
1764#ifndef R_ARM_THM_JUMP24
1765#define R_ARM_THM_JUMP24 30
1766#endif
1767#ifndef R_ARM_THM_JUMP19
1768#define R_ARM_THM_JUMP19 51
1769#endif
1770
1771static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1772{
1773 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1774
1775 switch (r_typ) {
1776 case R_ARM_ABS32:
1777 /* From ARM ABI: (S + A) | T */
1778 r->r_addend = (int)(long)
1779 (elf->symtab_start + ELF_R_SYM(r->r_info));
1780 break;
1781 case R_ARM_PC24:
1782 case R_ARM_CALL:
1783 case R_ARM_JUMP24:
1784 case R_ARM_THM_CALL:
1785 case R_ARM_THM_JUMP24:
1786 case R_ARM_THM_JUMP19:
1787 /* From ARM ABI: ((S + A) | T) - P */
1788 r->r_addend = (int)(long)(elf->hdr +
1789 sechdr->sh_offset +
1790 (r->r_offset - sechdr->sh_addr));
1791 break;
1792 default:
1793 return 1;
1794 }
1795 return 0;
1796}
1797
1798static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1799{
1800 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1801 unsigned int *location = reloc_location(elf, sechdr, r);
1802 unsigned int inst;
1803
1804 if (r_typ == R_MIPS_HI16)
1805 return 1; /* skip this */
1806 inst = TO_NATIVE(*location);
1807 switch (r_typ) {
1808 case R_MIPS_LO16:
1809 r->r_addend = inst & 0xffff;
1810 break;
1811 case R_MIPS_26:
1812 r->r_addend = (inst & 0x03ffffff) << 2;
1813 break;
1814 case R_MIPS_32:
1815 r->r_addend = inst;
1816 break;
1817 }
1818 return 0;
1819}
1820
1821static void section_rela(const char *modname, struct elf_info *elf,
1822 Elf_Shdr *sechdr)
1823{
1824 Elf_Sym *sym;
1825 Elf_Rela *rela;
1826 Elf_Rela r;
1827 unsigned int r_sym;
1828 const char *fromsec;
1829
1830 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1831 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1832
1833 fromsec = sech_name(elf, sechdr);
1834 fromsec += strlen(".rela");
1835 /* if from section (name) is know good then skip it */
1836 if (match(fromsec, section_white_list))
1837 return;
1838
1839 for (rela = start; rela < stop; rela++) {
1840 r.r_offset = TO_NATIVE(rela->r_offset);
1841#if KERNEL_ELFCLASS == ELFCLASS64
1842 if (elf->hdr->e_machine == EM_MIPS) {
1843 unsigned int r_typ;
1844 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1845 r_sym = TO_NATIVE(r_sym);
1846 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1847 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1848 } else {
1849 r.r_info = TO_NATIVE(rela->r_info);
1850 r_sym = ELF_R_SYM(r.r_info);
1851 }
1852#else
1853 r.r_info = TO_NATIVE(rela->r_info);
1854 r_sym = ELF_R_SYM(r.r_info);
1855#endif
1856 r.r_addend = TO_NATIVE(rela->r_addend);
1857 sym = elf->symtab_start + r_sym;
1858 /* Skip special sections */
1859 if (is_shndx_special(sym->st_shndx))
1860 continue;
1861 if (is_second_extable_reloc(start, rela, fromsec))
1862 find_extable_entry_size(fromsec, &r);
1863 check_section_mismatch(modname, elf, &r, sym, fromsec);
1864 }
1865}
1866
1867static void section_rel(const char *modname, struct elf_info *elf,
1868 Elf_Shdr *sechdr)
1869{
1870 Elf_Sym *sym;
1871 Elf_Rel *rel;
1872 Elf_Rela r;
1873 unsigned int r_sym;
1874 const char *fromsec;
1875
1876 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1877 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1878
1879 fromsec = sech_name(elf, sechdr);
1880 fromsec += strlen(".rel");
1881 /* if from section (name) is know good then skip it */
1882 if (match(fromsec, section_white_list))
1883 return;
1884
1885 for (rel = start; rel < stop; rel++) {
1886 r.r_offset = TO_NATIVE(rel->r_offset);
1887#if KERNEL_ELFCLASS == ELFCLASS64
1888 if (elf->hdr->e_machine == EM_MIPS) {
1889 unsigned int r_typ;
1890 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1891 r_sym = TO_NATIVE(r_sym);
1892 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1893 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1894 } else {
1895 r.r_info = TO_NATIVE(rel->r_info);
1896 r_sym = ELF_R_SYM(r.r_info);
1897 }
1898#else
1899 r.r_info = TO_NATIVE(rel->r_info);
1900 r_sym = ELF_R_SYM(r.r_info);
1901#endif
1902 r.r_addend = 0;
1903 switch (elf->hdr->e_machine) {
1904 case EM_386:
1905 if (addend_386_rel(elf, sechdr, &r))
1906 continue;
1907 break;
1908 case EM_ARM:
1909 if (addend_arm_rel(elf, sechdr, &r))
1910 continue;
1911 break;
1912 case EM_MIPS:
1913 if (addend_mips_rel(elf, sechdr, &r))
1914 continue;
1915 break;
1916 }
1917 sym = elf->symtab_start + r_sym;
1918 /* Skip special sections */
1919 if (is_shndx_special(sym->st_shndx))
1920 continue;
1921 if (is_second_extable_reloc(start, rel, fromsec))
1922 find_extable_entry_size(fromsec, &r);
1923 check_section_mismatch(modname, elf, &r, sym, fromsec);
1924 }
1925}
1926
1927/**
1928 * A module includes a number of sections that are discarded
1929 * either when loaded or when used as built-in.
1930 * For loaded modules all functions marked __init and all data
1931 * marked __initdata will be discarded when the module has been initialized.
1932 * Likewise for modules used built-in the sections marked __exit
1933 * are discarded because __exit marked function are supposed to be called
1934 * only when a module is unloaded which never happens for built-in modules.
1935 * The check_sec_ref() function traverses all relocation records
1936 * to find all references to a section that reference a section that will
1937 * be discarded and warns about it.
1938 **/
1939static void check_sec_ref(struct module *mod, const char *modname,
1940 struct elf_info *elf)
1941{
1942 int i;
1943 Elf_Shdr *sechdrs = elf->sechdrs;
1944
1945 /* Walk through all sections */
1946 for (i = 0; i < elf->num_sections; i++) {
1947 check_section(modname, elf, &elf->sechdrs[i]);
1948 /* We want to process only relocation sections and not .init */
1949 if (sechdrs[i].sh_type == SHT_RELA)
1950 section_rela(modname, elf, &elf->sechdrs[i]);
1951 else if (sechdrs[i].sh_type == SHT_REL)
1952 section_rel(modname, elf, &elf->sechdrs[i]);
1953 }
1954}
1955
1956static char *remove_dot(char *s)
1957{
1958 size_t n = strcspn(s, ".");
1959
1960 if (n && s[n]) {
1961 size_t m = strspn(s + n + 1, "0123456789");
1962 if (m && (s[n + m] == '.' || s[n + m] == 0))
1963 s[n] = 0;
1964
1965 /* strip trailing .lto */
1966 if (strends(s, ".lto"))
1967 s[strlen(s) - 4] = '\0';
1968 }
1969 return s;
1970}
1971
1972static void read_symbols(const char *modname)
1973{
1974 const char *symname;
1975 char *version;
1976 char *license;
1977 char *namespace;
1978 struct module *mod;
1979 struct elf_info info = { };
1980 Elf_Sym *sym;
1981
1982 if (!parse_elf(&info, modname))
1983 return;
1984
1985 {
1986 char *tmp;
1987
1988 /* strip trailing .o */
1989 tmp = NOFAIL(strdup(modname));
1990 tmp[strlen(tmp) - 2] = '\0';
1991 /* strip trailing .lto */
1992 if (strends(tmp, ".lto"))
1993 tmp[strlen(tmp) - 4] = '\0';
1994 mod = new_module(tmp);
1995 free(tmp);
1996 }
1997
1998 if (!mod->is_vmlinux) {
1999 license = get_modinfo(&info, "license");
2000 if (!license)
2001 error("missing MODULE_LICENSE() in %s\n", modname);
2002 while (license) {
2003 if (license_is_gpl_compatible(license))
2004 mod->gpl_compatible = 1;
2005 else {
2006 mod->gpl_compatible = 0;
2007 break;
2008 }
2009 license = get_next_modinfo(&info, "license", license);
2010 }
2011
2012 namespace = get_modinfo(&info, "import_ns");
2013 while (namespace) {
2014 add_namespace(&mod->imported_namespaces, namespace);
2015 namespace = get_next_modinfo(&info, "import_ns",
2016 namespace);
2017 }
2018 }
2019
2020 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2021 symname = remove_dot(info.strtab + sym->st_name);
2022
2023 handle_symbol(mod, &info, sym, symname);
2024 handle_moddevtable(mod, &info, sym, symname);
2025 }
2026
2027 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2028 symname = remove_dot(info.strtab + sym->st_name);
2029
2030 /* Apply symbol namespaces from __kstrtabns_<symbol> entries. */
2031 if (strstarts(symname, "__kstrtabns_"))
2032 sym_update_namespace(symname + strlen("__kstrtabns_"),
2033 namespace_from_kstrtabns(&info,
2034 sym));
2035
2036 if (strstarts(symname, "__crc_"))
2037 handle_modversion(mod, &info, sym,
2038 symname + strlen("__crc_"));
2039 }
2040
2041 // check for static EXPORT_SYMBOL_* functions && global vars
2042 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
2043 unsigned char bind = ELF_ST_BIND(sym->st_info);
2044
2045 if (bind == STB_GLOBAL || bind == STB_WEAK) {
2046 struct symbol *s =
2047 find_symbol(remove_dot(info.strtab +
2048 sym->st_name));
2049
2050 if (s)
2051 s->is_static = 0;
2052 }
2053 }
2054
2055 check_sec_ref(mod, modname, &info);
2056
2057 if (!mod->is_vmlinux) {
2058 version = get_modinfo(&info, "version");
2059 if (version || all_versions)
2060 get_src_version(modname, mod->srcversion,
2061 sizeof(mod->srcversion) - 1);
2062 }
2063
2064 parse_elf_finish(&info);
2065
2066 /* Our trick to get versioning for module struct etc. - it's
2067 * never passed as an argument to an exported function, so
2068 * the automatic versioning doesn't pick it up, but it's really
2069 * important anyhow */
2070 if (modversions)
2071 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
2072}
2073
2074static void read_symbols_from_files(const char *filename)
2075{
2076 FILE *in = stdin;
2077 char fname[PATH_MAX];
2078
2079 if (strcmp(filename, "-") != 0) {
2080 in = fopen(filename, "r");
2081 if (!in)
2082 fatal("Can't open filenames file %s: %m", filename);
2083 }
2084
2085 while (fgets(fname, PATH_MAX, in) != NULL) {
2086 if (strends(fname, "\n"))
2087 fname[strlen(fname)-1] = '\0';
2088 read_symbols(fname);
2089 }
2090
2091 if (in != stdin)
2092 fclose(in);
2093}
2094
2095#define SZ 500
2096
2097/* We first write the generated file into memory using the
2098 * following helper, then compare to the file on disk and
2099 * only update the later if anything changed */
2100
2101void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2102 const char *fmt, ...)
2103{
2104 char tmp[SZ];
2105 int len;
2106 va_list ap;
2107
2108 va_start(ap, fmt);
2109 len = vsnprintf(tmp, SZ, fmt, ap);
2110 buf_write(buf, tmp, len);
2111 va_end(ap);
2112}
2113
2114void buf_write(struct buffer *buf, const char *s, int len)
2115{
2116 if (buf->size - buf->pos < len) {
2117 buf->size += len + SZ;
2118 buf->p = NOFAIL(realloc(buf->p, buf->size));
2119 }
2120 strncpy(buf->p + buf->pos, s, len);
2121 buf->pos += len;
2122}
2123
2124static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2125{
2126 switch (exp) {
2127 case export_gpl:
2128 error("GPL-incompatible module %s.ko uses GPL-only symbol '%s'\n",
2129 m, s);
2130 break;
2131 case export_plain:
2132 case export_unknown:
2133 /* ignore */
2134 break;
2135 }
2136}
2137
2138static void check_exports(struct module *mod)
2139{
2140 struct symbol *s, *exp;
2141
2142 for (s = mod->unres; s; s = s->next) {
2143 const char *basename;
2144 exp = find_symbol(s->name);
2145 if (!exp || exp->module == mod) {
2146 if (!s->weak && nr_unresolved++ < MAX_UNRESOLVED_REPORTS)
2147 modpost_log(warn_unresolved ? LOG_WARN : LOG_ERROR,
2148 "\"%s\" [%s.ko] undefined!\n",
2149 s->name, mod->name);
2150 continue;
2151 }
2152 basename = strrchr(mod->name, '/');
2153 if (basename)
2154 basename++;
2155 else
2156 basename = mod->name;
2157
2158 if (exp->namespace &&
2159 !module_imports_namespace(mod, exp->namespace)) {
2160 modpost_log(allow_missing_ns_imports ? LOG_WARN : LOG_ERROR,
2161 "module %s uses symbol %s from namespace %s, but does not import it.\n",
2162 basename, exp->name, exp->namespace);
2163 add_namespace(&mod->missing_namespaces, exp->namespace);
2164 }
2165
2166 if (!mod->gpl_compatible)
2167 check_for_gpl_usage(exp->export, basename, exp->name);
2168 }
2169}
2170
2171static void check_modname_len(struct module *mod)
2172{
2173 const char *mod_name;
2174
2175 mod_name = strrchr(mod->name, '/');
2176 if (mod_name == NULL)
2177 mod_name = mod->name;
2178 else
2179 mod_name++;
2180 if (strlen(mod_name) >= MODULE_NAME_LEN)
2181 error("module name is too long [%s.ko]\n", mod->name);
2182}
2183
2184/**
2185 * Header for the generated file
2186 **/
2187static void add_header(struct buffer *b, struct module *mod)
2188{
2189 buf_printf(b, "#include <linux/module.h>\n");
2190 /*
2191 * Include build-salt.h after module.h in order to
2192 * inherit the definitions.
2193 */
2194 buf_printf(b, "#define INCLUDE_VERMAGIC\n");
2195 buf_printf(b, "#include <linux/build-salt.h>\n");
2196 buf_printf(b, "#include <linux/elfnote-lto.h>\n");
2197 buf_printf(b, "#include <linux/vermagic.h>\n");
2198 buf_printf(b, "#include <linux/compiler.h>\n");
2199 buf_printf(b, "\n");
2200 buf_printf(b, "BUILD_SALT;\n");
2201 buf_printf(b, "BUILD_LTO_INFO;\n");
2202 buf_printf(b, "\n");
2203 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2204 buf_printf(b, "MODULE_INFO(name, KBUILD_MODNAME);\n");
2205 buf_printf(b, "\n");
2206 buf_printf(b, "__visible struct module __this_module\n");
2207 buf_printf(b, "__section(\".gnu.linkonce.this_module\") = {\n");
2208 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2209 if (mod->has_init)
2210 buf_printf(b, "\t.init = init_module,\n");
2211 if (mod->has_cleanup)
2212 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2213 "\t.exit = cleanup_module,\n"
2214 "#endif\n");
2215 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2216 buf_printf(b, "};\n");
2217}
2218
2219static void add_intree_flag(struct buffer *b, int is_intree)
2220{
2221 if (is_intree)
2222 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2223}
2224
2225/* Cannot check for assembler */
2226static void add_retpoline(struct buffer *b)
2227{
2228 buf_printf(b, "\n#ifdef CONFIG_RETPOLINE\n");
2229 buf_printf(b, "MODULE_INFO(retpoline, \"Y\");\n");
2230 buf_printf(b, "#endif\n");
2231}
2232
2233static void add_staging_flag(struct buffer *b, const char *name)
2234{
2235 if (strstarts(name, "drivers/staging"))
2236 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2237}
2238
2239/**
2240 * Record CRCs for unresolved symbols
2241 **/
2242static void add_versions(struct buffer *b, struct module *mod)
2243{
2244 struct symbol *s, *exp;
2245
2246 for (s = mod->unres; s; s = s->next) {
2247 exp = find_symbol(s->name);
2248 if (!exp || exp->module == mod)
2249 continue;
2250 s->module = exp->module;
2251 s->crc_valid = exp->crc_valid;
2252 s->crc = exp->crc;
2253 }
2254
2255 if (!modversions)
2256 return;
2257
2258 buf_printf(b, "\n");
2259 buf_printf(b, "static const struct modversion_info ____versions[]\n");
2260 buf_printf(b, "__used __section(\"__versions\") = {\n");
2261
2262 for (s = mod->unres; s; s = s->next) {
2263 if (!s->module)
2264 continue;
2265 if (!s->crc_valid) {
2266 warn("\"%s\" [%s.ko] has no CRC!\n",
2267 s->name, mod->name);
2268 continue;
2269 }
2270 if (strlen(s->name) >= MODULE_NAME_LEN) {
2271 error("too long symbol \"%s\" [%s.ko]\n",
2272 s->name, mod->name);
2273 break;
2274 }
2275 buf_printf(b, "\t{ %#8x, \"%s\" },\n",
2276 s->crc, s->name);
2277 }
2278
2279 buf_printf(b, "};\n");
2280}
2281
2282static void add_depends(struct buffer *b, struct module *mod)
2283{
2284 struct symbol *s;
2285 int first = 1;
2286
2287 /* Clear ->seen flag of modules that own symbols needed by this. */
2288 for (s = mod->unres; s; s = s->next)
2289 if (s->module)
2290 s->module->seen = s->module->is_vmlinux;
2291
2292 buf_printf(b, "\n");
2293 buf_printf(b, "MODULE_INFO(depends, \"");
2294 for (s = mod->unres; s; s = s->next) {
2295 const char *p;
2296 if (!s->module)
2297 continue;
2298
2299 if (s->module->seen)
2300 continue;
2301
2302 s->module->seen = 1;
2303 p = strrchr(s->module->name, '/');
2304 if (p)
2305 p++;
2306 else
2307 p = s->module->name;
2308 buf_printf(b, "%s%s", first ? "" : ",", p);
2309 first = 0;
2310 }
2311 buf_printf(b, "\");\n");
2312}
2313
2314static void add_srcversion(struct buffer *b, struct module *mod)
2315{
2316 if (mod->srcversion[0]) {
2317 buf_printf(b, "\n");
2318 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2319 mod->srcversion);
2320 }
2321}
2322
2323static void write_buf(struct buffer *b, const char *fname)
2324{
2325 FILE *file;
2326
2327 file = fopen(fname, "w");
2328 if (!file) {
2329 perror(fname);
2330 exit(1);
2331 }
2332 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2333 perror(fname);
2334 exit(1);
2335 }
2336 if (fclose(file) != 0) {
2337 perror(fname);
2338 exit(1);
2339 }
2340}
2341
2342static void write_if_changed(struct buffer *b, const char *fname)
2343{
2344 char *tmp;
2345 FILE *file;
2346 struct stat st;
2347
2348 file = fopen(fname, "r");
2349 if (!file)
2350 goto write;
2351
2352 if (fstat(fileno(file), &st) < 0)
2353 goto close_write;
2354
2355 if (st.st_size != b->pos)
2356 goto close_write;
2357
2358 tmp = NOFAIL(malloc(b->pos));
2359 if (fread(tmp, 1, b->pos, file) != b->pos)
2360 goto free_write;
2361
2362 if (memcmp(tmp, b->p, b->pos) != 0)
2363 goto free_write;
2364
2365 free(tmp);
2366 fclose(file);
2367 return;
2368
2369 free_write:
2370 free(tmp);
2371 close_write:
2372 fclose(file);
2373 write:
2374 write_buf(b, fname);
2375}
2376
2377/* parse Module.symvers file. line format:
2378 * 0x12345678<tab>symbol<tab>module<tab>export<tab>namespace
2379 **/
2380static void read_dump(const char *fname)
2381{
2382 char *buf, *pos, *line;
2383
2384 buf = read_text_file(fname);
2385 if (!buf)
2386 /* No symbol versions, silently ignore */
2387 return;
2388
2389 pos = buf;
2390
2391 while ((line = get_line(&pos))) {
2392 char *symname, *namespace, *modname, *d, *export;
2393 unsigned int crc;
2394 struct module *mod;
2395 struct symbol *s;
2396
2397 if (!(symname = strchr(line, '\t')))
2398 goto fail;
2399 *symname++ = '\0';
2400 if (!(modname = strchr(symname, '\t')))
2401 goto fail;
2402 *modname++ = '\0';
2403 if (!(export = strchr(modname, '\t')))
2404 goto fail;
2405 *export++ = '\0';
2406 if (!(namespace = strchr(export, '\t')))
2407 goto fail;
2408 *namespace++ = '\0';
2409
2410 crc = strtoul(line, &d, 16);
2411 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2412 goto fail;
2413 mod = find_module(modname);
2414 if (!mod) {
2415 mod = new_module(modname);
2416 mod->from_dump = 1;
2417 }
2418 s = sym_add_exported(symname, mod, export_no(export));
2419 s->is_static = 0;
2420 sym_set_crc(symname, crc);
2421 sym_update_namespace(symname, namespace);
2422 }
2423 free(buf);
2424 return;
2425fail:
2426 free(buf);
2427 fatal("parse error in symbol dump file\n");
2428}
2429
2430static void write_dump(const char *fname)
2431{
2432 struct buffer buf = { };
2433 struct symbol *symbol;
2434 const char *namespace;
2435 int n;
2436
2437 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2438 symbol = symbolhash[n];
2439 while (symbol) {
2440 if (!symbol->module->from_dump) {
2441 namespace = symbol->namespace;
2442 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\t%s\n",
2443 symbol->crc, symbol->name,
2444 symbol->module->name,
2445 export_str(symbol->export),
2446 namespace ? namespace : "");
2447 }
2448 symbol = symbol->next;
2449 }
2450 }
2451 write_buf(&buf, fname);
2452 free(buf.p);
2453}
2454
2455static void write_namespace_deps_files(const char *fname)
2456{
2457 struct module *mod;
2458 struct namespace_list *ns;
2459 struct buffer ns_deps_buf = {};
2460
2461 for (mod = modules; mod; mod = mod->next) {
2462
2463 if (mod->from_dump || !mod->missing_namespaces)
2464 continue;
2465
2466 buf_printf(&ns_deps_buf, "%s.ko:", mod->name);
2467
2468 for (ns = mod->missing_namespaces; ns; ns = ns->next)
2469 buf_printf(&ns_deps_buf, " %s", ns->namespace);
2470
2471 buf_printf(&ns_deps_buf, "\n");
2472 }
2473
2474 write_if_changed(&ns_deps_buf, fname);
2475 free(ns_deps_buf.p);
2476}
2477
2478struct dump_list {
2479 struct dump_list *next;
2480 const char *file;
2481};
2482
2483int main(int argc, char **argv)
2484{
2485 struct module *mod;
2486 struct buffer buf = { };
2487 char *missing_namespace_deps = NULL;
2488 char *dump_write = NULL, *files_source = NULL;
2489 int opt;
2490 int n;
2491 struct dump_list *dump_read_start = NULL;
2492 struct dump_list **dump_read_iter = &dump_read_start;
2493
2494 while ((opt = getopt(argc, argv, "ei:mnT:o:awENd:")) != -1) {
2495 switch (opt) {
2496 case 'e':
2497 external_module = 1;
2498 break;
2499 case 'i':
2500 *dump_read_iter =
2501 NOFAIL(calloc(1, sizeof(**dump_read_iter)));
2502 (*dump_read_iter)->file = optarg;
2503 dump_read_iter = &(*dump_read_iter)->next;
2504 break;
2505 case 'm':
2506 modversions = 1;
2507 break;
2508 case 'n':
2509 ignore_missing_files = 1;
2510 break;
2511 case 'o':
2512 dump_write = optarg;
2513 break;
2514 case 'a':
2515 all_versions = 1;
2516 break;
2517 case 'T':
2518 files_source = optarg;
2519 break;
2520 case 'w':
2521 warn_unresolved = 1;
2522 break;
2523 case 'E':
2524 sec_mismatch_warn_only = false;
2525 break;
2526 case 'N':
2527 allow_missing_ns_imports = 1;
2528 break;
2529 case 'd':
2530 missing_namespace_deps = optarg;
2531 break;
2532 default:
2533 exit(1);
2534 }
2535 }
2536
2537 while (dump_read_start) {
2538 struct dump_list *tmp;
2539
2540 read_dump(dump_read_start->file);
2541 tmp = dump_read_start->next;
2542 free(dump_read_start);
2543 dump_read_start = tmp;
2544 }
2545
2546 while (optind < argc)
2547 read_symbols(argv[optind++]);
2548
2549 if (files_source)
2550 read_symbols_from_files(files_source);
2551
2552 for (mod = modules; mod; mod = mod->next) {
2553 char fname[PATH_MAX];
2554
2555 if (mod->is_vmlinux || mod->from_dump)
2556 continue;
2557
2558 buf.pos = 0;
2559
2560 check_modname_len(mod);
2561 check_exports(mod);
2562
2563 add_header(&buf, mod);
2564 add_intree_flag(&buf, !external_module);
2565 add_retpoline(&buf);
2566 add_staging_flag(&buf, mod->name);
2567 add_versions(&buf, mod);
2568 add_depends(&buf, mod);
2569 add_moddevtable(&buf, mod);
2570 add_srcversion(&buf, mod);
2571
2572 sprintf(fname, "%s.mod.c", mod->name);
2573 write_if_changed(&buf, fname);
2574 }
2575
2576 if (missing_namespace_deps)
2577 write_namespace_deps_files(missing_namespace_deps);
2578
2579 if (dump_write)
2580 write_dump(dump_write);
2581 if (sec_mismatch_count && !sec_mismatch_warn_only)
2582 error("Section mismatches detected.\n"
2583 "Set CONFIG_SECTION_MISMATCH_WARN_ONLY=y to allow them.\n");
2584 for (n = 0; n < SYMBOL_HASH_SIZE; n++) {
2585 struct symbol *s;
2586
2587 for (s = symbolhash[n]; s; s = s->next) {
2588 if (s->is_static)
2589 error("\"%s\" [%s] is a static %s\n",
2590 s->name, s->module->name,
2591 export_str(s->export));
2592 }
2593 }
2594
2595 if (nr_unresolved > MAX_UNRESOLVED_REPORTS)
2596 warn("suppressed %u unresolved symbol warnings because there were too many)\n",
2597 nr_unresolved - MAX_UNRESOLVED_REPORTS);
2598
2599 free(buf.p);
2600
2601 return error_occurred ? 1 : 0;
2602}