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