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