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