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