projects/linux·blob v6.4 · refs

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