projects/linux·blob v5.15 · refs

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