?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.2.6
[linux/fpc-iii.git] / scripts / mod / modpost.c
blob12d3db3bd46b491542090cd2db01637754467e99
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 ".coldtext"
891
892 #define INIT_SECTIONS ".init.*"
893 #define MEM_INIT_SECTIONS ".meminit.*"
894
895 #define EXIT_SECTIONS ".exit.*"
896 #define MEM_EXIT_SECTIONS ".memexit.*"
897
898 #define ALL_TEXT_SECTIONS ALL_INIT_TEXT_SECTIONS, ALL_EXIT_TEXT_SECTIONS, \
899 TEXT_SECTIONS, OTHER_TEXT_SECTIONS
900
901 /* init data sections */
902 static const char *const init_data_sections[] =
903 { ALL_INIT_DATA_SECTIONS, NULL };
904
905 /* all init sections */
906 static const char *const init_sections[] = { ALL_INIT_SECTIONS, NULL };
907
908 /* All init and exit sections (code + data) */
909 static const char *const init_exit_sections[] =
910 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
911
912 /* all text sections */
913 static const char *const text_sections[] = { ALL_TEXT_SECTIONS, NULL };
914
915 /* data section */
916 static const char *const data_sections[] = { DATA_SECTIONS, NULL };
917
918
919 /* symbols in .data that may refer to init/exit sections */
920 #define DEFAULT_SYMBOL_WHITE_LIST \
921 "*driver", \
922 "*_template", /* scsi uses *_template a lot */ \
923 "*_timer", /* arm uses ops structures named _timer a lot */ \
924 "*_sht", /* scsi also used *_sht to some extent */ \
925 "*_ops", \
926 "*_probe", \
927 "*_probe_one", \
928 "*_console"
929
930 static const char *const head_sections[] = { ".head.text*", NULL };
931 static const char *const linker_symbols[] =
932 { "__init_begin", "_sinittext", "_einittext", NULL };
933 static const char *const optim_symbols[] = { "*.constprop.*", NULL };
934
935 enum mismatch {
936 TEXT_TO_ANY_INIT,
937 DATA_TO_ANY_INIT,
938 TEXT_TO_ANY_EXIT,
939 DATA_TO_ANY_EXIT,
940 XXXINIT_TO_SOME_INIT,
941 XXXEXIT_TO_SOME_EXIT,
942 ANY_INIT_TO_ANY_EXIT,
943 ANY_EXIT_TO_ANY_INIT,
944 EXPORT_TO_INIT_EXIT,
945 EXTABLE_TO_NON_TEXT,
946 };
947
948 /**
949 * Describe how to match sections on different criterias:
950 *
951 * @fromsec: Array of sections to be matched.
952 *
953 * @bad_tosec: Relocations applied to a section in @fromsec to a section in
954 * this array is forbidden (black-list). Can be empty.
955 *
956 * @good_tosec: Relocations applied to a section in @fromsec must be
957 * targetting sections in this array (white-list). Can be empty.
958 *
959 * @mismatch: Type of mismatch.
960 *
961 * @symbol_white_list: Do not match a relocation to a symbol in this list
962 * even if it is targetting a section in @bad_to_sec.
963 *
964 * @handler: Specific handler to call when a match is found. If NULL,
965 * default_mismatch_handler() will be called.
966 *
967 */
968 struct sectioncheck {
969 const char *fromsec[20];
970 const char *bad_tosec[20];
971 const char *good_tosec[20];
972 enum mismatch mismatch;
973 const char *symbol_white_list[20];
974 void (*handler)(const char *modname, struct elf_info *elf,
975 const struct sectioncheck* const mismatch,
976 Elf_Rela *r, Elf_Sym *sym, const char *fromsec);
977
978 };
979
980 static void extable_mismatch_handler(const char *modname, struct elf_info *elf,
981 const struct sectioncheck* const mismatch,
982 Elf_Rela *r, Elf_Sym *sym,
983 const char *fromsec);
984
985 static const struct sectioncheck sectioncheck[] = {
986 /* Do not reference init/exit code/data from
987 * normal code and data
988 */
989 {
990 .fromsec = { TEXT_SECTIONS, NULL },
991 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
992 .mismatch = TEXT_TO_ANY_INIT,
993 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
994 },
995 {
996 .fromsec = { DATA_SECTIONS, NULL },
997 .bad_tosec = { ALL_XXXINIT_SECTIONS, NULL },
998 .mismatch = DATA_TO_ANY_INIT,
999 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1000 },
1001 {
1002 .fromsec = { DATA_SECTIONS, NULL },
1003 .bad_tosec = { INIT_SECTIONS, NULL },
1004 .mismatch = DATA_TO_ANY_INIT,
1005 .symbol_white_list = {
1006 "*_template", "*_timer", "*_sht", "*_ops",
1007 "*_probe", "*_probe_one", "*_console", NULL
1008 },
1009 },
1010 {
1011 .fromsec = { TEXT_SECTIONS, NULL },
1012 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1013 .mismatch = TEXT_TO_ANY_EXIT,
1014 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1015 },
1016 {
1017 .fromsec = { DATA_SECTIONS, NULL },
1018 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1019 .mismatch = DATA_TO_ANY_EXIT,
1020 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1021 },
1022 /* Do not reference init code/data from meminit code/data */
1023 {
1024 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
1025 .bad_tosec = { INIT_SECTIONS, NULL },
1026 .mismatch = XXXINIT_TO_SOME_INIT,
1027 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1028 },
1029 /* Do not reference exit code/data from memexit code/data */
1030 {
1031 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
1032 .bad_tosec = { EXIT_SECTIONS, NULL },
1033 .mismatch = XXXEXIT_TO_SOME_EXIT,
1034 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1035 },
1036 /* Do not use exit code/data from init code */
1037 {
1038 .fromsec = { ALL_INIT_SECTIONS, NULL },
1039 .bad_tosec = { ALL_EXIT_SECTIONS, NULL },
1040 .mismatch = ANY_INIT_TO_ANY_EXIT,
1041 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1042 },
1043 /* Do not use init code/data from exit code */
1044 {
1045 .fromsec = { ALL_EXIT_SECTIONS, NULL },
1046 .bad_tosec = { ALL_INIT_SECTIONS, NULL },
1047 .mismatch = ANY_EXIT_TO_ANY_INIT,
1048 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1049 },
1050 {
1051 .fromsec = { ALL_PCI_INIT_SECTIONS, NULL },
1052 .bad_tosec = { INIT_SECTIONS, NULL },
1053 .mismatch = ANY_INIT_TO_ANY_EXIT,
1054 .symbol_white_list = { NULL },
1055 },
1056 /* Do not export init/exit functions or data */
1057 {
1058 .fromsec = { "__ksymtab*", NULL },
1059 .bad_tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1060 .mismatch = EXPORT_TO_INIT_EXIT,
1061 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1062 },
1063 {
1064 .fromsec = { "__ex_table", NULL },
1065 /* If you're adding any new black-listed sections in here, consider
1066 * adding a special 'printer' for them in scripts/check_extable.
1067 */
1068 .bad_tosec = { ".altinstr_replacement", NULL },
1069 .good_tosec = {ALL_TEXT_SECTIONS , NULL},
1070 .mismatch = EXTABLE_TO_NON_TEXT,
1071 .handler = extable_mismatch_handler,
1072 }
1073 };
1074
1075 static const struct sectioncheck *section_mismatch(
1076 const char *fromsec, const char *tosec)
1077 {
1078 int i;
1079 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1080 const struct sectioncheck *check = &sectioncheck[0];
1081
1082 /*
1083 * The target section could be the SHT_NUL section when we're
1084 * handling relocations to un-resolved symbols, trying to match it
1085 * doesn't make much sense and causes build failures on parisc and
1086 * mn10300 architectures.
1087 */
1088 if (*tosec == '\0')
1089 return NULL;
1090
1091 for (i = 0; i < elems; i++) {
1092 if (match(fromsec, check->fromsec)) {
1093 if (check->bad_tosec[0] && match(tosec, check->bad_tosec))
1094 return check;
1095 if (check->good_tosec[0] && !match(tosec, check->good_tosec))
1096 return check;
1097 }
1098 check++;
1099 }
1100 return NULL;
1101 }
1102
1103 /**
1104 * Whitelist to allow certain references to pass with no warning.
1105 *
1106 * Pattern 1:
1107 * If a module parameter is declared __initdata and permissions=0
1108 * then this is legal despite the warning generated.
1109 * We cannot see value of permissions here, so just ignore
1110 * this pattern.
1111 * The pattern is identified by:
1112 * tosec = .init.data
1113 * fromsec = .data*
1114 * atsym =__param*
1115 *
1116 * Pattern 1a:
1117 * module_param_call() ops can refer to __init set function if permissions=0
1118 * The pattern is identified by:
1119 * tosec = .init.text
1120 * fromsec = .data*
1121 * atsym = __param_ops_*
1122 *
1123 * Pattern 2:
1124 * Many drivers utilise a *driver container with references to
1125 * add, remove, probe functions etc.
1126 * the pattern is identified by:
1127 * tosec = init or exit section
1128 * fromsec = data section
1129 * atsym = *driver, *_template, *_sht, *_ops, *_probe,
1130 * *probe_one, *_console, *_timer
1131 *
1132 * Pattern 3:
1133 * Whitelist all references from .head.text to any init section
1134 *
1135 * Pattern 4:
1136 * Some symbols belong to init section but still it is ok to reference
1137 * these from non-init sections as these symbols don't have any memory
1138 * allocated for them and symbol address and value are same. So even
1139 * if init section is freed, its ok to reference those symbols.
1140 * For ex. symbols marking the init section boundaries.
1141 * This pattern is identified by
1142 * refsymname = __init_begin, _sinittext, _einittext
1143 *
1144 * Pattern 5:
1145 * GCC may optimize static inlines when fed constant arg(s) resulting
1146 * in functions like cpumask_empty() -- generating an associated symbol
1147 * cpumask_empty.constprop.3 that appears in the audit. If the const that
1148 * is passed in comes from __init, like say nmi_ipi_mask, we get a
1149 * meaningless section warning. May need to add isra symbols too...
1150 * This pattern is identified by
1151 * tosec = init section
1152 * fromsec = text section
1153 * refsymname = *.constprop.*
1154 *
1155 **/
1156 static int secref_whitelist(const struct sectioncheck *mismatch,
1157 const char *fromsec, const char *fromsym,
1158 const char *tosec, const char *tosym)
1159 {
1160 /* Check for pattern 1 */
1161 if (match(tosec, init_data_sections) &&
1162 match(fromsec, data_sections) &&
1163 (strncmp(fromsym, "__param", strlen("__param")) == 0))
1164 return 0;
1165
1166 /* Check for pattern 1a */
1167 if (strcmp(tosec, ".init.text") == 0 &&
1168 match(fromsec, data_sections) &&
1169 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1170 return 0;
1171
1172 /* Check for pattern 2 */
1173 if (match(tosec, init_exit_sections) &&
1174 match(fromsec, data_sections) &&
1175 match(fromsym, mismatch->symbol_white_list))
1176 return 0;
1177
1178 /* Check for pattern 3 */
1179 if (match(fromsec, head_sections) &&
1180 match(tosec, init_sections))
1181 return 0;
1182
1183 /* Check for pattern 4 */
1184 if (match(tosym, linker_symbols))
1185 return 0;
1186
1187 /* Check for pattern 5 */
1188 if (match(fromsec, text_sections) &&
1189 match(tosec, init_sections) &&
1190 match(fromsym, optim_symbols))
1191 return 0;
1192
1193 return 1;
1194 }
1195
1196 /**
1197 * Find symbol based on relocation record info.
1198 * In some cases the symbol supplied is a valid symbol so
1199 * return refsym. If st_name != 0 we assume this is a valid symbol.
1200 * In other cases the symbol needs to be looked up in the symbol table
1201 * based on section and address.
1202 * **/
1203 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1204 Elf_Sym *relsym)
1205 {
1206 Elf_Sym *sym;
1207 Elf_Sym *near = NULL;
1208 Elf64_Sword distance = 20;
1209 Elf64_Sword d;
1210 unsigned int relsym_secindex;
1211
1212 if (relsym->st_name != 0)
1213 return relsym;
1214
1215 relsym_secindex = get_secindex(elf, relsym);
1216 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1217 if (get_secindex(elf, sym) != relsym_secindex)
1218 continue;
1219 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1220 continue;
1221 if (sym->st_value == addr)
1222 return sym;
1223 /* Find a symbol nearby - addr are maybe negative */
1224 d = sym->st_value - addr;
1225 if (d < 0)
1226 d = addr - sym->st_value;
1227 if (d < distance) {
1228 distance = d;
1229 near = sym;
1230 }
1231 }
1232 /* We need a close match */
1233 if (distance < 20)
1234 return near;
1235 else
1236 return NULL;
1237 }
1238
1239 static inline int is_arm_mapping_symbol(const char *str)
1240 {
1241 return str[0] == '$' && strchr("axtd", str[1])
1242 && (str[2] == '\0' || str[2] == '.');
1243 }
1244
1245 /*
1246 * If there's no name there, ignore it; likewise, ignore it if it's
1247 * one of the magic symbols emitted used by current ARM tools.
1248 *
1249 * Otherwise if find_symbols_between() returns those symbols, they'll
1250 * fail the whitelist tests and cause lots of false alarms ... fixable
1251 * only by merging __exit and __init sections into __text, bloating
1252 * the kernel (which is especially evil on embedded platforms).
1253 */
1254 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1255 {
1256 const char *name = elf->strtab + sym->st_name;
1257
1258 if (!name || !strlen(name))
1259 return 0;
1260 return !is_arm_mapping_symbol(name);
1261 }
1262
1263 /*
1264 * Find symbols before or equal addr and after addr - in the section sec.
1265 * If we find two symbols with equal offset prefer one with a valid name.
1266 * The ELF format may have a better way to detect what type of symbol
1267 * it is, but this works for now.
1268 **/
1269 static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1270 const char *sec)
1271 {
1272 Elf_Sym *sym;
1273 Elf_Sym *near = NULL;
1274 Elf_Addr distance = ~0;
1275
1276 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1277 const char *symsec;
1278
1279 if (is_shndx_special(sym->st_shndx))
1280 continue;
1281 symsec = sec_name(elf, get_secindex(elf, sym));
1282 if (strcmp(symsec, sec) != 0)
1283 continue;
1284 if (!is_valid_name(elf, sym))
1285 continue;
1286 if (sym->st_value <= addr) {
1287 if ((addr - sym->st_value) < distance) {
1288 distance = addr - sym->st_value;
1289 near = sym;
1290 } else if ((addr - sym->st_value) == distance) {
1291 near = sym;
1292 }
1293 }
1294 }
1295 return near;
1296 }
1297
1298 /*
1299 * Convert a section name to the function/data attribute
1300 * .init.text => __init
1301 * .memexitconst => __memconst
1302 * etc.
1303 *
1304 * The memory of returned value has been allocated on a heap. The user of this
1305 * method should free it after usage.
1306 */
1307 static char *sec2annotation(const char *s)
1308 {
1309 if (match(s, init_exit_sections)) {
1310 char *p = malloc(20);
1311 char *r = p;
1312
1313 *p++ = '_';
1314 *p++ = '_';
1315 if (*s == '.')
1316 s++;
1317 while (*s && *s != '.')
1318 *p++ = *s++;
1319 *p = '\0';
1320 if (*s == '.')
1321 s++;
1322 if (strstr(s, "rodata") != NULL)
1323 strcat(p, "const ");
1324 else if (strstr(s, "data") != NULL)
1325 strcat(p, "data ");
1326 else
1327 strcat(p, " ");
1328 return r;
1329 } else {
1330 return strdup("");
1331 }
1332 }
1333
1334 static int is_function(Elf_Sym *sym)
1335 {
1336 if (sym)
1337 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1338 else
1339 return -1;
1340 }
1341
1342 static void print_section_list(const char * const list[20])
1343 {
1344 const char *const *s = list;
1345
1346 while (*s) {
1347 fprintf(stderr, "%s", *s);
1348 s++;
1349 if (*s)
1350 fprintf(stderr, ", ");
1351 }
1352 fprintf(stderr, "\n");
1353 }
1354
1355 static inline void get_pretty_name(int is_func, const char** name, const char** name_p)
1356 {
1357 switch (is_func) {
1358 case 0: *name = "variable"; *name_p = ""; break;
1359 case 1: *name = "function"; *name_p = "()"; break;
1360 default: *name = "(unknown reference)"; *name_p = ""; break;
1361 }
1362 }
1363
1364 /*
1365 * Print a warning about a section mismatch.
1366 * Try to find symbols near it so user can find it.
1367 * Check whitelist before warning - it may be a false positive.
1368 */
1369 static void report_sec_mismatch(const char *modname,
1370 const struct sectioncheck *mismatch,
1371 const char *fromsec,
1372 unsigned long long fromaddr,
1373 const char *fromsym,
1374 int from_is_func,
1375 const char *tosec, const char *tosym,
1376 int to_is_func)
1377 {
1378 const char *from, *from_p;
1379 const char *to, *to_p;
1380 char *prl_from;
1381 char *prl_to;
1382
1383 sec_mismatch_count++;
1384 if (!sec_mismatch_verbose)
1385 return;
1386
1387 get_pretty_name(from_is_func, &from, &from_p);
1388 get_pretty_name(to_is_func, &to, &to_p);
1389
1390 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1391 "to the %s %s:%s%s\n",
1392 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1393 tosym, to_p);
1394
1395 switch (mismatch->mismatch) {
1396 case TEXT_TO_ANY_INIT:
1397 prl_from = sec2annotation(fromsec);
1398 prl_to = sec2annotation(tosec);
1399 fprintf(stderr,
1400 "The function %s%s() references\n"
1401 "the %s %s%s%s.\n"
1402 "This is often because %s lacks a %s\n"
1403 "annotation or the annotation of %s is wrong.\n",
1404 prl_from, fromsym,
1405 to, prl_to, tosym, to_p,
1406 fromsym, prl_to, tosym);
1407 free(prl_from);
1408 free(prl_to);
1409 break;
1410 case DATA_TO_ANY_INIT: {
1411 prl_to = sec2annotation(tosec);
1412 fprintf(stderr,
1413 "The variable %s references\n"
1414 "the %s %s%s%s\n"
1415 "If the reference is valid then annotate the\n"
1416 "variable with __init* or __refdata (see linux/init.h) "
1417 "or name the variable:\n",
1418 fromsym, to, prl_to, tosym, to_p);
1419 print_section_list(mismatch->symbol_white_list);
1420 free(prl_to);
1421 break;
1422 }
1423 case TEXT_TO_ANY_EXIT:
1424 prl_to = sec2annotation(tosec);
1425 fprintf(stderr,
1426 "The function %s() references a %s in an exit section.\n"
1427 "Often the %s %s%s has valid usage outside the exit section\n"
1428 "and the fix is to remove the %sannotation of %s.\n",
1429 fromsym, to, to, tosym, to_p, prl_to, tosym);
1430 free(prl_to);
1431 break;
1432 case DATA_TO_ANY_EXIT: {
1433 prl_to = sec2annotation(tosec);
1434 fprintf(stderr,
1435 "The variable %s references\n"
1436 "the %s %s%s%s\n"
1437 "If the reference is valid then annotate the\n"
1438 "variable with __exit* (see linux/init.h) or "
1439 "name the variable:\n",
1440 fromsym, to, prl_to, tosym, to_p);
1441 print_section_list(mismatch->symbol_white_list);
1442 free(prl_to);
1443 break;
1444 }
1445 case XXXINIT_TO_SOME_INIT:
1446 case XXXEXIT_TO_SOME_EXIT:
1447 prl_from = sec2annotation(fromsec);
1448 prl_to = sec2annotation(tosec);
1449 fprintf(stderr,
1450 "The %s %s%s%s references\n"
1451 "a %s %s%s%s.\n"
1452 "If %s is only used by %s then\n"
1453 "annotate %s with a matching annotation.\n",
1454 from, prl_from, fromsym, from_p,
1455 to, prl_to, tosym, to_p,
1456 tosym, fromsym, tosym);
1457 free(prl_from);
1458 free(prl_to);
1459 break;
1460 case ANY_INIT_TO_ANY_EXIT:
1461 prl_from = sec2annotation(fromsec);
1462 prl_to = sec2annotation(tosec);
1463 fprintf(stderr,
1464 "The %s %s%s%s references\n"
1465 "a %s %s%s%s.\n"
1466 "This is often seen when error handling "
1467 "in the init function\n"
1468 "uses functionality in the exit path.\n"
1469 "The fix is often to remove the %sannotation of\n"
1470 "%s%s so it may be used outside an exit section.\n",
1471 from, prl_from, fromsym, from_p,
1472 to, prl_to, tosym, to_p,
1473 prl_to, tosym, to_p);
1474 free(prl_from);
1475 free(prl_to);
1476 break;
1477 case ANY_EXIT_TO_ANY_INIT:
1478 prl_from = sec2annotation(fromsec);
1479 prl_to = sec2annotation(tosec);
1480 fprintf(stderr,
1481 "The %s %s%s%s references\n"
1482 "a %s %s%s%s.\n"
1483 "This is often seen when error handling "
1484 "in the exit function\n"
1485 "uses functionality in the init path.\n"
1486 "The fix is often to remove the %sannotation of\n"
1487 "%s%s so it may be used outside an init section.\n",
1488 from, prl_from, fromsym, from_p,
1489 to, prl_to, tosym, to_p,
1490 prl_to, tosym, to_p);
1491 free(prl_from);
1492 free(prl_to);
1493 break;
1494 case EXPORT_TO_INIT_EXIT:
1495 prl_to = sec2annotation(tosec);
1496 fprintf(stderr,
1497 "The symbol %s is exported and annotated %s\n"
1498 "Fix this by removing the %sannotation of %s "
1499 "or drop the export.\n",
1500 tosym, prl_to, prl_to, tosym);
1501 free(prl_to);
1502 break;
1503 case EXTABLE_TO_NON_TEXT:
1504 fatal("There's a special handler for this mismatch type, "
1505 "we should never get here.");
1506 break;
1507 }
1508 fprintf(stderr, "\n");
1509 }
1510
1511 static void default_mismatch_handler(const char *modname, struct elf_info *elf,
1512 const struct sectioncheck* const mismatch,
1513 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1514 {
1515 const char *tosec;
1516 Elf_Sym *to;
1517 Elf_Sym *from;
1518 const char *tosym;
1519 const char *fromsym;
1520
1521 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1522 fromsym = sym_name(elf, from);
1523
1524 if (!strncmp(fromsym, "reference___initcall",
1525 sizeof("reference___initcall")-1))
1526 return;
1527
1528 tosec = sec_name(elf, get_secindex(elf, sym));
1529 to = find_elf_symbol(elf, r->r_addend, sym);
1530 tosym = sym_name(elf, to);
1531
1532 /* check whitelist - we may ignore it */
1533 if (secref_whitelist(mismatch,
1534 fromsec, fromsym, tosec, tosym)) {
1535 report_sec_mismatch(modname, mismatch,
1536 fromsec, r->r_offset, fromsym,
1537 is_function(from), tosec, tosym,
1538 is_function(to));
1539 }
1540 }
1541
1542 static int is_executable_section(struct elf_info* elf, unsigned int section_index)
1543 {
1544 if (section_index > elf->num_sections)
1545 fatal("section_index is outside elf->num_sections!\n");
1546
1547 return ((elf->sechdrs[section_index].sh_flags & SHF_EXECINSTR) == SHF_EXECINSTR);
1548 }
1549
1550 /*
1551 * We rely on a gross hack in section_rel[a]() calling find_extable_entry_size()
1552 * to know the sizeof(struct exception_table_entry) for the target architecture.
1553 */
1554 static unsigned int extable_entry_size = 0;
1555 static void find_extable_entry_size(const char* const sec, const Elf_Rela* r)
1556 {
1557 /*
1558 * If we're currently checking the second relocation within __ex_table,
1559 * that relocation offset tells us the offsetof(struct
1560 * exception_table_entry, fixup) which is equal to sizeof(struct
1561 * exception_table_entry) divided by two. We use that to our advantage
1562 * since there's no portable way to get that size as every architecture
1563 * seems to go with different sized types. Not pretty but better than
1564 * hard-coding the size for every architecture..
1565 */
1566 if (!extable_entry_size)
1567 extable_entry_size = r->r_offset * 2;
1568 }
1569
1570 static inline bool is_extable_fault_address(Elf_Rela *r)
1571 {
1572 /*
1573 * extable_entry_size is only discovered after we've handled the
1574 * _second_ relocation in __ex_table, so only abort when we're not
1575 * handling the first reloc and extable_entry_size is zero.
1576 */
1577 if (r->r_offset && extable_entry_size == 0)
1578 fatal("extable_entry size hasn't been discovered!\n");
1579
1580 return ((r->r_offset == 0) ||
1581 (r->r_offset % extable_entry_size == 0));
1582 }
1583
1584 #define is_second_extable_reloc(Start, Cur, Sec) \
1585 (((Cur) == (Start) + 1) && (strcmp("__ex_table", (Sec)) == 0))
1586
1587 static void report_extable_warnings(const char* modname, struct elf_info* elf,
1588 const struct sectioncheck* const mismatch,
1589 Elf_Rela* r, Elf_Sym* sym,
1590 const char* fromsec, const char* tosec)
1591 {
1592 Elf_Sym* fromsym = find_elf_symbol2(elf, r->r_offset, fromsec);
1593 const char* fromsym_name = sym_name(elf, fromsym);
1594 Elf_Sym* tosym = find_elf_symbol(elf, r->r_addend, sym);
1595 const char* tosym_name = sym_name(elf, tosym);
1596 const char* from_pretty_name;
1597 const char* from_pretty_name_p;
1598 const char* to_pretty_name;
1599 const char* to_pretty_name_p;
1600
1601 get_pretty_name(is_function(fromsym),
1602 &from_pretty_name, &from_pretty_name_p);
1603 get_pretty_name(is_function(tosym),
1604 &to_pretty_name, &to_pretty_name_p);
1605
1606 warn("%s(%s+0x%lx): Section mismatch in reference"
1607 " from the %s %s%s to the %s %s:%s%s\n",
1608 modname, fromsec, (long)r->r_offset, from_pretty_name,
1609 fromsym_name, from_pretty_name_p,
1610 to_pretty_name, tosec, tosym_name, to_pretty_name_p);
1611
1612 if (!match(tosec, mismatch->bad_tosec) &&
1613 is_executable_section(elf, get_secindex(elf, sym)))
1614 fprintf(stderr,
1615 "The relocation at %s+0x%lx references\n"
1616 "section \"%s\" which is not in the list of\n"
1617 "authorized sections. If you're adding a new section\n"
1618 "and/or if this reference is valid, add \"%s\" to the\n"
1619 "list of authorized sections to jump to on fault.\n"
1620 "This can be achieved by adding \"%s\" to \n"
1621 "OTHER_TEXT_SECTIONS in scripts/mod/modpost.c.\n",
1622 fromsec, (long)r->r_offset, tosec, tosec, tosec);
1623 }
1624
1625 static void extable_mismatch_handler(const char* modname, struct elf_info *elf,
1626 const struct sectioncheck* const mismatch,
1627 Elf_Rela* r, Elf_Sym* sym,
1628 const char *fromsec)
1629 {
1630 const char* tosec = sec_name(elf, get_secindex(elf, sym));
1631
1632 sec_mismatch_count++;
1633
1634 if (sec_mismatch_verbose)
1635 report_extable_warnings(modname, elf, mismatch, r, sym,
1636 fromsec, tosec);
1637
1638 if (match(tosec, mismatch->bad_tosec))
1639 fatal("The relocation at %s+0x%lx references\n"
1640 "section \"%s\" which is black-listed.\n"
1641 "Something is seriously wrong and should be fixed.\n"
1642 "You might get more information about where this is\n"
1643 "coming from by using scripts/check_extable.sh %s\n",
1644 fromsec, (long)r->r_offset, tosec, modname);
1645 else if (!is_executable_section(elf, get_secindex(elf, sym))) {
1646 if (is_extable_fault_address(r))
1647 fatal("The relocation at %s+0x%lx references\n"
1648 "section \"%s\" which is not executable, IOW\n"
1649 "it is not possible for the kernel to fault\n"
1650 "at that address. Something is seriously wrong\n"
1651 "and should be fixed.\n",
1652 fromsec, (long)r->r_offset, tosec);
1653 else
1654 fatal("The relocation at %s+0x%lx references\n"
1655 "section \"%s\" which is not executable, IOW\n"
1656 "the kernel will fault if it ever tries to\n"
1657 "jump to it. Something is seriously wrong\n"
1658 "and should be fixed.\n",
1659 fromsec, (long)r->r_offset, tosec);
1660 }
1661 }
1662
1663 static void check_section_mismatch(const char *modname, struct elf_info *elf,
1664 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1665 {
1666 const char *tosec = sec_name(elf, get_secindex(elf, sym));;
1667 const struct sectioncheck *mismatch = section_mismatch(fromsec, tosec);
1668
1669 if (mismatch) {
1670 if (mismatch->handler)
1671 mismatch->handler(modname, elf, mismatch,
1672 r, sym, fromsec);
1673 else
1674 default_mismatch_handler(modname, elf, mismatch,
1675 r, sym, fromsec);
1676 }
1677 }
1678
1679 static unsigned int *reloc_location(struct elf_info *elf,
1680 Elf_Shdr *sechdr, Elf_Rela *r)
1681 {
1682 Elf_Shdr *sechdrs = elf->sechdrs;
1683 int section = sechdr->sh_info;
1684
1685 return (void *)elf->hdr + sechdrs[section].sh_offset +
1686 r->r_offset;
1687 }
1688
1689 static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1690 {
1691 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1692 unsigned int *location = reloc_location(elf, sechdr, r);
1693
1694 switch (r_typ) {
1695 case R_386_32:
1696 r->r_addend = TO_NATIVE(*location);
1697 break;
1698 case R_386_PC32:
1699 r->r_addend = TO_NATIVE(*location) + 4;
1700 /* For CONFIG_RELOCATABLE=y */
1701 if (elf->hdr->e_type == ET_EXEC)
1702 r->r_addend += r->r_offset;
1703 break;
1704 }
1705 return 0;
1706 }
1707
1708 #ifndef R_ARM_CALL
1709 #define R_ARM_CALL 28
1710 #endif
1711 #ifndef R_ARM_JUMP24
1712 #define R_ARM_JUMP24 29
1713 #endif
1714
1715 #ifndef R_ARM_THM_CALL
1716 #define R_ARM_THM_CALL 10
1717 #endif
1718 #ifndef R_ARM_THM_JUMP24
1719 #define R_ARM_THM_JUMP24 30
1720 #endif
1721 #ifndef R_ARM_THM_JUMP19
1722 #define R_ARM_THM_JUMP19 51
1723 #endif
1724
1725 static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1726 {
1727 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1728
1729 switch (r_typ) {
1730 case R_ARM_ABS32:
1731 /* From ARM ABI: (S + A) | T */
1732 r->r_addend = (int)(long)
1733 (elf->symtab_start + ELF_R_SYM(r->r_info));
1734 break;
1735 case R_ARM_PC24:
1736 case R_ARM_CALL:
1737 case R_ARM_JUMP24:
1738 case R_ARM_THM_CALL:
1739 case R_ARM_THM_JUMP24:
1740 case R_ARM_THM_JUMP19:
1741 /* From ARM ABI: ((S + A) | T) - P */
1742 r->r_addend = (int)(long)(elf->hdr +
1743 sechdr->sh_offset +
1744 (r->r_offset - sechdr->sh_addr));
1745 break;
1746 default:
1747 return 1;
1748 }
1749 return 0;
1750 }
1751
1752 static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1753 {
1754 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1755 unsigned int *location = reloc_location(elf, sechdr, r);
1756 unsigned int inst;
1757
1758 if (r_typ == R_MIPS_HI16)
1759 return 1; /* skip this */
1760 inst = TO_NATIVE(*location);
1761 switch (r_typ) {
1762 case R_MIPS_LO16:
1763 r->r_addend = inst & 0xffff;
1764 break;
1765 case R_MIPS_26:
1766 r->r_addend = (inst & 0x03ffffff) << 2;
1767 break;
1768 case R_MIPS_32:
1769 r->r_addend = inst;
1770 break;
1771 }
1772 return 0;
1773 }
1774
1775 static void section_rela(const char *modname, struct elf_info *elf,
1776 Elf_Shdr *sechdr)
1777 {
1778 Elf_Sym *sym;
1779 Elf_Rela *rela;
1780 Elf_Rela r;
1781 unsigned int r_sym;
1782 const char *fromsec;
1783
1784 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1785 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1786
1787 fromsec = sech_name(elf, sechdr);
1788 fromsec += strlen(".rela");
1789 /* if from section (name) is know good then skip it */
1790 if (match(fromsec, section_white_list))
1791 return;
1792
1793 for (rela = start; rela < stop; rela++) {
1794 r.r_offset = TO_NATIVE(rela->r_offset);
1795 #if KERNEL_ELFCLASS == ELFCLASS64
1796 if (elf->hdr->e_machine == EM_MIPS) {
1797 unsigned int r_typ;
1798 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1799 r_sym = TO_NATIVE(r_sym);
1800 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1801 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1802 } else {
1803 r.r_info = TO_NATIVE(rela->r_info);
1804 r_sym = ELF_R_SYM(r.r_info);
1805 }
1806 #else
1807 r.r_info = TO_NATIVE(rela->r_info);
1808 r_sym = ELF_R_SYM(r.r_info);
1809 #endif
1810 r.r_addend = TO_NATIVE(rela->r_addend);
1811 sym = elf->symtab_start + r_sym;
1812 /* Skip special sections */
1813 if (is_shndx_special(sym->st_shndx))
1814 continue;
1815 if (is_second_extable_reloc(start, rela, fromsec))
1816 find_extable_entry_size(fromsec, &r);
1817 check_section_mismatch(modname, elf, &r, sym, fromsec);
1818 }
1819 }
1820
1821 static void section_rel(const char *modname, struct elf_info *elf,
1822 Elf_Shdr *sechdr)
1823 {
1824 Elf_Sym *sym;
1825 Elf_Rel *rel;
1826 Elf_Rela r;
1827 unsigned int r_sym;
1828 const char *fromsec;
1829
1830 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1831 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1832
1833 fromsec = sech_name(elf, sechdr);
1834 fromsec += strlen(".rel");
1835 /* if from section (name) is know good then skip it */
1836 if (match(fromsec, section_white_list))
1837 return;
1838
1839 for (rel = start; rel < stop; rel++) {
1840 r.r_offset = TO_NATIVE(rel->r_offset);
1841 #if KERNEL_ELFCLASS == ELFCLASS64
1842 if (elf->hdr->e_machine == EM_MIPS) {
1843 unsigned int r_typ;
1844 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1845 r_sym = TO_NATIVE(r_sym);
1846 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1847 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1848 } else {
1849 r.r_info = TO_NATIVE(rel->r_info);
1850 r_sym = ELF_R_SYM(r.r_info);
1851 }
1852 #else
1853 r.r_info = TO_NATIVE(rel->r_info);
1854 r_sym = ELF_R_SYM(r.r_info);
1855 #endif
1856 r.r_addend = 0;
1857 switch (elf->hdr->e_machine) {
1858 case EM_386:
1859 if (addend_386_rel(elf, sechdr, &r))
1860 continue;
1861 break;
1862 case EM_ARM:
1863 if (addend_arm_rel(elf, sechdr, &r))
1864 continue;
1865 break;
1866 case EM_MIPS:
1867 if (addend_mips_rel(elf, sechdr, &r))
1868 continue;
1869 break;
1870 }
1871 sym = elf->symtab_start + r_sym;
1872 /* Skip special sections */
1873 if (is_shndx_special(sym->st_shndx))
1874 continue;
1875 if (is_second_extable_reloc(start, rel, fromsec))
1876 find_extable_entry_size(fromsec, &r);
1877 check_section_mismatch(modname, elf, &r, sym, fromsec);
1878 }
1879 }
1880
1881 /**
1882 * A module includes a number of sections that are discarded
1883 * either when loaded or when used as built-in.
1884 * For loaded modules all functions marked __init and all data
1885 * marked __initdata will be discarded when the module has been initialized.
1886 * Likewise for modules used built-in the sections marked __exit
1887 * are discarded because __exit marked function are supposed to be called
1888 * only when a module is unloaded which never happens for built-in modules.
1889 * The check_sec_ref() function traverses all relocation records
1890 * to find all references to a section that reference a section that will
1891 * be discarded and warns about it.
1892 **/
1893 static void check_sec_ref(struct module *mod, const char *modname,
1894 struct elf_info *elf)
1895 {
1896 int i;
1897 Elf_Shdr *sechdrs = elf->sechdrs;
1898
1899 /* Walk through all sections */
1900 for (i = 0; i < elf->num_sections; i++) {
1901 check_section(modname, elf, &elf->sechdrs[i]);
1902 /* We want to process only relocation sections and not .init */
1903 if (sechdrs[i].sh_type == SHT_RELA)
1904 section_rela(modname, elf, &elf->sechdrs[i]);
1905 else if (sechdrs[i].sh_type == SHT_REL)
1906 section_rel(modname, elf, &elf->sechdrs[i]);
1907 }
1908 }
1909
1910 static char *remove_dot(char *s)
1911 {
1912 size_t n = strcspn(s, ".");
1913
1914 if (n && s[n]) {
1915 size_t m = strspn(s + n + 1, "0123456789");
1916 if (m && (s[n + m] == '.' || s[n + m] == 0))
1917 s[n] = 0;
1918 }
1919 return s;
1920 }
1921
1922 static void read_symbols(char *modname)
1923 {
1924 const char *symname;
1925 char *version;
1926 char *license;
1927 struct module *mod;
1928 struct elf_info info = { };
1929 Elf_Sym *sym;
1930
1931 if (!parse_elf(&info, modname))
1932 return;
1933
1934 mod = new_module(modname);
1935
1936 /* When there's no vmlinux, don't print warnings about
1937 * unresolved symbols (since there'll be too many ;) */
1938 if (is_vmlinux(modname)) {
1939 have_vmlinux = 1;
1940 mod->skip = 1;
1941 }
1942
1943 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1944 if (info.modinfo && !license && !is_vmlinux(modname))
1945 warn("modpost: missing MODULE_LICENSE() in %s\n"
1946 "see include/linux/module.h for "
1947 "more information\n", modname);
1948 while (license) {
1949 if (license_is_gpl_compatible(license))
1950 mod->gpl_compatible = 1;
1951 else {
1952 mod->gpl_compatible = 0;
1953 break;
1954 }
1955 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1956 "license", license);
1957 }
1958
1959 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1960 symname = remove_dot(info.strtab + sym->st_name);
1961
1962 handle_modversions(mod, &info, sym, symname);
1963 handle_moddevtable(mod, &info, sym, symname);
1964 }
1965 if (!is_vmlinux(modname) ||
1966 (is_vmlinux(modname) && vmlinux_section_warnings))
1967 check_sec_ref(mod, modname, &info);
1968
1969 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1970 if (version)
1971 maybe_frob_rcs_version(modname, version, info.modinfo,
1972 version - (char *)info.hdr);
1973 if (version || (all_versions && !is_vmlinux(modname)))
1974 get_src_version(modname, mod->srcversion,
1975 sizeof(mod->srcversion)-1);
1976
1977 parse_elf_finish(&info);
1978
1979 /* Our trick to get versioning for module struct etc. - it's
1980 * never passed as an argument to an exported function, so
1981 * the automatic versioning doesn't pick it up, but it's really
1982 * important anyhow */
1983 if (modversions)
1984 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
1985 }
1986
1987 static void read_symbols_from_files(const char *filename)
1988 {
1989 FILE *in = stdin;
1990 char fname[PATH_MAX];
1991
1992 if (strcmp(filename, "-") != 0) {
1993 in = fopen(filename, "r");
1994 if (!in)
1995 fatal("Can't open filenames file %s: %m", filename);
1996 }
1997
1998 while (fgets(fname, PATH_MAX, in) != NULL) {
1999 if (strends(fname, "\n"))
2000 fname[strlen(fname)-1] = '\0';
2001 read_symbols(fname);
2002 }
2003
2004 if (in != stdin)
2005 fclose(in);
2006 }
2007
2008 #define SZ 500
2009
2010 /* We first write the generated file into memory using the
2011 * following helper, then compare to the file on disk and
2012 * only update the later if anything changed */
2013
2014 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
2015 const char *fmt, ...)
2016 {
2017 char tmp[SZ];
2018 int len;
2019 va_list ap;
2020
2021 va_start(ap, fmt);
2022 len = vsnprintf(tmp, SZ, fmt, ap);
2023 buf_write(buf, tmp, len);
2024 va_end(ap);
2025 }
2026
2027 void buf_write(struct buffer *buf, const char *s, int len)
2028 {
2029 if (buf->size - buf->pos < len) {
2030 buf->size += len + SZ;
2031 buf->p = realloc(buf->p, buf->size);
2032 }
2033 strncpy(buf->p + buf->pos, s, len);
2034 buf->pos += len;
2035 }
2036
2037 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
2038 {
2039 const char *e = is_vmlinux(m) ?"":".ko";
2040
2041 switch (exp) {
2042 case export_gpl:
2043 fatal("modpost: GPL-incompatible module %s%s "
2044 "uses GPL-only symbol '%s'\n", m, e, s);
2045 break;
2046 case export_unused_gpl:
2047 fatal("modpost: GPL-incompatible module %s%s "
2048 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
2049 break;
2050 case export_gpl_future:
2051 warn("modpost: GPL-incompatible module %s%s "
2052 "uses future GPL-only symbol '%s'\n", m, e, s);
2053 break;
2054 case export_plain:
2055 case export_unused:
2056 case export_unknown:
2057 /* ignore */
2058 break;
2059 }
2060 }
2061
2062 static void check_for_unused(enum export exp, const char *m, const char *s)
2063 {
2064 const char *e = is_vmlinux(m) ?"":".ko";
2065
2066 switch (exp) {
2067 case export_unused:
2068 case export_unused_gpl:
2069 warn("modpost: module %s%s "
2070 "uses symbol '%s' marked UNUSED\n", m, e, s);
2071 break;
2072 default:
2073 /* ignore */
2074 break;
2075 }
2076 }
2077
2078 static void check_exports(struct module *mod)
2079 {
2080 struct symbol *s, *exp;
2081
2082 for (s = mod->unres; s; s = s->next) {
2083 const char *basename;
2084 exp = find_symbol(s->name);
2085 if (!exp || exp->module == mod)
2086 continue;
2087 basename = strrchr(mod->name, '/');
2088 if (basename)
2089 basename++;
2090 else
2091 basename = mod->name;
2092 if (!mod->gpl_compatible)
2093 check_for_gpl_usage(exp->export, basename, exp->name);
2094 check_for_unused(exp->export, basename, exp->name);
2095 }
2096 }
2097
2098 /**
2099 * Header for the generated file
2100 **/
2101 static void add_header(struct buffer *b, struct module *mod)
2102 {
2103 buf_printf(b, "#include <linux/module.h>\n");
2104 buf_printf(b, "#include <linux/vermagic.h>\n");
2105 buf_printf(b, "#include <linux/compiler.h>\n");
2106 buf_printf(b, "\n");
2107 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
2108 buf_printf(b, "\n");
2109 buf_printf(b, "__visible struct module __this_module\n");
2110 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
2111 buf_printf(b, "\t.name = KBUILD_MODNAME,\n");
2112 if (mod->has_init)
2113 buf_printf(b, "\t.init = init_module,\n");
2114 if (mod->has_cleanup)
2115 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
2116 "\t.exit = cleanup_module,\n"
2117 "#endif\n");
2118 buf_printf(b, "\t.arch = MODULE_ARCH_INIT,\n");
2119 buf_printf(b, "};\n");
2120 }
2121
2122 static void add_intree_flag(struct buffer *b, int is_intree)
2123 {
2124 if (is_intree)
2125 buf_printf(b, "\nMODULE_INFO(intree, \"Y\");\n");
2126 }
2127
2128 static void add_staging_flag(struct buffer *b, const char *name)
2129 {
2130 static const char *staging_dir = "drivers/staging";
2131
2132 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
2133 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
2134 }
2135
2136 /**
2137 * Record CRCs for unresolved symbols
2138 **/
2139 static int add_versions(struct buffer *b, struct module *mod)
2140 {
2141 struct symbol *s, *exp;
2142 int err = 0;
2143
2144 for (s = mod->unres; s; s = s->next) {
2145 exp = find_symbol(s->name);
2146 if (!exp || exp->module == mod) {
2147 if (have_vmlinux && !s->weak) {
2148 if (warn_unresolved) {
2149 warn("\"%s\" [%s.ko] undefined!\n",
2150 s->name, mod->name);
2151 } else {
2152 merror("\"%s\" [%s.ko] undefined!\n",
2153 s->name, mod->name);
2154 err = 1;
2155 }
2156 }
2157 continue;
2158 }
2159 s->module = exp->module;
2160 s->crc_valid = exp->crc_valid;
2161 s->crc = exp->crc;
2162 }
2163
2164 if (!modversions)
2165 return err;
2166
2167 buf_printf(b, "\n");
2168 buf_printf(b, "static const struct modversion_info ____versions[]\n");
2169 buf_printf(b, "__used\n");
2170 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
2171
2172 for (s = mod->unres; s; s = s->next) {
2173 if (!s->module)
2174 continue;
2175 if (!s->crc_valid) {
2176 warn("\"%s\" [%s.ko] has no CRC!\n",
2177 s->name, mod->name);
2178 continue;
2179 }
2180 buf_printf(b, "\t{ %#8x, __VMLINUX_SYMBOL_STR(%s) },\n",
2181 s->crc, s->name);
2182 }
2183
2184 buf_printf(b, "};\n");
2185
2186 return err;
2187 }
2188
2189 static void add_depends(struct buffer *b, struct module *mod,
2190 struct module *modules)
2191 {
2192 struct symbol *s;
2193 struct module *m;
2194 int first = 1;
2195
2196 for (m = modules; m; m = m->next)
2197 m->seen = is_vmlinux(m->name);
2198
2199 buf_printf(b, "\n");
2200 buf_printf(b, "static const char __module_depends[]\n");
2201 buf_printf(b, "__used\n");
2202 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
2203 buf_printf(b, "\"depends=");
2204 for (s = mod->unres; s; s = s->next) {
2205 const char *p;
2206 if (!s->module)
2207 continue;
2208
2209 if (s->module->seen)
2210 continue;
2211
2212 s->module->seen = 1;
2213 p = strrchr(s->module->name, '/');
2214 if (p)
2215 p++;
2216 else
2217 p = s->module->name;
2218 buf_printf(b, "%s%s", first ? "" : ",", p);
2219 first = 0;
2220 }
2221 buf_printf(b, "\";\n");
2222 }
2223
2224 static void add_srcversion(struct buffer *b, struct module *mod)
2225 {
2226 if (mod->srcversion[0]) {
2227 buf_printf(b, "\n");
2228 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
2229 mod->srcversion);
2230 }
2231 }
2232
2233 static void write_if_changed(struct buffer *b, const char *fname)
2234 {
2235 char *tmp;
2236 FILE *file;
2237 struct stat st;
2238
2239 file = fopen(fname, "r");
2240 if (!file)
2241 goto write;
2242
2243 if (fstat(fileno(file), &st) < 0)
2244 goto close_write;
2245
2246 if (st.st_size != b->pos)
2247 goto close_write;
2248
2249 tmp = NOFAIL(malloc(b->pos));
2250 if (fread(tmp, 1, b->pos, file) != b->pos)
2251 goto free_write;
2252
2253 if (memcmp(tmp, b->p, b->pos) != 0)
2254 goto free_write;
2255
2256 free(tmp);
2257 fclose(file);
2258 return;
2259
2260 free_write:
2261 free(tmp);
2262 close_write:
2263 fclose(file);
2264 write:
2265 file = fopen(fname, "w");
2266 if (!file) {
2267 perror(fname);
2268 exit(1);
2269 }
2270 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
2271 perror(fname);
2272 exit(1);
2273 }
2274 fclose(file);
2275 }
2276
2277 /* parse Module.symvers file. line format:
2278 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
2279 **/
2280 static void read_dump(const char *fname, unsigned int kernel)
2281 {
2282 unsigned long size, pos = 0;
2283 void *file = grab_file(fname, &size);
2284 char *line;
2285
2286 if (!file)
2287 /* No symbol versions, silently ignore */
2288 return;
2289
2290 while ((line = get_next_line(&pos, file, size))) {
2291 char *symname, *modname, *d, *export, *end;
2292 unsigned int crc;
2293 struct module *mod;
2294 struct symbol *s;
2295
2296 if (!(symname = strchr(line, '\t')))
2297 goto fail;
2298 *symname++ = '\0';
2299 if (!(modname = strchr(symname, '\t')))
2300 goto fail;
2301 *modname++ = '\0';
2302 if ((export = strchr(modname, '\t')) != NULL)
2303 *export++ = '\0';
2304 if (export && ((end = strchr(export, '\t')) != NULL))
2305 *end = '\0';
2306 crc = strtoul(line, &d, 16);
2307 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2308 goto fail;
2309 mod = find_module(modname);
2310 if (!mod) {
2311 if (is_vmlinux(modname))
2312 have_vmlinux = 1;
2313 mod = new_module(modname);
2314 mod->skip = 1;
2315 }
2316 s = sym_add_exported(symname, mod, export_no(export));
2317 s->kernel = kernel;
2318 s->preloaded = 1;
2319 sym_update_crc(symname, mod, crc, export_no(export));
2320 }
2321 release_file(file, size);
2322 return;
2323 fail:
2324 release_file(file, size);
2325 fatal("parse error in symbol dump file\n");
2326 }
2327
2328 /* For normal builds always dump all symbols.
2329 * For external modules only dump symbols
2330 * that are not read from kernel Module.symvers.
2331 **/
2332 static int dump_sym(struct symbol *sym)
2333 {
2334 if (!external_module)
2335 return 1;
2336 if (sym->vmlinux || sym->kernel)
2337 return 0;
2338 return 1;
2339 }
2340
2341 static void write_dump(const char *fname)
2342 {
2343 struct buffer buf = { };
2344 struct symbol *symbol;
2345 int n;
2346
2347 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2348 symbol = symbolhash[n];
2349 while (symbol) {
2350 if (dump_sym(symbol))
2351 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2352 symbol->crc, symbol->name,
2353 symbol->module->name,
2354 export_str(symbol->export));
2355 symbol = symbol->next;
2356 }
2357 }
2358 write_if_changed(&buf, fname);
2359 }
2360
2361 struct ext_sym_list {
2362 struct ext_sym_list *next;
2363 const char *file;
2364 };
2365
2366 int main(int argc, char **argv)
2367 {
2368 struct module *mod;
2369 struct buffer buf = { };
2370 char *kernel_read = NULL, *module_read = NULL;
2371 char *dump_write = NULL, *files_source = NULL;
2372 int opt;
2373 int err;
2374 struct ext_sym_list *extsym_iter;
2375 struct ext_sym_list *extsym_start = NULL;
2376
2377 while ((opt = getopt(argc, argv, "i:I:e:mnsST:o:awM:K:")) != -1) {
2378 switch (opt) {
2379 case 'i':
2380 kernel_read = optarg;
2381 break;
2382 case 'I':
2383 module_read = optarg;
2384 external_module = 1;
2385 break;
2386 case 'e':
2387 external_module = 1;
2388 extsym_iter =
2389 NOFAIL(malloc(sizeof(*extsym_iter)));
2390 extsym_iter->next = extsym_start;
2391 extsym_iter->file = optarg;
2392 extsym_start = extsym_iter;
2393 break;
2394 case 'm':
2395 modversions = 1;
2396 break;
2397 case 'n':
2398 ignore_missing_files = 1;
2399 break;
2400 case 'o':
2401 dump_write = optarg;
2402 break;
2403 case 'a':
2404 all_versions = 1;
2405 break;
2406 case 's':
2407 vmlinux_section_warnings = 0;
2408 break;
2409 case 'S':
2410 sec_mismatch_verbose = 0;
2411 break;
2412 case 'T':
2413 files_source = optarg;
2414 break;
2415 case 'w':
2416 warn_unresolved = 1;
2417 break;
2418 default:
2419 exit(1);
2420 }
2421 }
2422
2423 if (kernel_read)
2424 read_dump(kernel_read, 1);
2425 if (module_read)
2426 read_dump(module_read, 0);
2427 while (extsym_start) {
2428 read_dump(extsym_start->file, 0);
2429 extsym_iter = extsym_start->next;
2430 free(extsym_start);
2431 extsym_start = extsym_iter;
2432 }
2433
2434 while (optind < argc)
2435 read_symbols(argv[optind++]);
2436
2437 if (files_source)
2438 read_symbols_from_files(files_source);
2439
2440 for (mod = modules; mod; mod = mod->next) {
2441 if (mod->skip)
2442 continue;
2443 check_exports(mod);
2444 }
2445
2446 err = 0;
2447
2448 for (mod = modules; mod; mod = mod->next) {
2449 char fname[PATH_MAX];
2450
2451 if (mod->skip)
2452 continue;
2453
2454 buf.pos = 0;
2455
2456 add_header(&buf, mod);
2457 add_intree_flag(&buf, !external_module);
2458 add_staging_flag(&buf, mod->name);
2459 err |= add_versions(&buf, mod);
2460 add_depends(&buf, mod, modules);
2461 add_moddevtable(&buf, mod);
2462 add_srcversion(&buf, mod);
2463
2464 sprintf(fname, "%s.mod.c", mod->name);
2465 write_if_changed(&buf, fname);
2466 }
2467
2468 if (dump_write)
2469 write_dump(dump_write);
2470 if (sec_mismatch_count && !sec_mismatch_verbose)
2471 warn("modpost: Found %d section mismatch(es).\n"
2472 "To see full details build your kernel with:\n"
2473 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2474 sec_mismatch_count);
2475
2476 return err;
2477 }
Linux with added FPC-III support