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